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