ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

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

Comparing UserCode/MitPhysics/Utils/src/ElectronIDMVA.cc (file contents):
Revision 1.8 by sixie, Wed Jan 4 13:37:14 2012 UTC vs.
Revision 1.14 by sixie, Mon Apr 16 11:05:29 2012 UTC

#	Line 15 | Line 15 | using namespace mithep;
15		//--------------------------------------------------------------------------------------------------
16		ElectronIDMVA::ElectronIDMVA() :
17		fMethodname("BDTG method"),
18	<	fIsInitialized(kFALSE)
18	>	fIsInitialized(kFALSE),
19	>	fMVAType(ElectronIDMVA::kUninitialized),
20	>	fUseBinnedVersion(kTRUE),
21	>	fNMVABins(0)
22		{
23		// Constructor.
21	–	for(UInt_t i=0; i<6; ++i) {
22	–	fTMVAReader[i] = 0;
23	–	}
24		}
25
26
27		//--------------------------------------------------------------------------------------------------
28		ElectronIDMVA::~ElectronIDMVA()
29		{
30	<	for(UInt_t i=0; i<6; ++i) {
30	>	for(UInt_t i=0; i<fTMVAReader.size(); ++i) {
31		if (fTMVAReader[i]) delete fTMVAReader[i];
32		}
33		}
34
35		//--------------------------------------------------------------------------------------------------
36	+	void ElectronIDMVA::Initialize( std::string methodName,
37	+	std::string weightsfile,
38	+	ElectronIDMVA::MVAType type)
39	+	{
40	+
41	+	std::vector<std::string> tempWeightFileVector;
42	+	tempWeightFileVector.push_back(weightsfile);
43	+	Initialize(methodName,type,kFALSE,tempWeightFileVector);
44	+	}
45	+
46	+	//--------------------------------------------------------------------------------------------------
47		void ElectronIDMVA::Initialize( TString methodName,
48		TString Subdet0Pt10To20Weights ,
49		TString Subdet1Pt10To20Weights ,
#	Line 42 | Line 53 | void ElectronIDMVA::Initialize( TString
53		TString Subdet2Pt20ToInfWeights,
54		ElectronIDMVA::MVAType type) {
55
56	+	std::vector<std::string> tempWeightFileVector;
57	+	tempWeightFileVector.push_back(std::string(Subdet0Pt10To20Weights.Data()));
58	+	tempWeightFileVector.push_back(std::string(Subdet1Pt10To20Weights.Data()));
59	+	tempWeightFileVector.push_back(std::string(Subdet2Pt10To20Weights.Data()));
60	+	tempWeightFileVector.push_back(std::string(Subdet0Pt20ToInfWeights.Data()));
61	+	tempWeightFileVector.push_back(std::string(Subdet1Pt20ToInfWeights.Data()));
62	+	tempWeightFileVector.push_back(std::string(Subdet2Pt20ToInfWeights.Data()));
63	+	Initialize(std::string(methodName.Data()),type,kTRUE,tempWeightFileVector);
64	+
65	+	}
66	+
67	+
68	+	//--------------------------------------------------------------------------------------------------
69	+	void ElectronIDMVA::Initialize(  std::string methodName,
70	+	ElectronIDMVA::MVAType type,
71	+	Bool_t useBinnedVersion,
72	+	std::vector<std::string> weightsfiles
73	+
74	+	) {
75	+
76	+	//clean up first
77	+	for (uint i=0;i<fTMVAReader.size(); ++i) {
78	+	if (fTMVAReader[i]) delete fTMVAReader[i];
79	+	}
80	+	fTMVAReader.clear();
81	+
82	+	//initialize
83		fIsInitialized = kTRUE;
46	–
84		fMethodname = methodName;
85	<
86	<	for(UInt_t i=0; i<6; ++i) {
87	<	if (fTMVAReader[i]) delete fTMVAReader[i];
85	>	fMVAType = type;
86	>	fUseBinnedVersion = useBinnedVersion;
87	>
88	>	//Define expected number of bins
89	>	UInt_t ExpectedNBins = 0;
90	>	if (!fUseBinnedVersion) {
91	>	ExpectedNBins = 1;
92	>	} else if (type == kBaseline
93	>	||type == kNoIPInfo
94	>	||type == kWithIPInfo
95	>	||type == kIDIsoCombined) {
96	>	ExpectedNBins = 6;
97	>	} else if (type == kIDEGamma2012TrigV0 ||
98	>	type == kIDEGamma2012NonTrigV0) {
99	>	ExpectedNBins = 6;
100	>	} else if (type == kIsoRingsV0) {
101	>	ExpectedNBins = 4;
102	>	}
103	>	fNMVABins = ExpectedNBins;
104	>
105	>	//Check number of weight files given
106	>	if (fNMVABins != weightsfiles.size() ) {
107	>	std::cout << "Error: Expected Number of bins = " << fNMVABins << " does not equal to weightsfiles.size() = "
108	>	<< weightsfiles.size() << std::endl;
109	>	assert(fNMVABins == weightsfiles.size());
110	>	}
111
112	<	fTMVAReader[i] = new TMVA::Reader( "!Color:!Silent:Error" );
113	<	fTMVAReader[i]->SetVerbose(kTRUE);
112	>
113	>	for(UInt_t i=0; i<fNMVABins; ++i) {
114	>	TMVA::Reader *tmpTMVAReader = new TMVA::Reader( "!Color:!Silent:Error" );
115	>	tmpTMVAReader->SetVerbose(kTRUE);
116
117		if (type == kBaseline) {
118	<	fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
119	<	fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
120	<	fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
121	<	fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
122	<	fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
123	<	fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                    );
124	<	fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
125	<	}
64	<
118	>	tmpTMVAReader->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
119	>	tmpTMVAReader->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
120	>	tmpTMVAReader->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
121	>	tmpTMVAReader->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
122	>	tmpTMVAReader->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
123	>	tmpTMVAReader->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                    );
124	>	tmpTMVAReader->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
125	>	}
126		if (type == kNoIPInfo) {
127	<	fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
128	<	fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
129	<	fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
130	<	fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
131	<	fTMVAReader[i]->AddVariable( "EOverP",                &fMVAVar_EleEOverP                   );
132	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout     );
133	<	fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
134	<	fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                    );
135	<	fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
136	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn      );
127	>	tmpTMVAReader->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
128	>	tmpTMVAReader->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
129	>	tmpTMVAReader->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
130	>	tmpTMVAReader->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
131	>	tmpTMVAReader->AddVariable( "EOverP",                &fMVAVar_EleEOverP                   );
132	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout     );
133	>	tmpTMVAReader->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
134	>	tmpTMVAReader->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                    );
135	>	tmpTMVAReader->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
136	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn      );
137		}
138		if (type == kWithIPInfo) {
139	<	fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
140	<	fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
141	<	fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
142	<	fTMVAReader[i]->AddVariable( "D0",                    &fMVAVar_EleD0                       );
143	<	fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
144	<	fTMVAReader[i]->AddVariable( "EOverP",                &fMVAVar_EleEOverP                   );
145	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout     );
146	<	fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
147	<	fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                    );
148	<	fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
149	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn      );
150	<	fTMVAReader[i]->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                     );
151	<	fTMVAReader[i]->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig                  );
139	>	tmpTMVAReader->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
140	>	tmpTMVAReader->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
141	>	tmpTMVAReader->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
142	>	tmpTMVAReader->AddVariable( "D0",                    &fMVAVar_EleD0                       );
143	>	tmpTMVAReader->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
144	>	tmpTMVAReader->AddVariable( "EOverP",                &fMVAVar_EleEOverP                   );
145	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout     );
146	>	tmpTMVAReader->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
147	>	tmpTMVAReader->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                    );
148	>	tmpTMVAReader->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
149	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn      );
150	>	tmpTMVAReader->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                     );
151	>	tmpTMVAReader->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig                  );
152		}
153		if (type == kIDIsoCombined) {
154	<	fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
155	<	fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
156	<	fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
157	<	fTMVAReader[i]->AddVariable( "D0",                    &fMVAVar_EleD0                       );
158	<	fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
159	<	fTMVAReader[i]->AddVariable( "EOverP",                &fMVAVar_EleEOverP                   );
160	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout     );
161	<	fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
162	<	fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
163	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn      );
164	<	fTMVAReader[i]->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                     );
165	<	fTMVAReader[i]->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig                  );
166	<
167	<	fTMVAReader[i]->AddVariable( "GsfTrackChi2OverNdof",  &fMVAVar_EleGsfTrackChi2OverNdof     );
168	<	fTMVAReader[i]->AddVariable( "dEtaCalo",              &fMVAVar_EledEtaCalo                 );
169	<	fTMVAReader[i]->AddVariable( "dPhiCalo",              &fMVAVar_EledPhiCalo                 );
170	<	fTMVAReader[i]->AddVariable( "R9",                    &fMVAVar_EleR9                       );
171	<	fTMVAReader[i]->AddVariable( "SCEtaWidth",            &fMVAVar_EleSCEtaWidth               );
172	<	fTMVAReader[i]->AddVariable( "SCPhiWidth",            &fMVAVar_EleSCPhiWidth               );
173	<	fTMVAReader[i]->AddVariable( "CovIEtaIPhi",           &fMVAVar_EleCovIEtaIPhi              );
154	>	tmpTMVAReader->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
155	>	tmpTMVAReader->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
156	>	tmpTMVAReader->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
157	>	tmpTMVAReader->AddVariable( "D0",                    &fMVAVar_EleD0                       );
158	>	tmpTMVAReader->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
159	>	tmpTMVAReader->AddVariable( "EOverP",                &fMVAVar_EleEOverP                   );
160	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout     );
161	>	tmpTMVAReader->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
162	>	tmpTMVAReader->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
163	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn      );
164	>	tmpTMVAReader->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                     );
165	>	tmpTMVAReader->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig                  );
166	>
167	>	tmpTMVAReader->AddVariable( "GsfTrackChi2OverNdof",  &fMVAVar_EleGsfTrackChi2OverNdof     );
168	>	tmpTMVAReader->AddVariable( "dEtaCalo",              &fMVAVar_EledEtaCalo                 );
169	>	tmpTMVAReader->AddVariable( "dPhiCalo",              &fMVAVar_EledPhiCalo                 );
170	>	tmpTMVAReader->AddVariable( "R9",                    &fMVAVar_EleR9                       );
171	>	tmpTMVAReader->AddVariable( "SCEtaWidth",            &fMVAVar_EleSCEtaWidth               );
172	>	tmpTMVAReader->AddVariable( "SCPhiWidth",            &fMVAVar_EleSCPhiWidth               );
173	>	tmpTMVAReader->AddVariable( "CovIEtaIPhi",           &fMVAVar_EleCovIEtaIPhi              );
174		if (i == 2 || i == 5) {
175	<	fTMVAReader[i]->AddVariable( "PreShowerOverRaw",      &fMVAVar_ElePreShowerOverRaw       );
175	>	tmpTMVAReader->AddVariable( "PreShowerOverRaw",      &fMVAVar_ElePreShowerOverRaw       );
176		}
177	<	fTMVAReader[i]->AddVariable( "ChargedIso03",          &fMVAVar_EleChargedIso03OverPt       );
178	<	fTMVAReader[i]->AddVariable( "NeutralHadronIso03",    &fMVAVar_EleNeutralHadronIso03OverPt );
179	<	fTMVAReader[i]->AddVariable( "GammaIso03",            &fMVAVar_EleGammaIso03OverPt         );
180	<	fTMVAReader[i]->AddVariable( "ChargedIso04",          &fMVAVar_EleChargedIso04OverPt       );
181	<	fTMVAReader[i]->AddVariable( "NeutralHadronIso04",    &fMVAVar_EleNeutralHadronIso04OverPt );
182	<	fTMVAReader[i]->AddVariable( "GammaIso04",            &fMVAVar_EleGammaIso04OverPt         );
177	>	tmpTMVAReader->AddVariable( "ChargedIso03",          &fMVAVar_EleChargedIso03OverPt       );
178	>	tmpTMVAReader->AddVariable( "NeutralHadronIso03",    &fMVAVar_EleNeutralHadronIso03OverPt );
179	>	tmpTMVAReader->AddVariable( "GammaIso03",            &fMVAVar_EleGammaIso03OverPt         );
180	>	tmpTMVAReader->AddVariable( "ChargedIso04",          &fMVAVar_EleChargedIso04OverPt       );
181	>	tmpTMVAReader->AddVariable( "NeutralHadronIso04",    &fMVAVar_EleNeutralHadronIso04OverPt );
182	>	tmpTMVAReader->AddVariable( "GammaIso04",            &fMVAVar_EleGammaIso04OverPt         );
183
184		}
185
186	<	if (i==0) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt10To20Weights );
187	<	if (i==1) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt10To20Weights );
188	<	if (i==2) fTMVAReader[i]->BookMVA(fMethodname , Subdet2Pt10To20Weights );
189	<	if (i==3) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt20ToInfWeights );
190	<	if (i==4) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt20ToInfWeights );
191	<	if (i==5) fTMVAReader[i]->BookMVA(fMethodname , Subdet2Pt20ToInfWeights );
186	>	if (type == kIDEGamma2012TrigV0 || type == kIDEGamma2012NonTrigV0 ) {
187	>	// Pure tracking variables
188	>	tmpTMVAReader->AddVariable("fbrem",           &fMVAVar_EleFBrem);
189	>	tmpTMVAReader->AddVariable("kfchi2",          &fMVAVar_EleKFTrkChiSqr);
190	>	tmpTMVAReader->AddVariable("kfhits",          &fMVAVar_EleKFTrkNLayers);  //Don't have this in (BAMBU <= 025)
191	>	tmpTMVAReader->AddVariable("kfhitsall",       &fMVAVar_EleKFTrkNHits);
192	>	tmpTMVAReader->AddVariable("gsfchi2",         &fMVAVar_EleGsfTrackChi2OverNdof);
193	>	tmpTMVAReader->AddVariable("deta",            &fMVAVar_EleDEtaIn);
194	>	tmpTMVAReader->AddVariable("dphi",            &fMVAVar_EleDPhiIn);
195	>	tmpTMVAReader->AddVariable("detacalo",        &fMVAVar_EledEtaCalo);
196	>	tmpTMVAReader->AddVariable("see",             &fMVAVar_EleSigmaIEtaIEta);
197	>	tmpTMVAReader->AddVariable("spp",             &fMVAVar_EleSigmaIPhiIPhi);
198	>	tmpTMVAReader->AddVariable("etawidth",        &fMVAVar_EleSCEtaWidth);
199	>	tmpTMVAReader->AddVariable("phiwidth",        &fMVAVar_EleSCPhiWidth);
200	>	tmpTMVAReader->AddVariable("e1x5e5x5",        &fMVAVar_EleE1x5OverE5x5);
201	>	tmpTMVAReader->AddVariable("R9",              &fMVAVar_EleR9);
202	>	tmpTMVAReader->AddVariable("HoE",             &fMVAVar_EleHoverE);
203	>	tmpTMVAReader->AddVariable("EoP",             &fMVAVar_EleEOverP);
204	>	tmpTMVAReader->AddVariable("IoEmIoP",         &fMVAVar_EleOneOverEMinusOneOverP);
205	>	tmpTMVAReader->AddVariable("eleEoPout",       &fMVAVar_EleEEleClusterOverPout); //Don't have this in (BAMBU <= 025)
206	>	tmpTMVAReader->AddVariable("EoPout",          &fMVAVar_EleESeedClusterOverPout);
207	>	tmpTMVAReader->AddVariable("PreShowerOverRaw",&fMVAVar_ElePreShowerOverRaw);
208	>
209	>	tmpTMVAReader->AddSpectator("eta",            &fMVAVar_EleEta);
210	>	tmpTMVAReader->AddSpectator("pt",             &fMVAVar_ElePt);
211	>	}
212	>
213	>	if (type == kIsoRingsV0) {
214	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p0To0p1",         &fMVAVar_ChargedIso_DR0p0To0p1        );
215	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p1To0p2",         &fMVAVar_ChargedIso_DR0p1To0p2        );
216	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p2To0p3",         &fMVAVar_ChargedIso_DR0p2To0p3        );
217	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p3To0p4",         &fMVAVar_ChargedIso_DR0p3To0p4        );
218	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p4To0p5",         &fMVAVar_ChargedIso_DR0p4To0p5        );
219	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p0To0p1",           &fMVAVar_GammaIso_DR0p0To0p1          );
220	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p1To0p2",           &fMVAVar_GammaIso_DR0p1To0p2          );
221	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p2To0p3",           &fMVAVar_GammaIso_DR0p2To0p3          );
222	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p3To0p4",           &fMVAVar_GammaIso_DR0p3To0p4          );
223	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p4To0p5",           &fMVAVar_GammaIso_DR0p4To0p5          );
224	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p0To0p1",   &fMVAVar_NeutralHadronIso_DR0p0To0p1  );
225	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p1To0p2",   &fMVAVar_NeutralHadronIso_DR0p1To0p2  );
226	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p2To0p3",   &fMVAVar_NeutralHadronIso_DR0p2To0p3  );
227	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p3To0p4",   &fMVAVar_NeutralHadronIso_DR0p3To0p4  );
228	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p4To0p5",   &fMVAVar_NeutralHadronIso_DR0p4To0p5  );
229	>	tmpTMVAReader->AddSpectator( "eta",   &fMVAVar_EleEta );
230	>	tmpTMVAReader->AddSpectator( "pt" ,   &fMVAVar_ElePt  );
231	>	}
232	>
233	>	tmpTMVAReader->BookMVA(fMethodname , weightsfiles[i] );
234	>	std::cout << "MVABin " << i << " : MethodName = " << fMethodname
235	>	<< " , type == " << type << " , "
236	>	<< "Load weights file : " << weightsfiles[i]
237	>	<< std::endl;
238	>	fTMVAReader.push_back(tmpTMVAReader);
239
240		}
241	+	std::cout << "Electron ID MVA Completed\n";
242	+	}
243	+
244	+
245	+	//--------------------------------------------------------------------------------------------------
246	+	UInt_t ElectronIDMVA::GetMVABin( double eta, double pt) const {
247	+
248	+	//Default is to return the first bin
249	+	uint bin = 0;
250	+
251	+	//return the first bin if not using binned version
252	+	if (!fUseBinnedVersion) return 0;
253
254	<	std::cout << "Electron ID MVA Initialization\n";
255	<	std::cout << "MethodName : " << fMethodname << " , type == " << type << std::endl;
256	<	std::cout << "Load weights file : " << Subdet0Pt10To20Weights << std::endl;
257	<	std::cout << "Load weights file : " << Subdet1Pt10To20Weights << std::endl;
258	<	std::cout << "Load weights file : " << Subdet2Pt10To20Weights << std::endl;
259	<	std::cout << "Load weights file : " << Subdet0Pt20ToInfWeights << std::endl;
260	<	std::cout << "Load weights file : " << Subdet1Pt20ToInfWeights << std::endl;
261	<	std::cout << "Load weights file : " << Subdet2Pt20ToInfWeights << std::endl;
254	>	if (fMVAType == ElectronIDMVA::kBaseline
255	>	||fMVAType == ElectronIDMVA::kNoIPInfo
256	>	||fMVAType == ElectronIDMVA::kWithIPInfo
257	>	||fMVAType == ElectronIDMVA::kIDIsoCombined) {
258	>	if (pt < 20 && fabs(eta) < 1.0) bin = 0;
259	>	if (pt < 20 && fabs(eta) >= 1.0 && fabs(eta) < 1.479) bin = 1;
260	>	if (pt < 20 && fabs(eta) >= 1.479) bin = 2;
261	>	if (pt >= 20 && fabs(eta) < 1.0) bin = 3;
262	>	if (pt >= 20 && fabs(eta) >= 1.0 && fabs(eta) < 1.479) bin = 4;
263	>	if (pt >= 20 && fabs(eta) >= 1.479) bin = 5;
264	>	}
265	>
266	>	if (fMVAType == ElectronIDMVA::kIsoRingsV0) {
267	>	if (pt < 10 && fabs(eta) < 1.479) bin = 0;
268	>	if (pt < 10 && fabs(eta) >= 1.479) bin = 1;
269	>	if (pt >= 10 && fabs(eta) < 1.479) bin = 2;
270	>	if (pt >= 10 && fabs(eta) >= 1.479) bin = 3;
271	>	}
272
273	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
274	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ) {
275	+	bin = 0;
276	+	if (pt < 10 && fabs(eta) < 0.8) bin = 0;
277	+	if (pt < 10 && fabs(eta) >= 0.8 && fabs(eta) < 1.479 ) bin = 1;
278	+	if (pt < 10 && fabs(eta) >= 1.479) bin = 2;
279	+	if (pt >= 10 && fabs(eta) < 0.8) bin = 3;
280	+	if (pt >= 10 && fabs(eta) >= 0.8 && fabs(eta) < 1.479 ) bin = 4;
281	+	if (pt >= 10 && fabs(eta) >= 1.479) bin = 5;
282	+	}
283	+
284	+	return bin;
285		}
286
287	+
288	+
289		//--------------------------------------------------------------------------------------------------
290		Double_t ElectronIDMVA::MVAValue(Double_t ElePt , Double_t EleEta,
291		Double_t EleSigmaIEtaIEta,
#	Line 166 | Line 310 | Double_t ElectronIDMVA::MVAValue(Double_
310		return -9999;
311		}
312
169	–	Int_t subdet = 0;
170	–	if (fabs(EleEta) < 1.0) subdet = 0;
171	–	else if (fabs(EleEta) < 1.479) subdet = 1;
172	–	else subdet = 2;
173	–	Int_t ptBin = 0;
174	–	if (ElePt > 20.0) ptBin = 1;
175	–
313		//set all input variables
314		fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
315		fMVAVar_EleDEtaIn = EleDEtaIn;
#	Line 192 | Line 329 | Double_t ElectronIDMVA::MVAValue(Double_
329
330		Double_t mva = -9999;
331		TMVA::Reader *reader = 0;
332	<	Int_t MVABin = -1;
196	<	if (subdet == 0 && ptBin == 0) MVABin = 0;
197	<	if (subdet == 1 && ptBin == 0) MVABin = 1;
198	<	if (subdet == 2 && ptBin == 0) MVABin = 2;
199	<	if (subdet == 0 && ptBin == 1) MVABin = 3;
200	<	if (subdet == 1 && ptBin == 1) MVABin = 4;
201	<	if (subdet == 2 && ptBin == 1) MVABin = 5;
202	<	assert(MVABin >= 0 && MVABin <= 5);
203	<	reader = fTMVAReader[MVABin];
332	>	reader = fTMVAReader[GetMVABin( EleEta, ElePt)];
333
334		mva = reader->EvaluateMVA( fMethodname );
335
#	Line 237 | Line 366 | Double_t ElectronIDMVA::MVAValue(Double_
366		Double_t EleGammaIso03,
367		Double_t EleChargedIso04,
368		Double_t EleNeutralHadronIso04,
369	<	Double_t EleGammaIso04
369	>	Double_t EleGammaIso04,
370	>	Bool_t printDebug
371		) {
372
373		if (!fIsInitialized) {
#	Line 248 | Line 378 | Double_t ElectronIDMVA::MVAValue(Double_
378		Double_t Rho = 0;
379		if (!(TMath::IsNaN(PileupEnergyDensity) || isinf(PileupEnergyDensity))) Rho = PileupEnergyDensity;
380
251	–	Int_t subdet = 0;
252	–	if (fabs(EleEta) < 1.0) subdet = 0;
253	–	else if (fabs(EleEta) < 1.479) subdet = 1;
254	–	else subdet = 2;
255	–	Int_t ptBin = 0;
256	–	if (ElePt > 20.0) ptBin = 1;
257	–
381		//set all input variables
382		fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
383		fMVAVar_EleDEtaIn = EleDEtaIn;
#	Line 301 | Line 424 | Double_t ElectronIDMVA::MVAValue(Double_
424		= (EleGammaIso04
425		- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso04, EleEta)
426		+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip04,EleEta))/ElePt;
427	<
427	>
428	>
429	>
430	>
431		Double_t mva = -9999;
432		TMVA::Reader *reader = 0;
433	<	Int_t MVABin = -1;
308	<	if (subdet == 0 && ptBin == 0) MVABin = 0;
309	<	if (subdet == 1 && ptBin == 0) MVABin = 1;
310	<	if (subdet == 2 && ptBin == 0) MVABin = 2;
311	<	if (subdet == 0 && ptBin == 1) MVABin = 3;
312	<	if (subdet == 1 && ptBin == 1) MVABin = 4;
313	<	if (subdet == 2 && ptBin == 1) MVABin = 5;
314	<	assert(MVABin >= 0 && MVABin <= 5);
315	<	reader = fTMVAReader[MVABin];
316	<
433	>	reader = fTMVAReader[GetMVABin( EleEta, ElePt)];
434		mva = reader->EvaluateMVA( fMethodname );
435
436	<	Bool_t printdebug = kTRUE;
320	<	if (printdebug == kTRUE) {
436	>	if (printDebug == kTRUE) {
437		std::cout << "Debug Electron MVA: "
438	<	<< ElePt << " " << EleEta << " " << " --> MVABin " << MVABin << " : "
438	>	<< ElePt << " " << EleEta << " " << " --> MVABin " << GetMVABin( EleEta, ElePt) << " : "
439		<< fMVAVar_EleSigmaIEtaIEta << " "
440		<< fMVAVar_EleDEtaIn << " "
441		<< fMVAVar_EleDPhiIn << " "
#	Line 361 | Line 477 | Double_t ElectronIDMVA::MVAValue(Double_
477		//--------------------------------------------------------------------------------------------------
478		Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
479		const PFCandidateCol *PFCands,
480	<	const PileupEnergyDensityCol *PileupEnergyDensity) {
480	>	const PileupEnergyDensityCol *PileupEnergyDensity,
481	>	Double_t intRadius,
482	>	Bool_t printDebug) {
483
484		if (!fIsInitialized) {
485		std::cout << "Error: ElectronIDMVA not properly initialized.\n";
486		return -9999;
487		}
488
371	–	Int_t subdet = 0;
372	–	if (ele->SCluster()->AbsEta() < 1.0) subdet = 0;
373	–	else if (ele->SCluster()->AbsEta() < 1.479) subdet = 1;
374	–	else subdet = 2;
375	–	Int_t ptBin = 0;
376	–	if (ele->Pt() > 20.0) ptBin = 1;
377	–
489		Double_t Rho = 0;
490		if (!(TMath::IsNaN(PileupEnergyDensity->At(0)->Rho()) || isinf(PileupEnergyDensity->At(0)->Rho()))) Rho = PileupEnergyDensity->At(0)->Rho();
491
#	Line 404 | Line 515 | Double_t ElectronIDMVA::MVAValue(const E
515		fMVAVar_EleCovIEtaIPhi = ele->SCluster()->Seed()->CoviEtaiPhi();
516		fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
517		fMVAVar_EleChargedIso03OverPt
518	<	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 99999, 0.3, 0.0)
518	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 99999, 0.3, intRadius)
519		- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso03, ele->SCluster()->Eta())) / ele->Pt();
520		fMVAVar_EleNeutralHadronIso03OverPt
521	<	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.3, 0.0, PFCandidate::eNeutralHadron)
521	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.3, intRadius, PFCandidate::eNeutralHadron)
522		- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso03, ele->SCluster()->Eta())
523		+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,ele->SCluster()->Eta())) / ele->Pt();
524		fMVAVar_EleGammaIso03OverPt
525	<	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.3, 0.0, PFCandidate::eGamma)
525	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.3, intRadius, PFCandidate::eGamma)
526		- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso03, ele->SCluster()->Eta())
527		+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip03,ele->SCluster()->Eta())) / ele->Pt();
528		fMVAVar_EleChargedIso04OverPt
529	<	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 99999, 0.4, 0.0)
529	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 99999, 0.4, intRadius)
530		- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso04, ele->SCluster()->Eta())) / ele->Pt();
531		fMVAVar_EleNeutralHadronIso04OverPt
532	<	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.4, 0.0, PFCandidate::eNeutralHadron)
532	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.4, intRadius, PFCandidate::eNeutralHadron)
533		- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso04, ele->SCluster()->Eta())
534		+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,ele->SCluster()->Eta())) / ele->Pt() ;
535		fMVAVar_EleGammaIso04OverPt
536	<	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.4, 0.0, PFCandidate::eGamma)
536	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.4, intRadius, PFCandidate::eGamma)
537		- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso04, ele->SCluster()->Eta())
538		+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip04,ele->SCluster()->Eta())) / ele->Pt();
539
540	+	//Additional vars
541	+	fMVAVar_EleEEleClusterOverPout = ele->EEleClusterOverPout();
542	+	if (ele->TrackerTrk()) {
543	+	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
544	+	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
545	+	} else {
546	+	fMVAVar_EleKFTrkChiSqr = -1;
547	+	fMVAVar_EleKFTrkNHits = 0;
548	+	}
549	+	fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5() / ele->SCluster()->Seed()->E5x5();
550	+
551	+
552		Double_t mva = -9999;
553		TMVA::Reader *reader = 0;
554	<	Int_t MVABin = -1;
432	<	if (subdet == 0 && ptBin == 0) MVABin = 0;
433	<	if (subdet == 1 && ptBin == 0) MVABin = 1;
434	<	if (subdet == 2 && ptBin == 0) MVABin = 2;
435	<	if (subdet == 0 && ptBin == 1) MVABin = 3;
436	<	if (subdet == 1 && ptBin == 1) MVABin = 4;
437	<	if (subdet == 2 && ptBin == 1) MVABin = 5;
438	<	assert(MVABin >= 0 && MVABin <= 5);
439	<	reader = fTMVAReader[MVABin];
440	<
554	>	reader = fTMVAReader[GetMVABin( ele->SCluster()->Eta(), ele->Pt())];
555		mva = reader->EvaluateMVA( fMethodname );
556
557	<	Bool_t printdebug = kTRUE;
444	<	if (printdebug == kTRUE) {
557	>	if (printDebug == kTRUE) {
558		std::cout << "Debug Electron MVA: "
559		<< ele->Pt() << " " << ele->Eta() << " " << ele->Phi() << " : "
560	<	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << MVABin << " : "
560	>	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << GetMVABin( ele->SCluster()->Eta(), ele->Pt()) << " : "
561		<< fMVAVar_EleSigmaIEtaIEta << " "
562		<< fMVAVar_EleDEtaIn << " "
563		<< fMVAVar_EleDPhiIn << " "
#	Line 468 | Line 581 | Double_t ElectronIDMVA::MVAValue(const E
581		<< fMVAVar_EleSCPhiWidth << " "
582		<< fMVAVar_EleCovIEtaIPhi << " "
583		<< fMVAVar_ElePreShowerOverRaw << " "
584	<	<< fMVAVar_EleChargedIso03OverPt  << " "
585	<	<< fMVAVar_EleNeutralHadronIso03OverPt  << " "
586	<	<< fMVAVar_EleGammaIso03OverPt  << " "
587	<	<< fMVAVar_EleChargedIso04OverPt  << " "
588	<	<< fMVAVar_EleNeutralHadronIso04OverPt  << " "
476	<	<< fMVAVar_EleGammaIso04OverPt  << " "
584	>	<< fMVAVar_EleKFTrkChiSqr  << " "
585	>	<< fMVAVar_EleKFTrkNHits  << " "
586	>	<< fMVAVar_EleE1x5OverE5x5  << " "
587	>	<< " ::: "
588	>
589		<< " === : === "
590		<< mva << " "
591		<< std::endl;
#	Line 484 | Line 596 | Double_t ElectronIDMVA::MVAValue(const E
596		}
597
598		//--------------------------------------------------------------------------------------------------
599	<	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex) {
599	>	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
600	>	Bool_t printDebug) {
601
602		if (!fIsInitialized) {
603		std::cout << "Error: ElectronIDMVA not properly initialized.\n";
604		return -9999;
605		}
606
607	<	Int_t subdet = 0;
608	<	if (ele->SCluster()->AbsEta() < 1.0) subdet = 0;
609	<	else if (ele->SCluster()->AbsEta() < 1.479) subdet = 1;
497	<	else subdet = 2;
498	<	Int_t ptBin = 0;
499	<	if (ele->Pt() > 20.0) ptBin = 1;
500	<
607	>	fMVAVar_ElePt = ele->Pt();
608	>	fMVAVar_EleEta = ele->Eta();
609	>
610		//set all input variables
611		fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
612		fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
#	Line 516 | Line 625 | Double_t ElectronIDMVA::MVAValue(const E
625		fMVAVar_EleIP3d = ele->Ip3dPV();
626		fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
627
628	+
629	+	fMVAVar_EleEEleClusterOverPout = 0;
630	+	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
631	+	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
632	+	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
633	+	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
634	+	fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
635	+	fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
636	+	fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5() / ele->SCluster()->Seed()->E5x5();
637	+	fMVAVar_EleR9 = ele->SCluster()->R9();
638	+	fMVAVar_EleHoverE = ele->HadronicOverEm();
639	+	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
640	+	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
641	+	fMVAVar_EleR9 = ele->SCluster()->R9();
642	+	fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
643	+
644	+
645		Double_t mva = -9999;
646		TMVA::Reader *reader = 0;
647	<	Int_t MVABin = -1;
648	<	if (subdet == 0 && ptBin == 0) MVABin = 0;
649	<	if (subdet == 1 && ptBin == 0) MVABin = 1;
650	<	if (subdet == 2 && ptBin == 0) MVABin = 2;
651	<	if (subdet == 0 && ptBin == 1) MVABin = 3;
652	<	if (subdet == 1 && ptBin == 1) MVABin = 4;
653	<	if (subdet == 2 && ptBin == 1) MVABin = 5;
654	<	assert(MVABin >= 0 && MVABin <= 5);
655	<	reader = fTMVAReader[MVABin];
656	<
647	>	reader = fTMVAReader[GetMVABin( ele->SCluster()->Eta(), ele->Pt())];
648	>	mva = reader->EvaluateMVA( fMethodname );
649	>
650	>	if (printDebug == kTRUE) {
651	>	std::cout << "Debug Electron MVA: "
652	>	<< ele->Pt() << " " << ele->Eta() << " " << ele->Phi() << " : "
653	>	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << GetMVABin( ele->SCluster()->Eta(), ele->Pt()) << " : "
654	>	<< fMVAVar_EleSigmaIEtaIEta << " "
655	>	<< fMVAVar_EleDEtaIn << " "
656	>	<< fMVAVar_EleDPhiIn << " "
657	>	<< fMVAVar_EleHoverE << " "
658	>	<< fMVAVar_EleD0 << " "
659	>	<< fMVAVar_EleDZ << " "
660	>	<< fMVAVar_EleFBrem << " "
661	>	<< fMVAVar_EleEOverP << " "
662	>	<< fMVAVar_EleESeedClusterOverPout << " "
663	>	<< fMVAVar_EleSigmaIPhiIPhi << " "
664	>	<< fMVAVar_EleNBrem << " "
665	>	<< fMVAVar_EleOneOverEMinusOneOverP << " "
666	>	<< fMVAVar_EleESeedClusterOverPIn << " "
667	>	<< fMVAVar_EleIP3d << " "
668	>	<< fMVAVar_EleIP3dSig << " "
669	>	<< fMVAVar_EleGsfTrackChi2OverNdof << " "
670	>	<< fMVAVar_EledEtaCalo << " "
671	>	<< fMVAVar_EledPhiCalo << " "
672	>	<< fMVAVar_EleR9 << " "
673	>	<< fMVAVar_EleSCEtaWidth << " "
674	>	<< fMVAVar_EleSCPhiWidth << " "
675	>	<< fMVAVar_EleCovIEtaIPhi << " "
676	>	<< fMVAVar_ElePreShowerOverRaw << " "
677	>	<< fMVAVar_EleKFTrkChiSqr  << " "
678	>	<< fMVAVar_EleKFTrkNHits  << " "
679	>	<< fMVAVar_EleE1x5OverE5x5  << " "
680	>	<< " === : === "
681	>	<< mva << " "
682	>	<< std::endl;
683	>
684	>	}
685	>
686	>
687	>
688	>	return mva;
689	>	}
690	>
691	>
692	>
693	>
694	>	//--------------------------------------------------------------------------------------------------
695	>	//MVA Includes Isolation with removal of other leptons
696	>	//
697	>	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
698	>	const PFCandidateCol *PFCands,
699	>	const PileupEnergyDensityCol *PileupEnergyDensity,
700	>	ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaTarget,
701	>	const ElectronCol *goodElectrons,
702	>	const MuonCol *goodMuons,
703	>	Bool_t printDebug) {
704	>
705	>	if (!fIsInitialized) {
706	>	std::cout << "Error: ElectronIDMVA not properly initialized.\n";
707	>	return -9999;
708	>	}
709	>
710	>	Double_t Rho = 0;
711	>	if (!(TMath::IsNaN(PileupEnergyDensity->At(0)->Rho()) || isinf(PileupEnergyDensity->At(0)->Rho()))) Rho = PileupEnergyDensity->At(0)->Rho();
712	>
713	>	//set all input variables
714	>	fMVAVar_ElePt = ele->Pt();
715	>	fMVAVar_EleEta = ele->SCluster()->Eta();
716	>	fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
717	>	fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
718	>	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
719	>	fMVAVar_EleHoverE = ele->HadronicOverEm();
720	>	fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
721	>	fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
722	>	fMVAVar_EleFBrem = ele->FBrem();
723	>	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
724	>	fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
725	>	if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
726	>	else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
727	>	fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
728	>
729	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0
730	>	|| fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0
731	>	|| fMVAType == ElectronIDMVA::kIsoRingsV0) {
732	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->P();
733	>	} else {
734	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
735	>	}
736	>
737	>	fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
738	>	fMVAVar_EleIP3d = ele->Ip3dPV();
739	>	fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
740	>	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
741	>	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
742	>	fMVAVar_EledPhiCalo = ele->DeltaPhiSeedClusterTrackAtCalo();
743	>	fMVAVar_EleR9 = ele->SCluster()->R9();
744	>	fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
745	>	fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
746	>	fMVAVar_EleCovIEtaIPhi = ele->SCluster()->Seed()->CoviEtaiPhi();
747	>	fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
748	>
749	>	//Additional vars
750	>	fMVAVar_EleEEleClusterOverPout = 0;
751	>	if (ele->TrackerTrk()) {
752	>	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
753	>	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
754	>	fMVAVar_EleKFTrkNLayers = ele->CTFTrkNLayersWithMeasurement();
755	>	} else {
756	>	fMVAVar_EleKFTrkChiSqr = -1;
757	>	fMVAVar_EleKFTrkNHits = 0;
758	>	fMVAVar_EleKFTrkNLayers = 0;
759	>	}
760	>
761	>	fMVAVar_EleE1x5OverE5x5 = (ele->SCluster()->Seed()->E5x5() > 0.0) ? 1.0-ele->SCluster()->Seed()->E1x5() / ele->SCluster()->Seed()->E5x5() : -1. ;
762	>
763	>	Double_t tmpChargedIso_DR0p0To0p1  = 0;
764	>	Double_t tmpChargedIso_DR0p1To0p2  = 0;
765	>	Double_t tmpChargedIso_DR0p2To0p3  = 0;
766	>	Double_t tmpChargedIso_DR0p3To0p4  = 0;
767	>	Double_t tmpChargedIso_DR0p4To0p5  = 0;
768	>	Double_t tmpGammaIso_DR0p0To0p1  = 0;
769	>	Double_t tmpGammaIso_DR0p1To0p2  = 0;
770	>	Double_t tmpGammaIso_DR0p2To0p3  = 0;
771	>	Double_t tmpGammaIso_DR0p3To0p4  = 0;
772	>	Double_t tmpGammaIso_DR0p4To0p5  = 0;
773	>	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
774	>	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
775	>	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
776	>	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
777	>	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
778	>
779	>	for (UInt_t p=0; p<PFCands->GetEntries();p++) {
780	>	const PFCandidate *pf = PFCands->At(p);
781	>
782	>	//exclude the electron itself
783	>	if(pf->GsfTrk() && ele->GsfTrk() &&
784	>	pf->GsfTrk() == ele->GsfTrk()) continue;
785	>	if(pf->TrackerTrk() && ele->TrackerTrk() &&
786	>	pf->TrackerTrk() == ele->TrackerTrk()) continue;
787	>
788	>	//************************************************************
789	>	// New Isolation Calculations
790	>	//************************************************************
791	>	Double_t dr = MathUtils::DeltaR(ele->Mom(), pf->Mom());
792	>
793	>	if (dr < 1.0) {
794	>	Bool_t IsLeptonFootprint = kFALSE;
795	>	//************************************************************
796	>	// Lepton Footprint Removal
797	>	//************************************************************
798	>	for (UInt_t q=0; q < goodElectrons->GetEntries() ; ++q) {
799	>	//if pf candidate matches an electron passing ID cuts, then veto it
800	>	if(pf->GsfTrk() && goodElectrons->At(q)->GsfTrk() &&
801	>	pf->GsfTrk() == goodElectrons->At(q)->GsfTrk()) IsLeptonFootprint = kTRUE;
802	>	if(pf->TrackerTrk() && goodElectrons->At(q)->TrackerTrk() &&
803	>	pf->TrackerTrk() == goodElectrons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
804	>	//if pf candidate lies in veto regions of electron passing ID cuts, then veto it
805	>	if(pf->BestTrk() && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479
806	>	&& MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.015) IsLeptonFootprint = kTRUE;
807	>	if(pf->PFType() == PFCandidate::eGamma && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479 &&
808	>	MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.08) IsLeptonFootprint = kTRUE;
809	>	}
810	>	for (UInt_t q=0; q < goodMuons->GetEntries() ; ++q) {
811	>	//if pf candidate matches an muon passing ID cuts, then veto it
812	>	if(pf->TrackerTrk() && goodMuons->At(q)->TrackerTrk() &&
813	>	pf->TrackerTrk() == goodMuons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
814	>	//if pf candidate lies in veto regions of muon passing ID cuts, then veto it
815	>	if(pf->BestTrk() && MathUtils::DeltaR(goodMuons->At(q)->Mom(), pf->Mom()) < 0.01) IsLeptonFootprint = kTRUE;
816	>	}
817	>
818	>	if (!IsLeptonFootprint) {
819	>	Bool_t passVeto = kTRUE;
820	>	//Charged
821	>	if(pf->BestTrk()) {
822	>	if (!(fabs(pf->BestTrk()->DzCorrected(*vertex) - ele->BestTrk()->DzCorrected(*vertex)) < 0.2)) passVeto = kFALSE;
823	>	//************************************************************
824	>	// Veto any PFmuon, or PFEle
825	>	if (pf->PFType() == PFCandidate::eElectron || pf->PFType() == PFCandidate::eMuon) passVeto = kFALSE;
826	>	//************************************************************
827	>	//************************************************************
828	>	// Footprint Veto
829	>	if (fabs(ele->SCluster()->Eta()) >= 1.479 && dr < 0.015) passVeto = kFALSE;
830	>	//************************************************************
831	>	if (passVeto) {
832	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
833	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
834	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
835	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
836	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
837	>	} //pass veto
838	>
839	>	}
840	>	//Gamma
841	>	else if (pf->PFType() == PFCandidate::eGamma) {
842	>	//************************************************************
843	>	// Footprint Veto
844	>	if (fabs(ele->SCluster()->Eta()) >= 1.479) {
845	>	if (dr < 0.08) passVeto = kFALSE;
846	>	}
847	>	//************************************************************
848	>
849	>	if (passVeto) {
850	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
851	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
852	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
853	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
854	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
855	>	}
856	>	}
857	>	//NeutralHadron
858	>	else {
859	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
860	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
861	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
862	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
863	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
864	>	}
865	>	} //not lepton footprint
866	>	} //in 1.0 dr cone
867	>	} //loop over PF candidates
868	>
869	>	Double_t fMVAVar_ChargedIso_DR0p0To0p1  = 0;
870	>	Double_t fMVAVar_ChargedIso_DR0p1To0p2  = 0;
871	>	Double_t fMVAVar_ChargedIso_DR0p2To0p3  = 0;
872	>	Double_t fMVAVar_ChargedIso_DR0p3To0p4  = 0;
873	>	Double_t fMVAVar_ChargedIso_DR0p4To0p5  = 0;
874	>	Double_t fMVAVar_GammaIso_DR0p0To0p1  = 0;
875	>	Double_t fMVAVar_GammaIso_DR0p1To0p2  = 0;
876	>	Double_t fMVAVar_GammaIso_DR0p2To0p3  = 0;
877	>	Double_t fMVAVar_GammaIso_DR0p3To0p4  = 0;
878	>	Double_t fMVAVar_GammaIso_DR0p4To0p5  = 0;
879	>	Double_t fMVAVar_NeutralHadronIso_DR0p0To0p1  = 0;
880	>	Double_t fMVAVar_NeutralHadronIso_DR0p1To0p2  = 0;
881	>	Double_t fMVAVar_NeutralHadronIso_DR0p2To0p3  = 0;
882	>	Double_t fMVAVar_NeutralHadronIso_DR0p3To0p4  = 0;
883	>	Double_t fMVAVar_NeutralHadronIso_DR0p4To0p5  = 0;
884	>
885	>	fMVAVar_ChargedIso_DR0p0To0p1   = TMath::Min((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
886	>	fMVAVar_ChargedIso_DR0p1To0p2   = TMath::Min((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
887	>	fMVAVar_ChargedIso_DR0p2To0p3 = TMath::Min((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
888	>	fMVAVar_ChargedIso_DR0p3To0p4 = TMath::Min((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
889	>	fMVAVar_ChargedIso_DR0p4To0p5 = TMath::Min((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
890	>	fMVAVar_GammaIso_DR0p0To0p1 = TMath::Max(TMath::Min((tmpGammaIso_DR0p0To0p1 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p0To0p1, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
891	>	fMVAVar_GammaIso_DR0p1To0p2 = TMath::Max(TMath::Min((tmpGammaIso_DR0p1To0p2 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p1To0p2, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
892	>	fMVAVar_GammaIso_DR0p2To0p3 = TMath::Max(TMath::Min((tmpGammaIso_DR0p2To0p3 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p2To0p3, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
893	>	fMVAVar_GammaIso_DR0p3To0p4 = TMath::Max(TMath::Min((tmpGammaIso_DR0p3To0p4 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p3To0p4, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
894	>	fMVAVar_GammaIso_DR0p4To0p5 = TMath::Max(TMath::Min((tmpGammaIso_DR0p4To0p5 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p4To0p5, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
895	>	fMVAVar_NeutralHadronIso_DR0p0To0p1 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p0To0p1 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p0To0p1, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
896	>	fMVAVar_NeutralHadronIso_DR0p1To0p2 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p1To0p2 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p1To0p2, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
897	>	fMVAVar_NeutralHadronIso_DR0p2To0p3 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p2To0p3 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p2To0p3, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
898	>	fMVAVar_NeutralHadronIso_DR0p3To0p4 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p3To0p4 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p3To0p4, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
899	>	fMVAVar_NeutralHadronIso_DR0p4To0p5 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p4To0p5 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p4To0p5, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
900	>
901	>	//Do Binding of MVA input variables
902	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0
903	>	|| fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0
904	>	|| fMVAType == ElectronIDMVA::kIsoRingsV0) {
905	>	bindVariables();
906	>	}
907	>
908	>	Double_t mva = -9999;
909	>	TMVA::Reader *reader = 0;
910	>
911	>	if (printDebug == kTRUE) {
912	>	std::cout <<" -> BIN: " << fMVAVar_EleEta << " " << fMVAVar_ElePt << " : " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << std::endl;
913	>	}
914	>	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
915		mva = reader->EvaluateMVA( fMethodname );
916
917	+	if (printDebug == kTRUE) {
918	+
919	+	std::cout << "Debug Electron MVA: \n";
920	+	std::cout << " fbrem " <<  fMVAVar_EleFBrem
921	+	<< " kfchi2 " << fMVAVar_EleKFTrkChiSqr
922	+	<< " kfhits " << fMVAVar_EleKFTrkNHits
923	+	<< " kfhitsall " << fMVAVar_EleKFTrkNHits
924	+	<< " gsfchi2 " << fMVAVar_EleGsfTrackChi2OverNdof
925	+	<< " deta " <<  fMVAVar_EleDEtaIn
926	+	<< " dphi " << fMVAVar_EleDPhiIn
927	+	<< " detacalo " << fMVAVar_EledEtaCalo
928	+	<< " see " << fMVAVar_EleSigmaIEtaIEta
929	+	<< " spp " << fMVAVar_EleSigmaIPhiIPhi
930	+	<< " etawidth " << fMVAVar_EleSCEtaWidth
931	+	<< " phiwidth " << fMVAVar_EleSCPhiWidth
932	+	<< " e1x5e5x5 " << fMVAVar_EleE1x5OverE5x5
933	+	<< " R9 " << fMVAVar_EleR9
934	+	<< " HoE " << fMVAVar_EleHoverE
935	+	<< " EoP " << fMVAVar_EleEOverP
936	+	<< " IoEmIoP " << fMVAVar_EleOneOverEMinusOneOverP
937	+	<< " eleEoPout " << fMVAVar_EleESeedClusterOverPout
938	+	<< " EoPout " << fMVAVar_EleESeedClusterOverPout
939	+	<< " d0 " << fMVAVar_EleD0
940	+	<< " ip3d " << fMVAVar_EleIP3d
941	+	<< " eta " << fMVAVar_EleEta
942	+	<< " pt " << fMVAVar_ElePt << std::endl;
943	+
944	+	std::cout << fMVAVar_ChargedIso_DR0p0To0p1 << " "
945	+	<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
946	+	<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
947	+	<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
948	+	<< fMVAVar_ChargedIso_DR0p4To0p5 << " "
949	+	<< fMVAVar_GammaIso_DR0p0To0p1 << " "
950	+	<< fMVAVar_GammaIso_DR0p1To0p2 << " "
951	+	<< fMVAVar_GammaIso_DR0p2To0p3 << " "
952	+	<< fMVAVar_GammaIso_DR0p3To0p4 << " "
953	+	<< fMVAVar_GammaIso_DR0p4To0p5 << " "
954	+	<< fMVAVar_NeutralHadronIso_DR0p0To0p1 << " "
955	+	<< fMVAVar_NeutralHadronIso_DR0p1To0p2 << " "
956	+	<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " "
957	+	<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
958	+	<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " "
959	+	<< std::endl;
960	+	std::cout << "MVA: " << mva << " "
961	+	<< std::endl;
962	+	}
963	+
964		return mva;
965		}
966	+
967	+
968	+	void ElectronIDMVA::bindVariables() {
969	+
970	+	// this binding is needed for variables that sometime diverge.
971	+
972	+	if(fMVAVar_EleFBrem < -1.)
973	+	fMVAVar_EleFBrem = -1.;
974	+
975	+	fMVAVar_EleDEtaIn = fabs(fMVAVar_EleDEtaIn);
976	+	if(fMVAVar_EleDEtaIn > 0.06)
977	+	fMVAVar_EleDEtaIn = 0.06;
978	+
979	+
980	+	fMVAVar_EleDPhiIn = fabs(fMVAVar_EleDPhiIn);
981	+	if(fMVAVar_EleDPhiIn > 0.6)
982	+	fMVAVar_EleDPhiIn = 0.6;
983	+
984	+
985	+	if(fMVAVar_EleESeedClusterOverPout > 20.)
986	+	fMVAVar_EleESeedClusterOverPout = 20.;
987	+
988	+	if(fMVAVar_EleEOverP > 20.)
989	+	fMVAVar_EleEOverP = 20.;
990	+
991	+	if(fMVAVar_EleEEleClusterOverPout > 20.)
992	+	fMVAVar_EleEEleClusterOverPout = 20.;
993	+
994	+
995	+	fMVAVar_EledEtaCalo = fabs(fMVAVar_EledEtaCalo);
996	+	if(fMVAVar_EledEtaCalo > 0.2)
997	+	fMVAVar_EledEtaCalo = 0.2;
998	+
999	+
1000	+	if(fMVAVar_EleE1x5OverE5x5 < -1.)
1001	+	fMVAVar_EleE1x5OverE5x5 = -1;
1002	+
1003	+	if(fMVAVar_EleE1x5OverE5x5 > 2.)
1004	+	fMVAVar_EleE1x5OverE5x5 = 2.;
1005	+
1006	+
1007	+
1008	+	if(fMVAVar_EleR9 > 5)
1009	+	fMVAVar_EleR9 = 5;
1010	+
1011	+	if(fMVAVar_EleGsfTrackChi2OverNdof > 200.)
1012	+	fMVAVar_EleGsfTrackChi2OverNdof = 200;
1013	+
1014	+
1015	+	if(fMVAVar_EleKFTrkChiSqr > 10.)
1016	+	fMVAVar_EleKFTrkChiSqr = 10.;
1017	+
1018	+	// Needed for a bug in CMSSW_420, fixed in more recent CMSSW versions
1019	+	if(std::isnan(fMVAVar_EleSigmaIPhiIPhi))
1020	+	fMVAVar_EleSigmaIPhiIPhi = 0.;
1021	+
1022	+
1023	+	return;
1024	+	}

Diff Legend

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