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