TAM/interface/TAModule.h

//
// $Id: TAModule.h,v 1.6 2009/04/28 14:50:19 loizides Exp $
//

#ifndef ROOT_TAModule
#define ROOT_TAModule

// keep this for compatibility 
#define TAM_TAModule


// typeid include
#include <typeinfo>


#ifndef ROOT_TTask
#include "TTask.h"
#endif
#ifndef ROOT_Varargs
#include "Varargs.h"
#endif
#ifndef ROOT_TAMSelector
#include "TAMSelector.h"
#endif
#ifndef ROOT_TAMOutput
#include "TAMOutput.h"
#endif

class TFile;
class TStopwatch;


class TAModule : public TTask {
public:
   enum EModResult {
      kWarning,      //a problem requiring no action, just printing of a warning
      kAbortModule,  //a problem requiring this mod (and its submods) to stop
      kAbortEvent,   //a problem requiring the processing of this event to stop
      kStopModule,   //a problem requiring this module (and its submodules) 
                     // to stop for the rest of the analysis
      kAbortAnalysis //a problem requiring the analysis to stop
   };

private:
   TAMSelector        *fSelector; //!the selector processing the tree
   TAMOutput          *fOutput;   //the list of output objects for this mod
   Bool_t              fDefActv;  //!copy of fActive so that TAMSelector can 
                                  // temporarily change this mod's active-ness 
                                  // to abort the module or the event
   UInt_t              fVerbose;  //verbosity level
   Bool_t              fStopped;  //!indicate if module (and its submodules) are
                                  // aborted for the rest of the analysis
   Bool_t              fUseName;  //if true use this module's name when 
                                  // writing the output in the flattening mode

   static const Char_t kExecBegin;           //!key to mark Begin
   static const Char_t kExecSlaveBegin;      //!key to mark SlaveBegin
   static const Char_t kExecProcess;         //!key to mark Process
   static const Char_t kExecBeginRun;        //!key to mark BeginRun
   static const Char_t kExecEndRun;          //!key to mark EndRun
   static const Char_t kExecSlaveTerminate;  //!key to mark SlaveTerminate
   static const Char_t kExecTerminate;       //!key to mark Terminate
   
   void                AbortAnalysis();
   void                AbortModule();
   void                DeactivateAll();
   void                NewOutputList(TList* list); 
   Bool_t              NotifyAll();
   void                ResetAllActiveFlags();
   void                SetAllModOutput(TAMOutput* o);
   void                SetModOutput(TAMOutput* o);
   void                StopModule();

protected:
  
   // utility functions to be used by derived classes
   void                AbortEvent();
   virtual Bool_t      AddObjThisEvt(TObject* obj);
   virtual Bool_t      AddObjThisEvt(TObject* obj, const char *name);
   template <class OC>
   void                AddOutput(OC* const & obj);
   const TAMSelector  *GetSelector()         const { return fSelector; }
   Bool_t              IsEventAborted()      const;
   Bool_t              IsAnalysisAborted()   const;
   void                ls(Option_t *option)  const;
   void                LoadBranch(const Char_t* bname);
   virtual TObject    *FindObjThisEvt(const Char_t* name) const;
   virtual Bool_t      Notify()                    { return kTRUE; }
   virtual TObject    *RemoveObjThisEvt(const Char_t* name);
   void                RemoveOutput(TObject* obj);
   template <typename T>
   void                ReqBranch(const Char_t* bname, T*& address);
   void                SendError(const EModResult errLevel,
                                 const Char_t* location,
                                 const Char_t* formattedMsg, ...);
   void                SkipEvent();

   // functions to be overloaded by specific TAModule
   virtual void        Begin()           {}
   virtual void        SlaveBegin()      {}
   virtual void        Process()         {}
   virtual void        BeginRun()        {}
   virtual void        EndRun()          {}
   virtual void        SlaveTerminate()  {}
   virtual void        Terminate()       {}

public:
   
   TAModule();
   TAModule(const Char_t* name, const Char_t* title);
   virtual ~TAModule();
   
   void                SetActive(Bool_t act = kTRUE) { SetDefActive(act); }
   virtual void        Browse(TBrowser* b);
   // intentionally have no GetSelector as modules should never directly
   // interact with the selector, the input list or the output list
   Bool_t              CheckSelectors(const TAMSelector* sel,
                                      const Bool_t warn=kTRUE) const;
   // TAMSelector is a friend to allow it to call Exec
   // using the private variables such as kExecProcess
   // and to prevent TAModules inheritting from this class
   // from making such explicit calls.
   friend class TAMSelector;
   void                Exec(Option_t* option);
   TObject            *FindPublicObj(const Char_t* name) const;
   TFile              *GetCurrentFile() const;
   const TAMOutput    *GetModOutput()   const { return fOutput;          }
   TAMOutput          *GetModOutput()         { return fOutput;          }
   TList*              GetSubModules()        { return GetListOfTasks(); }
   const TList        *GetSubModules()  const { return GetListOfTasks(); }
   Bool_t              GetUseName()     const { return fUseName;         }   
   UInt_t              GetVerbosity()   const { return fVerbose;         }
   virtual void        Print(Option_t *option="") const;
   Bool_t              PublishObj(TObject* obj);
   TObject            *RetractObj(const Char_t* name);
   void                SetDefActive(Bool_t active);
   void                SetSelector(TAMSelector* sel);
   void                SetUseName(Bool_t b)          { fUseName = b;     }
   void                SetVerbosity(UInt_t vb)       { fVerbose = vb;    }

   static const char  *Version();

   ClassDef(TAModule,4) // Base class for modular processing a tree
};


//______________________________________________________________________________
template <class OC>
inline void TAModule::AddOutput(OC* const & obj) 
{
   // Add the object to the list of output objects of this module.
   // The Proof facility can then merge this object from each worker
   // computer.
   // This version of the function will also store the address of the
   // pointer, and if the pointer is a member of the module, the member
   // will be made to point to the object in the output list on the
   // client computer before Terminate is called.

   if (fOutput!=0) {
      fOutput->AddOutput(obj);
   } else {
      SendError(kAbortAnalysis,
                "AddOutput",
                "fOutput is null in module [%s]",
                GetName());
   }
}


//______________________________________________________________________________
inline Bool_t TAModule::IsEventAborted() const 
{ 
   // Return kTRUE if event has been aborted.

   return (fSelector==0) ? kFALSE : fSelector->IsEventAborted(); 
}


//______________________________________________________________________________
inline Bool_t TAModule::IsAnalysisAborted() const 
{ 
   // Return kTRUE if analysis has been aborted.

   return (fSelector==0) ? kFALSE : fSelector->IsAnalysisAborted(); 
}

//______________________________________________________________________________
template <typename T>
inline void TAModule::ReqBranch(const Char_t* bname, T*& address) 
{
   // Requests that the branch with the specified name be made available
   // during processing and that it be read in to the address specified.
   // The TAMSelector will automatically change the value of the pointer 
   // pointed to ('*address') to the address of the branch entry when it
   // is read in via LoadBranch.

   if (fSelector!=0) {
      fSelector->ReqBranch(bname, address);
   } else {
      SendError(kAbortAnalysis,
                "ReqBranch",
                "fSelector is null in module [%s]",
                GetName());
   }
}


//______________________________________________________________________________
inline void TAModule::SetDefActive(Bool_t active) 
{
   // Set the activity and make it the default behavior.

   fDefActv = active; 
   TTask::SetActive(active);   
}

#endif //ROOT_TAModule
Revision:	1.7
Committed:	Mon Jul 13 19:18:38 2009 UTC (15 years, 9 months ago) by loizides
Content type:	text/plain
Branch:	MAIN
Changes since 1.6:	+40 -16 lines
Log Message:	Add GetUseName to check if module name should be appended to output names.
#	User	Rev	Content
1	loizides	1.1	//
2	loizides	1.7	// $Id: TAModule.h,v 1.6 2009/04/28 14:50:19 loizides Exp $
3	loizides	1.1	//
4
5			#ifndef ROOT_TAModule
6			#define ROOT_TAModule
7
8			// keep this for compatibility
9			#define TAM_TAModule
10
11
12			// typeid include
13			#include <typeinfo>
14
15
16			#ifndef ROOT_TTask
17			#include "TTask.h"
18			#endif
19			#ifndef ROOT_Varargs
20			#include "Varargs.h"
21			#endif
22			#ifndef ROOT_TAMSelector
23			#include "TAMSelector.h"
24			#endif
25			#ifndef ROOT_TAMOutput
26			#include "TAMOutput.h"
27			#endif
28
29			class TFile;
30			class TStopwatch;
31
32
33			class TAModule : public TTask {
34			public:
35			enum EModResult {
36	loizides	1.7	kWarning, //a problem requiring no action, just printing of a warning
37	loizides	1.1	kAbortModule, //a problem requiring this mod (and its submods) to stop
38			kAbortEvent, //a problem requiring the processing of this event to stop
39	loizides	1.7	kStopModule, //a problem requiring this module (and its submodules)
40			// to stop for the rest of the analysis
41			kAbortAnalysis //a problem requiring the analysis to stop
42	loizides	1.1	};
43
44			private:
45	loizides	1.7	TAMSelector *fSelector; //!the selector processing the tree
46	loizides	1.1	TAMOutput *fOutput; //the list of output objects for this mod
47	loizides	1.7	Bool_t fDefActv; //!copy of fActive so that TAMSelector can
48			// temporarily change this mod's active-ness
49			// to abort the module or the event
50	loizides	1.1	UInt_t fVerbose; //verbosity level
51	loizides	1.7	Bool_t fStopped; //!indicate if module (and its submodules) are
52			// aborted for the rest of the analysis
53			Bool_t fUseName; //if true use this module's name when
54			// writing the output in the flattening mode
55	loizides	1.1
56			static const Char_t kExecBegin; //!key to mark Begin
57			static const Char_t kExecSlaveBegin; //!key to mark SlaveBegin
58			static const Char_t kExecProcess; //!key to mark Process
59	loizides	1.2	static const Char_t kExecBeginRun; //!key to mark BeginRun
60			static const Char_t kExecEndRun; //!key to mark EndRun
61	loizides	1.1	static const Char_t kExecSlaveTerminate; //!key to mark SlaveTerminate
62			static const Char_t kExecTerminate; //!key to mark Terminate
63
64	loizides	1.6	void AbortAnalysis();
65			void AbortModule();
66	loizides	1.1	void DeactivateAll();
67			void NewOutputList(TList* list);
68			Bool_t NotifyAll();
69			void ResetAllActiveFlags();
70			void SetAllModOutput(TAMOutput* o);
71			void SetModOutput(TAMOutput* o);
72			void StopModule();
73
74			protected:
75	loizides	1.6
76			// utility functions to be used by derived classes
77	loizides	1.5	void AbortEvent();
78	loizides	1.1	virtual Bool_t AddObjThisEvt(TObject* obj);
79			virtual Bool_t AddObjThisEvt(TObject* obj, const char *name);
80			template <class OC>
81			void AddOutput(OC* const & obj);
82	loizides	1.4	const TAMSelector *GetSelector() const { return fSelector; }
83	loizides	1.7	Bool_t IsEventAborted() const;
84			Bool_t IsAnalysisAborted() const;
85	loizides	1.4	void ls(Option_t *option) const;
86	loizides	1.1	void LoadBranch(const Char_t* bname);
87			virtual TObject FindObjThisEvt(const Char_t name) const;
88	loizides	1.5	virtual Bool_t Notify() { return kTRUE; }
89	loizides	1.1	virtual TObject RemoveObjThisEvt(const Char_t name);
90			void RemoveOutput(TObject* obj);
91			template <typename T>
92			void ReqBranch(const Char_t* bname, T*& address);
93			void SendError(const EModResult errLevel,
94	loizides	1.5	const Char_t* location,
95			const Char_t* formattedMsg, ...);
96	loizides	1.1	void SkipEvent();
97
98			// functions to be overloaded by specific TAModule
99			virtual void Begin() {}
100			virtual void SlaveBegin() {}
101			virtual void Process() {}
102	loizides	1.2	virtual void BeginRun() {}
103			virtual void EndRun() {}
104	loizides	1.1	virtual void SlaveTerminate() {}
105			virtual void Terminate() {}
106
107			public:
108
109			TAModule();
110			TAModule(const Char_t* name, const Char_t* title);
111			virtual ~TAModule();
112
113	loizides	1.7	void SetActive(Bool_t act = kTRUE) { SetDefActive(act); }
114	loizides	1.1	virtual void Browse(TBrowser* b);
115			// intentionally have no GetSelector as modules should never directly
116			// interact with the selector, the input list or the output list
117			Bool_t CheckSelectors(const TAMSelector* sel,
118			const Bool_t warn=kTRUE) const;
119			// TAMSelector is a friend to allow it to call Exec
120			// using the private variables such as kExecProcess
121			// and to prevent TAModules inheritting from this class
122			// from making such explicit calls.
123			friend class TAMSelector;
124			void Exec(Option_t* option);
125			TObject FindPublicObj(const Char_t name) const;
126			TFile *GetCurrentFile() const;
127	loizides	1.7	const TAMOutput *GetModOutput() const { return fOutput; }
128			TAMOutput *GetModOutput() { return fOutput; }
129	loizides	1.1	TList* GetSubModules() { return GetListOfTasks(); }
130			const TList *GetSubModules() const { return GetListOfTasks(); }
131	loizides	1.7	Bool_t GetUseName() const { return fUseName; }
132			UInt_t GetVerbosity() const { return fVerbose; }
133	loizides	1.1	virtual void Print(Option_t *option="") const;
134			Bool_t PublishObj(TObject* obj);
135			TObject RetractObj(const Char_t name);
136			void SetDefActive(Bool_t active);
137			void SetSelector(TAMSelector* sel);
138	loizides	1.7	void SetUseName(Bool_t b) { fUseName = b; }
139			void SetVerbosity(UInt_t vb) { fVerbose = vb; }
140	loizides	1.1
141			static const char *Version();
142
143	loizides	1.7	ClassDef(TAModule,4) // Base class for modular processing a tree
144	loizides	1.1	};
145
146
147			//______________________________________________________________________________
148			template <class OC>
149			inline void TAModule::AddOutput(OC* const & obj)
150			{
151			// Add the object to the list of output objects of this module.
152			// The Proof facility can then merge this object from each worker
153			// computer.
154			// This version of the function will also store the address of the
155			// pointer, and if the pointer is a member of the module, the member
156			// will be made to point to the object in the output list on the
157			// client computer before Terminate is called.
158
159			if (fOutput!=0) {
160			fOutput->AddOutput(obj);
161			} else {
162			SendError(kAbortAnalysis,
163			"AddOutput",
164			"fOutput is null in module [%s]",
165			GetName());
166			}
167			}
168
169
170			//______________________________________________________________________________
171	loizides	1.7	inline Bool_t TAModule::IsEventAborted() const
172			{
173			// Return kTRUE if event has been aborted.
174
175			return (fSelector==0) ? kFALSE : fSelector->IsEventAborted();
176			}
177
178
179			//______________________________________________________________________________
180			inline Bool_t TAModule::IsAnalysisAborted() const
181			{
182			// Return kTRUE if analysis has been aborted.
183
184			return (fSelector==0) ? kFALSE : fSelector->IsAnalysisAborted();
185			}
186
187			//______________________________________________________________________________
188	loizides	1.1	template <typename T>
189			inline void TAModule::ReqBranch(const Char_t* bname, T*& address)
190			{
191			// Requests that the branch with the specified name be made available
192			// during processing and that it be read in to the address specified.
193			// The TAMSelector will automatically change the value of the pointer
194			// pointed to ('*address') to the address of the branch entry when it
195			// is read in via LoadBranch.
196
197			if (fSelector!=0) {
198			fSelector->ReqBranch(bname, address);
199			} else {
200			SendError(kAbortAnalysis,
201			"ReqBranch",
202			"fSelector is null in module [%s]",
203			GetName());
204			}
205			}
206
207
208			//______________________________________________________________________________
209			inline void TAModule::SetDefActive(Bool_t active)
210			{
211			// Set the activity and make it the default behavior.
212
213			fDefActv = active;
214			TTask::SetActive(active);
215			}
216
217			#endif //ROOT_TAModule