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 phi;
    int pdgId;
    int status;
  };

  struct GenVars {
    bool valid;
    double E;
    double pT;
    double eta;
    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 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 TauLeadTrkVars{
    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;
    //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 PFJetVars{
    double chargedHadronEnergy;
    double chargedHadronEnergyFraction;
    double neutralHadronEnergy;
    double neutralHadronEnergyFraction;
    double chargedEmEnergy;
    double chargedEmEnergyFraction;
    double chargedMuEnergy;
    double chargedMuEnergyFraction;
    double neutralEmEnergy;
    double neutralEmEnergyFraction;
    double chargedMultiplicity;
    double neutralMultiplicity;
    double muonMultiplicity;
  };

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


  struct JetIDVars{
    double fHPD; 
    double fRBX;
    double 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);

}//namespace

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