NtupleWriter/interface/Objects.h

#ifndef Objects_H
#define Objects_H

#include <vector>
#include "Math/LorentzVector.h"
#include "Math/PtEtaPhiE4D.h"
#include "TObject.h"

#ifndef PI
#define PI       3.14159265358979323846264338328     
#endif

typedef ROOT::Math::LorentzVector< ROOT::Math::PtEtaPhiE4D< Double32_t > > LorentzVector;

class Particle{
 public:
  Particle(){
    charge=0;
    pt=0; 
    eta=0; 
    phi=0; 
    energy=0; 
  };

  ~Particle(){
  };

  LorentzVector v4(){
    LorentzVector v4;
    v4.SetPt(pt);
    v4.SetEta(eta);
    v4.SetPhi(phi);
    v4.SetE(energy);
    return v4;
  };

  double deltaPhi(Particle p2){
    double deltaphi = fabs(this->phi - p2.phi);
    if(deltaphi > PI) deltaphi = 2* PI - deltaphi;
    return deltaphi;
  }
  double deltaR(Particle p2){
    double deltaeta = this->eta - p2.eta;
    return sqrt(deltaeta*deltaeta+deltaPhi(p2)*deltaPhi(p2));
  }

  float charge;
  float pt; 
  float eta; 
  float phi; 
  float energy; 

};

class Jet : public Particle{

 public:

  Jet(){
     nTracks=0;
     jetArea=0;
     pileup=0;
     numberOfDaughters=0; 
     neutralEmEnergyFraction=0;
     neutralHadronEnergyFraction=0;
     chargedEmEnergyFraction=0;
     chargedHadronEnergyFraction=0;
     muonEnergyFraction=0;
     photonEnergyFraction=0;
     chargedMultiplicity=0;
     neutralMultiplicity=0;
     muonMultiplicity=0; 
     electronMultiplicity=0;
     photonMultiplicity=0;
     btag_simpleSecondaryVertexHighEff=0;
     btag_simpleSecondaryVertexHighPur=0;
     btag_combinedSecondaryVertex=0;
     btag_combinedSecondaryVertexMVA=0;
     btag_jetBProbability=0;
     btag_jetProbability=0;
     JEC_uncertainty=0;
     JEC_factor_raw=0;
     genjet_pt=0;
     genjet_eta=0;
     genjet_phi=0;
     genjet_energy=0;
     genparticles_indices.clear();
  };

  ~Jet(){
  };
  
  int nTracks;
  float jetArea;
  float pileup;
  int numberOfDaughters; 
  float neutralEmEnergyFraction;
  float neutralHadronEnergyFraction;
  float chargedEmEnergyFraction;
  float chargedHadronEnergyFraction;
  float muonEnergyFraction;
  float photonEnergyFraction;
  int chargedMultiplicity;
  int neutralMultiplicity;
  int muonMultiplicity; 
  int electronMultiplicity;
  int photonMultiplicity;
  float btag_simpleSecondaryVertexHighEff;
  float btag_simpleSecondaryVertexHighPur;
  float btag_combinedSecondaryVertex;
  float btag_combinedSecondaryVertexMVA;
  float btag_jetBProbability;
  float btag_jetProbability;
  float JEC_uncertainty;
  float JEC_factor_raw;
  float genjet_pt;
  float genjet_eta;
  float genjet_phi;
  float genjet_energy;
  LorentzVector genjet_v4(){
    LorentzVector v4;
    v4.SetPt(genjet_pt);
    v4.SetEta(genjet_eta);
    v4.SetPhi(genjet_phi);
    v4.SetE(genjet_energy);
    return v4;
  };
  std::vector<unsigned int> genparticles_indices;

};


class Electron : public Particle{

 public:
  Electron(){
    vertex_x=0; 
    vertex_y=0; 
    vertex_z=0; 
    supercluster_eta=0; 
    supercluster_phi=0; 
    dB=0; 
    // particleIso=0; 
    neutralHadronIso=0; 
    chargedHadronIso=0; 
    photonIso=0;
    trackIso=0; 
    puChargedHadronIso=0;
    gsfTrack_trackerExpectedHitsInner_numberOfLostHits=0;
    gsfTrack_px=0;
    gsfTrack_py=0;
    gsfTrack_pz=0;
    gsfTrack_vx=0;
    gsfTrack_vy=0;
    gsfTrack_vz=0;
    passconversionveto=false;
    dEtaIn=0;
    dPhiIn=0;
    sigmaIEtaIEta=0;
    HoverE=0;
    fbrem=0;
    EoverPIn=0;
    EcalEnergy=0;
    mvaTrigV0=0;
    mvaNonTrigV0=0;
  };

  ~Electron(){
  };

  float vertex_x; 
  float vertex_y; 
  float vertex_z; 
  float supercluster_eta; 
  float supercluster_phi; 
  float dB; 
  //float particleIso; 
  float neutralHadronIso; 
  float chargedHadronIso; 
  float photonIso;
  float trackIso; 
  float puChargedHadronIso;
  int gsfTrack_trackerExpectedHitsInner_numberOfLostHits;
  float gsfTrack_px;
  float gsfTrack_py;
  float gsfTrack_pz;
  float gsfTrack_vx;
  float gsfTrack_vy;
  float gsfTrack_vz;
  float gsfTrack_dxy_vertex(const float point_x, const float point_y){ 
    return ( - (gsfTrack_vx-point_x) * gsfTrack_py + (gsfTrack_vy-point_y) * gsfTrack_px ) / sqrt(gsfTrack_px*gsfTrack_px+gsfTrack_py*gsfTrack_py);  
  };
  float gsfTrack_dz_vertex(const float point_x, const float point_y, const float point_z){ 
    return (gsfTrack_vz-point_z) - ((gsfTrack_vx-point_x)*gsfTrack_px+(gsfTrack_vy-point_y)*gsfTrack_py)/(gsfTrack_px*gsfTrack_px+gsfTrack_py*gsfTrack_py) * gsfTrack_pz; 
  }
  bool passconversionveto;
  float dEtaIn;
  float dPhiIn; 
  float sigmaIEtaIEta; 
  float HoverE;
  float fbrem;
  float EoverPIn;
  float EcalEnergy;
  float mvaTrigV0;
  float mvaNonTrigV0;

  float relIso(){
    return ( chargedHadronIso + std::max( 0.0, neutralHadronIso + photonIso - 0.5*puChargedHadronIso ) ) / pt;
  }

};

class Muon : public Particle{

 public:
  Muon(){
    vertex_x=0; 
    vertex_y=0; 
    vertex_z=0; 
    dB=0; 
    // particleIso=0; 
    neutralHadronIso=0; 
    chargedHadronIso=0; 
    trackIso=0; 
    photonIso=0;
    puChargedHadronIso=0;
    isGlobalMuon=false;
    isStandAloneMuon=false;
    isTrackerMuon=false;
    numberOfMatchedStations=0;
    globalTrack_chi2=0;
    globalTrack_ndof=0;
    globalTrack_d0=0;
    globalTrack_d0Error=0; 
    globalTrack_numberOfValidHits=0;  
    globalTrack_numberOfLostHits=0;  
    innerTrack_chi2=0;
    innerTrack_ndof=0;
    innerTrack_d0=0;
    innerTrack_d0Error=0; 
    innerTrack_numberOfValidHits=0;  
    innerTrack_numberOfLostHits=0;  
    innerTrack_trackerLayersWithMeasurement=0;
    innerTrack_numberOfValidPixelHits=0;
    outerTrack_chi2=0;
    outerTrack_ndof=0;
    outerTrack_d0=0;
    outerTrack_d0Error=0; 
    outerTrack_numberOfValidHits=0;  
    outerTrack_numberOfLostHits=0; 
  };

  ~Muon(){
  };

  float vertex_x; 
  float vertex_y; 
  float vertex_z; 
  float dB; 
  //float particleIso; 
  float neutralHadronIso; 
  float chargedHadronIso; 
  float trackIso; 
  float photonIso;
  float puChargedHadronIso;
  bool isGlobalMuon;
  bool isStandAloneMuon;
  bool isTrackerMuon;
  int numberOfMatchedStations;
  float globalTrack_chi2;
  float globalTrack_ndof;
  float globalTrack_d0;
  float globalTrack_d0Error; 
  unsigned short globalTrack_numberOfValidHits;  
  unsigned short globalTrack_numberOfLostHits;  
  float innerTrack_chi2;
  float innerTrack_ndof;
  float innerTrack_d0;
  float innerTrack_d0Error; 
  unsigned short innerTrack_numberOfValidHits;  
  unsigned short innerTrack_numberOfLostHits;  
  unsigned short innerTrack_trackerLayersWithMeasurement;
  unsigned short innerTrack_numberOfValidPixelHits;
  float outerTrack_chi2;
  float outerTrack_ndof;
  float outerTrack_d0;
  float outerTrack_d0Error; 
  unsigned short outerTrack_numberOfValidHits;  
  unsigned short outerTrack_numberOfLostHits;  
  
  float relIso(){
    return ( chargedHadronIso + std::max( 0.0, neutralHadronIso + photonIso - 0.5*puChargedHadronIso ) ) / pt;
  }

};


class Tau : public Particle{

 public:
  Tau(){
    leadPFCand_px=0;
    leadPFCand_py=0;
    leadPFCand_pz=0;
    decayModeFinding=false; 
    byVLooseCombinedIsolationDeltaBetaCorr =false;
    byLooseCombinedIsolationDeltaBetaCorr=false; 
    byMediumCombinedIsolationDeltaBetaCorr=false;
    byTightCombinedIsolationDeltaBetaCorr=false; 
    againstElectronLoose =false;
    againstElectronMedium=false;
    againstElectronTight=false ;
    againstElectronMVA =false;
    againstMuonLoose=false ;
    againstMuonMedium=false;
    againstMuonTight=false;
  };

  ~Tau(){
  };

  float leadPFCand_px;
  float leadPFCand_py;
  float leadPFCand_pz;

  bool decayModeFinding; 
  bool byVLooseCombinedIsolationDeltaBetaCorr ;
  bool byLooseCombinedIsolationDeltaBetaCorr; 
  bool byMediumCombinedIsolationDeltaBetaCorr;
  bool byTightCombinedIsolationDeltaBetaCorr; 
  bool againstElectronLoose ;
  bool againstElectronMedium;
  bool againstElectronTight ;
  bool againstElectronMVA ;
  bool againstMuonLoose ;
  bool againstMuonMedium;
  bool againstMuonTight;

};

class Photon : public Particle{

 public:
  Photon(){
 
    vertex_x=0; 
    vertex_y=0; 
    vertex_z=0; 
    supercluster_eta=0; 
    supercluster_phi=0;
/*     neutralHadronIso=0;  */
/*     chargedHadronIso=0;  */
    trackIso=0; 
  };

  ~Photon(){
  };
 
  float vertex_x; 
  float vertex_y; 
  float vertex_z; 
  float supercluster_eta; 
  float supercluster_phi; 
/*   float neutralHadronIso;  */
/*   float chargedHadronIso;  */
  float trackIso; 

};

class MET{
   
 public:
  MET(){
    pt=0; 
    phi=0; 
    mEtSig=0;

  };

  ~MET(){
  };

  float pt; 
  float phi; 
  float mEtSig; 

};

class PrimaryVertex{
   
 public:
  PrimaryVertex(){
    x=0; 
    y=0; 
    z=0; 
    nTracks=0; 
    //isValid=false; 
    chi2=0; 
    ndof=0;

  };

  ~PrimaryVertex(){
  };

  float x; 
  float y; 
  float z; 
  unsigned int nTracks; 
  //bool isValid; 
  float chi2; 
  float ndof;

};

class GenInfo{

 public:
  GenInfo(){
    binningValues.clear();
    weights.clear();
    alphaQCD=0;
    alphaQED=0;
    qScale=0;
    pdf_id1=0;
    pdf_id2=0;
    pdf_x1=0;
    pdf_x2=0;
    pdf_xPDF1=0;
    pdf_xPDF2=0;
    pdf_scalePDF=0;
    pileup_NumInteractions_intime=0; 
    pileup_NumInteractions_ootbefore=0; 
    pileup_NumInteractions_ootafter=0;
    pileup_TrueNumInteractions=0; 
  }

  ~GenInfo(){
  };
  std::vector<double> binningValues;
  std::vector<double> weights;
  float alphaQCD;
  float alphaQED;
  float qScale;
  int pdf_id1;
  int pdf_id2;
  float pdf_x1;
  float pdf_x2;
  float pdf_xPDF1;
  float pdf_xPDF2;
  float pdf_scalePDF;
  int pileup_NumInteractions_intime; 
  int pileup_NumInteractions_ootbefore; 
  int pileup_NumInteractions_ootafter;
  float pileup_TrueNumInteractions;  //poisson mean

};


class TopJet : public Jet{
 public:
  TopJet(){
    subjets.clear();
  };
  ~TopJet(){
  };

  std::vector<Particle> subjets;

};

class GenParticle : public Particle{
 public:
  GenParticle(){
    pdgId=0;
    status=0;
    index=0;
    mother1=0;
    mother2=0;
    daughter1=0;
    daughter2=0;
  };
  ~GenParticle(){
  };
  int pdgId;
  int status;
  int index;

  //return mother 1 or 2 (ind<=1 or ind>=2)
  GenParticle* mother(std::vector<GenParticle> *gplist, int ind=1){
    for(unsigned int i=0; i< gplist->size(); ++i){
      if(ind<=1){
        if(this->mother1 == gplist->at(i).index){
          return &(gplist->at(i));
        }
      }
      else{
        if(this->mother2 == gplist->at(i).index){
          return &(gplist->at(i));
        }       
      }
    }
    //std::cout << "WARNING: Mother " << ind << " not found in list of GenParticles" << std::endl;
    return 0;
  }
  //return daughter 1 or 2 (ind<=1 or ind>=2)
  GenParticle* daughter(std::vector<GenParticle> *gplist, int ind=1){
    for(unsigned int i=0; i< gplist->size(); ++i){
      if(ind<=1){
        if(this->daughter1 == gplist->at(i).index){
          return &(gplist->at(i));
        }
      }
      else{
        if(this->daughter2 == gplist->at(i).index){
          return &(gplist->at(i));
        }       
      }
    }
    //std::cout << "WARNING: Daughter " << ind << " not found in list of GenParticles" << std::endl;
    return 0;
  }

  int mother1;
  int mother2;
  int daughter1;
  int daughter2;
 

};

#endif 
Revision:	1.14
Committed:	Tue May 22 09:32:31 2012 UTC (12 years, 11 months ago) by peiffer
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.13:	+0 -0 lines
State:	*FILE REMOVED*
Log Message:	new class structure for objects
#	Content
1	#ifndef Objects_H
2	#define Objects_H
3
4	#include <vector>
5	#include "Math/LorentzVector.h"
6	#include "Math/PtEtaPhiE4D.h"
7	#include "TObject.h"
8
9	#ifndef PI
10	#define PI 3.14159265358979323846264338328
11	#endif
12
13	typedef ROOT::Math::LorentzVector< ROOT::Math::PtEtaPhiE4D< Double32_t > > LorentzVector;
14
15	class Particle{
16	public:
17	Particle(){
18	charge=0;
19	pt=0;
20	eta=0;
21	phi=0;
22	energy=0;
23	};
24
25	~Particle(){
26	};
27
28	LorentzVector v4(){
29	LorentzVector v4;
30	v4.SetPt(pt);
31	v4.SetEta(eta);
32	v4.SetPhi(phi);
33	v4.SetE(energy);
34	return v4;
35	};
36
37	double deltaPhi(Particle p2){
38	double deltaphi = fabs(this->phi - p2.phi);
39	if(deltaphi > PI) deltaphi = 2* PI - deltaphi;
40	return deltaphi;
41	}
42	double deltaR(Particle p2){
43	double deltaeta = this->eta - p2.eta;
44	return sqrt(deltaetadeltaeta+deltaPhi(p2)deltaPhi(p2));
45	}
46
47	float charge;
48	float pt;
49	float eta;
50	float phi;
51	float energy;
52
53	};
54
55	class Jet : public Particle{
56
57	public:
58
59	Jet(){
60	nTracks=0;
61	jetArea=0;
62	pileup=0;
63	numberOfDaughters=0;
64	neutralEmEnergyFraction=0;
65	neutralHadronEnergyFraction=0;
66	chargedEmEnergyFraction=0;
67	chargedHadronEnergyFraction=0;
68	muonEnergyFraction=0;
69	photonEnergyFraction=0;
70	chargedMultiplicity=0;
71	neutralMultiplicity=0;
72	muonMultiplicity=0;
73	electronMultiplicity=0;
74	photonMultiplicity=0;
75	btag_simpleSecondaryVertexHighEff=0;
76	btag_simpleSecondaryVertexHighPur=0;
77	btag_combinedSecondaryVertex=0;
78	btag_combinedSecondaryVertexMVA=0;
79	btag_jetBProbability=0;
80	btag_jetProbability=0;
81	JEC_uncertainty=0;
82	JEC_factor_raw=0;
83	genjet_pt=0;
84	genjet_eta=0;
85	genjet_phi=0;
86	genjet_energy=0;
87	genparticles_indices.clear();
88	};
89
90	~Jet(){
91	};
92
93	int nTracks;
94	float jetArea;
95	float pileup;
96	int numberOfDaughters;
97	float neutralEmEnergyFraction;
98	float neutralHadronEnergyFraction;
99	float chargedEmEnergyFraction;
100	float chargedHadronEnergyFraction;
101	float muonEnergyFraction;
102	float photonEnergyFraction;
103	int chargedMultiplicity;
104	int neutralMultiplicity;
105	int muonMultiplicity;
106	int electronMultiplicity;
107	int photonMultiplicity;
108	float btag_simpleSecondaryVertexHighEff;
109	float btag_simpleSecondaryVertexHighPur;
110	float btag_combinedSecondaryVertex;
111	float btag_combinedSecondaryVertexMVA;
112	float btag_jetBProbability;
113	float btag_jetProbability;
114	float JEC_uncertainty;
115	float JEC_factor_raw;
116	float genjet_pt;
117	float genjet_eta;
118	float genjet_phi;
119	float genjet_energy;
120	LorentzVector genjet_v4(){
121	LorentzVector v4;
122	v4.SetPt(genjet_pt);
123	v4.SetEta(genjet_eta);
124	v4.SetPhi(genjet_phi);
125	v4.SetE(genjet_energy);
126	return v4;
127	};
128	std::vector<unsigned int> genparticles_indices;
129
130	};
131
132
133	class Electron : public Particle{
134
135	public:
136	Electron(){
137	vertex_x=0;
138	vertex_y=0;
139	vertex_z=0;
140	supercluster_eta=0;
141	supercluster_phi=0;
142	dB=0;
143	// particleIso=0;
144	neutralHadronIso=0;
145	chargedHadronIso=0;
146	photonIso=0;
147	trackIso=0;
148	puChargedHadronIso=0;
149	gsfTrack_trackerExpectedHitsInner_numberOfLostHits=0;
150	gsfTrack_px=0;
151	gsfTrack_py=0;
152	gsfTrack_pz=0;
153	gsfTrack_vx=0;
154	gsfTrack_vy=0;
155	gsfTrack_vz=0;
156	passconversionveto=false;
157	dEtaIn=0;
158	dPhiIn=0;
159	sigmaIEtaIEta=0;
160	HoverE=0;
161	fbrem=0;
162	EoverPIn=0;
163	EcalEnergy=0;
164	mvaTrigV0=0;
165	mvaNonTrigV0=0;
166	};
167
168	~Electron(){
169	};
170
171	float vertex_x;
172	float vertex_y;
173	float vertex_z;
174	float supercluster_eta;
175	float supercluster_phi;
176	float dB;
177	//float particleIso;
178	float neutralHadronIso;
179	float chargedHadronIso;
180	float photonIso;
181	float trackIso;
182	float puChargedHadronIso;
183	int gsfTrack_trackerExpectedHitsInner_numberOfLostHits;
184	float gsfTrack_px;
185	float gsfTrack_py;
186	float gsfTrack_pz;
187	float gsfTrack_vx;
188	float gsfTrack_vy;
189	float gsfTrack_vz;
190	float gsfTrack_dxy_vertex(const float point_x, const float point_y){
191	return ( - (gsfTrack_vx-point_x) * gsfTrack_py + (gsfTrack_vy-point_y) * gsfTrack_px ) / sqrt(gsfTrack_pxgsfTrack_px+gsfTrack_pygsfTrack_py);
192	};
193	float gsfTrack_dz_vertex(const float point_x, const float point_y, const float point_z){
194	return (gsfTrack_vz-point_z) - ((gsfTrack_vx-point_x)gsfTrack_px+(gsfTrack_vy-point_y)gsfTrack_py)/(gsfTrack_pxgsfTrack_px+gsfTrack_pygsfTrack_py) * gsfTrack_pz;
195	}
196	bool passconversionveto;
197	float dEtaIn;
198	float dPhiIn;
199	float sigmaIEtaIEta;
200	float HoverE;
201	float fbrem;
202	float EoverPIn;
203	float EcalEnergy;
204	float mvaTrigV0;
205	float mvaNonTrigV0;
206
207	float relIso(){
208	return ( chargedHadronIso + std::max( 0.0, neutralHadronIso + photonIso - 0.5*puChargedHadronIso ) ) / pt;
209	}
210
211	};
212
213	class Muon : public Particle{
214
215	public:
216	Muon(){
217	vertex_x=0;
218	vertex_y=0;
219	vertex_z=0;
220	dB=0;
221	// particleIso=0;
222	neutralHadronIso=0;
223	chargedHadronIso=0;
224	trackIso=0;
225	photonIso=0;
226	puChargedHadronIso=0;
227	isGlobalMuon=false;
228	isStandAloneMuon=false;
229	isTrackerMuon=false;
230	numberOfMatchedStations=0;
231	globalTrack_chi2=0;
232	globalTrack_ndof=0;
233	globalTrack_d0=0;
234	globalTrack_d0Error=0;
235	globalTrack_numberOfValidHits=0;
236	globalTrack_numberOfLostHits=0;
237	innerTrack_chi2=0;
238	innerTrack_ndof=0;
239	innerTrack_d0=0;
240	innerTrack_d0Error=0;
241	innerTrack_numberOfValidHits=0;
242	innerTrack_numberOfLostHits=0;
243	innerTrack_trackerLayersWithMeasurement=0;
244	innerTrack_numberOfValidPixelHits=0;
245	outerTrack_chi2=0;
246	outerTrack_ndof=0;
247	outerTrack_d0=0;
248	outerTrack_d0Error=0;
249	outerTrack_numberOfValidHits=0;
250	outerTrack_numberOfLostHits=0;
251	};
252
253	~Muon(){
254	};
255
256	float vertex_x;
257	float vertex_y;
258	float vertex_z;
259	float dB;
260	//float particleIso;
261	float neutralHadronIso;
262	float chargedHadronIso;
263	float trackIso;
264	float photonIso;
265	float puChargedHadronIso;
266	bool isGlobalMuon;
267	bool isStandAloneMuon;
268	bool isTrackerMuon;
269	int numberOfMatchedStations;
270	float globalTrack_chi2;
271	float globalTrack_ndof;
272	float globalTrack_d0;
273	float globalTrack_d0Error;
274	unsigned short globalTrack_numberOfValidHits;
275	unsigned short globalTrack_numberOfLostHits;
276	float innerTrack_chi2;
277	float innerTrack_ndof;
278	float innerTrack_d0;
279	float innerTrack_d0Error;
280	unsigned short innerTrack_numberOfValidHits;
281	unsigned short innerTrack_numberOfLostHits;
282	unsigned short innerTrack_trackerLayersWithMeasurement;
283	unsigned short innerTrack_numberOfValidPixelHits;
284	float outerTrack_chi2;
285	float outerTrack_ndof;
286	float outerTrack_d0;
287	float outerTrack_d0Error;
288	unsigned short outerTrack_numberOfValidHits;
289	unsigned short outerTrack_numberOfLostHits;
290
291	float relIso(){
292	return ( chargedHadronIso + std::max( 0.0, neutralHadronIso + photonIso - 0.5*puChargedHadronIso ) ) / pt;
293	}
294
295	};
296
297
298	class Tau : public Particle{
299
300	public:
301	Tau(){
302	leadPFCand_px=0;
303	leadPFCand_py=0;
304	leadPFCand_pz=0;
305	decayModeFinding=false;
306	byVLooseCombinedIsolationDeltaBetaCorr =false;
307	byLooseCombinedIsolationDeltaBetaCorr=false;
308	byMediumCombinedIsolationDeltaBetaCorr=false;
309	byTightCombinedIsolationDeltaBetaCorr=false;
310	againstElectronLoose =false;
311	againstElectronMedium=false;
312	againstElectronTight=false ;
313	againstElectronMVA =false;
314	againstMuonLoose=false ;
315	againstMuonMedium=false;
316	againstMuonTight=false;
317	};
318
319	~Tau(){
320	};
321
322	float leadPFCand_px;
323	float leadPFCand_py;
324	float leadPFCand_pz;
325
326	bool decayModeFinding;
327	bool byVLooseCombinedIsolationDeltaBetaCorr ;
328	bool byLooseCombinedIsolationDeltaBetaCorr;
329	bool byMediumCombinedIsolationDeltaBetaCorr;
330	bool byTightCombinedIsolationDeltaBetaCorr;
331	bool againstElectronLoose ;
332	bool againstElectronMedium;
333	bool againstElectronTight ;
334	bool againstElectronMVA ;
335	bool againstMuonLoose ;
336	bool againstMuonMedium;
337	bool againstMuonTight;
338
339	};
340
341	class Photon : public Particle{
342
343	public:
344	Photon(){
345
346	vertex_x=0;
347	vertex_y=0;
348	vertex_z=0;
349	supercluster_eta=0;
350	supercluster_phi=0;
351	/* neutralHadronIso=0; */
352	/* chargedHadronIso=0; */
353	trackIso=0;
354	};
355
356	~Photon(){
357	};
358
359	float vertex_x;
360	float vertex_y;
361	float vertex_z;
362	float supercluster_eta;
363	float supercluster_phi;
364	/* float neutralHadronIso; */
365	/* float chargedHadronIso; */
366	float trackIso;
367
368	};
369
370	class MET{
371
372	public:
373	MET(){
374	pt=0;
375	phi=0;
376	mEtSig=0;
377
378	};
379
380	~MET(){
381	};
382
383	float pt;
384	float phi;
385	float mEtSig;
386
387	};
388
389	class PrimaryVertex{
390
391	public:
392	PrimaryVertex(){
393	x=0;
394	y=0;
395	z=0;
396	nTracks=0;
397	//isValid=false;
398	chi2=0;
399	ndof=0;
400
401	};
402
403	~PrimaryVertex(){
404	};
405
406	float x;
407	float y;
408	float z;
409	unsigned int nTracks;
410	//bool isValid;
411	float chi2;
412	float ndof;
413
414	};
415
416	class GenInfo{
417
418	public:
419	GenInfo(){
420	binningValues.clear();
421	weights.clear();
422	alphaQCD=0;
423	alphaQED=0;
424	qScale=0;
425	pdf_id1=0;
426	pdf_id2=0;
427	pdf_x1=0;
428	pdf_x2=0;
429	pdf_xPDF1=0;
430	pdf_xPDF2=0;
431	pdf_scalePDF=0;
432	pileup_NumInteractions_intime=0;
433	pileup_NumInteractions_ootbefore=0;
434	pileup_NumInteractions_ootafter=0;
435	pileup_TrueNumInteractions=0;
436	}
437
438	~GenInfo(){
439	};
440	std::vector<double> binningValues;
441	std::vector<double> weights;
442	float alphaQCD;
443	float alphaQED;
444	float qScale;
445	int pdf_id1;
446	int pdf_id2;
447	float pdf_x1;
448	float pdf_x2;
449	float pdf_xPDF1;
450	float pdf_xPDF2;
451	float pdf_scalePDF;
452	int pileup_NumInteractions_intime;
453	int pileup_NumInteractions_ootbefore;
454	int pileup_NumInteractions_ootafter;
455	float pileup_TrueNumInteractions; //poisson mean
456
457	};
458
459
460	class TopJet : public Jet{
461	public:
462	TopJet(){
463	subjets.clear();
464	};
465	~TopJet(){
466	};
467
468	std::vector<Particle> subjets;
469
470	};
471
472	class GenParticle : public Particle{
473	public:
474	GenParticle(){
475	pdgId=0;
476	status=0;
477	index=0;
478	mother1=0;
479	mother2=0;
480	daughter1=0;
481	daughter2=0;
482	};
483	~GenParticle(){
484	};
485	int pdgId;
486	int status;
487	int index;
488
489	//return mother 1 or 2 (ind<=1 or ind>=2)
490	GenParticle* mother(std::vector<GenParticle> *gplist, int ind=1){
491	for(unsigned int i=0; i< gplist->size(); ++i){
492	if(ind<=1){
493	if(this->mother1 == gplist->at(i).index){
494	return &(gplist->at(i));
495	}
496	}
497	else{
498	if(this->mother2 == gplist->at(i).index){
499	return &(gplist->at(i));
500	}
501	}
502	}
503	//std::cout << "WARNING: Mother " << ind << " not found in list of GenParticles" << std::endl;
504	return 0;
505	}
506	//return daughter 1 or 2 (ind<=1 or ind>=2)
507	GenParticle* daughter(std::vector<GenParticle> *gplist, int ind=1){
508	for(unsigned int i=0; i< gplist->size(); ++i){
509	if(ind<=1){
510	if(this->daughter1 == gplist->at(i).index){
511	return &(gplist->at(i));
512	}
513	}
514	else{
515	if(this->daughter2 == gplist->at(i).index){
516	return &(gplist->at(i));
517	}
518	}
519	}
520	//std::cout << "WARNING: Daughter " << ind << " not found in list of GenParticles" << std::endl;
521	return 0;
522	}
523
524	int mother1;
525	int mother2;
526	int daughter1;
527	int daughter2;
528
529
530	};
531
532	#endif