Corrected protection.
[u/mrichter/AliRoot.git] / STEER / AliRunLoader.h
1 #ifndef ALIRUNLoader_H
2 #define ALIRUNLoader_H
3
4 //___________________________________________________________________
5 /////////////////////////////////////////////////////////////////////
6 //                                                                 //
7 //  class AliRunLoader                                             //
8 //                                                                 //
9 //  This class aims to be the only one interface for manging data  //
10 //  It stores Loaders for all modules which knows the filenames    //
11 //  of the data files to be stored.                                //
12 //  It aims to substitude AliRun in automatic managing of data     //
13 //  positioning thus there won't be necessity of loading gAlice    //
14 //  from file in order to get fast access to the data              //
15 //                                                                 //
16 //  Logical place to put the specific Loader to the given          //
17 //  detector is detector  itself (i.e ITSLoader in ITS).           //
18 //  But, to load detector object one need to load gAlice, and      //
19 //  by the way all other detectors with their geometrieces and     //
20 //  so on. So, if one need to open TPC clusters there is no        //
21 //  principal nedd to read everything.                             //
22 //                                                                 //
23 /////////////////////////////////////////////////////////////////////
24
25 #include <TNamed.h>
26
27 #include "AliConfig.h"
28 #include "AliLoader.h"
29 #include "AliDataLoader.h"
30 #include "AliLog.h"
31
32 class TFile;
33 class TString;
34 class TFolder;
35 class TObjArray;
36 class TTree;
37 class TTask;
38 class TParticle;
39
40 class AliRun;
41 class AliLoader;
42 class AliDetector;
43 class AliHeader;
44 class AliStack;
45 class AliRunDigitizer;
46 class AliCDBEntry;
47 class AliCentralTrigger;
48
49 class AliRunLoader: public TNamed
50 {
51   public:
52     
53     AliRunLoader();
54     AliRunLoader(const char* topfoldername);
55     AliRunLoader(TFolder* topfolder);
56     
57     virtual ~AliRunLoader();
58     
59     static AliRunLoader* Open(const char* filename = "galice.root",
60                               const char* eventfoldername = AliConfig::GetDefaultEventFolderName(),
61                   Option_t* option = "READ");
62
63     Int_t       GetEventNumber() const {return fCurrentEvent;}
64
65     Int_t       GetEvent(Int_t evno);//sets the event number and reloads data in folders properly
66     Int_t       GetNextEvent(){return GetEvent(fCurrentEvent+1);}//gets next event 
67     Int_t       SetEventNumber(Int_t evno); //cleans folders and sets the root dirs in files (do not reload data)
68     Int_t       SetNextEvent(){return SetEventNumber(fCurrentEvent+1);}
69     
70     Int_t       GetNumberOfEvents();
71     
72     AliCDBEntry* GetCDBEntry(const char* name) const;
73
74     void        MakeTree(Option_t *option);
75     void        MakeHeader();
76     void        MakeTrigger();
77     void        MakeStack();
78     
79     Int_t       LoadgAlice();
80     Int_t       LoadHeader();
81     Int_t       LoadKinematics(Option_t* option = "READ");
82     Int_t       LoadTrigger(Option_t* option = "READ");
83     Int_t       LoadTrackRefs(Option_t* option = "READ");
84     
85     void        UnloadHeader();
86     void        UnloadTrigger();
87     void        UnloadKinematics();
88     void        UnloadgAlice();
89     void        UnloadTrackRefs();
90     
91     void        SetKineFileName(const TString& fname){fKineDataLoader->SetFileName(fname);}
92     void        SetTrackRefsFileName(const TString& fname){fTrackRefsDataLoader->SetFileName(fname);}
93     
94     TTree*      TreeE() const; //returns the tree from folder; shortcut method
95     TTree*      TreeCT() const; //returns the tree from folder; shortcut method
96     AliHeader*  GetHeader() const;
97     AliCentralTrigger*  GetTrigger() const;
98     
99     AliStack*   Stack() const {return fStack;}
100     
101     TTree*      TreeK() const; //returns the tree from folder; shortcut method
102     TTree*      TreeTR() const; //returns the tree from folder; shortcut method    
103     
104     AliRun*     GetAliRun()const;
105     Int_t       GetRunNumber() const {return fRun;}
106     void        SetRunNumber(Int_t run) {fRun=run;}
107         
108     Int_t       WriteHeader(Option_t* opt="");
109     Int_t       WriteTrigger(Option_t* opt="");
110     Int_t       WriteAliRun(Option_t* opt="");
111     Int_t       WriteKinematics(Option_t* opt="");
112     Int_t       WriteTrackRefs(Option_t* opt="");
113     Int_t       WriteRunLoader(Option_t* opt="");
114     
115     Int_t       WriteHits(Option_t* opt=""); 
116     Int_t       WriteSDigits(Option_t* opt="");
117     Int_t       WriteDigits(Option_t* opt="");
118     Int_t       WriteRecPoints(Option_t* opt="");
119     Int_t       WriteTracks(Option_t* opt="");
120     
121     Int_t       LoadHits(Option_t* detectors = "all",Option_t* opt = "READ");
122     Int_t       LoadSDigits(Option_t* detectors = "all",Option_t* opt = "READ");
123     Int_t       LoadDigits(Option_t* detectors = "all",Option_t* opt = "READ");
124     Int_t       LoadRecPoints(Option_t* detectors = "all",Option_t* opt = "READ");
125     Int_t       LoadTracks(Option_t* detectors = "all",Option_t* opt = "READ");
126     Int_t       LoadRecParticles(Option_t* detectors = "all",Option_t* opt = "READ");
127     
128     void        UnloadHits(Option_t* detectors = "all");
129     void        UnloadSDigits(Option_t* detectors = "all");
130     void        UnloadDigits(Option_t* detectors = "all");
131     void        UnloadRecPoints(Option_t* detectors = "all");
132     void        UnloadTracks(Option_t* detectors = "all");
133     void        UnloadRecParticles(Option_t* detectors = "all");
134     void        UnloadAll(Option_t* detectors = "all");    
135     
136     void        AddLoader(AliLoader* loader);
137     void        AddLoader(AliDetector* det);
138     AliLoader*  GetLoader(const char* detname) const;
139     AliLoader*  GetLoader(AliDetector* det) const;
140     Int_t       SetEventFolderName(const TString& name = AliConfig::GetDefaultEventFolderName());//sets top folder name for this run; of alread
141     void        CleanFolders();//removes all abjects from folder structure
142     void        CleanDetectors();
143     void        CleanKinematics(){Clean(fgkKineContainerName);}
144     void        CleanTrackRefs(){Clean(fgkTrackRefsContainerName);}
145     
146     void        RemoveEventFolder(); //remove folder structure from top folder 
147     void        SetCompressionLevel(Int_t cl);
148     void        SetKineComprLevel(Int_t cl);
149     void        SetTrackRefsComprLevel(Int_t cl);
150
151     TFolder*    GetEventFolder() const {return fEventFolder;}
152     void        CdGAFile();
153
154     void        MakeTrackRefsContainer();
155     void        SetDirName(TString& dirname);
156     Int_t       GetFileOffset() const;
157     void        SetNumberOfEventsPerFile(Int_t nevpf){fNEventsPerFile = nevpf;}
158     void        SetNumberOfEventsPerRun(Int_t nevpr) {fNEventsPerRun = nevpr;}
159     Int_t       GetNumberOfEventsPerRun()            {return fNEventsPerRun;}
160     void        SetDigitsFileNameSuffix(const TString& suffix);//adds the suffix before ".root", 
161                                                                //e.g. TPC.Digits.root -> TPC.DigitsMerged.root
162                                                                //made on Jiri Chudoba demand
163     TString     GetFileName() const;//returns name of galice file
164     const TObjArray* GetArrayOfLoaders() const {return fLoaders;}
165     void Cd(){fgRunLoader = this;}
166     void Synchronize();
167     
168     AliLoader*    GetDetectorLoader(const char* detname);
169     TTree*        GetTreeH(const char* detname, Bool_t maketree);
170     TTree*        GetTreeS(const char* detname, Bool_t maketree);
171     TTree*        GetTreeD(const char* detname, Bool_t maketree);
172     TTree*        GetTreeR(const char* detname, Bool_t maketree);
173     TTree*        GetTreeT(const char* detname, Bool_t maketree);
174     TTree*        GetTreeP(const char* detname, Bool_t maketree);
175
176   /******************************************/
177   /*****   Public S T A T I C Stuff   *******/
178   /******************************************/
179     static AliRunLoader* GetRunLoader(const char* eventfoldername);
180     static AliRunLoader* Instance(){return fgRunLoader;}
181     static AliLoader*    GetDetectorLoader(const char* detname, const char* eventfoldername);
182     static TTree*        GetTreeH(const char* detname, Bool_t maketree, const char* eventfoldername);
183     static TTree*        GetTreeS(const char* detname, Bool_t maketree, const char* eventfoldername);
184     static TTree*        GetTreeD(const char* detname, Bool_t maketree, const char* eventfoldername);
185     static TTree*        GetTreeR(const char* detname, Bool_t maketree, const char* eventfoldername);
186     static TTree*        GetTreeT(const char* detname, Bool_t maketree, const char* eventfoldername);
187     static TTree*        GetTreeP(const char* detname, Bool_t maketree, const char* eventfoldername);
188
189 //  Tasks are supposed to be singletons, that is why following methods are static
190     static TTask*           GetRunDigitizer();        //
191     static TTask*           GetRunSDigitizer();       //
192     static TTask*           GetRunReconstructioner(); //
193     static TTask*           GetRunTracker();          //
194     static TTask*           GetRunPIDTask();          // 
195     static TTask*           GetRunQATask();           //
196
197     static TString GetRunLoaderName () {return fgkRunLoaderName;}
198     static TString GetHeaderContainerName () {return fgkHeaderContainerName;}
199     static TString GetTriggerContainerName () {return fgkTriggerContainerName;}
200     static TString GetKineContainerName () {return fgkKineContainerName;}
201     static TString GetTrackRefsContainerName () {return fgkTrackRefsContainerName;}
202     static TString GetHeaderBranchName () {return fgkHeaderBranchName;}
203     static TString GetTriggerBranchName () {return fgkTriggerBranchName;}
204     static TString GetKineBranchName () {return fgkKineBranchName;}
205     static TString GetTriggerFileName() { return fgkDefaultTriggerFileName; }
206     static TString GetGAliceName () {return fgkGAliceName;}
207      
208 protected:
209     void               SetGAliceFile(TFile* gafile);//sets the pointer to gAlice file
210     Int_t              OpenKineFile(Option_t* opt);
211     Int_t              OpenTrackRefsFile(Option_t* opt);
212
213     Int_t              OpenDataFile(const TString& filename,TFile*& file,TDirectory*& dir,Option_t* opt,Int_t cl);
214     void               SetUnixDir(const TString& udirname);
215     const TString      SetFileOffset(const TString& fname);//adds the proper number before .root
216     void               SetDetectorAddresses();
217
218     TObjArray         *fLoaders;          //  List of Detectors
219     TFolder           *fEventFolder;      //!top folder for this run
220     
221     Int_t              fRun;               //! Current run number
222     Int_t              fCurrentEvent;//!Number of current event
223     
224     TFile             *fGAFile;//!  pointer to main file with AliRun and Run Loader -> galice.root 
225     AliHeader         *fHeader;//!  pointer to header
226     AliStack          *fStack; //!  pointer to stack
227     AliCentralTrigger *fCTrigger; //! pointer to CEntral Trigger Processor
228     
229     AliDataLoader     *fKineDataLoader;// kinematics data loader
230     AliDataLoader     *fTrackRefsDataLoader;//track reference data loader
231     
232     Int_t              fNEventsPerFile;  //defines number of events stored per one file
233     Int_t              fNEventsPerRun;   //defines number of event per run
234     TString            fUnixDirName;     //! name of unix path to directory that contains event
235     static const TString   fgkDefaultKineFileName;//default file name with kinamatics
236     static const TString   fgkDefaultTrackRefsFileName;//default file name with kinamatics
237     static const TString   fgkDefaultTriggerFileName;//default file name with trigger
238
239         
240   private:
241     AliRunLoader(const AliRunLoader &r);      //Not implemented
242     AliRunLoader & operator = (const AliRunLoader &); //Not implemented 
243     void  GetListOfDetectors(const char * namelist,TObjArray& pointerarray) const;
244     void  CleanHeader(){Clean(fgkHeaderContainerName);}
245     void  CleanTrigger(){Clean(fgkTriggerContainerName);}
246     void  Clean(const TString& name);
247     Int_t SetEvent();
248    
249     static AliRunLoader*   fgRunLoader; //pointer to the AliRunLoader instance
250
251     static const TString   fgkRunLoaderName;          //default name of the run loader
252     static const TString   fgkHeaderContainerName;    //default name of the kinematics container (TREE) name - TreeE
253     static const TString   fgkTriggerContainerName;   //default name of the trigger container (TREE) name - TreeCT
254     static const TString   fgkKineContainerName;      //default name of the kinematics container (TREE) name - TreeK
255     static const TString   fgkTrackRefsContainerName; //default name of the track references container (TREE) name - TreeTR
256     static const TString   fgkHeaderBranchName;       //default name of the branch containing the header
257     static const TString   fgkTriggerBranchName;      //default name of the branch containing the trigger
258     static const TString   fgkKineBranchName;         //default name of the branch with kinematics
259     static const TString   fgkGAliceName;             //default name for gAlice file    
260     
261     ClassDef(AliRunLoader,3)
262 };
263
264 #endif