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.4 by sixie, Wed Jan 4 13:35:09 2012 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	<	fTMVAReader[i]->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
115	<	fTMVAReader[i]->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
116	<	fTMVAReader[i]->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
117	<	fTMVAReader[i]->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
118	<	fTMVAReader[i]->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
119	<	fTMVAReader[i]->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
120	<	fTMVAReader[i]->AddVariable( "D0",                   &fMVAVar_MuD0                    );
121	<	fTMVAReader[i]->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );
122	<	fTMVAReader[i]->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );
123	<	fTMVAReader[i]->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
124	<	fTMVAReader[i]->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
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	<	fTMVAReader[i]->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
154	<	fTMVAReader[i]->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
155	<	fTMVAReader[i]->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
156	<	fTMVAReader[i]->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
157	<	fTMVAReader[i]->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
158	<	fTMVAReader[i]->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
159	<	fTMVAReader[i]->AddVariable( "D0",                   &fMVAVar_MuD0                    );
160	<	fTMVAReader[i]->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );
161	<	fTMVAReader[i]->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );
162	<	fTMVAReader[i]->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
163	<	fTMVAReader[i]->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
164	<	fTMVAReader[i]->AddVariable( "CaloCompatibility",    &fMVAVar_MuCaloCompatibility     );
165	<	fTMVAReader[i]->AddVariable( "HadEnergyOverPt",      &fMVAVar_MuHadEnergyOverPt       );
166	<	fTMVAReader[i]->AddVariable( "EmEnergyOverPt",       &fMVAVar_MuEmEnergyOverPt        );
167	<	fTMVAReader[i]->AddVariable( "HadS9EnergyOverPt",    &fMVAVar_MuHadS9EnergyOverPt     );
168	<	fTMVAReader[i]->AddVariable( "EmS9EnergyOverPt",     &fMVAVar_MuEmS9EnergyOverPt      );
169	<	fTMVAReader[i]->AddVariable( "ChargedIso03OverPt",   &fMVAVar_MuChargedIso03OverPt    );
170	<	fTMVAReader[i]->AddVariable( "NeutralIso03OverPt",   &fMVAVar_MuNeutralIso03OverPt    );
171	<	fTMVAReader[i]->AddVariable( "ChargedIso04OverPt",   &fMVAVar_MuChargedIso04OverPt    );
172	<	fTMVAReader[i]->AddVariable( "NeutralIso04OverPt",   &fMVAVar_MuNeutralIso04OverPt    );
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	+	//--------------------------------------------------------------------------------------------------
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	<	std::cout << "Muon ID MVA Initialization\n";
254	<	std::cout << "MethodName : " << fMethodname << " , type == " << type << std::endl;
255	<	std::cout << "Load weights file : " << Subdet0Pt10To14p5Weights << std::endl;
256	<	std::cout << "Load weights file : " << Subdet1Pt10To14p5Weights << std::endl;
257	<	std::cout << "Load weights file : " << Subdet0Pt14p5To20Weights << std::endl;
258	<	std::cout << "Load weights file : " << Subdet1Pt14p5To20Weights << std::endl;
259	<	std::cout << "Load weights file : " << Subdet0Pt20ToInfWeights << std::endl;
260	<	std::cout << "Load weights file : " << Subdet1Pt20ToInfWeights << std::endl;
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		//--------------------------------------------------------------------------------------------------
#	Line 157 | Line 297 | Double_t MuonIDMVA::MVAValue(Double_t Mu
297		Double_t                   MuChargedIso03OverPt,
298		Double_t                   MuNeutralIso03OverPt,
299		Double_t                   MuChargedIso04OverPt,
300	<	Double_t                   MuNeutralIso04OverPt
300	>	Double_t                   MuNeutralIso04OverPt,
301	>	Bool_t                     printDebug
302		) {
303
304		if (!fIsInitialized) {
#	Line 165 | Line 306 | Double_t MuonIDMVA::MVAValue(Double_t Mu
306		return -9999;
307		}
308
168	–	Int_t subdet = 0;
169	–	if (fabs(MuEta) < 1.479) subdet = 0;
170	–	else subdet = 1;
171	–	Int_t ptBin = 0;
172	–	if (MuPt > 14.5) ptBin = 1;
173	–	if (MuPt > 20.0) ptBin = 2;
174	–
309
310		//set all input variables
311		fMVAVar_MuTkNchi2              = MuTkNchi2;
#	Line 199 | Line 333 | Double_t MuonIDMVA::MVAValue(Double_t Mu
333
334		Double_t mva = -9999;
335		TMVA::Reader *reader = 0;
336	<
203	<	Int_t MVABin = -1;
204	<	if (subdet == 0 && ptBin == 0) MVABin = 0;
205	<	if (subdet == 1 && ptBin == 0) MVABin = 1;
206	<	if (subdet == 0 && ptBin == 1) MVABin = 2;
207	<	if (subdet == 1 && ptBin == 1) MVABin = 3;
208	<	if (subdet == 0 && ptBin == 2) MVABin = 4;
209	<	if (subdet == 1 && ptBin == 2) MVABin = 5;
210	<	assert(MVABin >= 0 && MVABin <= 5);
211	<	reader = fTMVAReader[MVABin];
336	>	reader = fTMVAReader[GetMVABin(MuEta, MuPt, kTRUE, kTRUE )];
337
338		mva = reader->EvaluateMVA( fMethodname );
339
340	<	Bool_t printdebug = kTRUE;
216	<	if (printdebug == kTRUE) {
340	>	if (printDebug) {
341		std::cout << "Debug Muon MVA: "
342	<	<< MuPt << " " << MuEta << " --> MVABin " << MVABin << " : "
342	>	<< MuPt << " " << MuEta << " --> MVABin " << GetMVABin(MuEta, MuPt, kTRUE, kTRUE ) << " : "
343		<< fMVAVar_MuTkNchi2              << " "
344		<< fMVAVar_MuGlobalNchi2          << " "
345		<< fMVAVar_MuNValidHits           << " "
#	Line 247 | Line 371 | Double_t MuonIDMVA::MVAValue(Double_t Mu
371		}
372
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 *mu, const Vertex *vertex, MuonTools *fMuonTools,
479		const PFCandidateCol *PFCands,
480	<	const PileupEnergyDensityCol *PileupEnergyDensity) {
480	>	const PileupEnergyDensityCol *PileupEnergyDensity,
481	>	Bool_t printDebug) {
482
483		if (!fIsInitialized) {
484		std::cout << "Error: MuonIDMVA not properly initialized.\n";
#	Line 267 | Line 494 | Double_t MuonIDMVA::MVAValue(const Muon
494		else if(mu->HasStandaloneTrk()) { muNchi2 = mu->StandaloneTrk()->RChi2(); }
495		else if(mu->HasTrackerTrk())    { muNchi2 = mu->TrackerTrk()->RChi2();    }
496
497	<	Double_t ChargedIso03 = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.1, 99999, 0.3, 0.0, 0.0);
498	<	Double_t NeutralIso03_05Threshold = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.0, 0.5, 0.3, 0.0, 0.0);
499	<	Double_t ChargedIso04 = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.1, 99999, 0.4, 0.0, 0.0);
500	<	Double_t NeutralIso04_05Threshold = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.0, 0.5, 0.4, 0.0, 0.0);
501	<
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	<	Int_t subdet = 0;
279	<	if (fabs(muTrk->Eta()) < 1.479) subdet = 0;
280	<	else subdet = 1;
281	<	Int_t ptBin = 0;
282	<	if (muTrk->Pt() > 14.5) ptBin = 1;
283	<	if (muTrk->Pt() > 20.0) ptBin = 2;
284	<
509	>
510		//set all input variables
511		fMVAVar_MuTkNchi2              = muTrk->RChi2();
512		fMVAVar_MuGlobalNchi2          = muNchi2;
#	Line 305 | Line 530 | Double_t MuonIDMVA::MVAValue(const Muon
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	<
312	<	Int_t MVABin = -1;
313	<	if (subdet == 0 && ptBin == 0) MVABin = 0;
314	<	if (subdet == 1 && ptBin == 0) MVABin = 1;
315	<	if (subdet == 0 && ptBin == 1) MVABin = 2;
316	<	if (subdet == 1 && ptBin == 1) MVABin = 3;
317	<	if (subdet == 0 && ptBin == 2) MVABin = 4;
318	<	if (subdet == 1 && ptBin == 2) MVABin = 5;
319	<	assert(MVABin >= 0 && MVABin <= 5);
320	<	reader = fTMVAReader[MVABin];
542	>	reader = fTMVAReader[GetMVABin(muTrk->Eta(), muTrk->Pt(), mu->IsGlobalMuon(), mu->IsTrackerMuon())];
543
544		mva = reader->EvaluateMVA( fMethodname );
545
546	<	Bool_t printdebug = kTRUE;
325	<	if (printdebug == kTRUE) {
546	>	if (printDebug) {
547		std::cout << "Debug Muon MVA: "
548		<< mu->Pt() << " " << mu->Eta() << " " << mu->Phi() << " : "
549	<	<< muTrk->Pt() << " " << muTrk->Eta() << " --> MVABin " << MVABin << " : "
549	>	<< muTrk->Pt() << " " << muTrk->Eta() << " --> MVABin " << GetMVABin(muTrk->Eta(), muTrk->Pt(), mu->IsGlobalMuon(), mu->IsTrackerMuon()) << " : "
550		<< fMVAVar_MuTkNchi2              << " "
551		<< fMVAVar_MuGlobalNchi2          << " "
552		<< fMVAVar_MuNValidHits           << " "
#	Line 348 | Line 569 | Double_t MuonIDMVA::MVAValue(const Muon
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	+	//--------------------------------------------------------------------------------------------------
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