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.1 by khahn, Mon Feb 13 09:35:20 2012 UTC vs.
Revision 1.26 by anlevin, Mon May 28 12:37:10 2012 UTC

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

Diff Legend

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