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.31 by khahn, Tue Jun 12 01:23:03 2012 UTC vs.
Revision 1.35 by dkralph, Mon Dec 17 17:12:27 2012 UTC

#	Line 9 | Line 9
9		#include "ElectronTools.h"
10		#include "ElectronIDMVA.h"
11
12	<	using namespace mithep;
13	<
14	<	mithep::MuonIDMVA     * muIsoMVA;
15	<	mithep::MuonTools       muT;
16	<	mithep::ElectronIDMVA * eleIsoMVA;
17	<	mithep::ElectronTools   eleT;
12	>	MuonIDMVA     * muIsoMVA;
13	>	MuonTools       muT;
14	>	ElectronIDMVA * eleIsoMVA;
15	>	ElectronTools   eleT;
16
17		// global hack to sync
18		double gChargedIso;
#	Line 24 | Line 22 | double gNeutralIso;
22		extern vector<bool> PFnoPUflag;
23
24		//--------------------------------------------------------------------------------------------------
25	<	Float_t computePFMuonIso(const mithep::Muon *muon,
26	<	const mithep::Vertex * vtx,
27	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
25	>	Float_t computePFMuonIso(const Muon *muon,
26	>	const Vertex * vtx,
27	>	const Array<PFCandidate> * fPFCandidates,
28		const Double_t dRMax)
29		//--------------------------------------------------------------------------------------------------
30		{
#	Line 59 | Line 57 | Float_t computePFMuonIso(const mithep::M
57		}
58
59		//--------------------------------------------------------------------------------------------------
60	<	Float_t computePFEleIso(const mithep::Electron *electron,
61	<	const mithep::Vertex * fVertex,
62	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
60	>	Float_t computePFEleIso(const Electron *electron,
61	>	const Vertex * fVertex,
62	>	const Array<PFCandidate> * fPFCandidates,
63		const Double_t dRMax)
64		//--------------------------------------------------------------------------------------------------
65		{
#	Line 101 | Line 99 | Float_t computePFEleIso(const mithep::El
99
100		return iso;
101		};
104	–
105	–	//--------------------------------------------------------------------------------------------------
106	–	bool pairwiseIsoSelection( ControlFlags &ctrl,
107	–	vector<SimpleLepton> &lepvec,
108	–	float rho )
109	–	//--------------------------------------------------------------------------------------------------
110	–	{
111	–
112	–	bool passiso=true;
113	–
114	–	for( int i=0; i<lepvec.size(); i++ )
115	–	{
116	–
117	–	if( !(lepvec[i].is4l) ) continue;
118	–
119	–	float effArea_ecal_i, effArea_hcal_i;
120	–	if( lepvec[i].isEB ) {
121	–	if( lepvec[i].type == 11 ) {
122	–	effArea_ecal_i = 0.101;
123	–	effArea_hcal_i = 0.021;
124	–	} else {
125	–	effArea_ecal_i = 0.074;
126	–	effArea_hcal_i = 0.022;
127	–	}
128	–	} else {
129	–	if( lepvec[i].type == 11 ) {
130	–	effArea_ecal_i = 0.046;
131	–	effArea_hcal_i = 0.040;
132	–	} else {
133	–	effArea_ecal_i = 0.045;
134	–	effArea_hcal_i = 0.030;
135	–	}
136	–	}
137	–
138	–	float isoEcal_corr_i = lepvec[i].isoEcal - (effArea_ecal_i*rho);
139	–	float isoHcal_corr_i = lepvec[i].isoHcal - (effArea_hcal_i*rho);
140	–
141	–	for( int j=i+1; j<lepvec.size(); j++ )
142	–	{
143	–
144	–	if( !(lepvec[j].is4l) ) continue;
145	–
146	–	float effArea_ecal_j, effArea_hcal_j;
147	–	if( lepvec[j].isEB ) {
148	–	if( lepvec[j].type == 11 ) {
149	–	effArea_ecal_j = 0.101;
150	–	effArea_hcal_j = 0.021;
151	–	} else {
152	–	effArea_ecal_j = 0.074;
153	–	effArea_hcal_j = 0.022;
154	–	}
155	–	} else {
156	–	if( lepvec[j].type == 11 ) {
157	–	effArea_ecal_j = 0.046;
158	–	effArea_hcal_j = 0.040;
159	–	} else {
160	–	effArea_ecal_j = 0.045;
161	–	effArea_hcal_j = 0.030;
162	–	}
163	–	}
164	–
165	–	float isoEcal_corr_j = lepvec[j].isoEcal - (effArea_ecal_j*rho);
166	–	float isoHcal_corr_j = lepvec[j].isoHcal - (effArea_hcal_j*rho);
167	–	float RIso_i = (lepvec[i].isoTrk+isoEcal_corr_i+isoHcal_corr_i)/lepvec[i].vec.Pt();
168	–	float RIso_j = (lepvec[j].isoTrk+isoEcal_corr_j+isoHcal_corr_j)/lepvec[j].vec.Pt();
169	–	float comboIso = RIso_i + RIso_j;
170	–
171	–	if( comboIso > 0.35 ) {
172	–	if( ctrl.debug ) cout << "combo failing for indices: " << i << "," << j << endl;
173	–	passiso = false;
174	–	return passiso;
175	–	}
176	–	}
177	–	}
178	–
179	–	return passiso;
180	–	}
181	–
102		//--------------------------------------------------------------------------------------------------
103		SelectionStatus muonIsoSelection(ControlFlags &ctrl,
104	<	const mithep::Muon * mu,
105	<	const mithep::Vertex * vtx,
106	<	const mithep::Array<mithep::PFCandidate> * fPFCandidateCol   )
104	>	const Muon * mu,
105	>	const Vertex * vtx,
106	>	const Array<PFCandidate> * fPFCandidateCol   )
107		//--------------------------------------------------------------------------------------------------
108		{
109		float reliso = computePFMuonIso(mu,vtx,fPFCandidateCol,0.3)/mu->Pt();
#	Line 211 | Line 131 | SelectionStatus muonIsoSelection(Control
131
132		//--------------------------------------------------------------------------------------------------
133		SelectionStatus electronIsoSelection(ControlFlags &ctrl,
134	<	const mithep::Electron * ele,
135	<	const mithep::Vertex *fVertex,
136	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates)
134	>	const Electron * ele,
135	>	const Vertex *fVertex,
136	>	const Array<PFCandidate> * fPFCandidates)
137		//--------------------------------------------------------------------------------------------------
138		{
139
#	Line 250 | Line 170 | bool noIso(ControlFlags &, vector<Simple
170		return true;
171		}
172
253	–
173		//--------------------------------------------------------------------------------------------------
174		SelectionStatus muonIsoMVASelection(ControlFlags &ctrl,
175	<	const mithep::Muon * mu,
176	<	const mithep::Vertex * vtx,
177	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
178	<	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
179	<	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
180	<	vector<const mithep::Muon*> muonsToVeto,
181	<	vector<const mithep::Electron*> electronsToVeto)
175	>	const Muon * mu,
176	>	const Vertex * vtx,
177	>	const Array<PFCandidate> * fPFCandidates,
178	>	const Array<PileupEnergyDensity> * fPUEnergyDensity,
179	>	MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
180	>	vector<const Muon*> muonsToVeto,
181	>	vector<const Electron*> electronsToVeto)
182		//--------------------------------------------------------------------------------------------------
183		{
184
185		if( ctrl.debug ) {
186		cout << "muonIsoMVASelection :: muons to veto " << endl;
187		for( int i=0; i<muonsToVeto.size(); i++ ) {
188	<	const mithep::Muon * vmu = muonsToVeto[i];
188	>	const Muon * vmu = muonsToVeto[i];
189		cout << "\tpt: " << vmu->Pt()
190		<< "\teta: " << vmu->Eta()
191		<< "\tphi: " << vmu->Phi()
#	Line 274 | Line 193 | SelectionStatus muonIsoMVASelection(Cont
193		}
194		cout << "muonIsoMVASelection :: electrson to veto " << endl;
195		for( int i=0; i<electronsToVeto.size(); i++ ) {
196	<	const mithep::Electron * vel = electronsToVeto[i];
196	>	const Electron * vel = electronsToVeto[i];
197		cout << "\tpt: " << vel->Pt()
198		<< "\teta: " << vel->Eta()
199		<< "\tphi: " << vel->Phi()
#	Line 341 | Line 260 | SelectionStatus muonIsoMVASelection(Cont
260
261		if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
262
263	<	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
263	>	const PFCandidate *pf = (PFCandidate*)((*fPFCandidates)[k]);
264
265		Double_t deta = (mu->Eta() - pf->Eta());
266	<	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
267	<	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
266	>	Double_t dphi = MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
267	>	Double_t dr = MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
268		if (dr > 1.0) continue;
269
270		if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
#	Line 360 | Line 279 | SelectionStatus muonIsoMVASelection(Cont
279		// Check for electrons
280		//
281		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
282	<	const mithep::Electron *tmpele = electronsToVeto[q];
282	>	const Electron *tmpele = electronsToVeto[q];
283		// 4l electron
284		if( pf->HasTrackerTrk() ) {
285		if( pf->TrackerTrk() == tmpele->TrackerTrk() )
#	Line 372 | Line 291 | SelectionStatus muonIsoMVASelection(Cont
291		}
292		// PF charged
293		if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479
294	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
294	>	&& MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
295		IsLeptonFootprint = kTRUE;
296		// PF gamma
297		if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
298	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
298	>	&& MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
299		IsLeptonFootprint = kTRUE;
300		} // loop over electrons
301
#	Line 385 | Line 304 | SelectionStatus muonIsoMVASelection(Cont
304		// Check for muons
305		//
306		for (Int_t q=0; q < muonsToVeto.size(); ++q) {
307	<	const mithep::Muon *tmpmu = muonsToVeto[q];
307	>	const Muon *tmpmu = muonsToVeto[q];
308		// 4l muon
309		if( pf->HasTrackerTrk() ) {
310		if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
311		IsLeptonFootprint = kTRUE;
312		}
313		// PF charged
314	<	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
314	>	if (pf->Charge() != 0 && MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
315		IsLeptonFootprint = kTRUE;
316		} // loop over muons
317		*/
#	Line 595 | Line 514 | SelectionStatus muonIsoMVASelection(Cont
514
515		//--------------------------------------------------------------------------------------------------
516		SelectionStatus muonIsoMVASelection(ControlFlags &ctrl,
517	<	const mithep::Muon * mu,
518	<	const mithep::Vertex * vtx,
519	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
517	>	const Muon * mu,
518	>	const Vertex * vtx,
519	>	const Array<PFCandidate> * fPFCandidates,
520		float rho,
521	<	//const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
522	<	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
523	<	vector<const mithep::Muon*> muonsToVeto,
524	<	vector<const mithep::Electron*> electronsToVeto)
521	>	//const Array<PileupEnergyDensity> * fPUEnergyDensity,
522	>	MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
523	>	vector<const Muon*> muonsToVeto,
524	>	vector<const Electron*> electronsToVeto)
525		//--------------------------------------------------------------------------------------------------
526		// hacked version
527		{
#	Line 610 | Line 529 | SelectionStatus muonIsoMVASelection(Cont
529		if( ctrl.debug ) {
530		cout << "muonIsoMVASelection :: muons to veto " << endl;
531		for( int i=0; i<muonsToVeto.size(); i++ ) {
532	<	const mithep::Muon * vmu = muonsToVeto[i];
532	>	const Muon * vmu = muonsToVeto[i];
533		cout << "\tpt: " << vmu->Pt()
534		<< "\teta: " << vmu->Eta()
535		<< "\tphi: " << vmu->Phi()
#	Line 618 | Line 537 | SelectionStatus muonIsoMVASelection(Cont
537		}
538		cout << "muonIsoMVASelection :: electrson to veto " << endl;
539		for( int i=0; i<electronsToVeto.size(); i++ ) {
540	<	const mithep::Electron * vel = electronsToVeto[i];
540	>	const Electron * vel = electronsToVeto[i];
541		cout << "\tpt: " << vel->Pt()
542		<< "\teta: " << vel->Eta()
543		<< "\tphi: " << vel->Phi()
#	Line 685 | Line 604 | SelectionStatus muonIsoMVASelection(Cont
604
605		if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
606
607	<	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
607	>	const PFCandidate *pf = (PFCandidate*)((*fPFCandidates)[k]);
608
609		Double_t deta = (mu->Eta() - pf->Eta());
610	<	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
611	<	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
610	>	Double_t dphi = MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
611	>	Double_t dr = MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
612		if (dr > 1.0) continue;
613
614		if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
#	Line 704 | Line 623 | SelectionStatus muonIsoMVASelection(Cont
623		// Check for electrons
624		//
625		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
626	<	const mithep::Electron *tmpele = electronsToVeto[q];
626	>	const Electron *tmpele = electronsToVeto[q];
627		// 4l electron
628		if( pf->HasTrackerTrk() ) {
629		if( pf->TrackerTrk() == tmpele->TrackerTrk() )
#	Line 716 | Line 635 | SelectionStatus muonIsoMVASelection(Cont
635		}
636		// PF charged
637		if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479
638	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
638	>	&& MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
639		IsLeptonFootprint = kTRUE;
640		// PF gamma
641		if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
642	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
642	>	&& MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
643		IsLeptonFootprint = kTRUE;
644		} // loop over electrons
645
#	Line 729 | Line 648 | SelectionStatus muonIsoMVASelection(Cont
648		// Check for muons
649		//
650		for (Int_t q=0; q < muonsToVeto.size(); ++q) {
651	<	const mithep::Muon *tmpmu = muonsToVeto[q];
651	>	const Muon *tmpmu = muonsToVeto[q];
652		// 4l muon
653		if( pf->HasTrackerTrk() ) {
654		if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
655		IsLeptonFootprint = kTRUE;
656		}
657		// PF charged
658	<	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
658	>	if (pf->Charge() != 0 && MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
659		IsLeptonFootprint = kTRUE;
660		} // loop over muons
661		*/
#	Line 939 | Line 858 | SelectionStatus muonIsoMVASelection(Cont
858		//--------------------------------------------------------------------------------------------------
859		void initMuonIsoMVA() {
860		//--------------------------------------------------------------------------------------------------
861	<	muIsoMVA = new mithep::MuonIDMVA();
861	>	muIsoMVA = new MuonIDMVA();
862		vector<string> weightFiles;
863		weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_barrel_lowpt.weights.xml");
864		weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_barrel_highpt.weights.xml");
#	Line 948 | Line 867 | void initMuonIsoMVA() {
867		weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_tracker.weights.xml");
868		weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_global.weights.xml");
869		muIsoMVA->Initialize( "MuonIsoMVA",
870	<	mithep::MuonIDMVA::kIsoRingsV0,
870	>	MuonIDMVA::kIsoRingsV0,
871		kTRUE, weightFiles);
872		}
873
874
875
957	–
876		//--------------------------------------------------------------------------------------------------
877		double  muonPFIso04(ControlFlags &ctrl,
878	<	const mithep::Muon * mu,
879	<	const mithep::Vertex * vtx,
880	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
881	<	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
882	<	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
883	<	vector<const mithep::PFCandidate*> photonsToVeto)
878	>	const Muon * mu,
879	>	const Vertex * vtx,
880	>	const Array<PFCandidate> * fPFCandidates,
881	>	const Array<PileupEnergyDensity> * fPUEnergyDensity,
882	>	MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
883	>	vector<const PFCandidate*> photonsToVeto)
884		//--------------------------------------------------------------------------------------------------
885		{
886
#	Line 980 | Line 898 | double  muonPFIso04(ControlFlags &ctrl,
898		//
899		//Loop over PF Candidates
900		//
901	+	if(ctrl.debug) cout << "  muonPFIso04(): ----> " << endl;
902		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
903
904		if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
905	<	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
905	>	const PFCandidate *pf = (PFCandidate*)((*fPFCandidates)[k]);
906
907		//
908		// veto FSR recovered photons
#	Line 1000 | Line 919 | double  muonPFIso04(ControlFlags &ctrl,
919		//
920
921		Double_t deta = (mu->Eta() - pf->Eta());
922	<	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
923	<	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
922	>	Double_t dphi = MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
923	>	Double_t dr = MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
924		if (dr > 0.4) continue;
925
926		if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
#	Line 1021 | Line 940 | double  muonPFIso04(ControlFlags &ctrl,
940		//
941		else if (abs(pf->PFType()) == PFCandidate::eGamma) {
942		// KH, add to sync
943	<	if( pf->Pt() > 0.5 )
943	>	if( pf->Pt() > 0.5 && dr > 0.01)
944		fGammaIso += pf->Pt();
945		}
946
#	Line 1029 | Line 948 | double  muonPFIso04(ControlFlags &ctrl,
948		// Other Neutrals
949		//
950		else {
951	<	if( pf->Pt() > 0.5 )
951	>
952	>	if( pf->Pt() > 0.5  && dr > 0.01)
953		fNeutralHadronIso += pf->Pt();
954		}
955		}
956
957		double rho=0;
958	<	if( (EffectiveAreaVersion == mithep::MuonTools::kMuEAFall11MC) ||
959	<	(EffectiveAreaVersion == mithep::MuonTools::kMuEAData2011) ) {
958	>	if( (EffectiveAreaVersion == MuonTools::kMuEAFall11MC) ||
959	>	(EffectiveAreaVersion == MuonTools::kMuEAData2011) ) {
960		if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25()) ||
961		isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25())))
962		rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25();
963		//rho = fPUEnergyDensity->At(0)->Rho();
964		// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
965	<	EffectiveAreaVersion  = mithep::MuonTools::kMuEAData2011;
965	>	EffectiveAreaVersion  = MuonTools::kMuEAData2011;
966		// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
967		} else {
968		if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral()) ||
969		isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral())))
970		rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral();
971		// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
972	<	EffectiveAreaVersion  = mithep::MuonTools::kMuEAData2012;
972	>	EffectiveAreaVersion  = MuonTools::kMuEAData2012;
973		// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
974		}
975	<	if(ctrl.debug) cout << "rho: " << rho << endl;
975	>	// if(ctrl.debug) cout << "    rho: " << rho << endl;
976
977		TLorentzVector  tmpvec;
978		tmpvec.SetPtEtaPhiM(mu->Pt(),mu->Eta(),mu->Phi(),mu->Mass());
979		for( int p=0; p<photonsToVeto.size(); p++ ) {
980	<	const mithep::PFCandidate * pf  = photonsToVeto[p];
980	>	const PFCandidate * pf  = photonsToVeto[p];
981		TLorentzVector pfvec;
982		pfvec.SetPtEtaPhiM(pf->Pt(),pf->Eta(),pf->Phi(),0.);
983		tmpvec += pfvec;
#	Line 1072 | Line 992 | double  muonPFIso04(ControlFlags &ctrl,
992		gNeutralIso = fNeutralHadronIso;
993
994		if( ctrl.debug ) {
995	<	cout << "PFiso: " << pfIso
996	<	<< "\tfChargedIso: " << fChargedIso
997	<	<< "\tfGammaIso: " << fGammaIso
998	<	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
995	>	cout << "    PFiso: " << pfIso
996	>	<< setw(9) << setprecision(4) << fChargedIso
997	>	<< setw(9) << setprecision(4) << fGammaIso
998	>	<< setw(9) << setprecision(4) << fNeutralHadronIso
999		<< endl;
1000		}
1001
1002		return pfIso;
1003		}
1004
1085	–
1086	–
1087	–
1088	–	//--------------------------------------------------------------------------------------------------
1089	–	// hacked version
1090	–	double  muonPFIso04(ControlFlags &ctrl,
1091	–	const mithep::Muon * mu,
1092	–	const mithep::Vertex * vtx,
1093	–	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1094	–	float rho,
1095	–	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1096	–	vector<const mithep::Muon*> muonsToVeto,
1097	–	vector<const mithep::Electron*> electronsToVeto)
1098	–	//--------------------------------------------------------------------------------------------------
1099	–	{
1100	–
1101	–	extern double gChargedIso;
1102	–	extern double  gGammaIso;
1103	–	extern double  gNeutralIso;
1104	–
1105	–	if( ctrl.debug ) {
1106	–	cout << "muonIsoMVASelection :: muons to veto " << endl;
1107	–	for( int i=0; i<muonsToVeto.size(); i++ ) {
1108	–	const mithep::Muon * vmu = muonsToVeto[i];
1109	–	cout << "\tpt: " << vmu->Pt()
1110	–	<< "\teta: " << vmu->Eta()
1111	–	<< "\tphi: " << vmu->Phi()
1112	–	<< endl;
1113	–	}
1114	–	cout << "muonIsoMVASelection :: electrson to veto " << endl;
1115	–	for( int i=0; i<electronsToVeto.size(); i++ ) {
1116	–	const mithep::Electron * vel = electronsToVeto[i];
1117	–	cout << "\tpt: " << vel->Pt()
1118	–	<< "\teta: " << vel->Eta()
1119	–	<< "\tphi: " << vel->Phi()
1120	–	<< endl;
1121	–	}
1122	–	}
1123	–
1124	–	//
1125	–	// final iso
1126	–	//
1127	–	Double_t fChargedIso  = 0.0;
1128	–	Double_t fGammaIso  = 0.0;
1129	–	Double_t fNeutralHadronIso  = 0.0;
1130	–
1131	–	//
1132	–	//Loop over PF Candidates
1133	–	//
1134	–	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1135	–
1136	–	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1137	–	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1138	–
1139	–	Double_t deta = (mu->Eta() - pf->Eta());
1140	–	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
1141	–	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
1142	–	if (dr > 0.4) continue;
1143	–
1144	–	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
1145	–
1146	–	//
1147	–	// Lepton Footprint Removal
1148	–	//
1149	–	Bool_t IsLeptonFootprint = kFALSE;
1150	–	if (dr < 1.0) {
1151	–
1152	–	//
1153	–	// Check for electrons
1154	–	//
1155	–	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1156	–	const mithep::Electron *tmpele = electronsToVeto[q];
1157	–	// 4l electron
1158	–	if( pf->HasTrackerTrk() ) {
1159	–	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
1160	–	IsLeptonFootprint = kTRUE;
1161	–	}
1162	–	if( pf->HasGsfTrk() ) {
1163	–	if( pf->GsfTrk() == tmpele->GsfTrk() )
1164	–	IsLeptonFootprint = kTRUE;
1165	–	}
1166	–	// PF charged
1167	–	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1168	–	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
1169	–	IsLeptonFootprint = kTRUE;
1170	–	// PF gamma
1171	–	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1172	–	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
1173	–	IsLeptonFootprint = kTRUE;
1174	–	} // loop over electrons
1175	–
1176	–	/* KH - comment for sync
1177	–	//
1178	–	// Check for muons
1179	–	//
1180	–	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1181	–	const mithep::Muon *tmpmu = muonsToVeto[q];
1182	–	// 4l muon
1183	–	if( pf->HasTrackerTrk() ) {
1184	–	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
1185	–	IsLeptonFootprint = kTRUE;
1186	–	}
1187	–	// PF charged
1188	–	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
1189	–	IsLeptonFootprint = kTRUE;
1190	–	} // loop over muons
1191	–	*/
1192	–
1193	–	if (IsLeptonFootprint)
1194	–	continue;
1195	–
1196	–	//
1197	–	// Charged Iso
1198	–	//
1199	–	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1200	–
1201	–	//if( dr < 0.01 ) continue; // only for muon iso mva?
1202	–	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1203	–
1204	–
1205	–	//       if( pf->HasTrackerTrk() ) {
1206	–	//      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1207	–	//      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1208	–	//                            << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1209	–	//                            << dr << endl;
1210	–	//       }
1211	–	//       if( pf->HasGsfTrk() ) {
1212	–	//      if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1213	–	//      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1214	–	//                            << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1215	–	//                            << dr << endl;
1216	–	//       }
1217	–
1218	–
1219	–	fChargedIso += pf->Pt();
1220	–	}
1221	–
1222	–	//
1223	–	// Gamma Iso
1224	–	//
1225	–	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1226	–	// KH, add to sync
1227	–	if( pf->Pt() > 0.5 )
1228	–	fGammaIso += pf->Pt();
1229	–	}
1230	–
1231	–	//
1232	–	// Other Neutrals
1233	–	//
1234	–	else {
1235	–	// KH, add to sync
1236	–	if( pf->Pt() > 0.5 )
1237	–	fNeutralHadronIso += pf->Pt();
1238	–	}
1239	–
1240	–	}
1241	–
1242	–	}
1243	–
1244	–	//   double rho = 0;
1245	–	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1246	–	//     rho = fPUEnergyDensity->At(0)->Rho();
1247	–
1248	–	// WARNING!!!!
1249	–	// hardcode for sync ...
1250	–	EffectiveAreaVersion = muT.kMuEAData2011;
1251	–	// WARNING!!!!
1252	–
1253	–
1254	–	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1255	–	-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1256	–	mu->Eta(),EffectiveAreaVersion)));
1257	–	gChargedIso = fChargedIso;
1258	–	gGammaIso   = fGammaIso;
1259	–	gNeutralIso = fNeutralHadronIso;
1260	–
1261	–	return pfIso;
1262	–	}
1263	–
1264	–
1005		//--------------------------------------------------------------------------------------------------
1006		SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1007	<	const mithep::Muon * mu,
1008	<	const mithep::Vertex * vtx,
1009	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1010	<	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1011	<	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1012	<	vector<const mithep::PFCandidate*> photonsToVeto)
1007	>	const Muon * mu,
1008	>	const Vertex * vtx,
1009	>	const Array<PFCandidate> * fPFCandidates,
1010	>	const Array<PileupEnergyDensity> * fPUEnergyDensity,
1011	>	MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1012	>	vector<const PFCandidate*> photonsToVeto)
1013		//--------------------------------------------------------------------------------------------------
1014		{
1015
#	Line 1277 | Line 1017 | SelectionStatus muonReferenceIsoSelectio
1017
1018		double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, fPUEnergyDensity,
1019		EffectiveAreaVersion, photonsToVeto);
1280	–	//  cout << "--------------> setting muon isoPF04 to" << pfIso << endl;
1020		status.isoPF04 = pfIso;
1021		status.chisoPF04 = gChargedIso;
1022		status.gaisoPF04 = gGammaIso;
#	Line 1290 | Line 1029 | SelectionStatus muonReferenceIsoSelectio
1029		status.orStatus(SelectionStatus::LOOSEISO);
1030		status.orStatus(SelectionStatus::TIGHTISO);
1031		}
1032	<	if(ctrl.debug) {
1033	<	cout << "mu relpfIso: " << pfIso/mu->Pt() << endl;
1295	<	cout << "returning status : " << hex << status.getStatus() << dec << endl;
1296	<	}
1032	>	if(ctrl.debug)
1033	>	cout << "  --> mu relpfIso: " << pfIso/mu->Pt() << ", returning status : " << hex << status.getStatus() << dec << endl;
1034		return status;
1298	–
1035		}
1036
1301	–
1302	–	//--------------------------------------------------------------------------------------------------
1303	–	// hacked version
1304	–	SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1305	–	const mithep::Muon * mu,
1306	–	const mithep::Vertex * vtx,
1307	–	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1308	–	float rho,
1309	–	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1310	–	vector<const mithep::Muon*> muonsToVeto,
1311	–	vector<const mithep::Electron*> electronsToVeto)
1312	–	//--------------------------------------------------------------------------------------------------
1313	–	{
1314	–
1315	–	SelectionStatus status;
1316	–
1317	–	double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, rho,
1318	–	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1319	–
1320	–	status.isoPF04 = pfIso;
1321	–	status.chisoPF04 = gChargedIso;
1322	–	status.gaisoPF04 = gGammaIso;
1323	–	status.neisoPF04 = gNeutralIso;
1324	–
1325	–	bool pass = false;
1326	–	if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1327	–
1328	–	if( pass ) {
1329	–	status.orStatus(SelectionStatus::LOOSEISO);
1330	–	status.orStatus(SelectionStatus::TIGHTISO);
1331	–	}
1332	–	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1333	–	return status;
1334	–
1335	–	}
1336	–
1337	–
1338	–
1339	–
1037		//--------------------------------------------------------------------------------------------------
1038		SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1039	<	const mithep::Electron * ele,
1040	<	const mithep::Vertex * vtx,
1041	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1042	<	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1043	<	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1044	<	vector<const mithep::Muon*> muonsToVeto,
1045	<	vector<const mithep::Electron*> electronsToVeto)
1039	>	const Electron * ele,
1040	>	const Vertex * vtx,
1041	>	const Array<PFCandidate> * fPFCandidates,
1042	>	const Array<PileupEnergyDensity> * fPUEnergyDensity,
1043	>	ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1044	>	vector<const Muon*> muonsToVeto,
1045	>	vector<const Electron*> electronsToVeto)
1046		//--------------------------------------------------------------------------------------------------
1047		{
1048
1049		if( ctrl.debug ) {
1050		cout << "electronIsoMVASelection :: muons to veto " << endl;
1051		for( int i=0; i<muonsToVeto.size(); i++ ) {
1052	<	const mithep::Muon * vmu = muonsToVeto[i];
1052	>	const Muon * vmu = muonsToVeto[i];
1053		cout << "\tpt: " << vmu->Pt()
1054		<< "\teta: " << vmu->Eta()
1055		<< "\tphi: " << vmu->Phi()
#	Line 1360 | Line 1057 | SelectionStatus electronIsoMVASelection(
1057		}
1058		cout << "electronIsoMVASelection :: electrson to veto " << endl;
1059		for( int i=0; i<electronsToVeto.size(); i++ ) {
1060	<	const mithep::Electron * vel = electronsToVeto[i];
1060	>	const Electron * vel = electronsToVeto[i];
1061		cout << "\tpt: " << vel->Pt()
1062		<< "\teta: " << vel->Eta()
1063		<< "\tphi: " << vel->Phi()
#	Line 1424 | Line 1121 | SelectionStatus electronIsoMVASelection(
1121
1122		if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1123
1124	<	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1124	>	const PFCandidate *pf = (PFCandidate*)((*fPFCandidates)[k]);
1125		Double_t deta = (ele->Eta() - pf->Eta());
1126	<	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1127	<	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1126	>	Double_t dphi = MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1127	>	Double_t dr = MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1128		if (dr > 1.0) continue;
1129
1130		if(ctrl.debug) {
#	Line 1453 | Line 1150 | SelectionStatus electronIsoMVASelection(
1150		//
1151
1152		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1153	<	const mithep::Electron *tmpele = electronsToVeto[q];
1154	<	double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1153	>	const Electron *tmpele = electronsToVeto[q];
1154	>	double tmpdr = MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1155
1156		// 4l electron
1157		if( pf->HasTrackerTrk()  ) {
#	Line 1488 | Line 1185 | SelectionStatus electronIsoMVASelection(
1185		// Check for muons
1186		//
1187		for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1188	<	const mithep::Muon *tmpmu = muonsToVeto[q];
1188	>	const Muon *tmpmu = muonsToVeto[q];
1189		// 4l muon
1190		if( pf->HasTrackerTrk() ) {
1191		if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
#	Line 1497 | Line 1194 | SelectionStatus electronIsoMVASelection(
1194		}
1195		}
1196		// PF charged
1197	<	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1197	>	if (pf->Charge() != 0 && MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1198		if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1199		IsLeptonFootprint = kTRUE;
1200		}
#	Line 1758 | Line 1455 | SelectionStatus electronIsoMVASelection(
1455
1456		//--------------------------------------------------------------------------------------------------
1457		SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1458	<	const mithep::Electron * ele,
1459	<	const mithep::Vertex * vtx,
1460	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1458	>	const Electron * ele,
1459	>	const Vertex * vtx,
1460	>	const Array<PFCandidate> * fPFCandidates,
1461		float rho,
1462	<	//const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1463	<	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1464	<	vector<const mithep::Muon*> muonsToVeto,
1465	<	vector<const mithep::Electron*> electronsToVeto)
1462	>	//const Array<PileupEnergyDensity> * fPUEnergyDensity,
1463	>	ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1464	>	vector<const Muon*> muonsToVeto,
1465	>	vector<const Electron*> electronsToVeto)
1466		//--------------------------------------------------------------------------------------------------
1467		// hacked version
1468		{
#	Line 1776 | Line 1473 | SelectionStatus electronIsoMVASelection(
1473		if( ctrl.debug ) {
1474		cout << "electronIsoMVASelection :: muons to veto " << endl;
1475		for( int i=0; i<muonsToVeto.size(); i++ ) {
1476	<	const mithep::Muon * vmu = muonsToVeto[i];
1476	>	const Muon * vmu = muonsToVeto[i];
1477		cout << "\tpt: " << vmu->Pt()
1478		<< "\teta: " << vmu->Eta()
1479		<< "\tphi: " << vmu->Phi()
#	Line 1784 | Line 1481 | SelectionStatus electronIsoMVASelection(
1481		}
1482		cout << "electronIsoMVASelection :: electrson to veto " << endl;
1483		for( int i=0; i<electronsToVeto.size(); i++ ) {
1484	<	const mithep::Electron * vel = electronsToVeto[i];
1484	>	const Electron * vel = electronsToVeto[i];
1485		cout << "\tpt: " << vel->Pt()
1486		<< "\teta: " << vel->Eta()
1487		<< "\tphi: " << vel->Phi()
#	Line 1848 | Line 1545 | SelectionStatus electronIsoMVASelection(
1545
1546		if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1547
1548	<	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1548	>	const PFCandidate *pf = (PFCandidate*)((*fPFCandidates)[k]);
1549		Double_t deta = (ele->Eta() - pf->Eta());
1550	<	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1551	<	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1550	>	Double_t dphi = MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1551	>	Double_t dr = MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1552		if (dr > 1.0) continue;
1553
1554		if(ctrl.debug) {
#	Line 1877 | Line 1574 | SelectionStatus electronIsoMVASelection(
1574		//
1575
1576		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1577	<	const mithep::Electron *tmpele = electronsToVeto[q];
1578	<	double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1577	>	const Electron *tmpele = electronsToVeto[q];
1578	>	double tmpdr = MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1579
1580		// 4l electron
1581		if( pf->HasTrackerTrk()  ) {
#	Line 1912 | Line 1609 | SelectionStatus electronIsoMVASelection(
1609		// Check for muons
1610		//
1611		for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1612	<	const mithep::Muon *tmpmu = muonsToVeto[q];
1612	>	const Muon *tmpmu = muonsToVeto[q];
1613		// 4l muon
1614		if( pf->HasTrackerTrk() ) {
1615		if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
#	Line 1921 | Line 1618 | SelectionStatus electronIsoMVASelection(
1618		}
1619		}
1620		// PF charged
1621	<	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1621	>	if (pf->Charge() != 0 && MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1622		if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1623		IsLeptonFootprint = kTRUE;
1624		}
#	Line 2183 | Line 1880 | SelectionStatus electronIsoMVASelection(
1880		//--------------------------------------------------------------------------------------------------
1881		void initElectronIsoMVA() {
1882		//--------------------------------------------------------------------------------------------------
1883	<	eleIsoMVA = new mithep::ElectronIDMVA();
1883	>	eleIsoMVA = new ElectronIDMVA();
1884		vector<string> weightFiles;
1885		weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_BarrelPt5To10.weights.xml");
1886		weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_EndcapPt5To10.weights.xml");
1887		weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_BarrelPt10ToInf.weights.xml");
1888		weightFiles.push_back("../MitPhysics/data/ElectronMVAWeights/ElectronIso_BDTG_V0_EndcapPt10ToInf.weights.xml");
1889		eleIsoMVA->Initialize( "ElectronIsoMVA",
1890	<	mithep::ElectronIDMVA::kIsoRingsV0,
1890	>	ElectronIDMVA::kIsoRingsV0,
1891		kTRUE, weightFiles);
1892		}
1893
#	Line 2199 | Line 1896 | void initElectronIsoMVA() {
1896
1897		//--------------------------------------------------------------------------------------------------
1898		float electronPFIso04(ControlFlags &ctrl,
1899	<	const mithep::Electron * ele,
1900	<	const mithep::Vertex * vtx,
1901	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1902	<	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1903	<	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1904	<	vector<const mithep::PFCandidate*> photonsToVeto)
1899	>	const Electron * ele,
1900	>	const Vertex * vtx,
1901	>	const Array<PFCandidate> * fPFCandidates,
1902	>	const Array<PileupEnergyDensity> * fPUEnergyDensity,
1903	>	ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1904	>	vector<const PFCandidate*> photonsToVeto)
1905		//--------------------------------------------------------------------------------------------------
1906		{
1907
#	Line 2219 | Line 1916 | float electronPFIso04(ControlFlags &ctrl
1916		//
1917		//Loop over PF Candidates
1918		//
1919	+	if(ctrl.debug) cout << "  electronPFIso04(): ----> " << endl;
1920		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1921
1922	<	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1922	>	const PFCandidate *pf = (PFCandidate*)((*fPFCandidates)[k]);
1923
1924		//
1925		// veto FSR recovered photons
#	Line 2235 | Line 1933 | float electronPFIso04(ControlFlags &ctrl
1933		} if( vetoPhoton ) continue;
1934
1935		Double_t deta = (ele->Eta() - pf->Eta());
1936	<	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1937	<	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1936	>	Double_t dphi = MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1937	>	Double_t dr = MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1938
1939		if (dr > 0.4) continue;
1940		if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1941
1942	<	if(ctrl.debug) {
1943	<	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
1944	<	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
1945	<	<< "\ttrk: " << pf->HasTrackerTrk()
1946	<	<< "\tgsf: " << pf->HasGsfTrk();
1947	<
1948	<	cout << endl;
2251	<	}
2252	<
2253	<
2254	<	//
2255	<	// sync : I don't think theyre doing this ...
2256	<	//
2257	<	//     if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
2258	<	//   (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2259	<	//       if( ctrl.debug ) cout << "\tskipping, matches to the electron ..."  << endl;
2260	<	//       continue;
2261	<	//     }
2262	<
1942	>	// if(ctrl.debug) {
1943	>	//   cout << "    pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
1944	>	//   if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
1945	>	//                               << "\ttrk: " << pf->HasTrackerTrk()
1946	>	//                               << "\tgsf: " << pf->HasGsfTrk();
1947	>	//   cout << endl;
1948	>	// }
1949
1950		//
1951		// Lepton Footprint Removal
#	Line 2275 | Line 1961 | float electronPFIso04(ControlFlags &ctrl
1961
1962		// Veto any PFmuon, or PFEle
1963		if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) {
1964	<	if( ctrl.debug ) cout << "\t skipping, pf is and ele or mu .." <<endl;
1964	>	// if( ctrl.debug ) cout << "    skipping, pf is an ele or mu .." <<endl;
1965		continue;
1966		}
1967
1968		// Footprint Veto
1969		if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1970
1971	<	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1972	<	<< "\ttype: " << pf->PFType()
1973	<	<< "\ttrk: " << pf->TrackerTrk() << endl;
1971	>	// if( ctrl.debug) cout << "    charged:: pt: " << pf->Pt()
1972	>	//                           << "\ttype: " << pf->PFType()
1973	>	//                           << "\ttrk: " << pf->TrackerTrk() << endl;
1974
1975		fChargedIso += pf->Pt();
1976		}
#	Line 2295 | Line 1981 | float electronPFIso04(ControlFlags &ctrl
1981		else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1982
1983		if (fabs(ele->SCluster()->Eta()) > 1.479) {
1984	<	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
1984	>	if (MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
1985		}
1986	<	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1987	<	<< dr << endl;
1988	<	// KH, add to sync
1989	<	//      if( pf->Pt() > 0.5 )
1990	<	fGammaIso += pf->Pt();
1986	>
1987	>	assert(ele->HasSuperCluster());
1988	>	if(ele->GsfTrk()->NExpectedHitsInner()>0 && pf->MvaGamma() > 0.99 && pf->HasSCluster() && ele->SCluster() == pf->SCluster())      continue;
1989	>
1990	>
1991	>	// if( ctrl.debug) cout << "    gamma:: " << pf->Pt() << " "
1992	>	//                           << dr << endl;
1993	>
1994	>	fGammaIso += pf->Pt();
1995		}
1996
1997		//
1998		// Neutral Iso
1999		//
2000		else {
2001	<	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2002	<	<< dr << endl;
2003	<	// KH, add to sync
2314	<	//      if( pf->Pt() > 0.5 )
2315	<	fNeutralHadronIso += pf->Pt();
2001	>	// if( ctrl.debug) cout << "    neutral:: " << pf->Pt() << " "
2002	>	//                           << dr << endl;
2003	>	fNeutralHadronIso += pf->Pt();
2004		}
2005
2006		}
#	Line 2321 | Line 2009 | float electronPFIso04(ControlFlags &ctrl
2009
2010
2011		double rho=0;
2012	<	if( (EffectiveAreaVersion == mithep::ElectronTools::kEleEAFall11MC) ||
2013	<	(EffectiveAreaVersion == mithep::ElectronTools::kEleEAData2011) ) {
2012	>	if( (EffectiveAreaVersion == ElectronTools::kEleEAFall11MC) ||
2013	>	(EffectiveAreaVersion == ElectronTools::kEleEAData2011) ) {
2014		if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25()) ||
2015		isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25())))
2016		rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25();
2017		// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2018	<	EffectiveAreaVersion  = mithep::ElectronTools::kEleEAData2011;
2018	>	EffectiveAreaVersion  = ElectronTools::kEleEAData2011;
2019		// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2020		} else {
2021		if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJets()) ||
2022		isinf(fPUEnergyDensity->At(0)->RhoKt6PFJets())))
2023		rho = fPUEnergyDensity->At(0)->RhoKt6PFJets();
2024		// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2025	<	EffectiveAreaVersion  = mithep::ElectronTools::kEleEAData2012;
2025	>	EffectiveAreaVersion  = ElectronTools::kEleEAData2012;
2026		// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2027		}
2028	<	if(ctrl.debug) cout << "rho: " << rho << endl;
2028	>	// if(ctrl.debug) cout << "    rho: " << rho << endl;
2029
2030		double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2031		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
#	Line 2349 | Line 2037 | float electronPFIso04(ControlFlags &ctrl
2037		gNeutralIso = fNeutralHadronIso;
2038
2039		if( ctrl.debug ) {
2040	<	cout << "PFiso: " << pfIso
2041	<	<< "\tfChargedIso: " << fChargedIso
2042	<	<< "\tfGammaIso: " << fGammaIso
2043	<	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
2040	>	cout << "    PFiso: " << pfIso
2041	>	<< setw(6) << setprecision(4) << fChargedIso
2042	>	<< setw(6) << setprecision(4) << fGammaIso
2043	>	<< setw(6) << setprecision(4) << fNeutralHadronIso
2044		<< endl;
2045		}
2046
2047		return pfIso;
2048		}
2049
2362	–
2363	–
2364	–	//--------------------------------------------------------------------------------------------------
2365	–	// hacked version
2366	–	float electronPFIso04(ControlFlags &ctrl,
2367	–	const mithep::Electron * ele,
2368	–	const mithep::Vertex * vtx,
2369	–	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2370	–	float rho,
2371	–	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2372	–	vector<const mithep::Muon*> muonsToVeto,
2373	–	vector<const mithep::Electron*> electronsToVeto)
2374	–	//--------------------------------------------------------------------------------------------------
2375	–	{
2376	–
2377	–	if( ctrl.debug ) {
2378	–	cout << "electronIsoMVASelection :: muons to veto " << endl;
2379	–	for( int i=0; i<muonsToVeto.size(); i++ ) {
2380	–	const mithep::Muon * vmu = muonsToVeto[i];
2381	–	cout << "\tpt: " << vmu->Pt()
2382	–	<< "\teta: " << vmu->Eta()
2383	–	<< "\tphi: " << vmu->Phi()
2384	–	<< endl;
2385	–	}
2386	–	cout << "electronIsoMVASelection :: electrons to veto " << endl;
2387	–	for( int i=0; i<electronsToVeto.size(); i++ ) {
2388	–	const mithep::Electron * vel = electronsToVeto[i];
2389	–	cout << "\tpt: " << vel->Pt()
2390	–	<< "\teta: " << vel->Eta()
2391	–	<< "\tphi: " << vel->Phi()
2392	–	<< "\ttrk: " << vel->TrackerTrk()
2393	–	<< endl;
2394	–	}
2395	–	}
2396	–
2397	–
2398	–	//
2399	–	// final iso
2400	–	//
2401	–	Double_t fChargedIso = 0.0;
2402	–	Double_t fGammaIso = 0.0;
2403	–	Double_t fNeutralHadronIso = 0.0;
2404	–
2405	–
2406	–	//
2407	–	//Loop over PF Candidates
2408	–	//
2409	–	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2410	–
2411	–
2412	–	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2413	–	Double_t deta = (ele->Eta() - pf->Eta());
2414	–	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2415	–	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2416	–
2417	–	if (dr > 0.4) continue;
2418	–	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2419	–
2420	–	if(ctrl.debug) {
2421	–	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2422	–	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
2423	–	<< "\ttrk: " << pf->HasTrackerTrk()
2424	–	<< "\tgsf: " << pf->HasGsfTrk();
2425	–
2426	–	cout << endl;
2427	–	}
2428	–
2429	–
2430	–	//
2431	–	// sync : I don't think theyre doing this ...
2432	–	//
2433	–	//     if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
2434	–	//   (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2435	–	//       if( ctrl.debug ) cout << "\tskipping, matches to the electron ..."  << endl;
2436	–	//       continue;
2437	–	//     }
2438	–
2439	–
2440	–	//
2441	–	// Lepton Footprint Removal
2442	–	//
2443	–	Bool_t IsLeptonFootprint = kFALSE;
2444	–	if (dr < 1.0) {
2445	–
2446	–	//
2447	–	// Check for electrons
2448	–	//
2449	–	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2450	–	const mithep::Electron *tmpele = electronsToVeto[q];
2451	–	/*
2452	–	// 4l electron
2453	–	if( pf->HasTrackerTrk()  ) {
2454	–	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
2455	–	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
2456	–	IsLeptonFootprint = kTRUE;
2457	–	}
2458	–	}
2459	–	if( pf->HasGsfTrk()  ) {
2460	–	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
2461	–	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
2462	–	IsLeptonFootprint = kTRUE;
2463	–	}
2464	–	}
2465	–	*/
2466	–	// PF charged
2467	–	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2468	–	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
2469	–	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
2470	–	IsLeptonFootprint = kTRUE;
2471	–	}
2472	–	// PF gamma
2473	–	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
2474	–	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
2475	–	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
2476	–	IsLeptonFootprint = kTRUE;
2477	–	}
2478	–	} // loop over electrons
2479	–
2480	–	/* KH - comment for sync
2481	–	//
2482	–	// Check for muons
2483	–	//
2484	–	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
2485	–	const mithep::Muon *tmpmu = muonsToVeto[q];
2486	–	// 4l muon
2487	–	if( pf->HasTrackerTrk() ) {
2488	–	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
2489	–	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
2490	–	IsLeptonFootprint = kTRUE;
2491	–	}
2492	–	}
2493	–	// PF charged
2494	–	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
2495	–	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
2496	–	IsLeptonFootprint = kTRUE;
2497	–	}
2498	–	} // loop over muons
2499	–	*/
2500	–
2501	–	if (IsLeptonFootprint)
2502	–	continue;
2503	–
2504	–	//
2505	–	// Charged Iso
2506	–	//
2507	–	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
2508	–
2509	–	//       if( pf->HasTrackerTrk() )
2510	–	//      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2511	–	//       if( pf->HasGsfTrk() )
2512	–	//      if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2513	–
2514	–	// Veto any PFmuon, or PFEle
2515	–	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) {
2516	–	if( ctrl.debug ) cout << "\t skipping, pf is and ele or mu .." <<endl;
2517	–	continue;
2518	–	}
2519	–
2520	–	// Footprint Veto
2521	–	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
2522	–
2523	–	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
2524	–	<< "\ttype: " << pf->PFType()
2525	–	<< "\ttrk: " << pf->TrackerTrk() << endl;
2526	–
2527	–	fChargedIso += pf->Pt();
2528	–	}
2529	–
2530	–	//
2531	–	// Gamma Iso
2532	–	//
2533	–	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2534	–
2535	–	if (fabs(ele->SCluster()->Eta()) > 1.479) {
2536	–	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
2537	–	}
2538	–	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2539	–	<< dr << endl;
2540	–	// KH, add to sync
2541	–	//      if( pf->Pt() > 0.5 )
2542	–	fGammaIso += pf->Pt();
2543	–	}
2544	–
2545	–	//
2546	–	// Neutral Iso
2547	–	//
2548	–	else {
2549	–	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2550	–	<< dr << endl;
2551	–	// KH, add to sync
2552	–	//      if( pf->Pt() > 0.5 )
2553	–	fNeutralHadronIso += pf->Pt();
2554	–	}
2555	–
2556	–	}
2557	–
2558	–	}
2559	–
2560	–	//   double rho = 0;
2561	–	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
2562	–	//     rho = fPUEnergyDensity->At(0)->Rho();
2563	–
2564	–	// WARNING!!!!
2565	–	// hardcode for sync ...
2566	–	EffectiveAreaVersion = eleT.kEleEAData2011;
2567	–	// WARNING!!!!
2568	–
2569	–
2570	–	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2571	–	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2572	–	ele->Eta(),EffectiveAreaVersion)));
2573	–
2574	–
2575	–	gChargedIso = fChargedIso;
2576	–	gGammaIso = fGammaIso;
2577	–	gNeutralIso = fNeutralHadronIso;
2578	–	return pfIso;
2579	–	}
2580	–
2581	–
2050		//--------------------------------------------------------------------------------------------------
2051		SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2052	<	const mithep::Electron * ele,
2053	<	const mithep::Vertex * vtx,
2054	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2055	<	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2056	<	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2057	<	vector<const mithep::PFCandidate*> photonsToVeto)
2052	>	const Electron * ele,
2053	>	const Vertex * vtx,
2054	>	const Array<PFCandidate> * fPFCandidates,
2055	>	const Array<PileupEnergyDensity> * fPUEnergyDensity,
2056	>	ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2057	>	vector<const PFCandidate*> photonsToVeto)
2058		//--------------------------------------------------------------------------------------------------
2059		{
2060
#	Line 2594 | Line 2062 | SelectionStatus electronReferenceIsoSele
2062
2063		double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, fPUEnergyDensity,
2064		EffectiveAreaVersion, photonsToVeto);
2597	–	//  cout << "--------------> setting electron isoPF04 to " << pfIso << endl;
2065		status.isoPF04 = pfIso;
2066		status.chisoPF04 = gChargedIso;
2067		status.gaisoPF04 = gGammaIso;
#	Line 2607 | Line 2074 | SelectionStatus electronReferenceIsoSele
2074		status.orStatus(SelectionStatus::LOOSEISO);
2075		status.orStatus(SelectionStatus::TIGHTISO);
2076		}
2077	<	if(ctrl.debug) {
2078	<	cout << "el relpfIso: " << pfIso/ele->Pt() << endl;
2612	<	cout << "returning status : " << hex << status.getStatus() << dec << endl;
2613	<	}
2077	>	if(ctrl.debug)
2078	>	cout << "  --> ele relpfIso: " << pfIso/ele->Pt() << ", returning status : " << hex << status.getStatus() << dec << endl;
2079		return status;
2615	–
2616	–	}
2617	–
2618	–
2619	–	//--------------------------------------------------------------------------------------------------
2620	–	// hacked version
2621	–	SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2622	–	const mithep::Electron * ele,
2623	–	const mithep::Vertex * vtx,
2624	–	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2625	–	float rho,
2626	–	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2627	–	vector<const mithep::Muon*> muonsToVeto,
2628	–	vector<const mithep::Electron*> electronsToVeto)
2629	–	//--------------------------------------------------------------------------------------------------
2630	–	{
2631	–
2632	–	SelectionStatus status;
2633	–
2634	–	double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, rho,
2635	–	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2636	–	status.isoPF04 = pfIso;
2637	–	status.chisoPF04 = gChargedIso;
2638	–	status.gaisoPF04 = gGammaIso;
2639	–	status.neisoPF04 = gNeutralIso;
2640	–	bool pass = false;
2641	–	if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2642	–
2643	–	if( pass ) {
2644	–	status.orStatus(SelectionStatus::LOOSEISO);
2645	–	status.orStatus(SelectionStatus::TIGHTISO);
2646	–	}
2647	–	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2648	–	return status;
2649	–
2650	–	}
2651	–
2652	–
2653	–
2654	–	//--------------------------------------------------------------------------------------------------
2655	–	double  dbetaCorrectedIsoDr03(ControlFlags & ctrl,
2656	–	const mithep::PFCandidate * photon,
2657	–	const mithep::Muon * lepton,
2658	–	const mithep::Array<mithep::PFCandidate> * fPFCandidates)
2659	–	//--------------------------------------------------------------------------------------------------
2660	–	{
2661	–
2662	–	//
2663	–	// final iso
2664	–	//
2665	–	Double_t fChargedIso  = 0.0;
2666	–	Double_t fGammaIso  = 0.0;
2667	–	Double_t fNeutralHadronIso  = 0.0;
2668	–	Double_t fpfPU  = 0.0;
2669	–
2670	–	//
2671	–	// Loop over PF Candidates
2672	–	//
2673	–	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2674	–
2675	–	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2676	–
2677	–	Double_t deta = (photon->Eta() - pf->Eta());
2678	–	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2679	–	Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2680	–	if (dr > 0.3) continue;
2681	–
2682	–	if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2683	–	if( pf->Pt() >= 0.2 && dr > 0.01 )
2684	–	fpfPU += pf->Pt();
2685	–	continue;
2686	–	}
2687	–
2688	–	//
2689	–	// skip this photon
2690	–	//
2691	–	if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
2692	–	pf->Et() == photon->Et() ) continue;
2693	–
2694	–
2695	–	//
2696	–	// Charged Iso
2697	–	//
2698	–	if (pf->Charge() != 0 ) {
2699	–	if( dr > 0.01 && pf->Pt() >= 0.2 &&
2700	–	!(pf->TrackerTrk() == lepton->TrackerTrk()) )
2701	–	fChargedIso += pf->Pt();
2702	–	}
2703	–
2704	–	//
2705	–	// Gamma Iso
2706	–	//
2707	–	else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
2708	–	if( pf->Pt() > 0.5 && dr > 0.01)
2709	–	fGammaIso += pf->Pt();
2710	–	}
2711	–
2712	–	//
2713	–	// Other Neutrals
2714	–	//
2715	–	else {
2716	–	if( pf->Pt() > 0.5 && dr > 0.01)
2717	–	fNeutralHadronIso += pf->Pt();
2718	–	}
2719	–
2720	–	}
2721	–
2722	–	if( ctrl.debug ) {
2723	–	cout << "photon dbetaIso :: " << endl;
2724	–	cout << "\tfChargedIso: " << fChargedIso
2725	–	<< "\tfGammaIso: " << fGammaIso
2726	–	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
2727	–	<< "\tfpfPU: " << fpfPU
2728	–	<< endl;
2729	–	}
2730	–	double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso - 0.5*fpfPU;
2731	–	return pfIso/photon->Pt();
2080		}
2733	–
2734	–
2081		//--------------------------------------------------------------------------------------------------
2082	<	double  dbetaCorrectedIsoDr03(ControlFlags & ctrl,
2083	<	const mithep::PFCandidate * photon,
2084	<	const mithep::Electron * lepton,
2085	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates)
2082	>	double  isoDr03ForFsr(ControlFlags & ctrl,
2083	>	const PFCandidate * photon,
2084	>	const ChargedParticle * lep,
2085	>	const Array<PFCandidate> * fPFCandidates,
2086	>	bool doDBetaCorr)
2087		//--------------------------------------------------------------------------------------------------
2088		{
2089
#	Line 2753 | Line 2100 | double  dbetaCorrectedIsoDr03(ControlFla
2100		//
2101		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2102
2103	<	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2757	<
2758	<	Double_t deta = (photon->Eta() - pf->Eta());
2759	<	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2760	<	Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2761	<	if (dr > 0.3) continue;
2762	<
2763	<	if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2764	<	if( pf->Pt() >= 0.2 && dr > 0.01 )
2765	<	fpfPU += pf->Pt();
2766	<	continue;
2767	<	}
2768	<
2769	<	//
2770	<	// skip this photon
2771	<	//
2772	<	if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
2773	<	pf->Et() == photon->Et() ) continue;
2774	<
2775	<
2776	<	//
2777	<	// Charged Iso
2778	<	//
2779	<	if (pf->Charge() != 0 ) {
2780	<	if( dr > 0.01 && pf->Pt() >= 0.2 &&
2781	<	!(pf->TrackerTrk() == lepton->TrackerTrk()) )
2782	<	fChargedIso += pf->Pt();
2783	<	}
2784	<
2785	<	//
2786	<	// Gamma Iso
2787	<	//
2788	<	else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
2789	<	if( pf->Pt() > 0.5 && dr > 0.01)
2790	<	fGammaIso += pf->Pt();
2791	<	}
2792	<
2793	<	//
2794	<	// Other Neutrals
2795	<	//
2796	<	else {
2797	<	if( pf->Pt() > 0.5 && dr > 0.01)
2798	<	fNeutralHadronIso += pf->Pt();
2799	<	}
2800	<
2801	<	}
2802	<
2803	<	if( ctrl.debug ) {
2804	<	cout << "photon dbetaIso :: " << endl;
2805	<	cout << "\tfChargedIso: " << fChargedIso
2806	<	<< "\tfGammaIso: " << fGammaIso
2807	<	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
2808	<	<< "\tfpfPU: " << fpfPU
2809	<	<< endl;
2810	<	}
2811	<	double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso - 0.5*fpfPU;
2812	<	return pfIso/photon->Pt();
2813	<	}
2814	<
2815	<
2816	<
2817	<
2818	<
2819	<	//--------------------------------------------------------------------------------------------------
2820	<	double  nonCorrectedIsoDr03(ControlFlags & ctrl,
2821	<	const mithep::PFCandidate * photon,
2822	<	const mithep::Muon * lepton,
2823	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates)
2824	<	//--------------------------------------------------------------------------------------------------
2825	<	{
2826	<
2827	<	//
2828	<	// final iso
2829	<	//
2830	<	Double_t fChargedIso  = 0.0;
2831	<	Double_t fGammaIso  = 0.0;
2832	<	Double_t fNeutralHadronIso  = 0.0;
2833	<	Double_t fpfPU  = 0.0;
2834	<
2835	<	//
2836	<	// Loop over PF Candidates
2837	<	//
2838	<	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2839	<
2840	<	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2841	<
2842	<	Double_t deta = (photon->Eta() - pf->Eta());
2843	<	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2844	<	Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2845	<	if (dr > 0.3) continue;
2846	<
2847	<	if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2848	<	if( pf->Pt() >= 0.2 && dr > 0.01 )
2849	<	fpfPU += pf->Pt();
2850	<	continue;
2851	<	}
2852	<
2853	<	//
2854	<	// skip this photon
2855	<	//
2856	<	if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
2857	<	pf->Et() == photon->Et() ) continue;
2858	<
2859	<
2860	<	//
2861	<	// Charged Iso
2862	<	//
2863	<	if (pf->Charge() != 0 ) {
2864	<	if( dr > 0.01 && pf->Pt() >= 0.2 &&
2865	<	!(pf->TrackerTrk() == lepton->TrackerTrk()) )
2866	<	fChargedIso += pf->Pt();
2867	<	}
2868	<
2869	<	//
2870	<	// Gamma Iso
2871	<	//
2872	<	else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
2873	<	if( pf->Pt() > 0.5 && dr > 0.01)
2874	<	fGammaIso += pf->Pt();
2875	<	}
2876	<
2877	<	//
2878	<	// Other Neutrals
2879	<	//
2880	<	else {
2881	<	if( pf->Pt() > 0.5 && dr > 0.01)
2882	<	fNeutralHadronIso += pf->Pt();
2883	<	}
2884	<
2885	<	}
2886	<
2887	<	if( ctrl.debug ) {
2888	<	cout << "photon dbetaIso :: " << endl;
2889	<	cout << "\tfChargedIso: " << fChargedIso
2890	<	<< "\tfGammaIso: " << fGammaIso
2891	<	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
2892	<	<< "\tfpfPU: " << fpfPU
2893	<	<< endl;
2894	<	}
2895	<	double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso + fpfPU;
2896	<	return pfIso/photon->Pt();
2897	<	}
2898	<
2899	<
2900	<
2901	<	//--------------------------------------------------------------------------------------------------
2902	<	double  nonCorrectedIsoDr03(ControlFlags & ctrl,
2903	<	const mithep::PFCandidate * photon,
2904	<	const mithep::Electron * lepton,
2905	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates)
2906	<	//--------------------------------------------------------------------------------------------------
2907	<	{
2908	<
2909	<	//
2910	<	// final iso
2911	<	//
2912	<	Double_t fChargedIso  = 0.0;
2913	<	Double_t fGammaIso  = 0.0;
2914	<	Double_t fNeutralHadronIso  = 0.0;
2915	<	Double_t fpfPU  = 0.0;
2916	<
2917	<	//
2918	<	// Loop over PF Candidates
2919	<	//
2920	<	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2921	<
2922	<	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2103	>	const PFCandidate *pf = (PFCandidate*)((*fPFCandidates)[k]);
2104
2105		Double_t deta = (photon->Eta() - pf->Eta());
2106	<	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2107	<	Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2106	>	Double_t dphi = MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2107	>	Double_t dr = MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2108		if (dr > 0.3) continue;
2109
2110		if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
#	Line 2935 | Line 2116 | double  nonCorrectedIsoDr03(ControlFlags
2116		//
2117		// skip this photon
2118		//
2119	<	if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
2119	>	if( abs(pf->PFType()) == PFCandidate::eGamma &&
2120		pf->Et() == photon->Et() ) continue;
2121
2122
#	Line 2944 | Line 2125 | double  nonCorrectedIsoDr03(ControlFlags
2125		//
2126		if (pf->Charge() != 0 ) {
2127		if( dr > 0.01 && pf->Pt() >= 0.2 &&
2128	<	!(pf->TrackerTrk() == lepton->TrackerTrk()) )
2128	>	!(pf->TrackerTrk() == lep->TrackerTrk()) )
2129		fChargedIso += pf->Pt();
2130		}
2131
2132		//
2133		// Gamma Iso
2134		//
2135	<	else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
2135	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2136		if( pf->Pt() > 0.5 && dr > 0.01)
2137		fGammaIso += pf->Pt();
2138		}
#	Line 2966 | Line 2147 | double  nonCorrectedIsoDr03(ControlFlags
2147
2148		}
2149
2150	<	if( ctrl.debug ) {
2151	<	cout << "photon dbetaIso :: " << endl;
2971	<	cout << "\tfChargedIso: " << fChargedIso
2972	<	<< "\tfGammaIso: " << fGammaIso
2973	<	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
2974	<	<< "\tfpfPU: " << fpfPU
2975	<	<< endl;
2976	<	}
2977	<	double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso + fpfPU;
2150	>	if(ctrl.debug) cout << "      isoDr03ForFsr: " << setw(12) << fChargedIso << setw(12) << fGammaIso << setw(12) << fNeutralHadronIso << setw(12) << fpfPU << endl;
2151	>	double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso + (doDBetaCorr ? -0.5 : 1)*fpfPU;
2152		return pfIso/photon->Pt();
2153		}
2980	–
2981	–
2982	–

Diff Legend

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