PhysicsMod/interface/PublisherMod.h

//--------------------------------------------------------------------------------------------------
// $Id: PublisherMod.h,v 1.8 2009/05/18 06:30:38 loizides Exp $
//
// PublisherMod
//
// This module simply loads a branch and publishes its content into an ObjArray. 
// Using PublisherPerEvent() one can chose whether the array will be published
// globally (ie only in SlaveBegin) or on per-event basis.
//
// Authors: C.Loizides
//--------------------------------------------------------------------------------------------------

#ifndef MITANA_PHYSICSMOD_PUBLISHERMOD_H
#define MITANA_PHYSICSMOD_PUBLISHERMOD_H

#include "MitAna/DataCont/interface/Collection.h"
#include "MitAna/DataCont/interface/ObjArray.h"
#include "MitAna/TreeMod/interface/BaseMod.h" 

namespace mithep 
{
  template<class TIn, class TOut=TIn>
  class PublisherMod : public BaseMod 
  {
    public:
      PublisherMod(const char *name="PublisherMod", 
                   const char *title="Publisher module");

      const char              *GetBranchName()              const { return fBranchName;     }
      const char              *GetInputName()               const { return GetBranchName(); }
      const char              *GetOutputName()              const { return GetPublicName(); }
      const char              *GetPublicName()              const { return fPublicName;     }
      Bool_t                   GetPubPerEvent()             const { return fPubPerEvent;    }
      void                     SetBranchName(const char *n)       { fBranchName=n;          }
      void                     SetInputName(const char *n)        { SetBranchName(n);       }
      void                     SetOutputName(const char *n)       { SetPublicName(n);       }
      void                     SetPublicName(const char *n)       { fPublicName=n;          }
      void                     PublishPerEvent(Bool_t b)          { fPubPerEvent = b;       }

    protected:
      TString                  fBranchName;    //name of collection
      TString                  fPublicName;    //name of collection
      Bool_t                   fPubPerEvent;   //=true then publish per event (def=1)
      const Collection<TIn>   *fColIn;         //!pointer to collection (in) 
      ObjArray<TOut>          *fColOut;        //!pointer to collection (out)

      void                     Process();
      void                     SlaveBegin();
      void                     SlaveTerminate();

      ClassDefT(PublisherMod, 1) // Publisher module
  };
}

//--------------------------------------------------------------------------------------------------
template<class TIn, class TOut>
mithep::PublisherMod<TIn, TOut>::PublisherMod(const char *name, const char *title) : 
  BaseMod(name,title),
  fBranchName("SetMe"),
  fPublicName(""),
  fPubPerEvent(kTRUE),
  fColIn(0),
  fColOut(0)
{
  // Constructor.
}

//--------------------------------------------------------------------------------------------------
template<class TIn, class TOut>
void mithep::PublisherMod<TIn, TOut>::Process()
{
  // Load the branch, add pointers to the object array. Publish object array if needed.

  LoadBranch(GetBranchName());
  if (fPubPerEvent)
    fColOut = new mithep::ObjArray<TOut>(0, GetPublicName());
  else
    fColOut->Reset();

  UInt_t entries = fColIn->GetEntries();
  for(UInt_t i=0; i<entries; ++i)
    fColOut->Add(fColIn->At(i));

  if (fPubPerEvent) 
    AddObjThisEvt(fColOut);
}

//--------------------------------------------------------------------------------------------------
template<class TIn, class TOut>
void mithep::PublisherMod<TIn, TOut>::SlaveBegin()
{
  // Request the branch to be published. Depending on the user's decision publish the array.

  ReqBranch(GetBranchName(), fColIn);

  if (fPublicName.IsNull())
    fPublicName = GetBranchName();

  if (!GetPubPerEvent()) {
    fColOut = new mithep::ObjArray<TOut>(0, GetPublicName());
    PublishObj(fColOut);
  }
}

//--------------------------------------------------------------------------------------------------
template<class TIn, class TOut>
void mithep::PublisherMod<TIn, TOut>::SlaveTerminate()
{
  // Cleanup in case objects are published only once.

  if (!fPubPerEvent) {
    RetractObj(GetPublicName());
    delete fColOut;
  }
}
#endif
Revision:	1.9
Committed:	Mon Jun 15 15:00:16 2009 UTC (15 years, 10 months ago) by loizides
Content type:	text/plain
Branch:	MAIN
CVS Tags:	Mit_009b
Changes since 1.8:	+3 -2 lines
Log Message:	Added proper fwd defs plus split up complilation of MitAna/DataTree LinkDefs.
#	User	Rev	Content
1	loizides	1.1	//--------------------------------------------------------------------------------------------------
2	loizides	1.9	// $Id: PublisherMod.h,v 1.8 2009/05/18 06:30:38 loizides Exp $
3	loizides	1.1	//
4			// PublisherMod
5			//
6	loizides	1.3	// This module simply loads a branch and publishes its content into an ObjArray.
7			// Using PublisherPerEvent() one can chose whether the array will be published
8			// globally (ie only in SlaveBegin) or on per-event basis.
9			//
10	loizides	1.1	// Authors: C.Loizides
11			//--------------------------------------------------------------------------------------------------
12
13			#ifndef MITANA_PHYSICSMOD_PUBLISHERMOD_H
14			#define MITANA_PHYSICSMOD_PUBLISHERMOD_H
15
16	loizides	1.9	#include "MitAna/DataCont/interface/Collection.h"
17			#include "MitAna/DataCont/interface/ObjArray.h"
18	loizides	1.1	#include "MitAna/TreeMod/interface/BaseMod.h"
19
20			namespace mithep
21			{
22	bendavid	1.6	template<class TIn, class TOut=TIn>
23	loizides	1.1	class PublisherMod : public BaseMod
24			{
25			public:
26			PublisherMod(const char *name="PublisherMod",
27			const char *title="Publisher module");
28
29	loizides	1.5	const char *GetBranchName() const { return fBranchName; }
30			const char *GetInputName() const { return GetBranchName(); }
31			const char *GetOutputName() const { return GetPublicName(); }
32			const char *GetPublicName() const { return fPublicName; }
33			Bool_t GetPubPerEvent() const { return fPubPerEvent; }
34			void SetBranchName(const char *n) { fBranchName=n; }
35			void SetInputName(const char *n) { SetBranchName(n); }
36			void SetOutputName(const char *n) { SetPublicName(n); }
37			void SetPublicName(const char *n) { fPublicName=n; }
38			void PublishPerEvent(Bool_t b) { fPubPerEvent = b; }
39	loizides	1.1
40			protected:
41			TString fBranchName; //name of collection
42			TString fPublicName; //name of collection
43	loizides	1.3	Bool_t fPubPerEvent; //=true then publish per event (def=1)
44	bendavid	1.6	const Collection<TIn> *fColIn; //!pointer to collection (in)
45			ObjArray<TOut> *fColOut; //!pointer to collection (out)
46	loizides	1.1
47			void Process();
48			void SlaveBegin();
49	loizides	1.3	void SlaveTerminate();
50	loizides	1.1
51	loizides	1.4	ClassDefT(PublisherMod, 1) // Publisher module
52	loizides	1.1	};
53			}
54
55			//--------------------------------------------------------------------------------------------------
56	bendavid	1.6	template<class TIn, class TOut>
57			mithep::PublisherMod<TIn, TOut>::PublisherMod(const char name, const char title) :
58	loizides	1.1	BaseMod(name,title),
59	loizides	1.3	fBranchName("SetMe"),
60	loizides	1.1	fPublicName(""),
61	loizides	1.3	fPubPerEvent(kTRUE),
62			fColIn(0),
63			fColOut(0)
64	loizides	1.1	{
65			// Constructor.
66			}
67
68			//--------------------------------------------------------------------------------------------------
69	bendavid	1.6	template<class TIn, class TOut>
70			void mithep::PublisherMod<TIn, TOut>::Process()
71	loizides	1.1	{
72	loizides	1.3	// Load the branch, add pointers to the object array. Publish object array if needed.
73	loizides	1.1
74			LoadBranch(GetBranchName());
75	loizides	1.3	if (fPubPerEvent)
76	bendavid	1.6	fColOut = new mithep::ObjArray<TOut>(0, GetPublicName());
77	loizides	1.3	else
78			fColOut->Reset();
79
80			UInt_t entries = fColIn->GetEntries();
81			for(UInt_t i=0; i<entries; ++i)
82			fColOut->Add(fColIn->At(i));
83
84			if (fPubPerEvent)
85			AddObjThisEvt(fColOut);
86	loizides	1.1	}
87
88			//--------------------------------------------------------------------------------------------------
89	bendavid	1.6	template<class TIn, class TOut>
90			void mithep::PublisherMod<TIn, TOut>::SlaveBegin()
91	loizides	1.1	{
92	loizides	1.3	// Request the branch to be published. Depending on the user's decision publish the array.
93	loizides	1.1
94	loizides	1.3	ReqBranch(GetBranchName(), fColIn);
95	loizides	1.1
96			if (fPublicName.IsNull())
97	loizides	1.8	fPublicName = GetBranchName();
98	loizides	1.3
99			if (!GetPubPerEvent()) {
100	bendavid	1.6	fColOut = new mithep::ObjArray<TOut>(0, GetPublicName());
101	loizides	1.3	PublishObj(fColOut);
102			}
103			}
104
105			//--------------------------------------------------------------------------------------------------
106	bendavid	1.6	template<class TIn, class TOut>
107			void mithep::PublisherMod<TIn, TOut>::SlaveTerminate()
108	loizides	1.3	{
109			// Cleanup in case objects are published only once.
110
111			if (!fPubPerEvent) {
112			RetractObj(GetPublicName());
113			delete fColOut;
114			}
115	loizides	1.1	}
116			#endif