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.5 by khahn, Thu Apr 26 07:02:28 2012 UTC vs.
Revision 1.20 by khahn, Mon May 14 18:01:02 2012 UTC

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

Diff Legend

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