CbmRoot
CbmMvdSensorFindHitTask.cxx
Go to the documentation of this file.
1 // ---------------------------------------------------------------------------------------------
2 // ----- CbmMvdSensorFindHitTask source file -----
3 // ----- Created 11/09/13 by P.Sitzmann -----
4 // ----- -----
5 // ---------------------------------------------------------------------------------------------
6 // Includes from MVD
8 
9 #include "CbmMvdCluster.h"
10 #include "CbmMvdHit.h"
11 #include "CbmMvdPileupManager.h"
12 #include "CbmMvdPoint.h"
13 
14 // Includes from base
15 #include "CbmMCTrack.h"
16 #include "FairGeoNode.h"
17 #include "FairLogger.h"
18 #include "FairRootManager.h"
19 #include "FairRunAna.h"
20 #include "FairRuntimeDb.h"
21 
22 // Includes from ROOT
23 #include "TArrayD.h"
24 #include "TCanvas.h"
25 #include "TGeoManager.h"
26 #include "TGeoTube.h"
27 #include "TObjArray.h"
28 #include "TRefArray.h"
29 
30 #include "TClonesArray.h"
31 
32 #include "TF1.h"
33 #include "TH1.h"
34 #include "TH2.h"
35 #include "TMath.h"
36 #include "TRandom3.h"
37 #include "TString.h"
38 #include "TVector3.h"
39 
40 // Includes from C++
41 #include <iomanip>
42 #include <iostream>
43 #include <map>
44 #include <vector>
45 
46 using std::cout;
47 using std::endl;
48 using std::fixed;
49 using std::ios_base;
50 using std::left;
51 using std::map;
52 using std::pair;
53 using std::right;
54 using std::setprecision;
55 using std::setw;
56 using std::vector;
57 
58 
59 // ----- Default constructor ------------------------------------------
62  , fAdcDynamic(200)
63  , fAdcOffset(0)
64  , fAdcBits(1)
65  , fAdcSteps(-1)
66  , fAdcStepSize(-1.)
67  , fDigis(NULL)
68  , fHits(NULL)
69  , fClusters(new TClonesArray("CbmMvdCluster", 10000))
70  , fPixelChargeHistos(NULL)
71  , fTotalChargeInNpixelsArray(NULL)
72  , fResolutionHistoX(NULL)
73  , fResolutionHistoY(NULL)
74  , fResolutionHistoCleanX(NULL)
75  , fResolutionHistoCleanY(NULL)
76  , fResolutionHistoMergedX(NULL)
77  , fResolutionHistoMergedY(NULL)
78  , fBadHitHisto(NULL)
79  , fGausArray(NULL)
80  , fGausArrayIt(-1)
81  , fGausArrayLimit(5000)
82  , fDigiMap()
83  , fDigiMapIt()
84  , h(NULL)
85  , h3(NULL)
86  , h1(NULL)
87  , h2(NULL)
88  , Qseed(NULL)
89  , fFullClusterHisto(NULL)
90  , c1(NULL)
91  , fNEvent(0)
92  , fMode(0)
93  , fCounter(0)
94  , fSigmaNoise(15.)
95  , fSeedThreshold(1.)
96  , fNeighThreshold(1.)
97  , fShowDebugHistos(kFALSE)
98  , fUseMCInfo(kFALSE)
99  , inputSet(kFALSE)
100  , fLayerRadius(0.)
101  , fLayerRadiusInner(0.)
102  , fLayerPosZ(0.)
103  , fHitPosX(0.)
104  , fHitPosY(0.)
105  , fHitPosZ(0.)
106  , fHitPosErrX(0.0005)
107  , fHitPosErrY(0.0005)
108  , fHitPosErrZ(0.0)
109  , fBranchName("MvdHit")
110  , fDigisInCluster(-1)
111  , fAddNoise(kFALSE) {}
112 // -------------------------------------------------------------------------
113 
114 
115 // ----- Standard constructor ------------------------------------------
117  : CbmMvdSensorTask()
118  , fAdcDynamic(200)
119  , fAdcOffset(0)
120  , fAdcBits(1)
121  , fAdcSteps(-1)
122  , fAdcStepSize(-1.)
123  , fDigis(NULL)
124  , fHits(NULL)
125  , fClusters(new TClonesArray("CbmMvdCluster", 10000))
126  , fPixelChargeHistos(NULL)
127  , fTotalChargeInNpixelsArray(NULL)
128  , fResolutionHistoX(NULL)
129  , fResolutionHistoY(NULL)
130  , fResolutionHistoCleanX(NULL)
131  , fResolutionHistoCleanY(NULL)
132  , fResolutionHistoMergedX(NULL)
133  , fResolutionHistoMergedY(NULL)
134  , fBadHitHisto(NULL)
135  , fGausArray(NULL)
136  , fGausArrayIt(-1)
137  , fGausArrayLimit(5000)
138  , fDigiMap()
139  , fDigiMapIt()
140  , h(NULL)
141  , h3(NULL)
142  , h1(NULL)
143  , h2(NULL)
144  , Qseed(NULL)
145  , fFullClusterHisto(NULL)
146  , c1(NULL)
147  , fNEvent(0)
148  , fMode(iMode)
149  , fCounter(0)
150  , fSigmaNoise(15.)
151  , fSeedThreshold(1.)
152  , fNeighThreshold(1.)
153  , fShowDebugHistos(kFALSE)
154  , fUseMCInfo(kFALSE)
155  , inputSet(kFALSE)
156  , fLayerRadius(0.)
157  , fLayerRadiusInner(0.)
158  , fLayerPosZ(0.)
159  , fHitPosX(0.)
160  , fHitPosY(0.)
161  , fHitPosZ(0.)
162  , fHitPosErrX(0.0005)
163  , fHitPosErrY(0.0005)
164  , fHitPosErrZ(0.0)
165  , fBranchName("MvdHit")
166  , fDigisInCluster(-1)
167  , fAddNoise(kFALSE) {}
168 // -------------------------------------------------------------------------
169 
170 // ----- Destructor ----------------------------------------------------
172 
173  if (fHits) {
174  fHits->Delete();
175  delete fHits;
176  }
177 
178  if (fClusters) {
179  fClusters->Delete();
180  delete fClusters;
181  }
182 
183  if (fInputBuffer) {
184  fInputBuffer->Delete();
185  delete fInputBuffer;
186  }
187 }
188 // -------------------------------------------------------------------------
189 
190 // ----- Virtual private method Init ----------------------------------
192 
193 
194  fSensor = mysensor;
195  //cout << "-Start- " << GetName() << ": Initialisation of sensor " << fSensor->GetName() << endl;
196  fInputBuffer = new TClonesArray("CbmMvdDigi", 10000);
197  fOutputBuffer = new TClonesArray("CbmMvdHit", 10000);
198  fHits = new TClonesArray("CbmMvdHit", 10000);
199 
200 
201  //Add charge collection histograms
202  fPixelChargeHistos = new TObjArray();
203 
204  fTotalChargeInNpixelsArray = new TObjArray();
205 
206  fAdcSteps = (Int_t) TMath::Power(2, fAdcBits);
208 
209  fGausArray = new Float_t[fGausArrayLimit];
210  for (Int_t i = 0; i < fGausArrayLimit; i++) {
211  fGausArray[i] = gRandom->Gaus(0, fSigmaNoise);
212  };
213  fGausArrayIt = 0;
214 
215 
216  initialized = kTRUE;
217 
218  //cout << "-Finished- " << GetName() << ": Initialisation of sensor " << fSensor->GetName() << endl;
219 }
220 // -------------------------------------------------------------------------
221 
222 // ----- Virtual public method Reinit ----------------------------------
224  cout << "-I- "
225  << "CbmMvdSensorFindHitTask::ReInt---------------" << endl;
226  return kSUCCESS;
227 }
228 // -------------------------------------------------------------------------
229 
230 // ----- Virtual public method ExecChain --------------
232 // -------------------------------------------------------------------------
233 
234 // ----- Virtual public method Exec --------------
236 
237  // if(!inputSet)
238  // {
239  // fInputBuffer->Clear();
240  // fInputBuffer->AbsorbObjects(fPreviousPlugin->GetOutputArray());
241  // cout << endl << "absorbt object from previous plugin at " << fSensor->GetName() << " got " << fInputBuffer->GetEntriesFast() << " entrys" << endl;
242  // }
243  if (fInputBuffer->GetEntriesFast() > 0) {
244  fHits->Clear("C");
245  fOutputBuffer->Clear();
246  fClusters->Clear("C");
247  inputSet = kFALSE;
248  vector<Int_t>* clusterArray = new vector<Int_t>;
249 
250  CbmMvdDigi* digi = NULL;
251 
252  Int_t iDigi = 0;
253  digi = (CbmMvdDigi*) fInputBuffer->At(iDigi);
254 
255 
256  if (!digi) {
257  cout << "-E- : CbmMvdSensorFindHitTask - Fatal: No Digits found in this "
258  "event."
259  << endl;
260  }
261 
262  Int_t nDigis = fInputBuffer->GetEntriesFast();
263 
264  //cout << endl << "working with " << nDigis << " entries" << endl;
265 
266 
267  if (fAddNoise == kTRUE) {
268  // Generate random number and call it noise
269  // add the noise to the charge of the digis
270 
271  cout << "-I- "
272  << "CbmMvdSensorFindHitTask: Calling method AddNoiseToDigis()...\n"
273  << endl;
274 
275  for (iDigi = 0; iDigi < nDigis; iDigi++) {
276 
277  digi = (CbmMvdDigi*) fInputBuffer->At(iDigi);
278  AddNoiseToDigis(digi);
279  }
280  }
281 
282  if (fMode == 1) {
283  // GenerateFakeDigis(pixelSizeX, pixelSizeY); // -------- Create Fake Digis -
284  cout << endl << "generate fake digis" << endl;
285  }
286 
287 
288  nDigis = fInputBuffer->GetEntriesFast();
289  TArrayS* pixelUsed = new TArrayS(nDigis);
290 
291  for (iDigi = 0; iDigi < nDigis; iDigi++) {
292  pixelUsed->AddAt(0, iDigi);
293  }
294 
295  fDigiMap.clear();
296  Int_t refId;
297  for (Int_t k = 0; k < nDigis; k++) {
298 
299  digi = (CbmMvdDigi*) fInputBuffer->At(k);
300  refId = digi->GetRefId();
301  if (refId < 0) {
302  LOG(fatal) << "RefID of this digi is -1 this should not happend ";
303  }
304  //apply fNeighThreshold
305 
306  if (GetAdcCharge(digi->GetCharge()) < fNeighThreshold) continue;
307 
308  pair<Int_t, Int_t> a(digi->GetPixelX(), digi->GetPixelY());
309  // cout << endl << "registerde pixel x:" << digi->GetPixelX() << " y:" << digi->GetPixelY() << endl;
310  fDigiMap[a] = k;
311  };
312 
313 
314  if (gDebug > 0) {
315  cout << "\n-I- " << GetName() << ": VolumeId " << fSensor->GetVolumeId()
316  << endl;
317  }
318 
319  for (iDigi = 0; iDigi < nDigis; iDigi++) {
320 
321  if (gDebug > 0 && iDigi % 10000 == 0) {
322  cout << "-I- " << GetName() << " Digi:" << iDigi << endl;
323  };
324 
325  digi = (CbmMvdDigi*) fInputBuffer->At(iDigi);
326  //cout << endl << "working with pixel x:" << digi->GetPixelX() << " y:" << digi->GetPixelY() << endl;
327 
328 
329  /*
330  ---------------------------------------------------------
331  check if digi is above threshold (define seed pixel)
332  then check for neighbours.
333  Once the cluster is created (seed and neighbours)
334  calculate the position of the hit
335  using center of gravity (CoG) method.
336  ---------------------------------------------------------
337  */
338 
339  if (gDebug > 0) {
340  cout << "-I- "
341  << "CbmMvdSensorFindHitTask: Checking for seed pixels..." << endl;
342  }
343 
344  if ((GetAdcCharge(digi->GetCharge()) >= fSeedThreshold)
345  && (pixelUsed->At(iDigi) == kFALSE)) {
346  clusterArray->clear();
347  clusterArray->push_back(iDigi);
348 
349 
350  pixelUsed->AddAt(1, iDigi);
351 
352  pair<Int_t, Int_t> a(digi->GetPixelX(), digi->GetPixelY());
353  fDigiMapIt = fDigiMap.find(a);
354  fDigiMap.erase(fDigiMapIt);
355 
356  for (ULong64_t iCluster = 0; iCluster < clusterArray->size();
357  iCluster++) {
358 
359  if (gDebug > 0) {
360  cout << "-I- "
361  << " CbmMvdSensorFindHitTask: Calling method "
362  "CheckForNeighbours()..."
363  << endl;
364  }
365 
366  CheckForNeighbours(clusterArray, iCluster, pixelUsed);
367  }
368 
369  //Calculate the center of gravity of all pixels in the cluster.
370  TVector3 pos(0, 0, 0);
371  TVector3 dpos(0, 0, 0);
372 
373  if (gDebug > 0) {
374  cout << "-I- "
375  << " CbmMvdSensorFindHitTask: Calling method CreateHit()..."
376  << endl;
377  }
378 
379  CreateHit(clusterArray, pos, dpos);
380 
381 
382  } // if AdcCharge>threshold
383  else { //cout << endl << "pixel is with " << digi->GetCharge() << " under Threshold or used" << endl;
384  }
385  } // loop on digis
386 
387 
388  //----------------------------------------------------------------------------------
389  //------------- End of Detector Loops ----------------------------------------------
390  //----------------------------------------------------------------------------------
391 
392  // cout << endl << "-I- End of task " << GetName() << ": Event Nr: " << fNEvent << ", nDIGIS: "<<nDigis << ", nHits:"<<fHits->GetEntriesFast()<<endl;
393 
394 
395  /*cout << "registered " << fHits->GetEntriesFast()
396  << " new hits out of " << fInputBuffer->GetEntriesFast()
397  << " Digis on sensor "
398  << fSensor->GetName() << endl; */
399 
400  delete pixelUsed;
401  clusterArray->clear();
402  delete clusterArray;
403  fInputBuffer->Clear();
404 
405  fDigiMap.clear();
406  } else { //cout << endl << "No input found." << endl;
407  }
408 }
409 //--------------------------------------------------------------------------
410 
411 
412 //--------------------------------------------------------------------------
414  Double_t noise = fGausArray[fGausArrayIt++]; // noise is simulated by a gauss
415  if (fGausArrayIt - 2 > fGausArrayLimit) { fGausArrayIt = 0; };
416  Double_t charge = digi->GetCharge() + noise;
417  digi->SetCharge((int) charge);
418 }
419 //--------------------------------------------------------------------------
420 
421 
422 //--------------------------------------------------------------------------
423 //void CbmMvdSensorFindHitTask::GenerateFakeDigis( Double_t pixelSizeX, Double_t pixelSizeY){
424 
425 //max index of pixels
426 //Int_t nx = TMath::Nint(2*fLayerRadius/pixelSizeX);
427 //Int_t ny = TMath::Nint(2*fLayerRadius/pixelSizeY);
428 
429 //cdritsa: parametrise geometry: 15/12/08
430 /* Double_t layerRadius = station->GetRmax();
431 // Double_t layerRadiusInner = station->GetRmin();
432 
433  Int_t nx = int(2*layerRadius/pixelSizeX);
434  Int_t ny = int(2*layerRadius/pixelSizeY);
435 
436  Double_t x;
437  Double_t y;
438  Double_t distance2;
439  Double_t noise;
440  Double_t r2 = layerRadius*layerRadius;
441  Double_t r2_inner = layerRadiusInner*layerRadiusInner;
442 
443  for( Int_t i=0; i<nx; i++){
444 
445  x = (i+0.5)*pixelSizeX - layerRadius;
446 
447  for( Int_t j=0; j<ny; j++){
448 
449  y = (j+0.5)*pixelSizeY - layerRadius;
450 
451  distance2 = x*x + y*y ;
452 
453 
454  if( distance2>r2 || distance2<r2_inner ) continue;
455 
456  noise = fGausArray[fGausArrayIt++]; // noise is simulated by a gauss
457  if (fGausArrayIt-2>fGausArrayLimit){fGausArrayIt=0;};
458 
459  if ( noise>fSeedThreshold && //pixel is not used ???){
460  Int_t nDigis = fInputBuffer->GetEntriesFast();
461  CbmMvdDigi* fakeDigi=
462  new ((*fInputBuffer)[nDigis]) CbmMvdDigi(station->GetVolumeId(), i,j, noise, pixelSizeX,pixelSizeY);
463 
464  Int_t data[5];
465  Float_t data2[5];
466 
467 
468 
469 
470  }
471  }
472  }
473 
474 
475 
476 }*/
477 
478 //--------------------------------------------------------------------------
479 //--------------------------------------------------------------------------
480 
481 void CbmMvdSensorFindHitTask::CheckForNeighbours(vector<Int_t>* clusterArray,
482  Int_t clusterDigi,
483  TArrayS* pixelUsed) {
484  CbmMvdDigi* seed =
485  (CbmMvdDigi*) fInputBuffer->At(clusterArray->at(clusterDigi));
486  //cout << endl << "pixel nr. " << clusterDigi << " is seed" << endl ;
487  // Remove Seed Pixel from list of non-used pixels
488  Int_t channelX = seed->GetPixelX();
489  Int_t channelY = seed->GetPixelY();
490  pair<Int_t, Int_t> a(channelX, channelY);
491 
492  // Find first neighbour
493 
494  a = std::make_pair(channelX + 1, channelY);
495  fDigiMapIt = fDigiMap.find(a);
496 
497  if (!(fDigiMapIt == fDigiMap.end())) {
498  Int_t i = fDigiMap[a];
499  //cout << endl << "pixel nr. " << i << " is used" << endl ;
500  // Only digis depassing fNeighThreshold are in the map, no cut required
501  clusterArray->push_back(i);
502 
503  pixelUsed->AddAt(1, i); // block pixel for the seed pixel scanner
504  fDigiMap.erase(fDigiMapIt); // block pixel for the neighbour pixel scanner
505  }
506 
507  a = std::make_pair(channelX - 1, channelY);
508  fDigiMapIt = fDigiMap.find(a);
509 
510  if (!(fDigiMapIt == fDigiMap.end())) {
511  Int_t i = fDigiMap[a];
512  //cout << endl << "pixel nr. " << i << " is used" << endl ;
513  // Only digits depassing fNeighThreshold are in the map, no cut required
514  clusterArray->push_back(i);
515  pixelUsed->AddAt(1, i); // block pixel for the seed pixel scanner
516  fDigiMap.erase(fDigiMapIt); // block pixel for the neighbour pixel scanner
517  }
518 
519  a = std::make_pair(channelX, channelY - 1);
520  fDigiMapIt = fDigiMap.find(a);
521  if (!(fDigiMapIt == fDigiMap.end())) {
522  Int_t i = fDigiMap[a];
523  // Only digits depassing fNeighThreshold are in the map, no cut required
524  //cout << endl << "pixel nr. " << i << " is used" << endl ;
525  clusterArray->push_back(i);
526  pixelUsed->AddAt(1, i); // block pixel for the seed pixel scanner
527  fDigiMap.erase(fDigiMapIt); // block pixel for the neighbour pixel scanner
528  }
529 
530  a = std::make_pair(channelX, channelY + 1);
531  fDigiMapIt = fDigiMap.find(a);
532 
533  if (!(fDigiMapIt == fDigiMap.end())) {
534  Int_t i = fDigiMap[a];
535  //cout << endl << "pixel nr. " << i << " is used" << endl ;
536  // Only digis depassing fNeighThreshold are in the map, no cut required
537  clusterArray->push_back(i);
538  pixelUsed->AddAt(1, i); // block pixel for the seed pixel scanner
539  fDigiMap.erase(fDigiMapIt); // block pixel for the neighbour pixel scanner
540  }
541 }
542 
543 //--------------------------------------------------------------------------
544 //--------------------------------------------------------------------------
545 void CbmMvdSensorFindHitTask::CreateHit(vector<Int_t>* clusterArray,
546  TVector3& pos,
547  TVector3& dpos) {
548 
549  //loop on cluster array elements
550  //calculate the CoG for this cluster
551 
552  Int_t clusterSize = clusterArray->size();
553  Int_t digiIndex = 0;
554  //cout << endl << "try to create hit from " << clusterSize << " pixels" << endl;
555  CbmMvdDigi* pixelInCluster =
556  (CbmMvdDigi*) fInputBuffer->At(clusterArray->at(digiIndex));
557  Int_t thisRefID = pixelInCluster->GetRefId();
558  while (thisRefID < 0 && digiIndex < clusterSize) {
559  pixelInCluster =
560  (CbmMvdDigi*) fInputBuffer->At(clusterArray->at(digiIndex));
561  thisRefID = pixelInCluster->GetRefId();
562  digiIndex++;
563  }
564  if (thisRefID < 0)
565  LOG(fatal) << "RefID of this digi is -1 this should not happend checked "
566  << digiIndex << " digis in this Cluster";
567 
568  // Calculate the center of gravity of the charge of a cluster
569 
570  ComputeCenterOfGravity(clusterArray, pos, dpos);
571 
572 
573  Int_t indexX, indexY;
574  //Double_t x,y;
575  Double_t local[2];
576  local[0] = pos.X();
577  local[1] = pos.Y();
578  //cout << endl << "found center of gravity at: " << local[0] << " , " << local[1] << endl;
579 
580  fSensor->TopToPixel(local, indexX, indexY);
581 
582  //cout << endl << "Center is on pixel: " << indexX << " , " << indexY << endl;
583  //Fill HitClusters
584 
585  Int_t i = 0;
586  Int_t* digiArray = new Int_t[fDigisInCluster];
587 
588  for (i = 0; i < fDigisInCluster; i++) {
589  digiArray[i] = 0;
590  };
591 
592  Int_t latestClusterIndex = -1;
593  Int_t digisInArray = 0;
594 
595  CbmMvdCluster* latestCluster = NULL;
596  Int_t nClusters = -1;
597 
598  for (i = 0; i < clusterSize; i++) {
599 
600  digiArray[i % fDigisInCluster] = clusterArray->at(i);
601  digisInArray = digisInArray + 1;
602 
603  if (digisInArray == fDigisInCluster) { // intermediate buffer full
604 
605  nClusters = fClusters->GetEntriesFast();
606  CbmMvdCluster* clusterNew = new ((*fClusters)[nClusters])
607  CbmMvdCluster(digiArray, digisInArray, clusterSize, latestClusterIndex);
608  if (latestCluster) { latestCluster->SetNeighbourUp(nClusters); }
609  latestCluster = clusterNew;
610  latestClusterIndex = nClusters;
611  digisInArray = 0;
612  }
613  }
614 
615  if (digisInArray != 0) {
616  nClusters = fClusters->GetEntriesFast();
617  CbmMvdCluster* clusterNew = new ((*fClusters)[nClusters])
618  CbmMvdCluster(digiArray, digisInArray, clusterSize, latestClusterIndex);
619  clusterNew->SetNeighbourUp(-1);
620  if (latestCluster) { latestCluster->SetNeighbourUp(nClusters); };
621  };
622 
623 
624  // Save hit into array
625  Int_t nHits = fHits->GetEntriesFast();
626  //cout << endl << "adding new hit to fHits at X: " << pos.X() << " , Y: "<< pos.Y() << " , Z: " << pos.Z() << " , " ;
627  new ((*fHits)[nHits])
628  CbmMvdHit(fSensor->GetStationNr(), pos, dpos, indexX, indexY, nClusters, 0);
629  CbmMvdHit* currentHit = new CbmMvdHit;
630  currentHit = (CbmMvdHit*) fHits->At(nHits);
631  currentHit->SetTime(fSensor->GetCurrentEventTime());
632  currentHit->SetTimeError(fSensor->GetIntegrationtime() / 2);
633  currentHit->SetRefId(thisRefID);
634  if (pixelInCluster->GetRefId() < 0)
635  cout << endl
636  << "new hit with refID " << pixelInCluster->GetRefId() << " to hit "
637  << nHits << endl;
638 
639  nHits = fOutputBuffer->GetEntriesFast();
640  new ((*fOutputBuffer)[nHits])
641  CbmMvdHit(fSensor->GetStationNr(), pos, dpos, indexX, indexY, nClusters, 0);
642  currentHit = (CbmMvdHit*) fOutputBuffer->At(nHits);
643  currentHit->SetTime(fSensor->GetCurrentEventTime());
644  currentHit->SetTimeError(fSensor->GetIntegrationtime() / 2);
645  currentHit->SetRefId(pixelInCluster->GetRefId());
646 
647  delete[] digiArray;
648 }
649 
650 //--------------------------------------------------------------------------
651 
652 void CbmMvdSensorFindHitTask::UpdateDebugHistos(vector<Int_t>* clusterArray,
653  Int_t seedIndexX,
654  Int_t seedIndexY) {
655  /************************************************************
656  Algorithm for cluster shapes
657 
658  ************************************************************/
659 
660 
661  Float_t chargeArray3D[fChargeArraySize][fChargeArraySize];
662  Float_t chargeArray[fChargeArraySize * fChargeArraySize];
663  Short_t seedPixelOffset = fChargeArraySize / 2; // 3 for 7, 2 for 5
664  Float_t xCentralTrack = 0.0;
665  Float_t yCentralTrack = 0.0;
666  Float_t clusterCharge = 0;
667 
668  Int_t clusterSize = clusterArray->size();
669 
670  for (Int_t k = 0; k < fChargeArraySize; k++) {
671  for (Int_t j = 0; j < fChargeArraySize; j++) {
672  chargeArray3D[k][j] = gRandom->Gaus(0, fSigmaNoise);
673  }
674  }
675 
676  for (Int_t k = 0; k < clusterSize; k++) {
677  CbmMvdDigi* digi = (CbmMvdDigi*) fInputBuffer->At(clusterArray->at(k));
678 
679  clusterCharge = clusterCharge + digi->GetCharge();
680 
681  Int_t relativeX = digi->GetPixelX() + seedPixelOffset - seedIndexX;
682  Int_t relativeY = digi->GetPixelY() + seedPixelOffset - seedIndexY;
683 
684  //for debugging
685  //cout << relativeX << " " << relativeY << " " <<digi->GetPixelX()<< " " << seedIndexX << endl;
686 
687 
688  if (relativeX >= 0 && relativeX < fChargeArraySize && relativeY >= 0
689  && relativeY < fChargeArraySize) {
690  chargeArray3D[relativeX][relativeY] = digi->GetCharge();
691  }
692 
693  if ((relativeX - seedPixelOffset == 0)
694  && (relativeY - seedPixelOffset == 0)) { //seed digiArray
695  }
696  }
697 
698  //for debugging
699  //for(Int_t i=0;i<fChargeArraySize;i++)
700  //{for (Int_t j=0;j<fChargeArraySize;j++) {cout << chargeArray3D[i][j] << " " ;}
701  // cout << endl;
702  //}
703 
704  //cout << endl;
705  //Fatal("Break","Break");
706 
707  fFullClusterHisto->Fill(clusterCharge);
708 
709  for (Int_t k = 0; k < fChargeArraySize; k++) {
710  for (Int_t j = 0; j < fChargeArraySize; j++) {
711  chargeArray[fChargeArraySize * k + j] = chargeArray3D[k][j];
712  }
713  }
714 
715  Int_t qSeed = chargeArray3D[seedPixelOffset][seedPixelOffset];
716  Int_t q9 = 0;
717 
718  for (Int_t k = seedPixelOffset - 1; k < seedPixelOffset + 1; k++) {
719  for (Int_t j = seedPixelOffset - 1; j < seedPixelOffset + 1; j++) {
720  q9 = q9 + chargeArray3D[k][j];
721  }
722  };
723 
724  if (fChargeArraySize <= 7) {
725  for (Int_t i = 0; i < (fChargeArraySize * fChargeArraySize); i++) {
726  ((TH1F*) fPixelChargeHistos->At(i))->Fill(chargeArray[i]);
727  //cout << counter++<<" Charge: " << chargeArray[i]<< endl;
728  };
729  };
730 
731  //cout << "End of Cluster: "<<fChargeArraySize*fChargeArraySize << endl;
732 
733  Int_t q25 = 0;
734  Int_t q49 = 0;
735 
736 
737  for (Int_t k = seedPixelOffset - 2; k < seedPixelOffset + 2; k++) {
738  for (Int_t j = seedPixelOffset - 2; j < seedPixelOffset + 2; j++) {
739  q25 = q25 + chargeArray3D[k][j];
740  }
741  };
742 
743  if (fChargeArraySize >= 7) {
744  for (Int_t k = seedPixelOffset - 3; k < seedPixelOffset + 3; k++) {
745  for (Int_t j = seedPixelOffset - 3; j < seedPixelOffset + 3; j++) {
746  q49 = q49 + chargeArray3D[k][j];
747  }
748  }
749  }
750 
751  ((TH1F*) fPixelChargeHistos->At(49))->Fill(qSeed);
752  ((TH1F*) fPixelChargeHistos->At(50))->Fill(q9);
753  ((TH1F*) fPixelChargeHistos->At(51))->Fill(q25);
754  ((TH1F*) fPixelChargeHistos->At(52))->Fill(q49);
755 
756  if (fHitPosX - xCentralTrack > 0.003 && fHitPosZ < 6) {
758  }
759 
760  fResolutionHistoX->Fill(fHitPosX - xCentralTrack);
761  fResolutionHistoY->Fill(fHitPosY - yCentralTrack);
762 
763 
764  //Prepare selection of crowns for charge bow histograms
765 
766 
767  Int_t orderArray[fChargeArraySize * fChargeArraySize];
768 
769  TMath::Sort(
770  fChargeArraySize * fChargeArraySize, chargeArray, orderArray, kTRUE);
771 
772  Float_t qSort = 0;
773  for (Int_t i = 0; i < 9; i++) {
774  qSort += chargeArray[orderArray[i]];
775  };
776  ((TH1F*) fPixelChargeHistos->At(53))->Fill(qSort);
777 
778  for (Int_t i = 9; i < 25; i++) {
779  qSort += chargeArray[orderArray[i]];
780  };
781  ((TH1F*) fPixelChargeHistos->At(54))->Fill(qSort);
782 
783  TH1F* histoTotalCharge;
784  qSort = 0;
785  for (Int_t i = 0; i < fChargeArraySize * fChargeArraySize; i++) {
786  qSort += chargeArray[orderArray[i]];
787  ((TH1F*) fPixelChargeHistos->At(55))->Fill(i + 1, qSort);
788  histoTotalCharge = (TH1F*) fTotalChargeInNpixelsArray->At(i);
789  histoTotalCharge->Fill(qSort);
790  };
791 }
792 
793 
794 //--------------------------------------------------------------------------
795 
797  vector<Int_t>* clusterArray,
798  TVector3& pos,
799  TVector3& dpos) {
800  Double_t numeratorX = 0;
801  Double_t numeratorY = 0;
802  Double_t denominator = 0;
803  Double_t pixelSizeX = 0;
804  Double_t pixelSizeY = 0;
805  Int_t charge;
806  Int_t xIndex;
807  Int_t yIndex;
808  Double_t x, y;
809  Double_t layerPosZ = fSensor->GetZ();
810  CbmMvdDigi* pixelInCluster;
811  Double_t lab[3] = {0, 0, 0};
812 
813  Int_t clusterSize = clusterArray->size();
814 
815  for (Int_t iCluster = 0; iCluster < clusterSize; iCluster++) {
816 
817  pixelInCluster = (CbmMvdDigi*) fInputBuffer->At(clusterArray->at(iCluster));
818 
819 
820  charge = GetAdcCharge(pixelInCluster->GetCharge());
821  xIndex = pixelInCluster->GetPixelX();
822  yIndex = pixelInCluster->GetPixelY();
823  pixelSizeX = pixelInCluster->GetPixelSizeX();
824  pixelSizeY = pixelInCluster->GetPixelSizeY();
825 
826  if (gDebug > 0) {
827  cout << "-I- "
828  << "CbmMvdSensorFindHitTask:: iCluster= " << iCluster
829  << " , clusterSize= " << clusterSize << endl;
830  cout << "-I- "
831  << "CbmMvdSensorFindHitTask::xIndex " << xIndex << " , yIndex "
832  << yIndex << " , charge = "
833  << pixelInCluster->GetAdcCharge(fAdcDynamic, fAdcOffset, fAdcBits)
834  << endl;
835  }
836 
838 
839  x = lab[0];
840  y = lab[1];
841 
842  //cout << endl << "x = " << x << " y = " << y << endl;
843  //Calculate x,y coordinates of the pixel in the detector ref frame
844  //Double_t x = ( 0.5+double(xIndex) )*pixelSizeX;
845  //Double_t y = ( 0.5+double(yIndex) )*pixelSizeY;
846 
847  Double_t xc = x * charge;
848  Double_t yc = y * charge;
849 
850 
851  numeratorX += xc;
852  numeratorY += yc;
853  denominator += charge;
854  }
855 
856  if (gDebug > 0) {
857  cout << "-I- "
858  << "CbmMvdSensorFindHitTask::=========================\n " << endl;
859  cout << "-I- "
860  << "CbmMvdSensorFindHitTask::numeratorX: " << numeratorX
861  << " , numeratorY: " << numeratorY << ", denominator: " << denominator
862  << endl;
863  }
864 
865  //Calculate x,y coordinates of the pixel in the laboratory ref frame
866  if (denominator != 0) {
869  fHitPosZ = layerPosZ;
870  } else {
871  fHitPosX = 0;
872  fHitPosY = 0;
873  fHitPosZ = 0;
874  }
875  if (gDebug > 0) {
876  cout << "-I- "
877  << "CbmMvdSensorFindHitTask::-----------------------------------"
878  << endl;
879  cout << "-I- "
880  << "CbmMvdSensorFindHitTask::X hit= " << fHitPosX
881  << " Y hit= " << fHitPosY << " Z hit= " << fHitPosZ << endl;
882 
883  cout << "-I- "
884  << "CbmMvdSensorFindHitTask::-----------------------------------\n"
885  << endl;
886  }
887 
888  // pos = center of gravity (labframe), dpos uncertainty
889  pos.SetXYZ(fHitPosX, fHitPosY, fHitPosZ);
891 }
892 
893 //--------------------------------------------------------------------------
894 
895 
896 //--------------------------------------------------------------------------
898  if (fShowDebugHistos) {
899  cout << "\n============================================================"
900  << endl;
901  cout << "-I- " << GetName()
902  << "::Finish: Total events skipped: " << fCounter << endl;
903  cout << "============================================================"
904  << endl;
905  cout << "-I- Parameters used" << endl;
906  cout << "Gaussian noise [electrons] : " << fSigmaNoise << endl;
907  cout << "Noise simulated [Bool] : " << fAddNoise << endl;
908  cout << "Threshold seed [ADC] : " << fSeedThreshold << endl;
909  cout << "Threshold neighbours [ADC] : " << fNeighThreshold << endl;
910  cout << "ADC - Bits : " << fAdcBits << endl;
911  cout << "ADC - Dynamic [electrons] : " << fAdcDynamic << endl;
912  cout << "ADC - Offset [electrons] : " << fAdcOffset << endl;
913  cout << "============================================================"
914  << endl;
915 
916 
917  TH1F* histo;
918  TH2F* clusterShapeHistogram;
919 
920 
921  TCanvas* canvas2 = new TCanvas("HitFinderCharge", "HitFinderCharge");
922  //cout <<fChargeArraySize << endl;
923  canvas2->Divide(2, 2);
924  canvas2->cd(1);
925 
926 
927  if (fChargeArraySize <= 7) {
928  clusterShapeHistogram = new TH2F("MvdClusterShape",
929  "MvdClusterShape",
931  0,
934  0,
936 
937  for (Int_t i = 0; i < fChargeArraySize * fChargeArraySize; i++) {
938  histo = (TH1F*) fPixelChargeHistos->At(i);
939  Float_t charge = histo->GetMean();
940  //cout <<i << " Charge " << charge << " xCluster: " << i%fChargeArraySize << " yCluster: " << i/fChargeArraySize << endl;
941  //histo->Fit("landau");
942  //TF1* fitFunction= histo->GetFunction("landau");
943  // Double_t MPV=fitFunction->GetParameter(1);
944  clusterShapeHistogram->Fill(
945  i % fChargeArraySize, i / fChargeArraySize, charge);
946  //canvas2->cd(i);
947  //histo->Draw();
948  }
949  }
950 
951  clusterShapeHistogram->Draw("Lego2");
952  canvas2->cd(2);
953  histo = (TH1F*) fPixelChargeHistos->At(24);
954  histo->Draw();
955  //cout <<"Mean charge" << histo->GetMean() << endl;
956  /*
957  TCanvas* canvas=new TCanvas("HitFinderCanvas","HitFinderCanvas");
958  canvas->Divide (2,3);
959  canvas->cd(1);
960  fResolutionHistoX->Draw();
961  fResolutionHistoX->Write();
962  canvas->cd(2);
963  fResolutionHistoY->Draw();
964  fResolutionHistoY->Write();
965  canvas->cd(3);
966  ((TH1F*)fPixelChargeHistos->At(49))->Draw();
967  ((TH1F*)fPixelChargeHistos->At(49))->Fit("landau");
968  canvas->cd(4);
969  fFullClusterHisto->Draw();
970  canvas->cd(5);
971  ((TH1F*)fTotalChargeInNpixelsArray->At(0))->Draw();
972  ((TH1F*)fTotalChargeInNpixelsArray->At(0))->Fit("landau");
973  //fResolutionHistoMergedX->Write();
974  canvas->cd(6);
975  clusterShapeHistogram->Draw("Lego2");
976  //fResolutionHistoMergedY->Draw();
977  //fResolutionHistoMergedY->Write();*/
978  }
979 }
980 //--------------------------------------------------------------------------
981 
983 
984  Int_t adcCharge;
985 
986  if (charge < fAdcOffset) { return 0; };
987 
988  adcCharge = int((charge - fAdcOffset) / fAdcStepSize);
989  if (adcCharge > fAdcSteps - 1) { adcCharge = fAdcSteps - 1; }
990 
991  return adcCharge;
992 }
993 
994 
995 // ----- Private method Reset ------------------------------------------
997  fHits->Clear("C");
998  fClusters->Clear("C");
999 }
1000 
1001 // -------------------------------------------------------------------------
1002 
1003 
CbmMvdSensorFindHitTask::fGausArray
Float_t * fGausArray
Definition: CbmMvdSensorFindHitTask.h:135
CbmMvdDigi::GetPixelY
Int_t GetPixelY()
Definition: CbmMvdDigi.cxx:143
CbmMvdDigi::GetCharge
Double_t GetCharge() const
Definition: CbmMvdDigi.h:49
CbmMvdSensorTask::fSensor
CbmMvdSensor * fSensor
Definition: CbmMvdSensorTask.h:59
CbmMvdSensorFindHitTask::fMode
Int_t fMode
Definition: CbmMvdSensorFindHitTask.h:154
CbmMvdSensorFindHitTask::ComputeCenterOfGravity
void ComputeCenterOfGravity(std::vector< Int_t > *clusterArray, TVector3 &pos, TVector3 &dpos)
Definition: CbmMvdSensorFindHitTask.cxx:796
CbmMvdSensor::GetZ
Double_t GetZ() const
Definition: CbmMvdSensor.h:75
CbmMvdSensorFindHitTask::fHitPosErrX
Double_t fHitPosErrX
Definition: CbmMvdSensorFindHitTask.h:170
CbmMvdSensorFindHitTask::CheckForNeighbours
void CheckForNeighbours(std::vector< Int_t > *clusterArray, Int_t clusterDigi, TArrayS *pixelUsed)
Definition: CbmMvdSensorFindHitTask.cxx:481
CbmMvdDigi::GetAdcCharge
Int_t GetAdcCharge(Int_t adcDynamic, Int_t adcOffset, Int_t adcBits)
Definition: CbmMvdDigi.cxx:103
CbmMvdSensorFindHitTask::fAdcBits
Int_t fAdcBits
Definition: CbmMvdSensorFindHitTask.h:115
CbmMvdSensorFindHitTask::GetAdcCharge
Int_t GetAdcCharge(Float_t charge)
Definition: CbmMvdSensorFindHitTask.cxx:982
CbmMvdSensorFindHitTask::fHits
TClonesArray * fHits
Definition: CbmMvdSensorFindHitTask.h:120
CbmMvdSensorFindHitTask.h
CbmMvdSensorFindHitTask::fHitPosErrZ
Double_t fHitPosErrZ
Definition: CbmMvdSensorFindHitTask.h:172
ClassImp
ClassImp(CbmMvdSensorFindHitTask)
i
int i
Definition: L1/vectors/P4_F32vec4.h:25
CbmMvdSensorFindHitTask::fSeedThreshold
Double_t fSeedThreshold
Definition: CbmMvdSensorFindHitTask.h:157
CbmMvdCluster
Definition: CbmMvdCluster.h:27
CbmMvdSensorFindHitTask::fCounter
Int_t fCounter
Definition: CbmMvdSensorFindHitTask.h:155
CbmMvdSensorFindHitTask::fHitPosY
Double_t fHitPosY
Definition: CbmMvdSensorFindHitTask.h:168
lab
Double_t lab[3]
Definition: CbmMvdSensorDigiToHitTask.cxx:62
CbmMvdSensorFindHitTask::CbmMvdSensorFindHitTask
CbmMvdSensorFindHitTask()
Definition: CbmMvdSensorFindHitTask.cxx:60
CbmMvdSensor::GetStationNr
Int_t GetStationNr() const
Definition: CbmMvdSensor.h:61
CbmMvdSensorTask::fOutputBuffer
TClonesArray * fOutputBuffer
Definition: CbmMvdSensorTask.h:58
CbmMvdSensorFindHitTask::fHitPosZ
Double_t fHitPosZ
Definition: CbmMvdSensorFindHitTask.h:169
CbmMvdSensor::GetIntegrationtime
Double_t GetIntegrationtime() const
Definition: CbmMvdSensor.h:76
CbmMvdSensorFindHitTask::AddNoiseToDigis
void AddNoiseToDigis(CbmMvdDigi *digi)
Definition: CbmMvdSensorFindHitTask.cxx:413
CbmMvdSensorFindHitTask::fResolutionHistoX
TH1F * fResolutionHistoX
Definition: CbmMvdSensorFindHitTask.h:128
CbmMvdSensorFindHitTask::fDigiMapIt
std::map< std::pair< Int_t, Int_t >, Int_t >::iterator fDigiMapIt
Definition: CbmMvdSensorFindHitTask.h:140
CbmMvdHit
Definition: CbmMvdHit.h:29
CbmHit::SetRefId
void SetRefId(Int_t refId)
Definition: CbmHit.h:81
CbmMvdSensorTask
Definition: CbmMvdSensorTask.h:26
CbmMvdSensorFindHitTask::fNeighThreshold
Double_t fNeighThreshold
Definition: CbmMvdSensorFindHitTask.h:158
CbmMvdSensorPlugin::initialized
Bool_t initialized
Definition: CbmMvdSensorPlugin.h:71
CbmMvdSensorFindHitTask::InitTask
void InitTask(CbmMvdSensor *mySensor)
Definition: CbmMvdSensorFindHitTask.cxx:191
CbmMvdPoint.h
CbmMvdSensorFindHitTask::~CbmMvdSensorFindHitTask
virtual ~CbmMvdSensorFindHitTask()
Definition: CbmMvdSensorFindHitTask.cxx:171
CbmMvdSensor
Definition: CbmMvdSensor.h:40
CbmMvdDigi::GetPixelSizeX
Double_t GetPixelSizeX()
Definition: CbmMvdDigi.h:52
dpos
TVector3 dpos
Definition: CbmMvdSensorDigiToHitTask.cxx:61
CbmMvdSensorFindHitTask::fBadHitHisto
TH2F * fBadHitHisto
Definition: CbmMvdSensorFindHitTask.h:134
CbmMvdSensorFindHitTask::fGausArrayIt
Int_t fGausArrayIt
Definition: CbmMvdSensorFindHitTask.h:136
h
Data class with information on a STS local track.
yIndex
Int_t yIndex
Definition: CbmMvdSensorDigiToHitTask.cxx:67
CbmMvdSensorFindHitTask
Definition: CbmMvdSensorFindHitTask.h:39
CbmMvdSensorFindHitTask::ReInit
InitStatus ReInit()
Definition: CbmMvdSensorFindHitTask.cxx:223
CbmMvdSensorFindHitTask::fAdcOffset
Int_t fAdcOffset
Definition: CbmMvdSensorFindHitTask.h:114
CbmMvdSensorPlugin::GetName
virtual const char * GetName() const
Definition: CbmMvdSensorPlugin.h:62
CbmMvdDigi::GetRefId
Int_t GetRefId() const
Definition: CbmMvdDigi.h:63
CbmMvdSensorFindHitTask::Reset
void Reset()
Definition: CbmMvdSensorFindHitTask.cxx:996
CbmMvdSensorFindHitTask::Finish
void Finish()
Definition: CbmMvdSensorFindHitTask.cxx:897
CbmMvdSensor::PixelToTop
void PixelToTop(Int_t pixelNumberX, Int_t pixelNumberY, Double_t *lab)
Definition: CbmMvdSensor.cxx:624
CbmMvdSensorFindHitTask::fShowDebugHistos
Bool_t fShowDebugHistos
Definition: CbmMvdSensorFindHitTask.h:159
CbmMvdSensorFindHitTask::fResolutionHistoY
TH1F * fResolutionHistoY
Definition: CbmMvdSensorFindHitTask.h:129
CbmMvdSensorFindHitTask::fAddNoise
Bool_t fAddNoise
Definition: CbmMvdSensorFindHitTask.h:180
CbmMvdSensorFindHitTask::fTotalChargeInNpixelsArray
TObjArray * fTotalChargeInNpixelsArray
Definition: CbmMvdSensorFindHitTask.h:125
xIndex
Int_t xIndex
Definition: CbmMvdSensorDigiToHitTask.cxx:66
CbmMvdSensorFindHitTask::fAdcDynamic
Int_t fAdcDynamic
Definition: CbmMvdSensorFindHitTask.h:113
CbmMvdSensorFindHitTask::fClusters
TClonesArray * fClusters
Definition: CbmMvdSensorFindHitTask.h:121
fCounter
constexpr const Int_t fCounter(0)
CbmMvdSensorFindHitTask::fDigiMap
std::map< std::pair< Int_t, Int_t >, Int_t > fDigiMap
Definition: CbmMvdSensorFindHitTask.h:139
CbmMvdSensorFindHitTask::Exec
void Exec()
Definition: CbmMvdSensorFindHitTask.cxx:235
CbmHit::SetTimeError
void SetTimeError(Double_t error)
Definition: CbmHit.h:89
CbmMvdDigi::SetCharge
void SetCharge(Float_t charge)
Definition: CbmMvdDigi.h:77
CbmHit::SetTime
void SetTime(Double_t time)
Definition: CbmHit.h:84
CbmMvdSensorFindHitTask::fFullClusterHisto
TH1F * fFullClusterHisto
Definition: CbmMvdSensorFindHitTask.h:148
CbmMvdSensorFindHitTask::ExecChain
void ExecChain()
Definition: CbmMvdSensorFindHitTask.cxx:231
CbmMvdSensorFindHitTask::CreateHit
void CreateHit(std::vector< Int_t > *clusterArray, TVector3 &pos, TVector3 &dpos)
Definition: CbmMvdSensorFindHitTask.cxx:545
CbmMvdSensorTask::fInputBuffer
TClonesArray * fInputBuffer
Definition: CbmMvdSensorTask.h:53
CbmMvdSensorFindHitTask::fPixelChargeHistos
TObjArray * fPixelChargeHistos
Definition: CbmMvdSensorFindHitTask.h:124
CbmMvdSensorFindHitTask::fChargeArraySize
static const Short_t fChargeArraySize
Definition: CbmMvdSensorFindHitTask.h:177
numeratorX
Double_t numeratorX
Definition: CbmMvdSensorDigiToHitTask.cxx:63
CbmMCTrack.h
CbmMvdSensorFindHitTask::fGausArrayLimit
Int_t fGausArrayLimit
Definition: CbmMvdSensorFindHitTask.h:137
CbmMvdSensorFindHitTask::fSigmaNoise
Double_t fSigmaNoise
Definition: CbmMvdSensorFindHitTask.h:156
CbmMvdSensorFindHitTask::fHitPosErrY
Double_t fHitPosErrY
Definition: CbmMvdSensorFindHitTask.h:171
CbmMvdSensorFindHitTask::fHitPosX
Double_t fHitPosX
Definition: CbmMvdSensorFindHitTask.h:167
x
Double_t x
Definition: CbmMvdSensorDigiToHitTask.cxx:68
CbmMvdHit.h
CbmMvdSensorFindHitTask::UpdateDebugHistos
void UpdateDebugHistos(std::vector< Int_t > *clusterArray, Int_t seedIndexX, Int_t seedIndexY)
Definition: CbmMvdSensorFindHitTask.cxx:652
CbmMvdDigi::GetPixelSizeY
Double_t GetPixelSizeY()
Definition: CbmMvdDigi.h:53
y
Double_t y
Definition: CbmMvdSensorDigiToHitTask.cxx:68
CbmMvdSensorFindHitTask::fAdcStepSize
Float_t fAdcStepSize
Definition: CbmMvdSensorFindHitTask.h:117
CbmMvdPileupManager.h
CbmMvdDigi
Definition: CbmMvdDigi.h:21
CbmMvdSensorFindHitTask::fDigisInCluster
Int_t fDigisInCluster
Definition: CbmMvdSensorFindHitTask.h:176
pos
TVector3 pos
Definition: CbmMvdSensorDigiToHitTask.cxx:60
CbmMvdDigi::GetPixelX
Int_t GetPixelX()
Definition: CbmMvdDigi.cxx:141
CbmMvdSensorFindHitTask::inputSet
Bool_t inputSet
Definition: CbmMvdSensorFindHitTask.h:161
CbmMvdSensor::TopToPixel
void TopToPixel(Double_t *lab, Int_t &pixelNumberX, Int_t &pixelNumberY)
Definition: CbmMvdSensor.cxx:633
PairAnalysisStyler::Fill
static Int_t Fill[]
Definition: PairAnalysisStyleDefs.h:82
numeratorY
Double_t numeratorY
Definition: CbmMvdSensorDigiToHitTask.cxx:64
CbmMvdSensorFindHitTask::fAdcSteps
Int_t fAdcSteps
Definition: CbmMvdSensorFindHitTask.h:116
CbmMvdSensor::GetCurrentEventTime
Double_t GetCurrentEventTime() const
Definition: CbmMvdSensor.h:79
denominator
Double_t denominator
Definition: CbmMvdSensorDigiToHitTask.cxx:65
CbmMvdCluster.h
CbmMvdSensor::GetVolumeId
Int_t GetVolumeId() const
Definition: CbmMvdSensor.h:62