HbbAnalysis/interface/HbbEvent.hh

#ifndef HbbAnalysis_HbbEvent_hh
#define HbbAnalysis_HbbEvent_hh
#include <vector>
#include <string>

#include "UserCode/HbbAnalysis/interface/GenParticle.hh"
#include "UserCode/HbbAnalysis/interface/Electron.hh"
#include "UserCode/HbbAnalysis/interface/Muon.hh"
#include "UserCode/HbbAnalysis/interface/Tau.hh"
#include "UserCode/HbbAnalysis/interface/Jet.hh"
#include "UserCode/HbbAnalysis/interface/GenJet.hh"
#include "UserCode/HbbAnalysis/interface/Met.hh"
#include "UserCode/HbbAnalysis/interface/Trigger.hh"
#include "UserCode/HbbAnalysis/interface/Vertex.hh"
#include "UserCode/HbbAnalysis/interface/BeamSpot.hh"
#include "UserCode/HbbAnalysis/interface/HLTObject.hh"
#include "UserCode/HbbAnalysis/interface/L1Object.hh"
#include "UserCode/HbbAnalysis/interface/GenInfo.hh"

namespace HbbAnalysis {
  
  class HbbEvent {

  public:
  
    /** Constructor/Destructor */
  
    HbbEvent():
      particles_(),
      genjets_(),
      lheParticles_(),
      electrons_(),
      muons_(),
      caloTaus_(),
      pfTaus_(),
      caloJets_(),
      jptJets_(),
      ak7Jets_(),
      pfJets_(),
      caloMet_(),
      tcMet_(),
      pfMet_(),
      triggers_(),
      vertices_(),
      beamSpot_(),
      l1Jets_(),
      hltObjs_(),
      puVars_(),
      event_(0),
      run_(0),
      lb_(0),
      bx_(0),
      genInfo_(0),
      isData_(false)
    {};

    ~HbbEvent(){
      Clear();
    };
  
    /** Getters */

    inline std::vector<GenParticle> & particles() 
    {
      return particles_;
    };

    inline std::vector<GenJet> & genjets() 
    {
      return genjets_;
    };

    inline std::vector<GenParticle> & lheParticles() 
    {
      return lheParticles_;
    };

    inline std::vector<Electron> & electrons() 
    {
      return electrons_;
    };

    inline std::vector<Muon> & muons() 
    {
      return muons_;
    };
  
    inline std::vector<Tau> & caloTaus() 
    {
      return caloTaus_;
    };
  
    inline std::vector<Tau> & pfTaus() 
    {
      return pfTaus_;
    };
  
    inline std::vector<Jet> & caloJets() 
    {
      return caloJets_;
    };
  
    inline std::vector<Jet> & jptJets() 
    {
      return jptJets_;
    };

    inline std::vector<Jet> & ak7Jets() 
    {
      return ak7Jets_;
    };
  
    inline std::vector<Jet> & pfJets() 
    {
      return pfJets_;
    };
  
    inline Met & caloMet() 
    {
      return caloMet_;
    };
  
    inline Met & tcMet() 
    {
      return tcMet_;
    };
  
    inline Met & pfMet() 
    {
      return pfMet_;
    };
  
    inline std::vector<Trigger> & triggers() 
    {
      return triggers_;
    };
  
    inline std::vector<Vertex> & vertices() 
    {
      return vertices_;
    };
  
    inline BeamSpot & beamSpot() {
      return beamSpot_;
    }

    inline std::vector<L1Object> & l1Jets() 
    {
      return l1Jets_;
    };
 
    inline std::vector<HLTObject> & hltObjects() 
    {
      return hltObjs_;
    };

    inline std::vector<PUVars> & puVars()
    {
      return puVars_;
    };

    inline unsigned int event() 
    {
      return event_;
    };

    inline unsigned int run() 
    {
      return run_;
    };

     inline unsigned int lumiBlock() 
    {
      return lb_;
    };

     inline unsigned int bx() 
    {
      return bx_;
    };

    inline GenInfo* generatorInfo()
    {
      return genInfo_;
    };

    inline bool isRealData()
    {
      return isData_;
    }

    /** Setters */
  

    inline void particles(const std::vector<GenParticle> & aVec) 
    {
      particles_=aVec;
    };

    inline void genjets(const std::vector<GenJet> & aVec) 
    {
      genjets_=aVec;
    };

    inline void lheParticles(const std::vector<GenParticle> & aVec) 
    {
      lheParticles_=aVec;
    };

    inline void electrons(const std::vector<Electron> & aVec) 
    {
      electrons_=aVec;
    };

    inline void muons(const std::vector<Muon> & aVec) 
    {
      muons_=aVec;
    };

    inline void caloTaus(const std::vector<Tau> & aVec) 
    {
      caloTaus_=aVec;
    };

    inline void pfTaus(const std::vector<Tau> & aVec) 
    {
      pfTaus_=aVec;
    };

    inline void caloJets(const std::vector<Jet> & aVec) 
    {
      caloJets_=aVec;
    };

    inline void jptJets(const std::vector<Jet> & aVec) 
    {
      jptJets_=aVec;
    };

    inline void ak7Jets(const std::vector<Jet> & aVec) 
    {
      ak7Jets_=aVec;
    };

    inline void pfJets(const std::vector<Jet> & aVec) 
    {
      pfJets_=aVec;
    };

    inline void caloMet(const Met & aValue) 
    {
      caloMet_=aValue;
    };

    inline void tcMet(const Met & aValue) 
    {
      tcMet_=aValue;
    };

    inline void pfMet(const Met & aValue) 
    {
      pfMet_=aValue;
    };

    inline void triggers(const std::vector<Trigger> & aVec) 
    {
      triggers_=aVec;
    };

    inline void vertices(const std::vector<Vertex> & aVec) 
    {
      vertices_=aVec;
    };

    inline void beamSpot(const BeamSpot & aBS)
    {
      beamSpot_ = aBS;
    }

    inline void l1Jets(const std::vector<L1Object> & aVec) 
    {
      l1Jets_=aVec;
    };

    inline void hltObjects(const std::vector<HLTObject> & aVec) 
    {
      hltObjs_=aVec;
    };

    inline void puVars(const std::vector<PUVars> & aVec)
    {
      puVars_=aVec;
    };

    inline void event(const unsigned int aHbbEvent) {
      event_ = aHbbEvent;
    };

    inline void run(const unsigned int aHbbRun) {
      run_ = aHbbRun;
    };

    inline void lumiBlock(const unsigned int aHbbLB) {
      lb_ = aHbbLB;
    };
 
    inline void bx(const unsigned int aBX) {
      bx_ = aBX;
    };

    inline void generatorInfo(const GenInfo & aInfo){
      genInfo_ = new GenInfo(aInfo);
    };

    inline void isRealData(const bool isData){
      isData_ = isData;
    }

    void Clear(){
      particles_.clear();
      genjets_.clear();
      lheParticles_.clear();
      electrons_.clear();
      muons_.clear();
      caloTaus_.clear();
      pfTaus_.clear();
      caloJets_.clear();
      jptJets_.clear();
      ak7Jets_.clear();
      pfJets_.clear();
      caloMet_.Clear();
      tcMet_.Clear();
      pfMet_.Clear();
      triggers_.clear();
      vertices_.clear();
      beamSpot_.Clear();
      l1Jets_.clear();
      hltObjs_.clear();
      puVars_.clear();
      if (genInfo_) delete genInfo_;
      genInfo_ = 0;
    };
  
    //void order(){}; 
    void retrieveLeadJets(const std::vector<HbbAnalysis::Jet> & aVec,
                          const std::vector<HbbAnalysis::Jet> & aNonbVec,
                          HbbAnalysis::Jet & aLead,
                          HbbAnalysis::Jet & aNtoLead);

  private:
  
    std::vector<GenParticle> particles_;
    std::vector<GenJet> genjets_;
    std::vector<GenParticle> lheParticles_;
    std::vector<Electron> electrons_;
    std::vector<Muon> muons_;
    std::vector<Tau> caloTaus_;
    std::vector<Tau> pfTaus_;
    std::vector<Jet> caloJets_;
    std::vector<Jet> jptJets_;
    std::vector<Jet> ak7Jets_;
    std::vector<Jet> pfJets_;
    Met caloMet_;
    Met tcMet_;
    Met pfMet_;
    std::vector<Trigger> triggers_;
    std::vector<Vertex> vertices_;
    BeamSpot beamSpot_;
    std::vector<L1Object> l1Jets_;
    std::vector<HLTObject> hltObjs_;
    std::vector<PUVars> puVars_;

 
    unsigned int event_;
    unsigned int run_;
    unsigned int lb_;
    unsigned int bx_;

    //pointer, not created unless it is MC file....
    GenInfo* genInfo_;

    bool isData_;

  };//class
    
}//namespace

#endif //HbbAnalysis_HbbEvent_hh
Revision:	1.12
Committed:	Sat Jul 16 10:00:53 2011 UTC (13 years, 9 months ago) by amagnan
Content type:	text/plain
Branch:	MAIN
Changes since 1.11:	+14 -0 lines
Log Message:	add genjet collections
#	User	Rev	Content
1	amagnan	1.1	#ifndef HbbAnalysis_HbbEvent_hh
2			#define HbbAnalysis_HbbEvent_hh
3			#include <vector>
4			#include <string>
5
6			#include "UserCode/HbbAnalysis/interface/GenParticle.hh"
7			#include "UserCode/HbbAnalysis/interface/Electron.hh"
8			#include "UserCode/HbbAnalysis/interface/Muon.hh"
9			#include "UserCode/HbbAnalysis/interface/Tau.hh"
10			#include "UserCode/HbbAnalysis/interface/Jet.hh"
11	amagnan	1.12	#include "UserCode/HbbAnalysis/interface/GenJet.hh"
12	amagnan	1.1	#include "UserCode/HbbAnalysis/interface/Met.hh"
13			#include "UserCode/HbbAnalysis/interface/Trigger.hh"
14	amagnan	1.2	#include "UserCode/HbbAnalysis/interface/Vertex.hh"
15	amagnan	1.8	#include "UserCode/HbbAnalysis/interface/BeamSpot.hh"
16	amagnan	1.5	#include "UserCode/HbbAnalysis/interface/HLTObject.hh"
17			#include "UserCode/HbbAnalysis/interface/L1Object.hh"
18	amagnan	1.6	#include "UserCode/HbbAnalysis/interface/GenInfo.hh"
19	amagnan	1.1
20			namespace HbbAnalysis {
21
22			class HbbEvent {
23
24			public:
25
26			/** Constructor/Destructor */
27
28			HbbEvent():
29			particles_(),
30	amagnan	1.12	genjets_(),
31	amagnan	1.10	lheParticles_(),
32	amagnan	1.1	electrons_(),
33			muons_(),
34			caloTaus_(),
35			pfTaus_(),
36			caloJets_(),
37			jptJets_(),
38	amagnan	1.9	ak7Jets_(),
39	amagnan	1.1	pfJets_(),
40			caloMet_(),
41			tcMet_(),
42			pfMet_(),
43			triggers_(),
44	amagnan	1.2	vertices_(),
45	amagnan	1.8	beamSpot_(),
46	amagnan	1.5	l1Jets_(),
47	amagnan	1.7	hltObjs_(),
48	agilbert	1.11	puVars_(),
49	amagnan	1.2	event_(0),
50			run_(0),
51	amagnan	1.4	lb_(0),
52	amagnan	1.7	bx_(0),
53	amagnan	1.6	genInfo_(0),
54	amagnan	1.4	isData_(false)
55	amagnan	1.1	{};
56
57			~HbbEvent(){
58			Clear();
59			};
60
61			/** Getters */
62
63			inline std::vector<GenParticle> & particles()
64			{
65			return particles_;
66			};
67
68	amagnan	1.12	inline std::vector<GenJet> & genjets()
69			{
70			return genjets_;
71			};
72
73	amagnan	1.10	inline std::vector<GenParticle> & lheParticles()
74			{
75			return lheParticles_;
76			};
77
78	amagnan	1.1	inline std::vector<Electron> & electrons()
79			{
80			return electrons_;
81			};
82
83			inline std::vector<Muon> & muons()
84			{
85			return muons_;
86			};
87
88			inline std::vector<Tau> & caloTaus()
89			{
90			return caloTaus_;
91			};
92
93			inline std::vector<Tau> & pfTaus()
94			{
95			return pfTaus_;
96			};
97
98			inline std::vector<Jet> & caloJets()
99			{
100			return caloJets_;
101			};
102
103			inline std::vector<Jet> & jptJets()
104			{
105			return jptJets_;
106			};
107	amagnan	1.9
108			inline std::vector<Jet> & ak7Jets()
109			{
110			return ak7Jets_;
111			};
112	amagnan	1.1
113			inline std::vector<Jet> & pfJets()
114			{
115			return pfJets_;
116			};
117
118			inline Met & caloMet()
119			{
120			return caloMet_;
121			};
122
123			inline Met & tcMet()
124			{
125			return tcMet_;
126			};
127
128			inline Met & pfMet()
129			{
130			return pfMet_;
131			};
132
133			inline std::vector<Trigger> & triggers()
134			{
135			return triggers_;
136			};
137	amagnan	1.2
138			inline std::vector<Vertex> & vertices()
139			{
140			return vertices_;
141			};
142	amagnan	1.5
143	amagnan	1.8	inline BeamSpot & beamSpot() {
144			return beamSpot_;
145			}
146
147	amagnan	1.5	inline std::vector<L1Object> & l1Jets()
148			{
149			return l1Jets_;
150			};
151
152	amagnan	1.7	inline std::vector<HLTObject> & hltObjects()
153	amagnan	1.5	{
154	amagnan	1.7	return hltObjs_;
155	amagnan	1.5	};
156	amagnan	1.1
157	agilbert	1.11	inline std::vector<PUVars> & puVars()
158			{
159			return puVars_;
160			};
161
162	amagnan	1.1	inline unsigned int event()
163			{
164			return event_;
165			};
166	amagnan	1.2
167			inline unsigned int run()
168			{
169			return run_;
170			};
171
172			inline unsigned int lumiBlock()
173			{
174			return lb_;
175			};
176	amagnan	1.7
177			inline unsigned int bx()
178			{
179			return bx_;
180			};
181	amagnan	1.6
182			inline GenInfo* generatorInfo()
183			{
184			return genInfo_;
185			};
186
187	amagnan	1.4	inline bool isRealData()
188			{
189			return isData_;
190			}
191
192	amagnan	1.1	/** Setters */
193
194
195			inline void particles(const std::vector<GenParticle> & aVec)
196			{
197			particles_=aVec;
198			};
199
200	amagnan	1.12	inline void genjets(const std::vector<GenJet> & aVec)
201			{
202			genjets_=aVec;
203			};
204
205	amagnan	1.10	inline void lheParticles(const std::vector<GenParticle> & aVec)
206			{
207			lheParticles_=aVec;
208			};
209
210	amagnan	1.1	inline void electrons(const std::vector<Electron> & aVec)
211			{
212			electrons_=aVec;
213			};
214
215			inline void muons(const std::vector<Muon> & aVec)
216			{
217			muons_=aVec;
218			};
219
220			inline void caloTaus(const std::vector<Tau> & aVec)
221			{
222			caloTaus_=aVec;
223			};
224
225			inline void pfTaus(const std::vector<Tau> & aVec)
226			{
227			pfTaus_=aVec;
228			};
229
230			inline void caloJets(const std::vector<Jet> & aVec)
231			{
232			caloJets_=aVec;
233			};
234
235			inline void jptJets(const std::vector<Jet> & aVec)
236			{
237			jptJets_=aVec;
238			};
239
240	amagnan	1.9	inline void ak7Jets(const std::vector<Jet> & aVec)
241			{
242			ak7Jets_=aVec;
243			};
244
245	amagnan	1.1	inline void pfJets(const std::vector<Jet> & aVec)
246			{
247			pfJets_=aVec;
248			};
249
250			inline void caloMet(const Met & aValue)
251			{
252			caloMet_=aValue;
253			};
254
255			inline void tcMet(const Met & aValue)
256			{
257			tcMet_=aValue;
258			};
259
260			inline void pfMet(const Met & aValue)
261			{
262			pfMet_=aValue;
263			};
264
265			inline void triggers(const std::vector<Trigger> & aVec)
266			{
267			triggers_=aVec;
268			};
269
270	amagnan	1.2	inline void vertices(const std::vector<Vertex> & aVec)
271			{
272			vertices_=aVec;
273			};
274
275	amagnan	1.8	inline void beamSpot(const BeamSpot & aBS)
276			{
277			beamSpot_ = aBS;
278			}
279
280	amagnan	1.5	inline void l1Jets(const std::vector<L1Object> & aVec)
281			{
282			l1Jets_=aVec;
283			};
284
285	amagnan	1.7	inline void hltObjects(const std::vector<HLTObject> & aVec)
286	amagnan	1.5	{
287	amagnan	1.7	hltObjs_=aVec;
288	amagnan	1.5	};
289
290	agilbert	1.11	inline void puVars(const std::vector<PUVars> & aVec)
291			{
292			puVars_=aVec;
293			};
294
295	amagnan	1.1	inline void event(const unsigned int aHbbEvent) {
296			event_ = aHbbEvent;
297			};
298
299	amagnan	1.2	inline void run(const unsigned int aHbbRun) {
300			run_ = aHbbRun;
301			};
302	amagnan	1.6
303	amagnan	1.2	inline void lumiBlock(const unsigned int aHbbLB) {
304			lb_ = aHbbLB;
305			};
306	amagnan	1.6
307	amagnan	1.7	inline void bx(const unsigned int aBX) {
308			bx_ = aBX;
309			};
310
311	amagnan	1.6	inline void generatorInfo(const GenInfo & aInfo){
312			genInfo_ = new GenInfo(aInfo);
313			};
314
315	amagnan	1.4	inline void isRealData(const bool isData){
316			isData_ = isData;
317			}
318	amagnan	1.2
319	amagnan	1.1	void Clear(){
320			particles_.clear();
321	amagnan	1.12	genjets_.clear();
322	amagnan	1.10	lheParticles_.clear();
323	amagnan	1.1	electrons_.clear();
324			muons_.clear();
325			caloTaus_.clear();
326			pfTaus_.clear();
327			caloJets_.clear();
328			jptJets_.clear();
329	amagnan	1.9	ak7Jets_.clear();
330	amagnan	1.1	pfJets_.clear();
331			caloMet_.Clear();
332			tcMet_.Clear();
333			pfMet_.Clear();
334			triggers_.clear();
335	amagnan	1.2	vertices_.clear();
336	amagnan	1.8	beamSpot_.Clear();
337	amagnan	1.5	l1Jets_.clear();
338	amagnan	1.7	hltObjs_.clear();
339	agilbert	1.11	puVars_.clear();
340	amagnan	1.6	if (genInfo_) delete genInfo_;
341			genInfo_ = 0;
342	amagnan	1.1	};
343
344			//void order(){};
345	amagnan	1.3	void retrieveLeadJets(const std::vector<HbbAnalysis::Jet> & aVec,
346			const std::vector<HbbAnalysis::Jet> & aNonbVec,
347			HbbAnalysis::Jet & aLead,
348			HbbAnalysis::Jet & aNtoLead);
349
350	amagnan	1.1	private:
351
352			std::vector<GenParticle> particles_;
353	amagnan	1.12	std::vector<GenJet> genjets_;
354	amagnan	1.10	std::vector<GenParticle> lheParticles_;
355	amagnan	1.1	std::vector<Electron> electrons_;
356			std::vector<Muon> muons_;
357			std::vector<Tau> caloTaus_;
358			std::vector<Tau> pfTaus_;
359			std::vector<Jet> caloJets_;
360			std::vector<Jet> jptJets_;
361	amagnan	1.9	std::vector<Jet> ak7Jets_;
362	amagnan	1.1	std::vector<Jet> pfJets_;
363			Met caloMet_;
364			Met tcMet_;
365			Met pfMet_;
366			std::vector<Trigger> triggers_;
367	amagnan	1.2	std::vector<Vertex> vertices_;
368	amagnan	1.8	BeamSpot beamSpot_;
369	amagnan	1.5	std::vector<L1Object> l1Jets_;
370	amagnan	1.7	std::vector<HLTObject> hltObjs_;
371	agilbert	1.11	std::vector<PUVars> puVars_;
372	amagnan	1.2
373	amagnan	1.1
374			unsigned int event_;
375	amagnan	1.2	unsigned int run_;
376			unsigned int lb_;
377	amagnan	1.7	unsigned int bx_;
378	amagnan	1.6
379			//pointer, not created unless it is MC file....
380			GenInfo* genInfo_;
381
382	amagnan	1.4	bool isData_;
383	amagnan	1.1
384			};//class
385
386			}//namespace
387
388			#endif //HbbAnalysis_HbbEvent_hh