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