ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/MitPhysics/Utils/src/JetIDMVA.cc

Comparing UserCode/MitPhysics/Utils/src/JetIDMVA.cc (file contents):
Revision 1.1 by pharris, Wed Mar 21 18:56:25 2012 UTC vs.
Revision 1.13 by bendavid, Tue May 29 16:55:43 2012 UTC

#	Line 1 | Line 1
1	+	#include "FWCore/PythonParameterSet/interface/MakeParameterSets.h"
2	+	#include "FWCore/ParameterSet/interface/ParameterSet.h"
3		#include "MitPhysics/Utils/interface/JetIDMVA.h"
4		#include "MitPhysics/Utils/interface/JetTools.h"
5		#include "MitAna/DataTree/interface/StableData.h"
#	Line 13 | Line 15 | using namespace mithep;
15
16		//--------------------------------------------------------------------------------------------------
17		JetIDMVA::JetIDMVA() :
18	<	fMethodName("JetIDMA"),
18	>	fJetPtMin(0.)  , //We need to lower this
19	>	fDZCut   (0.2),
20	>	fLowPtMethodName ("JetIDMVALowPt" ),
21	>	fHighPtMethodName("JetIDMVAHighPt"),
22		fIsInitialized(kFALSE),
23	<	fJetPtMin(10), //We need to lower this
24	<	fNPV    (0),
25	<	fJPt1   (0),
26	<	fJEta1  (0),
27	<	fJPhi1  (0),
28	<	fJD01   (0),
29	<	fJDZ1   (0),
30	<	fJM1    (0),
31	<	fNPart1 (0),
32	<	fLPt1   (0),
33	<	fLEta1  (0),
34	<	fLPhi1  (0),
35	<	fSPt1   (0),
36	<	fSEta1  (0),
37	<	fSPhi1  (0),
38	<	fNEPt1  (0),
39	<	fNEEta1 (0),
35	<	fNEPhi1 (0),
36	<	fEMPt1  (0),
37	<	fEMEta1 (0),
38	<	fEMPhi1 (0),
39	<	fChPt1  (0),
40	<	fChPhi1 (0),
41	<	fLFr1   (0),
42	<	fDRLC1  (0),
43	<	fDRLS1  (0),
44	<	fDRM1   (0),
45	<	fDRNE1  (0),
46	<	fDREM1  (0),
47	<	fDRCH1  (0)
23	>	fNVtx     (0),
24	>	fJPt1     (0),
25	>	fJEta1    (0),
26	>	fJPhi1    (0),
27	>	fJD01     (0),
28	>	fJDZ1     (0),
29	>	fBeta     (0),
30	>	fBetaStar (0),
31	>	fNCharged (0),
32	>	fNNeutrals(0),
33	>	fDRMean   (0),
34	>	fFrac01   (0),
35	>	fFrac02   (0),
36	>	fFrac03   (0),
37	>	fFrac04   (0),
38	>	fFrac05   (0),
39	>	fDR2Mean  (0)
40		{
41		fReader = 0;
42		}
43		//--------------------------------------------------------------------------------------------------
44	<	JetIDMVA::~JetIDMVA()
45	<	{
46	<	fReader = 0;
44	>	JetIDMVA::~JetIDMVA() {
45	>
46	>	delete fReader;
47	>	delete fLowPtReader;
48		}
49
50		//--------------------------------------------------------------------------------------------------
51	<	void JetIDMVA::Initialize( TString iMethodName,
52	<	TString iWeights,
53	<	JetIDMVA::MVAType iType)
51	>	void JetIDMVA::Initialize( JetIDMVA::CutType iCutType,
52	>	TString iLowPtWeights,
53	>	TString iHighPtWeights,
54	>	JetIDMVA::MVAType iType,
55	>	TString iCutFileName)
56		{
57
58		fIsInitialized = kTRUE;
64	–	fMethodName    = iMethodName;
59		fType          = iType;
60	+	fCutType       = iCutType;
61	+	fLowPtReader   = 0;
62	+	fLowPtReader   = new TMVA::Reader( "!Color:!Silent:Error" );
63	+	fLowPtReader->AddVariable( "nvtx"     , &fNVtx      );
64	+	fLowPtReader->AddVariable( "jetPt"    , &fJPt1      );
65	+	fLowPtReader->AddVariable( "jetEta"   , &fJEta1     );
66	+	fLowPtReader->AddVariable( "jetPhi"   , &fJPhi1     );
67	+	fLowPtReader->AddVariable( "dZ"       , &fJDZ1      );
68	+	fLowPtReader->AddVariable( "d0"       , &fJD01      );
69	+	fLowPtReader->AddVariable( "beta"     , &fBeta      );
70	+	fLowPtReader->AddVariable( "betaStar" , &fBetaStar  );
71	+	fLowPtReader->AddVariable( "nCharged" , &fNCharged  );
72	+	fLowPtReader->AddVariable( "nNeutrals", &fNNeutrals );
73	+	fLowPtReader->AddVariable( "dRMean"   , &fDRMean    );
74	+	fLowPtReader->AddVariable( "frac01"   , &fFrac01    );
75	+	fLowPtReader->AddVariable( "frac02"   , &fFrac02    );
76	+	fLowPtReader->AddVariable( "frac03"   , &fFrac03    );
77	+	fLowPtReader->AddVariable( "frac04"   , &fFrac04    );
78	+	fLowPtReader->AddVariable( "frac05"   , &fFrac05    );
79	+
80		fReader        = 0;
81		fReader        = new TMVA::Reader( "!Color:!Silent:Error" );
82		if (fType == kBaseline) {
83	<	fReader->AddSpectator( "npv"     , &fNPV    );
84	<	fReader->AddVariable( "jspt_1"   , &fJPt1   );
85	<	fReader->AddVariable( "jseta_1"  , &fJEta1  );
86	<	fReader->AddVariable( "jsphi_1"  , &fJPhi1  );
87	<	fReader->AddVariable( "jd0_1"    , &fJD01   );
88	<	fReader->AddVariable( "jdZ_1"    , &fJDZ1   );
89	<	fReader->AddVariable( "jm_1"     , &fJM1    );
90	<	fReader->AddVariable( "npart_1"  , &fNPart1 );
91	<	fReader->AddVariable( "lpt_1"    , &fLPt1   );
92	<	fReader->AddVariable( "leta_1"   , &fLEta1  );
93	<	fReader->AddVariable( "lphi_1"   , &fLPhi1  );
94	<	fReader->AddVariable( "spt_1"    , &fSPt1   );
95	<	fReader->AddVariable( "seta_1"   , &fSEta1  );
96	<	fReader->AddVariable( "sphi_1"   , &fSPhi1  );
97	<	fReader->AddVariable( "lnept_1"  , &fNEPt1  );
98	<	fReader->AddVariable( "lneeta_1" , &fNEEta1 );
85	<	fReader->AddVariable( "lnephi_1" , &fNEPhi1 );
86	<	fReader->AddVariable( "lempt_1"  , &fEMPt1  );
87	<	fReader->AddVariable( "lemeta_1" , &fEMEta1 );
88	<	fReader->AddVariable( "lemphi_1" , &fEMPhi1 );
89	<	fReader->AddVariable( "lchpt_1"  , &fChPt1  );
90	<	fReader->AddVariable( "lchphi_1" , &fChPhi1 );
91	<	fReader->AddVariable( "lLfr_1"   , &fLFr1   );
92	<	fReader->AddVariable( "drlc_1"   , &fDRLC1  );
93	<	fReader->AddVariable( "drls_1"   , &fDRLS1  );
94	<	fReader->AddVariable( "drm_1"    , &fDRM1   );
95	<	fReader->AddVariable( "drmne_1"  , &fDRNE1  );
96	<	fReader->AddVariable( "drem_1"   , &fDREM1  );
97	<	fReader->AddVariable( "drch_1"   , &fDRCH1  );
83	>	fReader->AddVariable( "nvtx"     , &fNVtx      );
84	>	fReader->AddVariable( "jetPt"    , &fJPt1      );
85	>	fReader->AddVariable( "jetEta"   , &fJEta1     );
86	>	fReader->AddVariable( "jetPhi"   , &fJPhi1     );
87	>	fReader->AddVariable( "dZ"       , &fJDZ1      );
88	>	fReader->AddVariable( "d0"       , &fJD01      );
89	>	fReader->AddVariable( "beta"     , &fBeta      );
90	>	fReader->AddVariable( "betaStar" , &fBetaStar  );
91	>	fReader->AddVariable( "nCharged" , &fNCharged  );
92	>	fReader->AddVariable( "nNeutrals", &fNNeutrals );
93	>	fReader->AddVariable( "dRMean"   , &fDRMean    );
94	>	fReader->AddVariable( "frac01"   , &fFrac01    );
95	>	fReader->AddVariable( "frac02"   , &fFrac02    );
96	>	fReader->AddVariable( "frac03"   , &fFrac03    );
97	>	fReader->AddVariable( "frac04"   , &fFrac04    );
98	>	fReader->AddVariable( "frac05"   , &fFrac05    );
99		}
100	<	fReader->BookMVA(fMethodName , iWeights );
100	>	if (fType == k42) {
101	>	fReader->AddVariable( "frac01"   , &fFrac01    );
102	>	fReader->AddVariable( "frac02"   , &fFrac02    );
103	>	fReader->AddVariable( "frac03"   , &fFrac03    );
104	>	fReader->AddVariable( "frac04"   , &fFrac04    );
105	>	fReader->AddVariable( "frac05"   , &fFrac05    );
106	>	fReader->AddVariable( "nvtx"     , &fNVtx      );
107	>	fReader->AddVariable( "nNeutrals", &fNNeutrals );
108	>	fReader->AddVariable( "beta"     , &fBeta      );
109	>	fReader->AddVariable( "betaStar" , &fBetaStar  );
110	>	fReader->AddVariable( "dZ"       , &fJDZ1      );
111	>	fReader->AddVariable( "nCharged" , &fNCharged  );
112	>	fReader->AddSpectator( "jetPt"    , &fJPt1      );
113	>	fReader->AddSpectator( "jetEta"   , &fJEta1     );
114	>	}
115	>	if (fType == k52) {
116	>	fReader->AddVariable( "frac01"   , &fFrac01    );
117	>	fReader->AddVariable( "frac02"   , &fFrac02    );
118	>	fReader->AddVariable( "frac03"   , &fFrac03    );
119	>	fReader->AddVariable( "frac04"   , &fFrac04    );
120	>	fReader->AddVariable( "frac05"   , &fFrac05    );
121	>	fReader->AddVariable( "dR2Mean"  , &fDR2Mean   );
122	>	fReader->AddVariable( "nvtx"     , &fNVtx      );
123	>	fReader->AddVariable( "nNeutrals", &fNNeutrals );
124	>	fReader->AddVariable( "beta"     , &fBeta      );
125	>	fReader->AddVariable( "betaStar" , &fBetaStar  );
126	>	fReader->AddVariable( "dZ"       , &fJDZ1      );
127	>	fReader->AddVariable( "nCharged" , &fNCharged  );
128	>	fReader->AddSpectator( "jetPt"    , &fJPt1      );
129	>	fReader->AddSpectator( "jetEta"   , &fJEta1     );
130	>	}
131	>
132	>	fLowPtReader->BookMVA(fLowPtMethodName  , iLowPtWeights );
133	>	fReader->BookMVA(fHighPtMethodName , iHighPtWeights );
134		std::cout << "Jet ID MVA Initialization\n";
135	<	std::cout << "MethodName : " << fMethodName << " , type == " << fType << std::endl;
135	>	std::cout << "MethodName : " << fLowPtMethodName << " , type == " << fType << std::endl;
136	>
137	>	std::string lCutId = "JetIdParams";
138	>	if(fType == k42)  lCutId = "PuJetIdOptMVA_wp";
139	>	if(fType == k52)  lCutId = "full_5x_wp";
140	>	if(fType == kCut) lCutId = "PuJetIdCutBased_wp";
141	>	//Load Cut Matrix
142	>	edm::ParameterSet lDefConfig = edm::readPSetsFrom(iCutFileName.Data())->getParameter<edm::ParameterSet>("JetIdParams");
143	>	edm::ParameterSet lConfig    = edm::readPSetsFrom(iCutFileName.Data())->getParameter<edm::ParameterSet>(lCutId);
144	>	std::string lCutType = "Tight";
145	>	if(fCutType == kMedium) lCutType = "Medium";
146	>	if(fCutType == kLoose ) lCutType = "Loose";
147	>	if(fCutType == kMET   ) lCutType = "MET";
148	>	if(fType != kCut) {
149	>	std::string lLowPtCut = "MET";
150	>	std::vector<double> lPt010  = lDefConfig.getParameter<std::vector<double> >(("Pt010_" +lLowPtCut).c_str());
151	>	std::vector<double> lPt1020 = lConfig.getParameter<std::vector<double> >(("Pt1020_"+lCutType).c_str());
152	>	std::vector<double> lPt2030 = lConfig.getParameter<std::vector<double> >(("Pt2030_"+lCutType).c_str());
153	>	std::vector<double> lPt3050 = lConfig.getParameter<std::vector<double> >(("Pt3050_"+lCutType).c_str());
154	>	for(int i0 = 0; i0 < 4; i0++) fMVACut[0][i0] = lPt010 [i0];
155	>	for(int i0 = 0; i0 < 4; i0++) fMVACut[1][i0] = lPt1020[i0];
156	>	for(int i0 = 0; i0 < 4; i0++) fMVACut[2][i0] = lPt2030[i0];
157	>	for(int i0 = 0; i0 < 4; i0++) fMVACut[3][i0] = lPt3050[i0];
158	>	}
159	>	if(fType == kCut) {
160	>	for(int i0 = 0; i0 < 2; i0++) {
161	>	std::string lFullCutType = lCutType;
162	>	if(i0 == 0) lFullCutType = "BetaStar"+ lCutType;
163	>	if(i0 == 1) lFullCutType = "RMS"     + lCutType;
164	>	std::vector<double> pt010  = lConfig.getParameter<std::vector<double> >(("Pt010_" +lFullCutType).c_str());
165	>	std::vector<double> pt1020 = lConfig.getParameter<std::vector<double> >(("Pt1020_"+lFullCutType).c_str());
166	>	std::vector<double> pt2030 = lConfig.getParameter<std::vector<double> >(("Pt2030_"+lFullCutType).c_str());
167	>	std::vector<double> pt3050 = lConfig.getParameter<std::vector<double> >(("Pt3050_"+lFullCutType).c_str());
168	>	if(i0 == 0) {
169	>	for(int i2 = 0; i2 < 4; i2++) fBetaStarCut[0][i2] = pt010 [i2];
170	>	for(int i2 = 0; i2 < 4; i2++) fBetaStarCut[1][i2] = pt1020[i2];
171	>	for(int i2 = 0; i2 < 4; i2++) fBetaStarCut[2][i2] = pt2030[i2];
172	>	for(int i2 = 0; i2 < 4; i2++) fBetaStarCut[3][i2] = pt3050[i2];
173	>	}
174	>	if(i0 == 1) {
175	>	for(int i2 = 0; i2 < 4; i2++) fRMSCut[0][i2] = pt010 [i2];
176	>	for(int i2 = 0; i2 < 4; i2++) fRMSCut[1][i2] = pt1020[i2];
177	>	for(int i2 = 0; i2 < 4; i2++) fRMSCut[2][i2] = pt2030[i2];
178	>	for(int i2 = 0; i2 < 4; i2++) fRMSCut[3][i2] = pt3050[i2];
179	>	}
180	>	}
181	>	}
182		}
183
184		//--------------------------------------------------------------------------------------------------
#	Line 109 | Line 189 | Double_t JetIDMVA::MVAValue(
189		Float_t iJPhi1  ,
190		Float_t iJD01   ,
191		Float_t iJDZ1   ,
192	<	Float_t iJM1    ,
193	<	Float_t iNPart1 ,
194	<	Float_t iLPt1   ,
195	<	Float_t iLEta1  ,
196	<	Float_t iLPhi1  ,
197	<	Float_t iSPt1   ,
198	<	Float_t iSEta1  ,
199	<	Float_t iSPhi1  ,
200	<	Float_t iNEPt1  ,
201	<	Float_t iNEEta1 ,
202	<	Float_t iNEPhi1 ,
123	<	Float_t iEMPt1  ,
124	<	Float_t iEMEta1 ,
125	<	Float_t iEMPhi1 ,
126	<	Float_t iChPt1  ,
127	<	Float_t iChPhi1 ,
128	<	Float_t iLFr1   ,
129	<	Float_t iDRLC1  ,
130	<	Float_t iDRLS1  ,
131	<	Float_t iDRM1   ,
132	<	Float_t iDRNE1 ,
133	<	Float_t iDREM1  ,
134	<	Float_t iDRCH1
192	>	Float_t iBeta   ,
193	>	Float_t iBetaStar,
194	>	Float_t iNCharged,
195	>	Float_t iNNeutrals,
196	>	Float_t iDRMean  ,
197	>	Float_t iFrac01  ,
198	>	Float_t iFrac02  ,
199	>	Float_t iFrac03  ,
200	>	Float_t iFrac04  ,
201	>	Float_t iFrac05  ,
202	>	Float_t iDR2Mean
203		){
204
205	<	if (!fIsInitialized) {
205	>	if(!fIsInitialized) {
206		std::cout << "Error: JetIDMVA not properly initialized.\n";
207		return -9999;
208		}
209
210	<	fNPV    = iNPV;
211	<	fJPt1   = iJPt1;
212	<	fJEta1  = iJEta1;
213	<	fJPhi1  = fJPhi1;
214	<	fJD01   = iJD01;
215	<	fJDZ1   = iJDZ1;
216	<	fJM1    = iJM1 ;
217	<	fNPart1 = iNPart1;
218	<	fLPt1   = iLPt1;
219	<	fLEta1  = iLEta1;
220	<	fLPhi1  = iLPhi1;
221	<	fSPt1   = iSPt1;
222	<	fSEta1  = iSEta1;
223	<	fSPhi1  = iSPhi1;
224	<	fNEPt1  = iNEPt1;
225	<	fNEEta1 = iNEEta1;
226	<	fNEPhi1 = iNEPhi1;
159	<	fEMPt1  = iEMPt1;
160	<	fEMEta1 = iEMEta1;
161	<	fEMPhi1 = iEMPhi1;
162	<	fChPt1  = iChPt1;
163	<	fChPhi1 = iChPhi1;
164	<	fLFr1   = iLFr1;
165	<	fDRLC1  = iDRLC1;
166	<	fDRLS1  = iDRLS1;
167	<	fDRM1   = iDRM1;
168	<	fDRNE1  = iDRNE1;
169	<	fDREM1  = iDREM1;
170	<	fDRCH1  = iDRCH1;
210	>	fNVtx      = iNPV;
211	>	fJPt1      = iJPt1;
212	>	fJEta1     = iJEta1;
213	>	fJPhi1     = fJPhi1;
214	>	fJD01      = iJD01;
215	>	fJDZ1      = iJDZ1;
216	>	fBeta      = iBeta;
217	>	fBetaStar  = iBetaStar;
218	>	fNCharged  = iNCharged;
219	>	fNNeutrals = iNNeutrals;
220	>	fDRMean    = iDRMean;
221	>	fFrac01    = iFrac01;
222	>	fFrac02    = iFrac02;
223	>	fFrac03    = iFrac03;
224	>	fFrac04    = iFrac04;
225	>	fFrac05    = iFrac05;
226	>	fDR2Mean   = iDR2Mean;
227
228		Double_t lMVA = -9999;
229	<	lMVA = fReader->EvaluateMVA( fMethodName );
229	>	if(iJPt1 < 10) lMVA = fLowPtReader->EvaluateMVA( fLowPtMethodName  );
230	>	if(iJPt1 > 10) lMVA = fReader->EvaluateMVA( fHighPtMethodName );
231
232		return lMVA;
233		}
234		//--------------------------------------------------------------------------------------------------
235	<	Bool_t JetIDMVA::pass(const PFJet *iJet,const Vertex *iVertex,
235	>	Bool_t JetIDMVA::pass(const PFJet *iJet,const Vertex *iVertex,const VertexCol *iVertices,
236		FactorizedJetCorrector *iJetCorrector,
237	<	const PileupEnergyDensityCol *iPileupEnergyDensity) {
237	>	const PileupEnergyDensityCol *iPileupEnergyDensity,
238	>	RhoUtilities::RhoType type) {
239	>
240	>	if(!JetTools::passPFLooseId(iJet))                 return false;
241	>	if(fabs(iJet->Eta()) > 4.99)                       return false;
242	>
243	>	double lMVA = MVAValue   (iJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity);
244	>	double lPt  = correctedPt(iJet,                  iJetCorrector,iPileupEnergyDensity,type);
245	>	if(lPt < fJetPtMin)                         return false;
246	>
247	>	int lPtId = 0;
248	>	if(lPt > 10 && lPt < 20) lPtId = 1;
249	>	if(lPt > 20 && lPt < 30) lPtId = 2;
250	>	if(lPt > 30                   ) lPtId = 3;
251	>
252	>	int lEtaId = 0;
253	>	if(fabs(iJet->Eta()) > 2.5  && fabs(iJet->Eta()) < 2.75) lEtaId = 1;
254	>	if(fabs(iJet->Eta()) > 2.75 && fabs(iJet->Eta()) < 3.0 ) lEtaId = 2;
255	>	if(fabs(iJet->Eta()) > 3.0  && fabs(iJet->Eta()) < 5.0 ) lEtaId = 3;
256	>
257	>	double lMVACut = fMVACut[lPtId][lEtaId];
258	>	if(lMVA < lMVACut) return false;
259	>	return true;
260	>	}
261	>	//--------------------------------------------------------------------------------------------------
262	>	Bool_t JetIDMVA::passCut(const PFJet *iJet,const Vertex *iVertex,const VertexCol *iVertices) {
263	>	if(!JetTools::passPFLooseId(iJet))                 return false;
264	>	if(iJet->Pt()        < fJetPtMin) return false;
265	>	if(fabs(iJet->Eta()) > 4.99)      return false;
266	>	//if(fType == kCut) passCut(iJet,iVertex,iVertices);
267	>
268	>	double lPt = iJet->Pt();
269	>	int lPtId = 0;
270	>	if(lPt > 10 && lPt < 20) lPtId = 1;
271	>	if(lPt > 20 && lPt < 30) lPtId = 2;
272	>	if(lPt > 30                   ) lPtId = 3;
273	>
274	>	int lEtaId = 0;
275	>	if(fabs(iJet->Eta()) > 2.5  && fabs(iJet->Eta()) < 2.75) lEtaId = 1;
276	>	if(fabs(iJet->Eta()) > 2.75 && fabs(iJet->Eta()) < 3.0 ) lEtaId = 2;
277	>	if(fabs(iJet->Eta()) > 3.0  && fabs(iJet->Eta()) < 5.0 ) lEtaId = 3;
278	>	float betaStarModified = JetTools::betaStarClassic(iJet,iVertex,iVertices)/log(iVertices ->GetEntries()-0.64);
279	>	float dR2Mean          = JetTools::dR2Mean(iJet,-1);
280	>
281	>	if(betaStarModified < fBetaStarCut[lPtId][lEtaId] &&
282	>	dR2Mean          < fRMSCut     [lPtId][lEtaId]
283	>	) return true;
284	>
285	>	return false;
286	>	}
287	>	//--------------------------------------------------------------------------------------------------
288	>	Bool_t JetIDMVA::pass(const PFJet *iJet,const Vertex *iVertex,const VertexCol *iVertices) {
289		if(!JetTools::passPFLooseId(iJet))                 return false;
290	<	if(correctedPt(iJet,iJetCorrector,iPileupEnergyDensity) < fJetPtMin && iJet->TrackCountingHighEffBJetTagsDisc() == -100) return false; //This line is a bug in the Met training
291	<	if( fabs(JetTools::impactParameter(iJet,iVertex,true)) < 0.2) return true;
292	<	double lMVA = MVAValue(iJet,iVertex,iJetCorrector,iPileupEnergyDensity);
293	<	if(lMVA < -0.8)                            return false;
294	<	if(lMVA < -0.5 && fabs(iJet->Eta()) > 3.0) return false;
290	>	if(iJet->Pt()        < fJetPtMin) return false;
291	>	if(fabs(iJet->Eta()) > 4.99)      return false;
292	>	if(fType == kCut) return passCut(iJet,iVertex,iVertices);
293	>	double lMVA = MVAValue(iJet,iVertex,iVertices);
294	>
295	>	int lPtId = 0;
296	>	if(iJet->Pt() > 10 && iJet->Pt() < 20) lPtId = 1;
297	>	if(iJet->Pt() > 20 && iJet->Pt() < 30) lPtId = 2;
298	>	if(iJet->Pt() > 30                   ) lPtId = 3;
299	>
300	>	int lEtaId = 0;
301	>	if(fabs(iJet->Eta()) > 2.5  && fabs(iJet->Eta()) < 2.75) lEtaId = 1;
302	>	if(fabs(iJet->Eta()) > 2.75 && fabs(iJet->Eta()) < 3.0 ) lEtaId = 2;
303	>	if(fabs(iJet->Eta()) > 3.0  && fabs(iJet->Eta()) < 5.0 ) lEtaId = 3;
304	>
305	>	double lMVACut = fMVACut[lPtId][lEtaId];
306	>	if(lMVA < lMVACut) return false;
307		return true;
308	+	//if(lMVA < -0.8)                            return false;
309	+	//if(lMVA < -0.5 && fabs(iJet->Eta()) > 3.0) return false;
310	+	//if(iJet->Pt() < fJetPtMin && iJet->TrackCountingHighEffBJetTagsDisc() == -100) return false; //This line is a bug in the Met training
311	+	//if( fabs(JetTools::impactParameter(iJet,iVertex,true)) < 0.2) return true;
312		}
313		//--------------------------------------------------------------------------------------------------
314	<	Double_t JetIDMVA::MVAValue(const PFJet *iJet,const Vertex *iVertex, //Vertex here is the PV
314	>	Double_t JetIDMVA::MVAValue(const PFJet *iJet,const Vertex *iVertex,const VertexCol *iVertices, //Vertex here is the PV
315		FactorizedJetCorrector *iJetCorrector,
316		const PileupEnergyDensityCol *iPileupEnergyDensity,
317		Bool_t printDebug) {
#	Line 199 | Line 323 | Double_t JetIDMVA::MVAValue(const PFJet
323		if(!JetTools::passPFLooseId(iJet)) return -2.;
324
325		//set all input variables
326	+	fNVtx      = iVertices->GetEntries();
327		fJPt1      = correctedPt(iJet,iJetCorrector,iPileupEnergyDensity);
328		fJEta1     = iJet->RawMom().Eta();
329		fJPhi1     = iJet->RawMom().Phi();
330	<	fJM1       = iJet->Mass();
330	>	fJD01      = JetTools::impactParameter(iJet,iVertex);
331	>	fJDZ1      = JetTools::impactParameter(iJet,iVertex,true);
332	>	fBeta      = JetTools::Beta(iJet,iVertex,fDZCut);
333	>	fBetaStar  = JetTools::betaStar(iJet,iVertex,iVertices,fDZCut);
334	>	fNCharged  = iJet->ChargedMultiplicity();
335	>	fNNeutrals = iJet->NeutralMultiplicity();
336	>
337	>	fDRMean    = JetTools::dRMean(iJet,-1);
338	>	fDR2Mean   = JetTools::dR2Mean(iJet,-1);
339	>	fFrac01    = JetTools::frac  (iJet,0.1,0. ,-1);
340	>	fFrac02    = JetTools::frac  (iJet,0.2,0.1,-1);
341	>	fFrac03    = JetTools::frac  (iJet,0.3,0.2,-1);
342	>	fFrac04    = JetTools::frac  (iJet,0.4,0.3,-1);
343	>	fFrac05    = JetTools::frac  (iJet,0.5,0.4,-1);
344	>
345	>	double lMVA = 0;
346	>	if(fJPt1 < 10) lMVA = fLowPtReader->EvaluateMVA( fLowPtMethodName  );
347	>	if(fJPt1 > 10) lMVA = fReader->EvaluateMVA( fHighPtMethodName );
348	>	if (printDebug == kTRUE) {
349	>	std::cout << "Debug Jet MVA: "
350	>	<< fNVtx      << " "
351	>	<< fJPt1      << " "
352	>	<< fJEta1     << " "
353	>	<< fJPhi1     << " "
354	>	<< fJD01      << " "
355	>	<< fJDZ1      << " "
356	>	<< fBeta      << " "
357	>	<< fBetaStar  << " "
358	>	<< fNCharged  << " "
359	>	<< fNNeutrals << " "
360	>	<< fDRMean    << " "
361	>	<< fFrac01    << " "
362	>	<< fFrac02    << " "
363	>	<< fFrac03    << " "
364	>	<< fFrac04    << " "
365	>	<< fFrac05    << " "
366	>	<< fDRMean
367	>	<< " === : === "
368	>	<< lMVA << " "
369	>	<< std::endl;
370	>	}
371
372	<	const mithep::PFCandidate *lLead     = JetTools::leadCand(iJet,-1);
373	<	const mithep::PFCandidate *lSecond   = JetTools::leadCand(iJet,-1,true);
374	<	const mithep::PFCandidate *lLeadNeut = JetTools::leadCand(iJet ,5);
375	<	const mithep::PFCandidate *lLeadEm   = JetTools::leadCand(iJet ,4);
376	<	const mithep::PFCandidate *lLeadCh   = JetTools::leadCand(iJet ,1);
377	<
378	<	fJD01         = JetTools::impactParameter(iJet,iVertex);
379	<	fJDZ1         = JetTools::impactParameter(iJet,iVertex,true);
380	<	fNPart1       = iJet->NPFCands();
381	<	fLPt1         = lLead    ->Pt();
217	<	fLEta1        = lLead    ->Eta();
218	<	fLPhi1        = lLead    ->Phi();
219	<	fSPt1         = lSecond  ->Pt();
220	<	fSEta1        = lSecond  ->Eta();
221	<	fSPhi1        = lSecond  ->Phi();
222	<	fNEPt1        = lLeadNeut->Pt();
223	<	fNEEta1       = lLeadNeut->Eta();
224	<	fNEPhi1       = lLeadNeut->Phi();
225	<	fEMPt1        = lLeadEm  ->Pt();
226	<	fEMEta1       = lLeadEm  ->Eta();
227	<	fEMPhi1       = lLeadEm  ->Phi();
228	<	fChPt1        = lLeadCh  ->Pt();
229	<	//fChEta1       = lLeadCh  ->Eta();
230	<	fChPhi1       = lLeadCh  ->Phi();
231	<	fLFr1         = lLead->Pt()/iJet->Pt();
232	<
233	<	fDRLC1        = MathUtils::DeltaR(iJet->Mom(),lLead  ->Mom());
234	<	fDRLS1        = MathUtils::DeltaR(iJet->Mom(),lSecond->Mom());
235	<	fDRM1         = JetTools::dRMean (iJet,-1);
236	<	fDRNE1        = JetTools::dRMean (iJet, 5);
237	<	fDREM1        = JetTools::dRMean (iJet, 4);
238	<	fDRCH1        = JetTools::dRMean (iJet, 1);
372	>	return lMVA;
373	>	}
374	>	Double_t JetIDMVA::MVAValue(const PFJet *iJet,const Vertex *iVertex, const VertexCol *iVertices,//Vertex here is the PV
375	>	Bool_t printDebug) {
376	>
377	>	if (!fIsInitialized) {
378	>	std::cout << "Error: JetIDMVA not properly initialized.\n";
379	>	return -9999;
380	>	}
381	>	if(!JetTools::passPFLooseId(iJet)) return -2.;
382
383	<	double lMVA = fReader->EvaluateMVA( fMethodName );
384	<
383	>	//set all input variables
384	>	fNVtx      = iVertices->GetEntries();
385	>	fJPt1      = iJet->Pt();
386	>	fJEta1     = iJet->RawMom().Eta();
387	>	fJPhi1     = iJet->RawMom().Phi();
388	>	fJD01      = JetTools::impactParameter(iJet,iVertex);
389	>	fJDZ1      = JetTools::impactParameter(iJet,iVertex,true);
390	>	fBeta      = JetTools::Beta(iJet,iVertex,fDZCut);
391	>	fBetaStar  = JetTools::betaStar(iJet,iVertex,iVertices,fDZCut);
392	>	fNCharged  = iJet->ChargedMultiplicity();
393	>	fNNeutrals = iJet->NeutralMultiplicity();
394	>
395	>	fDRMean    = JetTools::dRMean (iJet,-1);
396	>	fDR2Mean   = JetTools::dR2Mean(iJet,-1);
397	>	fFrac01    = JetTools::frac   (iJet,0.1,0. ,-1);
398	>	fFrac02    = JetTools::frac   (iJet,0.2,0.1,-1);
399	>	fFrac03    = JetTools::frac   (iJet,0.3,0.2,-1);
400	>	fFrac04    = JetTools::frac   (iJet,0.4,0.3,-1);
401	>	fFrac05    = JetTools::frac   (iJet,0.5,0.4,-1);
402	>
403	>	double lMVA = 0;
404	>	if(fJPt1 < 10) lMVA = fLowPtReader->EvaluateMVA( fLowPtMethodName  );
405	>	if(fJPt1 > 10) lMVA = fReader     ->EvaluateMVA( fHighPtMethodName );
406	>
407		if (printDebug == kTRUE) {
408		std::cout << "Debug Jet MVA: "
409	<	<< fNPV    << " "
410	<	<< fJPt1   << " "
411	<	<< fJEta1  << " "
412	<	<< fJPhi1  << " "
413	<	<< fJD01   << " "
414	<	<< fJDZ1   << " "
415	<	<< fJM1    << " "
416	<	<< fNPart1 << " "
417	<	<< fLPt1   << " "
418	<	<< fLEta1  << " "
419	<	<< fLPhi1  << " "
420	<	<< fSPt1   << " "
421	<	<< fSEta1  << " "
422	<	<< fSPhi1  << " "
423	<	<< fNEPt1  << " "
424	<	<< fNEEta1 << " "
425	<	<< fNEPhi1 << " "
261	<	<< fEMPt1  << " "
262	<	<< fEMEta1 << " "
263	<	<< fEMPhi1 << " "
264	<	<< fChPt1  << " "
265	<	<< fChPhi1 << " "
266	<	<< fLFr1   << " "
267	<	<< fDRLC1  << " "
268	<	<< fDRLS1  << " "
269	<	<< fDRM1   << " "
270	<	<< fDRNE1 << " "
271	<	<< fDREM1  << " "
272	<	<< fDRCH1  << " "
409	>	<< fNVtx      << " "
410	>	<< fJPt1      << " "
411	>	<< fJEta1     << " "
412	>	<< fJPhi1     << " "
413	>	<< fJD01      << " "
414	>	<< fJDZ1      << " "
415	>	<< fBeta      << " "
416	>	<< fBetaStar  << " "
417	>	<< fNCharged  << " "
418	>	<< fNNeutrals << " "
419	>	<< fDRMean    << " "
420	>	<< fFrac01    << " "
421	>	<< fFrac02    << " "
422	>	<< fFrac03    << " "
423	>	<< fFrac04    << " "
424	>	<< fFrac05    << " "
425	>	<< fDRMean
426		<< " === : === "
427		<< lMVA << " "
428		<< std::endl;
#	Line 277 | Line 430 | Double_t JetIDMVA::MVAValue(const PFJet
430
431		return lMVA;
432		}
433	<	Double_t JetIDMVA::correctedPt(const PFJet *iJet, FactorizedJetCorrector *iJetCorrector,const PileupEnergyDensityCol *iPUEnergyDensity) {
433	>	Double_t JetIDMVA::correctedPt(const PFJet *iJet, FactorizedJetCorrector *iJetCorrector,
434	>	const PileupEnergyDensityCol *iPUEnergyDensity,
435	>	RhoUtilities::RhoType type) {
436	>	Double_t Rho = 0.0;
437	>	switch(type) {
438	>	case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA:
439	>	Rho = iPUEnergyDensity->At(0)->Rho();
440	>	break;
441	>	case RhoUtilities::MIT_RHO_VORONOI_LOW_ETA:
442	>	Rho = iPUEnergyDensity->At(0)->RhoLowEta();
443	>	break;
444	>	case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA:
445	>	Rho = iPUEnergyDensity->At(0)->RhoRandom();
446	>	break;
447	>	case RhoUtilities::MIT_RHO_RANDOM_LOW_ETA:
448	>	Rho = iPUEnergyDensity->At(0)->RhoRandomLowEta();
449	>	break;
450	>	case RhoUtilities::CMS_RHO_RHOKT6PFJETS:
451	>	Rho = iPUEnergyDensity->At(0)->RhoKt6PFJets();
452	>	break;
453	>	default:
454	>	// use the old default
455	>	Rho = iPUEnergyDensity->At(0)->Rho();
456	>	break;
457	>	}
458	>
459		const FourVectorM rawMom = iJet->RawMom();
460		iJetCorrector->setJetEta(rawMom.Eta());
461		iJetCorrector->setJetPt (rawMom.Pt());
462		iJetCorrector->setJetPhi(rawMom.Phi());
463		iJetCorrector->setJetE  (rawMom.E());
464	<	iJetCorrector->setRho   (iPUEnergyDensity->At(0)->RhoHighEta());
464	>	iJetCorrector->setRho   (Rho);
465		iJetCorrector->setJetA  (iJet->JetArea());
466		iJetCorrector->setJetEMF(-99.0);
467		Double_t correction = iJetCorrector->getCorrection();

Diff Legend

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