ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

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

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents):
Revision 1.8 by khahn, Wed May 2 17:50:58 2012 UTC vs.
Revision 1.34 by dkralph, Tue Oct 23 10:41:23 2012 UTC

#	Line 9 | Line 9
9		#include "ElectronTools.h"
10		#include "ElectronIDMVA.h"
11
12	<	using namespace mithep;
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	<	mithep::MuonIDMVA     * muIsoMVA;
15	<	mithep::MuonTools       muT;
16	<	mithep::ElectronIDMVA * eleIsoMVA;
17	<	mithep::ElectronTools   eleT;
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 27 | 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 39 | 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 52 | 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 62 | 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 71 | 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 94 | Line 99 | Float_t computePFEleIso(const mithep::El
99
100		return iso;
101		};
97	–
98	–	//--------------------------------------------------------------------------------------------------
99	–	bool pairwiseIsoSelection( ControlFlags &ctrl,
100	–	vector<SimpleLepton> &lepvec,
101	–	float rho )
102	–	//--------------------------------------------------------------------------------------------------
103	–	{
104	–
105	–	bool passiso=true;
106	–
107	–	for( int i=0; i<lepvec.size(); i++ )
108	–	{
109	–
110	–	if( !(lepvec[i].is4l) ) continue;
111	–
112	–	float effArea_ecal_i, effArea_hcal_i;
113	–	if( lepvec[i].isEB ) {
114	–	if( lepvec[i].type == 11 ) {
115	–	effArea_ecal_i = 0.101;
116	–	effArea_hcal_i = 0.021;
117	–	} else {
118	–	effArea_ecal_i = 0.074;
119	–	effArea_hcal_i = 0.022;
120	–	}
121	–	} else {
122	–	if( lepvec[i].type == 11 ) {
123	–	effArea_ecal_i = 0.046;
124	–	effArea_hcal_i = 0.040;
125	–	} else {
126	–	effArea_ecal_i = 0.045;
127	–	effArea_hcal_i = 0.030;
128	–	}
129	–	}
130	–
131	–	float isoEcal_corr_i = lepvec[i].isoEcal - (effArea_ecal_i*rho);
132	–	float isoHcal_corr_i = lepvec[i].isoHcal - (effArea_hcal_i*rho);
133	–
134	–	for( int j=i+1; j<lepvec.size(); j++ )
135	–	{
136	–
137	–	if( !(lepvec[j].is4l) ) continue;
138	–
139	–	float effArea_ecal_j, effArea_hcal_j;
140	–	if( lepvec[j].isEB ) {
141	–	if( lepvec[j].type == 11 ) {
142	–	effArea_ecal_j = 0.101;
143	–	effArea_hcal_j = 0.021;
144	–	} else {
145	–	effArea_ecal_j = 0.074;
146	–	effArea_hcal_j = 0.022;
147	–	}
148	–	} else {
149	–	if( lepvec[j].type == 11 ) {
150	–	effArea_ecal_j = 0.046;
151	–	effArea_hcal_j = 0.040;
152	–	} else {
153	–	effArea_ecal_j = 0.045;
154	–	effArea_hcal_j = 0.030;
155	–	}
156	–	}
157	–
158	–	float isoEcal_corr_j = lepvec[j].isoEcal - (effArea_ecal_j*rho);
159	–	float isoHcal_corr_j = lepvec[j].isoHcal - (effArea_hcal_j*rho);
160	–	float RIso_i = (lepvec[i].isoTrk+isoEcal_corr_i+isoHcal_corr_i)/lepvec[i].vec->Pt();
161	–	float RIso_j = (lepvec[j].isoTrk+isoEcal_corr_j+isoHcal_corr_j)/lepvec[j].vec->Pt();
162	–	float comboIso = RIso_i + RIso_j;
163	–
164	–	if( comboIso > 0.35 ) {
165	–	if( ctrl.debug ) cout << "combo failing for indices: " << i << "," << j << endl;
166	–	passiso = false;
167	–	return passiso;
168	–	}
169	–	}
170	–	}
171	–
172	–	return passiso;
173	–	}
174	–
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 204 | 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 220 | Line 147 | SelectionStatus electronIsoSelection(Con
147		if( ele->IsEB() && ele->Pt() < 20 && reliso > PFISO_ELE_LOOSE_EB_LOWPT ) {
148		failiso = true;
149		}
223	–	if(ctrl.debug) cout << "before iso check ..." << endl;
150		if( !(ele->IsEB()) && ele->Pt() > 20 && reliso > PFISO_ELE_LOOSE_EE_HIGHPT ) {
225	–	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 247 | 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 268 | 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 332 | 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 351 | 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 362 | 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
302	+	/* KH - commented for sync
303		//
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	<
317	>	*/
318
319		if (IsLeptonFootprint)
320		continue;
#	Line 398 | Line 327 | SelectionStatus muonIsoMVASelection(Cont
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 448 | 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
394	+	// WARNING!!!!
395	+	// hardcode for sync ...
396	+	EffectiveAreaVersion = muT.kMuEAData2011;
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 511 | Line 448 | SelectionStatus muonIsoMVASelection(Cont
448
449
450		double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
451	<	mu->Eta(),
452	<	fChargedIso_DR0p0To0p1,
453	<	fChargedIso_DR0p1To0p2,
454	<	fChargedIso_DR0p2To0p3,
455	<	fChargedIso_DR0p3To0p4,
456	<	fChargedIso_DR0p4To0p5,
457	<	fGammaIso_DR0p0To0p1,
458	<	fGammaIso_DR0p1To0p2,
459	<	fGammaIso_DR0p2To0p3,
460	<	fGammaIso_DR0p3To0p4,
461	<	fGammaIso_DR0p4To0p5,
462	<	fNeutralHadronIso_DR0p0To0p1,
463	<	fNeutralHadronIso_DR0p1To0p2,
464	<	fNeutralHadronIso_DR0p2To0p3,
465	<	fNeutralHadronIso_DR0p3To0p4,
466	<	fNeutralHadronIso_DR0p4To0p5,
467	<	ctrl.debug);
451	>	mu->Eta(),
452	>	mu->IsGlobalMuon(),
453	>	mu->IsTrackerMuon(),
454	>	fChargedIso_DR0p0To0p1,
455	>	fChargedIso_DR0p1To0p2,
456	>	fChargedIso_DR0p2To0p3,
457	>	fChargedIso_DR0p3To0p4,
458	>	fChargedIso_DR0p4To0p5,
459	>	fGammaIso_DR0p0To0p1,
460	>	fGammaIso_DR0p1To0p2,
461	>	fGammaIso_DR0p2To0p3,
462	>	fGammaIso_DR0p3To0p4,
463	>	fGammaIso_DR0p4To0p5,
464	>	fNeutralHadronIso_DR0p0To0p1,
465	>	fNeutralHadronIso_DR0p1To0p2,
466	>	fNeutralHadronIso_DR0p2To0p3,
467	>	fNeutralHadronIso_DR0p3To0p4,
468	>	fNeutralHadronIso_DR0p4To0p5,
469	>	ctrl.debug);
470
471		SelectionStatus status;
472	<	bool pass = false;
472	>	bool pass;
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_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_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_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_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_FORPFID_CUT_BIN0)   pass = true;
490	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN0)   pass = true;
491		else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
492	<	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_FORPFID_CUT_BIN1)  pass = true;
492	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN1)  pass = true;
493		else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
494	<	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_FORPFID_CUT_BIN2)  pass = true;
494	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN2)  pass = true;
495		else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
496	<	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_FORPFID_CUT_BIN3)  pass = true;
497	<	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon()
498	<	&& mvaval >= MUON_ISOMVA_FORPFID_CUT_BIN4)
499	<	pass = true;
496	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN3)  pass = true;
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	>	status.isoMVA = mvaval;
505	>
506	>	if(ctrl.debug)  {
507	>	cout << "returning status : " << hex << status.getStatus() << dec << endl;
508	>	cout << "MVAVAL : " << status.isoMVA << endl;
509	>	}
510	>	return status;
511
512	+	}
513
548	–	pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
514
515	<	if( pass ) {
516	<	status.orStatus(SelectionStatus::LOOSEISO);
517	<	status.orStatus(SelectionStatus::TIGHTISO);
515	>	//--------------------------------------------------------------------------------------------------
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	>
529	>	if( ctrl.debug ) {
530	>	cout << "muonIsoMVASelection :: muons to veto " << endl;
531	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
532	>	const Muon * vmu = muonsToVeto[i];
533	>	cout << "\tpt: " << vmu->Pt()
534	>	<< "\teta: " << vmu->Eta()
535	>	<< "\tphi: " << vmu->Phi()
536	>	<< endl;
537	>	}
538	>	cout << "muonIsoMVASelection :: electrson to veto " << endl;
539	>	for( int i=0; i<electronsToVeto.size(); 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	>	// tmp iso rings
551	>	//
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	>
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 = 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	>
616	>	//
617	>	// Lepton Footprint Removal
618	>	//
619	>	Bool_t IsLeptonFootprint = kFALSE;
620	>	if (dr < 1.0) {
621	>
622	>	//
623	>	// Check for electrons
624	>	//
625	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
626	>	const Electron *tmpele = electronsToVeto[q];
627	>	// 4l electron
628	>	if( pf->HasTrackerTrk() ) {
629	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
630	>	IsLeptonFootprint = kTRUE;
631	>	}
632	>	if( pf->HasGsfTrk() ) {
633	>	if( pf->GsfTrk() == tmpele->GsfTrk() )
634	>	IsLeptonFootprint = kTRUE;
635	>	}
636	>	// PF charged
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	>	&& MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
643	>	IsLeptonFootprint = kTRUE;
644	>	} // loop over electrons
645	>
646	>	/* KH - commented for sync
647	>	//
648	>	// Check for muons
649	>	//
650	>	for (Int_t q=0; q < muonsToVeto.size(); ++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 && MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
659	>	IsLeptonFootprint = kTRUE;
660	>	} // loop over muons
661	>	*/
662	>
663	>	if (IsLeptonFootprint)
664	>	continue;
665	>
666	>	//
667	>	// Charged Iso Rings
668	>	//
669	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
670	>
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	>	//       }
686	>
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 Rings
698	>	//
699	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
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 Neutral Iso Rings
710	>	//
711	>	else {
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	>
720	>	}
721	>
722	>	}
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	>
765	>
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		}
554	–	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
853		return status;
854
855		}
856
857	+
858		//--------------------------------------------------------------------------------------------------
859		void initMuonIsoMVA() {
860		//--------------------------------------------------------------------------------------------------
861	<	muIsoMVA = new mithep::MuonIDMVA();
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");
#	Line 568 | Line 867 | void initMuonIsoMVA() {
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	<	mithep::MuonIDMVA::kIsoRingsV0,
870	>	MuonIDMVA::kIsoRingsV0,
871		kTRUE, weightFiles);
872		}
873
874
875
876		//--------------------------------------------------------------------------------------------------
877	+	double  muonPFIso04(ControlFlags &ctrl,
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;
890	+
891	+	//
892	+	// final iso
893	+	//
894	+	Double_t fChargedIso  = 0.0;
895	+	Double_t fGammaIso  = 0.0;
896	+	Double_t fNeutralHadronIso  = 0.0;
897	+
898	+	//
899	+	//Loop over PF Candidates
900	+	//
901	+	if(ctrl.debug) cout << "  muonPFIso04(): ----> " << endl;
902	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
903	+
904	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
905	+	const PFCandidate *pf = (PFCandidate*)((*fPFCandidates)[k]);
906	+
907	+	//
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	+	//
920	+
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 (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?
934	+	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
935	+	fChargedIso += pf->Pt();
936	+	}
937	+
938	+	//
939	+	// Gamma Iso
940	+	//
941	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
942	+	// KH, add to sync
943	+	if( pf->Pt() > 0.5 && dr > 0.01)
944	+	fGammaIso += pf->Pt();
945	+	}
946	+
947	+	//
948	+	// Other Neutrals
949	+	//
950	+	else {
951	+
952	+	if( pf->Pt() > 0.5  && dr > 0.01)
953	+	fNeutralHadronIso += pf->Pt();
954	+	}
955	+	}
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 + fmax(0.0,(fGammaIso + fNeutralHadronIso
987	+	-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
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	+	<< "\tfChargedIso: " << fChargedIso
997	+	<< "\tfGammaIso: " << fGammaIso
998	+	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
999	+	<< endl;
1000	+	}
1001	+
1002	+	return pfIso;
1003	+	}
1004	+
1005	+	//--------------------------------------------------------------------------------------------------
1006	+	SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
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, photonsToVeto);
1020	+	status.isoPF04 = pfIso;
1021	+	status.chisoPF04 = gChargedIso;
1022	+	status.gaisoPF04 = gGammaIso;
1023	+	status.neisoPF04 = gNeutralIso;
1024	+
1025	+	bool pass = false;
1026	+	if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1027	+
1028	+	if( pass ) {
1029	+	status.orStatus(SelectionStatus::LOOSEISO);
1030	+	status.orStatus(SelectionStatus::TIGHTISO);
1031	+	}
1032	+	if(ctrl.debug)
1033	+	cout << "  --> mu relpfIso: " << pfIso/mu->Pt() << ", returning status : " << hex << status.getStatus() << dec << endl;
1034	+	return status;
1035	+	}
1036	+
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 597 | 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 616 | Line 1076 | SelectionStatus electronIsoMVASelection(
1076		Double_t tmpChargedIso_DR0p2To0p3  = 0;
1077		Double_t tmpChargedIso_DR0p3To0p4  = 0;
1078		Double_t tmpChargedIso_DR0p4To0p5  = 0;
619	–	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;
633	–	Double_t tmpNeutralHadronIso_DR0p5To0p7  = 0;
1092
1093
1094
#	Line 660 | 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 682 | 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 701 | Line 1167 | SelectionStatus electronIsoMVASelection(
1167		}
1168		}
1169		// PF charged
1170	<	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
705	<	&& 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	<
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 727 | 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		}
1201		} // loop over muons
1202	<
1202	>	*/
1203
1204		if (IsLeptonFootprint)
1205		continue;
#	Line 742 | 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 762 | 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();
765	–	if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
1233
1234		}
1235
#	Line 771 | Line 1238 | SelectionStatus electronIsoMVASelection(
1238		//
1239		else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1240
1241	<	if (fabs(ele->SCluster()->Eta()) > 1.479) {
775	<	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
776	<	}
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 783 | 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();
786	–	if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
787	–
1251		}
1252
1253		//
#	Line 798 | 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();
801	–	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	>
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;
1294	+	// WARNING!!!!
1295
1296		if( ctrl.debug) {
1297		cout << "RHO: " << rho << endl;
#	Line 837 | 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 869 | 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 915 | 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 931 | Line 1427 | SelectionStatus electronIsoMVASelection(
1427		if (subdet == 0 && ptBin == 1) MVABin = 3;
1428		if (subdet == 1 && ptBin == 1) MVABin = 4;
1429		if (subdet == 2 && ptBin == 1) MVABin = 5;
934	–
935	–	if( MVABin == 0 && mvaval > ELECTRON_ISOMVA_CUT_BIN0 ) pass = true;
936	–	if( MVABin == 1 && mvaval > ELECTRON_ISOMVA_CUT_BIN1 ) pass = true;
937	–	if( MVABin == 2 && mvaval > ELECTRON_ISOMVA_CUT_BIN2 ) pass = true;
938	–	if( MVABin == 3 && mvaval > ELECTRON_ISOMVA_CUT_BIN3 ) pass = true;
939	–	if( MVABin == 4 && mvaval > ELECTRON_ISOMVA_CUT_BIN4 ) pass = true;
940	–	if( MVABin == 5 && mvaval > ELECTRON_ISOMVA_CUT_BIN5 ) pass = true;
1430
1431	<	// pre-selection iso ...
1432	<	pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
1431	>	pass = false;
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;
1442	>	//   if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
1443	>	//   if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
1444	>	//   if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
1445	>	//   if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
1446	>	//   if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
1447	>	//   if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
1448	>	//   if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
1449
945	–	if( pass ) {
946	–	status.orStatus(SelectionStatus::LOOSEISO);
947	–	status.orStatus(SelectionStatus::TIGHTISO);
948	–	}
1450		if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1451		return status;
1452	+
1453	+	}
1454	+
1455	+
1456	+	//--------------------------------------------------------------------------------------------------
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 Muon * vmu = muonsToVeto[i];
1477	+	cout << "\tpt: " << vmu->Pt()
1478	+	<< "\teta: " << vmu->Eta()
1479	+	<< "\tphi: " << vmu->Phi()
1480	+	<< endl;
1481	+	}
1482	+	cout << "electronIsoMVASelection :: electrson to veto " << endl;
1483	+	for( int i=0; i<electronsToVeto.size(); i++ ) {
1484	+	const Electron * vel = electronsToVeto[i];
1485	+	cout << "\tpt: " << vel->Pt()
1486	+	<< "\teta: " << vel->Eta()
1487	+	<< "\tphi: " << vel->Phi()
1488	+	<< "\ttrk: " << vel->TrackerTrk()
1489	+	<< endl;
1490	+	}
1491	+	}
1492	+
1493	+	bool failiso=false;
1494	+
1495	+	//
1496	+	// tmp iso rings
1497	+	//
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	+
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 = 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);
1557	+	cout << endl;
1558	+	}
1559	+
1560	+
1561	+	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
1562	+	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1563	+
1564	+
1565	+	//
1566	+	// Lepton Footprint Removal
1567	+	//
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 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() ) {
1583	+	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1584	+	IsLeptonFootprint = kTRUE;
1585	+	}
1586	+	}
1587	+	if( pf->HasGsfTrk()  ) {
1588	+	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1589	+	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1590	+	IsLeptonFootprint = kTRUE;
1591	+	}
1592	+	}
1593	+	// PF charged
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	+	&& 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 Muon *tmpmu = muonsToVeto[q];
1613	+	// 4l muon
1614	+	if( pf->HasTrackerTrk() ) {
1615	+	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1616	+	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1617	+	IsLeptonFootprint = kTRUE;
1618	+	}
1619	+	}
1620	+	// PF charged
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	+	*/
1627	+
1628	+	if (IsLeptonFootprint)
1629	+	continue;
1630	+
1631	+	//
1632	+	// Charged Iso Rings
1633	+	//
1634	+	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1635	+
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;
1644	+
1645	+	// Footprint Veto
1646	+	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1647	+
1648	+	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1649	+	<< "\ttype: " << pf->PFType()
1650	+	<< "\ttrk: " << pf->TrackerTrk() << endl;
1651	+
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 Rings
1662	+	//
1663	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1664	+
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	+
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	+	// Other Neutral Iso Rings
1679	+	//
1680	+	else {
1681	+	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
1682	+	<< dr << endl;
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	+	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	+	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	+	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	+	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		void initElectronIsoMVA() {
1882		//--------------------------------------------------------------------------------------------------
1883	<	eleIsoMVA = new mithep::ElectronIDMVA();
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	<	mithep::ElectronIDMVA::kIsoRingsV0,
1890	>	ElectronIDMVA::kIsoRingsV0,
1891		kTRUE, weightFiles);
1892		}
1893	+
1894	+
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	+	//
1911	+	Double_t fChargedIso = 0.0;
1912	+	Double_t fGammaIso = 0.0;
1913	+	Double_t fNeutralHadronIso = 0.0;
1914	+
1915	+
1916	+	//
1917	+	//Loop over PF Candidates
1918	+	//
1919	+	if(ctrl.debug) cout << "  electronPFIso04(): ----> " << endl;
1920	+	for(int k=0; k<fPFCandidates->GetEntries(); ++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 = 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(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	+	// sync : I don't think theyre doing this ...
1952	+	//
1953	+	//     if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
1954	+	//   (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
1955	+	//       if( ctrl.debug ) cout << "\tskipping, matches to the electron ..."  << endl;
1956	+	//       continue;
1957	+	//     }
1958	+
1959	+
1960	+	//
1961	+	// Lepton Footprint Removal
1962	+	//
1963	+	Bool_t IsLeptonFootprint = kFALSE;
1964	+	if (dr < 1.0) {
1965	+
1966	+
1967	+	//
1968	+	// Charged Iso
1969	+	//
1970	+	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1971	+
1972	+	// Veto any PFmuon, or PFEle
1973	+	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) {
1974	+	if( ctrl.debug ) cout << "    skipping, pf is an ele or mu .." <<endl;
1975	+	continue;
1976	+	}
1977	+
1978	+	// Footprint Veto
1979	+	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1980	+
1981	+	if( ctrl.debug) cout << "    charged:: pt: " << pf->Pt()
1982	+	<< "\ttype: " << pf->PFType()
1983	+	<< "\ttrk: " << pf->TrackerTrk() << endl;
1984	+
1985	+	fChargedIso += pf->Pt();
1986	+	}
1987	+
1988	+	//
1989	+	// Gamma Iso
1990	+	//
1991	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1992	+
1993	+	if (fabs(ele->SCluster()->Eta()) > 1.479) {
1994	+	if (MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
1995	+	}
1996	+
1997	+	assert(ele->HasSuperCluster());
1998	+	if(ele->GsfTrk()->NExpectedHitsInner()>0 && pf->MvaGamma() > 0.99 && pf->HasSCluster() && ele->SCluster() == pf->SCluster())      continue;
1999	+
2000	+
2001	+	if( ctrl.debug) cout << "    gamma:: " << pf->Pt() << " "
2002	+	<< dr << endl;
2003	+	// KH, add to sync
2004	+	//      if( pf->Pt() > 0.5 )
2005	+	fGammaIso += pf->Pt();
2006	+	}
2007	+
2008	+	//
2009	+	// Neutral Iso
2010	+	//
2011	+	else {
2012	+	if( ctrl.debug) cout << "    neutral:: " << pf->Pt() << " "
2013	+	<< dr << endl;
2014	+	// KH, add to sync
2015	+	//      if( pf->Pt() > 0.5 )
2016	+	fNeutralHadronIso += pf->Pt();
2017	+	}
2018	+
2019	+	}
2020	+
2021	+	}
2022	+
2023	+
2024	+	double rho=0;
2025	+	if( (EffectiveAreaVersion == ElectronTools::kEleEAFall11MC) ||
2026	+	(EffectiveAreaVersion == ElectronTools::kEleEAData2011) ) {
2027	+	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25()) ||
2028	+	isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25())))
2029	+	rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25();
2030	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2031	+	EffectiveAreaVersion  = ElectronTools::kEleEAData2011;
2032	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2033	+	} else {
2034	+	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJets()) ||
2035	+	isinf(fPUEnergyDensity->At(0)->RhoKt6PFJets())))
2036	+	rho = fPUEnergyDensity->At(0)->RhoKt6PFJets();
2037	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2038	+	EffectiveAreaVersion  = ElectronTools::kEleEAData2012;
2039	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2040	+	}
2041	+	if(ctrl.debug) cout << "    rho: " << rho << endl;
2042	+
2043	+	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2044	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2045	+	ele->Eta(),EffectiveAreaVersion)));
2046	+
2047	+
2048	+	gChargedIso = fChargedIso;
2049	+	gGammaIso = fGammaIso;
2050	+	gNeutralIso = fNeutralHadronIso;
2051	+
2052	+	if( ctrl.debug ) {
2053	+	cout << "    PFiso: " << pfIso
2054	+	<< "\tfChargedIso: " << fChargedIso
2055	+	<< "\tfGammaIso: " << fGammaIso
2056	+	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
2057	+	<< endl;
2058	+	}
2059	+
2060	+	return pfIso;
2061	+	}
2062	+
2063	+	//--------------------------------------------------------------------------------------------------
2064	+	SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2065	+	const Electron * ele,
2066	+	const Vertex * vtx,
2067	+	const Array<PFCandidate> * fPFCandidates,
2068	+	const Array<PileupEnergyDensity> * fPUEnergyDensity,
2069	+	ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2070	+	vector<const PFCandidate*> photonsToVeto)
2071	+	//--------------------------------------------------------------------------------------------------
2072	+	{
2073	+
2074	+	SelectionStatus status;
2075	+
2076	+	double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, fPUEnergyDensity,
2077	+	EffectiveAreaVersion, photonsToVeto);
2078	+	status.isoPF04 = pfIso;
2079	+	status.chisoPF04 = gChargedIso;
2080	+	status.gaisoPF04 = gGammaIso;
2081	+	status.neisoPF04 = gNeutralIso;
2082	+
2083	+	bool pass = false;
2084	+	if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2085	+
2086	+	if( pass ) {
2087	+	status.orStatus(SelectionStatus::LOOSEISO);
2088	+	status.orStatus(SelectionStatus::TIGHTISO);
2089	+	}
2090	+	if(ctrl.debug)
2091	+	cout << "  --> ele relpfIso: " << pfIso/ele->Pt() << ", returning status : " << hex << status.getStatus() << dec << endl;
2092	+	return status;
2093	+	}
2094	+
2095	+	//--------------------------------------------------------------------------------------------------
2096	+	double  dbetaCorrectedIsoDr03(ControlFlags & ctrl,
2097	+	const PFCandidate * photon,
2098	+	const Muon * lepton,
2099	+	const Array<PFCandidate> * fPFCandidates)
2100	+	//--------------------------------------------------------------------------------------------------
2101	+	{
2102	+
2103	+	//
2104	+	// final iso
2105	+	//
2106	+	Double_t fChargedIso  = 0.0;
2107	+	Double_t fGammaIso  = 0.0;
2108	+	Double_t fNeutralHadronIso  = 0.0;
2109	+	Double_t fpfPU  = 0.0;
2110	+
2111	+	//
2112	+	// Loop over PF Candidates
2113	+	//
2114	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2115	+
2116	+	const PFCandidate *pf = (PFCandidate*)((*fPFCandidates)[k]);
2117	+
2118	+	Double_t deta = (photon->Eta() - pf->Eta());
2119	+	Double_t dphi = MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2120	+	Double_t dr = MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2121	+	if (dr > 0.3) continue;
2122	+
2123	+	if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2124	+	if( pf->Pt() >= 0.2 && dr > 0.01 )
2125	+	fpfPU += pf->Pt();
2126	+	continue;
2127	+	}
2128	+
2129	+	//
2130	+	// skip this photon
2131	+	//
2132	+	if( abs(pf->PFType()) == PFCandidate::eGamma &&
2133	+	pf->Et() == photon->Et() ) continue;
2134	+
2135	+
2136	+	//
2137	+	// Charged Iso
2138	+	//
2139	+	if (pf->Charge() != 0 ) {
2140	+	if( dr > 0.01 && pf->Pt() >= 0.2 &&
2141	+	!(pf->TrackerTrk() == lepton->TrackerTrk()) )
2142	+	fChargedIso += pf->Pt();
2143	+	}
2144	+
2145	+	//
2146	+	// Gamma Iso
2147	+	//
2148	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2149	+	if( pf->Pt() > 0.5 && dr > 0.01)
2150	+	fGammaIso += pf->Pt();
2151	+	}
2152	+
2153	+	//
2154	+	// Other Neutrals
2155	+	//
2156	+	else {
2157	+	if( pf->Pt() > 0.5 && dr > 0.01)
2158	+	fNeutralHadronIso += pf->Pt();
2159	+	}
2160	+
2161	+	}
2162	+
2163	+	if( ctrl.debug ) {
2164	+	cout << "  ---> photon dbetaIso :: " << endl;
2165	+	cout << "\tfChargedIso: " << fChargedIso
2166	+	<< "\tfGammaIso: " << fGammaIso
2167	+	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
2168	+	<< "\tfpfPU: " << fpfPU
2169	+	<< endl;
2170	+	}
2171	+	double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso - 0.5*fpfPU;
2172	+	return pfIso/photon->Pt();
2173	+	}
2174	+
2175	+
2176	+	//--------------------------------------------------------------------------------------------------
2177	+	double  dbetaCorrectedIsoDr03(ControlFlags & ctrl,
2178	+	const PFCandidate * photon,
2179	+	const Electron * lepton,
2180	+	const Array<PFCandidate> * fPFCandidates)
2181	+	//--------------------------------------------------------------------------------------------------
2182	+	{
2183	+
2184	+	//
2185	+	// final iso
2186	+	//
2187	+	Double_t fChargedIso  = 0.0;
2188	+	Double_t fGammaIso  = 0.0;
2189	+	Double_t fNeutralHadronIso  = 0.0;
2190	+	Double_t fpfPU  = 0.0;
2191	+
2192	+	//
2193	+	// Loop over PF Candidates
2194	+	//
2195	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2196	+
2197	+	const PFCandidate *pf = (PFCandidate*)((*fPFCandidates)[k]);
2198	+
2199	+	Double_t deta = (photon->Eta() - pf->Eta());
2200	+	Double_t dphi = MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2201	+	Double_t dr = MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2202	+	if (dr > 0.3) continue;
2203	+
2204	+	if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2205	+	if( pf->Pt() >= 0.2 && dr > 0.01 )
2206	+	fpfPU += pf->Pt();
2207	+	continue;
2208	+	}
2209	+
2210	+	//
2211	+	// skip this photon
2212	+	//
2213	+	if( abs(pf->PFType()) == PFCandidate::eGamma &&
2214	+	pf->Et() == photon->Et() ) continue;
2215	+
2216	+
2217	+	//
2218	+	// Charged Iso
2219	+	//
2220	+	if (pf->Charge() != 0 ) {
2221	+	if( dr > 0.01 && pf->Pt() >= 0.2 &&
2222	+	!(pf->TrackerTrk() == lepton->TrackerTrk()) )
2223	+	fChargedIso += pf->Pt();
2224	+	}
2225	+
2226	+	//
2227	+	// Gamma Iso
2228	+	//
2229	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2230	+	if( pf->Pt() > 0.5 && dr > 0.01)
2231	+	fGammaIso += pf->Pt();
2232	+	}
2233	+
2234	+	//
2235	+	// Other Neutrals
2236	+	//
2237	+	else {
2238	+	if( pf->Pt() > 0.5 && dr > 0.01)
2239	+	fNeutralHadronIso += pf->Pt();
2240	+	}
2241	+
2242	+	}
2243	+
2244	+	if( ctrl.debug ) {
2245	+	cout << "  ---> photon dbetaIso :: " << endl;
2246	+	cout << "\tfChargedIso: " << fChargedIso
2247	+	<< "\tfGammaIso: " << fGammaIso
2248	+	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
2249	+	<< "\tfpfPU: " << fpfPU
2250	+	<< endl;
2251	+	}
2252	+	double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso - 0.5*fpfPU;
2253	+	return pfIso/photon->Pt();
2254	+	}
2255	+
2256	+
2257	+
2258	+
2259	+
2260	+	//--------------------------------------------------------------------------------------------------
2261	+	double  nonCorrectedIsoDr03(ControlFlags & ctrl,
2262	+	const PFCandidate * photon,
2263	+	const Muon * lepton,
2264	+	const Array<PFCandidate> * fPFCandidates)
2265	+	//--------------------------------------------------------------------------------------------------
2266	+	{
2267	+
2268	+	//
2269	+	// final iso
2270	+	//
2271	+	Double_t fChargedIso  = 0.0;
2272	+	Double_t fGammaIso  = 0.0;
2273	+	Double_t fNeutralHadronIso  = 0.0;
2274	+	Double_t fpfPU  = 0.0;
2275	+
2276	+	//
2277	+	// Loop over PF Candidates
2278	+	//
2279	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2280	+
2281	+	const PFCandidate *pf = (PFCandidate*)((*fPFCandidates)[k]);
2282	+
2283	+	Double_t deta = (photon->Eta() - pf->Eta());
2284	+	Double_t dphi = MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2285	+	Double_t dr = MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2286	+	if (dr > 0.3) continue;
2287	+
2288	+	if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2289	+	if( pf->Pt() >= 0.2 && dr > 0.01 )
2290	+	fpfPU += pf->Pt();
2291	+	continue;
2292	+	}
2293	+
2294	+	//
2295	+	// skip this photon
2296	+	//
2297	+	if( abs(pf->PFType()) == PFCandidate::eGamma &&
2298	+	pf->Et() == photon->Et() ) continue;
2299	+
2300	+
2301	+	//
2302	+	// Charged Iso
2303	+	//
2304	+	if (pf->Charge() != 0 ) {
2305	+	if( dr > 0.01 && pf->Pt() >= 0.2 &&
2306	+	!(pf->TrackerTrk() == lepton->TrackerTrk()) )
2307	+	fChargedIso += pf->Pt();
2308	+	}
2309	+
2310	+	//
2311	+	// Gamma Iso
2312	+	//
2313	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2314	+	if( pf->Pt() > 0.5 && dr > 0.01)
2315	+	fGammaIso += pf->Pt();
2316	+	}
2317	+
2318	+	//
2319	+	// Other Neutrals
2320	+	//
2321	+	else {
2322	+	if( pf->Pt() > 0.5 && dr > 0.01)
2323	+	fNeutralHadronIso += pf->Pt();
2324	+	}
2325	+
2326	+	}
2327	+
2328	+	if( ctrl.debug ) {
2329	+	cout << "  ---> photon dbetaIso :: " << endl;
2330	+	cout << "\tfChargedIso: " << fChargedIso
2331	+	<< "\tfGammaIso: " << fGammaIso
2332	+	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
2333	+	<< "\tfpfPU: " << fpfPU
2334	+	<< endl;
2335	+	}
2336	+	double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso + fpfPU;
2337	+	return pfIso/photon->Pt();
2338	+	}
2339	+
2340	+
2341	+
2342	+	//--------------------------------------------------------------------------------------------------
2343	+	double  nonCorrectedIsoDr03(ControlFlags & ctrl,
2344	+	const PFCandidate * photon,
2345	+	const Electron * lepton,
2346	+	const Array<PFCandidate> * fPFCandidates)
2347	+	//--------------------------------------------------------------------------------------------------
2348	+	{
2349	+
2350	+	//
2351	+	// final iso
2352	+	//
2353	+	Double_t fChargedIso  = 0.0;
2354	+	Double_t fGammaIso  = 0.0;
2355	+	Double_t fNeutralHadronIso  = 0.0;
2356	+	Double_t fpfPU  = 0.0;
2357	+
2358	+	//
2359	+	// Loop over PF Candidates
2360	+	//
2361	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2362	+
2363	+	const PFCandidate *pf = (PFCandidate*)((*fPFCandidates)[k]);
2364	+
2365	+	Double_t deta = (photon->Eta() - pf->Eta());
2366	+	Double_t dphi = MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2367	+	Double_t dr = MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2368	+	if (dr > 0.3) continue;
2369	+
2370	+	if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2371	+	if( pf->Pt() >= 0.2 && dr > 0.01 )
2372	+	fpfPU += pf->Pt();
2373	+	continue;
2374	+	}
2375	+
2376	+	//
2377	+	// skip this photon
2378	+	//
2379	+	if( abs(pf->PFType()) == PFCandidate::eGamma &&
2380	+	pf->Et() == photon->Et() ) continue;
2381	+
2382	+
2383	+	//
2384	+	// Charged Iso
2385	+	//
2386	+	if (pf->Charge() != 0 ) {
2387	+	if( dr > 0.01 && pf->Pt() >= 0.2 &&
2388	+	!(pf->TrackerTrk() == lepton->TrackerTrk()) )
2389	+	fChargedIso += pf->Pt();
2390	+	}
2391	+
2392	+	//
2393	+	// Gamma Iso
2394	+	//
2395	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2396	+	if( pf->Pt() > 0.5 && dr > 0.01)
2397	+	fGammaIso += pf->Pt();
2398	+	}
2399	+
2400	+	//
2401	+	// Other Neutrals
2402	+	//
2403	+	else {
2404	+	if( pf->Pt() > 0.5 && dr > 0.01)
2405	+	fNeutralHadronIso += pf->Pt();
2406	+	}
2407	+
2408	+	}
2409	+
2410	+	if( ctrl.debug ) {
2411	+	cout << "photon dbetaIso :: " << endl;
2412	+	cout << "\tfChargedIso: " << fChargedIso
2413	+	<< "\tfGammaIso: " << fGammaIso
2414	+	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
2415	+	<< "\tfpfPU: " << fpfPU
2416	+	<< endl;
2417	+	}
2418	+	double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso + fpfPU;
2419	+	return pfIso/photon->Pt();
2420	+	}
2421	+
2422	+
2423	+

Diff Legend

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