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.16 by anlevin, Sat May 12 00:05:30 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	>	fTheRhoType(RhoUtilities::DEFAULT)
23		{
20	–	// Constructor.
21	–	for(UInt_t i=0; i<6; ++i) {
22	–	fTMVAReader[i] = 0;
23	–	}
24		}
25
26
27		//--------------------------------------------------------------------------------------------------
28		MuonIDMVA::~MuonIDMVA()
29		{
30	<	for(UInt_t i=0; i<6; ++i) {
30	>	for(UInt_t i=0; i<fTMVAReader.size(); ++i) {
31		if (fTMVAReader[i]) delete fTMVAReader[i];
32		}
33		}
34
35		//--------------------------------------------------------------------------------------------------
36	+	void MuonIDMVA::Initialize( std::string methodName,
37	+	std::string weightsfile,
38	+	MuonIDMVA::MVAType type,
39	+	RhoUtilities::RhoType theRhoType)
40	+	{
41	+
42	+	std::vector<std::string> tempWeightFileVector;
43	+	tempWeightFileVector.push_back(weightsfile);
44	+	Initialize(methodName,type,kFALSE,tempWeightFileVector,theRhoType);
45	+	}
46	+
47	+	//--------------------------------------------------------------------------------------------------
48		void MuonIDMVA::Initialize( TString methodName,
49	<	TString Subdet0Pt10To14p5Weights ,
50	<	TString Subdet1Pt10To14p5Weights ,
51	<	TString Subdet0Pt14p5To20Weights,
52	<	TString Subdet1Pt14p5To20Weights,
53	<	TString Subdet0Pt20ToInfWeights,
54	<	TString Subdet1Pt20ToInfWeights,
55	<	MuonIDMVA::MVAType type) {
49	>	TString Subdet0Pt10To20Weights ,
50	>	TString Subdet1Pt10To20Weights ,
51	>	TString Subdet2Pt10To20Weights,
52	>	TString Subdet0Pt20ToInfWeights,
53	>	TString Subdet1Pt20ToInfWeights,
54	>	TString Subdet2Pt20ToInfWeights,
55	>	MuonIDMVA::MVAType type,
56	>	RhoUtilities::RhoType theRhoType) {
57	>
58	>	std::vector<std::string> tempWeightFileVector;
59	>	tempWeightFileVector.push_back(std::string(Subdet0Pt10To20Weights.Data()));
60	>	tempWeightFileVector.push_back(std::string(Subdet1Pt10To20Weights.Data()));
61	>	tempWeightFileVector.push_back(std::string(Subdet2Pt10To20Weights.Data()));
62	>	tempWeightFileVector.push_back(std::string(Subdet0Pt20ToInfWeights.Data()));
63	>	tempWeightFileVector.push_back(std::string(Subdet1Pt20ToInfWeights.Data()));
64	>	tempWeightFileVector.push_back(std::string(Subdet2Pt20ToInfWeights.Data()));
65	>	Initialize(std::string(methodName.Data()),type,kTRUE,tempWeightFileVector,theRhoType);
66	>
67	>	}
68	>
69	>
70	>	//--------------------------------------------------------------------------------------------------
71	>	void MuonIDMVA::Initialize( std::string methodName,
72	>	MuonIDMVA::MVAType type,
73	>	Bool_t useBinnedVersion,
74	>	std::vector<std::string> weightsfiles,
75	>	RhoUtilities::RhoType theRhoType) {
76
77	+	//clean up first
78	+	for (uint i=0;i<fTMVAReader.size(); ++i) {
79	+	if (fTMVAReader[i]) delete fTMVAReader[i];
80	+	}
81	+	fTMVAReader.clear();
82	+
83	+
84	+	//initialize
85		fIsInitialized = kTRUE;
46	–
86		fMethodname = methodName;
87	<
88	<	for(UInt_t i=0; i<6; ++i) {
89	<	if (fTMVAReader[i]) delete fTMVAReader[i];
87	>	fMVAType = type;
88	>	fUseBinnedVersion = useBinnedVersion;
89	>	fTheRhoType = theRhoType;
90	>
91	>	//Define expected number of bins
92	>	UInt_t ExpectedNBins = 0;
93	>	if (!fUseBinnedVersion) {
94	>	ExpectedNBins = 1;
95	>	} else if    (type == kV2
96	>	|| type == kV3
97	>	|| type == kV8
98	>	|| type == kIDIsoCombinedDetIso
99	>	|| type == kIsoRingsV0
100	>	|| type == kIDV0
101	>	|| type == kIDIsoCombinedIsoRingsV0
102	>	) {
103	>	ExpectedNBins = 6;
104	>	} else if (type == kIsoDeltaR){
105	>	ExpectedNBins = 4;
106	>	}
107	>
108	>	fNMVABins = ExpectedNBins;
109	>
110	>	//Check number of weight files given
111	>	if (fNMVABins != weightsfiles.size() ) {
112	>	std::cout << "Error: Expected Number of bins = " << fNMVABins << " does not equal to weightsfiles.size() = "
113	>	<< weightsfiles.size() << std::endl;
114	>	assert(fNMVABins == weightsfiles.size());
115	>	}
116
117	<	fTMVAReader[i] = new TMVA::Reader( "!Color:!Silent:Error" );
118	<	fTMVAReader[i]->SetVerbose(kTRUE);
117	>	for(UInt_t i=0; i<fNMVABins; ++i) {
118	>	TMVA::Reader *tmpTMVAReader = new TMVA::Reader( "!Color:!Silent:Error" );
119	>	tmpTMVAReader->SetVerbose(kTRUE);
120
121		if (type == kV2) {
122	<	fTMVAReader[i]->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
123	<	fTMVAReader[i]->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
124	<	fTMVAReader[i]->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
125	<	fTMVAReader[i]->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
126	<	fTMVAReader[i]->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
127	<	fTMVAReader[i]->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
128	<	fTMVAReader[i]->AddVariable( "D0",                   &fMVAVar_MuD0                    );
129	<	fTMVAReader[i]->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );
130	<	fTMVAReader[i]->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );
131	<	fTMVAReader[i]->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
132	<	fTMVAReader[i]->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
122	>	tmpTMVAReader->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
123	>	tmpTMVAReader->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
124	>	tmpTMVAReader->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
125	>	tmpTMVAReader->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
126	>	tmpTMVAReader->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
127	>	tmpTMVAReader->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
128	>	tmpTMVAReader->AddVariable( "D0",                   &fMVAVar_MuD0                    );
129	>	tmpTMVAReader->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );
130	>	tmpTMVAReader->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );
131	>	tmpTMVAReader->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
132	>	tmpTMVAReader->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
133		}
134
135		if (type == kV3) {
136	<	fTMVAReader[i]->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
137	<	fTMVAReader[i]->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
138	<	fTMVAReader[i]->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
139	<	fTMVAReader[i]->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
140	<	fTMVAReader[i]->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
141	<	fTMVAReader[i]->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
142	<	fTMVAReader[i]->AddVariable( "D0",                   &fMVAVar_MuD0                    );
143	<	fTMVAReader[i]->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );
144	<	fTMVAReader[i]->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );
145	<	fTMVAReader[i]->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
146	<	fTMVAReader[i]->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
147	<	fTMVAReader[i]->AddVariable( "CaloCompatibility",    &fMVAVar_MuCaloCompatibility     );
148	<	fTMVAReader[i]->AddVariable( "HadEnergyOverPt",      &fMVAVar_MuHadEnergyOverPt       );
136	>	tmpTMVAReader->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
137	>	tmpTMVAReader->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
138	>	tmpTMVAReader->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
139	>	tmpTMVAReader->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
140	>	tmpTMVAReader->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
141	>	tmpTMVAReader->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
142	>	tmpTMVAReader->AddVariable( "D0",                   &fMVAVar_MuD0                    );
143	>	tmpTMVAReader->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );
144	>	tmpTMVAReader->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );
145	>	tmpTMVAReader->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
146	>	tmpTMVAReader->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
147	>	tmpTMVAReader->AddVariable( "CaloCompatibility",    &fMVAVar_MuCaloCompatibility     );
148	>	tmpTMVAReader->AddVariable( "HadEnergyOverPt",      &fMVAVar_MuHadEnergyOverPt       );
149		if (i==0 || i==2 || i==4) {
150	<	fTMVAReader[i]->AddVariable( "HoEnergyOverPt",     &fMVAVar_MuHoEnergyOverPt        );
150	>	tmpTMVAReader->AddVariable( "HoEnergyOverPt",     &fMVAVar_MuHoEnergyOverPt        );
151		}
152	<	fTMVAReader[i]->AddVariable( "EmEnergyOverPt",       &fMVAVar_MuEmEnergyOverPt        );
153	<	fTMVAReader[i]->AddVariable( "HadS9EnergyOverPt",    &fMVAVar_MuHadS9EnergyOverPt     );
152	>	tmpTMVAReader->AddVariable( "EmEnergyOverPt",       &fMVAVar_MuEmEnergyOverPt        );
153	>	tmpTMVAReader->AddVariable( "HadS9EnergyOverPt",    &fMVAVar_MuHadS9EnergyOverPt     );
154		if (i==0 || i==2 || i==4) {
155	<	fTMVAReader[i]->AddVariable( "HoS9EnergyOverPt",   &fMVAVar_MuHoS9EnergyOverPt      );
155	>	tmpTMVAReader->AddVariable( "HoS9EnergyOverPt",   &fMVAVar_MuHoS9EnergyOverPt      );
156		}
157	<	fTMVAReader[i]->AddVariable( "EmS9EnergyOverPt",     &fMVAVar_MuEmS9EnergyOverPt      );
157	>	tmpTMVAReader->AddVariable( "EmS9EnergyOverPt",     &fMVAVar_MuEmS9EnergyOverPt      );
158		}
159
160		if (type == kV8) {
161	<	fTMVAReader[i]->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
162	<	fTMVAReader[i]->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
163	<	fTMVAReader[i]->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
164	<	fTMVAReader[i]->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
165	<	fTMVAReader[i]->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
166	<	fTMVAReader[i]->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
167	<	fTMVAReader[i]->AddVariable( "D0",                   &fMVAVar_MuD0                    );
168	<	fTMVAReader[i]->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );
169	<	fTMVAReader[i]->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );
170	<	fTMVAReader[i]->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
171	<	fTMVAReader[i]->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
172	<	fTMVAReader[i]->AddVariable( "CaloCompatibility",    &fMVAVar_MuCaloCompatibility     );
173	<	fTMVAReader[i]->AddVariable( "HadEnergyOverPt",      &fMVAVar_MuHadEnergyOverPt       );
174	<	fTMVAReader[i]->AddVariable( "EmEnergyOverPt",       &fMVAVar_MuEmEnergyOverPt        );
175	<	fTMVAReader[i]->AddVariable( "HadS9EnergyOverPt",    &fMVAVar_MuHadS9EnergyOverPt     );
176	<	fTMVAReader[i]->AddVariable( "EmS9EnergyOverPt",     &fMVAVar_MuEmS9EnergyOverPt      );
177	<	fTMVAReader[i]->AddVariable( "ChargedIso03OverPt",   &fMVAVar_MuChargedIso03OverPt    );
178	<	fTMVAReader[i]->AddVariable( "NeutralIso03OverPt",   &fMVAVar_MuNeutralIso03OverPt    );
179	<	fTMVAReader[i]->AddVariable( "ChargedIso04OverPt",   &fMVAVar_MuChargedIso04OverPt    );
180	<	fTMVAReader[i]->AddVariable( "NeutralIso04OverPt",   &fMVAVar_MuNeutralIso04OverPt    );
161	>	tmpTMVAReader->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
162	>	tmpTMVAReader->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
163	>	tmpTMVAReader->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
164	>	tmpTMVAReader->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
165	>	tmpTMVAReader->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
166	>	tmpTMVAReader->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
167	>	tmpTMVAReader->AddVariable( "D0",                   &fMVAVar_MuD0                    );
168	>	tmpTMVAReader->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );
169	>	tmpTMVAReader->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );
170	>	tmpTMVAReader->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
171	>	tmpTMVAReader->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
172	>	tmpTMVAReader->AddVariable( "CaloCompatibility",    &fMVAVar_MuCaloCompatibility     );
173	>	tmpTMVAReader->AddVariable( "HadEnergyOverPt",      &fMVAVar_MuHadEnergyOverPt       );
174	>	tmpTMVAReader->AddVariable( "EmEnergyOverPt",       &fMVAVar_MuEmEnergyOverPt        );
175	>	tmpTMVAReader->AddVariable( "HadS9EnergyOverPt",    &fMVAVar_MuHadS9EnergyOverPt     );
176	>	tmpTMVAReader->AddVariable( "EmS9EnergyOverPt",     &fMVAVar_MuEmS9EnergyOverPt      );
177	>	tmpTMVAReader->AddVariable( "ChargedIso03OverPt",   &fMVAVar_MuChargedIso03OverPt    );
178	>	tmpTMVAReader->AddVariable( "NeutralIso03OverPt",   &fMVAVar_MuNeutralIso03OverPt    );
179	>	tmpTMVAReader->AddVariable( "ChargedIso04OverPt",   &fMVAVar_MuChargedIso04OverPt    );
180	>	tmpTMVAReader->AddVariable( "NeutralIso04OverPt",   &fMVAVar_MuNeutralIso04OverPt    );
181		}
182
183	<	if (i==0) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt10To14p5Weights );
184	<	if (i==1) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt10To14p5Weights );
185	<	if (i==2) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt14p5To20Weights );
186	<	if (i==3) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt14p5To20Weights );
187	<	if (i==4) fTMVAReader[i]->BookMVA(fMethodname , Subdet0Pt20ToInfWeights  );
188	<	if (i==5) fTMVAReader[i]->BookMVA(fMethodname , Subdet1Pt20ToInfWeights  );
183	>	if (type == kIDIsoCombinedDetIso) {
184	>	tmpTMVAReader->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
185	>	tmpTMVAReader->AddVariable( "GlobalNchi2",          &fMVAVar_MuGlobalNchi2           );
186	>	tmpTMVAReader->AddVariable( "NValidHits",           &fMVAVar_MuNValidHits            );
187	>	tmpTMVAReader->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
188	>	tmpTMVAReader->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
189	>	tmpTMVAReader->AddVariable( "NMatches",             &fMVAVar_MuNMatches              );
190	>	tmpTMVAReader->AddVariable( "D0",                   &fMVAVar_MuD0                    );
191	>	tmpTMVAReader->AddVariable( "IP3d",                 &fMVAVar_MuIP3d                  );
192	>	tmpTMVAReader->AddVariable( "IP3dSig",              &fMVAVar_MuIP3dSig               );
193	>	tmpTMVAReader->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
194	>	tmpTMVAReader->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
195	>	tmpTMVAReader->AddVariable( "CaloCompatibility",    &fMVAVar_MuCaloCompatibility     );
196	>	tmpTMVAReader->AddVariable( "HadEnergyOverPt",      &fMVAVar_MuHadEnergyOverPt       );
197	>	tmpTMVAReader->AddVariable( "EmEnergyOverPt",       &fMVAVar_MuEmEnergyOverPt        );
198	>	tmpTMVAReader->AddVariable( "HadS9EnergyOverPt",    &fMVAVar_MuHadS9EnergyOverPt     );
199	>	tmpTMVAReader->AddVariable( "EmS9EnergyOverPt",     &fMVAVar_MuEmS9EnergyOverPt      );
200	>	tmpTMVAReader->AddVariable( "TrkIso03OverPt",       &fMVAVar_MuTrkIso03OverPt        );
201	>	tmpTMVAReader->AddVariable( "EMIso03OverPt",        &fMVAVar_MuEMIso03OverPt         );
202	>	tmpTMVAReader->AddVariable( "HadIso03OverPt",       &fMVAVar_MuHadIso03OverPt        );
203	>	tmpTMVAReader->AddVariable( "TrkIso05OverPt",       &fMVAVar_MuTrkIso05OverPt        );
204	>	tmpTMVAReader->AddVariable( "EMIso05OverPt",        &fMVAVar_MuEMIso05OverPt         );
205	>	tmpTMVAReader->AddVariable( "HadIso05OverPt",       &fMVAVar_MuHadIso05OverPt        );
206	>	}
207	>
208	>	if (type == kIDV0) {
209	>	tmpTMVAReader->AddVariable( "TkNchi2",              &fMVAVar_MuTkNchi2               );
210	>	if (i!=4) tmpTMVAReader->AddVariable( "GlobalNchi2",&fMVAVar_MuGlobalNchi2           );
211	>	if (i!=4) tmpTMVAReader->AddVariable( "NValidHits", &fMVAVar_MuNValidHits            );
212	>	tmpTMVAReader->AddVariable( "NTrackerHits",         &fMVAVar_MuNTrackerHits          );
213	>	tmpTMVAReader->AddVariable( "NPixelHits",           &fMVAVar_MuNPixelHits            );
214	>	if (i!=5) tmpTMVAReader->AddVariable( "NMatches",   &fMVAVar_MuNMatches              );
215	>	tmpTMVAReader->AddVariable( "TrkKink",              &fMVAVar_MuTrkKink               );
216	>	tmpTMVAReader->AddVariable( "SegmentCompatibility", &fMVAVar_MuSegmentCompatibility  );
217	>	tmpTMVAReader->AddVariable( "CaloCompatibility",    &fMVAVar_MuCaloCompatibility     );
218	>	tmpTMVAReader->AddVariable( "HadEnergy",            &fMVAVar_MuHadEnergy             );
219	>	tmpTMVAReader->AddVariable( "EmEnergy",             &fMVAVar_MuEmEnergy              );
220	>	tmpTMVAReader->AddVariable( "HadS9Energy",          &fMVAVar_MuHadS9Energy           );
221	>	tmpTMVAReader->AddVariable( "EmS9Energy",           &fMVAVar_MuEmS9Energy            );
222	>	}
223	>
224	>	if (type == kIsoRingsV0) {
225	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p0To0p1",         &fMVAVar_ChargedIso_DR0p0To0p1        );
226	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p1To0p2",         &fMVAVar_ChargedIso_DR0p1To0p2        );
227	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p2To0p3",         &fMVAVar_ChargedIso_DR0p2To0p3        );
228	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p3To0p4",         &fMVAVar_ChargedIso_DR0p3To0p4        );
229	>	tmpTMVAReader->AddVariable( "ChargedIso_DR0p4To0p5",         &fMVAVar_ChargedIso_DR0p4To0p5        );
230	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p0To0p1",           &fMVAVar_GammaIso_DR0p0To0p1          );
231	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p1To0p2",           &fMVAVar_GammaIso_DR0p1To0p2          );
232	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p2To0p3",           &fMVAVar_GammaIso_DR0p2To0p3          );
233	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p3To0p4",           &fMVAVar_GammaIso_DR0p3To0p4          );
234	>	tmpTMVAReader->AddVariable( "GammaIso_DR0p4To0p5",           &fMVAVar_GammaIso_DR0p4To0p5          );
235	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p0To0p1",   &fMVAVar_NeutralHadronIso_DR0p0To0p1  );
236	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p1To0p2",   &fMVAVar_NeutralHadronIso_DR0p1To0p2  );
237	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p2To0p3",   &fMVAVar_NeutralHadronIso_DR0p2To0p3  );
238	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p3To0p4",   &fMVAVar_NeutralHadronIso_DR0p3To0p4  );
239	>	tmpTMVAReader->AddVariable( "NeutralHadronIso_DR0p4To0p5",   &fMVAVar_NeutralHadronIso_DR0p4To0p5  );
240	>	}
241	>
242	>	if (type == kIsoDeltaR) {
243	>	tmpTMVAReader->AddVariable("PFCharged",                     &fMVAVar_MuRelIsoPFCharged       );
244	>	tmpTMVAReader->AddVariable("PFNeutral",                     &fMVAVar_MuRelIsoPFNeutral       );
245	>	tmpTMVAReader->AddVariable("PFPhotons",                     &fMVAVar_MuRelIsoPFPhotons       );
246	>	tmpTMVAReader->AddVariable("SumDeltaR",                     &fMVAVar_MuDeltaRSum             );
247	>	tmpTMVAReader->AddVariable("DeltaRMean",                    &fMVAVar_MuDeltaRMean            );
248	>	tmpTMVAReader->AddVariable("Density",                       &fMVAVar_MuDensity               );
249	>	}
250	>
251	>	tmpTMVAReader->BookMVA(fMethodname , weightsfiles[i] );
252	>	std::cout << "MVABin " << i << " : MethodName = " << fMethodname
253	>	<< " , type == " << type << " , "
254	>	<< "Load weights file : " << weightsfiles[i]
255	>	<< std::endl;
256	>	fTMVAReader.push_back(tmpTMVAReader);
257
258		}
259	+	std::cout << "Muon ID MVA Completed\n";
260	+	}
261	+
262	+	//--------------------------------------------------------------------------------------------------
263	+	UInt_t MuonIDMVA::GetMVABin( double eta, double pt,
264	+	Bool_t isGlobal, Bool_t isTrackerMuon) const {
265	+
266	+	//Default is to return the first bin
267	+	uint bin = 0;
268	+
269	+	//return the first bin if not using binned version
270	+	if (!fUseBinnedVersion) return 0;
271
272	<	std::cout << "Muon ID MVA Initialization\n";
273	<	std::cout << "MethodName : " << fMethodname << " , type == " << type << std::endl;
274	<	std::cout << "Load weights file : " << Subdet0Pt10To14p5Weights << std::endl;
275	<	std::cout << "Load weights file : " << Subdet1Pt10To14p5Weights << std::endl;
276	<	std::cout << "Load weights file : " << Subdet0Pt14p5To20Weights << std::endl;
277	<	std::cout << "Load weights file : " << Subdet1Pt14p5To20Weights << std::endl;
278	<	std::cout << "Load weights file : " << Subdet0Pt20ToInfWeights << std::endl;
279	<	std::cout << "Load weights file : " << Subdet1Pt20ToInfWeights << std::endl;
272	>	if (fMVAType == MuonIDMVA::kV2
273	>	|| fMVAType == MuonIDMVA::kV3
274	>	|| fMVAType == MuonIDMVA::kV8
275	>	|| fMVAType == MuonIDMVA::kIDIsoCombinedDetIso) {
276	>	if (pt < 14.5 && fabs(eta) < 1.5) bin = 0;
277	>	if (pt < 14.5 && fabs(eta) >= 1.5) bin = 1;
278	>	if (pt >= 14.5 && pt < 20 && fabs(eta) < 1.5) bin = 2;
279	>	if (pt >= 14.5 && pt < 20 && fabs(eta) >= 1.5) bin = 3;
280	>	if (pt >= 20 && fabs(eta) < 1.5) bin = 4;
281	>	if (pt >= 20 && fabs(eta) >= 1.5) bin = 5;
282	>	}
283	>
284	>	if (fMVAType == MuonIDMVA::kIsoRingsV0 || fMVAType == MuonIDMVA::kIDV0
285	>	|| fMVAType == MuonIDMVA::kIDIsoCombinedIsoRingsV0) {
286	>	if (isGlobal && isTrackerMuon) {
287	>	if (pt < 10 && fabs(eta) < 1.479) bin = 0;
288	>	if (pt >= 10 && fabs(eta) < 1.479) bin = 1;
289	>	if (pt < 10 && fabs(eta) >= 1.479) bin = 2;
290	>	if (pt >= 10 && fabs(eta) >= 1.479) bin = 3;
291	>	} else if (!isGlobal && isTrackerMuon) {
292	>	bin = 4;
293	>	} else if (isGlobal && !isTrackerMuon) {
294	>	bin = 5;
295	>	} else {
296	>	std::cout << "Warning: Muon is not a tracker muon. Such muons are not supported. \n";
297	>	bin = 0;
298	>	}
299	>	}
300
301	+	if (fMVAType == MuonIDMVA::kIsoDeltaR){
302	+	if (pt <  20 && fabs(eta) <  1.479) bin = 0;
303	+	if (pt <  20 && fabs(eta) >= 1.479) bin = 1;
304	+	if (pt >= 20 && fabs(eta) <  1.479) bin = 2;
305	+	if (pt >= 20 && fabs(eta) >= 1.479) bin = 3;
306	+	}
307	+
308	+	return bin;
309		}
310
311		//--------------------------------------------------------------------------------------------------
#	Line 157 | Line 331 | Double_t MuonIDMVA::MVAValue(Double_t Mu
331		Double_t                   MuChargedIso03OverPt,
332		Double_t                   MuNeutralIso03OverPt,
333		Double_t                   MuChargedIso04OverPt,
334	<	Double_t                   MuNeutralIso04OverPt
334	>	Double_t                   MuNeutralIso04OverPt,
335	>	Bool_t                     printDebug
336		) {
337
338		if (!fIsInitialized) {
#	Line 165 | Line 340 | Double_t MuonIDMVA::MVAValue(Double_t Mu
340		return -9999;
341		}
342
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	–
343
344		//set all input variables
345		fMVAVar_MuTkNchi2              = MuTkNchi2;
#	Line 199 | Line 367 | Double_t MuonIDMVA::MVAValue(Double_t Mu
367
368		Double_t mva = -9999;
369		TMVA::Reader *reader = 0;
370	<
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];
370	>	reader = fTMVAReader[GetMVABin(MuEta, MuPt, kTRUE, kTRUE )];
371
372		mva = reader->EvaluateMVA( fMethodname );
373
374	<	Bool_t printdebug = kTRUE;
216	<	if (printdebug == kTRUE) {
374	>	if (printDebug) {
375		std::cout << "Debug Muon MVA: "
376	<	<< MuPt << " " << MuEta << " --> MVABin " << MVABin << " : "
376	>	<< MuPt << " " << MuEta << " --> MVABin " << GetMVABin(MuEta, MuPt, kTRUE, kTRUE ) << " : "
377		<< fMVAVar_MuTkNchi2              << " "
378		<< fMVAVar_MuGlobalNchi2          << " "
379		<< fMVAVar_MuNValidHits           << " "
#	Line 247 | Line 405 | Double_t MuonIDMVA::MVAValue(Double_t Mu
405		}
406
407
408	+	//--------------------------------------------------------------------------------------------------
409	+	Double_t MuonIDMVA::MVAValue(Double_t MuPt , Double_t MuEta,
410	+	Double_t                   MuTkNchi2,
411	+	Double_t                   MuGlobalNchi2,
412	+	Double_t                   MuNValidHits,
413	+	Double_t                   MuNTrackerHits,
414	+	Double_t                   MuNPixelHits,
415	+	Double_t                   MuNMatches,
416	+	Double_t                   MuD0,
417	+	Double_t                   MuIP3d,
418	+	Double_t                   MuIP3dSig,
419	+	Double_t                   MuTrkKink,
420	+	Double_t                   MuSegmentCompatibility,
421	+	Double_t                   MuCaloCompatibility,
422	+	Double_t                   MuHadEnergyOverPt,
423	+	Double_t                   MuHoEnergyOverPt,
424	+	Double_t                   MuEmEnergyOverPt,
425	+	Double_t                   MuHadS9EnergyOverPt,
426	+	Double_t                   MuHoS9EnergyOverPt,
427	+	Double_t                   MuEmS9EnergyOverPt,
428	+	Double_t                   MuTrkIso03OverPt,
429	+	Double_t                   MuEMIso03OverPt,
430	+	Double_t                   MuHadIso03OverPt,
431	+	Double_t                   MuTrkIso05OverPt,
432	+	Double_t                   MuEMIso05OverPt,
433	+	Double_t                   MuHadIso05OverPt,
434	+	Bool_t                     printDebug
435	+	) {
436	+
437	+	if (!fIsInitialized) {
438	+	std::cout << "Error: MuonIDMVA not properly initialized.\n";
439	+	return -9999;
440	+	}
441	+
442	+	//set all input variables
443	+	fMVAVar_MuTkNchi2              = MuTkNchi2;
444	+	fMVAVar_MuGlobalNchi2          = MuGlobalNchi2;
445	+	fMVAVar_MuNValidHits           = MuNValidHits;
446	+	fMVAVar_MuNTrackerHits         = MuNTrackerHits;
447	+	fMVAVar_MuNPixelHits           = MuNPixelHits;
448	+	fMVAVar_MuNMatches             = MuNMatches;
449	+	fMVAVar_MuD0                   = MuD0;
450	+	fMVAVar_MuIP3d                 = MuIP3d;
451	+	fMVAVar_MuIP3dSig              = MuIP3dSig;
452	+	fMVAVar_MuTrkKink              = MuTrkKink;
453	+	fMVAVar_MuSegmentCompatibility = MuSegmentCompatibility;
454	+	fMVAVar_MuCaloCompatibility    = MuCaloCompatibility;
455	+	fMVAVar_MuHadEnergyOverPt      = MuHadEnergyOverPt;
456	+	fMVAVar_MuHoEnergyOverPt       = MuHoEnergyOverPt;
457	+	fMVAVar_MuEmEnergyOverPt       = MuEmEnergyOverPt;
458	+	fMVAVar_MuHadS9EnergyOverPt    = MuHadS9EnergyOverPt;
459	+	fMVAVar_MuHoS9EnergyOverPt     = MuHoS9EnergyOverPt;
460	+	fMVAVar_MuEmS9EnergyOverPt     = MuEmS9EnergyOverPt;
461	+	fMVAVar_MuTrkIso03OverPt       = MuTrkIso03OverPt;
462	+	fMVAVar_MuEMIso03OverPt        = MuEMIso03OverPt;
463	+	fMVAVar_MuHadIso03OverPt       = MuHadIso03OverPt;
464	+	fMVAVar_MuTrkIso05OverPt       = MuTrkIso05OverPt;
465	+	fMVAVar_MuEMIso05OverPt        = MuEMIso05OverPt;
466	+	fMVAVar_MuHadIso05OverPt       = MuHadIso05OverPt;
467	+
468	+	Double_t mva = -9999;
469	+	TMVA::Reader *reader = 0;
470	+	reader = fTMVAReader[GetMVABin(MuEta, MuPt, kTRUE, kTRUE )];
471	+
472	+	mva = reader->EvaluateMVA( fMethodname );
473	+
474	+	if (printDebug) {
475	+	std::cout << "Debug Muon MVA: "
476	+	<< MuPt << " " << MuEta << " --> MVABin " << GetMVABin(MuEta, MuPt, kTRUE, kTRUE ) << " : "
477	+	<< fMVAVar_MuTkNchi2              << " "
478	+	<< fMVAVar_MuGlobalNchi2          << " "
479	+	<< fMVAVar_MuNValidHits           << " "
480	+	<< fMVAVar_MuNTrackerHits         << " "
481	+	<< fMVAVar_MuNPixelHits           << " "
482	+	<< fMVAVar_MuNMatches             << " "
483	+	<< fMVAVar_MuD0                   << " "
484	+	<< fMVAVar_MuIP3d                 << " "
485	+	<< fMVAVar_MuIP3dSig              << " "
486	+	<< fMVAVar_MuTrkKink              << " "
487	+	<< fMVAVar_MuSegmentCompatibility << " "
488	+	<< fMVAVar_MuCaloCompatibility    << " "
489	+	<< fMVAVar_MuHadEnergyOverPt      << " "
490	+	<< fMVAVar_MuHoEnergyOverPt       << " "
491	+	<< fMVAVar_MuEmEnergyOverPt       << " "
492	+	<< fMVAVar_MuHadS9EnergyOverPt    << " "
493	+	<< fMVAVar_MuHoS9EnergyOverPt     << " "
494	+	<< fMVAVar_MuEmS9EnergyOverPt     << " "
495	+	<< fMVAVar_MuTrkIso03OverPt   << " "
496	+	<< fMVAVar_MuEMIso03OverPt   << " "
497	+	<< fMVAVar_MuHadIso03OverPt   << " "
498	+	<< fMVAVar_MuTrkIso05OverPt   << " "
499	+	<< fMVAVar_MuEMIso05OverPt   << " "
500	+	<< fMVAVar_MuHadIso05OverPt   << " "
501	+	<< " === : === "
502	+	<< mva
503	+	<< std::endl;
504	+	}
505	+
506	+	return mva;
507	+	}
508	+
509	+
510	+	Double_t MuonIDMVA::MVAValue_IsoRings( Double_t MuPt,
511	+	Double_t MuEta,
512	+	Bool_t MuIsGlobal,
513	+	Bool_t MuIsTracker,
514	+	Double_t ChargedIso_DR0p0To0p1,
515	+	Double_t ChargedIso_DR0p1To0p2,
516	+	Double_t ChargedIso_DR0p2To0p3,
517	+	Double_t ChargedIso_DR0p3To0p4,
518	+	Double_t ChargedIso_DR0p4To0p5,
519	+	Double_t GammaIso_DR0p0To0p1,
520	+	Double_t GammaIso_DR0p1To0p2,
521	+	Double_t GammaIso_DR0p2To0p3,
522	+	Double_t GammaIso_DR0p3To0p4,
523	+	Double_t GammaIso_DR0p4To0p5,
524	+	Double_t NeutralHadronIso_DR0p0To0p1,
525	+	Double_t NeutralHadronIso_DR0p1To0p2,
526	+	Double_t NeutralHadronIso_DR0p2To0p3,
527	+	Double_t NeutralHadronIso_DR0p3To0p4,
528	+	Double_t NeutralHadronIso_DR0p4To0p5,
529	+	Bool_t printDebug) {
530	+
531	+	if (fMVAType != MuonIDMVA::kIsoRingsV0) {
532	+	std::cout << "Error: This function is only supported for MVAType == kIsoRingsV0.\n" << std::endl;
533	+	assert(kFALSE);
534	+	}
535	+
536	+	fMVAVar_MuPt = MuPt;
537	+	fMVAVar_MuEta = MuEta;
538	+	fMVAVar_ChargedIso_DR0p0To0p1 = ChargedIso_DR0p0To0p1;
539	+	fMVAVar_ChargedIso_DR0p1To0p2 = ChargedIso_DR0p1To0p2;
540	+	fMVAVar_ChargedIso_DR0p2To0p3 = ChargedIso_DR0p2To0p3;
541	+	fMVAVar_ChargedIso_DR0p3To0p4 = ChargedIso_DR0p3To0p4;
542	+	fMVAVar_ChargedIso_DR0p4To0p5 = ChargedIso_DR0p4To0p5;
543	+	fMVAVar_GammaIso_DR0p0To0p1 = GammaIso_DR0p0To0p1;
544	+	fMVAVar_GammaIso_DR0p1To0p2 = GammaIso_DR0p1To0p2;
545	+	fMVAVar_GammaIso_DR0p2To0p3 = GammaIso_DR0p2To0p3;
546	+	fMVAVar_GammaIso_DR0p3To0p4 = GammaIso_DR0p3To0p4;
547	+	fMVAVar_GammaIso_DR0p4To0p5 = GammaIso_DR0p4To0p5;
548	+	fMVAVar_NeutralHadronIso_DR0p0To0p1 = NeutralHadronIso_DR0p0To0p1;
549	+	fMVAVar_NeutralHadronIso_DR0p1To0p2 = NeutralHadronIso_DR0p1To0p2;
550	+	fMVAVar_NeutralHadronIso_DR0p2To0p3 = NeutralHadronIso_DR0p2To0p3;
551	+	fMVAVar_NeutralHadronIso_DR0p3To0p4 = NeutralHadronIso_DR0p3To0p4;
552	+	fMVAVar_NeutralHadronIso_DR0p4To0p5 = NeutralHadronIso_DR0p4To0p5;
553	+
554	+	Double_t mva = -9999;
555	+	TMVA::Reader *reader = 0;
556	+
557	+	if (printDebug == kTRUE) {
558	+	std::cout <<" -> BIN: " << fMVAVar_MuEta << " " << fMVAVar_MuPt << " : "
559	+	<< GetMVABin( fMVAVar_MuEta , fMVAVar_MuPt, MuIsGlobal, MuIsTracker) << std::endl;
560	+	}
561	+	reader = fTMVAReader[GetMVABin( fMVAVar_MuEta , fMVAVar_MuPt, MuIsGlobal, MuIsTracker)];
562	+	mva = reader->EvaluateMVA( fMethodname );
563	+
564	+	if (printDebug == kTRUE) {
565	+
566	+	std::cout << "Debug Muon MVA: \n";
567	+	std::cout << fMVAVar_ChargedIso_DR0p0To0p1 << " "
568	+	<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
569	+	<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
570	+	<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
571	+	<< fMVAVar_ChargedIso_DR0p4To0p5 << " "
572	+	<< fMVAVar_GammaIso_DR0p0To0p1 << " "
573	+	<< fMVAVar_GammaIso_DR0p1To0p2 << " "
574	+	<< fMVAVar_GammaIso_DR0p2To0p3 << " "
575	+	<< fMVAVar_GammaIso_DR0p3To0p4 << " "
576	+	<< fMVAVar_GammaIso_DR0p4To0p5 << " "
577	+	<< fMVAVar_NeutralHadronIso_DR0p0To0p1 << " "
578	+	<< fMVAVar_NeutralHadronIso_DR0p1To0p2 << " "
579	+	<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " "
580	+	<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
581	+	<< fMVAVar_NeutralHadronIso_DR0p4To0p5 << " "
582	+	<< std::endl;
583	+	std::cout << "MVA: " << mva << " "
584	+	<< std::endl;
585	+	}
586	+	return mva;
587	+	}
588	+
589	+
590	+
591	+	Double_t MuonIDMVA::MVAValue_ID( Double_t MuPt,
592	+	Double_t MuEta,
593	+	Bool_t MuIsGlobal,
594	+	Bool_t MuIsTracker,
595	+	Double_t MuTkNchi2,
596	+	Double_t MuGlobalNchi2,
597	+	Double_t MuNValidHits,
598	+	Double_t MuNTrackerHits,
599	+	Double_t MuNPixelHits,
600	+	Double_t MuNMatches,
601	+	Double_t MuTrkKink,
602	+	Double_t MuSegmentCompatibility,
603	+	Double_t MuCaloCompatibility,
604	+	Double_t MuHadEnergy,
605	+	Double_t MuEmEnergy,
606	+	Double_t MuHadS9Energy,
607	+	Double_t MuEmS9Energy,
608	+	Bool_t printDebug) {
609	+
610	+	if (fMVAType != MuonIDMVA::kIDV0) {
611	+	std::cout << "Error: This function is only supported for MVAType == kIDV0.\n" << std::endl;
612	+	assert(kFALSE);
613	+	}
614	+
615	+	fMVAVar_MuPt = MuPt;
616	+	fMVAVar_MuEta = MuEta;
617	+
618	+	fMVAVar_MuTkNchi2 = MuTkNchi2;
619	+	fMVAVar_MuGlobalNchi2 = MuGlobalNchi2;
620	+	fMVAVar_MuNValidHits = MuNValidHits;
621	+	fMVAVar_MuNTrackerHits = MuNTrackerHits;
622	+	fMVAVar_MuNPixelHits = MuNPixelHits;
623	+	fMVAVar_MuNMatches = MuNMatches;
624	+	fMVAVar_MuTrkKink = MuTrkKink;
625	+	fMVAVar_MuSegmentCompatibility = MuSegmentCompatibility;
626	+	fMVAVar_MuCaloCompatibility = MuCaloCompatibility;
627	+	fMVAVar_MuHadEnergy = MuHadEnergy;
628	+	fMVAVar_MuEmEnergy = MuEmEnergy;
629	+	fMVAVar_MuHadS9Energy = MuHadS9Energy;
630	+	fMVAVar_MuEmS9Energy = MuEmS9Energy;
631	+
632	+	Double_t mva = -9999;
633	+	TMVA::Reader *reader = 0;
634	+
635	+	if (printDebug == kTRUE) {
636	+	std::cout <<" -> BIN: " << fMVAVar_MuEta << " " << fMVAVar_MuPt << " : "
637	+	<< GetMVABin( fMVAVar_MuEta , fMVAVar_MuPt, MuIsGlobal, MuIsTracker) << std::endl;
638	+	}
639	+	reader = fTMVAReader[GetMVABin( fMVAVar_MuEta , fMVAVar_MuPt, MuIsGlobal, MuIsTracker)];
640	+	mva = reader->EvaluateMVA( fMethodname );
641	+
642	+	if (printDebug == kTRUE) {
643	+
644	+	std::cout << "Debug Muon MVA: \n";
645	+	std::cout << fMVAVar_MuTkNchi2              << " "
646	+	<< fMVAVar_MuGlobalNchi2          << " "
647	+	<< fMVAVar_MuNValidHits           << " "
648	+	<< fMVAVar_MuNTrackerHits         << " "
649	+	<< fMVAVar_MuNPixelHits           << " "
650	+	<< fMVAVar_MuNMatches             << " "
651	+	<< fMVAVar_MuTrkKink              << " "
652	+	<< fMVAVar_MuSegmentCompatibility << " "
653	+	<< fMVAVar_MuCaloCompatibility    << " "
654	+	<< fMVAVar_MuHadEnergy            << " "
655	+	<< fMVAVar_MuEmEnergy             << " "
656	+	<< fMVAVar_MuHadS9Energy          << " "
657	+	<< fMVAVar_MuEmS9Energy           << " "
658	+	<< std::endl;
659	+	std::cout << "MVA: " << mva << " "
660	+	<< std::endl;
661	+	}
662	+	return mva;
663	+	}
664	+
665	+
666
667		//--------------------------------------------------------------------------------------------------
668		Double_t MuonIDMVA::MVAValue(const Muon *mu, const Vertex *vertex, MuonTools *fMuonTools,
669		const PFCandidateCol *PFCands,
670	<	const PileupEnergyDensityCol *PileupEnergyDensity) {
670	>	const PileupEnergyDensityCol *PileupEnergyDensity,
671	>	Bool_t printDebug) {
672
673		if (!fIsInitialized) {
674		std::cout << "Error: MuonIDMVA not properly initialized.\n";
#	Line 267 | Line 684 | Double_t MuonIDMVA::MVAValue(const Muon
684		else if(mu->HasStandaloneTrk()) { muNchi2 = mu->StandaloneTrk()->RChi2(); }
685		else if(mu->HasTrackerTrk())    { muNchi2 = mu->TrackerTrk()->RChi2();    }
686
687	<	Double_t ChargedIso03 = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.1, 99999, 0.3, 0.0, 0.0);
688	<	Double_t NeutralIso03_05Threshold = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.0, 0.5, 0.3, 0.0, 0.0);
689	<	Double_t ChargedIso04 = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.1, 99999, 0.4, 0.0, 0.0);
690	<	Double_t NeutralIso04_05Threshold = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.0, 0.5, 0.4, 0.0, 0.0);
691	<
687	>	Double_t ChargedIso03 = 0;
688	>	Double_t NeutralIso03_05Threshold = 0;
689	>	Double_t ChargedIso04 = 0;
690	>	Double_t NeutralIso04_05Threshold = 0;
691	>	ChargedIso03 = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.1, 99999, 0.3, 0.0, 0.0);
692	>	NeutralIso03_05Threshold = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.0, 0.5, 0.3, 0.0, 0.0);
693	>	ChargedIso04 = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.1, 99999, 0.4, 0.0, 0.0);
694	>	NeutralIso04_05Threshold = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.0, 0.5, 0.4, 0.0, 0.0);
695	>
696		Double_t Rho = 0;
697	<	if (!(TMath::IsNaN(PileupEnergyDensity->At(0)->Rho()) || isinf(PileupEnergyDensity->At(0)->Rho()))) Rho = PileupEnergyDensity->At(0)->Rho();
698	<
699	<	Int_t subdet = 0;
700	<	if (fabs(muTrk->Eta()) < 1.479) subdet = 0;
701	<	else subdet = 1;
702	<	Int_t ptBin = 0;
703	<	if (muTrk->Pt() > 14.5) ptBin = 1;
704	<	if (muTrk->Pt() > 20.0) ptBin = 2;
705	<
697	>	switch(fTheRhoType) {
698	>	case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA:
699	>	Rho = PileupEnergyDensity->At(0)->Rho();
700	>	break;
701	>	case RhoUtilities::MIT_RHO_VORONOI_LOW_ETA:
702	>	Rho = PileupEnergyDensity->At(0)->RhoLowEta();
703	>	break;
704	>	case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA:
705	>	Rho = PileupEnergyDensity->At(0)->RhoRandom();
706	>	break;
707	>	case RhoUtilities::MIT_RHO_RANDOM_LOW_ETA:
708	>	Rho = PileupEnergyDensity->At(0)->RhoRandomLowEta();
709	>	break;
710	>	case RhoUtilities::CMS_RHO_RHOKT6PFJETS:
711	>	Rho = PileupEnergyDensity->At(0)->RhoKt6PFJets();
712	>	break;
713	>	default:
714	>	// use the old default
715	>	Rho = PileupEnergyDensity->At(0)->Rho();
716	>	break;
717	>	}
718	>
719		//set all input variables
720		fMVAVar_MuTkNchi2              = muTrk->RChi2();
721		fMVAVar_MuGlobalNchi2          = muNchi2;
#	Line 305 | Line 739 | Double_t MuonIDMVA::MVAValue(const Muon
739		fMVAVar_MuNeutralIso03OverPt   = (NeutralIso03_05Threshold - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso03,muTrk->Eta()))/muTrk->Pt();
740		fMVAVar_MuChargedIso04OverPt   = (ChargedIso04 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuChargedIso04,muTrk->Eta()))/muTrk->Pt();
741		fMVAVar_MuNeutralIso04OverPt   = (NeutralIso04_05Threshold - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso04,muTrk->Eta()))/muTrk->Pt();
742	+	fMVAVar_MuTrkIso03OverPt       = (mu->IsoR03SumPt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuTrkIso03,muTrk->Eta()))/muTrk->Pt();
743	+	fMVAVar_MuEMIso03OverPt        = (mu->IsoR03EmEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuEMIso03,muTrk->Eta()))/muTrk->Pt();
744	+	fMVAVar_MuHadIso03OverPt       = (mu->IsoR03HadEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadIso03,muTrk->Eta()))/muTrk->Pt();
745	+	fMVAVar_MuTrkIso05OverPt       = (mu->IsoR05SumPt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuTrkIso05,muTrk->Eta()))/muTrk->Pt();
746	+	fMVAVar_MuEMIso05OverPt        = (mu->IsoR05EmEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuEMIso05,muTrk->Eta()))/muTrk->Pt();
747	+	fMVAVar_MuHadIso05OverPt       = (mu->IsoR05HadEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadIso05,muTrk->Eta()))/muTrk->Pt();
748
749		Double_t mva = -9999;
750		TMVA::Reader *reader = 0;
751	<
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];
751	>	reader = fTMVAReader[GetMVABin(muTrk->Eta(), muTrk->Pt(), mu->IsGlobalMuon(), mu->IsTrackerMuon())];
752
753		mva = reader->EvaluateMVA( fMethodname );
754
755	<	Bool_t printdebug = kTRUE;
325	<	if (printdebug == kTRUE) {
755	>	if (printDebug) {
756		std::cout << "Debug Muon MVA: "
757		<< mu->Pt() << " " << mu->Eta() << " " << mu->Phi() << " : "
758	<	<< muTrk->Pt() << " " << muTrk->Eta() << " --> MVABin " << MVABin << " : "
758	>	<< muTrk->Pt() << " " << muTrk->Eta() << " --> MVABin " << GetMVABin(muTrk->Eta(), muTrk->Pt(), mu->IsGlobalMuon(), mu->IsTrackerMuon()) << " : "
759		<< fMVAVar_MuTkNchi2              << " "
760		<< fMVAVar_MuGlobalNchi2          << " "
761		<< fMVAVar_MuNValidHits           << " "
#	Line 348 | Line 778 | Double_t MuonIDMVA::MVAValue(const Muon
778		<< fMVAVar_MuNeutralIso03OverPt   << " "
779		<< fMVAVar_MuChargedIso04OverPt   << " "
780		<< fMVAVar_MuNeutralIso04OverPt   << " "
781	+	<< fMVAVar_MuTrkIso03OverPt   << " "
782	+	<< fMVAVar_MuEMIso03OverPt   << " "
783	+	<< fMVAVar_MuHadIso03OverPt   << " "
784	+	<< fMVAVar_MuTrkIso05OverPt   << " "
785	+	<< fMVAVar_MuEMIso05OverPt   << " "
786	+	<< fMVAVar_MuHadIso05OverPt   << " "
787		<< " === : === "
788		<< mva
789		<< std::endl;
790		}
791
792	+	return mva;
793	+	}
794	+
795	+
796	+	//--------------------------------------------------------------------------------------------------
797	+	Double_t MuonIDMVA::MVAValue(const Muon *mu, const Vertex *vertex, MuonTools *fMuonTools,
798	+	const PFCandidateCol *PFCands,
799	+	const PileupEnergyDensityCol *PileupEnergyDensity,
800	+	MuonTools::EMuonEffectiveAreaTarget EffectiveAreaTarget,
801	+	const ElectronCol *goodElectrons,
802	+	const MuonCol *goodMuons,
803	+	Bool_t printDebug) {
804	+
805	+	if (!fIsInitialized) {
806	+	std::cout << "Error: MuonIDMVA not properly initialized.\n";
807	+	return -9999;
808	+	}
809	+
810	+	const Track *muTrk=0;
811	+	if(mu->HasTrackerTrk())         { muTrk = mu->TrackerTrk();    }
812	+	else if(mu->HasStandaloneTrk()) { muTrk = mu->StandaloneTrk(); }
813	+
814	+	Double_t muNchi2 = 0.0;
815	+	if(mu->HasGlobalTrk())          { muNchi2 = mu->GlobalTrk()->RChi2();     }
816	+	else if(mu->HasStandaloneTrk()) { muNchi2 = mu->StandaloneTrk()->RChi2(); }
817	+	else if(mu->HasTrackerTrk())    { muNchi2 = mu->TrackerTrk()->RChi2();    }
818	+
819	+	Double_t ChargedIso03 = 0;
820	+	Double_t NeutralIso03_05Threshold = 0;
821	+	Double_t ChargedIso04 = 0;
822	+	Double_t NeutralIso04_05Threshold = 0;
823	+	ChargedIso03 = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.1, 99999, 0.3, 0.0, 0.0);
824	+	NeutralIso03_05Threshold = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.0, 0.5, 0.3, 0.0, 0.0);
825	+	ChargedIso04 = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.1, 99999, 0.4, 0.0, 0.0);
826	+	NeutralIso04_05Threshold = IsolationTools::PFMuonIsolation(mu, PFCands, vertex, 0.0, 0.5, 0.4, 0.0, 0.0);
827	+
828	+	Double_t Rho = 0;
829	+	switch(fTheRhoType) {
830	+	case RhoUtilities::MIT_RHO_VORONOI_HIGH_ETA:
831	+	Rho = PileupEnergyDensity->At(0)->Rho();
832	+	break;
833	+	case RhoUtilities::MIT_RHO_VORONOI_LOW_ETA:
834	+	Rho = PileupEnergyDensity->At(0)->RhoLowEta();
835	+	break;
836	+	case RhoUtilities::MIT_RHO_RANDOM_HIGH_ETA:
837	+	Rho = PileupEnergyDensity->At(0)->RhoRandom();
838	+	break;
839	+	case RhoUtilities::MIT_RHO_RANDOM_LOW_ETA:
840	+	Rho = PileupEnergyDensity->At(0)->RhoRandomLowEta();
841	+	break;
842	+	case RhoUtilities::CMS_RHO_RHOKT6PFJETS:
843	+	Rho = PileupEnergyDensity->At(0)->RhoKt6PFJets();
844	+	break;
845	+	default:
846	+	// use the old default
847	+	Rho = PileupEnergyDensity->At(0)->Rho();
848	+	break;
849	+	}
850	+
851	+	//set all input variables
852	+	fMVAVar_MuPt                   = muTrk->Pt();
853	+	fMVAVar_MuEta                  = muTrk->Eta();
854	+	fMVAVar_MuTkNchi2              = muTrk->RChi2();
855	+	fMVAVar_MuGlobalNchi2          = muNchi2;
856	+	fMVAVar_MuNValidHits           = mu->NValidHits();
857	+	fMVAVar_MuNTrackerHits         = muTrk->NHits();
858	+	fMVAVar_MuNPixelHits           = muTrk->NPixelHits();
859	+	fMVAVar_MuNMatches             = mu->NMatches();
860	+	fMVAVar_MuD0                   = muTrk->D0Corrected(*vertex);
861	+	fMVAVar_MuIP3d                 = mu->Ip3dPV();
862	+	fMVAVar_MuIP3dSig              = mu->Ip3dPVSignificance();
863	+	fMVAVar_MuTrkKink              = mu->TrkKink();
864	+	fMVAVar_MuSegmentCompatibility = fMuonTools->GetSegmentCompatability(mu);
865	+	fMVAVar_MuCaloCompatibility    = fMuonTools->GetCaloCompatability(mu, kTRUE, kTRUE);
866	+	fMVAVar_MuHadEnergy            = mu->HadEnergy() ;
867	+	fMVAVar_MuEmEnergy             = mu->EmEnergy();
868	+	fMVAVar_MuHadS9Energy          = mu->HadS9Energy();
869	+	fMVAVar_MuEmS9Energy           = mu->EmS9Energy();
870	+	fMVAVar_MuChargedIso03OverPt   = (ChargedIso03 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuChargedIso03,muTrk->Eta()))/muTrk->Pt();
871	+	fMVAVar_MuNeutralIso03OverPt   = (NeutralIso03_05Threshold - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso03,muTrk->Eta()))/muTrk->Pt();
872	+	fMVAVar_MuChargedIso04OverPt   = (ChargedIso04 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuChargedIso04,muTrk->Eta()))/muTrk->Pt();
873	+	fMVAVar_MuNeutralIso04OverPt   = (NeutralIso04_05Threshold - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralIso04,muTrk->Eta()))/muTrk->Pt();
874	+	fMVAVar_MuTrkIso03OverPt       = (mu->IsoR03SumPt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuTrkIso03,muTrk->Eta()))/muTrk->Pt();
875	+	fMVAVar_MuEMIso03OverPt        = (mu->IsoR03EmEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuEMIso03,muTrk->Eta()))/muTrk->Pt();
876	+	fMVAVar_MuHadIso03OverPt       = (mu->IsoR03HadEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadIso03,muTrk->Eta()))/muTrk->Pt();
877	+	fMVAVar_MuTrkIso05OverPt       = (mu->IsoR05SumPt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuTrkIso05,muTrk->Eta()))/muTrk->Pt();
878	+	fMVAVar_MuEMIso05OverPt        = (mu->IsoR05EmEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuEMIso05,muTrk->Eta()))/muTrk->Pt();
879	+	fMVAVar_MuHadIso05OverPt       = (mu->IsoR05HadEt() - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuHadIso05,muTrk->Eta()))/muTrk->Pt();
880	+
881	+
882	+	Double_t tmpChargedIso_DR0p0To0p1  = 0;
883	+	Double_t tmpChargedIso_DR0p1To0p2  = 0;
884	+	Double_t tmpChargedIso_DR0p2To0p3  = 0;
885	+	Double_t tmpChargedIso_DR0p3To0p4  = 0;
886	+	Double_t tmpChargedIso_DR0p4To0p5  = 0;
887	+	Double_t tmpGammaIso_DR0p0To0p1  = 0;
888	+	Double_t tmpGammaIso_DR0p1To0p2  = 0;
889	+	Double_t tmpGammaIso_DR0p2To0p3  = 0;
890	+	Double_t tmpGammaIso_DR0p3To0p4  = 0;
891	+	Double_t tmpGammaIso_DR0p4To0p5  = 0;
892	+	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
893	+	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
894	+	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
895	+	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
896	+	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
897	+
898	+	Double_t tmpMuDeltaRMean = 0;
899	+	Double_t tmpMuDeltaRSum = 0;
900	+	Double_t tmpMuDensity = 0;
901	+	Double_t tmpMuNPFCand = 0;
902	+
903	+	for (UInt_t p=0; p<PFCands->GetEntries();p++) {
904	+	const PFCandidate *pf = PFCands->At(p);
905	+
906	+	//exclude the muon itself
907	+	if(pf->TrackerTrk() && mu->TrackerTrk() &&
908	+	pf->TrackerTrk() == mu->TrackerTrk()) continue;
909	+
910	+	//************************************************************
911	+	// New Isolation Calculations
912	+	//************************************************************
913	+	Double_t dr = MathUtils::DeltaR(mu->Mom(), pf->Mom());
914	+
915	+	if (dr < 0.5) {
916	+	Bool_t IsLeptonFootprint = kFALSE;
917	+	//************************************************************
918	+	// Lepton Footprint Removal
919	+	//************************************************************
920	+	if(goodElectrons) {
921	+	for (UInt_t q=0; q < goodElectrons->GetEntries() ; ++q) {
922	+	//if pf candidate matches an electron passing ID cuts, then veto it
923	+	if(pf->GsfTrk() && goodElectrons->At(q)->GsfTrk() &&
924	+	pf->GsfTrk() == goodElectrons->At(q)->GsfTrk()) IsLeptonFootprint = kTRUE;
925	+	if(pf->TrackerTrk() && goodElectrons->At(q)->TrackerTrk() &&
926	+	pf->TrackerTrk() == goodElectrons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
927	+	//if pf candidate lies in veto regions of electron passing ID cuts, then veto it
928	+	if(pf->BestTrk() && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479
929	+	&& MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.015) IsLeptonFootprint = kTRUE;
930	+	if(pf->PFType() == PFCandidate::eGamma && fabs(goodElectrons->At(q)->SCluster()->Eta()) >= 1.479 &&
931	+	MathUtils::DeltaR(goodElectrons->At(q)->Mom(), pf->Mom()) < 0.08) IsLeptonFootprint = kTRUE;
932	+	}
933	+	}
934	+	if(goodMuons) {
935	+	for (UInt_t q=0; q < goodMuons->GetEntries() ; ++q) {
936	+	//if pf candidate matches an muon passing ID cuts, then veto it
937	+	if(pf->TrackerTrk() && goodMuons->At(q)->TrackerTrk() &&
938	+	pf->TrackerTrk() == goodMuons->At(q)->TrackerTrk()) IsLeptonFootprint = kTRUE;
939	+	//if pf candidate lies in veto regions of muon passing ID cuts, then veto it
940	+	if(pf->BestTrk() && MathUtils::DeltaR(goodMuons->At(q)->Mom(), pf->Mom()) < 0.01) IsLeptonFootprint = kTRUE;
941	+	}
942	+	}
943	+
944	+	if (!IsLeptonFootprint) {
945	+	Bool_t passVeto = kTRUE;
946	+	//Charged
947	+	if(pf->BestTrk()) {
948	+	if (!(fabs(pf->BestTrk()->DzCorrected(*vertex) - mu->BestTrk()->DzCorrected(*vertex)) < 0.2)) passVeto = kFALSE;
949	+	//************************************************************
950	+	// Veto any PFmuon, or PFEle
951	+	if (pf->PFType() == PFCandidate::eElectron || pf->PFType() == PFCandidate::eMuon) passVeto = kFALSE;
952	+	//************************************************************
953	+	//************************************************************
954	+	// Footprint Veto
955	+	if (dr < 0.01) passVeto = kFALSE;
956	+	//************************************************************
957	+	if (passVeto) {
958	+	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
959	+	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
960	+	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
961	+	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
962	+	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
963	+	} //pass veto
964	+	}
965	+	//Gamma
966	+	else if (pf->PFType() == PFCandidate::eGamma) {
967	+	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
968	+	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
969	+	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
970	+	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
971	+	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
972	+	}
973	+	//NeutralHadron
974	+	else {
975	+	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
976	+	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
977	+	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
978	+	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
979	+	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
980	+	}
981	+
982	+	if (dr < 0.5) {
983	+	tmpMuNPFCand++;
984	+	tmpMuDeltaRMean += dr;
985	+	tmpMuDeltaRSum  += dr;
986	+	tmpMuDensity    += pf->Pt() / dr;
987	+	}
988	+	} //not lepton footprint
989	+	} //in 1.0 dr cone
990	+	} //loop over PF candidates
991	+
992	+	//   Double_t fMVAVar_ChargedIso_DR0p0To0p1  = 0;
993	+	//   Double_t fMVAVar_ChargedIso_DR0p1To0p2  = 0;
994	+	//   Double_t fMVAVar_ChargedIso_DR0p2To0p3  = 0;
995	+	//   Double_t fMVAVar_ChargedIso_DR0p3To0p4  = 0;
996	+	//   Double_t fMVAVar_ChargedIso_DR0p4To0p5  = 0;
997	+	//   Double_t fMVAVar_GammaIso_DR0p0To0p1  = 0;
998	+	//   Double_t fMVAVar_GammaIso_DR0p1To0p2  = 0;
999	+	//   Double_t fMVAVar_GammaIso_DR0p2To0p3  = 0;
1000	+	//   Double_t fMVAVar_GammaIso_DR0p3To0p4  = 0;
1001	+	//   Double_t fMVAVar_GammaIso_DR0p4To0p5  = 0;
1002	+	//   Double_t fMVAVar_NeutralHadronIso_DR0p0To0p1  = 0;
1003	+	//   Double_t fMVAVar_NeutralHadronIso_DR0p1To0p2  = 0;
1004	+	//   Double_t fMVAVar_NeutralHadronIso_DR0p2To0p3  = 0;
1005	+	//   Double_t fMVAVar_NeutralHadronIso_DR0p3To0p4  = 0;
1006	+	//   Double_t fMVAVar_NeutralHadronIso_DR0p4To0p5  = 0;
1007	+
1008	+	fMVAVar_ChargedIso_DR0p0To0p1 = TMath::Min((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
1009	+	fMVAVar_ChargedIso_DR0p1To0p2 = TMath::Min((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
1010	+	fMVAVar_ChargedIso_DR0p2To0p3 = TMath::Min((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
1011	+	fMVAVar_ChargedIso_DR0p3To0p4 = TMath::Min((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
1012	+	fMVAVar_ChargedIso_DR0p4To0p5 = TMath::Min((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
1013	+	fMVAVar_GammaIso_DR0p0To0p1 = TMath::Max(TMath::Min((tmpGammaIso_DR0p0To0p1 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p0To0p1, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
1014	+	fMVAVar_GammaIso_DR0p1To0p2 = TMath::Max(TMath::Min((tmpGammaIso_DR0p1To0p2 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p1To0p2, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
1015	+	fMVAVar_GammaIso_DR0p2To0p3 = TMath::Max(TMath::Min((tmpGammaIso_DR0p2To0p3 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p2To0p3, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
1016	+	fMVAVar_GammaIso_DR0p3To0p4 = TMath::Max(TMath::Min((tmpGammaIso_DR0p3To0p4 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p3To0p4, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
1017	+	fMVAVar_GammaIso_DR0p4To0p5 = TMath::Max(TMath::Min((tmpGammaIso_DR0p4To0p5 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p4To0p5, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
1018	+	fMVAVar_NeutralHadronIso_DR0p0To0p1 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p0To0p1 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p0To0p1, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
1019	+	fMVAVar_NeutralHadronIso_DR0p1To0p2 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p1To0p2 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p1To0p2, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
1020	+	fMVAVar_NeutralHadronIso_DR0p2To0p3 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p2To0p3 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p2To0p3, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
1021	+	fMVAVar_NeutralHadronIso_DR0p3To0p4 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p3To0p4 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p3To0p4, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
1022	+	fMVAVar_NeutralHadronIso_DR0p4To0p5 = TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p4To0p5 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p4To0p5, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
1023	+
1024	+	// Variables for dR MVA
1025	+	fMVAVar_MuRelIsoPFCharged  = 0.;
1026	+	fMVAVar_MuRelIsoPFCharged += TMath::Min((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
1027	+	fMVAVar_MuRelIsoPFCharged += TMath::Min((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
1028	+	fMVAVar_MuRelIsoPFCharged += TMath::Min((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
1029	+	fMVAVar_MuRelIsoPFCharged += TMath::Min((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
1030	+	fMVAVar_MuRelIsoPFCharged += TMath::Min((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
1031	+
1032	+	fMVAVar_MuRelIsoPFNeutral  = 0.;
1033	+	fMVAVar_MuRelIsoPFNeutral += TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p0To0p1 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p0To0p1, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
1034	+	fMVAVar_MuRelIsoPFNeutral += TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p1To0p2 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p1To0p2, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
1035	+	fMVAVar_MuRelIsoPFNeutral += TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p2To0p3 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p2To0p3, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
1036	+	fMVAVar_MuRelIsoPFNeutral += TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p3To0p4 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p3To0p4, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
1037	+	fMVAVar_MuRelIsoPFNeutral += TMath::Max(TMath::Min((tmpNeutralHadronIso_DR0p4To0p5 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuNeutralHadronIsoDR0p4To0p5, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
1038	+
1039	+	fMVAVar_MuRelIsoPFPhotons  = 0.;
1040	+	fMVAVar_MuRelIsoPFPhotons += TMath::Max(TMath::Min((tmpGammaIso_DR0p0To0p1 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p0To0p1, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
1041	+	fMVAVar_MuRelIsoPFPhotons += TMath::Max(TMath::Min((tmpGammaIso_DR0p1To0p2 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p1To0p2, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
1042	+	fMVAVar_MuRelIsoPFPhotons += TMath::Max(TMath::Min((tmpGammaIso_DR0p2To0p3 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p2To0p3, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
1043	+	fMVAVar_MuRelIsoPFPhotons += TMath::Max(TMath::Min((tmpGammaIso_DR0p3To0p4 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p3To0p4, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
1044	+	fMVAVar_MuRelIsoPFPhotons += TMath::Max(TMath::Min((tmpGammaIso_DR0p4To0p5 - Rho*MuonTools::MuonEffectiveArea(MuonTools::kMuGammaIsoDR0p4To0p5, mu->Eta(), EffectiveAreaTarget))/mu->Pt(), 2.5), 0.0);
1045	+
1046	+	fMVAVar_MuDeltaRMean      = tmpMuDeltaRMean/TMath::Max(1.0,tmpMuNPFCand);
1047	+	fMVAVar_MuDeltaRSum       = tmpMuDeltaRSum;
1048	+	fMVAVar_MuDensity         = tmpMuDensity;
1049	+
1050	+	Double_t mva = -9999;
1051	+	TMVA::Reader *reader = 0;
1052	+
1053	+	if (printDebug) {
1054	+	std::cout <<" -> BIN: " << fMVAVar_MuEta << " " << fMVAVar_MuPt << " : "
1055	+	<< GetMVABin(muTrk->Eta(), muTrk->Pt(), mu->IsGlobalMuon(), mu->IsTrackerMuon() )
1056	+	<< std::endl;
1057	+	}
1058	+
1059	+	reader = fTMVAReader[GetMVABin(muTrk->Eta(), muTrk->Pt(), mu->IsGlobalMuon(), mu->IsTrackerMuon() )];
1060	+
1061	+	mva = reader->EvaluateMVA( fMethodname );
1062	+
1063	+	if (printDebug) {
1064	+	std::cout << "Debug Muon MVA: ";
1065	+	std::cout << " MuTkNchi2 " << fMVAVar_MuTkNchi2
1066	+	<< " MuGlobalNchi2 " << fMVAVar_MuGlobalNchi2
1067	+	<< " MuNValidHits " << fMVAVar_MuNValidHits
1068	+	<< " MuNTrackerHits " << fMVAVar_MuNTrackerHits
1069	+	<< " MuNPixelHits " << fMVAVar_MuNPixelHits
1070	+	<< " MuNMatches " << fMVAVar_MuNMatches
1071	+	<< " MuD0 " << fMVAVar_MuD0
1072	+	<< " MuIP3d " << fMVAVar_MuIP3d
1073	+	<< " MuIP3dSig " << fMVAVar_MuIP3dSig
1074	+	<< " MuTrkKink " << fMVAVar_MuTrkKink
1075	+	<< " MuSegmentCompatibility " << fMVAVar_MuSegmentCompatibility
1076	+	<< " MuCaloCompatibility " << fMVAVar_MuCaloCompatibility
1077	+	<< " MuHadEnergy " << fMVAVar_MuHadEnergy
1078	+	<< " MuEmEnergy " << fMVAVar_MuEmEnergy
1079	+	<< " MuHadS9Energy " << fMVAVar_MuHadS9Energy
1080	+	<< " MuEmS9Energy " << fMVAVar_MuEmS9Energy
1081	+	<< " eta " << fMVAVar_MuEta
1082	+	<< " pt " << fMVAVar_MuPt
1083	+	<< " isoInfo: ";
1084	+	std::cout << fMVAVar_ChargedIso_DR0p0To0p1 << " "
1085	+	<< fMVAVar_ChargedIso_DR0p1To0p2 << " "
1086	+	<< fMVAVar_ChargedIso_DR0p2To0p3 << " "
1087	+	<< fMVAVar_ChargedIso_DR0p3To0p4 << " "
1088	+	<< fMVAVar_ChargedIso_DR0p4To0p5 << " "
1089	+	<< fMVAVar_GammaIso_DR0p0To0p1 << " "
1090	+	<< fMVAVar_GammaIso_DR0p1To0p2 << " "
1091	+	<< fMVAVar_GammaIso_DR0p2To0p3 << " "
1092	+	<< fMVAVar_GammaIso_DR0p3To0p4 << " "
1093	+	<< fMVAVar_GammaIso_DR0p4To0p5 << " "
1094	+	<< fMVAVar_NeutralHadronIso_DR0p0To0p1 << " "
1095	+	<< fMVAVar_NeutralHadronIso_DR0p1To0p2 << " "
1096	+	<< fMVAVar_NeutralHadronIso_DR0p2To0p3 << " "
1097	+	<< fMVAVar_NeutralHadronIso_DR0p3To0p4 << " "
1098	+	<< fMVAVar_NeutralHadronIso_DR0p4To0p5;
1099	+	std::cout << " MuRelIsoPFCharged: " << fMVAVar_MuRelIsoPFCharged
1100	+	<< " MuRelIsoPFNeutral: " << fMVAVar_MuRelIsoPFNeutral
1101	+	<< " MuRelIsoPFPhotons: " << fMVAVar_MuRelIsoPFPhotons
1102	+	<< " MuDeltaRMean: "      << fMVAVar_MuDeltaRMean
1103	+	<< " MuDeltaRMean: "      << fMVAVar_MuDeltaRMean
1104	+	<< " MuDensity: "         << fMVAVar_MuDensity;
1105	+	std::cout << " MVA: " << mva
1106	+	<< std::endl;
1107	+	}
1108	+
1109		return mva;
1110		}

Diff Legend

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