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
#	Content
1	#ifndef HbbAnalysis_Objects_hh
2	#define HbbAnalysis_Objects_hh
3
4	#include <vector>
5	#include <string>
6	#include <iostream>
7
8	#include "TLorentzVector.h"
9
10	namespace HbbAnalysis {
11
12	struct MCVars {
13	unsigned int index;
14	double E;
15	double pT;
16	double eta;
17	double phi;
18	int pdgId;
19	int status;
20	};
21
22	struct GenVars {
23	bool valid;
24	double E;
25	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	double E;
39	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	bool ecalDrivenSeed;
70	bool trackerDrivenSeed;
71	};
72
73	struct MuTrkVars {
74	float IPd0;
75	float IPdz;
76	unsigned int nHits;
77	};
78
79	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	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	};
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	float etaMean;
186	float phiMean;
187	float etaEtaMoment;
188	float phiPhiMoment;
189	float etaPhiMoment;
190	//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	double softElectronByPt;
235	double softElectronByIP3d;
236	double softMuon;
237	double softMuonByPt;
238	double softMuonByIP3d;
239	double tCHE;
240	double tCHP;
241	};
242
243
244	struct JetIDVars{
245	double fHPD;
246	double fRBX;
247	double n90Hits;
248	//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	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
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	double DeltaPhi(const double phi1, const double phi2);
297
298	double DeltaR(const BaseVars & v1, const BaseVars & v2);
299	double DeltaR(const BaseVars & v1, const GenVars & v2);
300
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
326	}//namespace
327
328	#endif