ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

root/cvsroot/UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents):
Revision 1.8 by khahn, Wed May 2 17:50:58 2012 UTC vs.
Revision 1.18 by khahn, Sat May 12 03:00:14 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	+
25		//--------------------------------------------------------------------------------------------------
26		Float_t computePFMuonIso(const mithep::Muon *muon,
27		const mithep::Vertex & vtx,
#	Line 157 | Line 163 | bool pairwiseIsoSelection( ControlFlags
163
164		float isoEcal_corr_j = lepvec[j].isoEcal - (effArea_ecal_j*rho);
165		float isoHcal_corr_j = lepvec[j].isoHcal - (effArea_hcal_j*rho);
166	<	float RIso_i = (lepvec[i].isoTrk+isoEcal_corr_i+isoHcal_corr_i)/lepvec[i].vec->Pt();
167	<	float RIso_j = (lepvec[j].isoTrk+isoEcal_corr_j+isoHcal_corr_j)/lepvec[j].vec->Pt();
166	>	float RIso_i = (lepvec[i].isoTrk+isoEcal_corr_i+isoHcal_corr_i)/lepvec[i].vec.Pt();
167	>	float RIso_j = (lepvec[j].isoTrk+isoEcal_corr_j+isoHcal_corr_j)/lepvec[j].vec.Pt();
168		float comboIso = RIso_i + RIso_j;
169
170		if( comboIso > 0.35 ) {
#	Line 371 | Line 377 | SelectionStatus muonIsoMVASelection(Cont
377		IsLeptonFootprint = kTRUE;
378		} // loop over electrons
379
380	+	/* KH - commented for sync
381		//
382		// Check for muons
383		//
#	Line 385 | Line 392 | SelectionStatus muonIsoMVASelection(Cont
392		if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
393		IsLeptonFootprint = kTRUE;
394		} // loop over muons
395	<
395	>	*/
396
397		if (IsLeptonFootprint)
398		continue;
#	Line 395 | Line 402 | SelectionStatus muonIsoMVASelection(Cont
402		//
403		if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
404
405	<	if( dr < 0.01 ) continue; // only for muon iso mva?
405	>	//      if( dr < 0.01 ) continue; // only for muon iso mva?
406		if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
407
408		if( pf->HasTrackerTrk() ) {
#	Line 458 | Line 465 | SelectionStatus muonIsoMVASelection(Cont
465		double rho = 0;
466		if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
467		rho = fPUEnergyDensity->At(0)->Rho();
468	+	//   if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
469	+	//     rho = fPUEnergyDensity->At(0)->RhoLowEta();
470
471	+	// WARNING!!!!
472	+	// hardcode for sync ...
473	+	EffectiveAreaVersion = muT.kMuEAData2011;
474	+	// WARNING!!!!
475	+
476
477		fGammaIso_DR0p0To0p1 = max(min((tmpGammaIso_DR0p0To0p1
478		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p0To0p1,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
#	Line 511 | Line 525 | SelectionStatus muonIsoMVASelection(Cont
525
526
527		double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
528	<	mu->Eta(),
529	<	fChargedIso_DR0p0To0p1,
530	<	fChargedIso_DR0p1To0p2,
531	<	fChargedIso_DR0p2To0p3,
532	<	fChargedIso_DR0p3To0p4,
533	<	fChargedIso_DR0p4To0p5,
534	<	fGammaIso_DR0p0To0p1,
535	<	fGammaIso_DR0p1To0p2,
536	<	fGammaIso_DR0p2To0p3,
537	<	fGammaIso_DR0p3To0p4,
538	<	fGammaIso_DR0p4To0p5,
539	<	fNeutralHadronIso_DR0p0To0p1,
540	<	fNeutralHadronIso_DR0p1To0p2,
541	<	fNeutralHadronIso_DR0p2To0p3,
542	<	fNeutralHadronIso_DR0p3To0p4,
543	<	fNeutralHadronIso_DR0p4To0p5,
544	<	ctrl.debug);
528	>	mu->Eta(),
529	>	mu->IsGlobalMuon(),
530	>	mu->IsTrackerMuon(),
531	>	fChargedIso_DR0p0To0p1,
532	>	fChargedIso_DR0p1To0p2,
533	>	fChargedIso_DR0p2To0p3,
534	>	fChargedIso_DR0p3To0p4,
535	>	fChargedIso_DR0p4To0p5,
536	>	fGammaIso_DR0p0To0p1,
537	>	fGammaIso_DR0p1To0p2,
538	>	fGammaIso_DR0p2To0p3,
539	>	fGammaIso_DR0p3To0p4,
540	>	fGammaIso_DR0p4To0p5,
541	>	fNeutralHadronIso_DR0p0To0p1,
542	>	fNeutralHadronIso_DR0p1To0p2,
543	>	fNeutralHadronIso_DR0p2To0p3,
544	>	fNeutralHadronIso_DR0p3To0p4,
545	>	fNeutralHadronIso_DR0p4To0p5,
546	>	ctrl.debug);
547
548		SelectionStatus status;
549	<	bool pass = false;
549	>	bool pass;
550
551	+	pass = false;
552		if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
553	<	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_FORPFID_CUT_BIN0)   pass = true;
553	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN0)   pass = true;
554		else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
555	<	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_FORPFID_CUT_BIN1)  pass = true;
555	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN1)  pass = true;
556		else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
557	<	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_FORPFID_CUT_BIN2)  pass = true;
557	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN2)  pass = true;
558		else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
559	<	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_FORPFID_CUT_BIN3)  pass = true;
560	<	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon()
561	<	&& mvaval >= MUON_ISOMVA_FORPFID_CUT_BIN4)
562	<	pass = true;
559	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN3)  pass = true;
560	>	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN4)  pass = true;
561	>	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN5)  pass = true;
562	>	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
563
564	+	pass = false;
565	+	if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
566	+	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN0)   pass = true;
567	+	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
568	+	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN1)  pass = true;
569	+	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
570	+	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN2)  pass = true;
571	+	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
572	+	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN3)  pass = true;
573	+	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN4)  pass = true;
574	+	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN5)  pass = true;
575	+	if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
576
577	<	pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
577	>	//  pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
578
550	–	if( pass ) {
551	–	status.orStatus(SelectionStatus::LOOSEISO);
552	–	status.orStatus(SelectionStatus::TIGHTISO);
553	–	}
579		if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
580		return status;
581
#	Line 573 | Line 598 | void initMuonIsoMVA() {
598		}
599
600
601	+	//--------------------------------------------------------------------------------------------------
602	+	double  muonPFIso04(ControlFlags &ctrl,
603	+	const mithep::Muon * mu,
604	+	const mithep::Vertex & vtx,
605	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
606	+	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
607	+	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
608	+	vector<const mithep::Muon*> muonsToVeto,
609	+	vector<const mithep::Electron*> electronsToVeto)
610	+	//--------------------------------------------------------------------------------------------------
611	+	{
612	+
613	+	if( ctrl.debug ) {
614	+	cout << "muonIsoMVASelection :: muons to veto " << endl;
615	+	for( int i=0; i<muonsToVeto.size(); i++ ) {
616	+	const mithep::Muon * vmu = muonsToVeto[i];
617	+	cout << "\tpt: " << vmu->Pt()
618	+	<< "\teta: " << vmu->Eta()
619	+	<< "\tphi: " << vmu->Phi()
620	+	<< endl;
621	+	}
622	+	cout << "muonIsoMVASelection :: electrson to veto " << endl;
623	+	for( int i=0; i<electronsToVeto.size(); i++ ) {
624	+	const mithep::Electron * vel = electronsToVeto[i];
625	+	cout << "\tpt: " << vel->Pt()
626	+	<< "\teta: " << vel->Eta()
627	+	<< "\tphi: " << vel->Phi()
628	+	<< endl;
629	+	}
630	+	}
631	+
632	+	//
633	+	// final iso
634	+	//
635	+	Double_t fChargedIso  = 0.0;
636	+	Double_t fGammaIso  = 0.0;
637	+	Double_t fNeutralHadronIso  = 0.0;
638	+
639	+	//
640	+	//Loop over PF Candidates
641	+	//
642	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
643	+	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
644	+
645	+	Double_t deta = (mu->Eta() - pf->Eta());
646	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
647	+	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
648	+	if (dr > 0.4) continue;
649	+
650	+	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
651	+
652	+	//
653	+	// Lepton Footprint Removal
654	+	//
655	+	Bool_t IsLeptonFootprint = kFALSE;
656	+	if (dr < 1.0) {
657	+
658	+	//
659	+	// Check for electrons
660	+	//
661	+	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
662	+	const mithep::Electron *tmpele = electronsToVeto[q];
663	+	// 4l electron
664	+	if( pf->HasTrackerTrk() ) {
665	+	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
666	+	IsLeptonFootprint = kTRUE;
667	+	}
668	+	if( pf->HasGsfTrk() ) {
669	+	if( pf->GsfTrk() == tmpele->GsfTrk() )
670	+	IsLeptonFootprint = kTRUE;
671	+	}
672	+	// PF charged
673	+	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
674	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
675	+	IsLeptonFootprint = kTRUE;
676	+	// PF gamma
677	+	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
678	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
679	+	IsLeptonFootprint = kTRUE;
680	+	} // loop over electrons
681	+
682	+	// KH, comment to sync
683	+	/*
684	+	//
685	+	// Check for muons
686	+	//
687	+	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
688	+	const mithep::Muon *tmpmu = muonsToVeto[q];
689	+	// 4l muon
690	+	if( pf->HasTrackerTrk() ) {
691	+	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
692	+	IsLeptonFootprint = kTRUE;
693	+	}
694	+	// PF charged
695	+	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
696	+	IsLeptonFootprint = kTRUE;
697	+	} // loop over muons
698	+	*/
699	+
700	+	if (IsLeptonFootprint)
701	+	continue;
702	+
703	+	//
704	+	// Charged Iso
705	+	//
706	+	if (pf->Charge() != 0 ) {
707	+
708	+	//if( dr < 0.01 ) continue; // only for muon iso mva?
709	+	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
710	+
711	+	if( pf->HasTrackerTrk() ) {
712	+	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
713	+	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
714	+	<< abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
715	+	<< dr << endl;
716	+	}
717	+	if( pf->HasGsfTrk() ) {
718	+	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
719	+	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
720	+	<< abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
721	+	<< dr << endl;
722	+	}
723	+
724	+
725	+	fChargedIso += pf->Pt();
726	+	}
727	+
728	+	//
729	+	// Gamma Iso
730	+	//
731	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
732	+	// KH, add to sync
733	+	if( pf->Pt() > 0.5 )
734	+	fGammaIso += pf->Pt();
735	+	}
736	+
737	+	//
738	+	// Other Neutrals
739	+	//
740	+	else {
741	+	// KH, add to sync
742	+	if( pf->Pt() > 0.5 )
743	+	fNeutralHadronIso += pf->Pt();
744	+	}
745	+
746	+	}
747	+
748	+	}
749	+
750	+	double rho = 0;
751	+	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
752	+	//     rho = fPUEnergyDensity->At(0)->Rho();
753	+	if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
754	+	rho = fPUEnergyDensity->At(0)->RhoLowEta();
755	+
756	+	// WARNING!!!!
757	+	// hardcode for sync ...
758	+	EffectiveAreaVersion = muT.kMuEAData2011;
759	+	// WARNING!!!!
760	+
761	+
762	+	double pfIso = fChargedIso + max(0.0,(fGammaIso + fNeutralHadronIso
763	+	-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
764	+	mu->Eta(),EffectiveAreaVersion)));
765	+
766	+	gChargedIso = fChargedIso;
767	+	gGammaIso = fGammaIso;
768	+	gNeutralIso = fNeutralHadronIso;
769	+	return pfIso;
770	+	}
771	+
772	+
773	+	//--------------------------------------------------------------------------------------------------
774	+	// hacked version
775	+	double  muonPFIso04(ControlFlags &ctrl,
776	+	const mithep::Muon * mu,
777	+	const mithep::Vertex & vtx,
778	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
779	+	float rho,
780	+	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
781	+	vector<const mithep::Muon*> muonsToVeto,
782	+	vector<const mithep::Electron*> electronsToVeto)
783	+	//--------------------------------------------------------------------------------------------------
784	+	{
785	+
786	+	extern double gChargedIso;
787	+	extern double  gGammaIso;
788	+	extern double  gNeutralIso;
789	+
790	+	if( ctrl.debug ) {
791	+	cout << "muonIsoMVASelection :: muons to veto " << endl;
792	+	for( int i=0; i<muonsToVeto.size(); i++ ) {
793	+	const mithep::Muon * vmu = muonsToVeto[i];
794	+	cout << "\tpt: " << vmu->Pt()
795	+	<< "\teta: " << vmu->Eta()
796	+	<< "\tphi: " << vmu->Phi()
797	+	<< endl;
798	+	}
799	+	cout << "muonIsoMVASelection :: electrson to veto " << endl;
800	+	for( int i=0; i<electronsToVeto.size(); i++ ) {
801	+	const mithep::Electron * vel = electronsToVeto[i];
802	+	cout << "\tpt: " << vel->Pt()
803	+	<< "\teta: " << vel->Eta()
804	+	<< "\tphi: " << vel->Phi()
805	+	<< endl;
806	+	}
807	+	}
808	+
809	+	//
810	+	// final iso
811	+	//
812	+	Double_t fChargedIso  = 0.0;
813	+	Double_t fGammaIso  = 0.0;
814	+	Double_t fNeutralHadronIso  = 0.0;
815	+
816	+	//
817	+	//Loop over PF Candidates
818	+	//
819	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
820	+	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
821	+
822	+	Double_t deta = (mu->Eta() - pf->Eta());
823	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
824	+	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
825	+	if (dr > 0.4) continue;
826	+
827	+	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
828	+
829	+	//
830	+	// Lepton Footprint Removal
831	+	//
832	+	Bool_t IsLeptonFootprint = kFALSE;
833	+	if (dr < 1.0) {
834	+
835	+	//
836	+	// Check for electrons
837	+	//
838	+	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
839	+	const mithep::Electron *tmpele = electronsToVeto[q];
840	+	// 4l electron
841	+	if( pf->HasTrackerTrk() ) {
842	+	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
843	+	IsLeptonFootprint = kTRUE;
844	+	}
845	+	if( pf->HasGsfTrk() ) {
846	+	if( pf->GsfTrk() == tmpele->GsfTrk() )
847	+	IsLeptonFootprint = kTRUE;
848	+	}
849	+	// PF charged
850	+	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
851	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
852	+	IsLeptonFootprint = kTRUE;
853	+	// PF gamma
854	+	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
855	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
856	+	IsLeptonFootprint = kTRUE;
857	+	} // loop over electrons
858	+
859	+	/* KH - comment for sync
860	+	//
861	+	// Check for muons
862	+	//
863	+	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
864	+	const mithep::Muon *tmpmu = muonsToVeto[q];
865	+	// 4l muon
866	+	if( pf->HasTrackerTrk() ) {
867	+	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
868	+	IsLeptonFootprint = kTRUE;
869	+	}
870	+	// PF charged
871	+	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
872	+	IsLeptonFootprint = kTRUE;
873	+	} // loop over muons
874	+	*/
875	+
876	+	if (IsLeptonFootprint)
877	+	continue;
878	+
879	+	//
880	+	// Charged Iso
881	+	//
882	+	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
883	+
884	+	if( dr < 0.01 ) continue; // only for muon iso mva?
885	+	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
886	+
887	+	if( pf->HasTrackerTrk() ) {
888	+	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
889	+	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
890	+	<< abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
891	+	<< dr << endl;
892	+	}
893	+	if( pf->HasGsfTrk() ) {
894	+	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
895	+	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
896	+	<< abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
897	+	<< dr << endl;
898	+	}
899	+
900	+
901	+	fChargedIso += pf->Pt();
902	+	}
903	+
904	+	//
905	+	// Gamma Iso
906	+	//
907	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
908	+	if( pf->Pt() > 0.5 )
909	+	fGammaIso += pf->Pt();
910	+	}
911	+
912	+	//
913	+	// Other Neutrals
914	+	//
915	+	else {
916	+	// KH, add to sync
917	+	if( pf->Pt() > 0.5 )
918	+	fNeutralHadronIso += pf->Pt();
919	+	}
920	+
921	+	}
922	+
923	+	}
924	+
925	+	//   double rho = 0;
926	+	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
927	+	//     rho = fPUEnergyDensity->At(0)->Rho();
928	+
929	+	// WARNING!!!!
930	+	// hardcode for sync ...
931	+	EffectiveAreaVersion = muT.kMuEAData2011;
932	+	// WARNING!!!!
933	+
934	+
935	+	double pfIso = fChargedIso + max(0.0,(fGammaIso + fNeutralHadronIso
936	+	-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
937	+	mu->Eta(),EffectiveAreaVersion)));
938	+	gChargedIso = fChargedIso;
939	+	gGammaIso   = fGammaIso;
940	+	gNeutralIso = fNeutralHadronIso;
941	+
942	+	return pfIso;
943	+	}
944	+
945	+
946	+	//--------------------------------------------------------------------------------------------------
947	+	SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
948	+	const mithep::Muon * mu,
949	+	const mithep::Vertex & vtx,
950	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
951	+	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
952	+	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
953	+	vector<const mithep::Muon*> muonsToVeto,
954	+	vector<const mithep::Electron*> electronsToVeto)
955	+	//--------------------------------------------------------------------------------------------------
956	+	{
957	+
958	+	SelectionStatus status;
959	+
960	+	double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, fPUEnergyDensity,
961	+	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
962	+	cout << "--------------> setting muon isoPF04 to" << pfIso << endl;
963	+	status.isoPF04 = pfIso;
964	+	status.chisoPF04 = gChargedIso;
965	+	status.gaisoPF04 = gGammaIso;
966	+	status.neisoPF04 = gNeutralIso;
967	+
968	+	bool pass = false;
969	+	if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
970	+
971	+	if( pass ) {
972	+	status.orStatus(SelectionStatus::LOOSEISO);
973	+	status.orStatus(SelectionStatus::TIGHTISO);
974	+	}
975	+	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
976	+	return status;
977	+
978	+	}
979	+
980	+
981	+	//--------------------------------------------------------------------------------------------------
982	+	// hacked version
983	+	SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
984	+	const mithep::Muon * mu,
985	+	const mithep::Vertex & vtx,
986	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
987	+	float rho,
988	+	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
989	+	vector<const mithep::Muon*> muonsToVeto,
990	+	vector<const mithep::Electron*> electronsToVeto)
991	+	//--------------------------------------------------------------------------------------------------
992	+	{
993	+
994	+	SelectionStatus status;
995	+
996	+	double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, rho,
997	+	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
998	+	bool pass = false;
999	+	if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1000	+
1001	+	if( pass ) {
1002	+	status.orStatus(SelectionStatus::LOOSEISO);
1003	+	status.orStatus(SelectionStatus::TIGHTISO);
1004	+	}
1005	+	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1006	+	return status;
1007	+
1008	+	}
1009	+
1010	+
1011
1012		//--------------------------------------------------------------------------------------------------
1013		SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
#	Line 713 | Line 1148 | SelectionStatus electronIsoMVASelection(
1148		IsLeptonFootprint = kTRUE;
1149		}
1150		} // loop over electrons
1151	<
1151	>
1152	>	/* KH - comment for sync
1153		//
1154		// Check for muons
1155		//
#	Line 732 | Line 1168 | SelectionStatus electronIsoMVASelection(
1168		IsLeptonFootprint = kTRUE;
1169		}
1170		} // loop over muons
1171	<
1171	>	*/
1172
1173		if (IsLeptonFootprint)
1174		continue;
#	Line 812 | Line 1248 | SelectionStatus electronIsoMVASelection(
1248		fChargedIso_DR0p4To0p5   = min((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1249
1250		double rho = 0;
1251	<	if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1252	<	rho = fPUEnergyDensity->At(0)->Rho();
1251	>	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1252	>	//     rho = fPUEnergyDensity->At(0)->Rho();
1253	>	if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1254	>	rho = fPUEnergyDensity->At(0)->RhoLowEta();
1255	>
1256	>	// WARNING!!!!
1257	>	// hardcode for sync ...
1258	>	EffectiveAreaVersion = eleT.kEleEAData2011;
1259	>	// WARNING!!!!
1260
1261		if( ctrl.debug) {
1262		cout << "RHO: " << rho << endl;
#	Line 931 | Line 1374 | SelectionStatus electronIsoMVASelection(
1374		if (subdet == 0 && ptBin == 1) MVABin = 3;
1375		if (subdet == 1 && ptBin == 1) MVABin = 4;
1376		if (subdet == 2 && ptBin == 1) MVABin = 5;
934	–
935	–	if( MVABin == 0 && mvaval > ELECTRON_ISOMVA_CUT_BIN0 ) pass = true;
936	–	if( MVABin == 1 && mvaval > ELECTRON_ISOMVA_CUT_BIN1 ) pass = true;
937	–	if( MVABin == 2 && mvaval > ELECTRON_ISOMVA_CUT_BIN2 ) pass = true;
938	–	if( MVABin == 3 && mvaval > ELECTRON_ISOMVA_CUT_BIN3 ) pass = true;
939	–	if( MVABin == 4 && mvaval > ELECTRON_ISOMVA_CUT_BIN4 ) pass = true;
940	–	if( MVABin == 5 && mvaval > ELECTRON_ISOMVA_CUT_BIN5 ) pass = true;
1377
1378	<	// pre-selection iso ...
1379	<	pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
1378	>	pass = false;
1379	>	if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN0 ) pass = true;
1380	>	if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN1 ) pass = true;
1381	>	if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN2 ) pass = true;
1382	>	if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN3 ) pass = true;
1383	>	if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN4 ) pass = true;
1384	>	if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN5 ) pass = true;
1385	>	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
1386	>
1387	>	//   pass = false;
1388	>	//   if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
1389	>	//   if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
1390	>	//   if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
1391	>	//   if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
1392	>	//   if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
1393	>	//   if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
1394	>	//   if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
1395
945	–	if( pass ) {
946	–	status.orStatus(SelectionStatus::LOOSEISO);
947	–	status.orStatus(SelectionStatus::TIGHTISO);
948	–	}
1396		if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1397		return status;
1398	<
1398	>
1399		}
1400
1401
#	Line 965 | Line 1412 | void initElectronIsoMVA() {
1412		mithep::ElectronIDMVA::kIsoRingsV0,
1413		kTRUE, weightFiles);
1414		}
1415	+
1416	+
1417	+
1418	+	//--------------------------------------------------------------------------------------------------
1419	+	float electronPFIso04(ControlFlags &ctrl,
1420	+	const mithep::Electron * ele,
1421	+	const mithep::Vertex & vtx,
1422	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1423	+	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1424	+	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1425	+	vector<const mithep::Muon*> muonsToVeto,
1426	+	vector<const mithep::Electron*> electronsToVeto)
1427	+	//--------------------------------------------------------------------------------------------------
1428	+	{
1429	+
1430	+	if( ctrl.debug ) {
1431	+	cout << "electronIsoMVASelection :: muons to veto " << endl;
1432	+	for( int i=0; i<muonsToVeto.size(); i++ ) {
1433	+	const mithep::Muon * vmu = muonsToVeto[i];
1434	+	cout << "\tpt: " << vmu->Pt()
1435	+	<< "\teta: " << vmu->Eta()
1436	+	<< "\tphi: " << vmu->Phi()
1437	+	<< endl;
1438	+	}
1439	+	cout << "electronIsoMVASelection :: electrson to veto " << endl;
1440	+	for( int i=0; i<electronsToVeto.size(); i++ ) {
1441	+	const mithep::Electron * vel = electronsToVeto[i];
1442	+	cout << "\tpt: " << vel->Pt()
1443	+	<< "\teta: " << vel->Eta()
1444	+	<< "\tphi: " << vel->Phi()
1445	+	<< "\ttrk: " << vel->TrackerTrk()
1446	+	<< endl;
1447	+	}
1448	+	}
1449	+
1450	+
1451	+	//
1452	+	// final iso
1453	+	//
1454	+	Double_t fChargedIso = 0.0;
1455	+	Double_t fGammaIso = 0.0;
1456	+	Double_t fNeutralHadronIso = 0.0;
1457	+
1458	+
1459	+	//
1460	+	//Loop over PF Candidates
1461	+	//
1462	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1463	+	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1464	+	Double_t deta = (ele->Eta() - pf->Eta());
1465	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1466	+	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1467	+	if (dr >= 0.4) continue;
1468	+	if(ctrl.debug) {
1469	+	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1470	+	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
1471	+	cout << endl;
1472	+	}
1473	+
1474	+
1475	+	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
1476	+	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1477	+
1478	+
1479	+	//
1480	+	// Lepton Footprint Removal
1481	+	//
1482	+	Bool_t IsLeptonFootprint = kFALSE;
1483	+	if (dr < 1.0) {
1484	+
1485	+	//
1486	+	// Check for electrons
1487	+	//
1488	+	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1489	+	const mithep::Electron *tmpele = electronsToVeto[q];
1490	+	// 4l electron
1491	+	if( pf->HasTrackerTrk()  ) {
1492	+	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1493	+	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1494	+	IsLeptonFootprint = kTRUE;
1495	+	}
1496	+	}
1497	+	if( pf->HasGsfTrk()  ) {
1498	+	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1499	+	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1500	+	IsLeptonFootprint = kTRUE;
1501	+	}
1502	+	}
1503	+	// PF charged
1504	+	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1505	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1506	+	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1507	+	IsLeptonFootprint = kTRUE;
1508	+	}
1509	+	// PF gamma
1510	+	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1511	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
1512	+	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1513	+	IsLeptonFootprint = kTRUE;
1514	+	}
1515	+	} // loop over electrons
1516	+
1517	+
1518	+	//
1519	+	// Check for muons
1520	+	//
1521	+	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1522	+	const mithep::Muon *tmpmu = muonsToVeto[q];
1523	+	// 4l muon
1524	+	if( pf->HasTrackerTrk() ) {
1525	+	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1526	+	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1527	+	IsLeptonFootprint = kTRUE;
1528	+	}
1529	+	}
1530	+	// PF charged
1531	+	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1532	+	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1533	+	IsLeptonFootprint = kTRUE;
1534	+	}
1535	+	} // loop over muons
1536	+
1537	+
1538	+	if (IsLeptonFootprint)
1539	+	continue;
1540	+
1541	+	//
1542	+	// Charged Iso
1543	+	//
1544	+	if (pf->Charge() != 0 ) {
1545	+
1546	+	if( pf->HasTrackerTrk() )
1547	+	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1548	+	if( pf->HasGsfTrk() )
1549	+	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1550	+
1551	+	// Veto any PFmuon, or PFEle
1552	+	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1553	+
1554	+	// Footprint Veto
1555	+	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1556	+
1557	+	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1558	+	<< "\ttype: " << pf->PFType()
1559	+	<< "\ttrk: " << pf->TrackerTrk() << endl;
1560	+
1561	+	fChargedIso += pf->Pt();
1562	+	}
1563	+
1564	+	//
1565	+	// Gamma Iso
1566	+	//
1567	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1568	+
1569	+	if (fabs(ele->SCluster()->Eta()) > 1.479) {
1570	+	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
1571	+	}
1572	+	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1573	+	<< dr << endl;
1574	+	if( pf->Pt() > 0.5 )
1575	+	fGammaIso += pf->Pt();
1576	+	}
1577	+
1578	+	//
1579	+	// Neutral Iso
1580	+	//
1581	+	else {
1582	+	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
1583	+	<< dr << endl;
1584	+	if( pf->Pt() > 0.5 )
1585	+	fNeutralHadronIso += pf->Pt();
1586	+	}
1587	+
1588	+	}
1589	+
1590	+	}
1591	+
1592	+	double rho = 0;
1593	+	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1594	+	//     rho = fPUEnergyDensity->At(0)->Rho();
1595	+	if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1596	+	rho = fPUEnergyDensity->At(0)->RhoLowEta();
1597	+
1598	+	// WARNING!!!!
1599	+	// hardcode for sync ...
1600	+	EffectiveAreaVersion = eleT.kEleEAData2011;
1601	+	// WARNING!!!!
1602	+
1603	+
1604	+	double pfIso = fChargedIso +
1605	+	max(0.0,fGammaIso -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIso04,
1606	+	ele->Eta(),EffectiveAreaVersion)) +
1607	+	max(0.0,fNeutralHadronIso -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIso04,
1608	+	ele->Eta(),EffectiveAreaVersion)) ;
1609	+
1610	+	gChargedIso = fChargedIso;
1611	+	gGammaIso = fGammaIso;
1612	+	gNeutralIso = fNeutralHadronIso;
1613	+
1614	+	return pfIso;
1615	+	}
1616	+
1617	+	//--------------------------------------------------------------------------------------------------
1618	+	// hacked version
1619	+	float electronPFIso04(ControlFlags &ctrl,
1620	+	const mithep::Electron * ele,
1621	+	const mithep::Vertex & vtx,
1622	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1623	+	float rho,
1624	+	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1625	+	vector<const mithep::Muon*> muonsToVeto,
1626	+	vector<const mithep::Electron*> electronsToVeto)
1627	+	//--------------------------------------------------------------------------------------------------
1628	+	{
1629	+
1630	+	if( ctrl.debug ) {
1631	+	cout << "electronIsoMVASelection :: muons to veto " << endl;
1632	+	for( int i=0; i<muonsToVeto.size(); i++ ) {
1633	+	const mithep::Muon * vmu = muonsToVeto[i];
1634	+	cout << "\tpt: " << vmu->Pt()
1635	+	<< "\teta: " << vmu->Eta()
1636	+	<< "\tphi: " << vmu->Phi()
1637	+	<< endl;
1638	+	}
1639	+	cout << "electronIsoMVASelection :: electrson to veto " << endl;
1640	+	for( int i=0; i<electronsToVeto.size(); i++ ) {
1641	+	const mithep::Electron * vel = electronsToVeto[i];
1642	+	cout << "\tpt: " << vel->Pt()
1643	+	<< "\teta: " << vel->Eta()
1644	+	<< "\tphi: " << vel->Phi()
1645	+	<< "\ttrk: " << vel->TrackerTrk()
1646	+	<< endl;
1647	+	}
1648	+	}
1649	+
1650	+
1651	+	//
1652	+	// final iso
1653	+	//
1654	+	Double_t fChargedIso = 0.0;
1655	+	Double_t fGammaIso = 0.0;
1656	+	Double_t fNeutralHadronIso = 0.0;
1657	+
1658	+
1659	+	//
1660	+	//Loop over PF Candidates
1661	+	//
1662	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1663	+	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1664	+	Double_t deta = (ele->Eta() - pf->Eta());
1665	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1666	+	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1667	+	if (dr >= 0.4) continue;
1668	+	if(ctrl.debug) {
1669	+	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1670	+	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
1671	+	cout << endl;
1672	+	}
1673	+
1674	+
1675	+	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
1676	+	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1677	+
1678	+
1679	+	//
1680	+	// Lepton Footprint Removal
1681	+	//
1682	+	Bool_t IsLeptonFootprint = kFALSE;
1683	+	if (dr < 1.0) {
1684	+
1685	+	//
1686	+	// Check for electrons
1687	+	//
1688	+	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1689	+	const mithep::Electron *tmpele = electronsToVeto[q];
1690	+	// 4l electron
1691	+	if( pf->HasTrackerTrk()  ) {
1692	+	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1693	+	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1694	+	IsLeptonFootprint = kTRUE;
1695	+	}
1696	+	}
1697	+	if( pf->HasGsfTrk()  ) {
1698	+	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1699	+	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1700	+	IsLeptonFootprint = kTRUE;
1701	+	}
1702	+	}
1703	+	// PF charged
1704	+	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1705	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1706	+	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1707	+	IsLeptonFootprint = kTRUE;
1708	+	}
1709	+	// PF gamma
1710	+	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1711	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
1712	+	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1713	+	IsLeptonFootprint = kTRUE;
1714	+	}
1715	+	} // loop over electrons
1716	+
1717	+	/* KH - comment for sync
1718	+	//
1719	+	// Check for muons
1720	+	//
1721	+	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1722	+	const mithep::Muon *tmpmu = muonsToVeto[q];
1723	+	// 4l muon
1724	+	if( pf->HasTrackerTrk() ) {
1725	+	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1726	+	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1727	+	IsLeptonFootprint = kTRUE;
1728	+	}
1729	+	}
1730	+	// PF charged
1731	+	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1732	+	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1733	+	IsLeptonFootprint = kTRUE;
1734	+	}
1735	+	} // loop over muons
1736	+	*/
1737	+
1738	+	if (IsLeptonFootprint)
1739	+	continue;
1740	+
1741	+	//
1742	+	// Charged Iso
1743	+	//
1744	+	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1745	+
1746	+	if( pf->HasTrackerTrk() )
1747	+	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1748	+	if( pf->HasGsfTrk() )
1749	+	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1750	+
1751	+	// Veto any PFmuon, or PFEle
1752	+	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1753	+
1754	+	// Footprint Veto
1755	+	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1756	+
1757	+	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1758	+	<< "\ttype: " << pf->PFType()
1759	+	<< "\ttrk: " << pf->TrackerTrk() << endl;
1760	+
1761	+	fChargedIso += pf->Pt();
1762	+	}
1763	+
1764	+	//
1765	+	// Gamma Iso
1766	+	//
1767	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1768	+
1769	+	if (fabs(ele->SCluster()->Eta()) > 1.479) {
1770	+	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
1771	+	}
1772	+	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1773	+	<< dr << endl;
1774	+	fGammaIso += pf->Pt();
1775	+	}
1776	+
1777	+	//
1778	+	// Neutral Iso
1779	+	//
1780	+	else {
1781	+	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
1782	+	<< dr << endl;
1783	+	// KH, add to sync
1784	+	if( pf->Pt() > 0.5 )
1785	+	fNeutralHadronIso += pf->Pt();
1786	+	}
1787	+
1788	+	}
1789	+
1790	+	}
1791	+
1792	+	//   double rho = 0;
1793	+	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1794	+	//     rho = fPUEnergyDensity->At(0)->Rho();
1795	+
1796	+	// WARNING!!!!
1797	+	// hardcode for sync ...
1798	+	EffectiveAreaVersion = eleT.kEleEAData2011;
1799	+	// WARNING!!!!
1800	+
1801	+
1802	+	double pfIso = fChargedIso +
1803	+	max(0.0,fGammaIso -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIso04,
1804	+	ele->Eta(),EffectiveAreaVersion)) +
1805	+	max(0.0,fNeutralHadronIso -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIso04,
1806	+	ele->Eta(),EffectiveAreaVersion)) ;
1807	+	return pfIso;
1808	+	}
1809	+
1810	+
1811	+	//--------------------------------------------------------------------------------------------------
1812	+	SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
1813	+	const mithep::Electron * ele,
1814	+	const mithep::Vertex & vtx,
1815	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1816	+	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1817	+	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1818	+	vector<const mithep::Muon*> muonsToVeto,
1819	+	vector<const mithep::Electron*> electronsToVeto)
1820	+	//--------------------------------------------------------------------------------------------------
1821	+	{
1822	+
1823	+	SelectionStatus status;
1824	+
1825	+	double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, fPUEnergyDensity,
1826	+	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1827	+	cout << "--------------> setting electron isoPF04 to " << pfIso << endl;
1828	+	status.isoPF04 = pfIso;
1829	+	status.chisoPF04 = gChargedIso;
1830	+	status.gaisoPF04 = gGammaIso;
1831	+	status.neisoPF04 = gNeutralIso;
1832	+
1833	+	bool pass = false;
1834	+	if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
1835	+
1836	+	if( pass ) {
1837	+	status.orStatus(SelectionStatus::LOOSEISO);
1838	+	status.orStatus(SelectionStatus::TIGHTISO);
1839	+	}
1840	+	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1841	+	return status;
1842	+
1843	+	}
1844	+
1845	+
1846	+	//--------------------------------------------------------------------------------------------------
1847	+	// hacked version
1848	+	SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
1849	+	const mithep::Electron * ele,
1850	+	const mithep::Vertex & vtx,
1851	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1852	+	float rho,
1853	+	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1854	+	vector<const mithep::Muon*> muonsToVeto,
1855	+	vector<const mithep::Electron*> electronsToVeto)
1856	+	//--------------------------------------------------------------------------------------------------
1857	+	{
1858	+
1859	+	SelectionStatus status;
1860	+
1861	+	double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, rho,
1862	+	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1863	+	bool pass = false;
1864	+	if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
1865	+
1866	+	if( pass ) {
1867	+	status.orStatus(SelectionStatus::LOOSEISO);
1868	+	status.orStatus(SelectionStatus::TIGHTISO);
1869	+	}
1870	+	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1871	+	return status;
1872	+
1873	+	}

Diff Legend

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