Possibility to store and retrieve TGeo geometry to/from file (R.Grosso)
[u/mrichter/AliRoot.git] / STEER / AliRun.cxx
1 /**************************************************************************
2  * Copyright(c) 1998-1999, ALICE Experiment at CERN, All rights reserved. *
3  *                                                                        *
4  * Author: The ALICE Off-line Project.                                    *
5  * Contributors are mentioned in the code where appropriate.              *
6  *                                                                        *
7  * Permission to use, copy, modify and distribute this software and its   *
8  * documentation strictly for non-commercial purposes is hereby granted   *
9  * without fee, provided that the above copyright notice appears in all   *
10  * copies and that both the copyright notice and this permission notice   *
11  * appear in the supporting documentation. The authors make no claims     *
12  * about the suitability of this software for any purpose. It is          *
13  * provided "as is" without express or implied warranty.                  *
14  **************************************************************************/
15
16 /* $Id$ */
17
18 ///////////////////////////////////////////////////////////////////////////////
19 //                                                                           //
20 //  Control class for Alice C++                                              //
21 //  Only one single instance of this class exists.                           //
22 //  The object is created in main program aliroot                            //
23 //  and is pointed by the global gAlice.                                     //
24 //                                                                           //
25 //   -Supports the list of all Alice Detectors (fModules).                 //
26 //   -Supports the list of particles (fParticles).                           //
27 //   -Supports the Trees.                                                    //
28 //   -Supports the geometry.                                                 //
29 //   -Supports the event display.                                            //
30 //Begin_Html
31 /*
32 <img src="picts/AliRunClass.gif">
33 */
34 //End_Html
35 //Begin_Html
36 /*
37 <img src="picts/alirun.gif">
38 */
39 //End_Html
40 //                                                                           //
41 ///////////////////////////////////////////////////////////////////////////////
42
43 #include <TBRIK.h> 
44 #include <TCint.h> 
45 #include <TDatabasePDG.h>
46 #include <TGeometry.h>
47 #include <TNode.h>
48 #include <TROOT.h>
49 #include <TRandom3.h>
50 #include <TSystem.h>
51 #include <TVirtualMC.h>
52 #include <TGeoManager.h>
53 // 
54 #include "AliLog.h"
55 #include "AliDetector.h"
56 #include "AliDisplay.h"
57 #include "AliHeader.h"
58 #include "AliLego.h"
59 #include "AliLegoGenerator.h"
60 #include "AliMC.h"
61 #include "AliMagFC.h"
62 #include "AliMagFCM.h"
63 #include "AliMagFDM.h"
64 #include "AliPDG.h"
65 #include "AliRun.h"
66 #include "AliStack.h"
67 #ifdef __APPLE__
68 //#include "AliTPCTrackHitsInterfaces.h"
69 #endif
70
71 AliRun *gAlice;
72
73 ClassImp(AliRun)
74
75 //_______________________________________________________________________
76 AliRun::AliRun():
77   fRun(0),
78   fEvent(0),
79   fEventNrInRun(0),
80   fEventsPerRun(0),
81   fModules(0),
82   fGeometry(0),
83   fMCApp(0),
84   fDisplay(0),
85   fField(0),
86   fMC(0),
87   fNdets(0),
88   fInitDone(kFALSE),
89   fLego(0),
90   fPDGDB(0),  //Particle factory object
91   fConfigFunction("\0"),
92   fRandom(0),
93   fIsRootGeometry(kFALSE),
94   fRunLoader(0x0)
95 {
96   //
97   // Default constructor for AliRun
98   //
99   AliConfig::Instance();//skowron 29 Feb 2002
100                         //ensures that the folder structure is build
101 }
102
103 //_______________________________________________________________________
104 AliRun::AliRun(const AliRun& arun):
105   TNamed(arun),
106   fRun(0),
107   fEvent(0),
108   fEventNrInRun(0),
109   fEventsPerRun(0),
110   fModules(0),
111   fGeometry(0),
112   fMCApp(0),
113   fDisplay(0),
114   fField(0),
115   fMC(0),
116   fNdets(0),
117   fInitDone(kFALSE),
118   fLego(0),
119   fPDGDB(0),  //Particle factory object
120   fConfigFunction("\0"),
121   fRandom(0),
122   fIsRootGeometry(kFALSE),
123   fRunLoader(0x0)
124 {
125   //
126   // Copy constructor for AliRun
127   //
128   arun.Copy(*this);
129 }
130
131 //_____________________________________________________________________________
132 AliRun::AliRun(const char *name, const char *title):
133   TNamed(name,title),
134   fRun(0),
135   fEvent(0),
136   fEventNrInRun(0),
137   fEventsPerRun(0),
138   fModules(new TObjArray(77)), // Support list for the Detectors
139   fGeometry(0),
140   fMCApp(0),
141   fDisplay(0),
142   fField(0),
143   fMC(gMC),
144   fNdets(0),
145   fInitDone(kFALSE),
146   fLego(0),
147   fPDGDB(TDatabasePDG::Instance()),        //Particle factory object!
148   fConfigFunction("Config();"),
149   fRandom(new TRandom3()),
150   fIsRootGeometry(kFALSE),
151   fRunLoader(0x0)
152 {
153   //
154   //  Constructor for the main processor.
155   //  Creates the geometry
156   //  Creates the list of Detectors.
157   //  Creates the list of particles.
158   //
159
160   gAlice     = this;
161
162   // Set random number generator
163   gRandom = fRandom;
164
165   if (gSystem->Getenv("CONFIG_SEED")) {
166      gRandom->SetSeed(static_cast<UInt_t>(atoi(gSystem->Getenv("CONFIG_SEED"))));
167   }
168
169   // Add to list of browsable  
170   gROOT->GetListOfBrowsables()->Add(this,name);
171   // Create the TNode geometry for the event display
172   BuildSimpleGeometry();
173   
174   // Create default mag field
175   SetField();
176
177   // Add particle list to configuration
178   AliConfig::Instance()->Add(fPDGDB); 
179
180 #ifdef __APPLE__
181   // Terrible hack to avoid problem with the initialisation of 
182   // static and globals on Mac OS X 
183   //  AliClassAliTrackHitsInfo p1=galiclass____AliClassAliTrackHitsInfo;
184   // AliClassAliTrackHitsParam p2=galiclass____AliTrackHitsParam;
185   //AliClassAliHitInfo p3=galiclass____AliHitInfo;
186 #endif
187
188 }
189
190
191 //_______________________________________________________________________
192 AliRun::~AliRun()
193 {
194   //
195   // Default AliRun destructor
196   //
197   gROOT->GetListOfBrowsables()->Remove(this);
198
199   if (fRunLoader)
200    {
201     TFolder* evfold = fRunLoader->GetEventFolder();
202     TFolder* modfold = dynamic_cast<TFolder*>(evfold->FindObjectAny(AliConfig::GetModulesFolderName()));
203     TIter next(fModules);
204     AliModule *mod;
205     while((mod = (AliModule*)next()))
206      { 
207        modfold->Remove(mod);
208      }
209    }
210   
211   
212   delete fField;
213   delete fMCApp;
214   delete gMC; gMC=0;
215   delete fGeometry;
216   delete fDisplay;
217   delete fLego;
218   if (fModules) {
219     fModules->Delete();
220     delete fModules;
221   }
222   
223   delete fPDGDB;
224 }
225
226 //_______________________________________________________________________
227 void AliRun::Copy(TObject &) const
228 {
229   AliFatal("Not implemented!");
230 }
231
232 //_______________________________________________________________________
233 void AliRun::Build()
234 {
235   //
236   // Initialize Alice geometry
237   // Dummy routine
238   //
239 }
240  
241 //_______________________________________________________________________
242 void AliRun::BuildSimpleGeometry()
243 {
244   //
245   // Create a simple TNode geometry used by Root display engine
246   //
247   // Initialise geometry
248   //
249   fGeometry = new TGeometry("AliceGeom","Galice Geometry for Hits");
250   new TMaterial("void","Vacuum",0,0,0);  //Everything is void
251   TBRIK *brik = new TBRIK("S_alice","alice volume","void",2000,2000,3000);
252   brik->SetVisibility(0);
253   new TNode("alice","alice","S_alice");
254 }
255
256 //_______________________________________________________________________
257 void AliRun::CleanDetectors()
258 {
259   //
260   // Clean Detectors at the end of event
261   //
262    fRunLoader->CleanDetectors();
263 }
264
265 //_______________________________________________________________________
266 void AliRun::ResetHits() 
267 {
268   fMCApp->ResetHits();
269 }
270
271 //_______________________________________________________________________
272 AliGenerator* AliRun::Generator() const 
273 {
274   return fMCApp->Generator();
275 }
276
277 //_______________________________________________________________________
278 void  AliRun::SetField(AliMagF* magField)
279 {
280   //
281   // Set Magnetic Field Map
282   //
283   fField = magField;
284   fField->ReadField();
285 }
286
287 //_______________________________________________________________________
288 void AliRun::SetRootGeometry(Bool_t flag)
289 {
290 // Instruct application that the geometry is to be retreived from a root file.
291    fIsRootGeometry = flag;
292    if (flag) gMC->SetRootGeometry();
293 }
294 //_______________________________________________________________________
295 void AliRun::SetField(Int_t type, Int_t version, Float_t scale,
296                       Float_t maxField, const char* filename)
297 {
298   //
299   //  Set magnetic field parameters
300   //  type      Magnetic field transport flag 0=no field, 2=helix, 3=Runge Kutta
301   //  version   Magnetic field map version (only 1 active now)
302   //  scale     Scale factor for the magnetic field
303   //  maxField  Maximum value for the magnetic field
304
305   //
306   // --- Sanity check on mag field flags
307   if(fField) delete fField;
308   if(version==1) {
309     fField = new AliMagFC("Map1"," ",type,scale,maxField);
310   } else if(version<=2) {
311     fField = new AliMagFCM("Map2-3",filename,type,scale,maxField);
312     fField->ReadField();
313   } else if(version==3) {
314     fField = new AliMagFDM("Map4",filename,type,scale,maxField);
315     fField->ReadField();
316   } else {
317     AliWarning(Form("Invalid map %d",version));
318   }
319 }
320
321 //_____________________________________________________________________________
322
323 void AliRun::InitLoaders()
324 {
325   //creates list of getters
326   AliDebug(1, "");
327   TIter next(fModules);
328   AliModule *mod;
329   while((mod = (AliModule*)next()))
330    { 
331      mod->SetRunLoader(fRunLoader);
332      AliDetector *det = dynamic_cast<AliDetector*>(mod);
333      if (det) 
334       {
335         AliDebug(2, Form("Adding %s", det->GetName()));
336         fRunLoader->AddLoader(det);
337       }
338    }
339   AliDebug(1, "Done");
340 }
341 //_____________________________________________________________________________
342
343 void AliRun::FinishRun()
344 {
345   //
346   // Called at the end of the run.
347   //
348   
349   if(fLego) 
350    {
351     AliDebug(1, "Finish Lego");
352     fRunLoader->CdGAFile();
353     fLego->FinishRun();
354    }
355   
356   // Clean detector information
357   TIter next(fModules);
358   AliModule *detector;
359   while((detector = dynamic_cast<AliModule*>(next()))) {
360     AliDebug(2, Form("%s->FinishRun()", detector->GetName()));
361     detector->FinishRun();
362   }
363   
364   AliDebug(1, "fRunLoader->WriteHeader(OVERWRITE)");
365   fRunLoader->WriteHeader("OVERWRITE");
366
367   // Write AliRun info and all detectors parameters
368   fRunLoader->CdGAFile();
369   Write(0,TObject::kOverwrite);//write AliRun
370   fRunLoader->Write(0,TObject::kOverwrite);//write RunLoader itself
371   
372   // Clean tree information
373   AliDebug(1, "fRunLoader->Stack()->FinishRun()");
374   fRunLoader->Stack()->FinishRun();
375
376   if(fMCApp) fMCApp->FinishRun();
377
378   fRunLoader->Synchronize();
379 }
380
381 //_______________________________________________________________________
382 void AliRun::Announce() const
383 {
384   //
385   // Announce the current version of AliRoot
386   //
387   printf("%70s",
388          "****************************************************************\n");
389   printf("%6s","*");printf("%64s","*\n");
390
391   printf("%6s","*");
392   printf("    You are running AliRoot version NewIO\n");
393
394   printf("%6s","*");
395   printf("    The cvs tag for the current program is $Name$\n");
396
397   printf("%6s","*");printf("%64s","*\n");
398   printf("%70s",
399          "****************************************************************\n");
400 }
401
402 //_______________________________________________________________________
403 AliModule *AliRun::GetModule(const char *name) const
404 {
405   //
406   // Return pointer to detector from name
407   //
408   return dynamic_cast<AliModule*>(fModules->FindObject(name));
409 }
410  
411 //_______________________________________________________________________
412 AliDetector *AliRun::GetDetector(const char *name) const
413 {
414   //
415   // Return pointer to detector from name
416   //
417   return dynamic_cast<AliDetector*>(fModules->FindObject(name));
418 }
419  
420 //_______________________________________________________________________
421 Int_t AliRun::GetModuleID(const char *name) const
422 {
423   //
424   // Return galice internal detector identifier from name
425   //
426   Int_t i=-1;
427   TObject *mod=fModules->FindObject(name);
428   if(mod) i=fModules->IndexOf(mod);
429   return i;
430 }
431  
432 //_______________________________________________________________________
433 Int_t AliRun::GetEvent(Int_t event)
434 {
435 //
436 // Reloads data containers in folders # event
437 // Set branch addresses
438 //
439   if (fRunLoader == 0x0)
440    {
441      AliError("RunLoader is not set. Can not load data.");
442      return -1;
443    }
444 /*****************************************/ 
445 /****   P R E    R E L O A D I N G    ****/
446 /*****************************************/ 
447 // Reset existing structures
448   fMCApp->ResetHits();
449   fMCApp->ResetTrackReferences();
450   ResetDigits();
451   ResetSDigits();
452
453 /*****************************************/ 
454 /****       R  E  L  O  A  D          ****/
455 /*****************************************/
456
457   fRunLoader->GetEvent(event);
458
459 /*****************************************/ 
460 /****  P O S T    R E L O A D I N G   ****/
461 /*****************************************/ 
462
463   // Set Trees branch addresses
464   TIter next(fModules);
465   AliModule *detector;
466   while((detector = dynamic_cast<AliModule*>(next()))) 
467    {
468      detector->SetTreeAddress();
469    }
470  
471   return fRunLoader->GetHeader()->GetNtrack();
472 }
473
474 //_______________________________________________________________________
475 TGeometry *AliRun::GetGeometry()
476 {
477   //
478   // Import Alice geometry from current file
479   // Return pointer to geometry object
480   //
481   if (!fGeometry) fGeometry = dynamic_cast<TGeometry*>(gDirectory->Get("AliceGeom"));
482   //
483   // Unlink and relink nodes in detectors
484   // This is bad and there must be a better way...
485   //
486   
487   TIter next(fModules);
488   AliModule *detector;
489   while((detector = dynamic_cast<AliModule*>(next()))) {
490     TList *dnodes=detector->Nodes();
491     Int_t j;
492     TNode *node, *node1;
493     for ( j=0; j<dnodes->GetSize(); j++) {
494       node = dynamic_cast<TNode*>(dnodes->At(j));
495       node1 = fGeometry->GetNode(node->GetName());
496       dnodes->Remove(node);
497       dnodes->AddAt(node1,j);
498     }
499   }
500   return fGeometry;
501 }
502
503 //_______________________________________________________________________
504 void AliRun::SetBaseFile(const char *filename)
505 {
506   fBaseFileName = filename;
507 }
508
509 //_______________________________________________________________________
510 void AliRun::ResetDigits()
511 {
512   //
513   //  Reset all Detectors digits
514   //
515   TIter next(fModules);
516   AliModule *detector;
517   while((detector = dynamic_cast<AliModule*>(next()))) {
518      detector->ResetDigits();
519   }
520 }
521
522 //_______________________________________________________________________
523 void AliRun::ResetSDigits()
524 {
525   //
526   //  Reset all Detectors digits
527   //
528   TIter next(fModules);
529   AliModule *detector;
530   while((detector = dynamic_cast<AliModule*>(next()))) {
531      detector->ResetSDigits();
532   }
533 }
534
535
536 //_______________________________________________________________________
537
538 void AliRun::ResetPoints()
539 {
540   //
541   // Reset all Detectors points
542   //
543   TIter next(fModules);
544   AliModule *detector;
545   while((detector = dynamic_cast<AliModule*>(next()))) {
546      detector->ResetPoints();
547   }
548 }
549 //_______________________________________________________________________
550
551 void AliRun::InitMC(const char *setup)
552 {
553   //
554   // Initialize ALICE Simulation run
555   //
556   Announce();
557
558   if(fInitDone) {
559     AliWarning("Cannot initialise AliRun twice!");
560     return;
561   }
562     
563   if (!fMCApp)  
564     fMCApp=new AliMC(GetName(),GetTitle());
565     
566   gROOT->LoadMacro(setup);
567   gInterpreter->ProcessLine(fConfigFunction.Data());
568
569   fRunLoader->CdGAFile();
570
571   AliPDG::AddParticlesToPdgDataBase();  
572
573   fNdets = fModules->GetLast()+1;
574
575   TIter next(fModules);
576   for(Int_t i=0; i<fNdets; ++i)
577    {
578      TObject *objfirst, *objlast;
579      AliModule *detector=dynamic_cast<AliModule*>(fModules->At(i));
580      objlast = gDirectory->GetList()->Last();
581       
582      // Add Detector histograms in Detector list of histograms
583      if (objlast) objfirst = gDirectory->GetList()->After(objlast);
584      else         objfirst = gDirectory->GetList()->First();
585      while (objfirst) 
586       {
587         detector->Histograms()->Add(objfirst);
588         objfirst = gDirectory->GetList()->After(objfirst);
589       }
590    }
591    
592    fMCApp->Init();
593    
594    //Must be here because some MCs (G4) adds detectors here and not in Config.C
595    InitLoaders();
596    fRunLoader->MakeTree("E");
597    if (fLego == 0x0)
598     {
599       fRunLoader->LoadKinematics("RECREATE");
600       fRunLoader->LoadTrackRefs("RECREATE");
601       fRunLoader->LoadHits("all","RECREATE");
602     }
603    fInitDone = kTRUE;
604    //
605    // Save stuff at the beginning of the file to avoid file corruption
606    fRunLoader->CdGAFile();
607    Write();
608    fEventNrInRun = -1; //important - we start Begin event from increasing current number in run
609 }
610
611 //_______________________________________________________________________
612
613 void AliRun::RunMC(Int_t nevent, const char *setup)
614 {
615   //
616   // Main function to be called to process a galice run
617   // example
618   //    Root > gAlice.Run(); 
619   // a positive number of events will cause the finish routine
620   // to be called
621   //
622   fEventsPerRun = nevent;
623   // check if initialisation has been done
624   if (!fInitDone) InitMC(setup);
625   
626   // Create the Root Tree with one branch per detector
627   //Hits moved to begin event -> now we are crating separate tree for each event
628
629   gMC->ProcessRun(nevent);
630
631   // End of this run, close files
632   if(nevent>0) FinishRun();
633 }
634
635 //_______________________________________________________________________
636 void AliRun::RunReco(const char *selected, Int_t first, Int_t last)
637 {
638   //
639   // Main function to be called to reconstruct Alice event
640   // 
641    Int_t nev = fRunLoader->GetNumberOfEvents();
642    AliDebug(1, Form("Found %d events", nev));
643    Int_t nFirst = first;
644    Int_t nLast  = (last < 0)? nev : last;
645    
646    for (Int_t nevent = nFirst; nevent <= nLast; nevent++) {
647      AliDebug(1, Form("Processing event %d", nevent));
648      GetEvent(nevent);
649      Digits2Reco(selected);
650    }
651 }
652
653 //_______________________________________________________________________
654
655 void AliRun::Hits2Digits(const char *selected)
656 {
657
658    // Convert Hits to sumable digits
659    // 
660    for (Int_t nevent=0; nevent<gAlice->TreeE()->GetEntries(); nevent++) {
661      GetEvent(nevent);
662      Hits2SDigits(selected);
663      SDigits2Digits(selected);
664    }  
665 }
666
667
668 //_______________________________________________________________________
669
670 void AliRun::Tree2Tree(Option_t *option, const char *selected)
671 {
672   //
673   // Function to transform the content of
674   //  
675   // - TreeH to TreeS (option "S")
676   // - TreeS to TreeD (option "D")
677   // - TreeD to TreeR (option "R")
678   // 
679   // If multiple options are specified ("SDR"), transformation will be done in sequence for
680   // selected detector and for all detectors if none is selected (detector string 
681   // can contain blank separated list of detector names). 
682
683
684    const char *oS = strstr(option,"S");
685    const char *oD = strstr(option,"D");
686    const char *oR = strstr(option,"R");
687    
688    TObjArray *detectors = Detectors();
689
690    TIter next(detectors);
691
692    AliDetector *detector = 0;
693
694    while((detector = dynamic_cast<AliDetector*>(next()))) {
695      if (selected) 
696        if (strcmp(detector->GetName(),selected)) continue;
697      if (detector->IsActive())
698       { 
699        
700        AliLoader* loader = detector->GetLoader();
701        if (loader == 0x0) continue;
702        
703        if (oS) 
704         {
705           AliDebug(1, Form("Processing Hits2SDigits for %s ...", detector->GetName()));
706           loader->LoadHits("read");
707           if (loader->TreeS() == 0x0) loader->MakeTree("S");
708           detector->MakeBranch(option);
709           detector->SetTreeAddress();
710           detector->Hits2SDigits();
711           loader->UnloadHits();
712           loader->UnloadSDigits();
713         }  
714        if (oD) 
715         {
716           AliDebug(1, Form("Processing SDigits2Digits for %s ...", detector->GetName()));
717           loader->LoadSDigits("read");
718           if (loader->TreeD() == 0x0) loader->MakeTree("D");
719           detector->MakeBranch(option);
720           detector->SetTreeAddress();
721           detector->SDigits2Digits();
722           loader->UnloadSDigits();
723           loader->UnloadDigits();
724         } 
725        if (oR) 
726         {
727           AliDebug(1, Form("Processing Digits2Reco for %s ...", detector->GetName()));
728           loader->LoadDigits("read");
729           if (loader->TreeR() == 0x0) loader->MakeTree("R");
730           detector->MakeBranch(option);
731           detector->SetTreeAddress();
732           detector->Digits2Reco(); 
733           loader->UnloadDigits();
734           loader->UnloadRecPoints();
735
736         }
737      }   
738    }
739 }
740
741 //_______________________________________________________________________
742 void AliRun::RunLego(const char *setup, Int_t nc1, Float_t c1min,
743                      Float_t c1max,Int_t nc2,Float_t c2min,Float_t c2max,
744                      Float_t rmin,Float_t rmax,Float_t zmax, AliLegoGenerator* gener)
745 {
746   //
747   // Generates lego plots of:
748   //    - radiation length map phi vs theta
749   //    - radiation length map phi vs eta
750   //    - interaction length map
751   //    - g/cm2 length map
752   //
753   //  ntheta    bins in theta, eta
754   //  themin    minimum angle in theta (degrees)
755   //  themax    maximum angle in theta (degrees)
756   //  nphi      bins in phi
757   //  phimin    minimum angle in phi (degrees)
758   //  phimax    maximum angle in phi (degrees)
759   //  rmin      minimum radius
760   //  rmax      maximum radius
761   //  
762   //
763   //  The number of events generated = ntheta*nphi
764   //  run input parameters in macro setup (default="Config.C")
765   //
766   //  Use macro "lego.C" to visualize the 3 lego plots in spherical coordinates
767   //Begin_Html
768   /*
769     <img src="picts/AliRunLego1.gif">
770   */
771   //End_Html
772   //Begin_Html
773   /*
774     <img src="picts/AliRunLego2.gif">
775   */
776   //End_Html
777   //Begin_Html
778   /*
779     <img src="picts/AliRunLego3.gif">
780   */
781   //End_Html
782   //
783
784   // check if initialisation has been done
785   // If runloader has been initialized, set the number of events per file to nc1 * nc2
786
787   // Set new generator
788   if (!gener) gener  = new AliLegoGenerator();
789   //
790   // Configure Generator
791   gener->SetRadiusRange(rmin, rmax);
792   gener->SetZMax(zmax);
793   gener->SetCoor1Range(nc1, c1min, c1max);
794   gener->SetCoor2Range(nc2, c2min, c2max);
795   
796   
797   //Create Lego object  
798   fLego = new AliLego("lego",gener);
799
800   if (!fInitDone) InitMC(setup);
801   //Save current generator
802   
803   AliGenerator *gen=fMCApp->Generator();
804   fMCApp->ResetGenerator(gener);
805   //Prepare MC for Lego Run
806   gMC->InitLego();
807   
808   //Run Lego Object
809
810   if (fRunLoader) fRunLoader->SetNumberOfEventsPerFile(nc1 * nc2);
811   //gMC->ProcessRun(nc1*nc2+1);
812   gMC->ProcessRun(nc1*nc2);
813   
814   // End of this run, close files
815   FinishRun();
816   // Restore current generator
817   fMCApp->ResetGenerator(gen);
818   // Delete Lego Object
819   delete fLego; fLego=0;
820 }
821
822 //_______________________________________________________________________
823 void AliRun::SetConfigFunction(const char * config) 
824 {
825   //
826   // Set the signature of the function contained in Config.C to configure
827   // the run
828   //
829   fConfigFunction=config;
830 }
831
832 // 
833 // MC Application
834 // 
835
836 //_______________________________________________________________________
837 void AliRun::Field(const Double_t* x, Double_t *b) const
838 {
839   //
840   // Return the value of the magnetic field
841   //
842   Float_t xfloat[3];
843   for (Int_t i=0; i<3; i++) xfloat[i] = x[i]; 
844   
845   if (Field()) {
846     Float_t bfloat[3];
847     Field()->Field(xfloat,bfloat);
848     for (Int_t j=0; j<3; j++) b[j] = bfloat[j]; 
849   } 
850   else {
851     AliError("No mag field defined!");
852     b[0]=b[1]=b[2]=0.;
853   }
854 }      
855
856 // 
857 // End of MC Application
858 // 
859
860 //_______________________________________________________________________
861 void AliRun::Streamer(TBuffer &R__b)
862 {
863   // Stream an object of class AliRun.
864
865   if (R__b.IsReading()) {
866     if (!gAlice) gAlice = this;
867     AliRun::Class()->ReadBuffer(R__b, this);
868     gROOT->GetListOfBrowsables()->Add(this,"Run");
869
870     gRandom = fRandom;
871   } else {
872     AliRun::Class()->WriteBuffer(R__b, this);
873   }
874 }
875 //_______________________________________________________________________
876
877 void AliRun::SetGenEventHeader(AliGenEventHeader* header)
878 {
879   fRunLoader->GetHeader()->SetGenEventHeader(header);
880 }
881 //_______________________________________________________________________
882
883 Int_t AliRun::GetEvNumber() const
884
885 //Returns number of current event  
886   if (fRunLoader == 0x0)
887    {
888      AliError("RunLoader is not set. Can not load data.");
889      return -1;
890    }
891
892   return fRunLoader->GetEventNumber();
893 }
894 //_______________________________________________________________________
895
896 void AliRun::SetRunLoader(AliRunLoader* rloader)
897 {
898   //
899   // Set the loader of the run
900   //
901   fRunLoader = rloader;
902   if (fRunLoader == 0x0) return;
903   
904   TString evfoldname;
905   TFolder* evfold = fRunLoader->GetEventFolder();
906   if (evfold) evfoldname = evfold->GetName();
907   else AliWarning("Did not get Event Folder from Run Loader");
908   
909   if ( fRunLoader->GetAliRun() )
910    {//if alrun already exists in folder
911     if (fRunLoader->GetAliRun() != this )
912      {//and is different than this - crash
913        AliFatal("AliRun is already in Folder and it is not this object");
914        return;//pro forma
915      }//else do nothing
916    }
917   else
918    {
919      evfold->Add(this);//Post this AliRun to Folder
920    }
921   
922   TIter next(fModules);
923   AliModule *module;
924   while((module = (AliModule*)next())) 
925    {
926      if (evfold) AliConfig::Instance()->Add(module,evfoldname);
927      module->SetRunLoader(fRunLoader);
928      AliDetector* detector = dynamic_cast<AliDetector*>(module);
929      if (detector)
930       {
931         AliLoader* loader = fRunLoader->GetLoader(detector);
932         if (loader == 0x0)
933          {
934            AliError(Form("Can not get loader for detector %s", detector->GetName()));
935          }
936         else
937          {
938            AliDebug(1, Form("Setting loader for detector %s", detector->GetName()));
939            detector->SetLoader(loader);
940          }
941       }
942    }
943 }
944
945 void AliRun::AddModule(AliModule* mod)
946 {
947   //
948   // Add a module to the module list
949   //
950   if (mod == 0x0) return;
951   if (strlen(mod->GetName()) == 0) return;
952   if (GetModuleID(mod->GetName()) >= 0) return;
953   
954   AliDebug(1, mod->GetName());
955   if (fRunLoader == 0x0) AliConfig::Instance()->Add(mod);
956   else AliConfig::Instance()->Add(mod,fRunLoader->GetEventFolder()->GetName());
957
958   Modules()->Add(mod);
959   
960   fNdets++;
961 }
962
963 // added by Alberto Colla
964 //_____________________________________________________________________________
965 /*inline*/ Bool_t AliRun::IsFileAccessible(const char* fnam, EAccessMode mode)
966 { return !gSystem->AccessPathName(fnam,mode);}
967
968 //______________________________________________________
969 /*inline*/ Bool_t AliRun::IsFileAccessible(Char_t* name,EAccessMode mode)
970 {
971   TString str = name; gSystem->ExpandPathName(str);
972   return !gSystem->AccessPathName(str.Data(),mode);
973 }
974
975