a722f41c7e1c47035e8d386b23114cdce3c9b919
[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     AliRunLoader(const AliRunLoader &rl);
57     AliRunLoader & operator = (const AliRunLoader &rl) 
58       {rl.Copy(*this); return *this;}
59     
60     virtual ~AliRunLoader();
61     
62     static AliRunLoader* Open(const char* filename = "galice.root",
63                               const char* eventfoldername = AliConfig::GetDefaultEventFolderName(),
64                   Option_t* option = "READ");
65
66     Int_t       GetEventNumber() const {return fCurrentEvent;}
67
68     Int_t       GetEvent(Int_t evno);//sets the event number and reloads data in folders properly
69     Int_t       GetNextEvent(){return GetEvent(fCurrentEvent+1);}//gets next event 
70     Int_t       SetEventNumber(Int_t evno); //cleans folders and sets the root dirs in files (do not reload data)
71     Int_t       SetNextEvent(){return SetEventNumber(fCurrentEvent+1);}
72     
73     Int_t       GetNumberOfEvents();
74     
75     AliCDBEntry* GetCDBEntry(const char* name) const;
76
77     void        MakeTree(Option_t *option);
78     void        MakeHeader();
79     void        MakeTrigger();
80     void        MakeStack();
81     
82     Int_t       LoadgAlice();
83     Int_t       LoadHeader();
84     Int_t       LoadKinematics(Option_t* option = "READ");
85     Int_t       LoadTrigger(Option_t* option = "READ");
86     Int_t       LoadTrackRefs(Option_t* option = "READ");
87     
88     void        UnloadHeader();
89     void        UnloadTrigger();
90     void        UnloadKinematics();
91     void        UnloadgAlice();
92     void        UnloadTrackRefs();
93     
94     void        SetKineFileName(const TString& fname){fKineDataLoader->SetFileName(fname);}
95     void        SetTrackRefsFileName(const TString& fname){fTrackRefsDataLoader->SetFileName(fname);}
96     
97     TTree*      TreeE() const; //returns the tree from folder; shortcut method
98     TTree*      TreeCT() const; //returns the tree from folder; shortcut method
99     AliHeader*  GetHeader() const;
100     AliCentralTrigger*  GetTrigger() const;
101     
102     AliStack*   Stack() const {return fStack;}
103     
104     TTree*      TreeK() const; //returns the tree from folder; shortcut method
105     TTree*      TreeTR() const; //returns the tree from folder; shortcut method    
106     
107     AliRun*     GetAliRun()const;
108         
109     Int_t       WriteGeometry(Option_t* opt="");
110     Int_t       WriteHeader(Option_t* opt="");
111     Int_t       WriteTrigger(Option_t* opt="");
112     Int_t       WriteAliRun(Option_t* opt="");
113     Int_t       WriteKinematics(Option_t* opt="");
114     Int_t       WriteTrackRefs(Option_t* opt="");
115     Int_t       WriteRunLoader(Option_t* opt="");
116     
117     Int_t       WriteHits(Option_t* opt=""); 
118     Int_t       WriteSDigits(Option_t* opt="");
119     Int_t       WriteDigits(Option_t* opt="");
120     Int_t       WriteRecPoints(Option_t* opt="");
121     Int_t       WriteTracks(Option_t* opt="");
122     
123     Int_t       LoadHits(Option_t* detectors = "all",Option_t* opt = "READ");
124     Int_t       LoadSDigits(Option_t* detectors = "all",Option_t* opt = "READ");
125     Int_t       LoadDigits(Option_t* detectors = "all",Option_t* opt = "READ");
126     Int_t       LoadRecPoints(Option_t* detectors = "all",Option_t* opt = "READ");
127     Int_t       LoadTracks(Option_t* detectors = "all",Option_t* opt = "READ");
128     Int_t       LoadRecParticles(Option_t* detectors = "all",Option_t* opt = "READ");
129     
130     void        UnloadHits(Option_t* detectors = "all");
131     void        UnloadSDigits(Option_t* detectors = "all");
132     void        UnloadDigits(Option_t* detectors = "all");
133     void        UnloadRecPoints(Option_t* detectors = "all");
134     void        UnloadTracks(Option_t* detectors = "all");
135     void        UnloadRecParticles(Option_t* detectors = "all");
136     void        UnloadAll(Option_t* detectors = "all");    
137     
138     void        AddLoader(AliLoader* loader);
139     void        AddLoader(AliDetector* det);
140     AliLoader*  GetLoader(const char* detname) const;
141     AliLoader*  GetLoader(AliDetector* det) const;
142     Int_t       SetEventFolderName(const TString& name = AliConfig::GetDefaultEventFolderName());//sets top folder name for this run; of alread
143     void        CleanFolders();//removes all abjects from folder structure
144     void        CleanDetectors();
145     void        CleanKinematics(){Clean(fgkKineContainerName);}
146     void        CleanTrackRefs(){Clean(fgkTrackRefsContainerName);}
147     
148     void        RemoveEventFolder(); //remove folder structure from top folder 
149     void        SetCompressionLevel(Int_t cl);
150     void        SetKineComprLevel(Int_t cl);
151     void        SetTrackRefsComprLevel(Int_t cl);
152
153     TFolder*    GetEventFolder() const {return fEventFolder;}
154     void        CdGAFile();
155
156     void        MakeTrackRefsContainer();
157     void        SetDirName(TString& dirname);
158     Int_t       GetFileOffset() const;
159     void        SetNumberOfEventsPerFile(Int_t nevpf){fNEventsPerFile = nevpf;}
160     
161     void        SetDigitsFileNameSuffix(const TString& suffix);//adds the suffix before ".root", 
162                                                                //e.g. TPC.Digits.root -> TPC.DigitsMerged.root
163                                                                //made on Jiri Chudoba demand
164     TString     GetFileName() const;//returns name of galice file
165     const TObjArray* GetArrayOfLoaders() const {return fLoaders;}
166     void Cd(){fgRunLoader = this;}
167     void Synchronize();
168     
169     AliLoader*    GetDetectorLoader(const char* detname);
170     TTree*        GetTreeH(const char* detname, Bool_t maketree);
171     TTree*        GetTreeS(const char* detname, Bool_t maketree);
172     TTree*        GetTreeD(const char* detname, Bool_t maketree);
173     TTree*        GetTreeR(const char* detname, Bool_t maketree);
174     TTree*        GetTreeT(const char* detname, Bool_t maketree);
175     TTree*        GetTreeP(const char* detname, Bool_t maketree);
176
177   /******************************************/
178   /*****   Public S T A T I C Stuff   *******/
179   /******************************************/
180     static AliRunLoader* GetRunLoader(const char* eventfoldername);
181     static AliRunLoader* GetRunLoader(){return fgRunLoader;}
182     static AliLoader*    GetDetectorLoader(const char* detname, const char* eventfoldername);
183     static TTree*        GetTreeH(const char* detname, Bool_t maketree, const char* eventfoldername);
184     static TTree*        GetTreeS(const char* detname, Bool_t maketree, const char* eventfoldername);
185     static TTree*        GetTreeD(const char* detname, Bool_t maketree, const char* eventfoldername);
186     static TTree*        GetTreeR(const char* detname, Bool_t maketree, const char* eventfoldername);
187     static TTree*        GetTreeT(const char* detname, Bool_t maketree, const char* eventfoldername);
188     static TTree*        GetTreeP(const char* detname, Bool_t maketree, const char* eventfoldername);
189
190 //    static AliRunDigitizer* GetRunDigitizer();
191 //  Tasks are supposed to be singletons, that is why following methods are static
192     static TTask*           GetRunDigitizer();        //
193     static TTask*           GetRunSDigitizer();       //
194     static TTask*           GetRunReconstructioner(); //
195     static TTask*           GetRunTracker();          //
196     static TTask*           GetRunPIDTask();          // 
197     static TTask*           GetRunQATask();           //
198
199     static TString GetRunLoaderName () {return fgkRunLoaderName;}
200     static TString GetHeaderContainerName () {return fgkHeaderContainerName;}
201     static TString GetTriggerContainerName () {return fgkTriggerContainerName;}
202     static TString GetKineContainerName () {return fgkKineContainerName;}
203     static TString GetTrackRefsContainerName () {return fgkTrackRefsContainerName;}
204     static TString GetHeaderBranchName () {return fgkHeaderBranchName;}
205     static TString GetTriggerBranchName () {return fgkTriggerBranchName;}
206     static TString GetKineBranchName () {return fgkKineBranchName;}
207     static TString GetTriggerFileName() { return fgkDefaultTriggerFileName; }
208     static TString GetGAliceName () {return fgkGAliceName;}
209      
210 protected:
211     /**********************************************/
212     /************    PROTECTED      ***************/
213     /*********        D A T A          ************/
214     /**********************************************/
215
216     TObjArray     *fLoaders;          //  List of Detectors
217     TFolder       *fEventFolder;      //!top folder for this run
218     
219     Int_t          fCurrentEvent;//!Number of current event
220     
221     TFile             *fGAFile;//!  pointer to main file with AliRun and Run Loader -> galice.root 
222     AliHeader         *fHeader;//!  pointer to header
223     AliStack          *fStack; //!  pointer to stack
224     AliCentralTrigger *fCTrigger; //! pointer to CEntral Trigger Processor
225     
226     AliDataLoader *fKineDataLoader;// kinematics data loader
227     AliDataLoader *fTrackRefsDataLoader;//track reference data loader
228     
229     Int_t          fNEventsPerFile;  //defines number of events stored per one file
230     TString        fUnixDirName;    //! name of unix path to directory that contains event
231     static const TString   fgkDefaultKineFileName;//default file name with kinamatics
232     static const TString   fgkDefaultTrackRefsFileName;//default file name with kinamatics
233     static const TString   fgkDefaultTriggerFileName;//default file name with trigger
234
235
236     /*********************************************/
237     /************    PROTECTED      **************/
238     /*********     M E T H O D S       ***********/
239     /*********************************************/
240
241     void           SetGAliceFile(TFile* gafile);//sets the pointer to gAlice file
242     Int_t          OpenKineFile(Option_t* opt);
243     Int_t          OpenTrackRefsFile(Option_t* opt);
244
245     Int_t          OpenDataFile(const TString& filename,TFile*& file,TDirectory*& dir,Option_t* opt,Int_t cl);
246     void           SetUnixDir(const TString& udirname);
247     const TString  SetFileOffset(const TString& fname);//adds the proper number before .root
248     void           SetDetectorAddresses();
249         
250   private:
251     void  GetListOfDetectors(const char * namelist,TObjArray& pointerarray) const;
252
253     void  CleanHeader(){Clean(fgkHeaderContainerName);}
254     void  CleanTrigger(){Clean(fgkTriggerContainerName);}
255     void  Clean(const TString& name);
256     
257     Int_t SetEvent();
258    
259     static AliRunLoader* fgRunLoader; //pointer to the AliRunLoader instance
260
261 private:
262     void Copy(TObject &arun) const;
263
264     static const TString   fgkRunLoaderName;          //default name of the run loader
265     static const TString   fgkHeaderContainerName;    //default name of the kinematics container (TREE) name - TreeE
266     static const TString   fgkTriggerContainerName;   //default name of the trigger container (TREE) name - TreeCT
267     static const TString   fgkKineContainerName;      //default name of the kinematics container (TREE) name - TreeK
268     static const TString   fgkTrackRefsContainerName; //default name of the track references container (TREE) name - TreeTR
269     static const TString   fgkHeaderBranchName;       //default name of the branch containing the header
270     static const TString   fgkTriggerBranchName;      //default name of the branch containing the trigger
271     static const TString   fgkKineBranchName;         //default name of the branch with kinematics
272     static const TString   fgkGAliceName;             //default name for gAlice file    
273     
274     ClassDef(AliRunLoader,2)
275 };
276
277 #endif