Mods/interface/ConversionRemoval.h

//--------------------------------------------------------------------------------------------------
// $Id: ConversionRemoval.h,v 1.1 2009/12/16 18:10:38 bendavid Exp $
//
// DiMuonResonance
//
// This is an analysis module which allows to study the properties of dimuon resonances. The
// implementation is reasonably general to at least allow the study of Jpsis and Upsilons without
// any code change.
//
//  Authors: C.Paus
//--------------------------------------------------------------------------------------------------
#ifndef MODS_CONVERSIONREMOVAL_H
#define MODS_CONVERSIONREMOVAL_H

#include <TH2F.h>
#include <TStopwatch.h>

#include "MitAna/TreeMod/interface/BaseMod.h"
#include "MitAna/DataTree/interface/EvtSelData.h"
#include "MitAna/DataTree/interface/CollectionsFwd.h"
#include "MitAna/DataTree/interface/Collections.h"


class TH1F;

namespace mithep 
{
  class ConversionRemoval : public BaseMod 
  {
    public:
      enum ECuts {
        eNDaughters,
        ePt,
        eRho,
        eEta,
        eL,
        eDxy,
        eCharge,
        eDaughters,
        eProb,
        ePV,
        eNTracks,
        eBx,
        eBptx,
        eClusVtx,
        eSharedHits
      };
      
      enum EElectronCuts {
        eEPt,
        eEEta,
        eENMissingHits,
        eENWrongHits,
        eENHits,
        eENStereoHits,
        eENPixelHits,
        eEProb,
        eEPxb1,
        eDz
      };
      
      enum ESimCuts {
        eSimPdg,
        eSimEta,
        eSimPt,
        eSimRho,
        eSimElectronPt,
        eSimElectronEta,
        eSimDaughters,
        eCleanElectron
      };
    
      ConversionRemoval(const char *name  = "ConversionRemoval", 
                      const char *title = "Analysis Module of photon conversions");
      ~ConversionRemoval() {}

      // Standard entry points allowing data processing
      void             Begin         ();
      void             Process       ();
      void             SlaveBegin    ();
      void             SlaveTerminate();
      void             Terminate     ();
      BitMask16        FailedCuts(const DecayParticle* c);
      Bool_t           PassConvCuts(const Conversion* p);
      BitMask16        FailedElectronCuts(const DaughterData* d, Bool_t trackQuality=kTRUE);
      Bool_t           PassTrackCuts(const Track* t);
      BitMask16        FailedSimCuts(const MCParticle* p);
      Bool_t           PassPhotonCuts(const Photon *p);
      const Electron*  ElectronMatch(const MCParticle *p);
      const MCParticle *GenElectronMatch(const MCParticle *p);
      const MCParticle* SimMatch(const DecayParticle* p);
      const MCParticle* SimMatch(const Track *t);
      UInt_t           NTracks(const TrackCol *col);
      //Double_t         TrackPtIsolation(const DecayParticle *p, Double_t r);
      Double_t         DCotTheta(const DecayParticle *c);
      Double_t         DPhi(const DecayParticle *c);
      Double_t         TwoPionMass(const DecayParticle *c);
      const DecayParticle   *MatchingConversion(const DecayParticle *c, const DecayParticleCol *col) const;
      const Electron        *MatchingElectron(const ChargedParticle *c, const ElectronCol *col) const;
      const Electron        *MatchingElectron(const Electron *ein, const ElectronCol *col) const;
      Bool_t           PassRho(Double_t rho);
      
      const MCParticle *SimConversionMatch(const Electron *e);
      const MCParticle *SimWeMatch(const Electron *e);
      const Electron   *ElectronMatch(const DecayParticle *d, const ElectronCol *c);
      
      void             SetConversionName(TString convName) { fMvfConvName = convName; }
      
      //set cuts
      void             SetPtMin(Double_t ptMin) { fPtMin = ptMin; }
      void             SetEtaMax(Double_t etaMax) { fEtaMax = etaMax; }
      void             SetProbMin(Double_t probMin) { fProbMin = probMin; }
      void             SetNHitsMin(UInt_t nhits) { fNHitsMin = nhits; }
      void             SetNStereoHitsMin(UInt_t nhits) { fNStereoHitsMin = nhits; }
      void             SetNPixelHitsMin(UInt_t nhits) { fNPixelHitsMin = nhits; }
      void             SetTrackProbMin(Double_t trackProb) { fTrackProbMin = trackProb; }
      void             SetLxyMin(Double_t lxy) { fLxyMin = lxy; }
      void             SetLzMin(Double_t lz) { fLzMin = lz; }
      void             SetAbsDxyMax(Double_t dxy) { fAbsDxyMax = dxy; }   
      void             SetExcludePXB1(Bool_t ex) { fExcludePXB1 = ex; }
      void             SetMassMax(Double_t mass) { fMassMax = mass; }
      void             SetMissedHitsMax(UInt_t hits) { fMissedHitsMax = hits; }
      void             SetWrongHitsMax(UInt_t hits)  { fWrongHitsMax = hits; }
      void             SetElectronPtMin(Double_t pt) { fElectronPtMin = pt; }
      void             SetElectronEtaMax(Double_t eta) { fElectronEtaMax = eta; }
      void             AddRhoRange(Double_t lower, Double_t upper);
      void             SetComputeEff(Bool_t b=kTRUE) { fComputeEff = b; }
      void             SetTrackerElectronsName(TString name) { fTrkElectronName = name; }
      void             SetGoodElectronsName(TString name) { fGoodElectronsName = name; }
      void             SetGoodTwoClusterElectronsName(TString name) { fGoodTwoClusterElectronsName = name; }
      void             SetBadElectronsName(TString name) { fBadElectronsName = name; }
      void             SetRequireCleanElectron(Bool_t b=kTRUE) { fRequireCleanElectron = b; }
      void             SetCleanElectronsName(TString name) { fCleanElectronsName = name; }
      void             SetTrackQualityFirstOnly(Bool_t b=kTRUE) { fTrackQualityFirstOnly = b; }
      void             SetHitBasedMatching(Bool_t b=kTRUE) { fHitBasedMatching = b; }
      void             SetMatchWe(Bool_t b=kTRUE) { fMatchWe = b; }
      void             SetMatchSimConv(Bool_t b=kTRUE) { fMatchSimConv = b; }
      void             SetFakingConversionsName(TString name) { fFakingConversionsName = name; }
      void             SetRemovedElectronsName(TString name) { fRemovedElectronsName = name; }
      void             SetAllConversionElectronsName(TString name) { fAllConversionElectronsName = name; }
      void             SetRequireGoodPv(Bool_t b) { fRequireGoodPv = b; }
      void             SetMaxTrackDzPv(Double_t x) { fMaxTrackDzPv = x; }
      void             SetMinClusterVtxQual(Double_t x) { fMinClusterVtxQual = x; }
      void             SetMaxSharedHits(UInt_t n) { fMaxNSharedHits = n; }
      void             SetMinSharedHits(UInt_t n) { fMinNSharedHits = n; }


    protected:
      Double_t         fPtMin; //minimum pt cut on conversions
      Double_t         fEtaMax; //maximum Eta cut on conversions
      Double_t         fProbMin; //minimum fit probability cut on conversions
      UInt_t           fNHitsMin;//
      UInt_t           fNStereoHitsMin;//
      UInt_t           fNPixelHitsMin;//
      Double_t         fTrackProbMin;//
      Double_t         fLxyMin; //minimum decay length
      Double_t         fLzMin; //min z decay length
      Double_t         fAbsDxyMax; //max impact parameter of conversion (to PV)
      Bool_t           fExcludePXB1;
      Double_t         fMassMax;
      UInt_t           fMissedHitsMax;
      UInt_t           fWrongHitsMax;
      Double_t         fElectronPtMin;
      Double_t         fElectronEtaMax;
      std::vector<Double_t> fRhoLbs;
      std::vector<Double_t> fRhoUbs;
      Bool_t           fComputeEff;
      Bool_t           fHitBasedMatching;
      Bool_t           fRequireCleanElectron;
      Bool_t           fTrackQualityFirstOnly;
      Bool_t           fMatchWe;
      Bool_t           fMatchSimConv;
      Bool_t           fRequireGoodPv;
      Double_t         fMaxTrackDzPv;
      Double_t         fMinClusterVtxQual;
      UInt_t           fMaxNSharedHits;
      UInt_t           fMinNSharedHits;
    
      const TrackCol          *fTracks;       //! point to track branch
      const TrackCol          *fGsfTracks;    //! point to track branch
      const TrackCol          *fInOutTracks; //!
      const TrackCol          *fOutInTracks; //!
      const ElectronCol     *fElectrons;    //! point to electron branch
      const ElectronCol     *fTrkElectrons;    //! point to tracker electron branch
      const PhotonCol       *fPhotons;  //! point to photon branch
      const MCParticleCol   *fMCParticles; //!
      const DecayParticleCol *fMvfConversions; //!
      const DecayParticleCol *fMvfConversionsUnconstrained; //!
      const VertexCol       *fPrimaryVertexes; //!
      const EvtSelData      *fEvtSel; //!
      ElectronCol     *fCleanElectrons;

      TString          fMCPartName;  // name of particle collection
      TString          fTrackName;    // name of track collection
      TString          fConvElectronName; // name of electron collection
      TString          fPhotonName; // name of photon collection
      TString          fMvfConvName;
      TString          fMvfConvUnconstrainedName;
      TString          fElectronName;
      TString          fTrkElectronName;
      TString          fCleanElectronsName;
      TStopwatch       fTimer;
      
      TString          fGoodElectronsName;
      TString          fGoodTwoClusterElectronsName;
      TString          fBadElectronsName;
      
      TString          fFakingConversionsName;
      TString          fRemovedElectronsName;
      TString          fAllConversionElectronsName;

      TH1F            *hConversionRadius;     //! Conversion radius
      TH1F            *hConversionRadiusBarrel;     //! Conversion radius, barrel only
      TH1F            *hConversionZ; //!
      TH2F            *hConversionRPhi; //! conversion position in R-phi plane
      TH2F            *hConversionRZ; //!
      TH2F            *hConversionFoldedRZ; //!
      TH1F            *hGammaPt; //! photon pt
      TH1F            *hGammaEta; //! photon eta
      TH1F            *hGammaMass; //! photon mass
      TH1F            *hGammaPhi;//! photon phi
      TH1F            *hSimMatchedGammaMass; //!
      TH1F            *hConvProb; //! conversion vertex fit probability
      TH1F            *hConvChi2; //! conversion vertex fit chi squared
      TH1F            *hSimMatchedConvChi2; //!
      TH1F            *hConvDCotTheta;//!
      TH1F            *hConvDCotThetaPreCut;//!
      TH1F            *hConvEOverP; //! conversion E over P
      TH1F            *hElectronPt; //! pt of conversion electrons
      TH1F            *hMinElectronPt; //!
      TH1F            *hSimMinElectronPt; //!
      TH1F            *hSimMatchedMinElectronPt; //!
      TH1F            *hSimMatchedMinElectronSimPt; //!
      TH1F            *hElectronEta; //! eta of conversion electrons
      TH1F            *hEPairMass; //! invariant mass of electron track pair
      TH1F            *hEPairDeltaPhi; //! angle between electron momentum vectors
      TH1F            *hGenNumDaughters; //!
      TH1F            *hGenDaughterPt; //!
      TH1F            *hGenDecayRadius; //!
      TH1F            *hSimPt; //!
      TH1F            *hSimEta; //!
      TH1F            *hSimConvRadius; //!
      TH2F            *hSimConvPosition; //!
      TH2F            *hSimConversionRZ; //!
      TH1F            *hTrackSimMatchType; //!
      TH1F            *hParentSimMatchType; //!
      TH1F            *hSimMatchedConvRadius; //!
      TH1F            *hSimMatchedConvProb; //!
      TH1F            *hSimMatchedEPairMass; //!
      TH1F            *hSimMatchedEPairDeltaPhi; //!
      TH1F            *hSimMatchedSimConvRadius; //!
      TH1F            *hSimMatchedConvResolution; //!
      TH1F            *hSimMatchedConvPhiRes; //!
      TH1F            *hSimMatchedConvEOverP; //!
      TH1F            *hSimMatchedElectronPt; //!
      TH1F            *hSimMatchedGammaPt; //!
      TH1F            *hSimMatchedGammaEta; //!
      TH1F            *hSimMatchedSimGammaPt; //!
      TH1F            *hSimMatchedSimGammaEta; //!
      TH1F            *hTrackChi2;//!
      TH1F            *hTrackProb;//!
      TH1F            *hTrackNHits;//!
      TH1F            *hTrackNWrongHits;//!
      TH1F            *hTrackNMissingHits;//!
      TH1F            *hNSharedHits;//!
      TH2F            *hTrackNHitsProb;//!
      TH1F            *hTrackD0; //!
      TH1F            *hTrackDzPv; //!
      TH1F            *hUnMatchedTrackChi2;//!
      TH1F            *hUnMatchedTrackProb;//!
      TH1F            *hUnMatchedTrackNHits;//!
      TH2F            *hUnMatchedTrackNHitsProb;//!
      TH1F            *hUnMatchedTrackD0; //!
      TH1F            *hSimMatchedTrackChi2;//!
      TH1F            *hSimMatchedTrackProb;//!
      TH1F            *hSimMatchedTrackNHits;//! 
      TH2F            *hSimMatchedTrackNHitsProb;//!
      TH1F            *hSimMatchedTrackD0; //!
      TH1F            *hLxy; //!
      TH1F            *hLxyOverLxyErr; //!
      TH1F            *hLz; //!
      TH1F            *hLzOverLzErr; //!
      TH1F            *hDxy;//!
      TH1F            *hSimMatchedLxy; //!
      TH1F            *hSimMatchedLz; //!
      TH1F            *hSimMatchedDxy;//!
      TH1F            *hNTracks; //!
      TH1F            *hSimMatchedNTracks; //!
      TH1F            *hIsolation;//!
      TH1F            *hSimMatchedIsolation; //!
      TH1F            *hNConversions; //!
      TH1F            *hDoubleConvMass; //!
      TH1F            *hConvGammaMass; //!
      TH1F            *hPiPiMass; //!
      
      TH1F            *hAllConversionElectronPt;
      TH1F            *hAllConversionElectronEta;
      TH1F            *hRemovedElectronPt;
      TH1F            *hRemovedElectronEta;
      
      TH1F            *hAllConversionElectronPtWrongCharge;
      TH1F            *hAllConversionElectronEtaWrongCharge;
      TH1F            *hRemovedElectronPtWrongCharge;
      TH1F            *hRemovedElectronEtaWrongCharge;
      
      TH1F            *hAllConversionElectronChargeAssign;
      TH1F            *hRemovedElectronChargeAssign;
      
      TH1F            *hTrackAlgo;
      
      TH1F            *hCharge;
      TH2F            *hPt1Pt2;
      
      TH1F            *hClusVtxDiff;
      TH1F            *hClusVtxQual;
      
      
      ClassDef(ConversionRemoval,1)
  };
}
#endif
Revision:	1.2
Committed:	Thu Dec 17 02:05:17 2009 UTC (15 years, 4 months ago) by bendavid
Content type:	text/plain
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.1:	+2 -1 lines
Log Message:	Added sim rz plot
#	Content
1	//--------------------------------------------------------------------------------------------------
2	// $Id: ConversionRemoval.h,v 1.1 2009/12/16 18:10:38 bendavid Exp $
3	//
4	// DiMuonResonance
5	//
6	// This is an analysis module which allows to study the properties of dimuon resonances. The
7	// implementation is reasonably general to at least allow the study of Jpsis and Upsilons without
8	// any code change.
9	//
10	// Authors: C.Paus
11	//--------------------------------------------------------------------------------------------------
12	#ifndef MODS_CONVERSIONREMOVAL_H
13	#define MODS_CONVERSIONREMOVAL_H
14
15	#include <TH2F.h>
16	#include <TStopwatch.h>
17
18	#include "MitAna/TreeMod/interface/BaseMod.h"
19	#include "MitAna/DataTree/interface/EvtSelData.h"
20	#include "MitAna/DataTree/interface/CollectionsFwd.h"
21	#include "MitAna/DataTree/interface/Collections.h"
22
23
24	class TH1F;
25
26	namespace mithep
27	{
28	class ConversionRemoval : public BaseMod
29	{
30	public:
31	enum ECuts {
32	eNDaughters,
33	ePt,
34	eRho,
35	eEta,
36	eL,
37	eDxy,
38	eCharge,
39	eDaughters,
40	eProb,
41	ePV,
42	eNTracks,
43	eBx,
44	eBptx,
45	eClusVtx,
46	eSharedHits
47	};
48
49	enum EElectronCuts {
50	eEPt,
51	eEEta,
52	eENMissingHits,
53	eENWrongHits,
54	eENHits,
55	eENStereoHits,
56	eENPixelHits,
57	eEProb,
58	eEPxb1,
59	eDz
60	};
61
62	enum ESimCuts {
63	eSimPdg,
64	eSimEta,
65	eSimPt,
66	eSimRho,
67	eSimElectronPt,
68	eSimElectronEta,
69	eSimDaughters,
70	eCleanElectron
71	};
72
73	ConversionRemoval(const char *name = "ConversionRemoval",
74	const char *title = "Analysis Module of photon conversions");
75	~ConversionRemoval() {}
76
77	// Standard entry points allowing data processing
78	void Begin ();
79	void Process ();
80	void SlaveBegin ();
81	void SlaveTerminate();
82	void Terminate ();
83	BitMask16 FailedCuts(const DecayParticle* c);
84	Bool_t PassConvCuts(const Conversion* p);
85	BitMask16 FailedElectronCuts(const DaughterData* d, Bool_t trackQuality=kTRUE);
86	Bool_t PassTrackCuts(const Track* t);
87	BitMask16 FailedSimCuts(const MCParticle* p);
88	Bool_t PassPhotonCuts(const Photon *p);
89	const Electron* ElectronMatch(const MCParticle *p);
90	const MCParticle GenElectronMatch(const MCParticle p);
91	const MCParticle* SimMatch(const DecayParticle* p);
92	const MCParticle* SimMatch(const Track *t);
93	UInt_t NTracks(const TrackCol *col);
94	//Double_t TrackPtIsolation(const DecayParticle *p, Double_t r);
95	Double_t DCotTheta(const DecayParticle *c);
96	Double_t DPhi(const DecayParticle *c);
97	Double_t TwoPionMass(const DecayParticle *c);
98	const DecayParticle MatchingConversion(const DecayParticle c, const DecayParticleCol *col) const;
99	const Electron MatchingElectron(const ChargedParticle c, const ElectronCol *col) const;
100	const Electron MatchingElectron(const Electron ein, const ElectronCol *col) const;
101	Bool_t PassRho(Double_t rho);
102
103	const MCParticle SimConversionMatch(const Electron e);
104	const MCParticle SimWeMatch(const Electron e);
105	const Electron ElectronMatch(const DecayParticle d, const ElectronCol *c);
106
107	void SetConversionName(TString convName) { fMvfConvName = convName; }
108
109	//set cuts
110	void SetPtMin(Double_t ptMin) { fPtMin = ptMin; }
111	void SetEtaMax(Double_t etaMax) { fEtaMax = etaMax; }
112	void SetProbMin(Double_t probMin) { fProbMin = probMin; }
113	void SetNHitsMin(UInt_t nhits) { fNHitsMin = nhits; }
114	void SetNStereoHitsMin(UInt_t nhits) { fNStereoHitsMin = nhits; }
115	void SetNPixelHitsMin(UInt_t nhits) { fNPixelHitsMin = nhits; }
116	void SetTrackProbMin(Double_t trackProb) { fTrackProbMin = trackProb; }
117	void SetLxyMin(Double_t lxy) { fLxyMin = lxy; }
118	void SetLzMin(Double_t lz) { fLzMin = lz; }
119	void SetAbsDxyMax(Double_t dxy) { fAbsDxyMax = dxy; }
120	void SetExcludePXB1(Bool_t ex) { fExcludePXB1 = ex; }
121	void SetMassMax(Double_t mass) { fMassMax = mass; }
122	void SetMissedHitsMax(UInt_t hits) { fMissedHitsMax = hits; }
123	void SetWrongHitsMax(UInt_t hits) { fWrongHitsMax = hits; }
124	void SetElectronPtMin(Double_t pt) { fElectronPtMin = pt; }
125	void SetElectronEtaMax(Double_t eta) { fElectronEtaMax = eta; }
126	void AddRhoRange(Double_t lower, Double_t upper);
127	void SetComputeEff(Bool_t b=kTRUE) { fComputeEff = b; }
128	void SetTrackerElectronsName(TString name) { fTrkElectronName = name; }
129	void SetGoodElectronsName(TString name) { fGoodElectronsName = name; }
130	void SetGoodTwoClusterElectronsName(TString name) { fGoodTwoClusterElectronsName = name; }
131	void SetBadElectronsName(TString name) { fBadElectronsName = name; }
132	void SetRequireCleanElectron(Bool_t b=kTRUE) { fRequireCleanElectron = b; }
133	void SetCleanElectronsName(TString name) { fCleanElectronsName = name; }
134	void SetTrackQualityFirstOnly(Bool_t b=kTRUE) { fTrackQualityFirstOnly = b; }
135	void SetHitBasedMatching(Bool_t b=kTRUE) { fHitBasedMatching = b; }
136	void SetMatchWe(Bool_t b=kTRUE) { fMatchWe = b; }
137	void SetMatchSimConv(Bool_t b=kTRUE) { fMatchSimConv = b; }
138	void SetFakingConversionsName(TString name) { fFakingConversionsName = name; }
139	void SetRemovedElectronsName(TString name) { fRemovedElectronsName = name; }
140	void SetAllConversionElectronsName(TString name) { fAllConversionElectronsName = name; }
141	void SetRequireGoodPv(Bool_t b) { fRequireGoodPv = b; }
142	void SetMaxTrackDzPv(Double_t x) { fMaxTrackDzPv = x; }
143	void SetMinClusterVtxQual(Double_t x) { fMinClusterVtxQual = x; }
144	void SetMaxSharedHits(UInt_t n) { fMaxNSharedHits = n; }
145	void SetMinSharedHits(UInt_t n) { fMinNSharedHits = n; }
146
147
148	protected:
149	Double_t fPtMin; //minimum pt cut on conversions
150	Double_t fEtaMax; //maximum Eta cut on conversions
151	Double_t fProbMin; //minimum fit probability cut on conversions
152	UInt_t fNHitsMin;//
153	UInt_t fNStereoHitsMin;//
154	UInt_t fNPixelHitsMin;//
155	Double_t fTrackProbMin;//
156	Double_t fLxyMin; //minimum decay length
157	Double_t fLzMin; //min z decay length
158	Double_t fAbsDxyMax; //max impact parameter of conversion (to PV)
159	Bool_t fExcludePXB1;
160	Double_t fMassMax;
161	UInt_t fMissedHitsMax;
162	UInt_t fWrongHitsMax;
163	Double_t fElectronPtMin;
164	Double_t fElectronEtaMax;
165	std::vector<Double_t> fRhoLbs;
166	std::vector<Double_t> fRhoUbs;
167	Bool_t fComputeEff;
168	Bool_t fHitBasedMatching;
169	Bool_t fRequireCleanElectron;
170	Bool_t fTrackQualityFirstOnly;
171	Bool_t fMatchWe;
172	Bool_t fMatchSimConv;
173	Bool_t fRequireGoodPv;
174	Double_t fMaxTrackDzPv;
175	Double_t fMinClusterVtxQual;
176	UInt_t fMaxNSharedHits;
177	UInt_t fMinNSharedHits;
178
179	const TrackCol *fTracks; //! point to track branch
180	const TrackCol *fGsfTracks; //! point to track branch
181	const TrackCol *fInOutTracks; //!
182	const TrackCol *fOutInTracks; //!
183	const ElectronCol *fElectrons; //! point to electron branch
184	const ElectronCol *fTrkElectrons; //! point to tracker electron branch
185	const PhotonCol *fPhotons; //! point to photon branch
186	const MCParticleCol *fMCParticles; //!
187	const DecayParticleCol *fMvfConversions; //!
188	const DecayParticleCol *fMvfConversionsUnconstrained; //!
189	const VertexCol *fPrimaryVertexes; //!
190	const EvtSelData *fEvtSel; //!
191	ElectronCol *fCleanElectrons;
192
193	TString fMCPartName; // name of particle collection
194	TString fTrackName; // name of track collection
195	TString fConvElectronName; // name of electron collection
196	TString fPhotonName; // name of photon collection
197	TString fMvfConvName;
198	TString fMvfConvUnconstrainedName;
199	TString fElectronName;
200	TString fTrkElectronName;
201	TString fCleanElectronsName;
202	TStopwatch fTimer;
203
204	TString fGoodElectronsName;
205	TString fGoodTwoClusterElectronsName;
206	TString fBadElectronsName;
207
208	TString fFakingConversionsName;
209	TString fRemovedElectronsName;
210	TString fAllConversionElectronsName;
211
212	TH1F *hConversionRadius; //! Conversion radius
213	TH1F *hConversionRadiusBarrel; //! Conversion radius, barrel only
214	TH1F *hConversionZ; //!
215	TH2F *hConversionRPhi; //! conversion position in R-phi plane
216	TH2F *hConversionRZ; //!
217	TH2F *hConversionFoldedRZ; //!
218	TH1F *hGammaPt; //! photon pt
219	TH1F *hGammaEta; //! photon eta
220	TH1F *hGammaMass; //! photon mass
221	TH1F *hGammaPhi;//! photon phi
222	TH1F *hSimMatchedGammaMass; //!
223	TH1F *hConvProb; //! conversion vertex fit probability
224	TH1F *hConvChi2; //! conversion vertex fit chi squared
225	TH1F *hSimMatchedConvChi2; //!
226	TH1F *hConvDCotTheta;//!
227	TH1F *hConvDCotThetaPreCut;//!
228	TH1F *hConvEOverP; //! conversion E over P
229	TH1F *hElectronPt; //! pt of conversion electrons
230	TH1F *hMinElectronPt; //!
231	TH1F *hSimMinElectronPt; //!
232	TH1F *hSimMatchedMinElectronPt; //!
233	TH1F *hSimMatchedMinElectronSimPt; //!
234	TH1F *hElectronEta; //! eta of conversion electrons
235	TH1F *hEPairMass; //! invariant mass of electron track pair
236	TH1F *hEPairDeltaPhi; //! angle between electron momentum vectors
237	TH1F *hGenNumDaughters; //!
238	TH1F *hGenDaughterPt; //!
239	TH1F *hGenDecayRadius; //!
240	TH1F *hSimPt; //!
241	TH1F *hSimEta; //!
242	TH1F *hSimConvRadius; //!
243	TH2F *hSimConvPosition; //!
244	TH2F *hSimConversionRZ; //!
245	TH1F *hTrackSimMatchType; //!
246	TH1F *hParentSimMatchType; //!
247	TH1F *hSimMatchedConvRadius; //!
248	TH1F *hSimMatchedConvProb; //!
249	TH1F *hSimMatchedEPairMass; //!
250	TH1F *hSimMatchedEPairDeltaPhi; //!
251	TH1F *hSimMatchedSimConvRadius; //!
252	TH1F *hSimMatchedConvResolution; //!
253	TH1F *hSimMatchedConvPhiRes; //!
254	TH1F *hSimMatchedConvEOverP; //!
255	TH1F *hSimMatchedElectronPt; //!
256	TH1F *hSimMatchedGammaPt; //!
257	TH1F *hSimMatchedGammaEta; //!
258	TH1F *hSimMatchedSimGammaPt; //!
259	TH1F *hSimMatchedSimGammaEta; //!
260	TH1F *hTrackChi2;//!
261	TH1F *hTrackProb;//!
262	TH1F *hTrackNHits;//!
263	TH1F *hTrackNWrongHits;//!
264	TH1F *hTrackNMissingHits;//!
265	TH1F *hNSharedHits;//!
266	TH2F *hTrackNHitsProb;//!
267	TH1F *hTrackD0; //!
268	TH1F *hTrackDzPv; //!
269	TH1F *hUnMatchedTrackChi2;//!
270	TH1F *hUnMatchedTrackProb;//!
271	TH1F *hUnMatchedTrackNHits;//!
272	TH2F *hUnMatchedTrackNHitsProb;//!
273	TH1F *hUnMatchedTrackD0; //!
274	TH1F *hSimMatchedTrackChi2;//!
275	TH1F *hSimMatchedTrackProb;//!
276	TH1F *hSimMatchedTrackNHits;//!
277	TH2F *hSimMatchedTrackNHitsProb;//!
278	TH1F *hSimMatchedTrackD0; //!
279	TH1F *hLxy; //!
280	TH1F *hLxyOverLxyErr; //!
281	TH1F *hLz; //!
282	TH1F *hLzOverLzErr; //!
283	TH1F *hDxy;//!
284	TH1F *hSimMatchedLxy; //!
285	TH1F *hSimMatchedLz; //!
286	TH1F *hSimMatchedDxy;//!
287	TH1F *hNTracks; //!
288	TH1F *hSimMatchedNTracks; //!
289	TH1F *hIsolation;//!
290	TH1F *hSimMatchedIsolation; //!
291	TH1F *hNConversions; //!
292	TH1F *hDoubleConvMass; //!
293	TH1F *hConvGammaMass; //!
294	TH1F *hPiPiMass; //!
295
296	TH1F *hAllConversionElectronPt;
297	TH1F *hAllConversionElectronEta;
298	TH1F *hRemovedElectronPt;
299	TH1F *hRemovedElectronEta;
300
301	TH1F *hAllConversionElectronPtWrongCharge;
302	TH1F *hAllConversionElectronEtaWrongCharge;
303	TH1F *hRemovedElectronPtWrongCharge;
304	TH1F *hRemovedElectronEtaWrongCharge;
305
306	TH1F *hAllConversionElectronChargeAssign;
307	TH1F *hRemovedElectronChargeAssign;
308
309	TH1F *hTrackAlgo;
310
311	TH1F *hCharge;
312	TH2F *hPt1Pt2;
313
314	TH1F *hClusVtxDiff;
315	TH1F *hClusVtxQual;
316
317
318
319	ClassDef(ConversionRemoval,1)
320	};
321	}
322	#endif