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