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.2 by sixie, Sun Sep 25 15:03:41 2011 UTC vs.
Revision 1.24 by paus, Sat May 12 18:40:30 2012 UTC

#	Line 15 | Line 15 | using namespace mithep;
15		//--------------------------------------------------------------------------------------------------
16		ElectronIDMVA::ElectronIDMVA() :
17		fMethodname("BDTG method"),
18	<	fLH(0),
19	<	fIsInitialized(kFALSE)
18	>	fIsInitialized(kFALSE),
19	>	fMVAType(ElectronIDMVA::kUninitialized),
20	>	fUseBinnedVersion(kTRUE),
21	>	fNMVABins(0),
22	>	fTheRhoType(RhoUtilities::DEFAULT)
23		{
24		// Constructor.
22	–	for(UInt_t i=0; i<6; ++i) {
23	–	fTMVAReader[i] = 0;
24	–	}
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 41 | Line 53 | void ElectronIDMVA::Initialize( TString
53		TString Subdet0Pt20ToInfWeights,
54		TString Subdet1Pt20ToInfWeights,
55		TString Subdet2Pt20ToInfWeights,
56	<	ElectronLikelihood *LH) {
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;
47	–
88		fMethodname = methodName;
89	<	fLH = LH;
90	<	if (!fLH) { std::cout << "Error: Likelihood is not properly initialized.\n"; assert(fLH); }
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	>
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	>	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	<	for(UInt_t i=0; i<6; ++i) {
222	<	if (fTMVAReader[i]) delete fTMVAReader[i];
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	<	fTMVAReader[i] = new TMVA::Reader( "!Color:!Silent:Error" );
272	<	fTMVAReader[i]->SetVerbose(kTRUE);
273	<	fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta         );
274	<	fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                );
275	<	fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                );
276	<	fTMVAReader[i]->AddVariable( "HoverE",                &fMVAVar_EleHoverE                );
61	<	fTMVAReader[i]->AddVariable( "D0",                    &fMVAVar_EleD0                    );
62	<	fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                 );
63	<	fTMVAReader[i]->AddVariable( "EOverP",                &fMVAVar_EleEOverP                );
64	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout  );
65	<	fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi         );
66	<	fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                 );
67	<	fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP );
68	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn   );
69	<	fTMVAReader[i]->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                  );
70	<	fTMVAReader[i]->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig               );
71	<	fTMVAReader[i]->AddVariable( "StandardLikelihood",    &fMVAVar_EleStandardLikelihood    );
72	<
73	<	if (i==0) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt10To20Weights );
74	<	if (i==1) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt10To20Weights );
75	<	if (i==2) fTMVAReader[i]->BookMVA(fMethodname , Subdet2Pt10To20Weights );
76	<	if (i==3) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt20ToInfWeights );
77	<	if (i==4) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt20ToInfWeights );
78	<	if (i==5) fTMVAReader[i]->BookMVA(fMethodname , Subdet2Pt20ToInfWeights );
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	+	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	<	std::cout << "Electron ID MVA Initialization\n";
312	<	std::cout << "MethodName : " << fMethodname << std::endl;
313	<	std::cout << "Load weights file : " << Subdet0Pt10To20Weights << std::endl;
314	<	std::cout << "Load weights file : " << Subdet1Pt10To20Weights << std::endl;
315	<	std::cout << "Load weights file : " << Subdet2Pt10To20Weights << std::endl;
316	<	std::cout << "Load weights file : " << Subdet0Pt20ToInfWeights << std::endl;
317	<	std::cout << "Load weights file : " << Subdet1Pt20ToInfWeights << std::endl;
318	<	std::cout << "Load weights file : " << Subdet2Pt20ToInfWeights << std::endl;
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(const Electron *ele, const Vertex *vertex) {
338	>	Double_t ElectronIDMVA::MVAValue(Double_t ElePt , Double_t EleEta,
339	>	Double_t EleSigmaIEtaIEta,
340	>	Double_t EleDEtaIn,
341	>	Double_t EleDPhiIn,
342	>	Double_t EleHoverE,
343	>	Double_t EleD0,
344	>	Double_t EleDZ,
345	>	Double_t EleFBrem,
346	>	Double_t EleEOverP,
347	>	Double_t EleESeedClusterOverPout,
348	>	Double_t EleSigmaIPhiIPhi,
349	>	Double_t EleNBrem,
350	>	Double_t EleOneOverEMinusOneOverP,
351	>	Double_t EleESeedClusterOverPIn,
352	>	Double_t EleIP3d,
353	>	Double_t EleIP3dSig
354	>	) {
355
356		if (!fIsInitialized) {
357		std::cout << "Error: ElectronIDMVA not properly initialized.\n";
358		return -9999;
359		}
360
361	<	Int_t subdet = 0;
362	<	if (ele->SCluster()->AbsEta() < 1.0) subdet = 0;
363	<	else if (ele->SCluster()->AbsEta() < 1.479) subdet = 1;
364	<	else subdet = 2;
365	<	Int_t ptBin = 0;
366	<	if (ele->Pt() > 20.0) ptBin = 1;
361	>	//set all input variables
362	>	fMVAVar_EleSigmaIEtaIEta = EleSigmaIEtaIEta;
363	>	fMVAVar_EleDEtaIn = EleDEtaIn;
364	>	fMVAVar_EleDPhiIn = EleDPhiIn;
365	>	fMVAVar_EleHoverE = EleHoverE;
366	>	fMVAVar_EleD0 = EleD0;
367	>	fMVAVar_EleDZ = EleDZ;
368	>	fMVAVar_EleFBrem = EleFBrem;
369	>	fMVAVar_EleEOverP = EleEOverP;
370	>	fMVAVar_EleESeedClusterOverPout = EleESeedClusterOverPout;
371	>	fMVAVar_EleSigmaIPhiIPhi = EleSigmaIPhiIPhi;
372	>	fMVAVar_EleNBrem = EleNBrem;
373	>	fMVAVar_EleOneOverEMinusOneOverP = EleOneOverEMinusOneOverP;
374	>	fMVAVar_EleESeedClusterOverPIn = EleESeedClusterOverPIn;
375	>	fMVAVar_EleIP3d = EleIP3d;
376	>	fMVAVar_EleIP3dSig = EleIP3dSig;
377	>
378	>	Double_t mva = -9999;
379	>	TMVA::Reader *reader = 0;
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,
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	+	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();
#	Line 119 | Line 733 | Double_t ElectronIDMVA::MVAValue(const E
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->ESuperClusterOverP()*ele->BestTrk()->P())) - 1.0 / ele->BestTrk()->P();
736	>	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->EcalEnergy())) - 1.0 / ele->BestTrk()->P();
737		fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
738		fMVAVar_EleIP3d = ele->Ip3dPV();
739		fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
740	<	fMVAVar_EleStandardLikelihood = ElectronTools::Likelihood(fLH, ele);
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	<	Int_t MVABin = -1;
131	<	if (subdet == 0 && ptBin == 0) MVABin = 0;
132	<	if (subdet == 1 && ptBin == 0) MVABin = 1;
133	<	if (subdet == 2 && ptBin == 0) MVABin = 2;
134	<	if (subdet == 0 && ptBin == 1) MVABin = 3;
135	<	if (subdet == 1 && ptBin == 1) MVABin = 4;
136	<	if (subdet == 2 && ptBin == 1) MVABin = 5;
137	<	assert(MVABin >= 0 && MVABin <= 5);
138	<	reader = fTMVAReader[MVABin];
139	<
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();
844	+	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
845	+	fMVAVar_EleHoverE = ele->HadronicOverEm();
846	+	fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
847	+	fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
848	+	fMVAVar_EleFBrem = ele->FBrem();
849	+	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
850	+	fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
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->EcalEnergy())) - 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->EcalEnergy())) - 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	+	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->EcalEnergy())) - 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->EcalEnergy())) - 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