TAM/interface/TAMSelector.h

//
// $Id: TAMSelector.h,v 1.14 2009/07/17 19:18:04 loizides Exp $
//

#ifndef ROOT_TAMSelector
#define ROOT_TAMSelector

// keep this for compatibility 
#define TAM_TAMSelector

#include <TTreeCache.h>

#ifndef ROOT_Riostream
#include <Riostream.h>
#endif
#ifndef ROOT_TSelector
#include "TSelector.h"
#endif
#ifndef ROOT_THashTable
#include "THashTable.h"
#endif
#ifndef ROOT_List
#include "TList.h"
#endif
#ifndef ROOT_TAMBranchInfo
#include "MitAna/TAM/interface/TAMBranchInfo.h"
#endif   
#ifndef ROOT_TAMVirtualLoader
#include "MitAna/TAM/interface/TAMVirtualLoader.h"
#endif   


class TBranch;
class TTree;
class TFile;
class TAModule;
class TAMOutput;
class TBranchRef;

class TAMSelector : public TSelector {
protected:
   
   struct TAMEvtObj : TNamed {
      // Class for storing event objects:
      // It assumes ownership of the object.
      // It is needed to force the THashTable to call Hash on a TNamed
      // to allow lookup using the hash value given the object's name
      // (as opposed to its pointer value, as is done for TObject's).
      TObject* fObj; //the object
      TAMEvtObj(TObject* obj) : TNamed(obj->GetName(),0), fObj(obj) {}
      TAMEvtObj(TObject* obj, const char *name) : TNamed(name,0), fObj(obj) {}
      virtual ~TAMEvtObj() { if (fObj!=0) delete fObj; }
   };

   class BranchProxy : public TObject {
      // Class that acts as a proxy between the TRefTable, TAM and TBranchRef.
      // If SetDoProxy(kTRUE) is called TRef branch auto-loading will be done 
      // via TAM loaders.
   public:
       BranchProxy(TAMSelector *sel, Bool_t e=kFALSE);
       virtual      ~BranchProxy();
       void          Disable();
       void          Enable();
       TObject      *GetObjectWithID(UInt_t uid, TProcessID *pid);
       Bool_t        Notify();

   protected:
       Bool_t        Load(UInt_t uid, TProcessID *pid, TBranchRef *br, TRefTable *table);       

       TAMSelector  *fSel;          //ptr to TAMSelector (we are a friend)
       TRefTable    *fOrig;         //ptr to original TRefTable filled by I/O 
                                    // (owner is TBranchRef)
       TRefTable    *fFake;         //ptr to our fake TRefTable 
                                    // of which we are owner
       Long64_t      fCurEntry;     //cache of current entry
       Bool_t        fBrRead[1024]; //flag which TBranchRef branch was read
   };

   TTree            *fTree;            //!the tree or chain
   TTreeCache       *fTreeCache;       //!tree cache
   Int_t             fCacheSize;       //tree cache size

   THashTable        fBranchTable;     //!table of requested branches
   THashTable        fEventObjs;       //!table of objects available to any mod
                                       // while the current event is processed
   TAModule         *fAModules;        //!the top-most TAModule. Nothing but a 
                                       //  container for more modules
   Long64_t          fCurEvt;          //!the current event
   TList            *fOwnInput;        //!keep pointer to own input list 
                                       // in case it was created by us 
   Bool_t            fAnalysisAborted; //!if the analysis should be aborted
   Bool_t            fModAborted;      //!if >=1 modules(s) are aborted
   Bool_t            fEventAborted;    //!if the current event should be aborted
   Bool_t            fActNotify;       //!if notify is active 
                                       // (avoiding recursive calls of Notify())
   UInt_t            fObjCounter;      //!keep object counter for resetting it 
                                       // in the process loop
   UInt_t            fObjCounterRun;   //!keep object counter for resetting it 
                                       // in process when end of run is reached
   UInt_t            fVerbosity;       //if one wants to print debug info
   BranchProxy       fProxy;           //proxy for reference resolving branch 
                                       // loading via TAM
   Bool_t            fDoProxy;         //if TAMSelector should be proxy for 
                                       // TRef branch autoloads
   Bool_t            fDoObjTabClean;   //true if TAMSelector should clean the 
                                       // object tables of process id's
   Bool_t            fObjTabClean;     //bool to track whether object tables of
                                       // process id's are currently clean
   TList             fLoaders;         //list of data loaders

   void              AddNewOutputLists();
   void              CleanObjTable(TProcessID *pid, UInt_t lastKeptUID) const;
   void              ClearAllLoaders();
   void              CopyModsFromInput();
   Bool_t            FindLoader(TAMBranchInfo* brInfo);
   void              LoadBranch(TAMBranchInfo* brInfo);
   void              TakeModsFromInput();
   void              TakeLoadersFromInput();
   void              ZeroAllBranches();
   
public:
   TAMSelector();
   virtual ~TAMSelector();
   
   void              AbortAnalysis();
   void              AbortEvent();
   void              AbortModule(TAModule* mod);
   virtual void      AddInput(TAModule* mod);
   void              AddLoader(TAMVirtualLoader *loader) 
                       { fLoaders.AddLast(loader); }
   virtual Bool_t    AddObjThisEvt(TObject* obj);
   virtual Bool_t    AddObjThisEvt(TObject* obj, const char *name);
   void              Begin(TTree* tree);
   virtual Bool_t    BeginRun()                { return kFALSE;  }
   virtual Bool_t    EndRun()                  { return kFALSE;  }
   TAMOutput        *FindModOutput(const TAModule* mod);
   virtual TObject  *FindObjThisEvt(const Char_t* name) const;
   virtual TObject  *FindPublicObj(const Char_t* name)  const;
   Long64_t          GetCurEvt()         const { return fCurEvt; }
   const TFile      *GetCurrentFile()    const;
   TFile            *GetCurrentFile();
   const TAMOutput  *GetModOutput()      const;
   TAMOutput        *GetModOutput();
   TObject          *GetObjectWithID(UInt_t uid, TProcessID *pid);
   const TAModule   *GetTopModule()      const { return fAModules;    }
   const TTree      *GetTree()           const { return fTree;        }
   Bool_t            GetObjTabClean()    const { return fObjTabClean; }
   TTree            *GetTree()                 { return fTree;        }
   UInt_t            GetVerbosity()      const { return fVerbosity;   }
   void              Init(TTree* tree);
   Bool_t            IsAModAborted()     const { return fModAborted;      }
   Bool_t            IsEventAborted()    const { return fEventAborted;    }
   Bool_t            IsAnalysisAborted() const { return fAnalysisAborted; }
   void              LoadBranch(const Char_t* bname);
   Bool_t            Notify();
   Bool_t            Process(Int_t entry) 
                       { return Process(static_cast<Long64_t>(entry));    }
   Bool_t            Process(Long64_t entry);
   virtual Bool_t    PublishObj(TObject* obj);
   template <typename T>
   void              ReqBranch(const Char_t* bname, T*& address);
   virtual TObject  *RemoveObjThisEvt(const Char_t* name);
   virtual TObject  *RetractObj(const Char_t* name);
   void              SetCacheSize(Int_t i)      { fCacheSize = i;     }
   void              SetDoProxy(Bool_t b)       { fDoProxy = b;       }
   void              SetDoObjTabClean(Bool_t b) { fDoObjTabClean = b; }
   void              SetVerbosity(UInt_t vb)    { fVerbosity = vb;    }
   void              SlaveBegin(TTree* tree);
   void              SlaveTerminate();
   void              Terminate();
   Int_t             Version()           const { return 1; }
   
    ClassDef(TAMSelector,8) // Tree analysis module selector
};


//______________________________________________________________________________
template <typename T>
inline void TAMSelector::ReqBranch(const Char_t* bname, T*& address)
{
   // Tells the selector that a branch with the given name may be
   // used by an TAModule and that the the module will access the branch
   // using the pointer 'address'.

   TAMBranchInfo* brInfo = 
     dynamic_cast<TAMBranchInfo*>( fBranchTable.FindObject(bname) );

   if (brInfo==0) {
      brInfo = new TAMBranchInfo(bname);
      fBranchTable.Add(brInfo);
   }

   if (!brInfo->AddPtr(address)) 
     AbortAnalysis();
}
#endif //ROOT_TAMSelector
Revision:	1.15
Committed:	Mon Mar 21 15:58:37 2011 UTC (14 years, 1 month ago) by paus
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Mit_032, Mit_031, Mit_025c_branch2, Mit_025c_branch1, Mit_030, Mit_029c, Mit_029b, Mit_030_pre1, Mit_029a, Mit_029, Mit_029_pre1, Mit_028a, Mit_025c_branch0, Mit_028, Mit_027a, Mit_027, Mit_026, Mit_025e, Mit_025d, Mit_025c, Mit_025b, Mit_025a, Mit_025, Mit_025pre2, Mit_024b, Mit_025pre1, Mit_024a, Mit_024, Mit_023, Mit_022a, Mit_022, Mit_020d, TMit_020d, Mit_020c, Mit_021, Mit_021pre2, Mit_021pre1, Mit_020b, Mit_020a, Mit_020, Mit_020pre1, HEAD
Branch point for:	Mit_025c_branch
Changes since 1.14:	+6 -1 lines
Log Message:	Improved caching.
#	User	Rev	Content
1	loizides	1.1	//
2	paus	1.15	// $Id: TAMSelector.h,v 1.14 2009/07/17 19:18:04 loizides Exp $
3	loizides	1.1	//
4
5			#ifndef ROOT_TAMSelector
6			#define ROOT_TAMSelector
7
8			// keep this for compatibility
9			#define TAM_TAMSelector
10
11	paus	1.15	#include <TTreeCache.h>
12	loizides	1.1
13	loizides	1.13	#ifndef ROOT_Riostream
14			#include <Riostream.h>
15			#endif
16	loizides	1.1	#ifndef ROOT_TSelector
17			#include "TSelector.h"
18			#endif
19			#ifndef ROOT_THashTable
20			#include "THashTable.h"
21			#endif
22			#ifndef ROOT_List
23			#include "TList.h"
24			#endif
25			#ifndef ROOT_TAMBranchInfo
26	loizides	1.13	#include "MitAna/TAM/interface/TAMBranchInfo.h"
27	loizides	1.1	#endif
28			#ifndef ROOT_TAMVirtualLoader
29	loizides	1.13	#include "MitAna/TAM/interface/TAMVirtualLoader.h"
30	loizides	1.1	#endif
31
32
33			class TBranch;
34			class TTree;
35			class TFile;
36			class TAModule;
37			class TAMOutput;
38	loizides	1.4	class TBranchRef;
39	loizides	1.1
40			class TAMSelector : public TSelector {
41	loizides	1.2	protected:
42	loizides	1.1
43			struct TAMEvtObj : TNamed {
44			// Class for storing event objects:
45			// It assumes ownership of the object.
46			// It is needed to force the THashTable to call Hash on a TNamed
47			// to allow lookup using the hash value given the object's name
48			// (as opposed to its pointer value, as is done for TObject's).
49	loizides	1.4	TObject* fObj; //the object
50	loizides	1.1	TAMEvtObj(TObject* obj) : TNamed(obj->GetName(),0), fObj(obj) {}
51			TAMEvtObj(TObject* obj, const char *name) : TNamed(name,0), fObj(obj) {}
52			virtual ~TAMEvtObj() { if (fObj!=0) delete fObj; }
53			};
54	loizides	1.4
55	loizides	1.11	class BranchProxy : public TObject {
56			// Class that acts as a proxy between the TRefTable, TAM and TBranchRef.
57	loizides	1.12	// If SetDoProxy(kTRUE) is called TRef branch auto-loading will be done
58			// via TAM loaders.
59	loizides	1.11	public:
60			BranchProxy(TAMSelector *sel, Bool_t e=kFALSE);
61	loizides	1.12	virtual ~BranchProxy();
62	loizides	1.11	void Disable();
63			void Enable();
64			TObject GetObjectWithID(UInt_t uid, TProcessID pid);
65			Bool_t Notify();
66
67			protected:
68			Bool_t Load(UInt_t uid, TProcessID pid, TBranchRef br, TRefTable *table);
69
70			TAMSelector *fSel; //ptr to TAMSelector (we are a friend)
71	loizides	1.14	TRefTable *fOrig; //ptr to original TRefTable filled by I/O
72			// (owner is TBranchRef)
73			TRefTable *fFake; //ptr to our fake TRefTable
74			// of which we are owner
75	loizides	1.11	Long64_t fCurEntry; //cache of current entry
76			Bool_t fBrRead[1024]; //flag which TBranchRef branch was read
77			};
78
79	loizides	1.1	TTree *fTree; //!the tree or chain
80	paus	1.15	TTreeCache *fTreeCache; //!tree cache
81			Int_t fCacheSize; //tree cache size
82
83	loizides	1.1	THashTable fBranchTable; //!table of requested branches
84	loizides	1.12	THashTable fEventObjs; //!table of objects available to any mod
85			// while the current event is processed
86			TAModule *fAModules; //!the top-most TAModule. Nothing but a
87			// container for more modules
88	loizides	1.1	Long64_t fCurEvt; //!the current event
89	loizides	1.12	TList *fOwnInput; //!keep pointer to own input list
90			// in case it was created by us
91			Bool_t fAnalysisAborted; //!if the analysis should be aborted
92			Bool_t fModAborted; //!if >=1 modules(s) are aborted
93			Bool_t fEventAborted; //!if the current event should be aborted
94			Bool_t fActNotify; //!if notify is active
95			// (avoiding recursive calls of Notify())
96			UInt_t fObjCounter; //!keep object counter for resetting it
97			// in the process loop
98			UInt_t fObjCounterRun; //!keep object counter for resetting it
99			// in process when end of run is reached
100			UInt_t fVerbosity; //if one wants to print debug info
101			BranchProxy fProxy; //proxy for reference resolving branch
102			// loading via TAM
103			Bool_t fDoProxy; //if TAMSelector should be proxy for
104			// TRef branch autoloads
105			Bool_t fDoObjTabClean; //true if TAMSelector should clean the
106			// object tables of process id's
107			Bool_t fObjTabClean; //bool to track whether object tables of
108			// process id's are currently clean
109	loizides	1.1	TList fLoaders; //list of data loaders
110
111			void AddNewOutputLists();
112	bendavid	1.9	void CleanObjTable(TProcessID *pid, UInt_t lastKeptUID) const;
113	loizides	1.1	void ClearAllLoaders();
114			void CopyModsFromInput();
115			Bool_t FindLoader(TAMBranchInfo* brInfo);
116	loizides	1.7	void LoadBranch(TAMBranchInfo* brInfo);
117	loizides	1.1	void TakeModsFromInput();
118			void TakeLoadersFromInput();
119			void ZeroAllBranches();
120
121			public:
122			TAMSelector();
123			virtual ~TAMSelector();
124
125			void AbortAnalysis();
126			void AbortEvent();
127			void AbortModule(TAModule* mod);
128			virtual void AddInput(TAModule* mod);
129	loizides	1.12	void AddLoader(TAMVirtualLoader *loader)
130			{ fLoaders.AddLast(loader); }
131	loizides	1.1	virtual Bool_t AddObjThisEvt(TObject* obj);
132			virtual Bool_t AddObjThisEvt(TObject* obj, const char *name);
133			void Begin(TTree* tree);
134	loizides	1.12	virtual Bool_t BeginRun() { return kFALSE; }
135			virtual Bool_t EndRun() { return kFALSE; }
136	loizides	1.1	TAMOutput FindModOutput(const TAModule mod);
137			virtual TObject FindObjThisEvt(const Char_t name) const;
138			virtual TObject FindPublicObj(const Char_t name) const;
139			Long64_t GetCurEvt() const { return fCurEvt; }
140	loizides	1.3	const TFile *GetCurrentFile() const;
141			TFile *GetCurrentFile();
142	loizides	1.1	const TAMOutput *GetModOutput() const;
143			TAMOutput *GetModOutput();
144	bendavid	1.10	TObject GetObjectWithID(UInt_t uid, TProcessID pid);
145	loizides	1.11	const TAModule *GetTopModule() const { return fAModules; }
146			const TTree *GetTree() const { return fTree; }
147			Bool_t GetObjTabClean() const { return fObjTabClean; }
148			TTree *GetTree() { return fTree; }
149			UInt_t GetVerbosity() const { return fVerbosity; }
150	loizides	1.1	void Init(TTree* tree);
151	loizides	1.11	Bool_t IsAModAborted() const { return fModAborted; }
152			Bool_t IsEventAborted() const { return fEventAborted; }
153	loizides	1.1	Bool_t IsAnalysisAborted() const { return fAnalysisAborted; }
154			void LoadBranch(const Char_t* bname);
155			Bool_t Notify();
156	loizides	1.12	Bool_t Process(Int_t entry)
157			{ return Process(static_cast<Long64_t>(entry)); }
158	loizides	1.1	Bool_t Process(Long64_t entry);
159			virtual Bool_t PublishObj(TObject* obj);
160			template <typename T>
161			void ReqBranch(const Char_t* bname, T*& address);
162			virtual TObject RemoveObjThisEvt(const Char_t name);
163			virtual TObject RetractObj(const Char_t name);
164	paus	1.15	void SetCacheSize(Int_t i) { fCacheSize = i; }
165	loizides	1.11	void SetDoProxy(Bool_t b) { fDoProxy = b; }
166			void SetDoObjTabClean(Bool_t b) { fDoObjTabClean = b; }
167			void SetVerbosity(UInt_t vb) { fVerbosity = vb; }
168	loizides	1.1	void SlaveBegin(TTree* tree);
169			void SlaveTerminate();
170			void Terminate();
171			Int_t Version() const { return 1; }
172
173	loizides	1.14	ClassDef(TAMSelector,8) // Tree analysis module selector
174	loizides	1.1	};
175
176
177			//______________________________________________________________________________
178			template <typename T>
179			inline void TAMSelector::ReqBranch(const Char_t* bname, T*& address)
180			{
181			// Tells the selector that a branch with the given name may be
182			// used by an TAModule and that the the module will access the branch
183			// using the pointer 'address'.
184
185	loizides	1.4	TAMBranchInfo* brInfo =
186			dynamic_cast<TAMBranchInfo*>( fBranchTable.FindObject(bname) );
187	loizides	1.1
188			if (brInfo==0) {
189			brInfo = new TAMBranchInfo(bname);
190			fBranchTable.Add(brInfo);
191			}
192
193	loizides	1.8	if (!brInfo->AddPtr(address))
194			AbortAnalysis();
195	loizides	1.1	}
196			#endif //ROOT_TAMSelector