[ViewVC] Diff of: cvsroot/UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc

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

Diff Legend

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

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents): Revision 1.10 by khahn, Sat May 5 13:09:05 2012 UTC vs. Revision 1.33 by anlevin, Wed Oct 17 01:31:22 2012 UTC

Diff Legend

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents):
Revision 1.10 by khahn, Sat May 5 13:09:05 2012 UTC vs.
Revision 1.33 by anlevin, Wed Oct 17 01:31:22 2012 UTC