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;
    unsigned int type;//1=EM, 2=muon, 3=jet, 0=unknown
  };

  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;
    bool hltMatch;
  };

  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{
    unsigned short idAndIso;
    std::vector<std::pair<std::string,float> > electronIDs;
    float hOverE;
    float deltaPhiIn;
    float deltaEtaIn;
    bool ecalDrivenSeed;
    bool trackerDrivenSeed;
    float dB;
  };

  struct MuTrkVars {
    float dxy;
    float dz;
    float normalizedChi2;
    unsigned int muonHits;
    int charge;
    unsigned int trackerHits;
    unsigned int pixelHits;
  };
  
  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;
    float dB;
  };

  
  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;
    //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;
    float calopT;
    float caloEta;
    //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;
    std::vector< std::pair<unsigned int,double> > particleStatusPt;
  };

  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;
    unsigned numberOfDaughters;
    double HFHadronEnergy;
  };

  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 JetECorVars{
    std::vector<std::pair<std::string,double> > Levels;
  };


  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;
    std::vector<float> trackpT;
    double chi2;
    double ndof;
    double x;
    double y;
    double z;
    double rho;
    double xError;
    double yError;
    double zError;
    double cov01;
    double cov02;
    double cov12;
  };

  struct BeamSpotVars{
    double x0;
    double y0;
    double z0;
    double sigmaZ;
    double BeamWidthX;
    double BeamWidthY;
    double x0Error;
    double y0Error;
    double z0Error;
    double sigmaZ0Error;
    double BeamWidthXError;
    double BeamWidthYError;     
    //double dxdz;
    //double dydz;
    //double dxdzError;
    //double dydzError;
    //BeamType type();
    //enum BeamType { Unknown=-1, Fake=0, LHC=1, Tracker=2 };
    //double emittanceX() const { return emittanceX_; }
    //double emittanceY() const { return emittanceY_; }
    //double betaStar() const { return betaStar_; }
  };


  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.22
Committed:	Tue May 31 16:27:54 2011 UTC (13 years, 11 months ago) by agilbert
Content type:	text/plain
Branch:	MAIN
CVS Tags:	v00-05-03
Changes since 1.21:	+5 -2 lines
Log Message:	Several changes to be ready for 42X data processing.
#	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	amagnan	1.12
12	amagnan	1.1	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	amagnan	1.12	unsigned int type;//1=EM, 2=muon, 3=jet, 0=unknown
30	amagnan	1.11	};
31
32			struct L1Vars {
33			//type:
34			//0 = empty
35			//1 = central jet
36			//2 = tau jet
37			//3 = forward jet
38			unsigned int type;
39			int bx;
40			float pT;
41			float ET;
42			float eta;
43			float phi;
44			};
45
46	amagnan	1.1	struct GenVars {
47			bool valid;
48	amagnan	1.2	double E;
49	amagnan	1.1	double pT;
50			double eta;
51	amagnan	1.9	double y;
52	amagnan	1.1	double phi;
53			int charge;
54			int pdgId;
55			int status;
56			double mass;
57			double vx;
58			double vy;
59			double vz;
60			};
61
62			struct BaseVars {
63	amagnan	1.2	double E;
64	amagnan	1.1	double pT;
65			double eta;
66	amagnan	1.9	double y;
67	amagnan	1.1	double phi;
68			float charge;
69			double vx;
70			double vy;
71			double vz;
72	agilbert	1.22	bool hltMatch;
73	amagnan	1.1	};
74
75			struct SCVars {
76			float sigmaEtaEta;
77			float sigmaIEtaIEta;
78			float e1x5;
79			float e2x5Max;
80			float e5x5;
81			float eOverP;
82			};
83
84			struct EleIsoVars {
85			float calo;
86			float track;
87			float ecal;
88			float hcal;
89			};
90
91			struct EleIDVars{
92	amagnan	1.17	unsigned short idAndIso;
93	amagnan	1.1	std::vector<std::pair<std::string,float> > electronIDs;
94			float hOverE;
95			float deltaPhiIn;
96			float deltaEtaIn;
97	amagnan	1.7	bool ecalDrivenSeed;
98			bool trackerDrivenSeed;
99	agilbert	1.22	float dB;
100	amagnan	1.1	};
101
102	amagnan	1.3	struct MuTrkVars {
103	amagnan	1.13	float dxy;
104			float dz;
105			float normalizedChi2;
106			unsigned int muonHits;
107	amagnan	1.14	int charge;
108	amagnan	1.13	unsigned int trackerHits;
109	amagnan	1.15	unsigned int pixelHits;
110	amagnan	1.3	};
111
112	amagnan	1.1	struct MuIsoVars {
113			float sumPt;
114			float emEt;
115			float hadEt;
116			float nTracks;
117			float nJets;
118			};
119
120			struct MuIDVars{
121			unsigned short type;
122			std::vector<unsigned short> ids;
123			float caloCompat;
124			float segCompat;
125			unsigned int nChambers;
126			unsigned int nMatchesLoose;
127			unsigned int nMatchesMedium;
128			unsigned int nMatchesTight;
129	agilbert	1.22	float dB;
130	amagnan	1.1	};
131
132	agilbert	1.20
133	amagnan	1.9	struct TrkVars{
134	amagnan	1.1	double pT;
135			double eta;
136			double phi;
137			double matchDist;
138			double IPxy;
139			double IPz;
140			float signedSipt;
141			};
142	agilbert	1.20
143	amagnan	1.1
144			struct CaloTauIsoVars{
145			unsigned int nIsoTracks;
146			unsigned int nSigTracks;
147			float leadTrackHCAL3x3hitsEtSum;
148			float leadTrackHCAL3x3hottesthitDEta;
149			float signalTracksInvariantMass;
150			float tracksInvariantMass;
151			float isolationTracksPtSum;
152			float isolationECALhitsEtSum;
153			float maximumHCALhitEt;
154			};
155
156			struct CaloTauIDVars{
157			float byIsolation;
158			float byLeadingTrackFinding;
159			float byLeadingTrackPtCut;
160			};
161
162			struct PFTauIsoVars{
163			unsigned int nSigCands;
164			unsigned int nIsoCands;
165			double maximumHCALPFClusterEt;
166			//double emFraction;
167			double hcalTotOverPLead;
168			double hcalMaxOverPLead;
169			double hcal3x3OverPLead;
170			double ecalStripSumEOverPLead;
171			double bremsRecoveryEOverPLead;
172			};
173
174			//for hadr, neutr and gamma cands
175			struct PFTauCandVars{
176			unsigned int nSigCands;
177			unsigned int nIsoCands;
178			double isolationPtSum;
179			};
180
181			struct PFTauIDVars{
182			float byLeadingTrackFinding;
183			float byLeadingTrackPtCut;
184			float byTrackIsolation;
185			float byECALIsolation;
186			float byIsolation;
187			float againstElectron;
188			float againstMuon;
189	amagnan	1.4	float byIsolationUsingLeadingPion;
190			float byTaNC;
191			float byTaNCfrHalfPercent;
192			float byTaNCfrOnePercent;
193			float byTaNCfrQuarterPercent;
194			float byTaNCfrTenthPercent;
195			float ecalIsolationUsingLeadingPion;
196			float leadingPionPtCut;
197			float trackIsolationUsingLeadingPion;
198	amagnan	1.1	};
199
200			struct PFTauEleIDVars{
201			double pT;
202			double eta;
203			double phi;
204			float output;
205			float decision;
206			};
207
208			struct PFTauMuIDVars{
209			float caloCompat;
210			float segCompat;
211			float decision;
212			};
213
214			struct JetVars{
215			//1=had, 2=e, 3=mu for heavy quarks;
216			//2=uds, 3=g for light quarks
217			unsigned int flavour;
218			int partonFlavour;
219			unsigned int nAssociatedTracks;
220			double rawpT;
221	amagnan	1.5	float etaMean;
222			float phiMean;
223			float etaEtaMoment;
224			float phiPhiMoment;
225			float etaPhiMoment;
226	amagnan	1.1	//double rawEta;
227			//double rawPhi;
228			};
229
230			struct CaloJetVars{
231			double maxEInEmTowers;
232			double maxEInHadTowers;
233			double energyFractionHadronic;
234			double emEnergyFraction;
235			double hadEnergyInHB;
236			double hadEnergyInHO;
237			double hadEnergyInHE;
238			double hadEnergyInHF;
239			double emEnergyInEB;
240			double emEnergyInEE;
241			double emEnergyInHF;
242			double towersArea;
243			double n90;
244			double n60;
245			};
246
247	amagnan	1.9	struct JPTJetVars{
248	amagnan	1.10	float zspCorrection;
249			int elecMultiplicity;
250	agilbert	1.20	float calopT;
251			float caloEta;
252			//std::vector<TrkVars> pionsInCone;
253			//std::vector<TrkVars> pionsCurledOut;
254			//std::vector<TrkVars> pionsCurledIn;
255			//std::vector<TrkVars> elecsInCone;
256			//std::vector<TrkVars> elecsCurledOut;
257			//std::vector<TrkVars> elecsCurledIn;
258			//std::vector<TrkVars> muonsInCone;
259			//std::vector<TrkVars> muonsCurledOut;
260			//std::vector<TrkVars> muonsCurledIn;
261			std::vector< std::pair<unsigned int,double> > particleStatusPt;
262	amagnan	1.9	};
263
264			struct JPTPFJetVars{
265	amagnan	1.1	double chargedHadronEnergy;
266			double chargedHadronEnergyFraction;
267			double neutralHadronEnergy;
268			double neutralHadronEnergyFraction;
269			double chargedEmEnergy;
270			double chargedEmEnergyFraction;
271			double neutralEmEnergy;
272			double neutralEmEnergyFraction;
273			double chargedMultiplicity;
274	amagnan	1.9	double muonMultiplicity;
275			};
276
277			struct PFJetVars{
278			double chargedMuEnergy;
279			double chargedMuEnergyFraction;
280	amagnan	1.1	double neutralMultiplicity;
281	agilbert	1.22	unsigned numberOfDaughters;
282			double HFHadronEnergy;
283	amagnan	1.1	};
284
285			struct JetBtagVars{
286			double cSV;
287			double cSVMVA;
288			double iPMVA;
289			double bProba;
290			double probability;
291	amagnan	1.8	double sSVHE;
292			double sSVHP;
293	amagnan	1.4	double softElectronByPt;
294			double softElectronByIP3d;
295	amagnan	1.1	double softMuon;
296	amagnan	1.4	double softMuonByPt;
297			double softMuonByIP3d;
298	amagnan	1.1	double tCHE;
299			double tCHP;
300			};
301
302	amagnan	1.4
303			struct JetIDVars{
304			double fHPD;
305			double fRBX;
306	amagnan	1.9	int n90Hits;
307	amagnan	1.4	//double fSubDetector1;
308			//double fSubDetector2;
309			//double fSubDetector3;
310			//double fSubDetector4;
311	amagnan	1.10	double restrictedEMF;
312			int nHCALTowers;
313			int nECALTowers;
314	amagnan	1.4	//double approximatefHPD;
315			//double approximatefRBX;
316	amagnan	1.9	int hitsInN90;
317	amagnan	1.4	// muon hits id
318			//int numberOfHits2RPC;
319			//int numberOfHits3RPC;
320			//int numberOfHitsRPC;
321			};
322
323	amagnan	1.18	struct JetECorVars{
324	amagnan	1.19	std::vector<std::pair<std::string,double> > Levels;
325	amagnan	1.18	};
326
327	amagnan	1.4
328	amagnan	1.1	struct MetVars{
329			double mET;
330			double mEx;
331			double mEy;
332			double sumET;
333			double phi;
334			double mEtSig;
335			};
336
337			struct TriggerVars{
338			std::string name;
339			unsigned int index;
340			bool accept;
341			};
342
343	amagnan	1.4
344			struct VertexVars{
345			std::vector<float> trackWeights;
346	agilbert	1.21	std::vector<float> trackpT;
347	amagnan	1.4	double chi2;
348			double ndof;
349			double x;
350			double y;
351			double z;
352	amagnan	1.16	double rho;
353	amagnan	1.4	double xError;
354			double yError;
355			double zError;
356			double cov01;
357			double cov02;
358			double cov12;
359			};
360
361	amagnan	1.14	struct BeamSpotVars{
362			double x0;
363			double y0;
364			double z0;
365			double sigmaZ;
366			double BeamWidthX;
367			double BeamWidthY;
368			double x0Error;
369			double y0Error;
370			double z0Error;
371			double sigmaZ0Error;
372			double BeamWidthXError;
373			double BeamWidthYError;
374			//double dxdz;
375			//double dydz;
376			//double dxdzError;
377			//double dydzError;
378			//BeamType type();
379			//enum BeamType { Unknown=-1, Fake=0, LHC=1, Tracker=2 };
380			//double emittanceX() const { return emittanceX_; }
381			//double emittanceY() const { return emittanceY_; }
382			//double betaStar() const { return betaStar_; }
383			};
384
385
386
387
388	amagnan	1.2	double DeltaPhi(const double phi1, const double phi2);
389
390			double DeltaR(const BaseVars & v1, const BaseVars & v2);
391	amagnan	1.6	double DeltaR(const BaseVars & v1, const GenVars & v2);
392	amagnan	1.2
393			double SameSign(const BaseVars & v1, const BaseVars & v2);
394
395			double OppSign(const BaseVars & v1, const BaseVars & v2);
396
397			TLorentzVector FourMomentum(const BaseVars & v, const double scale=1) ;
398
399			double TransverseMass(const BaseVars & leg1,
400			const BaseVars & leg2,
401			const double mEx,
402			const double mEy);
403
404			double TransverseMass(const BaseVars & leg1,
405			const double mEx,
406			const double mEy);
407
408			TLorentzVector FourMomentumCDFmethod(const BaseVars & leg1,
409			const BaseVars & leg2,
410			double mEx,
411			double mEy);
412
413			TLorentzVector FourMomentumCollinearApprox(const BaseVars & leg1,
414			const BaseVars & leg2,
415			double mEx,
416			double mEy);
417	amagnan	1.1
418	amagnan	1.9	double EtaDetector(const BaseVars & v1);
419			double EtaDetector(const GenVars & v1);
420
421	amagnan	1.2	}//namespace
422	amagnan	1.1
423			#endif