[ViewVC] Diff of: cvsroot/UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents):
Revision 1.18 by khahn, Sat May 12 03:00:14 2012 UTC vs.
Revision 1.35 by dkralph, Mon Dec 17 17:12:27 2012 UTC

#	Line 9 \| Line 9
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;
12	>	MuonIDMVA * muIsoMVA;
13	>	MuonTools muT;
14	>	ElectronIDMVA * eleIsoMVA;
15	>	ElectronTools eleT;
16
17		// global hack to sync
18		double gChargedIso;
19		double gGammaIso;
20		double gNeutralIso;
21
22	+	extern vector<bool> PFnoPUflag;
23
24		//--------------------------------------------------------------------------------------------------
25	<	Float_t computePFMuonIso(const mithep::Muon *muon,
26	<	const mithep::Vertex & vtx,
27	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
25	>	Float_t computePFMuonIso(const Muon *muon,
26	>	const Vertex * vtx,
27	>	const Array<PFCandidate> * fPFCandidates,
28		const Double_t dRMax)
29		//--------------------------------------------------------------------------------------------------
30		{
#	Line 33 \| Line 32 \| Float_t computePFMuonIso(const mithep::M
32		const Double_t neuPtMin = 1.0;
33		const Double_t dzMax = 0.1;
34
35	<	Double_t zLepton = (muon->BestTrk()) ? muon->BestTrk()->DzCorrected(vtx) : 0.0;
35	>	Double_t zLepton = (muon->BestTrk()) ? muon->BestTrk()->DzCorrected(*vtx) : 0.0;
36
37		Float_t iso=0;
38		for(UInt_t ipf=0; ipf<fPFCandidates->GetEntries(); ipf++) {
#	Line 45 \| Line 44 \| Float_t computePFMuonIso(const mithep::M
44		if(pfcand->TrackerTrk() && muon->TrackerTrk() && (pfcand->TrackerTrk()==muon->TrackerTrk())) continue;
45
46		// dz cut
47	<	Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(vtx) - zLepton) : 0;
47	>	Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(*vtx) - zLepton) : 0;
48		if(dz >= dzMax) continue;
49
50		// check iso cone
#	Line 58 \| Line 57 \| Float_t computePFMuonIso(const mithep::M
57		}
58
59		//--------------------------------------------------------------------------------------------------
60	<	Float_t computePFEleIso(const mithep::Electron *electron,
61	<	const mithep::Vertex & fVertex,
62	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
60	>	Float_t computePFEleIso(const Electron *electron,
61	>	const Vertex * fVertex,
62	>	const Array<PFCandidate> * fPFCandidates,
63		const Double_t dRMax)
64		//--------------------------------------------------------------------------------------------------
65		{
#	Line 68 \| Line 67 \| Float_t computePFEleIso(const mithep::El
67		const Double_t neuPtMin = 1.0;
68		const Double_t dzMax = 0.1;
69
70	<	Double_t zLepton = (electron->BestTrk()) ? electron->BestTrk()->DzCorrected(fVertex) : 0.0;
70	>	Double_t zLepton = (electron->BestTrk()) ? electron->BestTrk()->DzCorrected(*fVertex) : 0.0;
71
72		Float_t iso=0;
73		for(UInt_t ipf=0; ipf<fPFCandidates->GetEntries(); ipf++) {
#	Line 77 \| Line 76 \| Float_t computePFEleIso(const mithep::El
76		if(!pfcand->HasTrk() && (pfcand->Pt()<=neuPtMin)) continue; // pT cut on neutral particles
77
78		// dz cut
79	<	Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(fVertex) - zLepton) : 0;
79	>	Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(*fVertex) - zLepton) : 0;
80		if(dz >= dzMax) continue;
81
82		// remove THE electron
#	Line 100 \| Line 99 \| Float_t computePFEleIso(const mithep::El
99
100		return iso;
101		};
103	–
104	–	//--------------------------------------------------------------------------------------------------
105	–	bool pairwiseIsoSelection( ControlFlags &ctrl,
106	–	vector<SimpleLepton> &lepvec,
107	–	float rho )
108	–	//--------------------------------------------------------------------------------------------------
109	–	{
110	–
111	–	bool passiso=true;
112	–
113	–	for( int i=0; i<lepvec.size(); i++ )
114	–	{
115	–
116	–	if( !(lepvec[i].is4l) ) continue;
117	–
118	–	float effArea_ecal_i, effArea_hcal_i;
119	–	if( lepvec[i].isEB ) {
120	–	if( lepvec[i].type == 11 ) {
121	–	effArea_ecal_i = 0.101;
122	–	effArea_hcal_i = 0.021;
123	–	} else {
124	–	effArea_ecal_i = 0.074;
125	–	effArea_hcal_i = 0.022;
126	–	}
127	–	} else {
128	–	if( lepvec[i].type == 11 ) {
129	–	effArea_ecal_i = 0.046;
130	–	effArea_hcal_i = 0.040;
131	–	} else {
132	–	effArea_ecal_i = 0.045;
133	–	effArea_hcal_i = 0.030;
134	–	}
135	–	}
136	–
137	–	float isoEcal_corr_i = lepvec[i].isoEcal - (effArea_ecal_i*rho);
138	–	float isoHcal_corr_i = lepvec[i].isoHcal - (effArea_hcal_i*rho);
139	–
140	–	for( int j=i+1; j<lepvec.size(); j++ )
141	–	{
142	–
143	–	if( !(lepvec[j].is4l) ) continue;
144	–
145	–	float effArea_ecal_j, effArea_hcal_j;
146	–	if( lepvec[j].isEB ) {
147	–	if( lepvec[j].type == 11 ) {
148	–	effArea_ecal_j = 0.101;
149	–	effArea_hcal_j = 0.021;
150	–	} else {
151	–	effArea_ecal_j = 0.074;
152	–	effArea_hcal_j = 0.022;
153	–	}
154	–	} else {
155	–	if( lepvec[j].type == 11 ) {
156	–	effArea_ecal_j = 0.046;
157	–	effArea_hcal_j = 0.040;
158	–	} else {
159	–	effArea_ecal_j = 0.045;
160	–	effArea_hcal_j = 0.030;
161	–	}
162	–	}
163	–
164	–	float isoEcal_corr_j = lepvec[j].isoEcal - (effArea_ecal_j*rho);
165	–	float isoHcal_corr_j = lepvec[j].isoHcal - (effArea_hcal_j*rho);
166	–	float RIso_i = (lepvec[i].isoTrk+isoEcal_corr_i+isoHcal_corr_i)/lepvec[i].vec.Pt();
167	–	float RIso_j = (lepvec[j].isoTrk+isoEcal_corr_j+isoHcal_corr_j)/lepvec[j].vec.Pt();
168	–	float comboIso = RIso_i + RIso_j;
169	–
170	–	if( comboIso > 0.35 ) {
171	–	if( ctrl.debug ) cout << "combo failing for indices: " << i << "," << j << endl;
172	–	passiso = false;
173	–	return passiso;
174	–	}
175	–	}
176	–	}
177	–
178	–	return passiso;
179	–	}
180	–
102		//--------------------------------------------------------------------------------------------------
103		SelectionStatus muonIsoSelection(ControlFlags &ctrl,
104	<	const mithep::Muon * mu,
105	<	const mithep::Vertex & vtx,
106	<	const mithep::Array<mithep::PFCandidate> * fPFCandidateCol )
104	>	const Muon * mu,
105	>	const Vertex * vtx,
106	>	const Array<PFCandidate> * fPFCandidateCol )
107		//--------------------------------------------------------------------------------------------------
108		{
109		float reliso = computePFMuonIso(mu,vtx,fPFCandidateCol,0.3)/mu->Pt();
#	Line 210 \| Line 131 \| SelectionStatus muonIsoSelection(Control
131
132		//--------------------------------------------------------------------------------------------------
133		SelectionStatus electronIsoSelection(ControlFlags &ctrl,
134	<	const mithep::Electron * ele,
135	<	const mithep::Vertex &fVertex,
136	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates)
134	>	const Electron * ele,
135	>	const Vertex *fVertex,
136	>	const Array<PFCandidate> * fPFCandidates)
137		//--------------------------------------------------------------------------------------------------
138		{
139
#	Line 226 \| Line 147 \| SelectionStatus electronIsoSelection(Con
147		if( ele->IsEB() && ele->Pt() < 20 && reliso > PFISO_ELE_LOOSE_EB_LOWPT ) {
148		failiso = true;
149		}
229	–	if(ctrl.debug) cout << "before iso check ..." << endl;
150		if( !(ele->IsEB()) && ele->Pt() > 20 && reliso > PFISO_ELE_LOOSE_EE_HIGHPT ) {
231	–	if(ctrl.debug) cout << "\tit fails ..." << endl;
151		failiso = true;
152		}
153		if( !(ele->IsEB()) && ele->Pt() < 20 && reliso > PFISO_ELE_LOOSE_EE_LOWPT ) {
#	Line 253 \| Line 172 \| bool noIso(ControlFlags &, vector<Simple
172
173		//--------------------------------------------------------------------------------------------------
174		SelectionStatus muonIsoMVASelection(ControlFlags &ctrl,
175	<	const mithep::Muon * mu,
176	<	const mithep::Vertex & vtx,
177	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
178	<	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
179	<	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
180	<	vector<const mithep::Muon*> muonsToVeto,
181	<	vector<const mithep::Electron*> electronsToVeto)
175	>	const Muon * mu,
176	>	const Vertex * vtx,
177	>	const Array<PFCandidate> * fPFCandidates,
178	>	const Array<PileupEnergyDensity> * fPUEnergyDensity,
179	>	MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
180	>	vector<const Muon*> muonsToVeto,
181	>	vector<const Electron*> electronsToVeto)
182		//--------------------------------------------------------------------------------------------------
183		{
184
185		if( ctrl.debug ) {
186		cout << "muonIsoMVASelection :: muons to veto " << endl;
187		for( int i=0; i<muonsToVeto.size(); i++ ) {
188	<	const mithep::Muon * vmu = muonsToVeto[i];
188	>	const Muon * vmu = muonsToVeto[i];
189		cout << "\tpt: " << vmu->Pt()
190		<< "\teta: " << vmu->Eta()
191		<< "\tphi: " << vmu->Phi()
#	Line 274 \| Line 193 \| SelectionStatus muonIsoMVASelection(Cont
193		}
194		cout << "muonIsoMVASelection :: electrson to veto " << endl;
195		for( int i=0; i<electronsToVeto.size(); i++ ) {
196	<	const mithep::Electron * vel = electronsToVeto[i];
196	>	const Electron * vel = electronsToVeto[i];
197		cout << "\tpt: " << vel->Pt()
198		<< "\teta: " << vel->Eta()
199		<< "\tphi: " << vel->Phi()
#	Line 338 \| Line 257 \| SelectionStatus muonIsoMVASelection(Cont
257		//Loop over PF Candidates
258		//
259		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
260	<	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
260	>
261	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
262	>
263	>	const PFCandidate pf = (PFCandidate)((*fPFCandidates)[k]);
264
265		Double_t deta = (mu->Eta() - pf->Eta());
266	<	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
267	<	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
266	>	Double_t dphi = MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
267	>	Double_t dr = MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
268		if (dr > 1.0) continue;
269
270		if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
#	Line 357 \| Line 279 \| SelectionStatus muonIsoMVASelection(Cont
279		// Check for electrons
280		//
281		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
282	<	const mithep::Electron *tmpele = electronsToVeto[q];
282	>	const Electron *tmpele = electronsToVeto[q];
283		// 4l electron
284		if( pf->HasTrackerTrk() ) {
285		if( pf->TrackerTrk() == tmpele->TrackerTrk() )
#	Line 368 \| Line 290 \| SelectionStatus muonIsoMVASelection(Cont
290		IsLeptonFootprint = kTRUE;
291		}
292		// PF charged
293	<	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
294	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
293	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479
294	>	&& MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
295		IsLeptonFootprint = kTRUE;
296		// PF gamma
297	<	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
298	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
297	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
298	>	&& MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
299		IsLeptonFootprint = kTRUE;
300		} // loop over electrons
301
#	Line 382 \| Line 304 \| SelectionStatus muonIsoMVASelection(Cont
304		// Check for muons
305		//
306		for (Int_t q=0; q < muonsToVeto.size(); ++q) {
307	<	const mithep::Muon *tmpmu = muonsToVeto[q];
307	>	const Muon *tmpmu = muonsToVeto[q];
308		// 4l muon
309		if( pf->HasTrackerTrk() ) {
310		if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
311		IsLeptonFootprint = kTRUE;
312		}
313		// PF charged
314	<	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
314	>	if (pf->Charge() != 0 && MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
315		IsLeptonFootprint = kTRUE;
316		} // loop over muons
317		*/
#	Line 402 \| Line 324 \| SelectionStatus muonIsoMVASelection(Cont
324		//
325		if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
326
327	<	// if( dr < 0.01 ) continue; // only for muon iso mva?
327	>	if( dr < 0.01 ) continue; // only for muon iso mva?
328		if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
329
330	<	if( pf->HasTrackerTrk() ) {
331	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
332	<	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
333	<	<< abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
334	<	<< dr << endl;
335	<	}
336	<	if( pf->HasGsfTrk() ) {
337	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
338	<	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
339	<	<< abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
340	<	<< dr << endl;
341	<	}
330	>	// if( pf->HasTrackerTrk() ) {
331	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
332	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
333	>	// << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
334	>	// << dr << endl;
335	>	// }
336	>	// if( pf->HasGsfTrk() ) {
337	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
338	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
339	>	// << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
340	>	// << dr << endl;
341	>	// }
342
343		// Footprint Veto
344		if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
#	Line 455 \| Line 377 \| SelectionStatus muonIsoMVASelection(Cont
377
378		}
379
380	<	fChargedIso_DR0p0To0p1 = min((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
381	<	fChargedIso_DR0p1To0p2 = min((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
382	<	fChargedIso_DR0p2To0p3 = min((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
383	<	fChargedIso_DR0p3To0p4 = min((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
384	<	fChargedIso_DR0p4To0p5 = min((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
380	>	fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
381	>	fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
382	>	fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
383	>	fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
384	>	fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
385
386
387		double rho = 0;
388		if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
389		rho = fPUEnergyDensity->At(0)->Rho();
390	+
391		// if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
392		// rho = fPUEnergyDensity->At(0)->RhoLowEta();
393
#	Line 474 \| Line 397 \| SelectionStatus muonIsoMVASelection(Cont
397		// WARNING!!!!
398
399
400	<	fGammaIso_DR0p0To0p1 = max(min((tmpGammaIso_DR0p0To0p1
400	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
401		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p0To0p1,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
402		,2.5)
403		,0.0);
404	<	fGammaIso_DR0p1To0p2 = max(min((tmpGammaIso_DR0p1To0p2
404	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
405		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p1To0p2,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
406		,2.5)
407		,0.0);
408	<	fGammaIso_DR0p2To0p3 = max(min((tmpGammaIso_DR0p2To0p3
408	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
409		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p2To0p3,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
410		,2.5)
411		,0.0);
412	<	fGammaIso_DR0p3To0p4 = max(min((tmpGammaIso_DR0p3To0p4
412	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
413		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p3To0p4,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
414		,2.5)
415		,0.0);
416	<	fGammaIso_DR0p4To0p5 = max(min((tmpGammaIso_DR0p4To0p5
416	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
417		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p4To0p5,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
418		,2.5)
419		,0.0);
420
421
422
423	<	fNeutralHadronIso_DR0p0To0p1 = max(min((tmpNeutralHadronIso_DR0p0To0p1
423	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
424		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p0To0p1,
425		mu->Eta(),EffectiveAreaVersion))/mu->Pt()
426		, 2.5)
427		, 0.0);
428	<	fNeutralHadronIso_DR0p1To0p2 = max(min((tmpNeutralHadronIso_DR0p1To0p2
428	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
429		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p1To0p2,
430		mu->Eta(),EffectiveAreaVersion))/mu->Pt()
431		, 2.5)
432		, 0.0);
433	<	fNeutralHadronIso_DR0p2To0p3 = max(min((tmpNeutralHadronIso_DR0p2To0p3
433	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
434		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p2To0p3,
435		mu->Eta(),EffectiveAreaVersion))/mu->Pt()
436		, 2.5)
437		, 0.0);
438	<	fNeutralHadronIso_DR0p3To0p4 = max(min((tmpNeutralHadronIso_DR0p3To0p4
438	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
439		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p3To0p4,
440		mu->Eta(), EffectiveAreaVersion))/mu->Pt()
441		, 2.5)
442		, 0.0);
443	<	fNeutralHadronIso_DR0p4To0p5 = max(min((tmpNeutralHadronIso_DR0p4To0p5
443	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
444		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p4To0p5,
445		mu->Eta(), EffectiveAreaVersion))/mu->Pt()
446		, 2.5)
#	Line 550 \| Line 473 \| SelectionStatus muonIsoMVASelection(Cont
473
474		pass = false;
475		if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
476	<	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN0) pass = true;
476	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN0) pass = true;
477		else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
478	<	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN1) pass = true;
478	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN1) pass = true;
479		else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
480	<	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN2) pass = true;
480	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN2) pass = true;
481		else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
482	<	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN3) pass = true;
483	<	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN4) pass = true;
484	<	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN5) pass = true;
482	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN3) pass = true;
483	>	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN4) pass = true;
484	>	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN5) pass = true;
485		if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
486
487	+	/*
488		pass = false;
489		if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
490		&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN0) pass = true;
#	Line 573 \| Line 497 \| SelectionStatus muonIsoMVASelection(Cont
497		else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN4) pass = true;
498		else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN5) pass = true;
499		if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
500	+	*/
501
502		// pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
503
504	<	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
580	<	return status;
504	>	status.isoMVA = mvaval;
505
506	<	}
506	>	if(ctrl.debug) {
507	>	cout << "returning status : " << hex << status.getStatus() << dec << endl;
508	>	cout << "MVAVAL : " << status.isoMVA << endl;
509	>	}
510	>	return status;
511
584	–	//--------------------------------------------------------------------------------------------------
585	–	void initMuonIsoMVA() {
586	–	//--------------------------------------------------------------------------------------------------
587	–	muIsoMVA = new mithep::MuonIDMVA();
588	–	vector<string> weightFiles;
589	–	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_barrel_lowpt.weights.xml");
590	–	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_barrel_highpt.weights.xml");
591	–	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_endcap_lowpt.weights.xml");
592	–	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_endcap_highpt.weights.xml");
593	–	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_tracker.weights.xml");
594	–	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_global.weights.xml");
595	–	muIsoMVA->Initialize( "MuonIsoMVA",
596	–	mithep::MuonIDMVA::kIsoRingsV0,
597	–	kTRUE, weightFiles);
512		}
513
514
515		//--------------------------------------------------------------------------------------------------
516	<	double muonPFIso04(ControlFlags &ctrl,
517	<	const mithep::Muon * mu,
518	<	const mithep::Vertex & vtx,
519	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
520	<	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
521	<	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
522	<	vector<const mithep::Muon*> muonsToVeto,
523	<	vector<const mithep::Electron*> electronsToVeto)
516	>	SelectionStatus muonIsoMVASelection(ControlFlags &ctrl,
517	>	const Muon * mu,
518	>	const Vertex * vtx,
519	>	const Array<PFCandidate> * fPFCandidates,
520	>	float rho,
521	>	//const Array<PileupEnergyDensity> * fPUEnergyDensity,
522	>	MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
523	>	vector<const Muon*> muonsToVeto,
524	>	vector<const Electron*> electronsToVeto)
525		//--------------------------------------------------------------------------------------------------
526	+	// hacked version
527		{
528	<
528	>
529		if( ctrl.debug ) {
530		cout << "muonIsoMVASelection :: muons to veto " << endl;
531		for( int i=0; i<muonsToVeto.size(); i++ ) {
532	<	const mithep::Muon * vmu = muonsToVeto[i];
532	>	const Muon * vmu = muonsToVeto[i];
533		cout << "\tpt: " << vmu->Pt()
534		<< "\teta: " << vmu->Eta()
535		<< "\tphi: " << vmu->Phi()
#	Line 621 \| Line 537 \| double muonPFIso04(ControlFlags &ctrl,
537		}
538		cout << "muonIsoMVASelection :: electrson to veto " << endl;
539		for( int i=0; i<electronsToVeto.size(); i++ ) {
540	<	const mithep::Electron * vel = electronsToVeto[i];
540	>	const Electron * vel = electronsToVeto[i];
541		cout << "\tpt: " << vel->Pt()
542		<< "\teta: " << vel->Eta()
543		<< "\tphi: " << vel->Phi()
544		<< endl;
545		}
546		}
547	+	bool failiso=false;
548
549		//
550	<	// final iso
550	>	// tmp iso rings
551		//
552	<	Double_t fChargedIso = 0.0;
553	<	Double_t fGammaIso = 0.0;
554	<	Double_t fNeutralHadronIso = 0.0;
552	>	Double_t tmpChargedIso_DR0p0To0p1 = 0;
553	>	Double_t tmpChargedIso_DR0p1To0p2 = 0;
554	>	Double_t tmpChargedIso_DR0p2To0p3 = 0;
555	>	Double_t tmpChargedIso_DR0p3To0p4 = 0;
556	>	Double_t tmpChargedIso_DR0p4To0p5 = 0;
557	>	Double_t tmpChargedIso_DR0p5To0p7 = 0;
558	>
559	>	Double_t tmpGammaIso_DR0p0To0p1 = 0;
560	>	Double_t tmpGammaIso_DR0p1To0p2 = 0;
561	>	Double_t tmpGammaIso_DR0p2To0p3 = 0;
562	>	Double_t tmpGammaIso_DR0p3To0p4 = 0;
563	>	Double_t tmpGammaIso_DR0p4To0p5 = 0;
564	>	Double_t tmpGammaIso_DR0p5To0p7 = 0;
565	>
566	>	Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
567	>	Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
568	>	Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
569	>	Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
570	>	Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
571	>	Double_t tmpNeutralHadronIso_DR0p5To0p7 = 0;
572	>
573	>
574	>
575	>	//
576	>	// final rings for the MVA
577	>	//
578	>	Double_t fChargedIso_DR0p0To0p1;
579	>	Double_t fChargedIso_DR0p1To0p2;
580	>	Double_t fChargedIso_DR0p2To0p3;
581	>	Double_t fChargedIso_DR0p3To0p4;
582	>	Double_t fChargedIso_DR0p4To0p5;
583	>	Double_t fChargedIso_DR0p5To0p7;
584	>
585	>	Double_t fGammaIso_DR0p0To0p1;
586	>	Double_t fGammaIso_DR0p1To0p2;
587	>	Double_t fGammaIso_DR0p2To0p3;
588	>	Double_t fGammaIso_DR0p3To0p4;
589	>	Double_t fGammaIso_DR0p4To0p5;
590	>	Double_t fGammaIso_DR0p5To0p7;
591	>
592	>	Double_t fNeutralHadronIso_DR0p0To0p1;
593	>	Double_t fNeutralHadronIso_DR0p1To0p2;
594	>	Double_t fNeutralHadronIso_DR0p2To0p3;
595	>	Double_t fNeutralHadronIso_DR0p3To0p4;
596	>	Double_t fNeutralHadronIso_DR0p4To0p5;
597	>	Double_t fNeutralHadronIso_DR0p5To0p7;
598	>
599
600		//
601		//Loop over PF Candidates
602		//
603		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
604	<	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
604	>
605	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
606	>
607	>	const PFCandidate pf = (PFCandidate)((*fPFCandidates)[k]);
608
609		Double_t deta = (mu->Eta() - pf->Eta());
610	<	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
611	<	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
612	<	if (dr > 0.4) continue;
610	>	Double_t dphi = MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
611	>	Double_t dr = MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
612	>	if (dr > 1.0) continue;
613
614		if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
615
#	Line 659 \| Line 623 \| double muonPFIso04(ControlFlags &ctrl,
623		// Check for electrons
624		//
625		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
626	<	const mithep::Electron *tmpele = electronsToVeto[q];
626	>	const Electron *tmpele = electronsToVeto[q];
627		// 4l electron
628		if( pf->HasTrackerTrk() ) {
629		if( pf->TrackerTrk() == tmpele->TrackerTrk() )
#	Line 670 \| Line 634 \| double muonPFIso04(ControlFlags &ctrl,
634		IsLeptonFootprint = kTRUE;
635		}
636		// PF charged
637	<	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
638	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
637	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479
638	>	&& MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
639		IsLeptonFootprint = kTRUE;
640		// PF gamma
641	<	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
642	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
641	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
642	>	&& MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
643		IsLeptonFootprint = kTRUE;
644		} // loop over electrons
645	<
646	<	// KH, comment to sync
683	<	/*
645	>
646	>	/* KH - commented for sync
647		//
648		// Check for muons
649		//
650		for (Int_t q=0; q < muonsToVeto.size(); ++q) {
651	<	const mithep::Muon *tmpmu = muonsToVeto[q];
651	>	const Muon *tmpmu = muonsToVeto[q];
652		// 4l muon
653		if( pf->HasTrackerTrk() ) {
654		if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
655		IsLeptonFootprint = kTRUE;
656		}
657		// PF charged
658	<	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
658	>	if (pf->Charge() != 0 && MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
659		IsLeptonFootprint = kTRUE;
660		} // loop over muons
661		*/
#	Line 701 \| Line 664 \| double muonPFIso04(ControlFlags &ctrl,
664		continue;
665
666		//
667	<	// Charged Iso
667	>	// Charged Iso Rings
668		//
669	<	if (pf->Charge() != 0 ) {
669	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
670
671	<	//if( dr < 0.01 ) continue; // only for muon iso mva?
671	>	if( dr < 0.01 ) continue; // only for muon iso mva?
672		if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
673
674	<	if( pf->HasTrackerTrk() ) {
675	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
676	<	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
677	<	<< abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
678	<	<< dr << endl;
679	<	}
680	<	if( pf->HasGsfTrk() ) {
681	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
682	<	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
683	<	<< abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
684	<	<< dr << endl;
685	<	}
723	<
674	>	// if( pf->HasTrackerTrk() ) {
675	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
676	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
677	>	// << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
678	>	// << dr << endl;
679	>	// }
680	>	// if( pf->HasGsfTrk() ) {
681	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
682	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
683	>	// << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
684	>	// << dr << endl;
685	>	// }
686
687	<	fChargedIso += pf->Pt();
687	>	// Footprint Veto
688	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
689	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
690	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
691	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
692	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
693	>	if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
694		}
695
696		//
697	<	// Gamma Iso
697	>	// Gamma Iso Rings
698		//
699		else if (abs(pf->PFType()) == PFCandidate::eGamma) {
700	<	// KH, add to sync
701	<	if( pf->Pt() > 0.5 )
702	<	fGammaIso += pf->Pt();
700	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
701	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
702	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
703	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
704	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
705	>	if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
706		}
707
708		//
709	<	// Other Neutrals
709	>	// Other Neutral Iso Rings
710		//
711		else {
712	<	// KH, add to sync
713	<	if( pf->Pt() > 0.5 )
714	<	fNeutralHadronIso += pf->Pt();
712	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
713	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
714	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
715	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
716	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
717	>	if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
718		}
719	<
719	>
720		}
721	<
721	>
722		}
749	–
750	–	double rho = 0;
751	–	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
752	–	// rho = fPUEnergyDensity->At(0)->Rho();
753	–	if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
754	–	rho = fPUEnergyDensity->At(0)->RhoLowEta();
723
724	+	fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
725	+	fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
726	+	fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
727	+	fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
728	+	fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
729	+
730	+
731	+	// double rho = 0;
732	+	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
733	+	// rho = fPUEnergyDensity->At(0)->Rho();
734	+	// if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
735	+	// rho = fPUEnergyDensity->At(0)->RhoLowEta();
736	+
737		// WARNING!!!!
738		// hardcode for sync ...
739		EffectiveAreaVersion = muT.kMuEAData2011;
740		// WARNING!!!!
741
742	+
743	+	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
744	+	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p0To0p1,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
745	+	,2.5)
746	+	,0.0);
747	+	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
748	+	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p1To0p2,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
749	+	,2.5)
750	+	,0.0);
751	+	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
752	+	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p2To0p3,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
753	+	,2.5)
754	+	,0.0);
755	+	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
756	+	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p3To0p4,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
757	+	,2.5)
758	+	,0.0);
759	+	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
760	+	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p4To0p5,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
761	+	,2.5)
762	+	,0.0);
763	+
764
762	–	double pfIso = fChargedIso + max(0.0,(fGammaIso + fNeutralHadronIso
763	–	-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
764	–	mu->Eta(),EffectiveAreaVersion)));
765
766	<	gChargedIso = fChargedIso;
767	<	gGammaIso = fGammaIso;
768	<	gNeutralIso = fNeutralHadronIso;
769	<	return pfIso;
766	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
767	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p0To0p1,
768	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
769	>	, 2.5)
770	>	, 0.0);
771	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
772	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p1To0p2,
773	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
774	>	, 2.5)
775	>	, 0.0);
776	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
777	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p2To0p3,
778	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
779	>	, 2.5)
780	>	, 0.0);
781	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
782	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p3To0p4,
783	>	mu->Eta(), EffectiveAreaVersion))/mu->Pt()
784	>	, 2.5)
785	>	, 0.0);
786	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
787	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p4To0p5,
788	>	mu->Eta(), EffectiveAreaVersion))/mu->Pt()
789	>	, 2.5)
790	>	, 0.0);
791	>
792	>
793	>	double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
794	>	mu->Eta(),
795	>	mu->IsGlobalMuon(),
796	>	mu->IsTrackerMuon(),
797	>	fChargedIso_DR0p0To0p1,
798	>	fChargedIso_DR0p1To0p2,
799	>	fChargedIso_DR0p2To0p3,
800	>	fChargedIso_DR0p3To0p4,
801	>	fChargedIso_DR0p4To0p5,
802	>	fGammaIso_DR0p0To0p1,
803	>	fGammaIso_DR0p1To0p2,
804	>	fGammaIso_DR0p2To0p3,
805	>	fGammaIso_DR0p3To0p4,
806	>	fGammaIso_DR0p4To0p5,
807	>	fNeutralHadronIso_DR0p0To0p1,
808	>	fNeutralHadronIso_DR0p1To0p2,
809	>	fNeutralHadronIso_DR0p2To0p3,
810	>	fNeutralHadronIso_DR0p3To0p4,
811	>	fNeutralHadronIso_DR0p4To0p5,
812	>	ctrl.debug);
813	>
814	>	SelectionStatus status;
815	>	bool pass;
816	>
817	>	pass = false;
818	>	if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
819	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN0) pass = true;
820	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
821	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN1) pass = true;
822	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
823	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN2) pass = true;
824	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
825	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN3) pass = true;
826	>	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN4) pass = true;
827	>	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN5) pass = true;
828	>	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
829	>
830	>	/*
831	>	pass = false;
832	>	if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
833	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN0) pass = true;
834	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
835	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN1) pass = true;
836	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
837	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN2) pass = true;
838	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
839	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN3) pass = true;
840	>	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN4) pass = true;
841	>	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN5) pass = true;
842	>	if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
843	>	*/
844	>
845	>	// pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
846	>
847	>	status.isoMVA = mvaval;
848	>
849	>	if(ctrl.debug) {
850	>	cout << "returning status : " << hex << status.getStatus() << dec << endl;
851	>	cout << "MVAVAL : " << status.isoMVA << endl;
852	>	}
853	>	return status;
854	>
855		}
856
857
858		//--------------------------------------------------------------------------------------------------
859	<	// hacked version
859	>	void initMuonIsoMVA() {
860	>	//--------------------------------------------------------------------------------------------------
861	>	muIsoMVA = new MuonIDMVA();
862	>	vector<string> weightFiles;
863	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_barrel_lowpt.weights.xml");
864	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_barrel_highpt.weights.xml");
865	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_endcap_lowpt.weights.xml");
866	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_endcap_highpt.weights.xml");
867	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_tracker.weights.xml");
868	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_global.weights.xml");
869	>	muIsoMVA->Initialize( "MuonIsoMVA",
870	>	MuonIDMVA::kIsoRingsV0,
871	>	kTRUE, weightFiles);
872	>	}
873	>
874	>
875	>
876	>	//--------------------------------------------------------------------------------------------------
877		double muonPFIso04(ControlFlags &ctrl,
878	<	const mithep::Muon * mu,
879	<	const mithep::Vertex & vtx,
880	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
881	<	float rho,
882	<	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
883	<	vector<const mithep::Muon*> muonsToVeto,
782	<	vector<const mithep::Electron*> electronsToVeto)
878	>	const Muon * mu,
879	>	const Vertex * vtx,
880	>	const Array<PFCandidate> * fPFCandidates,
881	>	const Array<PileupEnergyDensity> * fPUEnergyDensity,
882	>	MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
883	>	vector<const PFCandidate*> photonsToVeto)
884		//--------------------------------------------------------------------------------------------------
885		{
886
887		extern double gChargedIso;
888		extern double gGammaIso;
889		extern double gNeutralIso;
789	–
790	–	if( ctrl.debug ) {
791	–	cout << "muonIsoMVASelection :: muons to veto " << endl;
792	–	for( int i=0; i<muonsToVeto.size(); i++ ) {
793	–	const mithep::Muon * vmu = muonsToVeto[i];
794	–	cout << "\tpt: " << vmu->Pt()
795	–	<< "\teta: " << vmu->Eta()
796	–	<< "\tphi: " << vmu->Phi()
797	–	<< endl;
798	–	}
799	–	cout << "muonIsoMVASelection :: electrson to veto " << endl;
800	–	for( int i=0; i<electronsToVeto.size(); i++ ) {
801	–	const mithep::Electron * vel = electronsToVeto[i];
802	–	cout << "\tpt: " << vel->Pt()
803	–	<< "\teta: " << vel->Eta()
804	–	<< "\tphi: " << vel->Phi()
805	–	<< endl;
806	–	}
807	–	}
890
891		//
892		// final iso
#	Line 816 \| Line 898 \| double muonPFIso04(ControlFlags &ctrl,
898		//
899		//Loop over PF Candidates
900		//
901	+	if(ctrl.debug) cout << " muonPFIso04(): ----> " << endl;
902		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
820	–	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
903
904	<	Double_t deta = (mu->Eta() - pf->Eta());
905	<	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
824	<	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
825	<	if (dr > 0.4) continue;
826	<
827	<	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
904	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
905	>	const PFCandidate pf = (PFCandidate)((*fPFCandidates)[k]);
906
907		//
908	<	// Lepton Footprint Removal
908	>	// veto FSR recovered photons
909	>	//
910	>	bool vetoPhoton = false;
911	>	for( int p=0; p<photonsToVeto.size(); p++ ) {
912	>	if( pf == photonsToVeto[p] ) {
913	>	vetoPhoton = true;
914	>	break;
915	>	}
916	>	} if( vetoPhoton ) continue;
917	>	//
918	>	//
919		//
832	–	Bool_t IsLeptonFootprint = kFALSE;
833	–	if (dr < 1.0) {
834	–
835	–	//
836	–	// Check for electrons
837	–	//
838	–	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
839	–	const mithep::Electron *tmpele = electronsToVeto[q];
840	–	// 4l electron
841	–	if( pf->HasTrackerTrk() ) {
842	–	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
843	–	IsLeptonFootprint = kTRUE;
844	–	}
845	–	if( pf->HasGsfTrk() ) {
846	–	if( pf->GsfTrk() == tmpele->GsfTrk() )
847	–	IsLeptonFootprint = kTRUE;
848	–	}
849	–	// PF charged
850	–	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
851	–	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
852	–	IsLeptonFootprint = kTRUE;
853	–	// PF gamma
854	–	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
855	–	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
856	–	IsLeptonFootprint = kTRUE;
857	–	} // loop over electrons
920
921	<	/* KH - comment for sync
922	<	//
923	<	// Check for muons
924	<	//
863	<	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
864	<	const mithep::Muon *tmpmu = muonsToVeto[q];
865	<	// 4l muon
866	<	if( pf->HasTrackerTrk() ) {
867	<	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
868	<	IsLeptonFootprint = kTRUE;
869	<	}
870	<	// PF charged
871	<	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
872	<	IsLeptonFootprint = kTRUE;
873	<	} // loop over muons
874	<	*/
921	>	Double_t deta = (mu->Eta() - pf->Eta());
922	>	Double_t dphi = MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
923	>	Double_t dr = MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
924	>	if (dr > 0.4) continue;
925
926	<	if (IsLeptonFootprint)
877	<	continue;
926	>	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
927
928		//
929		// Charged Iso
930		//
931		if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
932
933	<	if( dr < 0.01 ) continue; // only for muon iso mva?
933	>	//if( dr < 0.01 ) continue; // only for muon iso mva?
934		if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
886	–
887	–	if( pf->HasTrackerTrk() ) {
888	–	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
889	–	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
890	–	<< abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
891	–	<< dr << endl;
892	–	}
893	–	if( pf->HasGsfTrk() ) {
894	–	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
895	–	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
896	–	<< abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
897	–	<< dr << endl;
898	–	}
899	–
900	–
935		fChargedIso += pf->Pt();
936		}
937	<
937	>
938		//
939		// Gamma Iso
940		//
941		else if (abs(pf->PFType()) == PFCandidate::eGamma) {
942	<	if( pf->Pt() > 0.5 )
942	>	// KH, add to sync
943	>	if( pf->Pt() > 0.5 && dr > 0.01)
944		fGammaIso += pf->Pt();
945		}
946	<
946	>
947		//
948		// Other Neutrals
949		//
950		else {
951	<	// KH, add to sync
952	<	if( pf->Pt() > 0.5 )
951	>
952	>	if( pf->Pt() > 0.5 && dr > 0.01)
953		fNeutralHadronIso += pf->Pt();
954		}
920	–
921	–	}
922	–
955		}
924	–
925	–	// double rho = 0;
926	–	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
927	–	// rho = fPUEnergyDensity->At(0)->Rho();
928	–
929	–	// WARNING!!!!
930	–	// hardcode for sync ...
931	–	EffectiveAreaVersion = muT.kMuEAData2011;
932	–	// WARNING!!!!
956
957	+	double rho=0;
958	+	if( (EffectiveAreaVersion == MuonTools::kMuEAFall11MC) \|\|
959	+	(EffectiveAreaVersion == MuonTools::kMuEAData2011) ) {
960	+	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25()) \|\|
961	+	isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25())))
962	+	rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25();
963	+	//rho = fPUEnergyDensity->At(0)->Rho();
964	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
965	+	EffectiveAreaVersion = MuonTools::kMuEAData2011;
966	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
967	+	} else {
968	+	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral()) \|\|
969	+	isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral())))
970	+	rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral();
971	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
972	+	EffectiveAreaVersion = MuonTools::kMuEAData2012;
973	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
974	+	}
975	+	// if(ctrl.debug) cout << " rho: " << rho << endl;
976	+
977	+	TLorentzVector tmpvec;
978	+	tmpvec.SetPtEtaPhiM(mu->Pt(),mu->Eta(),mu->Phi(),mu->Mass());
979	+	for( int p=0; p<photonsToVeto.size(); p++ ) {
980	+	const PFCandidate * pf = photonsToVeto[p];
981	+	TLorentzVector pfvec;
982	+	pfvec.SetPtEtaPhiM(pf->Pt(),pf->Eta(),pf->Phi(),0.);
983	+	tmpvec += pfvec;
984	+	}
985
986	<	double pfIso = fChargedIso + max(0.0,(fGammaIso + fNeutralHadronIso
986	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
987		-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
988	<	mu->Eta(),EffectiveAreaVersion)));
988	>	//tmpvec.Eta(),EffectiveAreaVersion)));
989	>	mu->Eta(),EffectiveAreaVersion)));
990		gChargedIso = fChargedIso;
991		gGammaIso = fGammaIso;
992		gNeutralIso = fNeutralHadronIso;
993
994	+	if( ctrl.debug ) {
995	+	cout << " PFiso: " << pfIso
996	+	<< setw(9) << setprecision(4) << fChargedIso
997	+	<< setw(9) << setprecision(4) << fGammaIso
998	+	<< setw(9) << setprecision(4) << fNeutralHadronIso
999	+	<< endl;
1000	+	}
1001	+
1002		return pfIso;
1003		}
1004
945	–
1005		//--------------------------------------------------------------------------------------------------
1006		SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1007	<	const mithep::Muon * mu,
1008	<	const mithep::Vertex & vtx,
1009	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1010	<	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1011	<	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1012	<	vector<const mithep::Muon*> muonsToVeto,
954	<	vector<const mithep::Electron*> electronsToVeto)
1007	>	const Muon * mu,
1008	>	const Vertex * vtx,
1009	>	const Array<PFCandidate> * fPFCandidates,
1010	>	const Array<PileupEnergyDensity> * fPUEnergyDensity,
1011	>	MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1012	>	vector<const PFCandidate*> photonsToVeto)
1013		//--------------------------------------------------------------------------------------------------
1014		{
1015
1016		SelectionStatus status;
1017
1018		double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, fPUEnergyDensity,
1019	<	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
962	<	cout << "--------------> setting muon isoPF04 to" << pfIso << endl;
1019	>	EffectiveAreaVersion, photonsToVeto);
1020		status.isoPF04 = pfIso;
1021		status.chisoPF04 = gChargedIso;
1022		status.gaisoPF04 = gGammaIso;
#	Line 972 \| Line 1029 \| SelectionStatus muonReferenceIsoSelectio
1029		status.orStatus(SelectionStatus::LOOSEISO);
1030		status.orStatus(SelectionStatus::TIGHTISO);
1031		}
1032	<	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1033	<	return status;
977	<
978	<	}
979	<
980	<
981	<	//--------------------------------------------------------------------------------------------------
982	<	// hacked version
983	<	SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
984	<	const mithep::Muon * mu,
985	<	const mithep::Vertex & vtx,
986	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
987	<	float rho,
988	<	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
989	<	vector<const mithep::Muon*> muonsToVeto,
990	<	vector<const mithep::Electron*> electronsToVeto)
991	<	//--------------------------------------------------------------------------------------------------
992	<	{
993	<
994	<	SelectionStatus status;
995	<
996	<	double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, rho,
997	<	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
998	<	bool pass = false;
999	<	if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1000	<
1001	<	if( pass ) {
1002	<	status.orStatus(SelectionStatus::LOOSEISO);
1003	<	status.orStatus(SelectionStatus::TIGHTISO);
1004	<	}
1005	<	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1032	>	if(ctrl.debug)
1033	>	cout << " --> mu relpfIso: " << pfIso/mu->Pt() << ", returning status : " << hex << status.getStatus() << dec << endl;
1034		return status;
1007	–
1035		}
1036
1010	–
1011	–
1037		//--------------------------------------------------------------------------------------------------
1038		SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1039	<	const mithep::Electron * ele,
1040	<	const mithep::Vertex & vtx,
1041	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1042	<	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1043	<	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1044	<	vector<const mithep::Muon*> muonsToVeto,
1045	<	vector<const mithep::Electron*> electronsToVeto)
1039	>	const Electron * ele,
1040	>	const Vertex * vtx,
1041	>	const Array<PFCandidate> * fPFCandidates,
1042	>	const Array<PileupEnergyDensity> * fPUEnergyDensity,
1043	>	ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1044	>	vector<const Muon*> muonsToVeto,
1045	>	vector<const Electron*> electronsToVeto)
1046		//--------------------------------------------------------------------------------------------------
1047		{
1048
1049		if( ctrl.debug ) {
1050		cout << "electronIsoMVASelection :: muons to veto " << endl;
1051		for( int i=0; i<muonsToVeto.size(); i++ ) {
1052	<	const mithep::Muon * vmu = muonsToVeto[i];
1052	>	const Muon * vmu = muonsToVeto[i];
1053		cout << "\tpt: " << vmu->Pt()
1054		<< "\teta: " << vmu->Eta()
1055		<< "\tphi: " << vmu->Phi()
#	Line 1032 \| Line 1057 \| SelectionStatus electronIsoMVASelection(
1057		}
1058		cout << "electronIsoMVASelection :: electrson to veto " << endl;
1059		for( int i=0; i<electronsToVeto.size(); i++ ) {
1060	<	const mithep::Electron * vel = electronsToVeto[i];
1060	>	const Electron * vel = electronsToVeto[i];
1061		cout << "\tpt: " << vel->Pt()
1062		<< "\teta: " << vel->Eta()
1063		<< "\tphi: " << vel->Phi()
#	Line 1051 \| Line 1076 \| SelectionStatus electronIsoMVASelection(
1076		Double_t tmpChargedIso_DR0p2To0p3 = 0;
1077		Double_t tmpChargedIso_DR0p3To0p4 = 0;
1078		Double_t tmpChargedIso_DR0p4To0p5 = 0;
1054	–	Double_t tmpChargedIso_DR0p5To0p7 = 0;
1079
1080		Double_t tmpGammaIso_DR0p0To0p1 = 0;
1081		Double_t tmpGammaIso_DR0p1To0p2 = 0;
1082		Double_t tmpGammaIso_DR0p2To0p3 = 0;
1083		Double_t tmpGammaIso_DR0p3To0p4 = 0;
1084		Double_t tmpGammaIso_DR0p4To0p5 = 0;
1085	<	Double_t tmpGammaIso_DR0p5To0p7 = 0;
1085	>
1086
1087		Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
1088		Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
1089		Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
1090		Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
1091		Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
1068	–	Double_t tmpNeutralHadronIso_DR0p5To0p7 = 0;
1092
1093
1094
#	Line 1095 \| Line 1118 \| SelectionStatus electronIsoMVASelection(
1118		//Loop over PF Candidates
1119		//
1120		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1121	<	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1121	>
1122	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1123	>
1124	>	const PFCandidate pf = (PFCandidate)((*fPFCandidates)[k]);
1125		Double_t deta = (ele->Eta() - pf->Eta());
1126	<	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1127	<	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1128	<	if (dr >= 0.5) continue;
1126	>	Double_t dphi = MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1127	>	Double_t dr = MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1128	>	if (dr > 1.0) continue;
1129	>
1130		if(ctrl.debug) {
1131		cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1132	<	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
1132	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1133		cout << endl;
1134		}
1135
#	Line 1117 \| Line 1144 \| SelectionStatus electronIsoMVASelection(
1144		Bool_t IsLeptonFootprint = kFALSE;
1145		if (dr < 1.0) {
1146
1147	+
1148		//
1149		// Check for electrons
1150		//
1151	+
1152		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1153	<	const mithep::Electron *tmpele = electronsToVeto[q];
1153	>	const Electron *tmpele = electronsToVeto[q];
1154	>	double tmpdr = MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1155	>
1156		// 4l electron
1157		if( pf->HasTrackerTrk() ) {
1158		if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
#	Line 1136 \| Line 1167 \| SelectionStatus electronIsoMVASelection(
1167		}
1168		}
1169		// PF charged
1170	<	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1140	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1170	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1171		if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1172		IsLeptonFootprint = kTRUE;
1173		}
1174		// PF gamma
1175	<	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1176	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
1175	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1176	>	&& tmpdr < 0.08) {
1177		if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1178		IsLeptonFootprint = kTRUE;
1179		}
1180		} // loop over electrons
1181
1182	+
1183		/* KH - comment for sync
1184		//
1185		// Check for muons
1186		//
1187		for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1188	<	const mithep::Muon *tmpmu = muonsToVeto[q];
1188	>	const Muon *tmpmu = muonsToVeto[q];
1189		// 4l muon
1190		if( pf->HasTrackerTrk() ) {
1191		if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
#	Line 1163 \| Line 1194 \| SelectionStatus electronIsoMVASelection(
1194		}
1195		}
1196		// PF charged
1197	<	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1197	>	if (pf->Charge() != 0 && MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1198		if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1199		IsLeptonFootprint = kTRUE;
1200		}
#	Line 1178 \| Line 1209 \| SelectionStatus electronIsoMVASelection(
1209		//
1210		if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1211
1212	<	if( pf->HasTrackerTrk() )
1213	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1214	<	if( pf->HasGsfTrk() )
1215	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1212	>	// if( pf->HasGsfTrk() ) {
1213	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1214	>	// } else if( pf->HasTrackerTrk() ){
1215	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1216	>	// }
1217
1218		// Veto any PFmuon, or PFEle
1219		if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
#	Line 1198 \| Line 1230 \| SelectionStatus electronIsoMVASelection(
1230		if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1231		if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1232		if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
1201	–	if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
1233
1234		}
1235
#	Line 1207 \| Line 1238 \| SelectionStatus electronIsoMVASelection(
1238		//
1239		else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1240
1241	<	if (fabs(ele->SCluster()->Eta()) > 1.479) {
1211	<	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
1212	<	}
1241	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
1242
1243		if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1244		<< dr << endl;
#	Line 1219 \| Line 1248 \| SelectionStatus electronIsoMVASelection(
1248		if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1249		if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1250		if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
1222	–	if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
1223	–
1251		}
1252
1253		//
#	Line 1234 \| Line 1261 \| SelectionStatus electronIsoMVASelection(
1261		if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1262		if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1263		if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1237	–	if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
1264		}
1265
1266		}
1267
1268		}
1269
1270	<	fChargedIso_DR0p0To0p1 = min((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1271	<	fChargedIso_DR0p1To0p2 = min((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1272	<	fChargedIso_DR0p2To0p3 = min((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1273	<	fChargedIso_DR0p3To0p4 = min((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1274	<	fChargedIso_DR0p4To0p5 = min((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1270	>	fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1271	>	fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1272	>	fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1273	>	fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1274	>	fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1275	>
1276	>	if(ctrl.debug) {
1277	>	cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1 << endl;
1278	>	cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2 << endl;
1279	>	cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3 << endl;
1280	>	cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4 << endl;
1281	>	cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5 << endl;
1282	>	}
1283
1250	–	double rho = 0;
1251	–	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
1252	–	// rho = fPUEnergyDensity->At(0)->Rho();
1253	–	if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1254	–	rho = fPUEnergyDensity->At(0)->RhoLowEta();
1284
1285	+	double rho = 0;
1286	+	if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
1287	+	rho = fPUEnergyDensity->At(0)->Rho();
1288	+	// if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1289	+	// rho = fPUEnergyDensity->At(0)->RhoLowEta();
1290	+
1291		// WARNING!!!!
1292		// hardcode for sync ...
1293		EffectiveAreaVersion = eleT.kEleEAData2011;
#	Line 1280 \| Line 1315 \| SelectionStatus electronIsoMVASelection(
1315		<< endl;
1316		}
1317
1318	<	fGammaIso_DR0p0To0p1 = max(min((tmpGammaIso_DR0p0To0p1
1318	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
1319		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
1320		ele->SCluster()->Eta(),
1321		EffectiveAreaVersion))/ele->Pt()
1322		,2.5)
1323		,0.0);
1324	<	fGammaIso_DR0p1To0p2 = max(min((tmpGammaIso_DR0p1To0p2
1324	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
1325		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
1326		ele->SCluster()->Eta(),
1327		EffectiveAreaVersion))/ele->Pt()
1328		,2.5)
1329		,0.0);
1330	<	fGammaIso_DR0p2To0p3 = max(min((tmpGammaIso_DR0p2To0p3
1330	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
1331		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
1332		ele->SCluster()->Eta()
1333		,EffectiveAreaVersion))/ele->Pt()
1334		,2.5)
1335		,0.0);
1336	<	fGammaIso_DR0p3To0p4 = max(min((tmpGammaIso_DR0p3To0p4
1336	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
1337		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
1338		ele->SCluster()->Eta(),
1339		EffectiveAreaVersion))/ele->Pt()
1340		,2.5)
1341		,0.0);
1342	<	fGammaIso_DR0p4To0p5 = max(min((tmpGammaIso_DR0p4To0p5
1342	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
1343		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
1344		ele->SCluster()->Eta(),
1345		EffectiveAreaVersion))/ele->Pt()
#	Line 1312 \| Line 1347 \| SelectionStatus electronIsoMVASelection(
1347		,0.0);
1348
1349
1350	<	fNeutralHadronIso_DR0p0To0p1 = max(min((tmpNeutralHadronIso_DR0p0To0p1
1350	>	if( ctrl.debug) {
1351	>	cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
1352	>	cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
1353	>	cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
1354	>	cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
1355	>	cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
1356	>	}
1357	>
1358	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
1359		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1360		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1361		, 2.5)
1362		, 0.0);
1363	<	fNeutralHadronIso_DR0p1To0p2 = max(min((tmpNeutralHadronIso_DR0p1To0p2
1363	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
1364		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1365		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1366		, 2.5)
1367		, 0.0);
1368	<	fNeutralHadronIso_DR0p2To0p3 = max(min((tmpNeutralHadronIso_DR0p2To0p3
1368	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
1369		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1370		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1371		, 2.5)
1372		, 0.0);
1373	<	fNeutralHadronIso_DR0p3To0p4 = max(min((tmpNeutralHadronIso_DR0p3To0p4
1373	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
1374		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1375		ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1376		, 2.5)
1377		, 0.0);
1378	<	fNeutralHadronIso_DR0p4To0p5 = max(min((tmpNeutralHadronIso_DR0p4To0p5
1378	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
1379		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
1380		ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1381		, 2.5)
1382		, 0.0);
1383
1384	+	if( ctrl.debug) {
1385	+	cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
1386	+	cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
1387	+	cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
1388	+	cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
1389	+	cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
1390	+	}
1391	+
1392		double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
1393		ele->SCluster()->Eta(),
1394		fChargedIso_DR0p0To0p1,
#	Line 1358 \| Line 1409 \| SelectionStatus electronIsoMVASelection(
1409		ctrl.debug);
1410
1411		SelectionStatus status;
1412	+	status.isoMVA = mvaval;
1413		bool pass = false;
1414
1415		Int_t subdet = 0;
1416		if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
1417		else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
1418		else subdet = 2;
1419	+
1420		Int_t ptBin = 0;
1421	<	if (ele->Pt() > 10.0) ptBin = 1;
1421	>	if (ele->Pt() >= 10.0) ptBin = 1;
1422
1423		Int_t MVABin = -1;
1424		if (subdet == 0 && ptBin == 0) MVABin = 0;
#	Line 1376 \| Line 1429 \| SelectionStatus electronIsoMVASelection(
1429		if (subdet == 2 && ptBin == 1) MVABin = 5;
1430
1431		pass = false;
1432	<	if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN0 ) pass = true;
1433	<	if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN1 ) pass = true;
1434	<	if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN2 ) pass = true;
1435	<	if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN3 ) pass = true;
1436	<	if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN4 ) pass = true;
1437	<	if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN5 ) pass = true;
1432	>	if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN0 ) pass = true;
1433	>	if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN1 ) pass = true;
1434	>	if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN2 ) pass = true;
1435	>	if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN3 ) pass = true;
1436	>	if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN4 ) pass = true;
1437	>	if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN5 ) pass = true;
1438	>	// pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
1439		if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
1440
1441		// pass = false;
#	Line 1400 \| Line 1454 \| SelectionStatus electronIsoMVASelection(
1454
1455
1456		//--------------------------------------------------------------------------------------------------
1457	<	void initElectronIsoMVA() {
1458	<	//--------------------------------------------------------------------------------------------------
1459	<	eleIsoMVA = new mithep::ElectronIDMVA();
1460	<	vector<string> weightFiles;
1461	<	weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_BarrelPt5To10.weights.xml");
1462	<	weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_EndcapPt5To10.weights.xml");
1463	<	weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_BarrelPt10ToInf.weights.xml");
1464	<	weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_EndcapPt10ToInf.weights.xml");
1465	<	eleIsoMVA->Initialize( "ElectronIsoMVA",
1412	<	mithep::ElectronIDMVA::kIsoRingsV0,
1413	<	kTRUE, weightFiles);
1414	<	}
1415	<
1416	<
1417	<
1418	<	//--------------------------------------------------------------------------------------------------
1419	<	float electronPFIso04(ControlFlags &ctrl,
1420	<	const mithep::Electron * ele,
1421	<	const mithep::Vertex & vtx,
1422	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1423	<	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1424	<	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1425	<	vector<const mithep::Muon*> muonsToVeto,
1426	<	vector<const mithep::Electron*> electronsToVeto)
1457	>	SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1458	>	const Electron * ele,
1459	>	const Vertex * vtx,
1460	>	const Array<PFCandidate> * fPFCandidates,
1461	>	float rho,
1462	>	//const Array<PileupEnergyDensity> * fPUEnergyDensity,
1463	>	ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1464	>	vector<const Muon*> muonsToVeto,
1465	>	vector<const Electron*> electronsToVeto)
1466		//--------------------------------------------------------------------------------------------------
1467	+	// hacked version
1468		{
1469	+	if( ctrl.debug ) {
1470	+	cout << "================> hacked ele Iso MVA <======================" << endl;
1471	+	}
1472
1473		if( ctrl.debug ) {
1474		cout << "electronIsoMVASelection :: muons to veto " << endl;
1475		for( int i=0; i<muonsToVeto.size(); i++ ) {
1476	<	const mithep::Muon * vmu = muonsToVeto[i];
1476	>	const Muon * vmu = muonsToVeto[i];
1477		cout << "\tpt: " << vmu->Pt()
1478		<< "\teta: " << vmu->Eta()
1479		<< "\tphi: " << vmu->Phi()
#	Line 1438 \| Line 1481 \| float electronPFIso04(ControlFlags &ctrl
1481		}
1482		cout << "electronIsoMVASelection :: electrson to veto " << endl;
1483		for( int i=0; i<electronsToVeto.size(); i++ ) {
1484	<	const mithep::Electron * vel = electronsToVeto[i];
1484	>	const Electron * vel = electronsToVeto[i];
1485		cout << "\tpt: " << vel->Pt()
1486		<< "\teta: " << vel->Eta()
1487		<< "\tphi: " << vel->Phi()
#	Line 1447 \| Line 1490 \| float electronPFIso04(ControlFlags &ctrl
1490		}
1491		}
1492
1493	+	bool failiso=false;
1494
1495		//
1496	<	// final iso
1496	>	// tmp iso rings
1497		//
1498	<	Double_t fChargedIso = 0.0;
1499	<	Double_t fGammaIso = 0.0;
1500	<	Double_t fNeutralHadronIso = 0.0;
1498	>	Double_t tmpChargedIso_DR0p0To0p1 = 0;
1499	>	Double_t tmpChargedIso_DR0p1To0p2 = 0;
1500	>	Double_t tmpChargedIso_DR0p2To0p3 = 0;
1501	>	Double_t tmpChargedIso_DR0p3To0p4 = 0;
1502	>	Double_t tmpChargedIso_DR0p4To0p5 = 0;
1503	>
1504	>	Double_t tmpGammaIso_DR0p0To0p1 = 0;
1505	>	Double_t tmpGammaIso_DR0p1To0p2 = 0;
1506	>	Double_t tmpGammaIso_DR0p2To0p3 = 0;
1507	>	Double_t tmpGammaIso_DR0p3To0p4 = 0;
1508	>	Double_t tmpGammaIso_DR0p4To0p5 = 0;
1509	>
1510	>
1511	>	Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
1512	>	Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
1513	>	Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
1514	>	Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
1515	>	Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
1516	>
1517	>
1518	>
1519	>	//
1520	>	// final rings for the MVA
1521	>	//
1522	>	Double_t fChargedIso_DR0p0To0p1;
1523	>	Double_t fChargedIso_DR0p1To0p2;
1524	>	Double_t fChargedIso_DR0p2To0p3;
1525	>	Double_t fChargedIso_DR0p3To0p4;
1526	>	Double_t fChargedIso_DR0p4To0p5;
1527	>
1528	>	Double_t fGammaIso_DR0p0To0p1;
1529	>	Double_t fGammaIso_DR0p1To0p2;
1530	>	Double_t fGammaIso_DR0p2To0p3;
1531	>	Double_t fGammaIso_DR0p3To0p4;
1532	>	Double_t fGammaIso_DR0p4To0p5;
1533	>
1534	>	Double_t fNeutralHadronIso_DR0p0To0p1;
1535	>	Double_t fNeutralHadronIso_DR0p1To0p2;
1536	>	Double_t fNeutralHadronIso_DR0p2To0p3;
1537	>	Double_t fNeutralHadronIso_DR0p3To0p4;
1538	>	Double_t fNeutralHadronIso_DR0p4To0p5;
1539
1540
1541		//
1542		//Loop over PF Candidates
1543		//
1544		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1545	<	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1545	>
1546	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1547	>
1548	>	const PFCandidate pf = (PFCandidate)((*fPFCandidates)[k]);
1549		Double_t deta = (ele->Eta() - pf->Eta());
1550	<	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1551	<	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1552	<	if (dr >= 0.4) continue;
1550	>	Double_t dphi = MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1551	>	Double_t dr = MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1552	>	if (dr > 1.0) continue;
1553	>
1554		if(ctrl.debug) {
1555		cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1556	<	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
1556	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1557		cout << endl;
1558		}
1559
#	Line 1482 \| Line 1568 \| float electronPFIso04(ControlFlags &ctrl
1568		Bool_t IsLeptonFootprint = kFALSE;
1569		if (dr < 1.0) {
1570
1571	+
1572		//
1573		// Check for electrons
1574		//
1575	+
1576		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1577	<	const mithep::Electron *tmpele = electronsToVeto[q];
1577	>	const Electron *tmpele = electronsToVeto[q];
1578	>	double tmpdr = MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1579	>
1580		// 4l electron
1581		if( pf->HasTrackerTrk() ) {
1582		if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
#	Line 1501 \| Line 1591 \| float electronPFIso04(ControlFlags &ctrl
1591		}
1592		}
1593		// PF charged
1594	<	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1505	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1594	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1595		if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1596		IsLeptonFootprint = kTRUE;
1597		}
1598		// PF gamma
1599	<	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1600	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
1599	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1600	>	&& tmpdr < 0.08) {
1601		if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1602		IsLeptonFootprint = kTRUE;
1603		}
1604		} // loop over electrons
1605
1606
1607	+	/* KH - comment for sync
1608		//
1609		// Check for muons
1610		//
1611		for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1612	<	const mithep::Muon *tmpmu = muonsToVeto[q];
1612	>	const Muon *tmpmu = muonsToVeto[q];
1613		// 4l muon
1614		if( pf->HasTrackerTrk() ) {
1615		if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
#	Line 1528 \| Line 1618 \| float electronPFIso04(ControlFlags &ctrl
1618		}
1619		}
1620		// PF charged
1621	<	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1621	>	if (pf->Charge() != 0 && MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1622		if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1623		IsLeptonFootprint = kTRUE;
1624		}
1625		} // loop over muons
1626	<
1626	>	*/
1627
1628		if (IsLeptonFootprint)
1629		continue;
1630
1631		//
1632	<	// Charged Iso
1632	>	// Charged Iso Rings
1633		//
1634	<	if (pf->Charge() != 0 ) {
1634	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1635
1636	<	if( pf->HasTrackerTrk() )
1637	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1638	<	if( pf->HasGsfTrk() )
1639	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1636	>	// if( pf->HasGsfTrk() ) {
1637	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1638	>	// } else if( pf->HasTrackerTrk() ){
1639	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1640	>	// }
1641
1642		// Veto any PFmuon, or PFEle
1643		if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
#	Line 1558 \| Line 1649 \| float electronPFIso04(ControlFlags &ctrl
1649		<< "\ttype: " << pf->PFType()
1650		<< "\ttrk: " << pf->TrackerTrk() << endl;
1651
1652	<	fChargedIso += pf->Pt();
1652	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
1653	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
1654	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1655	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1656	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
1657	>
1658		}
1659
1660		//
1661	<	// Gamma Iso
1661	>	// Gamma Iso Rings
1662		//
1663		else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1664
1665	<	if (fabs(ele->SCluster()->Eta()) > 1.479) {
1666	<	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
1571	<	}
1665	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
1666	>
1667		if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1668		<< dr << endl;
1669	<	if( pf->Pt() > 0.5 )
1670	<	fGammaIso += pf->Pt();
1669	>
1670	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
1671	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
1672	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1673	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1674	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
1675		}
1676
1677		//
1678	<	// Neutral Iso
1678	>	// Other Neutral Iso Rings
1679		//
1680		else {
1681		if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
1682		<< dr << endl;
1683	<	if( pf->Pt() > 0.5 )
1684	<	fNeutralHadronIso += pf->Pt();
1683	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
1684	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
1685	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1686	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1687	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1688		}
1689
1690		}
1691
1692		}
1693
1694	<	double rho = 0;
1695	<	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
1696	<	// rho = fPUEnergyDensity->At(0)->Rho();
1697	<	if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1698	<	rho = fPUEnergyDensity->At(0)->RhoLowEta();
1694	>	fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1695	>	fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1696	>	fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1697	>	fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1698	>	fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1699	>
1700	>	if(ctrl.debug) {
1701	>	cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1 << endl;
1702	>	cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2 << endl;
1703	>	cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3 << endl;
1704	>	cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4 << endl;
1705	>	cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5 << endl;
1706	>	}
1707	>
1708
1709	+	// rho=0;
1710	+	// double rho = 0;
1711	+	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
1712	+	// rho = fPUEnergyDensity->At(0)->Rho();
1713	+	// if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1714	+	// rho = fPUEnergyDensity->At(0)->RhoLowEta();
1715	+
1716		// WARNING!!!!
1717		// hardcode for sync ...
1718		EffectiveAreaVersion = eleT.kEleEAData2011;
1719		// WARNING!!!!
1720
1721	+	if( ctrl.debug) {
1722	+	cout << "RHO: " << rho << endl;
1723	+	cout << "eta: " << ele->SCluster()->Eta() << endl;
1724	+	cout << "target: " << EffectiveAreaVersion << endl;
1725	+	cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1726	+	ele->SCluster()->Eta(),
1727	+	EffectiveAreaVersion)
1728	+	<< endl;
1729	+	cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1730	+	ele->SCluster()->Eta(),
1731	+	EffectiveAreaVersion)
1732	+	<< endl;
1733	+	cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1734	+	ele->SCluster()->Eta(),
1735	+	EffectiveAreaVersion)
1736	+	<< endl;
1737	+	cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1738	+	ele->SCluster()->Eta(),
1739	+	EffectiveAreaVersion)
1740	+	<< endl;
1741	+	}
1742	+
1743	+	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
1744	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
1745	+	ele->SCluster()->Eta(),
1746	+	EffectiveAreaVersion))/ele->Pt()
1747	+	,2.5)
1748	+	,0.0);
1749	+	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
1750	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
1751	+	ele->SCluster()->Eta(),
1752	+	EffectiveAreaVersion))/ele->Pt()
1753	+	,2.5)
1754	+	,0.0);
1755	+	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
1756	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
1757	+	ele->SCluster()->Eta()
1758	+	,EffectiveAreaVersion))/ele->Pt()
1759	+	,2.5)
1760	+	,0.0);
1761	+	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
1762	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
1763	+	ele->SCluster()->Eta(),
1764	+	EffectiveAreaVersion))/ele->Pt()
1765	+	,2.5)
1766	+	,0.0);
1767	+	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
1768	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
1769	+	ele->SCluster()->Eta(),
1770	+	EffectiveAreaVersion))/ele->Pt()
1771	+	,2.5)
1772	+	,0.0);
1773	+
1774
1775	<	double pfIso = fChargedIso +
1776	<	max(0.0,fGammaIso -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIso04,
1777	<	ele->Eta(),EffectiveAreaVersion)) +
1778	<	max(0.0,fNeutralHadronIso -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIso04,
1779	<	ele->Eta(),EffectiveAreaVersion)) ;
1775	>	if( ctrl.debug) {
1776	>	cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
1777	>	cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
1778	>	cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
1779	>	cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
1780	>	cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
1781	>	}
1782
1783	<	gChargedIso = fChargedIso;
1784	<	gGammaIso = fGammaIso;
1785	<	gNeutralIso = fNeutralHadronIso;
1783	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
1784	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1785	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1786	>	, 2.5)
1787	>	, 0.0);
1788	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
1789	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1790	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1791	>	, 2.5)
1792	>	, 0.0);
1793	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
1794	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1795	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1796	>	, 2.5)
1797	>	, 0.0);
1798	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
1799	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1800	>	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1801	>	, 2.5)
1802	>	, 0.0);
1803	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
1804	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
1805	>	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1806	>	, 2.5)
1807	>	, 0.0);
1808
1809	<	return pfIso;
1809	>	if( ctrl.debug) {
1810	>	cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
1811	>	cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
1812	>	cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
1813	>	cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
1814	>	cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
1815	>	}
1816	>
1817	>	double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
1818	>	ele->SCluster()->Eta(),
1819	>	fChargedIso_DR0p0To0p1,
1820	>	fChargedIso_DR0p1To0p2,
1821	>	fChargedIso_DR0p2To0p3,
1822	>	fChargedIso_DR0p3To0p4,
1823	>	fChargedIso_DR0p4To0p5,
1824	>	fGammaIso_DR0p0To0p1,
1825	>	fGammaIso_DR0p1To0p2,
1826	>	fGammaIso_DR0p2To0p3,
1827	>	fGammaIso_DR0p3To0p4,
1828	>	fGammaIso_DR0p4To0p5,
1829	>	fNeutralHadronIso_DR0p0To0p1,
1830	>	fNeutralHadronIso_DR0p1To0p2,
1831	>	fNeutralHadronIso_DR0p2To0p3,
1832	>	fNeutralHadronIso_DR0p3To0p4,
1833	>	fNeutralHadronIso_DR0p4To0p5,
1834	>	ctrl.debug);
1835	>
1836	>	SelectionStatus status;
1837	>	status.isoMVA = mvaval;
1838	>	bool pass = false;
1839	>
1840	>	Int_t subdet = 0;
1841	>	if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
1842	>	else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
1843	>	else subdet = 2;
1844	>
1845	>	Int_t ptBin = 0;
1846	>	if (ele->Pt() >= 10.0) ptBin = 1;
1847	>
1848	>	Int_t MVABin = -1;
1849	>	if (subdet == 0 && ptBin == 0) MVABin = 0;
1850	>	if (subdet == 1 && ptBin == 0) MVABin = 1;
1851	>	if (subdet == 2 && ptBin == 0) MVABin = 2;
1852	>	if (subdet == 0 && ptBin == 1) MVABin = 3;
1853	>	if (subdet == 1 && ptBin == 1) MVABin = 4;
1854	>	if (subdet == 2 && ptBin == 1) MVABin = 5;
1855	>
1856	>	pass = false;
1857	>	if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN0 ) pass = true;
1858	>	if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN1 ) pass = true;
1859	>	if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN2 ) pass = true;
1860	>	if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN3 ) pass = true;
1861	>	if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN4 ) pass = true;
1862	>	if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN5 ) pass = true;
1863	>	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
1864	>
1865	>	// pass = false;
1866	>	// if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
1867	>	// if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
1868	>	// if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
1869	>	// if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
1870	>	// if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
1871	>	// if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
1872	>	// if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
1873	>
1874	>	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1875	>	return status;
1876	>
1877		}
1878
1879	+
1880		//--------------------------------------------------------------------------------------------------
1881	<	// hacked version
1619	<	float electronPFIso04(ControlFlags &ctrl,
1620	<	const mithep::Electron * ele,
1621	<	const mithep::Vertex & vtx,
1622	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1623	<	float rho,
1624	<	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1625	<	vector<const mithep::Muon*> muonsToVeto,
1626	<	vector<const mithep::Electron*> electronsToVeto)
1881	>	void initElectronIsoMVA() {
1882		//--------------------------------------------------------------------------------------------------
1883	<	{
1883	>	eleIsoMVA = new ElectronIDMVA();
1884	>	vector<string> weightFiles;
1885	>	weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_BarrelPt5To10.weights.xml");
1886	>	weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_EndcapPt5To10.weights.xml");
1887	>	weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_BarrelPt10ToInf.weights.xml");
1888	>	weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_EndcapPt10ToInf.weights.xml");
1889	>	eleIsoMVA->Initialize( "ElectronIsoMVA",
1890	>	ElectronIDMVA::kIsoRingsV0,
1891	>	kTRUE, weightFiles);
1892	>	}
1893	>
1894
1630	–	if( ctrl.debug ) {
1631	–	cout << "electronIsoMVASelection :: muons to veto " << endl;
1632	–	for( int i=0; i<muonsToVeto.size(); i++ ) {
1633	–	const mithep::Muon * vmu = muonsToVeto[i];
1634	–	cout << "\tpt: " << vmu->Pt()
1635	–	<< "\teta: " << vmu->Eta()
1636	–	<< "\tphi: " << vmu->Phi()
1637	–	<< endl;
1638	–	}
1639	–	cout << "electronIsoMVASelection :: electrson to veto " << endl;
1640	–	for( int i=0; i<electronsToVeto.size(); i++ ) {
1641	–	const mithep::Electron * vel = electronsToVeto[i];
1642	–	cout << "\tpt: " << vel->Pt()
1643	–	<< "\teta: " << vel->Eta()
1644	–	<< "\tphi: " << vel->Phi()
1645	–	<< "\ttrk: " << vel->TrackerTrk()
1646	–	<< endl;
1647	–	}
1648	–	}
1895
1896
1897	+	//--------------------------------------------------------------------------------------------------
1898	+	float electronPFIso04(ControlFlags &ctrl,
1899	+	const Electron * ele,
1900	+	const Vertex * vtx,
1901	+	const Array<PFCandidate> * fPFCandidates,
1902	+	const Array<PileupEnergyDensity> * fPUEnergyDensity,
1903	+	ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1904	+	vector<const PFCandidate*> photonsToVeto)
1905	+	//--------------------------------------------------------------------------------------------------
1906	+	{
1907	+
1908		//
1909		// final iso
1910		//
#	Line 1659 \| Line 1916 \| float electronPFIso04(ControlFlags &ctrl
1916		//
1917		//Loop over PF Candidates
1918		//
1919	+	if(ctrl.debug) cout << " electronPFIso04(): ----> " << endl;
1920		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1921	<	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1921	>
1922	>	const PFCandidate pf = (PFCandidate)((*fPFCandidates)[k]);
1923	>
1924	>	//
1925	>	// veto FSR recovered photons
1926	>	//
1927	>	bool vetoPhoton = false;
1928	>	for( int p=0; p<photonsToVeto.size(); p++ ) {
1929	>	if( pf == photonsToVeto[p] ) {
1930	>	vetoPhoton = true;
1931	>	break;
1932	>	}
1933	>	} if( vetoPhoton ) continue;
1934	>
1935		Double_t deta = (ele->Eta() - pf->Eta());
1936	<	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1937	<	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1667	<	if (dr >= 0.4) continue;
1668	<	if(ctrl.debug) {
1669	<	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1670	<	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
1671	<	cout << endl;
1672	<	}
1936	>	Double_t dphi = MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1937	>	Double_t dr = MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1938
1939	+	if (dr > 0.4) continue;
1940	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1941
1942	<	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
1943	<	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1944	<
1942	>	// if(ctrl.debug) {
1943	>	// cout << " pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
1944	>	// if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
1945	>	// << "\ttrk: " << pf->HasTrackerTrk()
1946	>	// << "\tgsf: " << pf->HasGsfTrk();
1947	>	// cout << endl;
1948	>	// }
1949
1950		//
1951		// Lepton Footprint Removal
#	Line 1682 \| Line 1953 \| float electronPFIso04(ControlFlags &ctrl
1953		Bool_t IsLeptonFootprint = kFALSE;
1954		if (dr < 1.0) {
1955
1685	–	//
1686	–	// Check for electrons
1687	–	//
1688	–	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1689	–	const mithep::Electron *tmpele = electronsToVeto[q];
1690	–	// 4l electron
1691	–	if( pf->HasTrackerTrk() ) {
1692	–	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1693	–	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1694	–	IsLeptonFootprint = kTRUE;
1695	–	}
1696	–	}
1697	–	if( pf->HasGsfTrk() ) {
1698	–	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1699	–	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1700	–	IsLeptonFootprint = kTRUE;
1701	–	}
1702	–	}
1703	–	// PF charged
1704	–	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1705	–	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1706	–	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1707	–	IsLeptonFootprint = kTRUE;
1708	–	}
1709	–	// PF gamma
1710	–	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1711	–	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
1712	–	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1713	–	IsLeptonFootprint = kTRUE;
1714	–	}
1715	–	} // loop over electrons
1716	–
1717	–	/* KH - comment for sync
1718	–	//
1719	–	// Check for muons
1720	–	//
1721	–	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1722	–	const mithep::Muon *tmpmu = muonsToVeto[q];
1723	–	// 4l muon
1724	–	if( pf->HasTrackerTrk() ) {
1725	–	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1726	–	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1727	–	IsLeptonFootprint = kTRUE;
1728	–	}
1729	–	}
1730	–	// PF charged
1731	–	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1732	–	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1733	–	IsLeptonFootprint = kTRUE;
1734	–	}
1735	–	} // loop over muons
1736	–	*/
1737	–
1738	–	if (IsLeptonFootprint)
1739	–	continue;
1956
1957		//
1958		// Charged Iso
1959		//
1960		if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1961
1746	–	if( pf->HasTrackerTrk() )
1747	–	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1748	–	if( pf->HasGsfTrk() )
1749	–	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1750	–
1962		// Veto any PFmuon, or PFEle
1963	<	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
1963	>	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) {
1964	>	// if( ctrl.debug ) cout << " skipping, pf is an ele or mu .." <<endl;
1965	>	continue;
1966	>	}
1967
1968		// Footprint Veto
1969		if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1970
1971	<	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1972	<	<< "\ttype: " << pf->PFType()
1973	<	<< "\ttrk: " << pf->TrackerTrk() << endl;
1971	>	// if( ctrl.debug) cout << " charged:: pt: " << pf->Pt()
1972	>	// << "\ttype: " << pf->PFType()
1973	>	// << "\ttrk: " << pf->TrackerTrk() << endl;
1974
1975		fChargedIso += pf->Pt();
1976		}
#	Line 1767 \| Line 1981 \| float electronPFIso04(ControlFlags &ctrl
1981		else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1982
1983		if (fabs(ele->SCluster()->Eta()) > 1.479) {
1984	<	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
1984	>	if (MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
1985		}
1986	<	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1987	<	<< dr << endl;
1986	>
1987	>	assert(ele->HasSuperCluster());
1988	>	if(ele->GsfTrk()->NExpectedHitsInner()>0 && pf->MvaGamma() > 0.99 && pf->HasSCluster() && ele->SCluster() == pf->SCluster()) continue;
1989	>
1990	>
1991	>	// if( ctrl.debug) cout << " gamma:: " << pf->Pt() << " "
1992	>	// << dr << endl;
1993	>
1994		fGammaIso += pf->Pt();
1995		}
1996
#	Line 1778 \| Line 1998 \| float electronPFIso04(ControlFlags &ctrl
1998		// Neutral Iso
1999		//
2000		else {
2001	<	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2002	<	<< dr << endl;
2003	<	// KH, add to sync
1784	<	if( pf->Pt() > 0.5 )
1785	<	fNeutralHadronIso += pf->Pt();
2001	>	// if( ctrl.debug) cout << " neutral:: " << pf->Pt() << " "
2002	>	// << dr << endl;
2003	>	fNeutralHadronIso += pf->Pt();
2004		}
2005
2006		}
2007
2008		}
2009
1792	–	// double rho = 0;
1793	–	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
1794	–	// rho = fPUEnergyDensity->At(0)->Rho();
2010
2011	<	// WARNING!!!!
2012	<	// hardcode for sync ...
2013	<	EffectiveAreaVersion = eleT.kEleEAData2011;
2014	<	// WARNING!!!!
2011	>	double rho=0;
2012	>	if( (EffectiveAreaVersion == ElectronTools::kEleEAFall11MC) \|\|
2013	>	(EffectiveAreaVersion == ElectronTools::kEleEAData2011) ) {
2014	>	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25()) \|\|
2015	>	isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25())))
2016	>	rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25();
2017	>	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2018	>	EffectiveAreaVersion = ElectronTools::kEleEAData2011;
2019	>	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2020	>	} else {
2021	>	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJets()) \|\|
2022	>	isinf(fPUEnergyDensity->At(0)->RhoKt6PFJets())))
2023	>	rho = fPUEnergyDensity->At(0)->RhoKt6PFJets();
2024	>	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2025	>	EffectiveAreaVersion = ElectronTools::kEleEAData2012;
2026	>	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2027	>	}
2028	>	// if(ctrl.debug) cout << " rho: " << rho << endl;
2029	>
2030	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2031	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2032	>	ele->Eta(),EffectiveAreaVersion)));
2033
2034
2035	<	double pfIso = fChargedIso +
2036	<	max(0.0,fGammaIso -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIso04,
2037	<	ele->Eta(),EffectiveAreaVersion)) +
2038	<	max(0.0,fNeutralHadronIso -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIso04,
2039	<	ele->Eta(),EffectiveAreaVersion)) ;
2035	>	gChargedIso = fChargedIso;
2036	>	gGammaIso = fGammaIso;
2037	>	gNeutralIso = fNeutralHadronIso;
2038	>
2039	>	if( ctrl.debug ) {
2040	>	cout << " PFiso: " << pfIso
2041	>	<< setw(6) << setprecision(4) << fChargedIso
2042	>	<< setw(6) << setprecision(4) << fGammaIso
2043	>	<< setw(6) << setprecision(4) << fNeutralHadronIso
2044	>	<< endl;
2045	>	}
2046	>
2047		return pfIso;
2048		}
2049
1810	–
2050		//--------------------------------------------------------------------------------------------------
2051		SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2052	<	const mithep::Electron * ele,
2053	<	const mithep::Vertex & vtx,
2054	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2055	<	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2056	<	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2057	<	vector<const mithep::Muon*> muonsToVeto,
1819	<	vector<const mithep::Electron*> electronsToVeto)
2052	>	const Electron * ele,
2053	>	const Vertex * vtx,
2054	>	const Array<PFCandidate> * fPFCandidates,
2055	>	const Array<PileupEnergyDensity> * fPUEnergyDensity,
2056	>	ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2057	>	vector<const PFCandidate*> photonsToVeto)
2058		//--------------------------------------------------------------------------------------------------
2059		{
2060
2061		SelectionStatus status;
2062
2063		double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, fPUEnergyDensity,
2064	<	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1827	<	cout << "--------------> setting electron isoPF04 to " << pfIso << endl;
2064	>	EffectiveAreaVersion, photonsToVeto);
2065		status.isoPF04 = pfIso;
2066		status.chisoPF04 = gChargedIso;
2067		status.gaisoPF04 = gGammaIso;
#	Line 1837 \| Line 2074 \| SelectionStatus electronReferenceIsoSele
2074		status.orStatus(SelectionStatus::LOOSEISO);
2075		status.orStatus(SelectionStatus::TIGHTISO);
2076		}
2077	<	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2077	>	if(ctrl.debug)
2078	>	cout << " --> ele relpfIso: " << pfIso/ele->Pt() << ", returning status : " << hex << status.getStatus() << dec << endl;
2079		return status;
1842	–
2080		}
1844	–
1845	–
2081		//--------------------------------------------------------------------------------------------------
2082	<	// hacked version
2083	<	SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2084	<	const mithep::Electron * ele,
2085	<	const mithep::Vertex & vtx,
2086	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1852	<	float rho,
1853	<	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1854	<	vector<const mithep::Muon*> muonsToVeto,
1855	<	vector<const mithep::Electron*> electronsToVeto)
2082	>	double isoDr03ForFsr(ControlFlags & ctrl,
2083	>	const PFCandidate * photon,
2084	>	const ChargedParticle * lep,
2085	>	const Array<PFCandidate> * fPFCandidates,
2086	>	bool doDBetaCorr)
2087		//--------------------------------------------------------------------------------------------------
2088	<	{
2088	>	{
2089
2090	<	SelectionStatus status;
2090	>	//
2091	>	// final iso
2092	>	//
2093	>	Double_t fChargedIso = 0.0;
2094	>	Double_t fGammaIso = 0.0;
2095	>	Double_t fNeutralHadronIso = 0.0;
2096	>	Double_t fpfPU = 0.0;
2097
2098	<	double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, rho,
2099	<	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2100	<	bool pass = false;
2101	<	if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2098	>	//
2099	>	// Loop over PF Candidates
2100	>	//
2101	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2102
2103	<	if( pass ) {
1867	<	status.orStatus(SelectionStatus::LOOSEISO);
1868	<	status.orStatus(SelectionStatus::TIGHTISO);
1869	<	}
1870	<	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1871	<	return status;
2103	>	const PFCandidate pf = (PFCandidate)((*fPFCandidates)[k]);
2104
2105	+	Double_t deta = (photon->Eta() - pf->Eta());
2106	+	Double_t dphi = MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2107	+	Double_t dr = MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2108	+	if (dr > 0.3) continue;
2109	+
2110	+	if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2111	+	if( pf->Pt() >= 0.2 && dr > 0.01 )
2112	+	fpfPU += pf->Pt();
2113	+	continue;
2114	+	}
2115	+
2116	+	//
2117	+	// skip this photon
2118	+	//
2119	+	if( abs(pf->PFType()) == PFCandidate::eGamma &&
2120	+	pf->Et() == photon->Et() ) continue;
2121	+
2122	+
2123	+	//
2124	+	// Charged Iso
2125	+	//
2126	+	if (pf->Charge() != 0 ) {
2127	+	if( dr > 0.01 && pf->Pt() >= 0.2 &&
2128	+	!(pf->TrackerTrk() == lep->TrackerTrk()) )
2129	+	fChargedIso += pf->Pt();
2130	+	}
2131	+
2132	+	//
2133	+	// Gamma Iso
2134	+	//
2135	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2136	+	if( pf->Pt() > 0.5 && dr > 0.01)
2137	+	fGammaIso += pf->Pt();
2138	+	}
2139	+
2140	+	//
2141	+	// Other Neutrals
2142	+	//
2143	+	else {
2144	+	if( pf->Pt() > 0.5 && dr > 0.01)
2145	+	fNeutralHadronIso += pf->Pt();
2146	+	}
2147	+
2148	+	}
2149	+
2150	+	if(ctrl.debug) cout << " isoDr03ForFsr: " << setw(12) << fChargedIso << setw(12) << fGammaIso << setw(12) << fNeutralHadronIso << setw(12) << fpfPU << endl;
2151	+	double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso + (doDBetaCorr ? -0.5 : 1)*fpfPU;
2152	+	return pfIso/photon->Pt();
2153		}

Diff Legend

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

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents): Revision 1.18 by khahn, Sat May 12 03:00:14 2012 UTC vs. Revision 1.35 by dkralph, Mon Dec 17 17:12:27 2012 UTC

Diff Legend

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents):
Revision 1.18 by khahn, Sat May 12 03:00:14 2012 UTC vs.
Revision 1.35 by dkralph, Mon Dec 17 17:12:27 2012 UTC