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