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

#ifndef ALIRUNLoader_H
#define ALIRUNLoader_H

//___________________________________________________________________
/////////////////////////////////////////////////////////////////////
//                                                                 //
//  class AliRunLoader                                             //
//                                                                 //
//  This class aims to be the only one interface for manging data  //
//  It stores Loaders for all modules which knows the filenames    //
//  of the data files to be stored.                                //
//  It aims to substitude AliRun in automatic managing of data     //
//  positioning thus there won't be necessity of loading gAlice    //
//  from file in order to get fast access to the data              //
//                                                                 //
//  Logical place to put the specific Loader to the given          //
//  detector is detector  itself (i.e ITSLoader in ITS).           //
//  But, to load detector object one need to load gAlice, and      //
//  by the way all other detectors with their geometrieces and     //
//  so on. So, if one need to open TPC clusters there is no        //
//  principal nedd to read everything.                             //
//                                                                 //
/////////////////////////////////////////////////////////////////////

#include <TNamed.h>

#include "AliConfig.h"
#include "AliLoader.h"
#include "AliDataLoader.h"
#include "AliLog.h"

class TFile;
class TString;
class TFolder;
class TObjArray;
class TTree;
class TTask;
class TParticle;

class AliRun;
class AliLoader;
class AliDetector;
class AliHeader;
class AliStack;
class AliRunDigitizer;
class AliCDBEntry;
class AliCentralTrigger;

class AliRunLoader: public TNamed
{
  public:
    
    AliRunLoader();
    AliRunLoader(const char* topfoldername);
    AliRunLoader(TFolder* topfolder);
    AliRunLoader(const AliRunLoader &rl);
    AliRunLoader & operator = (const AliRunLoader &rl) 
      {rl.Copy(*this); return *this;}
    
    virtual ~AliRunLoader();
    
    static AliRunLoader* Open(const char* filename = "galice.root",
                              const char* eventfoldername = AliConfig::GetDefaultEventFolderName(),
	          Option_t* option = "READ");

    Int_t       GetEventNumber() const {return fCurrentEvent;}

    Int_t       GetEvent(Int_t evno);//sets the event number and reloads data in folders properly
    Int_t       GetNextEvent(){return GetEvent(fCurrentEvent+1);}//gets next event 
    Int_t       SetEventNumber(Int_t evno); //cleans folders and sets the root dirs in files (do not reload data)
    Int_t       SetNextEvent(){return SetEventNumber(fCurrentEvent+1);}
    
    Int_t       GetNumberOfEvents();
    
    AliCDBEntry* GetCDBEntry(const char* name) const;

    void        MakeTree(Option_t *option);
    void        MakeHeader();
    void        MakeTrigger();
    void        MakeStack();
    
    Int_t       LoadgAlice();
    Int_t       LoadHeader();
    Int_t       LoadKinematics(Option_t* option = "READ");
    Int_t       LoadTrigger(Option_t* option = "READ");
    Int_t       LoadTrackRefs(Option_t* option = "READ");
    
    void        UnloadHeader();
    void        UnloadTrigger();
    void        UnloadKinematics();
    void        UnloadgAlice();
    void        UnloadTrackRefs();
    
    void        SetKineFileName(const TString& fname){fKineDataLoader->SetFileName(fname);}
    void        SetTrackRefsFileName(const TString& fname){fTrackRefsDataLoader->SetFileName(fname);}
    
    TTree*      TreeE() const; //returns the tree from folder; shortcut method
    TTree*      TreeCT() const; //returns the tree from folder; shortcut method
    AliHeader*  GetHeader() const;
    AliCentralTrigger*  GetTrigger() const;
    
    AliStack*   Stack() const {return fStack;}
    
    TTree*      TreeK() const; //returns the tree from folder; shortcut method
    TTree*      TreeTR() const; //returns the tree from folder; shortcut method    
    
    AliRun*     GetAliRun()const;
        
    Int_t       WriteGeometry(Option_t* opt="");
    Int_t       WriteHeader(Option_t* opt="");
    Int_t       WriteTrigger(Option_t* opt="");
    Int_t       WriteAliRun(Option_t* opt="");
    Int_t       WriteKinematics(Option_t* opt="");
    Int_t       WriteTrackRefs(Option_t* opt="");
    Int_t       WriteRunLoader(Option_t* opt="");
    
    Int_t       WriteHits(Option_t* opt=""); 
    Int_t       WriteSDigits(Option_t* opt="");
    Int_t       WriteDigits(Option_t* opt="");
    Int_t       WriteRecPoints(Option_t* opt="");
    Int_t       WriteTracks(Option_t* opt="");
    
    Int_t       LoadHits(Option_t* detectors = "all",Option_t* opt = "READ");
    Int_t       LoadSDigits(Option_t* detectors = "all",Option_t* opt = "READ");
    Int_t       LoadDigits(Option_t* detectors = "all",Option_t* opt = "READ");
    Int_t       LoadRecPoints(Option_t* detectors = "all",Option_t* opt = "READ");
    Int_t       LoadTracks(Option_t* detectors = "all",Option_t* opt = "READ");
    Int_t       LoadRecParticles(Option_t* detectors = "all",Option_t* opt = "READ");
    
    void        UnloadHits(Option_t* detectors = "all");
    void        UnloadSDigits(Option_t* detectors = "all");
    void        UnloadDigits(Option_t* detectors = "all");
    void        UnloadRecPoints(Option_t* detectors = "all");
    void        UnloadTracks(Option_t* detectors = "all");
    void        UnloadRecParticles(Option_t* detectors = "all");
    void        UnloadAll(Option_t* detectors = "all");    
    
    void        AddLoader(AliLoader* loader);
    void        AddLoader(AliDetector* det);
    AliLoader*  GetLoader(const char* detname) const;
    AliLoader*  GetLoader(AliDetector* det) const;
    Int_t       SetEventFolderName(const TString& name = AliConfig::GetDefaultEventFolderName());//sets top folder name for this run; of alread
    void        CleanFolders();//removes all abjects from folder structure
    void        CleanDetectors();
    void        CleanKinematics(){Clean(fgkKineContainerName);}
    void        CleanTrackRefs(){Clean(fgkTrackRefsContainerName);}
    
    void        RemoveEventFolder(); //remove folder structure from top folder 
    void        SetCompressionLevel(Int_t cl);
    void        SetKineComprLevel(Int_t cl);
    void        SetTrackRefsComprLevel(Int_t cl);

    TFolder*    GetEventFolder() const {return fEventFolder;}
    void        CdGAFile();

    void        MakeTrackRefsContainer();
    void        SetDirName(TString& dirname);
    Int_t       GetFileOffset() const;
    void        SetNumberOfEventsPerFile(Int_t nevpf){fNEventsPerFile = nevpf;}
    
    void        SetDigitsFileNameSuffix(const TString& suffix);//adds the suffix before ".root", 
                                                               //e.g. TPC.Digits.root -> TPC.DigitsMerged.root
                                                               //made on Jiri Chudoba demand
    TString     GetFileName() const;//returns name of galice file
    const TObjArray* GetArrayOfLoaders() const {return fLoaders;}
    void Cd(){fgRunLoader = this;}
    void Synchronize();
    
    AliLoader*    GetDetectorLoader(const char* detname);
    TTree*        GetTreeH(const char* detname, Bool_t maketree);
    TTree*        GetTreeS(const char* detname, Bool_t maketree);
    TTree*        GetTreeD(const char* detname, Bool_t maketree);
    TTree*        GetTreeR(const char* detname, Bool_t maketree);
    TTree*        GetTreeT(const char* detname, Bool_t maketree);
    TTree*        GetTreeP(const char* detname, Bool_t maketree);

  /******************************************/
  /*****   Public S T A T I C Stuff   *******/
  /******************************************/
    static AliRunLoader* GetRunLoader(const char* eventfoldername);
    static AliRunLoader* GetRunLoader(){return fgRunLoader;}
    static AliLoader*    GetDetectorLoader(const char* detname, const char* eventfoldername);
    static TTree*        GetTreeH(const char* detname, Bool_t maketree, const char* eventfoldername);
    static TTree*        GetTreeS(const char* detname, Bool_t maketree, const char* eventfoldername);
    static TTree*        GetTreeD(const char* detname, Bool_t maketree, const char* eventfoldername);
    static TTree*        GetTreeR(const char* detname, Bool_t maketree, const char* eventfoldername);
    static TTree*        GetTreeT(const char* detname, Bool_t maketree, const char* eventfoldername);
    static TTree*        GetTreeP(const char* detname, Bool_t maketree, const char* eventfoldername);

//    static AliRunDigitizer* GetRunDigitizer();
//  Tasks are supposed to be singletons, that is why following methods are static
    static TTask*           GetRunDigitizer();        //
    static TTask*           GetRunSDigitizer();       //
    static TTask*           GetRunReconstructioner(); //
    static TTask*           GetRunTracker();          //
    static TTask*           GetRunPIDTask();          // 
    static TTask*           GetRunQATask();           //

    static TString GetRunLoaderName () {return fgkRunLoaderName;}
    static TString GetHeaderContainerName () {return fgkHeaderContainerName;}
    static TString GetTriggerContainerName () {return fgkTriggerContainerName;}
    static TString GetKineContainerName () {return fgkKineContainerName;}
    static TString GetTrackRefsContainerName () {return fgkTrackRefsContainerName;}
    static TString GetHeaderBranchName () {return fgkHeaderBranchName;}
    static TString GetTriggerBranchName () {return fgkTriggerBranchName;}
    static TString GetKineBranchName () {return fgkKineBranchName;}
    static TString GetTriggerFileName() { return fgkDefaultTriggerFileName; }
    static TString GetGAliceName () {return fgkGAliceName;}
     
protected:
    /**********************************************/
    /************    PROTECTED      ***************/
    /*********        D A T A          ************/
    /**********************************************/

    TObjArray     *fLoaders;          //  List of Detectors
    TFolder       *fEventFolder;      //!top folder for this run
    
    Int_t          fCurrentEvent;//!Number of current event
    
    TFile             *fGAFile;//!  pointer to main file with AliRun and Run Loader -> galice.root 
    AliHeader         *fHeader;//!  pointer to header
    AliStack          *fStack; //!  pointer to stack
    AliCentralTrigger *fCTrigger; //! pointer to CEntral Trigger Processor
    
    AliDataLoader *fKineDataLoader;// kinematics data loader
    AliDataLoader *fTrackRefsDataLoader;//track reference data loader
    
    Int_t          fNEventsPerFile;  //defines number of events stored per one file
    TString        fUnixDirName;    //! name of unix path to directory that contains event
    static const TString   fgkDefaultKineFileName;//default file name with kinamatics
    static const TString   fgkDefaultTrackRefsFileName;//default file name with kinamatics
    static const TString   fgkDefaultTriggerFileName;//default file name with trigger


    /*********************************************/
    /************    PROTECTED      **************/
    /*********     M E T H O D S       ***********/
    /*********************************************/

    void           SetGAliceFile(TFile* gafile);//sets the pointer to gAlice file
    Int_t          OpenKineFile(Option_t* opt);
    Int_t          OpenTrackRefsFile(Option_t* opt);

    Int_t          OpenDataFile(const TString& filename,TFile*& file,TDirectory*& dir,Option_t* opt,Int_t cl);
    void           SetUnixDir(const TString& udirname);
    const TString  SetFileOffset(const TString& fname);//adds the proper number before .root
    void           SetDetectorAddresses();
        
  private:
    void  GetListOfDetectors(const char * namelist,TObjArray& pointerarray) const;

    void  CleanHeader(){Clean(fgkHeaderContainerName);}
    void  CleanTrigger(){Clean(fgkTriggerContainerName);}
    void  Clean(const TString& name);
    
    Int_t SetEvent();
   
    static AliRunLoader* fgRunLoader; //pointer to the AliRunLoader instance

private:
    void Copy(TObject &arun) const;

    static const TString   fgkRunLoaderName;          //default name of the run loader
    static const TString   fgkHeaderContainerName;    //default name of the kinematics container (TREE) name - TreeE
    static const TString   fgkTriggerContainerName;   //default name of the trigger container (TREE) name - TreeCT
    static const TString   fgkKineContainerName;      //default name of the kinematics container (TREE) name - TreeK
    static const TString   fgkTrackRefsContainerName; //default name of the track references container (TREE) name - TreeTR
    static const TString   fgkHeaderBranchName;       //default name of the branch containing the header
    static const TString   fgkTriggerBranchName;      //default name of the branch containing the trigger
    static const TString   fgkKineBranchName;         //default name of the branch with kinematics
    static const TString   fgkGAliceName;             //default name for gAlice file    
    
    ClassDef(AliRunLoader,2)
};

#endif
Commit	Line	Data
88cb7938	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>
024a7e64	26
88cb7938	27	#include "AliConfig.h"
	28	#include "AliLoader.h"
	29	#include "AliDataLoader.h"
4951e003	30	#include "AliLog.h"
88cb7938	31
024a7e64	32	class TFile;
88cb7938	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;
9e1ceb13	46	class AliCDBEntry;
bacbe0fd	47	class AliCentralTrigger;
88cb7938	48
	49	class AliRunLoader: public TNamed
	50	{
	51	public:
	52
	53	AliRunLoader();
	54	AliRunLoader(const char* topfoldername);
	55	AliRunLoader(TFolder* topfolder);
024a7e64	56	AliRunLoader(const AliRunLoader &rl);
	57	AliRunLoader & operator = (const AliRunLoader &rl)
	58	{rl.Copy(this); return this;}
88cb7938	59
	60	virtual ~AliRunLoader();
	61
	62	static AliRunLoader* Open(const char* filename = "galice.root",
e191bb57	63	const char* eventfoldername = AliConfig::GetDefaultEventFolderName(),
88cb7938	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
9e1ceb13	75	AliCDBEntry* GetCDBEntry(const char* name) const;
2c8628dd	76
88cb7938	77	void MakeTree(Option_t *option);
88cb7938	78	void MakeHeader();
bacbe0fd	79	void MakeTrigger();
88cb7938	80	void MakeStack();
	81
	82	Int_t LoadgAlice();
	83	Int_t LoadHeader();
	84	Int_t LoadKinematics(Option_t* option = "READ");
bacbe0fd	85	Int_t LoadTrigger(Option_t* option = "READ");
88cb7938	86	Int_t LoadTrackRefs(Option_t* option = "READ");
	87
	88	void UnloadHeader();
bacbe0fd	89	void UnloadTrigger();
88cb7938	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
bacbe0fd	98	TTree* TreeCT() const; //returns the tree from folder; shortcut method
88cb7938	99	AliHeader* GetHeader() const;
bacbe0fd	100	AliCentralTrigger* GetTrigger() const;
88cb7938	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="");
bacbe0fd	111	Int_t WriteTrigger(Option_t* opt="");
88cb7938	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
f49dcb04	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");
88cb7938	129
1bb20a37	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");
88cb7938	137
	138	void AddLoader(AliLoader* loader);
	139	void AddLoader(AliDetector* det);
	140	AliLoader* GetLoader(const char* detname) const;
	141	AliLoader* GetLoader(AliDetector* det) const;
e191bb57	142	Int_t SetEventFolderName(const TString& name = AliConfig::GetDefaultEventFolderName());//sets top folder name for this run; of alread
88cb7938	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;}
024a7e64	166	void Cd(){fgRunLoader = this;}
f0f6f856	167	void Synchronize();
f0f6f856	168
1bb20a37	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);
d0d4a6b3	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(); //
024a7e64	198
	199	static TString GetRunLoaderName () {return fgkRunLoaderName;}
	200	static TString GetHeaderContainerName () {return fgkHeaderContainerName;}
bacbe0fd	201	static TString GetTriggerContainerName () {return fgkTriggerContainerName;}
024a7e64	202	static TString GetKineContainerName () {return fgkKineContainerName;}
	203	static TString GetTrackRefsContainerName () {return fgkTrackRefsContainerName;}
	204	static TString GetHeaderBranchName () {return fgkHeaderBranchName;}
bacbe0fd	205	static TString GetTriggerBranchName () {return fgkTriggerBranchName;}
024a7e64	206	static TString GetKineBranchName () {return fgkKineBranchName;}
bacbe0fd	207	static TString GetTriggerFileName() { return fgkDefaultTriggerFileName; }
024a7e64	208	static TString GetGAliceName () {return fgkGAliceName;}
d0d4a6b3	209
024a7e64	210	protected:
88cb7938	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
bacbe0fd	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
88cb7938	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
bacbe0fd	233	static const TString fgkDefaultTriggerFileName;//default file name with trigger
88cb7938	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);}
bacbe0fd	254	void CleanTrigger(){Clean(fgkTriggerContainerName);}
88cb7938	255	void Clean(const TString& name);
	256
	257	Int_t SetEvent();
	258
d0d4a6b3	259	static AliRunLoader* fgRunLoader; //pointer to the AliRunLoader instance
88cb7938	260
024a7e64	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
bacbe0fd	266	static const TString fgkTriggerContainerName; //default name of the trigger container (TREE) name - TreeCT
024a7e64	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
bacbe0fd	270	static const TString fgkTriggerBranchName; //default name of the branch containing the trigger
024a7e64	271	static const TString fgkKineBranchName; //default name of the branch with kinematics
024a7e64	272	static const TString fgkGAliceName; //default name for gAlice file
88cb7938	273
bacbe0fd	274	ClassDef(AliRunLoader,2)
88cb7938	275	};
	276
	277	#endif