ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

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

Comparing UserCode/MitPhysics/Utils/src/MuonIDMVA.cc (file contents):
Revision 1.1 by sixie, Fri Dec 16 12:58:13 2011 UTC vs.
Revision 1.8 by sixie, Mon Apr 16 11:08:47 2012 UTC

#	Line 15 | Line 15 | using namespace mithep;
15		//--------------------------------------------------------------------------------------------------
16		MuonIDMVA::MuonIDMVA() :
17		fMethodname("BDTG method"),
18	<	fIsInitialized(kFALSE)
18	>	fIsInitialized(kFALSE),
19	>	fMVAType(MuonIDMVA::kUninitialized),
20	>	fUseBinnedVersion(kTRUE),
21	>	fNMVABins(0)
22		{
20	–	// Constructor.
21	–	for(UInt_t i=0; i<6; ++i) {
22	–	fTMVAReader[i] = 0;
23	–	}
23		}
24
25
26		//--------------------------------------------------------------------------------------------------
27		MuonIDMVA::~MuonIDMVA()
28		{
29	<	for(UInt_t i=0; i<6; ++i) {
29	>	for(UInt_t i=0; i<fTMVAReader.size(); ++i) {
30		if (fTMVAReader[i]) delete fTMVAReader[i];
31		}
32		}
33
34		//--------------------------------------------------------------------------------------------------
35	+	void MuonIDMVA::Initialize( std::string methodName,
36	+	std::string weightsfile,
37	+	MuonIDMVA::MVAType type)
38	+	{
39	+
40	+	std::vector<std::string> tempWeightFileVector;
41	+	tempWeightFileVector.push_back(weightsfile);
42	+	Initialize(methodName,type,kFALSE,tempWeightFileVector);
43	+	}
44	+
45	+	//--------------------------------------------------------------------------------------------------
46		void MuonIDMVA::Initialize( TString methodName,
47	<	TString Subdet0Pt10To14p5Weights ,
48	<	TString Subdet1Pt10To14p5Weights ,
49	<	TString Subdet0Pt14p5To20Weights,
50	<	TString Subdet1Pt14p5To20Weights,
51	<	TString Subdet0Pt20ToInfWeights,
52	<	TString Subdet1Pt20ToInfWeights,
53	<	MuonIDMVA::MVAType type) {
47	>	TString Subdet0Pt10To20Weights ,
48	>	TString Subdet1Pt10To20Weights ,
49	>	TString Subdet2Pt10To20Weights,
50	>	TString Subdet0Pt20ToInfWeights,
51	>	TString Subdet1Pt20ToInfWeights,
52	>	TString Subdet2Pt20ToInfWeights,
53	>	MuonIDMVA::MVAType type) {
54	>
55	>	std::vector<std::string> tempWeightFileVector;
56	>	tempWeightFileVector.push_back(std::string(Subdet0Pt10To20Weights.Data()));
57	>	tempWeightFileVector.push_back(std::string(Subdet1Pt10To20Weights.Data()));
58	>	tempWeightFileVector.push_back(std::string(Subdet2Pt10To20Weights.Data()));
59	>	tempWeightFileVector.push_back(std::string(Subdet0Pt20ToInfWeights.Data()));
60	>	tempWeightFileVector.push_back(std::string(Subdet1Pt20ToInfWeights.Data()));
61	>	tempWeightFileVector.push_back(std::string(Subdet2Pt20ToInfWeights.Data()));
62	>	Initialize(std::string(methodName.Data()),type,kTRUE,tempWeightFileVector);
63	>
64	>	}
65	>
66	>
67	>	//--------------------------------------------------------------------------------------------------
68	>	void MuonIDMVA::Initialize(  std::string methodName,
69	>	MuonIDMVA::MVAType type,
70	>	Bool_t useBinnedVersion,
71	>	std::vector<std::string> weightsfiles) {
72
73	+	//clean up first
74	+	for (uint i=0;i<fTMVAReader.size(); ++i) {
75	+	if (fTMVAReader[i]) delete fTMVAReader[i];
76	+	}
77	+	fTMVAReader.clear();
78	+
79	+
80	+	//initialize
81		fIsInitialized = kTRUE;
46	–
82		fMethodname = methodName;
83	<
84	<	for(UInt_t i=0; i<6; ++i) {
50	<	if (fTMVAReader[i]) delete fTMVAReader[i];
83	>	fMVAType = type;
84	>	fUseBinnedVersion = useBinnedVersion;
85
86	<	fTMVAReader[i] = new TMVA::Reader( "!Color:!Silent:Error" );
87	<	fTMVAReader[i]->SetVerbose(kTRUE);
86	>	//Define expected number of bins
87	>	UInt_t ExpectedNBins = 0;
88	>	if (!fUseBinnedVersion) {
89	>	ExpectedNBins = 1;
90	>	} else if (type == kV2
91	>	||type == kV3
92	>	||type == kV8
93	>	||type == kIDIsoCombinedDetIso) {
94	>	ExpectedNBins = 6;
95	>	} else if (type == kIDIsoCombinedIsoRingsV0) {
96	>	ExpectedNBins = 5;
97	>	} else if (type == kIsoRingsV0) {
98	>	ExpectedNBins = 4;
99	>	}
100	>	fNMVABins = ExpectedNBins;
101	>
102	>	//Check number of weight files given
103	>	if (fNMVABins != weightsfiles.size() ) {
104	>	std::cout << "Error: Expected Number of bins = " << fNMVABins << " does not equal to weightsfiles.size() = "
105	>	<< weightsfiles.size() << std::endl;
106	>	assert(fNMVABins == weightsfiles.size());
107	>	}
108	>
109	>	for(UInt_t i=0; i<fNMVABins; ++i) {
110	>	TMVA::Reader *tmpTMVAReader = new TMVA::Reader( "!Color:!Silent:Error" );
111	>	tmpTMVAReader->SetVerbose(kTRUE);
112	>
113	>	if (type == kV2) {
114	>	tmpTMVAReader->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
115	>	tmpTMVAReader->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
116	>	tmpTMVAReader->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
117	>	tmpTMVAReader->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
118	>	tmpTMVAReader->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
119	>	tmpTMVAReader->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
120	>	tmpTMVAReader->AddVariable( "D0",                   &fMVAVar_MuD0                    );
121	>	tmpTMVAReader->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );
122	>	tmpTMVAReader->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );
123	>	tmpTMVAReader->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
124	>	tmpTMVAReader->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
125	>	}
126
127		if (type == kV3) {
128	<	fTMVAReader[i]->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
129	<	fTMVAReader[i]->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
130	<	fTMVAReader[i]->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
131	<	fTMVAReader[i]->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
132	<	fTMVAReader[i]->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
133	<	fTMVAReader[i]->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
134	<	fTMVAReader[i]->AddVariable( "D0",                   &fMVAVar_MuD0                    );
135	<	fTMVAReader[i]->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );
136	<	fTMVAReader[i]->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );
137	<	fTMVAReader[i]->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
138	<	fTMVAReader[i]->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
139	<	fTMVAReader[i]->AddVariable( "CaloCompatibility",    &fMVAVar_MuCaloCompatibility     );
140	<	fTMVAReader[i]->AddVariable( "HadEnergyOverPt",      &fMVAVar_MuHadEnergyOverPt       );
128	>	tmpTMVAReader->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
129	>	tmpTMVAReader->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
130	>	tmpTMVAReader->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
131	>	tmpTMVAReader->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
132	>	tmpTMVAReader->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
133	>	tmpTMVAReader->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
134	>	tmpTMVAReader->AddVariable( "D0",                   &fMVAVar_MuD0                    );
135	>	tmpTMVAReader->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );
136	>	tmpTMVAReader->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );
137	>	tmpTMVAReader->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
138	>	tmpTMVAReader->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
139	>	tmpTMVAReader->AddVariable( "CaloCompatibility",    &fMVAVar_MuCaloCompatibility     );
140	>	tmpTMVAReader->AddVariable( "HadEnergyOverPt",      &fMVAVar_MuHadEnergyOverPt       );
141		if (i==0 || i==2 || i==4) {
142	<	fTMVAReader[i]->AddVariable( "HoEnergyOverPt",     &fMVAVar_MuHoEnergyOverPt        );
142	>	tmpTMVAReader->AddVariable( "HoEnergyOverPt",     &fMVAVar_MuHoEnergyOverPt        );
143		}
144	<	fTMVAReader[i]->AddVariable( "EmEnergyOverPt",       &fMVAVar_MuEmEnergyOverPt        );
145	<	fTMVAReader[i]->AddVariable( "HadS9EnergyOverPt",    &fMVAVar_MuHadS9EnergyOverPt     );
144	>	tmpTMVAReader->AddVariable( "EmEnergyOverPt",       &fMVAVar_MuEmEnergyOverPt        );
145	>	tmpTMVAReader->AddVariable( "HadS9EnergyOverPt",    &fMVAVar_MuHadS9EnergyOverPt     );
146		if (i==0 || i==2 || i==4) {
147	<	fTMVAReader[i]->AddVariable( "HoS9EnergyOverPt",   &fMVAVar_MuHoS9EnergyOverPt      );
147	>	tmpTMVAReader->AddVariable( "HoS9EnergyOverPt",   &fMVAVar_MuHoS9EnergyOverPt      );
148		}
149	<	fTMVAReader[i]->AddVariable( "EmS9EnergyOverPt",     &fMVAVar_MuEmS9EnergyOverPt      );
149	>	tmpTMVAReader->AddVariable( "EmS9EnergyOverPt",     &fMVAVar_MuEmS9EnergyOverPt      );
150	>	}
151	>
152	>	if (type == kV8) {
153	>	tmpTMVAReader->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
154	>	tmpTMVAReader->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
155	>	tmpTMVAReader->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
156	>	tmpTMVAReader->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
157	>	tmpTMVAReader->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
158	>	tmpTMVAReader->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
159	>	tmpTMVAReader->AddVariable( "D0",                   &fMVAVar_MuD0                    );
160	>	tmpTMVAReader->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );
161	>	tmpTMVAReader->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );
162	>	tmpTMVAReader->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
163	>	tmpTMVAReader->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
164	>	tmpTMVAReader->AddVariable( "CaloCompatibility",    &fMVAVar_MuCaloCompatibility     );
165	>	tmpTMVAReader->AddVariable( "HadEnergyOverPt",      &fMVAVar_MuHadEnergyOverPt       );
166	>	tmpTMVAReader->AddVariable( "EmEnergyOverPt",       &fMVAVar_MuEmEnergyOverPt        );
167	>	tmpTMVAReader->AddVariable( "HadS9EnergyOverPt",    &fMVAVar_MuHadS9EnergyOverPt     );
168	>	tmpTMVAReader->AddVariable( "EmS9EnergyOverPt",     &fMVAVar_MuEmS9EnergyOverPt      );
169	>	tmpTMVAReader->AddVariable( "ChargedIso03OverPt",   &fMVAVar_MuChargedIso03OverPt    );
170	>	tmpTMVAReader->AddVariable( "NeutralIso03OverPt",   &fMVAVar_MuNeutralIso03OverPt    );
171	>	tmpTMVAReader->AddVariable( "ChargedIso04OverPt",   &fMVAVar_MuChargedIso04OverPt    );
172	>	tmpTMVAReader->AddVariable( "NeutralIso04OverPt",   &fMVAVar_MuNeutralIso04OverPt    );
173		}
174
175	<	if (i==0) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt10To14p5Weights );
176	<	if (i==1) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt10To14p5Weights );
177	<	if (i==2) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt14p5To20Weights );
178	<	if (i==3) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt14p5To20Weights );
179	<	if (i==4) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt20ToInfWeights  );
180	<	if (i==5) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt20ToInfWeights  );
175	>	if (type == kIDIsoCombinedDetIso) {
176	>	tmpTMVAReader->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
177	>	tmpTMVAReader->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
178	>	tmpTMVAReader->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
179	>	tmpTMVAReader->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
180	>	tmpTMVAReader->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
181	>	tmpTMVAReader->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
182	>	tmpTMVAReader->AddVariable( "D0",                   &fMVAVar_MuD0                    );
183	>	tmpTMVAReader->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );
184	>	tmpTMVAReader->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );
185	>	tmpTMVAReader->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
186	>	tmpTMVAReader->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
187	>	tmpTMVAReader->AddVariable( "CaloCompatibility",    &fMVAVar_MuCaloCompatibility     );
188	>	tmpTMVAReader->AddVariable( "HadEnergyOverPt",      &fMVAVar_MuHadEnergyOverPt       );
189	>	tmpTMVAReader->AddVariable( "EmEnergyOverPt",       &fMVAVar_MuEmEnergyOverPt        );
190	>	tmpTMVAReader->AddVariable( "HadS9EnergyOverPt",    &fMVAVar_MuHadS9EnergyOverPt     );
191	>	tmpTMVAReader->AddVariable( "EmS9EnergyOverPt",     &fMVAVar_MuEmS9EnergyOverPt      );
192	>	tmpTMVAReader->AddVariable( "TrkIso03OverPt",       &fMVAVar_MuTrkIso03OverPt        );
193	>	tmpTMVAReader->AddVariable( "EMIso03OverPt",        &fMVAVar_MuEMIso03OverPt         );
194	>	tmpTMVAReader->AddVariable( "HadIso03OverPt",       &fMVAVar_MuHadIso03OverPt        );
195	>	tmpTMVAReader->AddVariable( "TrkIso05OverPt",       &fMVAVar_MuTrkIso05OverPt        );
196	>	tmpTMVAReader->AddVariable( "EMIso05OverPt",        &fMVAVar_MuEMIso05OverPt         );
197	>	tmpTMVAReader->AddVariable( "HadIso05OverPt",       &fMVAVar_MuHadIso05OverPt        );
198	>	}
199	>
200	>	if (type == kIsoRingsV0) {
201	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p0To0p1",         &fMVAVar_ChargedIso_DR0p0To0p1        );
202	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p1To0p2",         &fMVAVar_ChargedIso_DR0p1To0p2        );
203	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p2To0p3",         &fMVAVar_ChargedIso_DR0p2To0p3        );
204	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p3To0p4",         &fMVAVar_ChargedIso_DR0p3To0p4        );
205	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p4To0p5",         &fMVAVar_ChargedIso_DR0p4To0p5        );
206	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p0To0p1",           &fMVAVar_GammaIso_DR0p0To0p1          );
207	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p1To0p2",           &fMVAVar_GammaIso_DR0p1To0p2          );
208	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p2To0p3",           &fMVAVar_GammaIso_DR0p2To0p3          );
209	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p3To0p4",           &fMVAVar_GammaIso_DR0p3To0p4          );
210	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p4To0p5",           &fMVAVar_GammaIso_DR0p4To0p5          );
211	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p0To0p1",   &fMVAVar_NeutralHadronIso_DR0p0To0p1  );
212	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p1To0p2",   &fMVAVar_NeutralHadronIso_DR0p1To0p2  );
213	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p2To0p3",   &fMVAVar_NeutralHadronIso_DR0p2To0p3  );
214	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p3To0p4",   &fMVAVar_NeutralHadronIso_DR0p3To0p4  );
215	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p4To0p5",   &fMVAVar_NeutralHadronIso_DR0p4To0p5  );
216	>	tmpTMVAReader->AddSpectator("eta",            &fMVAVar_MuEta);
217	>	tmpTMVAReader->AddSpectator("pt",             &fMVAVar_MuPt);
218	>	}
219	>
220	>	tmpTMVAReader->BookMVA(fMethodname , weightsfiles[i] );
221	>	std::cout << "MVABin " << i << " : MethodName = " << fMethodname
222	>	<< " , type == " << type << " , "
223	>	<< "Load weights file : " << weightsfiles[i]
224	>	<< std::endl;
225	>	fTMVAReader.push_back(tmpTMVAReader);
226
227		}
228	+	std::cout << "Muon ID MVA Completed\n";
229	+	}
230
231	<	std::cout << "Muon ID MVA Initialization\n";
232	<	std::cout << "MethodName : " << fMethodname << " , type == " << type << std::endl;
233	<	std::cout << "Load weights file : " << Subdet0Pt10To14p5Weights << std::endl;
234	<	std::cout << "Load weights file : " << Subdet1Pt10To14p5Weights << std::endl;
235	<	std::cout << "Load weights file : " << Subdet0Pt14p5To20Weights << std::endl;
236	<	std::cout << "Load weights file : " << Subdet1Pt14p5To20Weights << std::endl;
95	<	std::cout << "Load weights file : " << Subdet0Pt20ToInfWeights << std::endl;
96	<	std::cout << "Load weights file : " << Subdet1Pt20ToInfWeights << std::endl;
231	>	//--------------------------------------------------------------------------------------------------
232	>	UInt_t MuonIDMVA::GetMVABin( double eta, double pt,
233	>	Bool_t isGlobal, Bool_t isTrackerMuon) const {
234	>
235	>	//Default is to return the first bin
236	>	uint bin = 0;
237
238	+	//return the first bin if not using binned version
239	+	if (!fUseBinnedVersion) return 0;
240	+
241	+	if (fMVAType == MuonIDMVA::kV2
242	+	|| fMVAType == MuonIDMVA::kV3
243	+	|| fMVAType == MuonIDMVA::kV8
244	+	|| fMVAType == MuonIDMVA::kIDIsoCombinedDetIso) {
245	+	if (pt < 14.5 && fabs(eta) < 1.5) bin = 0;
246	+	if (pt < 14.5 && fabs(eta) >= 1.5) bin = 1;
247	+	if (pt >= 14.5 && pt < 20 && fabs(eta) < 1.5) bin = 2;
248	+	if (pt >= 14.5 && pt < 20 && fabs(eta) >= 1.5) bin = 3;
249	+	if (pt >= 20 && fabs(eta) < 1.5) bin = 4;
250	+	if (pt >= 20 && fabs(eta) >= 1.5) bin = 5;
251	+	}
252	+
253	+	if (fMVAType == MuonIDMVA::kIDIsoCombinedIsoRingsV0) {
254	+	if (isGlobal && isTrackerMuon) {
255	+	if (pt < 10 && fabs(eta) < 1.479) bin = 0;
256	+	if (pt < 10 && fabs(eta) >= 1.479) bin = 1;
257	+	if (pt >= 10 && fabs(eta) < 1.479) bin = 2;
258	+	if (pt >= 10 && fabs(eta) >= 1.479) bin = 3;
259	+	} else if (!isGlobal && isTrackerMuon) {
260	+	bin = 4;
261	+	} else {
262	+	std::cout << "Warning: Muon is not a tracker muon. Such muons are not supported. \n";
263	+	bin = 0;
264	+	}
265	+	}
266	+
267	+	if (fMVAType == MuonIDMVA::kIsoRingsV0) {
268	+	if (pt < 10 && fabs(eta) < 1.479) bin = 0;
269	+	if (pt < 10 && fabs(eta) >= 1.479) bin = 1;
270	+	if (pt >= 10 && fabs(eta) < 1.479) bin = 2;
271	+	if (pt >= 10 && fabs(eta) >= 1.479) bin = 3;
272	+	}
273	+
274	+	return bin;
275		}
276
277		//--------------------------------------------------------------------------------------------------
278		Double_t MuonIDMVA::MVAValue(Double_t MuPt , Double_t MuEta,
279	<	Double_t                   MuTkNchi2,
280	<	Double_t                   MuGlobalNchi2,
281	<	Double_t                   MuNValidHits,
282	<	Double_t                   MuNTrackerHits,
283	<	Double_t                   MuNPixelHits,
284	<	Double_t                   MuNMatches,
285	<	Double_t                   MuD0,
286	<	Double_t                   MuIP3d,
287	<	Double_t                   MuIP3dSig,
288	<	Double_t                   MuTrkKink,
289	<	Double_t                   MuSegmentCompatibility,
290	<	Double_t                   MuCaloCompatibility,
291	<	Double_t                   MuHadEnergyOverPt,
292	<	Double_t                   MuHoEnergyOverPt,
293	<	Double_t                   MuEmEnergyOverPt,
294	<	Double_t                   MuHadS9EnergyOverPt,
295	<	Double_t                   MuHoS9EnergyOverPt,
296	<	Double_t                   MuEmS9EnergyOverPt
279	>	Double_t                   MuTkNchi2,
280	>	Double_t                   MuGlobalNchi2,
281	>	Double_t                   MuNValidHits,
282	>	Double_t                   MuNTrackerHits,
283	>	Double_t                   MuNPixelHits,
284	>	Double_t                   MuNMatches,
285	>	Double_t                   MuD0,
286	>	Double_t                   MuIP3d,
287	>	Double_t                   MuIP3dSig,
288	>	Double_t                   MuTrkKink,
289	>	Double_t                   MuSegmentCompatibility,
290	>	Double_t                   MuCaloCompatibility,
291	>	Double_t                   MuHadEnergyOverPt,
292	>	Double_t                   MuHoEnergyOverPt,
293	>	Double_t                   MuEmEnergyOverPt,
294	>	Double_t                   MuHadS9EnergyOverPt,
295	>	Double_t                   MuHoS9EnergyOverPt,
296	>	Double_t                   MuEmS9EnergyOverPt,
297	>	Double_t                   MuChargedIso03OverPt,
298	>	Double_t                   MuNeutralIso03OverPt,
299	>	Double_t                   MuChargedIso04OverPt,
300	>	Double_t                   MuNeutralIso04OverPt,
301	>	Bool_t                     printDebug
302		) {
303
304		if (!fIsInitialized) {
#	Line 124 | Line 306 | Double_t MuonIDMVA::MVAValue(Double_t Mu
306		return -9999;
307		}
308
127	–	Int_t subdet = 0;
128	–	if (fabs(MuEta) < 1.479) subdet = 0;
129	–	else subdet = 1;
130	–	Int_t ptBin = 0;
131	–	if (MuPt > 14.5) ptBin = 1;
132	–	if (MuPt > 20.0) ptBin = 2;
133	–
309
310		//set all input variables
311		fMVAVar_MuTkNchi2              = MuTkNchi2;
#	Line 151 | Line 326 | Double_t MuonIDMVA::MVAValue(Double_t Mu
326		fMVAVar_MuHadS9EnergyOverPt    = MuHadS9EnergyOverPt;
327		fMVAVar_MuHoS9EnergyOverPt     = MuHoS9EnergyOverPt;
328		fMVAVar_MuEmS9EnergyOverPt     = MuEmS9EnergyOverPt;
329	<
329	>	fMVAVar_MuChargedIso03OverPt   = MuChargedIso03OverPt;
330	>	fMVAVar_MuNeutralIso03OverPt   = MuNeutralIso03OverPt;
331	>	fMVAVar_MuChargedIso04OverPt   = MuChargedIso04OverPt;
332	>	fMVAVar_MuNeutralIso04OverPt   = MuNeutralIso04OverPt;
333
334		Double_t mva = -9999;
335		TMVA::Reader *reader = 0;
336	+	reader = fTMVAReader[GetMVABin(MuEta, MuPt, kTRUE, kTRUE )];
337	+
338	+	mva = reader->EvaluateMVA( fMethodname );
339	+
340	+	if (printDebug) {
341	+	std::cout << "Debug Muon MVA: "
342	+	<< MuPt << " " << MuEta << " --> MVABin " << GetMVABin(MuEta, MuPt, kTRUE, kTRUE ) << " : "
343	+	<< fMVAVar_MuTkNchi2              << " "
344	+	<< fMVAVar_MuGlobalNchi2          << " "
345	+	<< fMVAVar_MuNValidHits           << " "
346	+	<< fMVAVar_MuNTrackerHits         << " "
347	+	<< fMVAVar_MuNPixelHits           << " "
348	+	<< fMVAVar_MuNMatches             << " "
349	+	<< fMVAVar_MuD0                   << " "
350	+	<< fMVAVar_MuIP3d                 << " "
351	+	<< fMVAVar_MuIP3dSig              << " "
352	+	<< fMVAVar_MuTrkKink              << " "
353	+	<< fMVAVar_MuSegmentCompatibility << " "
354	+	<< fMVAVar_MuCaloCompatibility    << " "
355	+	<< fMVAVar_MuHadEnergyOverPt      << " "
356	+	<< fMVAVar_MuHoEnergyOverPt       << " "
357	+	<< fMVAVar_MuEmEnergyOverPt       << " "
358	+	<< fMVAVar_MuHadS9EnergyOverPt    << " "
359	+	<< fMVAVar_MuHoS9EnergyOverPt     << " "
360	+	<< fMVAVar_MuEmS9EnergyOverPt     << " "
361	+	<< fMVAVar_MuChargedIso03OverPt   << " "
362	+	<< fMVAVar_MuNeutralIso03OverPt   << " "
363	+	<< fMVAVar_MuChargedIso04OverPt   << " "
364	+	<< fMVAVar_MuNeutralIso04OverPt   << " "
365	+	<< " === : === "
366	+	<< mva
367	+	<< std::endl;
368	+	}
369	+
370	+	return mva;
371	+	}
372
373	<	Int_t MVABin = -1;
374	<	if (subdet == 0 && ptBin == 0) MVABin = 0;
375	<	if (subdet == 1 && ptBin == 0) MVABin = 1;
376	<	if (subdet == 0 && ptBin == 1) MVABin = 2;
377	<	if (subdet == 1 && ptBin == 1) MVABin = 3;
378	<	if (subdet == 0 && ptBin == 2) MVABin = 4;
379	<	if (subdet == 1 && ptBin == 2) MVABin = 5;
380	<	assert(MVABin >= 0 && MVABin <= 5);
381	<	reader = fTMVAReader[MVABin];
373	>
374	>	//--------------------------------------------------------------------------------------------------
375	>	Double_t MuonIDMVA::MVAValue(Double_t MuPt , Double_t MuEta,
376	>	Double_t                   MuTkNchi2,
377	>	Double_t                   MuGlobalNchi2,
378	>	Double_t                   MuNValidHits,
379	>	Double_t                   MuNTrackerHits,
380	>	Double_t                   MuNPixelHits,
381	>	Double_t                   MuNMatches,
382	>	Double_t                   MuD0,
383	>	Double_t                   MuIP3d,
384	>	Double_t                   MuIP3dSig,
385	>	Double_t                   MuTrkKink,
386	>	Double_t                   MuSegmentCompatibility,
387	>	Double_t                   MuCaloCompatibility,
388	>	Double_t                   MuHadEnergyOverPt,
389	>	Double_t                   MuHoEnergyOverPt,
390	>	Double_t                   MuEmEnergyOverPt,
391	>	Double_t                   MuHadS9EnergyOverPt,
392	>	Double_t                   MuHoS9EnergyOverPt,
393	>	Double_t                   MuEmS9EnergyOverPt,
394	>	Double_t                   MuTrkIso03OverPt,
395	>	Double_t                   MuEMIso03OverPt,
396	>	Double_t                   MuHadIso03OverPt,
397	>	Double_t                   MuTrkIso05OverPt,
398	>	Double_t                   MuEMIso05OverPt,
399	>	Double_t                   MuHadIso05OverPt,
400	>	Bool_t                     printDebug
401	>	) {
402	>
403	>	if (!fIsInitialized) {
404	>	std::cout << "Error: MuonIDMVA not properly initialized.\n";
405	>	return -9999;
406	>	}
407	>
408	>	//set all input variables
409	>	fMVAVar_MuTkNchi2              = MuTkNchi2;
410	>	fMVAVar_MuGlobalNchi2          = MuGlobalNchi2;
411	>	fMVAVar_MuNValidHits           = MuNValidHits;
412	>	fMVAVar_MuNTrackerHits         = MuNTrackerHits;
413	>	fMVAVar_MuNPixelHits           = MuNPixelHits;
414	>	fMVAVar_MuNMatches             = MuNMatches;
415	>	fMVAVar_MuD0                   = MuD0;
416	>	fMVAVar_MuIP3d                 = MuIP3d;
417	>	fMVAVar_MuIP3dSig              = MuIP3dSig;
418	>	fMVAVar_MuTrkKink              = MuTrkKink;
419	>	fMVAVar_MuSegmentCompatibility = MuSegmentCompatibility;
420	>	fMVAVar_MuCaloCompatibility    = MuCaloCompatibility;
421	>	fMVAVar_MuHadEnergyOverPt      = MuHadEnergyOverPt;
422	>	fMVAVar_MuHoEnergyOverPt       = MuHoEnergyOverPt;
423	>	fMVAVar_MuEmEnergyOverPt       = MuEmEnergyOverPt;
424	>	fMVAVar_MuHadS9EnergyOverPt    = MuHadS9EnergyOverPt;
425	>	fMVAVar_MuHoS9EnergyOverPt     = MuHoS9EnergyOverPt;
426	>	fMVAVar_MuEmS9EnergyOverPt     = MuEmS9EnergyOverPt;
427	>	fMVAVar_MuTrkIso03OverPt       = MuTrkIso03OverPt;
428	>	fMVAVar_MuEMIso03OverPt        = MuEMIso03OverPt;
429	>	fMVAVar_MuHadIso03OverPt       = MuHadIso03OverPt;
430	>	fMVAVar_MuTrkIso05OverPt       = MuTrkIso05OverPt;
431	>	fMVAVar_MuEMIso05OverPt        = MuEMIso05OverPt;
432	>	fMVAVar_MuHadIso05OverPt       = MuHadIso05OverPt;
433	>
434	>	Double_t mva = -9999;
435	>	TMVA::Reader *reader = 0;
436	>	reader = fTMVAReader[GetMVABin(MuEta, MuPt, kTRUE, kTRUE )];
437
438		mva = reader->EvaluateMVA( fMethodname );
439
440	+	if (printDebug) {
441	+	std::cout << "Debug Muon MVA: "
442	+	<< MuPt << " " << MuEta << " --> MVABin " << GetMVABin(MuEta, MuPt, kTRUE, kTRUE ) << " : "
443	+	<< fMVAVar_MuTkNchi2              << " "
444	+	<< fMVAVar_MuGlobalNchi2          << " "
445	+	<< fMVAVar_MuNValidHits           << " "
446	+	<< fMVAVar_MuNTrackerHits         << " "
447	+	<< fMVAVar_MuNPixelHits           << " "
448	+	<< fMVAVar_MuNMatches             << " "
449	+	<< fMVAVar_MuD0                   << " "
450	+	<< fMVAVar_MuIP3d                 << " "
451	+	<< fMVAVar_MuIP3dSig              << " "
452	+	<< fMVAVar_MuTrkKink              << " "
453	+	<< fMVAVar_MuSegmentCompatibility << " "
454	+	<< fMVAVar_MuCaloCompatibility    << " "
455	+	<< fMVAVar_MuHadEnergyOverPt      << " "
456	+	<< fMVAVar_MuHoEnergyOverPt       << " "
457	+	<< fMVAVar_MuEmEnergyOverPt       << " "
458	+	<< fMVAVar_MuHadS9EnergyOverPt    << " "
459	+	<< fMVAVar_MuHoS9EnergyOverPt     << " "
460	+	<< fMVAVar_MuEmS9EnergyOverPt     << " "
461	+	<< fMVAVar_MuTrkIso03OverPt   << " "
462	+	<< fMVAVar_MuEMIso03OverPt   << " "
463	+	<< fMVAVar_MuHadIso03OverPt   << " "
464	+	<< fMVAVar_MuTrkIso05OverPt   << " "
465	+	<< fMVAVar_MuEMIso05OverPt   << " "
466	+	<< fMVAVar_MuHadIso05OverPt   << " "
467	+	<< " === : === "
468	+	<< mva
469	+	<< std::endl;
470	+	}
471	+
472		return mva;
473		}
474
475
476
477	<	// //--------------------------------------------------------------------------------------------------
478	<	// Double_t MuonIDMVA::MVAValue(const Muon *ele, const Vertex *vertex) {
477	>	//--------------------------------------------------------------------------------------------------
478	>	Double_t MuonIDMVA::MVAValue(const Muon *mu, const Vertex *vertex, MuonTools *fMuonTools,
479	>	const PFCandidateCol *PFCands,
480	>	const PileupEnergyDensityCol *PileupEnergyDensity,
481	>	Bool_t printDebug) {
482
483	<	//   if (!fIsInitialized) {
484	<	//     std::cout << "Error: MuonIDMVA not properly initialized.\n";
485	<	//     return -9999;
486	<	//   }
487	<
488	<	//   Int_t subdet = 0;
489	<	//   if (ele->SCluster()->AbsEta() < 1.0) subdet = 0;
490	<	//   else if (ele->SCluster()->AbsEta() < 1.479) subdet = 1;
491	<	//   else subdet = 2;
492	<	//   Int_t ptBin = 0;
493	<	//   if (ele->Pt() > 20.0) ptBin = 1;
494	<
495	<	//   //set all input variables
496	<	//   fMVAVar_EleSigmaIEtaIEta = ele->CoviEtaiEta() ;
497	<	//   fMVAVar_EleDEtaIn = ele->DeltaEtaSuperClusterTrackAtVtx();
498	<	//   fMVAVar_EleDPhiIn = ele->DeltaPhiSuperClusterTrackAtVtx();
499	<	//   fMVAVar_EleHoverE = ele->HadronicOverEm();
500	<	//   fMVAVar_EleD0 = ele->BestTrk()->D0Corrected(*vertex);
501	<	//   fMVAVar_EleDZ = ele->BestTrk()->DzCorrected(*vertex);
502	<	//   fMVAVar_EleFBrem = ele->FBrem();
503	<	//   fMVAVar_EleEOverP = ele->ESuperClusterOverP();
504	<	//   fMVAVar_EleESeedClusterOverPout = ele->ESeedClusterOverPout();
505	<	//   if (!TMath::IsNaN(ele->SCluster()->Seed()->CoviPhiiPhi())) fMVAVar_EleSigmaIPhiIPhi = TMath::Sqrt(ele->SCluster()->Seed()->CoviPhiiPhi());
506	<	//   else fMVAVar_EleSigmaIPhiIPhi = ele->CoviEtaiEta();
507	<	//   fMVAVar_EleNBrem = ele->NumberOfClusters() - 1;
508	<	//   fMVAVar_EleOneOverEMinusOneOverP = (1.0/(ele->SCluster()->Energy())) - 1.0 / ele->BestTrk()->P();
509	<	//   fMVAVar_EleESeedClusterOverPIn = ele->ESeedClusterOverPIn();
510	<	//   fMVAVar_EleIP3d = ele->Ip3dPV();
511	<	//   fMVAVar_EleIP3dSig = ele->Ip3dPVSignificance();
512	<
513	<	//   Double_t mva = -9999;
514	<	//   TMVA::Reader *reader = 0;
515	<	//   Int_t MVABin = -1;
516	<	//   if (subdet == 0 && ptBin == 0) MVABin = 0;
517	<	//   if (subdet == 1 && ptBin == 0) MVABin = 1;
518	<	//   if (subdet == 2 && ptBin == 0) MVABin = 2;
519	<	//   if (subdet == 0 && ptBin == 1) MVABin = 3;
520	<	//   if (subdet == 1 && ptBin == 1) MVABin = 4;
521	<	//   if (subdet == 2 && ptBin == 1) MVABin = 5;
522	<	//   assert(MVABin >= 0 && MVABin <= 5);
523	<	//   reader = fTMVAReader[MVABin];
483	>	if (!fIsInitialized) {
484	>	std::cout << "Error: MuonIDMVA not properly initialized.\n";
485	>	return -9999;
486	>	}
487	>
488	>	const Track *muTrk=0;
489	>	if(mu->HasTrackerTrk())         { muTrk = mu->TrackerTrk();    }
490	>	else if(mu->HasStandaloneTrk()) { muTrk = mu->StandaloneTrk(); }
491	>
492	>	Double_t muNchi2 = 0.0;
493	>	if(mu->HasGlobalTrk())          { muNchi2 = mu->GlobalTrk()->RChi2();     }
494	>	else if(mu->HasStandaloneTrk()) { muNchi2 = mu->StandaloneTrk()->RChi2(); }
495	>	else if(mu->HasTrackerTrk())    { muNchi2 = mu->TrackerTrk()->RChi2();    }
496	>
497	>	Double_t ChargedIso03 = 0;
498	>	Double_t NeutralIso03_05Threshold = 0;
499	>	Double_t ChargedIso04 = 0;
500	>	Double_t NeutralIso04_05Threshold = 0;
501	>	ChargedIso03 = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.1, 99999, 0.3, 0.0, 0.0);
502	>	NeutralIso03_05Threshold = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.0, 0.5, 0.3, 0.0, 0.0);
503	>	ChargedIso04 = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.1, 99999, 0.4, 0.0, 0.0);
504	>	NeutralIso04_05Threshold = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.0, 0.5, 0.4, 0.0, 0.0);
505	>
506	>	Double_t Rho = 0;
507	>	if (!(TMath::IsNaN(PileupEnergyDensity->At(0)->Rho()) || isinf(PileupEnergyDensity->At(0)->Rho()))) Rho = PileupEnergyDensity->At(0)->Rho();
508	>
509	>
510	>	//set all input variables
511	>	fMVAVar_MuTkNchi2              = muTrk->RChi2();
512	>	fMVAVar_MuGlobalNchi2          = muNchi2;
513	>	fMVAVar_MuNValidHits           = mu->NValidHits();
514	>	fMVAVar_MuNTrackerHits         = muTrk->NHits();
515	>	fMVAVar_MuNPixelHits           = muTrk->NPixelHits();
516	>	fMVAVar_MuNMatches             = mu->NMatches();
517	>	fMVAVar_MuD0                   = muTrk->D0Corrected(*vertex);
518	>	fMVAVar_MuIP3d                 = mu->Ip3dPV();
519	>	fMVAVar_MuIP3dSig              = mu->Ip3dPVSignificance();
520	>	fMVAVar_MuTrkKink              = mu->TrkKink();
521	>	fMVAVar_MuSegmentCompatibility = fMuonTools->GetSegmentCompatability(mu);
522	>	fMVAVar_MuCaloCompatibility    = fMuonTools->GetCaloCompatability(mu, kTRUE, kTRUE);
523	>	fMVAVar_MuHadEnergyOverPt      = (mu->HadEnergy() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadEnergy,muTrk->Eta()))/muTrk->Pt();
524	>	fMVAVar_MuHoEnergyOverPt       = (mu->HoEnergy() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHoEnergy,muTrk->Eta()))/muTrk->Pt();
525	>	fMVAVar_MuEmEnergyOverPt       = (mu->EmEnergy() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuEmEnergy,muTrk->Eta()))/muTrk->Pt();
526	>	fMVAVar_MuHadS9EnergyOverPt    = (mu->HadS9Energy() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadS9Energy,muTrk->Eta()))/muTrk->Pt();
527	>	fMVAVar_MuHoS9EnergyOverPt     = (mu->HoS9Energy() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHoS9Energy,muTrk->Eta()))/muTrk->Pt();
528	>	fMVAVar_MuEmS9EnergyOverPt     = (mu->EmS9Energy() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuEmS9Energy,muTrk->Eta()))/muTrk->Pt();
529	>	fMVAVar_MuChargedIso03OverPt   = (ChargedIso03 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuChargedIso03,muTrk->Eta()))/muTrk->Pt();
530	>	fMVAVar_MuNeutralIso03OverPt   = (NeutralIso03_05Threshold - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso03,muTrk->Eta()))/muTrk->Pt();
531	>	fMVAVar_MuChargedIso04OverPt   = (ChargedIso04 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuChargedIso04,muTrk->Eta()))/muTrk->Pt();
532	>	fMVAVar_MuNeutralIso04OverPt   = (NeutralIso04_05Threshold - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso04,muTrk->Eta()))/muTrk->Pt();
533	>	fMVAVar_MuTrkIso03OverPt       = (mu->IsoR03SumPt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuTrkIso03,muTrk->Eta()))/muTrk->Pt();
534	>	fMVAVar_MuEMIso03OverPt        = (mu->IsoR03EmEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuEMIso03,muTrk->Eta()))/muTrk->Pt();
535	>	fMVAVar_MuHadIso03OverPt       = (mu->IsoR03HadEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadIso03,muTrk->Eta()))/muTrk->Pt();
536	>	fMVAVar_MuTrkIso05OverPt       = (mu->IsoR05SumPt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuTrkIso05,muTrk->Eta()))/muTrk->Pt();
537	>	fMVAVar_MuEMIso05OverPt        = (mu->IsoR05EmEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuEMIso05,muTrk->Eta()))/muTrk->Pt();
538	>	fMVAVar_MuHadIso05OverPt       = (mu->IsoR05HadEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadIso05,muTrk->Eta()))/muTrk->Pt();
539	>
540	>	Double_t mva = -9999;
541	>	TMVA::Reader *reader = 0;
542	>	reader = fTMVAReader[GetMVABin(muTrk->Eta(), muTrk->Pt(), mu->IsGlobalMuon(), mu->IsTrackerMuon())];
543
544	<	//   mva = reader->EvaluateMVA( fMethodname );
544	>	mva = reader->EvaluateMVA( fMethodname );
545	>
546	>	if (printDebug) {
547	>	std::cout << "Debug Muon MVA: "
548	>	<< mu->Pt() << " " << mu->Eta() << " " << mu->Phi() << " : "
549	>	<< muTrk->Pt() << " " << muTrk->Eta() << " --> MVABin " << GetMVABin(muTrk->Eta(), muTrk->Pt(), mu->IsGlobalMuon(), mu->IsTrackerMuon()) << " : "
550	>	<< fMVAVar_MuTkNchi2              << " "
551	>	<< fMVAVar_MuGlobalNchi2          << " "
552	>	<< fMVAVar_MuNValidHits           << " "
553	>	<< fMVAVar_MuNTrackerHits         << " "
554	>	<< fMVAVar_MuNPixelHits           << " "
555	>	<< fMVAVar_MuNMatches             << " "
556	>	<< fMVAVar_MuD0                   << " "
557	>	<< fMVAVar_MuIP3d                 << " "
558	>	<< fMVAVar_MuIP3dSig              << " "
559	>	<< fMVAVar_MuTrkKink              << " "
560	>	<< fMVAVar_MuSegmentCompatibility << " "
561	>	<< fMVAVar_MuCaloCompatibility    << " "
562	>	<< fMVAVar_MuHadEnergyOverPt      << " "
563	>	<< fMVAVar_MuHoEnergyOverPt       << " "
564	>	<< fMVAVar_MuEmEnergyOverPt       << " "
565	>	<< fMVAVar_MuHadS9EnergyOverPt    << " "
566	>	<< fMVAVar_MuHoS9EnergyOverPt     << " "
567	>	<< fMVAVar_MuEmS9EnergyOverPt     << " "
568	>	<< fMVAVar_MuChargedIso03OverPt   << " "
569	>	<< fMVAVar_MuNeutralIso03OverPt   << " "
570	>	<< fMVAVar_MuChargedIso04OverPt   << " "
571	>	<< fMVAVar_MuNeutralIso04OverPt   << " "
572	>	<< fMVAVar_MuTrkIso03OverPt   << " "
573	>	<< fMVAVar_MuEMIso03OverPt   << " "
574	>	<< fMVAVar_MuHadIso03OverPt   << " "
575	>	<< fMVAVar_MuTrkIso05OverPt   << " "
576	>	<< fMVAVar_MuEMIso05OverPt   << " "
577	>	<< fMVAVar_MuHadIso05OverPt   << " "
578	>	<< " === : === "
579	>	<< mva
580	>	<< std::endl;
581	>	}
582	>
583	>	return mva;
584	>	}
585	>
586
587	<	//   return mva;
588	<	// }
587	>	//--------------------------------------------------------------------------------------------------
588	>	Double_t MuonIDMVA::MVAValue(const Muon *mu, const Vertex *vertex, MuonTools *fMuonTools,
589	>	const PFCandidateCol *PFCands,
590	>	const PileupEnergyDensityCol *PileupEnergyDensity,
591	>	MuonTools::EMuonEffectiveAreaTarget EffectiveAreaTarget,
592	>	const ElectronCol *goodElectrons,
593	>	const MuonCol *goodMuons,
594	>	Bool_t printDebug) {
595	>
596	>	if (!fIsInitialized) {
597	>	std::cout << "Error: MuonIDMVA not properly initialized.\n";
598	>	return -9999;
599	>	}
600	>
601	>	const Track *muTrk=0;
602	>	if(mu->HasTrackerTrk())         { muTrk = mu->TrackerTrk();    }
603	>	else if(mu->HasStandaloneTrk()) { muTrk = mu->StandaloneTrk(); }
604	>
605	>	Double_t muNchi2 = 0.0;
606	>	if(mu->HasGlobalTrk())          { muNchi2 = mu->GlobalTrk()->RChi2();     }
607	>	else if(mu->HasStandaloneTrk()) { muNchi2 = mu->StandaloneTrk()->RChi2(); }
608	>	else if(mu->HasTrackerTrk())    { muNchi2 = mu->TrackerTrk()->RChi2();    }
609	>
610	>	Double_t ChargedIso03 = 0;
611	>	Double_t NeutralIso03_05Threshold = 0;
612	>	Double_t ChargedIso04 = 0;
613	>	Double_t NeutralIso04_05Threshold = 0;
614	>	ChargedIso03 = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.1, 99999, 0.3, 0.0, 0.0);
615	>	NeutralIso03_05Threshold = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.0, 0.5, 0.3, 0.0, 0.0);
616	>	ChargedIso04 = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.1, 99999, 0.4, 0.0, 0.0);
617	>	NeutralIso04_05Threshold = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.0, 0.5, 0.4, 0.0, 0.0);
618	>
619	>	Double_t Rho = 0;
620	>	if (!(TMath::IsNaN(PileupEnergyDensity->At(0)->Rho()) || isinf(PileupEnergyDensity->At(0)->Rho()))) Rho = PileupEnergyDensity->At(0)->Rho();
621	>
622	>
623	>	//set all input variables
624	>	fMVAVar_MuPt                   = muTrk->Pt();
625	>	fMVAVar_MuEta                  = muTrk->Eta();
626	>	fMVAVar_MuTkNchi2              = muTrk->RChi2();
627	>	fMVAVar_MuGlobalNchi2          = muNchi2;
628	>	fMVAVar_MuNValidHits           = mu->NValidHits();
629	>	fMVAVar_MuNTrackerHits         = muTrk->NHits();
630	>	fMVAVar_MuNPixelHits           = muTrk->NPixelHits();
631	>	fMVAVar_MuNMatches             = mu->NMatches();
632	>	fMVAVar_MuD0                   = muTrk->D0Corrected(*vertex);
633	>	fMVAVar_MuIP3d                 = mu->Ip3dPV();
634	>	fMVAVar_MuIP3dSig              = mu->Ip3dPVSignificance();
635	>	fMVAVar_MuTrkKink              = mu->TrkKink();
636	>	fMVAVar_MuSegmentCompatibility = fMuonTools->GetSegmentCompatability(mu);
637	>	fMVAVar_MuCaloCompatibility    = fMuonTools->GetCaloCompatability(mu, kTRUE, kTRUE);
638	>	fMVAVar_MuHadEnergy            = mu->HadEnergy() ;
639	>	fMVAVar_MuEmEnergy             = mu->EmEnergy();
640	>	fMVAVar_MuHadS9Energy          = mu->HadS9Energy();
641	>	fMVAVar_MuEmS9Energy           = mu->EmS9Energy();
642	>	fMVAVar_MuChargedIso03OverPt   = (ChargedIso03 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuChargedIso03,muTrk->Eta()))/muTrk->Pt();
643	>	fMVAVar_MuNeutralIso03OverPt   = (NeutralIso03_05Threshold - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso03,muTrk->Eta()))/muTrk->Pt();
644	>	fMVAVar_MuChargedIso04OverPt   = (ChargedIso04 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuChargedIso04,muTrk->Eta()))/muTrk->Pt();
645	>	fMVAVar_MuNeutralIso04OverPt   = (NeutralIso04_05Threshold - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso04,muTrk->Eta()))/muTrk->Pt();
646	>	fMVAVar_MuTrkIso03OverPt       = (mu->IsoR03SumPt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuTrkIso03,muTrk->Eta()))/muTrk->Pt();
647	>	fMVAVar_MuEMIso03OverPt        = (mu->IsoR03EmEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuEMIso03,muTrk->Eta()))/muTrk->Pt();
648	>	fMVAVar_MuHadIso03OverPt       = (mu->IsoR03HadEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadIso03,muTrk->Eta()))/muTrk->Pt();
649	>	fMVAVar_MuTrkIso05OverPt       = (mu->IsoR05SumPt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuTrkIso05,muTrk->Eta()))/muTrk->Pt();
650	>	fMVAVar_MuEMIso05OverPt        = (mu->IsoR05EmEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuEMIso05,muTrk->Eta()))/muTrk->Pt();
651	>	fMVAVar_MuHadIso05OverPt       = (mu->IsoR05HadEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadIso05,muTrk->Eta()))/muTrk->Pt();
652	>
653	>
654	>	Double_t tmpChargedIso_DR0p0To0p1  = 0;
655	>	Double_t tmpChargedIso_DR0p1To0p2  = 0;
656	>	Double_t tmpChargedIso_DR0p2To0p3  = 0;
657	>	Double_t tmpChargedIso_DR0p3To0p4  = 0;
658	>	Double_t tmpChargedIso_DR0p4To0p5  = 0;
659	>	Double_t tmpGammaIso_DR0p0To0p1  = 0;
660	>	Double_t tmpGammaIso_DR0p1To0p2  = 0;
661	>	Double_t tmpGammaIso_DR0p2To0p3  = 0;
662	>	Double_t tmpGammaIso_DR0p3To0p4  = 0;
663	>	Double_t tmpGammaIso_DR0p4To0p5  = 0;
664	>	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
665	>	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
666	>	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
667	>	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
668	>	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
669	>
670	>	for (UInt_t p=0; p<PFCands->GetEntries();p++) {
671	>	const PFCandidate *pf = PFCands->At(p);
672	>
673	>	//exclude the muon itself
674	>	if(pf->TrackerTrk() && mu->TrackerTrk() &&
675	>	pf->TrackerTrk() == mu->TrackerTrk()) continue;
676	>
677	>	//************************************************************
678	>	// New Isolation Calculations
679	>	//************************************************************
680	>	Double_t dr = MathUtils::DeltaR(mu->Mom(), pf->Mom());
681	>
682	>	if (dr < 0.5) {
683	>	Bool_t IsLeptonFootprint = kFALSE;
684	>	//************************************************************
685	>	// Lepton Footprint Removal
686	>	//************************************************************
687	>	for (UInt_t q=0; q < goodElectrons->GetEntries() ; ++q) {
688	>	//if pf candidate matches an electron passing ID cuts, then veto it
689	>	if(pf->GsfTrk() && goodElectrons->At(q)->GsfTrk() &&
690	>	pf->GsfTrk() == goodElectrons->At(q)->GsfTrk()) IsLeptonFootprint = kTRUE;
691	>	if(pf->TrackerTrk() && goodElectrons->At(q)->TrackerTrk() &&
692	>	pf->TrackerTrk() == goodElectrons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
693	>	//if pf candidate lies in veto regions of electron passing ID cuts, then veto it
694	>	if(pf->BestTrk() && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479
695	>	&& MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.015) IsLeptonFootprint = kTRUE;
696	>	if(pf->PFType() == PFCandidate::eGamma && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479 &&
697	>	MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.08) IsLeptonFootprint = kTRUE;
698	>	}
699	>	for (UInt_t q=0; q < goodMuons->GetEntries() ; ++q) {
700	>	//if pf candidate matches an muon passing ID cuts, then veto it
701	>	if(pf->TrackerTrk() && goodMuons->At(q)->TrackerTrk() &&
702	>	pf->TrackerTrk() == goodMuons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
703	>	//if pf candidate lies in veto regions of muon passing ID cuts, then veto it
704	>	if(pf->BestTrk() && MathUtils::DeltaR(goodMuons->At(q)->Mom(), pf->Mom()) < 0.01) IsLeptonFootprint = kTRUE;
705	>	}
706	>
707	>	if (!IsLeptonFootprint) {
708	>	Bool_t passVeto = kTRUE;
709	>	//Charged
710	>	if(pf->BestTrk()) {
711	>	if (!(fabs(pf->BestTrk()->DzCorrected(*vertex) - mu->BestTrk()->DzCorrected(*vertex)) < 0.2)) passVeto = kFALSE;
712	>	//************************************************************
713	>	// Veto any PFmuon, or PFEle
714	>	if (pf->PFType() == PFCandidate::eElectron || pf->PFType() == PFCandidate::eMuon) passVeto = kFALSE;
715	>	//************************************************************
716	>	//************************************************************
717	>	// Footprint Veto
718	>	if (dr < 0.01) passVeto = kFALSE;
719	>	//************************************************************
720	>	if (passVeto) {
721	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
722	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
723	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
724	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
725	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
726	>	} //pass veto
727	>	}
728	>	//Gamma
729	>	else if (pf->PFType() == PFCandidate::eGamma) {
730	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
731	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
732	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
733	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
734	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
735	>	}
736	>	//NeutralHadron
737	>	else {
738	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
739	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
740	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
741	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
742	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
743	>	}
744	>	} //not lepton footprint
745	>	} //in 1.0 dr cone
746	>	} //loop over PF candidates
747	>
748	>	Double_t fMVAVar_ChargedIso_DR0p0To0p1  = 0;
749	>	Double_t fMVAVar_ChargedIso_DR0p1To0p2  = 0;
750	>	Double_t fMVAVar_ChargedIso_DR0p2To0p3  = 0;
751	>	Double_t fMVAVar_ChargedIso_DR0p3To0p4  = 0;
752	>	Double_t fMVAVar_ChargedIso_DR0p4To0p5  = 0;
753	>	Double_t fMVAVar_GammaIso_DR0p0To0p1  = 0;
754	>	Double_t fMVAVar_GammaIso_DR0p1To0p2  = 0;
755	>	Double_t fMVAVar_GammaIso_DR0p2To0p3  = 0;
756	>	Double_t fMVAVar_GammaIso_DR0p3To0p4  = 0;
757	>	Double_t fMVAVar_GammaIso_DR0p4To0p5  = 0;
758	>	Double_t fMVAVar_NeutralHadronIso_DR0p0To0p1  = 0;
759	>	Double_t fMVAVar_NeutralHadronIso_DR0p1To0p2  = 0;
760	>	Double_t fMVAVar_NeutralHadronIso_DR0p2To0p3  = 0;
761	>	Double_t fMVAVar_NeutralHadronIso_DR0p3To0p4  = 0;
762	>	Double_t fMVAVar_NeutralHadronIso_DR0p4To0p5  = 0;
763	>
764	>	fMVAVar_ChargedIso_DR0p0To0p1   = TMath::Min((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
765	>	fMVAVar_ChargedIso_DR0p1To0p2   = TMath::Min((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
766	>	fMVAVar_ChargedIso_DR0p2To0p3 = TMath::Min((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
767	>	fMVAVar_ChargedIso_DR0p3To0p4 = TMath::Min((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
768	>	fMVAVar_ChargedIso_DR0p4To0p5 = TMath::Min((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
769	>	fMVAVar_GammaIso_DR0p0To0p1 = TMath::Max(TMath::Min((tmpGammaIso_DR0p0To0p1 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p0To0p1, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
770	>	fMVAVar_GammaIso_DR0p1To0p2 = TMath::Max(TMath::Min((tmpGammaIso_DR0p1To0p2 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p1To0p2, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
771	>	fMVAVar_GammaIso_DR0p2To0p3 = TMath::Max(TMath::Min((tmpGammaIso_DR0p2To0p3 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p2To0p3, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
772	>	fMVAVar_GammaIso_DR0p3To0p4 = TMath::Max(TMath::Min((tmpGammaIso_DR0p3To0p4 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p3To0p4, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
773	>	fMVAVar_GammaIso_DR0p4To0p5 = TMath::Max(TMath::Min((tmpGammaIso_DR0p4To0p5 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p4To0p5, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
774	>	fMVAVar_NeutralHadronIso_DR0p0To0p1 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p0To0p1 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p0To0p1, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
775	>	fMVAVar_NeutralHadronIso_DR0p1To0p2 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p1To0p2 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p1To0p2, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
776	>	fMVAVar_NeutralHadronIso_DR0p2To0p3 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p2To0p3 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p2To0p3, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
777	>	fMVAVar_NeutralHadronIso_DR0p3To0p4 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p3To0p4 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p3To0p4, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
778	>	fMVAVar_NeutralHadronIso_DR0p4To0p5 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p4To0p5 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p4To0p5, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
779	>
780	>
781	>
782	>	Double_t mva = -9999;
783	>	TMVA::Reader *reader = 0;
784	>
785	>	if (printDebug) {
786	>	std::cout <<" -> BIN: " << fMVAVar_MuEta << " " << fMVAVar_MuPt << " : "
787	>	<< GetMVABin(muTrk->Eta(), muTrk->Pt(), mu->IsGlobalMuon(), mu->IsTrackerMuon() )
788	>	<< std::endl;
789	>	}
790	>
791	>	reader = fTMVAReader[GetMVABin(muTrk->Eta(), muTrk->Pt(), mu->IsGlobalMuon(), mu->IsTrackerMuon() )];
792	>
793	>	mva = reader->EvaluateMVA( fMethodname );
794	>
795	>	if (printDebug) {
796	>	std::cout << "Debug Muon MVA: \n";
797	>	std::cout << " MuTkNchi2 " << fMVAVar_MuTkNchi2
798	>	<< " MuGlobalNchi2 " << fMVAVar_MuGlobalNchi2
799	>	<< " MuNValidHits " << fMVAVar_MuNValidHits
800	>	<< " MuNTrackerHits " << fMVAVar_MuNTrackerHits
801	>	<< " MuNPixelHits " << fMVAVar_MuNPixelHits
802	>	<< " MuNMatches " << fMVAVar_MuNMatches
803	>	<< " MuD0 " << fMVAVar_MuD0
804	>	<< " MuIP3d " << fMVAVar_MuIP3d
805	>	<< " MuIP3dSig " << fMVAVar_MuIP3dSig
806	>	<< " MuTrkKink " << fMVAVar_MuTrkKink
807	>	<< " MuSegmentCompatibility " << fMVAVar_MuSegmentCompatibility
808	>	<< " MuCaloCompatibility " << fMVAVar_MuCaloCompatibility
809	>	<< " MuHadEnergy " << fMVAVar_MuHadEnergy
810	>	<< " MuEmEnergy " << fMVAVar_MuEmEnergy
811	>	<< " MuHadS9Energy " << fMVAVar_MuHadS9Energy
812	>	<< " MuEmS9Energy " << fMVAVar_MuEmS9Energy
813	>	<< " eta " << fMVAVar_MuEta
814	>	<< " pt " << fMVAVar_MuPt << std::endl;
815	>
816	>	std::cout << fMVAVar_ChargedIso_DR0p0To0p1 << " "
817	>	<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
818	>	<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
819	>	<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
820	>	<< fMVAVar_ChargedIso_DR0p4To0p5 << " "
821	>	<< fMVAVar_GammaIso_DR0p0To0p1 << " "
822	>	<< fMVAVar_GammaIso_DR0p1To0p2 << " "
823	>	<< fMVAVar_GammaIso_DR0p2To0p3 << " "
824	>	<< fMVAVar_GammaIso_DR0p3To0p4 << " "
825	>	<< fMVAVar_GammaIso_DR0p4To0p5 << " "
826	>	<< fMVAVar_NeutralHadronIso_DR0p0To0p1 << " "
827	>	<< fMVAVar_NeutralHadronIso_DR0p1To0p2 << " "
828	>	<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " "
829	>	<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
830	>	<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " "
831	>	<< std::endl;
832	>	std::cout << "MVA: " << mva
833	>	<< std::endl;
834	>	}
835	>
836	>	return mva;
837	>	}

Diff Legend

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