HbbAnalysis/interface/Objects.hh

#ifndef HbbAnalysis_Objects_hh
#define HbbAnalysis_Objects_hh

#include <vector>
#include <string>
#include <iostream>

#include "TLorentzVector.h"

namespace HbbAnalysis {
 
  struct MCVars {
    unsigned int index;
    double E;
    double pT;
    double eta;
    double y;
    double phi;
    int pdgId;
    int status;
  };

  struct HLTVars {
    float pT;
    float eta;
    float phi;
    int id;
    float mass;
  };

  struct L1Vars {
    //type:
    //0 = empty
    //1 = central jet
    //2 = tau jet
    //3 = forward jet
    unsigned int type;
    int bx;
    float pT;
    float ET;
    float eta;
    float phi; 
  };

  struct GenVars {
    bool valid;
    double E;
    double pT;
    double eta;
    double y;
    double phi;
    int charge;
    int pdgId;
    int status;
    double mass;
    double vx;
    double vy;
    double vz;
  };

  struct BaseVars {
    double E;
    double pT;
    double eta;
    double y;
    double phi;
    float charge;
    double vx;
    double vy;
    double vz;
  };

  struct SCVars {
    float sigmaEtaEta;
    float sigmaIEtaIEta;
    float e1x5;
    float e2x5Max;
    float e5x5;
    float eOverP;
  };

  struct EleIsoVars {
    float calo;
    float track;
    float ecal;
    float hcal;
  };
  
  struct EleIDVars{
    std::vector<std::pair<std::string,float> > electronIDs;
    float hOverE;
    float deltaPhiIn;
    float deltaEtaIn;
    bool ecalDrivenSeed;
    bool trackerDrivenSeed;
  };

  struct MuTrkVars {
    float IPd0;
    float IPdz;
    unsigned int nHits;
  };
  
  struct MuIsoVars {
    float sumPt;
    float emEt;
    float hadEt;
    float nTracks;
    float nJets;
  };
  
  struct MuIDVars{
    unsigned short type;
    std::vector<unsigned short> ids;
    float caloCompat;
    float segCompat;
    unsigned int nChambers;
    unsigned int nMatchesLoose;
    unsigned int nMatchesMedium;
    unsigned int nMatchesTight;
  };

  struct TrkVars{
    double pT;
    double eta;
    double phi;
    double matchDist;
    double IPxy;
    double IPz;
    float signedSipt;
  };

  struct CaloTauIsoVars{
    unsigned int nIsoTracks;
    unsigned int nSigTracks;
    float leadTrackHCAL3x3hitsEtSum;
    float leadTrackHCAL3x3hottesthitDEta;
    float signalTracksInvariantMass;
    float tracksInvariantMass; 
    float isolationTracksPtSum;
    float isolationECALhitsEtSum;
    float maximumHCALhitEt;
  };

  struct CaloTauIDVars{
    float byIsolation;
    float byLeadingTrackFinding;
    float byLeadingTrackPtCut;
  };

  struct PFTauIsoVars{
    unsigned int nSigCands;
    unsigned int nIsoCands;
    double maximumHCALPFClusterEt;
    //double emFraction;
    double hcalTotOverPLead;
    double hcalMaxOverPLead;
    double hcal3x3OverPLead;
    double ecalStripSumEOverPLead;
    double bremsRecoveryEOverPLead;
  };

  //for hadr, neutr and gamma cands
  struct PFTauCandVars{
    unsigned int nSigCands;
    unsigned int nIsoCands;
    double isolationPtSum;
  };

  struct PFTauIDVars{
    float byLeadingTrackFinding;
    float byLeadingTrackPtCut;
    float byTrackIsolation;
    float byECALIsolation;
    float byIsolation;
    float againstElectron;
    float againstMuon;
    float byIsolationUsingLeadingPion;
    float byTaNC;
    float byTaNCfrHalfPercent;
    float byTaNCfrOnePercent;
    float byTaNCfrQuarterPercent;
    float byTaNCfrTenthPercent;
    float ecalIsolationUsingLeadingPion;
    float leadingPionPtCut;
    float trackIsolationUsingLeadingPion;
  };

  struct PFTauEleIDVars{
    double pT;
    double eta;
    double phi;
    float output;
    float decision;
  };
    
  struct PFTauMuIDVars{
    float caloCompat;
    float segCompat;
    float decision;
  };

  struct JetVars{
    //1=had, 2=e, 3=mu for heavy quarks; 
    //2=uds, 3=g for light quarks
    unsigned int flavour;
    int partonFlavour;
    unsigned int nAssociatedTracks;
    double rawpT;
    float etaMean;
    float phiMean;
    float etaEtaMoment;
    float phiPhiMoment;
    float etaPhiMoment;
    bool l1Match;
    bool hltMatch;
    //double rawEta;
    //double rawPhi;
  };

  struct CaloJetVars{
    double maxEInEmTowers;
    double maxEInHadTowers;
    double energyFractionHadronic;
    double emEnergyFraction;
    double hadEnergyInHB;
    double hadEnergyInHO;
    double hadEnergyInHE;
    double hadEnergyInHF;
    double emEnergyInEB;
    double emEnergyInEE;
    double emEnergyInHF;
    double towersArea;
    double n90;
    double n60;
  };

  struct JPTJetVars{
    float zspCorrection;
    int elecMultiplicity;
    std::vector<TrkVars> pionsInCone;
    std::vector<TrkVars> pionsCurledOut;
    std::vector<TrkVars> pionsCurledIn;
    std::vector<TrkVars> elecsInCone;
    std::vector<TrkVars> elecsCurledOut;
    std::vector<TrkVars> elecsCurledIn;
    std::vector<TrkVars> muonsInCone;
    std::vector<TrkVars> muonsCurledOut;
    std::vector<TrkVars> muonsCurledIn;
  };

  struct JPTPFJetVars{
    double chargedHadronEnergy;
    double chargedHadronEnergyFraction;
    double neutralHadronEnergy;
    double neutralHadronEnergyFraction;
    double chargedEmEnergy;
    double chargedEmEnergyFraction;
    double neutralEmEnergy;
    double neutralEmEnergyFraction;
    double chargedMultiplicity;
    double muonMultiplicity;
  };

  struct PFJetVars{
    double chargedMuEnergy;
    double chargedMuEnergyFraction;
    double neutralMultiplicity;
  };

  struct JetBtagVars{
    double cSV;
    double cSVMVA;
    double iPMVA;
    double bProba;
    double probability;
    double sSVHE;
    double sSVHP;
    double softElectronByPt;
    double softElectronByIP3d;
    double softMuon;
    double softMuonByPt;
    double softMuonByIP3d;
    double tCHE;
    double tCHP;
  };


  struct JetIDVars{
    double fHPD; 
    double fRBX;
    int n90Hits;
    //double fSubDetector1;
    //double fSubDetector2;
    //double fSubDetector3;
    //double fSubDetector4;
    double restrictedEMF;
    int    nHCALTowers;
    int    nECALTowers;
    //double approximatefHPD;
    //double approximatefRBX;
    int hitsInN90;
    // muon hits id
    //int numberOfHits2RPC;
    //int numberOfHits3RPC;
    //int numberOfHitsRPC;
  };


  struct MetVars{
    double mET;
    double mEx;
    double mEy;
    double sumET;
    double phi;
    double mEtSig;
  };

  struct TriggerVars{
    std::string name;
    unsigned int index;
    bool accept;
  };


  struct VertexVars{
    std::vector<float> trackWeights;
    double chi2;
    double ndof;
    double x;
    double y;
    double z;
    double xError;
    double yError;
    double zError;
    double cov01;
    double cov02;
    double cov12;
  };

  double DeltaPhi(const double phi1, const double phi2);
 
  double DeltaR(const BaseVars & v1, const BaseVars & v2);
  double DeltaR(const BaseVars & v1, const GenVars & v2);
 
  double SameSign(const BaseVars & v1, const BaseVars & v2);
 
  double OppSign(const BaseVars & v1, const BaseVars & v2);
 
  TLorentzVector FourMomentum(const BaseVars & v, const double scale=1) ;
 
  double TransverseMass(const BaseVars & leg1, 
                        const BaseVars & leg2, 
                        const double mEx, 
                        const double mEy);
 
  double TransverseMass(const BaseVars & leg1, 
                        const double mEx, 
                        const double mEy);

  TLorentzVector FourMomentumCDFmethod(const BaseVars & leg1, 
                                       const BaseVars & leg2, 
                                       double mEx, 
                                       double mEy);

  TLorentzVector FourMomentumCollinearApprox(const BaseVars & leg1,
                                             const BaseVars & leg2,
                                             double mEx, 
                                             double mEy);

  double EtaDetector(const BaseVars & v1);
  double EtaDetector(const GenVars & v1);

}//namespace

#endif
Revision:	1.11
Committed:	Wed May 19 17:24:44 2010 UTC (14 years, 11 months ago) by amagnan
Content type:	text/plain
Branch:	MAIN
Changes since 1.10:	+22 -0 lines
Log Message:	adding L1 and HLT jet objects to tree
#	User	Rev	Content
1	amagnan	1.1	#ifndef HbbAnalysis_Objects_hh
2			#define HbbAnalysis_Objects_hh
3
4			#include <vector>
5			#include <string>
6	amagnan	1.2	#include <iostream>
7
8			#include "TLorentzVector.h"
9	amagnan	1.1
10			namespace HbbAnalysis {
11
12			struct MCVars {
13			unsigned int index;
14	amagnan	1.2	double E;
15	amagnan	1.1	double pT;
16			double eta;
17	amagnan	1.9	double y;
18	amagnan	1.1	double phi;
19			int pdgId;
20			int status;
21			};
22
23	amagnan	1.11	struct HLTVars {
24			float pT;
25			float eta;
26			float phi;
27			int id;
28			float mass;
29			};
30
31			struct L1Vars {
32			//type:
33			//0 = empty
34			//1 = central jet
35			//2 = tau jet
36			//3 = forward jet
37			unsigned int type;
38			int bx;
39			float pT;
40			float ET;
41			float eta;
42			float phi;
43			};
44
45	amagnan	1.1	struct GenVars {
46			bool valid;
47	amagnan	1.2	double E;
48	amagnan	1.1	double pT;
49			double eta;
50	amagnan	1.9	double y;
51	amagnan	1.1	double phi;
52			int charge;
53			int pdgId;
54			int status;
55			double mass;
56			double vx;
57			double vy;
58			double vz;
59			};
60
61			struct BaseVars {
62	amagnan	1.2	double E;
63	amagnan	1.1	double pT;
64			double eta;
65	amagnan	1.9	double y;
66	amagnan	1.1	double phi;
67			float charge;
68			double vx;
69			double vy;
70			double vz;
71			};
72
73			struct SCVars {
74			float sigmaEtaEta;
75			float sigmaIEtaIEta;
76			float e1x5;
77			float e2x5Max;
78			float e5x5;
79			float eOverP;
80			};
81
82			struct EleIsoVars {
83			float calo;
84			float track;
85			float ecal;
86			float hcal;
87			};
88
89			struct EleIDVars{
90			std::vector<std::pair<std::string,float> > electronIDs;
91			float hOverE;
92			float deltaPhiIn;
93			float deltaEtaIn;
94	amagnan	1.7	bool ecalDrivenSeed;
95			bool trackerDrivenSeed;
96	amagnan	1.1	};
97
98	amagnan	1.3	struct MuTrkVars {
99			float IPd0;
100			float IPdz;
101			unsigned int nHits;
102			};
103
104	amagnan	1.1	struct MuIsoVars {
105			float sumPt;
106			float emEt;
107			float hadEt;
108			float nTracks;
109			float nJets;
110			};
111
112			struct MuIDVars{
113			unsigned short type;
114			std::vector<unsigned short> ids;
115			float caloCompat;
116			float segCompat;
117			unsigned int nChambers;
118			unsigned int nMatchesLoose;
119			unsigned int nMatchesMedium;
120			unsigned int nMatchesTight;
121			};
122
123	amagnan	1.9	struct TrkVars{
124	amagnan	1.1	double pT;
125			double eta;
126			double phi;
127			double matchDist;
128			double IPxy;
129			double IPz;
130			float signedSipt;
131			};
132
133			struct CaloTauIsoVars{
134			unsigned int nIsoTracks;
135			unsigned int nSigTracks;
136			float leadTrackHCAL3x3hitsEtSum;
137			float leadTrackHCAL3x3hottesthitDEta;
138			float signalTracksInvariantMass;
139			float tracksInvariantMass;
140			float isolationTracksPtSum;
141			float isolationECALhitsEtSum;
142			float maximumHCALhitEt;
143			};
144
145			struct CaloTauIDVars{
146			float byIsolation;
147			float byLeadingTrackFinding;
148			float byLeadingTrackPtCut;
149			};
150
151			struct PFTauIsoVars{
152			unsigned int nSigCands;
153			unsigned int nIsoCands;
154			double maximumHCALPFClusterEt;
155			//double emFraction;
156			double hcalTotOverPLead;
157			double hcalMaxOverPLead;
158			double hcal3x3OverPLead;
159			double ecalStripSumEOverPLead;
160			double bremsRecoveryEOverPLead;
161			};
162
163			//for hadr, neutr and gamma cands
164			struct PFTauCandVars{
165			unsigned int nSigCands;
166			unsigned int nIsoCands;
167			double isolationPtSum;
168			};
169
170			struct PFTauIDVars{
171			float byLeadingTrackFinding;
172			float byLeadingTrackPtCut;
173			float byTrackIsolation;
174			float byECALIsolation;
175			float byIsolation;
176			float againstElectron;
177			float againstMuon;
178	amagnan	1.4	float byIsolationUsingLeadingPion;
179			float byTaNC;
180			float byTaNCfrHalfPercent;
181			float byTaNCfrOnePercent;
182			float byTaNCfrQuarterPercent;
183			float byTaNCfrTenthPercent;
184			float ecalIsolationUsingLeadingPion;
185			float leadingPionPtCut;
186			float trackIsolationUsingLeadingPion;
187	amagnan	1.1	};
188
189			struct PFTauEleIDVars{
190			double pT;
191			double eta;
192			double phi;
193			float output;
194			float decision;
195			};
196
197			struct PFTauMuIDVars{
198			float caloCompat;
199			float segCompat;
200			float decision;
201			};
202
203			struct JetVars{
204			//1=had, 2=e, 3=mu for heavy quarks;
205			//2=uds, 3=g for light quarks
206			unsigned int flavour;
207			int partonFlavour;
208			unsigned int nAssociatedTracks;
209			double rawpT;
210	amagnan	1.5	float etaMean;
211			float phiMean;
212			float etaEtaMoment;
213			float phiPhiMoment;
214			float etaPhiMoment;
215	amagnan	1.9	bool l1Match;
216			bool hltMatch;
217	amagnan	1.1	//double rawEta;
218			//double rawPhi;
219			};
220
221			struct CaloJetVars{
222			double maxEInEmTowers;
223			double maxEInHadTowers;
224			double energyFractionHadronic;
225			double emEnergyFraction;
226			double hadEnergyInHB;
227			double hadEnergyInHO;
228			double hadEnergyInHE;
229			double hadEnergyInHF;
230			double emEnergyInEB;
231			double emEnergyInEE;
232			double emEnergyInHF;
233			double towersArea;
234			double n90;
235			double n60;
236			};
237
238	amagnan	1.9	struct JPTJetVars{
239	amagnan	1.10	float zspCorrection;
240			int elecMultiplicity;
241	amagnan	1.9	std::vector<TrkVars> pionsInCone;
242			std::vector<TrkVars> pionsCurledOut;
243			std::vector<TrkVars> pionsCurledIn;
244			std::vector<TrkVars> elecsInCone;
245			std::vector<TrkVars> elecsCurledOut;
246			std::vector<TrkVars> elecsCurledIn;
247			std::vector<TrkVars> muonsInCone;
248			std::vector<TrkVars> muonsCurledOut;
249			std::vector<TrkVars> muonsCurledIn;
250			};
251
252			struct JPTPFJetVars{
253	amagnan	1.1	double chargedHadronEnergy;
254			double chargedHadronEnergyFraction;
255			double neutralHadronEnergy;
256			double neutralHadronEnergyFraction;
257			double chargedEmEnergy;
258			double chargedEmEnergyFraction;
259			double neutralEmEnergy;
260			double neutralEmEnergyFraction;
261			double chargedMultiplicity;
262	amagnan	1.9	double muonMultiplicity;
263			};
264
265			struct PFJetVars{
266			double chargedMuEnergy;
267			double chargedMuEnergyFraction;
268	amagnan	1.1	double neutralMultiplicity;
269			};
270
271			struct JetBtagVars{
272			double cSV;
273			double cSVMVA;
274			double iPMVA;
275			double bProba;
276			double probability;
277	amagnan	1.8	double sSVHE;
278			double sSVHP;
279	amagnan	1.4	double softElectronByPt;
280			double softElectronByIP3d;
281	amagnan	1.1	double softMuon;
282	amagnan	1.4	double softMuonByPt;
283			double softMuonByIP3d;
284	amagnan	1.1	double tCHE;
285			double tCHP;
286			};
287
288	amagnan	1.4
289			struct JetIDVars{
290			double fHPD;
291			double fRBX;
292	amagnan	1.9	int n90Hits;
293	amagnan	1.4	//double fSubDetector1;
294			//double fSubDetector2;
295			//double fSubDetector3;
296			//double fSubDetector4;
297	amagnan	1.10	double restrictedEMF;
298			int nHCALTowers;
299			int nECALTowers;
300	amagnan	1.4	//double approximatefHPD;
301			//double approximatefRBX;
302	amagnan	1.9	int hitsInN90;
303	amagnan	1.4	// muon hits id
304			//int numberOfHits2RPC;
305			//int numberOfHits3RPC;
306			//int numberOfHitsRPC;
307			};
308
309
310	amagnan	1.1	struct MetVars{
311			double mET;
312			double mEx;
313			double mEy;
314			double sumET;
315			double phi;
316			double mEtSig;
317			};
318
319			struct TriggerVars{
320			std::string name;
321			unsigned int index;
322			bool accept;
323			};
324
325	amagnan	1.4
326			struct VertexVars{
327			std::vector<float> trackWeights;
328			double chi2;
329			double ndof;
330			double x;
331			double y;
332			double z;
333			double xError;
334			double yError;
335			double zError;
336			double cov01;
337			double cov02;
338			double cov12;
339			};
340
341	amagnan	1.2	double DeltaPhi(const double phi1, const double phi2);
342
343			double DeltaR(const BaseVars & v1, const BaseVars & v2);
344	amagnan	1.6	double DeltaR(const BaseVars & v1, const GenVars & v2);
345	amagnan	1.2
346			double SameSign(const BaseVars & v1, const BaseVars & v2);
347
348			double OppSign(const BaseVars & v1, const BaseVars & v2);
349
350			TLorentzVector FourMomentum(const BaseVars & v, const double scale=1) ;
351
352			double TransverseMass(const BaseVars & leg1,
353			const BaseVars & leg2,
354			const double mEx,
355			const double mEy);
356
357			double TransverseMass(const BaseVars & leg1,
358			const double mEx,
359			const double mEy);
360
361			TLorentzVector FourMomentumCDFmethod(const BaseVars & leg1,
362			const BaseVars & leg2,
363			double mEx,
364			double mEy);
365
366			TLorentzVector FourMomentumCollinearApprox(const BaseVars & leg1,
367			const BaseVars & leg2,
368			double mEx,
369			double mEy);
370	amagnan	1.1
371	amagnan	1.9	double EtaDetector(const BaseVars & v1);
372			double EtaDetector(const GenVars & v1);
373
374	amagnan	1.2	}//namespace
375	amagnan	1.1
376			#endif