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

Diff Legend

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