CbmRoot
CbmMvdSensorDigiToHitTask.cxx
Go to the documentation of this file.
1 // -------------------------------------------------------------------------
2 // ----- CbmMvdSensorDigiToHitTask source file -----
3 // ----- 27.11.18 Edited by K. Hunold -----
4 // -------------------------------------------------------------------------
5 
6 
7 #include "CbmMvdSensorDigiToHitTask.h"
8 #include "TClonesArray.h"
9 
10 #include "FairLogger.h"
11 #include "TObjArray.h"
12 #include <cstring>
13 
14 #include "TArrayD.h"
15 #include "TGeoManager.h"
16 #include "TGeoTube.h"
17 #include "TObjArray.h"
18 #include "TRefArray.h"
19 #include <TMatrixD.h>
20 
21 
22 using std::cout;
23 using std::endl;
24 using std::map;
25 using std::pair;
26 using std::vector;
27 
28 //Initialize Variables
29 Int_t dth_fAdcSteps(-1);
30 Int_t dth_fAddress(0);
31 Float_t dth_fAdcStepSize(-1.);
32 std::vector<TH1F*> dth_fPixelChargeHistos;
33 std::vector<TH1F*> dth_fTotalChargeInNpixelsArray;
34 
35 
36 const constexpr Int_t fCounter(0);
37 // const constexpr Float_t fSigmaNoise(15.); //unused
38 const float dth_fSeedThreshold = 1.;
39 const float dth_fNeighThreshold = 1.;
40 
41 // const constexpr Bool_t inputSet(kFALSE); //unused
42 std::map<std::pair<Int_t, Int_t>, Int_t> dth_ftempPixelMap;
43 
44 // const constexpr Bool_t fAddNoise(kFALSE); //unused
45 
46 
47 //2 bigger becuase we are also checking -1 and (range + 1) usually 576, 1152
48 const constexpr int pixelRows = 578;
49 const constexpr int pixelCols = 1154;
50 
51 Float_t dth_grid[pixelCols][pixelRows];
52 std::vector<std::pair<short, short>> dth_clusterArray;
53 std::vector<std::pair<short, short>> dth_coordArray;
54 std::vector<int> dth_refIDArray;
55 
56 //Hitfinder Variables:
57 // const constexpr Int_t fGausArrayLimit = 5000; //unused
58 
59 
60 TVector3 pos;
61 TVector3 dpos;
62 Double_t lab[3];
63 Double_t numeratorX;
64 Double_t numeratorY;
65 Double_t denominator;
66 Int_t xIndex;
67 Int_t yIndex;
68 Double_t x, y;
69 Int_t xIndex0;
70 Int_t yIndex0;
71 int ID = 0;
72 int counter = 0;
73 UInt_t shape = 0;
74 
75 
76 // ----- Default constructor -------------------------------------------
77 CbmMvdSensorDigiToHitTask::CbmMvdSensorDigiToHitTask()
78  : CbmMvdSensorDigiToHitTask(0, 0) {}
79 // -------------------------------------------------------------------------
80 
81 // -------------------------------------------------------------------------
82 CbmMvdSensorDigiToHitTask::~CbmMvdSensorDigiToHitTask() {
83  if (fOutputBuffer) {
84  fOutputBuffer->Delete();
85  delete fOutputBuffer;
86  }
87 }
88 // -------------------------------------------------------------------------
89 
90 // -------------------------------------------------------------------------
91 CbmMvdSensorDigiToHitTask::CbmMvdSensorDigiToHitTask(Int_t /*iMode*/,
92  Int_t iVerbose)
93  : CbmMvdSensorTask()
94  , fAdcDynamic(200)
95  , fAdcOffset(0)
96  , fAdcBits(1)
97  , fDigiMap()
98  , fDigiMapIt()
99  , fVerbose(iVerbose)
100  ,
101 
102  //HitFinder Variables
103  fSigmaNoise(15.)
104  , fHitPosX(0.)
105  , fHitPosY(0.)
106  , fHitPosZ(0.)
107  , fHitPosErrX(0.0005)
108  , fHitPosErrY(0.0005)
109  , fHitPosErrZ(0.0)
110 
111 {}
112 // -------------------------------------------------------------------------
113 
114 // ----- Virtual private method Init ----------------------------------
115 void CbmMvdSensorDigiToHitTask::InitTask(CbmMvdSensor* mysensor) {
116 
117 
118  fInputBuffer = new TClonesArray("CbmMvdDigi", 100);
119  fOutputBuffer = new TClonesArray("CbmMvdHit", 100);
120 
121  dth_fAdcSteps = (Int_t) TMath::Power(2, fAdcBits);
122  dth_fAdcStepSize = fAdcDynamic / dth_fAdcSteps;
123  fSensor = mysensor;
124  dth_fAddress = 1000 * fSensor->GetStationNr() + fSensor->GetSensorNr();
125 
126  std::memset(dth_grid, 0, sizeof(dth_grid));
127 
128  initialized = kTRUE;
129 }
130 // -------------------------------------------------------------------------
131 
132 // ----- Virtual public method Reinit ----------------------------------
133 Bool_t CbmMvdSensorDigiToHitTask::ReInit() {
134  cout << "-I- "
135  << "CbmMvdSensorDigiToHitTask::ReInt---------------" << endl;
136  return kTRUE;
137 }
138 // -------------------------------------------------------------------------
139 
140 // ----- Virtual public method ExecChain --------------
141 void CbmMvdSensorDigiToHitTask::ExecChain() { Exec(); }
142 // -------------------------------------------------------------------------
143 
144 // ----- Public method Exec --------------
145 void CbmMvdSensorDigiToHitTask::Exec() {
146  int nDigis = fInputBuffer->GetEntriesFast();
147  if (nDigis > 0) {
148 
149  fOutputBuffer->Delete();
150  inputSet = kFALSE;
151  short iDigi = 0;
152 
153  CbmMvdDigi* digi = (CbmMvdDigi*) fInputBuffer->At(iDigi);
154 
155  if (!digi) {
156  cout << "-E- : CbmMvdSensorFindHitTask - Fatal: No Digits found in this "
157  "event."
158  << endl;
159  }
160 
161 
162  dth_clusterArray.reserve(nDigis);
163  dth_coordArray.reserve(nDigis);
164  dth_refIDArray.reserve(nDigis);
165 
166  for (Int_t k = 0; k < nDigis; k++) {
167  digi = (CbmMvdDigi*) fInputBuffer->At(k);
168 
169  if (digi->GetRefId() < 0) {
170  LOG(fatal) << "RefID of this digi is -1 this should not happend ";
171  }
172 
173  //apply fNeighThreshold
174  Float_t curr_digi_charge = digi->GetCharge();
175 
176  short dth_current_digi_X = digi->GetPixelX();
177  short dth_current_digi_Y = digi->GetPixelY();
178  dth_coordArray.emplace_back(
179  std::make_pair(dth_current_digi_X, dth_current_digi_Y));
180 
181  if (GetAdcCharge(curr_digi_charge) >= dth_fNeighThreshold) {
182  //puts index into dth_grid.
183  dth_grid[dth_current_digi_X + 1][dth_current_digi_Y + 1] =
184  curr_digi_charge;
185  }
186  }
187 
188 
189  /*___________________________________________________________________________________________________
190  ___________________________________________________________________________________________________*/
191  for (auto& curr_coord : dth_coordArray) {
192 
193  auto& dth_current_digi_X = curr_coord.first;
194  auto& dth_current_digi_Y = curr_coord.second;
195 
196 
197  auto& root_digi_pos_charge =
198  dth_grid[dth_current_digi_X + 1][dth_current_digi_Y + 1];
199 
200  if (GetAdcCharge(root_digi_pos_charge) >= dth_fSeedThreshold) {
201 
202  pos = {0, 0, 0};
203  dpos = {0, 0, 0};
204  numeratorX = 0;
205  numeratorY = 0;
206  denominator = 0;
207  counter = 0;
208  shape = 0;
209 
210  //"-1" has nothing todo with the incremented Grid-Size
211  xIndex0 = dth_current_digi_X - 1;
212  yIndex0 = dth_current_digi_Y - 1;
213 
214  //setting Values for HitfinderCalculation to default.
215  /*___________________________________________________________________________________________________
216  ___________________________________________________________________________________________________*/
217 
218  dth_clusterArray.clear();
219  dth_clusterArray.emplace_back(curr_coord);
220 
221  //Calculating Median für the first Element
222  lab[0] = 0;
223  lab[1] = 0;
224  lab[2] = 0;
225 
226  shape += TMath::Power(2,
227  (4 * (dth_current_digi_Y - 1 - yIndex0 + 3))
228  + (dth_current_digi_X - 1 - xIndex0));
229  //shape &= 1 << ((4*(dth_current_digi_Y - 1 - yIndex0+3))+(dth_current_digi_X - 1 - xIndex0)) ;
230  fSensor->PixelToTop(
231  (dth_current_digi_X - 1), (dth_current_digi_Y - 1), lab);
232 
233  numeratorX += lab[0] * root_digi_pos_charge;
234  numeratorY += lab[1] * root_digi_pos_charge;
235  denominator += root_digi_pos_charge;
236 
237 
238  root_digi_pos_charge = 0;
239  /*___________________________________________________________________________________________________
240  ___________________________________________________________________________________________________*/
241  for (unsigned short i = 0; i < dth_clusterArray.size(); i++) {
242 
243  auto& index = dth_clusterArray[i];
244 
245 
246  auto checkNeighbour = [&](short channelX, short channelY) {
247  auto& curr_digi_pos_charge = dth_grid[channelX + 1][channelY + 1];
248 
249  if (curr_digi_pos_charge != 0) {
250 
251  //Calculatin Median
252  lab[0] = 0;
253  lab[1] = 0;
254  lab[2] = 0;
255 
256  if (counter <= 3) {
257  shape += TMath::Power(2,
258  (4 * (channelY - 1 - yIndex0 + 3))
259  + (channelX - 1 - xIndex0));
260  //shape &= 1 << ((4*(channelY - 1 - yIndex0+3))+(channelX - 1 - xIndex0)) ;
261  }
262 
263  fSensor->PixelToTop((channelX - 1), (channelY - 1), lab);
264 
265  numeratorX += lab[0] * curr_digi_pos_charge;
266  numeratorY += lab[1] * curr_digi_pos_charge;
267  denominator += curr_digi_pos_charge;
268  counter++;
269 
270  //Saving current Digi in ClusterArray
271  dth_clusterArray.emplace_back(std::make_pair(channelX, channelY));
272 
273  //Marking Digi in Grid as used/not relevant anymore
274  curr_digi_pos_charge = 0;
275  }
276  };
277 
278  short channelX = index.first;
279  short channelY = index.second;
280 
281  checkNeighbour(channelX + 1, channelY);
282  checkNeighbour(channelX - 1, channelY);
283  checkNeighbour(channelX, channelY + 1);
284  checkNeighbour(channelX, channelY - 1);
285  }
286 
287 
288  //Compute Center of Gravity
289  //__________________________________________________________________________________________
290 
291  Double_t layerPosZ = fSensor->GetZ();
292  Double_t sigmaIn[3], sigmaOut[3], shiftIn[3], shiftOut[3];
293 
294  //Calculate x,y coordinates of the pixel in the laboratory ref frame
295  if (denominator != 0) {
296  fHitPosX = (numeratorX / denominator);
297  fHitPosY = (numeratorY / denominator);
298  fHitPosZ = layerPosZ;
299  } else {
300  fHitPosX = 0;
301  fHitPosY = 0;
302  fHitPosZ = 0;
303  }
304 
305 
306  if (dth_clusterArray.size() > 4) { shape = 0; }
307 
308 
309  //_________________________________________________________________________________________
310  switch (shape) {
311  case 12288: {
312  sigmaIn[0] = 0.00053;
313  sigmaIn[1] = 0.00063;
314  sigmaIn[2] = 0.;
315  shiftIn[0] = -0.00000;
316  shiftIn[1] = -0.00001;
317  shiftIn[2] = 0.;
318  break;
319  }
320  case 208896: {
321  sigmaIn[0] = 0.00035;
322  sigmaIn[1] = 0.00036;
323  sigmaIn[2] = 0.;
324  shiftIn[0] = -0.00000;
325  shiftIn[1] = -0.00002;
326  shiftIn[2] = 0.;
327  break;
328  }
329  case 69632: {
330  sigmaIn[0] = 0.00028;
331  sigmaIn[1] = 0.00028;
332  sigmaIn[2] = 0.;
333  shiftIn[0] = -0.00000;
334  shiftIn[1] = -0.00002;
335  shiftIn[2] = 0.;
336  break;
337  }
338  case 28672: {
339  sigmaIn[0] = 0.00028;
340  sigmaIn[1] = 0.00039;
341  sigmaIn[2] = 0.;
342  shiftIn[0] = -0.00000;
343  shiftIn[1] = -0.00001;
344  shiftIn[2] = 0.;
345  break;
346  }
347  case 143360: {
348  sigmaIn[0] = 0.00024;
349  sigmaIn[1] = 0.00022;
350  sigmaIn[2] = 0.;
351  shiftIn[0] = +0.00020;
352  shiftIn[1] = +0.00008;
353  shiftIn[2] = 0.;
354  break;
355  }
356  case 200704: {
357  sigmaIn[0] = 0.00024;
358  sigmaIn[1] = 0.00022;
359  sigmaIn[2] = 0.;
360  shiftIn[0] = -0.00020;
361  shiftIn[1] = -0.00011;
362  shiftIn[2] = 0.;
363  break;
364  }
365  case 77824: {
366  sigmaIn[0] = 0.00024;
367  sigmaIn[1] = 0.00022;
368  sigmaIn[2] = 0.;
369  shiftIn[0] = -0.00020;
370  shiftIn[1] = +0.00008;
371  shiftIn[2] = 0.;
372  break;
373  }
374  case 12800: {
375  sigmaIn[0] = 0.00024;
376  sigmaIn[1] = 0.00022;
377  sigmaIn[2] = 0.;
378  shiftIn[0] = +0.00020;
379  shiftIn[1] = -0.00011;
380  shiftIn[2] = 0.;
381  break;
382  }
383  case 4096: {
384  sigmaIn[0] = 0.00027;
385  sigmaIn[1] = 0.00092;
386  sigmaIn[2] = 0.;
387  shiftIn[0] = +0.00002;
388  shiftIn[1] = +0.00004;
389  shiftIn[2] = 0.;
390  break;
391  }
392  default: {
393  sigmaIn[0] = 0.00036;
394  sigmaIn[1] = 0.00044;
395  sigmaIn[2] = 0.;
396  shiftIn[0] = -0.00000;
397  shiftIn[1] = -0.00002;
398  shiftIn[2] = 0.;
399  }
400  }
401  //_________________________________________________________________________________________
402 
403  // Consider Sensor Orientation
404 
405  TGeoHMatrix* RecoMatrix = fSensor->GetRecoMatrix();
406  TGeoHMatrix RotMatrix;
407  RotMatrix.SetRotation(RecoMatrix->GetRotationMatrix());
408 
409  RotMatrix.LocalToMaster(sigmaIn, sigmaOut);
410  RotMatrix.LocalToMaster(shiftIn, shiftOut);
411 
412  fHitPosX += shiftOut[0];
413  fHitPosY += shiftOut[1];
414  fHitPosZ += shiftOut[2];
415 
416  // pos = center of gravity (labframe), dpos uncertaintycout<<setw(10)<<setprecision(2)<< VolumeShape->GetDX();
417  pos.SetXYZ(fHitPosX, fHitPosY, fHitPosZ);
418  dpos.SetXYZ(TMath::Abs(sigmaOut[0]),
419  TMath::Abs(sigmaOut[1]),
420  TMath::Abs(sigmaOut[2]));
421 
422  //Create Hit
423  //__________________________________________________________________________________________
424 
425  Int_t indexX, indexY;
426 
427  Double_t local[2];
428  local[0] = pos.X();
429  local[1] = pos.Y();
430 
431  fSensor->TopToPixel(local, indexX, indexY);
432  Int_t nHits = fOutputBuffer->GetEntriesFast();
433 
434  new ((*fOutputBuffer)[nHits])
435  CbmMvdHit(fSensor->GetStationNr(), pos, dpos, indexX, indexY, ID, 0);
436  CbmMvdHit* currentHit = (CbmMvdHit*) fOutputBuffer->At(nHits);
437  currentHit->SetTime(fSensor->GetCurrentEventTime());
438  currentHit->SetTimeError(fSensor->GetIntegrationtime() / 2);
439  currentHit->SetRefId(ID);
440  ID++;
441  }
442  }
443 
444  // Int_t nHits = fOutputBuffer->GetEntriesFast();
445 
446  dth_clusterArray.clear();
447  fInputBuffer->Delete();
448  dth_coordArray.clear();
449  }
450 }
451 
452 
453 //--------------------------------------------------------------------------
454 
455 
456 // -------------------------------------------------------------------------
457 float CbmMvdSensorDigiToHitTask::GetAdcCharge(Float_t curr_charge) {
458  int adcCharge;
459 
460  if (curr_charge < fAdcOffset) { return 0; };
461 
462  adcCharge = int((curr_charge - fAdcOffset) / dth_fAdcStepSize);
463 
464  if (adcCharge > dth_fAdcSteps - 1) {
465  return dth_fAdcSteps - 1;
466  } else {
467  return adcCharge;
468  }
469 }
470 
471 
472 //--------------------------------------------------------------------------
473 void CbmMvdSensorDigiToHitTask::Finish() {
474  if (fShowDebugHistos) {
475  cout << "\n============================================================"
476  << endl;
477  cout << "-I- " << GetName()
478  << "::Finish: Total events skipped: " << fCounter << endl;
479  cout << "============================================================"
480  << endl;
481  cout << "-I- Parameters used" << endl;
482  cout << "Gaussian noise [electrons] : " << fSigmaNoise << endl;
483  cout << "Noise simulated [Bool] : " << fAddNoise << endl;
484  cout << "Threshold seed [ADC] : " << dth_fSeedThreshold << endl;
485  cout << "Threshold neighbours [ADC] : " << dth_fNeighThreshold << endl;
486  cout << "ADC - Bits : " << fAdcBits << endl;
487  cout << "ADC - Dynamic [electrons] : " << fAdcDynamic << endl;
488  cout << "ADC - Offset [electrons] : " << fAdcOffset << endl;
489  cout << "============================================================"
490  << endl;
491 
492 
493  TH1F* histo;
494  TH2F* clusterShapeHistogram;
495  TCanvas* canvas2 = new TCanvas("HitFinderCharge", "HitFinderCharge");
496  canvas2->Divide(2, 2);
497  canvas2->cd(1);
498  if (fChargeArraySize <= 7) {
499  clusterShapeHistogram = new TH2F("MvdClusterShape",
500  "MvdClusterShape",
501  fChargeArraySize,
502  0,
503  fChargeArraySize,
504  fChargeArraySize,
505  0,
506  fChargeArraySize);
507  for (Int_t i = 0; i < fChargeArraySize * fChargeArraySize; i++) {
508  histo = dth_fPixelChargeHistos[i];
509  Float_t curr_charge = histo->GetMean();
510  //cout <<i << " Charge " << charge << " xCluster: " << i%fChargeArraySize << " yCluster: " << i/fChargeArraySize << endl;
511  //histo->Fit("landau");
512  //TF1* fitFunction= histo->GetFunction("landau");
513  //Double_t MPV=fitFunction->GetParameter(1);
514  clusterShapeHistogram->Fill(
515  i % fChargeArraySize, i / fChargeArraySize, curr_charge);
516  }
517  }
518  clusterShapeHistogram->Draw("Lego2");
519  canvas2->cd(2);
520  histo = dth_fPixelChargeHistos[50];
521  histo->Draw();
522  canvas2->cd(3);
523  histo = dth_fPixelChargeHistos[51];
524  histo->Draw();
525  canvas2->cd(4);
526  //fFullClusterHisto->Draw();
527  }
528 }
529 //--------------------------------------------------------------------------
530 ClassImp(CbmMvdSensorDigiToHitTask)
CbmMvdDigi::GetPixelY
Int_t GetPixelY()
Definition: CbmMvdDigi.cxx:143
CbmMvdSensorDigiToHitTask::fAdcDynamic
Int_t fAdcDynamic
Definition: CbmMvdSensorDigiToHitTask.h:98
CbmMvdDigi::GetCharge
Double_t GetCharge() const
Definition: CbmMvdDigi.h:49
CbmMvdSensorTask::fSensor
CbmMvdSensor * fSensor
Definition: CbmMvdSensorTask.h:59
CbmMvdSensor::GetZ
Double_t GetZ() const
Definition: CbmMvdSensor.h:75
CbmMvdSensorDigiToHitTask::fAddNoise
Bool_t fAddNoise
Definition: CbmMvdSensorDigiToHitTask.h:129
CbmMvdSensorDigiToHitTask::fSigmaNoise
Double_t fSigmaNoise
Definition: CbmMvdSensorDigiToHitTask.h:109
CbmMvdSensorDigiToHitTask::~CbmMvdSensorDigiToHitTask
virtual ~CbmMvdSensorDigiToHitTask()
Definition: CbmMvdSensorDigiToHitTask.cxx:82
CbmMvdSensorDigiToHitTask::fHitPosX
Double_t fHitPosX
Definition: CbmMvdSensorDigiToHitTask.h:118
CbmMvdSensorDigiToHitTask::CbmMvdSensorDigiToHitTask
CbmMvdSensorDigiToHitTask()
Definition: CbmMvdSensorDigiToHitTask.cxx:77
xIndex0
Int_t xIndex0
Definition: CbmMvdSensorDigiToHitTask.cxx:69
memset
void memset(T *dest, T i, size_t num)
Definition: L1Grid.cxx:21
CbmMvdSensorDigiToHitTask::Finish
void Finish()
Definition: CbmMvdSensorDigiToHitTask.cxx:473
i
int i
Definition: L1/vectors/P4_F32vec4.h:25
CbmMvdSensorDigiToHitTask::fAdcOffset
Int_t fAdcOffset
Definition: CbmMvdSensorDigiToHitTask.h:99
CbmMvdSensorPlugin::fShowDebugHistos
Bool_t fShowDebugHistos
Definition: CbmMvdSensorPlugin.h:72
dth_fAddress
Int_t dth_fAddress(0)
dth_ftempPixelMap
std::map< std::pair< Int_t, Int_t >, Int_t > dth_ftempPixelMap
Definition: CbmMvdSensorDigiToHitTask.cxx:42
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
CbmMvdSensorDigiToHitTask::inputSet
Bool_t inputSet
Definition: CbmMvdSensorDigiToHitTask.h:113
CbmMvdSensor::GetIntegrationtime
Double_t GetIntegrationtime() const
Definition: CbmMvdSensor.h:76
CbmMvdSensorDigiToHitTask::ExecChain
void ExecChain()
Definition: CbmMvdSensorDigiToHitTask.cxx:141
dth_fNeighThreshold
const float dth_fNeighThreshold
Definition: CbmMvdSensorDigiToHitTask.cxx:39
CbmMvdHit
Definition: CbmMvdHit.h:29
CbmHit::SetRefId
void SetRefId(Int_t refId)
Definition: CbmHit.h:81
CbmMvdSensorTask
Definition: CbmMvdSensorTask.h:26
dth_grid
Float_t dth_grid[pixelCols][pixelRows]
Definition: CbmMvdSensorDigiToHitTask.cxx:51
pixelCols
constexpr const int pixelCols
Definition: CbmMvdSensorDigiToHitTask.cxx:49
CbmMvdSensorPlugin::initialized
Bool_t initialized
Definition: CbmMvdSensorPlugin.h:71
CbmMvdSensorDigiToHitTask::GetAdcCharge
float GetAdcCharge(Float_t charge)
Definition: CbmMvdSensorDigiToHitTask.cxx:457
CbmMvdSensor
Definition: CbmMvdSensor.h:40
dpos
TVector3 dpos
Definition: CbmMvdSensorDigiToHitTask.cxx:61
yIndex
Int_t yIndex
Definition: CbmMvdSensorDigiToHitTask.cxx:67
pixelRows
constexpr const int pixelRows
Definition: CbmMvdSensorDigiToHitTask.cxx:48
dth_fTotalChargeInNpixelsArray
std::vector< TH1F * > dth_fTotalChargeInNpixelsArray
Definition: CbmMvdSensorDigiToHitTask.cxx:33
CbmMvdSensorDigiToHitTask::InitTask
void InitTask(CbmMvdSensor *mySensor)
Definition: CbmMvdSensorDigiToHitTask.cxx:115
CbmMvdSensorPlugin::GetName
virtual const char * GetName() const
Definition: CbmMvdSensorPlugin.h:62
CbmMvdDigi::GetRefId
Int_t GetRefId() const
Definition: CbmMvdDigi.h:63
dth_refIDArray
std::vector< int > dth_refIDArray
Definition: CbmMvdSensorDigiToHitTask.cxx:54
ClassImp
ClassImp(CbmConverterManager) InitStatus CbmConverterManager
Definition: CbmConverterManager.cxx:12
CbmMvdSensorDigiToHitTask::fHitPosZ
Double_t fHitPosZ
Definition: CbmMvdSensorDigiToHitTask.h:120
CbmMvdSensor::PixelToTop
void PixelToTop(Int_t pixelNumberX, Int_t pixelNumberY, Double_t *lab)
Definition: CbmMvdSensor.cxx:624
dth_fPixelChargeHistos
std::vector< TH1F * > dth_fPixelChargeHistos
Definition: CbmMvdSensorDigiToHitTask.cxx:32
xIndex
Int_t xIndex
Definition: CbmMvdSensorDigiToHitTask.cxx:66
CbmMvdSensorDigiToHitTask
Definition: CbmMvdSensorDigiToHitTask.h:40
CbmMvdSensorDigiToHitTask::fAdcBits
Int_t fAdcBits
Definition: CbmMvdSensorDigiToHitTask.h:100
fCounter
constexpr const Int_t fCounter(0)
CbmHit::SetTimeError
void SetTimeError(Double_t error)
Definition: CbmHit.h:89
dth_fAdcSteps
Int_t dth_fAdcSteps(-1)
CbmMvdSensorDigiToHitTask::fHitPosY
Double_t fHitPosY
Definition: CbmMvdSensorDigiToHitTask.h:119
CbmHit::SetTime
void SetTime(Double_t time)
Definition: CbmHit.h:84
CbmMvdSensorTask::fInputBuffer
TClonesArray * fInputBuffer
Definition: CbmMvdSensorTask.h:53
counter
int counter
Definition: CbmMvdSensorDigiToHitTask.cxx:72
numeratorX
Double_t numeratorX
Definition: CbmMvdSensorDigiToHitTask.cxx:63
shape
UInt_t shape
Definition: CbmMvdSensorDigiToHitTask.cxx:73
x
Double_t x
Definition: CbmMvdSensorDigiToHitTask.cxx:68
y
Double_t y
Definition: CbmMvdSensorDigiToHitTask.cxx:68
CbmMvdDigi
Definition: CbmMvdDigi.h:21
pos
TVector3 pos
Definition: CbmMvdSensorDigiToHitTask.cxx:60
dth_coordArray
std::vector< std::pair< short, short > > dth_coordArray
Definition: CbmMvdSensorDigiToHitTask.cxx:53
CbmMvdDigi::GetPixelX
Int_t GetPixelX()
Definition: CbmMvdDigi.cxx:141
ID
int ID
Definition: CbmMvdSensorDigiToHitTask.cxx:71
CbmMvdSensorDigiToHitTask::Exec
void Exec()
Definition: CbmMvdSensorDigiToHitTask.cxx:145
CbmMvdSensor::GetSensorNr
Int_t GetSensorNr() const
Definition: CbmMvdSensor.h:64
CbmMvdSensor::GetRecoMatrix
TGeoHMatrix * GetRecoMatrix()
Definition: CbmMvdSensor.h:113
dth_fSeedThreshold
const float dth_fSeedThreshold
Definition: CbmMvdSensorDigiToHitTask.cxx:38
yIndex0
Int_t yIndex0
Definition: CbmMvdSensorDigiToHitTask.cxx:70
dth_fAdcStepSize
Float_t dth_fAdcStepSize(-1.)
CbmMvdSensor::TopToPixel
void TopToPixel(Double_t *lab, Int_t &pixelNumberX, Int_t &pixelNumberY)
Definition: CbmMvdSensor.cxx:633
CbmMvdSensorDigiToHitTask::fChargeArraySize
static const Short_t fChargeArraySize
Definition: CbmMvdSensorDigiToHitTask.h:126
CbmMvdSensorDigiToHitTask::ReInit
Bool_t ReInit()
Definition: CbmMvdSensorDigiToHitTask.cxx:133
dth_clusterArray
std::vector< std::pair< short, short > > dth_clusterArray
Definition: CbmMvdSensorDigiToHitTask.cxx:52
numeratorY
Double_t numeratorY
Definition: CbmMvdSensorDigiToHitTask.cxx:64
CbmMvdSensor::GetCurrentEventTime
Double_t GetCurrentEventTime() const
Definition: CbmMvdSensor.h:79
CbmMvdSensorDigiToHitTask.h
denominator
Double_t denominator
Definition: CbmMvdSensorDigiToHitTask.cxx:65