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.14 by khahn, Thu May 10 11:14:33 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	>	//--------------------------------------------------------------------------------------------------
20	>	Float_t computePFMuonIso(const mithep::Muon *muon,
21	>	const mithep::Vertex & vtx,
22	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
23	>	const Double_t dRMax)
24	>	//--------------------------------------------------------------------------------------------------
25	>	{
26	>	const Double_t dRMin    = 0;
27	>	const Double_t neuPtMin = 1.0;
28	>	const Double_t dzMax    = 0.1;
29	>
30	>	Double_t zLepton = (muon->BestTrk()) ? muon->BestTrk()->DzCorrected(vtx) : 0.0;
31	>
32	>	Float_t iso=0;
33	>	for(UInt_t ipf=0; ipf<fPFCandidates->GetEntries(); ipf++) {
34	>	const PFCandidate *pfcand = fPFCandidates->At(ipf);
35	>
36	>	if(!pfcand->HasTrk() && (pfcand->Pt()<=neuPtMin)) continue;  // pT cut on neutral particles
37	>
38	>	// exclude THE muon
39	>	if(pfcand->TrackerTrk() && muon->TrackerTrk() && (pfcand->TrackerTrk()==muon->TrackerTrk())) continue;
40	>
41	>	// dz cut
42	>	Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(vtx) - zLepton) : 0;
43	>	if(dz >= dzMax) continue;
44	>
45	>	// check iso cone
46	>	Double_t dr = MathUtils::DeltaR(muon->Mom(), pfcand->Mom());
47	>	if(dr<dRMax && dr>=dRMin)
48	>	iso += pfcand->Pt();
49	>	}
50	>
51	>	return iso;
52	>	}
53	>
54	>	//--------------------------------------------------------------------------------------------------
55	>	Float_t computePFEleIso(const mithep::Electron *electron,
56	>	const mithep::Vertex & fVertex,
57	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
58	>	const Double_t dRMax)
59	>	//--------------------------------------------------------------------------------------------------
60	>	{
61	>	const Double_t dRMin    = 0;
62	>	const Double_t neuPtMin = 1.0;
63	>	const Double_t dzMax    = 0.1;
64	>
65	>	Double_t zLepton = (electron->BestTrk()) ? electron->BestTrk()->DzCorrected(fVertex) : 0.0;
66	>
67	>	Float_t iso=0;
68	>	for(UInt_t ipf=0; ipf<fPFCandidates->GetEntries(); ipf++) {
69	>	const PFCandidate *pfcand = (PFCandidate*)(fPFCandidates->At(ipf));
70	>
71	>	if(!pfcand->HasTrk() && (pfcand->Pt()<=neuPtMin)) continue;  // pT cut on neutral particles
72	>
73	>	// dz cut
74	>	Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(fVertex) - zLepton) : 0;
75	>	if(dz >= dzMax) continue;
76	>
77	>	// remove THE electron
78	>	if(pfcand->TrackerTrk() && electron->TrackerTrk() && (pfcand->TrackerTrk()==electron->TrackerTrk())) continue;
79	>	if(pfcand->GsfTrk()     && electron->GsfTrk()     && (pfcand->GsfTrk()==electron->GsfTrk()))         continue;
80	>
81	>	// check iso cone
82	>	Double_t dr = MathUtils::DeltaR(electron->Mom(), pfcand->Mom());
83	>	if(dr<dRMax && dr>=dRMin) {
84	>	// eta-strip veto for photons
85	>	if((pfcand->PFType() == PFCandidate::eGamma) && fabs(electron->Eta() - pfcand->Eta()) < 0.025) continue;
86	>
87	>	// Inner cone (one tower = dR < 0.07) veto for non-photon neutrals
88	>	if(!pfcand->HasTrk() && (pfcand->PFType() == PFCandidate::eNeutralHadron) &&
89	>	(MathUtils::DeltaR(electron->Mom(), pfcand->Mom()) < 0.07)) continue;
90	>
91	>	iso += pfcand->Pt();
92	>	}
93	>	}
94	>
95	>	return iso;
96	>	};
97	>
98	>	//--------------------------------------------------------------------------------------------------
99	>	bool pairwiseIsoSelection( ControlFlags &ctrl,
100	>	vector<SimpleLepton> &lepvec,
101	>	float rho )
102	>	//--------------------------------------------------------------------------------------------------
103	>	{
104	>
105	>	bool passiso=true;
106	>
107	>	for( int i=0; i<lepvec.size(); i++ )
108	>	{
109	>
110	>	if( !(lepvec[i].is4l) ) continue;
111	>
112	>	float effArea_ecal_i, effArea_hcal_i;
113	>	if( lepvec[i].isEB ) {
114	>	if( lepvec[i].type == 11 ) {
115	>	effArea_ecal_i = 0.101;
116	>	effArea_hcal_i = 0.021;
117	>	} else {
118	>	effArea_ecal_i = 0.074;
119	>	effArea_hcal_i = 0.022;
120	>	}
121	>	} else {
122	>	if( lepvec[i].type == 11 ) {
123	>	effArea_ecal_i = 0.046;
124	>	effArea_hcal_i = 0.040;
125	>	} else {
126	>	effArea_ecal_i = 0.045;
127	>	effArea_hcal_i = 0.030;
128	>	}
129	>	}
130	>
131	>	float isoEcal_corr_i = lepvec[i].isoEcal - (effArea_ecal_i*rho);
132	>	float isoHcal_corr_i = lepvec[i].isoHcal - (effArea_hcal_i*rho);
133	>
134	>	for( int j=i+1; j<lepvec.size(); j++ )
135	>	{
136	>
137	>	if( !(lepvec[j].is4l) ) continue;
138	>
139	>	float effArea_ecal_j, effArea_hcal_j;
140	>	if( lepvec[j].isEB ) {
141	>	if( lepvec[j].type == 11 ) {
142	>	effArea_ecal_j = 0.101;
143	>	effArea_hcal_j = 0.021;
144	>	} else {
145	>	effArea_ecal_j = 0.074;
146	>	effArea_hcal_j = 0.022;
147	>	}
148	>	} else {
149	>	if( lepvec[j].type == 11 ) {
150	>	effArea_ecal_j = 0.046;
151	>	effArea_hcal_j = 0.040;
152	>	} else {
153	>	effArea_ecal_j = 0.045;
154	>	effArea_hcal_j = 0.030;
155	>	}
156	>	}
157	>
158	>	float isoEcal_corr_j = lepvec[j].isoEcal - (effArea_ecal_j*rho);
159	>	float isoHcal_corr_j = lepvec[j].isoHcal - (effArea_hcal_j*rho);
160	>	float RIso_i = (lepvec[i].isoTrk+isoEcal_corr_i+isoHcal_corr_i)/lepvec[i].vec.Pt();
161	>	float RIso_j = (lepvec[j].isoTrk+isoEcal_corr_j+isoHcal_corr_j)/lepvec[j].vec.Pt();
162	>	float comboIso = RIso_i + RIso_j;
163	>
164	>	if( comboIso > 0.35 ) {
165	>	if( ctrl.debug ) cout << "combo failing for indices: " << i << "," << j << endl;
166	>	passiso = false;
167	>	return passiso;
168	>	}
169	>	}
170	>	}
171	>
172	>	return passiso;
173	>	}
174	>
175	>	//--------------------------------------------------------------------------------------------------
176	>	SelectionStatus muonIsoSelection(ControlFlags &ctrl,
177	>	const mithep::Muon * mu,
178	>	const mithep::Vertex & vtx,
179	>	const mithep::Array<mithep::PFCandidate> * fPFCandidateCol   )
180	>	//--------------------------------------------------------------------------------------------------
181	>	{
182	>	float reliso = computePFMuonIso(mu,vtx,fPFCandidateCol,0.3)/mu->Pt();
183	>	bool isEB = (fabs(mu->Eta()) < 1.479 ? 1 : 0 );
184		bool failiso = false;
185	<	if( isEB && mu->pt > 20 && reliso > PFISO_MU_LOOSE_EB_HIGHPT ) {
185	>	if( isEB && mu->Pt() > 20 && reliso > PFISO_MU_LOOSE_EB_HIGHPT ) {
186		failiso = true;
187		}
188	<	if( isEB && mu->pt < 20 && reliso > PFISO_MU_LOOSE_EB_LOWPT ) {
188	>	if( isEB && mu->Pt() < 20 && reliso > PFISO_MU_LOOSE_EB_LOWPT ) {
189		failiso = true;
190		}
191	<	if( !(isEB) && mu->pt > 20 && reliso > PFISO_MU_LOOSE_EE_HIGHPT ) {
191	>	if( !(isEB) && mu->Pt() > 20 && reliso > PFISO_MU_LOOSE_EE_HIGHPT ) {
192		failiso = true;
193		}
194	<	if( !(isEB) && mu->pt < 20 && reliso > PFISO_MU_LOOSE_EE_LOWPT ) {
194	>	if( !(isEB) && mu->Pt() < 20 && reliso > PFISO_MU_LOOSE_EE_LOWPT ) {
195		failiso = true;
196		}
197
#	Line 28 | Line 202 | SelectionStatus passMuonIsoSelection( Co
202
203		};
204
205	<
206	<	SelectionStatus failEleIso(ControlFlags &ctrl, const mithep::TElectron * ele) {
205	>	//--------------------------------------------------------------------------------------------------
206	>	SelectionStatus electronIsoSelection(ControlFlags &ctrl,
207	>	const mithep::Electron * ele,
208	>	const mithep::Vertex &fVertex,
209	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates)
210	>	//--------------------------------------------------------------------------------------------------
211	>	{
212
213		bool failiso=false;
214
215	<	float reliso = ele->pfIso04/ele->pt;
216	<	bool isEB = (fabs(ele->eta) < 1.479 ? 1 : 0 );
217	<	if( isEB && ele->pt > 20 && reliso > PFISO_ELE_LOOSE_EB_HIGHPT ) {
215	>	float reliso = computePFEleIso(ele,fVertex,fPFCandidates,0.4)/ele->Pt();
216	>
217	>	if( ele->IsEB() && ele->Pt() > 20 && reliso > PFISO_ELE_LOOSE_EB_HIGHPT ) {
218		failiso = true;
219		}
220	<	if( isEB && ele->pt < 20 && reliso > PFISO_ELE_LOOSE_EB_LOWPT ) {
220	>	if( ele->IsEB() && ele->Pt() < 20 && reliso > PFISO_ELE_LOOSE_EB_LOWPT ) {
221		failiso = true;
222		}
223		if(ctrl.debug) cout << "before iso check ..." << endl;
224	<	if( !(isEB) && ele->pt > 20 && reliso > PFISO_ELE_LOOSE_EE_HIGHPT ) {
224	>	if( !(ele->IsEB()) && ele->Pt() > 20 && reliso > PFISO_ELE_LOOSE_EE_HIGHPT ) {
225		if(ctrl.debug) cout << "\tit fails ..." << endl;
226		failiso = true;
227		}
228	<	if( !(isEB) && ele->pt < 20 && reliso > PFISO_ELE_LOOSE_EE_LOWPT ) {
228	>	if( !(ele->IsEB()) && ele->Pt() < 20 && reliso > PFISO_ELE_LOOSE_EE_LOWPT ) {
229		failiso = true;
230		}
231
232		SelectionStatus status;
233		if( !failiso ) {
234	<	status.setStatus(SelectionStatus::LOOSEISO);
235	<	status.setStatus(SelectionStatus::TIGHTISO);
234	>	status.orStatus(SelectionStatus::LOOSEISO);
235	>	status.orStatus(SelectionStatus::TIGHTISO);
236	>	}
237	>	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
238	>	return status;
239	>
240	>	}
241	>
242	>
243	>	bool noIso(ControlFlags &, vector<SimpleLepton> &, float rho) {
244	>
245	>	return true;
246	>	}
247	>
248	>	//--------------------------------------------------------------------------------------------------
249	>	SelectionStatus muonIsoMVASelection(ControlFlags &ctrl,
250	>	const mithep::Muon * mu,
251	>	const mithep::Vertex & vtx,
252	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
253	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
254	>	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
255	>	vector<const mithep::Muon*> muonsToVeto,
256	>	vector<const mithep::Electron*> electronsToVeto)
257	>	//--------------------------------------------------------------------------------------------------
258	>	{
259	>
260	>	if( ctrl.debug ) {
261	>	cout << "muonIsoMVASelection :: muons to veto " << endl;
262	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
263	>	const mithep::Muon * vmu = muonsToVeto[i];
264	>	cout << "\tpt: " << vmu->Pt()
265	>	<< "\teta: " << vmu->Eta()
266	>	<< "\tphi: " << vmu->Phi()
267	>	<< endl;
268	>	}
269	>	cout << "muonIsoMVASelection :: electrson to veto " << endl;
270	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
271	>	const mithep::Electron * vel = electronsToVeto[i];
272	>	cout << "\tpt: " << vel->Pt()
273	>	<< "\teta: " << vel->Eta()
274	>	<< "\tphi: " << vel->Phi()
275	>	<< endl;
276	>	}
277	>	}
278	>	bool failiso=false;
279	>
280	>	//
281	>	// tmp iso rings
282	>	//
283	>	Double_t tmpChargedIso_DR0p0To0p1  = 0;
284	>	Double_t tmpChargedIso_DR0p1To0p2  = 0;
285	>	Double_t tmpChargedIso_DR0p2To0p3  = 0;
286	>	Double_t tmpChargedIso_DR0p3To0p4  = 0;
287	>	Double_t tmpChargedIso_DR0p4To0p5  = 0;
288	>	Double_t tmpChargedIso_DR0p5To0p7  = 0;
289	>
290	>	Double_t tmpGammaIso_DR0p0To0p1  = 0;
291	>	Double_t tmpGammaIso_DR0p1To0p2  = 0;
292	>	Double_t tmpGammaIso_DR0p2To0p3  = 0;
293	>	Double_t tmpGammaIso_DR0p3To0p4  = 0;
294	>	Double_t tmpGammaIso_DR0p4To0p5  = 0;
295	>	Double_t tmpGammaIso_DR0p5To0p7  = 0;
296	>
297	>	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
298	>	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
299	>	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
300	>	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
301	>	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
302	>	Double_t tmpNeutralHadronIso_DR0p5To0p7  = 0;
303	>
304	>
305	>
306	>	//
307	>	// final rings for the MVA
308	>	//
309	>	Double_t fChargedIso_DR0p0To0p1;
310	>	Double_t fChargedIso_DR0p1To0p2;
311	>	Double_t fChargedIso_DR0p2To0p3;
312	>	Double_t fChargedIso_DR0p3To0p4;
313	>	Double_t fChargedIso_DR0p4To0p5;
314	>	Double_t fChargedIso_DR0p5To0p7;
315	>
316	>	Double_t fGammaIso_DR0p0To0p1;
317	>	Double_t fGammaIso_DR0p1To0p2;
318	>	Double_t fGammaIso_DR0p2To0p3;
319	>	Double_t fGammaIso_DR0p3To0p4;
320	>	Double_t fGammaIso_DR0p4To0p5;
321	>	Double_t fGammaIso_DR0p5To0p7;
322	>
323	>	Double_t fNeutralHadronIso_DR0p0To0p1;
324	>	Double_t fNeutralHadronIso_DR0p1To0p2;
325	>	Double_t fNeutralHadronIso_DR0p2To0p3;
326	>	Double_t fNeutralHadronIso_DR0p3To0p4;
327	>	Double_t fNeutralHadronIso_DR0p4To0p5;
328	>	Double_t fNeutralHadronIso_DR0p5To0p7;
329	>
330	>
331	>	//
332	>	//Loop over PF Candidates
333	>	//
334	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
335	>	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
336	>
337	>	Double_t deta = (mu->Eta() - pf->Eta());
338	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
339	>	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
340	>	if (dr > 1.0) continue;
341	>
342	>	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
343	>
344	>	//
345	>	// Lepton Footprint Removal
346	>	//
347	>	Bool_t IsLeptonFootprint = kFALSE;
348	>	if (dr < 1.0) {
349	>
350	>	//
351	>	// Check for electrons
352	>	//
353	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
354	>	const mithep::Electron *tmpele = electronsToVeto[q];
355	>	// 4l electron
356	>	if( pf->HasTrackerTrk() ) {
357	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
358	>	IsLeptonFootprint = kTRUE;
359	>	}
360	>	if( pf->HasGsfTrk() ) {
361	>	if( pf->GsfTrk() == tmpele->GsfTrk() )
362	>	IsLeptonFootprint = kTRUE;
363	>	}
364	>	// PF charged
365	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
366	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
367	>	IsLeptonFootprint = kTRUE;
368	>	// PF gamma
369	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
370	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
371	>	IsLeptonFootprint = kTRUE;
372	>	} // loop over electrons
373	>
374	>	/* KH - commented for sync
375	>	//
376	>	// Check for muons
377	>	//
378	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
379	>	const mithep::Muon *tmpmu = muonsToVeto[q];
380	>	// 4l muon
381	>	if( pf->HasTrackerTrk() ) {
382	>	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
383	>	IsLeptonFootprint = kTRUE;
384	>	}
385	>	// PF charged
386	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
387	>	IsLeptonFootprint = kTRUE;
388	>	} // loop over muons
389	>	*/
390	>
391	>	if (IsLeptonFootprint)
392	>	continue;
393	>
394	>	//
395	>	// Charged Iso Rings
396	>	//
397	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
398	>
399	>	if( dr < 0.01 ) continue; // only for muon iso mva?
400	>	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
401	>
402	>	if( pf->HasTrackerTrk() ) {
403	>	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
404	>	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
405	>	<< abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
406	>	<< dr << endl;
407	>	}
408	>	if( pf->HasGsfTrk() ) {
409	>	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
410	>	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
411	>	<< abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
412	>	<< dr << endl;
413	>	}
414	>
415	>	// Footprint Veto
416	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
417	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
418	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
419	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
420	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
421	>	if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
422	>	}
423	>
424	>	//
425	>	// Gamma Iso Rings
426	>	//
427	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
428	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
429	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
430	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
431	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
432	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
433	>	if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
434	>	}
435	>
436	>	//
437	>	// Other Neutral Iso Rings
438	>	//
439	>	else {
440	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
441	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
442	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
443	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
444	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
445	>	if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
446	>	}
447	>
448	>	}
449	>
450	>	}
451	>
452	>	fChargedIso_DR0p0To0p1   = min((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
453	>	fChargedIso_DR0p1To0p2   = min((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
454	>	fChargedIso_DR0p2To0p3   = min((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
455	>	fChargedIso_DR0p3To0p4   = min((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
456	>	fChargedIso_DR0p4To0p5   = min((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
457	>
458	>
459	>	double rho = 0;
460	>	if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
461	>	rho = fPUEnergyDensity->At(0)->Rho();
462	>
463	>
464	>	fGammaIso_DR0p0To0p1 = max(min((tmpGammaIso_DR0p0To0p1
465	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p0To0p1,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
466	>	,2.5)
467	>	,0.0);
468	>	fGammaIso_DR0p1To0p2 = max(min((tmpGammaIso_DR0p1To0p2
469	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p1To0p2,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
470	>	,2.5)
471	>	,0.0);
472	>	fGammaIso_DR0p2To0p3 = max(min((tmpGammaIso_DR0p2To0p3
473	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p2To0p3,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
474	>	,2.5)
475	>	,0.0);
476	>	fGammaIso_DR0p3To0p4 = max(min((tmpGammaIso_DR0p3To0p4
477	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p3To0p4,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
478	>	,2.5)
479	>	,0.0);
480	>	fGammaIso_DR0p4To0p5 = max(min((tmpGammaIso_DR0p4To0p5
481	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p4To0p5,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
482	>	,2.5)
483	>	,0.0);
484	>
485	>
486	>
487	>	fNeutralHadronIso_DR0p0To0p1 = max(min((tmpNeutralHadronIso_DR0p0To0p1
488	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p0To0p1,
489	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
490	>	, 2.5)
491	>	, 0.0);
492	>	fNeutralHadronIso_DR0p1To0p2 = max(min((tmpNeutralHadronIso_DR0p1To0p2
493	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p1To0p2,
494	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
495	>	, 2.5)
496	>	, 0.0);
497	>	fNeutralHadronIso_DR0p2To0p3 = max(min((tmpNeutralHadronIso_DR0p2To0p3
498	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p2To0p3,
499	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
500	>	, 2.5)
501	>	, 0.0);
502	>	fNeutralHadronIso_DR0p3To0p4 = max(min((tmpNeutralHadronIso_DR0p3To0p4
503	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p3To0p4,
504	>	mu->Eta(), EffectiveAreaVersion))/mu->Pt()
505	>	, 2.5)
506	>	, 0.0);
507	>	fNeutralHadronIso_DR0p4To0p5 = max(min((tmpNeutralHadronIso_DR0p4To0p5
508	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p4To0p5,
509	>	mu->Eta(), EffectiveAreaVersion))/mu->Pt()
510	>	, 2.5)
511	>	, 0.0);
512	>
513	>
514	>	double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
515	>	mu->Eta(),
516	>	fChargedIso_DR0p0To0p1,
517	>	fChargedIso_DR0p1To0p2,
518	>	fChargedIso_DR0p2To0p3,
519	>	fChargedIso_DR0p3To0p4,
520	>	fChargedIso_DR0p4To0p5,
521	>	fGammaIso_DR0p0To0p1,
522	>	fGammaIso_DR0p1To0p2,
523	>	fGammaIso_DR0p2To0p3,
524	>	fGammaIso_DR0p3To0p4,
525	>	fGammaIso_DR0p4To0p5,
526	>	fNeutralHadronIso_DR0p0To0p1,
527	>	fNeutralHadronIso_DR0p1To0p2,
528	>	fNeutralHadronIso_DR0p2To0p3,
529	>	fNeutralHadronIso_DR0p3To0p4,
530	>	fNeutralHadronIso_DR0p4To0p5,
531	>	ctrl.debug);
532	>
533	>	SelectionStatus status;
534	>	bool pass;
535	>
536	>	pass = false;
537	>	if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
538	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN0)   pass = true;
539	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
540	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN1)  pass = true;
541	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
542	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN2)  pass = true;
543	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
544	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN3)  pass = true;
545	>	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN4)  pass = true;
546	>	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN5)  pass = true;
547	>	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
548	>
549	>	pass = false;
550	>	if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
551	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN0)   pass = true;
552	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
553	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN1)  pass = true;
554	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
555	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN2)  pass = true;
556	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
557	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN3)  pass = true;
558	>	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN4)  pass = true;
559	>	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN5)  pass = true;
560	>	if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
561	>
562	>	//  pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
563	>
564	>	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
565	>	return status;
566	>
567	>	}
568	>
569	>	//--------------------------------------------------------------------------------------------------
570	>	void initMuonIsoMVA() {
571	>	//--------------------------------------------------------------------------------------------------
572	>	muIsoMVA = new mithep::MuonIDMVA();
573	>	vector<string> weightFiles;
574	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_barrel_lowpt.weights.xml");
575	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_barrel_highpt.weights.xml");
576	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_endcap_lowpt.weights.xml");
577	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_endcap_highpt.weights.xml");
578	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_tracker.weights.xml");
579	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_global.weights.xml");
580	>	muIsoMVA->Initialize( "MuonIsoMVA",
581	>	mithep::MuonIDMVA::kIsoRingsV0,
582	>	kTRUE, weightFiles);
583	>	}
584	>
585	>
586	>	//--------------------------------------------------------------------------------------------------
587	>	double  muonPFIso04(ControlFlags &ctrl,
588	>	const mithep::Muon * mu,
589	>	const mithep::Vertex & vtx,
590	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
591	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
592	>	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
593	>	vector<const mithep::Muon*> muonsToVeto,
594	>	vector<const mithep::Electron*> electronsToVeto)
595	>	//--------------------------------------------------------------------------------------------------
596	>	{
597	>
598	>	if( ctrl.debug ) {
599	>	cout << "muonIsoMVASelection :: muons to veto " << endl;
600	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
601	>	const mithep::Muon * vmu = muonsToVeto[i];
602	>	cout << "\tpt: " << vmu->Pt()
603	>	<< "\teta: " << vmu->Eta()
604	>	<< "\tphi: " << vmu->Phi()
605	>	<< endl;
606	>	}
607	>	cout << "muonIsoMVASelection :: electrson to veto " << endl;
608	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
609	>	const mithep::Electron * vel = electronsToVeto[i];
610	>	cout << "\tpt: " << vel->Pt()
611	>	<< "\teta: " << vel->Eta()
612	>	<< "\tphi: " << vel->Phi()
613	>	<< endl;
614	>	}
615	>	}
616	>
617	>	//
618	>	// final iso
619	>	//
620	>	Double_t fChargedIso  = 0.0;
621	>	Double_t fGammaIso  = 0.0;
622	>	Double_t fNeutralHadronIso  = 0.0;
623	>
624	>	//
625	>	//Loop over PF Candidates
626	>	//
627	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
628	>	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
629	>
630	>	Double_t deta = (mu->Eta() - pf->Eta());
631	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
632	>	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
633	>	if (dr > 0.4) continue;
634	>
635	>	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
636	>
637	>	//
638	>	// Lepton Footprint Removal
639	>	//
640	>	Bool_t IsLeptonFootprint = kFALSE;
641	>	if (dr < 1.0) {
642	>
643	>	//
644	>	// Check for electrons
645	>	//
646	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
647	>	const mithep::Electron *tmpele = electronsToVeto[q];
648	>	// 4l electron
649	>	if( pf->HasTrackerTrk() ) {
650	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
651	>	IsLeptonFootprint = kTRUE;
652	>	}
653	>	if( pf->HasGsfTrk() ) {
654	>	if( pf->GsfTrk() == tmpele->GsfTrk() )
655	>	IsLeptonFootprint = kTRUE;
656	>	}
657	>	// PF charged
658	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
659	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
660	>	IsLeptonFootprint = kTRUE;
661	>	// PF gamma
662	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
663	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
664	>	IsLeptonFootprint = kTRUE;
665	>	} // loop over electrons
666	>
667	>	/* KH - comment for sync
668	>	//
669	>	// Check for muons
670	>	//
671	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
672	>	const mithep::Muon *tmpmu = muonsToVeto[q];
673	>	// 4l muon
674	>	if( pf->HasTrackerTrk() ) {
675	>	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
676	>	IsLeptonFootprint = kTRUE;
677	>	}
678	>	// PF charged
679	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
680	>	IsLeptonFootprint = kTRUE;
681	>	} // loop over muons
682	>	*/
683	>
684	>	if (IsLeptonFootprint)
685	>	continue;
686	>
687	>	//
688	>	// Charged Iso
689	>	//
690	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
691	>
692	>	if( dr < 0.01 ) continue; // only for muon iso mva?
693	>	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
694	>
695	>	if( pf->HasTrackerTrk() ) {
696	>	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
697	>	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
698	>	<< abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
699	>	<< dr << endl;
700	>	}
701	>	if( pf->HasGsfTrk() ) {
702	>	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
703	>	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
704	>	<< abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
705	>	<< dr << endl;
706	>	}
707	>
708	>
709	>	fChargedIso += pf->Pt();
710	>	}
711	>
712	>	//
713	>	// Gamma Iso
714	>	//
715	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
716	>	fGammaIso += pf->Pt();
717	>	}
718	>
719	>	//
720	>	// Other Neutrals
721	>	//
722	>	else {
723	>	// KH, add to sync
724	>	if( pf->Pt() > 0.5 )
725	>	fNeutralHadronIso += pf->Pt();
726	>	}
727	>
728	>	}
729	>
730	>	}
731	>
732	>	double rho = 0;
733	>	if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
734	>	rho = fPUEnergyDensity->At(0)->Rho();
735	>
736	>	// WARNING!!!!
737	>	// hardcode for sync ...
738	>	EffectiveAreaVersion = muT.kMuEAData2011;
739	>	// WARNING!!!!
740	>
741	>
742	>	double pfIso = fChargedIso + max(0.0,(fGammaIso + fNeutralHadronIso
743	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
744	>	mu->Eta(),EffectiveAreaVersion)));
745	>
746	>	return pfIso;
747	>	}
748	>
749	>	//--------------------------------------------------------------------------------------------------
750	>	SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
751	>	const mithep::Muon * mu,
752	>	const mithep::Vertex & vtx,
753	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
754	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
755	>	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
756	>	vector<const mithep::Muon*> muonsToVeto,
757	>	vector<const mithep::Electron*> electronsToVeto)
758	>	//--------------------------------------------------------------------------------------------------
759	>	{
760	>
761	>	SelectionStatus status;
762	>
763	>	double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, fPUEnergyDensity,
764	>	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
765	>	bool pass = false;
766	>	if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
767	>
768	>	if( pass ) {
769	>	status.orStatus(SelectionStatus::LOOSEISO);
770	>	status.orStatus(SelectionStatus::TIGHTISO);
771	>	}
772	>	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
773	>	return status;
774	>
775	>	}
776	>
777	>
778	>
779	>	//--------------------------------------------------------------------------------------------------
780	>	SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
781	>	const mithep::Electron * ele,
782	>	const mithep::Vertex & vtx,
783	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
784	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
785	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
786	>	vector<const mithep::Muon*> muonsToVeto,
787	>	vector<const mithep::Electron*> electronsToVeto)
788	>	//--------------------------------------------------------------------------------------------------
789	>	{
790	>
791	>	if( ctrl.debug ) {
792	>	cout << "electronIsoMVASelection :: muons to veto " << endl;
793	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
794	>	const mithep::Muon * vmu = muonsToVeto[i];
795	>	cout << "\tpt: " << vmu->Pt()
796	>	<< "\teta: " << vmu->Eta()
797	>	<< "\tphi: " << vmu->Phi()
798	>	<< endl;
799	>	}
800	>	cout << "electronIsoMVASelection :: electrson to veto " << endl;
801	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
802	>	const mithep::Electron * vel = electronsToVeto[i];
803	>	cout << "\tpt: " << vel->Pt()
804	>	<< "\teta: " << vel->Eta()
805	>	<< "\tphi: " << vel->Phi()
806	>	<< "\ttrk: " << vel->TrackerTrk()
807	>	<< endl;
808	>	}
809	>	}
810	>
811	>	bool failiso=false;
812	>
813	>	//
814	>	// tmp iso rings
815	>	//
816	>	Double_t tmpChargedIso_DR0p0To0p1  = 0;
817	>	Double_t tmpChargedIso_DR0p1To0p2  = 0;
818	>	Double_t tmpChargedIso_DR0p2To0p3  = 0;
819	>	Double_t tmpChargedIso_DR0p3To0p4  = 0;
820	>	Double_t tmpChargedIso_DR0p4To0p5  = 0;
821	>	Double_t tmpChargedIso_DR0p5To0p7  = 0;
822	>
823	>	Double_t tmpGammaIso_DR0p0To0p1  = 0;
824	>	Double_t tmpGammaIso_DR0p1To0p2  = 0;
825	>	Double_t tmpGammaIso_DR0p2To0p3  = 0;
826	>	Double_t tmpGammaIso_DR0p3To0p4  = 0;
827	>	Double_t tmpGammaIso_DR0p4To0p5  = 0;
828	>	Double_t tmpGammaIso_DR0p5To0p7  = 0;
829	>
830	>	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
831	>	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
832	>	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
833	>	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
834	>	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
835	>	Double_t tmpNeutralHadronIso_DR0p5To0p7  = 0;
836	>
837	>
838	>
839	>	//
840	>	// final rings for the MVA
841	>	//
842	>	Double_t fChargedIso_DR0p0To0p1;
843	>	Double_t fChargedIso_DR0p1To0p2;
844	>	Double_t fChargedIso_DR0p2To0p3;
845	>	Double_t fChargedIso_DR0p3To0p4;
846	>	Double_t fChargedIso_DR0p4To0p5;
847	>
848	>	Double_t fGammaIso_DR0p0To0p1;
849	>	Double_t fGammaIso_DR0p1To0p2;
850	>	Double_t fGammaIso_DR0p2To0p3;
851	>	Double_t fGammaIso_DR0p3To0p4;
852	>	Double_t fGammaIso_DR0p4To0p5;
853	>
854	>	Double_t fNeutralHadronIso_DR0p0To0p1;
855	>	Double_t fNeutralHadronIso_DR0p1To0p2;
856	>	Double_t fNeutralHadronIso_DR0p2To0p3;
857	>	Double_t fNeutralHadronIso_DR0p3To0p4;
858	>	Double_t fNeutralHadronIso_DR0p4To0p5;
859	>
860	>
861	>	//
862	>	//Loop over PF Candidates
863	>	//
864	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
865	>	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
866	>	Double_t deta = (ele->Eta() - pf->Eta());
867	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
868	>	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
869	>	if (dr >= 0.5) continue;
870	>	if(ctrl.debug) {
871	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
872	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
873	>	cout << endl;
874	>	}
875	>
876	>
877	>	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
878	>	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
879	>
880	>
881	>	//
882	>	// Lepton Footprint Removal
883	>	//
884	>	Bool_t IsLeptonFootprint = kFALSE;
885	>	if (dr < 1.0) {
886	>
887	>	//
888	>	// Check for electrons
889	>	//
890	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
891	>	const mithep::Electron *tmpele = electronsToVeto[q];
892	>	// 4l electron
893	>	if( pf->HasTrackerTrk()  ) {
894	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
895	>	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
896	>	IsLeptonFootprint = kTRUE;
897	>	}
898	>	}
899	>	if( pf->HasGsfTrk()  ) {
900	>	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
901	>	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
902	>	IsLeptonFootprint = kTRUE;
903	>	}
904	>	}
905	>	// PF charged
906	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
907	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
908	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
909	>	IsLeptonFootprint = kTRUE;
910	>	}
911	>	// PF gamma
912	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
913	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
914	>	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
915	>	IsLeptonFootprint = kTRUE;
916	>	}
917	>	} // loop over electrons
918	>
919	>	/* KH - comment for sync
920	>	//
921	>	// Check for muons
922	>	//
923	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
924	>	const mithep::Muon *tmpmu = muonsToVeto[q];
925	>	// 4l muon
926	>	if( pf->HasTrackerTrk() ) {
927	>	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
928	>	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
929	>	IsLeptonFootprint = kTRUE;
930	>	}
931	>	}
932	>	// PF charged
933	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
934	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
935	>	IsLeptonFootprint = kTRUE;
936	>	}
937	>	} // loop over muons
938	>	*/
939	>
940	>	if (IsLeptonFootprint)
941	>	continue;
942	>
943	>	//
944	>	// Charged Iso Rings
945	>	//
946	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
947	>
948	>	if( pf->HasTrackerTrk() )
949	>	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
950	>	if( pf->HasGsfTrk() )
951	>	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
952	>
953	>	// Veto any PFmuon, or PFEle
954	>	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
955	>
956	>	// Footprint Veto
957	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
958	>
959	>	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
960	>	<< "\ttype: " << pf->PFType()
961	>	<< "\ttrk: " << pf->TrackerTrk() << endl;
962	>
963	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
964	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
965	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
966	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
967	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
968	>	if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
969	>
970	>	}
971	>
972	>	//
973	>	// Gamma Iso Rings
974	>	//
975	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
976	>
977	>	if (fabs(ele->SCluster()->Eta()) > 1.479) {
978	>	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
979	>	}
980	>
981	>	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
982	>	<< dr << endl;
983	>
984	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
985	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
986	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
987	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
988	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
989	>	if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
990	>
991	>	}
992	>
993	>	//
994	>	// Other Neutral Iso Rings
995	>	//
996	>	else {
997	>	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
998	>	<< dr << endl;
999	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
1000	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
1001	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1002	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1003	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1004	>	if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
1005	>	}
1006	>
1007	>	}
1008	>
1009	>	}
1010	>
1011	>	fChargedIso_DR0p0To0p1   = min((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1012	>	fChargedIso_DR0p1To0p2   = min((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1013	>	fChargedIso_DR0p2To0p3   = min((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1014	>	fChargedIso_DR0p3To0p4   = min((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1015	>	fChargedIso_DR0p4To0p5   = min((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1016	>
1017	>	double rho = 0;
1018	>	if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1019	>	rho = fPUEnergyDensity->At(0)->Rho();
1020	>
1021	>	if( ctrl.debug) {
1022	>	cout << "RHO: " << rho << endl;
1023	>	cout << "eta: " << ele->SCluster()->Eta() << endl;
1024	>	cout << "target: " << EffectiveAreaVersion << endl;
1025	>	cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1026	>	ele->SCluster()->Eta(),
1027	>	EffectiveAreaVersion)
1028	>	<< endl;
1029	>	cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1030	>	ele->SCluster()->Eta(),
1031	>	EffectiveAreaVersion)
1032	>	<< endl;
1033	>	cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1034	>	ele->SCluster()->Eta(),
1035	>	EffectiveAreaVersion)
1036	>	<< endl;
1037	>	cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1038	>	ele->SCluster()->Eta(),
1039	>	EffectiveAreaVersion)
1040	>	<< endl;
1041	>	}
1042	>
1043	>	fGammaIso_DR0p0To0p1 = max(min((tmpGammaIso_DR0p0To0p1
1044	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
1045	>	ele->SCluster()->Eta(),
1046	>	EffectiveAreaVersion))/ele->Pt()
1047	>	,2.5)
1048	>	,0.0);
1049	>	fGammaIso_DR0p1To0p2 = max(min((tmpGammaIso_DR0p1To0p2
1050	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
1051	>	ele->SCluster()->Eta(),
1052	>	EffectiveAreaVersion))/ele->Pt()
1053	>	,2.5)
1054	>	,0.0);
1055	>	fGammaIso_DR0p2To0p3 = max(min((tmpGammaIso_DR0p2To0p3
1056	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
1057	>	ele->SCluster()->Eta()
1058	>	,EffectiveAreaVersion))/ele->Pt()
1059	>	,2.5)
1060	>	,0.0);
1061	>	fGammaIso_DR0p3To0p4 = max(min((tmpGammaIso_DR0p3To0p4
1062	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
1063	>	ele->SCluster()->Eta(),
1064	>	EffectiveAreaVersion))/ele->Pt()
1065	>	,2.5)
1066	>	,0.0);
1067	>	fGammaIso_DR0p4To0p5 = max(min((tmpGammaIso_DR0p4To0p5
1068	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
1069	>	ele->SCluster()->Eta(),
1070	>	EffectiveAreaVersion))/ele->Pt()
1071	>	,2.5)
1072	>	,0.0);
1073	>
1074	>
1075	>	fNeutralHadronIso_DR0p0To0p1 = max(min((tmpNeutralHadronIso_DR0p0To0p1
1076	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1077	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1078	>	, 2.5)
1079	>	, 0.0);
1080	>	fNeutralHadronIso_DR0p1To0p2 = max(min((tmpNeutralHadronIso_DR0p1To0p2
1081	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1082	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1083	>	, 2.5)
1084	>	, 0.0);
1085	>	fNeutralHadronIso_DR0p2To0p3 = max(min((tmpNeutralHadronIso_DR0p2To0p3
1086	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1087	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1088	>	, 2.5)
1089	>	, 0.0);
1090	>	fNeutralHadronIso_DR0p3To0p4 = max(min((tmpNeutralHadronIso_DR0p3To0p4
1091	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1092	>	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1093	>	, 2.5)
1094	>	, 0.0);
1095	>	fNeutralHadronIso_DR0p4To0p5 = max(min((tmpNeutralHadronIso_DR0p4To0p5
1096	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
1097	>	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1098	>	, 2.5)
1099	>	, 0.0);
1100	>
1101	>	double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
1102	>	ele->SCluster()->Eta(),
1103	>	fChargedIso_DR0p0To0p1,
1104	>	fChargedIso_DR0p1To0p2,
1105	>	fChargedIso_DR0p2To0p3,
1106	>	fChargedIso_DR0p3To0p4,
1107	>	fChargedIso_DR0p4To0p5,
1108	>	fGammaIso_DR0p0To0p1,
1109	>	fGammaIso_DR0p1To0p2,
1110	>	fGammaIso_DR0p2To0p3,
1111	>	fGammaIso_DR0p3To0p4,
1112	>	fGammaIso_DR0p4To0p5,
1113	>	fNeutralHadronIso_DR0p0To0p1,
1114	>	fNeutralHadronIso_DR0p1To0p2,
1115	>	fNeutralHadronIso_DR0p2To0p3,
1116	>	fNeutralHadronIso_DR0p3To0p4,
1117	>	fNeutralHadronIso_DR0p4To0p5,
1118	>	ctrl.debug);
1119	>
1120	>	SelectionStatus status;
1121	>	bool pass = false;
1122	>
1123	>	Int_t subdet = 0;
1124	>	if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
1125	>	else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
1126	>	else subdet = 2;
1127	>	Int_t ptBin = 0;
1128	>	if (ele->Pt() > 10.0) ptBin = 1;
1129	>
1130	>	Int_t MVABin = -1;
1131	>	if (subdet == 0 && ptBin == 0) MVABin = 0;
1132	>	if (subdet == 1 && ptBin == 0) MVABin = 1;
1133	>	if (subdet == 2 && ptBin == 0) MVABin = 2;
1134	>	if (subdet == 0 && ptBin == 1) MVABin = 3;
1135	>	if (subdet == 1 && ptBin == 1) MVABin = 4;
1136	>	if (subdet == 2 && ptBin == 1) MVABin = 5;
1137	>
1138	>	pass = false;
1139	>	if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN0 ) pass = true;
1140	>	if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN1 ) pass = true;
1141	>	if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN2 ) pass = true;
1142	>	if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN3 ) pass = true;
1143	>	if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN4 ) pass = true;
1144	>	if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN5 ) pass = true;
1145	>	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
1146	>
1147	>	pass = false;
1148	>	if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
1149	>	if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
1150	>	if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
1151	>	if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
1152	>	if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
1153	>	if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
1154	>	if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
1155	>
1156	>	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1157	>	return status;
1158	>
1159	>	}
1160	>
1161	>
1162	>	//--------------------------------------------------------------------------------------------------
1163	>	void initElectronIsoMVA() {
1164	>	//--------------------------------------------------------------------------------------------------
1165	>	eleIsoMVA = new mithep::ElectronIDMVA();
1166	>	vector<string> weightFiles;
1167	>	weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_BarrelPt5To10.weights.xml");
1168	>	weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_EndcapPt5To10.weights.xml");
1169	>	weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_BarrelPt10ToInf.weights.xml");
1170	>	weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_EndcapPt10ToInf.weights.xml");
1171	>	eleIsoMVA->Initialize( "ElectronIsoMVA",
1172	>	mithep::ElectronIDMVA::kIsoRingsV0,
1173	>	kTRUE, weightFiles);
1174	>	}
1175	>
1176	>
1177	>
1178	>	//--------------------------------------------------------------------------------------------------
1179	>	float electronPFIso04(ControlFlags &ctrl,
1180	>	const mithep::Electron * ele,
1181	>	const mithep::Vertex & vtx,
1182	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1183	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1184	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1185	>	vector<const mithep::Muon*> muonsToVeto,
1186	>	vector<const mithep::Electron*> electronsToVeto)
1187	>	//--------------------------------------------------------------------------------------------------
1188	>	{
1189	>
1190	>	if( ctrl.debug ) {
1191	>	cout << "electronIsoMVASelection :: muons to veto " << endl;
1192	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
1193	>	const mithep::Muon * vmu = muonsToVeto[i];
1194	>	cout << "\tpt: " << vmu->Pt()
1195	>	<< "\teta: " << vmu->Eta()
1196	>	<< "\tphi: " << vmu->Phi()
1197	>	<< endl;
1198	>	}
1199	>	cout << "electronIsoMVASelection :: electrson to veto " << endl;
1200	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
1201	>	const mithep::Electron * vel = electronsToVeto[i];
1202	>	cout << "\tpt: " << vel->Pt()
1203	>	<< "\teta: " << vel->Eta()
1204	>	<< "\tphi: " << vel->Phi()
1205	>	<< "\ttrk: " << vel->TrackerTrk()
1206	>	<< endl;
1207	>	}
1208	>	}
1209	>
1210	>
1211	>	//
1212	>	// final iso
1213	>	//
1214	>	Double_t fChargedIso = 0.0;
1215	>	Double_t fGammaIso = 0.0;
1216	>	Double_t fNeutralHadronIso = 0.0;
1217	>
1218	>
1219	>	//
1220	>	//Loop over PF Candidates
1221	>	//
1222	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1223	>	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1224	>	Double_t deta = (ele->Eta() - pf->Eta());
1225	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1226	>	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1227	>	if (dr >= 0.4) continue;
1228	>	if(ctrl.debug) {
1229	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1230	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
1231	>	cout << endl;
1232	>	}
1233	>
1234	>
1235	>	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
1236	>	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1237	>
1238	>
1239	>	//
1240	>	// Lepton Footprint Removal
1241	>	//
1242	>	Bool_t IsLeptonFootprint = kFALSE;
1243	>	if (dr < 1.0) {
1244	>
1245	>	//
1246	>	// Check for electrons
1247	>	//
1248	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1249	>	const mithep::Electron *tmpele = electronsToVeto[q];
1250	>	// 4l electron
1251	>	if( pf->HasTrackerTrk()  ) {
1252	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1253	>	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1254	>	IsLeptonFootprint = kTRUE;
1255	>	}
1256	>	}
1257	>	if( pf->HasGsfTrk()  ) {
1258	>	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1259	>	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1260	>	IsLeptonFootprint = kTRUE;
1261	>	}
1262	>	}
1263	>	// PF charged
1264	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1265	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1266	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1267	>	IsLeptonFootprint = kTRUE;
1268	>	}
1269	>	// PF gamma
1270	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1271	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
1272	>	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1273	>	IsLeptonFootprint = kTRUE;
1274	>	}
1275	>	} // loop over electrons
1276	>
1277	>	/* KH - comment for sync
1278	>	//
1279	>	// Check for muons
1280	>	//
1281	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1282	>	const mithep::Muon *tmpmu = muonsToVeto[q];
1283	>	// 4l muon
1284	>	if( pf->HasTrackerTrk() ) {
1285	>	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1286	>	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1287	>	IsLeptonFootprint = kTRUE;
1288	>	}
1289	>	}
1290	>	// PF charged
1291	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1292	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1293	>	IsLeptonFootprint = kTRUE;
1294	>	}
1295	>	} // loop over muons
1296	>	*/
1297	>
1298	>	if (IsLeptonFootprint)
1299	>	continue;
1300	>
1301	>	//
1302	>	// Charged Iso
1303	>	//
1304	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1305	>
1306	>	if( pf->HasTrackerTrk() )
1307	>	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1308	>	if( pf->HasGsfTrk() )
1309	>	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1310	>
1311	>	// Veto any PFmuon, or PFEle
1312	>	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1313	>
1314	>	// Footprint Veto
1315	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1316	>
1317	>	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1318	>	<< "\ttype: " << pf->PFType()
1319	>	<< "\ttrk: " << pf->TrackerTrk() << endl;
1320	>
1321	>	fChargedIso += pf->Pt();
1322	>	}
1323	>
1324	>	//
1325	>	// Gamma Iso
1326	>	//
1327	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1328	>
1329	>	if (fabs(ele->SCluster()->Eta()) > 1.479) {
1330	>	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
1331	>	}
1332	>	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1333	>	<< dr << endl;
1334	>	fGammaIso += pf->Pt();
1335	>	}
1336	>
1337	>	//
1338	>	// Neutral Iso
1339	>	//
1340	>	else {
1341	>	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
1342	>	<< dr << endl;
1343	>	// KH, add to sync
1344	>	if( pf->Pt() > 0.5 )
1345	>	fNeutralHadronIso += pf->Pt();
1346	>	}
1347	>
1348	>	}
1349	>
1350	>	}
1351	>
1352	>	double rho = 0;
1353	>	if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1354	>	rho = fPUEnergyDensity->At(0)->Rho();
1355	>
1356	>	// WARNING!!!!
1357	>	// hardcode for sync ...
1358	>	EffectiveAreaVersion = eleT.kEleEAData2011;
1359	>	// WARNING!!!!
1360	>
1361	>
1362	>	double pfIso = fChargedIso +
1363	>	max(0.0,fGammaIso -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIso04,
1364	>	ele->Eta(),EffectiveAreaVersion)) +
1365	>	max(0.0,fNeutralHadronIso -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIso04,
1366	>	ele->Eta(),EffectiveAreaVersion)) ;
1367	>	return pfIso;
1368	>	}
1369	>
1370	>	//--------------------------------------------------------------------------------------------------
1371	>	SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
1372	>	const mithep::Electron * ele,
1373	>	const mithep::Vertex & vtx,
1374	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1375	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1376	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1377	>	vector<const mithep::Muon*> muonsToVeto,
1378	>	vector<const mithep::Electron*> electronsToVeto)
1379	>	//--------------------------------------------------------------------------------------------------
1380	>	{
1381	>
1382	>	SelectionStatus status;
1383	>
1384	>	double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, fPUEnergyDensity,
1385	>	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1386	>	bool pass = false;
1387	>	if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
1388	>
1389	>	if( pass ) {
1390	>	status.orStatus(SelectionStatus::LOOSEISO);
1391	>	status.orStatus(SelectionStatus::TIGHTISO);
1392		}
1393		if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1394		return status;

Diff Legend

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