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.10 by khahn, Sat May 5 13:09:05 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;
#	Line 612 | Line 628 | double  muonPFIso04(ControlFlags &ctrl,
628		<< endl;
629		}
630		}
615	–	bool failiso=false;
631
632		//
633	<	// tmp iso
633	>	// final iso
634		//
635	<	Double_t tmpChargedIso        = 0;
636	<	Double_t tmpGammaIso          = 0;
637	<	Double_t tmpNeutralHadronIso  = 0;
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;
813	<	Double_t fGammaIso;
814	<	Double_t fNeutralHadronIso;
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
#	Line 670 | Line 855 | double  muonPFIso04(ControlFlags &ctrl,
855		&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
856		IsLeptonFootprint = kTRUE;
857		} // loop over electrons
858	<
858	>
859	>	/* KH - comment for sync
860		//
861		// Check for muons
862		//
#	Line 685 | Line 871 | double  muonPFIso04(ControlFlags &ctrl,
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	<
874	>	*/
875
876		if (IsLeptonFootprint)
877		continue;
878
879		//
880	<	// Charged Iso Rings
880	>	// Charged Iso
881		//
882		if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
883
#	Line 712 | Line 898 | double  muonPFIso04(ControlFlags &ctrl,
898		}
899
900
901	<	tmpChargedIso += pf->Pt();
901	>	fChargedIso += pf->Pt();
902		}
903
904		//
905		// Gamma Iso
906		//
907		else if (abs(pf->PFType()) == PFCandidate::eGamma) {
908	<	tmpGammaIso += pf->Pt();
908	>	if( pf->Pt() > 0.5 )
909	>	fGammaIso += pf->Pt();
910		}
911
912		//
913	<	// Other Neutral Iso Rings
913	>	// Other Neutrals
914		//
915		else {
916	<	tmpNeutralHadronIso += pf->Pt();
916	>	// KH, add to sync
917	>	if( pf->Pt() > 0.5 )
918	>	fNeutralHadronIso += pf->Pt();
919		}
920
921		}
922
923		}
924
925	<	fChargedIso   = mu->Pt() * min((tmpChargedIso)/mu->Pt(), 2.5);
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	<	double rho = 0;
946	<	if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
947	<	rho = fPUEnergyDensity->At(0)->Rho();
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	<
959	<	fGammaIso = mu->Pt()*max(min((tmpGammaIso
960	<	-rho*muT.MuonEffectiveArea(muT.kMuGammaIso04,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
961	<	,2.5)
962	<	,0.0);
963	<	fNeutralHadronIso = mu->Pt()*max(min((tmpNeutralHadronIso
964	<	-rho*muT.MuonEffectiveArea(muT.kMuNeutralIso04,
965	<	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
966	<	, 2.5)
752	<	, 0.0);
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	<	double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso;
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
756	–	return pfIso;
978		}
979
980	+
981		//--------------------------------------------------------------------------------------------------
982	<	SelectionStatus muonIsoReferenceSelection(ControlFlags &ctrl,
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	<	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
987	>	float rho,
988		mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
989		vector<const mithep::Muon*> muonsToVeto,
990		vector<const mithep::Electron*> electronsToVeto)
#	Line 770 | Line 993 | SelectionStatus muonIsoReferenceSelectio
993
994		SelectionStatus status;
995
996	<	double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, fPUEnergyDensity,
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;
#	Line 925 | 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 944 | Line 1168 | SelectionStatus electronIsoMVASelection(
1168		IsLeptonFootprint = kTRUE;
1169		}
1170		} // loop over muons
1171	<
1171	>	*/
1172
1173		if (IsLeptonFootprint)
1174		continue;
#	Line 1024 | 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 1153 | Line 1384 | SelectionStatus electronIsoMVASelection(
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);
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
1396		if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1397		return status;
#	Line 1216 | Line 1447 | float electronPFIso04(ControlFlags &ctrl
1447		}
1448		}
1449
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;
1450
1451		//
1452		// final iso
1453		//
1454	<	Double_t fChargedIso;
1455	<	Double_t fGammaIso;
1456	<	Double_t fNeutralHadronIso;
1454	>	Double_t fChargedIso = 0.0;
1455	>	Double_t fGammaIso = 0.0;
1456	>	Double_t fNeutralHadronIso = 0.0;
1457
1458
1459		//
#	Line 1290 | Line 1513 | float electronPFIso04(ControlFlags &ctrl
1513		IsLeptonFootprint = kTRUE;
1514		}
1515		} // loop over electrons
1516	<
1516	>
1517	>
1518		//
1519		// Check for muons
1520		//
#	Line 1315 | Line 1539 | float electronPFIso04(ControlFlags &ctrl
1539		continue;
1540
1541		//
1542	<	// Charged Iso Rings
1542	>	// Charged Iso
1543		//
1544	<	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1544	>	if (pf->Charge() != 0 ) {
1545
1546		if( pf->HasTrackerTrk() )
1547		if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
#	Line 1334 | Line 1558 | float electronPFIso04(ControlFlags &ctrl
1558		<< "\ttype: " << pf->PFType()
1559		<< "\ttrk: " << pf->TrackerTrk() << endl;
1560
1561	<	tmpChargedIso += pf->Pt();
1561	>	fChargedIso += pf->Pt();
1562		}
1563
1564		//
#	Line 1347 | Line 1571 | float electronPFIso04(ControlFlags &ctrl
1571		}
1572		if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1573		<< dr << endl;
1574	<	tmpGammaIso += pf->Pt();
1574	>	if( pf->Pt() > 0.5 )
1575	>	fGammaIso += pf->Pt();
1576		}
1577
1578		//
#	Line 1356 | Line 1581 | float electronPFIso04(ControlFlags &ctrl
1581		else {
1582		if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
1583		<< dr << endl;
1584	<	tmpNeutralHadronIso += pf->Pt();
1584	>	if( pf->Pt() > 0.5 )
1585	>	fNeutralHadronIso += pf->Pt();
1586		}
1587
1588		}
1589
1590		}
1591
1366	–	fChargedIso   = ele->Pt()*min((tmpChargedIso)/ele->Pt(), 2.5);
1367	–
1592		double rho = 0;
1593	<	if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1594	<	rho = fPUEnergyDensity->At(0)->Rho();
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	<	if( ctrl.debug) {
1615	<	cout << "RHO: " << rho << endl;
1616	<	cout << "eta: " << ele->SCluster()->Eta() << endl;
1617	<	cout << "target: " << EffectiveAreaVersion << endl;
1618	<	cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1619	<	ele->SCluster()->Eta(),
1620	<	EffectiveAreaVersion)
1621	<	<< endl;
1622	<	cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1623	<	ele->SCluster()->Eta(),
1624	<	EffectiveAreaVersion)
1625	<	<< endl;
1626	<	cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1627	<	ele->SCluster()->Eta(),
1628	<	EffectiveAreaVersion)
1629	<	<< endl;
1630	<	cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1631	<	ele->SCluster()->Eta(),
1632	<	EffectiveAreaVersion)
1633	<	<< endl;
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
1394	–	fGammaIso = ele->Pt()*max(min((tmpGammaIso
1395	–	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIso04,
1396	–	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);
1650
1651	<	double pfiso = fChargedIso + fGammaIso + fNeutralHadronIso;
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	<	return pfiso;
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 electronIsoReferenceSelection(ControlFlags &ctrl,
1812	>	SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
1813		const mithep::Electron * ele,
1814		const mithep::Vertex & vtx,
1815		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
#	Line 1424 | Line 1824 | SelectionStatus electronIsoReferenceSele
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

Diff Legend

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