CbmRoot
CbmMvdSensorHitfinderTask.cxx
Go to the documentation of this file.
1 // ---------------------------------------------------------------------------------------------
2 // ----- CbmMvdSensorHitfinderTask source file -----
3 // ----- Created 11/09/13 by P.Sitzmann -----
4 // ----- -----
5 // ---------------------------------------------------------------------------------------------
6 // Includes from MVD
7 #include "CbmMvdSensorHitfinderTask.h"
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 #include <TMatrixD.h>
30 
31 #include "TClonesArray.h"
32 
33 #include "TF1.h"
34 #include "TH1.h"
35 #include "TH2.h"
36 #include "TMath.h"
37 #include "TRandom3.h"
38 #include "TString.h"
39 #include "TVector3.h"
40 
41 // Includes from C++
42 #include <iomanip>
43 #include <iostream>
44 #include <map>
45 #include <vector>
46 
47 using std::cout;
48 using std::endl;
49 using std::fixed;
50 using std::ios_base;
51 using std::left;
52 using std::map;
53 using std::pair;
54 using std::right;
55 using std::setprecision;
56 using std::setw;
57 using std::vector;
58 
59 
60 // ----- Default constructor ------------------------------------------
61 CbmMvdSensorHitfinderTask::CbmMvdSensorHitfinderTask()
62  : CbmMvdSensorTask()
63  , fAdcDynamic(200)
64  , fAdcOffset(0)
65  , fAdcBits(1)
66  , fAdcSteps(-1)
67  , fAdcStepSize(-1.)
68  , fClusters(new TClonesArray("CbmMvdCluster", 10000))
69  , fPixelChargeHistos(NULL)
70  , fTotalChargeInNpixelsArray(NULL)
71  , fResolutionHistoX(NULL)
72  , fResolutionHistoY(NULL)
73  , fResolutionHistoCleanX(NULL)
74  , fResolutionHistoCleanY(NULL)
75  , fResolutionHistoMergedX(NULL)
76  , fResolutionHistoMergedY(NULL)
77  , fBadHitHisto(NULL)
78  , fGausArray(NULL)
79  , fGausArrayIt(-1)
80  , fGausArrayLimit(5000)
81  , fDigiMap()
82  , fDigiMapIt()
83  , h(NULL)
84  , h3(NULL)
85  , h1(NULL)
86  , h2(NULL)
87  , Qseed(NULL)
88  , fFullClusterHisto(NULL)
89  , c1(NULL)
90  , fNEvent(0)
91  , fMode(0)
92  , fCounter(0)
93  , fSigmaNoise(15.)
94  , fSeedThreshold(1.)
95  , fNeighThreshold(1.)
96  , fShowDebugHistos(kFALSE)
97  , fUseMCInfo(kFALSE)
98  , inputSet(kFALSE)
99  , fLayerRadius(0.)
100  , fLayerRadiusInner(0.)
101  , fLayerPosZ(0.)
102  , fHitPosX(0.)
103  , fHitPosY(0.)
104  , fHitPosZ(0.)
105  , fHitPosErrX(0.0005)
106  , fHitPosErrY(0.0005)
107  , fHitPosErrZ(0.0)
108  , fBranchName("MvdHit")
109  , fDigisInCluster(0)
110  , fAddNoise(kFALSE) {}
111 // -------------------------------------------------------------------------
112 
113 
114 // ----- Standard constructor ------------------------------------------
115 CbmMvdSensorHitfinderTask::CbmMvdSensorHitfinderTask(Int_t iMode)
116  : CbmMvdSensorTask()
117  , fAdcDynamic(200)
118  , fAdcOffset(0)
119  , fAdcBits(1)
120  , fAdcSteps(-1)
121  , fAdcStepSize(-1.)
122  , fClusters(new TClonesArray("CbmMvdCluster", 10000))
123  , fPixelChargeHistos(NULL)
124  , fTotalChargeInNpixelsArray(NULL)
125  , fResolutionHistoX(NULL)
126  , fResolutionHistoY(NULL)
127  , fResolutionHistoCleanX(NULL)
128  , fResolutionHistoCleanY(NULL)
129  , fResolutionHistoMergedX(NULL)
130  , fResolutionHistoMergedY(NULL)
131  , fBadHitHisto(NULL)
132  , fGausArray(NULL)
133  , fGausArrayIt(-1)
134  , fGausArrayLimit(5000)
135  , fDigiMap()
136  , fDigiMapIt()
137  , h(NULL)
138  , h3(NULL)
139  , h1(NULL)
140  , h2(NULL)
141  , Qseed(NULL)
142  , fFullClusterHisto(NULL)
143  , c1(NULL)
144  , fNEvent(0)
145  , fMode(iMode)
146  , fCounter(0)
147  , fSigmaNoise(15.)
148  , fSeedThreshold(1.)
149  , fNeighThreshold(1.)
150  , fShowDebugHistos(kFALSE)
151  , fUseMCInfo(kFALSE)
152  , inputSet(kFALSE)
153  , fLayerRadius(0.)
154  , fLayerRadiusInner(0.)
155  , fLayerPosZ(0.)
156  , fHitPosX(0.)
157  , fHitPosY(0.)
158  , fHitPosZ(0.)
159  , fHitPosErrX(0.0005)
160  , fHitPosErrY(0.0005)
161  , fHitPosErrZ(0.0)
162  , fBranchName("MvdHit")
163  , fDigisInCluster(0)
164  , fAddNoise(kFALSE) {}
165 // -------------------------------------------------------------------------
166 
167 // ----- Destructor ----------------------------------------------------
168 CbmMvdSensorHitfinderTask::~CbmMvdSensorHitfinderTask() {
169 
170  if (fOutputBuffer) {
171  fOutputBuffer->Delete();
172  delete fOutputBuffer;
173  }
174 
175  if (fClusters) {
176  fClusters->Delete();
177  delete fClusters;
178  }
179 
180  if (fInputBuffer) {
181  fInputBuffer->Delete();
182  delete fInputBuffer;
183  }
184 }
185 // -------------------------------------------------------------------------
186 
187 // ----- Virtual private method Init ----------------------------------
188 void CbmMvdSensorHitfinderTask::InitTask(CbmMvdSensor* mysensor) {
189 
190 
191  fSensor = mysensor;
192  //cout << "-Start- " << GetName() << ": Initialisation of sensor " << fSensor->GetName() << endl;
193  fInputBuffer = new TClonesArray("CbmMvdCluster", 10000);
194  fOutputBuffer = new TClonesArray("CbmMvdHit", 10000);
195 
196 
197  //Add charge collection histograms
198  fPixelChargeHistos = new TObjArray();
199 
200  fTotalChargeInNpixelsArray = new TObjArray();
201 
202  fAdcSteps = (Int_t) TMath::Power(2, fAdcBits);
203  fAdcStepSize = fAdcDynamic / fAdcSteps;
204 
205  fGausArray = new Float_t[fGausArrayLimit];
206  for (Int_t i = 0; i < fGausArrayLimit; i++) {
207  fGausArray[i] = gRandom->Gaus(0, fSigmaNoise);
208  };
209  fGausArrayIt = 0;
210 
211 
212  initialized = kTRUE;
213 
214  //cout << "-Finished- " << GetName() << ": Initialisation of sensor " << fSensor->GetName() << endl;
215 }
216 // -------------------------------------------------------------------------
217 
218 // ----- Virtual public method Reinit ----------------------------------
219 InitStatus CbmMvdSensorHitfinderTask::ReInit() {
220  cout << "-I- "
221  << "CbmMvdSensorHitfinderTask::ReInt---------------" << endl;
222  return kSUCCESS;
223 }
224 // -------------------------------------------------------------------------
225 
226 // ----- Virtual public method ExecChain --------------
227 void CbmMvdSensorHitfinderTask::ExecChain() { Exec(); }
228 // -------------------------------------------------------------------------
229 
230 // ----- Virtual public method Exec --------------
231 void CbmMvdSensorHitfinderTask::Exec() {
232 
233  // if(!inputSet)
234  // {
235  // fInputBuffer->Clear();
236  // fInputBuffer->AbsorbObjects(fPreviousPlugin->GetOutputArray());
237  // cout << endl << "absorbt object from previous plugin at " << fSensor->GetName() << " got " << fInputBuffer->GetEntriesFast() << " entrys" << endl;
238  // }
239  if (fInputBuffer->GetEntriesFast() > 0) {
240 
241  fOutputBuffer->Clear();
242  inputSet = kFALSE;
243  for (Int_t i = 0; i < fInputBuffer->GetEntriesFast(); i++) {
244  CbmMvdCluster* cluster = (CbmMvdCluster*) fInputBuffer->At(i);
245  TVector3 pos(0, 0, 0);
246  TVector3 dpos(0, 0, 0);
247  CreateHit(cluster, pos, dpos);
248  }
249  }
250  fInputBuffer->Delete();
251 }
252 //--------------------------------------------------------------------------
253 
254 
255 //--------------------------------------------------------------------------
256 void CbmMvdSensorHitfinderTask::CreateHit(CbmMvdCluster* cluster,
257  TVector3& pos,
258  TVector3& dpos) {
259  // Calculate the center of gravity of the charge of a cluster
260 
261  ComputeCenterOfGravity(cluster, pos, dpos);
262 
263 
264  Int_t indexX, indexY;
265  //Double_t x,y;
266  Double_t local[2];
267  local[0] = pos.X();
268  local[1] = pos.Y();
269  //cout << endl << "found center of gravity at: " << local[0] << " , " << local[1] << endl;
270 
271  fSensor->TopToPixel(local, indexX, indexY);
272 
273  //cout << endl << "Center is on pixel: " << indexX << " , " << indexY << endl;
274 
275 
276  // Save hit into array
277 
278  //cout << endl << "adding new hit to fHits at X: " << pos.X() << " , Y: "<< pos.Y() << " , Z: " << pos.Z() << " , from cluster nr " << cluster->GetRefId() ;
279  Int_t nHits = fOutputBuffer->GetEntriesFast();
280  new ((*fOutputBuffer)[nHits]) CbmMvdHit(
281  fSensor->GetStationNr(), pos, dpos, indexX, indexY, cluster->GetRefId(), 0);
282  CbmMvdHit* currentHit = (CbmMvdHit*) fOutputBuffer->At(nHits);
283  currentHit->SetTime(fSensor->GetCurrentEventTime());
284  currentHit->SetTimeError(fSensor->GetIntegrationtime() / 2);
285  currentHit->SetRefId(cluster->GetRefId());
286 }
287 
288 //--------------------------------------------------------------------------
289 
290 /*void CbmMvdSensorHitfinderTask::UpdateDebugHistos(vector<Int_t>* clusterArray, Int_t seedIndexX, Int_t seedIndexY)
291 {
292 ;
293 } */
294 
295 
296 //--------------------------------------------------------------------------
297 
298 void CbmMvdSensorHitfinderTask::ComputeCenterOfGravity(CbmMvdCluster* cluster,
299  TVector3& pos,
300  TVector3& dpos) {
301 
302  Double_t numeratorX = 0;
303  Double_t numeratorY = 0;
304  Double_t denominator = 0;
305  Int_t charge;
306  Int_t xIndex;
307  Int_t yIndex;
308  Double_t x, y;
309  Double_t layerPosZ = fSensor->GetZ();
310  Double_t lab[3] = {0, 0, 0};
311  std::map<pair<Int_t, Int_t>, Int_t> PixelMap = cluster->GetPixelMap();
312  Int_t clusterSize = cluster->GetNofDigis();
313 
314  UInt_t shape = 0;
315  Int_t xIndex0 = 0;
316  Int_t yIndex0 = 0;
317  Double_t sigmaIn[3], sigmaOut[3], shiftIn[3], shiftOut[3];
318 
319  for (map<pair<Int_t, Int_t>, Int_t>::iterator it = PixelMap.begin();
320  it != PixelMap.end();
321  ++it) {
322  pair<Int_t, Int_t> pixel = it->first;
323 
324  charge = GetAdcCharge(it->second);
325  xIndex = pixel.first;
326  yIndex = pixel.second;
327 
328  // Determine Cluster Shape
329  if (PixelMap.size() <= 4) {
330  if (it == PixelMap.begin()) {
331  xIndex0 = xIndex;
332  yIndex0 = yIndex;
333  }
334  shape +=
335  TMath::Power(2, (4 * (yIndex - yIndex0 + 3)) + (xIndex - xIndex0));
336  }
337 
338  if (gDebug > 0) {
339  cout << "-I- "
340  << "CbmMvdSensorHitfinderTask:: iCluster= " << cluster->GetRefId()
341  << " , clusterSize= " << clusterSize << endl;
342  cout << "-I- "
343  << "CbmMvdSensorHitfinderTask::xIndex " << xIndex << " , yIndex "
344  << yIndex << " , charge = " << charge << endl;
345  }
346 
347  fSensor->PixelToTop(xIndex, yIndex, lab);
348 
349  x = lab[0];
350  y = lab[1];
351 
352  Double_t xc = x * charge;
353  Double_t yc = y * charge;
354 
355  numeratorX += xc;
356  numeratorY += yc;
357  denominator += charge;
358  }
359 
360  if (gDebug > 0) {
361  cout << "-I- "
362  << "CbmMvdSensorHitfinderTask::=========================\n " << endl;
363  cout << "-I- "
364  << "CbmMvdSensorHitfinderTask::numeratorX: " << numeratorX
365  << " , numeratorY: " << numeratorY << ", denominator: " << denominator
366  << endl;
367  }
368 
369  //Calculate x,y coordinates of the pixel in the laboratory ref frame
370  if (denominator != 0) {
371  fHitPosX = (numeratorX / denominator);
372  fHitPosY = (numeratorY / denominator);
373  fHitPosZ = layerPosZ;
374  } else {
375  fHitPosX = 0;
376  fHitPosY = 0;
377  fHitPosZ = 0;
378  }
379 
380  if (gDebug > 0) {
381  cout << "-I- "
382  << "CbmMvdSensorHitfinderTask::-----------------------------------"
383  << endl;
384  cout << "-I- "
385  << "CbmMvdSensorHitfinderTask::X hit= " << fHitPosX
386  << " Y hit= " << fHitPosY << " Z hit= " << fHitPosZ << endl;
387  cout << "-I- "
388  << "CbmMvdSensorHitfinderTask::-----------------------------------\n"
389  << endl;
390  }
391 
392  // Treat Sigma/Shift of the Cluster according to the Shape
393  if (shape == 12288) {
394  sigmaIn[0] = 0.00053;
395  sigmaIn[1] = 0.00063;
396  sigmaIn[2] = 0.;
397  shiftIn[0] = -0.00000;
398  shiftIn[1] = -0.00001;
399  shiftIn[2] = 0.;
400  } else if (shape == 208896) {
401  sigmaIn[0] = 0.00035;
402  sigmaIn[1] = 0.00036;
403  sigmaIn[2] = 0.;
404  shiftIn[0] = -0.00000;
405  shiftIn[1] = -0.00002;
406  shiftIn[2] = 0.;
407  } else if (shape == 69632) {
408  sigmaIn[0] = 0.00028;
409  sigmaIn[1] = 0.00028;
410  sigmaIn[2] = 0.;
411  shiftIn[0] = -0.00000;
412  shiftIn[1] = -0.00002;
413  shiftIn[2] = 0.;
414  } else if (shape == 28672) {
415  sigmaIn[0] = 0.00028;
416  sigmaIn[1] = 0.00039;
417  sigmaIn[2] = 0.;
418  shiftIn[0] = -0.00000;
419  shiftIn[1] = -0.00001;
420  shiftIn[2] = 0.;
421  } else if (shape == 143360) {
422  sigmaIn[0] = 0.00024;
423  sigmaIn[1] = 0.00022;
424  sigmaIn[2] = 0.;
425  shiftIn[0] = +0.00020;
426  shiftIn[1] = +0.00008;
427  shiftIn[2] = 0.;
428  } else if (shape == 200704) {
429  sigmaIn[0] = 0.00024;
430  sigmaIn[1] = 0.00022;
431  sigmaIn[2] = 0.;
432  shiftIn[0] = -0.00020;
433  shiftIn[1] = -0.00011;
434  shiftIn[2] = 0.;
435  } else if (shape == 77824) {
436  sigmaIn[0] = 0.00024;
437  sigmaIn[1] = 0.00022;
438  sigmaIn[2] = 0.;
439  shiftIn[0] = -0.00020;
440  shiftIn[1] = +0.00008;
441  shiftIn[2] = 0.;
442  } else if (shape == 12800) {
443  sigmaIn[0] = 0.00024;
444  sigmaIn[1] = 0.00022;
445  sigmaIn[2] = 0.;
446  shiftIn[0] = +0.00020;
447  shiftIn[1] = -0.00011;
448  shiftIn[2] = 0.;
449  } else if (shape == 4096) {
450  sigmaIn[0] = 0.00027;
451  sigmaIn[1] = 0.00092;
452  sigmaIn[2] = 0.;
453  shiftIn[0] = +0.00002;
454  shiftIn[1] = +0.00004;
455  shiftIn[2] = 0.;
456  } else {
457  sigmaIn[0] = 0.00036;
458  sigmaIn[1] = 0.00044;
459  sigmaIn[2] = 0.;
460  shiftIn[0] = -0.00000;
461  shiftIn[1] = -0.00002;
462  shiftIn[2] = 0.;
463  }
464  // Consider Sensor Orientation
465  TGeoHMatrix* RecoMatrix = fSensor->GetRecoMatrix();
466  TGeoHMatrix RotMatrix;
467  RotMatrix.SetRotation(RecoMatrix->GetRotationMatrix());
468 
469  RotMatrix.LocalToMaster(sigmaIn, sigmaOut);
470  RotMatrix.LocalToMaster(shiftIn, shiftOut);
471 
472  fHitPosErrX = TMath::Abs(sigmaOut[0]);
473  fHitPosErrY = TMath::Abs(sigmaOut[1]);
474  fHitPosErrZ = TMath::Abs(sigmaOut[2]);
475 
476  fHitPosX += shiftOut[0];
477  fHitPosY += shiftOut[1];
478  fHitPosZ += shiftOut[2];
479 
480  // pos = center of gravity (labframe), dpos uncertaintycout<<setw(10)<<setprecision(2)<< VolumeShape->GetDX();
481  pos.SetXYZ(fHitPosX, fHitPosY, fHitPosZ);
482  dpos.SetXYZ(fHitPosErrX, fHitPosErrY, fHitPosErrZ);
483 }
484 
485 //--------------------------------------------------------------------------
486 
487 
488 //--------------------------------------------------------------------------
489 void CbmMvdSensorHitfinderTask::Finish() {}
490 //--------------------------------------------------------------------------
491 
492 Int_t CbmMvdSensorHitfinderTask::GetAdcCharge(Float_t charge) {
493 
494  Int_t adcCharge;
495 
496  if (charge < fAdcOffset) { return 0; };
497 
498  adcCharge = int((charge - fAdcOffset) / fAdcStepSize);
499  if (adcCharge > fAdcSteps - 1) { adcCharge = fAdcSteps - 1; }
500 
501  return adcCharge;
502 }
503 
504 
505 // ----- Private method Reset ------------------------------------------
506 void CbmMvdSensorHitfinderTask::Reset() { fClusters->Clear("C"); }
507 
508 // -------------------------------------------------------------------------
509 
510 
511 ClassImp(CbmMvdSensorHitfinderTask);
CbmMvdSensorTask::fSensor
CbmMvdSensor * fSensor
Definition: CbmMvdSensorTask.h:59
CbmMvdSensorHitfinderTask::fAdcDynamic
Int_t fAdcDynamic
Definition: CbmMvdSensorHitfinderTask.h:114
CbmMvdSensorHitfinderTask::CbmMvdSensorHitfinderTask
CbmMvdSensorHitfinderTask()
Definition: CbmMvdSensorHitfinderTask.cxx:61
CbmMvdSensorHitfinderTask::fAdcSteps
Int_t fAdcSteps
Definition: CbmMvdSensorHitfinderTask.h:117
CbmMvdSensor::GetZ
Double_t GetZ() const
Definition: CbmMvdSensor.h:75
CbmMvdSensorHitfinderTask::~CbmMvdSensorHitfinderTask
virtual ~CbmMvdSensorHitfinderTask()
Definition: CbmMvdSensorHitfinderTask.cxx:168
CbmMvdSensorHitfinderTask.h
CbmMvdSensorHitfinderTask::fGausArrayIt
Int_t fGausArrayIt
Definition: CbmMvdSensorHitfinderTask.h:135
CbmMvdSensorHitfinderTask::fHitPosErrZ
Double_t fHitPosErrZ
Definition: CbmMvdSensorHitfinderTask.h:171
xIndex0
Int_t xIndex0
Definition: CbmMvdSensorDigiToHitTask.cxx:69
CbmMvdSensorHitfinderTask::fHitPosZ
Double_t fHitPosZ
Definition: CbmMvdSensorHitfinderTask.h:168
CbmMvdSensorHitfinderTask::fTotalChargeInNpixelsArray
TObjArray * fTotalChargeInNpixelsArray
Definition: CbmMvdSensorHitfinderTask.h:124
CbmMvdSensorHitfinderTask::GetAdcCharge
Int_t GetAdcCharge(Float_t charge)
Definition: CbmMvdSensorHitfinderTask.cxx:492
CbmMvdSensorHitfinderTask::ReInit
InitStatus ReInit()
Definition: CbmMvdSensorHitfinderTask.cxx:219
i
int i
Definition: L1/vectors/P4_F32vec4.h:25
CbmMvdCluster::GetPixelMap
std::map< std::pair< Int_t, Int_t >, Int_t > GetPixelMap()
Definition: CbmMvdCluster.h:47
CbmMvdSensorHitfinderTask::InitTask
void InitTask(CbmMvdSensor *mySensor)
Definition: CbmMvdSensorHitfinderTask.cxx:188
CbmMvdSensorHitfinderTask::fGausArrayLimit
Int_t fGausArrayLimit
Definition: CbmMvdSensorHitfinderTask.h:136
CbmMvdCluster
Definition: CbmMvdCluster.h:27
lab
Double_t lab[3]
Definition: CbmMvdSensorDigiToHitTask.cxx:62
CbmMvdSensor::GetStationNr
Int_t GetStationNr() const
Definition: CbmMvdSensor.h:61
CbmMvdSensorTask::fOutputBuffer
TClonesArray * fOutputBuffer
Definition: CbmMvdSensorTask.h:58
CbmMvdSensor::GetIntegrationtime
Double_t GetIntegrationtime() const
Definition: CbmMvdSensor.h:76
CbmMvdHit
Definition: CbmMvdHit.h:29
CbmHit::SetRefId
void SetRefId(Int_t refId)
Definition: CbmHit.h:81
CbmCluster::GetNofDigis
Int_t GetNofDigis() const
Number of digis in cluster.
Definition: CbmCluster.h:69
CbmMvdSensorTask
Definition: CbmMvdSensorTask.h:26
CbmMvdSensorPlugin::initialized
Bool_t initialized
Definition: CbmMvdSensorPlugin.h:71
CbmMvdPoint.h
CbmMvdSensor
Definition: CbmMvdSensor.h:40
dpos
TVector3 dpos
Definition: CbmMvdSensorDigiToHitTask.cxx:61
CbmMvdCluster::GetRefId
Int_t GetRefId()
Definition: CbmMvdCluster.h:49
h
Data class with information on a STS local track.
yIndex
Int_t yIndex
Definition: CbmMvdSensorDigiToHitTask.cxx:67
CbmMvdSensorHitfinderTask::fAdcStepSize
Float_t fAdcStepSize
Definition: CbmMvdSensorHitfinderTask.h:118
CbmMvdSensorHitfinderTask::fHitPosY
Double_t fHitPosY
Definition: CbmMvdSensorHitfinderTask.h:167
CbmMvdSensorHitfinderTask
Definition: CbmMvdSensorHitfinderTask.h:40
CbmMvdSensorHitfinderTask::fHitPosErrY
Double_t fHitPosErrY
Definition: CbmMvdSensorHitfinderTask.h:170
CbmMvdSensorHitfinderTask::fHitPosX
Double_t fHitPosX
Definition: CbmMvdSensorHitfinderTask.h:166
CbmMvdSensor::PixelToTop
void PixelToTop(Int_t pixelNumberX, Int_t pixelNumberY, Double_t *lab)
Definition: CbmMvdSensor.cxx:624
CbmMvdSensorHitfinderTask::CreateHit
void CreateHit(CbmMvdCluster *clusterArray, TVector3 &pos, TVector3 &dpos)
Definition: CbmMvdSensorHitfinderTask.cxx:256
CbmMvdSensorHitfinderTask::fHitPosErrX
Double_t fHitPosErrX
Definition: CbmMvdSensorHitfinderTask.h:169
CbmMvdSensorHitfinderTask::Exec
void Exec()
Definition: CbmMvdSensorHitfinderTask.cxx:231
ClassImp
ClassImp(CbmMvdSensorHitfinderTask)
xIndex
Int_t xIndex
Definition: CbmMvdSensorDigiToHitTask.cxx:66
CbmMvdSensorHitfinderTask::Reset
void Reset()
Definition: CbmMvdSensorHitfinderTask.cxx:506
CbmMvdSensorHitfinderTask::fGausArray
Float_t * fGausArray
Definition: CbmMvdSensorHitfinderTask.h:134
fCounter
constexpr const Int_t fCounter(0)
CbmHit::SetTimeError
void SetTimeError(Double_t error)
Definition: CbmHit.h:89
CbmHit::SetTime
void SetTime(Double_t time)
Definition: CbmHit.h:84
CbmMvdSensorTask::fInputBuffer
TClonesArray * fInputBuffer
Definition: CbmMvdSensorTask.h:53
CbmMvdSensorHitfinderTask::Finish
void Finish()
Definition: CbmMvdSensorHitfinderTask.cxx:489
numeratorX
Double_t numeratorX
Definition: CbmMvdSensorDigiToHitTask.cxx:63
CbmMCTrack.h
shape
UInt_t shape
Definition: CbmMvdSensorDigiToHitTask.cxx:73
x
Double_t x
Definition: CbmMvdSensorDigiToHitTask.cxx:68
CbmMvdHit.h
CbmMvdSensorHitfinderTask::ExecChain
void ExecChain()
Definition: CbmMvdSensorHitfinderTask.cxx:227
CbmMvdSensorHitfinderTask::fAdcOffset
Int_t fAdcOffset
Definition: CbmMvdSensorHitfinderTask.h:115
y
Double_t y
Definition: CbmMvdSensorDigiToHitTask.cxx:68
CbmMvdSensorHitfinderTask::fPixelChargeHistos
TObjArray * fPixelChargeHistos
Definition: CbmMvdSensorHitfinderTask.h:123
CbmMvdPileupManager.h
pos
TVector3 pos
Definition: CbmMvdSensorDigiToHitTask.cxx:60
CbmMvdSensorHitfinderTask::ComputeCenterOfGravity
void ComputeCenterOfGravity(CbmMvdCluster *clusterArray, TVector3 &pos, TVector3 &dpos)
Definition: CbmMvdSensorHitfinderTask.cxx:298
CbmMvdSensor::GetRecoMatrix
TGeoHMatrix * GetRecoMatrix()
Definition: CbmMvdSensor.h:113
CbmMvdSensorHitfinderTask::inputSet
Bool_t inputSet
Definition: CbmMvdSensorHitfinderTask.h:160
CbmMvdSensorHitfinderTask::fClusters
TClonesArray * fClusters
Definition: CbmMvdSensorHitfinderTask.h:120
yIndex0
Int_t yIndex0
Definition: CbmMvdSensorDigiToHitTask.cxx:70
CbmMvdSensor::TopToPixel
void TopToPixel(Double_t *lab, Int_t &pixelNumberX, Int_t &pixelNumberY)
Definition: CbmMvdSensor.cxx:633
CbmMvdSensorHitfinderTask::fAdcBits
Int_t fAdcBits
Definition: CbmMvdSensorHitfinderTask.h:116
CbmMvdSensorHitfinderTask::fSigmaNoise
Double_t fSigmaNoise
Definition: CbmMvdSensorHitfinderTask.h:155
numeratorY
Double_t numeratorY
Definition: CbmMvdSensorDigiToHitTask.cxx:64
CbmMvdSensor::GetCurrentEventTime
Double_t GetCurrentEventTime() const
Definition: CbmMvdSensor.h:79
denominator
Double_t denominator
Definition: CbmMvdSensorDigiToHitTask.cxx:65
CbmMvdCluster.h