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_(),
      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),
      genjets_(),
      partonjets_()
    {};

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

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

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

    inline std::vector<GenJet> & partonjets() 
    {
      return partonjets_;
    };

    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 partonjets(const std::vector<GenJet> & aVec) 
    {
      partonjets_=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();
      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;
      genjets_.clear();
      partonjets_.clear();
    };
  
    //void order(){}; 
 //    void retrieveLeadJets(const std::vector<HbbAnalysis::Jet> & aVec,
//                        const std::vector<HbbAnalysis::Jet> & abVec,
//                        HbbAnalysis::Jet & aLead,
//                        HbbAnalysis::Jet & aNtoLead);

  private:
  
    std::vector<GenParticle> particles_;
    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_;
    std::vector<GenJet> genjets_;
    std::vector<GenJet> partonjets_;

  };//class
    
}//namespace

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