CbmRoot
LxTBTask.cxx
Go to the documentation of this file.
1 /*
2  * To change this license header, choose License Headers in Project Properties.
3  * To change this template file, choose Tools | Templates
4  * and open the template in the editor.
5  */
6 
7 #include "LxTBTask.h"
8 #include "CbmCluster.h"
9 #include "CbmMCDataManager.h"
10 #include "CbmMCTrack.h"
11 #include "CbmMatch.h"
12 #include "CbmMuchGeoScheme.h"
13 #include "CbmMuchPixelHit.h"
14 #include "CbmTrdHit.h"
15 #include "FairLogger.h"
16 #include "LxTBTieTracks.h"
17 #include "TClonesArray.h"
18 #include "TDatabasePDG.h"
19 #include "TGeoArb8.h"
20 #include "TGeoBoolNode.h"
21 #include "TGeoCompositeShape.h"
22 #include "TMath.h"
23 #include "TParticlePDG.h"
24 #include "TRandom3.h"
25 #include <map>
26 #include <set>
27 
28 #ifdef LXTB_QA
29 #include "CbmStsHit.h"
30 #include "TH1F.h"
31 #include "TH2F.h"
32 #endif //LXTB_QA
33 
34 #include <TFile.h>
35 
36 using std::cout;
37 using std::endl;
38 using std::ifstream;
39 using std::ios_base;
40 using std::list;
41 using std::map;
42 using std::ofstream;
43 using std::pair;
44 using std::set;
45 using std::vector;
46 
47 ClassImp(LxTBFinder)
48 
49  Double_t speedOfLight = 0;
50 
51 LxTbBinnedFinder::SignalParticle LxTbBinnedFinder::particleDescs[] = {
52  {"jpsi", 443, 3.0, true},
53  {"omega", 223, 1.5, true},
54  {"", -1, 0, false}};
55 
56 LxTBFinder::LxTBFinder()
57  : fMuchPoints()
58  , fMuchMCPoints(nullptr)
59  , fMuchPixelHits(nullptr)
60  , fMuchClusters(nullptr)
61  , fMuchPixelDigiMatches(nullptr)
62  , fTrdPoints()
63  , fTrdMCPoints(nullptr)
64  , fTrdHits(nullptr)
65  , fTrdClusters(nullptr)
66  , fTrdDigiMatches(nullptr)
67  ,
68 #ifdef LXTB_QA
69  fMvdDigis(nullptr)
70  , fStsDigis(nullptr)
71  , fTofDigis(nullptr)
72  , fMCTracks()
73  ,
74 #endif //LXTB_QA
75  isEvByEv(false)
76  , fFinder(nullptr)
77  , recoTracks()
78  , hasTrd(false)
79  , useTrd(true)
80  , useIdeal(false)
81  , useAsciiSig(false)
82  , fSignalParticle("jpsi")
83  ,
84 #ifdef LXTB_EMU_TS
85  nof_timebins(1000)
86  ,
87 #else //LXTB_EMU_TS
88  nof_timebins(isEvByEv ? 5 : 1000)
89  ,
90 #endif //LXTB_EMU_TS
91  last_timebin(nof_timebins - 1)
92  , fNEvents(1000)
93  , fEventTimes()
94  ,
95 #ifdef LXTB_TIE
96  fStsHits(nullptr)
97  , fStsTracks(nullptr)
98  , fStsClusters(nullptr)
99  , fStsDigiMatches(nullptr)
100  , fDetector(nullptr)
101  ,
102 #endif //LXTB_TIE
103  dummy(0) {
104 }
105 
106 static bool HasTrd() {
107  gGeoManager->cd("/cave_1");
108  TObjArray* children = gGeoManager->GetCurrentNode()->GetNodes();
109 
110  if (0 != children) {
111  TObject* child = children->First();
112 
113  while (child) {
114  TString name(static_cast<TGeoNode*>(child)->GetName());
115 
116  if (name.Contains("trd", TString::kIgnoreCase)) return true;
117 
118  child = children->After(child);
119  }
120  }
121 
122  return false;
123 }
124 
125 static void
126 FindGeoChild(TGeoNode* node, const char* name, list<TGeoNode*>& results) {
127  Int_t nofChildren = node->GetNdaughters();
128 
129  for (Int_t i = 0; i < nofChildren; ++i) {
130  TGeoNode* child = node->GetDaughter(i);
131  TString childName(child->GetName());
132 
133  if (childName.Contains(name, TString::kIgnoreCase))
134  results.push_back(child);
135  }
136 }
137 
138 void LxTBFinder::HandleGeometry() {
139  Double_t localCoords[3] = {0., 0., 0.};
140  Double_t globalCoords[3];
141  TGeoNavigator* pNavigator = gGeoManager->GetCurrentNavigator();
142  gGeoManager->cd("/cave_1");
143  list<TGeoNode*> detectors;
144  FindGeoChild(gGeoManager->GetCurrentNode(), "much", detectors);
145 
146  for (list<TGeoNode*>::iterator i = detectors.begin(); i != detectors.end();
147  ++i) {
148  TGeoNode* detector = *i;
149  pNavigator->CdDown(detector);
150  list<TGeoNode*> stations;
151  FindGeoChild(detector, "station", stations);
152  int stationNumber = 0;
153 
154  for (list<TGeoNode*>::iterator j = stations.begin(); j != stations.end();
155  ++j) {
156  TGeoNode* station = *j;
157  pNavigator->CdDown(station);
158  list<TGeoNode*> layers;
159  FindGeoChild(station, "layer", layers);
160  int layerNumber = 0;
161 
162  for (list<TGeoNode*>::iterator k = layers.begin(); k != layers.end();
163  ++k) {
164  TGeoNode* layer = *k;
165  pNavigator->CdDown(layer);
166  gGeoManager->LocalToMaster(localCoords, globalCoords);
167 
168  if (1 == layerNumber) {
169  fFinder->stations[stationNumber].stationNumber = stationNumber;
170  fFinder->stations[stationNumber].z = globalCoords[2];
171  fFinder->stations[stationNumber].minX = 0;
172  fFinder->stations[stationNumber].maxX = 0;
173  fFinder->stations[stationNumber].binSizeX = 0;
174  fFinder->stations[stationNumber].minY = 0;
175  fFinder->stations[stationNumber].maxY = 0;
176  fFinder->stations[stationNumber].binSizeY = 0;
177  }
178 
179 #ifdef LXTB_TIE
180  fDetector->fLayers[stationNumber * 3 + layerNumber].z = globalCoords[2];
181  fDetector->fLayers[stationNumber * 3 + layerNumber].minX = 0;
182  fDetector->fLayers[stationNumber * 3 + layerNumber].maxX = 0;
183  fDetector->fLayers[stationNumber * 3 + layerNumber].binSizeX = 0;
184  fDetector->fLayers[stationNumber * 3 + layerNumber].minY = 0;
185  fDetector->fLayers[stationNumber * 3 + layerNumber].maxY = 0;
186  fDetector->fLayers[stationNumber * 3 + layerNumber].binSizeY = 0;
187 #endif //LXTB_TIE
188 
189  list<TGeoNode*> actives;
190  FindGeoChild(layer, "active", actives);
191 
192  for (list<TGeoNode*>::iterator l = actives.begin(); l != actives.end();
193  ++l) {
194  TGeoNode* active = *l;
195  pNavigator->CdDown(active);
196  TGeoCompositeShape* cs =
197  dynamic_cast<TGeoCompositeShape*>(active->GetVolume()->GetShape());
198  TGeoBoolNode* bn = cs->GetBoolNode();
199  TGeoTrap* trap = dynamic_cast<TGeoTrap*>(bn->GetLeftShape());
200 
201  if (0 != trap) {
202  Double_t* xy = trap->GetVertices();
203 
204  for (int m = 0; m < 4; ++m) {
205  Double_t localActiveCoords[3] = {xy[2 * m], xy[2 * m + 1], 0.};
206  Double_t globalActiveCoords[3];
207  gGeoManager->LocalToMaster(localActiveCoords, globalActiveCoords);
208 
209 #ifdef LXTB_TIE
210  if (fDetector->fLayers[stationNumber * 3 + layerNumber].minY
211  > globalActiveCoords[1])
212  fDetector->fLayers[stationNumber * 3 + layerNumber].minY =
213  globalActiveCoords[1];
214 
215  if (fDetector->fLayers[stationNumber * 3 + layerNumber].maxY
216  < globalActiveCoords[1])
217  fDetector->fLayers[stationNumber * 3 + layerNumber].maxY =
218  globalActiveCoords[1];
219 
220  if (fDetector->fLayers[stationNumber * 3 + layerNumber].minX
221  > globalActiveCoords[0])
222  fDetector->fLayers[stationNumber * 3 + layerNumber].minX =
223  globalActiveCoords[0];
224 
225  if (fDetector->fLayers[stationNumber * 3 + layerNumber].maxX
226  < globalActiveCoords[0])
227  fDetector->fLayers[stationNumber * 3 + layerNumber].maxX =
228  globalActiveCoords[0];
229 #endif //LXTB_TIE
230 
231  if (1 == layerNumber) {
232  if (fFinder->stations[stationNumber].minY
233  > globalActiveCoords[1])
234  fFinder->stations[stationNumber].minY = globalActiveCoords[1];
235 
236  if (fFinder->stations[stationNumber].maxY
237  < globalActiveCoords[1])
238  fFinder->stations[stationNumber].maxY = globalActiveCoords[1];
239 
240  if (fFinder->stations[stationNumber].minX
241  > globalActiveCoords[0])
242  fFinder->stations[stationNumber].minX = globalActiveCoords[0];
243 
244  if (fFinder->stations[stationNumber].maxX
245  < globalActiveCoords[0])
246  fFinder->stations[stationNumber].maxX = globalActiveCoords[0];
247  }
248  }
249  }
250 
251  pNavigator->CdUp();
252  }
253 
254  pNavigator->CdUp();
255  ++layerNumber;
256  }
257 
258  ++stationNumber;
259  pNavigator->CdUp();
260  }
261 
262  int nofStations = stationNumber;
263 
264  list<TGeoNode*> absorbers;
265  FindGeoChild(detector, "absorber", absorbers);
266  int absorberNumber = 0;
267 
268  for (list<TGeoNode*>::iterator j = absorbers.begin(); j != absorbers.end();
269  ++j) {
270  TGeoNode* absorber = *j;
271  pNavigator->CdDown(absorber);
272  TGeoVolume* absVol = gGeoManager->GetCurrentVolume();
273  const TGeoBBox* absShape =
274  static_cast<const TGeoBBox*>(absVol->GetShape());
275 
276  if (absorberNumber < nofStations) {
277  gGeoManager->LocalToMaster(localCoords, globalCoords);
278  fFinder->stations[absorberNumber].absorber.zCoord =
279  globalCoords[2] - absShape->GetDZ();
280  fFinder->stations[absorberNumber].absorber.width =
281  2 * absShape->GetDZ();
282  fFinder->stations[absorberNumber].absorber.radLength =
283  absVol->GetMaterial()->GetRadLen();
284  fFinder->stations[absorberNumber].absorber.rho =
285  absVol->GetMaterial()->GetDensity();
286  fFinder->stations[absorberNumber].absorber.Z =
287  absVol->GetMaterial()->GetZ();
288  fFinder->stations[absorberNumber].absorber.A =
289  absVol->GetMaterial()->GetA();
290  } else {
291  fFinder->trdStation.absorber.width = 2 * absShape->GetDZ();
292  fFinder->trdStation.absorber.radLength =
293  absVol->GetMaterial()->GetRadLen();
294  fFinder->trdStation.absorber.rho = absVol->GetMaterial()->GetDensity();
295  fFinder->trdStation.absorber.Z = absVol->GetMaterial()->GetZ();
296  fFinder->trdStation.absorber.A = absVol->GetMaterial()->GetA();
297  }
298 
299  ++absorberNumber;
300  pNavigator->CdUp();
301  }
302 
303  pNavigator->CdUp();
304  }
305 
306  fFinder->trdStation.minX = 0;
307  fFinder->trdStation.maxX = 0;
308  fFinder->trdStation.binSizeX = 0;
309  fFinder->trdStation.minY = 0;
310  fFinder->trdStation.maxY = 0;
311  fFinder->trdStation.binSizeY = 0;
312  detectors.clear();
313  FindGeoChild(gGeoManager->GetCurrentNode(), "trd", detectors);
314 
315  for (list<TGeoNode*>::iterator i = detectors.begin(); i != detectors.end();
316  ++i) {
317  TGeoNode* detector = *i;
318  pNavigator->CdDown(detector);
319  list<TGeoNode*> layers;
320  FindGeoChild(detector, "layer", layers);
321  int layerNumber = 0;
322 
323  for (list<TGeoNode*>::iterator j = layers.begin(); j != layers.end(); ++j) {
324  TGeoNode* layer = *j;
325  pNavigator->CdDown(layer);
326  list<TGeoNode*> modules;
327  FindGeoChild(layer, "module", modules);
328 
329  for (list<TGeoNode*>::iterator k = modules.begin(); k != modules.end();
330  ++k) {
331  TGeoNode* module = *k;
332  pNavigator->CdDown(module);
333  list<TGeoNode*> padCoppers;
334  FindGeoChild(module, "padcopper", padCoppers);
335 
336  for (list<TGeoNode*>::iterator l = padCoppers.begin();
337  l != padCoppers.end();
338  ++l) {
339  TGeoNode* padCopper = *l;
340  pNavigator->CdDown(padCopper);
341  TGeoBBox* pBox =
342  static_cast<TGeoBBox*>(padCopper->GetVolume()->GetShape());
343  pBox->ComputeBBox();
344  gGeoManager->LocalToMaster(localCoords, globalCoords);
345  fFinder->trdStation.Zs[layerNumber] = globalCoords[2];
346 
347 #ifdef LXTB_TIE
348  fDetector->fLayers[CUR_NOF_STATIONS * 3 + layerNumber].z =
349  globalCoords[2];
350 #endif //LXTB_TIE
351 
352  if (fFinder->trdStation.minY > globalCoords[1] - pBox->GetDY())
353  fFinder->trdStation.minY = globalCoords[1] - pBox->GetDY();
354 
355  if (fFinder->trdStation.maxY < globalCoords[1] + pBox->GetDY())
356  fFinder->trdStation.maxY = globalCoords[1] + pBox->GetDY();
357 
358  if (fFinder->trdStation.minX > globalCoords[0] - pBox->GetDX())
359  fFinder->trdStation.minX = globalCoords[0] - pBox->GetDX();
360 
361  if (fFinder->trdStation.maxX < globalCoords[0] + pBox->GetDX())
362  fFinder->trdStation.maxX = globalCoords[0] + pBox->GetDX();
363 
364  pNavigator->CdUp();
365  }
366 
367  pNavigator->CdUp();
368  }
369 
370  ++layerNumber;
371  pNavigator->CdUp();
372  }
373 
374  pNavigator->CdUp();
375  }
376 
377 #ifdef LXTB_TIE
378  for (int i = 0; i < CUR_NOF_TRD_LAYERS; ++i) {
379  fDetector->fLayers[CUR_NOF_STATIONS * 3 + i].minX =
380  fFinder->trdStation.minX;
381  fDetector->fLayers[CUR_NOF_STATIONS * 3 + i].maxX =
382  fFinder->trdStation.maxX;
383  fDetector->fLayers[CUR_NOF_STATIONS * 3 + i].binSizeX = 0;
384  fDetector->fLayers[CUR_NOF_STATIONS * 3 + i].minY =
385  fFinder->trdStation.minY;
386  fDetector->fLayers[CUR_NOF_STATIONS * 3 + i].maxY =
387  fFinder->trdStation.maxY;
388  fDetector->fLayers[CUR_NOF_STATIONS * 3 + i].binSizeY = 0;
389  }
390 #endif //LXTB_TIE
391 }
392 
393 #ifdef LXTB_QA
394 static list<timetype> shortSignalMCTimes;
395 static list<timetype> longSignalMCTimes;
396 static list<timetype> middleSignalMCTimes;
397 static list<pair<timetype, timetype>> triggerTimes_trd0_sign0_dist0;
398 static list<pair<timetype, timetype>> triggerTimes_trd0_sign0_dist1;
399 static list<pair<timetype, timetype>> triggerTimes_trd0_sign1_dist0;
400 static list<pair<timetype, timetype>> triggerTimes_trd0_sign1_dist1;
401 static list<pair<timetype, timetype>> triggerTimes_trd1_sign0_dist0;
402 static list<pair<timetype, timetype>> triggerTimes_trd1_sign0_dist1;
403 static list<pair<timetype, timetype>> triggerTimes_trd1_sign1_dist0;
404 static list<pair<timetype, timetype>> triggerTimes_trd1_sign1_dist1;
405 static list<pair<timetype, timetype>> triggerTimes_trd05_sign0_dist0;
406 static list<pair<timetype, timetype>> triggerTimes_trd05_sign0_dist1;
407 static list<pair<timetype, timetype>> triggerTimes_trd05_sign1_dist0;
408 static list<pair<timetype, timetype>> triggerTimes_trd05_sign1_dist1;
409 #endif //LXTB_QA
410 
411 InitStatus LxTBFinder::Init() {
412  FairRootManager* ioman = FairRootManager::Instance();
413 
414  if (0 == ioman) LOG(fatal) << "No FairRootManager";
415 
416  Int_t nofEventsInFile = ioman->CheckMaxEventNo();
417 
418  if (nofEventsInFile < fNEvents) fNEvents = nofEventsInFile;
419 
420  speedOfLight =
421  100 * TMath::C(); // Multiply by 100 to express in centimeters.
422  gMuonMass = TDatabasePDG::Instance()->GetParticle(13)->Mass();
423  gElectronMass = TDatabasePDG::Instance()->GetParticle(11)->Mass();
424 
425  time_t initTime;
426  gRandom->SetSeed(time(&initTime));
427 
428  //TObjArray* absorbers = CbmMuchGeoScheme::Instance()->GetAbsorbers(); (VF) unused
429 
430  hasTrd = useTrd ? HasTrd() : false;
431  pair<int, int> stSpatLimits[] = {
432  {20, 20}, {20, 20}, {20, 20}, {20, 20}, {20, 20}, {20, 20}};
433  fFinder = new LxTbBinnedFinder(hasTrd ? CUR_NOF_TRD_LAYERS : 0,
434  CUR_NOF_STATIONS,
435  nof_timebins,
436  stSpatLimits,
437  20,
438  20,
439  CUR_TIMEBIN_LENGTH);
440  fFinder->SetSignalParticle(fSignalParticle);
441  hasTrd = fFinder->fSignalParticle->fHasTrd;
442 
443 #ifdef LXTB_TIE
444  int nofLayers = CUR_NOF_STATIONS * 3;
445 
446  if (hasTrd) nofLayers += CUR_NOF_TRD_LAYERS;
447 
448  fDetector =
449  new LxTBBinnedDetector(nofLayers, 20, 20, nof_timebins, CUR_TIMEBIN_LENGTH);
450 
451  fStsHits = static_cast<TClonesArray*>(ioman->GetObject("StsHit"));
452  fStsTracks = static_cast<TClonesArray*>(ioman->GetObject("StsTrack"));
453  fStsClusters = static_cast<TClonesArray*>(ioman->GetObject("StsCluster"));
454  fStsDigiMatches =
455  static_cast<TClonesArray*>(ioman->GetObject("StsDigiMatch"));
456 
457  fDetector->fMuchTracks = new TClonesArray("CbmMuchTrack", 100);
458  ioman->Register("MuchTrack",
459  "Much",
460  fDetector->fMuchTracks,
461  IsOutputBranchPersistent("MuchTrack"));
462  fDetector->fGlobalTracks = new TClonesArray("CbmGlobalTrack", 100);
463  ioman->Register("GlobalTrack",
464  "Global",
465  fDetector->fGlobalTracks,
466  IsOutputBranchPersistent("GlobalTrack"));
467 #endif //LXTB_TIE
468 
469  HandleGeometry();
470  fFinder->Init();
471 
472 #ifdef LXTB_TIE
473  fDetector->Init();
474 #endif //LXTB_TIE
475 
476  fMuchPixelHits = static_cast<TClonesArray*>(ioman->GetObject("MuchPixelHit"));
477  fTrdHits = static_cast<TClonesArray*>(ioman->GetObject("TrdHit"));
478 
479 #ifdef LXTB_QA
480  CbmMCDataManager* mcManager =
481  static_cast<CbmMCDataManager*>(ioman->GetObject("MCDataManager"));
482  fMuchMCPoints = mcManager->InitBranch("MuchPoint");
483  fMuchClusters = static_cast<TClonesArray*>(ioman->GetObject("MuchCluster"));
484  fMuchPixelDigiMatches =
485  static_cast<TClonesArray*>(ioman->GetObject("MuchDigiMatch"));
486  fTrdMCPoints = mcManager->InitBranch("TrdPoint");
487  fTrdClusters = static_cast<TClonesArray*>(ioman->GetObject("TrdCluster"));
488  fTrdDigiMatches =
489  static_cast<TClonesArray*>(ioman->GetObject("TrdDigiMatch"));
490  fMvdDigis = static_cast<TClonesArray*>(ioman->GetObject("MvdDigi"));
491  fStsDigis = static_cast<TClonesArray*>(ioman->GetObject("StsDigi"));
492  fTofDigis = static_cast<TClonesArray*>(ioman->GetObject("TofDigi"));
493  CbmMCDataArray* mcTracks = mcManager->InitBranch("MCTrack");
494 
495  TH1F* jpsiPHisto = new TH1F("jpsiPHisto", "jpsiPHisto", 90, 0., 30.);
496  TH1F* jpsiMHisto = new TH1F("jpsiMHisto", "jpsiMHisto", 200, 3., 3.2);
497  TH1F* jpsiEHisto = new TH1F("jpsiEHisto", "jpsiEHisto", 90, 0., 30.);
498  TH1F* signalMHisto = new TH1F("signalMHisto", "signalMHisto", 600, 0., 6.0);
499 
500  for (int i = 0; i < fNEvents; ++i) {
501  Int_t evSize = mcTracks->Size(0, i);
502  fMCTracks.push_back(vector<TrackDataHolder>());
503 
504  if (0 >= evSize) continue;
505 
506  vector<TrackDataHolder>& evTracks = fMCTracks.back();
507  const CbmMCTrack* posTrack = 0;
508  const CbmMCTrack* negTrack = 0;
509 
510  for (int j = 0; j < evSize; ++j) {
511  evTracks.push_back(TrackDataHolder());
512  const CbmMCTrack* mcTrack =
513  static_cast<const CbmMCTrack*>(mcTracks->Get(0, i, j));
514 
515  if (mcTrack->GetPdgCode() == 443) {
516  Double_t p = mcTrack->GetP();
517  jpsiPHisto->Fill(p);
518  Double_t m = mcTrack->GetMass();
519  jpsiMHisto->Fill(m);
520  Double_t e = mcTrack->GetEnergy();
521  jpsiEHisto->Fill(e);
522  }
523 
524  if (mcTrack->GetPdgCode() == 13 || mcTrack->GetPdgCode() == -13) {
525  //Double_t m = mcTrack->GetMass();
526  Int_t motherId = mcTrack->GetMotherId();
527 
528  if ((useAsciiSig && motherId < 0)
529  || (motherId >= 0
530  && static_cast<const CbmMCTrack*>(mcTracks->Get(0, i, motherId))
531  ->GetPdgCode()
532  == fFinder->fSignalParticle->fPdgCode)) {
533  //const CbmMCTrack* motherTrack = static_cast<const CbmMCTrack*> (mcTracks->Get(0, i, motherId));
534 
535  //if (fFinder->fSignalParticle->fPdgCode == motherTrack->GetPdgCode())
536  {
537  evTracks.back().isSignalShort = true;
538  evTracks.back().isSignalLong = true;
539  evTracks.back().isPos = mcTrack->GetPdgCode() == -13;
540 
541  if (-13 == mcTrack->GetPdgCode())
542  posTrack = mcTrack;
543  else
544  negTrack = mcTrack;
545  }
546  }
547  }
548  } // for (int j = 0; j < evSize; ++j)
549 
550  if (0 != posTrack && 0 != negTrack) {
551  Double_t E12 = posTrack->GetEnergy() + negTrack->GetEnergy();
552  Double_t E12Sq = E12 * E12;
553  Double_t P12Sq = (posTrack->GetPx() + negTrack->GetPx())
554  * (posTrack->GetPx() + negTrack->GetPx())
555  + (posTrack->GetPy() + negTrack->GetPy())
556  * (posTrack->GetPy() + negTrack->GetPy())
557  + (posTrack->GetPz() + negTrack->GetPz())
558  * (posTrack->GetPz() + negTrack->GetPz());
559  Double_t m = sqrt(E12Sq - P12Sq);
560  signalMHisto->Fill(m);
561  }
562  } // for (int i = 0; i < fNEvents; ++i)
563 
564  {
565  TFile* curFile = TFile::CurrentFile();
566  TString histoName = "jpsiMHisto.root";
567 
568  TFile fh(histoName.Data(), "RECREATE");
569  jpsiMHisto->Write();
570  fh.Close();
571  delete jpsiMHisto;
572 
573  TFile::CurrentFile() = curFile;
574  }
575 
576  {
577  TFile* curFile = TFile::CurrentFile();
578  TString histoName = "jpsiPHisto.root";
579 
580  TFile fh(histoName.Data(), "RECREATE");
581  jpsiPHisto->Write();
582  fh.Close();
583  delete jpsiPHisto;
584 
585  TFile::CurrentFile() = curFile;
586  }
587 
588  {
589  TFile* curFile = TFile::CurrentFile();
590  TString histoName = "jpsiEHisto.root";
591 
592  TFile fh(histoName.Data(), "RECREATE");
593  jpsiEHisto->Write();
594  fh.Close();
595  delete jpsiEHisto;
596 
597  TFile::CurrentFile() = curFile;
598  }
599 
600  {
601  TFile* curFile = TFile::CurrentFile();
602  TString histoName = "signalMHisto.root";
603 
604  TFile fh(histoName.Data(), "RECREATE");
605  signalMHisto->Write();
606  fh.Close();
607  delete signalMHisto;
608 
609  TFile::CurrentFile() = curFile;
610  }
611 
612  TH2F* trdHisto = new TH2F("TRD", "TRD", 500, -50., 1000., 500, 0., 600.);
613  TH2F* trdHistoXY =
614  new TH2F("TRD_XY", "TRD_XY", 400, -400., 400., 300, -300., 300.);
615 
616  //Int_t numEvents = 0;
617  //Int_t numPoints[] = { 0, 0, 0, 0, 0, 0 }; (VF) unused
618  fEventTimes.resize(fNEvents);
619 
620 #ifdef LXTB_EMU_TS
621  fEventTimes[0] = 0;
622 
623  for (int i = 1; i < fNEvents; ++i)
624  fEventTimes[i] = fEventTimes[i - 1] + gRandom->Exp(CUR_TIMEBIN_LENGTH);
625 #else
626  fEventTimes[0] = 50;
627 
628  for (int i = 1; i < fNEvents; ++i)
629  fEventTimes[i] = fEventTimes[i - 1] + 100;
630 #endif //LXTB_EMU_TS
631 
632  for (int i = 0; i < fNEvents; ++i) {
633  Int_t evSize = fMuchMCPoints->Size(0, i);
634  fMuchPoints.push_back(vector<PointDataHolder>());
635 
636  if (0 >= evSize) continue;
637 
638  //++numEvents;
639  vector<PointDataHolder>& evPoints = fMuchPoints.back();
640 
641  for (int j = 0; j < evSize; ++j) {
642  const CbmMuchPoint* pMuchPt =
643  static_cast<const CbmMuchPoint*>(fMuchMCPoints->Get(0, i, j));
644 
645  Int_t layerNumber =
646  CbmMuchGeoScheme::GetLayerIndex(pMuchPt->GetDetectorId());
647 
648  //if (1 == layerNumber)
649  {
650  PointDataHolder muchPt;
651  muchPt.x = (pMuchPt->GetXIn() + pMuchPt->GetXOut()) / 2;
652  muchPt.y = (pMuchPt->GetYIn() + pMuchPt->GetYOut()) / 2;
653  muchPt.t = fEventTimes[i] + pMuchPt->GetTime();
654  muchPt.eventId = i;
655  muchPt.trackId = pMuchPt->GetTrackID();
656  muchPt.pointId = j;
657  muchPt.stationNumber =
658  CbmMuchGeoScheme::GetStationIndex(pMuchPt->GetDetectorId());
659  muchPt.layerNumber = layerNumber;
660  evPoints.push_back(muchPt);
661  }
662  }
663  }
664 
665  if (hasTrd) {
666  for (int i = 0; i < fNEvents; ++i) {
667  Int_t evSize = fTrdMCPoints->Size(0, i);
668  fTrdPoints.push_back(vector<PointDataHolder>());
669 
670  if (0 >= evSize) continue;
671 
672  set<Int_t> trdTracks;
673  vector<PointDataHolder>& evPoints = fTrdPoints.back();
674 
675  for (int j = 0; j < evSize; ++j) {
676  const CbmTrdPoint* pTrdPt =
677  static_cast<const CbmTrdPoint*>(fTrdMCPoints->Get(0, i, j));
678  Int_t trackId = pTrdPt->GetTrackID();
679  trdTracks.insert(trackId);
680 
681  Int_t layerNumber =
682  CbmTrdAddress::GetLayerId(pTrdPt->GetModuleAddress());
683 
684  //if (0 != layerNumber)
685  //continue;
686 
687  PointDataHolder trdPt;
688  trdPt.x = (pTrdPt->GetXIn() + pTrdPt->GetXOut()) / 2;
689  trdPt.y = (pTrdPt->GetYIn() + pTrdPt->GetYOut()) / 2;
690  trdPt.z = (pTrdPt->GetZIn() + pTrdPt->GetZOut()) / 2;
691  trdPt.t = fEventTimes[i] + pTrdPt->GetTime();
692  trdPt.eventId = i;
693  trdPt.trackId = pTrdPt->GetTrackID();
694  trdPt.pointId = j;
695  trdPt.stationNumber = layerNumber;
696  evPoints.push_back(trdPt);
697 
698  trdHistoXY->Fill(trdPt.x, trdPt.y);
699  }
700 
701  for (set<Int_t>::const_iterator j = trdTracks.begin();
702  j != trdTracks.end();
703  ++j) {
704  Int_t trackId = *j;
705  const CbmMCTrack* mcTrack =
706  static_cast<const CbmMCTrack*>(mcTracks->Get(0, i, trackId));
707  Double_t startZ = mcTrack->GetStartZ();
708  Double_t startR = sqrt(mcTrack->GetStartX() * mcTrack->GetStartX()
709  + mcTrack->GetStartY() * mcTrack->GetStartY());
710  trdHisto->Fill(startZ, startR);
711  }
712  }
713  }
714 
715  for (vector<vector<PointDataHolder>>::iterator i = fMuchPoints.begin();
716  i != fMuchPoints.end();
717  ++i) {
718  vector<PointDataHolder>& evPoints = *i;
719 
720  for (vector<PointDataHolder>::iterator j = evPoints.begin();
721  j != evPoints.end();
722  ++j) {
723  PointDataHolder& pt = *j;
724 
725  if (1 == pt.layerNumber)
726  fMCTracks[pt.eventId][pt.trackId].pointInds[pt.stationNumber] =
727  pt.pointId;
728  }
729  }
730 
731  if (hasTrd) {
732  for (vector<vector<PointDataHolder>>::iterator i = fTrdPoints.begin();
733  i != fTrdPoints.end();
734  ++i) {
735  vector<PointDataHolder>& evPoints = *i;
736 
737  for (vector<PointDataHolder>::iterator j = evPoints.begin();
738  j != evPoints.end();
739  ++j) {
740  PointDataHolder& pt = *j;
741  fMCTracks[pt.eventId][pt.trackId].trdPointInds[pt.stationNumber] =
742  pt.pointId;
743  }
744  }
745  }
746 
747  TH1F* trd2XHisto = new TH1F("trd2XHisto", "trd2XHisto", 100, -2.5, 2.5);
748  TH1F* trd2YHisto = new TH1F("trd2YHisto", "trd2YHisto", 100, -2.5, 2.5);
749  TH1F* trd3XHisto = new TH1F("trd3XHisto", "trd3XHisto", 100, -2.5, 2.5);
750  TH1F* trd3YHisto = new TH1F("trd3YHisto", "trd3YHisto", 100, -2.5, 2.5);
751  int eventId = 0;
752 
753  for (vector<vector<TrackDataHolder>>::iterator i = fMCTracks.begin();
754  i != fMCTracks.end();
755  ++i) {
756  vector<TrackDataHolder>& evTracks = *i;
757 
758  for (vector<TrackDataHolder>::iterator j = evTracks.begin();
759  j != evTracks.end();
760  ++j) {
761  TrackDataHolder& track = *j;
762 
763  if (!track.isSignalShort) continue;
764 
765  for (int k = 0; k < CUR_NOF_STATIONS; ++k) {
766  if (track.pointInds[k] < 0) {
767  track.isSignalShort = false;
768  track.isSignalLong = false;
769  break;
770  }
771  }
772 
773  if (hasTrd) {
774  for (int k = 0; k < CUR_NOF_TRD_LAYERS; ++k) {
775  if (track.trdPointInds[k] < 0) {
776  track.isSignalLong = false;
777  break;
778  }
779  }
780 
781  if (!track.isSignalLong) continue;
782 
783  PointDataHolder& trdPt0 = fTrdPoints[eventId][track.trdPointInds[0]];
784  PointDataHolder& trdPt1 = fTrdPoints[eventId][track.trdPointInds[1]];
785  PointDataHolder& trdPt2 = fTrdPoints[eventId][track.trdPointInds[2]];
786  PointDataHolder& trdPt3 = fTrdPoints[eventId][track.trdPointInds[3]];
787 
788  Double_t tx = (trdPt1.x - trdPt0.x) / (trdPt1.z - trdPt0.z);
789  Double_t ty = (trdPt1.y - trdPt0.y) / (trdPt1.z - trdPt0.z);
790  Double_t p2X = trdPt1.x + tx * (trdPt2.z - trdPt1.z);
791  trd2XHisto->Fill(p2X - trdPt2.x);
792  Double_t p2Y = trdPt1.y + ty * (trdPt2.z - trdPt1.z);
793  trd2YHisto->Fill(p2Y - trdPt2.y);
794  Double_t p3X = trdPt1.x + tx * (trdPt3.z - trdPt1.z);
795  trd3XHisto->Fill(p3X - trdPt3.x);
796  Double_t p3Y = trdPt1.y + ty * (trdPt3.z - trdPt1.z);
797  trd3YHisto->Fill(p3Y - trdPt3.y);
798  }
799  }
800 
801  ++eventId;
802  }
803 
804  if (hasTrd) {
805  {
806  TFile* curFile = TFile::CurrentFile();
807  TString histoName = "trd2XHisto.root";
808 
809  TFile fh(histoName.Data(), "RECREATE");
810  trd2XHisto->Write();
811  fh.Close();
812  delete trd2XHisto;
813 
814  TFile::CurrentFile() = curFile;
815  }
816 
817  {
818  TFile* curFile = TFile::CurrentFile();
819  TString histoName = "trd2YHisto.root";
820 
821  TFile fh(histoName.Data(), "RECREATE");
822  trd2YHisto->Write();
823  fh.Close();
824  delete trd2YHisto;
825 
826  TFile::CurrentFile() = curFile;
827  }
828 
829  {
830  TFile* curFile = TFile::CurrentFile();
831  TString histoName = "trd3XHisto.root";
832 
833  TFile fh(histoName.Data(), "RECREATE");
834  trd3XHisto->Write();
835  fh.Close();
836  delete trd3XHisto;
837 
838  TFile::CurrentFile() = curFile;
839  }
840 
841  {
842  TFile* curFile = TFile::CurrentFile();
843  TString histoName = "trd3YHisto.root";
844 
845  TFile fh(histoName.Data(), "RECREATE");
846  trd3YHisto->Write();
847  fh.Close();
848  delete trd3YHisto;
849 
850  TFile::CurrentFile() = curFile;
851  }
852  }
853 
854  int evNum = 0;
855  TH1F* signalDistHisto =
856  new TH1F("signalDistHisto", "signalDistHisto", 200, 0., 200.);
857 
858  for (vector<vector<TrackDataHolder>>::iterator i = fMCTracks.begin();
859  i != fMCTracks.end();
860  ++i) {
861  vector<TrackDataHolder>& evTracks = *i;
862  bool hasShortPos = false;
863  bool hasShortNeg = false;
864  bool hasLongPos = false;
865  bool hasLongNeg = false;
866  timetype posTime = 0;
867  timetype negTime = 0;
868  Double_t posX = 0;
869  Double_t posY = 0;
870  Double_t negX = 0;
871  Double_t negY = 0;
872 
873  for (vector<TrackDataHolder>::iterator j = evTracks.begin();
874  j != evTracks.end();
875  ++j) {
876  TrackDataHolder& track = *j;
877 
878  if (!track.isSignalShort) continue;
879 
880  if (track.isPos) {
881  hasShortPos = true;
882  posTime = fMuchPoints[evNum][track.pointInds[CUR_LAST_STATION]].t;
883  posX = fMuchPoints[evNum][track.pointInds[0]].x;
884  posY = fMuchPoints[evNum][track.pointInds[0]].y;
885 
886  if (track.isSignalLong) hasLongPos = true;
887  } else {
888  hasShortNeg = true;
889  negTime = fMuchPoints[evNum][track.pointInds[CUR_LAST_STATION]].t;
890  negX = fMuchPoints[evNum][track.pointInds[0]].x;
891  negY = fMuchPoints[evNum][track.pointInds[0]].y;
892 
893  if (track.isSignalLong) hasLongNeg = true;
894  }
895  }
896 
897  if (hasShortPos && hasShortNeg) {
898  shortSignalMCTimes.push_back((posTime + negTime) / 2);
899 
900  if (hasLongPos && hasLongNeg) {
901  longSignalMCTimes.push_back((posTime + negTime) / 2);
902  signalDistHisto->Fill(
903  sqrt((posX - negX) * (posX - negX) + (posY - negY) * (posY - negY)));
904  }
905 
906  if (hasLongPos || hasLongNeg)
907  middleSignalMCTimes.push_back((posTime + negTime) / 2);
908  }
909 
910  ++evNum;
911  }
912 
913  {
914  TFile* curFile = TFile::CurrentFile();
915  TString histoName = "signalDistHisto.root";
916 
917  TFile fh(histoName.Data(), "RECREATE");
918  signalDistHisto->Write();
919  fh.Close();
920  delete signalDistHisto;
921 
922  TFile::CurrentFile() = curFile;
923  }
924 
925  if (hasTrd) {
926  {
927  TFile* curFile = TFile::CurrentFile();
928  TString histoName = "trdMctByZR_All.root";
929 
930  TFile fh(histoName.Data(), "RECREATE");
931  trdHisto->Write();
932  fh.Close();
933  delete trdHisto;
934 
935  TFile::CurrentFile() = curFile;
936  }
937 
938  {
939  TFile* curFile = TFile::CurrentFile();
940  TString histoName = "trdMctByXY_All.root";
941 
942  TFile fh(histoName.Data(), "RECREATE");
943  trdHistoXY->Write();
944  fh.Close();
945  delete trdHistoXY;
946 
947  TFile::CurrentFile() = curFile;
948  }
949  }
950 #endif //LXTB_QA
951 
952  return kSUCCESS;
953 }
954 
955 static Int_t currentEventN = 0;
956 static unsigned long long tsStartTime = 0;
957 
958 #ifdef LXTB_EMU_TS
959 static Double_t min_ts_time = 100000;
960 static Double_t max_ts_time = -100000;
961 static list<LxTbBinnedPoint> ts_points;
962 #endif //LXTB_EMU_TS
963 
964 #ifdef LXTB_QA
965 void LxTBFinder::AddHit(const CbmPixelHit* hit,
966  Int_t stationNumber,
967  Int_t refId,
968  bool isTrd)
969 #else
970 void LxTBFinder::AddHit(const CbmPixelHit* hit,
971  Int_t stationNumber,
972  Int_t refId)
973 #endif //LXTB_QA
974 {
975  scaltype x = hit->GetX();
976  scaltype y = hit->GetY();
977  timetype t = hit->GetTime();
978  scaltype dx = hit->GetDx();
979  scaltype dy = hit->GetDy();
980  timetype dt = 4; //hit->GetTimeError();
981  LxTbBinnedPoint point(x,
982  dx,
983  y,
984  dy,
985  t,
986  dt,
987  refId, CUR_LAST_STATION == stationNumber);
989 #ifdef LXTB_QA
990  point.isTrd = isTrd;
991  point.stationNumber = stationNumber;
992  //point.eventId = pt.eventId;
993  //point.trackId = pt.trackId;
994  //fMCTracks[point.eventId][point.trackId].hasPoint[stationNumber] = true;
995  //point.pHit = hit;
996  //point.isTrd = isTrd;
997  Int_t clusterId = hit->GetRefId();
998 
999  if (useIdeal) {
1000  const FairMCPoint* pMCPt = static_cast<const FairMCPoint*>(
1001  isTrd ? fTrdMCPoints->Get(0, currentEventN, clusterId)
1002  : fMuchMCPoints->Get(0, currentEventN, clusterId));
1003  Int_t trackId = pMCPt->GetTrackID();
1004  LxTbBinnedPoint::PointDesc ptDesc = {currentEventN, clusterId, trackId};
1005  t = isTrd ? fTrdPoints[currentEventN][clusterId].t
1006  : fMuchPoints[currentEventN][clusterId].t;
1007 #ifdef LXTB_EMU_TS
1008  t += gRandom->Gaus(0, 4);
1009 #endif //LXTB_EMU_TS
1010  point.mcRefs.push_back(ptDesc);
1011  } else {
1012  const CbmCluster* cluster = static_cast<const CbmCluster*>(
1013  isTrd ? fTrdClusters->At(clusterId) : fMuchClusters->At(clusterId));
1014  Int_t nDigis = cluster->GetNofDigis();
1015  double avT = 0;
1016 #ifdef LXTB_EMU_TS
1017  double avTErr = 0;
1018 #endif //LXTB_EMU_TS
1019  int nofT = 0;
1020 
1021  for (Int_t i = 0; i < nDigis; ++i) {
1022  const CbmMatch* digiMatch = static_cast<const CbmMatch*>(
1023  isTrd ? fTrdDigiMatches->At(cluster->GetDigi(i))
1024  : fMuchPixelDigiMatches->At(cluster->GetDigi(i)));
1025  Int_t nMCs = digiMatch->GetNofLinks();
1026 
1027  for (Int_t j = 0; j < nMCs; ++j) {
1028  const CbmLink& lnk = digiMatch->GetLink(j);
1029  Int_t eventId = isEvByEv ? currentEventN : lnk.GetEntry();
1030  Int_t pointId = lnk.GetIndex();
1031 
1032  if (
1033  (isTrd && fTrdPoints[eventId].size() <= static_cast<size_t>(pointId))
1034  || (!isTrd
1035  && fMuchPoints[eventId].size() <= static_cast<size_t>(
1036  pointId))) // Do this check because of possible addition of noise electrons in runtime.
1037  continue;
1038 
1039  const FairMCPoint* pMCPt = static_cast<const FairMCPoint*>(
1040  isTrd ? fTrdMCPoints->Get(0, eventId, pointId)
1041  : fMuchMCPoints->Get(0, eventId, pointId));
1042  Int_t trackId = pMCPt->GetTrackID();
1043  LxTbBinnedPoint::PointDesc ptDesc = {eventId, pointId, trackId};
1044  point.mcRefs.push_back(ptDesc);
1045  Double_t deltaT = isTrd ? fTrdPoints[eventId][pointId].t
1046  : fMuchPoints[eventId][pointId].t;
1047 #ifdef LXTB_EMU_TS
1048  deltaT += gRandom->Gaus(0, 4);
1049  avTErr += 4 * 4;
1050 #endif //LXTB_EMU_TS
1051  avT += deltaT;
1052  ++nofT;
1053  }
1054  }
1055 
1056  if (nofT > 0) {
1057  avT /= nofT;
1058 #ifdef LXTB_EMU_TS
1059  avTErr = TMath::Sqrt(avTErr);
1060  avTErr /= nofT;
1061  dt = avT;
1062 #endif //LXTB_EMU_TS
1063  }
1064 
1065  t = avT;
1066  }
1067 #endif //LXTB_QA
1068  point.t = t;
1069 
1070 #ifdef LXTB_EMU_TS
1071  ts_points.push_back(point);
1072 
1073  if (min_ts_time > t) min_ts_time = t;
1074 
1075  if (max_ts_time < t) max_ts_time = t;
1076 #else //LXTB_EMU_TS
1077  scaltype minY =
1078  (isTrd ? fFinder->trdStation.minY : fFinder->stations[stationNumber].minY);
1079  scaltype binSizeY = (isTrd ? fFinder->trdStation.binSizeY
1080  : fFinder->stations[stationNumber].binSizeY);
1081  int lastYBin = (isTrd ? fFinder->trdStation.lastYBin
1082  : fFinder->stations[stationNumber].lastYBin);
1083  scaltype minX =
1084  (isTrd ? fFinder->trdStation.minX : fFinder->stations[stationNumber].minX);
1085  scaltype binSizeX = (isTrd ? fFinder->trdStation.binSizeX
1086  : fFinder->stations[stationNumber].binSizeX);
1087  int lastXBin = (isTrd ? fFinder->trdStation.lastXBin
1088  : fFinder->stations[stationNumber].lastXBin);
1089 
1090  int tInd = (t - fFinder->minT) / CUR_TIMEBIN_LENGTH;
1091 
1092  if (tInd < 0)
1093  tInd = 0;
1094  else if (tInd > last_timebin)
1095  tInd = last_timebin;
1096 
1097  LxTbTYXBin& tyxBin =
1098  (isTrd ? fFinder->trdStation.tyxBinsArr[stationNumber][tInd]
1099  : fFinder->stations[stationNumber].tyxBins[tInd]);
1100  int yInd = (y - minY) / binSizeY;
1101 
1102  if (yInd < 0)
1103  yInd = 0;
1104  else if (yInd > lastYBin)
1105  yInd = lastYBin;
1106 
1107  LxTbYXBin& yxBin = tyxBin.yxBins[yInd];
1108  int xInd = (x - minX) / binSizeX;
1109 
1110  if (xInd < 0)
1111  xInd = 0;
1112  else if (xInd > lastXBin)
1113  xInd = lastXBin;
1114 
1115  LxTbXBin& xBin = yxBin.xBins[xInd];
1116  xBin.points.push_back(point);
1117 
1118  if ( CUR_LAST_STATION == stationNumber) {
1119  xBin.use = true;
1120  yxBin.use = true;
1121  tyxBin.use = true;
1122  }
1123 #endif //LXTB_EMU_TS
1124 }
1125 
1126 #ifdef LXTB_TIE
1127 void LxTBFinder::AddLayerHit(const CbmPixelHit* hit,
1128  Int_t layerNumber,
1129  Int_t refId,
1130  bool isTrd) {
1131  scaltype x = hit->GetX();
1132  scaltype y = hit->GetY();
1133  timetype t = hit->GetTime();
1134  scaltype dx = hit->GetDx();
1135  scaltype dy = hit->GetDy();
1136  timetype dt = 4; //hit->GetTimeError();
1137 
1138  LxTBBinndedLayer& layer = fDetector->fLayers[layerNumber];
1139 
1140  if (layer.maxDx < dx) layer.maxDx = dx;
1141 
1142  if (layer.maxDy < dy) layer.maxDy = dy;
1143 
1144  if (layer.maxDt < dt) layer.maxDt = dt;
1145 
1146  LxTbBinnedPoint point(x, dx, y, dy, t, dt, refId, false);
1147 #ifdef LXTB_QA
1148  point.isTrd = isTrd;
1149  point.stationNumber =
1150  layerNumber; // Station number does not matter in this context.
1151  Int_t clusterId = hit->GetRefId();
1152 
1153  /*if (useIdeal)
1154  {
1155  const FairMCPoint* pMCPt = static_cast<const FairMCPoint*> (isTrd ? fTrdMCPoints->Get(0, currentEventN, clusterId) : fMuchMCPoints->Get(0, currentEventN, clusterId));
1156  Int_t trackId = pMCPt->GetTrackID();
1157  LxTbBinnedPoint::PointDesc ptDesc = {currentEventN, clusterId, trackId};
1158  t = isTrd ? fTrdPoints[currentEventN][clusterId].t : fMuchPoints[currentEventN][clusterId].t;
1159 #ifdef LXTB_EMU_TS
1160  t += gRandom->Gaus(0, 4);
1161 #endif//LXTB_EMU_TS
1162  point.mcRefs.push_back(ptDesc);
1163  }
1164  else*/
1165  {
1166  const CbmCluster* cluster = static_cast<const CbmCluster*>(
1167  isTrd ? fTrdClusters->At(clusterId) : fMuchClusters->At(clusterId));
1168  Int_t nDigis = cluster->GetNofDigis();
1169  double avT = 0;
1170 #ifdef LXTB_EMU_TS
1171  double avTErr = 0;
1172 #endif //LXTB_EMU_TS
1173  int nofT = 0;
1174 
1175  for (Int_t i = 0; i < nDigis; ++i) {
1176  const CbmMatch* digiMatch = static_cast<const CbmMatch*>(
1177  isTrd ? fTrdDigiMatches->At(cluster->GetDigi(i))
1178  : fMuchPixelDigiMatches->At(cluster->GetDigi(i)));
1179  Int_t nMCs = digiMatch->GetNofLinks();
1180 
1181  for (Int_t j = 0; j < nMCs; ++j) {
1182  const CbmLink& lnk = digiMatch->GetLink(j);
1183  Int_t eventId = isEvByEv ? currentEventN : lnk.GetEntry();
1184  Int_t pointId = lnk.GetIndex();
1185 
1186  if (
1187  (isTrd && fTrdPoints[eventId].size() <= pointId)
1188  || (!isTrd
1189  && fMuchPoints[eventId].size()
1190  <= pointId)) // Do this check because of possible addition of noise electrons in runtime.
1191  continue;
1192 
1193  const FairMCPoint* pMCPt = static_cast<const FairMCPoint*>(
1194  isTrd ? fTrdMCPoints->Get(0, eventId, pointId)
1195  : fMuchMCPoints->Get(0, eventId, pointId));
1196  Int_t trackId = pMCPt->GetTrackID();
1197  LxTbBinnedPoint::PointDesc ptDesc = {eventId, pointId, trackId};
1198  point.mcRefs.push_back(ptDesc);
1199  Double_t deltaT = isTrd ? fTrdPoints[eventId][pointId].t
1200  : fMuchPoints[eventId][pointId].t;
1201 #ifdef LXTB_EMU_TS
1202  deltaT += gRandom->Gaus(0, 4);
1203  avTErr += 4 * 4;
1204 #endif //LXTB_EMU_TS
1205  avT += deltaT;
1206  ++nofT;
1207  }
1208  }
1209 
1210  if (nofT > 0) {
1211  avT /= nofT;
1212 #ifdef LXTB_EMU_TS
1213  avTErr = TMath::Sqrt(avTErr);
1214  avTErr /= nofT;
1215  dt = avT;
1216 #endif //LXTB_EMU_TS
1217  }
1218 
1219  t = avT;
1220  }
1221 #endif //LXTB_QA
1222  point.t = t;
1223 
1224  /*#ifdef LXTB_EMU_TS
1225  ts_points.push_back(point);
1226 
1227  if (min_ts_time > t)
1228  min_ts_time = t;
1229 
1230  if (max_ts_time < t)
1231  max_ts_time = t;
1232 #else//LXTB_EMU_TS*/
1233  scaltype minY = fDetector->fLayers[layerNumber].minY;
1234  scaltype binSizeY = fDetector->fLayers[layerNumber].binSizeY;
1235  int lastYBin = fDetector->fLayers[layerNumber].lastYBin;
1236  scaltype minX = fDetector->fLayers[layerNumber].minX;
1237  scaltype binSizeX = fDetector->fLayers[layerNumber].binSizeX;
1238  int lastXBin = fDetector->fLayers[layerNumber].lastXBin;
1239  timetype minT = fDetector->fLayers[layerNumber].minT;
1240  int binSizeT = fDetector->fLayers[layerNumber].binSizeT;
1241  int lastTBin = fDetector->fLayers[layerNumber].lastTBin;
1242 
1243  int tInd = (t - minT) / binSizeT;
1244 
1245  if (tInd < 0)
1246  tInd = 0;
1247  else if (tInd > lastTBin)
1248  tInd = lastTBin;
1249 
1250  LxTbTYXBin& tyxBin = fDetector->fLayers[layerNumber].tyxBins[tInd];
1251  int yInd = (y - minY) / binSizeY;
1252 
1253  if (yInd < 0)
1254  yInd = 0;
1255  else if (yInd > lastYBin)
1256  yInd = lastYBin;
1257 
1258  LxTbYXBin& yxBin = tyxBin.yxBins[yInd];
1259  int xInd = (x - minX) / binSizeX;
1260 
1261  if (xInd < 0)
1262  xInd = 0;
1263  else if (xInd > lastXBin)
1264  xInd = lastXBin;
1265 
1266  LxTbXBin& xBin = yxBin.xBins[xInd];
1267  xBin.points.push_back(point);
1268  //#endif//LXTB_EMU_TS
1269 }
1270 
1271 void LxTBFinder::AddStsTrack(const CbmStsTrack& stsTrack, Int_t selfId) {
1272  const FairTrackParam& par = *stsTrack.GetParamLast();
1273 
1274  if (0 == par.GetQp()) return;
1275 
1276  Int_t nofHits = stsTrack.GetNofHits();
1277 
1278  if (nofHits < 1) return;
1279 
1280  Int_t lastHitNr = nofHits - 1;
1281 
1282  if (kSTSHIT != stsTrack.GetHitType(lastHitNr)) return;
1283 
1284  Int_t lastHitIndex = stsTrack.GetHitIndex(lastHitNr);
1285  const CbmStsHit& lastHit =
1286  *static_cast<const CbmStsHit*>(fStsHits->At(lastHitIndex));
1287  Double_t lastHitTime = fEventTimes[currentEventN] + lastHit.GetTime();
1288  Double_t lastHitTimeErr = lastHit.GetTimeError();
1289  fDetector->AddStsTrack(par, stsTrack.GetChiSq(), lastHitTime, selfId);
1290 }
1291 #endif //LXTB_TIE
1292 
1293 #ifdef LXTB_QA
1294 static vector<int> nof_ev_digis(1000);
1295 static int nof_digis = 0;
1296 #endif //LXTB_QA
1297 
1298 static void SpliceTriggerings(list<pair<timetype, timetype>>& out,
1299  LxTbBinnedFinder::TriggerTimeArray& in) {
1300  for (int i = 0; i < in.nofTimebins; ++i)
1301  out.splice(out.end(), in.triggerTimeBins[i]);
1302 }
1303 
1304 void LxTBFinder::Exec(Option_t*) {
1305  FairRootManager* ioman = FairRootManager::Instance();
1306 
1307  if (0 == ioman) LOG(fatal) << "No FairRootManager";
1308 
1309  Int_t evNumb = ioman->GetEntryNr();
1310  cout << "evNumb = " << evNumb << endl;
1311  //Double_t evTi = ioman->GetEventTime(); (VF) unused
1312 
1313  fFinder->Clear();
1314  fFinder->SetTSBegin(tsStartTime);
1315 
1316 #ifdef LXTB_TIE
1317  fDetector->fMuchTracks->Delete();
1318  fDetector->fGlobalTracks->Clear();
1319  fDetector->SetTSBegin(tsStartTime);
1320 #endif //LXTB_TIE
1321 
1322  // As the SIS100 geometry contains 4 MUCH and 1 TRD stations we need to read both MUCH and TRD hits.
1323  for (int i = 0; i < fMuchPixelHits->GetEntriesFast(); ++i) {
1324  const CbmMuchPixelHit* mh =
1325  static_cast<const CbmMuchPixelHit*>(fMuchPixelHits->At(i));
1326  Int_t hitLrN = CbmMuchGeoScheme::GetLayerIndex(mh->GetAddress());
1327 
1328  if (1 != hitLrN) continue;
1329 
1330  Int_t hitStN = CbmMuchGeoScheme::GetStationIndex(mh->GetAddress());
1331 #ifdef LXTB_QA
1332  AddHit(mh, hitStN, i, false);
1333 #else
1334  AddHit(mh, hitStN, i);
1335 #endif //LXTB_QA
1336  }
1337 
1338  if (hasTrd) {
1339  for (int i = 0; i < fTrdHits->GetEntriesFast(); ++i) {
1340  const CbmTrdHit* th = static_cast<const CbmTrdHit*>(fTrdHits->At(i));
1341  Int_t hitStN = th->GetPlaneId();
1342 
1343  //if (0 != hitStN)
1344  //continue;
1345 
1346  //hitStN = CUR_LAST_STATION;
1347 #ifdef LXTB_QA
1348  AddHit(th, hitStN, i, true);
1349 #else
1350  AddHit(th, hitStN, i);
1351 #endif //LXTB_QA
1352  }
1353  }
1354 
1355 #ifndef LXTB_EMU_TS
1356  fFinder->Reconstruct();
1357  tsStartTime += 100;
1358 
1359  for (int i = 0; i < fFinder->nofTrackBins; ++i) {
1360  list<LxTbBinnedFinder::Chain*>& recoTracksBin = fFinder->recoTracks[i];
1361 
1362  for (list<LxTbBinnedFinder::Chain*>::const_iterator j =
1363  recoTracksBin.begin();
1364  j != recoTracksBin.end();
1365  ++j)
1366  recoTracks.push_back(*j);
1367  }
1368 
1369  SpliceTriggerings(triggerTimes_trd0_sign0_dist0,
1370  fFinder->triggerTimes_trd0_sign0_dist0);
1371  SpliceTriggerings(triggerTimes_trd0_sign0_dist1,
1372  fFinder->triggerTimes_trd0_sign0_dist1);
1373  SpliceTriggerings(triggerTimes_trd0_sign1_dist0,
1374  fFinder->triggerTimes_trd0_sign1_dist0);
1375  SpliceTriggerings(triggerTimes_trd0_sign1_dist1,
1376  fFinder->triggerTimes_trd0_sign1_dist1);
1377  SpliceTriggerings(triggerTimes_trd1_sign0_dist0,
1378  fFinder->triggerTimes_trd1_sign0_dist0);
1379  SpliceTriggerings(triggerTimes_trd1_sign0_dist1,
1380  fFinder->triggerTimes_trd1_sign0_dist1);
1381  SpliceTriggerings(triggerTimes_trd1_sign1_dist0,
1382  fFinder->triggerTimes_trd1_sign1_dist0);
1383 
1384  int prevTrigTimeSize =
1385  triggerTimes_trd1_sign1_dist1
1386  .size(); // Not very elegant! >---------------------------------------
1387  SpliceTriggerings(
1388  triggerTimes_trd1_sign1_dist1,
1389  fFinder->triggerTimes_trd1_sign1_dist1); // |
1390 #ifdef LXTB_TIE
1391  // |
1392  if (triggerTimes_trd1_sign1_dist1.size() - prevTrigTimeSize
1393  > 0) // Triggering event. Do global tracks generation. <------
1394  {
1395  fDetector->Clear();
1396  Int_t nofStsTracks = fStsTracks->GetEntriesFast();
1397 
1398  for (int i = 0; i < nofStsTracks; ++i) {
1399  const CbmStsTrack* stsTrack =
1400  static_cast<const CbmStsTrack*>(fStsTracks->At(i));
1401  AddStsTrack(*stsTrack, i);
1402  }
1403 
1404  for (int i = 0; i < fMuchPixelHits->GetEntriesFast(); ++i) {
1405  const CbmMuchPixelHit* mh =
1406  static_cast<const CbmMuchPixelHit*>(fMuchPixelHits->At(i));
1407  Int_t hitStN = CbmMuchGeoScheme::GetStationIndex(mh->GetAddress());
1408  Int_t hitLrN = CbmMuchGeoScheme::GetLayerIndex(mh->GetAddress());
1409  AddLayerHit(mh, hitStN * 3 + hitLrN, i, false);
1410  }
1411 
1412  for (int i = 0; i < fTrdHits->GetEntriesFast(); ++i) {
1413  const CbmTrdHit* th = static_cast<const CbmTrdHit*>(fTrdHits->At(i));
1414  Int_t hitStN = th->GetPlaneId();
1415  AddLayerHit(th, CUR_NOF_STATIONS * 3 + hitStN, i, true);
1416  }
1417 
1418  fDetector->TieTracks(*fFinder);
1419  }
1420 #endif //LXTB_TIE
1421  SpliceTriggerings(triggerTimes_trd05_sign0_dist0,
1422  fFinder->triggerTimes_trd05_sign0_dist0);
1423  SpliceTriggerings(triggerTimes_trd05_sign0_dist1,
1424  fFinder->triggerTimes_trd05_sign0_dist1);
1425  SpliceTriggerings(triggerTimes_trd05_sign1_dist0,
1426  fFinder->triggerTimes_trd05_sign1_dist0);
1427  SpliceTriggerings(triggerTimes_trd05_sign1_dist1,
1428  fFinder->triggerTimes_trd05_sign1_dist1);
1429 #endif //LXTB_EMU_TS
1430 
1431 #ifdef LXTB_QA
1432  if (fMvdDigis) {
1433  nof_ev_digis[currentEventN] += fMvdDigis->GetEntriesFast();
1434  nof_digis += fMvdDigis->GetEntriesFast();
1435  }
1436 
1437  if (fStsDigis) {
1438  nof_ev_digis[currentEventN] += fStsDigis->GetEntriesFast();
1439  nof_digis += fStsDigis->GetEntriesFast();
1440  }
1441 
1442  nof_ev_digis[currentEventN] += fMuchPixelDigiMatches->GetEntriesFast();
1443  nof_digis += fMuchPixelDigiMatches->GetEntriesFast();
1444  nof_ev_digis[currentEventN] += fTrdDigiMatches->GetEntriesFast();
1445  nof_digis += fTrdDigiMatches->GetEntriesFast();
1446 
1447  if (fTofDigis) {
1448  nof_ev_digis[currentEventN] += fTofDigis->GetEntriesFast();
1449  nof_digis += fTofDigis->GetEntriesFast();
1450  }
1451 #endif //LXTB_QA
1452 
1453  ++currentEventN;
1454 }
1455 
1456 struct RecoTrackData {
1457  Int_t eventId;
1458  Int_t trackId;
1459 
1460  RecoTrackData(Int_t eId, Int_t tId) : eventId(eId), trackId(tId) {}
1461 };
1462 
1463 struct RTDLess {
1464  bool operator()(const RecoTrackData& x, const RecoTrackData& y) const {
1465  if (x.eventId < y.eventId) return true;
1466 
1467  return x.trackId < y.trackId;
1468  }
1469 };
1470 
1471 static void PrintTrigger(list<pair<timetype, timetype>>& signalRecoTimes,
1472  list<timetype>& signalMCTimes,
1473  const char* name,
1474  bool write_eff_for_inv_m = false) {
1475  int nofRecoSignals = 0;
1476 
1477  for (list<timetype>::const_iterator i = signalMCTimes.begin();
1478  i != signalMCTimes.end();
1479  ++i) {
1480  timetype mcTime = *i;
1481  bool matched = false;
1482 
1483  for (list<pair<timetype, timetype>>::const_iterator j =
1484  signalRecoTimes.begin();
1485  j != signalRecoTimes.end();
1486  ++j) {
1487  timetype recoTime = j->first;
1488  timetype dt = j->second;
1489 
1490  if (fabs(recoTime - mcTime) < NOF_SIGMAS * dt) matched = true;
1491  }
1492 
1493  if (matched) ++nofRecoSignals;
1494  }
1495 
1496  cout << "Have: " << signalRecoTimes.size() << " signaled " << name
1497  << " events" << endl;
1498  double eff = 0 == signalMCTimes.size()
1499  ? 100
1500  : 100.0 * nofRecoSignals / signalMCTimes.size();
1501  cout << "Triggered signals(" << name << "): " << eff << "% [ "
1502  << nofRecoSignals << " / " << signalMCTimes.size() << " ]" << endl;
1503 
1504  char buf[256];
1505  sprintf(buf, "triggerings_%s.txt", name);
1506  ofstream triggeringsFile(buf, ios_base::out | ios_base::trunc);
1507  triggeringsFile << signalRecoTimes.size();
1508 
1509  sprintf(buf, "signal_triggerings_%s.txt", name);
1510  ofstream signalTriggeringsFile(buf, ios_base::out | ios_base::trunc);
1511  signalTriggeringsFile << nofRecoSignals;
1512 
1513  if (write_eff_for_inv_m) {
1514  ifstream invMFile("inv_m.txt");
1515 
1516  if (invMFile.is_open()) {
1517  double invM;
1518  invMFile >> invM;
1519  ofstream invMEffFile("inv_m_eff.txt", ios_base::out | ios_base::trunc);
1520  invMEffFile << invM << " " << eff << endl;
1521  }
1522  }
1523 }
1524 
1525 void LxTBFinder::Finish() {
1526 #ifdef LXTB_EMU_TS
1527  Double_t tCoeff =
1528  CUR_TIMEBIN_LENGTH * nof_timebins / (max_ts_time - min_ts_time);
1529 
1530  for (list<LxTbBinnedPoint>::iterator i = ts_points.begin();
1531  i != ts_points.end();
1532  ++i) {
1533  LxTbBinnedPoint& point = *i;
1534  point.t = (point.t - min_ts_time) * tCoeff;
1535  point.dt *= tCoeff;
1536 
1537  bool isTrd = point.isTrd;
1538  Int_t stationNumber = point.stationNumber;
1539  scaltype minY = (isTrd ? fFinder->trdStation.minY
1540  : fFinder->stations[stationNumber].minY);
1541  scaltype binSizeY = (isTrd ? fFinder->trdStation.binSizeY
1542  : fFinder->stations[stationNumber].binSizeY);
1543  int lastYBin = (isTrd ? fFinder->trdStation.lastYBin
1544  : fFinder->stations[stationNumber].lastYBin);
1545  scaltype minX = (isTrd ? fFinder->trdStation.minX
1546  : fFinder->stations[stationNumber].minX);
1547  scaltype binSizeX = (isTrd ? fFinder->trdStation.binSizeX
1548  : fFinder->stations[stationNumber].binSizeX);
1549  int lastXBin = (isTrd ? fFinder->trdStation.lastXBin
1550  : fFinder->stations[stationNumber].lastXBin);
1551 
1552  int tInd = (point.t - fFinder->minT) / CUR_TIMEBIN_LENGTH;
1553 
1554  if (tInd < 0)
1555  tInd = 0;
1556  else if (tInd > int(last_timebin))
1557  tInd = last_timebin;
1558 
1559  LxTbTYXBin& tyxBin =
1560  (isTrd ? fFinder->trdStation.tyxBinsArr[stationNumber][tInd]
1561  : fFinder->stations[stationNumber].tyxBins[tInd]);
1562  int yInd = (point.y - minY) / binSizeY;
1563 
1564  if (yInd < 0)
1565  yInd = 0;
1566  else if (yInd > lastYBin)
1567  yInd = lastYBin;
1568 
1569  LxTbYXBin& yxBin = tyxBin.yxBins[yInd];
1570  int xInd = (point.x - minX) / binSizeX;
1571 
1572  if (xInd < 0)
1573  xInd = 0;
1574  else if (xInd > lastXBin)
1575  xInd = lastXBin;
1576 
1577  LxTbXBin& xBin = yxBin.xBins[xInd];
1578  xBin.points.push_back(point);
1579 
1580  if ( CUR_LAST_STATION == stationNumber) {
1581  xBin.use = true;
1582  yxBin.use = true;
1583  tyxBin.use = true;
1584  }
1585  }
1586 
1587 #ifdef LXTB_TIE
1588  fDetector->SetTSBegin(0);
1589 #endif //LXTB_TIE
1590 
1591  fFinder->Reconstruct();
1592 
1593  for (list<timetype>::iterator i = shortSignalMCTimes.begin();
1594  i != shortSignalMCTimes.end();
1595  ++i) {
1596  timetype& v = *i;
1597  v = (v - min_ts_time) * tCoeff;
1598  }
1599 
1600  for (list<timetype>::iterator i = longSignalMCTimes.begin();
1601  i != longSignalMCTimes.end();
1602  ++i) {
1603  timetype& v = *i;
1604  v = (v - min_ts_time) * tCoeff;
1605  }
1606 
1607  for (list<timetype>::iterator i = middleSignalMCTimes.begin();
1608  i != middleSignalMCTimes.end();
1609  ++i) {
1610  timetype& v = *i;
1611  v = (v - min_ts_time) * tCoeff;
1612  }
1613 
1614  for (int i = 0; i < fFinder->nofTrackBins; ++i) {
1615  list<LxTbBinnedFinder::Chain*>& recoTracksBin = fFinder->recoTracks[i];
1616 
1617  for (list<LxTbBinnedFinder::Chain*>::const_iterator j =
1618  recoTracksBin.begin();
1619  j != recoTracksBin.end();
1620  ++j)
1621  recoTracks.push_back(*j);
1622  }
1623 
1624  SpliceTriggerings(triggerTimes_trd0_sign0_dist0,
1625  fFinder->triggerTimes_trd0_sign0_dist0);
1626  SpliceTriggerings(triggerTimes_trd0_sign0_dist1,
1627  fFinder->triggerTimes_trd0_sign0_dist1);
1628  SpliceTriggerings(triggerTimes_trd0_sign1_dist0,
1629  fFinder->triggerTimes_trd0_sign1_dist0);
1630  SpliceTriggerings(triggerTimes_trd0_sign1_dist1,
1631  fFinder->triggerTimes_trd0_sign1_dist1);
1632  SpliceTriggerings(triggerTimes_trd1_sign0_dist0,
1633  fFinder->triggerTimes_trd1_sign0_dist0);
1634  SpliceTriggerings(triggerTimes_trd1_sign0_dist1,
1635  fFinder->triggerTimes_trd1_sign0_dist1);
1636  SpliceTriggerings(triggerTimes_trd1_sign1_dist0,
1637  fFinder->triggerTimes_trd1_sign1_dist0);
1638  SpliceTriggerings(triggerTimes_trd1_sign1_dist1,
1639  fFinder->triggerTimes_trd1_sign1_dist1);
1640  SpliceTriggerings(triggerTimes_trd05_sign0_dist0,
1641  fFinder->triggerTimes_trd05_sign0_dist0);
1642  SpliceTriggerings(triggerTimes_trd05_sign0_dist1,
1643  fFinder->triggerTimes_trd05_sign0_dist1);
1644  SpliceTriggerings(triggerTimes_trd05_sign1_dist0,
1645  fFinder->triggerTimes_trd05_sign1_dist0);
1646  SpliceTriggerings(triggerTimes_trd05_sign1_dist1,
1647  fFinder->triggerTimes_trd05_sign1_dist1);
1648 #endif //LXTB_EMU_TS
1649  cout << "LxTbBinnedFinder::Reconstruct() full duration was: " << fullDuration
1650  << endl;
1651 
1652  int nofRecoTracks = 0;
1653 
1654  for (list<LxTbBinnedFinder::Chain*>::const_iterator i = recoTracks.begin();
1655  i != recoTracks.end();
1656  ++i) {
1657  const LxTbBinnedFinder::Chain* chain = *i;
1658 
1659  if (!hasTrd || chain->highMom) ++nofRecoTracks;
1660  }
1661 
1662  cout << "LxTbBinnedFinder::Reconstruct() the number of found tracks: "
1663  << nofRecoTracks << endl;
1664 
1665 #ifdef LXTB_QA
1666  static int nofSignalTracks = 0;
1667  static int nofRecoSignalTracks = 0;
1668  int eventN = 0;
1669 
1670  for (vector<vector<TrackDataHolder>>::iterator i = fMCTracks.begin();
1671  i != fMCTracks.end();
1672  ++i) {
1673  vector<TrackDataHolder>& evTracks = *i;
1674 
1675  for (vector<TrackDataHolder>::iterator j = evTracks.begin();
1676  j != evTracks.end();
1677  ++j) {
1678  TrackDataHolder& track = *j;
1679 
1680  if (!track.isSignalShort || (hasTrd && !track.isSignalLong)) continue;
1681 
1682  ++nofSignalTracks;
1683 
1684  int nofMatchPoints = 0;
1685 
1686  for (list<LxTbBinnedFinder::Chain*>::const_iterator k =
1687  recoTracks.begin();
1688  k != recoTracks.end();
1689  ++k) {
1690  const LxTbBinnedFinder::Chain* chain = *k;
1691 
1692  if (hasTrd && !chain->highMom) continue;
1693 
1694  for (int l = 0; l < CUR_NOF_STATIONS; ++l) {
1695  bool pointsMatched = false;
1696 
1697  for (list<LxTbBinnedPoint::PointDesc>::const_iterator m =
1698  chain->points[l]->mcRefs.begin();
1699  m != chain->points[l]->mcRefs.end();
1700  ++m) {
1701  if (m->eventId == eventN && m->pointId == track.pointInds[l]) {
1702  pointsMatched = true;
1703  break;
1704  }
1705  }
1706 
1707  if (pointsMatched) ++nofMatchPoints;
1708  }
1709  }
1710 
1711  if (nofMatchPoints >= 2) {
1712  ++nofRecoSignalTracks;
1713  continue;
1714  }
1715  }
1716 
1717  ++eventN;
1718  }
1719 
1720  double eff =
1721  0 == nofSignalTracks ? 100 : 100.0 * nofRecoSignalTracks / nofSignalTracks;
1722  cout << "Reconstruction efficiency is: " << eff << "% [ "
1723  << nofRecoSignalTracks << " / " << nofSignalTracks << " ]" << endl;
1724 
1725  int nofRightRecoTracks = 0;
1726 
1727  for (list<LxTbBinnedFinder::Chain*>::const_iterator i = recoTracks.begin();
1728  i != recoTracks.end();
1729  ++i) {
1730  const LxTbBinnedFinder::Chain* chain = *i;
1731 
1732  if (hasTrd && !chain->highMom) continue;
1733 
1734  map<RecoTrackData, int, RTDLess> nofTracks;
1735 
1736  for (int j = 0; j < CUR_NOF_STATIONS; ++j) {
1737  int stMask = 1 << j;
1738 
1739  for (list<LxTbBinnedPoint::PointDesc>::const_iterator k =
1740  chain->points[j]->mcRefs.begin();
1741  k != chain->points[j]->mcRefs.end();
1742  ++k) {
1743  RecoTrackData st(k->eventId, k->trackId);
1744  map<RecoTrackData, int, RTDLess>::iterator nofTIter =
1745  nofTracks.find(st);
1746 
1747  if (nofTIter != nofTracks.end())
1748  nofTIter->second |= stMask;
1749  else
1750  nofTracks[st] = stMask;
1751  }
1752  }
1753 
1754  int nofPoints = 0;
1755 
1756  for (map<RecoTrackData, int, RTDLess>::const_iterator j = nofTracks.begin();
1757  j != nofTracks.end();
1758  ++j) {
1759  int nofp = 0;
1760 
1761  for (int k = 0; k < CUR_NOF_STATIONS; ++k) {
1762  if (j->second & (1 << k)) ++nofp;
1763  }
1764 
1765  if (nofp > nofPoints) nofPoints = nofp;
1766  }
1767 
1768  if (nofPoints >= 2) ++nofRightRecoTracks;
1769  }
1770 
1771  eff =
1772  0 == recoTracks.size() ? 100 : 100.0 * nofRightRecoTracks / nofRecoTracks;
1773  cout << "Non ghosts are: " << eff << "% [ " << nofRightRecoTracks << " / "
1774  << nofRecoTracks << " ]" << endl;
1775 
1776  cout << "Have: " << shortSignalMCTimes.size() << " short signaling events"
1777  << endl;
1778  cout << "Have: " << longSignalMCTimes.size() << " long signaling events"
1779  << endl;
1780  cout << "Have: " << middleSignalMCTimes.size() << " middle signaling events"
1781  << endl;
1782  cout << "Have: " << currentEventN << " events" << endl;
1783 
1784  ofstream nofEventsFile("nof_events.txt", ios_base::out | ios_base::trunc);
1785  nofEventsFile << currentEventN;
1786 
1787  ofstream nofShortSignalsFile("nof_short_signals.txt",
1788  ios_base::out | ios_base::trunc);
1789  nofShortSignalsFile << shortSignalMCTimes.size();
1790 
1791  ofstream nofLongSignalsFile("nof_long_signals.txt",
1792  ios_base::out | ios_base::trunc);
1793  nofLongSignalsFile << longSignalMCTimes.size();
1794 
1795  ofstream nofMiddleSignalsFile("nof_middle_signals.txt",
1796  ios_base::out | ios_base::trunc);
1797  nofMiddleSignalsFile << middleSignalMCTimes.size();
1798 
1799  PrintTrigger(triggerTimes_trd0_sign0_dist0,
1800  shortSignalMCTimes,
1801  "triggerTimes_trd0_sign0_dist0");
1802  PrintTrigger(triggerTimes_trd0_sign0_dist1,
1803  shortSignalMCTimes,
1804  "triggerTimes_trd0_sign0_dist1");
1805  PrintTrigger(triggerTimes_trd0_sign1_dist0,
1806  shortSignalMCTimes,
1807  "triggerTimes_trd0_sign1_dist0");
1808  PrintTrigger(triggerTimes_trd0_sign1_dist1,
1809  shortSignalMCTimes,
1810  "triggerTimes_trd0_sign1_dist1");
1811  PrintTrigger(triggerTimes_trd1_sign0_dist0,
1812  longSignalMCTimes,
1813  "triggerTimes_trd1_sign0_dist0");
1814  PrintTrigger(triggerTimes_trd1_sign0_dist1,
1815  longSignalMCTimes,
1816  "triggerTimes_trd1_sign0_dist1");
1817  PrintTrigger(triggerTimes_trd1_sign1_dist0,
1818  longSignalMCTimes,
1819  "triggerTimes_trd1_sign1_dist0");
1820  PrintTrigger(triggerTimes_trd1_sign1_dist1,
1821  longSignalMCTimes,
1822  "triggerTimes_trd1_sign1_dist1",
1823  true);
1824  PrintTrigger(triggerTimes_trd05_sign0_dist0,
1825  middleSignalMCTimes,
1826  "triggerTimes_trd05_sign0_dist0");
1827  PrintTrigger(triggerTimes_trd05_sign0_dist1,
1828  middleSignalMCTimes,
1829  "triggerTimes_trd05_sign0_dist1");
1830  PrintTrigger(triggerTimes_trd05_sign1_dist0,
1831  middleSignalMCTimes,
1832  "triggerTimes_trd05_sign1_dist0");
1833  PrintTrigger(triggerTimes_trd05_sign1_dist1,
1834  middleSignalMCTimes,
1835  "triggerTimes_trd05_sign1_dist1");
1836 
1837  Int_t nofTriggerDigis = 0;
1838 
1839  for (set<Int_t>::const_iterator i = fFinder->triggerEventNumber.begin();
1840  i != fFinder->triggerEventNumber.end();
1841  ++i)
1842  nofTriggerDigis += nof_ev_digis[*i];
1843 
1844  ofstream nofTriggerDigisFile("nof_trigger_digis.txt",
1845  ios_base::out | ios_base::trunc);
1846  nofTriggerDigisFile << nofTriggerDigis;
1847  ofstream nofDigisFile("nof_digis.txt", ios_base::out | ios_base::trunc);
1848  nofDigisFile << nof_digis;
1849 #endif //LXTB_QA
1850 
1851  for (list<LxTbBinnedFinder::Chain*>::iterator i = recoTracks.begin();
1852  i != recoTracks.end();
1853  ++i)
1854  delete *i;
1855 }
LxTBFinder::LxTBFinder
LxTBFinder()
Definition: LxTBTask.cxx:56
LxTbBinnedTrdStation::binSizeX
scaltype binSizeX
Definition: LxTBBinned.h:277
CbmMuchPoint::GetXOut
Double_t GetXOut() const
Definition: CbmMuchPoint.h:73
PrintTrigger
static void PrintTrigger(list< pair< timetype, timetype >> &signalRecoTimes, list< timetype > &signalMCTimes, const char *name, bool write_eff_for_inv_m=false)
Definition: LxTBTask.cxx:1471
LxTbBinnedFinder::TriggerTimeArray
Definition: LxTBBinned.h:451
CbmMCTrack::GetMotherId
Int_t GetMotherId() const
Definition: CbmMCTrack.h:71
LxTbBinnedFinder::triggerTimes_trd05_sign0_dist0
TriggerTimeArray triggerTimes_trd05_sign0_dist0
Definition: LxTBBinned.h:547
gMuonMass
static scaltype gMuonMass
Definition: LxTBMatEffs.h:19
LxTbBinnedStation::lastYBin
int lastYBin
Definition: LxTBBinned.h:217
CbmTrack::GetChiSq
Double_t GetChiSq() const
Definition: CbmTrack.h:58
CbmMCTrack::GetMass
Double_t GetMass() const
Mass of the associated particle.
Definition: CbmMCTrack.cxx:114
CbmMatch
Definition: CbmMatch.h:22
CbmMCTrack::GetStartX
Double_t GetStartX() const
Definition: CbmMCTrack.h:75
CbmMCDataManager.h
CbmTrdPoint::GetYOut
Double_t GetYOut() const
Definition: CbmTrdPoint.h:67
CbmTrack::GetParamLast
const FairTrackParam * GetParamLast() const
Definition: CbmTrack.h:62
LxTbBinnedFinder::fSignalParticle
SignalParticle * fSignalParticle
Definition: LxTBBinned.h:527
LxTBFinder::fStsDigis
TClonesArray * fStsDigis
Definition: LxTBTask.h:134
CUR_LAST_STATION
#define CUR_LAST_STATION
Definition: LxTBTask.h:33
CbmMuchPoint
Definition: CbmMuchPoint.h:21
LxTBFinder::fSignalParticle
const char * fSignalParticle
Definition: LxTBTask.h:148
CbmTrdPoint::GetZIn
Double_t GetZIn() const
Definition: CbmTrdPoint.h:65
LxTBFinder::PointDataHolder::x
Double_t x
Definition: LxTBTask.h:44
LxTBFinder::PointDataHolder::layerNumber
Int_t layerNumber
Definition: LxTBTask.h:52
LxTBFinder::isEvByEv
bool isEvByEv
Definition: LxTBTask.h:141
LxTBFinder::fTrdMCPoints
CbmMCDataArray * fTrdMCPoints
Definition: LxTBTask.h:127
LxTbBinnedFinder::Chain::points
LxTbBinnedPoint ** points
Definition: LxTBBinned.h:414
LxTBFinder::fMCTracks
std::vector< std::vector< TrackDataHolder > > fMCTracks
Definition: LxTBTask.h:139
CbmPixelHit::GetX
Double_t GetX() const
Definition: CbmPixelHit.h:83
triggerTimes_trd0_sign1_dist0
static list< pair< timetype, timetype > > triggerTimes_trd0_sign1_dist0
Definition: LxTBTask.cxx:399
CbmMatch::GetLink
const CbmLink & GetLink(Int_t i) const
Definition: CbmMatch.h:35
LxTbBinnedTrdStation::absorber
LxTbAbsorber absorber
Definition: LxTBBinned.h:281
CbmMatch::GetNofLinks
Int_t GetNofLinks() const
Definition: CbmMatch.h:38
LxTBFinder::hasTrd
bool hasTrd
Definition: LxTBTask.h:144
LxTBFinder::fTofDigis
TClonesArray * fTofDigis
Definition: LxTBTask.h:135
LxTbAbsorber::Z
scaltype Z
Definition: LxTBMatEffs.h:27
LxTbBinnedStation::lastXBin
int lastXBin
Definition: LxTBBinned.h:216
LxTbTYXBin
Definition: LxTBBinned.h:180
LxTbBinnedPoint::mcRefs
std::list< PointDesc > mcRefs
Definition: LxTBBinned.h:100
triggerTimes_trd05_sign0_dist0
static list< pair< timetype, timetype > > triggerTimes_trd05_sign0_dist0
Definition: LxTBTask.cxx:405
scaltype
#define scaltype
Definition: CbmGlobalTrackingDefs.h:17
LxTbBinnedFinder::SetTSBegin
void SetTSBegin(unsigned long long tsLowBound)
Definition: LxTBBinned.h:654
triggerTimes_trd0_sign0_dist0
static list< pair< timetype, timetype > > triggerTimes_trd0_sign0_dist0
Definition: LxTBTask.cxx:397
CbmPixelHit::GetY
Double_t GetY() const
Definition: CbmPixelHit.h:84
LxTBFinder::TrackDataHolder::isSignalLong
bool isSignalLong
Definition: LxTBTask.h:59
triggerTimes_trd1_sign0_dist0
static list< pair< timetype, timetype > > triggerTimes_trd1_sign0_dist0
Definition: LxTBTask.cxx:401
LxTbBinnedFinder::triggerTimes_trd0_sign1_dist1
TriggerTimeArray triggerTimes_trd0_sign1_dist1
Definition: LxTBBinned.h:542
LxTbBinnedStation::absorber
LxTbAbsorber absorber
Definition: LxTBBinned.h:224
LxTbBinnedFinder::minT
timetype minT
Definition: LxTBBinned.h:532
sqrt
friend F32vec4 sqrt(const F32vec4 &a)
Definition: L1/vectors/P4_F32vec4.h:41
CbmPixelHit::GetDx
Double_t GetDx() const
Definition: CbmPixelHit.h:85
CbmMCDataArray::Size
Int_t Size(Int_t fileNumber, Int_t eventNumber)
Definition: CbmMCDataArray.cxx:133
LxTbBinnedTrdStation::Zs
scaltype Zs[4]
Definition: LxTBBinned.h:269
LxTBFinder::Init
InitStatus Init()
Definition: LxTBTask.cxx:411
LxTBFinder::fMvdDigis
TClonesArray * fMvdDigis
Definition: LxTBTask.h:133
LxTbBinnedTrdStation::minX
scaltype minX
Definition: LxTBBinned.h:275
FindGeoChild
static void FindGeoChild(TGeoNode *node, const char *name, list< TGeoNode * > &results)
Definition: LxTBTask.cxx:126
RecoTrackData::eventId
Int_t eventId
Definition: LxTBMLTask.cxx:1663
LxTbBinnedFinder::nofTrackBins
int nofTrackBins
Definition: LxTBBinned.h:535
nof_ev_digis
static vector< int > nof_ev_digis(1000)
LxTbAbsorber::zCoord
scaltype zCoord
Definition: LxTBMatEffs.h:23
LxTbTYXBin::yxBins
LxTbYXBin * yxBins
Definition: LxTBBinned.h:181
LxTBTieTracks.h
LxTBFinder::TrackDataHolder::isPos
bool isPos
Definition: LxTBTask.h:60
triggerTimes_trd0_sign0_dist1
static list< pair< timetype, timetype > > triggerTimes_trd0_sign0_dist1
Definition: LxTBTask.cxx:398
LxTBFinder::PointDataHolder::t
Double_t t
Definition: LxTBTask.h:47
CbmMCTrack::GetPdgCode
Int_t GetPdgCode() const
Definition: CbmMCTrack.h:70
i
int i
Definition: L1/vectors/P4_F32vec4.h:25
shortSignalMCTimes
static list< timetype > shortSignalMCTimes
Definition: LxTBTask.cxx:394
LxTbBinnedFinder::SetSignalParticle
void SetSignalParticle(const char *name)
Definition: LxTBBinned.h:617
RecoTrackData
Definition: LxTBMLTask.cxx:1662
CbmTrdHit
data class for a reconstructed Energy-4D measurement in the TRD
Definition: CbmTrdHit.h:35
LxTbYXBin::use
bool use
Definition: LxTBBinned.h:164
NOF_SIGMAS
#define NOF_SIGMAS
Definition: LxTBBinned.h:52
CbmMCDataManager::InitBranch
CbmMCDataArray * InitBranch(const char *name)
Definition: CbmMCDataManager.cxx:106
LxTbBinnedFinder::Reconstruct
void Reconstruct()
Definition: LxTBBinned.h:844
max_ts_time
static Double_t max_ts_time
Definition: LxTBTask.cxx:960
CbmMuchPoint::GetDetectorId
Int_t GetDetectorId() const
Definition: CbmMuchPoint.h:69
CUR_TIMEBIN_LENGTH
#define CUR_TIMEBIN_LENGTH
Definition: LxTBTask.h:36
LxTbBinnedFinder::Chain
Definition: LxTBBinned.h:413
LxTBFinder::last_timebin
unsigned int last_timebin
Definition: LxTBTask.h:150
LxTBFinder::fMuchPoints
std::vector< std::vector< PointDataHolder > > fMuchPoints
Definition: LxTBTask.h:120
CbmTrdPoint::GetXOut
Double_t GetXOut() const
Definition: CbmTrdPoint.h:66
CbmTrdAddress::GetLayerId
static UInt_t GetLayerId(UInt_t address)
Return layer ID from address.
Definition: CbmTrdAddress.h:69
LxTbBinnedFinder::triggerTimes_trd0_sign0_dist1
TriggerTimeArray triggerTimes_trd0_sign0_dist1
Definition: LxTBBinned.h:540
CbmMCDataArray
Access to a MC data branch for time-based analysis.
Definition: CbmMCDataArray.h:35
LxTbXBin::points
std::list< LxTbBinnedPoint > points
Definition: LxTBBinned.h:145
CbmHit::GetRefId
Int_t GetRefId() const
Definition: CbmHit.h:72
CbmMCTrack::GetPx
Double_t GetPx() const
Definition: CbmMCTrack.h:72
triggerTimes_trd1_sign0_dist1
static list< pair< timetype, timetype > > triggerTimes_trd1_sign0_dist1
Definition: LxTBTask.cxx:402
triggerTimes_trd05_sign0_dist1
static list< pair< timetype, timetype > > triggerTimes_trd05_sign0_dist1
Definition: LxTBTask.cxx:406
LxTbYXBin::xBins
LxTbXBin * xBins
Definition: LxTBBinned.h:162
CbmMCTrack::GetPy
Double_t GetPy() const
Definition: CbmMCTrack.h:73
currentEventN
static Int_t currentEventN
Definition: LxTBTask.cxx:955
LxTBFinder::fMuchPixelHits
TClonesArray * fMuchPixelHits
Definition: LxTBTask.h:122
LxTBFinder::HandleGeometry
void HandleGeometry()
Definition: LxTBTask.cxx:138
CbmMatch.h
LxTBBinndedLayer::maxDx
scaltype maxDx
Definition: LxTBTieTracks.h:41
LxTBFinder::Finish
void Finish()
Definition: LxTBTask.cxx:1525
LxTBFinder::PointDataHolder::pointId
Int_t pointId
Definition: LxTBTask.h:50
LxTbBinnedPoint::isTrd
bool isTrd
Definition: LxTBBinned.h:91
LxTbBinnedTrdStation::maxX
scaltype maxX
Definition: LxTBBinned.h:276
LxTBTask.h
CbmPixelHit::GetDy
Double_t GetDy() const
Definition: CbmPixelHit.h:86
LxTbBinnedFinder::SignalParticle
Definition: LxTBBinned.h:519
LxTBFinder::PointDataHolder::z
Double_t z
Definition: LxTBTask.h:46
CbmHit::GetTimeError
Double_t GetTimeError() const
Definition: CbmHit.h:76
triggerTimes_trd0_sign1_dist1
static list< pair< timetype, timetype > > triggerTimes_trd0_sign1_dist1
Definition: LxTBTask.cxx:400
CbmStsTrack::GetNofHits
virtual Int_t GetNofHits() const
Definition: CbmStsTrack.h:76
min_ts_time
static Double_t min_ts_time
Definition: LxTBTask.cxx:959
LxTbBinnedFinder::triggerEventNumber
std::set< Int_t > triggerEventNumber
Definition: LxTBBinned.h:552
CbmCluster::GetNofDigis
Int_t GetNofDigis() const
Number of digis in cluster.
Definition: CbmCluster.h:69
LxTbXBin
Definition: LxTBBinned.h:144
LxTBFinder::AddHit
void AddHit(const CbmPixelHit *hit, Int_t stationNumber, Int_t refId, bool isTrd)
Definition: LxTBTask.cxx:965
CbmMuchPoint::GetYOut
Double_t GetYOut() const
Definition: CbmMuchPoint.h:74
LxTbAbsorber::radLength
scaltype radLength
Definition: LxTBMatEffs.h:25
LxTbBinnedFinder::triggerTimes_trd1_sign1_dist1
TriggerTimeArray triggerTimes_trd1_sign1_dist1
Definition: LxTBBinned.h:546
CbmMCTrack::GetStartZ
Double_t GetStartZ() const
Definition: CbmMCTrack.h:77
LxTBFinder::useTrd
bool useTrd
Definition: LxTBTask.h:145
CbmStsHit
data class for a reconstructed 3-d hit in the STS
Definition: CbmStsHit.h:31
LxTbXBin::use
bool use
Definition: LxTBBinned.h:146
tsStartTime
static unsigned long long tsStartTime
Definition: LxTBTask.cxx:956
LxTBFinder::TrackDataHolder::pointInds
Int_t pointInds[CUR_NOF_STATIONS]
Definition: LxTBTask.h:56
triggerTimes_trd05_sign1_dist1
static list< pair< timetype, timetype > > triggerTimes_trd05_sign1_dist1
Definition: LxTBTask.cxx:408
RecoTrackData::RecoTrackData
RecoTrackData(Int_t eId, Int_t tId)
Definition: LxTBTask.cxx:1460
LxTbBinnedFinder::Chain::highMom
bool highMom
Definition: LxTBBinned.h:417
LxTbBinnedStation::stationNumber
int stationNumber
Definition: LxTBBinned.h:211
CbmMuchGeoScheme::GetLayerIndex
static Int_t GetLayerIndex(Int_t address)
Definition: CbmMuchGeoScheme.h:71
CbmMuchGeoScheme::GetStationIndex
static Int_t GetStationIndex(Int_t address)
Definition: CbmMuchGeoScheme.h:68
LxTBFinder::PointDataHolder::y
Double_t y
Definition: LxTBTask.h:45
LxTbBinnedFinder::TriggerTimeArray::triggerTimeBins
std::list< std::pair< timetype, timetype > > * triggerTimeBins
Definition: LxTBBinned.h:516
LxTbBinnedFinder
Definition: LxTBBinned.h:336
RTDLess
Definition: LxTBMLTask.cxx:1669
LxTBFinder::recoTracks
std::list< LxTbBinnedFinder::Chain * > recoTracks
Definition: LxTBTask.h:143
mcTracks
static vector< vector< QAMCTrack > > mcTracks
Definition: CbmTofHitFinderTBQA.cxx:112
nof_digis
static int nof_digis
Definition: LxTBTask.cxx:1295
LxTbBinnedStation::binSizeX
scaltype binSizeX
Definition: LxTBBinned.h:220
LxTBFinder
Definition: LxTBTask.h:40
LxTbBinnedFinder::triggerTimes_trd1_sign0_dist1
TriggerTimeArray triggerTimes_trd1_sign0_dist1
Definition: LxTBBinned.h:544
CbmMCDataArray::Get
TObject * Get(const CbmLink *lnk)
Definition: CbmMCDataArray.h:47
CbmHit::GetTime
Double_t GetTime() const
Definition: CbmHit.h:75
LxTbBinnedStation::minX
scaltype minX
Definition: LxTBBinned.h:218
LxTbBinnedFinder::triggerTimes_trd0_sign1_dist0
TriggerTimeArray triggerTimes_trd0_sign1_dist0
Definition: LxTBBinned.h:541
CbmTrack::GetHitIndex
Int_t GetHitIndex(Int_t iHit) const
Definition: CbmTrack.h:54
CbmHit::GetAddress
Int_t GetAddress() const
Definition: CbmHit.h:73
LxTBFinder::TrackDataHolder::trdPointInds
Int_t trdPointInds[CUR_NOF_TRD_LAYERS]
Definition: LxTBTask.h:57
LxTBFinder::PointDataHolder::trackId
Int_t trackId
Definition: LxTBTask.h:49
triggerTimes_trd05_sign1_dist0
static list< pair< timetype, timetype > > triggerTimes_trd05_sign1_dist0
Definition: LxTBTask.cxx:407
LxTbBinnedFinder::triggerTimes_trd0_sign0_dist0
TriggerTimeArray triggerTimes_trd0_sign0_dist0
Definition: LxTBBinned.h:539
CUR_NOF_TRD_LAYERS
#define CUR_NOF_TRD_LAYERS
Definition: LxTBTask.h:23
LxTbBinnedFinder::TriggerTimeArray::nofTimebins
int nofTimebins
Definition: LxTBBinned.h:513
LxTbBinnedStation::binSizeY
scaltype binSizeY
Definition: LxTBBinned.h:223
CbmTrdHit.h
Class for hits in TRD detector.
LxTBFinder::useAsciiSig
bool useAsciiSig
Definition: LxTBTask.h:147
LxTbBinnedFinder::particleDescs
static SignalParticle particleDescs[]
Definition: LxTBBinned.h:526
LxTBFinder::PointDataHolder
Definition: LxTBTask.h:43
CUR_NOF_STATIONS
#define CUR_NOF_STATIONS
Definition: LxTBTask.h:32
LxTbBinnedPoint::y
scaltype y
Definition: LxTBBinned.h:81
LxTBFinder::PointDataHolder::stationNumber
Int_t stationNumber
Definition: LxTBTask.h:51
LXTB_EMU_TS
#define LXTB_EMU_TS
Definition: LxTBDefinitions.h:21
LxTbBinnedPoint::PointDesc
Definition: LxTBBinned.h:94
CbmTrack::GetHitType
HitType GetHitType(Int_t iHit) const
Definition: CbmTrack.h:55
gElectronMass
static scaltype gElectronMass
Definition: LxTBMatEffs.h:20
CbmTrdPoint::GetZOut
Double_t GetZOut() const
Definition: CbmTrdPoint.h:68
LxTBBinnedDetector
Definition: LxTBTieTracks.h:200
LxTbBinnedStation::z
scaltype z
Definition: LxTBBinned.h:212
CbmTrdPoint
Definition: CbmTrdPoint.h:23
CbmMCDataManager
Task class creating and managing CbmMCDataArray objects.
Definition: CbmMCDataManager.h:27
LxTBFinder::Exec
void Exec(Option_t *opt)
Definition: LxTBTask.cxx:1304
LxTBFinder::fEventTimes
std::vector< Double_t > fEventTimes
Definition: LxTBTask.h:152
LxTbBinnedStation::maxY
scaltype maxY
Definition: LxTBBinned.h:222
LxTbBinnedFinder::triggerTimes_trd1_sign1_dist0
TriggerTimeArray triggerTimes_trd1_sign1_dist0
Definition: LxTBBinned.h:545
LxTbBinnedFinder::trdStation
LxTbBinnedTrdStation trdStation
Definition: LxTBBinned.h:531
LxTbBinnedFinder::triggerTimes_trd05_sign0_dist1
TriggerTimeArray triggerTimes_trd05_sign0_dist1
Definition: LxTBBinned.h:548
LxTBFinder::fMuchClusters
TClonesArray * fMuchClusters
Definition: LxTBTask.h:123
LxTBFinder::fMuchPixelDigiMatches
TClonesArray * fMuchPixelDigiMatches
Definition: LxTBTask.h:124
LxTBFinder::PointDataHolder::eventId
Int_t eventId
Definition: LxTBTask.h:48
LxTbTYXBin::use
bool use
Definition: LxTBBinned.h:183
CbmMCTrack::GetStartY
Double_t GetStartY() const
Definition: CbmMCTrack.h:76
LxTbBinnedTrdStation::binSizeY
scaltype binSizeY
Definition: LxTBBinned.h:280
LxTBFinder::fTrdHits
TClonesArray * fTrdHits
Definition: LxTBTask.h:128
LxTBFinder::fTrdDigiMatches
TClonesArray * fTrdDigiMatches
Definition: LxTBTask.h:130
triggerTimes_trd1_sign1_dist0
static list< pair< timetype, timetype > > triggerTimes_trd1_sign1_dist0
Definition: LxTBTask.cxx:403
CbmMCTrack.h
v
__m128 v
Definition: L1/vectors/P4_F32vec4.h:1
LxTbBinnedTrdStation::lastXBin
int lastXBin
Definition: LxTBBinned.h:273
CbmTrdPoint::GetXIn
Double_t GetXIn() const
Definition: CbmTrdPoint.h:63
LxTbBinnedPoint::dt
timetype dt
Definition: LxTBBinned.h:84
timetype
#define timetype
Definition: CbmGlobalTrackingDefs.h:18
CbmCluster
Base class for cluster objects.
Definition: CbmCluster.h:26
LxTbBinnedStation::maxX
scaltype maxX
Definition: LxTBBinned.h:219
LxTbYXBin
Definition: LxTBBinned.h:161
middleSignalMCTimes
static list< timetype > middleSignalMCTimes
Definition: LxTBTask.cxx:396
LxTbAbsorber::width
scaltype width
Definition: LxTBMatEffs.h:24
LxTBBinndedLayer::maxDy
scaltype maxDy
Definition: LxTBTieTracks.h:42
CbmMCTrack
Definition: CbmMCTrack.h:34
kSTSHIT
@ kSTSHIT
Definition: CbmHit.h:20
speedOfLight
Double_t speedOfLight
CbmMuchPoint::GetYIn
Double_t GetYIn() const
Definition: CbmMuchPoint.h:71
x
Double_t x
Definition: CbmMvdSensorDigiToHitTask.cxx:68
LxTBBinndedLayer::maxDt
timetype maxDt
Definition: LxTBTieTracks.h:43
CbmTrdPoint::GetModuleAddress
Int_t GetModuleAddress() const
Definition: CbmTrdPoint.h:76
fabs
friend F32vec4 fabs(const F32vec4 &a)
Definition: L1/vectors/P4_F32vec4.h:60
LxTbBinnedFinder::triggerTimes_trd05_sign1_dist1
TriggerTimeArray triggerTimes_trd05_sign1_dist1
Definition: LxTBBinned.h:550
LxTbAbsorber::A
scaltype A
Definition: LxTBMatEffs.h:28
m
__m128 m
Definition: L1/vectors/P4_F32vec4.h:26
CbmMuchPixelHit.h
Class for pixel hits in MUCH detector.
y
Double_t y
Definition: CbmMvdSensorDigiToHitTask.cxx:68
LxTbBinnedStation::minY
scaltype minY
Definition: LxTBBinned.h:221
LxTbBinnedFinder::SignalParticle::fPdgCode
int fPdgCode
Definition: LxTBBinned.h:521
LxTbBinnedFinder::triggerTimes_trd05_sign1_dist0
TriggerTimeArray triggerTimes_trd05_sign1_dist0
Definition: LxTBBinned.h:549
CbmMuchPoint::GetXIn
Double_t GetXIn() const
Definition: CbmMuchPoint.h:70
CbmPixelHit
Definition: CbmPixelHit.h:21
longSignalMCTimes
static list< timetype > longSignalMCTimes
Definition: LxTBTask.cxx:395
LXTB_QA
#define LXTB_QA
Definition: LxTBDefinitions.h:18
LxTBFinder::fTrdPoints
std::vector< std::vector< PointDataHolder > > fTrdPoints
Definition: LxTBTask.h:126
RTDLess::operator()
bool operator()(const RecoTrackData &x, const RecoTrackData &y) const
Definition: LxTBTask.cxx:1464
LxTBFinder::fTrdClusters
TClonesArray * fTrdClusters
Definition: LxTBTask.h:129
CbmMuchPixelHit
Definition: CbmMuchPixelHit.h:17
ClassImp
ClassImp(LxTBFinder) Double_t speedOfLight=0
CbmCluster.h
Base class for cluster objects.
fullDuration
static long fullDuration
Definition: CbmTofTBClusterizer.cxx:392
LxTbBinnedFinder::recoTracks
std::list< Chain * > * recoTracks
Definition: LxTBBinned.h:534
LxTBFinder::fFinder
LxTbBinnedFinder * fFinder
Definition: LxTBTask.h:142
CbmMuchGeoScheme.h
RecoTrackData::trackId
Int_t trackId
Definition: LxTBMLTask.cxx:1664
CbmMCTrack::GetEnergy
Double_t GetEnergy() const
Definition: CbmMCTrack.h:165
LxTbBinnedPoint::t
timetype t
Definition: LxTBBinned.h:83
LxTbBinnedTrdStation::lastYBin
int lastYBin
Definition: LxTBBinned.h:274
LxTbBinnedFinder::Clear
void Clear()
Definition: LxTBBinned.h:628
CbmStsTrack
Definition: CbmStsTrack.h:37
LxTbBinnedPoint
Definition: LxTBBinned.h:78
LxTbBinnedFinder::SignalParticle::fHasTrd
bool fHasTrd
Definition: LxTBBinned.h:523
LxTBFinder::TrackDataHolder::isSignalShort
bool isSignalShort
Definition: LxTBTask.h:58
HasTrd
static bool HasTrd()
Definition: LxTBTask.cxx:106
LxTbBinnedTrdStation::maxY
scaltype maxY
Definition: LxTBBinned.h:279
CbmTrdPoint::GetYIn
Double_t GetYIn() const
Definition: CbmTrdPoint.h:64
CbmCluster::GetDigi
Int_t GetDigi(Int_t index) const
Get digi at position index.
Definition: CbmCluster.h:76
LxTbBinnedFinder::triggerTimes_trd1_sign0_dist0
TriggerTimeArray triggerTimes_trd1_sign0_dist0
Definition: LxTBBinned.h:543
LxTBFinder::fMuchMCPoints
CbmMCDataArray * fMuchMCPoints
Definition: LxTBTask.h:121
LxTbBinnedTrdStation::minY
scaltype minY
Definition: LxTBBinned.h:278
LxTbBinnedStation::tyxBins
LxTbTYXBin * tyxBins
Definition: LxTBBinned.h:229
ts_points
static list< LxTbBinnedPoint > ts_points
Definition: LxTBTask.cxx:961
CbmMCTrack::GetP
Double_t GetP() const
Definition: CbmMCTrack.h:100
LxTbBinnedTrdStation::tyxBinsArr
LxTbTYXBin * tyxBinsArr[4]
Definition: LxTBBinned.h:286
LxTbBinnedPoint::x
scaltype x
Definition: LxTBBinned.h:79
LxTBFinder::fNEvents
Int_t fNEvents
Definition: LxTBTask.h:151
CbmMCTrack::GetPz
Double_t GetPz() const
Definition: CbmMCTrack.h:74
LxTbBinnedPoint::stationNumber
Int_t stationNumber
Definition: LxTBBinned.h:92
LxTBFinder::nof_timebins
unsigned int nof_timebins
Definition: LxTBTask.h:149
LxTbBinnedFinder::stations
LxTbBinnedStation * stations
Definition: LxTBBinned.h:529
LxTBBinndedLayer
Definition: LxTBTieTracks.h:23
LxTbBinnedFinder::Init
void Init()
Definition: LxTBBinned.h:656
LxTBFinder::TrackDataHolder
Definition: LxTBTask.h:55
SpliceTriggerings
static void SpliceTriggerings(list< pair< timetype, timetype >> &out, LxTbBinnedFinder::TriggerTimeArray &in)
Definition: LxTBTask.cxx:1298
triggerTimes_trd1_sign1_dist1
static list< pair< timetype, timetype > > triggerTimes_trd1_sign1_dist1
Definition: LxTBTask.cxx:404
CbmStsHit.h
Data class for a reconstructed hit in the STS.
LxTbAbsorber::rho
scaltype rho
Definition: LxTBMatEffs.h:26
CbmTrdHit::GetPlaneId
Int_t GetPlaneId() const
Inherited from CbmBaseHit.
Definition: CbmTrdHit.h:73