[u/mrichter/AliRoot.git] / STEER / AliDataLoader.h

#ifndef ALIDATALOADER_H
#define ALIDATALOADER_H
//__________________________________________
////////////////////////////////////////////
//                                        //
//  class AliDataLoader                   //
//                                        //
//  Loader responsible for one data type  //
//  i.e. Hits, Kine, etc.                 //
//  many objects type can be assciated    //
//  with one data type: storing object    //
//  (usually tree), task producing it,    //
//  Quality Assurance(QA), QA Task, and   //
//  others.                               //
//                                        //
//                                        //
////////////////////////////////////////////
#include <TNamed.h>
#include <TString.h>
#include <TTree.h>
#include <TTask.h>
#include <TDirectory.h>

class AliLoader;
class TFile;
class TFolder;
class AliRunLoader;
class AliBaseLoader;
class AliObjectLoader;
class AliTreeLoader;
class AliTaskLoader;

class AliDataLoader: public TNamed
 {
  public:
   AliDataLoader();
   AliDataLoader(const char* filename, const char* contname, const char* name, Option_t* opt = "t");
   AliDataLoader(const AliDataLoader& source);
   AliDataLoader& operator=(const AliDataLoader& source);
   virtual ~AliDataLoader();

   virtual Int_t      SetEvent();
   virtual Int_t      GetEvent();

   //shrtcuts method to basic data base loader 0  
   virtual Int_t      Load(Option_t* opt="");
   virtual void       Unload();
   virtual Int_t      Reload(); 
   virtual Int_t      WriteData(Option_t* opt="");
   virtual TTree*     Tree() const;
   virtual void       Clean();
   virtual void       MakeTree();
   virtual Int_t      OpenFile(Option_t* opt);

   virtual void       CloseFile();
   void               UnloadAll();
   void               CleanAll();
   const TString&     GetFileName() const {return fFileName;}
   TFile*             GetFile() const {return fFile;}
   TDirectory*        GetDirectory() const {return fDirectory;}
   const TString&     GetFileOption() const {return fFileOption;}
   const Int_t&       GetCompressionLevel() const {return fCompressionLevel;}
   
   Bool_t             cd(){return (fDirectory)?fDirectory->cd():kFALSE;}
   
   virtual void       SetFileName(const TString& filename){fFileName = filename;}
   virtual void       SetFileOption(const Option_t* fileopt);
   virtual void       SetCompressionLevel(Int_t cl);

   Int_t              SetEventFolder(TFolder* eventfolder);//sets the event folder
   Int_t              SetFolder(TFolder* folder);//sets the data folder ??????
   TFolder*           GetEventFolder();
   TFolder*           GetFolder() const {return fFolder;}
   
//   TObject*           GetFromDirectory(const char *name){return (fDirectory)?fDirectory->Get(name):0x0;}
   void               SetFileNameSuffix(const TString& suffix);//adds the suffix before ".root", 
                                                               //e.g. TPC.Digits.root -> TPC.DigitsMerged.root
                                                               //made on Jiri Chudoba demand
   const TString      SetFileOffset(const TString& fname);//adds the proper number before .root extension suffix
   void               SetDirName(TString& dirname);

   void               AddBaseLoader(AliBaseLoader* bl);
   enum EStdBasicLoaders {kData = 0,kTask,kQA,kQATask};//standard basic loaders identifiers

   AliBaseLoader*     GetBaseLoader(const TString& name) const;
   AliBaseLoader*     GetBaseLoader(Int_t n) const;
   AliObjectLoader*   GetBaseDataLoader();
   AliTaskLoader*     GetBaseTaskLoader();
   AliBaseLoader*     GetBaseQALoader();
   AliTaskLoader*     GetBaseQATaskLoader();
   
   void               SetBaseDataLoader(AliBaseLoader* bl);
   void               SetBaseTaskLoader(AliTaskLoader* bl);
   void               SetBaseQALoader(AliBaseLoader* bl);
   void               SetBaseQATaskLoader(AliTaskLoader* bl);
   
   Bool_t             CheckReload();//checks if we have to reload given file
   Bool_t             IsFileWritable() const;
   Bool_t             IsFileOpen() const;
   Bool_t             IsOptionContrary(const TString& option) const;
   
   void Synchronize();

  protected:
   Int_t              GetDebug() const;
   AliRunLoader*      GetRunLoader();//gets the run-loader from event folder

  private:
      
   TString      fFileName; //name of the file 
   TFile*       fFile; //! pointer to file 
   TDirectory*  fDirectory; //!pointer to TDirectory
   TString      fFileOption; //!file option while opened 
   Int_t        fCompressionLevel; //Compression Level of File
   
   TObjArray*   fBaseLoaders;//base loaders
   Bool_t       fHasTask;// flag if has a task
   TString      fTaskName;// name of the task
   TTask*       fParentalTask;//Parental task

   TFolder*     fEventFolder;//!event folder
   TFolder*     fFolder;//! folder with data
   
   ClassDef(AliDataLoader,1)
 };


//__________________________________________
////////////////////////////////////////////
//                                        //
//  class AliBaseLoader                   //
//                                        //
//                                        //
////////////////////////////////////////////


class AliBaseLoader: public TNamed
{
  public:
    AliBaseLoader();
    AliBaseLoader(const TString& name, AliDataLoader* dl, Bool_t storeontop = kFALSE);
   AliBaseLoader(const AliBaseLoader& source);
   AliBaseLoader& operator=(const AliBaseLoader& source);
    
    virtual ~AliBaseLoader(){};
     
    virtual Int_t      Load(Option_t* opt="");
    virtual void       Unload();
    virtual Int_t      Reload();
    virtual Int_t      WriteData(Option_t* opt="");
    virtual void       Clean();
    virtual Int_t      Post();//Takes from file and sends to proper TFolder (Data Folder)
    virtual Int_t      Post(TObject* data);//Sends to proper TFolder (Data Folder)
    virtual TObject*   Get() const = 0; 
    Bool_t             IsLoaded()const{return fIsLoaded;}
    void               SetDataLoader(AliDataLoader* dl){fDataLoader = dl;}
    void               SetEventFolder(TFolder* /*ef*/){;}
    void               SetDoNotReload(Bool_t flag){fDoNotReload = flag;}
    Bool_t             DoNotReload() const {return fDoNotReload;}
    TDirectory*        GetDirectory() const;//returns pointer to directory where data are stored. 
    TObject*           GetFromDirectory(const char *name) const
      {return (GetDirectory())?GetDirectory()->Get(name):0x0;}    
   protected:
    
    virtual Int_t      AddToBoard(TObject* obj) = 0;//add to white board - board can be TTask or TFolder
    virtual void       RemoveFromBoard(TObject* obj) = 0;
    
    AliDataLoader*     GetDataLoader() const;
    Int_t              GetDebug() const;

    Bool_t             fIsLoaded;    //!  flag indicating if data are loaded
    Bool_t             fStoreInTopOfFile;// if true, data are stored in top of file ->Indicates fDoNotReload == kTRUE

   private:
    Bool_t             fDoNotReload; // if this flag is on object is not reloaded while GetEvent is called.
                                     //Specially important for tasks. Task loops over events while producing data, 
	                 //and has a base loader which writes it to file every processed event.
	                 //If this flag is not on, while taking next event, loader deletes task
	                 // and tries to get new one from file
    AliDataLoader*     fDataLoader;  //! pointer to Data Loader this Base Loader belongs to

 ClassDef(AliBaseLoader,1)    
};

//__________________________________________
////////////////////////////////////////////
//                                        //
//  class AliObjectLoader                 //
//                                        //
//                                        //
////////////////////////////////////////////

class AliObjectLoader: public AliBaseLoader
 {
   public:
     AliObjectLoader(){};
     AliObjectLoader(const TString& name, AliDataLoader* dl, Bool_t storeontop = kFALSE);
     AliObjectLoader(const AliObjectLoader& source);
     AliObjectLoader& operator=(const AliObjectLoader& source);
     virtual          ~AliObjectLoader(){};
     TObject*          Get() const;

   protected:
     TFolder*          GetFolder() const;
     Int_t             AddToBoard(TObject* obj);
     void              RemoveFromBoard(TObject* obj);

 ClassDef(AliObjectLoader,1)    
  
 };

//__________________________________________
////////////////////////////////////////////
//                                        //
//  class AliTreeLoader                   //
//                                        //
//                                        //
////////////////////////////////////////////

class AliTreeLoader: public AliObjectLoader
 {
   public:
     AliTreeLoader(){};
     AliTreeLoader(const TString& name, AliDataLoader* dl, Bool_t storeontop = kFALSE);
     AliTreeLoader(const AliTreeLoader& source);
     AliTreeLoader& operator=(const AliTreeLoader& source);
     virtual ~AliTreeLoader(){};
     
     virtual TTree*     Tree() const {return dynamic_cast<TTree*>(Get());}
     virtual void       MakeTree();
     virtual Int_t      WriteData(Option_t* opt="");

   ClassDef(AliTreeLoader,1)    
 };

//__________________________________________
////////////////////////////////////////////
//                                        //
//  class AliTaskLoader                   //
//                                        //
//                                        //
////////////////////////////////////////////
 
class AliTaskLoader: public AliBaseLoader
 {
  public:
    AliTaskLoader():fParentalTask(0x0){};
    AliTaskLoader(const TString& name, AliDataLoader* dl, TTask* parentaltask, Bool_t storeontop = kFALSE);
    AliTaskLoader(const AliTaskLoader& source);
    AliTaskLoader& operator=(const AliTaskLoader& source);
    virtual ~AliTaskLoader(){};
    
    TObject*           Get() const; 
    virtual TTask*     Task() const {return dynamic_cast<TTask*>(Get());}
    virtual void       Clean();

  protected:
    Int_t              AddToBoard(TObject* obj);
    void               RemoveFromBoard(TObject* obj);
    TTask*             GetParentalTask() const;

  private:
    TTask*             fParentalTask; // Parental task

  ClassDef(AliTaskLoader,1)    
 };

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