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.9 by sixie, Wed Jan 4 14:39:16 2012 UTC vs.
Revision 1.13 by sixie, Sun Apr 15 12:27:34 2012 UTC

#	Line 15 | Line 15 | using namespace mithep;
15		//--------------------------------------------------------------------------------------------------
16		ElectronIDMVA::ElectronIDMVA() :
17		fMethodname("BDTG method"),
18	<	fIsInitialized(kFALSE)
18	>	fIsInitialized(kFALSE),
19	>	fMVAType(ElectronIDMVA::kUninitialized),
20	>	fUseBinnedVersion(kTRUE),
21	>	fNMVABins(0)
22		{
23		// Constructor.
21	–	for(UInt_t i=0; i<6; ++i) {
22	–	fTMVAReader[i] = 0;
23	–	}
24		}
25
26
27		//--------------------------------------------------------------------------------------------------
28		ElectronIDMVA::~ElectronIDMVA()
29		{
30	<	for(UInt_t i=0; i<6; ++i) {
30	>	for(UInt_t i=0; i<fTMVAReader.size(); ++i) {
31		if (fTMVAReader[i]) delete fTMVAReader[i];
32		}
33		}
34
35		//--------------------------------------------------------------------------------------------------
36	+	void ElectronIDMVA::Initialize( std::string methodName,
37	+	std::string weightsfile,
38	+	ElectronIDMVA::MVAType type)
39	+	{
40	+
41	+	std::vector<std::string> tempWeightFileVector;
42	+	tempWeightFileVector.push_back(weightsfile);
43	+	Initialize(methodName,type,kFALSE,tempWeightFileVector);
44	+	}
45	+
46	+	//--------------------------------------------------------------------------------------------------
47		void ElectronIDMVA::Initialize( TString methodName,
48		TString Subdet0Pt10To20Weights ,
49		TString Subdet1Pt10To20Weights ,
#	Line 42 | Line 53 | void ElectronIDMVA::Initialize( TString
53		TString Subdet2Pt20ToInfWeights,
54		ElectronIDMVA::MVAType type) {
55
56	+	std::vector<std::string> tempWeightFileVector;
57	+	tempWeightFileVector.push_back(std::string(Subdet0Pt10To20Weights.Data()));
58	+	tempWeightFileVector.push_back(std::string(Subdet1Pt10To20Weights.Data()));
59	+	tempWeightFileVector.push_back(std::string(Subdet2Pt10To20Weights.Data()));
60	+	tempWeightFileVector.push_back(std::string(Subdet0Pt20ToInfWeights.Data()));
61	+	tempWeightFileVector.push_back(std::string(Subdet1Pt20ToInfWeights.Data()));
62	+	tempWeightFileVector.push_back(std::string(Subdet2Pt20ToInfWeights.Data()));
63	+	Initialize(std::string(methodName.Data()),type,kTRUE,tempWeightFileVector);
64	+
65	+	}
66	+
67	+
68	+	//--------------------------------------------------------------------------------------------------
69	+	void ElectronIDMVA::Initialize(  std::string methodName,
70	+	ElectronIDMVA::MVAType type,
71	+	Bool_t useBinnedVersion,
72	+	std::vector<std::string> weightsfiles
73	+
74	+	) {
75	+
76	+	//clean up first
77	+	for (uint i=0;i<fTMVAReader.size(); ++i) {
78	+	if (fTMVAReader[i]) delete fTMVAReader[i];
79	+	}
80	+	fTMVAReader.clear();
81	+
82	+	//initialize
83		fIsInitialized = kTRUE;
46	–
84		fMethodname = methodName;
85	<
86	<	for(UInt_t i=0; i<6; ++i) {
87	<	if (fTMVAReader[i]) delete fTMVAReader[i];
85	>	fMVAType = type;
86	>	fUseBinnedVersion = useBinnedVersion;
87	>
88	>	//Define expected number of bins
89	>	UInt_t ExpectedNBins = 0;
90	>	if (!fUseBinnedVersion) {
91	>	ExpectedNBins = 1;
92	>	} else if (type == kBaseline
93	>	||type == kNoIPInfo
94	>	||type == kWithIPInfo
95	>	||type == kIDIsoCombined) {
96	>	ExpectedNBins = 6;
97	>	} else if (type == kIDEGamma2012TrigV0 ||
98	>	type == kIDEGamma2012NonTrigV0) {
99	>	ExpectedNBins = 6;
100	>	} else if (type == kIsoRingsV0) {
101	>	ExpectedNBins = 4;
102	>	}
103	>	fNMVABins = ExpectedNBins;
104	>
105	>	//Check number of weight files given
106	>	if (fNMVABins != weightsfiles.size() ) {
107	>	std::cout << "Error: Expected Number of bins = " << fNMVABins << " does not equal to weightsfiles.size() = "
108	>	<< weightsfiles.size() << std::endl;
109	>	assert(fNMVABins == weightsfiles.size());
110	>	}
111
112	<	fTMVAReader[i] = new TMVA::Reader( "!Color:!Silent:Error" );
113	<	fTMVAReader[i]->SetVerbose(kTRUE);
112	>
113	>	for(UInt_t i=0; i<fNMVABins; ++i) {
114	>	TMVA::Reader *tmpTMVAReader = new TMVA::Reader( "!Color:!Silent:Error" );
115	>	tmpTMVAReader->SetVerbose(kTRUE);
116
117		if (type == kBaseline) {
118	<	fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
119	<	fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
120	<	fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
121	<	fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
122	<	fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
123	<	fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                    );
124	<	fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
125	<	}
64	<
118	>	tmpTMVAReader->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
119	>	tmpTMVAReader->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
120	>	tmpTMVAReader->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
121	>	tmpTMVAReader->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
122	>	tmpTMVAReader->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
123	>	tmpTMVAReader->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                    );
124	>	tmpTMVAReader->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
125	>	}
126		if (type == kNoIPInfo) {
127	<	fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
128	<	fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
129	<	fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
130	<	fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
131	<	fTMVAReader[i]->AddVariable( "EOverP",                &fMVAVar_EleEOverP                   );
132	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout     );
133	<	fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
134	<	fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                    );
135	<	fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
136	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn      );
127	>	tmpTMVAReader->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
128	>	tmpTMVAReader->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
129	>	tmpTMVAReader->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
130	>	tmpTMVAReader->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
131	>	tmpTMVAReader->AddVariable( "EOverP",                &fMVAVar_EleEOverP                   );
132	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout     );
133	>	tmpTMVAReader->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
134	>	tmpTMVAReader->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                    );
135	>	tmpTMVAReader->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
136	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn      );
137		}
138		if (type == kWithIPInfo) {
139	<	fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
140	<	fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
141	<	fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
142	<	fTMVAReader[i]->AddVariable( "D0",                    &fMVAVar_EleD0                       );
143	<	fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
144	<	fTMVAReader[i]->AddVariable( "EOverP",                &fMVAVar_EleEOverP                   );
145	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout     );
146	<	fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
147	<	fTMVAReader[i]->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                    );
148	<	fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
149	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn      );
150	<	fTMVAReader[i]->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                     );
151	<	fTMVAReader[i]->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig                  );
139	>	tmpTMVAReader->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
140	>	tmpTMVAReader->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
141	>	tmpTMVAReader->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
142	>	tmpTMVAReader->AddVariable( "D0",                    &fMVAVar_EleD0                       );
143	>	tmpTMVAReader->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
144	>	tmpTMVAReader->AddVariable( "EOverP",                &fMVAVar_EleEOverP                   );
145	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout     );
146	>	tmpTMVAReader->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
147	>	tmpTMVAReader->AddVariable( "NBrem",                 &fMVAVar_EleNBrem                    );
148	>	tmpTMVAReader->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
149	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn      );
150	>	tmpTMVAReader->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                     );
151	>	tmpTMVAReader->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig                  );
152		}
153		if (type == kIDIsoCombined) {
154	<	fTMVAReader[i]->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
155	<	fTMVAReader[i]->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
156	<	fTMVAReader[i]->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
157	<	fTMVAReader[i]->AddVariable( "D0",                    &fMVAVar_EleD0                       );
158	<	fTMVAReader[i]->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
159	<	fTMVAReader[i]->AddVariable( "EOverP",                &fMVAVar_EleEOverP                   );
160	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout     );
161	<	fTMVAReader[i]->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
162	<	fTMVAReader[i]->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
163	<	fTMVAReader[i]->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn      );
164	<	fTMVAReader[i]->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                     );
165	<	fTMVAReader[i]->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig                  );
166	<
167	<	fTMVAReader[i]->AddVariable( "GsfTrackChi2OverNdof",  &fMVAVar_EleGsfTrackChi2OverNdof     );
168	<	fTMVAReader[i]->AddVariable( "dEtaCalo",              &fMVAVar_EledEtaCalo                 );
169	<	fTMVAReader[i]->AddVariable( "dPhiCalo",              &fMVAVar_EledPhiCalo                 );
170	<	fTMVAReader[i]->AddVariable( "R9",                    &fMVAVar_EleR9                       );
171	<	fTMVAReader[i]->AddVariable( "SCEtaWidth",            &fMVAVar_EleSCEtaWidth               );
172	<	fTMVAReader[i]->AddVariable( "SCPhiWidth",            &fMVAVar_EleSCPhiWidth               );
173	<	fTMVAReader[i]->AddVariable( "CovIEtaIPhi",           &fMVAVar_EleCovIEtaIPhi              );
154	>	tmpTMVAReader->AddVariable( "SigmaIEtaIEta",         &fMVAVar_EleSigmaIEtaIEta            );
155	>	tmpTMVAReader->AddVariable( "DEtaIn",                &fMVAVar_EleDEtaIn                   );
156	>	tmpTMVAReader->AddVariable( "DPhiIn",                &fMVAVar_EleDPhiIn                   );
157	>	tmpTMVAReader->AddVariable( "D0",                    &fMVAVar_EleD0                       );
158	>	tmpTMVAReader->AddVariable( "FBrem",                 &fMVAVar_EleFBrem                    );
159	>	tmpTMVAReader->AddVariable( "EOverP",                &fMVAVar_EleEOverP                   );
160	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPout",  &fMVAVar_EleESeedClusterOverPout     );
161	>	tmpTMVAReader->AddVariable( "SigmaIPhiIPhi",         &fMVAVar_EleSigmaIPhiIPhi            );
162	>	tmpTMVAReader->AddVariable( "OneOverEMinusOneOverP", &fMVAVar_EleOneOverEMinusOneOverP    );
163	>	tmpTMVAReader->AddVariable( "ESeedClusterOverPIn",   &fMVAVar_EleESeedClusterOverPIn      );
164	>	tmpTMVAReader->AddVariable( "IP3d",                  &fMVAVar_EleIP3d                     );
165	>	tmpTMVAReader->AddVariable( "IP3dSig",               &fMVAVar_EleIP3dSig                  );
166	>
167	>	tmpTMVAReader->AddVariable( "GsfTrackChi2OverNdof",  &fMVAVar_EleGsfTrackChi2OverNdof     );
168	>	tmpTMVAReader->AddVariable( "dEtaCalo",              &fMVAVar_EledEtaCalo                 );
169	>	tmpTMVAReader->AddVariable( "dPhiCalo",              &fMVAVar_EledPhiCalo                 );
170	>	tmpTMVAReader->AddVariable( "R9",                    &fMVAVar_EleR9                       );
171	>	tmpTMVAReader->AddVariable( "SCEtaWidth",            &fMVAVar_EleSCEtaWidth               );
172	>	tmpTMVAReader->AddVariable( "SCPhiWidth",            &fMVAVar_EleSCPhiWidth               );
173	>	tmpTMVAReader->AddVariable( "CovIEtaIPhi",           &fMVAVar_EleCovIEtaIPhi              );
174		if (i == 2 || i == 5) {
175	<	fTMVAReader[i]->AddVariable( "PreShowerOverRaw",      &fMVAVar_ElePreShowerOverRaw       );
175	>	tmpTMVAReader->AddVariable( "PreShowerOverRaw",      &fMVAVar_ElePreShowerOverRaw       );
176		}
177	<	fTMVAReader[i]->AddVariable( "ChargedIso03",          &fMVAVar_EleChargedIso03OverPt       );
178	<	fTMVAReader[i]->AddVariable( "NeutralHadronIso03",    &fMVAVar_EleNeutralHadronIso03OverPt );
179	<	fTMVAReader[i]->AddVariable( "GammaIso03",            &fMVAVar_EleGammaIso03OverPt         );
180	<	fTMVAReader[i]->AddVariable( "ChargedIso04",          &fMVAVar_EleChargedIso04OverPt       );
181	<	fTMVAReader[i]->AddVariable( "NeutralHadronIso04",    &fMVAVar_EleNeutralHadronIso04OverPt );
182	<	fTMVAReader[i]->AddVariable( "GammaIso04",            &fMVAVar_EleGammaIso04OverPt         );
177	>	tmpTMVAReader->AddVariable( "ChargedIso03",          &fMVAVar_EleChargedIso03OverPt       );
178	>	tmpTMVAReader->AddVariable( "NeutralHadronIso03",    &fMVAVar_EleNeutralHadronIso03OverPt );
179	>	tmpTMVAReader->AddVariable( "GammaIso03",            &fMVAVar_EleGammaIso03OverPt         );
180	>	tmpTMVAReader->AddVariable( "ChargedIso04",          &fMVAVar_EleChargedIso04OverPt       );
181	>	tmpTMVAReader->AddVariable( "NeutralHadronIso04",    &fMVAVar_EleNeutralHadronIso04OverPt );
182	>	tmpTMVAReader->AddVariable( "GammaIso04",            &fMVAVar_EleGammaIso04OverPt         );
183
184		}
185
186	<	if (i==0) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt10To20Weights );
187	<	if (i==1) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt10To20Weights );
188	<	if (i==2) fTMVAReader[i]->BookMVA(fMethodname , Subdet2Pt10To20Weights );
189	<	if (i==3) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt20ToInfWeights );
190	<	if (i==4) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt20ToInfWeights );
191	<	if (i==5) fTMVAReader[i]->BookMVA(fMethodname , Subdet2Pt20ToInfWeights );
186	>	if (type == kIDEGamma2012TrigV0 || type == kIDEGamma2012NonTrigV0 ) {
187	>	// Pure tracking variables
188	>	tmpTMVAReader->AddVariable("fbrem",           &fMVAVar_EleFBrem);
189	>	tmpTMVAReader->AddVariable("kfchi2",          &fMVAVar_EleKFTrkChiSqr);
190	>	tmpTMVAReader->AddVariable("kfhits",          &fMVAVar_EleKFTrkNHits);  //Don't have this in BAMBU
191	>	tmpTMVAReader->AddVariable("kfhitsall",       &fMVAVar_EleKFTrkNHits);
192	>	tmpTMVAReader->AddVariable("gsfchi2",         &fMVAVar_EleGsfTrackChi2OverNdof);
193	>	tmpTMVAReader->AddVariable("deta",            &fMVAVar_EleDEtaIn);
194	>	tmpTMVAReader->AddVariable("dphi",            &fMVAVar_EleDPhiIn);
195	>	tmpTMVAReader->AddVariable("detacalo",        &fMVAVar_EledEtaCalo);
196	>	tmpTMVAReader->AddVariable("see",             &fMVAVar_EleSigmaIEtaIEta);
197	>	tmpTMVAReader->AddVariable("spp",             &fMVAVar_EleSigmaIPhiIPhi);
198	>	tmpTMVAReader->AddVariable("etawidth",        &fMVAVar_EleSCEtaWidth);
199	>	tmpTMVAReader->AddVariable("phiwidth",        &fMVAVar_EleSCPhiWidth);
200	>	tmpTMVAReader->AddVariable("e1x5e5x5",        &fMVAVar_EleE1x5OverE5x5);
201	>	tmpTMVAReader->AddVariable("R9",              &fMVAVar_EleR9);
202	>	tmpTMVAReader->AddVariable("HoE",             &fMVAVar_EleHoverE);
203	>	tmpTMVAReader->AddVariable("EoP",             &fMVAVar_EleEOverP);
204	>	tmpTMVAReader->AddVariable("IoEmIoP",         &fMVAVar_EleOneOverEMinusOneOverP);
205	>	tmpTMVAReader->AddVariable("eleEoPout",       &fMVAVar_EleEEleClusterOverPout);
206	>	tmpTMVAReader->AddVariable("EoPout",          &fMVAVar_EleESeedClusterOverPout); //we have this only in BAMBU
207	>	tmpTMVAReader->AddVariable("PreShowerOverRaw",&fMVAVar_ElePreShowerOverRaw);
208	>
209	>	tmpTMVAReader->AddSpectator("eta",            &fMVAVar_EleEta);
210	>	tmpTMVAReader->AddSpectator("pt",             &fMVAVar_ElePt);
211	>	}
212	>
213	>	if (type == kIsoRingsV0) {
214	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p0To0p1",         &fMVAVar_ChargedIso_DR0p0To0p1        );
215	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p1To0p2",         &fMVAVar_ChargedIso_DR0p1To0p2        );
216	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p2To0p3",         &fMVAVar_ChargedIso_DR0p2To0p3        );
217	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p3To0p4",         &fMVAVar_ChargedIso_DR0p3To0p4        );
218	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p4To0p5",         &fMVAVar_ChargedIso_DR0p4To0p5        );
219	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p0To0p1",           &fMVAVar_GammaIso_DR0p0To0p1          );
220	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p1To0p2",           &fMVAVar_GammaIso_DR0p1To0p2          );
221	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p2To0p3",           &fMVAVar_GammaIso_DR0p2To0p3          );
222	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p3To0p4",           &fMVAVar_GammaIso_DR0p3To0p4          );
223	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p4To0p5",           &fMVAVar_GammaIso_DR0p4To0p5          );
224	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p0To0p1",   &fMVAVar_NeutralHadronIso_DR0p0To0p1  );
225	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p1To0p2",   &fMVAVar_NeutralHadronIso_DR0p1To0p2  );
226	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p2To0p3",   &fMVAVar_NeutralHadronIso_DR0p2To0p3  );
227	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p3To0p4",   &fMVAVar_NeutralHadronIso_DR0p3To0p4  );
228	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p4To0p5",   &fMVAVar_NeutralHadronIso_DR0p4To0p5  );
229	>	tmpTMVAReader->AddSpectator( "eta",   &fMVAVar_EleEta );
230	>	tmpTMVAReader->AddSpectator( "pt" ,   &fMVAVar_ElePt  );
231	>	}
232	>
233	>	tmpTMVAReader->BookMVA(fMethodname , weightsfiles[i] );
234	>	std::cout << "MVABin " << i << " : MethodName = " << fMethodname
235	>	<< " , type == " << type << " , "
236	>	<< "Load weights file : " << weightsfiles[i]
237	>	<< std::endl;
238	>	fTMVAReader.push_back(tmpTMVAReader);
239
240		}
241	+	std::cout << "Electron ID MVA Completed\n";
242	+	}
243	+
244	+
245	+	//--------------------------------------------------------------------------------------------------
246	+	UInt_t ElectronIDMVA::GetMVABin( double eta, double pt) const {
247	+
248	+	//Default is to return the first bin
249	+	uint bin = 0;
250	+
251	+	if (fMVAType == ElectronIDMVA::kBaseline
252	+	||fMVAType == ElectronIDMVA::kNoIPInfo
253	+	||fMVAType == ElectronIDMVA::kWithIPInfo
254	+	||fMVAType == ElectronIDMVA::kIDIsoCombined) {
255	+	if (pt < 20 && fabs(eta) < 1.0) bin = 0;
256	+	if (pt < 20 && fabs(eta) >= 1.0 && fabs(eta) < 1.479) bin = 1;
257	+	if (pt < 20 && fabs(eta) >= 1.479) bin = 2;
258	+	if (pt >= 20 && fabs(eta) < 1.0) bin = 3;
259	+	if (pt >= 20 && fabs(eta) >= 1.0 && fabs(eta) < 1.479) bin = 4;
260	+	if (pt >= 20 && fabs(eta) >= 1.479) bin = 5;
261	+	}
262	+
263	+	if (fMVAType == ElectronIDMVA::kIsoRingsV0) {
264	+	if (pt < 10 && fabs(eta) < 1.479) bin = 0;
265	+	if (pt < 10 && fabs(eta) >= 1.479) bin = 1;
266	+	if (pt >= 10 && fabs(eta) < 1.479) bin = 2;
267	+	if (pt >= 10 && fabs(eta) >= 1.479) bin = 3;
268	+	}
269
270	<	std::cout << "Electron ID MVA Initialization\n";
271	<	std::cout << "MethodName : " << fMethodname << " , type == " << type << std::endl;
272	<	std::cout << "Load weights file : " << Subdet0Pt10To20Weights << std::endl;
273	<	std::cout << "Load weights file : " << Subdet1Pt10To20Weights << std::endl;
274	<	std::cout << "Load weights file : " << Subdet2Pt10To20Weights << std::endl;
275	<	std::cout << "Load weights file : " << Subdet0Pt20ToInfWeights << std::endl;
276	<	std::cout << "Load weights file : " << Subdet1Pt20ToInfWeights << std::endl;
277	<	std::cout << "Load weights file : " << Subdet2Pt20ToInfWeights << std::endl;
270	>	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0 ||
271	>	fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0 ) {
272	>	bin = 0;
273	>	if (pt < 10 && fabs(eta) < 0.8) bin = 0;
274	>	if (pt < 10 && fabs(eta) >= 0.8 && fabs(eta) < 1.479 ) bin = 1;
275	>	if (pt < 10 && fabs(eta) >= 1.479) bin = 2;
276	>	if (pt >= 10 && fabs(eta) < 0.8) bin = 3;
277	>	if (pt >= 10 && fabs(eta) >= 0.8 && fabs(eta) < 1.479 ) bin = 4;
278	>	if (pt >= 10 && fabs(eta) >= 1.479) bin = 5;
279	>	}
280
281	+	return bin;
282		}
283
284	+
285	+
286		//--------------------------------------------------------------------------------------------------
287		Double_t ElectronIDMVA::MVAValue(Double_t ElePt , Double_t EleEta,
288		Double_t EleSigmaIEtaIEta,
#	Line 237 | Line 378 | Double_t ElectronIDMVA::MVAValue(Double_
378		Double_t EleGammaIso03,
379		Double_t EleChargedIso04,
380		Double_t EleNeutralHadronIso04,
381	<	Double_t EleGammaIso04
381	>	Double_t EleGammaIso04,
382	>	Bool_t printDebug
383		) {
384
385		if (!fIsInitialized) {
#	Line 301 | Line 443 | Double_t ElectronIDMVA::MVAValue(Double_
443		= (EleGammaIso04
444		- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso04, EleEta)
445		+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip04,EleEta))/ElePt;
446	<
446	>
447	>
448	>
449	>
450		Double_t mva = -9999;
451		TMVA::Reader *reader = 0;
452		Int_t MVABin = -1;
#	Line 316 | Line 461 | Double_t ElectronIDMVA::MVAValue(Double_
461
462		mva = reader->EvaluateMVA( fMethodname );
463
464	<	Bool_t printdebug = kFALSE;
320	<	if (printdebug == kTRUE) {
464	>	if (printDebug == kTRUE) {
465		std::cout << "Debug Electron MVA: "
466		<< ElePt << " " << EleEta << " " << " --> MVABin " << MVABin << " : "
467		<< fMVAVar_EleSigmaIEtaIEta << " "
#	Line 361 | Line 505 | Double_t ElectronIDMVA::MVAValue(Double_
505		//--------------------------------------------------------------------------------------------------
506		Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
507		const PFCandidateCol *PFCands,
508	<	const PileupEnergyDensityCol *PileupEnergyDensity) {
508	>	const PileupEnergyDensityCol *PileupEnergyDensity,
509	>	Double_t intRadius,
510	>	Bool_t printDebug) {
511
512		if (!fIsInitialized) {
513		std::cout << "Error: ElectronIDMVA not properly initialized.\n";
#	Line 404 | Line 550 | Double_t ElectronIDMVA::MVAValue(const E
550		fMVAVar_EleCovIEtaIPhi = ele->SCluster()->Seed()->CoviEtaiPhi();
551		fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
552		fMVAVar_EleChargedIso03OverPt
553	<	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 99999, 0.3, 0.0)
553	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 99999, 0.3, intRadius)
554		- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso03, ele->SCluster()->Eta())) / ele->Pt();
555		fMVAVar_EleNeutralHadronIso03OverPt
556	<	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.3, 0.0, PFCandidate::eNeutralHadron)
556	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.3, intRadius, PFCandidate::eNeutralHadron)
557		- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso03, ele->SCluster()->Eta())
558		+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,ele->SCluster()->Eta())) / ele->Pt();
559		fMVAVar_EleGammaIso03OverPt
560	<	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.3, 0.0, PFCandidate::eGamma)
560	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.3, intRadius, PFCandidate::eGamma)
561		- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso03, ele->SCluster()->Eta())
562		+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip03,ele->SCluster()->Eta())) / ele->Pt();
563		fMVAVar_EleChargedIso04OverPt
564	<	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 99999, 0.4, 0.0)
564	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 99999, 0.4, intRadius)
565		- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleChargedIso04, ele->SCluster()->Eta())) / ele->Pt();
566		fMVAVar_EleNeutralHadronIso04OverPt
567	<	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.4, 0.0, PFCandidate::eNeutralHadron)
567	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.4, intRadius, PFCandidate::eNeutralHadron)
568		- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso04, ele->SCluster()->Eta())
569		+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIso007,ele->SCluster()->Eta())) / ele->Pt() ;
570		fMVAVar_EleGammaIso04OverPt
571	<	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.4, 0.0, PFCandidate::eGamma)
571	>	= (IsolationTools::PFElectronIsolation(ele, PFCands, vertex, 0.1, 0.5, 0.4, intRadius, PFCandidate::eGamma)
572		- Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIso04, ele->SCluster()->Eta())
573		+ Rho * ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoVetoEtaStrip04,ele->SCluster()->Eta())) / ele->Pt();
574
575	+	//Additional vars
576	+	fMVAVar_EleEEleClusterOverPout = 0;
577	+	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
578	+	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
579	+	fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5() / ele->SCluster()->Seed()->E5x5();
580	+
581	+
582	+
583	+
584		Double_t mva = -9999;
585		TMVA::Reader *reader = 0;
586		Int_t MVABin = -1;
#	Line 440 | Line 595 | Double_t ElectronIDMVA::MVAValue(const E
595
596		mva = reader->EvaluateMVA( fMethodname );
597
598	<	Bool_t printdebug = kFALSE;
599	<	if (printdebug == kTRUE) {
598	>	if (printDebug == kTRUE) {
599	>	//     std::cout << "Debug Electron MVA: "
600	>	//               << ele->Pt() << " " << ele->Eta() << " " << ele->Phi() << " : "
601	>	//               << ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << MVABin << " : "
602	>	//               << fMVAVar_EleSigmaIEtaIEta << " "
603	>	//               << fMVAVar_EleDEtaIn << " "
604	>	//               << fMVAVar_EleDPhiIn << " "
605	>	//               << fMVAVar_EleHoverE << " "
606	>	//               << fMVAVar_EleD0 << " "
607	>	//               << fMVAVar_EleDZ << " "
608	>	//               << fMVAVar_EleFBrem << " "
609	>	//               << fMVAVar_EleEOverP << " "
610	>	//               << fMVAVar_EleESeedClusterOverPout << " "
611	>	//               << fMVAVar_EleSigmaIPhiIPhi << " "
612	>	//               << fMVAVar_EleNBrem << " "
613	>	//               << fMVAVar_EleOneOverEMinusOneOverP << " "
614	>	//               << fMVAVar_EleESeedClusterOverPIn << " "
615	>	//               << fMVAVar_EleIP3d << " "
616	>	//               << fMVAVar_EleIP3dSig << " "
617	>	//               << fMVAVar_EleGsfTrackChi2OverNdof << " "
618	>	//               << fMVAVar_EledEtaCalo << " "
619	>	//               << fMVAVar_EledPhiCalo << " "
620	>	//               << fMVAVar_EleR9 << " "
621	>	//               << fMVAVar_EleSCEtaWidth << " "
622	>	//               << fMVAVar_EleSCPhiWidth << " "
623	>	//               << fMVAVar_EleCovIEtaIPhi << " "
624	>	//               << fMVAVar_ElePreShowerOverRaw << " "
625	>	//               << fMVAVar_EleChargedIso03OverPt  << " "
626	>	//               << fMVAVar_EleNeutralHadronIso03OverPt  << " "
627	>	//               << fMVAVar_EleGammaIso03OverPt  << " "
628	>	//               << fMVAVar_EleChargedIso04OverPt  << " "
629	>	//               << fMVAVar_EleNeutralHadronIso04OverPt  << " "
630	>	//               << fMVAVar_EleGammaIso04OverPt  << " "
631	>	//               << " === : === "
632	>	//               << mva << " "
633	>	//               << std::endl;
634		std::cout << "Debug Electron MVA: "
635		<< ele->Pt() << " " << ele->Eta() << " " << ele->Phi() << " : "
636		<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << MVABin << " : "
#	Line 468 | Line 657 | Double_t ElectronIDMVA::MVAValue(const E
657		<< fMVAVar_EleSCPhiWidth << " "
658		<< fMVAVar_EleCovIEtaIPhi << " "
659		<< fMVAVar_ElePreShowerOverRaw << " "
660	<	<< fMVAVar_EleChargedIso03OverPt  << " "
661	<	<< fMVAVar_EleNeutralHadronIso03OverPt  << " "
662	<	<< fMVAVar_EleGammaIso03OverPt  << " "
663	<	<< fMVAVar_EleChargedIso04OverPt  << " "
664	<	<< fMVAVar_EleNeutralHadronIso04OverPt  << " "
476	<	<< fMVAVar_EleGammaIso04OverPt  << " "
660	>	<< fMVAVar_EleKFTrkChiSqr  << " "
661	>	<< fMVAVar_EleKFTrkNHits  << " "
662	>	<< fMVAVar_EleE1x5OverE5x5  << " "
663	>	<< " ::: "
664	>
665		<< " === : === "
666		<< mva << " "
667		<< std::endl;
#	Line 484 | Line 672 | Double_t ElectronIDMVA::MVAValue(const E
672		}
673
674		//--------------------------------------------------------------------------------------------------
675	<	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex) {
675	>	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
676	>	Bool_t printDebug) {
677
678		if (!fIsInitialized) {
679		std::cout << "Error: ElectronIDMVA not properly initialized.\n";
#	Line 498 | Line 687 | Double_t ElectronIDMVA::MVAValue(const E
687		Int_t ptBin = 0;
688		if (ele->Pt() > 20.0) ptBin = 1;
689
690	+	fMVAVar_ElePt = ele->Pt();
691	+	fMVAVar_EleEta = ele->Eta();
692	+
693		//set all input variables
694		fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
695		fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
#	Line 516 | Line 708 | Double_t ElectronIDMVA::MVAValue(const E
708		fMVAVar_EleIP3d = ele->Ip3dPV();
709		fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
710
711	+
712	+	fMVAVar_EleEEleClusterOverPout = 0;
713	+	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
714	+	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
715	+	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
716	+	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
717	+	fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
718	+	fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
719	+	fMVAVar_EleE1x5OverE5x5 = ele->SCluster()->Seed()->E1x5() / ele->SCluster()->Seed()->E5x5();
720	+	fMVAVar_EleR9 = ele->SCluster()->R9();
721	+	fMVAVar_EleHoverE = ele->HadronicOverEm();
722	+	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
723	+	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
724	+	fMVAVar_EleR9 = ele->SCluster()->R9();
725	+	fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
726	+
727	+
728		Double_t mva = -9999;
729		TMVA::Reader *reader = 0;
730		Int_t MVABin = -1;
#	Line 530 | Line 739 | Double_t ElectronIDMVA::MVAValue(const E
739
740		mva = reader->EvaluateMVA( fMethodname );
741
742	+	if (printDebug == kTRUE) {
743	+	std::cout << "Debug Electron MVA: "
744	+	<< ele->Pt() << " " << ele->Eta() << " " << ele->Phi() << " : "
745	+	<< ele->Pt() << " " << ele->SCluster()->AbsEta() << " --> MVABin " << MVABin << " : "
746	+	<< fMVAVar_EleSigmaIEtaIEta << " "
747	+	<< fMVAVar_EleDEtaIn << " "
748	+	<< fMVAVar_EleDPhiIn << " "
749	+	<< fMVAVar_EleHoverE << " "
750	+	<< fMVAVar_EleD0 << " "
751	+	<< fMVAVar_EleDZ << " "
752	+	<< fMVAVar_EleFBrem << " "
753	+	<< fMVAVar_EleEOverP << " "
754	+	<< fMVAVar_EleESeedClusterOverPout << " "
755	+	<< fMVAVar_EleSigmaIPhiIPhi << " "
756	+	<< fMVAVar_EleNBrem << " "
757	+	<< fMVAVar_EleOneOverEMinusOneOverP << " "
758	+	<< fMVAVar_EleESeedClusterOverPIn << " "
759	+	<< fMVAVar_EleIP3d << " "
760	+	<< fMVAVar_EleIP3dSig << " "
761	+	<< fMVAVar_EleGsfTrackChi2OverNdof << " "
762	+	<< fMVAVar_EledEtaCalo << " "
763	+	<< fMVAVar_EledPhiCalo << " "
764	+	<< fMVAVar_EleR9 << " "
765	+	<< fMVAVar_EleSCEtaWidth << " "
766	+	<< fMVAVar_EleSCPhiWidth << " "
767	+	<< fMVAVar_EleCovIEtaIPhi << " "
768	+	<< fMVAVar_ElePreShowerOverRaw << " "
769	+	<< fMVAVar_EleKFTrkChiSqr  << " "
770	+	<< fMVAVar_EleKFTrkNHits  << " "
771	+	<< fMVAVar_EleE1x5OverE5x5  << " "
772	+	<< " === : === "
773	+	<< mva << " "
774	+	<< std::endl;
775	+
776	+	}
777	+
778	+
779	+
780	+	return mva;
781	+	}
782	+
783	+
784	+
785	+
786	+	//--------------------------------------------------------------------------------------------------
787	+	//MVA Includes Isolation with removal of other leptons
788	+	//
789	+	Double_t ElectronIDMVA::MVAValue(const Electron *ele, const Vertex *vertex,
790	+	const PFCandidateCol *PFCands,
791	+	const PileupEnergyDensityCol *PileupEnergyDensity,
792	+	ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaTarget,
793	+	const ElectronCol *goodElectrons,
794	+	const MuonCol *goodMuons,
795	+	Bool_t printDebug) {
796	+
797	+	if (!fIsInitialized) {
798	+	std::cout << "Error: ElectronIDMVA not properly initialized.\n";
799	+	return -9999;
800	+	}
801	+
802	+	Double_t Rho = 0;
803	+	if (!(TMath::IsNaN(PileupEnergyDensity->At(0)->Rho()) || isinf(PileupEnergyDensity->At(0)->Rho()))) Rho = PileupEnergyDensity->At(0)->Rho();
804	+
805	+	//set all input variables
806	+	fMVAVar_ElePt = ele->Pt();
807	+	fMVAVar_EleEta = ele->SCluster()->Eta();
808	+	fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
809	+	fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
810	+	fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
811	+	fMVAVar_EleHoverE = ele->HadronicOverEm();
812	+	fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
813	+	fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
814	+	fMVAVar_EleFBrem = ele->FBrem();
815	+	fMVAVar_EleEOverP = ele->ESuperClusterOverP();
816	+	fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
817	+	if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
818	+	else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
819	+	fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
820	+
821	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0
822	+	|| fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0
823	+	|| fMVAType == ElectronIDMVA::kIsoRingsV0) {
824	+	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->P();
825	+	} else {
826	+	fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
827	+	}
828	+
829	+	fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
830	+	fMVAVar_EleIP3d = ele->Ip3dPV();
831	+	fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
832	+	fMVAVar_EleGsfTrackChi2OverNdof = ele->BestTrk()->Chi2() / ele->BestTrk()->Ndof();
833	+	fMVAVar_EledEtaCalo =  ele->DeltaEtaSeedClusterTrackAtCalo();
834	+	fMVAVar_EledPhiCalo = ele->DeltaPhiSeedClusterTrackAtCalo();
835	+	fMVAVar_EleR9 = ele->SCluster()->R9();
836	+	fMVAVar_EleSCEtaWidth = ele->SCluster()->EtaWidth();
837	+	fMVAVar_EleSCPhiWidth = ele->SCluster()->PhiWidth();
838	+	fMVAVar_EleCovIEtaIPhi = ele->SCluster()->Seed()->CoviEtaiPhi();
839	+	fMVAVar_ElePreShowerOverRaw = ele->SCluster()->PreshowerEnergy() / ele->SCluster()->RawEnergy();
840	+
841	+	//Additional vars
842	+	fMVAVar_EleEEleClusterOverPout = 0;
843	+	if (ele->TrackerTrk()) {
844	+	fMVAVar_EleKFTrkChiSqr = ele->TrackerTrk()->RChi2();
845	+	fMVAVar_EleKFTrkNHits = ele->TrackerTrk()->NHits();
846	+	} else {
847	+	fMVAVar_EleKFTrkChiSqr = 0;
848	+	fMVAVar_EleKFTrkNHits = -1;
849	+	}
850	+
851	+	fMVAVar_EleE1x5OverE5x5 = (ele->SCluster()->Seed()->E5x5() > 0.0) ? 1.0-ele->SCluster()->Seed()->E1x5() / ele->SCluster()->Seed()->E5x5() : -1. ;
852	+
853	+	Double_t tmpChargedIso_DR0p0To0p1  = 0;
854	+	Double_t tmpChargedIso_DR0p1To0p2  = 0;
855	+	Double_t tmpChargedIso_DR0p2To0p3  = 0;
856	+	Double_t tmpChargedIso_DR0p3To0p4  = 0;
857	+	Double_t tmpChargedIso_DR0p4To0p5  = 0;
858	+	Double_t tmpGammaIso_DR0p0To0p1  = 0;
859	+	Double_t tmpGammaIso_DR0p1To0p2  = 0;
860	+	Double_t tmpGammaIso_DR0p2To0p3  = 0;
861	+	Double_t tmpGammaIso_DR0p3To0p4  = 0;
862	+	Double_t tmpGammaIso_DR0p4To0p5  = 0;
863	+	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
864	+	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
865	+	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
866	+	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
867	+	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
868	+
869	+	for (UInt_t p=0; p<PFCands->GetEntries();p++) {
870	+	const PFCandidate *pf = PFCands->At(p);
871	+
872	+	//exclude the electron itself
873	+	if(pf->GsfTrk() && ele->GsfTrk() &&
874	+	pf->GsfTrk() == ele->GsfTrk()) continue;
875	+	if(pf->TrackerTrk() && ele->TrackerTrk() &&
876	+	pf->TrackerTrk() == ele->TrackerTrk()) continue;
877	+
878	+	//************************************************************
879	+	// New Isolation Calculations
880	+	//************************************************************
881	+	Double_t dr = MathUtils::DeltaR(ele->Mom(), pf->Mom());
882	+
883	+	if (dr < 1.0) {
884	+	Bool_t IsLeptonFootprint = kFALSE;
885	+	//************************************************************
886	+	// Lepton Footprint Removal
887	+	//************************************************************
888	+	for (UInt_t q=0; q < goodElectrons->GetEntries() ; ++q) {
889	+	//if pf candidate matches an electron passing ID cuts, then veto it
890	+	if(pf->GsfTrk() && goodElectrons->At(q)->GsfTrk() &&
891	+	pf->GsfTrk() == goodElectrons->At(q)->GsfTrk()) IsLeptonFootprint = kTRUE;
892	+	if(pf->TrackerTrk() && goodElectrons->At(q)->TrackerTrk() &&
893	+	pf->TrackerTrk() == goodElectrons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
894	+	//if pf candidate lies in veto regions of electron passing ID cuts, then veto it
895	+	if(pf->BestTrk() && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479
896	+	&& MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.015) IsLeptonFootprint = kTRUE;
897	+	if(pf->PFType() == PFCandidate::eGamma && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479 &&
898	+	MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.08) IsLeptonFootprint = kTRUE;
899	+	}
900	+	for (UInt_t q=0; q < goodMuons->GetEntries() ; ++q) {
901	+	//if pf candidate matches an muon passing ID cuts, then veto it
902	+	if(pf->TrackerTrk() && goodMuons->At(q)->TrackerTrk() &&
903	+	pf->TrackerTrk() == goodMuons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
904	+	//if pf candidate lies in veto regions of muon passing ID cuts, then veto it
905	+	if(pf->BestTrk() && MathUtils::DeltaR(goodMuons->At(q)->Mom(), pf->Mom()) < 0.01) IsLeptonFootprint = kTRUE;
906	+	}
907	+
908	+	if (!IsLeptonFootprint) {
909	+	Bool_t passVeto = kTRUE;
910	+	//Charged
911	+	if(pf->BestTrk()) {
912	+	if (!(fabs(pf->BestTrk()->DzCorrected(*vertex) - ele->BestTrk()->DzCorrected(*vertex)) < 0.2)) passVeto = kFALSE;
913	+	//************************************************************
914	+	// Veto any PFmuon, or PFEle
915	+	if (pf->PFType() == PFCandidate::eElectron || pf->PFType() == PFCandidate::eMuon) passVeto = kFALSE;
916	+	//************************************************************
917	+	//************************************************************
918	+	// Footprint Veto
919	+	if (fabs(ele->SCluster()->Eta()) >= 1.479 && dr < 0.015) passVeto = kFALSE;
920	+	//************************************************************
921	+	if (passVeto) {
922	+	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
923	+	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
924	+	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
925	+	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
926	+	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
927	+	} //pass veto
928	+
929	+	}
930	+	//Gamma
931	+	else if (pf->PFType() == PFCandidate::eGamma) {
932	+	//************************************************************
933	+	// Footprint Veto
934	+	if (fabs(ele->SCluster()->Eta()) >= 1.479) {
935	+	if (dr < 0.08) passVeto = kFALSE;
936	+	}
937	+	//************************************************************
938	+
939	+	if (passVeto) {
940	+	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
941	+	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
942	+	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
943	+	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
944	+	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
945	+	}
946	+	}
947	+	//NeutralHadron
948	+	else {
949	+	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
950	+	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
951	+	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
952	+	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
953	+	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
954	+	}
955	+	} //not lepton footprint
956	+	} //in 1.0 dr cone
957	+	} //loop over PF candidates
958	+
959	+	Double_t fMVAVar_ChargedIso_DR0p0To0p1  = 0;
960	+	Double_t fMVAVar_ChargedIso_DR0p1To0p2  = 0;
961	+	Double_t fMVAVar_ChargedIso_DR0p2To0p3  = 0;
962	+	Double_t fMVAVar_ChargedIso_DR0p3To0p4  = 0;
963	+	Double_t fMVAVar_ChargedIso_DR0p4To0p5  = 0;
964	+	Double_t fMVAVar_GammaIso_DR0p0To0p1  = 0;
965	+	Double_t fMVAVar_GammaIso_DR0p1To0p2  = 0;
966	+	Double_t fMVAVar_GammaIso_DR0p2To0p3  = 0;
967	+	Double_t fMVAVar_GammaIso_DR0p3To0p4  = 0;
968	+	Double_t fMVAVar_GammaIso_DR0p4To0p5  = 0;
969	+	Double_t fMVAVar_NeutralHadronIso_DR0p0To0p1  = 0;
970	+	Double_t fMVAVar_NeutralHadronIso_DR0p1To0p2  = 0;
971	+	Double_t fMVAVar_NeutralHadronIso_DR0p2To0p3  = 0;
972	+	Double_t fMVAVar_NeutralHadronIso_DR0p3To0p4  = 0;
973	+	Double_t fMVAVar_NeutralHadronIso_DR0p4To0p5  = 0;
974	+
975	+	fMVAVar_ChargedIso_DR0p0To0p1   = TMath::Min((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
976	+	fMVAVar_ChargedIso_DR0p1To0p2   = TMath::Min((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
977	+	fMVAVar_ChargedIso_DR0p2To0p3 = TMath::Min((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
978	+	fMVAVar_ChargedIso_DR0p3To0p4 = TMath::Min((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
979	+	fMVAVar_ChargedIso_DR0p4To0p5 = TMath::Min((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
980	+	fMVAVar_GammaIso_DR0p0To0p1 = TMath::Max(TMath::Min((tmpGammaIso_DR0p0To0p1 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p0To0p1, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
981	+	fMVAVar_GammaIso_DR0p1To0p2 = TMath::Max(TMath::Min((tmpGammaIso_DR0p1To0p2 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p1To0p2, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
982	+	fMVAVar_GammaIso_DR0p2To0p3 = TMath::Max(TMath::Min((tmpGammaIso_DR0p2To0p3 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p2To0p3, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
983	+	fMVAVar_GammaIso_DR0p3To0p4 = TMath::Max(TMath::Min((tmpGammaIso_DR0p3To0p4 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p3To0p4, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
984	+	fMVAVar_GammaIso_DR0p4To0p5 = TMath::Max(TMath::Min((tmpGammaIso_DR0p4To0p5 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p4To0p5, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
985	+	fMVAVar_NeutralHadronIso_DR0p0To0p1 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p0To0p1 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p0To0p1, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
986	+	fMVAVar_NeutralHadronIso_DR0p1To0p2 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p1To0p2 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p1To0p2, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
987	+	fMVAVar_NeutralHadronIso_DR0p2To0p3 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p2To0p3 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p2To0p3, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
988	+	fMVAVar_NeutralHadronIso_DR0p3To0p4 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p3To0p4 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p3To0p4, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
989	+	fMVAVar_NeutralHadronIso_DR0p4To0p5 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p4To0p5 - Rho*ElectronTools::ElectronEffectiveArea(ElectronTools::kEleNeutralHadronIsoDR0p4To0p5, ele->SCluster()->Eta(), EffectiveAreaTarget))/ele->Pt(), 2.5), 0.0);
990	+
991	+	//   cout << "gg: " << tmpGammaIso_DR0p4To0p5 << " : " << ElectronTools::ElectronEffectiveArea(ElectronTools::kEleGammaIsoDR0p4To0p5, ele->SCluster()->Eta(), EffectiveAreaTarget) << " " << EffectiveAreaTarget << endl;
992	+
993	+	//Do Binding of MVA input variables
994	+	if (fMVAType == ElectronIDMVA::kIDEGamma2012TrigV0
995	+	|| fMVAType == ElectronIDMVA::kIDEGamma2012NonTrigV0
996	+	|| fMVAType == ElectronIDMVA::kIsoRingsV0) {
997	+	bindVariables();
998	+	}
999	+
1000	+	Double_t mva = -9999;
1001	+	TMVA::Reader *reader = 0;
1002	+	Int_t MVABin = -1;
1003	+
1004	+	if (fMVAVar_ElePt < 10 && fabs(fMVAVar_EleEta) < 1.479) MVABin = 0;
1005	+	if (fMVAVar_ElePt < 10 && fabs(fMVAVar_EleEta) >= 1.479) MVABin = 1;
1006	+	if (fMVAVar_ElePt > 10 && fabs(fMVAVar_EleEta) < 1.479) MVABin = 2;
1007	+	if (fMVAVar_ElePt > 10 && fabs(fMVAVar_EleEta) >= 1.479) MVABin = 3;
1008	+
1009	+	std::cout <<" -> BIN: " << fMVAVar_EleEta << " " << fMVAVar_ElePt << " : " << MVABin << std::endl;
1010	+
1011	+	if (!fUseBinnedVersion) {
1012	+	reader = fTMVAReader[0];
1013	+	} else {
1014	+	reader = fTMVAReader[MVABin];
1015	+	}
1016	+
1017	+
1018	+	mva = reader->EvaluateMVA( fMethodname );
1019	+
1020	+	if (printDebug == kTRUE) {
1021	+
1022	+	std::cout << "Debug Electron MVA: \n";
1023	+	std::cout << " fbrem " <<  fMVAVar_EleFBrem
1024	+	<< " kfchi2 " << fMVAVar_EleKFTrkChiSqr
1025	+	<< " kfhits " << fMVAVar_EleKFTrkNHits
1026	+	<< " kfhitsall " << fMVAVar_EleKFTrkNHits
1027	+	<< " gsfchi2 " << fMVAVar_EleGsfTrackChi2OverNdof
1028	+	<< " deta " <<  fMVAVar_EleDEtaIn
1029	+	<< " dphi " << fMVAVar_EleDPhiIn
1030	+	<< " detacalo " << fMVAVar_EledEtaCalo
1031	+	<< " see " << fMVAVar_EleSigmaIEtaIEta
1032	+	<< " spp " << fMVAVar_EleSigmaIPhiIPhi
1033	+	<< " etawidth " << fMVAVar_EleSCEtaWidth
1034	+	<< " phiwidth " << fMVAVar_EleSCPhiWidth
1035	+	<< " e1x5e5x5 " << fMVAVar_EleE1x5OverE5x5
1036	+	<< " R9 " << fMVAVar_EleR9
1037	+	<< " HoE " << fMVAVar_EleHoverE
1038	+	<< " EoP " << fMVAVar_EleEOverP
1039	+	<< " IoEmIoP " << fMVAVar_EleOneOverEMinusOneOverP
1040	+	<< " eleEoPout " << fMVAVar_EleESeedClusterOverPout
1041	+	<< " EoPout " << fMVAVar_EleESeedClusterOverPout
1042	+	<< " d0 " << fMVAVar_EleD0
1043	+	<< " ip3d " << fMVAVar_EleIP3d
1044	+	<< " eta " << fMVAVar_EleEta
1045	+	<< " pt " << fMVAVar_ElePt << std::endl;
1046	+
1047	+	std::cout << fMVAVar_ChargedIso_DR0p0To0p1 << " "
1048	+	<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
1049	+	<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
1050	+	<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
1051	+	<< fMVAVar_ChargedIso_DR0p4To0p5 << " "
1052	+	<< fMVAVar_GammaIso_DR0p0To0p1 << " "
1053	+	<< fMVAVar_GammaIso_DR0p1To0p2 << " "
1054	+	<< fMVAVar_GammaIso_DR0p2To0p3 << " "
1055	+	<< fMVAVar_GammaIso_DR0p3To0p4 << " "
1056	+	<< fMVAVar_GammaIso_DR0p4To0p5 << " "
1057	+	<< fMVAVar_NeutralHadronIso_DR0p0To0p1 << " "
1058	+	<< fMVAVar_NeutralHadronIso_DR0p1To0p2 << " "
1059	+	<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " "
1060	+	<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
1061	+	<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " "
1062	+	<< std::endl;
1063	+	std::cout << "MVA: " << mva << " "
1064	+	<< std::endl;
1065	+	}
1066	+
1067		return mva;
1068		}
1069	+
1070	+
1071	+	void ElectronIDMVA::bindVariables() {
1072	+
1073	+	// this binding is needed for variables that sometime diverge.
1074	+
1075	+	if(fMVAVar_EleFBrem < -1.)
1076	+	fMVAVar_EleFBrem = -1.;
1077	+
1078	+	fMVAVar_EleDEtaIn = fabs(fMVAVar_EleDEtaIn);
1079	+	if(fMVAVar_EleDEtaIn > 0.06)
1080	+	fMVAVar_EleDEtaIn = 0.06;
1081	+
1082	+
1083	+	fMVAVar_EleDPhiIn = fabs(fMVAVar_EleDPhiIn);
1084	+	if(fMVAVar_EleDPhiIn > 0.6)
1085	+	fMVAVar_EleDPhiIn = 0.6;
1086	+
1087	+
1088	+	if(fMVAVar_EleESeedClusterOverPout > 20.)
1089	+	fMVAVar_EleESeedClusterOverPout = 20.;
1090	+
1091	+	if(fMVAVar_EleEOverP > 20.)
1092	+	fMVAVar_EleEOverP = 20.;
1093	+
1094	+	if(fMVAVar_EleEEleClusterOverPout > 20.)
1095	+	fMVAVar_EleEEleClusterOverPout = 20.;
1096	+
1097	+
1098	+	fMVAVar_EledEtaCalo = fabs(fMVAVar_EledEtaCalo);
1099	+	if(fMVAVar_EledEtaCalo > 0.2)
1100	+	fMVAVar_EledEtaCalo = 0.2;
1101	+
1102	+
1103	+	if(fMVAVar_EleE1x5OverE5x5 < -1.)
1104	+	fMVAVar_EleE1x5OverE5x5 = -1;
1105	+
1106	+	if(fMVAVar_EleE1x5OverE5x5 > 2.)
1107	+	fMVAVar_EleE1x5OverE5x5 = 2.;
1108	+
1109	+
1110	+
1111	+	if(fMVAVar_EleR9 > 5)
1112	+	fMVAVar_EleR9 = 5;
1113	+
1114	+	if(fMVAVar_EleGsfTrackChi2OverNdof > 200.)
1115	+	fMVAVar_EleGsfTrackChi2OverNdof = 200;
1116	+
1117	+
1118	+	if(fMVAVar_EleKFTrkChiSqr > 10.)
1119	+	fMVAVar_EleKFTrkChiSqr = 10.;
1120	+
1121	+	// Needed for a bug in CMSSW_420, fixed in more recent CMSSW versions
1122	+	if(std::isnan(fMVAVar_EleSigmaIPhiIPhi))
1123	+	fMVAVar_EleSigmaIPhiIPhi = 0.;
1124	+
1125	+
1126	+	return;
1127	+	}

Diff Legend

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