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.7 by sixie, Mon Jan 23 20:05:41 2012 UTC vs.
Revision 1.13 by ceballos, Fri May 4 21:56:29 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) {
85	<	if (fTMVAReader[i]) delete fTMVAReader[i];
83	>	fMVAType = type;
84	>	fUseBinnedVersion = useBinnedVersion;
85	>
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	>	|| type == kIsoRingsV0
95	>	|| type == kIDV0
96	>	|| type == kIDIsoCombinedIsoRingsV0
97	>	) {
98	>	ExpectedNBins = 6;
99	>	} else if (type == kIsoDeltaR){
100	>	ExpectedNBins = 4;
101	>	}
102
103	<	fTMVAReader[i] = new TMVA::Reader( "!Color:!Silent:Error" );
104	<	fTMVAReader[i]->SetVerbose(kTRUE);
103	>	fNMVABins = ExpectedNBins;
104	>
105	>	//Check number of weight files given
106	>	if (fNMVABins != weightsfiles.size() ) {
107	>	std::cout << "Error: Expected Number of bins = " << fNMVABins << " does not equal to weightsfiles.size() = "
108	>	<< weightsfiles.size() << std::endl;
109	>	assert(fNMVABins == weightsfiles.size());
110	>	}
111	>
112	>	for(UInt_t i=0; i<fNMVABins; ++i) {
113	>	TMVA::Reader *tmpTMVAReader = new TMVA::Reader( "!Color:!Silent:Error" );
114	>	tmpTMVAReader->SetVerbose(kTRUE);
115
116		if (type == kV2) {
117	<	fTMVAReader[i]->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
118	<	fTMVAReader[i]->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
119	<	fTMVAReader[i]->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
120	<	fTMVAReader[i]->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
121	<	fTMVAReader[i]->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
122	<	fTMVAReader[i]->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
123	<	fTMVAReader[i]->AddVariable( "D0",                   &fMVAVar_MuD0                    );
124	<	fTMVAReader[i]->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );
125	<	fTMVAReader[i]->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );
126	<	fTMVAReader[i]->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
127	<	fTMVAReader[i]->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
117	>	tmpTMVAReader->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
118	>	tmpTMVAReader->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
119	>	tmpTMVAReader->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
120	>	tmpTMVAReader->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
121	>	tmpTMVAReader->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
122	>	tmpTMVAReader->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
123	>	tmpTMVAReader->AddVariable( "D0",                   &fMVAVar_MuD0                    );
124	>	tmpTMVAReader->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );
125	>	tmpTMVAReader->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );
126	>	tmpTMVAReader->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
127	>	tmpTMVAReader->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
128		}
129
130		if (type == kV3) {
131	<	fTMVAReader[i]->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
132	<	fTMVAReader[i]->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
133	<	fTMVAReader[i]->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
134	<	fTMVAReader[i]->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
135	<	fTMVAReader[i]->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
136	<	fTMVAReader[i]->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
137	<	fTMVAReader[i]->AddVariable( "D0",                   &fMVAVar_MuD0                    );
138	<	fTMVAReader[i]->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );
139	<	fTMVAReader[i]->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );
140	<	fTMVAReader[i]->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
141	<	fTMVAReader[i]->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
142	<	fTMVAReader[i]->AddVariable( "CaloCompatibility",    &fMVAVar_MuCaloCompatibility     );
143	<	fTMVAReader[i]->AddVariable( "HadEnergyOverPt",      &fMVAVar_MuHadEnergyOverPt       );
131	>	tmpTMVAReader->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
132	>	tmpTMVAReader->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
133	>	tmpTMVAReader->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
134	>	tmpTMVAReader->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
135	>	tmpTMVAReader->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
136	>	tmpTMVAReader->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
137	>	tmpTMVAReader->AddVariable( "D0",                   &fMVAVar_MuD0                    );
138	>	tmpTMVAReader->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );
139	>	tmpTMVAReader->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );
140	>	tmpTMVAReader->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
141	>	tmpTMVAReader->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
142	>	tmpTMVAReader->AddVariable( "CaloCompatibility",    &fMVAVar_MuCaloCompatibility     );
143	>	tmpTMVAReader->AddVariable( "HadEnergyOverPt",      &fMVAVar_MuHadEnergyOverPt       );
144		if (i==0 || i==2 || i==4) {
145	<	fTMVAReader[i]->AddVariable( "HoEnergyOverPt",     &fMVAVar_MuHoEnergyOverPt        );
145	>	tmpTMVAReader->AddVariable( "HoEnergyOverPt",     &fMVAVar_MuHoEnergyOverPt        );
146		}
147	<	fTMVAReader[i]->AddVariable( "EmEnergyOverPt",       &fMVAVar_MuEmEnergyOverPt        );
148	<	fTMVAReader[i]->AddVariable( "HadS9EnergyOverPt",    &fMVAVar_MuHadS9EnergyOverPt     );
147	>	tmpTMVAReader->AddVariable( "EmEnergyOverPt",       &fMVAVar_MuEmEnergyOverPt        );
148	>	tmpTMVAReader->AddVariable( "HadS9EnergyOverPt",    &fMVAVar_MuHadS9EnergyOverPt     );
149		if (i==0 || i==2 || i==4) {
150	<	fTMVAReader[i]->AddVariable( "HoS9EnergyOverPt",   &fMVAVar_MuHoS9EnergyOverPt      );
150	>	tmpTMVAReader->AddVariable( "HoS9EnergyOverPt",   &fMVAVar_MuHoS9EnergyOverPt      );
151		}
152	<	fTMVAReader[i]->AddVariable( "EmS9EnergyOverPt",     &fMVAVar_MuEmS9EnergyOverPt      );
152	>	tmpTMVAReader->AddVariable( "EmS9EnergyOverPt",     &fMVAVar_MuEmS9EnergyOverPt      );
153		}
154
155		if (type == kV8) {
156	<	fTMVAReader[i]->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
157	<	fTMVAReader[i]->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
158	<	fTMVAReader[i]->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
159	<	fTMVAReader[i]->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
160	<	fTMVAReader[i]->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
161	<	fTMVAReader[i]->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
162	<	fTMVAReader[i]->AddVariable( "D0",                   &fMVAVar_MuD0                    );
163	<	fTMVAReader[i]->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );
164	<	fTMVAReader[i]->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );
165	<	fTMVAReader[i]->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
166	<	fTMVAReader[i]->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
167	<	fTMVAReader[i]->AddVariable( "CaloCompatibility",    &fMVAVar_MuCaloCompatibility     );
168	<	fTMVAReader[i]->AddVariable( "HadEnergyOverPt",      &fMVAVar_MuHadEnergyOverPt       );
169	<	fTMVAReader[i]->AddVariable( "EmEnergyOverPt",       &fMVAVar_MuEmEnergyOverPt        );
170	<	fTMVAReader[i]->AddVariable( "HadS9EnergyOverPt",    &fMVAVar_MuHadS9EnergyOverPt     );
171	<	fTMVAReader[i]->AddVariable( "EmS9EnergyOverPt",     &fMVAVar_MuEmS9EnergyOverPt      );
172	<	fTMVAReader[i]->AddVariable( "ChargedIso03OverPt",   &fMVAVar_MuChargedIso03OverPt    );
173	<	fTMVAReader[i]->AddVariable( "NeutralIso03OverPt",   &fMVAVar_MuNeutralIso03OverPt    );
174	<	fTMVAReader[i]->AddVariable( "ChargedIso04OverPt",   &fMVAVar_MuChargedIso04OverPt    );
175	<	fTMVAReader[i]->AddVariable( "NeutralIso04OverPt",   &fMVAVar_MuNeutralIso04OverPt    );
156	>	tmpTMVAReader->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
157	>	tmpTMVAReader->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
158	>	tmpTMVAReader->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
159	>	tmpTMVAReader->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
160	>	tmpTMVAReader->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
161	>	tmpTMVAReader->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
162	>	tmpTMVAReader->AddVariable( "D0",                   &fMVAVar_MuD0                    );
163	>	tmpTMVAReader->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );
164	>	tmpTMVAReader->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );
165	>	tmpTMVAReader->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
166	>	tmpTMVAReader->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
167	>	tmpTMVAReader->AddVariable( "CaloCompatibility",    &fMVAVar_MuCaloCompatibility     );
168	>	tmpTMVAReader->AddVariable( "HadEnergyOverPt",      &fMVAVar_MuHadEnergyOverPt       );
169	>	tmpTMVAReader->AddVariable( "EmEnergyOverPt",       &fMVAVar_MuEmEnergyOverPt        );
170	>	tmpTMVAReader->AddVariable( "HadS9EnergyOverPt",    &fMVAVar_MuHadS9EnergyOverPt     );
171	>	tmpTMVAReader->AddVariable( "EmS9EnergyOverPt",     &fMVAVar_MuEmS9EnergyOverPt      );
172	>	tmpTMVAReader->AddVariable( "ChargedIso03OverPt",   &fMVAVar_MuChargedIso03OverPt    );
173	>	tmpTMVAReader->AddVariable( "NeutralIso03OverPt",   &fMVAVar_MuNeutralIso03OverPt    );
174	>	tmpTMVAReader->AddVariable( "ChargedIso04OverPt",   &fMVAVar_MuChargedIso04OverPt    );
175	>	tmpTMVAReader->AddVariable( "NeutralIso04OverPt",   &fMVAVar_MuNeutralIso04OverPt    );
176		}
177
178		if (type == kIDIsoCombinedDetIso) {
179	<	fTMVAReader[i]->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
180	<	fTMVAReader[i]->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
181	<	fTMVAReader[i]->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
182	<	fTMVAReader[i]->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
183	<	fTMVAReader[i]->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
184	<	fTMVAReader[i]->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
185	<	fTMVAReader[i]->AddVariable( "D0",                   &fMVAVar_MuD0                    );
186	<	fTMVAReader[i]->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );
187	<	fTMVAReader[i]->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );
188	<	fTMVAReader[i]->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
189	<	fTMVAReader[i]->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
190	<	fTMVAReader[i]->AddVariable( "CaloCompatibility",    &fMVAVar_MuCaloCompatibility     );
191	<	fTMVAReader[i]->AddVariable( "HadEnergyOverPt",      &fMVAVar_MuHadEnergyOverPt       );
192	<	fTMVAReader[i]->AddVariable( "EmEnergyOverPt",       &fMVAVar_MuEmEnergyOverPt        );
193	<	fTMVAReader[i]->AddVariable( "HadS9EnergyOverPt",    &fMVAVar_MuHadS9EnergyOverPt     );
194	<	fTMVAReader[i]->AddVariable( "EmS9EnergyOverPt",     &fMVAVar_MuEmS9EnergyOverPt      );
195	<	fTMVAReader[i]->AddVariable( "TrkIso03OverPt",       &fMVAVar_MuTrkIso03OverPt        );
196	<	fTMVAReader[i]->AddVariable( "EMIso03OverPt",        &fMVAVar_MuEMIso03OverPt         );
197	<	fTMVAReader[i]->AddVariable( "HadIso03OverPt",       &fMVAVar_MuHadIso03OverPt        );
198	<	fTMVAReader[i]->AddVariable( "TrkIso05OverPt",       &fMVAVar_MuTrkIso05OverPt        );
199	<	fTMVAReader[i]->AddVariable( "EMIso05OverPt",        &fMVAVar_MuEMIso05OverPt         );
200	<	fTMVAReader[i]->AddVariable( "HadIso05OverPt",       &fMVAVar_MuHadIso05OverPt        );
201	<
179	>	tmpTMVAReader->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
180	>	tmpTMVAReader->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
181	>	tmpTMVAReader->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
182	>	tmpTMVAReader->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
183	>	tmpTMVAReader->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
184	>	tmpTMVAReader->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
185	>	tmpTMVAReader->AddVariable( "D0",                   &fMVAVar_MuD0                    );
186	>	tmpTMVAReader->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );
187	>	tmpTMVAReader->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );
188	>	tmpTMVAReader->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
189	>	tmpTMVAReader->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
190	>	tmpTMVAReader->AddVariable( "CaloCompatibility",    &fMVAVar_MuCaloCompatibility     );
191	>	tmpTMVAReader->AddVariable( "HadEnergyOverPt",      &fMVAVar_MuHadEnergyOverPt       );
192	>	tmpTMVAReader->AddVariable( "EmEnergyOverPt",       &fMVAVar_MuEmEnergyOverPt        );
193	>	tmpTMVAReader->AddVariable( "HadS9EnergyOverPt",    &fMVAVar_MuHadS9EnergyOverPt     );
194	>	tmpTMVAReader->AddVariable( "EmS9EnergyOverPt",     &fMVAVar_MuEmS9EnergyOverPt      );
195	>	tmpTMVAReader->AddVariable( "TrkIso03OverPt",       &fMVAVar_MuTrkIso03OverPt        );
196	>	tmpTMVAReader->AddVariable( "EMIso03OverPt",        &fMVAVar_MuEMIso03OverPt         );
197	>	tmpTMVAReader->AddVariable( "HadIso03OverPt",       &fMVAVar_MuHadIso03OverPt        );
198	>	tmpTMVAReader->AddVariable( "TrkIso05OverPt",       &fMVAVar_MuTrkIso05OverPt        );
199	>	tmpTMVAReader->AddVariable( "EMIso05OverPt",        &fMVAVar_MuEMIso05OverPt         );
200	>	tmpTMVAReader->AddVariable( "HadIso05OverPt",       &fMVAVar_MuHadIso05OverPt        );
201	>	}
202	>
203	>	if (type == kIDV0) {
204	>	tmpTMVAReader->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
205	>	if (i!=4) tmpTMVAReader->AddVariable( "GlobalNchi2",&fMVAVar_MuGlobalNchi2           );
206	>	if (i!=4) tmpTMVAReader->AddVariable( "NValidHits", &fMVAVar_MuNValidHits            );
207	>	tmpTMVAReader->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
208	>	tmpTMVAReader->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
209	>	if (i!=5) tmpTMVAReader->AddVariable( "NMatches",   &fMVAVar_MuNMatches              );
210	>	tmpTMVAReader->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
211	>	tmpTMVAReader->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
212	>	tmpTMVAReader->AddVariable( "CaloCompatibility",    &fMVAVar_MuCaloCompatibility     );
213	>	tmpTMVAReader->AddVariable( "HadEnergy",            &fMVAVar_MuHadEnergy             );
214	>	tmpTMVAReader->AddVariable( "EmEnergy",             &fMVAVar_MuEmEnergy              );
215	>	tmpTMVAReader->AddVariable( "HadS9Energy",          &fMVAVar_MuHadS9Energy           );
216	>	tmpTMVAReader->AddVariable( "EmS9Energy",           &fMVAVar_MuEmS9Energy            );
217	>	}
218	>
219	>	if (type == kIsoRingsV0) {
220	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p0To0p1",         &fMVAVar_ChargedIso_DR0p0To0p1        );
221	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p1To0p2",         &fMVAVar_ChargedIso_DR0p1To0p2        );
222	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p2To0p3",         &fMVAVar_ChargedIso_DR0p2To0p3        );
223	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p3To0p4",         &fMVAVar_ChargedIso_DR0p3To0p4        );
224	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p4To0p5",         &fMVAVar_ChargedIso_DR0p4To0p5        );
225	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p0To0p1",           &fMVAVar_GammaIso_DR0p0To0p1          );
226	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p1To0p2",           &fMVAVar_GammaIso_DR0p1To0p2          );
227	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p2To0p3",           &fMVAVar_GammaIso_DR0p2To0p3          );
228	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p3To0p4",           &fMVAVar_GammaIso_DR0p3To0p4          );
229	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p4To0p5",           &fMVAVar_GammaIso_DR0p4To0p5          );
230	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p0To0p1",   &fMVAVar_NeutralHadronIso_DR0p0To0p1  );
231	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p1To0p2",   &fMVAVar_NeutralHadronIso_DR0p1To0p2  );
232	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p2To0p3",   &fMVAVar_NeutralHadronIso_DR0p2To0p3  );
233	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p3To0p4",   &fMVAVar_NeutralHadronIso_DR0p3To0p4  );
234	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p4To0p5",   &fMVAVar_NeutralHadronIso_DR0p4To0p5  );
235	>	}
236	>
237	>	if (type == kIsoDeltaR) {
238	>	tmpTMVAReader->AddVariable("PFCharged",                     &fMVAVar_MuRelIsoPFCharged       );
239	>	tmpTMVAReader->AddVariable("PFNeutral",                     &fMVAVar_MuRelIsoPFNeutral       );
240	>	tmpTMVAReader->AddVariable("PFPhotons",                     &fMVAVar_MuRelIsoPFPhotons       );
241	>	tmpTMVAReader->AddVariable("SumDeltaR",                     &fMVAVar_MuDeltaRSum             );
242	>	tmpTMVAReader->AddVariable("DeltaRMean",                    &fMVAVar_MuDeltaRMean            );
243	>	tmpTMVAReader->AddVariable("Density",                       &fMVAVar_MuDensity               );
244		}
245
246	<	if (i==0) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt10To14p5Weights );
247	<	if (i==1) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt10To14p5Weights );
248	<	if (i==2) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt14p5To20Weights );
249	<	if (i==3) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt14p5To20Weights );
250	<	if (i==4) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt20ToInfWeights  );
251	<	if (i==5) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt20ToInfWeights  );
246	>	tmpTMVAReader->BookMVA(fMethodname , weightsfiles[i] );
247	>	std::cout << "MVABin " << i << " : MethodName = " << fMethodname
248	>	<< " , type == " << type << " , "
249	>	<< "Load weights file : " << weightsfiles[i]
250	>	<< std::endl;
251	>	fTMVAReader.push_back(tmpTMVAReader);
252
253		}
254	+	std::cout << "Muon ID MVA Completed\n";
255	+	}
256
257	<	std::cout << "Muon ID MVA Initialization\n";
258	<	std::cout << "MethodName : " << fMethodname << " , type == " << type << std::endl;
259	<	std::cout << "Load weights file : " << Subdet0Pt10To14p5Weights << std::endl;
260	<	std::cout << "Load weights file : " << Subdet1Pt10To14p5Weights << std::endl;
261	<	std::cout << "Load weights file : " << Subdet0Pt14p5To20Weights << std::endl;
262	<	std::cout << "Load weights file : " << Subdet1Pt14p5To20Weights << std::endl;
263	<	std::cout << "Load weights file : " << Subdet0Pt20ToInfWeights << std::endl;
264	<	std::cout << "Load weights file : " << Subdet1Pt20ToInfWeights << std::endl;
257	>	//--------------------------------------------------------------------------------------------------
258	>	UInt_t MuonIDMVA::GetMVABin( double eta, double pt,
259	>	Bool_t isGlobal, Bool_t isTrackerMuon) const {
260	>
261	>	//Default is to return the first bin
262	>	uint bin = 0;
263	>
264	>	//return the first bin if not using binned version
265	>	if (!fUseBinnedVersion) return 0;
266	>
267	>	if (fMVAType == MuonIDMVA::kV2
268	>	|| fMVAType == MuonIDMVA::kV3
269	>	|| fMVAType == MuonIDMVA::kV8
270	>	|| fMVAType == MuonIDMVA::kIDIsoCombinedDetIso) {
271	>	if (pt < 14.5 && fabs(eta) < 1.5) bin = 0;
272	>	if (pt < 14.5 && fabs(eta) >= 1.5) bin = 1;
273	>	if (pt >= 14.5 && pt < 20 && fabs(eta) < 1.5) bin = 2;
274	>	if (pt >= 14.5 && pt < 20 && fabs(eta) >= 1.5) bin = 3;
275	>	if (pt >= 20 && fabs(eta) < 1.5) bin = 4;
276	>	if (pt >= 20 && fabs(eta) >= 1.5) bin = 5;
277	>	}
278	>
279	>	if (fMVAType == MuonIDMVA::kIsoRingsV0 || fMVAType == MuonIDMVA::kIDV0
280	>	|| fMVAType == MuonIDMVA::kIDIsoCombinedIsoRingsV0) {
281	>	if (isGlobal && isTrackerMuon) {
282	>	if (pt < 10 && fabs(eta) < 1.479) bin = 0;
283	>	if (pt >= 10 && fabs(eta) < 1.479) bin = 1;
284	>	if (pt < 10 && fabs(eta) >= 1.479) bin = 2;
285	>	if (pt >= 10 && fabs(eta) >= 1.479) bin = 3;
286	>	} else if (!isGlobal && isTrackerMuon) {
287	>	bin = 4;
288	>	} else if (isGlobal && !isTrackerMuon) {
289	>	bin = 5;
290	>	} else {
291	>	std::cout << "Warning: Muon is not a tracker muon. Such muons are not supported. \n";
292	>	bin = 0;
293	>	}
294	>	}
295
296	+	if (fMVAType == MuonIDMVA::kIsoDeltaR){
297	+	if (pt <  20 && fabs(eta) <  1.479) bin = 0;
298	+	if (pt <  20 && fabs(eta) >= 1.479) bin = 1;
299	+	if (pt >= 20 && fabs(eta) <  1.479) bin = 2;
300	+	if (pt >= 20 && fabs(eta) >= 1.479) bin = 3;
301	+	}
302	+
303	+	return bin;
304		}
305
306		//--------------------------------------------------------------------------------------------------
#	Line 192 | Line 335 | Double_t MuonIDMVA::MVAValue(Double_t Mu
335		return -9999;
336		}
337
195	–	Int_t subdet = 0;
196	–	if (fabs(MuEta) < 1.479) subdet = 0;
197	–	else subdet = 1;
198	–	Int_t ptBin = 0;
199	–	if (MuPt > 14.5) ptBin = 1;
200	–	if (MuPt > 20.0) ptBin = 2;
201	–
338
339		//set all input variables
340		fMVAVar_MuTkNchi2              = MuTkNchi2;
#	Line 226 | Line 362 | Double_t MuonIDMVA::MVAValue(Double_t Mu
362
363		Double_t mva = -9999;
364		TMVA::Reader *reader = 0;
365	<
230	<	Int_t MVABin = -1;
231	<	if (subdet == 0 && ptBin == 0) MVABin = 0;
232	<	if (subdet == 1 && ptBin == 0) MVABin = 1;
233	<	if (subdet == 0 && ptBin == 1) MVABin = 2;
234	<	if (subdet == 1 && ptBin == 1) MVABin = 3;
235	<	if (subdet == 0 && ptBin == 2) MVABin = 4;
236	<	if (subdet == 1 && ptBin == 2) MVABin = 5;
237	<	assert(MVABin >= 0 && MVABin <= 5);
238	<	reader = fTMVAReader[MVABin];
365	>	reader = fTMVAReader[GetMVABin(MuEta, MuPt, kTRUE, kTRUE )];
366
367		mva = reader->EvaluateMVA( fMethodname );
368
369		if (printDebug) {
370		std::cout << "Debug Muon MVA: "
371	<	<< MuPt << " " << MuEta << " --> MVABin " << MVABin << " : "
371	>	<< MuPt << " " << MuEta << " --> MVABin " << GetMVABin(MuEta, MuPt, kTRUE, kTRUE ) << " : "
372		<< fMVAVar_MuTkNchi2              << " "
373		<< fMVAVar_MuGlobalNchi2          << " "
374		<< fMVAVar_MuNValidHits           << " "
#	Line 306 | Line 433 | Double_t MuonIDMVA::MVAValue(Double_t Mu
433		std::cout << "Error: MuonIDMVA not properly initialized.\n";
434		return -9999;
435		}
309	–
310	–	Int_t subdet = 0;
311	–	if (fabs(MuEta) < 1.479) subdet = 0;
312	–	else subdet = 1;
313	–	Int_t ptBin = 0;
314	–	if (MuPt > 14.5) ptBin = 1;
315	–	if (MuPt > 20.0) ptBin = 2;
316	–
436
437		//set all input variables
438		fMVAVar_MuTkNchi2              = MuTkNchi2;
#	Line 343 | Line 462 | Double_t MuonIDMVA::MVAValue(Double_t Mu
462
463		Double_t mva = -9999;
464		TMVA::Reader *reader = 0;
465	<
347	<	Int_t MVABin = -1;
348	<	if (subdet == 0 && ptBin == 0) MVABin = 0;
349	<	if (subdet == 1 && ptBin == 0) MVABin = 1;
350	<	if (subdet == 0 && ptBin == 1) MVABin = 2;
351	<	if (subdet == 1 && ptBin == 1) MVABin = 3;
352	<	if (subdet == 0 && ptBin == 2) MVABin = 4;
353	<	if (subdet == 1 && ptBin == 2) MVABin = 5;
354	<	assert(MVABin >= 0 && MVABin <= 5);
355	<	reader = fTMVAReader[MVABin];
465	>	reader = fTMVAReader[GetMVABin(MuEta, MuPt, kTRUE, kTRUE )];
466
467		mva = reader->EvaluateMVA( fMethodname );
468
469		if (printDebug) {
470		std::cout << "Debug Muon MVA: "
471	<	<< MuPt << " " << MuEta << " --> MVABin " << MVABin << " : "
471	>	<< MuPt << " " << MuEta << " --> MVABin " << GetMVABin(MuEta, MuPt, kTRUE, kTRUE ) << " : "
472		<< fMVAVar_MuTkNchi2              << " "
473		<< fMVAVar_MuGlobalNchi2          << " "
474		<< fMVAVar_MuNValidHits           << " "
#	Line 392 | Line 502 | Double_t MuonIDMVA::MVAValue(Double_t Mu
502		}
503
504
505	+	Double_t MuonIDMVA::MVAValue_IsoRings( Double_t MuPt,
506	+	Double_t MuEta,
507	+	Double_t ChargedIso_DR0p0To0p1,
508	+	Double_t ChargedIso_DR0p1To0p2,
509	+	Double_t ChargedIso_DR0p2To0p3,
510	+	Double_t ChargedIso_DR0p3To0p4,
511	+	Double_t ChargedIso_DR0p4To0p5,
512	+	Double_t GammaIso_DR0p0To0p1,
513	+	Double_t GammaIso_DR0p1To0p2,
514	+	Double_t GammaIso_DR0p2To0p3,
515	+	Double_t GammaIso_DR0p3To0p4,
516	+	Double_t GammaIso_DR0p4To0p5,
517	+	Double_t NeutralHadronIso_DR0p0To0p1,
518	+	Double_t NeutralHadronIso_DR0p1To0p2,
519	+	Double_t NeutralHadronIso_DR0p2To0p3,
520	+	Double_t NeutralHadronIso_DR0p3To0p4,
521	+	Double_t NeutralHadronIso_DR0p4To0p5,
522	+	Bool_t printDebug) {
523	+
524	+	if (fMVAType != MuonIDMVA::kIsoRingsV0) {
525	+	std::cout << "Error: This function is only supported for MVAType == kIsoRingsV0.\n" << std::endl;
526	+	assert(kFALSE);
527	+	}
528	+
529	+	fMVAVar_MuPt = MuPt;
530	+	fMVAVar_MuEta = MuEta;
531	+	fMVAVar_ChargedIso_DR0p0To0p1 = ChargedIso_DR0p0To0p1;
532	+	fMVAVar_ChargedIso_DR0p1To0p2 = ChargedIso_DR0p1To0p2;
533	+	fMVAVar_ChargedIso_DR0p2To0p3 = ChargedIso_DR0p2To0p3;
534	+	fMVAVar_ChargedIso_DR0p3To0p4 = ChargedIso_DR0p3To0p4;
535	+	fMVAVar_ChargedIso_DR0p4To0p5 = ChargedIso_DR0p4To0p5;
536	+	fMVAVar_GammaIso_DR0p0To0p1 = GammaIso_DR0p0To0p1;
537	+	fMVAVar_GammaIso_DR0p1To0p2 = GammaIso_DR0p1To0p2;
538	+	fMVAVar_GammaIso_DR0p2To0p3 = GammaIso_DR0p2To0p3;
539	+	fMVAVar_GammaIso_DR0p3To0p4 = GammaIso_DR0p3To0p4;
540	+	fMVAVar_GammaIso_DR0p4To0p5 = GammaIso_DR0p4To0p5;
541	+	fMVAVar_NeutralHadronIso_DR0p0To0p1 = NeutralHadronIso_DR0p0To0p1;
542	+	fMVAVar_NeutralHadronIso_DR0p1To0p2 = NeutralHadronIso_DR0p1To0p2;
543	+	fMVAVar_NeutralHadronIso_DR0p2To0p3 = NeutralHadronIso_DR0p2To0p3;
544	+	fMVAVar_NeutralHadronIso_DR0p3To0p4 = NeutralHadronIso_DR0p3To0p4;
545	+	fMVAVar_NeutralHadronIso_DR0p4To0p5 = NeutralHadronIso_DR0p4To0p5;
546	+
547	+	Double_t mva = -9999;
548	+	TMVA::Reader *reader = 0;
549	+
550	+	if (printDebug == kTRUE) {
551	+	std::cout <<" -> BIN: " << fMVAVar_MuEta << " " << fMVAVar_MuPt << " : "
552	+	<< GetMVABin( fMVAVar_MuEta , fMVAVar_MuPt) << std::endl;
553	+	}
554	+	reader = fTMVAReader[GetMVABin( fMVAVar_MuEta , fMVAVar_MuPt)];
555	+	mva = reader->EvaluateMVA( fMethodname );
556	+
557	+	if (printDebug == kTRUE) {
558	+
559	+	std::cout << "Debug Muon MVA: \n";
560	+	std::cout << fMVAVar_ChargedIso_DR0p0To0p1 << " "
561	+	<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
562	+	<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
563	+	<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
564	+	<< fMVAVar_ChargedIso_DR0p4To0p5 << " "
565	+	<< fMVAVar_GammaIso_DR0p0To0p1 << " "
566	+	<< fMVAVar_GammaIso_DR0p1To0p2 << " "
567	+	<< fMVAVar_GammaIso_DR0p2To0p3 << " "
568	+	<< fMVAVar_GammaIso_DR0p3To0p4 << " "
569	+	<< fMVAVar_GammaIso_DR0p4To0p5 << " "
570	+	<< fMVAVar_NeutralHadronIso_DR0p0To0p1 << " "
571	+	<< fMVAVar_NeutralHadronIso_DR0p1To0p2 << " "
572	+	<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " "
573	+	<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
574	+	<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " "
575	+	<< std::endl;
576	+	std::cout << "MVA: " << mva << " "
577	+	<< std::endl;
578	+	}
579	+	return mva;
580	+	}
581	+
582	+
583	+
584	+	Double_t MuonIDMVA::MVAValue_ID( Double_t MuPt,
585	+	Double_t MuEta,
586	+	Bool_t MuIsGlobal,
587	+	Bool_t MuIsTracker,
588	+	Double_t MuTkNchi2,
589	+	Double_t MuGlobalNchi2,
590	+	Double_t MuNValidHits,
591	+	Double_t MuNTrackerHits,
592	+	Double_t MuNPixelHits,
593	+	Double_t MuNMatches,
594	+	Double_t MuTrkKink,
595	+	Double_t MuSegmentCompatibility,
596	+	Double_t MuCaloCompatibility,
597	+	Double_t MuHadEnergy,
598	+	Double_t MuEmEnergy,
599	+	Double_t MuHadS9Energy,
600	+	Double_t MuEmS9Energy,
601	+	Bool_t printDebug) {
602	+
603	+	if (fMVAType != MuonIDMVA::kIDV0) {
604	+	std::cout << "Error: This function is only supported for MVAType == kIDV0.\n" << std::endl;
605	+	assert(kFALSE);
606	+	}
607	+
608	+	fMVAVar_MuPt = MuPt;
609	+	fMVAVar_MuEta = MuEta;
610	+
611	+	fMVAVar_MuTkNchi2 = MuTkNchi2;
612	+	fMVAVar_MuGlobalNchi2 = MuGlobalNchi2;
613	+	fMVAVar_MuNValidHits = MuNValidHits;
614	+	fMVAVar_MuNTrackerHits = MuNTrackerHits;
615	+	fMVAVar_MuNPixelHits = MuNPixelHits;
616	+	fMVAVar_MuNMatches = MuNMatches;
617	+	fMVAVar_MuTrkKink = MuTrkKink;
618	+	fMVAVar_MuSegmentCompatibility = MuSegmentCompatibility;
619	+	fMVAVar_MuCaloCompatibility = MuCaloCompatibility;
620	+	fMVAVar_MuHadEnergy = MuHadEnergy;
621	+	fMVAVar_MuEmEnergy = MuEmEnergy;
622	+	fMVAVar_MuHadS9Energy = MuHadS9Energy;
623	+	fMVAVar_MuEmS9Energy = MuEmS9Energy;
624	+
625	+	Double_t mva = -9999;
626	+	TMVA::Reader *reader = 0;
627	+
628	+	if (printDebug == kTRUE) {
629	+	std::cout <<" -> BIN: " << fMVAVar_MuEta << " " << fMVAVar_MuPt << " : "
630	+	<< GetMVABin( fMVAVar_MuEta , fMVAVar_MuPt, MuIsGlobal, MuIsTracker) << std::endl;
631	+	}
632	+	reader = fTMVAReader[GetMVABin( fMVAVar_MuEta , fMVAVar_MuPt, MuIsGlobal, MuIsTracker)];
633	+	mva = reader->EvaluateMVA( fMethodname );
634	+
635	+	if (printDebug == kTRUE) {
636	+
637	+	std::cout << "Debug Muon MVA: \n";
638	+	std::cout << fMVAVar_MuTkNchi2              << " "
639	+	<< fMVAVar_MuGlobalNchi2          << " "
640	+	<< fMVAVar_MuNValidHits           << " "
641	+	<< fMVAVar_MuNTrackerHits         << " "
642	+	<< fMVAVar_MuNPixelHits           << " "
643	+	<< fMVAVar_MuNMatches             << " "
644	+	<< fMVAVar_MuTrkKink              << " "
645	+	<< fMVAVar_MuSegmentCompatibility << " "
646	+	<< fMVAVar_MuCaloCompatibility    << " "
647	+	<< fMVAVar_MuHadEnergy            << " "
648	+	<< fMVAVar_MuEmEnergy             << " "
649	+	<< fMVAVar_MuHadS9Energy          << " "
650	+	<< fMVAVar_MuEmS9Energy           << " "
651	+	<< std::endl;
652	+	std::cout << "MVA: " << mva << " "
653	+	<< std::endl;
654	+	}
655	+	return mva;
656	+	}
657	+
658	+
659
660		//--------------------------------------------------------------------------------------------------
661		Double_t MuonIDMVA::MVAValue(const Muon *mu, const Vertex *vertex, MuonTools *fMuonTools,
#	Line 425 | Line 689 | Double_t MuonIDMVA::MVAValue(const Muon
689		Double_t Rho = 0;
690		if (!(TMath::IsNaN(PileupEnergyDensity->At(0)->Rho()) || isinf(PileupEnergyDensity->At(0)->Rho()))) Rho = PileupEnergyDensity->At(0)->Rho();
691
692	<	Int_t subdet = 0;
429	<	if (fabs(muTrk->Eta()) < 1.479) subdet = 0;
430	<	else subdet = 1;
431	<	Int_t ptBin = 0;
432	<	if (muTrk->Pt() > 14.5) ptBin = 1;
433	<	if (muTrk->Pt() > 20.0) ptBin = 2;
434	<
692	>
693		//set all input variables
694		fMVAVar_MuTkNchi2              = muTrk->RChi2();
695		fMVAVar_MuGlobalNchi2          = muNchi2;
#	Line 464 | Line 722 | Double_t MuonIDMVA::MVAValue(const Muon
722
723		Double_t mva = -9999;
724		TMVA::Reader *reader = 0;
725	<
468	<	Int_t MVABin = -1;
469	<	if (subdet == 0 && ptBin == 0) MVABin = 0;
470	<	if (subdet == 1 && ptBin == 0) MVABin = 1;
471	<	if (subdet == 0 && ptBin == 1) MVABin = 2;
472	<	if (subdet == 1 && ptBin == 1) MVABin = 3;
473	<	if (subdet == 0 && ptBin == 2) MVABin = 4;
474	<	if (subdet == 1 && ptBin == 2) MVABin = 5;
475	<	assert(MVABin >= 0 && MVABin <= 5);
476	<	reader = fTMVAReader[MVABin];
725	>	reader = fTMVAReader[GetMVABin(muTrk->Eta(), muTrk->Pt(), mu->IsGlobalMuon(), mu->IsTrackerMuon())];
726
727		mva = reader->EvaluateMVA( fMethodname );
728
729		if (printDebug) {
730		std::cout << "Debug Muon MVA: "
731		<< mu->Pt() << " " << mu->Eta() << " " << mu->Phi() << " : "
732	<	<< muTrk->Pt() << " " << muTrk->Eta() << " --> MVABin " << MVABin << " : "
732	>	<< muTrk->Pt() << " " << muTrk->Eta() << " --> MVABin " << GetMVABin(muTrk->Eta(), muTrk->Pt(), mu->IsGlobalMuon(), mu->IsTrackerMuon()) << " : "
733		<< fMVAVar_MuTkNchi2              << " "
734		<< fMVAVar_MuGlobalNchi2          << " "
735		<< fMVAVar_MuNValidHits           << " "
#	Line 514 | Line 763 | Double_t MuonIDMVA::MVAValue(const Muon
763		<< std::endl;
764		}
765
766	+	return mva;
767	+	}
768	+
769	+
770	+	//--------------------------------------------------------------------------------------------------
771	+	Double_t MuonIDMVA::MVAValue(const Muon *mu, const Vertex *vertex, MuonTools *fMuonTools,
772	+	const PFCandidateCol *PFCands,
773	+	const PileupEnergyDensityCol *PileupEnergyDensity,
774	+	MuonTools::EMuonEffectiveAreaTarget EffectiveAreaTarget,
775	+	const ElectronCol *goodElectrons,
776	+	const MuonCol *goodMuons,
777	+	Bool_t printDebug) {
778	+
779	+	if (!fIsInitialized) {
780	+	std::cout << "Error: MuonIDMVA not properly initialized.\n";
781	+	return -9999;
782	+	}
783	+
784	+	const Track *muTrk=0;
785	+	if(mu->HasTrackerTrk())         { muTrk = mu->TrackerTrk();    }
786	+	else if(mu->HasStandaloneTrk()) { muTrk = mu->StandaloneTrk(); }
787	+
788	+	Double_t muNchi2 = 0.0;
789	+	if(mu->HasGlobalTrk())          { muNchi2 = mu->GlobalTrk()->RChi2();     }
790	+	else if(mu->HasStandaloneTrk()) { muNchi2 = mu->StandaloneTrk()->RChi2(); }
791	+	else if(mu->HasTrackerTrk())    { muNchi2 = mu->TrackerTrk()->RChi2();    }
792	+
793	+	Double_t ChargedIso03 = 0;
794	+	Double_t NeutralIso03_05Threshold = 0;
795	+	Double_t ChargedIso04 = 0;
796	+	Double_t NeutralIso04_05Threshold = 0;
797	+	ChargedIso03 = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.1, 99999, 0.3, 0.0, 0.0);
798	+	NeutralIso03_05Threshold = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.0, 0.5, 0.3, 0.0, 0.0);
799	+	ChargedIso04 = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.1, 99999, 0.4, 0.0, 0.0);
800	+	NeutralIso04_05Threshold = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.0, 0.5, 0.4, 0.0, 0.0);
801	+
802	+	Double_t Rho = 0;
803	+	if (!(TMath::IsNaN(PileupEnergyDensity->At(0)->Rho()) || isinf(PileupEnergyDensity->At(0)->Rho()))) Rho = PileupEnergyDensity->At(0)->Rho();
804	+
805	+
806	+	//set all input variables
807	+	fMVAVar_MuPt                   = muTrk->Pt();
808	+	fMVAVar_MuEta                  = muTrk->Eta();
809	+	fMVAVar_MuTkNchi2              = muTrk->RChi2();
810	+	fMVAVar_MuGlobalNchi2          = muNchi2;
811	+	fMVAVar_MuNValidHits           = mu->NValidHits();
812	+	fMVAVar_MuNTrackerHits         = muTrk->NHits();
813	+	fMVAVar_MuNPixelHits           = muTrk->NPixelHits();
814	+	fMVAVar_MuNMatches             = mu->NMatches();
815	+	fMVAVar_MuD0                   = muTrk->D0Corrected(*vertex);
816	+	fMVAVar_MuIP3d                 = mu->Ip3dPV();
817	+	fMVAVar_MuIP3dSig              = mu->Ip3dPVSignificance();
818	+	fMVAVar_MuTrkKink              = mu->TrkKink();
819	+	fMVAVar_MuSegmentCompatibility = fMuonTools->GetSegmentCompatability(mu);
820	+	fMVAVar_MuCaloCompatibility    = fMuonTools->GetCaloCompatability(mu, kTRUE, kTRUE);
821	+	fMVAVar_MuHadEnergy            = mu->HadEnergy() ;
822	+	fMVAVar_MuEmEnergy             = mu->EmEnergy();
823	+	fMVAVar_MuHadS9Energy          = mu->HadS9Energy();
824	+	fMVAVar_MuEmS9Energy           = mu->EmS9Energy();
825	+	fMVAVar_MuChargedIso03OverPt   = (ChargedIso03 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuChargedIso03,muTrk->Eta()))/muTrk->Pt();
826	+	fMVAVar_MuNeutralIso03OverPt   = (NeutralIso03_05Threshold - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso03,muTrk->Eta()))/muTrk->Pt();
827	+	fMVAVar_MuChargedIso04OverPt   = (ChargedIso04 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuChargedIso04,muTrk->Eta()))/muTrk->Pt();
828	+	fMVAVar_MuNeutralIso04OverPt   = (NeutralIso04_05Threshold - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso04,muTrk->Eta()))/muTrk->Pt();
829	+	fMVAVar_MuTrkIso03OverPt       = (mu->IsoR03SumPt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuTrkIso03,muTrk->Eta()))/muTrk->Pt();
830	+	fMVAVar_MuEMIso03OverPt        = (mu->IsoR03EmEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuEMIso03,muTrk->Eta()))/muTrk->Pt();
831	+	fMVAVar_MuHadIso03OverPt       = (mu->IsoR03HadEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadIso03,muTrk->Eta()))/muTrk->Pt();
832	+	fMVAVar_MuTrkIso05OverPt       = (mu->IsoR05SumPt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuTrkIso05,muTrk->Eta()))/muTrk->Pt();
833	+	fMVAVar_MuEMIso05OverPt        = (mu->IsoR05EmEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuEMIso05,muTrk->Eta()))/muTrk->Pt();
834	+	fMVAVar_MuHadIso05OverPt       = (mu->IsoR05HadEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadIso05,muTrk->Eta()))/muTrk->Pt();
835	+
836	+
837	+	Double_t tmpChargedIso_DR0p0To0p1  = 0;
838	+	Double_t tmpChargedIso_DR0p1To0p2  = 0;
839	+	Double_t tmpChargedIso_DR0p2To0p3  = 0;
840	+	Double_t tmpChargedIso_DR0p3To0p4  = 0;
841	+	Double_t tmpChargedIso_DR0p4To0p5  = 0;
842	+	Double_t tmpGammaIso_DR0p0To0p1  = 0;
843	+	Double_t tmpGammaIso_DR0p1To0p2  = 0;
844	+	Double_t tmpGammaIso_DR0p2To0p3  = 0;
845	+	Double_t tmpGammaIso_DR0p3To0p4  = 0;
846	+	Double_t tmpGammaIso_DR0p4To0p5  = 0;
847	+	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
848	+	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
849	+	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
850	+	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
851	+	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
852	+
853	+	Double_t tmpMuDeltaRMean = 0;
854	+	Double_t tmpMuDeltaRSum = 0;
855	+	Double_t tmpMuDensity = 0;
856	+	Double_t tmpMuNPFCand = 0;
857	+
858	+	for (UInt_t p=0; p<PFCands->GetEntries();p++) {
859	+	const PFCandidate *pf = PFCands->At(p);
860	+
861	+	//exclude the muon itself
862	+	if(pf->TrackerTrk() && mu->TrackerTrk() &&
863	+	pf->TrackerTrk() == mu->TrackerTrk()) continue;
864	+
865	+	//************************************************************
866	+	// New Isolation Calculations
867	+	//************************************************************
868	+	Double_t dr = MathUtils::DeltaR(mu->Mom(), pf->Mom());
869	+
870	+	if (dr < 0.5) {
871	+	Bool_t IsLeptonFootprint = kFALSE;
872	+	//************************************************************
873	+	// Lepton Footprint Removal
874	+	//************************************************************
875	+	if(goodElectrons) {
876	+	for (UInt_t q=0; q < goodElectrons->GetEntries() ; ++q) {
877	+	//if pf candidate matches an electron passing ID cuts, then veto it
878	+	if(pf->GsfTrk() && goodElectrons->At(q)->GsfTrk() &&
879	+	pf->GsfTrk() == goodElectrons->At(q)->GsfTrk()) IsLeptonFootprint = kTRUE;
880	+	if(pf->TrackerTrk() && goodElectrons->At(q)->TrackerTrk() &&
881	+	pf->TrackerTrk() == goodElectrons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
882	+	//if pf candidate lies in veto regions of electron passing ID cuts, then veto it
883	+	if(pf->BestTrk() && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479
884	+	&& MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.015) IsLeptonFootprint = kTRUE;
885	+	if(pf->PFType() == PFCandidate::eGamma && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479 &&
886	+	MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.08) IsLeptonFootprint = kTRUE;
887	+	}
888	+	}
889	+	if(goodMuons) {
890	+	for (UInt_t q=0; q < goodMuons->GetEntries() ; ++q) {
891	+	//if pf candidate matches an muon passing ID cuts, then veto it
892	+	if(pf->TrackerTrk() && goodMuons->At(q)->TrackerTrk() &&
893	+	pf->TrackerTrk() == goodMuons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
894	+	//if pf candidate lies in veto regions of muon passing ID cuts, then veto it
895	+	if(pf->BestTrk() && MathUtils::DeltaR(goodMuons->At(q)->Mom(), pf->Mom()) < 0.01) IsLeptonFootprint = kTRUE;
896	+	}
897	+	}
898	+
899	+	if (!IsLeptonFootprint) {
900	+	Bool_t passVeto = kTRUE;
901	+	//Charged
902	+	if(pf->BestTrk()) {
903	+	if (!(fabs(pf->BestTrk()->DzCorrected(*vertex) - mu->BestTrk()->DzCorrected(*vertex)) < 0.2)) passVeto = kFALSE;
904	+	//************************************************************
905	+	// Veto any PFmuon, or PFEle
906	+	if (pf->PFType() == PFCandidate::eElectron || pf->PFType() == PFCandidate::eMuon) passVeto = kFALSE;
907	+	//************************************************************
908	+	//************************************************************
909	+	// Footprint Veto
910	+	if (dr < 0.01) passVeto = kFALSE;
911	+	//************************************************************
912	+	if (passVeto) {
913	+	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
914	+	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
915	+	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
916	+	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
917	+	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
918	+	} //pass veto
919	+	}
920	+	//Gamma
921	+	else if (pf->PFType() == PFCandidate::eGamma) {
922	+	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
923	+	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
924	+	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
925	+	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
926	+	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
927	+	}
928	+	//NeutralHadron
929	+	else {
930	+	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
931	+	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
932	+	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
933	+	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
934	+	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
935	+	}
936	+
937	+	if (dr < 0.5) {
938	+	tmpMuNPFCand++;
939	+	tmpMuDeltaRMean += dr;
940	+	tmpMuDeltaRSum  += dr;
941	+	tmpMuDensity    += pf->Pt() / dr;
942	+	}
943	+	} //not lepton footprint
944	+	} //in 1.0 dr cone
945	+	} //loop over PF candidates
946	+
947	+	//   Double_t fMVAVar_ChargedIso_DR0p0To0p1  = 0;
948	+	//   Double_t fMVAVar_ChargedIso_DR0p1To0p2  = 0;
949	+	//   Double_t fMVAVar_ChargedIso_DR0p2To0p3  = 0;
950	+	//   Double_t fMVAVar_ChargedIso_DR0p3To0p4  = 0;
951	+	//   Double_t fMVAVar_ChargedIso_DR0p4To0p5  = 0;
952	+	//   Double_t fMVAVar_GammaIso_DR0p0To0p1  = 0;
953	+	//   Double_t fMVAVar_GammaIso_DR0p1To0p2  = 0;
954	+	//   Double_t fMVAVar_GammaIso_DR0p2To0p3  = 0;
955	+	//   Double_t fMVAVar_GammaIso_DR0p3To0p4  = 0;
956	+	//   Double_t fMVAVar_GammaIso_DR0p4To0p5  = 0;
957	+	//   Double_t fMVAVar_NeutralHadronIso_DR0p0To0p1  = 0;
958	+	//   Double_t fMVAVar_NeutralHadronIso_DR0p1To0p2  = 0;
959	+	//   Double_t fMVAVar_NeutralHadronIso_DR0p2To0p3  = 0;
960	+	//   Double_t fMVAVar_NeutralHadronIso_DR0p3To0p4  = 0;
961	+	//   Double_t fMVAVar_NeutralHadronIso_DR0p4To0p5  = 0;
962	+
963	+	fMVAVar_ChargedIso_DR0p0To0p1 = TMath::Min((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
964	+	fMVAVar_ChargedIso_DR0p1To0p2 = TMath::Min((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
965	+	fMVAVar_ChargedIso_DR0p2To0p3 = TMath::Min((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
966	+	fMVAVar_ChargedIso_DR0p3To0p4 = TMath::Min((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
967	+	fMVAVar_ChargedIso_DR0p4To0p5 = TMath::Min((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
968	+	fMVAVar_GammaIso_DR0p0To0p1 = TMath::Max(TMath::Min((tmpGammaIso_DR0p0To0p1 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p0To0p1, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
969	+	fMVAVar_GammaIso_DR0p1To0p2 = TMath::Max(TMath::Min((tmpGammaIso_DR0p1To0p2 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p1To0p2, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
970	+	fMVAVar_GammaIso_DR0p2To0p3 = TMath::Max(TMath::Min((tmpGammaIso_DR0p2To0p3 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p2To0p3, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
971	+	fMVAVar_GammaIso_DR0p3To0p4 = TMath::Max(TMath::Min((tmpGammaIso_DR0p3To0p4 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p3To0p4, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
972	+	fMVAVar_GammaIso_DR0p4To0p5 = TMath::Max(TMath::Min((tmpGammaIso_DR0p4To0p5 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p4To0p5, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
973	+	fMVAVar_NeutralHadronIso_DR0p0To0p1 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p0To0p1 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p0To0p1, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
974	+	fMVAVar_NeutralHadronIso_DR0p1To0p2 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p1To0p2 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p1To0p2, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
975	+	fMVAVar_NeutralHadronIso_DR0p2To0p3 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p2To0p3 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p2To0p3, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
976	+	fMVAVar_NeutralHadronIso_DR0p3To0p4 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p3To0p4 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p3To0p4, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
977	+	fMVAVar_NeutralHadronIso_DR0p4To0p5 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p4To0p5 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p4To0p5, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
978	+
979	+	// Variables for dR MVA
980	+	fMVAVar_MuRelIsoPFCharged  = 0.;
981	+	fMVAVar_MuRelIsoPFCharged += TMath::Min((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
982	+	fMVAVar_MuRelIsoPFCharged += TMath::Min((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
983	+	fMVAVar_MuRelIsoPFCharged += TMath::Min((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
984	+	fMVAVar_MuRelIsoPFCharged += TMath::Min((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
985	+	fMVAVar_MuRelIsoPFCharged += TMath::Min((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
986	+
987	+	fMVAVar_MuRelIsoPFNeutral  = 0.;
988	+	fMVAVar_MuRelIsoPFNeutral += TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p0To0p1 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p0To0p1, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
989	+	fMVAVar_MuRelIsoPFNeutral += TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p1To0p2 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p1To0p2, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
990	+	fMVAVar_MuRelIsoPFNeutral += TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p2To0p3 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p2To0p3, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
991	+	fMVAVar_MuRelIsoPFNeutral += TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p3To0p4 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p3To0p4, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
992	+	fMVAVar_MuRelIsoPFNeutral += TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p4To0p5 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p4To0p5, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
993	+
994	+	fMVAVar_MuRelIsoPFPhotons  = 0.;
995	+	fMVAVar_MuRelIsoPFPhotons += TMath::Max(TMath::Min((tmpGammaIso_DR0p0To0p1 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p0To0p1, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
996	+	fMVAVar_MuRelIsoPFPhotons += TMath::Max(TMath::Min((tmpGammaIso_DR0p1To0p2 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p1To0p2, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
997	+	fMVAVar_MuRelIsoPFPhotons += TMath::Max(TMath::Min((tmpGammaIso_DR0p2To0p3 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p2To0p3, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
998	+	fMVAVar_MuRelIsoPFPhotons += TMath::Max(TMath::Min((tmpGammaIso_DR0p3To0p4 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p3To0p4, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
999	+	fMVAVar_MuRelIsoPFPhotons += TMath::Max(TMath::Min((tmpGammaIso_DR0p4To0p5 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p4To0p5, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
1000	+
1001	+	fMVAVar_MuDeltaRMean      = tmpMuDeltaRMean/TMath::Max(1.0,tmpMuNPFCand);
1002	+	fMVAVar_MuDeltaRSum       = tmpMuDeltaRSum;
1003	+	fMVAVar_MuDensity         = tmpMuDensity;
1004	+
1005	+	Double_t mva = -9999;
1006	+	TMVA::Reader *reader = 0;
1007	+
1008	+	if (printDebug) {
1009	+	std::cout <<" -> BIN: " << fMVAVar_MuEta << " " << fMVAVar_MuPt << " : "
1010	+	<< GetMVABin(muTrk->Eta(), muTrk->Pt(), mu->IsGlobalMuon(), mu->IsTrackerMuon() )
1011	+	<< std::endl;
1012	+	}
1013	+
1014	+	reader = fTMVAReader[GetMVABin(muTrk->Eta(), muTrk->Pt(), mu->IsGlobalMuon(), mu->IsTrackerMuon() )];
1015	+
1016	+	mva = reader->EvaluateMVA( fMethodname );
1017	+
1018	+	if (printDebug) {
1019	+	std::cout << "Debug Muon MVA: \n";
1020	+	std::cout << " MuTkNchi2 " << fMVAVar_MuTkNchi2
1021	+	<< " MuGlobalNchi2 " << fMVAVar_MuGlobalNchi2
1022	+	<< " MuNValidHits " << fMVAVar_MuNValidHits
1023	+	<< " MuNTrackerHits " << fMVAVar_MuNTrackerHits
1024	+	<< " MuNPixelHits " << fMVAVar_MuNPixelHits
1025	+	<< " MuNMatches " << fMVAVar_MuNMatches
1026	+	<< " MuD0 " << fMVAVar_MuD0
1027	+	<< " MuIP3d " << fMVAVar_MuIP3d
1028	+	<< " MuIP3dSig " << fMVAVar_MuIP3dSig
1029	+	<< " MuTrkKink " << fMVAVar_MuTrkKink
1030	+	<< " MuSegmentCompatibility " << fMVAVar_MuSegmentCompatibility
1031	+	<< " MuCaloCompatibility " << fMVAVar_MuCaloCompatibility
1032	+	<< " MuHadEnergy " << fMVAVar_MuHadEnergy
1033	+	<< " MuEmEnergy " << fMVAVar_MuEmEnergy
1034	+	<< " MuHadS9Energy " << fMVAVar_MuHadS9Energy
1035	+	<< " MuEmS9Energy " << fMVAVar_MuEmS9Energy
1036	+	<< " eta " << fMVAVar_MuEta
1037	+	<< " pt " << fMVAVar_MuPt
1038	+	<< " isoInfo: ";
1039	+	std::cout << fMVAVar_ChargedIso_DR0p0To0p1 << " "
1040	+	<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
1041	+	<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
1042	+	<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
1043	+	<< fMVAVar_ChargedIso_DR0p4To0p5 << " "
1044	+	<< fMVAVar_GammaIso_DR0p0To0p1 << " "
1045	+	<< fMVAVar_GammaIso_DR0p1To0p2 << " "
1046	+	<< fMVAVar_GammaIso_DR0p2To0p3 << " "
1047	+	<< fMVAVar_GammaIso_DR0p3To0p4 << " "
1048	+	<< fMVAVar_GammaIso_DR0p4To0p5 << " "
1049	+	<< fMVAVar_NeutralHadronIso_DR0p0To0p1 << " "
1050	+	<< fMVAVar_NeutralHadronIso_DR0p1To0p2 << " "
1051	+	<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " "
1052	+	<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
1053	+	<< fMVAVar_NeutralHadronIso_DR0p4To0p5;
1054	+	std::cout << " MuRelIsoPFCharged: " << fMVAVar_MuRelIsoPFCharged
1055	+	<< " MuRelIsoPFNeutral: " << fMVAVar_MuRelIsoPFNeutral
1056	+	<< " MuRelIsoPFPhotons: " << fMVAVar_MuRelIsoPFPhotons
1057	+	<< " MuDeltaRMean: "      << fMVAVar_MuDeltaRMean
1058	+	<< " MuDeltaRMean: "      << fMVAVar_MuDeltaRMean
1059	+	<< " MuDensity: "         << fMVAVar_MuDensity;
1060	+	std::cout << " MVA: " << mva
1061	+	<< std::endl;
1062	+	}
1063	+
1064		return mva;
1065		}

Diff Legend

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