ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents):
Revision 1.2 by khahn, Fri Feb 17 14:49:00 2012 UTC vs.
Revision 1.8 by khahn, Wed May 2 17:50:58 2012 UTC

#	Line 3 | Line 3
3		#include "IsolationSelection.h"
4		#include "IsolationSelectionDefs.h"
5
6	<	bool pairwiseIsoSelection( ControlFlags &ctrl, vector<SimpleLepton> &lepvec, float rho ) {
6	>	#include "MathUtils.h"
7	>	#include "MuonTools.h"
8	>	#include "MuonIDMVA.h"
9	>	#include "ElectronTools.h"
10	>	#include "ElectronIDMVA.h"
11	>
12	>	using namespace mithep;
13	>
14	>	mithep::MuonIDMVA     * muIsoMVA;
15	>	mithep::MuonTools       muT;
16	>	mithep::ElectronIDMVA * eleIsoMVA;
17	>	mithep::ElectronTools   eleT;
18	>
19	>	//--------------------------------------------------------------------------------------------------
20	>	Float_t computePFMuonIso(const mithep::Muon *muon,
21	>	const mithep::Vertex & vtx,
22	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
23	>	const Double_t dRMax)
24	>	//--------------------------------------------------------------------------------------------------
25	>	{
26	>	const Double_t dRMin    = 0;
27	>	const Double_t neuPtMin = 1.0;
28	>	const Double_t dzMax    = 0.1;
29	>
30	>	Double_t zLepton = (muon->BestTrk()) ? muon->BestTrk()->DzCorrected(vtx) : 0.0;
31	>
32	>	Float_t iso=0;
33	>	for(UInt_t ipf=0; ipf<fPFCandidates->GetEntries(); ipf++) {
34	>	const PFCandidate *pfcand = fPFCandidates->At(ipf);
35	>
36	>	if(!pfcand->HasTrk() && (pfcand->Pt()<=neuPtMin)) continue;  // pT cut on neutral particles
37	>
38	>	// exclude THE muon
39	>	if(pfcand->TrackerTrk() && muon->TrackerTrk() && (pfcand->TrackerTrk()==muon->TrackerTrk())) continue;
40	>
41	>	// dz cut
42	>	Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(vtx) - zLepton) : 0;
43	>	if(dz >= dzMax) continue;
44	>
45	>	// check iso cone
46	>	Double_t dr = MathUtils::DeltaR(muon->Mom(), pfcand->Mom());
47	>	if(dr<dRMax && dr>=dRMin)
48	>	iso += pfcand->Pt();
49	>	}
50	>
51	>	return iso;
52	>	}
53	>
54	>	//--------------------------------------------------------------------------------------------------
55	>	Float_t computePFEleIso(const mithep::Electron *electron,
56	>	const mithep::Vertex & fVertex,
57	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
58	>	const Double_t dRMax)
59	>	//--------------------------------------------------------------------------------------------------
60	>	{
61	>	const Double_t dRMin    = 0;
62	>	const Double_t neuPtMin = 1.0;
63	>	const Double_t dzMax    = 0.1;
64	>
65	>	Double_t zLepton = (electron->BestTrk()) ? electron->BestTrk()->DzCorrected(fVertex) : 0.0;
66	>
67	>	Float_t iso=0;
68	>	for(UInt_t ipf=0; ipf<fPFCandidates->GetEntries(); ipf++) {
69	>	const PFCandidate *pfcand = (PFCandidate*)(fPFCandidates->At(ipf));
70	>
71	>	if(!pfcand->HasTrk() && (pfcand->Pt()<=neuPtMin)) continue;  // pT cut on neutral particles
72	>
73	>	// dz cut
74	>	Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(fVertex) - zLepton) : 0;
75	>	if(dz >= dzMax) continue;
76	>
77	>	// remove THE electron
78	>	if(pfcand->TrackerTrk() && electron->TrackerTrk() && (pfcand->TrackerTrk()==electron->TrackerTrk())) continue;
79	>	if(pfcand->GsfTrk()     && electron->GsfTrk()     && (pfcand->GsfTrk()==electron->GsfTrk()))         continue;
80	>
81	>	// check iso cone
82	>	Double_t dr = MathUtils::DeltaR(electron->Mom(), pfcand->Mom());
83	>	if(dr<dRMax && dr>=dRMin) {
84	>	// eta-strip veto for photons
85	>	if((pfcand->PFType() == PFCandidate::eGamma) && fabs(electron->Eta() - pfcand->Eta()) < 0.025) continue;
86	>
87	>	// Inner cone (one tower = dR < 0.07) veto for non-photon neutrals
88	>	if(!pfcand->HasTrk() && (pfcand->PFType() == PFCandidate::eNeutralHadron) &&
89	>	(MathUtils::DeltaR(electron->Mom(), pfcand->Mom()) < 0.07)) continue;
90	>
91	>	iso += pfcand->Pt();
92	>	}
93	>	}
94	>
95	>	return iso;
96	>	};
97	>
98	>	//--------------------------------------------------------------------------------------------------
99	>	bool pairwiseIsoSelection( ControlFlags &ctrl,
100	>	vector<SimpleLepton> &lepvec,
101	>	float rho )
102	>	//--------------------------------------------------------------------------------------------------
103	>	{
104
105		bool passiso=true;
106
#	Line 75 | Line 172 | bool pairwiseIsoSelection( ControlFlags
172		return passiso;
173		}
174
175	<
176	<	SelectionStatus passMuonIsoSelection( ControlFlags &ctrl, const mithep::TMuon * mu ) {
177	<
178	<	float reliso = mu->pfIso03/mu->pt;
179	<	bool isEB = (fabs(mu->eta) < 1.479 ? 1 : 0 );
175	>	//--------------------------------------------------------------------------------------------------
176	>	SelectionStatus muonIsoSelection(ControlFlags &ctrl,
177	>	const mithep::Muon * mu,
178	>	const mithep::Vertex & vtx,
179	>	const mithep::Array<mithep::PFCandidate> * fPFCandidateCol   )
180	>	//--------------------------------------------------------------------------------------------------
181	>	{
182	>	float reliso = computePFMuonIso(mu,vtx,fPFCandidateCol,0.3)/mu->Pt();
183	>	bool isEB = (fabs(mu->Eta()) < 1.479 ? 1 : 0 );
184		bool failiso = false;
185	<	if( isEB && mu->pt > 20 && reliso > PFISO_MU_LOOSE_EB_HIGHPT ) {
185	>	if( isEB && mu->Pt() > 20 && reliso > PFISO_MU_LOOSE_EB_HIGHPT ) {
186		failiso = true;
187		}
188	<	if( isEB && mu->pt < 20 && reliso > PFISO_MU_LOOSE_EB_LOWPT ) {
188	>	if( isEB && mu->Pt() < 20 && reliso > PFISO_MU_LOOSE_EB_LOWPT ) {
189		failiso = true;
190		}
191	<	if( !(isEB) && mu->pt > 20 && reliso > PFISO_MU_LOOSE_EE_HIGHPT ) {
191	>	if( !(isEB) && mu->Pt() > 20 && reliso > PFISO_MU_LOOSE_EE_HIGHPT ) {
192		failiso = true;
193		}
194	<	if( !(isEB) && mu->pt < 20 && reliso > PFISO_MU_LOOSE_EE_LOWPT ) {
194	>	if( !(isEB) && mu->Pt() < 20 && reliso > PFISO_MU_LOOSE_EE_LOWPT ) {
195		failiso = true;
196		}
197
#	Line 101 | Line 202 | SelectionStatus passMuonIsoSelection( Co
202
203		};
204
205	<
206	<	SelectionStatus failEleIso(ControlFlags &ctrl, const mithep::TElectron * ele) {
205	>	//--------------------------------------------------------------------------------------------------
206	>	SelectionStatus electronIsoSelection(ControlFlags &ctrl,
207	>	const mithep::Electron * ele,
208	>	const mithep::Vertex &fVertex,
209	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates)
210	>	//--------------------------------------------------------------------------------------------------
211	>	{
212
213		bool failiso=false;
214
215	<	float reliso = ele->pfIso04/ele->pt;
216	<	bool isEB = (fabs(ele->eta) < 1.479 ? 1 : 0 );
217	<	if( isEB && ele->pt > 20 && reliso > PFISO_ELE_LOOSE_EB_HIGHPT ) {
215	>	float reliso = computePFEleIso(ele,fVertex,fPFCandidates,0.4)/ele->Pt();
216	>
217	>	if( ele->IsEB() && ele->Pt() > 20 && reliso > PFISO_ELE_LOOSE_EB_HIGHPT ) {
218		failiso = true;
219		}
220	<	if( isEB && ele->pt < 20 && reliso > PFISO_ELE_LOOSE_EB_LOWPT ) {
220	>	if( ele->IsEB() && ele->Pt() < 20 && reliso > PFISO_ELE_LOOSE_EB_LOWPT ) {
221		failiso = true;
222		}
223		if(ctrl.debug) cout << "before iso check ..." << endl;
224	<	if( !(isEB) && ele->pt > 20 && reliso > PFISO_ELE_LOOSE_EE_HIGHPT ) {
224	>	if( !(ele->IsEB()) && ele->Pt() > 20 && reliso > PFISO_ELE_LOOSE_EE_HIGHPT ) {
225		if(ctrl.debug) cout << "\tit fails ..." << endl;
226		failiso = true;
227		}
228	<	if( !(isEB) && ele->pt < 20 && reliso > PFISO_ELE_LOOSE_EE_LOWPT ) {
228	>	if( !(ele->IsEB()) && ele->Pt() < 20 && reliso > PFISO_ELE_LOOSE_EE_LOWPT ) {
229		failiso = true;
230		}
231
232		SelectionStatus status;
233		if( !failiso ) {
234	<	status.setStatus(SelectionStatus::LOOSEISO);
235	<	status.setStatus(SelectionStatus::TIGHTISO);
234	>	status.orStatus(SelectionStatus::LOOSEISO);
235	>	status.orStatus(SelectionStatus::TIGHTISO);
236	>	}
237	>	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
238	>	return status;
239	>
240	>	}
241	>
242	>
243	>	bool noIso(ControlFlags &, vector<SimpleLepton> &, float rho) {
244	>
245	>	return true;
246	>	}
247	>
248	>	//--------------------------------------------------------------------------------------------------
249	>	SelectionStatus muonIsoMVASelection(ControlFlags &ctrl,
250	>	const mithep::Muon * mu,
251	>	const mithep::Vertex & vtx,
252	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
253	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
254	>	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
255	>	vector<const mithep::Muon*> muonsToVeto,
256	>	vector<const mithep::Electron*> electronsToVeto)
257	>	//--------------------------------------------------------------------------------------------------
258	>	{
259	>
260	>	if( ctrl.debug ) {
261	>	cout << "muonIsoMVASelection :: muons to veto " << endl;
262	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
263	>	const mithep::Muon * vmu = muonsToVeto[i];
264	>	cout << "\tpt: " << vmu->Pt()
265	>	<< "\teta: " << vmu->Eta()
266	>	<< "\tphi: " << vmu->Phi()
267	>	<< endl;
268	>	}
269	>	cout << "muonIsoMVASelection :: electrson to veto " << endl;
270	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
271	>	const mithep::Electron * vel = electronsToVeto[i];
272	>	cout << "\tpt: " << vel->Pt()
273	>	<< "\teta: " << vel->Eta()
274	>	<< "\tphi: " << vel->Phi()
275	>	<< endl;
276	>	}
277	>	}
278	>	bool failiso=false;
279	>
280	>	//
281	>	// tmp iso rings
282	>	//
283	>	Double_t tmpChargedIso_DR0p0To0p1  = 0;
284	>	Double_t tmpChargedIso_DR0p1To0p2  = 0;
285	>	Double_t tmpChargedIso_DR0p2To0p3  = 0;
286	>	Double_t tmpChargedIso_DR0p3To0p4  = 0;
287	>	Double_t tmpChargedIso_DR0p4To0p5  = 0;
288	>	Double_t tmpChargedIso_DR0p5To0p7  = 0;
289	>
290	>	Double_t tmpGammaIso_DR0p0To0p1  = 0;
291	>	Double_t tmpGammaIso_DR0p1To0p2  = 0;
292	>	Double_t tmpGammaIso_DR0p2To0p3  = 0;
293	>	Double_t tmpGammaIso_DR0p3To0p4  = 0;
294	>	Double_t tmpGammaIso_DR0p4To0p5  = 0;
295	>	Double_t tmpGammaIso_DR0p5To0p7  = 0;
296	>
297	>	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
298	>	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
299	>	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
300	>	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
301	>	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
302	>	Double_t tmpNeutralHadronIso_DR0p5To0p7  = 0;
303	>
304	>
305	>
306	>	//
307	>	// final rings for the MVA
308	>	//
309	>	Double_t fChargedIso_DR0p0To0p1;
310	>	Double_t fChargedIso_DR0p1To0p2;
311	>	Double_t fChargedIso_DR0p2To0p3;
312	>	Double_t fChargedIso_DR0p3To0p4;
313	>	Double_t fChargedIso_DR0p4To0p5;
314	>	Double_t fChargedIso_DR0p5To0p7;
315	>
316	>	Double_t fGammaIso_DR0p0To0p1;
317	>	Double_t fGammaIso_DR0p1To0p2;
318	>	Double_t fGammaIso_DR0p2To0p3;
319	>	Double_t fGammaIso_DR0p3To0p4;
320	>	Double_t fGammaIso_DR0p4To0p5;
321	>	Double_t fGammaIso_DR0p5To0p7;
322	>
323	>	Double_t fNeutralHadronIso_DR0p0To0p1;
324	>	Double_t fNeutralHadronIso_DR0p1To0p2;
325	>	Double_t fNeutralHadronIso_DR0p2To0p3;
326	>	Double_t fNeutralHadronIso_DR0p3To0p4;
327	>	Double_t fNeutralHadronIso_DR0p4To0p5;
328	>	Double_t fNeutralHadronIso_DR0p5To0p7;
329	>
330	>
331	>	//
332	>	//Loop over PF Candidates
333	>	//
334	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
335	>	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
336	>
337	>	Double_t deta = (mu->Eta() - pf->Eta());
338	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
339	>	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
340	>	if (dr > 1.0) continue;
341	>
342	>	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
343	>
344	>	//
345	>	// Lepton Footprint Removal
346	>	//
347	>	Bool_t IsLeptonFootprint = kFALSE;
348	>	if (dr < 1.0) {
349	>
350	>	//
351	>	// Check for electrons
352	>	//
353	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
354	>	const mithep::Electron *tmpele = electronsToVeto[q];
355	>	// 4l electron
356	>	if( pf->HasTrackerTrk() ) {
357	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
358	>	IsLeptonFootprint = kTRUE;
359	>	}
360	>	if( pf->HasGsfTrk() ) {
361	>	if( pf->GsfTrk() == tmpele->GsfTrk() )
362	>	IsLeptonFootprint = kTRUE;
363	>	}
364	>	// PF charged
365	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
366	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
367	>	IsLeptonFootprint = kTRUE;
368	>	// PF gamma
369	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
370	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
371	>	IsLeptonFootprint = kTRUE;
372	>	} // loop over electrons
373	>
374	>	//
375	>	// Check for muons
376	>	//
377	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
378	>	const mithep::Muon *tmpmu = muonsToVeto[q];
379	>	// 4l muon
380	>	if( pf->HasTrackerTrk() ) {
381	>	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
382	>	IsLeptonFootprint = kTRUE;
383	>	}
384	>	// PF charged
385	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
386	>	IsLeptonFootprint = kTRUE;
387	>	} // loop over muons
388	>
389	>
390	>	if (IsLeptonFootprint)
391	>	continue;
392	>
393	>	//
394	>	// Charged Iso Rings
395	>	//
396	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
397	>
398	>	if( dr < 0.01 ) continue; // only for muon iso mva?
399	>	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
400	>
401	>	if( pf->HasTrackerTrk() ) {
402	>	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
403	>	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
404	>	<< abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
405	>	<< dr << endl;
406	>	}
407	>	if( pf->HasGsfTrk() ) {
408	>	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
409	>	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
410	>	<< abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
411	>	<< dr << endl;
412	>	}
413	>
414	>	// Footprint Veto
415	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
416	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
417	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
418	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
419	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
420	>	if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
421	>	}
422	>
423	>	//
424	>	// Gamma Iso Rings
425	>	//
426	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
427	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
428	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
429	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
430	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
431	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
432	>	if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
433	>	}
434	>
435	>	//
436	>	// Other Neutral Iso Rings
437	>	//
438	>	else {
439	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
440	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
441	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
442	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
443	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
444	>	if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
445	>	}
446	>
447	>	}
448	>
449	>	}
450	>
451	>	fChargedIso_DR0p0To0p1   = min((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
452	>	fChargedIso_DR0p1To0p2   = min((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
453	>	fChargedIso_DR0p2To0p3   = min((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
454	>	fChargedIso_DR0p3To0p4   = min((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
455	>	fChargedIso_DR0p4To0p5   = min((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
456	>
457	>
458	>	double rho = 0;
459	>	if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
460	>	rho = fPUEnergyDensity->At(0)->Rho();
461	>
462	>
463	>	fGammaIso_DR0p0To0p1 = max(min((tmpGammaIso_DR0p0To0p1
464	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p0To0p1,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
465	>	,2.5)
466	>	,0.0);
467	>	fGammaIso_DR0p1To0p2 = max(min((tmpGammaIso_DR0p1To0p2
468	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p1To0p2,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
469	>	,2.5)
470	>	,0.0);
471	>	fGammaIso_DR0p2To0p3 = max(min((tmpGammaIso_DR0p2To0p3
472	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p2To0p3,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
473	>	,2.5)
474	>	,0.0);
475	>	fGammaIso_DR0p3To0p4 = max(min((tmpGammaIso_DR0p3To0p4
476	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p3To0p4,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
477	>	,2.5)
478	>	,0.0);
479	>	fGammaIso_DR0p4To0p5 = max(min((tmpGammaIso_DR0p4To0p5
480	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p4To0p5,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
481	>	,2.5)
482	>	,0.0);
483	>
484	>
485	>
486	>	fNeutralHadronIso_DR0p0To0p1 = max(min((tmpNeutralHadronIso_DR0p0To0p1
487	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p0To0p1,
488	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
489	>	, 2.5)
490	>	, 0.0);
491	>	fNeutralHadronIso_DR0p1To0p2 = max(min((tmpNeutralHadronIso_DR0p1To0p2
492	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p1To0p2,
493	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
494	>	, 2.5)
495	>	, 0.0);
496	>	fNeutralHadronIso_DR0p2To0p3 = max(min((tmpNeutralHadronIso_DR0p2To0p3
497	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p2To0p3,
498	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
499	>	, 2.5)
500	>	, 0.0);
501	>	fNeutralHadronIso_DR0p3To0p4 = max(min((tmpNeutralHadronIso_DR0p3To0p4
502	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p3To0p4,
503	>	mu->Eta(), EffectiveAreaVersion))/mu->Pt()
504	>	, 2.5)
505	>	, 0.0);
506	>	fNeutralHadronIso_DR0p4To0p5 = max(min((tmpNeutralHadronIso_DR0p4To0p5
507	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p4To0p5,
508	>	mu->Eta(), EffectiveAreaVersion))/mu->Pt()
509	>	, 2.5)
510	>	, 0.0);
511	>
512	>
513	>	double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
514	>	mu->Eta(),
515	>	fChargedIso_DR0p0To0p1,
516	>	fChargedIso_DR0p1To0p2,
517	>	fChargedIso_DR0p2To0p3,
518	>	fChargedIso_DR0p3To0p4,
519	>	fChargedIso_DR0p4To0p5,
520	>	fGammaIso_DR0p0To0p1,
521	>	fGammaIso_DR0p1To0p2,
522	>	fGammaIso_DR0p2To0p3,
523	>	fGammaIso_DR0p3To0p4,
524	>	fGammaIso_DR0p4To0p5,
525	>	fNeutralHadronIso_DR0p0To0p1,
526	>	fNeutralHadronIso_DR0p1To0p2,
527	>	fNeutralHadronIso_DR0p2To0p3,
528	>	fNeutralHadronIso_DR0p3To0p4,
529	>	fNeutralHadronIso_DR0p4To0p5,
530	>	ctrl.debug);
531	>
532	>	SelectionStatus status;
533	>	bool pass = false;
534	>
535	>	if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
536	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_FORPFID_CUT_BIN0)   pass = true;
537	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
538	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_FORPFID_CUT_BIN1)  pass = true;
539	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
540	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_FORPFID_CUT_BIN2)  pass = true;
541	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
542	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_FORPFID_CUT_BIN3)  pass = true;
543	>	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon()
544	>	&& mvaval >= MUON_ISOMVA_FORPFID_CUT_BIN4)
545	>	pass = true;
546	>
547	>
548	>	pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
549	>
550	>	if( pass ) {
551	>	status.orStatus(SelectionStatus::LOOSEISO);
552	>	status.orStatus(SelectionStatus::TIGHTISO);
553	>	}
554	>	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
555	>	return status;
556	>
557	>	}
558	>
559	>	//--------------------------------------------------------------------------------------------------
560	>	void initMuonIsoMVA() {
561	>	//--------------------------------------------------------------------------------------------------
562	>	muIsoMVA = new mithep::MuonIDMVA();
563	>	vector<string> weightFiles;
564	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_barrel_lowpt.weights.xml");
565	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_barrel_highpt.weights.xml");
566	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_endcap_lowpt.weights.xml");
567	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_endcap_highpt.weights.xml");
568	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_tracker.weights.xml");
569	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_global.weights.xml");
570	>	muIsoMVA->Initialize( "MuonIsoMVA",
571	>	mithep::MuonIDMVA::kIsoRingsV0,
572	>	kTRUE, weightFiles);
573	>	}
574	>
575	>
576	>
577	>	//--------------------------------------------------------------------------------------------------
578	>	SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
579	>	const mithep::Electron * ele,
580	>	const mithep::Vertex & vtx,
581	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
582	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
583	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
584	>	vector<const mithep::Muon*> muonsToVeto,
585	>	vector<const mithep::Electron*> electronsToVeto)
586	>	//--------------------------------------------------------------------------------------------------
587	>	{
588	>
589	>	if( ctrl.debug ) {
590	>	cout << "electronIsoMVASelection :: muons to veto " << endl;
591	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
592	>	const mithep::Muon * vmu = muonsToVeto[i];
593	>	cout << "\tpt: " << vmu->Pt()
594	>	<< "\teta: " << vmu->Eta()
595	>	<< "\tphi: " << vmu->Phi()
596	>	<< endl;
597	>	}
598	>	cout << "electronIsoMVASelection :: electrson to veto " << endl;
599	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
600	>	const mithep::Electron * vel = electronsToVeto[i];
601	>	cout << "\tpt: " << vel->Pt()
602	>	<< "\teta: " << vel->Eta()
603	>	<< "\tphi: " << vel->Phi()
604	>	<< "\ttrk: " << vel->TrackerTrk()
605	>	<< endl;
606	>	}
607	>	}
608	>
609	>	bool failiso=false;
610	>
611	>	//
612	>	// tmp iso rings
613	>	//
614	>	Double_t tmpChargedIso_DR0p0To0p1  = 0;
615	>	Double_t tmpChargedIso_DR0p1To0p2  = 0;
616	>	Double_t tmpChargedIso_DR0p2To0p3  = 0;
617	>	Double_t tmpChargedIso_DR0p3To0p4  = 0;
618	>	Double_t tmpChargedIso_DR0p4To0p5  = 0;
619	>	Double_t tmpChargedIso_DR0p5To0p7  = 0;
620	>
621	>	Double_t tmpGammaIso_DR0p0To0p1  = 0;
622	>	Double_t tmpGammaIso_DR0p1To0p2  = 0;
623	>	Double_t tmpGammaIso_DR0p2To0p3  = 0;
624	>	Double_t tmpGammaIso_DR0p3To0p4  = 0;
625	>	Double_t tmpGammaIso_DR0p4To0p5  = 0;
626	>	Double_t tmpGammaIso_DR0p5To0p7  = 0;
627	>
628	>	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
629	>	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
630	>	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
631	>	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
632	>	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
633	>	Double_t tmpNeutralHadronIso_DR0p5To0p7  = 0;
634	>
635	>
636	>
637	>	//
638	>	// final rings for the MVA
639	>	//
640	>	Double_t fChargedIso_DR0p0To0p1;
641	>	Double_t fChargedIso_DR0p1To0p2;
642	>	Double_t fChargedIso_DR0p2To0p3;
643	>	Double_t fChargedIso_DR0p3To0p4;
644	>	Double_t fChargedIso_DR0p4To0p5;
645	>
646	>	Double_t fGammaIso_DR0p0To0p1;
647	>	Double_t fGammaIso_DR0p1To0p2;
648	>	Double_t fGammaIso_DR0p2To0p3;
649	>	Double_t fGammaIso_DR0p3To0p4;
650	>	Double_t fGammaIso_DR0p4To0p5;
651	>
652	>	Double_t fNeutralHadronIso_DR0p0To0p1;
653	>	Double_t fNeutralHadronIso_DR0p1To0p2;
654	>	Double_t fNeutralHadronIso_DR0p2To0p3;
655	>	Double_t fNeutralHadronIso_DR0p3To0p4;
656	>	Double_t fNeutralHadronIso_DR0p4To0p5;
657	>
658	>
659	>	//
660	>	//Loop over PF Candidates
661	>	//
662	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
663	>	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
664	>	Double_t deta = (ele->Eta() - pf->Eta());
665	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
666	>	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
667	>	if (dr >= 0.5) continue;
668	>	if(ctrl.debug) {
669	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
670	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
671	>	cout << endl;
672	>	}
673	>
674	>
675	>	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
676	>	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
677	>
678	>
679	>	//
680	>	// Lepton Footprint Removal
681	>	//
682	>	Bool_t IsLeptonFootprint = kFALSE;
683	>	if (dr < 1.0) {
684	>
685	>	//
686	>	// Check for electrons
687	>	//
688	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
689	>	const mithep::Electron *tmpele = electronsToVeto[q];
690	>	// 4l electron
691	>	if( pf->HasTrackerTrk()  ) {
692	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
693	>	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
694	>	IsLeptonFootprint = kTRUE;
695	>	}
696	>	}
697	>	if( pf->HasGsfTrk()  ) {
698	>	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
699	>	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
700	>	IsLeptonFootprint = kTRUE;
701	>	}
702	>	}
703	>	// PF charged
704	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
705	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
706	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
707	>	IsLeptonFootprint = kTRUE;
708	>	}
709	>	// PF gamma
710	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
711	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
712	>	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
713	>	IsLeptonFootprint = kTRUE;
714	>	}
715	>	} // loop over electrons
716	>
717	>	//
718	>	// Check for muons
719	>	//
720	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
721	>	const mithep::Muon *tmpmu = muonsToVeto[q];
722	>	// 4l muon
723	>	if( pf->HasTrackerTrk() ) {
724	>	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
725	>	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
726	>	IsLeptonFootprint = kTRUE;
727	>	}
728	>	}
729	>	// PF charged
730	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
731	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
732	>	IsLeptonFootprint = kTRUE;
733	>	}
734	>	} // loop over muons
735	>
736	>
737	>	if (IsLeptonFootprint)
738	>	continue;
739	>
740	>	//
741	>	// Charged Iso Rings
742	>	//
743	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
744	>
745	>	if( pf->HasTrackerTrk() )
746	>	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
747	>	if( pf->HasGsfTrk() )
748	>	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
749	>
750	>	// Veto any PFmuon, or PFEle
751	>	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
752	>
753	>	// Footprint Veto
754	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
755	>
756	>	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
757	>	<< "\ttype: " << pf->PFType()
758	>	<< "\ttrk: " << pf->TrackerTrk() << endl;
759	>
760	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
761	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
762	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
763	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
764	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
765	>	if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
766	>
767	>	}
768	>
769	>	//
770	>	// Gamma Iso Rings
771	>	//
772	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
773	>
774	>	if (fabs(ele->SCluster()->Eta()) > 1.479) {
775	>	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
776	>	}
777	>
778	>	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
779	>	<< dr << endl;
780	>
781	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
782	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
783	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
784	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
785	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
786	>	if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
787	>
788	>	}
789	>
790	>	//
791	>	// Other Neutral Iso Rings
792	>	//
793	>	else {
794	>	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
795	>	<< dr << endl;
796	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
797	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
798	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
799	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
800	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
801	>	if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
802	>	}
803	>
804	>	}
805	>
806	>	}
807	>
808	>	fChargedIso_DR0p0To0p1   = min((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
809	>	fChargedIso_DR0p1To0p2   = min((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
810	>	fChargedIso_DR0p2To0p3   = min((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
811	>	fChargedIso_DR0p3To0p4   = min((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
812	>	fChargedIso_DR0p4To0p5   = min((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
813	>
814	>	double rho = 0;
815	>	if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
816	>	rho = fPUEnergyDensity->At(0)->Rho();
817	>
818	>	if( ctrl.debug) {
819	>	cout << "RHO: " << rho << endl;
820	>	cout << "eta: " << ele->SCluster()->Eta() << endl;
821	>	cout << "target: " << EffectiveAreaVersion << endl;
822	>	cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
823	>	ele->SCluster()->Eta(),
824	>	EffectiveAreaVersion)
825	>	<< endl;
826	>	cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
827	>	ele->SCluster()->Eta(),
828	>	EffectiveAreaVersion)
829	>	<< endl;
830	>	cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
831	>	ele->SCluster()->Eta(),
832	>	EffectiveAreaVersion)
833	>	<< endl;
834	>	cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
835	>	ele->SCluster()->Eta(),
836	>	EffectiveAreaVersion)
837	>	<< endl;
838	>	}
839	>
840	>	fGammaIso_DR0p0To0p1 = max(min((tmpGammaIso_DR0p0To0p1
841	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
842	>	ele->SCluster()->Eta(),
843	>	EffectiveAreaVersion))/ele->Pt()
844	>	,2.5)
845	>	,0.0);
846	>	fGammaIso_DR0p1To0p2 = max(min((tmpGammaIso_DR0p1To0p2
847	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
848	>	ele->SCluster()->Eta(),
849	>	EffectiveAreaVersion))/ele->Pt()
850	>	,2.5)
851	>	,0.0);
852	>	fGammaIso_DR0p2To0p3 = max(min((tmpGammaIso_DR0p2To0p3
853	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
854	>	ele->SCluster()->Eta()
855	>	,EffectiveAreaVersion))/ele->Pt()
856	>	,2.5)
857	>	,0.0);
858	>	fGammaIso_DR0p3To0p4 = max(min((tmpGammaIso_DR0p3To0p4
859	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
860	>	ele->SCluster()->Eta(),
861	>	EffectiveAreaVersion))/ele->Pt()
862	>	,2.5)
863	>	,0.0);
864	>	fGammaIso_DR0p4To0p5 = max(min((tmpGammaIso_DR0p4To0p5
865	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
866	>	ele->SCluster()->Eta(),
867	>	EffectiveAreaVersion))/ele->Pt()
868	>	,2.5)
869	>	,0.0);
870	>
871	>
872	>	fNeutralHadronIso_DR0p0To0p1 = max(min((tmpNeutralHadronIso_DR0p0To0p1
873	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
874	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
875	>	, 2.5)
876	>	, 0.0);
877	>	fNeutralHadronIso_DR0p1To0p2 = max(min((tmpNeutralHadronIso_DR0p1To0p2
878	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
879	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
880	>	, 2.5)
881	>	, 0.0);
882	>	fNeutralHadronIso_DR0p2To0p3 = max(min((tmpNeutralHadronIso_DR0p2To0p3
883	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
884	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
885	>	, 2.5)
886	>	, 0.0);
887	>	fNeutralHadronIso_DR0p3To0p4 = max(min((tmpNeutralHadronIso_DR0p3To0p4
888	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
889	>	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
890	>	, 2.5)
891	>	, 0.0);
892	>	fNeutralHadronIso_DR0p4To0p5 = max(min((tmpNeutralHadronIso_DR0p4To0p5
893	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
894	>	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
895	>	, 2.5)
896	>	, 0.0);
897	>
898	>	double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
899	>	ele->SCluster()->Eta(),
900	>	fChargedIso_DR0p0To0p1,
901	>	fChargedIso_DR0p1To0p2,
902	>	fChargedIso_DR0p2To0p3,
903	>	fChargedIso_DR0p3To0p4,
904	>	fChargedIso_DR0p4To0p5,
905	>	fGammaIso_DR0p0To0p1,
906	>	fGammaIso_DR0p1To0p2,
907	>	fGammaIso_DR0p2To0p3,
908	>	fGammaIso_DR0p3To0p4,
909	>	fGammaIso_DR0p4To0p5,
910	>	fNeutralHadronIso_DR0p0To0p1,
911	>	fNeutralHadronIso_DR0p1To0p2,
912	>	fNeutralHadronIso_DR0p2To0p3,
913	>	fNeutralHadronIso_DR0p3To0p4,
914	>	fNeutralHadronIso_DR0p4To0p5,
915	>	ctrl.debug);
916	>
917	>	SelectionStatus status;
918	>	bool pass = false;
919	>
920	>	Int_t subdet = 0;
921	>	if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
922	>	else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
923	>	else subdet = 2;
924	>	Int_t ptBin = 0;
925	>	if (ele->Pt() > 10.0) ptBin = 1;
926	>
927	>	Int_t MVABin = -1;
928	>	if (subdet == 0 && ptBin == 0) MVABin = 0;
929	>	if (subdet == 1 && ptBin == 0) MVABin = 1;
930	>	if (subdet == 2 && ptBin == 0) MVABin = 2;
931	>	if (subdet == 0 && ptBin == 1) MVABin = 3;
932	>	if (subdet == 1 && ptBin == 1) MVABin = 4;
933	>	if (subdet == 2 && ptBin == 1) MVABin = 5;
934	>
935	>	if( MVABin == 0 && mvaval > ELECTRON_ISOMVA_CUT_BIN0 ) pass = true;
936	>	if( MVABin == 1 && mvaval > ELECTRON_ISOMVA_CUT_BIN1 ) pass = true;
937	>	if( MVABin == 2 && mvaval > ELECTRON_ISOMVA_CUT_BIN2 ) pass = true;
938	>	if( MVABin == 3 && mvaval > ELECTRON_ISOMVA_CUT_BIN3 ) pass = true;
939	>	if( MVABin == 4 && mvaval > ELECTRON_ISOMVA_CUT_BIN4 ) pass = true;
940	>	if( MVABin == 5 && mvaval > ELECTRON_ISOMVA_CUT_BIN5 ) pass = true;
941	>
942	>	// pre-selection iso ...
943	>	pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
944	>
945	>	if( pass ) {
946	>	status.orStatus(SelectionStatus::LOOSEISO);
947	>	status.orStatus(SelectionStatus::TIGHTISO);
948		}
949		if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
950		return status;
951
952		}
953	+
954	+
955	+	//--------------------------------------------------------------------------------------------------
956	+	void initElectronIsoMVA() {
957	+	//--------------------------------------------------------------------------------------------------
958	+	eleIsoMVA = new mithep::ElectronIDMVA();
959	+	vector<string> weightFiles;
960	+	weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_BarrelPt5To10.weights.xml");
961	+	weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_EndcapPt5To10.weights.xml");
962	+	weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_BarrelPt10ToInf.weights.xml");
963	+	weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_EndcapPt10ToInf.weights.xml");
964	+	eleIsoMVA->Initialize( "ElectronIsoMVA",
965	+	mithep::ElectronIDMVA::kIsoRingsV0,
966	+	kTRUE, weightFiles);
967	+	}

Diff Legend

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