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.4 by sixie, Mon Oct 3 16:32:09 2011 UTC vs.
Revision 1.23 by ceballos, Sat May 12 07:03:53 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	>	fTheRhoType(RhoUtilities::DEFAULT)
23		{
24		// Constructor.
21	–	for(UInt_t i=0; i<6; ++i) {
22	–	fTMVAReader[i] = 0;
23	–	}
25		}
26
27
28		//--------------------------------------------------------------------------------------------------
29		ElectronIDMVA::~ElectronIDMVA()
30		{
31	<	for(UInt_t i=0; i<6; ++i) {
31	>	for(UInt_t i=0; i<fTMVAReader.size(); ++i) {
32		if (fTMVAReader[i]) delete fTMVAReader[i];
33		}
34		}
35
36		//--------------------------------------------------------------------------------------------------
37	+	void ElectronIDMVA::Initialize( std::string methodName,
38	+	std::string weightsfile,
39	+	ElectronIDMVA::MVAType type,
40	+	RhoUtilities::RhoType theRhoType)
41	+	{
42	+
43	+	std::vector<std::string> tempWeightFileVector;
44	+	tempWeightFileVector.push_back(weightsfile);
45	+	Initialize(methodName,type,kFALSE,tempWeightFileVector,theRhoType);
46	+	}
47	+
48	+	//--------------------------------------------------------------------------------------------------
49		void ElectronIDMVA::Initialize( TString methodName,
50		TString Subdet0Pt10To20Weights ,
51		TString Subdet1Pt10To20Weights ,
#	Line 40 | Line 53 | void ElectronIDMVA::Initialize( TString
53		TString Subdet0Pt20ToInfWeights,
54		TString Subdet1Pt20ToInfWeights,
55		TString Subdet2Pt20ToInfWeights,
56	<	ElectronIDMVA::MVAType type) {
56	>	ElectronIDMVA::MVAType type,
57	>	RhoUtilities::RhoType theRhoType) {
58	>
59	>	std::vector<std::string> tempWeightFileVector;
60	>	tempWeightFileVector.push_back(std::string(Subdet0Pt10To20Weights.Data()));
61	>	tempWeightFileVector.push_back(std::string(Subdet1Pt10To20Weights.Data()));
62	>	tempWeightFileVector.push_back(std::string(Subdet2Pt10To20Weights.Data()));
63	>	tempWeightFileVector.push_back(std::string(Subdet0Pt20ToInfWeights.Data()));
64	>	tempWeightFileVector.push_back(std::string(Subdet1Pt20ToInfWeights.Data()));
65	>	tempWeightFileVector.push_back(std::string(Subdet2Pt20ToInfWeights.Data()));
66	>	Initialize(std::string(methodName.Data()),type,kTRUE,tempWeightFileVector,theRhoType);
67	>
68	>	}
69	>
70	>
71	>	//--------------------------------------------------------------------------------------------------
72	>	void ElectronIDMVA::Initialize( std::string methodName,
73	>	ElectronIDMVA::MVAType type,
74	>	Bool_t useBinnedVersion,
75	>	std::vector<std::string> weightsfiles,
76	>	RhoUtilities::RhoType theRhoType
77	>
78	>	) {
79
80	+	//clean up first
81	+	for (uint i=0;i<fTMVAReader.size(); ++i) {
82	+	if (fTMVAReader[i]) delete fTMVAReader[i];
83	+	}
84	+	fTMVAReader.clear();
85	+
86	+	//initialize
87		fIsInitialized = kTRUE;
46	–
88		fMethodname = methodName;
89	<
90	<	for(UInt_t i=0; i<6; ++i) {
91	<	if (fTMVAReader[i]) delete fTMVAReader[i];
89	>	fMVAType = type;
90	>	fUseBinnedVersion = useBinnedVersion;
91	>	fTheRhoType = theRhoType;
92	>
93	>	//Define expected number of bins
94	>	UInt_t ExpectedNBins = 0;
95	>	if (!fUseBinnedVersion) {
96	>	ExpectedNBins = 1;
97	>	} else if (type == kBaseline
98	>	||type == kNoIPInfo
99	>	||type == kWithIPInfo
100	>	||type == kIDIsoCombined) {
101	>	ExpectedNBins = 6;
102	>	} else if (type == kIDEGamma2012TrigV0 ||
103	>	type == kIDEGamma2012NonTrigV0 ||
104	>	type == kIDHWW2012TrigV0) {
105	>	ExpectedNBins = 6;
106	>	} else if (type == kIsoRingsV0) {
107	>	ExpectedNBins = 4;
108	>	}
109	>	fNMVABins = ExpectedNBins;
110	>
111	>	//Check number of weight files given
112	>	if (fNMVABins != weightsfiles.size() ) {
113	>	std::cout << "Error: Expected Number of bins = " << fNMVABins << " does not equal to weightsfiles.size() = "
114	>	<< weightsfiles.size() << std::endl;
115	>	assert(fNMVABins == weightsfiles.size());
116	>	}
117
118	<	fTMVAReader[i] = new TMVA::Reader( "!Color:!Silent:Error" );
119	<	fTMVAReader[i]->SetVerbose(kTRUE);
118	>
119	>	for(UInt_t i=0; i<fNMVABins; ++i) {
120	>	TMVA::Reader *tmpTMVAReader = new TMVA::Reader( "!Color:!Silent:Error" );
121	>	tmpTMVAReader->SetVerbose(kTRUE);
122
123		if (type == kBaseline) {
124	<	fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta         );
125	<	fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                );
126	<	fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                );
127	<	fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                 );
128	<	fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi         );
129	<	fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                 );
130	<	fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP );
124	>	tmpTMVAReader->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
125	>	tmpTMVAReader->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
126	>	tmpTMVAReader->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
127	>	tmpTMVAReader->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
128	>	tmpTMVAReader->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
129	>	tmpTMVAReader->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                    );
130	>	tmpTMVAReader->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
131	>	}
132	>	if (type == kNoIPInfo) {
133	>	tmpTMVAReader->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
134	>	tmpTMVAReader->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
135	>	tmpTMVAReader->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
136	>	tmpTMVAReader->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
137	>	tmpTMVAReader->AddVariable( "EOverP",                &fMVAVar_EleEOverP                   );
138	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout     );
139	>	tmpTMVAReader->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
140	>	tmpTMVAReader->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                    );
141	>	tmpTMVAReader->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
142	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn      );
143	>	}
144	>	if (type == kWithIPInfo) {
145	>	tmpTMVAReader->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
146	>	tmpTMVAReader->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
147	>	tmpTMVAReader->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
148	>	tmpTMVAReader->AddVariable( "D0",                    &fMVAVar_EleD0                       );
149	>	tmpTMVAReader->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
150	>	tmpTMVAReader->AddVariable( "EOverP",                &fMVAVar_EleEOverP                   );
151	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout     );
152	>	tmpTMVAReader->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
153	>	tmpTMVAReader->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                    );
154	>	tmpTMVAReader->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
155	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn      );
156	>	tmpTMVAReader->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                     );
157	>	tmpTMVAReader->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig                  );
158		}
159	+	if (type == kIDIsoCombined) {
160	+	tmpTMVAReader->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
161	+	tmpTMVAReader->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
162	+	tmpTMVAReader->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
163	+	tmpTMVAReader->AddVariable( "D0",                    &fMVAVar_EleD0                       );
164	+	tmpTMVAReader->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
165	+	tmpTMVAReader->AddVariable( "EOverP",                &fMVAVar_EleEOverP                   );
166	+	tmpTMVAReader->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout     );
167	+	tmpTMVAReader->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
168	+	tmpTMVAReader->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
169	+	tmpTMVAReader->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn      );
170	+	tmpTMVAReader->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                     );
171	+	tmpTMVAReader->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig                  );
172	+
173	+	tmpTMVAReader->AddVariable( "GsfTrackChi2OverNdof",  &fMVAVar_EleGsfTrackChi2OverNdof     );
174	+	tmpTMVAReader->AddVariable( "dEtaCalo",              &fMVAVar_EledEtaCalo                 );
175	+	tmpTMVAReader->AddVariable( "dPhiCalo",              &fMVAVar_EledPhiCalo                 );
176	+	tmpTMVAReader->AddVariable( "R9",                    &fMVAVar_EleR9                       );
177	+	tmpTMVAReader->AddVariable( "SCEtaWidth",            &fMVAVar_EleSCEtaWidth               );
178	+	tmpTMVAReader->AddVariable( "SCPhiWidth",            &fMVAVar_EleSCPhiWidth               );
179	+	tmpTMVAReader->AddVariable( "CovIEtaIPhi",           &fMVAVar_EleCovIEtaIPhi              );
180	+	if (i == 2 || i == 5) {
181	+	tmpTMVAReader->AddVariable( "PreShowerOverRaw",      &fMVAVar_ElePreShowerOverRaw       );
182	+	}
183	+	tmpTMVAReader->AddVariable( "ChargedIso03",          &fMVAVar_EleChargedIso03OverPt       );
184	+	tmpTMVAReader->AddVariable( "NeutralHadronIso03",    &fMVAVar_EleNeutralHadronIso03OverPt );
185	+	tmpTMVAReader->AddVariable( "GammaIso03",            &fMVAVar_EleGammaIso03OverPt         );
186	+	tmpTMVAReader->AddVariable( "ChargedIso04",          &fMVAVar_EleChargedIso04OverPt       );
187	+	tmpTMVAReader->AddVariable( "NeutralHadronIso04",    &fMVAVar_EleNeutralHadronIso04OverPt );
188	+	tmpTMVAReader->AddVariable( "GammaIso04",            &fMVAVar_EleGammaIso04OverPt         );
189	+
190	+	}
191	+
192	+	if (type == kIDEGamma2012TrigV0 || type == kIDHWW2012TrigV0) {
193	+	// Pure tracking variables
194	+	tmpTMVAReader->AddVariable("fbrem",           &fMVAVar_EleFBrem);
195	+	tmpTMVAReader->AddVariable("kfchi2",          &fMVAVar_EleKFTrkChiSqr);
196	+	tmpTMVAReader->AddVariable("kfhits",          &fMVAVar_EleKFTrkNLayers);  //Don't have this in (BAMBU <= 025)
197	+	if(type == kIDEGamma2012TrigV0)
198	+	tmpTMVAReader->AddVariable("kfhitsall",       &fMVAVar_EleKFTrkNHits);
199	+	tmpTMVAReader->AddVariable("gsfchi2",         &fMVAVar_EleGsfTrackChi2OverNdof);
200	+	tmpTMVAReader->AddVariable("deta",            &fMVAVar_EleDEtaIn);
201	+	tmpTMVAReader->AddVariable("dphi",            &fMVAVar_EleDPhiIn);
202	+	tmpTMVAReader->AddVariable("detacalo",        &fMVAVar_EledEtaCalo);
203	+	tmpTMVAReader->AddVariable("see",             &fMVAVar_EleSigmaIEtaIEta);
204	+	tmpTMVAReader->AddVariable("spp",             &fMVAVar_EleSigmaIPhiIPhi);
205	+	tmpTMVAReader->AddVariable("etawidth",        &fMVAVar_EleSCEtaWidth);
206	+	tmpTMVAReader->AddVariable("phiwidth",        &fMVAVar_EleSCPhiWidth);
207	+	tmpTMVAReader->AddVariable("e1x5e5x5",        &fMVAVar_EleE1x5OverE5x5);
208	+	tmpTMVAReader->AddVariable("R9",              &fMVAVar_EleR9);
209	+	tmpTMVAReader->AddVariable("HoE",             &fMVAVar_EleHoverE);
210	+	tmpTMVAReader->AddVariable("EoP",             &fMVAVar_EleEOverP);
211	+	tmpTMVAReader->AddVariable("IoEmIoP",         &fMVAVar_EleOneOverEMinusOneOverP);
212	+	tmpTMVAReader->AddVariable("eleEoPout",       &fMVAVar_EleEEleClusterOverPout); //Don't have this in (BAMBU <= 025)
213	+	if(type == kIDEGamma2012TrigV0)
214	+	tmpTMVAReader->AddVariable("EoPout",          &fMVAVar_EleESeedClusterOverPout);
215	+	if (i == 2 || i == 5) {
216	+	tmpTMVAReader->AddVariable( "PreShowerOverRaw",      &fMVAVar_ElePreShowerOverRaw       );
217	+	}
218	+	tmpTMVAReader->AddVariable( "d0",             &fMVAVar_EleD0);
219	+	tmpTMVAReader->AddVariable( "ip3d",           &fMVAVar_EleIP3d);
220
221	<	if (type == kV1) {
222	<	fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta         );
223	<	fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                );
224	<	fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                );
225	<	fTMVAReader[i]->AddVariable( "HoverE",                &fMVAVar_EleHoverE                );
226	<	fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                 );
227	<	fTMVAReader[i]->AddVariable( "EOverP",                &fMVAVar_EleEOverP                );
228	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout  );
229	<	fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi         );
230	<	fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                 );
231	<	fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP );
232	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn   );
233	<	}
234	<	if (type == kV2) {
235	<	fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta         );
236	<	fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                );
237	<	fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                );
238	<	fTMVAReader[i]->AddVariable( "HoverE",                &fMVAVar_EleHoverE                );
239	<	fTMVAReader[i]->AddVariable( "D0",                    &fMVAVar_EleD0                    );
240	<	fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                 );
241	<	fTMVAReader[i]->AddVariable( "EOverP",                &fMVAVar_EleEOverP                );
242	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout  );
243	<	fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi         );
244	<	fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                 );
245	<	fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP );
246	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn   );
247	<	fTMVAReader[i]->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                  );
248	<	fTMVAReader[i]->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig               );
249	<	}
250	<
251	<	if (i==0) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt10To20Weights );
252	<	if (i==1) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt10To20Weights );
253	<	if (i==2) fTMVAReader[i]->BookMVA(fMethodname , Subdet2Pt10To20Weights );
254	<	if (i==3) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt20ToInfWeights );
255	<	if (i==4) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt20ToInfWeights );
256	<	if (i==5) fTMVAReader[i]->BookMVA(fMethodname , Subdet2Pt20ToInfWeights );
221	>	tmpTMVAReader->AddSpectator("eta",            &fMVAVar_EleEta);
222	>	tmpTMVAReader->AddSpectator("pt",             &fMVAVar_ElePt);
223	>	}
224	>
225	>	if (type == kIDEGamma2012NonTrigV0 ) {
226	>	// Pure tracking variables
227	>	tmpTMVAReader->AddVariable("fbrem",           &fMVAVar_EleFBrem);
228	>	tmpTMVAReader->AddVariable("kfchi2",          &fMVAVar_EleKFTrkChiSqr);
229	>	tmpTMVAReader->AddVariable("kfhitsall",       &fMVAVar_EleKFTrkNHits);
230	>	tmpTMVAReader->AddVariable("gsfchi2",         &fMVAVar_EleGsfTrackChi2OverNdof);
231	>	tmpTMVAReader->AddVariable("deta",            &fMVAVar_EleDEtaIn);
232	>	tmpTMVAReader->AddVariable("dphi",            &fMVAVar_EleDPhiIn);
233	>	tmpTMVAReader->AddVariable("detacalo",        &fMVAVar_EledEtaCalo);
234	>	tmpTMVAReader->AddVariable("see",             &fMVAVar_EleSigmaIEtaIEta);
235	>	tmpTMVAReader->AddVariable("spp",             &fMVAVar_EleSigmaIPhiIPhi);
236	>	tmpTMVAReader->AddVariable("etawidth",        &fMVAVar_EleSCEtaWidth);
237	>	tmpTMVAReader->AddVariable("phiwidth",        &fMVAVar_EleSCPhiWidth);
238	>	tmpTMVAReader->AddVariable("e1x5e5x5",        &fMVAVar_EleE1x5OverE5x5);
239	>	tmpTMVAReader->AddVariable("R9",              &fMVAVar_EleR9);
240	>	tmpTMVAReader->AddVariable("HoE",             &fMVAVar_EleHoverE);
241	>	tmpTMVAReader->AddVariable("EoP",             &fMVAVar_EleEOverP);
242	>	tmpTMVAReader->AddVariable("IoEmIoP",         &fMVAVar_EleOneOverEMinusOneOverP);
243	>	tmpTMVAReader->AddVariable("EoPout",          &fMVAVar_EleESeedClusterOverPout);
244	>	if (i==2 || i==5) {
245	>	tmpTMVAReader->AddVariable("PreShowerOverRaw",&fMVAVar_ElePreShowerOverRaw);
246	>	}
247	>	tmpTMVAReader->AddSpectator("eta",            &fMVAVar_EleEta);
248	>	tmpTMVAReader->AddSpectator("pt",             &fMVAVar_ElePt);
249	>	}
250	>
251	>	if (type == kIsoRingsV0) {
252	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p0To0p1",         &fMVAVar_ChargedIso_DR0p0To0p1        );
253	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p1To0p2",         &fMVAVar_ChargedIso_DR0p1To0p2        );
254	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p2To0p3",         &fMVAVar_ChargedIso_DR0p2To0p3        );
255	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p3To0p4",         &fMVAVar_ChargedIso_DR0p3To0p4        );
256	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p4To0p5",         &fMVAVar_ChargedIso_DR0p4To0p5        );
257	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p0To0p1",           &fMVAVar_GammaIso_DR0p0To0p1          );
258	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p1To0p2",           &fMVAVar_GammaIso_DR0p1To0p2          );
259	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p2To0p3",           &fMVAVar_GammaIso_DR0p2To0p3          );
260	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p3To0p4",           &fMVAVar_GammaIso_DR0p3To0p4          );
261	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p4To0p5",           &fMVAVar_GammaIso_DR0p4To0p5          );
262	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p0To0p1",   &fMVAVar_NeutralHadronIso_DR0p0To0p1  );
263	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p1To0p2",   &fMVAVar_NeutralHadronIso_DR0p1To0p2  );
264	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p2To0p3",   &fMVAVar_NeutralHadronIso_DR0p2To0p3  );
265	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p3To0p4",   &fMVAVar_NeutralHadronIso_DR0p3To0p4  );
266	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p4To0p5",   &fMVAVar_NeutralHadronIso_DR0p4To0p5  );
267	>	tmpTMVAReader->AddSpectator( "eta",   &fMVAVar_EleEta );
268	>	tmpTMVAReader->AddSpectator( "pt" ,   &fMVAVar_ElePt  );
269	>	}
270	>
271	>	tmpTMVAReader->BookMVA(fMethodname , weightsfiles[i] );
272	>	std::cout << "MVABin " << i << " : MethodName = " << fMethodname
273	>	<< " , type == " << type << " , "
274	>	<< "Load weights file : " << weightsfiles[i]
275	>	<< std::endl;
276	>	fTMVAReader.push_back(tmpTMVAReader);
277
278		}
279	+	std::cout << "Electron ID MVA Completed\n";
280	+	}
281	+
282	+
283	+	//--------------------------------------------------------------------------------------------------
284	+	UInt_t ElectronIDMVA::GetMVABin( double eta, double pt) const {
285	+
286	+	//Default is to return the first bin
287	+	uint bin = 0;
288	+
289	+	//return the first bin if not using binned version
290	+	if (!fUseBinnedVersion) return 0;
291
292	<	std::cout << "Electron ID MVA Initialization\n";
293	<	std::cout << "MethodName : " << fMethodname << " , type == " << type << std::endl;
294	<	std::cout << "Load weights file : " << Subdet0Pt10To20Weights << std::endl;
295	<	std::cout << "Load weights file : " << Subdet1Pt10To20Weights << std::endl;
296	<	std::cout << "Load weights file : " << Subdet2Pt10To20Weights << std::endl;
297	<	std::cout << "Load weights file : " << Subdet0Pt20ToInfWeights << std::endl;
298	<	std::cout << "Load weights file : " << Subdet1Pt20ToInfWeights << std::endl;
299	<	std::cout << "Load weights file : " << Subdet2Pt20ToInfWeights << std::endl;
292	>	if (fMVAType == ElectronIDMVA::kBaseline
293	>	||fMVAType == ElectronIDMVA::kNoIPInfo
294	>	||fMVAType == ElectronIDMVA::kWithIPInfo
295	>	||fMVAType == ElectronIDMVA::kIDIsoCombined) {
296	>	if (pt < 20 && fabs(eta) < 1.0) bin = 0;
297	>	if (pt < 20 && fabs(eta) >= 1.0 && fabs(eta) < 1.479) bin = 1;
298	>	if (pt < 20 && fabs(eta) >= 1.479) bin = 2;
299	>	if (pt >= 20 && fabs(eta) < 1.0) bin = 3;
300	>	if (pt >= 20 && fabs(eta) >= 1.0 && fabs(eta) < 1.479) bin = 4;
301	>	if (pt >= 20 && fabs(eta) >= 1.479) bin = 5;
302	>	}
303	>
304	>	if (fMVAType == ElectronIDMVA::kIsoRingsV0) {
305	>	if (pt < 10 && fabs(eta) < 1.479) bin = 0;
306	>	if (pt < 10 && fabs(eta) >= 1.479) bin = 1;
307	>	if (pt >= 10 && fabs(eta) < 1.479) bin = 2;
308	>	if (pt >= 10 && fabs(eta) >= 1.479) bin = 3;
309	>	}
310	>
311	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0) {
312	>	bin = 0;
313	>	if (pt < 10 && fabs(eta) < 0.8) bin = 0;
314	>	if (pt < 10 && fabs(eta) >= 0.8 && fabs(eta) < 1.479 ) bin = 1;
315	>	if (pt < 10 && fabs(eta) >= 1.479) bin = 2;
316	>	if (pt >= 10 && fabs(eta) < 0.8) bin = 3;
317	>	if (pt >= 10 && fabs(eta) >= 0.8 && fabs(eta) < 1.479 ) bin = 4;
318	>	if (pt >= 10 && fabs(eta) >= 1.479) bin = 5;
319	>	}
320	>
321	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
322	>	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0) {
323	>	bin = 0;
324	>	if (pt < 20 && fabs(eta) < 0.8) bin = 0;
325	>	if (pt < 20 && fabs(eta) >= 0.8 && fabs(eta) < 1.479 ) bin = 1;
326	>	if (pt < 20 && fabs(eta) >= 1.479) bin = 2;
327	>	if (pt >= 20 && fabs(eta) < 0.8) bin = 3;
328	>	if (pt >= 20 && fabs(eta) >= 0.8 && fabs(eta) < 1.479 ) bin = 4;
329	>	if (pt >= 20 && fabs(eta) >= 1.479) bin = 5;
330	>	}
331
332	+	return bin;
333		}
334
335	+
336	+
337		//--------------------------------------------------------------------------------------------------
338	<	Double_t ElectronIDMVA::MVAValue(Double_t ElePt , Double_t EleSCEta,
338	>	Double_t ElectronIDMVA::MVAValue(Double_t ElePt , Double_t EleEta,
339		Double_t EleSigmaIEtaIEta,
340		Double_t EleDEtaIn,
341		Double_t EleDPhiIn,
#	Line 136 | Line 358 | Double_t ElectronIDMVA::MVAValue(Double_
358		return -9999;
359		}
360
139	–	Int_t subdet = 0;
140	–	if (fabs(EleSCEta) < 1.0) subdet = 0;
141	–	else if (fabs(EleSCEta) < 1.479) subdet = 1;
142	–	else subdet = 2;
143	–	Int_t ptBin = 0;
144	–	if (ElePt > 20.0) ptBin = 1;
145	–
361		//set all input variables
362		fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
363		fMVAVar_EleDEtaIn = EleDEtaIn;
#	Line 162 | Line 377 | Double_t ElectronIDMVA::MVAValue(Double_
377
378		Double_t mva = -9999;
379		TMVA::Reader *reader = 0;
380	<	Int_t MVABin = -1;
166	<	if (subdet == 0 && ptBin == 0) MVABin = 0;
167	<	if (subdet == 1 && ptBin == 0) MVABin = 1;
168	<	if (subdet == 2 && ptBin == 0) MVABin = 2;
169	<	if (subdet == 0 && ptBin == 1) MVABin = 3;
170	<	if (subdet == 1 && ptBin == 1) MVABin = 4;
171	<	if (subdet == 2 && ptBin == 1) MVABin = 5;
172	<	assert(MVABin >= 0 && MVABin <= 5);
173	<	reader = fTMVAReader[MVABin];
380	>	reader = fTMVAReader[GetMVABin( EleEta, ElePt)];
381
382		mva = reader->EvaluateMVA( fMethodname );
383
384		return mva;
385		}
386
387	+	//--------------------------------------------------------------------------------------------------
388	+	Double_t ElectronIDMVA::MVAValue(Double_t ElePt , Double_t EleEta, Double_t PileupEnergyDensity,
389	+	Double_t EleSigmaIEtaIEta,
390	+	Double_t EleDEtaIn,
391	+	Double_t EleDPhiIn,
392	+	Double_t EleHoverE,
393	+	Double_t EleD0,
394	+	Double_t EleDZ,
395	+	Double_t EleFBrem,
396	+	Double_t EleEOverP,
397	+	Double_t EleESeedClusterOverPout,
398	+	Double_t EleSigmaIPhiIPhi,
399	+	Double_t EleNBrem,
400	+	Double_t EleOneOverEMinusOneOverP,
401	+	Double_t EleESeedClusterOverPIn,
402	+	Double_t EleIP3d,
403	+	Double_t EleIP3dSig,
404	+	Double_t EleGsfTrackChi2OverNdof,
405	+	Double_t EledEtaCalo,
406	+	Double_t EledPhiCalo,
407	+	Double_t EleR9,
408	+	Double_t EleSCEtaWidth,
409	+	Double_t EleSCPhiWidth,
410	+	Double_t EleCovIEtaIPhi,
411	+	Double_t ElePreShowerOverRaw,
412	+	Double_t EleChargedIso03,
413	+	Double_t EleNeutralHadronIso03,
414	+	Double_t EleGammaIso03,
415	+	Double_t EleChargedIso04,
416	+	Double_t EleNeutralHadronIso04,
417	+	Double_t EleGammaIso04,
418	+	Bool_t printDebug
419	+	) {
420	+
421	+	if (!fIsInitialized) {
422	+	std::cout << "Error: ElectronIDMVA not properly initialized.\n";
423	+	return -9999;
424	+	}
425	+
426	+	Double_t Rho = 0;
427	+	if (!(TMath::IsNaN(PileupEnergyDensity) || isinf(PileupEnergyDensity))) Rho = PileupEnergyDensity;
428	+
429	+	//set all input variables
430	+	fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
431	+	fMVAVar_EleDEtaIn = EleDEtaIn;
432	+	fMVAVar_EleDPhiIn = EleDPhiIn;
433	+	fMVAVar_EleHoverE = EleHoverE;
434	+	fMVAVar_EleD0 = EleD0;
435	+	fMVAVar_EleDZ = EleDZ;
436	+	fMVAVar_EleFBrem = EleFBrem;
437	+	fMVAVar_EleEOverP = EleEOverP;
438	+	fMVAVar_EleESeedClusterOverPout = EleESeedClusterOverPout;
439	+	fMVAVar_EleSigmaIPhiIPhi = EleSigmaIPhiIPhi;
440	+	fMVAVar_EleNBrem = EleNBrem;
441	+	fMVAVar_EleOneOverEMinusOneOverP = EleOneOverEMinusOneOverP;
442	+	fMVAVar_EleESeedClusterOverPIn = EleESeedClusterOverPIn;
443	+	fMVAVar_EleIP3d = EleIP3d;
444	+	fMVAVar_EleIP3dSig = EleIP3dSig;
445	+	fMVAVar_EleGsfTrackChi2OverNdof = EleGsfTrackChi2OverNdof;
446	+	fMVAVar_EledEtaCalo = EledEtaCalo;
447	+	fMVAVar_EledPhiCalo = EledPhiCalo;
448	+	fMVAVar_EleR9 = EleR9;
449	+	fMVAVar_EleSCEtaWidth = EleSCEtaWidth;
450	+	fMVAVar_EleSCPhiWidth = EleSCPhiWidth;
451	+	fMVAVar_EleCovIEtaIPhi = EleCovIEtaIPhi;
452	+	fMVAVar_ElePreShowerOverRaw = ElePreShowerOverRaw;
453	+	fMVAVar_EleChargedIso03OverPt
454	+	= (EleChargedIso03
455	+	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso03, EleEta)) / ElePt;
456	+	fMVAVar_EleNeutralHadronIso03OverPt
457	+	= (EleNeutralHadronIso03
458	+	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso03, EleEta)
459	+	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,EleEta)) / ElePt;
460	+	fMVAVar_EleGammaIso03OverPt
461	+	= (EleGammaIso03
462	+	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso03, EleEta)
463	+	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip03,EleEta))/ElePt;
464	+	fMVAVar_EleChargedIso04OverPt
465	+	= (EleChargedIso04
466	+	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso04, EleEta))/ElePt;
467	+	fMVAVar_EleNeutralHadronIso04OverPt
468	+	= (EleNeutralHadronIso04
469	+	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso04, EleEta)
470	+	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,EleEta))/ElePt;
471	+	fMVAVar_EleGammaIso04OverPt
472	+	= (EleGammaIso04
473	+	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso04, EleEta)
474	+	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip04,EleEta))/ElePt;
475	+
476	+
477	+
478	+
479	+	Double_t mva = -9999;
480	+	TMVA::Reader *reader = 0;
481	+	reader = fTMVAReader[GetMVABin( EleEta, ElePt)];
482	+	mva = reader->EvaluateMVA( fMethodname );
483	+
484	+	if (printDebug == kTRUE) {
485	+	std::cout << "Debug Electron MVA: "
486	+	<< ElePt << " " << EleEta << " " << " --> MVABin " << GetMVABin( EleEta, ElePt) << " : "
487	+	<< fMVAVar_EleSigmaIEtaIEta << " "
488	+	<< fMVAVar_EleDEtaIn << " "
489	+	<< fMVAVar_EleDPhiIn << " "
490	+	<< fMVAVar_EleHoverE << " "
491	+	<< fMVAVar_EleD0 << " "
492	+	<< fMVAVar_EleDZ << " "
493	+	<< fMVAVar_EleFBrem << " "
494	+	<< fMVAVar_EleEOverP << " "
495	+	<< fMVAVar_EleESeedClusterOverPout << " "
496	+	<< fMVAVar_EleSigmaIPhiIPhi << " "
497	+	<< fMVAVar_EleNBrem << " "
498	+	<< fMVAVar_EleOneOverEMinusOneOverP << " "
499	+	<< fMVAVar_EleESeedClusterOverPIn << " "
500	+	<< fMVAVar_EleIP3d << " "
501	+	<< fMVAVar_EleIP3dSig << " "
502	+	<< fMVAVar_EleGsfTrackChi2OverNdof << " "
503	+	<< fMVAVar_EledEtaCalo << " "
504	+	<< fMVAVar_EledPhiCalo << " "
505	+	<< fMVAVar_EleR9 << " "
506	+	<< fMVAVar_EleSCEtaWidth << " "
507	+	<< fMVAVar_EleSCPhiWidth << " "
508	+	<< fMVAVar_EleCovIEtaIPhi << " "
509	+	<< fMVAVar_ElePreShowerOverRaw << " "
510	+	<< fMVAVar_EleChargedIso03OverPt  << " "
511	+	<< fMVAVar_EleNeutralHadronIso03OverPt  << " "
512	+	<< fMVAVar_EleGammaIso03OverPt  << " "
513	+	<< fMVAVar_EleChargedIso04OverPt  << " "
514	+	<< fMVAVar_EleNeutralHadronIso04OverPt  << " "
515	+	<< fMVAVar_EleGammaIso04OverPt  << " "
516	+	<< " === : === "
517	+	<< mva
518	+	<< std::endl;
519	+	}
520	+
521	+	return mva;
522	+	}
523	+
524	+	Double_t ElectronIDMVA::MVAValue_IsoRings( Double_t ElePt,
525	+	Double_t EleSCEta,
526	+	Double_t ChargedIso_DR0p0To0p1,
527	+	Double_t ChargedIso_DR0p1To0p2,
528	+	Double_t ChargedIso_DR0p2To0p3,
529	+	Double_t ChargedIso_DR0p3To0p4,
530	+	Double_t ChargedIso_DR0p4To0p5,
531	+	Double_t GammaIso_DR0p0To0p1,
532	+	Double_t GammaIso_DR0p1To0p2,
533	+	Double_t GammaIso_DR0p2To0p3,
534	+	Double_t GammaIso_DR0p3To0p4,
535	+	Double_t GammaIso_DR0p4To0p5,
536	+	Double_t NeutralHadronIso_DR0p0To0p1,
537	+	Double_t NeutralHadronIso_DR0p1To0p2,
538	+	Double_t NeutralHadronIso_DR0p2To0p3,
539	+	Double_t NeutralHadronIso_DR0p3To0p4,
540	+	Double_t NeutralHadronIso_DR0p4To0p5,
541	+	Bool_t printDebug) {
542	+
543	+	if (fMVAType != ElectronIDMVA::kIsoRingsV0) {
544	+	std::cout << "Error: This function is only supported for MVAType == kIsoRingsV0.\n" << std::endl;
545	+	assert(kFALSE);
546	+	}
547	+
548	+	fMVAVar_ElePt = ElePt;
549	+	fMVAVar_EleEta = EleSCEta;
550	+	fMVAVar_ChargedIso_DR0p0To0p1 = ChargedIso_DR0p0To0p1;
551	+	fMVAVar_ChargedIso_DR0p1To0p2 = ChargedIso_DR0p1To0p2;
552	+	fMVAVar_ChargedIso_DR0p2To0p3 = ChargedIso_DR0p2To0p3;
553	+	fMVAVar_ChargedIso_DR0p3To0p4 = ChargedIso_DR0p3To0p4;
554	+	fMVAVar_ChargedIso_DR0p4To0p5 = ChargedIso_DR0p4To0p5;
555	+	fMVAVar_GammaIso_DR0p0To0p1 = GammaIso_DR0p0To0p1;
556	+	fMVAVar_GammaIso_DR0p1To0p2 = GammaIso_DR0p1To0p2;
557	+	fMVAVar_GammaIso_DR0p2To0p3 = GammaIso_DR0p2To0p3;
558	+	fMVAVar_GammaIso_DR0p3To0p4 = GammaIso_DR0p3To0p4;
559	+	fMVAVar_GammaIso_DR0p4To0p5 = GammaIso_DR0p4To0p5;
560	+	fMVAVar_NeutralHadronIso_DR0p0To0p1 = NeutralHadronIso_DR0p0To0p1;
561	+	fMVAVar_NeutralHadronIso_DR0p1To0p2 = NeutralHadronIso_DR0p1To0p2;
562	+	fMVAVar_NeutralHadronIso_DR0p2To0p3 = NeutralHadronIso_DR0p2To0p3;
563	+	fMVAVar_NeutralHadronIso_DR0p3To0p4 = NeutralHadronIso_DR0p3To0p4;
564	+	fMVAVar_NeutralHadronIso_DR0p4To0p5 = NeutralHadronIso_DR0p4To0p5;
565	+
566	+	Double_t mva = -9999;
567	+	TMVA::Reader *reader = 0;
568	+
569	+	if (printDebug == kTRUE) {
570	+	std::cout <<" -> BIN: " << fMVAVar_EleEta << " " << fMVAVar_ElePt << " : " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << std::endl;
571	+	}
572	+	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
573	+	mva = reader->EvaluateMVA( fMethodname );
574	+
575	+	if (printDebug == kTRUE) {
576	+
577	+	std::cout << "Debug Electron MVA-ISO: ";
578	+	std::cout << fMVAVar_ChargedIso_DR0p0To0p1 << " "
579	+	<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
580	+	<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
581	+	<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
582	+	<< fMVAVar_ChargedIso_DR0p4To0p5 << " "
583	+	<< fMVAVar_GammaIso_DR0p0To0p1 << " "
584	+	<< fMVAVar_GammaIso_DR0p1To0p2 << " "
585	+	<< fMVAVar_GammaIso_DR0p2To0p3 << " "
586	+	<< fMVAVar_GammaIso_DR0p3To0p4 << " "
587	+	<< fMVAVar_GammaIso_DR0p4To0p5 << " "
588	+	<< fMVAVar_NeutralHadronIso_DR0p0To0p1 << " "
589	+	<< fMVAVar_NeutralHadronIso_DR0p1To0p2 << " "
590	+	<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " "
591	+	<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
592	+	<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " "
593	+	<< std::endl;
594	+	std::cout << "MVA: " << mva << " "
595	+	<< std::endl;
596	+	}
597	+	return mva;
598	+	}
599	+
600	+	Double_t ElectronIDMVA::MVAValue_IDNonTrig( Double_t ElePt,
601	+	Double_t EleSCEta,
602	+	Double_t EleFBrem,
603	+	Double_t EleKFTrkChiSqr,
604	+	Double_t EleKFTrkNHits,
605	+	Double_t EleGsfTrackChi2OverNdof,
606	+	Double_t EleDEtaIn,
607	+	Double_t EleDPhiIn,
608	+	Double_t EledEtaCalo,
609	+	Double_t EleSigmaIEtaIEta,
610	+	Double_t EleSigmaIPhiIPhi,
611	+	Double_t EleSCEtaWidth,
612	+	Double_t EleSCPhiWidth,
613	+	Double_t EleE1x5OverE5x5,
614	+	Double_t EleR9,
615	+	Double_t EleHoverE,
616	+	Double_t EleEOverP,
617	+	Double_t EleOneOverEMinusOneOverP,
618	+	Double_t EleESeedClusterOverPout,
619	+	Double_t ElePreShowerOverRaw,
620	+	Bool_t printDebug) {
621	+
622	+	if (fMVAType != ElectronIDMVA::kIDEGamma2012NonTrigV0) {
623	+	std::cout << "Error: This function is only supported for MVAType == kIDEGamma2012NonTrigV0.\n" << std::endl;
624	+	assert(kFALSE);
625	+	}
626	+
627	+	fMVAVar_ElePt = ElePt;
628	+	fMVAVar_EleEta = EleSCEta;
629	+	fMVAVar_EleFBrem = EleFBrem;
630	+	fMVAVar_EleKFTrkChiSqr = EleKFTrkChiSqr;
631	+	fMVAVar_EleKFTrkNHits = EleKFTrkNHits;
632	+	fMVAVar_EleGsfTrackChi2OverNdof = EleGsfTrackChi2OverNdof;
633	+	fMVAVar_EleDEtaIn = EleDEtaIn;
634	+	fMVAVar_EleDPhiIn = EleDPhiIn;
635	+	fMVAVar_EledEtaCalo = EledEtaCalo;
636	+	fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
637	+	fMVAVar_EleSigmaIPhiIPhi = EleSigmaIPhiIPhi;
638	+	fMVAVar_EleSCEtaWidth = EleSCEtaWidth;
639	+	fMVAVar_EleSCPhiWidth = EleSCPhiWidth;
640	+	fMVAVar_EleE1x5OverE5x5 = EleE1x5OverE5x5;
641	+	fMVAVar_EleR9 = EleR9;
642	+	fMVAVar_EleHoverE = EleHoverE;
643	+	fMVAVar_EleEOverP = EleEOverP;
644	+	fMVAVar_EleOneOverEMinusOneOverP = EleOneOverEMinusOneOverP;
645	+	fMVAVar_EleESeedClusterOverPout = EleESeedClusterOverPout;
646	+	fMVAVar_ElePreShowerOverRaw = ElePreShowerOverRaw;
647	+
648	+	Double_t mva = -9999;
649	+	TMVA::Reader *reader = 0;
650	+
651	+	if (printDebug == kTRUE) {
652	+	std::cout <<" -> BIN: " << fMVAVar_EleEta << " " << fMVAVar_ElePt << " : " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << std::endl;
653	+	}
654	+	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
655	+	mva = reader->EvaluateMVA( fMethodname );
656
657	+	if (printDebug == kTRUE) {
658	+	std::cout << "Debug Electron MVA: ";
659	+	std::cout << " fbrem " <<  fMVAVar_EleFBrem
660	+	<< " kfchi2 " << fMVAVar_EleKFTrkChiSqr
661	+	<< " kfhits " << fMVAVar_EleKFTrkNLayers
662	+	<< " kfhitsall " <<  fMVAVar_EleKFTrkNHits
663	+	<< " gsfchi2 " << fMVAVar_EleGsfTrackChi2OverNdof
664	+	<< " deta " <<  fMVAVar_EleDEtaIn
665	+	<< " dphi " << fMVAVar_EleDPhiIn
666	+	<< " detacalo " << fMVAVar_EledEtaCalo
667	+	<< " see " << fMVAVar_EleSigmaIEtaIEta
668	+	<< " spp " << fMVAVar_EleSigmaIPhiIPhi
669	+	<< " etawidth " << fMVAVar_EleSCEtaWidth
670	+	<< " phiwidth " << fMVAVar_EleSCPhiWidth
671	+	<< " e1x5e5x5 " << fMVAVar_EleE1x5OverE5x5
672	+	<< " R9 " << fMVAVar_EleR9
673	+	<< " HoE " << fMVAVar_EleHoverE
674	+	<< " EoP " << fMVAVar_EleEOverP
675	+	<< " IoEmIoP " << fMVAVar_EleOneOverEMinusOneOverP
676	+	<< " eleEoPout " << fMVAVar_EleESeedClusterOverPout
677	+	<< " EoPout " << fMVAVar_EleESeedClusterOverPout
678	+	<< " d0 " << fMVAVar_EleD0
679	+	<< " ip3d " << fMVAVar_EleIP3d
680	+	<< " eta " << fMVAVar_EleEta
681	+	<< " pt " << fMVAVar_ElePt << std::endl;
682	+	std::cout << "MVA: " << mva << " "
683	+	<< std::endl;
684	+	}
685	+	return mva;
686	+	}
687
688		//--------------------------------------------------------------------------------------------------
689	<	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex) {
689	>	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
690	>	const PFCandidateCol *PFCands,
691	>	const PileupEnergyDensityCol *PileupEnergyDensity,
692	>	Double_t intRadius,
693	>	Bool_t printDebug) {
694
695		if (!fIsInitialized) {
696		std::cout << "Error: ElectronIDMVA not properly initialized.\n";
697		return -9999;
698		}
699
700	<	Int_t subdet = 0;
701	<	if (ele->SCluster()->AbsEta() < 1.0) subdet = 0;
702	<	else if (ele->SCluster()->AbsEta() < 1.479) subdet = 1;
703	<	else subdet = 2;
704	<	Int_t ptBin = 0;
705	<	if (ele->Pt() > 20.0) ptBin = 1;
700	>	Double_t Rho = 0;
701	>	switch(fTheRhoType) {
702	>	case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA:
703	>	Rho = PileupEnergyDensity->At(0)->Rho();
704	>	break;
705	>	case RhoUtilities::MIT_RHO_VORONOI_LOW_ETA:
706	>	Rho = PileupEnergyDensity->At(0)->RhoLowEta();
707	>	break;
708	>	case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA:
709	>	Rho = PileupEnergyDensity->At(0)->RhoRandom();
710	>	break;
711	>	case RhoUtilities::MIT_RHO_RANDOM_LOW_ETA:
712	>	Rho = PileupEnergyDensity->At(0)->RhoRandomLowEta();
713	>	break;
714	>	case RhoUtilities::CMS_RHO_RHOKT6PFJETS:
715	>	Rho = PileupEnergyDensity->At(0)->RhoKt6PFJets();
716	>	break;
717	>	default:
718	>	// use the old default
719	>	Rho = PileupEnergyDensity->At(0)->Rho();
720	>	break;
721	>	}
722	>
723	>	//set all input variables
724	>	fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
725	>	fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
726	>	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
727	>	fMVAVar_EleHoverE = ele->HadronicOverEm();
728	>	fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
729	>	fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
730	>	fMVAVar_EleFBrem = ele->FBrem();
731	>	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
732	>	fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
733	>	if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
734	>	else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
735	>	fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
736	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->CorrectedEcalEnergy())) - 1.0 / ele->BestTrk()->P();
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	>	fMVAVar_EleChargedIso03OverPt
749	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 99999, 0.3, intRadius)
750	>	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso03, ele->SCluster()->Eta())) / ele->Pt();
751	>	fMVAVar_EleNeutralHadronIso03OverPt
752	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.3, intRadius, PFCandidate::eNeutralHadron)
753	>	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso03, ele->SCluster()->Eta())
754	>	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,ele->SCluster()->Eta())) / ele->Pt();
755	>	fMVAVar_EleGammaIso03OverPt
756	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.3, intRadius, PFCandidate::eGamma)
757	>	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso03, ele->SCluster()->Eta())
758	>	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip03,ele->SCluster()->Eta())) / ele->Pt();
759	>	fMVAVar_EleChargedIso04OverPt
760	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 99999, 0.4, intRadius)
761	>	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso04, ele->SCluster()->Eta())) / ele->Pt();
762	>	fMVAVar_EleNeutralHadronIso04OverPt
763	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.4, intRadius, PFCandidate::eNeutralHadron)
764	>	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso04, ele->SCluster()->Eta())
765	>	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,ele->SCluster()->Eta())) / ele->Pt() ;
766	>	fMVAVar_EleGammaIso04OverPt
767	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.4, intRadius, PFCandidate::eGamma)
768	>	- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso04, ele->SCluster()->Eta())
769	>	+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip04,ele->SCluster()->Eta())) / ele->Pt();
770	>
771	>	//Additional vars
772	>	fMVAVar_EleEEleClusterOverPout = ele->EEleClusterOverPout();
773	>	if (ele->TrackerTrk()) {
774	>	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
775	>	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
776	>	} else {
777	>	fMVAVar_EleKFTrkChiSqr = -1;
778	>	fMVAVar_EleKFTrkNHits = 0;
779	>	}
780	>	fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5() / ele->SCluster()->Seed()->E5x5();
781	>
782	>
783	>	Double_t mva = -9999;
784	>	TMVA::Reader *reader = 0;
785	>	reader = fTMVAReader[GetMVABin( ele->SCluster()->Eta(), ele->Pt())];
786	>	mva = reader->EvaluateMVA( fMethodname );
787	>
788	>	if (printDebug == kTRUE) {
789	>	std::cout << "Debug Electron MVA: "
790	>	<< ele->Pt() << " " << ele->Eta() << " " << ele->Phi() << " : "
791	>	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << GetMVABin( ele->SCluster()->Eta(), ele->Pt()) << " : "
792	>	<< fMVAVar_EleSigmaIEtaIEta << " "
793	>	<< fMVAVar_EleDEtaIn << " "
794	>	<< fMVAVar_EleDPhiIn << " "
795	>	<< fMVAVar_EleHoverE << " "
796	>	<< fMVAVar_EleD0 << " "
797	>	<< fMVAVar_EleDZ << " "
798	>	<< fMVAVar_EleFBrem << " "
799	>	<< fMVAVar_EleEOverP << " "
800	>	<< fMVAVar_EleESeedClusterOverPout << " "
801	>	<< fMVAVar_EleSigmaIPhiIPhi << " "
802	>	<< fMVAVar_EleNBrem << " "
803	>	<< fMVAVar_EleOneOverEMinusOneOverP << " "
804	>	<< fMVAVar_EleESeedClusterOverPIn << " "
805	>	<< fMVAVar_EleIP3d << " "
806	>	<< fMVAVar_EleIP3dSig << " "
807	>	<< fMVAVar_EleGsfTrackChi2OverNdof << " "
808	>	<< fMVAVar_EledEtaCalo << " "
809	>	<< fMVAVar_EledPhiCalo << " "
810	>	<< fMVAVar_EleR9 << " "
811	>	<< fMVAVar_EleSCEtaWidth << " "
812	>	<< fMVAVar_EleSCPhiWidth << " "
813	>	<< fMVAVar_EleCovIEtaIPhi << " "
814	>	<< fMVAVar_ElePreShowerOverRaw << " "
815	>	<< fMVAVar_EleKFTrkChiSqr  << " "
816	>	<< fMVAVar_EleKFTrkNHits  << " "
817	>	<< fMVAVar_EleE1x5OverE5x5  << " "
818	>	<< " ::: "
819	>
820	>	<< " === : === "
821	>	<< mva << " "
822	>	<< std::endl;
823	>
824	>	}
825	>
826	>	return mva;
827	>	}
828	>
829	>	//--------------------------------------------------------------------------------------------------
830	>	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
831	>	Bool_t printDebug) {
832
833	+	if (!fIsInitialized) {
834	+	std::cout << "Error: ElectronIDMVA not properly initialized.\n";
835	+	return -9999;
836	+	}
837	+
838	+	fMVAVar_ElePt = ele->Pt();
839	+	fMVAVar_EleEta = ele->Eta();
840	+
841		//set all input variables
842		fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
843		fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
#	Line 207 | Line 851 | Double_t ElectronIDMVA::MVAValue(const E
851		if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
852		else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
853		fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
854	<	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->ESuperClusterOverP()*ele->BestTrk()->P())) - 1.0 / ele->BestTrk()->P();
854	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->CorrectedEcalEnergy())) - 1.0 / ele->BestTrk()->P();
855		fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
856		fMVAVar_EleIP3d = ele->Ip3dPV();
857		fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
858
859	+
860	+	fMVAVar_EleEEleClusterOverPout = ele->EEleClusterOverPout();
861	+	if (ele->TrackerTrk()) {
862	+	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
863	+	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
864	+	} else {
865	+	fMVAVar_EleKFTrkChiSqr = -1;
866	+	fMVAVar_EleKFTrkNHits = 0;
867	+	}
868	+	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
869	+	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
870	+	fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
871	+	fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
872	+	fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5() / ele->SCluster()->Seed()->E5x5();
873	+	fMVAVar_EleR9 = ele->SCluster()->R9();
874	+	fMVAVar_EleHoverE = ele->HadronicOverEm();
875	+	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
876	+	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->CorrectedEcalEnergy())) - 1.0 / ele->BestTrk()->P();
877	+	fMVAVar_EleR9 = ele->SCluster()->R9();
878	+	fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
879	+
880	+
881		Double_t mva = -9999;
882		TMVA::Reader *reader = 0;
883	<	Int_t MVABin = -1;
218	<	if (subdet == 0 && ptBin == 0) MVABin = 0;
219	<	if (subdet == 1 && ptBin == 0) MVABin = 1;
220	<	if (subdet == 2 && ptBin == 0) MVABin = 2;
221	<	if (subdet == 0 && ptBin == 1) MVABin = 3;
222	<	if (subdet == 1 && ptBin == 1) MVABin = 4;
223	<	if (subdet == 2 && ptBin == 1) MVABin = 5;
224	<	assert(MVABin >= 0 && MVABin <= 5);
225	<	reader = fTMVAReader[MVABin];
226	<
883	>	reader = fTMVAReader[GetMVABin( ele->SCluster()->Eta(), ele->Pt())];
884		mva = reader->EvaluateMVA( fMethodname );
885
886	+	if (printDebug == kTRUE) {
887	+	std::cout << "Debug Electron MVA: "
888	+	<< ele->Pt() << " " << ele->Eta() << " " << ele->Phi() << " : "
889	+	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << GetMVABin( ele->SCluster()->Eta(), ele->Pt()) << " : "
890	+	<< fMVAVar_EleSigmaIEtaIEta << " "
891	+	<< fMVAVar_EleDEtaIn << " "
892	+	<< fMVAVar_EleDPhiIn << " "
893	+	<< fMVAVar_EleHoverE << " "
894	+	<< fMVAVar_EleD0 << " "
895	+	<< fMVAVar_EleDZ << " "
896	+	<< fMVAVar_EleFBrem << " "
897	+	<< fMVAVar_EleEOverP << " "
898	+	<< fMVAVar_EleESeedClusterOverPout << " "
899	+	<< fMVAVar_EleSigmaIPhiIPhi << " "
900	+	<< fMVAVar_EleNBrem << " "
901	+	<< fMVAVar_EleOneOverEMinusOneOverP << " "
902	+	<< fMVAVar_EleESeedClusterOverPIn << " "
903	+	<< fMVAVar_EleIP3d << " "
904	+	<< fMVAVar_EleIP3dSig << " "
905	+	<< fMVAVar_EleGsfTrackChi2OverNdof << " "
906	+	<< fMVAVar_EledEtaCalo << " "
907	+	<< fMVAVar_EledPhiCalo << " "
908	+	<< fMVAVar_EleR9 << " "
909	+	<< fMVAVar_EleSCEtaWidth << " "
910	+	<< fMVAVar_EleSCPhiWidth << " "
911	+	<< fMVAVar_EleCovIEtaIPhi << " "
912	+	<< fMVAVar_ElePreShowerOverRaw << " "
913	+	<< fMVAVar_EleKFTrkChiSqr  << " "
914	+	<< fMVAVar_EleKFTrkNHits  << " "
915	+	<< fMVAVar_EleE1x5OverE5x5  << " "
916	+	<< " === : === "
917	+	<< mva << " "
918	+	<< std::endl;
919	+
920	+	}
921	+
922	+
923	+
924		return mva;
925		}
926	+
927	+
928	+
929	+
930	+	//--------------------------------------------------------------------------------------------------
931	+	//MVA Includes Isolation with removal of other leptons
932	+	//
933	+	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
934	+	const PFCandidateCol *PFCands,
935	+	const PileupEnergyDensityCol *PileupEnergyDensity,
936	+	ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaTarget,
937	+	const ElectronCol *goodElectrons,
938	+	const MuonCol *goodMuons,
939	+	Bool_t printDebug) {
940	+
941	+	if (!fIsInitialized) {
942	+	std::cout << "Error: ElectronIDMVA not properly initialized.\n";
943	+	return -9999;
944	+	}
945	+
946	+	Double_t Rho = 0;
947	+	switch(fTheRhoType) {
948	+	case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA:
949	+	Rho = PileupEnergyDensity->At(0)->Rho();
950	+	break;
951	+	case RhoUtilities::MIT_RHO_VORONOI_LOW_ETA:
952	+	Rho = PileupEnergyDensity->At(0)->RhoLowEta();
953	+	break;
954	+	case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA:
955	+	Rho = PileupEnergyDensity->At(0)->RhoRandom();
956	+	break;
957	+	case RhoUtilities::MIT_RHO_RANDOM_LOW_ETA:
958	+	Rho = PileupEnergyDensity->At(0)->RhoRandomLowEta();
959	+	break;
960	+	case RhoUtilities::CMS_RHO_RHOKT6PFJETS:
961	+	Rho = PileupEnergyDensity->At(0)->RhoKt6PFJets();
962	+	break;
963	+	default:
964	+	// use the old default
965	+	Rho = PileupEnergyDensity->At(0)->Rho();
966	+	break;
967	+	}
968	+
969	+	//set all input variables
970	+	fMVAVar_ElePt = ele->Pt();
971	+	fMVAVar_EleEta = ele->SCluster()->Eta();
972	+	fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
973	+
974	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
975	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
976	+	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0) {
977	+	fMVAVar_EleDEtaIn = TMath::Min(fabs(double(ele->DeltaEtaSuperClusterTrackAtVtx())),0.06); ;
978	+	fMVAVar_EleDPhiIn = TMath::Min(fabs(double(ele->DeltaPhiSuperClusterTrackAtVtx())),0.6);
979	+	fMVAVar_EleFBrem = TMath::Max(double(ele->FBrem()),-1.0);
980	+	fMVAVar_EleEOverP = TMath::Min(double(ele->ESuperClusterOverP()), 20.0);
981	+	fMVAVar_EleESeedClusterOverPout = TMath::Min(double(ele->ESeedClusterOverPout()),20.0);
982	+	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->CorrectedEcalEnergy())) - 1.0 / ele->P();
983	+	fMVAVar_EleGsfTrackChi2OverNdof = TMath::Min(double( ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof()),200.0);
984	+	fMVAVar_EledEtaCalo =  TMath::Min(fabs(double(ele->DeltaEtaSeedClusterTrackAtCalo())),0.2);
985	+	fMVAVar_EleR9 = TMath::Min(double(ele->SCluster()->R9()), 5.0);
986	+	} else {
987	+	fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
988	+	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
989	+	fMVAVar_EleFBrem = ele->FBrem();
990	+	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
991	+	fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
992	+	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->CorrectedEcalEnergy())) - 1.0 / ele->BestTrk()->P();
993	+	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
994	+	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
995	+	fMVAVar_EleR9 = ele->SCluster()->R9();
996	+	}
997	+
998	+	fMVAVar_EleHoverE = ele->HadronicOverEm();
999	+	fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
1000	+	fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
1001	+	if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
1002	+	else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
1003	+	fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
1004	+	fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
1005	+	fMVAVar_EleIP3d = ele->Ip3dPV();
1006	+	fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
1007	+	fMVAVar_EledPhiCalo = ele->DeltaPhiSeedClusterTrackAtCalo();
1008	+	fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
1009	+	fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
1010	+	fMVAVar_EleCovIEtaIPhi = ele->SCluster()->Seed()->CoviEtaiPhi();
1011	+	fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
1012	+
1013	+	//Additional vars
1014	+	fMVAVar_EleEEleClusterOverPout = ele->EEleClusterOverPout();
1015	+	if (ele->TrackerTrk()) {
1016	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1017	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1018	+	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ) {
1019	+	fMVAVar_EleKFTrkChiSqr = TMath::Min(double(ele->TrackerTrk()->RChi2()),10.0);
1020	+	} else {
1021	+	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
1022	+	}
1023	+	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
1024	+	fMVAVar_EleKFTrkNLayers = ele->CTFTrkNLayersWithMeasurement();
1025	+	} else {
1026	+	fMVAVar_EleKFTrkChiSqr = 0;
1027	+	fMVAVar_EleKFTrkNHits = -1;
1028	+	fMVAVar_EleKFTrkNLayers = -1;
1029	+	}
1030	+
1031	+	if( ele->SCluster()->Seed()->E5x5() > 0.0 ) {
1032	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
1033	+	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ||
1034	+	fMVAType == ElectronIDMVA::kIDHWW2012TrigV0 ) {
1035	+	fMVAVar_EleE1x5OverE5x5 = TMath::Min(TMath::Max(1 - double(ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5()) , -1.0),2.0);
1036	+	} else {
1037	+	fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5()/ele->SCluster()->Seed()->E5x5();
1038	+	}
1039	+	} else {
1040	+	fMVAVar_EleE1x5OverE5x5 = -1.0;
1041	+	}
1042	+
1043	+
1044	+	Double_t tmpChargedIso_DR0p0To0p1  = 0;
1045	+	Double_t tmpChargedIso_DR0p1To0p2  = 0;
1046	+	Double_t tmpChargedIso_DR0p2To0p3  = 0;
1047	+	Double_t tmpChargedIso_DR0p3To0p4  = 0;
1048	+	Double_t tmpChargedIso_DR0p4To0p5  = 0;
1049	+	Double_t tmpGammaIso_DR0p0To0p1  = 0;
1050	+	Double_t tmpGammaIso_DR0p1To0p2  = 0;
1051	+	Double_t tmpGammaIso_DR0p2To0p3  = 0;
1052	+	Double_t tmpGammaIso_DR0p3To0p4  = 0;
1053	+	Double_t tmpGammaIso_DR0p4To0p5  = 0;
1054	+	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
1055	+	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
1056	+	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
1057	+	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
1058	+	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
1059	+
1060	+	for (UInt_t p=0; p<PFCands->GetEntries();p++) {
1061	+	const PFCandidate *pf = PFCands->At(p);
1062	+
1063	+	//exclude the electron itself
1064	+	if(pf->GsfTrk() && ele->GsfTrk() &&
1065	+	pf->GsfTrk() == ele->GsfTrk()) continue;
1066	+	if(pf->TrackerTrk() && ele->TrackerTrk() &&
1067	+	pf->TrackerTrk() == ele->TrackerTrk()) continue;
1068	+
1069	+	//************************************************************
1070	+	// New Isolation Calculations
1071	+	//************************************************************
1072	+	Double_t dr = MathUtils::DeltaR(ele->Mom(), pf->Mom());
1073	+
1074	+	if (dr < 1.0) {
1075	+	Bool_t IsLeptonFootprint = kFALSE;
1076	+	//************************************************************
1077	+	// Lepton Footprint Removal
1078	+	//************************************************************
1079	+	if(goodElectrons) {
1080	+	for (UInt_t q=0; q < goodElectrons->GetEntries() ; ++q) {
1081	+	//if pf candidate matches an electron passing ID cuts, then veto it
1082	+	if(pf->GsfTrk() && goodElectrons->At(q)->GsfTrk() &&
1083	+	pf->GsfTrk() == goodElectrons->At(q)->GsfTrk()) IsLeptonFootprint = kTRUE;
1084	+	if(pf->TrackerTrk() && goodElectrons->At(q)->TrackerTrk() &&
1085	+	pf->TrackerTrk() == goodElectrons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
1086	+	//if pf candidate lies in veto regions of electron passing ID cuts, then veto it
1087	+	if(pf->BestTrk() && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479
1088	+	&& MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.015) IsLeptonFootprint = kTRUE;
1089	+	if(pf->PFType() == PFCandidate::eGamma && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479 &&
1090	+	MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.08) IsLeptonFootprint = kTRUE;
1091	+	}
1092	+	}
1093	+	if(goodMuons) {
1094	+	for (UInt_t q=0; q < goodMuons->GetEntries() ; ++q) {
1095	+	//if pf candidate matches an muon passing ID cuts, then veto it
1096	+	if(pf->TrackerTrk() && goodMuons->At(q)->TrackerTrk() &&
1097	+	pf->TrackerTrk() == goodMuons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
1098	+	//if pf candidate lies in veto regions of muon passing ID cuts, then veto it
1099	+	if(pf->BestTrk() && MathUtils::DeltaR(goodMuons->At(q)->Mom(), pf->Mom()) < 0.01) IsLeptonFootprint = kTRUE;
1100	+	}
1101	+	}
1102	+
1103	+	if (!IsLeptonFootprint) {
1104	+	Bool_t passVeto = kTRUE;
1105	+	//Charged
1106	+	if(pf->BestTrk()) {
1107	+	if (!(fabs(pf->BestTrk()->DzCorrected(*vertex) - ele->BestTrk()->DzCorrected(*vertex)) < 0.2)) passVeto = kFALSE;
1108	+	//************************************************************
1109	+	// Veto any PFmuon, or PFEle
1110	+	if (pf->PFType() == PFCandidate::eElectron || pf->PFType() == PFCandidate::eMuon) passVeto = kFALSE;
1111	+	//************************************************************
1112	+	//************************************************************
1113	+	// Footprint Veto
1114	+	if (fabs(ele->SCluster()->Eta()) >= 1.479 && dr < 0.015) passVeto = kFALSE;
1115	+	//************************************************************
1116	+	if (passVeto) {
1117	+	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
1118	+	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
1119	+	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1120	+	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1121	+	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
1122	+	} //pass veto
1123	+
1124	+	}
1125	+	//Gamma
1126	+	else if (pf->PFType() == PFCandidate::eGamma) {
1127	+	//************************************************************
1128	+	// Footprint Veto
1129	+	if (fabs(ele->SCluster()->Eta()) >= 1.479) {
1130	+	if (dr < 0.08) passVeto = kFALSE;
1131	+	}
1132	+	//************************************************************
1133	+
1134	+	if (passVeto) {
1135	+	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
1136	+	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
1137	+	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1138	+	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1139	+	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
1140	+	}
1141	+	}
1142	+	//NeutralHadron
1143	+	else {
1144	+	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
1145	+	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
1146	+	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1147	+	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1148	+	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1149	+	}
1150	+	} //not lepton footprint
1151	+	} //in 1.0 dr cone
1152	+	} //loop over PF candidates
1153	+
1154	+	fMVAVar_ChargedIso_DR0p0To0p1   = TMath::Min((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1155	+	fMVAVar_ChargedIso_DR0p1To0p2   = TMath::Min((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1156	+	fMVAVar_ChargedIso_DR0p2To0p3 = TMath::Min((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1157	+	fMVAVar_ChargedIso_DR0p3To0p4 = TMath::Min((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1158	+	fMVAVar_ChargedIso_DR0p4To0p5 = TMath::Min((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1159	+	fMVAVar_GammaIso_DR0p0To0p1 = TMath::Max(TMath::Min((tmpGammaIso_DR0p0To0p1 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p0To0p1, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1160	+	fMVAVar_GammaIso_DR0p1To0p2 = TMath::Max(TMath::Min((tmpGammaIso_DR0p1To0p2 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p1To0p2, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1161	+	fMVAVar_GammaIso_DR0p2To0p3 = TMath::Max(TMath::Min((tmpGammaIso_DR0p2To0p3 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p2To0p3, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1162	+	fMVAVar_GammaIso_DR0p3To0p4 = TMath::Max(TMath::Min((tmpGammaIso_DR0p3To0p4 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p3To0p4, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1163	+	fMVAVar_GammaIso_DR0p4To0p5 = TMath::Max(TMath::Min((tmpGammaIso_DR0p4To0p5 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p4To0p5, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1164	+	fMVAVar_NeutralHadronIso_DR0p0To0p1 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p0To0p1 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p0To0p1, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1165	+	fMVAVar_NeutralHadronIso_DR0p1To0p2 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p1To0p2 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p1To0p2, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1166	+	fMVAVar_NeutralHadronIso_DR0p2To0p3 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p2To0p3 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p2To0p3, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1167	+	fMVAVar_NeutralHadronIso_DR0p3To0p4 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p3To0p4 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p3To0p4, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1168	+	fMVAVar_NeutralHadronIso_DR0p4To0p5 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p4To0p5 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p4To0p5, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
1169	+
1170	+	//Do Binding of MVA input variables
1171	+	if (   fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0
1172	+	|| fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0
1173	+	|| fMVAType == ElectronIDMVA::kIsoRingsV0
1174	+	|| fMVAType == ElectronIDMVA::kIDHWW2012TrigV0) {
1175	+	bindVariables();
1176	+	}
1177	+
1178	+	Double_t mva = -9999;
1179	+	TMVA::Reader *reader = 0;
1180	+
1181	+	reader = fTMVAReader[GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt)];
1182	+	mva = reader->EvaluateMVA( fMethodname );
1183	+
1184	+	if (printDebug == kTRUE) {
1185	+
1186	+	std::cout << "Debug Electron MVA-ID: "
1187	+	<< fMVAVar_ElePt<< " " << fMVAVar_EleEta << " "
1188	+	<< " --> MVABin " << GetMVABin( fMVAVar_EleEta , fMVAVar_ElePt) << " : "
1189	+	<< " fbrem " <<  fMVAVar_EleFBrem
1190	+	<< " kfchi2 " << fMVAVar_EleKFTrkChiSqr
1191	+	<< " kfhits " << fMVAVar_EleKFTrkNLayers
1192	+	<< " kfhitsall " << fMVAVar_EleKFTrkNHits
1193	+	<< " gsfchi2 " << fMVAVar_EleGsfTrackChi2OverNdof
1194	+	<< " deta " <<  fMVAVar_EleDEtaIn
1195	+	<< " dphi " << fMVAVar_EleDPhiIn
1196	+	<< " detacalo " << fMVAVar_EledEtaCalo
1197	+	<< " see " << fMVAVar_EleSigmaIEtaIEta
1198	+	<< " spp " << fMVAVar_EleSigmaIPhiIPhi
1199	+	<< " etawidth " << fMVAVar_EleSCEtaWidth
1200	+	<< " phiwidth " << fMVAVar_EleSCPhiWidth
1201	+	<< " e1x5e5x5 " << fMVAVar_EleE1x5OverE5x5
1202	+	<< " R9 " << fMVAVar_EleR9
1203	+	<< " HoE " << fMVAVar_EleHoverE
1204	+	<< " EoP " << fMVAVar_EleEOverP
1205	+	<< " IoEmIoP " << fMVAVar_EleOneOverEMinusOneOverP
1206	+	<< " eleEoPout " << fMVAVar_EleEEleClusterOverPout
1207	+	<< " EoPout " << fMVAVar_EleESeedClusterOverPout
1208	+	<< " PreShowerOverRaw" << fMVAVar_ElePreShowerOverRaw
1209	+	<< " d0 " << fMVAVar_EleD0
1210	+	<< " ip3d " << fMVAVar_EleIP3d
1211	+	<< " eta " << fMVAVar_EleEta
1212	+	<< " pt " << fMVAVar_ElePt
1213	+	<< " === : === "
1214	+	<< mva << " "
1215	+	<< std::endl;
1216	+	std::cout << "Debug Electron MVA-ISO: "
1217	+	<< fMVAVar_ChargedIso_DR0p0To0p1 << " "
1218	+	<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
1219	+	<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
1220	+	<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
1221	+	<< fMVAVar_ChargedIso_DR0p4To0p5 << " "
1222	+	<< fMVAVar_GammaIso_DR0p0To0p1 << " "
1223	+	<< fMVAVar_GammaIso_DR0p1To0p2 << " "
1224	+	<< fMVAVar_GammaIso_DR0p2To0p3 << " "
1225	+	<< fMVAVar_GammaIso_DR0p3To0p4 << " "
1226	+	<< fMVAVar_GammaIso_DR0p4To0p5 << " "
1227	+	<< fMVAVar_NeutralHadronIso_DR0p0To0p1 << " "
1228	+	<< fMVAVar_NeutralHadronIso_DR0p1To0p2 << " "
1229	+	<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " "
1230	+	<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
1231	+	<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " "
1232	+	<< std::endl;
1233	+	}
1234	+
1235	+	return mva;
1236	+	}
1237	+
1238	+
1239	+	void ElectronIDMVA::bindVariables() {
1240	+
1241	+	// this binding is needed for variables that sometime diverge.
1242	+
1243	+	if(fMVAVar_EleFBrem < -1.)
1244	+	fMVAVar_EleFBrem = -1.;
1245	+
1246	+	fMVAVar_EleDEtaIn = fabs(fMVAVar_EleDEtaIn);
1247	+	if(fMVAVar_EleDEtaIn > 0.06)
1248	+	fMVAVar_EleDEtaIn = 0.06;
1249	+
1250	+
1251	+	fMVAVar_EleDPhiIn = fabs(fMVAVar_EleDPhiIn);
1252	+	if(fMVAVar_EleDPhiIn > 0.6)
1253	+	fMVAVar_EleDPhiIn = 0.6;
1254	+
1255	+
1256	+	if(fMVAVar_EleESeedClusterOverPout > 20.)
1257	+	fMVAVar_EleESeedClusterOverPout = 20.;
1258	+
1259	+	if(fMVAVar_EleEOverP > 20.)
1260	+	fMVAVar_EleEOverP = 20.;
1261	+
1262	+	if(fMVAVar_EleEEleClusterOverPout > 20.)
1263	+	fMVAVar_EleEEleClusterOverPout = 20.;
1264	+
1265	+
1266	+	fMVAVar_EledEtaCalo = fabs(fMVAVar_EledEtaCalo);
1267	+	if(fMVAVar_EledEtaCalo > 0.2)
1268	+	fMVAVar_EledEtaCalo = 0.2;
1269	+
1270	+
1271	+	if(fMVAVar_EleE1x5OverE5x5 < -1.)
1272	+	fMVAVar_EleE1x5OverE5x5 = -1;
1273	+
1274	+	if(fMVAVar_EleE1x5OverE5x5 > 2.)
1275	+	fMVAVar_EleE1x5OverE5x5 = 2.;
1276	+
1277	+
1278	+
1279	+	if(fMVAVar_EleR9 > 5)
1280	+	fMVAVar_EleR9 = 5;
1281	+
1282	+	if(fMVAVar_EleGsfTrackChi2OverNdof > 200.)
1283	+	fMVAVar_EleGsfTrackChi2OverNdof = 200;
1284	+
1285	+
1286	+	if(fMVAVar_EleKFTrkChiSqr > 10.)
1287	+	fMVAVar_EleKFTrkChiSqr = 10.;
1288	+
1289	+	// Needed for a bug in CMSSW_420, fixed in more recent CMSSW versions
1290	+	if(std::isnan(fMVAVar_EleSigmaIPhiIPhi))
1291	+	fMVAVar_EleSigmaIPhiIPhi = 0.;
1292	+
1293	+
1294	+	return;
1295	+	}

Diff Legend

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