[ViewVC] Diff of: cvsroot/UserCode/MitPhysics/Utils/src/JetIDMVA.cc

Comparing UserCode/MitPhysics/Utils/src/JetIDMVA.cc (file contents):
Revision 1.7 by pharris, Tue May 1 16:53:38 2012 UTC vs.
Revision 1.16 by pharris, Tue Sep 25 15:39:15 2012 UTC

#	Line 15 \| Line 15 \| using namespace mithep;
15
16		//--------------------------------------------------------------------------------------------------
17		JetIDMVA::JetIDMVA() :
18	<	fJetPtMin(0) , //We need to lower this
18	>	fJetPtMin(0.) , //We need to lower this
19		fDZCut (0.2),
20		fLowPtMethodName ("JetIDMVALowPt" ),
21		fHighPtMethodName("JetIDMVAHighPt"),
#	Line 35 \| Line 35 \| JetIDMVA::JetIDMVA() :
35		fFrac02 (0),
36		fFrac03 (0),
37		fFrac04 (0),
38	<	fFrac05 (0)
38	>	fFrac05 (0),
39	>	fDR2Mean (0)
40		{
41		fReader = 0;
42		}
43		//--------------------------------------------------------------------------------------------------
44		JetIDMVA::~JetIDMVA() {
45
46	<	fReader = 0;
46	>	delete fReader;
47	>	delete fLowPtReader;
48		}
49
50		//--------------------------------------------------------------------------------------------------
#	Line 56 \| Line 58 \| void JetIDMVA::Initialize( JetIDMVA::Cut
58		fIsInitialized = kTRUE;
59		fType = iType;
60		fCutType = iCutType;
61	+
62	+	std::string lCutId = "JetIdParams";
63	+	if(fType == k42) lCutId = "PuJetIdOptMVA_wp";
64	+	if(fType == k52) lCutId = "full_5x_wp";
65	+	if(fType == kCut) lCutId = "PuJetIdCutBased_wp";
66	+	//Load Cut Matrix
67	+	edm::ParameterSet lDefConfig = edm::readPSetsFrom(iCutFileName.Data())->getParameter<edm::ParameterSet>("JetIdParams");
68	+	edm::ParameterSet lConfig = edm::readPSetsFrom(iCutFileName.Data())->getParameter<edm::ParameterSet>(lCutId);
69	+	std::string lCutType = "Tight";
70	+	if(fCutType == kMedium) lCutType = "Medium";
71	+	if(fCutType == kLoose ) lCutType = "Loose";
72	+	if(fCutType == kMET ) lCutType = "MET";
73	+	if(fType != kCut) {
74	+	std::string lLowPtCut = "MET";
75	+	std::vector<double> lPt010 = lDefConfig.getParameter<std::vector<double> >(("Pt010_" +lLowPtCut).c_str());
76	+	std::vector<double> lPt1020 = lConfig.getParameter<std::vector<double> >(("Pt1020_"+lCutType).c_str());
77	+	std::vector<double> lPt2030 = lConfig.getParameter<std::vector<double> >(("Pt2030_"+lCutType).c_str());
78	+	std::vector<double> lPt3050 = lConfig.getParameter<std::vector<double> >(("Pt3050_"+lCutType).c_str());
79	+	for(int i0 = 0; i0 < 4; i0++) fMVACut[0][i0] = lPt010 [i0];
80	+	for(int i0 = 0; i0 < 4; i0++) fMVACut[1][i0] = lPt1020[i0];
81	+	for(int i0 = 0; i0 < 4; i0++) fMVACut[2][i0] = lPt2030[i0];
82	+	for(int i0 = 0; i0 < 4; i0++) fMVACut[3][i0] = lPt3050[i0];
83	+	}
84	+	if(fType == kCut) {
85	+	for(int i0 = 0; i0 < 2; i0++) {
86	+	std::string lFullCutType = lCutType;
87	+	if(i0 == 0) lFullCutType = "BetaStar"+ lCutType;
88	+	if(i0 == 1) lFullCutType = "RMS" + lCutType;
89	+	std::vector<double> pt010 = lConfig.getParameter<std::vector<double> >(("Pt010_" +lFullCutType).c_str());
90	+	std::vector<double> pt1020 = lConfig.getParameter<std::vector<double> >(("Pt1020_"+lFullCutType).c_str());
91	+	std::vector<double> pt2030 = lConfig.getParameter<std::vector<double> >(("Pt2030_"+lFullCutType).c_str());
92	+	std::vector<double> pt3050 = lConfig.getParameter<std::vector<double> >(("Pt3050_"+lFullCutType).c_str());
93	+	if(i0 == 0) {
94	+	for(int i2 = 0; i2 < 4; i2++) fBetaStarCut[0][i2] = pt010 [i2];
95	+	for(int i2 = 0; i2 < 4; i2++) fBetaStarCut[1][i2] = pt1020[i2];
96	+	for(int i2 = 0; i2 < 4; i2++) fBetaStarCut[2][i2] = pt2030[i2];
97	+	for(int i2 = 0; i2 < 4; i2++) fBetaStarCut[3][i2] = pt3050[i2];
98	+	}
99	+	if(i0 == 1) {
100	+	for(int i2 = 0; i2 < 4; i2++) fRMSCut[0][i2] = pt010 [i2];
101	+	for(int i2 = 0; i2 < 4; i2++) fRMSCut[1][i2] = pt1020[i2];
102	+	for(int i2 = 0; i2 < 4; i2++) fRMSCut[2][i2] = pt2030[i2];
103	+	for(int i2 = 0; i2 < 4; i2++) fRMSCut[3][i2] = pt3050[i2];
104	+	}
105	+	}
106	+	return;
107	+	}
108	+
109	+
110	+	fLowPtReader = 0;
111	+	fLowPtReader = new TMVA::Reader( "!Color:!Silent:Error" );
112	+	fLowPtReader->AddVariable( "nvtx" , &fNVtx );
113	+	fLowPtReader->AddVariable( "jetPt" , &fJPt1 );
114	+	fLowPtReader->AddVariable( "jetEta" , &fJEta1 );
115	+	fLowPtReader->AddVariable( "jetPhi" , &fJPhi1 );
116	+	fLowPtReader->AddVariable( "dZ" , &fJDZ1 );
117	+	fLowPtReader->AddVariable( "d0" , &fJD01 );
118	+	fLowPtReader->AddVariable( "beta" , &fBeta );
119	+	fLowPtReader->AddVariable( "betaStar" , &fBetaStar );
120	+	fLowPtReader->AddVariable( "nCharged" , &fNCharged );
121	+	fLowPtReader->AddVariable( "nNeutrals", &fNNeutrals );
122	+	fLowPtReader->AddVariable( "dRMean" , &fDRMean );
123	+	fLowPtReader->AddVariable( "frac01" , &fFrac01 );
124	+	fLowPtReader->AddVariable( "frac02" , &fFrac02 );
125	+	fLowPtReader->AddVariable( "frac03" , &fFrac03 );
126	+	fLowPtReader->AddVariable( "frac04" , &fFrac04 );
127	+	fLowPtReader->AddVariable( "frac05" , &fFrac05 );
128	+
129		fReader = 0;
130		fReader = new TMVA::Reader( "!Color:!Silent:Error" );
131		if (fType == kBaseline) {
#	Line 76 \| Line 146 \| void JetIDMVA::Initialize( JetIDMVA::Cut
146		fReader->AddVariable( "frac04" , &fFrac04 );
147		fReader->AddVariable( "frac05" , &fFrac05 );
148		}
149	<	fReader->BookMVA(fLowPtMethodName , iLowPtWeights );
149	>	if (fType == k42) {
150	>	fReader->AddVariable( "frac01" , &fFrac01 );
151	>	fReader->AddVariable( "frac02" , &fFrac02 );
152	>	fReader->AddVariable( "frac03" , &fFrac03 );
153	>	fReader->AddVariable( "frac04" , &fFrac04 );
154	>	fReader->AddVariable( "frac05" , &fFrac05 );
155	>	fReader->AddVariable( "nvtx" , &fNVtx );
156	>	fReader->AddVariable( "nNeutrals", &fNNeutrals );
157	>	fReader->AddVariable( "beta" , &fBeta );
158	>	fReader->AddVariable( "betaStar" , &fBetaStar );
159	>	fReader->AddVariable( "dZ" , &fJDZ1 );
160	>	fReader->AddVariable( "nCharged" , &fNCharged );
161	>	fReader->AddSpectator( "jetPt" , &fJPt1 );
162	>	fReader->AddSpectator( "jetEta" , &fJEta1 );
163	>	}
164	>	if (fType == k52) {
165	>	fReader->AddVariable( "frac01" , &fFrac01 );
166	>	fReader->AddVariable( "frac02" , &fFrac02 );
167	>	fReader->AddVariable( "frac03" , &fFrac03 );
168	>	fReader->AddVariable( "frac04" , &fFrac04 );
169	>	fReader->AddVariable( "frac05" , &fFrac05 );
170	>	fReader->AddVariable( "dR2Mean" , &fDR2Mean );
171	>	fReader->AddVariable( "nvtx" , &fNVtx );
172	>	fReader->AddVariable( "nNeutrals", &fNNeutrals );
173	>	fReader->AddVariable( "beta" , &fBeta );
174	>	fReader->AddVariable( "betaStar" , &fBetaStar );
175	>	fReader->AddVariable( "dZ" , &fJDZ1 );
176	>	fReader->AddVariable( "nCharged" , &fNCharged );
177	>	fReader->AddSpectator( "jetPt" , &fJPt1 );
178	>	fReader->AddSpectator( "jetEta" , &fJEta1 );
179	>	}
180	>	if (fType == kQGP) {
181	>	fReader->AddVariable( "nvtx" , &fNVtx );
182	>	fReader->AddVariable( "jetPt" , &fJPt1 );
183	>	fReader->AddVariable( "jetEta" , &fJEta1 );
184	>	fReader->AddVariable( "jetPhi" , &fJPhi1 );
185	>	fReader->AddVariable( "beta" , &fBeta );
186	>	fReader->AddVariable( "betaStar" , &fBetaStar );
187	>	fReader->AddVariable( "nParticles", &fNNeutrals );
188	>	fReader->AddVariable( "nCharged" , &fNCharged );
189	>	fReader->AddVariable( "dRMean" , &fDRMean );
190	>	fReader->AddVariable( "ptD" , &fPtD );
191	>	fReader->AddVariable( "frac01" , &fFrac01 );
192	>	fReader->AddVariable( "frac02" , &fFrac02 );
193	>	fReader->AddVariable( "frac03" , &fFrac03 );
194	>	fReader->AddVariable( "frac04" , &fFrac04 );
195	>	fReader->AddVariable( "frac05" , &fFrac05 );
196	>	}
197	>
198	>	fLowPtReader->BookMVA(fLowPtMethodName , iLowPtWeights );
199		fReader->BookMVA(fHighPtMethodName , iHighPtWeights );
200		std::cout << "Jet ID MVA Initialization\n";
201		std::cout << "MethodName : " << fLowPtMethodName << " , type == " << fType << std::endl;
202
84	–	//Load Cut Matrix
85	–	edm::ParameterSet lConfig = edm::readPSetsFrom(iCutFileName.Data())->getParameter<edm::ParameterSet>("JetIdParams");
86	–	std::string lCutType = "Tight";
87	–	if(fCutType == kMedium) lCutType = "Medium";
88	–	if(fCutType == kLoose ) lCutType = "Loose";
89	–	if(fCutType == kMET ) lCutType = "MET";
90	–	std::vector<double> lPt010 = lConfig.getParameter<std::vector<double> >(("Pt010_" +lCutType).c_str());
91	–	std::vector<double> lPt1020 = lConfig.getParameter<std::vector<double> >(("Pt1020_"+lCutType).c_str());
92	–	std::vector<double> lPt2030 = lConfig.getParameter<std::vector<double> >(("Pt2030_"+lCutType).c_str());
93	–	std::vector<double> lPt3050 = lConfig.getParameter<std::vector<double> >(("Pt3050_"+lCutType).c_str());
94	–	for(int i0 = 0; i0 < 4; i0++) fMVACut[0][i0] = lPt010 [i0];
95	–	for(int i0 = 0; i0 < 4; i0++) fMVACut[1][i0] = lPt1020[i0];
96	–	for(int i0 = 0; i0 < 4; i0++) fMVACut[2][i0] = lPt2030[i0];
97	–	for(int i0 = 0; i0 < 4; i0++) fMVACut[3][i0] = lPt3050[i0];
98	–	//std::cout << " Working Points : << " << std::endl;
99	–	//for(int i0 = 0; i0 < 4; i0++) for(int i1 = 0; i1 < 4; i1++)
100	–	// std::cout << " ==> " << i0 << " -- " << i1 << " -- " << fMVACut[i0][i1] << std::endl;
203		}
204
205		//--------------------------------------------------------------------------------------------------
#	Line 117 \| Line 219 \| Double_t JetIDMVA::MVAValue(
219		Float_t iFrac02 ,
220		Float_t iFrac03 ,
221		Float_t iFrac04 ,
222	<	Float_t iFrac05
222	>	Float_t iFrac05 ,
223	>	Float_t iDR2Mean
224		){
225
226		if(!fIsInitialized) {
#	Line 141 \| Line 244 \| Double_t JetIDMVA::MVAValue(
244		fFrac03 = iFrac03;
245		fFrac04 = iFrac04;
246		fFrac05 = iFrac05;
247	+	fDR2Mean = iDR2Mean;
248
249		Double_t lMVA = -9999;
250	<	if(iJPt1 < 10) lMVA = fReader->EvaluateMVA( fLowPtMethodName );
250	>	if(iJPt1 < 10) lMVA = fLowPtReader->EvaluateMVA( fLowPtMethodName );
251		if(iJPt1 > 10) lMVA = fReader->EvaluateMVA( fHighPtMethodName );
252
253		return lMVA;
254		}
255		//--------------------------------------------------------------------------------------------------
256	+	Bool_t JetIDMVA::passPt(const PFJet iJet, FactorizedJetCorrector iJetCorrector,
257	+	const PileupEnergyDensityCol *iPileupEnergyDensity,
258	+	RhoUtilities::RhoType type) {
259	+	if(iJetCorrector == 0) return (iJet->Pt() > fJetPtMin);
260	+	double lPt = correctedPt(iJet, iJetCorrector,iPileupEnergyDensity,type);
261	+	if(lPt < fJetPtMin) return false;
262	+	return true;
263	+	}
264	+	//--------------------------------------------------------------------------------------------------
265		Bool_t JetIDMVA::pass(const PFJet iJet,const Vertex iVertex,const VertexCol *iVertices,
266		FactorizedJetCorrector *iJetCorrector,
267	<	const PileupEnergyDensityCol *iPileupEnergyDensity) {
267	>	const PileupEnergyDensityCol *iPileupEnergyDensity,
268	>	RhoUtilities::RhoType type) {
269
270		if(!JetTools::passPFLooseId(iJet)) return false;
157	–	if(iJet->Pt() < fJetPtMin) return false;
271		if(fabs(iJet->Eta()) > 4.99) return false;
272
273		double lMVA = MVAValue (iJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity);
274	<	double lPt = correctedPt(iJet, iJetCorrector,iPileupEnergyDensity);
275	<	if(lPt > 50) return true; //==> we can raise this
274	>	double lPt = correctedPt(iJet, iJetCorrector,iPileupEnergyDensity,type);
275	>	if(lPt < fJetPtMin) return false;
276
277		int lPtId = 0;
278		if(lPt > 10 && lPt < 20) lPtId = 1;
#	Line 174 \| Line 287 \| *Bool_t JetIDMVA::pass(const PFJet iJet,**
287		double lMVACut = fMVACut[lPtId][lEtaId];
288		if(lMVA < lMVACut) return false;
289		return true;
290	<	//if( fabs(JetTools::impactParameter(iJet,iVertex,true)) < 0.2) return true;
291	<	//if(correctedPt(iJet,iJetCorrector,iPileupEnergyDensity) < fJetPtMin && iJet->TrackCountingHighEffBJetTagsDisc() == -100) return false;
292	<	//This line is a bug in the Met training
293	<	//if(lMVA < -0.8) return false;
294	<	//if(lMVA < -0.5 && fabs(iJet->Eta()) > 3.0) return false;
290	>	}
291	>	//--------------------------------------------------------------------------------------------------
292	>	Bool_t JetIDMVA::passCut(const PFJet iJet,const Vertex iVertex,const VertexCol *iVertices) {
293	>	if(!JetTools::passPFLooseId(iJet)) return false;
294	>	if(iJet->Pt() < fJetPtMin) return false;
295	>	if(fabs(iJet->Eta()) > 4.99) return false;
296	>	//if(fType == kCut) passCut(iJet,iVertex,iVertices);
297	>
298	>	double lPt = iJet->Pt();
299	>	int lPtId = 0;
300	>	if(lPt > 10 && lPt < 20) lPtId = 1;
301	>	if(lPt > 20 && lPt < 30) lPtId = 2;
302	>	if(lPt > 30 ) lPtId = 3;
303	>
304	>	int lEtaId = 0;
305	>	if(fabs(iJet->Eta()) > 2.5 && fabs(iJet->Eta()) < 2.75) lEtaId = 1;
306	>	if(fabs(iJet->Eta()) > 2.75 && fabs(iJet->Eta()) < 3.0 ) lEtaId = 2;
307	>	if(fabs(iJet->Eta()) > 3.0 && fabs(iJet->Eta()) < 5.0 ) lEtaId = 3;
308	>	float betaStarModified = JetTools::betaStarClassic(iJet,iVertex,iVertices)/log(iVertices ->GetEntries()-0.64);
309	>	float dR2Mean = JetTools::dR2Mean(iJet,-1);
310	>
311	>	if(betaStarModified < fBetaStarCut[lPtId][lEtaId] &&
312	>	dR2Mean < fRMSCut [lPtId][lEtaId]
313	>	) return true;
314	>
315	>	return false;
316		}
317		//--------------------------------------------------------------------------------------------------
318		Bool_t JetIDMVA::pass(const PFJet iJet,const Vertex iVertex,const VertexCol *iVertices) {
319		if(!JetTools::passPFLooseId(iJet)) return false;
320		if(iJet->Pt() < fJetPtMin) return false;
187	–	if(iJet->Pt() > 50) return true; //==> we can raise this
321		if(fabs(iJet->Eta()) > 4.99) return false;
322	+	if(fType == kCut) return passCut(iJet,iVertex,iVertices);
323		double lMVA = MVAValue(iJet,iVertex,iVertices);
324
325		int lPtId = 0;
#	Line 231 \| Line 365 \| Double_t JetIDMVA::MVAValue(const PFJet
365		fNNeutrals = iJet->NeutralMultiplicity();
366
367		fDRMean = JetTools::dRMean(iJet,-1);
368	+	fDR2Mean = JetTools::dR2Mean(iJet,-1);
369		fFrac01 = JetTools::frac (iJet,0.1,0. ,-1);
370		fFrac02 = JetTools::frac (iJet,0.2,0.1,-1);
371		fFrac03 = JetTools::frac (iJet,0.3,0.2,-1);
#	Line 238 \| Line 373 \| Double_t JetIDMVA::MVAValue(const PFJet
373		fFrac05 = JetTools::frac (iJet,0.5,0.4,-1);
374
375		double lMVA = 0;
376	<	if(fJPt1 < 10) lMVA = fReader->EvaluateMVA( fLowPtMethodName );
376	>	if(fJPt1 < 10) lMVA = fLowPtReader->EvaluateMVA( fLowPtMethodName );
377		if(fJPt1 > 10) lMVA = fReader->EvaluateMVA( fHighPtMethodName );
378		if (printDebug == kTRUE) {
379		std::cout << "Debug Jet MVA: "
#	Line 257 \| Line 392 \| Double_t JetIDMVA::MVAValue(const PFJet
392		<< fFrac02 << " "
393		<< fFrac03 << " "
394		<< fFrac04 << " "
395	<	<< fFrac05
395	>	<< fFrac05 << " "
396	>	<< fDRMean
397		<< " === : === "
398		<< lMVA << " "
399		<< std::endl;
#	Line 286 \| Line 422 \| Double_t JetIDMVA::MVAValue(const PFJet
422		fNCharged = iJet->ChargedMultiplicity();
423		fNNeutrals = iJet->NeutralMultiplicity();
424
425	+	fDRMean = JetTools::dRMean (iJet,-1);
426	+	fDR2Mean = JetTools::dR2Mean(iJet,-1);
427	+	fFrac01 = JetTools::frac (iJet,0.1,0. ,-1);
428	+	fFrac02 = JetTools::frac (iJet,0.2,0.1,-1);
429	+	fFrac03 = JetTools::frac (iJet,0.3,0.2,-1);
430	+	fFrac04 = JetTools::frac (iJet,0.4,0.3,-1);
431	+	fFrac05 = JetTools::frac (iJet,0.5,0.4,-1);
432	+
433	+	double lMVA = 0;
434	+	if(fJPt1 < 10) lMVA = fLowPtReader->EvaluateMVA( fLowPtMethodName );
435	+	if(fJPt1 > 10) lMVA = fReader ->EvaluateMVA( fHighPtMethodName );
436	+
437	+	if (printDebug == kTRUE) {
438	+	std::cout << "Debug Jet MVA: "
439	+	<< fNVtx << " "
440	+	<< fJPt1 << " "
441	+	<< fJEta1 << " "
442	+	<< fJPhi1 << " "
443	+	<< fJD01 << " "
444	+	<< fJDZ1 << " "
445	+	<< fBeta << " "
446	+	<< fBetaStar << " "
447	+	<< fNCharged << " "
448	+	<< fNNeutrals << " "
449	+	<< fDRMean << " "
450	+	<< fFrac01 << " "
451	+	<< fFrac02 << " "
452	+	<< fFrac03 << " "
453	+	<< fFrac04 << " "
454	+	<< fFrac05 << " "
455	+	<< fDRMean
456	+	<< " === : === "
457	+	<< lMVA << " "
458	+	<< std::endl;
459	+	}
460	+
461	+	return lMVA;
462	+	}
463	+	//--------------------------------------------------------------------------------------------------
464	+	Double_t* JetIDMVA::QGValue(const PFJet iJet,const Vertex iVertex,const VertexCol *iVertices, //Vertex here is the PV
465	+	FactorizedJetCorrector *iJetCorrector,
466	+	const PileupEnergyDensityCol *iPileupEnergyDensity,
467	+	Bool_t printDebug) {
468	+
469	+	Double_t *lId = new double[3];
470	+	lId[0] = -2;
471	+	lId[1] = -2;
472	+	lId[2] = -2;
473	+	if (!fIsInitialized) {
474	+	std::cout << "Error: JetIDMVA not properly initialized.\n";
475	+	return lId;
476	+	}
477	+	if(!JetTools::passPFLooseId(iJet)) return lId;
478	+
479	+	fJPt1 = correctedPt(iJet,iJetCorrector,iPileupEnergyDensity);
480	+	if(fJPt1 < 20) return lId;
481	+
482	+	//set all input variables
483	+	fNVtx = iVertices->GetEntries();
484	+	fJEta1 = iJet->RawMom().Eta();
485	+	fJPhi1 = iJet->RawMom().Phi();
486	+	fJD01 = JetTools::impactParameter(iJet,iVertex);
487	+	fJDZ1 = JetTools::impactParameter(iJet,iVertex,true);
488	+	fBeta = JetTools::Beta(iJet,iVertex,fDZCut);
489	+	fBetaStar = JetTools::betaStar(iJet,iVertex,iVertices,fDZCut);
490	+	fNCharged = iJet->ChargedMultiplicity();
491	+	fNNeutrals = iJet->NeutralMultiplicity();
492	+	fNParticles = fNCharged+fNNeutrals;
493	+	fPtD = JetTools::W(iJet,-1,0);
494	+
495		fDRMean = JetTools::dRMean(iJet,-1);
496	+	fDR2Mean = JetTools::dR2Mean(iJet,-1);
497		fFrac01 = JetTools::frac (iJet,0.1,0. ,-1);
498		fFrac02 = JetTools::frac (iJet,0.2,0.1,-1);
499		fFrac03 = JetTools::frac (iJet,0.3,0.2,-1);
#	Line 294 \| Line 501 \| Double_t JetIDMVA::MVAValue(const PFJet
501		fFrac05 = JetTools::frac (iJet,0.5,0.4,-1);
502
503		double lMVA = 0;
504	<	if(fJPt1 < 10) lMVA = fReader->EvaluateMVA( fLowPtMethodName );
505	<	if(fJPt1 > 10) lMVA = fReader->EvaluateMVA( fHighPtMethodName );
506	<
504	>	lId[0] = fReader->EvaluateMulticlass( fHighPtMethodName )[0];
505	>	lId[1] = fReader->EvaluateMulticlass( fHighPtMethodName )[1];
506	>	lId[2] = fReader->EvaluateMulticlass( fHighPtMethodName )[2];
507		if (printDebug == kTRUE) {
508		std::cout << "Debug Jet MVA: "
509		<< fNVtx << " "
#	Line 314 \| Line 521 \| Double_t JetIDMVA::MVAValue(const PFJet
521		<< fFrac02 << " "
522		<< fFrac03 << " "
523		<< fFrac04 << " "
524	<	<< fFrac05
524	>	<< fFrac05 << " "
525	>	<< fDRMean
526		<< " === : === "
527		<< lMVA << " "
528		<< std::endl;
529		}
530	<
323	<	return lMVA;
530	>	return lId;
531		}
532	<	Double_t JetIDMVA::correctedPt(const PFJet iJet, FactorizedJetCorrector iJetCorrector,const PileupEnergyDensityCol *iPUEnergyDensity) {
532	>	Double_t JetIDMVA::correctedPt(const PFJet iJet, FactorizedJetCorrector iJetCorrector,
533	>	const PileupEnergyDensityCol *iPUEnergyDensity,
534	>	RhoUtilities::RhoType type,int iId) {
535	>	Double_t Rho = 0.0;
536	>	switch(type) {
537	>	case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA:
538	>	Rho = iPUEnergyDensity->At(0)->Rho();
539	>	break;
540	>	case RhoUtilities::MIT_RHO_VORONOI_LOW_ETA:
541	>	Rho = iPUEnergyDensity->At(0)->RhoLowEta();
542	>	break;
543	>	case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA:
544	>	Rho = iPUEnergyDensity->At(0)->RhoRandom();
545	>	break;
546	>	case RhoUtilities::MIT_RHO_RANDOM_LOW_ETA:
547	>	Rho = iPUEnergyDensity->At(0)->RhoRandomLowEta();
548	>	break;
549	>	case RhoUtilities::CMS_RHO_RHOKT6PFJETS:
550	>	Rho = iPUEnergyDensity->At(0)->RhoKt6PFJets();
551	>	break;
552	>	default:
553	>	// use the old default
554	>	Rho = iPUEnergyDensity->At(0)->Rho();
555	>	break;
556	>	}
557	>
558		const FourVectorM rawMom = iJet->RawMom();
559		iJetCorrector->setJetEta(rawMom.Eta());
560		iJetCorrector->setJetPt (rawMom.Pt());
561		iJetCorrector->setJetPhi(rawMom.Phi());
562		iJetCorrector->setJetE (rawMom.E());
563	<	iJetCorrector->setRho (iPUEnergyDensity->At(0)->RhoHighEta());
563	>	iJetCorrector->setRho (Rho);
564		iJetCorrector->setJetA (iJet->JetArea());
565		iJetCorrector->setJetEMF(-99.0);
566	<	Double_t correction = iJetCorrector->getCorrection();
566	>	Double_t correction = 1.;
567	>	if(iId < 0 \|\| iId == 100) correction = iJetCorrector->getCorrection();
568	>	std::vector<float> lCorrections; if(iId != -1 && iId != 100) lCorrections = iJetCorrector->getSubCorrections();
569	>	if(iId > -1 && iId < int(lCorrections.size())) correction = lCorrections[iId];
570	>	if(iId == 100) {
571	>	iJetCorrector->setJetEta(rawMom.Eta());
572	>	iJetCorrector->setJetPt (rawMom.Pt());
573	>	iJetCorrector->setJetPhi(rawMom.Phi());
574	>	iJetCorrector->setJetE (rawMom.E());
575	>	iJetCorrector->setRho (Rho);
576	>	iJetCorrector->setJetA (iJet->JetArea());
577	>	iJetCorrector->setJetEMF(-99.0);
578	>	lCorrections = iJetCorrector->getSubCorrections();
579	>	double correction2 = 1;
580	>	correction2 *= lCorrections[0];
581	>	correction = correction-correction2;
582	>	}
583	>
584		return rawMom.Pt()*correction;
585		}

Diff Legend

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

Comparing UserCode/MitPhysics/Utils/src/JetIDMVA.cc (file contents): Revision 1.7 by pharris, Tue May 1 16:53:38 2012 UTC vs. Revision 1.16 by pharris, Tue Sep 25 15:39:15 2012 UTC

Diff Legend

Comparing UserCode/MitPhysics/Utils/src/JetIDMVA.cc (file contents):
Revision 1.7 by pharris, Tue May 1 16:53:38 2012 UTC vs.
Revision 1.16 by pharris, Tue Sep 25 15:39:15 2012 UTC