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