ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/MitPhysics/Mods/interface/MuonIDMod.h

Comparing UserCode/MitPhysics/Mods/interface/MuonIDMod.h (file contents):
Revision 1.10 by loizides, Wed Dec 10 11:44:33 2008 UTC vs.
Revision 1.51 by fabstoec, Mon May 14 16:38:01 2012 UTC

#	Line 6 | Line 6
6		// This module applies muon identification criteria and exports a pointer to a collection
7		// of "good muons" according to the specified ID scheme.
8		//
9	+	// See http://indico.cern.ch/contributionDisplay.py?contribId=1&confId=45945
10	+	// See http://indico.cern.ch/getFile.py/access?contribId=1&resId=0&materialId=slides&confId=42229
11	+	//
12		// Authors: S.Xie
13		//--------------------------------------------------------------------------------------------------
14
#	Line 13 | Line 16
16		#define MITPHYSICS_MODS_MUONIDMOD_H
17
18		#include "MitAna/TreeMod/interface/BaseMod.h"
19	<	#include "MitAna/DataTree/interface/Collections.h"
19	>	#include "MitAna/DataTree/interface/MuonFwd.h"
20	>	#include "MitAna/DataTree/interface/VertexFwd.h"
21	>	#include "MitAna/DataTree/interface/TrackFwd.h"
22	>	#include "MitAna/DataTree/interface/PFCandidateFwd.h"
23		#include "MitPhysics/Utils/interface/MuonTools.h"
24	+	#include "MitPhysics/Utils/interface/MuonIDMVA.h"
25	+	#include "MitPhysics/Utils/interface/IsolationTools.h"
26	+	#include "MitAna/DataTree/interface/PileupEnergyDensityCol.h"
27	+
28	+	#include "MitPhysics/Utils/interface/RhoUtilities.h"
29
30		namespace mithep
31		{
#	Line 23 | Line 34 | namespace mithep
34		public:
35		MuonIDMod(const char *name="MuonIDMod",
36		const char *title="Muon identification module");
26	–	~MuonIDMod() {}
37
38	<	const char    *GetMuonBranchName(const char *name) const { return fMuonBranchName;    }
39	<	const char    *GetCleanMuonsName(const char *name) const { return fCleanMuonsName;    }
40	<	const char    *GetMuonIDType(const char *type)     const { return fMuonIDType;       }
41	<	const char    *GetMuonIsoType(const char *type)    const { return fMuonIsoType;      }
42	<	const char    *GetMuonClassType(const char *type)  const { return fMuonClassType;     }
43	<	Double_t       GetTrackIsolationCut(Double_t cut)  const { return fTrackIsolationCut; }
44	<	Double_t       GetCaloIsolationCut(Double_t cut)   const { return fCaloIsolationCut;  }
45	<	Double_t       GetCombIsolationCut(Double_t cut)   const { return fCombIsolationCut;  }
46	<	Double_t       GetMuonPtMin(Double_t pt)           const { return fMuonPtMin;         }
47	<	void           SetMuonBranchName(const char *name)       { fMuonBranchName    = name; }
48	<	void           SetCleanMuonsName(const char *name)       { fCleanMuonsName    = name; }
49	<	void           SetMuonIDType(const char *type)           { fMuonIDType       = type; }
50	<	void           SetMuonIsoType(const char *type)          { fMuonIsoType      = type; }
51	<	void           SetMuonClassType(const char *type)        { fMuonClassType     = type; }
52	<	void           SetTrackIsolationCut(Double_t cut)        { fTrackIsolationCut = cut;  }
53	<	void           SetCaloIsolationCut(Double_t cut)         { fCaloIsolationCut  = cut;  }
54	<	void           SetCombIsolationCut(Double_t cut)         { fCombIsolationCut  = cut;  }
55	<	void           SetMuonPtMin(Double_t pt)                 { fMuonPtMin         = pt;  }
38	>	Double_t           GetCaloIsoCut()                const { return fCaloIsolationCut;   }
39	>	const char        *GetClassType()                 const { return fMuonClassType;      }
40	>	const char        *GetCleanName()                 const { return GetCleanMuonsName(); }
41	>	const char        *GetCleanMuonsName()            const { return fCleanMuonsName;     }
42	>	Double_t           GetCombIsoCut()                const { return fCombIsolationCut;   }
43	>	const char        *GetIDType()                    const { return fMuonIDType;         }
44	>	const char        *GetInputName()                 const { return fMuonBranchName;     }
45	>	const char        *GetIsoType()                   const { return fMuonIsoType;        }
46	>	const char        *GetOutputName()                const { return GetCleanMuonsName(); }
47	>	Double_t           GetPtMin()                     const { return fMuonPtMin;          }
48	>	Double_t           GetTrackIsoCut()               const { return fTrackIsolationCut;  }
49	>	Bool_t             PassMuonMVA_BDTG_IdIso(const Muon *mu, const Vertex *vertex,
50	>	const PileupEnergyDensityCol *PileupEnergyDensity) const;
51	>	Bool_t             PassMuonIsoRingsV0_BDTG_Iso(const Muon *mu, const Vertex *vertex,
52	>	const PileupEnergyDensityCol *PileupEnergyDensity) const;
53	>	Bool_t             PassMuonIsoDeltaR(const Muon *mu, const Vertex *vertex,
54	>	const PileupEnergyDensityCol *PileupEnergyDensity) const;
55	>	void               SetPrintMVADebugInfo(Bool_t b)       { fPrintMVADebugInfo = b;     }
56	>	void               SetApplyD0Cut(Bool_t b)              { fApplyD0Cut        = b;     }
57	>	void               SetApplyDZCut(Bool_t b)              { fApplyDZCut        = b;     }
58	>	void               SetCaloIsoCut(Double_t cut)          { fCaloIsolationCut  = cut;   }
59	>	void               SetClassType(const char *type)       { fMuonClassType     = type;  }
60	>	void               SetCleanMuonsName(const char *name)  { fCleanMuonsName    = name;  }
61	>	void               SetOldMuonsName(const char *n)       { fNonIsolatedMuonsName  = n; }
62	>	void               SetOldElectronsName(const char *n)   { fNonIsolatedElectronsName  = n; }
63	>	void               SetCleanName(const char *name)       { SetCleanMuonsName(name);    }
64	>	void               SetCombIsoCut(Double_t cut)          { fCombIsolationCut  = cut;   }
65	>	void               SetCombRelativeIsoCut(Double_t cut)  { fCombRelativeIsolationCut  = cut; }
66	>	void               SetPFIsoCut(Double_t cut)            { fPFIsolationCut  = cut;     }
67	>	void               SetD0Cut(Double_t cut)               { fD0Cut             = cut;   }
68	>	void               SetDZCut(Double_t cut)               { fDZCut             = cut;   }
69	>	void               SetWhichVertex(Int_t d)              { fWhichVertex = d;           }
70	>	void               SetEtaCut(Double_t cut)              { fEtaCut            = cut;   }
71	>	void               SetIDType(const char *type)          { fMuonIDType        = type;  }
72	>	void               SetInputName(const char *name)       { fMuonBranchName    = name;  }
73	>	void               SetIsoType(const char *type)         { fMuonIsoType       = type;  }
74	>	void               SetOutputName(const char *name)      { SetCleanMuonsName(name);    }
75	>	void               SetPtMin(Double_t pt)                { fMuonPtMin         = pt;    }
76	>	void               SetTrackIsoCut(Double_t cut)         { fTrackIsolationCut = cut;   }
77	>	void               SetIntRadius(Double_t dr)            { fIntRadius = dr;            }
78	>
79	>	void               SetRhoType(RhoUtilities::RhoType type)
80	>	{ fTheRhoType = type; };
81	>
82	>	void               SetVertexName(const char* name) { fVertexName = name; }
83
84		enum EMuIdType {
85		kIdUndef = 0,       //not defined
86	+	kWMuId,             //"WMuId"
87	+	kZMuId,             //"ZMuId"
88		kTight,             //"Tight"
89		kLoose,             //"Loose"
90	<	kCustomId           //"Custom"
90	>	kWWMuIdV1,          //"WWMuIdV1"
91	>	kWWMuIdV2,          //"WWMuIdV2"
92	>	kWWMuIdV3,          //"WWMuIdV3"
93	>	kWWMuIdV4,          //"WWMuIdV4"
94	>	kNoId,              //"NoId"
95	>	kCustomId,          //"Custom"
96	>	kMVAID_BDTG_IDIso   //"BDTG ID + Iso03, Iso04 Combined"
97		};
98		enum EMuIsoType {
99	<	kIsoUndef = 0,      //not defined
100	<	kTrackCalo,         //"TrackCalo"
101	<	kTrackCaloCombined, //"TrackCaloCombined"
102	<	kTrackCaloSliding,  //"TrackCaloSliding"
103	<	kCustomIso,         //"Custom"
104	<	kNoIso              //"NoIso"
99	>	kIsoUndef = 0,                      //"not defined"
100	>	kTrackCalo,                         //"TrackCalo"
101	>	kTrackCaloCombined,                 //"TrackCaloCombined"
102	>	kTrackCaloSliding,                  //"TrackCaloSliding"
103	>	kTrackCaloSlidingNoCorrection,      //"TrackCaloSlidingNoCorrection"
104	>	kCombinedRelativeConeAreaCorrected, //"CombinedRelativeConeAreaCorrected"
105	>	kCombinedRelativeEffectiveAreaCorrected,
106	>	kCustomIso,                         //"Custom"
107	>	kPFIso,                             //"PFIso"
108	>	kPFRadialIso,                       //"PFRadialIso"
109	>	kPFIsoEffectiveAreaCorrected,       //"PFIso with EffectiveArea Pileup Correction"
110	>	kPFIsoNoL,                          //"PFIsoNoL"
111	>	kNoIso,                             //"NoIso"
112	>	kMVAIso_BDTG_IDIso,                 //"BDTG ID + Iso03, Iso04 Combined"
113	>	kIsoRingsV0_BDTG_Iso,               //"BDTG Iso Rings"
114	>	kIsoDeltaR                          //"BGDT Iso dR"
115		};
116		enum EMuClassType {
117		kClassUndef = 0,    //not defined
118		kAll,               //"All"
119		kGlobal,            //"Global"
120	+	kGlobalTracker,     //"GlobalTracker"
121		kSta,               //"Standalone"
122	<	kTrackerOnly        //"TrackerOnly"
122	>	kTrackerMuon,       //"TrackerMuon"
123	>	kCaloMuon,          //"CaloMuon"
124	>	kTrackerBased       //"TrackerMuon or CaloMuon"
125	>
126		};
127
128		protected:
129	<	void           Process();
130	<	void           SlaveBegin();
131	<
132	<	TString        fMuonBranchName;            //name of muon collection (in branch)
133	<	TString        fCleanMuonsName;            //name of exported "good muon" collection
134	<	TString        fMuonIDType;                //type of muon id scheme we impose
135	<	TString        fMuonIsoType;               //type of muon isolations scheme we impose
136	<	TString        fMuonClassType;             //type of muon class we impose
137	<	Double_t       fTrackIsolationCut;         //cut value for track isolation
138	<	Double_t       fCaloIsolationCut;          //cut value for calo isolation
139	<	Double_t       fCombIsolationCut;          //cut value for combined isolation
140	<	Double_t       fMuonPtMin;                 //min muon pt
141	<	const MuonCol *fMuons;                     //!muon branch
142	<	MuonTools     *fMuonTools;                 //!muon tool
143	<	EMuIdType      fMuIDType;                  //!muon id type (imposed)
144	<	EMuIsoType     fMuIsoType;                 //!muon iso type (imposed)
145	<	EMuClassType   fMuClassType;               //!muon class type (imposed)
146	<
147	<	ClassDef(MuonIDMod,1) // Muon identification module
129	>	void               Process();
130	>	void               SlaveBegin();
131	>	void               Terminate();
132	>
133	>	Bool_t             fPrintMVADebugInfo;   //print MVA debug information
134	>	TString            fMuonBranchName;      //name of muon collection (input)
135	>	TString            fCleanMuonsName;      //name of exported "good muon" collection
136	>	TString            fNonIsolatedMuonsName;    //name of imported "old muon" collection
137	>	TString            fNonIsolatedElectronsName;//name of imported "old electron" collection
138	>	TString            fVertexName;          //name of vertex collection
139	>	TString            fBeamSpotName;        //name of beamspot collection
140	>	TString            fTrackName;           //name of track collection
141	>	TString            fPFCandidatesName;    //name of pfcandidates collection
142	>	TString            fMuonIDType;          //type of muon id scheme we impose
143	>	TString            fMuonIsoType;         //type of muon isolations scheme we impose
144	>	TString            fMuonClassType;       //type of muon class we impose
145	>	Double_t           fTrackIsolationCut;   //cut value for track isolation
146	>	Double_t           fCaloIsolationCut;    //cut value for calo isolation
147	>	Double_t           fCombIsolationCut;    //cut value for combined isolation
148	>	Double_t           fCombRelativeIsolationCut; //cut value for combined relative isolation
149	>	Double_t           fPFIsolationCut;      //cut value for combined isolation
150	>	Double_t           fMuonPtMin;           //min muon pt
151	>	Bool_t             fApplyD0Cut;          //=true then apply d0 cut (def=1)
152	>	Bool_t             fApplyDZCut;          //=true then apply dz cut (def=1)
153	>	Double_t           fD0Cut;               //max d0
154	>	Double_t           fDZCut;               //max dz
155	>	Int_t              fWhichVertex;         //vertex to use (-2: beamspot, -1: closest in Z)
156	>	Double_t           fEtaCut;              //max eta, absolute value
157	>	EMuIdType          fMuIDType;            //!muon id type (imposed)
158	>	EMuIsoType         fMuIsoType;           //!muon iso type (imposed)
159	>	EMuClassType       fMuClassType;         //!muon class type (imposed)
160	>	const MuonCol     *fMuons;               //!muon collection
161	>	const VertexCol   *fVertices;            //!vertices branch
162	>	const BeamSpotCol *fBeamSpot;            //!beamspot branch
163	>	const TrackCol    *fTracks;              //!track branch
164	>	const PFCandidateCol *fPFCandidates;     //!pfcandidate branch
165	>	const PFCandidateCol *fPFNoPileUpCands;  //!pfnpu collection
166	>	Double_t           fIntRadius;           //!min IntRadius cut in pf isolation
167	>	MuonCol            *fNonIsolatedMuons;    //!pointer to old muon collection
168	>	ElectronCol        *fNonIsolatedElectrons;//!pointer to old electron collection
169	>	TString             fPileupEnergyDensityName;
170	>	const PileupEnergyDensityCol *fPileupEnergyDensity;
171	>	MuonTools          *fMuonTools;           // interface to tools for muon ID
172	>	MuonIDMVA          *fMuonIDMVA;           // helper class for MuonMVA
173	>
174	>	RhoUtilities::RhoType fTheRhoType;
175	>
176	>	ClassDef(MuonIDMod, 1) // Muon identification module
177		};
178		}
179		#endif

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines