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.2 by pharris, Wed Apr 4 07:57:01 2012 UTC vs.
Revision 1.5 by pharris, Fri Apr 13 14:24:00 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),
34	<	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		{
40		fReader = 0;
41		}
42		//--------------------------------------------------------------------------------------------------
43	<	JetIDMVA::~JetIDMVA()
44	<	{
43	>	JetIDMVA::~JetIDMVA() {
44	>
45		fReader = 0;
46		}
47
48		//--------------------------------------------------------------------------------------------------
49	<	void JetIDMVA::Initialize( TString iMethodName,
50	<	TString iWeights,
51	<	JetIDMVA::MVAType iType)
49	>	void JetIDMVA::Initialize( JetIDMVA::CutType iCutType,
50	>	TString iLowPtWeights,
51	>	TString iHighPtWeights,
52	>	JetIDMVA::MVAType iType,
53	>	TString iCutFileName)
54		{
55
56		fIsInitialized = kTRUE;
64	–	fMethodName    = iMethodName;
57		fType          = iType;
58	+	fCutType       = iCutType;
59		fReader        = 0;
60		fReader        = new TMVA::Reader( "!Color:!Silent:Error" );
61		if (fType == kBaseline) {
62	<	fReader->AddSpectator( "npv"     , &fNPV    );
63	<	fReader->AddVariable( "jspt_1"   , &fJPt1   );
64	<	fReader->AddVariable( "jseta_1"  , &fJEta1  );
65	<	fReader->AddVariable( "jsphi_1"  , &fJPhi1  );
66	<	fReader->AddVariable( "jd0_1"    , &fJD01   );
67	<	fReader->AddVariable( "jdZ_1"    , &fJDZ1   );
68	<	fReader->AddVariable( "jm_1"     , &fJM1    );
69	<	fReader->AddVariable( "npart_1"  , &fNPart1 );
70	<	fReader->AddVariable( "lpt_1"    , &fLPt1   );
71	<	fReader->AddVariable( "leta_1"   , &fLEta1  );
72	<	fReader->AddVariable( "lphi_1"   , &fLPhi1  );
73	<	fReader->AddVariable( "spt_1"    , &fSPt1   );
74	<	fReader->AddVariable( "seta_1"   , &fSEta1  );
75	<	fReader->AddVariable( "sphi_1"   , &fSPhi1  );
76	<	fReader->AddVariable( "lnept_1"  , &fNEPt1  );
77	<	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  );
62	>	fReader->AddVariable( "nvtx"     , &fNVtx      );
63	>	fReader->AddVariable( "jetPt"    , &fJPt1      );
64	>	fReader->AddVariable( "jetEta"   , &fJEta1     );
65	>	fReader->AddVariable( "jetPhi"   , &fJPhi1     );
66	>	fReader->AddVariable( "dZ"       , &fJDZ1      );
67	>	fReader->AddVariable( "d0"       , &fJD01      );
68	>	fReader->AddVariable( "beta"     , &fBeta      );
69	>	fReader->AddVariable( "betaStar" , &fBetaStar  );
70	>	fReader->AddVariable( "nCharged" , &fNCharged  );
71	>	fReader->AddVariable( "nNeutrals", &fNNeutrals );
72	>	fReader->AddVariable( "dRMean"   , &fDRMean    );
73	>	fReader->AddVariable( "frac01"   , &fFrac01    );
74	>	fReader->AddVariable( "frac02"   , &fFrac02    );
75	>	fReader->AddVariable( "frac03"   , &fFrac03    );
76	>	fReader->AddVariable( "frac04"   , &fFrac04    );
77	>	fReader->AddVariable( "frac05"   , &fFrac05    );
78		}
79	<	fReader->BookMVA(fMethodName , iWeights );
79	>	fReader->BookMVA(fLowPtMethodName  , iLowPtWeights );
80	>	fReader->BookMVA(fHighPtMethodName , iHighPtWeights );
81		std::cout << "Jet ID MVA Initialization\n";
82	<	std::cout << "MethodName : " << fMethodName << " , type == " << fType << std::endl;
82	>	std::cout << "MethodName : " << fLowPtMethodName << " , type == " << fType << std::endl;
83	>
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	>	std::vector<double> lPt010  = lConfig.getParameter<std::vector<double> >(("Pt010_" +lCutType).c_str());
90	>	std::vector<double> lPt1020 = lConfig.getParameter<std::vector<double> >(("Pt1020_"+lCutType).c_str());
91	>	std::vector<double> lPt2030 = lConfig.getParameter<std::vector<double> >(("Pt2030_"+lCutType).c_str());
92	>	std::vector<double> lPt3050 = lConfig.getParameter<std::vector<double> >(("Pt3050_"+lCutType).c_str());
93	>	for(int i0 = 0; i0 < 4; i0++) fMVACut[0][i0] = lPt010 [i0];
94	>	for(int i0 = 0; i0 < 4; i0++) fMVACut[1][i0] = lPt1020[i0];
95	>	for(int i0 = 0; i0 < 4; i0++) fMVACut[2][i0] = lPt2030[i0];
96	>	for(int i0 = 0; i0 < 4; i0++) fMVACut[3][i0] = lPt3050[i0];
97	>	//std::cout << " Working Points : << " << std::endl;
98	>	//for(int i0 = 0; i0 < 4; i0++) for(int i1 = 0; i1 < 4; i1++)
99	>	//  std::cout << " ==> " << i0 << " -- " << i1 << " -- " << fMVACut[i0][i1] << std::endl;
100		}
101
102		//--------------------------------------------------------------------------------------------------
#	Line 109 | Line 107 | Double_t JetIDMVA::MVAValue(
107		Float_t iJPhi1  ,
108		Float_t iJD01   ,
109		Float_t iJDZ1   ,
110	<	Float_t iJM1    ,
111	<	Float_t iNPart1 ,
112	<	Float_t iLPt1   ,
113	<	Float_t iLEta1  ,
114	<	Float_t iLPhi1  ,
115	<	Float_t iSPt1   ,
116	<	Float_t iSEta1  ,
117	<	Float_t iSPhi1  ,
118	<	Float_t iNEPt1  ,
119	<	Float_t iNEEta1 ,
122	<	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
110	>	Float_t iBeta   ,
111	>	Float_t iBetaStar,
112	>	Float_t iNCharged,
113	>	Float_t iNNeutrals,
114	>	Float_t iDRMean  ,
115	>	Float_t iFrac01  ,
116	>	Float_t iFrac02  ,
117	>	Float_t iFrac03  ,
118	>	Float_t iFrac04  ,
119	>	Float_t iFrac05
120		){
121
122	<	if (!fIsInitialized) {
122	>	if(!fIsInitialized) {
123		std::cout << "Error: JetIDMVA not properly initialized.\n";
124		return -9999;
125		}
126
127	<	fNPV    = iNPV;
128	<	fJPt1   = iJPt1;
129	<	fJEta1  = iJEta1;
130	<	fJPhi1  = fJPhi1;
131	<	fJD01   = iJD01;
132	<	fJDZ1   = iJDZ1;
133	<	fJM1    = iJM1 ;
134	<	fNPart1 = iNPart1;
135	<	fLPt1   = iLPt1;
136	<	fLEta1  = iLEta1;
137	<	fLPhi1  = iLPhi1;
138	<	fSPt1   = iSPt1;
139	<	fSEta1  = iSEta1;
140	<	fSPhi1  = iSPhi1;
141	<	fNEPt1  = iNEPt1;
142	<	fNEEta1 = iNEEta1;
158	<	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;
127	>	fNVtx      = iNPV;
128	>	fJPt1      = iJPt1;
129	>	fJEta1     = iJEta1;
130	>	fJPhi1     = fJPhi1;
131	>	fJD01      = iJD01;
132	>	fJDZ1      = iJDZ1;
133	>	fBeta      = iBeta;
134	>	fBetaStar  = iBetaStar;
135	>	fNCharged  = iNCharged;
136	>	fNNeutrals = iNNeutrals;
137	>	fDRMean    = iDRMean;
138	>	fFrac01    = iFrac01;
139	>	fFrac02    = iFrac02;
140	>	fFrac03    = iFrac03;
141	>	fFrac04    = iFrac04;
142	>	fFrac05    = iFrac05;
143
144		Double_t lMVA = -9999;
145	<	lMVA = fReader->EvaluateMVA( fMethodName );
145	>	if(iJPt1 < 10) lMVA = fReader->EvaluateMVA( fLowPtMethodName  );
146	>	if(iJPt1 > 10) lMVA = fReader->EvaluateMVA( fHighPtMethodName );
147
148		return lMVA;
149		}
150		//--------------------------------------------------------------------------------------------------
151	<	Bool_t JetIDMVA::pass(const PFJet *iJet,const Vertex *iVertex,
151	>	Bool_t JetIDMVA::pass(const PFJet *iJet,const Vertex *iVertex,const VertexCol *iVertices,
152		FactorizedJetCorrector *iJetCorrector,
153		const PileupEnergyDensityCol *iPileupEnergyDensity) {
154	+
155		if(!JetTools::passPFLooseId(iJet))                 return false;
156	<	if(correctedPt(iJet,iJetCorrector,iPileupEnergyDensity) < fJetPtMin && iJet->TrackCountingHighEffBJetTagsDisc() == -100) return false; //This line is a bug in the Met training
157	<	if( fabs(JetTools::impactParameter(iJet,iVertex,true)) < 0.2) return true;
158	<	double lMVA = MVAValue(iJet,iVertex,iJetCorrector,iPileupEnergyDensity);
159	<	if(lMVA < -0.8)                            return false;
160	<	if(lMVA < -0.5 && fabs(iJet->Eta()) > 3.0) return false;
156	>	if(iJet->Pt() < fJetPtMin)                         return false;
157	>	if(fabs(iJet->Eta()) > 4.99)                       return true; //==> Castor
158	>	//if(iJet->Pt() > 50)                                return true; //==> we can raise this
159	>
160	>	double lMVA = MVAValue   (iJet,iVertex,iVertices,iJetCorrector,iPileupEnergyDensity);
161	>	double lPt  = correctedPt(iJet,                  iJetCorrector,iPileupEnergyDensity);
162	>
163	>	int lPtId = 0;
164	>	if(lPt > 10 && iJet->Pt() < 20) lPtId = 1;
165	>	if(lPt > 20 && iJet->Pt() < 30) lPtId = 2;
166	>	if(lPt > 30                   ) lPtId = 3;
167	>
168	>	int lEtaId = 0;
169	>	if(fabs(iJet->Eta()) > 2.5  && fabs(iJet->Eta()) < 2.75) lEtaId = 1;
170	>	if(fabs(iJet->Eta()) > 2.75 && fabs(iJet->Eta()) < 3.0 ) lEtaId = 2;
171	>	if(fabs(iJet->Eta()) > 3.0  && fabs(iJet->Eta()) < 5.0 ) lEtaId = 3;
172	>
173	>	double lMVACut = fMVACut[lPtId][lEtaId];
174	>	if(lMVA < lMVACut) return false;
175		return true;
176	+	//if( fabs(JetTools::impactParameter(iJet,iVertex,true)) < 0.2) return true;
177	+	//if(correctedPt(iJet,iJetCorrector,iPileupEnergyDensity) < fJetPtMin && iJet->TrackCountingHighEffBJetTagsDisc() == -100) return false;
178	+	//This line is a bug in the Met training
179	+	//if(lMVA < -0.8)                            return false;
180	+	//if(lMVA < -0.5 && fabs(iJet->Eta()) > 3.0) return false;
181		}
182		//--------------------------------------------------------------------------------------------------
183	<	Bool_t JetIDMVA::pass(const PFJet *iJet,const Vertex *iVertex) {
183	>	Bool_t JetIDMVA::pass(const PFJet *iJet,const Vertex *iVertex,const VertexCol *iVertices) {
184		if(!JetTools::passPFLooseId(iJet))                 return false;
185	<	if(iJet->Pt() < fJetPtMin && iJet->TrackCountingHighEffBJetTagsDisc() == -100) return false; //This line is a bug in the Met training
186	<	if( fabs(JetTools::impactParameter(iJet,iVertex,true)) < 0.2) return true;
187	<	double lMVA = MVAValue(iJet,iVertex);
188	<	if(lMVA < -0.8)                            return false;
189	<	if(lMVA < -0.5 && fabs(iJet->Eta()) > 3.0) return false;
185	>	if(iJet->Pt()        < fJetPtMin) return false;
186	>	//if(iJet->Pt()        > 50)        return true; //==> we can raise this
187	>	if(fabs(iJet->Eta()) > 4.99)     return true; //==> Castor
188	>	double lMVA = MVAValue(iJet,iVertex,iVertices);
189	>
190	>	int lPtId = 0;
191	>	if(iJet->Pt() > 10 && iJet->Pt() < 20) lPtId = 1;
192	>	if(iJet->Pt() > 20 && iJet->Pt() < 30) lPtId = 2;
193	>	if(iJet->Pt() > 30                   ) lPtId = 3;
194	>
195	>	int lEtaId = 0;
196	>	if(fabs(iJet->Eta()) > 2.5  && fabs(iJet->Eta()) < 2.75) lEtaId = 1;
197	>	if(fabs(iJet->Eta()) > 2.75 && fabs(iJet->Eta()) < 3.0 ) lEtaId = 2;
198	>	if(fabs(iJet->Eta()) > 3.0  && fabs(iJet->Eta()) < 5.0 ) lEtaId = 3;
199	>
200	>	double lMVACut = fMVACut[lPtId][lEtaId];
201	>	if(lMVA < lMVACut) return false;
202		return true;
203	+	//if(lMVA < -0.8)                            return false;
204	+	//if(lMVA < -0.5 && fabs(iJet->Eta()) > 3.0) return false;
205	+	//if(iJet->Pt() < fJetPtMin && iJet->TrackCountingHighEffBJetTagsDisc() == -100) return false; //This line is a bug in the Met training
206	+	//if( fabs(JetTools::impactParameter(iJet,iVertex,true)) < 0.2) return true;
207		}
208		//--------------------------------------------------------------------------------------------------
209	<	Double_t JetIDMVA::MVAValue(const PFJet *iJet,const Vertex *iVertex, //Vertex here is the PV
209	>	Double_t JetIDMVA::MVAValue(const PFJet *iJet,const Vertex *iVertex,const VertexCol *iVertices, //Vertex here is the PV
210		FactorizedJetCorrector *iJetCorrector,
211		const PileupEnergyDensityCol *iPileupEnergyDensity,
212		Bool_t printDebug) {
#	Line 209 | Line 218 | Double_t JetIDMVA::MVAValue(const PFJet
218		if(!JetTools::passPFLooseId(iJet)) return -2.;
219
220		//set all input variables
221	+	fNVtx      = iVertices->GetEntries();
222		fJPt1      = correctedPt(iJet,iJetCorrector,iPileupEnergyDensity);
223		fJEta1     = iJet->RawMom().Eta();
224		fJPhi1     = iJet->RawMom().Phi();
225	<	fJM1       = iJet->Mass();
226	<
227	<	const mithep::PFCandidate *lLead     = JetTools::leadCand(iJet,-1);
228	<	const mithep::PFCandidate *lSecond   = JetTools::leadCand(iJet,-1,true);
229	<	const mithep::PFCandidate *lLeadNeut = JetTools::leadCand(iJet ,5);
230	<	const mithep::PFCandidate *lLeadEm   = JetTools::leadCand(iJet ,4);
231	<	const mithep::PFCandidate *lLeadCh   = JetTools::leadCand(iJet ,1);
232	<
233	<	fJD01         = JetTools::impactParameter(iJet,iVertex);
234	<	fJDZ1         = JetTools::impactParameter(iJet,iVertex,true);
235	<	fNPart1       = iJet->NPFCands();
236	<	fLPt1         = lLead    ->Pt();
237	<	fLEta1        = lLead    ->Eta();
238	<	fLPhi1        = lLead    ->Phi();
239	<	fSPt1         = lSecond  ->Pt();
240	<	fSEta1        = lSecond  ->Eta();
241	<	fSPhi1        = lSecond  ->Phi();
232	<	fNEPt1        = lLeadNeut->Pt();
233	<	fNEEta1       = lLeadNeut->Eta();
234	<	fNEPhi1       = lLeadNeut->Phi();
235	<	fEMPt1        = lLeadEm  ->Pt();
236	<	fEMEta1       = lLeadEm  ->Eta();
237	<	fEMPhi1       = lLeadEm  ->Phi();
238	<	fChPt1        = lLeadCh  ->Pt();
239	<	//fChEta1       = lLeadCh  ->Eta();
240	<	fChPhi1       = lLeadCh  ->Phi();
241	<	fLFr1         = lLead->Pt()/iJet->Pt();
242	<
243	<	fDRLC1        = MathUtils::DeltaR(iJet->Mom(),lLead  ->Mom());
244	<	fDRLS1        = MathUtils::DeltaR(iJet->Mom(),lSecond->Mom());
245	<	fDRM1         = JetTools::dRMean (iJet,-1);
246	<	fDRNE1        = JetTools::dRMean (iJet, 5);
247	<	fDREM1        = JetTools::dRMean (iJet, 4);
248	<	fDRCH1        = JetTools::dRMean (iJet, 1);
249	<
250	<	double lMVA = fReader->EvaluateMVA( fMethodName );
251	<
225	>	fJD01      = JetTools::impactParameter(iJet,iVertex);
226	>	fJDZ1      = JetTools::impactParameter(iJet,iVertex,true);
227	>	fBeta      = JetTools::Beta(iJet,iVertex,fDZCut);
228	>	fBetaStar  = JetTools::betaStar(iJet,iVertex,iVertices,fDZCut);
229	>	fNCharged  = iJet->ChargedMultiplicity();
230	>	fNNeutrals = iJet->NeutralMultiplicity();
231	>
232	>	fDRMean    = JetTools::dRMean(iJet,-1);
233	>	fFrac01    = JetTools::frac  (iJet,0.1,0. ,-1);
234	>	fFrac02    = JetTools::frac  (iJet,0.2,0.1,-1);
235	>	fFrac03    = JetTools::frac  (iJet,0.3,0.2,-1);
236	>	fFrac04    = JetTools::frac  (iJet,0.4,0.3,-1);
237	>	fFrac05    = JetTools::frac  (iJet,0.5,0.4,-1);
238	>
239	>	double lMVA = 0;
240	>	if(fJPt1 < 10) lMVA = fReader->EvaluateMVA( fLowPtMethodName  );
241	>	if(fJPt1 > 10) lMVA = fReader->EvaluateMVA( fHighPtMethodName );
242		if (printDebug == kTRUE) {
243		std::cout << "Debug Jet MVA: "
244	<	<< fNPV    << " "
245	<	<< fJPt1   << " "
246	<	<< fJEta1  << " "
247	<	<< fJPhi1  << " "
248	<	<< fJD01   << " "
249	<	<< fJDZ1   << " "
250	<	<< fJM1    << " "
251	<	<< fNPart1 << " "
252	<	<< fLPt1   << " "
253	<	<< fLEta1  << " "
254	<	<< fLPhi1  << " "
255	<	<< fSPt1   << " "
256	<	<< fSEta1  << " "
257	<	<< fSPhi1  << " "
258	<	<< fNEPt1  << " "
259	<	<< fNEEta1 << " "
270	<	<< fNEPhi1 << " "
271	<	<< fEMPt1  << " "
272	<	<< fEMEta1 << " "
273	<	<< fEMPhi1 << " "
274	<	<< fChPt1  << " "
275	<	<< fChPhi1 << " "
276	<	<< fLFr1   << " "
277	<	<< fDRLC1  << " "
278	<	<< fDRLS1  << " "
279	<	<< fDRM1   << " "
280	<	<< fDRNE1 << " "
281	<	<< fDREM1  << " "
282	<	<< fDRCH1  << " "
244	>	<< fNVtx      << " "
245	>	<< fJPt1      << " "
246	>	<< fJEta1     << " "
247	>	<< fJPhi1     << " "
248	>	<< fJD01      << " "
249	>	<< fJDZ1      << " "
250	>	<< fBeta      << " "
251	>	<< fBetaStar  << " "
252	>	<< fNCharged  << " "
253	>	<< fNNeutrals << " "
254	>	<< fDRMean    << " "
255	>	<< fFrac01    << " "
256	>	<< fFrac02    << " "
257	>	<< fFrac03    << " "
258	>	<< fFrac04    << " "
259	>	<< fFrac05
260		<< " === : === "
261		<< lMVA << " "
262		<< std::endl;
#	Line 287 | Line 264 | Double_t JetIDMVA::MVAValue(const PFJet
264
265		return lMVA;
266		}
267	<	Double_t JetIDMVA::MVAValue(const PFJet *iJet,const Vertex *iVertex, //Vertex here is the PV
267	>	Double_t JetIDMVA::MVAValue(const PFJet *iJet,const Vertex *iVertex, const VertexCol *iVertices,//Vertex here is the PV
268		Bool_t printDebug) {
269
270		if (!fIsInitialized) {
#	Line 297 | Line 274 | Double_t JetIDMVA::MVAValue(const PFJet
274		if(!JetTools::passPFLooseId(iJet)) return -2.;
275
276		//set all input variables
277	+	fNVtx      = iVertices->GetEntries();
278		fJPt1      = iJet->Pt();
279		fJEta1     = iJet->RawMom().Eta();
280		fJPhi1     = iJet->RawMom().Phi();
281	<	fJM1       = iJet->Mass();
282	<
283	<	const mithep::PFCandidate *lLead     = JetTools::leadCand(iJet,-1);
284	<	const mithep::PFCandidate *lSecond   = JetTools::leadCand(iJet,-1,true);
285	<	const mithep::PFCandidate *lLeadNeut = JetTools::leadCand(iJet ,5);
286	<	const mithep::PFCandidate *lLeadEm   = JetTools::leadCand(iJet ,4);
287	<	const mithep::PFCandidate *lLeadCh   = JetTools::leadCand(iJet ,1);
288	<
289	<	fJD01         = JetTools::impactParameter(iJet,iVertex);
290	<	fJDZ1         = JetTools::impactParameter(iJet,iVertex,true);
291	<	fNPart1       = iJet->NPFCands();
292	<	fLPt1         = lLead    ->Pt();
293	<	fLEta1        = lLead    ->Eta();
294	<	fLPhi1        = lLead    ->Phi();
295	<	fSPt1         = lSecond  ->Pt();
296	<	fSEta1        = lSecond  ->Eta();
297	<	fSPhi1        = lSecond  ->Phi();
298	<	fNEPt1        = lLeadNeut->Pt();
321	<	fNEEta1       = lLeadNeut->Eta();
322	<	fNEPhi1       = lLeadNeut->Phi();
323	<	fEMPt1        = lLeadEm  ->Pt();
324	<	fEMEta1       = lLeadEm  ->Eta();
325	<	fEMPhi1       = lLeadEm  ->Phi();
326	<	fChPt1        = lLeadCh  ->Pt();
327	<	//fChEta1       = lLeadCh  ->Eta();
328	<	fChPhi1       = lLeadCh  ->Phi();
329	<	fLFr1         = lLead->Pt()/iJet->RawMom().Pt();
330	<
331	<	fDRLC1        = MathUtils::DeltaR(iJet->Mom(),lLead  ->Mom());
332	<	fDRLS1        = MathUtils::DeltaR(iJet->Mom(),lSecond->Mom());
333	<	fDRM1         = JetTools::dRMean (iJet,-1);
334	<	fDRNE1        = JetTools::dRMean (iJet, 5);
335	<	fDREM1        = JetTools::dRMean (iJet, 4);
336	<	fDRCH1        = JetTools::dRMean (iJet, 1);
337	<
338	<	double lMVA = fReader->EvaluateMVA( fMethodName );
339	<
281	>	fJD01      = JetTools::impactParameter(iJet,iVertex);
282	>	fJDZ1      = JetTools::impactParameter(iJet,iVertex,true);
283	>	fBeta      = JetTools::Beta(iJet,iVertex,fDZCut);
284	>	fBetaStar  = JetTools::betaStar(iJet,iVertex,iVertices,fDZCut);
285	>	fNCharged  = iJet->ChargedMultiplicity();
286	>	fNNeutrals = iJet->NeutralMultiplicity();
287	>
288	>	fDRMean    = JetTools::dRMean(iJet,-1);
289	>	fFrac01    = JetTools::frac  (iJet,0.1,0. ,-1);
290	>	fFrac02    = JetTools::frac  (iJet,0.2,0.1,-1);
291	>	fFrac03    = JetTools::frac  (iJet,0.3,0.2,-1);
292	>	fFrac04    = JetTools::frac  (iJet,0.4,0.3,-1);
293	>	fFrac05    = JetTools::frac  (iJet,0.5,0.4,-1);
294	>
295	>	double lMVA = 0;
296	>	if(fJPt1 < 10) lMVA = fReader->EvaluateMVA( fLowPtMethodName  );
297	>	if(fJPt1 > 10) lMVA = fReader->EvaluateMVA( fHighPtMethodName );
298	>
299		if (printDebug == kTRUE) {
300		std::cout << "Debug Jet MVA: "
301	<	<< fNPV    << " "
302	<	<< fJPt1   << " "
303	<	<< fJEta1  << " "
304	<	<< fJPhi1  << " "
305	<	<< fJD01   << " "
306	<	<< fJDZ1   << " "
307	<	<< fJM1    << " "
308	<	<< fNPart1 << " "
309	<	<< fLPt1   << " "
310	<	<< fLEta1  << " "
311	<	<< fLPhi1  << " "
312	<	<< fSPt1   << " "
313	<	<< fSEta1  << " "
314	<	<< fSPhi1  << " "
315	<	<< fNEPt1  << " "
316	<	<< fNEEta1 << " "
358	<	<< fNEPhi1 << " "
359	<	<< fEMPt1  << " "
360	<	<< fEMEta1 << " "
361	<	<< fEMPhi1 << " "
362	<	<< fChPt1  << " "
363	<	<< fChPhi1 << " "
364	<	<< fLFr1   << " "
365	<	<< fDRLC1  << " "
366	<	<< fDRLS1  << " "
367	<	<< fDRM1   << " "
368	<	<< fDRNE1 << " "
369	<	<< fDREM1  << " "
370	<	<< fDRCH1  << " "
301	>	<< fNVtx      << " "
302	>	<< fJPt1      << " "
303	>	<< fJEta1     << " "
304	>	<< fJPhi1     << " "
305	>	<< fJD01      << " "
306	>	<< fJDZ1      << " "
307	>	<< fBeta      << " "
308	>	<< fBetaStar  << " "
309	>	<< fNCharged  << " "
310	>	<< fNNeutrals << " "
311	>	<< fDRMean    << " "
312	>	<< fFrac01    << " "
313	>	<< fFrac02    << " "
314	>	<< fFrac03    << " "
315	>	<< fFrac04    << " "
316	>	<< fFrac05
317		<< " === : === "
318		<< lMVA << " "
319		<< std::endl;

Diff Legend

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