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.20 by khahn, Mon May 14 18:01:02 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	>	extern vector<bool> PFnoPUflag;
25	>
26	>	//--------------------------------------------------------------------------------------------------
27	>	Float_t computePFMuonIso(const mithep::Muon *muon,
28	>	const mithep::Vertex & vtx,
29	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
30	>	const Double_t dRMax)
31	>	//--------------------------------------------------------------------------------------------------
32	>	{
33	>	const Double_t dRMin    = 0;
34	>	const Double_t neuPtMin = 1.0;
35	>	const Double_t dzMax    = 0.1;
36	>
37	>	Double_t zLepton = (muon->BestTrk()) ? muon->BestTrk()->DzCorrected(vtx) : 0.0;
38	>
39	>	Float_t iso=0;
40	>	for(UInt_t ipf=0; ipf<fPFCandidates->GetEntries(); ipf++) {
41	>	const PFCandidate *pfcand = fPFCandidates->At(ipf);
42	>
43	>	if(!pfcand->HasTrk() && (pfcand->Pt()<=neuPtMin)) continue;  // pT cut on neutral particles
44	>
45	>	// exclude THE muon
46	>	if(pfcand->TrackerTrk() && muon->TrackerTrk() && (pfcand->TrackerTrk()==muon->TrackerTrk())) continue;
47	>
48	>	// dz cut
49	>	Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(vtx) - zLepton) : 0;
50	>	if(dz >= dzMax) continue;
51	>
52	>	// check iso cone
53	>	Double_t dr = MathUtils::DeltaR(muon->Mom(), pfcand->Mom());
54	>	if(dr<dRMax && dr>=dRMin)
55	>	iso += pfcand->Pt();
56	>	}
57	>
58	>	return iso;
59	>	}
60	>
61	>	//--------------------------------------------------------------------------------------------------
62	>	Float_t computePFEleIso(const mithep::Electron *electron,
63	>	const mithep::Vertex & fVertex,
64	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
65	>	const Double_t dRMax)
66	>	//--------------------------------------------------------------------------------------------------
67	>	{
68	>	const Double_t dRMin    = 0;
69	>	const Double_t neuPtMin = 1.0;
70	>	const Double_t dzMax    = 0.1;
71	>
72	>	Double_t zLepton = (electron->BestTrk()) ? electron->BestTrk()->DzCorrected(fVertex) : 0.0;
73	>
74	>	Float_t iso=0;
75	>	for(UInt_t ipf=0; ipf<fPFCandidates->GetEntries(); ipf++) {
76	>	const PFCandidate *pfcand = (PFCandidate*)(fPFCandidates->At(ipf));
77	>
78	>	if(!pfcand->HasTrk() && (pfcand->Pt()<=neuPtMin)) continue;  // pT cut on neutral particles
79	>
80	>	// dz cut
81	>	Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(fVertex) - zLepton) : 0;
82	>	if(dz >= dzMax) continue;
83	>
84	>	// remove THE electron
85	>	if(pfcand->TrackerTrk() && electron->TrackerTrk() && (pfcand->TrackerTrk()==electron->TrackerTrk())) continue;
86	>	if(pfcand->GsfTrk()     && electron->GsfTrk()     && (pfcand->GsfTrk()==electron->GsfTrk()))         continue;
87	>
88	>	// check iso cone
89	>	Double_t dr = MathUtils::DeltaR(electron->Mom(), pfcand->Mom());
90	>	if(dr<dRMax && dr>=dRMin) {
91	>	// eta-strip veto for photons
92	>	if((pfcand->PFType() == PFCandidate::eGamma) && fabs(electron->Eta() - pfcand->Eta()) < 0.025) continue;
93	>
94	>	// Inner cone (one tower = dR < 0.07) veto for non-photon neutrals
95	>	if(!pfcand->HasTrk() && (pfcand->PFType() == PFCandidate::eNeutralHadron) &&
96	>	(MathUtils::DeltaR(electron->Mom(), pfcand->Mom()) < 0.07)) continue;
97	>
98	>	iso += pfcand->Pt();
99	>	}
100	>	}
101	>
102	>	return iso;
103	>	};
104	>
105	>	//--------------------------------------------------------------------------------------------------
106	>	bool pairwiseIsoSelection( ControlFlags &ctrl,
107	>	vector<SimpleLepton> &lepvec,
108	>	float rho )
109	>	//--------------------------------------------------------------------------------------------------
110	>	{
111
112		bool passiso=true;
113
#	Line 60 | Line 164 | bool pairwiseIsoSelection( ControlFlags
164
165		float isoEcal_corr_j = lepvec[j].isoEcal - (effArea_ecal_j*rho);
166		float isoHcal_corr_j = lepvec[j].isoHcal - (effArea_hcal_j*rho);
167	<	float RIso_i = (lepvec[i].isoTrk+isoEcal_corr_i+isoHcal_corr_i)/lepvec[i].vec->Pt();
168	<	float RIso_j = (lepvec[j].isoTrk+isoEcal_corr_j+isoHcal_corr_j)/lepvec[j].vec->Pt();
167	>	float RIso_i = (lepvec[i].isoTrk+isoEcal_corr_i+isoHcal_corr_i)/lepvec[i].vec.Pt();
168	>	float RIso_j = (lepvec[j].isoTrk+isoEcal_corr_j+isoHcal_corr_j)/lepvec[j].vec.Pt();
169		float comboIso = RIso_i + RIso_j;
170
171		if( comboIso > 0.35 ) {
#	Line 75 | Line 179 | bool pairwiseIsoSelection( ControlFlags
179		return passiso;
180		}
181
182	<
183	<	SelectionStatus passMuonIsoSelection( ControlFlags &ctrl, const mithep::TMuon * mu ) {
184	<
185	<	float reliso = mu->pfIso03/mu->pt;
186	<	bool isEB = (fabs(mu->eta) < 1.479 ? 1 : 0 );
182	>	//--------------------------------------------------------------------------------------------------
183	>	SelectionStatus muonIsoSelection(ControlFlags &ctrl,
184	>	const mithep::Muon * mu,
185	>	const mithep::Vertex & vtx,
186	>	const mithep::Array<mithep::PFCandidate> * fPFCandidateCol   )
187	>	//--------------------------------------------------------------------------------------------------
188	>	{
189	>	float reliso = computePFMuonIso(mu,vtx,fPFCandidateCol,0.3)/mu->Pt();
190	>	bool isEB = (fabs(mu->Eta()) < 1.479 ? 1 : 0 );
191		bool failiso = false;
192	<	if( isEB && mu->pt > 20 && reliso > PFISO_MU_LOOSE_EB_HIGHPT ) {
192	>	if( isEB && mu->Pt() > 20 && reliso > PFISO_MU_LOOSE_EB_HIGHPT ) {
193		failiso = true;
194		}
195	<	if( isEB && mu->pt < 20 && reliso > PFISO_MU_LOOSE_EB_LOWPT ) {
195	>	if( isEB && mu->Pt() < 20 && reliso > PFISO_MU_LOOSE_EB_LOWPT ) {
196		failiso = true;
197		}
198	<	if( !(isEB) && mu->pt > 20 && reliso > PFISO_MU_LOOSE_EE_HIGHPT ) {
198	>	if( !(isEB) && mu->Pt() > 20 && reliso > PFISO_MU_LOOSE_EE_HIGHPT ) {
199		failiso = true;
200		}
201	<	if( !(isEB) && mu->pt < 20 && reliso > PFISO_MU_LOOSE_EE_LOWPT ) {
201	>	if( !(isEB) && mu->Pt() < 20 && reliso > PFISO_MU_LOOSE_EE_LOWPT ) {
202		failiso = true;
203		}
204
#	Line 101 | Line 209 | SelectionStatus passMuonIsoSelection( Co
209
210		};
211
212	<
213	<	SelectionStatus failEleIso(ControlFlags &ctrl, const mithep::TElectron * ele) {
212	>	//--------------------------------------------------------------------------------------------------
213	>	SelectionStatus electronIsoSelection(ControlFlags &ctrl,
214	>	const mithep::Electron * ele,
215	>	const mithep::Vertex &fVertex,
216	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates)
217	>	//--------------------------------------------------------------------------------------------------
218	>	{
219
220		bool failiso=false;
221
222	<	float reliso = ele->pfIso04/ele->pt;
223	<	bool isEB = (fabs(ele->eta) < 1.479 ? 1 : 0 );
224	<	if( isEB && ele->pt > 20 && reliso > PFISO_ELE_LOOSE_EB_HIGHPT ) {
222	>	float reliso = computePFEleIso(ele,fVertex,fPFCandidates,0.4)/ele->Pt();
223	>
224	>	if( ele->IsEB() && ele->Pt() > 20 && reliso > PFISO_ELE_LOOSE_EB_HIGHPT ) {
225		failiso = true;
226		}
227	<	if( isEB && ele->pt < 20 && reliso > PFISO_ELE_LOOSE_EB_LOWPT ) {
227	>	if( ele->IsEB() && ele->Pt() < 20 && reliso > PFISO_ELE_LOOSE_EB_LOWPT ) {
228		failiso = true;
229		}
230		if(ctrl.debug) cout << "before iso check ..." << endl;
231	<	if( !(isEB) && ele->pt > 20 && reliso > PFISO_ELE_LOOSE_EE_HIGHPT ) {
231	>	if( !(ele->IsEB()) && ele->Pt() > 20 && reliso > PFISO_ELE_LOOSE_EE_HIGHPT ) {
232		if(ctrl.debug) cout << "\tit fails ..." << endl;
233		failiso = true;
234		}
235	<	if( !(isEB) && ele->pt < 20 && reliso > PFISO_ELE_LOOSE_EE_LOWPT ) {
235	>	if( !(ele->IsEB()) && ele->Pt() < 20 && reliso > PFISO_ELE_LOOSE_EE_LOWPT ) {
236		failiso = true;
237		}
238
239		SelectionStatus status;
240		if( !failiso ) {
241	<	status.setStatus(SelectionStatus::LOOSEISO);
242	<	status.setStatus(SelectionStatus::TIGHTISO);
241	>	status.orStatus(SelectionStatus::LOOSEISO);
242	>	status.orStatus(SelectionStatus::TIGHTISO);
243	>	}
244	>	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
245	>	return status;
246	>
247	>	}
248	>
249	>
250	>	bool noIso(ControlFlags &, vector<SimpleLepton> &, float rho) {
251	>
252	>	return true;
253	>	}
254	>
255	>	//--------------------------------------------------------------------------------------------------
256	>	SelectionStatus muonIsoMVASelection(ControlFlags &ctrl,
257	>	const mithep::Muon * mu,
258	>	const mithep::Vertex & vtx,
259	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
260	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
261	>	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
262	>	vector<const mithep::Muon*> muonsToVeto,
263	>	vector<const mithep::Electron*> electronsToVeto)
264	>	//--------------------------------------------------------------------------------------------------
265	>	{
266	>
267	>	if( ctrl.debug ) {
268	>	cout << "muonIsoMVASelection :: muons to veto " << endl;
269	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
270	>	const mithep::Muon * vmu = muonsToVeto[i];
271	>	cout << "\tpt: " << vmu->Pt()
272	>	<< "\teta: " << vmu->Eta()
273	>	<< "\tphi: " << vmu->Phi()
274	>	<< endl;
275	>	}
276	>	cout << "muonIsoMVASelection :: electrson to veto " << endl;
277	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
278	>	const mithep::Electron * vel = electronsToVeto[i];
279	>	cout << "\tpt: " << vel->Pt()
280	>	<< "\teta: " << vel->Eta()
281	>	<< "\tphi: " << vel->Phi()
282	>	<< endl;
283	>	}
284	>	}
285	>	bool failiso=false;
286	>
287	>	//
288	>	// tmp iso rings
289	>	//
290	>	Double_t tmpChargedIso_DR0p0To0p1  = 0;
291	>	Double_t tmpChargedIso_DR0p1To0p2  = 0;
292	>	Double_t tmpChargedIso_DR0p2To0p3  = 0;
293	>	Double_t tmpChargedIso_DR0p3To0p4  = 0;
294	>	Double_t tmpChargedIso_DR0p4To0p5  = 0;
295	>	Double_t tmpChargedIso_DR0p5To0p7  = 0;
296	>
297	>	Double_t tmpGammaIso_DR0p0To0p1  = 0;
298	>	Double_t tmpGammaIso_DR0p1To0p2  = 0;
299	>	Double_t tmpGammaIso_DR0p2To0p3  = 0;
300	>	Double_t tmpGammaIso_DR0p3To0p4  = 0;
301	>	Double_t tmpGammaIso_DR0p4To0p5  = 0;
302	>	Double_t tmpGammaIso_DR0p5To0p7  = 0;
303	>
304	>	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
305	>	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
306	>	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
307	>	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
308	>	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
309	>	Double_t tmpNeutralHadronIso_DR0p5To0p7  = 0;
310	>
311	>
312	>
313	>	//
314	>	// final rings for the MVA
315	>	//
316	>	Double_t fChargedIso_DR0p0To0p1;
317	>	Double_t fChargedIso_DR0p1To0p2;
318	>	Double_t fChargedIso_DR0p2To0p3;
319	>	Double_t fChargedIso_DR0p3To0p4;
320	>	Double_t fChargedIso_DR0p4To0p5;
321	>	Double_t fChargedIso_DR0p5To0p7;
322	>
323	>	Double_t fGammaIso_DR0p0To0p1;
324	>	Double_t fGammaIso_DR0p1To0p2;
325	>	Double_t fGammaIso_DR0p2To0p3;
326	>	Double_t fGammaIso_DR0p3To0p4;
327	>	Double_t fGammaIso_DR0p4To0p5;
328	>	Double_t fGammaIso_DR0p5To0p7;
329	>
330	>	Double_t fNeutralHadronIso_DR0p0To0p1;
331	>	Double_t fNeutralHadronIso_DR0p1To0p2;
332	>	Double_t fNeutralHadronIso_DR0p2To0p3;
333	>	Double_t fNeutralHadronIso_DR0p3To0p4;
334	>	Double_t fNeutralHadronIso_DR0p4To0p5;
335	>	Double_t fNeutralHadronIso_DR0p5To0p7;
336	>
337	>
338	>	//
339	>	//Loop over PF Candidates
340	>	//
341	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
342	>	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
343	>
344	>	Double_t deta = (mu->Eta() - pf->Eta());
345	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
346	>	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
347	>	if (dr > 0.5) continue;
348	>	if (dr < 0.01) continue;
349	>
350	>	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
351	>
352	>	//
353	>	// Lepton Footprint Removal
354	>	//
355	>	Bool_t IsLeptonFootprint = kFALSE;
356	>	if (dr < 1.0) {
357	>
358	>	//
359	>	// Check for electrons
360	>	//
361	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
362	>	const mithep::Electron *tmpele = electronsToVeto[q];
363	>	// 4l electron
364	>	if( pf->HasTrackerTrk() ) {
365	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
366	>	IsLeptonFootprint = kTRUE;
367	>	}
368	>	if( pf->HasGsfTrk() ) {
369	>	if( pf->GsfTrk() == tmpele->GsfTrk() )
370	>	IsLeptonFootprint = kTRUE;
371	>	}
372	>	// PF charged
373	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479
374	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
375	>	IsLeptonFootprint = kTRUE;
376	>	// PF gamma
377	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
378	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
379	>	IsLeptonFootprint = kTRUE;
380	>	} // loop over electrons
381	>
382	>	/*
383	>	//
384	>	// Check for muons
385	>	//
386	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
387	>	const mithep::Muon *tmpmu = muonsToVeto[q];
388	>	// 4l muon
389	>	if( pf->HasTrackerTrk() ) {
390	>	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
391	>	IsLeptonFootprint = kTRUE;
392	>	}
393	>	// PF charged
394	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
395	>	IsLeptonFootprint = kTRUE;
396	>	} // loop over muons
397	>	*/
398	>
399	>	if (IsLeptonFootprint)
400	>	continue;
401	>
402	>	//
403	>	// Charged Iso Rings
404	>	//
405	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
406	>
407	>	if( dr < 0.01 ) continue; // only for muon iso mva?
408	>	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
409	>
410	>	//       if( pf->HasTrackerTrk() ) {
411	>	//      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
412	>	//      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
413	>	//                            << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
414	>	//                            << dr << endl;
415	>	//       }
416	>
417	>
418	>	// Footprint Veto
419	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
420	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
421	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
422	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
423	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
424	>	if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
425	>	}
426	>
427	>	//
428	>	// Gamma Iso Rings
429	>	//
430	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
431	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
432	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
433	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
434	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
435	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
436	>	if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
437	>	}
438	>
439	>	//
440	>	// Other Neutral Iso Rings
441	>	//
442	>	else {
443	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
444	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
445	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
446	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
447	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
448	>	if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
449	>	}
450	>
451	>	}
452	>
453	>	}
454	>
455	>	fChargedIso_DR0p0To0p1   = fmin((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
456	>	fChargedIso_DR0p1To0p2   = fmin((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
457	>	fChargedIso_DR0p2To0p3   = fmin((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
458	>	fChargedIso_DR0p3To0p4   = fmin((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
459	>	fChargedIso_DR0p4To0p5   = fmin((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
460	>
461	>
462	>	double rho = 0;
463	>	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
464	>	//     rho = fPUEnergyDensity->At(0)->Rho();
465	>	if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
466	>	rho = fPUEnergyDensity->At(0)->RhoLowEta();
467	>
468	>	// WARNING!!!!
469	>	// hardcode for sync ...
470	>	EffectiveAreaVersion = muT.kMuEAData2011;
471	>	// WARNING!!!!
472	>
473	>
474	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
475	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p0To0p1,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
476	>	,2.5)
477	>	,0.0);
478	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
479	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p1To0p2,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
480	>	,2.5)
481	>	,0.0);
482	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
483	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p2To0p3,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
484	>	,2.5)
485	>	,0.0);
486	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
487	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p3To0p4,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
488	>	,2.5)
489	>	,0.0);
490	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
491	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p4To0p5,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
492	>	,2.5)
493	>	,0.0);
494	>
495	>
496	>
497	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
498	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p0To0p1,
499	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
500	>	, 2.5)
501	>	, 0.0);
502	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
503	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p1To0p2,
504	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
505	>	, 2.5)
506	>	, 0.0);
507	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
508	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p2To0p3,
509	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
510	>	, 2.5)
511	>	, 0.0);
512	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
513	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p3To0p4,
514	>	mu->Eta(), EffectiveAreaVersion))/mu->Pt()
515	>	, 2.5)
516	>	, 0.0);
517	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
518	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p4To0p5,
519	>	mu->Eta(), EffectiveAreaVersion))/mu->Pt()
520	>	, 2.5)
521	>	, 0.0);
522	>
523	>
524	>	double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
525	>	mu->Eta(),
526	>	mu->IsGlobalMuon(),
527	>	mu->IsTrackerMuon(),
528	>	fChargedIso_DR0p0To0p1,
529	>	fChargedIso_DR0p1To0p2,
530	>	fChargedIso_DR0p2To0p3,
531	>	fChargedIso_DR0p3To0p4,
532	>	fChargedIso_DR0p4To0p5,
533	>	fGammaIso_DR0p0To0p1,
534	>	fGammaIso_DR0p1To0p2,
535	>	fGammaIso_DR0p2To0p3,
536	>	fGammaIso_DR0p3To0p4,
537	>	fGammaIso_DR0p4To0p5,
538	>	fNeutralHadronIso_DR0p0To0p1,
539	>	fNeutralHadronIso_DR0p1To0p2,
540	>	fNeutralHadronIso_DR0p2To0p3,
541	>	fNeutralHadronIso_DR0p3To0p4,
542	>	fNeutralHadronIso_DR0p4To0p5,
543	>	ctrl.debug);
544	>
545	>	SelectionStatus status;
546	>	bool pass;
547	>
548	>	pass = false;
549	>	if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
550	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN0)   pass = true;
551	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
552	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN1)  pass = true;
553	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
554	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN2)  pass = true;
555	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
556	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN3)  pass = true;
557	>	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN4)  pass = true;
558	>	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN5)  pass = true;
559	>	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
560	>
561	>	pass = false;
562	>	if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
563	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN0)   pass = true;
564	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
565	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN1)  pass = true;
566	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
567	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN2)  pass = true;
568	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
569	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN3)  pass = true;
570	>	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN4)  pass = true;
571	>	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN5)  pass = true;
572	>	if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
573	>
574	>	//  pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
575	>
576	>	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
577	>	return status;
578	>
579	>	}
580	>
581	>
582	>	//--------------------------------------------------------------------------------------------------
583	>	SelectionStatus muonIsoMVASelection(ControlFlags &ctrl,
584	>	const mithep::Muon * mu,
585	>	const mithep::Vertex & vtx,
586	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
587	>	float rho,
588	>	//const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
589	>	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
590	>	vector<const mithep::Muon*> muonsToVeto,
591	>	vector<const mithep::Electron*> electronsToVeto)
592	>	//--------------------------------------------------------------------------------------------------
593	>	// hacked version
594	>	{
595	>
596	>	if( ctrl.debug ) {
597	>	cout << "muonIsoMVASelection :: muons to veto " << endl;
598	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
599	>	const mithep::Muon * vmu = muonsToVeto[i];
600	>	cout << "\tpt: " << vmu->Pt()
601	>	<< "\teta: " << vmu->Eta()
602	>	<< "\tphi: " << vmu->Phi()
603	>	<< endl;
604	>	}
605	>	cout << "muonIsoMVASelection :: electrson to veto " << endl;
606	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
607	>	const mithep::Electron * vel = electronsToVeto[i];
608	>	cout << "\tpt: " << vel->Pt()
609	>	<< "\teta: " << vel->Eta()
610	>	<< "\tphi: " << vel->Phi()
611	>	<< endl;
612	>	}
613	>	}
614	>	bool failiso=false;
615	>
616	>	//
617	>	// tmp iso rings
618	>	//
619	>	Double_t tmpChargedIso_DR0p0To0p1  = 0;
620	>	Double_t tmpChargedIso_DR0p1To0p2  = 0;
621	>	Double_t tmpChargedIso_DR0p2To0p3  = 0;
622	>	Double_t tmpChargedIso_DR0p3To0p4  = 0;
623	>	Double_t tmpChargedIso_DR0p4To0p5  = 0;
624	>	Double_t tmpChargedIso_DR0p5To0p7  = 0;
625	>
626	>	Double_t tmpGammaIso_DR0p0To0p1  = 0;
627	>	Double_t tmpGammaIso_DR0p1To0p2  = 0;
628	>	Double_t tmpGammaIso_DR0p2To0p3  = 0;
629	>	Double_t tmpGammaIso_DR0p3To0p4  = 0;
630	>	Double_t tmpGammaIso_DR0p4To0p5  = 0;
631	>	Double_t tmpGammaIso_DR0p5To0p7  = 0;
632	>
633	>	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
634	>	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
635	>	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
636	>	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
637	>	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
638	>	Double_t tmpNeutralHadronIso_DR0p5To0p7  = 0;
639	>
640	>
641	>
642	>	//
643	>	// final rings for the MVA
644	>	//
645	>	Double_t fChargedIso_DR0p0To0p1;
646	>	Double_t fChargedIso_DR0p1To0p2;
647	>	Double_t fChargedIso_DR0p2To0p3;
648	>	Double_t fChargedIso_DR0p3To0p4;
649	>	Double_t fChargedIso_DR0p4To0p5;
650	>	Double_t fChargedIso_DR0p5To0p7;
651	>
652	>	Double_t fGammaIso_DR0p0To0p1;
653	>	Double_t fGammaIso_DR0p1To0p2;
654	>	Double_t fGammaIso_DR0p2To0p3;
655	>	Double_t fGammaIso_DR0p3To0p4;
656	>	Double_t fGammaIso_DR0p4To0p5;
657	>	Double_t fGammaIso_DR0p5To0p7;
658	>
659	>	Double_t fNeutralHadronIso_DR0p0To0p1;
660	>	Double_t fNeutralHadronIso_DR0p1To0p2;
661	>	Double_t fNeutralHadronIso_DR0p2To0p3;
662	>	Double_t fNeutralHadronIso_DR0p3To0p4;
663	>	Double_t fNeutralHadronIso_DR0p4To0p5;
664	>	Double_t fNeutralHadronIso_DR0p5To0p7;
665	>
666	>
667	>	//
668	>	//Loop over PF Candidates
669	>	//
670	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
671	>
672	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
673	>
674	>	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
675	>
676	>	Double_t deta = (mu->Eta() - pf->Eta());
677	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
678	>	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
679	>	if (dr > 1.0) continue;
680	>
681	>	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
682	>
683	>	//
684	>	// Lepton Footprint Removal
685	>	//
686	>	Bool_t IsLeptonFootprint = kFALSE;
687	>	if (dr < 1.0) {
688	>
689	>	//
690	>	// Check for electrons
691	>	//
692	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
693	>	const mithep::Electron *tmpele = electronsToVeto[q];
694	>	// 4l electron
695	>	if( pf->HasTrackerTrk() ) {
696	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
697	>	IsLeptonFootprint = kTRUE;
698	>	}
699	>	if( pf->HasGsfTrk() ) {
700	>	if( pf->GsfTrk() == tmpele->GsfTrk() )
701	>	IsLeptonFootprint = kTRUE;
702	>	}
703	>	// PF charged
704	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479
705	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
706	>	IsLeptonFootprint = kTRUE;
707	>	// PF gamma
708	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
709	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
710	>	IsLeptonFootprint = kTRUE;
711	>	} // loop over electrons
712	>
713	>	/* KH - commented for sync
714	>	//
715	>	// Check for muons
716	>	//
717	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
718	>	const mithep::Muon *tmpmu = muonsToVeto[q];
719	>	// 4l muon
720	>	if( pf->HasTrackerTrk() ) {
721	>	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
722	>	IsLeptonFootprint = kTRUE;
723	>	}
724	>	// PF charged
725	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
726	>	IsLeptonFootprint = kTRUE;
727	>	} // loop over muons
728	>	*/
729	>
730	>	if (IsLeptonFootprint)
731	>	continue;
732	>
733	>	//
734	>	// Charged Iso Rings
735	>	//
736	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
737	>
738	>	if( dr < 0.01 ) continue; // only for muon iso mva?
739	>	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
740	>
741	>	//       if( pf->HasTrackerTrk() ) {
742	>	//      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
743	>	//      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
744	>	//                            << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
745	>	//                            << dr << endl;
746	>	//       }
747	>	//       if( pf->HasGsfTrk() ) {
748	>	//      if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
749	>	//      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
750	>	//                            << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
751	>	//                            << dr << endl;
752	>	//       }
753	>
754	>	// Footprint Veto
755	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
756	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
757	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
758	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
759	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
760	>	if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
761	>	}
762	>
763	>	//
764	>	// Gamma Iso Rings
765	>	//
766	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
767	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
768	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
769	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
770	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
771	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
772	>	if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
773	>	}
774	>
775	>	//
776	>	// Other Neutral Iso Rings
777	>	//
778	>	else {
779	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
780	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
781	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
782	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
783	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
784	>	if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
785	>	}
786	>
787	>	}
788	>
789	>	}
790	>
791	>	fChargedIso_DR0p0To0p1   = fmin((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
792	>	fChargedIso_DR0p1To0p2   = fmin((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
793	>	fChargedIso_DR0p2To0p3   = fmin((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
794	>	fChargedIso_DR0p3To0p4   = fmin((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
795	>	fChargedIso_DR0p4To0p5   = fmin((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
796	>
797	>
798	>	//   double rho = 0;
799	>	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
800	>	//     rho = fPUEnergyDensity->At(0)->Rho();
801	>	//   if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
802	>	//     rho = fPUEnergyDensity->At(0)->RhoLowEta();
803	>
804	>	// WARNING!!!!
805	>	// hardcode for sync ...
806	>	EffectiveAreaVersion = muT.kMuEAData2011;
807	>	// WARNING!!!!
808	>
809	>
810	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
811	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p0To0p1,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
812	>	,2.5)
813	>	,0.0);
814	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
815	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p1To0p2,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
816	>	,2.5)
817	>	,0.0);
818	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
819	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p2To0p3,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
820	>	,2.5)
821	>	,0.0);
822	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
823	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p3To0p4,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
824	>	,2.5)
825	>	,0.0);
826	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
827	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p4To0p5,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
828	>	,2.5)
829	>	,0.0);
830	>
831	>
832	>
833	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
834	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p0To0p1,
835	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
836	>	, 2.5)
837	>	, 0.0);
838	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
839	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p1To0p2,
840	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
841	>	, 2.5)
842	>	, 0.0);
843	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
844	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p2To0p3,
845	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
846	>	, 2.5)
847	>	, 0.0);
848	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
849	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p3To0p4,
850	>	mu->Eta(), EffectiveAreaVersion))/mu->Pt()
851	>	, 2.5)
852	>	, 0.0);
853	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
854	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p4To0p5,
855	>	mu->Eta(), EffectiveAreaVersion))/mu->Pt()
856	>	, 2.5)
857	>	, 0.0);
858	>
859	>
860	>	double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
861	>	mu->Eta(),
862	>	mu->IsGlobalMuon(),
863	>	mu->IsTrackerMuon(),
864	>	fChargedIso_DR0p0To0p1,
865	>	fChargedIso_DR0p1To0p2,
866	>	fChargedIso_DR0p2To0p3,
867	>	fChargedIso_DR0p3To0p4,
868	>	fChargedIso_DR0p4To0p5,
869	>	fGammaIso_DR0p0To0p1,
870	>	fGammaIso_DR0p1To0p2,
871	>	fGammaIso_DR0p2To0p3,
872	>	fGammaIso_DR0p3To0p4,
873	>	fGammaIso_DR0p4To0p5,
874	>	fNeutralHadronIso_DR0p0To0p1,
875	>	fNeutralHadronIso_DR0p1To0p2,
876	>	fNeutralHadronIso_DR0p2To0p3,
877	>	fNeutralHadronIso_DR0p3To0p4,
878	>	fNeutralHadronIso_DR0p4To0p5,
879	>	ctrl.debug);
880	>
881	>	SelectionStatus status;
882	>	bool pass;
883	>
884	>	pass = false;
885	>	if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
886	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN0)   pass = true;
887	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
888	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN1)  pass = true;
889	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
890	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN2)  pass = true;
891	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
892	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN3)  pass = true;
893	>	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN4)  pass = true;
894	>	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN5)  pass = true;
895	>	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
896	>
897	>	/*
898	>	pass = false;
899	>	if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
900	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN0)   pass = true;
901	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
902	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN1)  pass = true;
903	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
904	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN2)  pass = true;
905	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
906	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN3)  pass = true;
907	>	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN4)  pass = true;
908	>	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN5)  pass = true;
909	>	if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
910	>	*/
911	>
912	>	//  pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
913	>
914	>	status.isoMVA = mvaval;
915	>
916	>	if(ctrl.debug)  {
917	>	cout << "returning status : " << hex << status.getStatus() << dec << endl;
918	>	cout << "MVAVAL : " << status.isoMVA << endl;
919	>	}
920	>	return status;
921	>
922	>	}
923	>
924	>
925	>	//--------------------------------------------------------------------------------------------------
926	>	void initMuonIsoMVA() {
927	>	//--------------------------------------------------------------------------------------------------
928	>	muIsoMVA = new mithep::MuonIDMVA();
929	>	vector<string> weightFiles;
930	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_barrel_lowpt.weights.xml");
931	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_barrel_highpt.weights.xml");
932	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_endcap_lowpt.weights.xml");
933	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_endcap_highpt.weights.xml");
934	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_tracker.weights.xml");
935	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_global.weights.xml");
936	>	muIsoMVA->Initialize( "MuonIsoMVA",
937	>	mithep::MuonIDMVA::kIsoRingsV0,
938	>	kTRUE, weightFiles);
939	>	}
940	>
941	>
942	>	//--------------------------------------------------------------------------------------------------
943	>	double  muonPFIso04(ControlFlags &ctrl,
944	>	const mithep::Muon * mu,
945	>	const mithep::Vertex & vtx,
946	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
947	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
948	>	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
949	>	vector<const mithep::Muon*> muonsToVeto,
950	>	vector<const mithep::Electron*> electronsToVeto)
951	>	//--------------------------------------------------------------------------------------------------
952	>	{
953	>
954	>	if( ctrl.debug ) {
955	>	cout << "muonIsoMVASelection :: muons to veto " << endl;
956	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
957	>	const mithep::Muon * vmu = muonsToVeto[i];
958	>	cout << "\tpt: " << vmu->Pt()
959	>	<< "\teta: " << vmu->Eta()
960	>	<< "\tphi: " << vmu->Phi()
961	>	<< endl;
962	>	}
963	>	cout << "muonIsoMVASelection :: electrson to veto " << endl;
964	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
965	>	const mithep::Electron * vel = electronsToVeto[i];
966	>	cout << "\tpt: " << vel->Pt()
967	>	<< "\teta: " << vel->Eta()
968	>	<< "\tphi: " << vel->Phi()
969	>	<< endl;
970	>	}
971	>	}
972	>
973	>	//
974	>	// final iso
975	>	//
976	>	Double_t fChargedIso  = 0.0;
977	>	Double_t fGammaIso  = 0.0;
978	>	Double_t fNeutralHadronIso  = 0.0;
979	>
980	>	//
981	>	//Loop over PF Candidates
982	>	//
983	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
984	>	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
985	>
986	>	Double_t deta = (mu->Eta() - pf->Eta());
987	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
988	>	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
989	>	if (dr > 0.4) continue;
990	>
991	>	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
992	>
993	>	//
994	>	// Lepton Footprint Removal
995	>	//
996	>	Bool_t IsLeptonFootprint = kFALSE;
997	>	if (dr < 1.0) {
998	>
999	>	//
1000	>	// Check for electrons
1001	>	//
1002	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1003	>	const mithep::Electron *tmpele = electronsToVeto[q];
1004	>	// 4l electron
1005	>	if( pf->HasTrackerTrk() ) {
1006	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
1007	>	IsLeptonFootprint = kTRUE;
1008	>	}
1009	>	if( pf->HasGsfTrk() ) {
1010	>	if( pf->GsfTrk() == tmpele->GsfTrk() )
1011	>	IsLeptonFootprint = kTRUE;
1012	>	}
1013	>	// PF charged
1014	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1015	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
1016	>	IsLeptonFootprint = kTRUE;
1017	>	// PF gamma
1018	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1019	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
1020	>	IsLeptonFootprint = kTRUE;
1021	>	} // loop over electrons
1022	>
1023	>	// KH, comment to sync
1024	>	/*
1025	>	//
1026	>	// Check for muons
1027	>	//
1028	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1029	>	const mithep::Muon *tmpmu = muonsToVeto[q];
1030	>	// 4l muon
1031	>	if( pf->HasTrackerTrk() ) {
1032	>	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
1033	>	IsLeptonFootprint = kTRUE;
1034	>	}
1035	>	// PF charged
1036	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
1037	>	IsLeptonFootprint = kTRUE;
1038	>	} // loop over muons
1039	>	*/
1040	>
1041	>	if (IsLeptonFootprint)
1042	>	continue;
1043	>
1044	>	//
1045	>	// Charged Iso
1046	>	//
1047	>	if (pf->Charge() != 0 ) {
1048	>
1049	>	//if( dr < 0.01 ) continue; // only for muon iso mva?
1050	>	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1051	>
1052	>	if( pf->HasTrackerTrk() ) {
1053	>	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1054	>	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1055	>	<< abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1056	>	<< dr << endl;
1057	>	}
1058	>	if( pf->HasGsfTrk() ) {
1059	>	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1060	>	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1061	>	<< abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1062	>	<< dr << endl;
1063	>	}
1064	>
1065	>
1066	>	fChargedIso += pf->Pt();
1067	>	}
1068	>
1069	>	//
1070	>	// Gamma Iso
1071	>	//
1072	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1073	>	// KH, add to sync
1074	>	if( pf->Pt() > 0.5 )
1075	>	fGammaIso += pf->Pt();
1076	>	}
1077	>
1078	>	//
1079	>	// Other Neutrals
1080	>	//
1081	>	else {
1082	>	// KH, add to sync
1083	>	if( pf->Pt() > 0.5 )
1084	>	fNeutralHadronIso += pf->Pt();
1085	>	}
1086	>
1087	>	}
1088	>
1089	>	}
1090	>
1091	>	double rho = 0;
1092	>	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1093	>	//     rho = fPUEnergyDensity->At(0)->Rho();
1094	>	if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1095	>	rho = fPUEnergyDensity->At(0)->RhoLowEta();
1096	>
1097	>	// WARNING!!!!
1098	>	// hardcode for sync ...
1099	>	EffectiveAreaVersion = muT.kMuEAData2011;
1100	>	// WARNING!!!!
1101	>
1102	>
1103	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1104	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1105	>	mu->Eta(),EffectiveAreaVersion)));
1106	>
1107	>	gChargedIso = fChargedIso;
1108	>	gGammaIso = fGammaIso;
1109	>	gNeutralIso = fNeutralHadronIso;
1110	>	return pfIso;
1111	>	}
1112	>
1113	>
1114	>	//--------------------------------------------------------------------------------------------------
1115	>	// hacked version
1116	>	double  muonPFIso04(ControlFlags &ctrl,
1117	>	const mithep::Muon * mu,
1118	>	const mithep::Vertex & vtx,
1119	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1120	>	float rho,
1121	>	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1122	>	vector<const mithep::Muon*> muonsToVeto,
1123	>	vector<const mithep::Electron*> electronsToVeto)
1124	>	//--------------------------------------------------------------------------------------------------
1125	>	{
1126	>
1127	>	extern double gChargedIso;
1128	>	extern double  gGammaIso;
1129	>	extern double  gNeutralIso;
1130	>
1131	>	if( ctrl.debug ) {
1132	>	cout << "muonIsoMVASelection :: muons to veto " << endl;
1133	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
1134	>	const mithep::Muon * vmu = muonsToVeto[i];
1135	>	cout << "\tpt: " << vmu->Pt()
1136	>	<< "\teta: " << vmu->Eta()
1137	>	<< "\tphi: " << vmu->Phi()
1138	>	<< endl;
1139	>	}
1140	>	cout << "muonIsoMVASelection :: electrson to veto " << endl;
1141	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
1142	>	const mithep::Electron * vel = electronsToVeto[i];
1143	>	cout << "\tpt: " << vel->Pt()
1144	>	<< "\teta: " << vel->Eta()
1145	>	<< "\tphi: " << vel->Phi()
1146	>	<< endl;
1147	>	}
1148	>	}
1149	>
1150	>	//
1151	>	// final iso
1152	>	//
1153	>	Double_t fChargedIso  = 0.0;
1154	>	Double_t fGammaIso  = 0.0;
1155	>	Double_t fNeutralHadronIso  = 0.0;
1156	>
1157	>	//
1158	>	//Loop over PF Candidates
1159	>	//
1160	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1161	>
1162	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1163	>	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1164	>
1165	>	Double_t deta = (mu->Eta() - pf->Eta());
1166	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
1167	>	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
1168	>	if (dr > 0.4) continue;
1169	>
1170	>	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
1171	>
1172	>	//
1173	>	// Lepton Footprint Removal
1174	>	//
1175	>	Bool_t IsLeptonFootprint = kFALSE;
1176	>	if (dr < 1.0) {
1177	>
1178	>	//
1179	>	// Check for electrons
1180	>	//
1181	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1182	>	const mithep::Electron *tmpele = electronsToVeto[q];
1183	>	// 4l electron
1184	>	if( pf->HasTrackerTrk() ) {
1185	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
1186	>	IsLeptonFootprint = kTRUE;
1187	>	}
1188	>	if( pf->HasGsfTrk() ) {
1189	>	if( pf->GsfTrk() == tmpele->GsfTrk() )
1190	>	IsLeptonFootprint = kTRUE;
1191	>	}
1192	>	// PF charged
1193	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1194	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
1195	>	IsLeptonFootprint = kTRUE;
1196	>	// PF gamma
1197	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1198	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
1199	>	IsLeptonFootprint = kTRUE;
1200	>	} // loop over electrons
1201	>
1202	>	/* KH - comment for sync
1203	>	//
1204	>	// Check for muons
1205	>	//
1206	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1207	>	const mithep::Muon *tmpmu = muonsToVeto[q];
1208	>	// 4l muon
1209	>	if( pf->HasTrackerTrk() ) {
1210	>	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
1211	>	IsLeptonFootprint = kTRUE;
1212	>	}
1213	>	// PF charged
1214	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
1215	>	IsLeptonFootprint = kTRUE;
1216	>	} // loop over muons
1217	>	*/
1218	>
1219	>	if (IsLeptonFootprint)
1220	>	continue;
1221	>
1222	>	//
1223	>	// Charged Iso
1224	>	//
1225	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1226	>
1227	>	//if( dr < 0.01 ) continue; // only for muon iso mva?
1228	>	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1229	>
1230	>
1231	>	//       if( pf->HasTrackerTrk() ) {
1232	>	//      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1233	>	//      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1234	>	//                            << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1235	>	//                            << dr << endl;
1236	>	//       }
1237	>	//       if( pf->HasGsfTrk() ) {
1238	>	//      if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1239	>	//      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1240	>	//                            << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1241	>	//                            << dr << endl;
1242	>	//       }
1243	>
1244	>
1245	>	fChargedIso += pf->Pt();
1246	>	}
1247	>
1248	>	//
1249	>	// Gamma Iso
1250	>	//
1251	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1252	>	// KH, add to sync
1253	>	if( pf->Pt() > 0.5 )
1254	>	fGammaIso += pf->Pt();
1255	>	}
1256	>
1257	>	//
1258	>	// Other Neutrals
1259	>	//
1260	>	else {
1261	>	// KH, add to sync
1262	>	if( pf->Pt() > 0.5 )
1263	>	fNeutralHadronIso += pf->Pt();
1264	>	}
1265	>
1266	>	}
1267	>
1268	>	}
1269	>
1270	>	//   double rho = 0;
1271	>	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1272	>	//     rho = fPUEnergyDensity->At(0)->Rho();
1273	>
1274	>	// WARNING!!!!
1275	>	// hardcode for sync ...
1276	>	EffectiveAreaVersion = muT.kMuEAData2011;
1277	>	// WARNING!!!!
1278	>
1279	>
1280	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1281	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1282	>	mu->Eta(),EffectiveAreaVersion)));
1283	>	gChargedIso = fChargedIso;
1284	>	gGammaIso   = fGammaIso;
1285	>	gNeutralIso = fNeutralHadronIso;
1286	>
1287	>	return pfIso;
1288	>	}
1289	>
1290	>
1291	>	//--------------------------------------------------------------------------------------------------
1292	>	SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1293	>	const mithep::Muon * mu,
1294	>	const mithep::Vertex & vtx,
1295	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1296	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1297	>	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1298	>	vector<const mithep::Muon*> muonsToVeto,
1299	>	vector<const mithep::Electron*> electronsToVeto)
1300	>	//--------------------------------------------------------------------------------------------------
1301	>	{
1302	>
1303	>	SelectionStatus status;
1304	>
1305	>	double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, fPUEnergyDensity,
1306	>	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1307	>	//  cout << "--------------> setting muon isoPF04 to" << pfIso << endl;
1308	>	status.isoPF04 = pfIso;
1309	>	status.chisoPF04 = gChargedIso;
1310	>	status.gaisoPF04 = gGammaIso;
1311	>	status.neisoPF04 = gNeutralIso;
1312	>
1313	>	bool pass = false;
1314	>	if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1315	>
1316	>	if( pass ) {
1317	>	status.orStatus(SelectionStatus::LOOSEISO);
1318	>	status.orStatus(SelectionStatus::TIGHTISO);
1319	>	}
1320	>	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1321	>	return status;
1322	>
1323	>	}
1324	>
1325	>
1326	>	//--------------------------------------------------------------------------------------------------
1327	>	// hacked version
1328	>	SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1329	>	const mithep::Muon * mu,
1330	>	const mithep::Vertex & vtx,
1331	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1332	>	float rho,
1333	>	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1334	>	vector<const mithep::Muon*> muonsToVeto,
1335	>	vector<const mithep::Electron*> electronsToVeto)
1336	>	//--------------------------------------------------------------------------------------------------
1337	>	{
1338	>
1339	>	SelectionStatus status;
1340	>
1341	>	double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, rho,
1342	>	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1343	>
1344	>	status.isoPF04 = pfIso;
1345	>	status.chisoPF04 = gChargedIso;
1346	>	status.gaisoPF04 = gGammaIso;
1347	>	status.neisoPF04 = gNeutralIso;
1348	>
1349	>	bool pass = false;
1350	>	if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1351	>
1352	>	if( pass ) {
1353	>	status.orStatus(SelectionStatus::LOOSEISO);
1354	>	status.orStatus(SelectionStatus::TIGHTISO);
1355	>	}
1356	>	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1357	>	return status;
1358	>
1359	>	}
1360	>
1361	>
1362	>
1363	>	//--------------------------------------------------------------------------------------------------
1364	>	SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1365	>	const mithep::Electron * ele,
1366	>	const mithep::Vertex & vtx,
1367	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1368	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1369	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1370	>	vector<const mithep::Muon*> muonsToVeto,
1371	>	vector<const mithep::Electron*> electronsToVeto)
1372	>	//--------------------------------------------------------------------------------------------------
1373	>	{
1374	>
1375	>	if( ctrl.debug ) {
1376	>	cout << "electronIsoMVASelection :: muons to veto " << endl;
1377	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
1378	>	const mithep::Muon * vmu = muonsToVeto[i];
1379	>	cout << "\tpt: " << vmu->Pt()
1380	>	<< "\teta: " << vmu->Eta()
1381	>	<< "\tphi: " << vmu->Phi()
1382	>	<< endl;
1383	>	}
1384	>	cout << "electronIsoMVASelection :: electrson to veto " << endl;
1385	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
1386	>	const mithep::Electron * vel = electronsToVeto[i];
1387	>	cout << "\tpt: " << vel->Pt()
1388	>	<< "\teta: " << vel->Eta()
1389	>	<< "\tphi: " << vel->Phi()
1390	>	<< "\ttrk: " << vel->TrackerTrk()
1391	>	<< endl;
1392	>	}
1393	>	}
1394	>
1395	>	bool failiso=false;
1396	>
1397	>	//
1398	>	// tmp iso rings
1399	>	//
1400	>	Double_t tmpChargedIso_DR0p0To0p1  = 0;
1401	>	Double_t tmpChargedIso_DR0p1To0p2  = 0;
1402	>	Double_t tmpChargedIso_DR0p2To0p3  = 0;
1403	>	Double_t tmpChargedIso_DR0p3To0p4  = 0;
1404	>	Double_t tmpChargedIso_DR0p4To0p5  = 0;
1405	>	Double_t tmpChargedIso_DR0p5To0p7  = 0;
1406	>
1407	>	Double_t tmpGammaIso_DR0p0To0p1  = 0;
1408	>	Double_t tmpGammaIso_DR0p1To0p2  = 0;
1409	>	Double_t tmpGammaIso_DR0p2To0p3  = 0;
1410	>	Double_t tmpGammaIso_DR0p3To0p4  = 0;
1411	>	Double_t tmpGammaIso_DR0p4To0p5  = 0;
1412	>	Double_t tmpGammaIso_DR0p5To0p7  = 0;
1413	>
1414	>	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
1415	>	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
1416	>	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
1417	>	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
1418	>	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
1419	>	Double_t tmpNeutralHadronIso_DR0p5To0p7  = 0;
1420	>
1421	>
1422	>
1423	>	//
1424	>	// final rings for the MVA
1425	>	//
1426	>	Double_t fChargedIso_DR0p0To0p1;
1427	>	Double_t fChargedIso_DR0p1To0p2;
1428	>	Double_t fChargedIso_DR0p2To0p3;
1429	>	Double_t fChargedIso_DR0p3To0p4;
1430	>	Double_t fChargedIso_DR0p4To0p5;
1431	>
1432	>	Double_t fGammaIso_DR0p0To0p1;
1433	>	Double_t fGammaIso_DR0p1To0p2;
1434	>	Double_t fGammaIso_DR0p2To0p3;
1435	>	Double_t fGammaIso_DR0p3To0p4;
1436	>	Double_t fGammaIso_DR0p4To0p5;
1437	>
1438	>	Double_t fNeutralHadronIso_DR0p0To0p1;
1439	>	Double_t fNeutralHadronIso_DR0p1To0p2;
1440	>	Double_t fNeutralHadronIso_DR0p2To0p3;
1441	>	Double_t fNeutralHadronIso_DR0p3To0p4;
1442	>	Double_t fNeutralHadronIso_DR0p4To0p5;
1443	>
1444	>
1445	>	//
1446	>	//Loop over PF Candidates
1447	>	//
1448	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1449	>
1450	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1451	>
1452	>	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1453	>	Double_t deta = (ele->Eta() - pf->Eta());
1454	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1455	>	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1456	>	if (dr > 0.5) continue;
1457	>	if(ctrl.debug) {
1458	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1459	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
1460	>	cout << endl;
1461	>	}
1462	>
1463	>
1464	>	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
1465	>	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1466	>
1467	>
1468	>	//
1469	>	// Lepton Footprint Removal
1470	>	//
1471	>	Bool_t IsLeptonFootprint = kFALSE;
1472	>	if (dr < 1.0) {
1473	>
1474	>	//
1475	>	// Check for electrons
1476	>	//
1477	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1478	>	const mithep::Electron *tmpele = electronsToVeto[q];
1479	>	// 4l electron
1480	>	if( pf->HasTrackerTrk()  ) {
1481	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1482	>	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1483	>	IsLeptonFootprint = kTRUE;
1484	>	}
1485	>	}
1486	>	if( pf->HasGsfTrk()  ) {
1487	>	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1488	>	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1489	>	IsLeptonFootprint = kTRUE;
1490	>	}
1491	>	}
1492	>	// PF charged
1493	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479
1494	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1495	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1496	>	IsLeptonFootprint = kTRUE;
1497	>	}
1498	>	// PF gamma
1499	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1500	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
1501	>	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1502	>	IsLeptonFootprint = kTRUE;
1503	>	}
1504	>	} // loop over electrons
1505	>
1506	>	/* KH - comment for sync
1507	>	//
1508	>	// Check for muons
1509	>	//
1510	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1511	>	const mithep::Muon *tmpmu = muonsToVeto[q];
1512	>	// 4l muon
1513	>	if( pf->HasTrackerTrk() ) {
1514	>	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1515	>	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1516	>	IsLeptonFootprint = kTRUE;
1517	>	}
1518	>	}
1519	>	// PF charged
1520	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1521	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1522	>	IsLeptonFootprint = kTRUE;
1523	>	}
1524	>	} // loop over muons
1525	>	*/
1526	>
1527	>	if (IsLeptonFootprint)
1528	>	continue;
1529	>
1530	>	//
1531	>	// Charged Iso Rings
1532	>	//
1533	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1534	>
1535	>	//       if( pf->HasGsfTrk() ) {
1536	>	//       if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1537	>	//       } else if( pf->HasTrackerTrk() ){
1538	>	//      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1539	>	//       }
1540	>
1541	>	// Veto any PFmuon, or PFEle
1542	>	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1543	>
1544	>	// Footprint Veto
1545	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1546	>
1547	>	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1548	>	<< "\ttype: " << pf->PFType()
1549	>	<< "\ttrk: " << pf->TrackerTrk() << endl;
1550	>
1551	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
1552	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
1553	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1554	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1555	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
1556	>	if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
1557	>
1558	>	}
1559	>
1560	>	//
1561	>	// Gamma Iso Rings
1562	>	//
1563	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1564	>
1565	>	if (fabs(ele->SCluster()->Eta()) > 1.479) {
1566	>	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
1567	>	}
1568	>
1569	>	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1570	>	<< dr << endl;
1571	>
1572	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
1573	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
1574	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1575	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1576	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
1577	>	if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
1578	>
1579	>	}
1580	>
1581	>	//
1582	>	// Other Neutral Iso Rings
1583	>	//
1584	>	else {
1585	>	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
1586	>	<< dr << endl;
1587	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
1588	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
1589	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1590	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1591	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1592	>	if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
1593	>	}
1594	>
1595	>	}
1596	>
1597	>	}
1598	>
1599	>	fChargedIso_DR0p0To0p1   = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1600	>	fChargedIso_DR0p1To0p2   = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1601	>	fChargedIso_DR0p2To0p3   = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1602	>	fChargedIso_DR0p3To0p4   = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1603	>	fChargedIso_DR0p4To0p5   = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1604	>
1605	>	double rho = 0;
1606	>	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1607	>	//     rho = fPUEnergyDensity->At(0)->Rho();
1608	>	if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1609	>	rho = fPUEnergyDensity->At(0)->RhoLowEta();
1610	>
1611	>	// WARNING!!!!
1612	>	// hardcode for sync ...
1613	>	//  EffectiveAreaVersion = eleT.kEleEAData2011;
1614	>	EffectiveAreaVersion = eleT.kEleEAFall11MC;
1615	>	// WARNING!!!!
1616	>
1617	>	if( ctrl.debug) {
1618	>	cout << "RHO: " << rho << endl;
1619	>	cout << "eta: " << ele->SCluster()->Eta() << endl;
1620	>	cout << "target: " << EffectiveAreaVersion << endl;
1621	>	cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1622	>	ele->SCluster()->Eta(),
1623	>	EffectiveAreaVersion)
1624	>	<< endl;
1625	>	cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1626	>	ele->SCluster()->Eta(),
1627	>	EffectiveAreaVersion)
1628	>	<< endl;
1629	>	cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1630	>	ele->SCluster()->Eta(),
1631	>	EffectiveAreaVersion)
1632	>	<< endl;
1633	>	cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1634	>	ele->SCluster()->Eta(),
1635	>	EffectiveAreaVersion)
1636	>	<< endl;
1637	>	}
1638	>
1639	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
1640	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
1641	>	ele->SCluster()->Eta(),
1642	>	EffectiveAreaVersion))/ele->Pt()
1643	>	,2.5)
1644	>	,0.0);
1645	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
1646	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
1647	>	ele->SCluster()->Eta(),
1648	>	EffectiveAreaVersion))/ele->Pt()
1649	>	,2.5)
1650	>	,0.0);
1651	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
1652	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
1653	>	ele->SCluster()->Eta()
1654	>	,EffectiveAreaVersion))/ele->Pt()
1655	>	,2.5)
1656	>	,0.0);
1657	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
1658	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
1659	>	ele->SCluster()->Eta(),
1660	>	EffectiveAreaVersion))/ele->Pt()
1661	>	,2.5)
1662	>	,0.0);
1663	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
1664	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
1665	>	ele->SCluster()->Eta(),
1666	>	EffectiveAreaVersion))/ele->Pt()
1667	>	,2.5)
1668	>	,0.0);
1669	>
1670	>
1671	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
1672	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1673	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1674	>	, 2.5)
1675	>	, 0.0);
1676	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
1677	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1678	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1679	>	, 2.5)
1680	>	, 0.0);
1681	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
1682	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1683	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1684	>	, 2.5)
1685	>	, 0.0);
1686	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
1687	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1688	>	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1689	>	, 2.5)
1690	>	, 0.0);
1691	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
1692	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
1693	>	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1694	>	, 2.5)
1695	>	, 0.0);
1696	>
1697	>	double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
1698	>	ele->SCluster()->Eta(),
1699	>	fChargedIso_DR0p0To0p1,
1700	>	fChargedIso_DR0p1To0p2,
1701	>	fChargedIso_DR0p2To0p3,
1702	>	fChargedIso_DR0p3To0p4,
1703	>	fChargedIso_DR0p4To0p5,
1704	>	fGammaIso_DR0p0To0p1,
1705	>	fGammaIso_DR0p1To0p2,
1706	>	fGammaIso_DR0p2To0p3,
1707	>	fGammaIso_DR0p3To0p4,
1708	>	fGammaIso_DR0p4To0p5,
1709	>	fNeutralHadronIso_DR0p0To0p1,
1710	>	fNeutralHadronIso_DR0p1To0p2,
1711	>	fNeutralHadronIso_DR0p2To0p3,
1712	>	fNeutralHadronIso_DR0p3To0p4,
1713	>	fNeutralHadronIso_DR0p4To0p5,
1714	>	ctrl.debug);
1715	>
1716	>	SelectionStatus status;
1717	>	bool pass = false;
1718	>
1719	>	Int_t subdet = 0;
1720	>	if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
1721	>	else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
1722	>	else subdet = 2;
1723	>	Int_t ptBin = 0;
1724	>	if (ele->Pt() > 10.0) ptBin = 1;
1725	>
1726	>	Int_t MVABin = -1;
1727	>	if (subdet == 0 && ptBin == 0) MVABin = 0;
1728	>	if (subdet == 1 && ptBin == 0) MVABin = 1;
1729	>	if (subdet == 2 && ptBin == 0) MVABin = 2;
1730	>	if (subdet == 0 && ptBin == 1) MVABin = 3;
1731	>	if (subdet == 1 && ptBin == 1) MVABin = 4;
1732	>	if (subdet == 2 && ptBin == 1) MVABin = 5;
1733	>
1734	>	pass = false;
1735	>	if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN0 ) pass = true;
1736	>	if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN1 ) pass = true;
1737	>	if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN2 ) pass = true;
1738	>	if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN3 ) pass = true;
1739	>	if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN4 ) pass = true;
1740	>	if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN5 ) pass = true;
1741	>	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
1742	>
1743	>	//   pass = false;
1744	>	//   if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
1745	>	//   if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
1746	>	//   if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
1747	>	//   if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
1748	>	//   if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
1749	>	//   if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
1750	>	//   if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
1751	>
1752	>	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1753	>	return status;
1754	>
1755	>	}
1756	>
1757	>
1758	>
1759	>	//--------------------------------------------------------------------------------------------------
1760	>	SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1761	>	const mithep::Electron * ele,
1762	>	const mithep::Vertex & vtx,
1763	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1764	>	float rho,
1765	>	//const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1766	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1767	>	vector<const mithep::Muon*> muonsToVeto,
1768	>	vector<const mithep::Electron*> electronsToVeto)
1769	>	//--------------------------------------------------------------------------------------------------
1770	>	// hacked version
1771	>	{
1772	>	if( ctrl.debug ) {
1773	>	cout << "================> hacked ele Iso MVA <======================" << endl;
1774	>	}
1775	>
1776	>	if( ctrl.debug ) {
1777	>	cout << "electronIsoMVASelection :: muons to veto " << endl;
1778	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
1779	>	const mithep::Muon * vmu = muonsToVeto[i];
1780	>	cout << "\tpt: " << vmu->Pt()
1781	>	<< "\teta: " << vmu->Eta()
1782	>	<< "\tphi: " << vmu->Phi()
1783	>	<< endl;
1784	>	}
1785	>	cout << "electronIsoMVASelection :: electrson to veto " << endl;
1786	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
1787	>	const mithep::Electron * vel = electronsToVeto[i];
1788	>	cout << "\tpt: " << vel->Pt()
1789	>	<< "\teta: " << vel->Eta()
1790	>	<< "\tphi: " << vel->Phi()
1791	>	<< "\ttrk: " << vel->TrackerTrk()
1792	>	<< endl;
1793	>	}
1794	>	}
1795	>
1796	>	bool failiso=false;
1797	>
1798	>	//
1799	>	// tmp iso rings
1800	>	//
1801	>	Double_t tmpChargedIso_DR0p0To0p1  = 0;
1802	>	Double_t tmpChargedIso_DR0p1To0p2  = 0;
1803	>	Double_t tmpChargedIso_DR0p2To0p3  = 0;
1804	>	Double_t tmpChargedIso_DR0p3To0p4  = 0;
1805	>	Double_t tmpChargedIso_DR0p4To0p5  = 0;
1806	>
1807	>	Double_t tmpGammaIso_DR0p0To0p1  = 0;
1808	>	Double_t tmpGammaIso_DR0p1To0p2  = 0;
1809	>	Double_t tmpGammaIso_DR0p2To0p3  = 0;
1810	>	Double_t tmpGammaIso_DR0p3To0p4  = 0;
1811	>	Double_t tmpGammaIso_DR0p4To0p5  = 0;
1812	>
1813	>
1814	>	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
1815	>	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
1816	>	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
1817	>	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
1818	>	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
1819	>
1820	>
1821	>
1822	>	//
1823	>	// final rings for the MVA
1824	>	//
1825	>	Double_t fChargedIso_DR0p0To0p1;
1826	>	Double_t fChargedIso_DR0p1To0p2;
1827	>	Double_t fChargedIso_DR0p2To0p3;
1828	>	Double_t fChargedIso_DR0p3To0p4;
1829	>	Double_t fChargedIso_DR0p4To0p5;
1830	>
1831	>	Double_t fGammaIso_DR0p0To0p1;
1832	>	Double_t fGammaIso_DR0p1To0p2;
1833	>	Double_t fGammaIso_DR0p2To0p3;
1834	>	Double_t fGammaIso_DR0p3To0p4;
1835	>	Double_t fGammaIso_DR0p4To0p5;
1836	>
1837	>	Double_t fNeutralHadronIso_DR0p0To0p1;
1838	>	Double_t fNeutralHadronIso_DR0p1To0p2;
1839	>	Double_t fNeutralHadronIso_DR0p2To0p3;
1840	>	Double_t fNeutralHadronIso_DR0p3To0p4;
1841	>	Double_t fNeutralHadronIso_DR0p4To0p5;
1842	>
1843	>
1844	>	//
1845	>	//Loop over PF Candidates
1846	>	//
1847	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1848	>
1849	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1850	>
1851	>	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1852	>	Double_t deta = (ele->Eta() - pf->Eta());
1853	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1854	>	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1855	>	if (dr > 1.0) continue;
1856	>
1857	>	if(ctrl.debug) {
1858	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1859	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
1860	>	cout << endl;
1861	>	}
1862	>
1863	>
1864	>	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
1865	>	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1866	>
1867	>
1868	>	//
1869	>	// Lepton Footprint Removal
1870	>	//
1871	>	Bool_t IsLeptonFootprint = kFALSE;
1872	>	if (dr < 1.0) {
1873	>
1874	>
1875	>	//
1876	>	// Check for electrons
1877	>	//
1878	>
1879	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1880	>	const mithep::Electron *tmpele = electronsToVeto[q];
1881	>	double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1882	>
1883	>	// 4l electron
1884	>	if( pf->HasTrackerTrk()  ) {
1885	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1886	>	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1887	>	IsLeptonFootprint = kTRUE;
1888	>	}
1889	>	}
1890	>	if( pf->HasGsfTrk()  ) {
1891	>	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1892	>	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1893	>	IsLeptonFootprint = kTRUE;
1894	>	}
1895	>	}
1896	>	// PF charged
1897	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1898	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1899	>	IsLeptonFootprint = kTRUE;
1900	>	}
1901	>	// PF gamma
1902	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1903	>	&& tmpdr < 0.08) {
1904	>	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1905	>	IsLeptonFootprint = kTRUE;
1906	>	}
1907	>	} // loop over electrons
1908	>
1909	>
1910	>	/* KH - comment for sync
1911	>	//
1912	>	// Check for muons
1913	>	//
1914	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1915	>	const mithep::Muon *tmpmu = muonsToVeto[q];
1916	>	// 4l muon
1917	>	if( pf->HasTrackerTrk() ) {
1918	>	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1919	>	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1920	>	IsLeptonFootprint = kTRUE;
1921	>	}
1922	>	}
1923	>	// PF charged
1924	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1925	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1926	>	IsLeptonFootprint = kTRUE;
1927	>	}
1928	>	} // loop over muons
1929	>	*/
1930	>
1931	>	if (IsLeptonFootprint)
1932	>	continue;
1933	>
1934	>	//
1935	>	// Charged Iso Rings
1936	>	//
1937	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1938	>
1939	>	//       if( pf->HasGsfTrk() ) {
1940	>	//       if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1941	>	//       } else if( pf->HasTrackerTrk() ){
1942	>	//      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1943	>	//       }
1944	>
1945	>	// Veto any PFmuon, or PFEle
1946	>	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1947	>
1948	>	// Footprint Veto
1949	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1950	>
1951	>	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1952	>	<< "\ttype: " << pf->PFType()
1953	>	<< "\ttrk: " << pf->TrackerTrk() << endl;
1954	>
1955	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
1956	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
1957	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1958	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1959	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
1960	>
1961	>	}
1962	>
1963	>	//
1964	>	// Gamma Iso Rings
1965	>	//
1966	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1967	>
1968	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
1969	>
1970	>	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1971	>	<< dr << endl;
1972	>
1973	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
1974	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
1975	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1976	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1977	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
1978	>	}
1979	>
1980	>	//
1981	>	// Other Neutral Iso Rings
1982	>	//
1983	>	else {
1984	>	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
1985	>	<< dr << endl;
1986	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
1987	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
1988	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1989	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1990	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1991	>	}
1992	>
1993	>	}
1994	>
1995	>	}
1996	>
1997	>	fChargedIso_DR0p0To0p1   = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1998	>	fChargedIso_DR0p1To0p2   = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1999	>	fChargedIso_DR0p2To0p3   = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
2000	>	fChargedIso_DR0p3To0p4   = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
2001	>	fChargedIso_DR0p4To0p5   = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
2002	>
2003	>	if(ctrl.debug) {
2004	>	cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1  << endl;
2005	>	cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2  << endl;
2006	>	cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3  << endl;
2007	>	cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4  << endl;
2008	>	cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5  << endl;
2009	>	}
2010	>
2011	>
2012	>	//  rho=0;
2013	>	//  double rho = 0;
2014	>	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
2015	>	//     rho = fPUEnergyDensity->At(0)->Rho();
2016	>	//   if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
2017	>	//     rho = fPUEnergyDensity->At(0)->RhoLowEta();
2018	>
2019	>	// WARNING!!!!
2020	>	// hardcode for sync ...
2021	>	EffectiveAreaVersion = eleT.kEleEAData2011;
2022	>	// WARNING!!!!
2023	>
2024	>	if( ctrl.debug) {
2025	>	cout << "RHO: " << rho << endl;
2026	>	cout << "eta: " << ele->SCluster()->Eta() << endl;
2027	>	cout << "target: " << EffectiveAreaVersion << endl;
2028	>	cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
2029	>	ele->SCluster()->Eta(),
2030	>	EffectiveAreaVersion)
2031	>	<< endl;
2032	>	cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
2033	>	ele->SCluster()->Eta(),
2034	>	EffectiveAreaVersion)
2035	>	<< endl;
2036	>	cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
2037	>	ele->SCluster()->Eta(),
2038	>	EffectiveAreaVersion)
2039	>	<< endl;
2040	>	cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
2041	>	ele->SCluster()->Eta(),
2042	>	EffectiveAreaVersion)
2043	>	<< endl;
2044	>	}
2045	>
2046	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
2047	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
2048	>	ele->SCluster()->Eta(),
2049	>	EffectiveAreaVersion))/ele->Pt()
2050	>	,2.5)
2051	>	,0.0);
2052	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
2053	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
2054	>	ele->SCluster()->Eta(),
2055	>	EffectiveAreaVersion))/ele->Pt()
2056	>	,2.5)
2057	>	,0.0);
2058	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
2059	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
2060	>	ele->SCluster()->Eta()
2061	>	,EffectiveAreaVersion))/ele->Pt()
2062	>	,2.5)
2063	>	,0.0);
2064	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
2065	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
2066	>	ele->SCluster()->Eta(),
2067	>	EffectiveAreaVersion))/ele->Pt()
2068	>	,2.5)
2069	>	,0.0);
2070	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
2071	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
2072	>	ele->SCluster()->Eta(),
2073	>	EffectiveAreaVersion))/ele->Pt()
2074	>	,2.5)
2075	>	,0.0);
2076	>
2077	>
2078	>	if( ctrl.debug) {
2079	>	cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
2080	>	cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
2081	>	cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
2082	>	cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
2083	>	cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
2084	>	}
2085	>
2086	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
2087	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
2088	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2089	>	, 2.5)
2090	>	, 0.0);
2091	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
2092	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
2093	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2094	>	, 2.5)
2095	>	, 0.0);
2096	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
2097	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
2098	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2099	>	, 2.5)
2100	>	, 0.0);
2101	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
2102	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
2103	>	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2104	>	, 2.5)
2105	>	, 0.0);
2106	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
2107	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
2108	>	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2109	>	, 2.5)
2110	>	, 0.0);
2111	>
2112	>	if( ctrl.debug) {
2113	>	cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
2114	>	cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
2115	>	cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
2116	>	cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
2117	>	cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
2118	>	}
2119	>
2120	>	double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
2121	>	ele->SCluster()->Eta(),
2122	>	fChargedIso_DR0p0To0p1,
2123	>	fChargedIso_DR0p1To0p2,
2124	>	fChargedIso_DR0p2To0p3,
2125	>	fChargedIso_DR0p3To0p4,
2126	>	fChargedIso_DR0p4To0p5,
2127	>	fGammaIso_DR0p0To0p1,
2128	>	fGammaIso_DR0p1To0p2,
2129	>	fGammaIso_DR0p2To0p3,
2130	>	fGammaIso_DR0p3To0p4,
2131	>	fGammaIso_DR0p4To0p5,
2132	>	fNeutralHadronIso_DR0p0To0p1,
2133	>	fNeutralHadronIso_DR0p1To0p2,
2134	>	fNeutralHadronIso_DR0p2To0p3,
2135	>	fNeutralHadronIso_DR0p3To0p4,
2136	>	fNeutralHadronIso_DR0p4To0p5,
2137	>	ctrl.debug);
2138	>
2139	>	SelectionStatus status;
2140	>	status.isoMVA = mvaval;
2141	>	bool pass = false;
2142	>
2143	>	Int_t subdet = 0;
2144	>	if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
2145	>	else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
2146	>	else subdet = 2;
2147	>
2148	>	Int_t ptBin = 0;
2149	>	if (ele->Pt() >= 10.0) ptBin = 1;
2150	>
2151	>	Int_t MVABin = -1;
2152	>	if (subdet == 0 && ptBin == 0) MVABin = 0;
2153	>	if (subdet == 1 && ptBin == 0) MVABin = 1;
2154	>	if (subdet == 2 && ptBin == 0) MVABin = 2;
2155	>	if (subdet == 0 && ptBin == 1) MVABin = 3;
2156	>	if (subdet == 1 && ptBin == 1) MVABin = 4;
2157	>	if (subdet == 2 && ptBin == 1) MVABin = 5;
2158	>
2159	>	pass = false;
2160	>	if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN0 ) pass = true;
2161	>	if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN1 ) pass = true;
2162	>	if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN2 ) pass = true;
2163	>	if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN3 ) pass = true;
2164	>	if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN4 ) pass = true;
2165	>	if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN5 ) pass = true;
2166	>	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
2167	>
2168	>	//   pass = false;
2169	>	//   if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
2170	>	//   if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
2171	>	//   if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
2172	>	//   if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
2173	>	//   if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
2174	>	//   if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
2175	>	//   if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
2176	>
2177	>	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2178	>	return status;
2179	>
2180	>	}
2181	>
2182	>
2183	>	//--------------------------------------------------------------------------------------------------
2184	>	void initElectronIsoMVA() {
2185	>	//--------------------------------------------------------------------------------------------------
2186	>	eleIsoMVA = new mithep::ElectronIDMVA();
2187	>	vector<string> weightFiles;
2188	>	weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_BarrelPt5To10.weights.xml");
2189	>	weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_EndcapPt5To10.weights.xml");
2190	>	weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_BarrelPt10ToInf.weights.xml");
2191	>	weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_EndcapPt10ToInf.weights.xml");
2192	>	eleIsoMVA->Initialize( "ElectronIsoMVA",
2193	>	mithep::ElectronIDMVA::kIsoRingsV0,
2194	>	kTRUE, weightFiles);
2195	>	}
2196	>
2197	>
2198	>
2199	>	//--------------------------------------------------------------------------------------------------
2200	>	float electronPFIso04(ControlFlags &ctrl,
2201	>	const mithep::Electron * ele,
2202	>	const mithep::Vertex & vtx,
2203	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2204	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2205	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2206	>	vector<const mithep::Muon*> muonsToVeto,
2207	>	vector<const mithep::Electron*> electronsToVeto)
2208	>	//--------------------------------------------------------------------------------------------------
2209	>	{
2210	>
2211	>	if( ctrl.debug ) {
2212	>	cout << "electronIsoMVASelection :: muons to veto " << endl;
2213	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
2214	>	const mithep::Muon * vmu = muonsToVeto[i];
2215	>	cout << "\tpt: " << vmu->Pt()
2216	>	<< "\teta: " << vmu->Eta()
2217	>	<< "\tphi: " << vmu->Phi()
2218	>	<< endl;
2219	>	}
2220	>	cout << "electronIsoMVASelection :: electrson to veto " << endl;
2221	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
2222	>	const mithep::Electron * vel = electronsToVeto[i];
2223	>	cout << "\tpt: " << vel->Pt()
2224	>	<< "\teta: " << vel->Eta()
2225	>	<< "\tphi: " << vel->Phi()
2226	>	<< "\ttrk: " << vel->TrackerTrk()
2227	>	<< endl;
2228	>	}
2229	>	}
2230	>
2231	>
2232	>	//
2233	>	// final iso
2234	>	//
2235	>	Double_t fChargedIso = 0.0;
2236	>	Double_t fGammaIso = 0.0;
2237	>	Double_t fNeutralHadronIso = 0.0;
2238	>
2239	>
2240	>	//
2241	>	//Loop over PF Candidates
2242	>	//
2243	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2244	>	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2245	>	Double_t deta = (ele->Eta() - pf->Eta());
2246	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2247	>	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2248	>	if (dr >= 0.4) continue;
2249	>	if(ctrl.debug) {
2250	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
2251	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
2252	>	cout << endl;
2253	>	}
2254	>
2255	>
2256	>	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
2257	>	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
2258	>
2259	>
2260	>	//
2261	>	// Lepton Footprint Removal
2262	>	//
2263	>	Bool_t IsLeptonFootprint = kFALSE;
2264	>	if (dr < 1.0) {
2265	>
2266	>	//
2267	>	// Check for electrons
2268	>	//
2269	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2270	>	const mithep::Electron *tmpele = electronsToVeto[q];
2271	>	// 4l electron
2272	>	if( pf->HasTrackerTrk()  ) {
2273	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
2274	>	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
2275	>	IsLeptonFootprint = kTRUE;
2276	>	}
2277	>	}
2278	>	if( pf->HasGsfTrk()  ) {
2279	>	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
2280	>	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
2281	>	IsLeptonFootprint = kTRUE;
2282	>	}
2283	>	}
2284	>	// PF charged
2285	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2286	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
2287	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
2288	>	IsLeptonFootprint = kTRUE;
2289	>	}
2290	>	// PF gamma
2291	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
2292	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
2293	>	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
2294	>	IsLeptonFootprint = kTRUE;
2295	>	}
2296	>	} // loop over electrons
2297	>
2298	>
2299	>	//
2300	>	// Check for muons
2301	>	//
2302	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
2303	>	const mithep::Muon *tmpmu = muonsToVeto[q];
2304	>	// 4l muon
2305	>	if( pf->HasTrackerTrk() ) {
2306	>	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
2307	>	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
2308	>	IsLeptonFootprint = kTRUE;
2309	>	}
2310	>	}
2311	>	// PF charged
2312	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
2313	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
2314	>	IsLeptonFootprint = kTRUE;
2315	>	}
2316	>	} // loop over muons
2317	>
2318	>
2319	>	if (IsLeptonFootprint)
2320	>	continue;
2321	>
2322	>	//
2323	>	// Charged Iso
2324	>	//
2325	>	if (pf->Charge() != 0 ) {
2326	>
2327	>	if( pf->HasTrackerTrk() )
2328	>	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2329	>	if( pf->HasGsfTrk() )
2330	>	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2331	>
2332	>	// Veto any PFmuon, or PFEle
2333	>	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
2334	>
2335	>	// Footprint Veto
2336	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
2337	>
2338	>	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
2339	>	<< "\ttype: " << pf->PFType()
2340	>	<< "\ttrk: " << pf->TrackerTrk() << endl;
2341	>
2342	>	fChargedIso += pf->Pt();
2343	>	}
2344	>
2345	>	//
2346	>	// Gamma Iso
2347	>	//
2348	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2349	>
2350	>	if (fabs(ele->SCluster()->Eta()) > 1.479) {
2351	>	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
2352	>	}
2353	>	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2354	>	<< dr << endl;
2355	>	// KH, add to sync
2356	>	//      if( pf->Pt() > 0.5 )
2357	>	fGammaIso += pf->Pt();
2358	>	}
2359	>
2360	>	//
2361	>	// Neutral Iso
2362	>	//
2363	>	else {
2364	>	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2365	>	<< dr << endl;
2366	>	// KH, add to sync
2367	>	//      if( pf->Pt() > 0.5 )
2368	>	fNeutralHadronIso += pf->Pt();
2369	>	}
2370	>
2371	>	}
2372	>
2373	>	}
2374	>
2375	>	double rho = 0;
2376	>	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
2377	>	//     rho = fPUEnergyDensity->At(0)->Rho();
2378	>	if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
2379	>	rho = fPUEnergyDensity->At(0)->RhoLowEta();
2380	>
2381	>	// WARNING!!!!
2382	>	// hardcode for sync ...
2383	>	EffectiveAreaVersion = eleT.kEleEAData2011;
2384	>	// WARNING!!!!
2385	>
2386	>
2387	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2388	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2389	>	ele->Eta(),EffectiveAreaVersion)));
2390	>
2391	>	gChargedIso = fChargedIso;
2392	>	gGammaIso = fGammaIso;
2393	>	gNeutralIso = fNeutralHadronIso;
2394	>
2395	>	return pfIso;
2396	>	}
2397	>
2398	>	//--------------------------------------------------------------------------------------------------
2399	>	// hacked version
2400	>	float electronPFIso04(ControlFlags &ctrl,
2401	>	const mithep::Electron * ele,
2402	>	const mithep::Vertex & vtx,
2403	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2404	>	float rho,
2405	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2406	>	vector<const mithep::Muon*> muonsToVeto,
2407	>	vector<const mithep::Electron*> electronsToVeto)
2408	>	//--------------------------------------------------------------------------------------------------
2409	>	{
2410	>
2411	>	if( ctrl.debug ) {
2412	>	cout << "electronIsoMVASelection :: muons to veto " << endl;
2413	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
2414	>	const mithep::Muon * vmu = muonsToVeto[i];
2415	>	cout << "\tpt: " << vmu->Pt()
2416	>	<< "\teta: " << vmu->Eta()
2417	>	<< "\tphi: " << vmu->Phi()
2418	>	<< endl;
2419	>	}
2420	>	cout << "electronIsoMVASelection :: electrons to veto " << endl;
2421	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
2422	>	const mithep::Electron * vel = electronsToVeto[i];
2423	>	cout << "\tpt: " << vel->Pt()
2424	>	<< "\teta: " << vel->Eta()
2425	>	<< "\tphi: " << vel->Phi()
2426	>	<< "\ttrk: " << vel->TrackerTrk()
2427	>	<< endl;
2428	>	}
2429	>	}
2430	>
2431	>
2432	>	//
2433	>	// final iso
2434	>	//
2435	>	Double_t fChargedIso = 0.0;
2436	>	Double_t fGammaIso = 0.0;
2437	>	Double_t fNeutralHadronIso = 0.0;
2438	>
2439	>
2440	>	//
2441	>	//Loop over PF Candidates
2442	>	//
2443	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2444	>
2445	>
2446	>	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2447	>	Double_t deta = (ele->Eta() - pf->Eta());
2448	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2449	>	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2450	>
2451	>	if (dr > 0.4) continue;
2452	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2453	>
2454	>	if(ctrl.debug) {
2455	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2456	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx)
2457	>	<< "\ttrk: " << pf->HasTrackerTrk()
2458	>	<< "\tgsf: " << pf->HasGsfTrk();
2459	>
2460	>	cout << endl;
2461	>	}
2462	>
2463	>
2464	>	//
2465	>	// sync : I don't think theyre doing this ...
2466	>	//
2467	>	//     if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
2468	>	//   (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2469	>	//       if( ctrl.debug ) cout << "\tskipping, matches to the electron ..."  << endl;
2470	>	//       continue;
2471	>	//     }
2472	>
2473	>
2474	>	//
2475	>	// Lepton Footprint Removal
2476	>	//
2477	>	Bool_t IsLeptonFootprint = kFALSE;
2478	>	if (dr < 1.0) {
2479	>
2480	>	//
2481	>	// Check for electrons
2482	>	//
2483	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2484	>	const mithep::Electron *tmpele = electronsToVeto[q];
2485	>	/*
2486	>	// 4l electron
2487	>	if( pf->HasTrackerTrk()  ) {
2488	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
2489	>	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
2490	>	IsLeptonFootprint = kTRUE;
2491	>	}
2492	>	}
2493	>	if( pf->HasGsfTrk()  ) {
2494	>	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
2495	>	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
2496	>	IsLeptonFootprint = kTRUE;
2497	>	}
2498	>	}
2499	>	*/
2500	>	// PF charged
2501	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2502	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
2503	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
2504	>	IsLeptonFootprint = kTRUE;
2505	>	}
2506	>	// PF gamma
2507	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
2508	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
2509	>	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
2510	>	IsLeptonFootprint = kTRUE;
2511	>	}
2512	>	} // loop over electrons
2513	>
2514	>	/* KH - comment for sync
2515	>	//
2516	>	// Check for muons
2517	>	//
2518	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
2519	>	const mithep::Muon *tmpmu = muonsToVeto[q];
2520	>	// 4l muon
2521	>	if( pf->HasTrackerTrk() ) {
2522	>	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
2523	>	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
2524	>	IsLeptonFootprint = kTRUE;
2525	>	}
2526	>	}
2527	>	// PF charged
2528	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
2529	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
2530	>	IsLeptonFootprint = kTRUE;
2531	>	}
2532	>	} // loop over muons
2533	>	*/
2534	>
2535	>	if (IsLeptonFootprint)
2536	>	continue;
2537	>
2538	>	//
2539	>	// Charged Iso
2540	>	//
2541	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
2542	>
2543	>	//       if( pf->HasTrackerTrk() )
2544	>	//      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2545	>	//       if( pf->HasGsfTrk() )
2546	>	//      if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2547	>
2548	>	// Veto any PFmuon, or PFEle
2549	>	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) {
2550	>	cout << "\t skipping, pf is and ele or mu .." <<endl;
2551	>	continue;
2552	>	}
2553	>
2554	>	// Footprint Veto
2555	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
2556	>
2557	>	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
2558	>	<< "\ttype: " << pf->PFType()
2559	>	<< "\ttrk: " << pf->TrackerTrk() << endl;
2560	>
2561	>	fChargedIso += pf->Pt();
2562	>	}
2563	>
2564	>	//
2565	>	// Gamma Iso
2566	>	//
2567	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2568	>
2569	>	if (fabs(ele->SCluster()->Eta()) > 1.479) {
2570	>	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
2571	>	}
2572	>	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2573	>	<< dr << endl;
2574	>	// KH, add to sync
2575	>	//      if( pf->Pt() > 0.5 )
2576	>	fGammaIso += pf->Pt();
2577	>	}
2578	>
2579	>	//
2580	>	// Neutral Iso
2581	>	//
2582	>	else {
2583	>	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2584	>	<< dr << endl;
2585	>	// KH, add to sync
2586	>	//      if( pf->Pt() > 0.5 )
2587	>	fNeutralHadronIso += pf->Pt();
2588	>	}
2589	>
2590	>	}
2591	>
2592	>	}
2593	>
2594	>	//   double rho = 0;
2595	>	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
2596	>	//     rho = fPUEnergyDensity->At(0)->Rho();
2597	>
2598	>	// WARNING!!!!
2599	>	// hardcode for sync ...
2600	>	EffectiveAreaVersion = eleT.kEleEAData2011;
2601	>	// WARNING!!!!
2602	>
2603	>
2604	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2605	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2606	>	ele->Eta(),EffectiveAreaVersion)));
2607	>
2608	>
2609	>	gChargedIso = fChargedIso;
2610	>	gGammaIso = fGammaIso;
2611	>	gNeutralIso = fNeutralHadronIso;
2612	>	return pfIso;
2613	>	}
2614	>
2615	>
2616	>	//--------------------------------------------------------------------------------------------------
2617	>	SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2618	>	const mithep::Electron * ele,
2619	>	const mithep::Vertex & vtx,
2620	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2621	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2622	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2623	>	vector<const mithep::Muon*> muonsToVeto,
2624	>	vector<const mithep::Electron*> electronsToVeto)
2625	>	//--------------------------------------------------------------------------------------------------
2626	>	{
2627	>
2628	>	SelectionStatus status;
2629	>
2630	>	double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, fPUEnergyDensity,
2631	>	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2632	>	//  cout << "--------------> setting electron isoPF04 to " << pfIso << endl;
2633	>	status.isoPF04 = pfIso;
2634	>	status.chisoPF04 = gChargedIso;
2635	>	status.gaisoPF04 = gGammaIso;
2636	>	status.neisoPF04 = gNeutralIso;
2637	>
2638	>	bool pass = false;
2639	>	if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2640	>
2641	>	if( pass ) {
2642	>	status.orStatus(SelectionStatus::LOOSEISO);
2643	>	status.orStatus(SelectionStatus::TIGHTISO);
2644	>	}
2645	>	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2646	>	return status;
2647	>
2648	>	}
2649	>
2650	>
2651	>	//--------------------------------------------------------------------------------------------------
2652	>	// hacked version
2653	>	SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2654	>	const mithep::Electron * ele,
2655	>	const mithep::Vertex & vtx,
2656	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2657	>	float rho,
2658	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2659	>	vector<const mithep::Muon*> muonsToVeto,
2660	>	vector<const mithep::Electron*> electronsToVeto)
2661	>	//--------------------------------------------------------------------------------------------------
2662	>	{
2663	>
2664	>	SelectionStatus status;
2665	>
2666	>	double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, rho,
2667	>	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2668	>	status.isoPF04 = pfIso;
2669	>	status.chisoPF04 = gChargedIso;
2670	>	status.gaisoPF04 = gGammaIso;
2671	>	status.neisoPF04 = gNeutralIso;
2672	>	bool pass = false;
2673	>	if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2674	>
2675	>	if( pass ) {
2676	>	status.orStatus(SelectionStatus::LOOSEISO);
2677	>	status.orStatus(SelectionStatus::TIGHTISO);
2678		}
2679		if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2680		return status;

Diff Legend

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