ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

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

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents):
Revision 1.2 by khahn, Fri Feb 17 14:49:00 2012 UTC vs.
Revision 1.16 by khahn, Thu May 10 22:53:21 2012 UTC

#	Line 3 | Line 3
3		#include "IsolationSelection.h"
4		#include "IsolationSelectionDefs.h"
5
6	<	bool pairwiseIsoSelection( ControlFlags &ctrl, vector<SimpleLepton> &lepvec, float rho ) {
6	>	#include "MathUtils.h"
7	>	#include "MuonTools.h"
8	>	#include "MuonIDMVA.h"
9	>	#include "ElectronTools.h"
10	>	#include "ElectronIDMVA.h"
11	>
12	>	using namespace mithep;
13	>
14	>	mithep::MuonIDMVA     * muIsoMVA;
15	>	mithep::MuonTools       muT;
16	>	mithep::ElectronIDMVA * eleIsoMVA;
17	>	mithep::ElectronTools   eleT;
18	>
19	>	// global hack to sync
20	>	double gChargedIso;
21	>	double gGammaIso;
22	>	double gNeutralIso;
23	>
24	>
25	>	//--------------------------------------------------------------------------------------------------
26	>	Float_t computePFMuonIso(const mithep::Muon *muon,
27	>	const mithep::Vertex & vtx,
28	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
29	>	const Double_t dRMax)
30	>	//--------------------------------------------------------------------------------------------------
31	>	{
32	>	const Double_t dRMin    = 0;
33	>	const Double_t neuPtMin = 1.0;
34	>	const Double_t dzMax    = 0.1;
35	>
36	>	Double_t zLepton = (muon->BestTrk()) ? muon->BestTrk()->DzCorrected(vtx) : 0.0;
37	>
38	>	Float_t iso=0;
39	>	for(UInt_t ipf=0; ipf<fPFCandidates->GetEntries(); ipf++) {
40	>	const PFCandidate *pfcand = fPFCandidates->At(ipf);
41	>
42	>	if(!pfcand->HasTrk() && (pfcand->Pt()<=neuPtMin)) continue;  // pT cut on neutral particles
43	>
44	>	// exclude THE muon
45	>	if(pfcand->TrackerTrk() && muon->TrackerTrk() && (pfcand->TrackerTrk()==muon->TrackerTrk())) continue;
46	>
47	>	// dz cut
48	>	Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(vtx) - zLepton) : 0;
49	>	if(dz >= dzMax) continue;
50	>
51	>	// check iso cone
52	>	Double_t dr = MathUtils::DeltaR(muon->Mom(), pfcand->Mom());
53	>	if(dr<dRMax && dr>=dRMin)
54	>	iso += pfcand->Pt();
55	>	}
56	>
57	>	return iso;
58	>	}
59	>
60	>	//--------------------------------------------------------------------------------------------------
61	>	Float_t computePFEleIso(const mithep::Electron *electron,
62	>	const mithep::Vertex & fVertex,
63	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
64	>	const Double_t dRMax)
65	>	//--------------------------------------------------------------------------------------------------
66	>	{
67	>	const Double_t dRMin    = 0;
68	>	const Double_t neuPtMin = 1.0;
69	>	const Double_t dzMax    = 0.1;
70	>
71	>	Double_t zLepton = (electron->BestTrk()) ? electron->BestTrk()->DzCorrected(fVertex) : 0.0;
72	>
73	>	Float_t iso=0;
74	>	for(UInt_t ipf=0; ipf<fPFCandidates->GetEntries(); ipf++) {
75	>	const PFCandidate *pfcand = (PFCandidate*)(fPFCandidates->At(ipf));
76	>
77	>	if(!pfcand->HasTrk() && (pfcand->Pt()<=neuPtMin)) continue;  // pT cut on neutral particles
78	>
79	>	// dz cut
80	>	Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(fVertex) - zLepton) : 0;
81	>	if(dz >= dzMax) continue;
82	>
83	>	// remove THE electron
84	>	if(pfcand->TrackerTrk() && electron->TrackerTrk() && (pfcand->TrackerTrk()==electron->TrackerTrk())) continue;
85	>	if(pfcand->GsfTrk()     && electron->GsfTrk()     && (pfcand->GsfTrk()==electron->GsfTrk()))         continue;
86	>
87	>	// check iso cone
88	>	Double_t dr = MathUtils::DeltaR(electron->Mom(), pfcand->Mom());
89	>	if(dr<dRMax && dr>=dRMin) {
90	>	// eta-strip veto for photons
91	>	if((pfcand->PFType() == PFCandidate::eGamma) && fabs(electron->Eta() - pfcand->Eta()) < 0.025) continue;
92	>
93	>	// Inner cone (one tower = dR < 0.07) veto for non-photon neutrals
94	>	if(!pfcand->HasTrk() && (pfcand->PFType() == PFCandidate::eNeutralHadron) &&
95	>	(MathUtils::DeltaR(electron->Mom(), pfcand->Mom()) < 0.07)) continue;
96	>
97	>	iso += pfcand->Pt();
98	>	}
99	>	}
100	>
101	>	return iso;
102	>	};
103	>
104	>	//--------------------------------------------------------------------------------------------------
105	>	bool pairwiseIsoSelection( ControlFlags &ctrl,
106	>	vector<SimpleLepton> &lepvec,
107	>	float rho )
108	>	//--------------------------------------------------------------------------------------------------
109	>	{
110
111		bool passiso=true;
112
#	Line 60 | Line 163 | bool pairwiseIsoSelection( ControlFlags
163
164		float isoEcal_corr_j = lepvec[j].isoEcal - (effArea_ecal_j*rho);
165		float isoHcal_corr_j = lepvec[j].isoHcal - (effArea_hcal_j*rho);
166	<	float RIso_i = (lepvec[i].isoTrk+isoEcal_corr_i+isoHcal_corr_i)/lepvec[i].vec->Pt();
167	<	float RIso_j = (lepvec[j].isoTrk+isoEcal_corr_j+isoHcal_corr_j)/lepvec[j].vec->Pt();
166	>	float RIso_i = (lepvec[i].isoTrk+isoEcal_corr_i+isoHcal_corr_i)/lepvec[i].vec.Pt();
167	>	float RIso_j = (lepvec[j].isoTrk+isoEcal_corr_j+isoHcal_corr_j)/lepvec[j].vec.Pt();
168		float comboIso = RIso_i + RIso_j;
169
170		if( comboIso > 0.35 ) {
#	Line 75 | Line 178 | bool pairwiseIsoSelection( ControlFlags
178		return passiso;
179		}
180
181	<
182	<	SelectionStatus passMuonIsoSelection( ControlFlags &ctrl, const mithep::TMuon * mu ) {
183	<
184	<	float reliso = mu->pfIso03/mu->pt;
185	<	bool isEB = (fabs(mu->eta) < 1.479 ? 1 : 0 );
181	>	//--------------------------------------------------------------------------------------------------
182	>	SelectionStatus muonIsoSelection(ControlFlags &ctrl,
183	>	const mithep::Muon * mu,
184	>	const mithep::Vertex & vtx,
185	>	const mithep::Array<mithep::PFCandidate> * fPFCandidateCol   )
186	>	//--------------------------------------------------------------------------------------------------
187	>	{
188	>	float reliso = computePFMuonIso(mu,vtx,fPFCandidateCol,0.3)/mu->Pt();
189	>	bool isEB = (fabs(mu->Eta()) < 1.479 ? 1 : 0 );
190		bool failiso = false;
191	<	if( isEB && mu->pt > 20 && reliso > PFISO_MU_LOOSE_EB_HIGHPT ) {
191	>	if( isEB && mu->Pt() > 20 && reliso > PFISO_MU_LOOSE_EB_HIGHPT ) {
192		failiso = true;
193		}
194	<	if( isEB && mu->pt < 20 && reliso > PFISO_MU_LOOSE_EB_LOWPT ) {
194	>	if( isEB && mu->Pt() < 20 && reliso > PFISO_MU_LOOSE_EB_LOWPT ) {
195		failiso = true;
196		}
197	<	if( !(isEB) && mu->pt > 20 && reliso > PFISO_MU_LOOSE_EE_HIGHPT ) {
197	>	if( !(isEB) && mu->Pt() > 20 && reliso > PFISO_MU_LOOSE_EE_HIGHPT ) {
198		failiso = true;
199		}
200	<	if( !(isEB) && mu->pt < 20 && reliso > PFISO_MU_LOOSE_EE_LOWPT ) {
200	>	if( !(isEB) && mu->Pt() < 20 && reliso > PFISO_MU_LOOSE_EE_LOWPT ) {
201		failiso = true;
202		}
203
#	Line 101 | Line 208 | SelectionStatus passMuonIsoSelection( Co
208
209		};
210
211	<
212	<	SelectionStatus failEleIso(ControlFlags &ctrl, const mithep::TElectron * ele) {
211	>	//--------------------------------------------------------------------------------------------------
212	>	SelectionStatus electronIsoSelection(ControlFlags &ctrl,
213	>	const mithep::Electron * ele,
214	>	const mithep::Vertex &fVertex,
215	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates)
216	>	//--------------------------------------------------------------------------------------------------
217	>	{
218
219		bool failiso=false;
220
221	<	float reliso = ele->pfIso04/ele->pt;
222	<	bool isEB = (fabs(ele->eta) < 1.479 ? 1 : 0 );
223	<	if( isEB && ele->pt > 20 && reliso > PFISO_ELE_LOOSE_EB_HIGHPT ) {
221	>	float reliso = computePFEleIso(ele,fVertex,fPFCandidates,0.4)/ele->Pt();
222	>
223	>	if( ele->IsEB() && ele->Pt() > 20 && reliso > PFISO_ELE_LOOSE_EB_HIGHPT ) {
224		failiso = true;
225		}
226	<	if( isEB && ele->pt < 20 && reliso > PFISO_ELE_LOOSE_EB_LOWPT ) {
226	>	if( ele->IsEB() && ele->Pt() < 20 && reliso > PFISO_ELE_LOOSE_EB_LOWPT ) {
227		failiso = true;
228		}
229		if(ctrl.debug) cout << "before iso check ..." << endl;
230	<	if( !(isEB) && ele->pt > 20 && reliso > PFISO_ELE_LOOSE_EE_HIGHPT ) {
230	>	if( !(ele->IsEB()) && ele->Pt() > 20 && reliso > PFISO_ELE_LOOSE_EE_HIGHPT ) {
231		if(ctrl.debug) cout << "\tit fails ..." << endl;
232		failiso = true;
233		}
234	<	if( !(isEB) && ele->pt < 20 && reliso > PFISO_ELE_LOOSE_EE_LOWPT ) {
234	>	if( !(ele->IsEB()) && ele->Pt() < 20 && reliso > PFISO_ELE_LOOSE_EE_LOWPT ) {
235		failiso = true;
236		}
237
238		SelectionStatus status;
239		if( !failiso ) {
240	<	status.setStatus(SelectionStatus::LOOSEISO);
241	<	status.setStatus(SelectionStatus::TIGHTISO);
240	>	status.orStatus(SelectionStatus::LOOSEISO);
241	>	status.orStatus(SelectionStatus::TIGHTISO);
242	>	}
243	>	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
244	>	return status;
245	>
246	>	}
247	>
248	>
249	>	bool noIso(ControlFlags &, vector<SimpleLepton> &, float rho) {
250	>
251	>	return true;
252	>	}
253	>
254	>	//--------------------------------------------------------------------------------------------------
255	>	SelectionStatus muonIsoMVASelection(ControlFlags &ctrl,
256	>	const mithep::Muon * mu,
257	>	const mithep::Vertex & vtx,
258	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
259	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
260	>	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
261	>	vector<const mithep::Muon*> muonsToVeto,
262	>	vector<const mithep::Electron*> electronsToVeto)
263	>	//--------------------------------------------------------------------------------------------------
264	>	{
265	>
266	>	if( ctrl.debug ) {
267	>	cout << "muonIsoMVASelection :: muons to veto " << endl;
268	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
269	>	const mithep::Muon * vmu = muonsToVeto[i];
270	>	cout << "\tpt: " << vmu->Pt()
271	>	<< "\teta: " << vmu->Eta()
272	>	<< "\tphi: " << vmu->Phi()
273	>	<< endl;
274	>	}
275	>	cout << "muonIsoMVASelection :: electrson to veto " << endl;
276	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
277	>	const mithep::Electron * vel = electronsToVeto[i];
278	>	cout << "\tpt: " << vel->Pt()
279	>	<< "\teta: " << vel->Eta()
280	>	<< "\tphi: " << vel->Phi()
281	>	<< endl;
282	>	}
283	>	}
284	>	bool failiso=false;
285	>
286	>	//
287	>	// tmp iso rings
288	>	//
289	>	Double_t tmpChargedIso_DR0p0To0p1  = 0;
290	>	Double_t tmpChargedIso_DR0p1To0p2  = 0;
291	>	Double_t tmpChargedIso_DR0p2To0p3  = 0;
292	>	Double_t tmpChargedIso_DR0p3To0p4  = 0;
293	>	Double_t tmpChargedIso_DR0p4To0p5  = 0;
294	>	Double_t tmpChargedIso_DR0p5To0p7  = 0;
295	>
296	>	Double_t tmpGammaIso_DR0p0To0p1  = 0;
297	>	Double_t tmpGammaIso_DR0p1To0p2  = 0;
298	>	Double_t tmpGammaIso_DR0p2To0p3  = 0;
299	>	Double_t tmpGammaIso_DR0p3To0p4  = 0;
300	>	Double_t tmpGammaIso_DR0p4To0p5  = 0;
301	>	Double_t tmpGammaIso_DR0p5To0p7  = 0;
302	>
303	>	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
304	>	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
305	>	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
306	>	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
307	>	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
308	>	Double_t tmpNeutralHadronIso_DR0p5To0p7  = 0;
309	>
310	>
311	>
312	>	//
313	>	// final rings for the MVA
314	>	//
315	>	Double_t fChargedIso_DR0p0To0p1;
316	>	Double_t fChargedIso_DR0p1To0p2;
317	>	Double_t fChargedIso_DR0p2To0p3;
318	>	Double_t fChargedIso_DR0p3To0p4;
319	>	Double_t fChargedIso_DR0p4To0p5;
320	>	Double_t fChargedIso_DR0p5To0p7;
321	>
322	>	Double_t fGammaIso_DR0p0To0p1;
323	>	Double_t fGammaIso_DR0p1To0p2;
324	>	Double_t fGammaIso_DR0p2To0p3;
325	>	Double_t fGammaIso_DR0p3To0p4;
326	>	Double_t fGammaIso_DR0p4To0p5;
327	>	Double_t fGammaIso_DR0p5To0p7;
328	>
329	>	Double_t fNeutralHadronIso_DR0p0To0p1;
330	>	Double_t fNeutralHadronIso_DR0p1To0p2;
331	>	Double_t fNeutralHadronIso_DR0p2To0p3;
332	>	Double_t fNeutralHadronIso_DR0p3To0p4;
333	>	Double_t fNeutralHadronIso_DR0p4To0p5;
334	>	Double_t fNeutralHadronIso_DR0p5To0p7;
335	>
336	>
337	>	//
338	>	//Loop over PF Candidates
339	>	//
340	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
341	>	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
342	>
343	>	Double_t deta = (mu->Eta() - pf->Eta());
344	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
345	>	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
346	>	if (dr > 1.0) continue;
347	>
348	>	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
349	>
350	>	//
351	>	// Lepton Footprint Removal
352	>	//
353	>	Bool_t IsLeptonFootprint = kFALSE;
354	>	if (dr < 1.0) {
355	>
356	>	//
357	>	// Check for electrons
358	>	//
359	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
360	>	const mithep::Electron *tmpele = electronsToVeto[q];
361	>	// 4l electron
362	>	if( pf->HasTrackerTrk() ) {
363	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
364	>	IsLeptonFootprint = kTRUE;
365	>	}
366	>	if( pf->HasGsfTrk() ) {
367	>	if( pf->GsfTrk() == tmpele->GsfTrk() )
368	>	IsLeptonFootprint = kTRUE;
369	>	}
370	>	// PF charged
371	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
372	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
373	>	IsLeptonFootprint = kTRUE;
374	>	// PF gamma
375	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
376	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
377	>	IsLeptonFootprint = kTRUE;
378	>	} // loop over electrons
379	>
380	>	/* KH - commented for sync
381	>	//
382	>	// Check for muons
383	>	//
384	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
385	>	const mithep::Muon *tmpmu = muonsToVeto[q];
386	>	// 4l muon
387	>	if( pf->HasTrackerTrk() ) {
388	>	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
389	>	IsLeptonFootprint = kTRUE;
390	>	}
391	>	// PF charged
392	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
393	>	IsLeptonFootprint = kTRUE;
394	>	} // loop over muons
395	>	*/
396	>
397	>	if (IsLeptonFootprint)
398	>	continue;
399	>
400	>	//
401	>	// Charged Iso Rings
402	>	//
403	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
404	>
405	>	if( dr < 0.01 ) continue; // only for muon iso mva?
406	>	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
407	>
408	>	if( pf->HasTrackerTrk() ) {
409	>	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
410	>	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
411	>	<< abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
412	>	<< dr << endl;
413	>	}
414	>	if( pf->HasGsfTrk() ) {
415	>	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
416	>	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
417	>	<< abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
418	>	<< dr << endl;
419	>	}
420	>
421	>	// Footprint Veto
422	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
423	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
424	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
425	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
426	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
427	>	if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
428	>	}
429	>
430	>	//
431	>	// Gamma Iso Rings
432	>	//
433	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
434	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
435	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
436	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
437	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
438	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
439	>	if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
440	>	}
441	>
442	>	//
443	>	// Other Neutral Iso Rings
444	>	//
445	>	else {
446	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
447	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
448	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
449	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
450	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
451	>	if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
452	>	}
453	>
454	>	}
455	>
456	>	}
457	>
458	>	fChargedIso_DR0p0To0p1   = min((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
459	>	fChargedIso_DR0p1To0p2   = min((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
460	>	fChargedIso_DR0p2To0p3   = min((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
461	>	fChargedIso_DR0p3To0p4   = min((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
462	>	fChargedIso_DR0p4To0p5   = min((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
463	>
464	>
465	>	double rho = 0;
466	>	if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
467	>	rho = fPUEnergyDensity->At(0)->Rho();
468	>
469	>
470	>	fGammaIso_DR0p0To0p1 = max(min((tmpGammaIso_DR0p0To0p1
471	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p0To0p1,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
472	>	,2.5)
473	>	,0.0);
474	>	fGammaIso_DR0p1To0p2 = max(min((tmpGammaIso_DR0p1To0p2
475	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p1To0p2,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
476	>	,2.5)
477	>	,0.0);
478	>	fGammaIso_DR0p2To0p3 = max(min((tmpGammaIso_DR0p2To0p3
479	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p2To0p3,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
480	>	,2.5)
481	>	,0.0);
482	>	fGammaIso_DR0p3To0p4 = max(min((tmpGammaIso_DR0p3To0p4
483	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p3To0p4,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
484	>	,2.5)
485	>	,0.0);
486	>	fGammaIso_DR0p4To0p5 = max(min((tmpGammaIso_DR0p4To0p5
487	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p4To0p5,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
488	>	,2.5)
489	>	,0.0);
490	>
491	>
492	>
493	>	fNeutralHadronIso_DR0p0To0p1 = max(min((tmpNeutralHadronIso_DR0p0To0p1
494	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p0To0p1,
495	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
496	>	, 2.5)
497	>	, 0.0);
498	>	fNeutralHadronIso_DR0p1To0p2 = max(min((tmpNeutralHadronIso_DR0p1To0p2
499	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p1To0p2,
500	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
501	>	, 2.5)
502	>	, 0.0);
503	>	fNeutralHadronIso_DR0p2To0p3 = max(min((tmpNeutralHadronIso_DR0p2To0p3
504	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p2To0p3,
505	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
506	>	, 2.5)
507	>	, 0.0);
508	>	fNeutralHadronIso_DR0p3To0p4 = max(min((tmpNeutralHadronIso_DR0p3To0p4
509	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p3To0p4,
510	>	mu->Eta(), EffectiveAreaVersion))/mu->Pt()
511	>	, 2.5)
512	>	, 0.0);
513	>	fNeutralHadronIso_DR0p4To0p5 = max(min((tmpNeutralHadronIso_DR0p4To0p5
514	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p4To0p5,
515	>	mu->Eta(), EffectiveAreaVersion))/mu->Pt()
516	>	, 2.5)
517	>	, 0.0);
518	>
519	>
520	>	double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
521	>	mu->Eta(),
522	>	fChargedIso_DR0p0To0p1,
523	>	fChargedIso_DR0p1To0p2,
524	>	fChargedIso_DR0p2To0p3,
525	>	fChargedIso_DR0p3To0p4,
526	>	fChargedIso_DR0p4To0p5,
527	>	fGammaIso_DR0p0To0p1,
528	>	fGammaIso_DR0p1To0p2,
529	>	fGammaIso_DR0p2To0p3,
530	>	fGammaIso_DR0p3To0p4,
531	>	fGammaIso_DR0p4To0p5,
532	>	fNeutralHadronIso_DR0p0To0p1,
533	>	fNeutralHadronIso_DR0p1To0p2,
534	>	fNeutralHadronIso_DR0p2To0p3,
535	>	fNeutralHadronIso_DR0p3To0p4,
536	>	fNeutralHadronIso_DR0p4To0p5,
537	>	ctrl.debug);
538	>
539	>	SelectionStatus status;
540	>	bool pass;
541	>
542	>	pass = false;
543	>	if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
544	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN0)   pass = true;
545	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
546	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN1)  pass = true;
547	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
548	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN2)  pass = true;
549	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
550	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN3)  pass = true;
551	>	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN4)  pass = true;
552	>	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN5)  pass = true;
553	>	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
554	>
555	>	pass = false;
556	>	if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
557	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN0)   pass = true;
558	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
559	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN1)  pass = true;
560	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
561	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN2)  pass = true;
562	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
563	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN3)  pass = true;
564	>	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN4)  pass = true;
565	>	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN5)  pass = true;
566	>	if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
567	>
568	>	//  pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
569	>
570	>	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
571	>	return status;
572	>
573	>	}
574	>
575	>	//--------------------------------------------------------------------------------------------------
576	>	void initMuonIsoMVA() {
577	>	//--------------------------------------------------------------------------------------------------
578	>	muIsoMVA = new mithep::MuonIDMVA();
579	>	vector<string> weightFiles;
580	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_barrel_lowpt.weights.xml");
581	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_barrel_highpt.weights.xml");
582	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_endcap_lowpt.weights.xml");
583	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_endcap_highpt.weights.xml");
584	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_tracker.weights.xml");
585	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_global.weights.xml");
586	>	muIsoMVA->Initialize( "MuonIsoMVA",
587	>	mithep::MuonIDMVA::kIsoRingsV0,
588	>	kTRUE, weightFiles);
589	>	}
590	>
591	>
592	>	//--------------------------------------------------------------------------------------------------
593	>	double  muonPFIso04(ControlFlags &ctrl,
594	>	const mithep::Muon * mu,
595	>	const mithep::Vertex & vtx,
596	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
597	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
598	>	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
599	>	vector<const mithep::Muon*> muonsToVeto,
600	>	vector<const mithep::Electron*> electronsToVeto)
601	>	//--------------------------------------------------------------------------------------------------
602	>	{
603	>
604	>	if( ctrl.debug ) {
605	>	cout << "muonIsoMVASelection :: muons to veto " << endl;
606	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
607	>	const mithep::Muon * vmu = muonsToVeto[i];
608	>	cout << "\tpt: " << vmu->Pt()
609	>	<< "\teta: " << vmu->Eta()
610	>	<< "\tphi: " << vmu->Phi()
611	>	<< endl;
612	>	}
613	>	cout << "muonIsoMVASelection :: electrson to veto " << endl;
614	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
615	>	const mithep::Electron * vel = electronsToVeto[i];
616	>	cout << "\tpt: " << vel->Pt()
617	>	<< "\teta: " << vel->Eta()
618	>	<< "\tphi: " << vel->Phi()
619	>	<< endl;
620	>	}
621	>	}
622	>
623	>	//
624	>	// final iso
625	>	//
626	>	Double_t fChargedIso  = 0.0;
627	>	Double_t fGammaIso  = 0.0;
628	>	Double_t fNeutralHadronIso  = 0.0;
629	>
630	>	//
631	>	//Loop over PF Candidates
632	>	//
633	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
634	>	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
635	>
636	>	Double_t deta = (mu->Eta() - pf->Eta());
637	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
638	>	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
639	>	if (dr > 0.4) continue;
640	>
641	>	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
642	>
643	>	//
644	>	// Lepton Footprint Removal
645	>	//
646	>	Bool_t IsLeptonFootprint = kFALSE;
647	>	if (dr < 1.0) {
648	>
649	>	//
650	>	// Check for electrons
651	>	//
652	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
653	>	const mithep::Electron *tmpele = electronsToVeto[q];
654	>	// 4l electron
655	>	if( pf->HasTrackerTrk() ) {
656	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
657	>	IsLeptonFootprint = kTRUE;
658	>	}
659	>	if( pf->HasGsfTrk() ) {
660	>	if( pf->GsfTrk() == tmpele->GsfTrk() )
661	>	IsLeptonFootprint = kTRUE;
662	>	}
663	>	// PF charged
664	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
665	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
666	>	IsLeptonFootprint = kTRUE;
667	>	// PF gamma
668	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
669	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
670	>	IsLeptonFootprint = kTRUE;
671	>	} // loop over electrons
672	>
673	>	// KH, comment to sync
674	>	/*
675	>	//
676	>	// Check for muons
677	>	//
678	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
679	>	const mithep::Muon *tmpmu = muonsToVeto[q];
680	>	// 4l muon
681	>	if( pf->HasTrackerTrk() ) {
682	>	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
683	>	IsLeptonFootprint = kTRUE;
684	>	}
685	>	// PF charged
686	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
687	>	IsLeptonFootprint = kTRUE;
688	>	} // loop over muons
689	>	*/
690	>
691	>	if (IsLeptonFootprint)
692	>	continue;
693	>
694	>	//
695	>	// Charged Iso
696	>	//
697	>	if (pf->Charge() != 0 ) {
698	>
699	>	//if( dr < 0.01 ) continue; // only for muon iso mva?
700	>	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
701	>
702	>	if( pf->HasTrackerTrk() ) {
703	>	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
704	>	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
705	>	<< abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
706	>	<< dr << endl;
707	>	}
708	>	if( pf->HasGsfTrk() ) {
709	>	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
710	>	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
711	>	<< abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
712	>	<< dr << endl;
713	>	}
714	>
715	>
716	>	fChargedIso += pf->Pt();
717	>	}
718	>
719	>	//
720	>	// Gamma Iso
721	>	//
722	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
723	>	// KH, add to sync
724	>	if( pf->Pt() > 0.5 )
725	>	fGammaIso += pf->Pt();
726	>	}
727	>
728	>	//
729	>	// Other Neutrals
730	>	//
731	>	else {
732	>	// KH, add to sync
733	>	if( pf->Pt() > 0.5 )
734	>	fNeutralHadronIso += pf->Pt();
735	>	}
736	>
737	>	}
738	>
739	>	}
740	>
741	>	double rho = 0;
742	>	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
743	>	//     rho = fPUEnergyDensity->At(0)->Rho();
744	>	if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
745	>	rho = fPUEnergyDensity->At(0)->RhoLowEta();
746	>
747	>	// WARNING!!!!
748	>	// hardcode for sync ...
749	>	EffectiveAreaVersion = muT.kMuEAData2011;
750	>	// WARNING!!!!
751	>
752	>
753	>	double pfIso = fChargedIso + max(0.0,(fGammaIso + fNeutralHadronIso
754	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
755	>	mu->Eta(),EffectiveAreaVersion)));
756	>
757	>	gChargedIso = fChargedIso;
758	>	gGammaIso = fGammaIso;
759	>	gNeutralIso = fNeutralHadronIso;
760	>	return pfIso;
761	>	}
762	>
763	>
764	>	//--------------------------------------------------------------------------------------------------
765	>	// hacked version
766	>	double  muonPFIso04(ControlFlags &ctrl,
767	>	const mithep::Muon * mu,
768	>	const mithep::Vertex & vtx,
769	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
770	>	float rho,
771	>	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
772	>	vector<const mithep::Muon*> muonsToVeto,
773	>	vector<const mithep::Electron*> electronsToVeto)
774	>	//--------------------------------------------------------------------------------------------------
775	>	{
776	>
777	>	extern double gChargedIso;
778	>	extern double  gGammaIso;
779	>	extern double  gNeutralIso;
780	>
781	>	if( ctrl.debug ) {
782	>	cout << "muonIsoMVASelection :: muons to veto " << endl;
783	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
784	>	const mithep::Muon * vmu = muonsToVeto[i];
785	>	cout << "\tpt: " << vmu->Pt()
786	>	<< "\teta: " << vmu->Eta()
787	>	<< "\tphi: " << vmu->Phi()
788	>	<< endl;
789	>	}
790	>	cout << "muonIsoMVASelection :: electrson to veto " << endl;
791	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
792	>	const mithep::Electron * vel = electronsToVeto[i];
793	>	cout << "\tpt: " << vel->Pt()
794	>	<< "\teta: " << vel->Eta()
795	>	<< "\tphi: " << vel->Phi()
796	>	<< endl;
797	>	}
798	>	}
799	>
800	>	//
801	>	// final iso
802	>	//
803	>	Double_t fChargedIso  = 0.0;
804	>	Double_t fGammaIso  = 0.0;
805	>	Double_t fNeutralHadronIso  = 0.0;
806	>
807	>	//
808	>	//Loop over PF Candidates
809	>	//
810	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
811	>	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
812	>
813	>	Double_t deta = (mu->Eta() - pf->Eta());
814	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
815	>	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
816	>	if (dr > 0.4) continue;
817	>
818	>	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
819	>
820	>	//
821	>	// Lepton Footprint Removal
822	>	//
823	>	Bool_t IsLeptonFootprint = kFALSE;
824	>	if (dr < 1.0) {
825	>
826	>	//
827	>	// Check for electrons
828	>	//
829	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
830	>	const mithep::Electron *tmpele = electronsToVeto[q];
831	>	// 4l electron
832	>	if( pf->HasTrackerTrk() ) {
833	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
834	>	IsLeptonFootprint = kTRUE;
835	>	}
836	>	if( pf->HasGsfTrk() ) {
837	>	if( pf->GsfTrk() == tmpele->GsfTrk() )
838	>	IsLeptonFootprint = kTRUE;
839	>	}
840	>	// PF charged
841	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
842	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
843	>	IsLeptonFootprint = kTRUE;
844	>	// PF gamma
845	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
846	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
847	>	IsLeptonFootprint = kTRUE;
848	>	} // loop over electrons
849	>
850	>	/* KH - comment for sync
851	>	//
852	>	// Check for muons
853	>	//
854	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
855	>	const mithep::Muon *tmpmu = muonsToVeto[q];
856	>	// 4l muon
857	>	if( pf->HasTrackerTrk() ) {
858	>	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
859	>	IsLeptonFootprint = kTRUE;
860	>	}
861	>	// PF charged
862	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
863	>	IsLeptonFootprint = kTRUE;
864	>	} // loop over muons
865	>	*/
866	>
867	>	if (IsLeptonFootprint)
868	>	continue;
869	>
870	>	//
871	>	// Charged Iso
872	>	//
873	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
874	>
875	>	if( dr < 0.01 ) continue; // only for muon iso mva?
876	>	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
877	>
878	>	if( pf->HasTrackerTrk() ) {
879	>	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
880	>	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
881	>	<< abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
882	>	<< dr << endl;
883	>	}
884	>	if( pf->HasGsfTrk() ) {
885	>	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
886	>	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
887	>	<< abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
888	>	<< dr << endl;
889	>	}
890	>
891	>
892	>	fChargedIso += pf->Pt();
893	>	}
894	>
895	>	//
896	>	// Gamma Iso
897	>	//
898	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
899	>	fGammaIso += pf->Pt();
900	>	}
901	>
902	>	//
903	>	// Other Neutrals
904	>	//
905	>	else {
906	>	// KH, add to sync
907	>	if( pf->Pt() > 0.5 )
908	>	fNeutralHadronIso += pf->Pt();
909	>	}
910	>
911	>	}
912	>
913	>	}
914	>
915	>	//   double rho = 0;
916	>	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
917	>	//     rho = fPUEnergyDensity->At(0)->Rho();
918	>
919	>	// WARNING!!!!
920	>	// hardcode for sync ...
921	>	EffectiveAreaVersion = muT.kMuEAData2011;
922	>	// WARNING!!!!
923	>
924	>
925	>	double pfIso = fChargedIso + max(0.0,(fGammaIso + fNeutralHadronIso
926	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
927	>	mu->Eta(),EffectiveAreaVersion)));
928	>	gChargedIso = fChargedIso;
929	>	gGammaIso   = fGammaIso;
930	>	gNeutralIso = fNeutralHadronIso;
931	>
932	>	return pfIso;
933	>	}
934	>
935	>
936	>	//--------------------------------------------------------------------------------------------------
937	>	SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
938	>	const mithep::Muon * mu,
939	>	const mithep::Vertex & vtx,
940	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
941	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
942	>	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
943	>	vector<const mithep::Muon*> muonsToVeto,
944	>	vector<const mithep::Electron*> electronsToVeto)
945	>	//--------------------------------------------------------------------------------------------------
946	>	{
947	>
948	>	SelectionStatus status;
949	>
950	>	double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, fPUEnergyDensity,
951	>	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
952	>	cout << "--------------> setting muon isoPF04 to" << pfIso << endl;
953	>	status.isoPF04 = pfIso;
954	>	status.chisoPF04 = gChargedIso;
955	>	status.gaisoPF04 = gGammaIso;
956	>	status.neisoPF04 = gNeutralIso;
957	>
958	>	bool pass = false;
959	>	if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
960	>
961	>	if( pass ) {
962	>	status.orStatus(SelectionStatus::LOOSEISO);
963	>	status.orStatus(SelectionStatus::TIGHTISO);
964	>	}
965	>	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
966	>	return status;
967	>
968	>	}
969	>
970	>
971	>	//--------------------------------------------------------------------------------------------------
972	>	// hacked version
973	>	SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
974	>	const mithep::Muon * mu,
975	>	const mithep::Vertex & vtx,
976	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
977	>	float rho,
978	>	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
979	>	vector<const mithep::Muon*> muonsToVeto,
980	>	vector<const mithep::Electron*> electronsToVeto)
981	>	//--------------------------------------------------------------------------------------------------
982	>	{
983	>
984	>	SelectionStatus status;
985	>
986	>	double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, rho,
987	>	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
988	>	bool pass = false;
989	>	if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
990	>
991	>	if( pass ) {
992	>	status.orStatus(SelectionStatus::LOOSEISO);
993	>	status.orStatus(SelectionStatus::TIGHTISO);
994	>	}
995	>	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
996	>	return status;
997	>
998	>	}
999	>
1000	>
1001	>
1002	>	//--------------------------------------------------------------------------------------------------
1003	>	SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1004	>	const mithep::Electron * ele,
1005	>	const mithep::Vertex & vtx,
1006	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1007	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1008	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1009	>	vector<const mithep::Muon*> muonsToVeto,
1010	>	vector<const mithep::Electron*> electronsToVeto)
1011	>	//--------------------------------------------------------------------------------------------------
1012	>	{
1013	>
1014	>	if( ctrl.debug ) {
1015	>	cout << "electronIsoMVASelection :: muons to veto " << endl;
1016	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
1017	>	const mithep::Muon * vmu = muonsToVeto[i];
1018	>	cout << "\tpt: " << vmu->Pt()
1019	>	<< "\teta: " << vmu->Eta()
1020	>	<< "\tphi: " << vmu->Phi()
1021	>	<< endl;
1022	>	}
1023	>	cout << "electronIsoMVASelection :: electrson to veto " << endl;
1024	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
1025	>	const mithep::Electron * vel = electronsToVeto[i];
1026	>	cout << "\tpt: " << vel->Pt()
1027	>	<< "\teta: " << vel->Eta()
1028	>	<< "\tphi: " << vel->Phi()
1029	>	<< "\ttrk: " << vel->TrackerTrk()
1030	>	<< endl;
1031	>	}
1032	>	}
1033	>
1034	>	bool failiso=false;
1035	>
1036	>	//
1037	>	// tmp iso rings
1038	>	//
1039	>	Double_t tmpChargedIso_DR0p0To0p1  = 0;
1040	>	Double_t tmpChargedIso_DR0p1To0p2  = 0;
1041	>	Double_t tmpChargedIso_DR0p2To0p3  = 0;
1042	>	Double_t tmpChargedIso_DR0p3To0p4  = 0;
1043	>	Double_t tmpChargedIso_DR0p4To0p5  = 0;
1044	>	Double_t tmpChargedIso_DR0p5To0p7  = 0;
1045	>
1046	>	Double_t tmpGammaIso_DR0p0To0p1  = 0;
1047	>	Double_t tmpGammaIso_DR0p1To0p2  = 0;
1048	>	Double_t tmpGammaIso_DR0p2To0p3  = 0;
1049	>	Double_t tmpGammaIso_DR0p3To0p4  = 0;
1050	>	Double_t tmpGammaIso_DR0p4To0p5  = 0;
1051	>	Double_t tmpGammaIso_DR0p5To0p7  = 0;
1052	>
1053	>	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
1054	>	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
1055	>	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
1056	>	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
1057	>	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
1058	>	Double_t tmpNeutralHadronIso_DR0p5To0p7  = 0;
1059	>
1060	>
1061	>
1062	>	//
1063	>	// final rings for the MVA
1064	>	//
1065	>	Double_t fChargedIso_DR0p0To0p1;
1066	>	Double_t fChargedIso_DR0p1To0p2;
1067	>	Double_t fChargedIso_DR0p2To0p3;
1068	>	Double_t fChargedIso_DR0p3To0p4;
1069	>	Double_t fChargedIso_DR0p4To0p5;
1070	>
1071	>	Double_t fGammaIso_DR0p0To0p1;
1072	>	Double_t fGammaIso_DR0p1To0p2;
1073	>	Double_t fGammaIso_DR0p2To0p3;
1074	>	Double_t fGammaIso_DR0p3To0p4;
1075	>	Double_t fGammaIso_DR0p4To0p5;
1076	>
1077	>	Double_t fNeutralHadronIso_DR0p0To0p1;
1078	>	Double_t fNeutralHadronIso_DR0p1To0p2;
1079	>	Double_t fNeutralHadronIso_DR0p2To0p3;
1080	>	Double_t fNeutralHadronIso_DR0p3To0p4;
1081	>	Double_t fNeutralHadronIso_DR0p4To0p5;
1082	>
1083	>
1084	>	//
1085	>	//Loop over PF Candidates
1086	>	//
1087	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1088	>	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1089	>	Double_t deta = (ele->Eta() - pf->Eta());
1090	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1091	>	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1092	>	if (dr >= 0.5) continue;
1093	>	if(ctrl.debug) {
1094	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1095	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
1096	>	cout << endl;
1097	>	}
1098	>
1099	>
1100	>	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
1101	>	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1102	>
1103	>
1104	>	//
1105	>	// Lepton Footprint Removal
1106	>	//
1107	>	Bool_t IsLeptonFootprint = kFALSE;
1108	>	if (dr < 1.0) {
1109	>
1110	>	//
1111	>	// Check for electrons
1112	>	//
1113	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1114	>	const mithep::Electron *tmpele = electronsToVeto[q];
1115	>	// 4l electron
1116	>	if( pf->HasTrackerTrk()  ) {
1117	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1118	>	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1119	>	IsLeptonFootprint = kTRUE;
1120	>	}
1121	>	}
1122	>	if( pf->HasGsfTrk()  ) {
1123	>	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1124	>	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1125	>	IsLeptonFootprint = kTRUE;
1126	>	}
1127	>	}
1128	>	// PF charged
1129	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1130	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1131	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1132	>	IsLeptonFootprint = kTRUE;
1133	>	}
1134	>	// PF gamma
1135	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1136	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
1137	>	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1138	>	IsLeptonFootprint = kTRUE;
1139	>	}
1140	>	} // loop over electrons
1141	>
1142	>	/* KH - comment for sync
1143	>	//
1144	>	// Check for muons
1145	>	//
1146	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1147	>	const mithep::Muon *tmpmu = muonsToVeto[q];
1148	>	// 4l muon
1149	>	if( pf->HasTrackerTrk() ) {
1150	>	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1151	>	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1152	>	IsLeptonFootprint = kTRUE;
1153	>	}
1154	>	}
1155	>	// PF charged
1156	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1157	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1158	>	IsLeptonFootprint = kTRUE;
1159	>	}
1160	>	} // loop over muons
1161	>	*/
1162	>
1163	>	if (IsLeptonFootprint)
1164	>	continue;
1165	>
1166	>	//
1167	>	// Charged Iso Rings
1168	>	//
1169	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1170	>
1171	>	if( pf->HasTrackerTrk() )
1172	>	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1173	>	if( pf->HasGsfTrk() )
1174	>	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1175	>
1176	>	// Veto any PFmuon, or PFEle
1177	>	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1178	>
1179	>	// Footprint Veto
1180	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1181	>
1182	>	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1183	>	<< "\ttype: " << pf->PFType()
1184	>	<< "\ttrk: " << pf->TrackerTrk() << endl;
1185	>
1186	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
1187	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
1188	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1189	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1190	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
1191	>	if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
1192	>
1193	>	}
1194	>
1195	>	//
1196	>	// Gamma Iso Rings
1197	>	//
1198	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1199	>
1200	>	if (fabs(ele->SCluster()->Eta()) > 1.479) {
1201	>	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
1202	>	}
1203	>
1204	>	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1205	>	<< dr << endl;
1206	>
1207	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
1208	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
1209	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1210	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1211	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
1212	>	if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
1213	>
1214	>	}
1215	>
1216	>	//
1217	>	// Other Neutral Iso Rings
1218	>	//
1219	>	else {
1220	>	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
1221	>	<< dr << endl;
1222	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
1223	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
1224	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1225	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1226	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1227	>	if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
1228	>	}
1229	>
1230	>	}
1231	>
1232	>	}
1233	>
1234	>	fChargedIso_DR0p0To0p1   = min((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1235	>	fChargedIso_DR0p1To0p2   = min((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1236	>	fChargedIso_DR0p2To0p3   = min((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1237	>	fChargedIso_DR0p3To0p4   = min((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1238	>	fChargedIso_DR0p4To0p5   = min((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1239	>
1240	>	double rho = 0;
1241	>	if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1242	>	rho = fPUEnergyDensity->At(0)->Rho();
1243	>
1244	>	if( ctrl.debug) {
1245	>	cout << "RHO: " << rho << endl;
1246	>	cout << "eta: " << ele->SCluster()->Eta() << endl;
1247	>	cout << "target: " << EffectiveAreaVersion << endl;
1248	>	cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1249	>	ele->SCluster()->Eta(),
1250	>	EffectiveAreaVersion)
1251	>	<< endl;
1252	>	cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1253	>	ele->SCluster()->Eta(),
1254	>	EffectiveAreaVersion)
1255	>	<< endl;
1256	>	cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1257	>	ele->SCluster()->Eta(),
1258	>	EffectiveAreaVersion)
1259	>	<< endl;
1260	>	cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1261	>	ele->SCluster()->Eta(),
1262	>	EffectiveAreaVersion)
1263	>	<< endl;
1264	>	}
1265	>
1266	>	fGammaIso_DR0p0To0p1 = max(min((tmpGammaIso_DR0p0To0p1
1267	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
1268	>	ele->SCluster()->Eta(),
1269	>	EffectiveAreaVersion))/ele->Pt()
1270	>	,2.5)
1271	>	,0.0);
1272	>	fGammaIso_DR0p1To0p2 = max(min((tmpGammaIso_DR0p1To0p2
1273	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
1274	>	ele->SCluster()->Eta(),
1275	>	EffectiveAreaVersion))/ele->Pt()
1276	>	,2.5)
1277	>	,0.0);
1278	>	fGammaIso_DR0p2To0p3 = max(min((tmpGammaIso_DR0p2To0p3
1279	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
1280	>	ele->SCluster()->Eta()
1281	>	,EffectiveAreaVersion))/ele->Pt()
1282	>	,2.5)
1283	>	,0.0);
1284	>	fGammaIso_DR0p3To0p4 = max(min((tmpGammaIso_DR0p3To0p4
1285	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
1286	>	ele->SCluster()->Eta(),
1287	>	EffectiveAreaVersion))/ele->Pt()
1288	>	,2.5)
1289	>	,0.0);
1290	>	fGammaIso_DR0p4To0p5 = max(min((tmpGammaIso_DR0p4To0p5
1291	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
1292	>	ele->SCluster()->Eta(),
1293	>	EffectiveAreaVersion))/ele->Pt()
1294	>	,2.5)
1295	>	,0.0);
1296	>
1297	>
1298	>	fNeutralHadronIso_DR0p0To0p1 = max(min((tmpNeutralHadronIso_DR0p0To0p1
1299	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1300	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1301	>	, 2.5)
1302	>	, 0.0);
1303	>	fNeutralHadronIso_DR0p1To0p2 = max(min((tmpNeutralHadronIso_DR0p1To0p2
1304	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1305	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1306	>	, 2.5)
1307	>	, 0.0);
1308	>	fNeutralHadronIso_DR0p2To0p3 = max(min((tmpNeutralHadronIso_DR0p2To0p3
1309	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1310	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1311	>	, 2.5)
1312	>	, 0.0);
1313	>	fNeutralHadronIso_DR0p3To0p4 = max(min((tmpNeutralHadronIso_DR0p3To0p4
1314	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1315	>	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1316	>	, 2.5)
1317	>	, 0.0);
1318	>	fNeutralHadronIso_DR0p4To0p5 = max(min((tmpNeutralHadronIso_DR0p4To0p5
1319	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
1320	>	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1321	>	, 2.5)
1322	>	, 0.0);
1323	>
1324	>	double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
1325	>	ele->SCluster()->Eta(),
1326	>	fChargedIso_DR0p0To0p1,
1327	>	fChargedIso_DR0p1To0p2,
1328	>	fChargedIso_DR0p2To0p3,
1329	>	fChargedIso_DR0p3To0p4,
1330	>	fChargedIso_DR0p4To0p5,
1331	>	fGammaIso_DR0p0To0p1,
1332	>	fGammaIso_DR0p1To0p2,
1333	>	fGammaIso_DR0p2To0p3,
1334	>	fGammaIso_DR0p3To0p4,
1335	>	fGammaIso_DR0p4To0p5,
1336	>	fNeutralHadronIso_DR0p0To0p1,
1337	>	fNeutralHadronIso_DR0p1To0p2,
1338	>	fNeutralHadronIso_DR0p2To0p3,
1339	>	fNeutralHadronIso_DR0p3To0p4,
1340	>	fNeutralHadronIso_DR0p4To0p5,
1341	>	ctrl.debug);
1342	>
1343	>	SelectionStatus status;
1344	>	bool pass = false;
1345	>
1346	>	Int_t subdet = 0;
1347	>	if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
1348	>	else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
1349	>	else subdet = 2;
1350	>	Int_t ptBin = 0;
1351	>	if (ele->Pt() > 10.0) ptBin = 1;
1352	>
1353	>	Int_t MVABin = -1;
1354	>	if (subdet == 0 && ptBin == 0) MVABin = 0;
1355	>	if (subdet == 1 && ptBin == 0) MVABin = 1;
1356	>	if (subdet == 2 && ptBin == 0) MVABin = 2;
1357	>	if (subdet == 0 && ptBin == 1) MVABin = 3;
1358	>	if (subdet == 1 && ptBin == 1) MVABin = 4;
1359	>	if (subdet == 2 && ptBin == 1) MVABin = 5;
1360	>
1361	>	pass = false;
1362	>	if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN0 ) pass = true;
1363	>	if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN1 ) pass = true;
1364	>	if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN2 ) pass = true;
1365	>	if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN3 ) pass = true;
1366	>	if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN4 ) pass = true;
1367	>	if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN5 ) pass = true;
1368	>	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
1369	>
1370	>	pass = false;
1371	>	if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
1372	>	if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
1373	>	if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
1374	>	if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
1375	>	if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
1376	>	if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
1377	>	if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
1378	>
1379	>	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1380	>	return status;
1381	>
1382	>	}
1383	>
1384	>
1385	>	//--------------------------------------------------------------------------------------------------
1386	>	void initElectronIsoMVA() {
1387	>	//--------------------------------------------------------------------------------------------------
1388	>	eleIsoMVA = new mithep::ElectronIDMVA();
1389	>	vector<string> weightFiles;
1390	>	weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_BarrelPt5To10.weights.xml");
1391	>	weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_EndcapPt5To10.weights.xml");
1392	>	weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_BarrelPt10ToInf.weights.xml");
1393	>	weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_EndcapPt10ToInf.weights.xml");
1394	>	eleIsoMVA->Initialize( "ElectronIsoMVA",
1395	>	mithep::ElectronIDMVA::kIsoRingsV0,
1396	>	kTRUE, weightFiles);
1397	>	}
1398	>
1399	>
1400	>
1401	>	//--------------------------------------------------------------------------------------------------
1402	>	float electronPFIso04(ControlFlags &ctrl,
1403	>	const mithep::Electron * ele,
1404	>	const mithep::Vertex & vtx,
1405	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1406	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1407	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1408	>	vector<const mithep::Muon*> muonsToVeto,
1409	>	vector<const mithep::Electron*> electronsToVeto)
1410	>	//--------------------------------------------------------------------------------------------------
1411	>	{
1412	>
1413	>	if( ctrl.debug ) {
1414	>	cout << "electronIsoMVASelection :: muons to veto " << endl;
1415	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
1416	>	const mithep::Muon * vmu = muonsToVeto[i];
1417	>	cout << "\tpt: " << vmu->Pt()
1418	>	<< "\teta: " << vmu->Eta()
1419	>	<< "\tphi: " << vmu->Phi()
1420	>	<< endl;
1421	>	}
1422	>	cout << "electronIsoMVASelection :: electrson to veto " << endl;
1423	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
1424	>	const mithep::Electron * vel = electronsToVeto[i];
1425	>	cout << "\tpt: " << vel->Pt()
1426	>	<< "\teta: " << vel->Eta()
1427	>	<< "\tphi: " << vel->Phi()
1428	>	<< "\ttrk: " << vel->TrackerTrk()
1429	>	<< endl;
1430	>	}
1431	>	}
1432	>
1433	>
1434	>	//
1435	>	// final iso
1436	>	//
1437	>	Double_t fChargedIso = 0.0;
1438	>	Double_t fGammaIso = 0.0;
1439	>	Double_t fNeutralHadronIso = 0.0;
1440	>
1441	>
1442	>	//
1443	>	//Loop over PF Candidates
1444	>	//
1445	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1446	>	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1447	>	Double_t deta = (ele->Eta() - pf->Eta());
1448	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1449	>	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1450	>	if (dr >= 0.4) continue;
1451	>	if(ctrl.debug) {
1452	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1453	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
1454	>	cout << endl;
1455	>	}
1456	>
1457	>
1458	>	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
1459	>	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1460	>
1461	>
1462	>	//
1463	>	// Lepton Footprint Removal
1464	>	//
1465	>	Bool_t IsLeptonFootprint = kFALSE;
1466	>	if (dr < 1.0) {
1467	>
1468	>	//
1469	>	// Check for electrons
1470	>	//
1471	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1472	>	const mithep::Electron *tmpele = electronsToVeto[q];
1473	>	// 4l electron
1474	>	if( pf->HasTrackerTrk()  ) {
1475	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1476	>	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1477	>	IsLeptonFootprint = kTRUE;
1478	>	}
1479	>	}
1480	>	if( pf->HasGsfTrk()  ) {
1481	>	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1482	>	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1483	>	IsLeptonFootprint = kTRUE;
1484	>	}
1485	>	}
1486	>	// PF charged
1487	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1488	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1489	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1490	>	IsLeptonFootprint = kTRUE;
1491	>	}
1492	>	// PF gamma
1493	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1494	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
1495	>	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1496	>	IsLeptonFootprint = kTRUE;
1497	>	}
1498	>	} // loop over electrons
1499	>
1500	>
1501	>	//
1502	>	// Check for muons
1503	>	//
1504	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1505	>	const mithep::Muon *tmpmu = muonsToVeto[q];
1506	>	// 4l muon
1507	>	if( pf->HasTrackerTrk() ) {
1508	>	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1509	>	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1510	>	IsLeptonFootprint = kTRUE;
1511	>	}
1512	>	}
1513	>	// PF charged
1514	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1515	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1516	>	IsLeptonFootprint = kTRUE;
1517	>	}
1518	>	} // loop over muons
1519	>
1520	>
1521	>	if (IsLeptonFootprint)
1522	>	continue;
1523	>
1524	>	//
1525	>	// Charged Iso
1526	>	//
1527	>	if (pf->Charge() != 0 ) {
1528	>
1529	>	if( pf->HasTrackerTrk() )
1530	>	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1531	>	if( pf->HasGsfTrk() )
1532	>	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1533	>
1534	>	// Veto any PFmuon, or PFEle
1535	>	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1536	>
1537	>	// Footprint Veto
1538	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1539	>
1540	>	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1541	>	<< "\ttype: " << pf->PFType()
1542	>	<< "\ttrk: " << pf->TrackerTrk() << endl;
1543	>
1544	>	fChargedIso += pf->Pt();
1545	>	}
1546	>
1547	>	//
1548	>	// Gamma Iso
1549	>	//
1550	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1551	>
1552	>	if (fabs(ele->SCluster()->Eta()) > 1.479) {
1553	>	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
1554	>	}
1555	>	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1556	>	<< dr << endl;
1557	>	fGammaIso += pf->Pt();
1558	>	}
1559	>
1560	>	//
1561	>	// Neutral Iso
1562	>	//
1563	>	else {
1564	>	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
1565	>	<< dr << endl;
1566	>	fNeutralHadronIso += pf->Pt();
1567	>	}
1568	>
1569	>	}
1570	>
1571	>	}
1572	>
1573	>	double rho = 0;
1574	>	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1575	>	//     rho = fPUEnergyDensity->At(0)->Rho();
1576	>	if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1577	>	rho = fPUEnergyDensity->At(0)->RhoLowEta();
1578	>
1579	>	// WARNING!!!!
1580	>	// hardcode for sync ...
1581	>	EffectiveAreaVersion = eleT.kEleEAData2011;
1582	>	// WARNING!!!!
1583	>
1584	>
1585	>	double pfIso = fChargedIso +
1586	>	max(0.0,fGammaIso -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIso04,
1587	>	ele->Eta(),EffectiveAreaVersion)) +
1588	>	max(0.0,fNeutralHadronIso -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIso04,
1589	>	ele->Eta(),EffectiveAreaVersion)) ;
1590	>
1591	>	gChargedIso = fChargedIso;
1592	>	gGammaIso = fGammaIso;
1593	>	gNeutralIso = fNeutralHadronIso;
1594	>
1595	>	return pfIso;
1596	>	}
1597	>
1598	>	//--------------------------------------------------------------------------------------------------
1599	>	// hacked version
1600	>	float electronPFIso04(ControlFlags &ctrl,
1601	>	const mithep::Electron * ele,
1602	>	const mithep::Vertex & vtx,
1603	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1604	>	float rho,
1605	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1606	>	vector<const mithep::Muon*> muonsToVeto,
1607	>	vector<const mithep::Electron*> electronsToVeto)
1608	>	//--------------------------------------------------------------------------------------------------
1609	>	{
1610	>
1611	>	if( ctrl.debug ) {
1612	>	cout << "electronIsoMVASelection :: muons to veto " << endl;
1613	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
1614	>	const mithep::Muon * vmu = muonsToVeto[i];
1615	>	cout << "\tpt: " << vmu->Pt()
1616	>	<< "\teta: " << vmu->Eta()
1617	>	<< "\tphi: " << vmu->Phi()
1618	>	<< endl;
1619	>	}
1620	>	cout << "electronIsoMVASelection :: electrson to veto " << endl;
1621	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
1622	>	const mithep::Electron * vel = electronsToVeto[i];
1623	>	cout << "\tpt: " << vel->Pt()
1624	>	<< "\teta: " << vel->Eta()
1625	>	<< "\tphi: " << vel->Phi()
1626	>	<< "\ttrk: " << vel->TrackerTrk()
1627	>	<< endl;
1628	>	}
1629	>	}
1630	>
1631	>
1632	>	//
1633	>	// final iso
1634	>	//
1635	>	Double_t fChargedIso = 0.0;
1636	>	Double_t fGammaIso = 0.0;
1637	>	Double_t fNeutralHadronIso = 0.0;
1638	>
1639	>
1640	>	//
1641	>	//Loop over PF Candidates
1642	>	//
1643	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1644	>	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1645	>	Double_t deta = (ele->Eta() - pf->Eta());
1646	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1647	>	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1648	>	if (dr >= 0.4) continue;
1649	>	if(ctrl.debug) {
1650	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1651	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
1652	>	cout << endl;
1653	>	}
1654	>
1655	>
1656	>	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
1657	>	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1658	>
1659	>
1660	>	//
1661	>	// Lepton Footprint Removal
1662	>	//
1663	>	Bool_t IsLeptonFootprint = kFALSE;
1664	>	if (dr < 1.0) {
1665	>
1666	>	//
1667	>	// Check for electrons
1668	>	//
1669	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1670	>	const mithep::Electron *tmpele = electronsToVeto[q];
1671	>	// 4l electron
1672	>	if( pf->HasTrackerTrk()  ) {
1673	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1674	>	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1675	>	IsLeptonFootprint = kTRUE;
1676	>	}
1677	>	}
1678	>	if( pf->HasGsfTrk()  ) {
1679	>	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1680	>	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1681	>	IsLeptonFootprint = kTRUE;
1682	>	}
1683	>	}
1684	>	// PF charged
1685	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1686	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1687	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1688	>	IsLeptonFootprint = kTRUE;
1689	>	}
1690	>	// PF gamma
1691	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1692	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
1693	>	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1694	>	IsLeptonFootprint = kTRUE;
1695	>	}
1696	>	} // loop over electrons
1697	>
1698	>	/* KH - comment for sync
1699	>	//
1700	>	// Check for muons
1701	>	//
1702	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1703	>	const mithep::Muon *tmpmu = muonsToVeto[q];
1704	>	// 4l muon
1705	>	if( pf->HasTrackerTrk() ) {
1706	>	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1707	>	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1708	>	IsLeptonFootprint = kTRUE;
1709	>	}
1710	>	}
1711	>	// PF charged
1712	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1713	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1714	>	IsLeptonFootprint = kTRUE;
1715	>	}
1716	>	} // loop over muons
1717	>	*/
1718	>
1719	>	if (IsLeptonFootprint)
1720	>	continue;
1721	>
1722	>	//
1723	>	// Charged Iso
1724	>	//
1725	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1726	>
1727	>	if( pf->HasTrackerTrk() )
1728	>	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1729	>	if( pf->HasGsfTrk() )
1730	>	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1731	>
1732	>	// Veto any PFmuon, or PFEle
1733	>	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1734	>
1735	>	// Footprint Veto
1736	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1737	>
1738	>	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1739	>	<< "\ttype: " << pf->PFType()
1740	>	<< "\ttrk: " << pf->TrackerTrk() << endl;
1741	>
1742	>	fChargedIso += pf->Pt();
1743	>	}
1744	>
1745	>	//
1746	>	// Gamma Iso
1747	>	//
1748	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1749	>
1750	>	if (fabs(ele->SCluster()->Eta()) > 1.479) {
1751	>	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
1752	>	}
1753	>	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1754	>	<< dr << endl;
1755	>	fGammaIso += pf->Pt();
1756	>	}
1757	>
1758	>	//
1759	>	// Neutral Iso
1760	>	//
1761	>	else {
1762	>	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
1763	>	<< dr << endl;
1764	>	// KH, add to sync
1765	>	if( pf->Pt() > 0.5 )
1766	>	fNeutralHadronIso += pf->Pt();
1767	>	}
1768	>
1769	>	}
1770	>
1771	>	}
1772	>
1773	>	//   double rho = 0;
1774	>	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1775	>	//     rho = fPUEnergyDensity->At(0)->Rho();
1776	>
1777	>	// WARNING!!!!
1778	>	// hardcode for sync ...
1779	>	EffectiveAreaVersion = eleT.kEleEAData2011;
1780	>	// WARNING!!!!
1781	>
1782	>
1783	>	double pfIso = fChargedIso +
1784	>	max(0.0,fGammaIso -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIso04,
1785	>	ele->Eta(),EffectiveAreaVersion)) +
1786	>	max(0.0,fNeutralHadronIso -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIso04,
1787	>	ele->Eta(),EffectiveAreaVersion)) ;
1788	>	return pfIso;
1789	>	}
1790	>
1791	>
1792	>	//--------------------------------------------------------------------------------------------------
1793	>	SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
1794	>	const mithep::Electron * ele,
1795	>	const mithep::Vertex & vtx,
1796	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1797	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1798	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1799	>	vector<const mithep::Muon*> muonsToVeto,
1800	>	vector<const mithep::Electron*> electronsToVeto)
1801	>	//--------------------------------------------------------------------------------------------------
1802	>	{
1803	>
1804	>	SelectionStatus status;
1805	>
1806	>	double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, fPUEnergyDensity,
1807	>	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1808	>	cout << "--------------> setting electron isoPF04 to " << pfIso << endl;
1809	>	status.isoPF04 = pfIso;
1810	>	status.chisoPF04 = gChargedIso;
1811	>	status.gaisoPF04 = gGammaIso;
1812	>	status.neisoPF04 = gNeutralIso;
1813	>
1814	>	bool pass = false;
1815	>	if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
1816	>
1817	>	if( pass ) {
1818	>	status.orStatus(SelectionStatus::LOOSEISO);
1819	>	status.orStatus(SelectionStatus::TIGHTISO);
1820	>	}
1821	>	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1822	>	return status;
1823	>
1824	>	}
1825	>
1826	>
1827	>	//--------------------------------------------------------------------------------------------------
1828	>	// hacked version
1829	>	SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
1830	>	const mithep::Electron * ele,
1831	>	const mithep::Vertex & vtx,
1832	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1833	>	float rho,
1834	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1835	>	vector<const mithep::Muon*> muonsToVeto,
1836	>	vector<const mithep::Electron*> electronsToVeto)
1837	>	//--------------------------------------------------------------------------------------------------
1838	>	{
1839	>
1840	>	SelectionStatus status;
1841	>
1842	>	double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, rho,
1843	>	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1844	>	bool pass = false;
1845	>	if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
1846	>
1847	>	if( pass ) {
1848	>	status.orStatus(SelectionStatus::LOOSEISO);
1849	>	status.orStatus(SelectionStatus::TIGHTISO);
1850		}
1851		if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1852		return status;

Diff Legend

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