STEER/AliDataLoader.h

   1 #ifndef ALIDATALOADER_H
   2 #define ALIDATALOADER_H
   3 //__________________________________________
   4 ////////////////////////////////////////////
   5 //                                        //
   6 //  class AliDataLoader                   //
   7 //                                        //
   8 //  Loader responsible for one data type  //
   9 //  i.e. Hits, Kine, etc.                 //
  10 //  many objects type can be assciated    //
  11 //  with one data type: storing object    //
  12 //  (usually tree), task producing it,    //
  13 //  Quality Assurance(QA), QA Task, and   //
  14 //  others.                               //
  15 //                                        //
  16 //                                        //
  17 ////////////////////////////////////////////
  18
  19 #include <TDirectory.h>
  20 #include <TNamed.h>
  21 #include <TString.h>
  22 #include <TTask.h>
  23 #include <TTree.h>
  24 class TFile;
  25 class TFolder;
  26
  27 class AliBaseLoader;
  28 class AliLoader;
  29 class AliObjectLoader;
  30 class AliRunLoader;
  31 class AliTaskLoader;
  32 class AliTreeLoader;
  33
  34 class AliDataLoader: public TNamed
  35  {
  36   public:
  37    AliDataLoader();
  38    AliDataLoader(const char* filename, const char* contname, const char* name, Option_t* opt = "t");
  39    AliDataLoader(const AliDataLoader& source);
  40    AliDataLoader& operator=(const AliDataLoader& source);
  41    virtual ~AliDataLoader();
  42
  43    virtual Int_t      SetEvent();
  44    virtual Int_t      GetEvent();
  45
  46    //shrtcuts method to basic data base loader 0
  47    virtual Int_t      Load(Option_t* opt="");
  48    virtual void       Unload();
  49    virtual Int_t      Reload();
  50    virtual Int_t      WriteData(Option_t* opt="");
  51    virtual TTree*     Tree() const;
  52    virtual void       Clean();
  53    virtual void       MakeTree();
  54    virtual Int_t      OpenFile(Option_t* opt);
  55
  56    virtual void       CloseFile();
  57    void               UnloadAll();
  58    void               CleanAll();
  59    const TString&     GetFileName() const {return fFileName;}
  60    TFile*             GetFile() const {return fFile;}
  61    TDirectory*        GetDirectory() const {return fDirectory;}
  62    const TString&     GetFileOption() const {return fFileOption;}
  63    const Int_t&       GetCompressionLevel() const {return fCompressionLevel;}
  64
  65    Bool_t             Cd(){return (fDirectory)?fDirectory->cd():kFALSE;}
  66
  67    virtual void       SetFileName(const TString& filename){fFileName = filename;}
  68    virtual void       SetFileOption(const Option_t* fileopt);
  69    virtual void       SetCompressionLevel(Int_t cl);
  70
  71    Int_t              SetEventFolder(TFolder* eventfolder);//sets the event folder
  72    Int_t              SetFolder(TFolder* folder);//sets the data folder ??????
  73    TFolder*           GetEventFolder();
  74    TFolder*           GetFolder() const {return fFolder;}
  75
  76 //   TObject*           GetFromDirectory(const char *name){return (fDirectory)?fDirectory->Get(name):0x0;}
  77    void               SetFileNameSuffix(const TString& suffix);//adds the suffix before ".root",
  78                                                                //e.g. TPC.Digits.root -> TPC.DigitsMerged.root
  79                                                                //made on Jiri Chudoba demand
  80    const TString      SetFileOffset(const TString& fname);//adds the proper number before .root extension suffix
  81    void               SetDirName(TString& dirname);
  82
  83    void               AddBaseLoader(AliBaseLoader* bl);
  84    enum EStdBasicLoaders {kData = 0,kTask,kQA,kQATask};//standard basic loaders identifiers
  85
  86    AliBaseLoader*     GetBaseLoader(const TString& name) const;
  87    AliBaseLoader*     GetBaseLoader(Int_t n) const;
  88    AliObjectLoader*   GetBaseDataLoader();
  89    AliTaskLoader*     GetBaseTaskLoader();
  90    AliBaseLoader*     GetBaseQALoader();
  91    AliTaskLoader*     GetBaseQATaskLoader();
  92
  93    void               SetBaseDataLoader(AliBaseLoader* bl);
  94    void               SetBaseTaskLoader(AliTaskLoader* bl);
  95    void               SetBaseQALoader(AliBaseLoader* bl);
  96    void               SetBaseQATaskLoader(AliTaskLoader* bl);
  97
  98    Bool_t             CheckReload();//checks if we have to reload given file
  99    Bool_t             IsFileWritable() const;
 100    Bool_t             IsFileOpen() const;
 101    Bool_t             IsOptionContrary(const TString& option) const;
 102
 103    void Synchronize();
 104
 105   protected:
 106    Int_t              GetDebug() const;
 107    AliRunLoader*      GetRunLoader();//gets the run-loader from event folder
 108
 109   private:
 110
 111    TString      fFileName; //name of the file
 112    TFile*       fFile; //! pointer to file
 113    TDirectory*  fDirectory; //!pointer to TDirectory
 114    TString      fFileOption; //!file option while opened
 115    Int_t        fCompressionLevel; //Compression Level of File
 116
 117    TObjArray*   fBaseLoaders;//base loaders
 118    Bool_t       fHasTask;// flag if has a task
 119    TString      fTaskName;// name of the task
 120    TTask*       fParentalTask;//Parental task
 121
 122    TFolder*     fEventFolder;//!event folder
 123    TFolder*     fFolder;//! folder with data
 124
 125    ClassDef(AliDataLoader,1)
 126  };
 127
 128
 129 //__________________________________________
 130 ////////////////////////////////////////////
 131 //                                        //
 132 //  class AliBaseLoader                   //
 133 //                                        //
 134 //                                        //
 135 ////////////////////////////////////////////
 136
 137
 138 class AliBaseLoader: public TNamed
 139 {
 140   public:
 141     AliBaseLoader();
 142     AliBaseLoader(const TString& name, AliDataLoader* dl, Bool_t storeontop = kFALSE);
 143    AliBaseLoader(const AliBaseLoader& source);
 144    AliBaseLoader& operator=(const AliBaseLoader& source);
 145
 146     virtual ~AliBaseLoader(){};
 147
 148     virtual Int_t      Load(Option_t* opt="");
 149     virtual void       Unload();
 150     virtual Int_t      Reload();
 151     virtual Int_t      WriteData(Option_t* opt="");
 152     virtual void       Clean();
 153     virtual Int_t      Post();//Takes from file and sends to proper TFolder (Data Folder)
 154     virtual Int_t      Post(TObject* data);//Sends to proper TFolder (Data Folder)
 155     virtual TObject*   Get() const = 0;
 156     Bool_t             IsLoaded()const{return fIsLoaded;}
 157     void               SetDataLoader(AliDataLoader* dl){fDataLoader = dl;}
 158     void               SetEventFolder(TFolder* /*ef*/){;}
 159     void               SetDoNotReload(Bool_t flag){fDoNotReload = flag;}
 160     Bool_t             DoNotReload() const {return fDoNotReload;}
 161     TDirectory*        GetDirectory() const;//returns pointer to directory where data are stored.
 162     TObject*           GetFromDirectory(const char *name) const
 163       {return (GetDirectory())?GetDirectory()->Get(name):0x0;}
 164    protected:
 165
 166     virtual Int_t      AddToBoard(TObject* obj) = 0;//add to white board - board can be TTask or TFolder
 167     virtual void       RemoveFromBoard(TObject* obj) = 0;
 168
 169     AliDataLoader*     GetDataLoader() const;
 170     Int_t              GetDebug() const;
 171
 172     Bool_t             fIsLoaded;    //!  flag indicating if data are loaded
 173     Bool_t             fStoreInTopOfFile;// if true, data are stored in top of file ->Indicates fDoNotReload == kTRUE
 174
 175    private:
 176     Bool_t             fDoNotReload; // if this flag is on object is not reloaded while GetEvent is called.
 177                                      //Specially important for tasks. Task loops over events while producing data,
 178                          //and has a base loader which writes it to file every processed event.
 179                          //If this flag is not on, while taking next event, loader deletes task
 180                          // and tries to get new one from file
 181     AliDataLoader*     fDataLoader;  //! pointer to Data Loader this Base Loader belongs to
 182
 183  ClassDef(AliBaseLoader,1)
 184 };
 185
 186 //__________________________________________
 187 ////////////////////////////////////////////
 188 //                                        //
 189 //  class AliObjectLoader                 //
 190 //                                        //
 191 //                                        //
 192 ////////////////////////////////////////////
 193
 194 class AliObjectLoader: public AliBaseLoader
 195  {
 196    public:
 197      AliObjectLoader(){};
 198      AliObjectLoader(const TString& name, AliDataLoader* dl, Bool_t storeontop = kFALSE);
 199      AliObjectLoader(const AliObjectLoader& source);
 200      AliObjectLoader& operator=(const AliObjectLoader& source);
 201      virtual          ~AliObjectLoader(){};
 202      TObject*          Get() const;
 203
 204    protected:
 205      TFolder*          GetFolder() const;
 206      Int_t             AddToBoard(TObject* obj);
 207      void              RemoveFromBoard(TObject* obj);
 208
 209  ClassDef(AliObjectLoader,1)
 210
 211  };
 212
 213 //__________________________________________
 214 ////////////////////////////////////////////
 215 //                                        //
 216 //  class AliTreeLoader                   //
 217 //                                        //
 218 //                                        //
 219 ////////////////////////////////////////////
 220
 221 class AliTreeLoader: public AliObjectLoader
 222  {
 223    public:
 224      AliTreeLoader(){};
 225      AliTreeLoader(const TString& name, AliDataLoader* dl, Bool_t storeontop = kFALSE);
 226      AliTreeLoader(const AliTreeLoader& source);
 227      AliTreeLoader& operator=(const AliTreeLoader& source);
 228      virtual ~AliTreeLoader(){};
 229
 230      virtual TTree*     Tree() const {return dynamic_cast<TTree*>(Get());}
 231      virtual void       MakeTree();
 232      virtual Int_t      WriteData(Option_t* opt="");
 233
 234    ClassDef(AliTreeLoader,1)
 235  };
 236
 237 //__________________________________________
 238 ////////////////////////////////////////////
 239 //                                        //
 240 //  class AliTaskLoader                   //
 241 //                                        //
 242 //                                        //
 243 ////////////////////////////////////////////
 244
 245 class AliTaskLoader: public AliBaseLoader
 246  {
 247   public:
 248     AliTaskLoader():fParentalTask(0x0){};
 249     AliTaskLoader(const TString& name, AliDataLoader* dl, TTask* parentaltask, Bool_t storeontop = kFALSE);
 250     AliTaskLoader(const AliTaskLoader& source);
 251     AliTaskLoader& operator=(const AliTaskLoader& source);
 252     virtual ~AliTaskLoader(){};
 253
 254     TObject*           Get() const;
 255     virtual TTask*     Task() const {return dynamic_cast<TTask*>(Get());}
 256     virtual void       Clean();
 257
 258   protected:
 259     Int_t              AddToBoard(TObject* obj);
 260     void               RemoveFromBoard(TObject* obj);
 261     TTask*             GetParentalTask() const;
 262
 263   private:
 264     TTask*             fParentalTask; // Parental task
 265
 266   ClassDef(AliTaskLoader,1)
 267  };
 268
 269 #endif
 270
 271