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.10 by khahn, Sat May 5 13:09:05 2012 UTC

#	Line 530 | Line 530 | SelectionStatus muonIsoMVASelection(Cont
530		ctrl.debug);
531
532		SelectionStatus status;
533	<	bool pass = false;
533	>	bool pass;
534
535	+	pass = false;
536		if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
537	<	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_FORPFID_CUT_BIN0)   pass = true;
537	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN0)   pass = true;
538		else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
539	<	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_FORPFID_CUT_BIN1)  pass = true;
539	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN1)  pass = true;
540		else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
541	<	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_FORPFID_CUT_BIN2)  pass = true;
541	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN2)  pass = true;
542		else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
543	<	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_FORPFID_CUT_BIN3)  pass = true;
544	<	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon()
545	<	&& mvaval >= MUON_ISOMVA_FORPFID_CUT_BIN4)
546	<	pass = true;
543	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN3)  pass = true;
544	>	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN4)  pass = true;
545	>	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN5)  pass = true;
546	>	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
547
548	+	pass = false;
549	+	if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
550	+	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN0)   pass = true;
551	+	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
552	+	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN1)  pass = true;
553	+	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
554	+	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN2)  pass = true;
555	+	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
556	+	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN3)  pass = true;
557	+	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN4)  pass = true;
558	+	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN5)  pass = true;
559	+	if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
560
561	<	pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
561	>	//  pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
562
550	–	if( pass ) {
551	–	status.orStatus(SelectionStatus::LOOSEISO);
552	–	status.orStatus(SelectionStatus::TIGHTISO);
553	–	}
563		if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
564		return status;
565
#	Line 573 | Line 582 | void initMuonIsoMVA() {
582		}
583
584
585	+	//--------------------------------------------------------------------------------------------------
586	+	double  muonPFIso04(ControlFlags &ctrl,
587	+	const mithep::Muon * mu,
588	+	const mithep::Vertex & vtx,
589	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
590	+	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
591	+	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
592	+	vector<const mithep::Muon*> muonsToVeto,
593	+	vector<const mithep::Electron*> electronsToVeto)
594	+	//--------------------------------------------------------------------------------------------------
595	+	{
596	+
597	+	if( ctrl.debug ) {
598	+	cout << "muonIsoMVASelection :: muons to veto " << endl;
599	+	for( int i=0; i<muonsToVeto.size(); i++ ) {
600	+	const mithep::Muon * vmu = muonsToVeto[i];
601	+	cout << "\tpt: " << vmu->Pt()
602	+	<< "\teta: " << vmu->Eta()
603	+	<< "\tphi: " << vmu->Phi()
604	+	<< endl;
605	+	}
606	+	cout << "muonIsoMVASelection :: electrson to veto " << endl;
607	+	for( int i=0; i<electronsToVeto.size(); i++ ) {
608	+	const mithep::Electron * vel = electronsToVeto[i];
609	+	cout << "\tpt: " << vel->Pt()
610	+	<< "\teta: " << vel->Eta()
611	+	<< "\tphi: " << vel->Phi()
612	+	<< endl;
613	+	}
614	+	}
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;
623	+
624	+	//
625	+	// final iso
626	+	//
627	+	Double_t fChargedIso;
628	+	Double_t fGammaIso;
629	+	Double_t fNeutralHadronIso;
630	+
631	+	//
632	+	//Loop over PF Candidates
633	+	//
634	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
635	+	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
636	+
637	+	Double_t deta = (mu->Eta() - pf->Eta());
638	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
639	+	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
640	+	if (dr > 0.4) continue;
641	+
642	+	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
643	+
644	+	//
645	+	// Lepton Footprint Removal
646	+	//
647	+	Bool_t IsLeptonFootprint = kFALSE;
648	+	if (dr < 1.0) {
649	+
650	+	//
651	+	// Check for electrons
652	+	//
653	+	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
654	+	const mithep::Electron *tmpele = electronsToVeto[q];
655	+	// 4l electron
656	+	if( pf->HasTrackerTrk() ) {
657	+	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
658	+	IsLeptonFootprint = kTRUE;
659	+	}
660	+	if( pf->HasGsfTrk() ) {
661	+	if( pf->GsfTrk() == tmpele->GsfTrk() )
662	+	IsLeptonFootprint = kTRUE;
663	+	}
664	+	// PF charged
665	+	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
666	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
667	+	IsLeptonFootprint = kTRUE;
668	+	// PF gamma
669	+	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
670	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
671	+	IsLeptonFootprint = kTRUE;
672	+	} // loop over electrons
673	+
674	+	//
675	+	// Check for muons
676	+	//
677	+	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
678	+	const mithep::Muon *tmpmu = muonsToVeto[q];
679	+	// 4l muon
680	+	if( pf->HasTrackerTrk() ) {
681	+	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
682	+	IsLeptonFootprint = kTRUE;
683	+	}
684	+	// PF charged
685	+	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
686	+	IsLeptonFootprint = kTRUE;
687	+	} // loop over muons
688	+
689	+
690	+	if (IsLeptonFootprint)
691	+	continue;
692	+
693	+	//
694	+	// Charged Iso Rings
695	+	//
696	+	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
697	+
698	+	if( dr < 0.01 ) continue; // only for muon iso mva?
699	+	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
700	+
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	+	}
713	+
714	+
715	+	tmpChargedIso += pf->Pt();
716	+	}
717	+
718	+	//
719	+	// Gamma Iso
720	+	//
721	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
722	+	tmpGammaIso += pf->Pt();
723	+	}
724	+
725	+	//
726	+	// Other Neutral Iso Rings
727	+	//
728	+	else {
729	+	tmpNeutralHadronIso += pf->Pt();
730	+	}
731	+
732	+	}
733	+
734	+	}
735	+
736	+	fChargedIso   = mu->Pt() * min((tmpChargedIso)/mu->Pt(), 2.5);
737	+
738	+
739	+	double rho = 0;
740	+	if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
741	+	rho = fPUEnergyDensity->At(0)->Rho();
742	+
743	+
744	+	fGammaIso = mu->Pt()*max(min((tmpGammaIso
745	+	-rho*muT.MuonEffectiveArea(muT.kMuGammaIso04,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
746	+	,2.5)
747	+	,0.0);
748	+	fNeutralHadronIso = mu->Pt()*max(min((tmpNeutralHadronIso
749	+	-rho*muT.MuonEffectiveArea(muT.kMuNeutralIso04,
750	+	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
751	+	, 2.5)
752	+	, 0.0);
753	+
754	+	double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso;
755	+
756	+	return pfIso;
757	+	}
758	+
759	+	//--------------------------------------------------------------------------------------------------
760	+	SelectionStatus muonIsoReferenceSelection(ControlFlags &ctrl,
761	+	const mithep::Muon * mu,
762	+	const mithep::Vertex & vtx,
763	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
764	+	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
765	+	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
766	+	vector<const mithep::Muon*> muonsToVeto,
767	+	vector<const mithep::Electron*> electronsToVeto)
768	+	//--------------------------------------------------------------------------------------------------
769	+	{
770	+
771	+	SelectionStatus status;
772	+
773	+	double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, fPUEnergyDensity,
774	+	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
775	+	bool pass = false;
776	+	if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
777	+
778	+	if( pass ) {
779	+	status.orStatus(SelectionStatus::LOOSEISO);
780	+	status.orStatus(SelectionStatus::TIGHTISO);
781	+	}
782	+	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
783	+	return status;
784	+
785	+	}
786	+
787	+
788
789		//--------------------------------------------------------------------------------------------------
790		SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
#	Line 931 | Line 1143 | SelectionStatus electronIsoMVASelection(
1143		if (subdet == 0 && ptBin == 1) MVABin = 3;
1144		if (subdet == 1 && ptBin == 1) MVABin = 4;
1145		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;
1146
1147	<	// pre-selection iso ...
1148	<	pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
1147	>	pass = false;
1148	>	if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN0 ) pass = true;
1149	>	if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN1 ) pass = true;
1150	>	if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN2 ) pass = true;
1151	>	if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN3 ) pass = true;
1152	>	if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN4 ) pass = true;
1153	>	if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN5 ) pass = true;
1154	>	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
1155	>
1156	>	pass = false;
1157	>	if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
1158	>	if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
1159	>	if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
1160	>	if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
1161	>	if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
1162	>	if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
1163	>	if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
1164
945	–	if( pass ) {
946	–	status.orStatus(SelectionStatus::LOOSEISO);
947	–	status.orStatus(SelectionStatus::TIGHTISO);
948	–	}
1165		if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1166		return status;
1167	<
1167	>
1168		}
1169
1170
#	Line 965 | Line 1181 | void initElectronIsoMVA() {
1181		mithep::ElectronIDMVA::kIsoRingsV0,
1182		kTRUE, weightFiles);
1183		}
1184	+
1185	+
1186	+
1187	+	//--------------------------------------------------------------------------------------------------
1188	+	float electronPFIso04(ControlFlags &ctrl,
1189	+	const mithep::Electron * ele,
1190	+	const mithep::Vertex & vtx,
1191	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1192	+	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1193	+	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1194	+	vector<const mithep::Muon*> muonsToVeto,
1195	+	vector<const mithep::Electron*> electronsToVeto)
1196	+	//--------------------------------------------------------------------------------------------------
1197	+	{
1198	+
1199	+	if( ctrl.debug ) {
1200	+	cout << "electronIsoMVASelection :: muons to veto " << endl;
1201	+	for( int i=0; i<muonsToVeto.size(); i++ ) {
1202	+	const mithep::Muon * vmu = muonsToVeto[i];
1203	+	cout << "\tpt: " << vmu->Pt()
1204	+	<< "\teta: " << vmu->Eta()
1205	+	<< "\tphi: " << vmu->Phi()
1206	+	<< endl;
1207	+	}
1208	+	cout << "electronIsoMVASelection :: electrson to veto " << endl;
1209	+	for( int i=0; i<electronsToVeto.size(); i++ ) {
1210	+	const mithep::Electron * vel = electronsToVeto[i];
1211	+	cout << "\tpt: " << vel->Pt()
1212	+	<< "\teta: " << vel->Eta()
1213	+	<< "\tphi: " << vel->Phi()
1214	+	<< "\ttrk: " << vel->TrackerTrk()
1215	+	<< endl;
1216	+	}
1217	+	}
1218	+
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;
1227	+
1228	+	//
1229	+	// final iso
1230	+	//
1231	+	Double_t fChargedIso;
1232	+	Double_t fGammaIso;
1233	+	Double_t fNeutralHadronIso;
1234	+
1235	+
1236	+	//
1237	+	//Loop over PF Candidates
1238	+	//
1239	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1240	+	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1241	+	Double_t deta = (ele->Eta() - pf->Eta());
1242	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1243	+	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1244	+	if (dr >= 0.4) continue;
1245	+	if(ctrl.debug) {
1246	+	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1247	+	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
1248	+	cout << endl;
1249	+	}
1250	+
1251	+
1252	+	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
1253	+	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1254	+
1255	+
1256	+	//
1257	+	// Lepton Footprint Removal
1258	+	//
1259	+	Bool_t IsLeptonFootprint = kFALSE;
1260	+	if (dr < 1.0) {
1261	+
1262	+	//
1263	+	// Check for electrons
1264	+	//
1265	+	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1266	+	const mithep::Electron *tmpele = electronsToVeto[q];
1267	+	// 4l electron
1268	+	if( pf->HasTrackerTrk()  ) {
1269	+	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1270	+	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1271	+	IsLeptonFootprint = kTRUE;
1272	+	}
1273	+	}
1274	+	if( pf->HasGsfTrk()  ) {
1275	+	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1276	+	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1277	+	IsLeptonFootprint = kTRUE;
1278	+	}
1279	+	}
1280	+	// PF charged
1281	+	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1282	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1283	+	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1284	+	IsLeptonFootprint = kTRUE;
1285	+	}
1286	+	// PF gamma
1287	+	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1288	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
1289	+	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1290	+	IsLeptonFootprint = kTRUE;
1291	+	}
1292	+	} // loop over electrons
1293	+
1294	+	//
1295	+	// Check for muons
1296	+	//
1297	+	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1298	+	const mithep::Muon *tmpmu = muonsToVeto[q];
1299	+	// 4l muon
1300	+	if( pf->HasTrackerTrk() ) {
1301	+	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1302	+	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1303	+	IsLeptonFootprint = kTRUE;
1304	+	}
1305	+	}
1306	+	// PF charged
1307	+	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1308	+	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1309	+	IsLeptonFootprint = kTRUE;
1310	+	}
1311	+	} // loop over muons
1312	+
1313	+
1314	+	if (IsLeptonFootprint)
1315	+	continue;
1316	+
1317	+	//
1318	+	// Charged Iso Rings
1319	+	//
1320	+	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1321	+
1322	+	if( pf->HasTrackerTrk() )
1323	+	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1324	+	if( pf->HasGsfTrk() )
1325	+	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1326	+
1327	+	// Veto any PFmuon, or PFEle
1328	+	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1329	+
1330	+	// Footprint Veto
1331	+	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1332	+
1333	+	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1334	+	<< "\ttype: " << pf->PFType()
1335	+	<< "\ttrk: " << pf->TrackerTrk() << endl;
1336	+
1337	+	tmpChargedIso += pf->Pt();
1338	+	}
1339	+
1340	+	//
1341	+	// Gamma Iso
1342	+	//
1343	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1344	+
1345	+	if (fabs(ele->SCluster()->Eta()) > 1.479) {
1346	+	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
1347	+	}
1348	+	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1349	+	<< dr << endl;
1350	+	tmpGammaIso += pf->Pt();
1351	+	}
1352	+
1353	+	//
1354	+	// Neutral Iso
1355	+	//
1356	+	else {
1357	+	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
1358	+	<< dr << endl;
1359	+	tmpNeutralHadronIso += pf->Pt();
1360	+	}
1361	+
1362	+	}
1363	+
1364	+	}
1365	+
1366	+	fChargedIso   = ele->Pt()*min((tmpChargedIso)/ele->Pt(), 2.5);
1367	+
1368	+	double rho = 0;
1369	+	if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1370	+	rho = fPUEnergyDensity->At(0)->Rho();
1371	+
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	+	}
1393	+
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);
1405	+
1406	+	double pfiso = fChargedIso + fGammaIso + fNeutralHadronIso;
1407	+
1408	+	return pfiso;
1409	+	}
1410	+
1411	+	//--------------------------------------------------------------------------------------------------
1412	+	SelectionStatus electronIsoReferenceSelection(ControlFlags &ctrl,
1413	+	const mithep::Electron * ele,
1414	+	const mithep::Vertex & vtx,
1415	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1416	+	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1417	+	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1418	+	vector<const mithep::Muon*> muonsToVeto,
1419	+	vector<const mithep::Electron*> electronsToVeto)
1420	+	//--------------------------------------------------------------------------------------------------
1421	+	{
1422	+
1423	+	SelectionStatus status;
1424	+
1425	+	double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, fPUEnergyDensity,
1426	+	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1427	+	bool pass = false;
1428	+	if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
1429	+
1430	+	if( pass ) {
1431	+	status.orStatus(SelectionStatus::LOOSEISO);
1432	+	status.orStatus(SelectionStatus::TIGHTISO);
1433	+	}
1434	+	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1435	+	return status;
1436	+
1437	+	}

Diff Legend

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