FairRoot
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
FairRunAna.cxx
Go to the documentation of this file.
1 /********************************************************************************
2  * Copyright (C) 2014 GSI Helmholtzzentrum fuer Schwerionenforschung GmbH *
3  * *
4  * This software is distributed under the terms of the *
5  * GNU Lesser General Public Licence (LGPL) version 3, *
6  * copied verbatim in the file "LICENSE" *
7  ********************************************************************************/
8 // -------------------------------------------------------------------------
9 // ----- FairRunAna source file -----
10 // ----- Created 06/01/04 by M. Al-Turany -----
11 // -------------------------------------------------------------------------
12 
13 #include "FairRunAna.h"
14 
15 #include "FairBaseParSet.h" // for FairBaseParSet
16 #include "FairEventHeader.h" // for FairEventHeader
17 #include "FairField.h" // for FairField
18 #include "FairFieldFactory.h" // for FairFieldFactory
19 #include "FairFileHeader.h" // for FairFileHeader
20 #include "FairFileSource.h" // ONLY TEMPORARILY, FOR COMPABILITY
21 #include "FairLogger.h" // for FairLogger, MESSAGE_ORIGIN
22 #include "FairMixedSource.h" // ONLY TEMPORARILY, FOR COMPABILITY
23 #include "FairParSet.h" // for FairParSet
24 #include "FairRootManager.h" // for FairRootManager
25 #include "FairRunIdGenerator.h" // for FairRunIdGenerator
26 #include "FairRuntimeDb.h" // for FairRuntimeDb
27 #include "FairTask.h" // for FairTask
28 #include "FairTrajFilter.h" // for FairTrajFilter
29 #include "signal.h"
30 
31 #include <TCollection.h> // for TIter
32 #include <TFile.h> // for TFile, gFile
33 #include <TGeoManager.h> // for gGeoManager, TGeoManager
34 #include <TKey.h> // for TKey
35 #include <TList.h> // for TList
36 #include <TObjArray.h> // for TObjArray
37 #include <TObject.h> // for TObject
38 #include <TROOT.h> // for TROOT, gROOT
39 #include <TSeqCollection.h> // for TSeqCollection
40 #include <TSystem.h> // for TSystem, gSystem
41 #include <iostream> // for operator<<, basic_ostream, etc
42 #include <stdlib.h> // for exit
43 #include <string.h> // for strcmp
44 
45 using std::cout;
46 using std::endl;
47 
49 
50 //_____________________________________________________________________________
52 {
53  LOG(info) << "*********** CTRL C PRESSED *************";
54  gFRAIsInterrupted = kTRUE;
55 }
56 //_____________________________________________________________________________
57 
58 //_____________________________________________________________________________
60 //_____________________________________________________________________________
62 //_____________________________________________________________________________
64  : FairRun()
65  , fRunInfo()
66  , fIsInitialized(kFALSE)
67  , fInputGeoFile(0)
68  , fLoadGeo(kFALSE)
69  , fStatic(kFALSE)
70  , fField(0)
71  , fTimeStamps(kFALSE)
72  , fInFileIsOpen(kFALSE)
73  , fEventTimeMin(0)
74  , fEventTimeMax(0)
75  , fEventTime(0)
76  , fEventMeanTime(0)
77  , fTimeProb(0)
78  , fFinishProcessingLMDFile(kFALSE)
79  , fFileSource(0)
80  , fMixedSource(0)
81  , fStoreEventHeader(kTRUE)
82 
83 {
84 
85  fgRinstance = this;
86  fAna = kTRUE;
87 }
88 //_____________________________________________________________________________
89 
90 //_____________________________________________________________________________
92 {
93  // delete fFriendFileList;
94  delete fField;
95  if (gGeoManager) {
96  if (gROOT->GetVersionInt() >= 60602) {
97  gGeoManager->GetListOfVolumes()->Delete();
98  gGeoManager->GetListOfShapes()->Delete();
99  }
100  delete gGeoManager;
101  }
102 }
103 
104 //_____________________________________________________________________________
105 
106 void FairRunAna::SetGeomFile(const char* GeoFileName)
107 {
108  if (fIsInitialized) {
109  LOG(fatal) << "Geometry file has to be set before Run::Init !";
110  exit(-1);
111  } else {
112 
113  TFile* CurrentFile = gFile;
114  fInputGeoFile = TFile::Open(GeoFileName);
115  if (fInputGeoFile->IsZombie()) {
116  LOG(error) << "Error opening Geometry Input file";
117  fInputGeoFile = 0;
118  }
119  LOG(info) << "Opening Geometry input file: " << GeoFileName;
120  fLoadGeo = kTRUE;
121  gFile = CurrentFile;
122  }
123 }
124 
125 //_____________________________________________________________________________
126 
128 {
129 
130  if (fIsInitialized) {
131  LOG(fatal) << "Error Init is already called before!";
132  exit(-1);
133  } else {
134  fIsInitialized = kTRUE;
135  }
136  fRtdb = GetRuntimeDb();
137 
138  // Check if we have an input file to be used
141 
142  // Load Geometry from user file
143  if (fLoadGeo) {
144  if (fInputGeoFile != 0) { // First check if the user has a separate Geo file!
145  TIter next(fInputGeoFile->GetListOfKeys());
146  TKey* key;
147  while ((key = dynamic_cast<TKey*>(next()))) {
148  if (strcmp(key->GetClassName(), "TGeoManager") != 0) {
149  continue;
150  }
151  gGeoManager = dynamic_cast<TGeoManager*>(key->ReadObj());
152  break;
153  }
154  }
155  } else {
156  /*** Get the container that normly has the geometry and all the basic stuff from simulation*/
157  fRtdb->getContainer("FairGeoParSet");
158  }
159 
160  if (fInFileIsOpen) {
161  // check that the geometry was loaded if not try all connected files!
162  if (fLoadGeo && gGeoManager == 0) {
163  LOG(info) << "Geometry was not found in the input file we will look in the friends if any!";
164  TFile* currentfile = gFile;
165  TFile* nextfile = 0;
166  TSeqCollection* fileList = gROOT->GetListOfFiles();
167  for (Int_t k = 0; k < fileList->GetEntries(); k++) {
168  nextfile = dynamic_cast<TFile*>(fileList->At(k));
169  if (nextfile) {
170  nextfile->Get("FAIRGeom");
171  }
172  if (gGeoManager) {
173  break;
174  }
175  }
176  gFile = currentfile;
177  }
178  } else { // if(fInputFile )
179  // NO input file but there is a geometry file
180  if (fLoadGeo) {
181  if (fInputGeoFile != 0) { // First check if the user has a separate Geo file!
182  TIter next(fInputGeoFile->GetListOfKeys());
183  TKey* key;
184  while ((key = dynamic_cast<TKey*>(next()))) {
185  if (strcmp(key->GetClassName(), "TGeoManager") != 0) {
186  continue;
187  }
188  gGeoManager = dynamic_cast<TGeoManager*>(key->ReadObj());
189  break;
190  }
191  }
192  }
193  }
194 
195  gROOT->GetListOfBrowsables()->Add(fTask);
196 
197  // Init the RTDB containers
198 
199  FairBaseParSet* par = dynamic_cast<FairBaseParSet*>(fRtdb->getContainer("FairBaseParSet"));
200 
202  if (fTimeStamps) {
204  }
205 
206  // Assure that basic info is there for the run
207  // if(par && fInputFile) {
208  if (par && fInFileIsOpen) {
209 
210  LOG(info) << "Parameter and input file are available, Assure that basic info is there for the run!";
212 
213  // fEvtHeader = GetEventHeader();
214  GetEventHeader();
215 
217 
219 
220  // Copy the Event Header Info to Output
222 
223  // Init the containers in Tasks
224  LOG(info) << "--- Initialize with RunId --- " << fRunId;
226  fTask->SetParTask();
227 
228  // fRtdb->initContainers( fRunId );
229 
230  } else { // end----- if(fMixedInput)
231  LOG(info) << "Initializing without input file or Mixed input";
234  FairRunIdGenerator genid;
235  fRunId = genid.generateId();
236  fRtdb->addRun(fRunId);
237  evt->SetRunId(fRunId);
238  fTask->SetParTask();
240  }
242  if (fieldfact) {
243  fieldfact->SetParm();
244  }
245 
248 
249  // create a field
250  // <DB>
251  // Add test for external FairField settings
252  if (fieldfact && !fField) {
253  fField = fieldfact->createFairField();
254  }
255  // Now call the User initialize for Tasks
256  fTask->InitTask();
257  // if the vis manager is available then initialize it!
259  if (fTrajFilter) {
260  fTrajFilter->Init();
261  }
262  // Create a list of time based branches (if any).
263 
265 
266  // create the output tree after tasks initialisation
269 
270  AlignGeometry();
271 }
272 //_____________________________________________________________________________
273 
274 //_____________________________________________________________________________
275 void FairRunAna::Run(Int_t Ev_start, Int_t Ev_end)
276 {
277  gFRAIsInterrupted = kFALSE;
278 
279  if (fTimeStamps) {
280  RunTSBuffers();
281  } else {
282  UInt_t tmpId = 0;
283  // if (fInputFile==0) {
284  if (!fInFileIsOpen) {
285  DummyRun(Ev_start, Ev_end);
286  return;
287  }
288 
289  Int_t MaxAllowed = fRootManager->CheckMaxEventNo(Ev_end);
290  if (MaxAllowed != -1) {
291  if (Ev_end == 0) {
292  if (Ev_start == 0) {
293  Ev_end = MaxAllowed;
294  } else {
295  Ev_end = Ev_start;
296  if (Ev_end > MaxAllowed) {
297  Ev_end = MaxAllowed;
298  }
299  Ev_start = 0;
300  }
301  } else {
302  if (Ev_end > MaxAllowed) {
303  cout << "-------------------Warning---------------------------" << endl;
304  cout << " -W FairRunAna : File has less events than requested!!" << endl;
305  cout << " File contains : " << MaxAllowed << " Events" << endl;
306  cout << " Requested number of events = " << Ev_end << " Events" << endl;
307  cout << " The number of events is set to " << MaxAllowed << " Events" << endl;
308  cout << "-----------------------------------------------------" << endl;
309  Ev_end = MaxAllowed;
310  }
311  }
312  LOG(info) << "FairRunAna::Run() After checking, the run will run from event " << Ev_start << " to "
313  << Ev_end << ".";
314  } else {
315  LOG(info) << "FairRunAna::Run() continue running without stop";
316  }
317 
318  if (fGenerateRunInfo) {
319  fRunInfo.Reset();
320  }
321 
322  Int_t readEventReturn = 0;
323 
324  for (int i = Ev_start; i < Ev_end || MaxAllowed == -1; i++) {
325 
326  gSystem->IgnoreInterrupt();
327  // gFRAIsInterrupted = kFALSE;
328  signal(SIGINT, FRA_handler_ctrlc);
329 
330  if (gFRAIsInterrupted) {
331  LOG(warn) << "FairRunAna::Run() Event loop was interrupted by the user!";
332  break;
333  }
334 
335  readEventReturn = fRootManager->ReadEvent(i);
336 
337  if (readEventReturn != 0) {
338  LOG(warn) << "FairRunAna::Run() fRootManager->ReadEvent(" << i << ") returned " << readEventReturn
339  << ". Breaking the event loop";
340  break;
341  }
342 
344 
345  tmpId = fEvtHeader->GetRunId();
346  if (tmpId != fRunId) {
347  fRunId = tmpId;
348  if (!fStatic) {
349  Reinit(fRunId);
350  fTask->ReInitTask();
351  }
352  }
353  // std::cout << "WriteoutBufferData with time: " << fRootManager->GetEventTime();
355  fTask->ExecuteTask("");
356  Fill();
358  fTask->FinishEvent();
359 
360  if (fGenerateRunInfo) {
361  fRunInfo.StoreInfo();
362  }
363  if (nullptr != FairTrajFilter::Instance()) {
365  }
366  }
367 
369  fTask->FinishTask();
370  if (fGenerateRunInfo) {
371  fRunInfo.WriteInfo();
372  }
374  fRootManager->Write();
375  }
376 }
377 //_____________________________________________________________________________
378 
379 //_____________________________________________________________________________
380 void FairRunAna::RunEventReco(Int_t Ev_start, Int_t Ev_end)
381 {
382  UInt_t tmpId = 0;
383 
384  Int_t MaxAllowed = fRootManager->CheckMaxEventNo(Ev_end);
385  if (MaxAllowed != -1) {
386  if (Ev_end == 0) {
387  if (Ev_start == 0) {
388  Ev_end = MaxAllowed;
389  } else {
390  Ev_end = Ev_start;
391  if (Ev_end > MaxAllowed) {
392  Ev_end = MaxAllowed;
393  }
394  Ev_start = 0;
395  }
396  } else {
397  if (Ev_end > MaxAllowed) {
398  cout << "-------------------Warning---------------------------" << endl;
399  cout << " -W FairRunAna : File has less events than requested!!" << endl;
400  cout << " File contains : " << MaxAllowed << " Events" << endl;
401  cout << " Requested number of events = " << Ev_end << " Events" << endl;
402  cout << " The number of events is set to " << MaxAllowed << " Events" << endl;
403  cout << "-----------------------------------------------------" << endl;
404  Ev_end = MaxAllowed;
405  }
406  }
407  LOG(info) << "FairRunAna::Run() After checking, the run will run from event " << Ev_start << " to " << Ev_end
408  << ".";
409  } else {
410  LOG(info) << "FairRunAna::Run() continue running without stop";
411  }
412 
413  if (fGenerateRunInfo) {
414  fRunInfo.Reset();
415  }
416 
417  for (int i = Ev_start; i < Ev_end; i++) {
423  if (tmpId != fRunId) {
424  fRunId = tmpId;
425  if (!fStatic) {
426  Reinit(fRunId);
427  fTask->ReInitTask();
428  }
429  }
430  // FairMCEventHeader* header = dynamic_cast<FairMCEventHeader*>(fRootManager->GetObject("MCEventHeader.");
431  // std::cout << "WriteoutBufferData with time: " << fRootManager->GetEventTime();
433  fTask->ExecuteTask("");
434 
436  // Fill();
437  fTask->FinishEvent();
438 
439  if (fGenerateRunInfo) {
440  fRunInfo.StoreInfo();
441  }
442  if (nullptr != FairTrajFilter::Instance()) {
444  }
445  }
446 
447  fTask->FinishTask();
448  if (fGenerateRunInfo) {
449  fRunInfo.WriteInfo();
450  }
452  fRootManager->Write();
453 }
454 //_____________________________________________________________________________
455 
456 //_____________________________________________________________________________
457 void FairRunAna::Run(Double_t delta_t)
458 {
459  while (fRootManager->ReadNextEvent(delta_t) == kTRUE) {
460  fTask->ExecuteTask("");
462  Fill();
464  fTask->FinishEvent();
465  if (nullptr != FairTrajFilter::Instance()) {
467  }
468  }
469 
471  fTask->FinishTask();
473  fRootManager->Write();
474 }
475 //_____________________________________________________________________________
476 
477 //_____________________________________________________________________________
478 void FairRunAna::RunMQ(Long64_t entry)
479 {
484  UInt_t tmpId = 0;
485  fRootManager->ReadEvent(entry);
486  tmpId = fEvtHeader->GetRunId();
487  if (tmpId != fRunId) {
488  fRunId = tmpId;
489  if (!fStatic) {
490  Reinit(fRunId);
491  fTask->ReInitTask();
492  }
493  }
494  fTask->ExecuteTask("");
496  fTask->FinishTask();
497 }
498 //_____________________________________________________________________________
499 
500 //_____________________________________________________________________________
501 void FairRunAna::Run(Long64_t entry)
502 {
503  UInt_t tmpId = 0;
504  fRootManager->ReadEvent(entry);
505  tmpId = fEvtHeader->GetRunId();
506  if (tmpId != fRunId) {
507  fRunId = tmpId;
508  if (!fStatic) {
509  Reinit(fRunId);
510  fTask->ReInitTask();
511  }
512  }
513  fTask->ExecuteTask("");
515  fTask->FinishTask();
516  Fill();
519  fRootManager->Write();
520 }
521 //_____________________________________________________________________________
522 
523 //_____________________________________________________________________________
525 {
526  Int_t globalEvent = 0;
527 
528  bool firstRun = true;
529  while (firstRun || fRootManager->AllDataProcessed() == kFALSE) {
530  firstRun = false;
531  if (globalEvent < fRootManager->CheckMaxEventNo(
532  0)) { // this step is necessary to load in all data which is not read in via TSBuffers
534  }
535  fTask->ExecuteTask("");
537  Fill();
539  fTask->FinishEvent();
540  if (nullptr != FairTrajFilter::Instance()) {
542  }
543  }
545  fTask->FinishTask();
547  fRootManager->Write();
548 }
549 //_____________________________________________________________________________
550 //_____________________________________________________________________________
551 
552 void FairRunAna::RunOnLmdFiles(UInt_t NStart, UInt_t NStop)
553 {
554  if (NStart == 0 && NStop == 0) {
555  NStart = 0;
556  NStop = 1000000000;
557  LOG(info) << " Maximum number of event is set to 1E9";
558  }
559  for (UInt_t i = NStart; i < NStop; i++) {
561  i = NStop;
562  }
563 
564  fTask->ExecuteTask("");
566  Fill();
567  }
568 
569  fTask->FinishTask();
570  fRootManager->Write();
571 }
572 //_____________________________________________________________________________
574 {
575  // std::cout << "FairRunAna::RunOnTBData " << std::endl;
576  while (fRootManager->FinishRun() != kTRUE) {
577  fTask->ExecuteTask("");
578  Fill();
579  fTask->FinishEvent();
580  }
581 
582  fTask->FinishTask();
584  fRootManager->Write();
585 }
586 //_____________________________________________________________________________
587 void FairRunAna::DummyRun(Int_t Ev_start, Int_t Ev_end)
588 {
589 
591  for (int i = Ev_start; i < Ev_end; i++) {
592  fTask->ExecuteTask("");
594  Fill();
595  }
596  fTask->FinishTask();
597  fRootManager->Write();
598 }
599 //_____________________________________________________________________________
600 
601 //_____________________________________________________________________________
603 {
605  fTask->FinishTask();
606  // gDirectory->SetName(fRootManager->GetOutFile()->GetName());
607  // fRunInfo.WriteInfo(); // CRASHES due to file ownership i guess...
608  // cout << ">>> SlaveTerminate fRootManager->GetInChain()->Print()" << endl;
609  // fRootManager->GetInChain()->Print();
610  // cout << ">>>------------------------------------------------<<<" << endl;
612  fRootManager->Write();
614 }
615 //_____________________________________________________________________________
616 
617 void FairRunAna::Reinit(UInt_t runId)
618 {
619  // reinit procedure
620  fRtdb->initContainers(runId);
621 }
622 //_____________________________________________________________________________
623 
625 {
626  if (fIsInitialized) {
627  LOG(warn) << "RunWithTimeStamps has to be set before Run::Init !";
628  exit(-1);
629  } else {
630  fTimeStamps = kTRUE;
632  }
633 }
634 //_____________________________________________________________________________
635 
636 //_____________________________________________________________________________
637 void FairRunAna::SetContainerStatic(Bool_t tempBool)
638 {
639  fStatic = tempBool;
640  if (fStatic) {
641  LOG(info) << "Parameter Cont. initialisation is static";
642  } else {
643  LOG(info) << "Parameter Cont. initialisation is NOT static";
644  }
645 }
646 //_____________________________________________________________________________
648 {
649  if (fMarkFill) {
650  fRootManager->Fill();
651  } else {
652  fMarkFill = kTRUE;
653  }
654 }
655 //_____________________________________________________________________________
656 
657 // void FairRunAna::SetMixAllInputs(Bool_t Status)
658 // {
659 // fLogger->Info(MESSAGE_ORIGIN, "Mixing for all input is choosed, in this mode one event per input file is read per
660 // step"); fRootManager->SetMixAllInputs(Status);
661 // }
662 //_____________________________________________________________________________
663 // ABOVE FUNCTIONS SHOULD BE DELETED AND MOVED TO FairFileSource AND FairMixedSource ONLY
664 
void AlignGeometry() const
Definition: FairRun.cxx:181
void TerminateRun()
Definition: FairRunAna.cxx:602
Bool_t fTimeStamps
Definition: FairRunAna.h:121
virtual FairField * createFairField()
Int_t CheckMaxEventNo(Int_t EvtEnd=0)
void Init()
Definition: FairRunAna.cxx:127
Bool_t fAna
Definition: FairRun.h:203
void WriteInfo()
Definition: FairRunInfo.cxx:79
virtual void ExecuteTask(Option_t *option="0")
Definition: FairTask.cxx:118
Bool_t gFRAIsInterrupted
Definition: FairRunAna.cxx:48
Int_t ReadEvent(Int_t i=0)
void Reinit(UInt_t runId)
Definition: FairRunAna.cxx:617
unsigned int generateId(void)
void RunOnLmdFiles(UInt_t NStart=0, UInt_t NStop=0)
Definition: FairRunAna.cxx:552
Bool_t fStoreEventHeader
Definition: FairRunAna.h:141
Bool_t fLoadGeo
Definition: FairRunAna.h:117
void ReInitTask()
Definition: FairTask.cxx:58
FairRootManager * fRootManager
Definition: FairRun.h:193
void SetRunId(UInt_t runid)
FairTask * fTask
Definition: FairRun.h:191
void WriteFileHeader(FairFileHeader *f)
FairEventHeader * GetEventHeader()
Definition: FairRun.cxx:112
Bool_t fInFileIsOpen
Definition: FairRunAna.h:122
void RunTSBuffers()
Definition: FairRunAna.cxx:524
FairEventHeader * fEvtHeader
Definition: FairRun.h:205
ClassImp(FairEventBuilder)
void Run(Int_t NStart=0, Int_t NStop=0)
Definition: FairRunAna.cxx:275
static FairFieldFactory * Instance()
virtual void SetParm()
Int_t ReadNonTimeBasedEventFromBranches(Int_t i=0)
FairField * fField
Definition: FairRunAna.h:120
FairParSet * getContainer(const Text_t *)
Int_t Write(const char *name=0, Int_t option=0, Int_t bufsize=0)
Bool_t initContainers(Int_t runId, Int_t refId=-1, const Text_t *fileName="")
void FRA_handler_ctrlc(int)
Definition: FairRunAna.cxx:51
void RunMQ(Long64_t entry)
Definition: FairRunAna.cxx:478
void StoreInfo()
Definition: FairRunInfo.cxx:36
static FairRunAna * Instance()
Definition: FairRunAna.cxx:61
void StoreAllWriteoutBufferData()
virtual void Register(Bool_t Persistance=kTRUE)
FairMQExParamsParOne * par
void RunOnTBData()
Definition: FairRunAna.cxx:573
void SetContainerStatic(Bool_t tempBool=kTRUE)
Definition: FairRunAna.cxx:637
FairFileHeader * fFileHeader
Definition: FairRun.h:207
virtual void FinishTask()
Definition: FairTask.cxx:90
static FairRunAna * fgRinstance
Definition: FairRunAna.h:116
Double_t GetEventTime()
static FairTrajFilter * Instance()
void InitTask()
Definition: FairTask.cxx:41
void RunEventReco(Int_t NStart, Int_t NStop)
Definition: FairRunAna.cxx:380
FairRuntimeDb * GetRuntimeDb(void)
Definition: FairRun.h:80
virtual ~FairRunAna()
Definition: FairRunAna.cxx:91
Bool_t fMarkFill
Definition: FairRun.h:213
Bool_t fGenerateRunInfo
Definition: FairRun.h:209
Bool_t ReadNextEvent(Double_t dt)
Bool_t fStatic
Definition: FairRunAna.h:119
FairRtdbRun * addRun(Int_t runId, Int_t refId=-1)
Bool_t fFinishProcessingLMDFile
Definition: FairRunAna.h:134
UInt_t fRunId
Definition: FairRun.h:201
void UpdateListOfTimebasedBranches()
void RunWithTimeStamps()
Definition: FairRunAna.cxx:624
void DummyRun(Int_t NStart, Int_t NStop)
Definition: FairRunAna.cxx:587
virtual void FinishEvent()
Definition: FairTask.cxx:82
FairRuntimeDb * fRtdb
Definition: FairRun.h:189
void SetRunId(UInt_t runid)
void DeleteOldWriteoutBufferData()
TFile * fInputGeoFile
Definition: FairRunAna.h:115
void StoreWriteoutBufferData(Double_t eventTime)
void SetGeomFile(const char *GeoFileName)
Definition: FairRunAna.cxx:106
virtual void Fill()
Definition: FairRunAna.cxx:647
FairTrajFilter * fTrajFilter
Bool_t fIsInitialized
Definition: FairRunAna.h:114
void Init(TString brName="GeoTracks", TString folderName="MCGeoTrack")
void SetParTask()
Definition: FairTask.cxx:73
void FillEventHeader(FairEventHeader *feh)