CbmRoot
CbmMvdDetector.cxx
Go to the documentation of this file.
1 // -------------------------------------------------------------------------
2 // ----- CbmMvdDetector source file -----
3 // ----- Created 31/01/11 by M. Deveaux -----
4 // -------------------------------------------------------------------------
5 
6 #include "CbmMvdDetector.h"
7 
9 #include "CbmMvdDigi.h"
10 #include "CbmMvdSensor.h"
11 #include "plugins/CbmMvdSensorPlugin.h"
12 #include "plugins/buffers/CbmMvdSensorBuffer.h"
13 #include "plugins/buffers/CbmMvdSensorFrameBuffer.h"
14 #include "plugins/buffers/CbmMvdSensorTrackingBuffer.h"
15 #include "plugins/tasks/CbmMvdSensorClusterfinderTask.h" //khun
16 #include "plugins/tasks/CbmMvdSensorDigiToHitTask.h"
17 #include "plugins/tasks/CbmMvdSensorDigitizerTBTask.h"
18 #include "plugins/tasks/CbmMvdSensorDigitizerTask.h"
19 #include "plugins/tasks/CbmMvdSensorFindHitTask.h"
20 #include "plugins/tasks/CbmMvdSensorHitfinderTask.h" //khun
21 #include "plugins/tasks/CbmMvdSensorTask.h"
22 #include "tools/CbmMvdGeoHandler.h"
23 
24 #include "CbmDigiManager.h"
25 
27 #include "FairLogger.h"
28 
30 #include "TGeoBBox.h"
31 #include "TGeoMatrix.h"
32 #include "TGeoVolume.h"
33 #include "TString.h"
34 
36 #include <iostream>
37 
38 using std::cout;
39 using std::endl;
40 
41 //_____________________________________________________________________________
42 CbmMvdDetector* CbmMvdDetector::fInstance = 0;
43 
44 CbmMvdSensorTyp CbmMvdDetector::fSensorTyp = CbmMvdSensorTyp::MIMOSIS;
45 
46 //_____________________________________________________________________________
47 CbmMvdDetector* CbmMvdDetector::Instance() {
48  if (fInstance)
49  return fInstance;
50  else {
51  fInstance = new CbmMvdDetector("A");
52  CbmMvdGeoHandler* mvdHandler = new CbmMvdGeoHandler();
53  mvdHandler->SetSensorTyp(fSensorTyp);
54  mvdHandler->Init();
55  mvdHandler->Fill();
56  mvdHandler->PrintGeoParameter();
57  return fInstance;
58  }
59 }
60 
61 // ----- Default constructor -------------------------------------------
62 CbmMvdDetector::CbmMvdDetector()
63  : TNamed()
64  , fSensorArray(nullptr)
65  , fSensorIDArray(nullptr)
66  , fPluginCount(0)
67  , foutput(nullptr)
68  , foutputHits(nullptr)
69  , foutputDigis(nullptr)
70  , foutputCluster(nullptr)
71  , //khun
72  foutputDigiMatchs(nullptr)
73  , foutputHitMatchs(nullptr)
74  , fcurrentEvent(nullptr)
75  , fepsilon()
76  , fDigiPlugin(-1)
77  , fHitPlugin(-1)
78  , fClusterPlugin(-1)
79  , fSensorArrayFilled(kFALSE)
80  , initialized(kFALSE)
81  , fFinished(kFALSE)
82  , fName("")
83  , fParameter(nullptr) {
84 
85  Fatal(GetName(), " - Do not use standard constructor");
86 }
87 // -------------------------------------------------------------------------
88 
89 
90 // ----- Standard constructor ------------------------------------------
91 CbmMvdDetector::CbmMvdDetector(const char* name)
92  : TNamed()
93  , fSensorArray(new TClonesArray("CbmMvdSensor", 10))
94  , fSensorIDArray(nullptr)
95  , fPluginCount(0)
96  , foutput(nullptr)
97  , foutputHits(nullptr)
98  , foutputDigis(nullptr)
99  , foutputCluster(nullptr)
100  , //khun
101  foutputDigiMatchs(nullptr)
102  , foutputHitMatchs(nullptr)
103  , fcurrentEvent(nullptr)
104  , fepsilon()
105  , fDigiPlugin(-1)
106  , fHitPlugin(-1)
107  , fClusterPlugin(-1)
108  , fSensorArrayFilled(kFALSE)
109  , initialized(kFALSE)
110  , fFinished(kFALSE)
111  , fName(name)
112  , fParameter(nullptr) {
113 
114  if (fInstance) {
115  Fatal(GetName(), " - Error, singleton does already exist.");
116  } else {
117  fInstance = this;
118  };
119  fepsilon[0] = fepsilon[1] = fepsilon[2] = 0;
120  fName = name;
121 }
122 // -------------------------------------------------------------------------
123 
124 
125 // ----- Destructor ----------------------------------------------------
126 CbmMvdDetector::~CbmMvdDetector() {}
127 //-----------------------------------------------------------------------
128 
129 // -------Setters -----------------------------------------------------
130 
131 void CbmMvdDetector::AddSensor(TString clearName,
132  TString fullName,
133  TString nodeName,
134  CbmMvdSensorDataSheet* sensorData,
135  Int_t sensorNr,
136  Int_t volumeId,
137  Double_t sensorStartTime,
138  Int_t stationNr) {
145  TString myname;
146 
147  if (fSensorArrayFilled) {
148  Fatal(GetName(), " - Error, must add all sensors before adding plugins.");
149  }
150 
151 
152  Int_t nSensors = fSensorArray->GetEntriesFast();
153 
154  myname = clearName;
155  myname += nSensors;
156 
157  new ((*fSensorArray)[nSensors]) CbmMvdSensor(myname,
158  sensorData,
159  fullName,
160  nodeName,
161  sensorNr,
162  volumeId,
163  sensorStartTime);
164  //CbmMvdSensor(const char* name, CbmMvdSensorDataSheet* dataSheet, TString volName,
165  //TString nodeName, Int_t stationNr, Int_t volumeId, Double_t sensorStartTime);
166 
167  CbmMvdSensor* sensor = (CbmMvdSensor*) fSensorArray->At(nSensors);
168  sensor->SetDataSheet(sensorData);
169  sensor->SetStation(stationNr);
170 
171  Float_t misalignment[3], randArray[3];
172  // TRandom3* rand = new TRandom3(0);
173  gRandom->RndmArray(3, randArray);
174  misalignment[0] = ((2 * randArray[0]) - 1) * fepsilon[0];
175  misalignment[1] = ((2 * randArray[0]) - 1) * fepsilon[1];
176  misalignment[2] = ((2 * randArray[0]) - 1) * fepsilon[2];
177  sensor->SetMisalignment(misalignment);
178  LOG(debug1) << "new sensor " << myname
179  << " to detector added at station: " << stationNr;
180 }
181 
182 // ----------------------------------------------------------------------
183 
184 
185 //-----------------------------------------------------------------------
186 void CbmMvdDetector::AddPlugin(CbmMvdSensorPlugin* plugin) {
191  fSensorArrayFilled = kTRUE;
192 
193  CbmMvdSensor* sensor;
194  Int_t nSensors = fSensorArray->GetEntriesFast();
195  const TString digitizername = "CbmMvdSensorDigitizerTask";
196  const TString digitizerTBname = "CbmMvdSensorDigitizerTBTask";
197  const TString findername = "CbmMvdSensorFindHitTask";
198  //const TString framename = "CbmMvdSensorFrameBuffer";
199  //const TString trackingname = "CbmMvdSensorTrackingBuffer";
200  const TString clustername = "CbmMvdSensorClusterfinderTask"; //khun
201  const TString hitname = "CbmMvdSensorHitfinderTask"; //khun
202  const TString digitohitname = "CbmMvdSensorDigiToHitTask";
203 
204 
205  for (Int_t i = 0; i < nSensors; i++) {
206 
207 
208  if (plugin->GetPluginType() == task) {
209 
210  if (plugin->ClassName() == digitizername) {
211  CbmMvdSensorDigitizerTask* digiTask = new CbmMvdSensorDigitizerTask();
212  sensor = (CbmMvdSensor*) fSensorArray->At(i);
213  sensor->AddPlugin(digiTask);
214  sensor->SetDigiPlugin(fPluginCount);
215 
216  //cout << "Adding Task CbmMvdSensorDigitizerTask at Sensor " << sensor->GetName() << endl;
217  } else if (plugin->ClassName() == digitizerTBname) {
218  CbmMvdSensorDigitizerTBTask* digiTask =
219  new CbmMvdSensorDigitizerTBTask();
220  sensor = (CbmMvdSensor*) fSensorArray->At(i);
221  sensor->AddPlugin(digiTask);
222  sensor->SetDigiPlugin(fPluginCount);
223 
224  //cout << "Adding Task CbmMvdSensorDigitizerTask at Sensor " << sensor->GetName() << endl;
225  } else if (plugin->ClassName() == findername) {
226  CbmMvdSensorFindHitTask* findTask = new CbmMvdSensorFindHitTask();
227  sensor = (CbmMvdSensor*) fSensorArray->At(i);
228  sensor->AddPlugin(findTask);
229  sensor->SetHitPlugin(fPluginCount);
230  // cout << "Adding Task CbmMvdSensorFindHitTask at Sensor " << sensor->GetName() << endl;
231  }
232 
233  //Re-enable cluster and hit finder in addition to khun
234  else if (plugin->ClassName() == clustername) {
235  CbmMvdSensorClusterfinderTask* clusterTask =
236  new CbmMvdSensorClusterfinderTask();
237  sensor = (CbmMvdSensor*) fSensorArray->At(i);
238  sensor->AddPlugin(clusterTask);
239  sensor->SetClusterPlugin(fPluginCount);
240  // cout << "Adding Task CbmMvdSensorClusterfinderTask at Sensor " << sensor->GetName() << endl;
241  } else if (plugin->ClassName() == hitname) {
242  CbmMvdSensorHitfinderTask* hitTask = new CbmMvdSensorHitfinderTask();
243  sensor = (CbmMvdSensor*) fSensorArray->At(i);
244  sensor->AddPlugin(hitTask);
245  sensor->SetHitPlugin(fPluginCount);
246  // cout << "Adding Task CbmMvdSensorHitfinderTask at Sensor " << sensor->GetName() << endl;
247  }
248  //end: re-enable cluster and hit finder in addition to khun
249 
250  else if (plugin->ClassName() == digitohitname) {
251  CbmMvdSensorDigiToHitTask* digitohitTask =
252  new CbmMvdSensorDigiToHitTask();
253  sensor = (CbmMvdSensor*) fSensorArray->At(i);
254  sensor->AddPlugin(digitohitTask);
255  sensor->SetHitPlugin(fPluginCount);
256  // cout << "Adding Task CbmMvdSensorClusterfinderTask at Sensor " << sensor->GetName() << endl;
257  } else {
258  cout << endl << "task not included yet, adding standart task." << endl;
259  CbmMvdSensorTask* task = new CbmMvdSensorTask();
260  sensor = (CbmMvdSensor*) fSensorArray->At(i);
261  sensor->AddPlugin(task);
262  }
263  //data parallelizm requires that each sensor get its own task object
264 
265  }
266 
267  else {
268  cout << "Invalide" << endl;
269  }
270  };
271  fPluginCount++;
272 };
273 
274 //----------------------------------------------------------------------
275 
276 
277 //-----------------------------------------------------------------------
278 void CbmMvdDetector::Init() {
279 
287  if (!initialized) {
288  foutput = new TClonesArray("CbmMvdPoint", 1000);
289  fcurrentEvent = new TClonesArray("CbmMvdPoint", 1000);
290  foutputDigis = new TClonesArray("CbmMvdDigi", 1000);
291  foutputDigiMatchs = new TClonesArray("CbmMatch", 1000);
292  foutputHits = new TClonesArray("CbmMvdHit", 1000);
293  foutputCluster = new TClonesArray("CbmMvdCluster", 1000); //khun
294  }
295 
296  Int_t nSensors = fSensorArray->GetEntriesFast();
297  if (nSensors <= 0)
298  LOG(fatal) << "CbmMvdDetector could not load Sensors from Geometry!";
299  CbmMvdSensor* sensor;
300 
301  for (Int_t j = 0; j < nSensors; j++) {
302 
303  sensor = (CbmMvdSensor*) fSensorArray->At(j);
304  LOG(debug1) << "Init Sensor " << sensor->GetName();
305  sensor->Init();
306  }
307 
308  initialized = kTRUE;
309 }
310 //-----------------------------------------------------------------------
311 
312 //-----------------------------------------------------------------------
313 void CbmMvdDetector::ShowDebugHistos() {
314 
315  Int_t nSensors = fSensorArray->GetEntriesFast();
316  CbmMvdSensor* sensor;
317 
318  for (Int_t j = 0; j < nSensors; j++) {
319  sensor = (CbmMvdSensor*) fSensorArray->At(j);
320  sensor->ShowDebugHistos();
321  }
322 }
323 //-----------------------------------------------------------------------
324 
325 //-----------------------------------------------------------------------
326 void CbmMvdDetector::SetProduceNoise() {
327  Int_t nSensors = fSensorArray->GetEntriesFast();
328  CbmMvdSensor* sensor;
329 
330  for (Int_t j = 0; j < nSensors; j++) {
331  sensor = (CbmMvdSensor*) fSensorArray->At(j);
332  sensor->SetProduceNoise();
333  }
334 }
335 //-----------------------------------------------------------------------
336 
337 //-----------------------------------------------------------------------
338 void CbmMvdDetector::SendInput(TClonesArray* input) {
349  CbmMvdPoint* point;
350  Int_t nEntries = input->GetEntriesFast();
351  Int_t nSensors = fSensorArray->GetEntriesFast();
352  CbmMvdSensor* sensor;
353  Bool_t send = kFALSE;
354  for (Int_t i = 0; i < nEntries; i++) {
355  point = (CbmMvdPoint*) input->At(i);
356  point->SetPointId(i);
357  for (Int_t k = 0; k < nSensors; k++) {
358  sensor = (CbmMvdSensor*) fSensorArray->At(k);
359 
360  if (point->GetDetectorID() == sensor->GetDetectorID()) {
361  sensor->SendInput(point);
362  send = true;
363  }
364  }
365  if (!send)
366  LOG(warn) << "Point not send to any sensor: " << point->GetDetectorID();
367  }
368 }
369 //-----------------------------------------------------------------------
370 
371 
372 //-----------------------------------------------------------------------
373 void CbmMvdDetector::SendInputDigis(CbmDigiManager* digiMan) {
382  assert(digiMan);
383  assert(digiMan->IsPresent(ECbmModuleId::kMvd));
384 
385 
386  CbmMvdDigi* digi;
387 
388  Int_t nSensors = fSensorArray->GetEntriesFast();
389  Int_t nEntries = digiMan->GetNofDigis(ECbmModuleId::kMvd);
390  CbmMvdSensor* sensor;
391  for (Int_t i = 0; i < nEntries; i++) {
392  digi = new CbmMvdDigi(*(digiMan->Get<CbmMvdDigi>(i)));
393  digi->SetRefId(i);
394  for (Int_t k = 0; k < nSensors; k++) {
395  sensor = (CbmMvdSensor*) fSensorArray->At(k);
396 
397  if (digi->GetDetectorId() == sensor->GetDetectorID()) {
398  sensor->SendInputDigi(digi);
399  }
400  }
401  }
402 }
403 //-----------------------------------------------------------------------
404 
405 
406 //-----------------------------------------------------------------------
407 void CbmMvdDetector::SendInputDigis(TClonesArray* digis) {
418  CbmMvdDigi* digi;
419 
420  Int_t nSensors = fSensorArray->GetEntriesFast();
421  Int_t nEntries = digis->GetEntriesFast();
422  CbmMvdSensor* sensor;
423  for (Int_t i = 0; i < nEntries; i++) {
424  digi = (CbmMvdDigi*) digis->At(i);
425  digi->SetRefId(i);
426  for (Int_t k = 0; k < nSensors; k++) {
427  sensor = (CbmMvdSensor*) fSensorArray->At(k);
428 
429  if (digi->GetDetectorId() == sensor->GetDetectorID()) {
430  sensor->SendInputDigi(digi);
431  }
432  }
433  }
434 }
435 //-----------------------------------------------------------------------
436 
437 //-----------------------------------------------------------------------
438 void CbmMvdDetector::SendInputDigisToHits(TClonesArray* digis) {
449  CbmMvdDigi* digi;
450  Int_t nEntries = digis->GetEntriesFast();
451  Int_t nSensors = fSensorArray->GetEntriesFast();
452  CbmMvdSensor* sensor;
453  for (Int_t i = 0; i < nEntries; i++) {
454  digi = (CbmMvdDigi*) digis->At(i);
455  digi->SetRefId(i);
456  for (Int_t k = 0; k < nSensors; k++) {
457  sensor = (CbmMvdSensor*) fSensorArray->At(k);
458 
459  if (digi->GetDetectorId() == sensor->GetDetectorID()) {
460  sensor->SendInputDigiToHit(digi);
461  }
462  }
463  }
464 }
465 //-----------------------------------------------------------------------
466 
467 
468 //-----------------------------------------------------------------------
469 void CbmMvdDetector::SendInputCluster(TClonesArray* clusters) {
470 
479  CbmMvdCluster* cluster;
480  Int_t nEntries = clusters->GetEntriesFast();
481  Int_t nSensors = fSensorArray->GetEntriesFast();
482  CbmMvdSensor* sensor;
483  for (Int_t i = 0; i < nEntries; i++) {
484  cluster = (CbmMvdCluster*) clusters->At(i);
485  cluster->SetRefId(i);
486  for (Int_t k = 0; k < nSensors; k++) {
487  sensor = (CbmMvdSensor*) fSensorArray->At(k);
488 
489  if (cluster->GetSensorNr() == sensor->GetSensorNr()) {
490  LOG(debug2) << "Sending cluster to sensor: " << sensor->GetSensorNr();
491  sensor->SendInputCluster(cluster);
492  }
493  }
494  }
495 }
496 //-----------------------------------------------------------------------
497 
498 //-----------------------------------------------------------------------
499 void CbmMvdDetector::ExecChain() {
506  foutput->Clear();
507  fcurrentEvent->Clear();
508  foutputDigis->Clear();
509  foutputDigiMatchs->Clear();
510  foutputHits->Clear();
511  foutputCluster->Clear(); //khun
512 
513  Int_t nSensors = fSensorArray->GetEntriesFast();
514  CbmMvdSensor* sensor;
515  for (Int_t i = 0; i < nSensors; i++) {
516  sensor = (CbmMvdSensor*) fSensorArray->At(i);
517  //cout << "I------ Send Chain to " << sensor->GetName() << endl;
518  sensor->ExecChain();
519  //cout << "I------ finished Chain at "<< sensor->GetName() <<endl<< endl;
520  };
521 }
522 
523 //-----------------------------------------------------------------------
524 
525 
526 //-----------------------------------------------------------------------
527 void CbmMvdDetector::Exec(UInt_t nLevel) {
534  foutput->Clear();
535  fcurrentEvent->Clear();
536  foutputDigis->Clear();
537  foutputDigiMatchs->Clear();
538  foutputHits->Clear();
539  foutputCluster->Clear(); //khun
540  Int_t nSensors = fSensorArray->GetEntriesFast();
541  CbmMvdSensor* sensor;
542  for (Int_t i = 0; i < nSensors; i++) {
543  sensor = (CbmMvdSensor*) fSensorArray->At(i);
544  sensor->Exec(nLevel);
545  }
546 }
547 
548 //-----------------------------------------------------------------------
549 
550 //-----------------------------------------------------------------------
551 
552 void CbmMvdDetector::ExecFrom(UInt_t nLevel) {
553 
559  foutput->Clear();
560  fcurrentEvent->Clear();
561  foutputDigis->Clear();
562  foutputDigiMatchs->Clear();
563  foutputHits->Clear();
564  foutputCluster->Clear(); //khun
565 
566  Int_t nSensors = fSensorArray->GetEntriesFast();
567  CbmMvdSensor* sensor;
568  for (Int_t i = 0; i < nSensors; i++) {
569  sensor = (CbmMvdSensor*) fSensorArray->At(i);
570  sensor->ExecFrom(nLevel);
571  }
572 }
573 //-----------------------------------------------------------------------
574 
575 //-----------------------------------------------------------------------
576 TClonesArray* CbmMvdDetector::GetCurrentEvent() {
577 
581  Int_t nSensors = fSensorArray->GetEntriesFast();
582  CbmMvdSensor* sensor;
583  for (Int_t i = 0; i < nSensors; i++) {
584  sensor = (CbmMvdSensor*) fSensorArray->At(i);
585  // foutput = sensor->GetOutputArray(0);
586  fcurrentEvent->AbsorbObjects(sensor->GetOutputArray(0));
587  }
588 
589  return (fcurrentEvent);
590 }
591 //-----------------------------------------------------------------------
592 
593 //-----------------------------------------------------------------------
594 
595 TClonesArray* CbmMvdDetector::GetOutputHits() {
596 
601  Int_t nSensors = fSensorArray->GetEntriesFast();
602  CbmMvdSensor* sensor;
603  for (Int_t i = 0; i < nSensors; i++) {
604  sensor = (CbmMvdSensor*) fSensorArray->At(i);
605  Int_t length = sensor->GetOutputArrayLen(sensor->GetHitPlugin());
606  if (length >= 0) {
607  foutputHits->AbsorbObjects(sensor->GetOutputBuffer(),
608  0,
609  sensor->GetOutputBuffer()->GetEntriesFast()
610  - 1);
611  }
612  }
613 
614  return (foutputHits);
615 }
616 //-----------------------------------------------------------------------
617 
618 //-----------------------------------------------------------------------
619 TClonesArray* CbmMvdDetector::GetOutputDigis() {
620 
625  Int_t nSensors = fSensorArray->GetEntriesFast();
626  CbmMvdSensor* sensor;
627  for (Int_t i = 0; i < nSensors; i++) {
628  sensor = (CbmMvdSensor*) fSensorArray->At(i);
629  fDigiPlugin = sensor->GetDigiPlugin();
630  Int_t length = sensor->GetOutputArrayLen(fDigiPlugin);
631  if (length >= 0) {
632  foutputDigis->AbsorbObjects(sensor->GetOutputArray(fDigiPlugin));
633  }
634  }
635 
636  return (foutputDigis);
637 }
638 //-----------------------------------------------------------------------
639 
640 //-----------------------------------------------------------------------
641 TClonesArray* CbmMvdDetector::GetOutputDigiMatchs() {
642 
646  Int_t nSensors = fSensorArray->GetEntriesFast();
647  CbmMvdSensor* sensor;
648  for (Int_t i = 0; i < nSensors; i++) {
649  sensor = (CbmMvdSensor*) fSensorArray->At(i);
650  fDigiPlugin = sensor->GetDigiPlugin();
651  // Int_t length = sensor->GetOutputArrayLen(fDigiPlugin);
652  foutputDigiMatchs->AbsorbObjects(sensor->GetOutputMatch());
653  }
654  return (foutputDigiMatchs);
655 }
656 //-----------------------------------------------------------------------
657 
658 //-----------------------------------------------------------------------
659 // khun /*
660 TClonesArray* CbmMvdDetector::GetOutputCluster() {
664  Int_t nSensors = fSensorArray->GetEntriesFast();
665  CbmMvdSensor* sensor;
666  for (Int_t i = 0; i < nSensors; i++) {
667  sensor = (CbmMvdSensor*) fSensorArray->At(i);
668  fClusterPlugin = sensor->GetClusterPlugin();
669  Int_t length = sensor->GetOutputArrayLen(fClusterPlugin);
670  if (length >= 0)
671  foutputCluster->AbsorbObjects(
672  sensor->GetOutputArray(fClusterPlugin), 0, length); //khun
673  }
674 
675  return (foutputCluster);
676 };
677 // khun */
678 
679 //-----------------------------------------------------------------------
680 
681 
682 //-----------------------------------------------------------------------
683 
684 TClonesArray* CbmMvdDetector::GetOutputArray(Int_t nPlugin) {
685 
690  Int_t nSensors = fSensorArray->GetEntriesFast();
691  CbmMvdSensor* sensor;
692  for (Int_t i = 0; i < nSensors; i++) {
693  sensor = (CbmMvdSensor*) fSensorArray->At(i);
694  Int_t length = sensor->GetOutputArrayLen(nPlugin);
695  if (length >= 0) {
696  foutputDigis->AbsorbObjects(sensor->GetOutputArray(nPlugin), 0, length);
697  foutputDigiMatchs->AbsorbObjects(sensor->GetOutputMatch(), 0, length);
698  }
699  }
700  return (foutputDigis);
701 }
702 //-----------------------------------------------------------------------
703 
704 //-----------------------------------------------------------------------
705 void CbmMvdDetector::Finish() {
706  if (!fFinished) {
707  Int_t nSensors = fSensorArray->GetEntriesFast();
708  CbmMvdSensor* sensor;
709  for (Int_t i = 0; i < nSensors; i++) {
710  sensor = (CbmMvdSensor*) fSensorArray->At(i);
711  sensor->Finish();
712  }
713  fFinished = kTRUE;
714  }
715 }
716 //-----------------------------------------------------------------------
717 
718 ClassImp(CbmMvdDetector)
CbmMvdDetector::Instance
static CbmMvdDetector * Instance()
Definition: CbmMvdDetector.cxx:47
CbmMvdSensor::GetDetectorID
Int_t GetDetectorID() const
Definition: CbmMvdSensor.h:63
CbmMvdSensor::SetDigiPlugin
void SetDigiPlugin(const Int_t &nPlugin)
Definition: CbmMvdSensor.h:107
CbmMvdDetector.h
CbmMvdSensor::GetOutputArray
TClonesArray * GetOutputArray(Int_t nPlugin) const
Definition: CbmMvdSensor.cxx:491
CbmMvdSensor::Exec
void Exec(UInt_t nPlugin)
Definition: CbmMvdSensor.cxx:416
CbmMvdDetector::fcurrentEvent
TClonesArray * fcurrentEvent
Definition: CbmMvdDetector.h:133
CbmMvdDetector::Exec
void Exec(UInt_t nLevel)
Definition: CbmMvdDetector.cxx:527
CbmMvdDetector::foutputDigiMatchs
TClonesArray * foutputDigiMatchs
Definition: CbmMvdDetector.h:131
CbmMvdDetector::SendInputDigisToHits
void SendInputDigisToHits(TClonesArray *digis)
Definition: CbmMvdDetector.cxx:438
CbmMvdSensor::SendInputCluster
void SendInputCluster(CbmMvdCluster *cluster)
Definition: CbmMvdSensor.cxx:365
CbmMvdDetector::CbmMvdDetector
CbmMvdDetector()
Definition: CbmMvdDetector.cxx:62
CbmMvdSensorHitfinderTask.h
CbmMvdDetector::GetOutputCluster
TClonesArray * GetOutputCluster()
Definition: CbmMvdDetector.cxx:660
CbmMvdGeoHandler::Init
void Init(Bool_t isSimulation=kFALSE)
Definition: CbmMvdGeoHandler.cxx:84
CbmMvdSensorClusterfinderTask.h
CbmMvdGeoHandler::SetSensorTyp
void SetSensorTyp(CbmMvdSensorTyp typ)
Definition: CbmMvdGeoHandler.h:73
CbmMvdDigi::SetRefId
void SetRefId(Int_t refId)
Definition: CbmMvdDigi.h:84
CbmMvdDigi.h
CbmMvdSensor::SetDataSheet
void SetDataSheet(CbmMvdSensorDataSheet *sheet)
Definition: CbmMvdSensor.h:84
CbmMvdSensor::SetMisalignment
void SetMisalignment(Float_t misalignment[3])
Definition: CbmMvdSensor.h:133
CbmMvdDetector::ExecChain
void ExecChain()
Definition: CbmMvdDetector.cxx:499
CbmMvdSensorPlugin
Definition: CbmMvdSensorPlugin.h:24
CbmMvdSensorFindHitTask.h
CbmMvdDetector::~CbmMvdDetector
virtual ~CbmMvdDetector()
Definition: CbmMvdDetector.cxx:126
CbmMvdSensor::ExecFrom
void ExecFrom(UInt_t nPlugin)
Definition: CbmMvdSensor.cxx:463
CbmMvdSensorPlugin.h
CbmMvdGeoHandler::Fill
void Fill()
Definition: CbmMvdGeoHandler.cxx:371
CbmMvdDetector::Init
void Init()
Definition: CbmMvdDetector.cxx:278
CbmMvdDetector::Finish
void Finish()
Definition: CbmMvdDetector.cxx:705
CbmMvdSensor::Finish
void Finish()
Definition: CbmMvdSensor.cxx:703
i
int i
Definition: L1/vectors/P4_F32vec4.h:25
CbmMvdDetector::SendInput
void SendInput(TClonesArray *input)
Definition: CbmMvdDetector.cxx:338
CbmMvdSensor.h
CbmMvdDetector::GetOutputDigiMatchs
TClonesArray * GetOutputDigiMatchs()
Definition: CbmMvdDetector.cxx:641
CbmMvdDetector::foutput
TClonesArray * foutput
Definition: CbmMvdDetector.h:127
CbmMvdSensorPlugin::GetPluginType
virtual MvdSensorPluginType GetPluginType()=0
CbmMvdSensor::SetHitPlugin
void SetHitPlugin(const Int_t &nPlugin)
Definition: CbmMvdSensor.h:108
CbmMvdDetector::GetOutputArray
TClonesArray * GetOutputArray(Int_t nPlugin)
Definition: CbmMvdDetector.cxx:684
CbmMvdSensor::Init
void Init()
Definition: CbmMvdSensor.cxx:203
ECbmModuleId::kMvd
@ kMvd
Micro-Vertex Detector.
CbmMvdSensor::SetStation
void SetStation(Int_t StationNumber)
Definition: CbmMvdSensor.h:92
CbmMvdSensorClusterfinderTask
Definition: CbmMvdSensorClusterfinderTask.h:38
CbmMvdCluster
Definition: CbmMvdCluster.h:27
CbmDigiManager::GetNofDigis
static Int_t GetNofDigis(ECbmModuleId systemId)
Definition: CbmDigiManager.cxx:62
CbmMvdSensorDigitizerTask
Definition: CbmMvdSensorDigitizerTask.h:47
CbmDigiManager::IsPresent
static Bool_t IsPresent(ECbmModuleId systemId)
Presence of a digi branch.
Definition: CbmDigiManager.cxx:112
CbmMvdDetector::initialized
Bool_t initialized
Definition: CbmMvdDetector.h:144
CbmMvdGeoHandler.h
Helper class to extract information from the GeoManager. Addapted from TrdGeoHandler byFlorian Uhlig ...
CbmMvdDetector::ShowDebugHistos
void ShowDebugHistos()
Definition: CbmMvdDetector.cxx:313
CbmMvdDetector::fName
TString fName
Definition: CbmMvdDetector.h:147
CbmMvdSensor::ExecChain
void ExecChain()
Definition: CbmMvdSensor.cxx:380
CbmMvdSensorTask
Definition: CbmMvdSensorTask.h:26
CbmMvdSensorFrameBuffer.h
CbmMvdSensorDigitizerTask.h
CbmMvdSensorTyp::MIMOSIS
@ MIMOSIS
CbmMvdSensor::GetHitPlugin
Int_t GetHitPlugin() const
Definition: CbmMvdSensor.h:104
CbmMvdDetector::GetCurrentEvent
TClonesArray * GetCurrentEvent()
Definition: CbmMvdDetector.cxx:576
CbmMvdSensor
Definition: CbmMvdSensor.h:40
CbmMvdCluster::GetSensorNr
Int_t GetSensorNr()
Definition: CbmMvdCluster.h:51
CbmMvdPoint
Definition: CbmMvdPoint.h:28
CbmMvdGeoHandler
Definition: CbmMvdGeoHandler.h:37
CbmMvdGeoHandler::PrintGeoParameter
void PrintGeoParameter()
Definition: CbmMvdGeoHandler.cxx:555
CbmMvdSensor::SendInput
void SendInput(CbmMvdPoint *point)
Definition: CbmMvdSensor.cxx:306
CbmMvdSensor::GetOutputMatch
TClonesArray * GetOutputMatch() const
Definition: CbmMvdSensor.cxx:545
CbmMvdSensor::GetOutputArrayLen
Int_t GetOutputArrayLen(Int_t nPlugin) const
Definition: CbmMvdSensor.cxx:522
CbmMvdDetector::GetOutputHits
TClonesArray * GetOutputHits()
Definition: CbmMvdDetector.cxx:595
CbmDigiManager::Get
const Digi * Get(Int_t index) const
Get a digi object.
Definition: CbmDigiManager.h:52
CbmMvdDetector::AddSensor
void AddSensor(TString clearName, TString fullName, TString nodeName, CbmMvdSensorDataSheet *sensorData, Int_t sensorNr, Int_t volumeId, Double_t sensorStartTime, Int_t stationNr)
Definition: CbmMvdDetector.cxx:131
CbmMvdSensor::GetDigiPlugin
Int_t GetDigiPlugin() const
Definition: CbmMvdSensor.h:103
CbmMvdDetector::fFinished
Bool_t fFinished
Definition: CbmMvdDetector.h:145
CbmMvdSensorDigitizerTBTask
Definition: CbmMvdSensorDigitizerTBTask.h:47
CbmMvdSensor::SendInputDigiToHit
void SendInputDigiToHit(CbmMvdDigi *digi)
Definition: CbmMvdSensor.cxx:350
CbmMvdSensorFindHitTask
Definition: CbmMvdSensorFindHitTask.h:39
CbmMvdSensorHitfinderTask
Definition: CbmMvdSensorHitfinderTask.h:40
CbmMvdDetector::SendInputDigis
void SendInputDigis(CbmDigiManager *digiMan)
Definition: CbmMvdDetector.cxx:373
CbmMvdDetector::SetProduceNoise
void SetProduceNoise()
Definition: CbmMvdDetector.cxx:326
task
@ task
Definition: CbmMvdSensorPlugin.h:22
ClassImp
ClassImp(CbmConverterManager) InitStatus CbmConverterManager
Definition: CbmConverterManager.cxx:12
CbmDigiManager
CbmDigiManager.
Definition: CbmDigiManager.h:37
CbmMvdDetector::fSensorArray
TClonesArray * fSensorArray
Definition: CbmMvdDetector.h:124
CbmMvdSensorTyp
CbmMvdSensorTyp
Definition: CbmMvdHelper.h:4
CbmMvdCluster::SetRefId
void SetRefId(Int_t RefId)
Definition: CbmMvdCluster.h:41
CbmMvdDetector::ExecFrom
void ExecFrom(UInt_t nLevel)
Definition: CbmMvdDetector.cxx:552
CbmMvdDetector::foutputCluster
TClonesArray * foutputCluster
Definition: CbmMvdDetector.h:130
CbmMvdPoint::SetPointId
void SetPointId(Int_t myId)
Definition: CbmMvdPoint.h:92
CbmMvdSensorDigiToHitTask
Definition: CbmMvdSensorDigiToHitTask.h:40
CbmMvdDetector::foutputDigis
TClonesArray * foutputDigis
Definition: CbmMvdDetector.h:129
CbmMvdSensor::SendInputDigi
void SendInputDigi(CbmMvdDigi *digi)
Definition: CbmMvdSensor.cxx:336
CbmMvdDetector::fPluginCount
UInt_t fPluginCount
Definition: CbmMvdDetector.h:126
CbmMvdDetector
Definition: CbmMvdDetector.h:39
CbmMvdSensor::GetClusterPlugin
Int_t GetClusterPlugin() const
Definition: CbmMvdSensor.h:105
CbmMvdDetector::fSensorTyp
static CbmMvdSensorTyp fSensorTyp
Definition: CbmMvdDetector.h:119
CbmMvdSensor::GetOutputBuffer
TClonesArray * GetOutputBuffer() const
Definition: CbmMvdSensor.cxx:553
CbmMvdDetector::fInstance
static CbmMvdDetector * fInstance
Definition: CbmMvdDetector.h:142
CbmDigiManager.h
CbmMvdDetector::fDigiPlugin
Int_t fDigiPlugin
Definition: CbmMvdDetector.h:137
CbmMvdDetector::fClusterPlugin
Int_t fClusterPlugin
Definition: CbmMvdDetector.h:139
CbmMvdDetector::foutputHits
TClonesArray * foutputHits
Definition: CbmMvdDetector.h:128
CbmMvdDigi
Definition: CbmMvdDigi.h:21
CbmMvdDetector::fepsilon
Float_t fepsilon[3]
Definition: CbmMvdDetector.h:134
CbmMvdSensor::GetSensorNr
Int_t GetSensorNr() const
Definition: CbmMvdSensor.h:64
CbmMvdDetector::fSensorArrayFilled
Bool_t fSensorArrayFilled
Definition: CbmMvdDetector.h:143
CbmMvdSensorTask.h
CbmMvdDetector::AddPlugin
void AddPlugin(CbmMvdSensorPlugin *plugin)
Definition: CbmMvdDetector.cxx:186
CbmMvdSensor::SetProduceNoise
void SetProduceNoise()
Definition: CbmMvdSensor.cxx:279
CbmMvdDetector::SendInputCluster
void SendInputCluster(TClonesArray *cluster)
Definition: CbmMvdDetector.cxx:469
CbmMvdSensorBuffer.h
CbmMvdSensor::AddPlugin
void AddPlugin(CbmMvdSensorPlugin *plugin)
Definition: CbmMvdSensor.h:125
CbmMvdSensorTrackingBuffer.h
CbmMvdSensor::SetClusterPlugin
void SetClusterPlugin(const Int_t &nPlugin)
Definition: CbmMvdSensor.h:109
CbmMvdDetector::GetOutputDigis
TClonesArray * GetOutputDigis()
Definition: CbmMvdDetector.cxx:619
CbmMvdDigi::GetDetectorId
Int_t GetDetectorId()
Definition: CbmMvdDigi.h:57
CbmMvdSensorDataSheet
Definition: CbmMvdSensorDataSheet.h:22
CbmMvdSensorDigiToHitTask.h
CbmMvdSensorDigitizerTBTask.h
CbmMvdSensor::ShowDebugHistos
void ShowDebugHistos()
Definition: CbmMvdSensor.cxx:264