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.5 by khahn, Thu Apr 26 07:02:28 2012 UTC vs.
Revision 1.29 by khahn, Sun Jun 3 15:51:51 2012 UTC

#	Line 16 | Line 16 | mithep::MuonTools       muT;
16		mithep::ElectronIDMVA * eleIsoMVA;
17		mithep::ElectronTools   eleT;
18
19	+	// global hack to sync
20	+	double gChargedIso;
21	+	double gGammaIso;
22	+	double gNeutralIso;
23	+
24	+	extern vector<bool> PFnoPUflag;
25	+
26		//--------------------------------------------------------------------------------------------------
27		Float_t computePFMuonIso(const mithep::Muon *muon,
28	<	const mithep::Vertex & vtx,
28	>	const mithep::Vertex * vtx,
29		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
30		const Double_t dRMax)
31		//--------------------------------------------------------------------------------------------------
#	Line 27 | Line 34 | Float_t computePFMuonIso(const mithep::M
34		const Double_t neuPtMin = 1.0;
35		const Double_t dzMax    = 0.1;
36
37	<	Double_t zLepton = (muon->BestTrk()) ? muon->BestTrk()->DzCorrected(vtx) : 0.0;
37	>	Double_t zLepton = (muon->BestTrk()) ? muon->BestTrk()->DzCorrected(*vtx) : 0.0;
38
39		Float_t iso=0;
40		for(UInt_t ipf=0; ipf<fPFCandidates->GetEntries(); ipf++) {
#	Line 39 | Line 46 | Float_t computePFMuonIso(const mithep::M
46		if(pfcand->TrackerTrk() && muon->TrackerTrk() && (pfcand->TrackerTrk()==muon->TrackerTrk())) continue;
47
48		// dz cut
49	<	Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(vtx) - zLepton) : 0;
49	>	Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(*vtx) - zLepton) : 0;
50		if(dz >= dzMax) continue;
51
52		// check iso cone
#	Line 53 | Line 60 | Float_t computePFMuonIso(const mithep::M
60
61		//--------------------------------------------------------------------------------------------------
62		Float_t computePFEleIso(const mithep::Electron *electron,
63	<	const mithep::Vertex & fVertex,
63	>	const mithep::Vertex * fVertex,
64		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
65		const Double_t dRMax)
66		//--------------------------------------------------------------------------------------------------
#	Line 62 | Line 69 | Float_t computePFEleIso(const mithep::El
69		const Double_t neuPtMin = 1.0;
70		const Double_t dzMax    = 0.1;
71
72	<	Double_t zLepton = (electron->BestTrk()) ? electron->BestTrk()->DzCorrected(fVertex) : 0.0;
72	>	Double_t zLepton = (electron->BestTrk()) ? electron->BestTrk()->DzCorrected(*fVertex) : 0.0;
73
74		Float_t iso=0;
75		for(UInt_t ipf=0; ipf<fPFCandidates->GetEntries(); ipf++) {
#	Line 71 | Line 78 | Float_t computePFEleIso(const mithep::El
78		if(!pfcand->HasTrk() && (pfcand->Pt()<=neuPtMin)) continue;  // pT cut on neutral particles
79
80		// dz cut
81	<	Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(fVertex) - zLepton) : 0;
81	>	Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(*fVertex) - zLepton) : 0;
82		if(dz >= dzMax) continue;
83
84		// remove THE electron
#	Line 157 | Line 164 | bool pairwiseIsoSelection( ControlFlags
164
165		float isoEcal_corr_j = lepvec[j].isoEcal - (effArea_ecal_j*rho);
166		float isoHcal_corr_j = lepvec[j].isoHcal - (effArea_hcal_j*rho);
167	<	float RIso_i = (lepvec[i].isoTrk+isoEcal_corr_i+isoHcal_corr_i)/lepvec[i].vec->Pt();
168	<	float RIso_j = (lepvec[j].isoTrk+isoEcal_corr_j+isoHcal_corr_j)/lepvec[j].vec->Pt();
167	>	float RIso_i = (lepvec[i].isoTrk+isoEcal_corr_i+isoHcal_corr_i)/lepvec[i].vec.Pt();
168	>	float RIso_j = (lepvec[j].isoTrk+isoEcal_corr_j+isoHcal_corr_j)/lepvec[j].vec.Pt();
169		float comboIso = RIso_i + RIso_j;
170
171		if( comboIso > 0.35 ) {
#	Line 175 | Line 182 | bool pairwiseIsoSelection( ControlFlags
182		//--------------------------------------------------------------------------------------------------
183		SelectionStatus muonIsoSelection(ControlFlags &ctrl,
184		const mithep::Muon * mu,
185	<	const mithep::Vertex & vtx,
185	>	const mithep::Vertex * vtx,
186		const mithep::Array<mithep::PFCandidate> * fPFCandidateCol   )
187		//--------------------------------------------------------------------------------------------------
188		{
#	Line 205 | Line 212 | SelectionStatus muonIsoSelection(Control
212		//--------------------------------------------------------------------------------------------------
213		SelectionStatus electronIsoSelection(ControlFlags &ctrl,
214		const mithep::Electron * ele,
215	<	const mithep::Vertex &fVertex,
215	>	const mithep::Vertex *fVertex,
216		const mithep::Array<mithep::PFCandidate> * fPFCandidates)
217		//--------------------------------------------------------------------------------------------------
218		{
#	Line 220 | Line 227 | SelectionStatus electronIsoSelection(Con
227		if( ele->IsEB() && ele->Pt() < 20 && reliso > PFISO_ELE_LOOSE_EB_LOWPT ) {
228		failiso = true;
229		}
223	–	if(ctrl.debug) cout << "before iso check ..." << endl;
230		if( !(ele->IsEB()) && ele->Pt() > 20 && reliso > PFISO_ELE_LOOSE_EE_HIGHPT ) {
225	–	if(ctrl.debug) cout << "\tit fails ..." << endl;
231		failiso = true;
232		}
233		if( !(ele->IsEB()) && ele->Pt() < 20 && reliso > PFISO_ELE_LOOSE_EE_LOWPT ) {
#	Line 245 | Line 250 | bool noIso(ControlFlags &, vector<Simple
250		return true;
251		}
252
253	+
254		//--------------------------------------------------------------------------------------------------
255		SelectionStatus muonIsoMVASelection(ControlFlags &ctrl,
256		const mithep::Muon * mu,
257	<	const mithep::Vertex & vtx,
257	>	const mithep::Vertex * vtx,
258		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
259		const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
260		mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
#	Line 257 | Line 263 | SelectionStatus muonIsoMVASelection(Cont
263		//--------------------------------------------------------------------------------------------------
264		{
265
266	+	if( ctrl.debug ) {
267	+	cout << "muonIsoMVASelection :: muons to veto " << endl;
268	+	for( int i=0; i<muonsToVeto.size(); i++ ) {
269	+	const mithep::Muon * vmu = muonsToVeto[i];
270	+	cout << "\tpt: " << vmu->Pt()
271	+	<< "\teta: " << vmu->Eta()
272	+	<< "\tphi: " << vmu->Phi()
273	+	<< endl;
274	+	}
275	+	cout << "muonIsoMVASelection :: electrson to veto " << endl;
276	+	for( int i=0; i<electronsToVeto.size(); i++ ) {
277	+	const mithep::Electron * vel = electronsToVeto[i];
278	+	cout << "\tpt: " << vel->Pt()
279	+	<< "\teta: " << vel->Eta()
280	+	<< "\tphi: " << vel->Phi()
281	+	<< endl;
282	+	}
283	+	}
284		bool failiso=false;
285
286		//
287		// tmp iso rings
288		//
289	<	Double_t tmpChargedIso_DR0p0To0p05  = 0;
290	<	Double_t tmpChargedIso_DR0p05To0p1  = 0;
291	<	Double_t tmpChargedIso_DR0p1To0p15  = 0;
268	<	Double_t tmpChargedIso_DR0p15To0p2  = 0;
269	<	Double_t tmpChargedIso_DR0p2To0p25  = 0;
270	<	Double_t tmpChargedIso_DR0p25To0p3  = 0;
289	>	Double_t tmpChargedIso_DR0p0To0p1  = 0;
290	>	Double_t tmpChargedIso_DR0p1To0p2  = 0;
291	>	Double_t tmpChargedIso_DR0p2To0p3  = 0;
292		Double_t tmpChargedIso_DR0p3To0p4  = 0;
293		Double_t tmpChargedIso_DR0p4To0p5  = 0;
294	+	Double_t tmpChargedIso_DR0p5To0p7  = 0;
295
296	<	Double_t tmpGammaIso_DR0p0To0p05  = 0;
297	<	Double_t tmpGammaIso_DR0p05To0p1  = 0;
298	<	Double_t tmpGammaIso_DR0p1To0p15  = 0;
277	<	Double_t tmpGammaIso_DR0p15To0p2  = 0;
278	<	Double_t tmpGammaIso_DR0p2To0p25  = 0;
279	<	Double_t tmpGammaIso_DR0p25To0p3  = 0;
296	>	Double_t tmpGammaIso_DR0p0To0p1  = 0;
297	>	Double_t tmpGammaIso_DR0p1To0p2  = 0;
298	>	Double_t tmpGammaIso_DR0p2To0p3  = 0;
299		Double_t tmpGammaIso_DR0p3To0p4  = 0;
300		Double_t tmpGammaIso_DR0p4To0p5  = 0;
301	+	Double_t tmpGammaIso_DR0p5To0p7  = 0;
302
303	<	Double_t tmpNeutralHadronIso_DR0p0To0p05  = 0;
304	<	Double_t tmpNeutralHadronIso_DR0p05To0p1  = 0;
305	<	Double_t tmpNeutralHadronIso_DR0p1To0p15  = 0;
286	<	Double_t tmpNeutralHadronIso_DR0p15To0p2  = 0;
287	<	Double_t tmpNeutralHadronIso_DR0p2To0p25  = 0;
288	<	Double_t tmpNeutralHadronIso_DR0p25To0p3  = 0;
303	>	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
304	>	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
305	>	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
306		Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
307		Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
308	+	Double_t tmpNeutralHadronIso_DR0p5To0p7  = 0;
309	+
310
292	–	Double_t tmp2ChargedIso_DR0p5To1p0  = 0;
311
312		//
313		// final rings for the MVA
#	Line 299 | Line 317 | SelectionStatus muonIsoMVASelection(Cont
317		Double_t fChargedIso_DR0p2To0p3;
318		Double_t fChargedIso_DR0p3To0p4;
319		Double_t fChargedIso_DR0p4To0p5;
320	+	Double_t fChargedIso_DR0p5To0p7;
321
322		Double_t fGammaIso_DR0p0To0p1;
323		Double_t fGammaIso_DR0p1To0p2;
324		Double_t fGammaIso_DR0p2To0p3;
325		Double_t fGammaIso_DR0p3To0p4;
326		Double_t fGammaIso_DR0p4To0p5;
327	+	Double_t fGammaIso_DR0p5To0p7;
328
329		Double_t fNeutralHadronIso_DR0p0To0p1;
330		Double_t fNeutralHadronIso_DR0p1To0p2;
331		Double_t fNeutralHadronIso_DR0p2To0p3;
332		Double_t fNeutralHadronIso_DR0p3To0p4;
333		Double_t fNeutralHadronIso_DR0p4To0p5;
334	+	Double_t fNeutralHadronIso_DR0p5To0p7;
335
336
337		//
338		//Loop over PF Candidates
339		//
340		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
341	+
342	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
343	+
344		const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
345
346		Double_t deta = (mu->Eta() - pf->Eta());
#	Line 324 | Line 348 | SelectionStatus muonIsoMVASelection(Cont
348		Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
349		if (dr > 1.0) continue;
350
351	<	if (pf->PFType() == PFCandidate::eMuon && pf->TrackerTrk() == mu->TrackerTrk() ) continue;
351	>	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
352
353		//
354		// Lepton Footprint Removal
#	Line 337 | Line 361 | SelectionStatus muonIsoMVASelection(Cont
361		//
362		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
363		const mithep::Electron *tmpele = electronsToVeto[q];
364	<	// PF electron
365	<	if( pf->PFType() == PFCandidate::eElectron && pf->TrackerTrk() == tmpele->TrackerTrk() )
366	<	IsLeptonFootprint = kTRUE;
364	>	// 4l electron
365	>	if( pf->HasTrackerTrk() ) {
366	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
367	>	IsLeptonFootprint = kTRUE;
368	>	}
369	>	if( pf->HasGsfTrk() ) {
370	>	if( pf->GsfTrk() == tmpele->GsfTrk() )
371	>	IsLeptonFootprint = kTRUE;
372	>	}
373		// PF charged
374	<	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
374	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479
375		&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
376		IsLeptonFootprint = kTRUE;
377		// PF gamma
378	<	if (pf->PFType() == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
378	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
379		&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
380		IsLeptonFootprint = kTRUE;
381		} // loop over electrons
382
383	+	/* KH - commented for sync
384		//
385		// Check for muons
386		//
387		for (Int_t q=0; q < muonsToVeto.size(); ++q) {
388		const mithep::Muon *tmpmu = muonsToVeto[q];
389	<	// PF muons
390	<	if (pf->PFType() == PFCandidate::eMuon && pf->TrackerTrk() == tmpmu->TrackerTrk() )
391	<	IsLeptonFootprint = kTRUE;
389	>	// 4l muon
390	>	if( pf->HasTrackerTrk() ) {
391	>	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
392	>	IsLeptonFootprint = kTRUE;
393	>	}
394		// PF charged
395		if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
396		IsLeptonFootprint = kTRUE;
397		} // loop over muons
398	<
398	>	*/
399
400		if (IsLeptonFootprint)
401		continue;
#	Line 370 | Line 403 | SelectionStatus muonIsoMVASelection(Cont
403		//
404		// Charged Iso Rings
405		//
406	<	if (pf->Charge() != 0 && pf->HasTrackerTrk() ) {
406	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
407
408	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
409	<
377	<	// Veto any PFmuon, or PFEle
378	<	if (pf->PFType() == PFCandidate::eElectron || pf->PFType() == PFCandidate::eMuon) continue;
408	>	if( dr < 0.01 ) continue; // only for muon iso mva?
409	>	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
410
411	<	// Footprint Veto
412	<	if (dr < 0.01) continue;
411	>	//       if( pf->HasTrackerTrk() ) {
412	>	//      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
413	>	//      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
414	>	//                            << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
415	>	//                            << dr << endl;
416	>	//       }
417	>	//       if( pf->HasGsfTrk() ) {
418	>	//      if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
419	>	//      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
420	>	//                            << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
421	>	//                            << dr << endl;
422	>	//       }
423
424	<	if (dr < 0.05)               tmpChargedIso_DR0p0To0p05 += pf->Pt();
425	<	if (dr >= 0.05 && dr < 0.10) tmpChargedIso_DR0p05To0p1 += pf->Pt();
426	<	if (dr >= 0.10 && dr < 0.15) tmpChargedIso_DR0p1To0p15 += pf->Pt();
427	<	if (dr >= 0.15 && dr < 0.20) tmpChargedIso_DR0p15To0p2 += pf->Pt();
428	<	if (dr >= 0.20 && dr < 0.25) tmpChargedIso_DR0p2To0p25 += pf->Pt();
429	<	if (dr >= 0.25 && dr < 0.3)  tmpChargedIso_DR0p25To0p3 += pf->Pt();
430	<	if (dr >= 0.3 && dr < 0.4)   tmpChargedIso_DR0p3To0p4  += pf->Pt();
390	<	if (dr >= 0.4 && dr < 0.5)   tmpChargedIso_DR0p4To0p5  += pf->Pt();
424	>	// Footprint Veto
425	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
426	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
427	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
428	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
429	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
430	>	if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
431		}
432
433		//
434		// Gamma Iso Rings
435		//
436	<	else if (pf->PFType() == PFCandidate::eGamma) {
437	<
438	<	if (dr < 0.05)               tmpGammaIso_DR0p0To0p05 += pf->Pt();
439	<	if (dr >= 0.05 && dr < 0.10) tmpGammaIso_DR0p05To0p1 += pf->Pt();
440	<	if (dr >= 0.10 && dr < 0.15) tmpGammaIso_DR0p1To0p15 += pf->Pt();
441	<	if (dr >= 0.15 && dr < 0.20) tmpGammaIso_DR0p15To0p2 += pf->Pt();
442	<	if (dr >= 0.20 && dr < 0.25) tmpGammaIso_DR0p2To0p25 += pf->Pt();
403	<	if (dr >= 0.25 && dr < 0.3)  tmpGammaIso_DR0p25To0p3 += pf->Pt();
404	<	if (dr >= 0.3 && dr < 0.4)   tmpGammaIso_DR0p3To0p4  += pf->Pt();
405	<	if (dr >= 0.4 && dr < 0.5)   tmpGammaIso_DR0p4To0p5  += pf->Pt();
436	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
437	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
438	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
439	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
440	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
441	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
442	>	if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
443		}
444
445		//
446		// Other Neutral Iso Rings
447		//
448		else {
449	<	if (dr < 0.05)               tmpNeutralHadronIso_DR0p0To0p05 += pf->Pt();
450	<	if (dr >= 0.05 && dr < 0.10) tmpNeutralHadronIso_DR0p05To0p1 += pf->Pt();
451	<	if (dr >= 0.10 && dr < 0.15) tmpNeutralHadronIso_DR0p1To0p15 += pf->Pt();
452	<	if (dr >= 0.15 && dr < 0.20) tmpNeutralHadronIso_DR0p15To0p2 += pf->Pt();
453	<	if (dr >= 0.20 && dr < 0.25) tmpNeutralHadronIso_DR0p2To0p25 += pf->Pt();
454	<	if (dr >= 0.25 && dr < 0.3)  tmpNeutralHadronIso_DR0p25To0p3 += pf->Pt();
418	<	if (dr >= 0.3 && dr < 0.4)   tmpNeutralHadronIso_DR0p3To0p4  += pf->Pt();
419	<	if (dr >= 0.4 && dr < 0.5)   tmpNeutralHadronIso_DR0p4To0p5  += pf->Pt();
449	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
450	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
451	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
452	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
453	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
454	>	if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
455		}
456
457		}
458
459		}
460
461	<	fChargedIso_DR0p0To0p1   = min((tmpChargedIso_DR0p0To0p05 + tmpChargedIso_DR0p05To0p1 )/mu->Pt(), 2.5);
462	<	fChargedIso_DR0p1To0p2   = min((tmpChargedIso_DR0p1To0p15 + tmpChargedIso_DR0p15To0p2)/mu->Pt(), 2.5);
463	<	fChargedIso_DR0p2To0p3   = min((tmpChargedIso_DR0p2To0p25 + tmpChargedIso_DR0p25To0p3)/mu->Pt(), 2.5);
464	<	fChargedIso_DR0p3To0p4   = min((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
465	<	fChargedIso_DR0p4To0p5   = min((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
461	>	fChargedIso_DR0p0To0p1   = fmin((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
462	>	fChargedIso_DR0p1To0p2   = fmin((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
463	>	fChargedIso_DR0p2To0p3   = fmin((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
464	>	fChargedIso_DR0p3To0p4   = fmin((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
465	>	fChargedIso_DR0p4To0p5   = fmin((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
466	>
467
468		double rho = 0;
469		if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
470		rho = fPUEnergyDensity->At(0)->Rho();
471	+
472	+	//   if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
473	+	//     rho = fPUEnergyDensity->At(0)->RhoLowEta();
474
475	+	// WARNING!!!!
476	+	// hardcode for sync ...
477	+	EffectiveAreaVersion = muT.kMuEAData2011;
478	+	// WARNING!!!!
479	+
480
481	<	fGammaIso_DR0p0To0p1 = max(min((tmpGammaIso_DR0p0To0p05 + tmpGammaIso_DR0p05To0p1
481	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
482		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p0To0p1,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
483		,2.5)
484		,0.0);
485	<	fGammaIso_DR0p1To0p2 = max(min((tmpGammaIso_DR0p1To0p15 + tmpGammaIso_DR0p15To0p2
485	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
486		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p1To0p2,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
487		,2.5)
488		,0.0);
489	<	fGammaIso_DR0p2To0p3 = max(min((tmpGammaIso_DR0p2To0p25 + tmpGammaIso_DR0p25To0p3
489	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
490		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p2To0p3,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
491		,2.5)
492		,0.0);
493	<	fGammaIso_DR0p3To0p4 = max(min((tmpGammaIso_DR0p3To0p4
493	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
494		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p3To0p4,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
495		,2.5)
496		,0.0);
497	<	fGammaIso_DR0p4To0p5 = max(min((tmpGammaIso_DR0p4To0p5
497	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
498		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p4To0p5,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
499		,2.5)
500		,0.0);
501
502
503	<	fNeutralHadronIso_DR0p0To0p1 = max(min((tmpNeutralHadronIso_DR0p0To0p05 + tmpNeutralHadronIso_DR0p05To0p1
503	>
504	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
505		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p0To0p1,
506		mu->Eta(),EffectiveAreaVersion))/mu->Pt()
507		, 2.5)
508		, 0.0);
509	<	fNeutralHadronIso_DR0p1To0p2 = max(min((tmpNeutralHadronIso_DR0p1To0p15 + tmpNeutralHadronIso_DR0p15To0p2
509	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
510		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p1To0p2,
511		mu->Eta(),EffectiveAreaVersion))/mu->Pt()
512		, 2.5)
513		, 0.0);
514	<	fNeutralHadronIso_DR0p2To0p3 = max(min((tmpNeutralHadronIso_DR0p2To0p25 + tmpNeutralHadronIso_DR0p25To0p3
514	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
515		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p2To0p3,
516		mu->Eta(),EffectiveAreaVersion))/mu->Pt()
517		, 2.5)
518		, 0.0);
519	<	fNeutralHadronIso_DR0p3To0p4 = max(min((tmpNeutralHadronIso_DR0p3To0p4
519	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
520		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p3To0p4,
521		mu->Eta(), EffectiveAreaVersion))/mu->Pt()
522		, 2.5)
523		, 0.0);
524	<	fNeutralHadronIso_DR0p4To0p5 = max(min((tmpNeutralHadronIso_DR0p4To0p5
524	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
525		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p4To0p5,
526		mu->Eta(), EffectiveAreaVersion))/mu->Pt()
527		, 2.5)
528		, 0.0);
529
530	+
531		double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
532	<	mu->Eta(),
533	<	fChargedIso_DR0p0To0p1,
534	<	fChargedIso_DR0p1To0p2,
535	<	fChargedIso_DR0p2To0p3,
536	<	fChargedIso_DR0p3To0p4,
537	<	fChargedIso_DR0p4To0p5,
538	<	fGammaIso_DR0p0To0p1,
539	<	fGammaIso_DR0p1To0p2,
540	<	fGammaIso_DR0p2To0p3,
541	<	fGammaIso_DR0p3To0p4,
542	<	fGammaIso_DR0p4To0p5,
543	<	fNeutralHadronIso_DR0p0To0p1,
544	<	fNeutralHadronIso_DR0p1To0p2,
545	<	fNeutralHadronIso_DR0p2To0p3,
546	<	fNeutralHadronIso_DR0p3To0p4,
547	<	fNeutralHadronIso_DR0p4To0p5,
548	<	ctrl.debug);
532	>	mu->Eta(),
533	>	mu->IsGlobalMuon(),
534	>	mu->IsTrackerMuon(),
535	>	fChargedIso_DR0p0To0p1,
536	>	fChargedIso_DR0p1To0p2,
537	>	fChargedIso_DR0p2To0p3,
538	>	fChargedIso_DR0p3To0p4,
539	>	fChargedIso_DR0p4To0p5,
540	>	fGammaIso_DR0p0To0p1,
541	>	fGammaIso_DR0p1To0p2,
542	>	fGammaIso_DR0p2To0p3,
543	>	fGammaIso_DR0p3To0p4,
544	>	fGammaIso_DR0p4To0p5,
545	>	fNeutralHadronIso_DR0p0To0p1,
546	>	fNeutralHadronIso_DR0p1To0p2,
547	>	fNeutralHadronIso_DR0p2To0p3,
548	>	fNeutralHadronIso_DR0p3To0p4,
549	>	fNeutralHadronIso_DR0p4To0p5,
550	>	ctrl.debug);
551
552		SelectionStatus status;
553	<	bool pass = false;
553	>	bool pass;
554
555	+	pass = false;
556		if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
557	<	&& fabs(mu->Eta()) < 1.5 && mu->Pt() < 10 && mvaval >= MUON_ISOMVA_CUT_BIN0)  pass = true;
557	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN0)   pass = true;
558		else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
559	<	&& fabs(mu->Eta()) < 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_CUT_BIN1)  pass = true;
559	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN1)  pass = true;
560		else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
561	<	&& fabs(mu->Eta()) > 1.5 && mu->Pt() < 10 && mvaval >= MUON_ISOMVA_CUT_BIN2)  pass = true;
561	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN2)  pass = true;
562		else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
563	<	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_CUT_BIN3)  pass = true;
564	<	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon()
565	<	&& (mu->Quality().QualityMask().Mask() & mithep::MuonQuality::AllArbitrated) && mvaval >= MUON_ISOMVA_CUT_BIN4)
566	<	pass = true;
563	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN3)  pass = true;
564	>	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN4)  pass = true;
565	>	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN5)  pass = true;
566	>	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
567
568	+	/*
569	+	pass = false;
570	+	if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
571	+	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN0)   pass = true;
572	+	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
573	+	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN1)  pass = true;
574	+	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
575	+	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN2)  pass = true;
576	+	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
577	+	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN3)  pass = true;
578	+	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN4)  pass = true;
579	+	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN5)  pass = true;
580	+	if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
581	+	*/
582	+
583	+	//  pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
584	+
585	+	status.isoMVA = mvaval;
586	+
587	+	if(ctrl.debug)  {
588	+	cout << "returning status : " << hex << status.getStatus() << dec << endl;
589	+	cout << "MVAVAL : " << status.isoMVA << endl;
590	+	}
591	+	return status;
592
593	<	if( pass ) {
594	<	status.orStatus(SelectionStatus::LOOSEISO);
595	<	status.orStatus(SelectionStatus::TIGHTISO);
593	>	}
594	>
595	>
596	>	//--------------------------------------------------------------------------------------------------
597	>	SelectionStatus muonIsoMVASelection(ControlFlags &ctrl,
598	>	const mithep::Muon * mu,
599	>	const mithep::Vertex * vtx,
600	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
601	>	float rho,
602	>	//const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
603	>	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
604	>	vector<const mithep::Muon*> muonsToVeto,
605	>	vector<const mithep::Electron*> electronsToVeto)
606	>	//--------------------------------------------------------------------------------------------------
607	>	// hacked version
608	>	{
609	>
610	>	if( ctrl.debug ) {
611	>	cout << "muonIsoMVASelection :: muons to veto " << endl;
612	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
613	>	const mithep::Muon * vmu = muonsToVeto[i];
614	>	cout << "\tpt: " << vmu->Pt()
615	>	<< "\teta: " << vmu->Eta()
616	>	<< "\tphi: " << vmu->Phi()
617	>	<< endl;
618	>	}
619	>	cout << "muonIsoMVASelection :: electrson to veto " << endl;
620	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
621	>	const mithep::Electron * vel = electronsToVeto[i];
622	>	cout << "\tpt: " << vel->Pt()
623	>	<< "\teta: " << vel->Eta()
624	>	<< "\tphi: " << vel->Phi()
625	>	<< endl;
626	>	}
627	>	}
628	>	bool failiso=false;
629	>
630	>	//
631	>	// tmp iso rings
632	>	//
633	>	Double_t tmpChargedIso_DR0p0To0p1  = 0;
634	>	Double_t tmpChargedIso_DR0p1To0p2  = 0;
635	>	Double_t tmpChargedIso_DR0p2To0p3  = 0;
636	>	Double_t tmpChargedIso_DR0p3To0p4  = 0;
637	>	Double_t tmpChargedIso_DR0p4To0p5  = 0;
638	>	Double_t tmpChargedIso_DR0p5To0p7  = 0;
639	>
640	>	Double_t tmpGammaIso_DR0p0To0p1  = 0;
641	>	Double_t tmpGammaIso_DR0p1To0p2  = 0;
642	>	Double_t tmpGammaIso_DR0p2To0p3  = 0;
643	>	Double_t tmpGammaIso_DR0p3To0p4  = 0;
644	>	Double_t tmpGammaIso_DR0p4To0p5  = 0;
645	>	Double_t tmpGammaIso_DR0p5To0p7  = 0;
646	>
647	>	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
648	>	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
649	>	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
650	>	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
651	>	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
652	>	Double_t tmpNeutralHadronIso_DR0p5To0p7  = 0;
653	>
654	>
655	>
656	>	//
657	>	// final rings for the MVA
658	>	//
659	>	Double_t fChargedIso_DR0p0To0p1;
660	>	Double_t fChargedIso_DR0p1To0p2;
661	>	Double_t fChargedIso_DR0p2To0p3;
662	>	Double_t fChargedIso_DR0p3To0p4;
663	>	Double_t fChargedIso_DR0p4To0p5;
664	>	Double_t fChargedIso_DR0p5To0p7;
665	>
666	>	Double_t fGammaIso_DR0p0To0p1;
667	>	Double_t fGammaIso_DR0p1To0p2;
668	>	Double_t fGammaIso_DR0p2To0p3;
669	>	Double_t fGammaIso_DR0p3To0p4;
670	>	Double_t fGammaIso_DR0p4To0p5;
671	>	Double_t fGammaIso_DR0p5To0p7;
672	>
673	>	Double_t fNeutralHadronIso_DR0p0To0p1;
674	>	Double_t fNeutralHadronIso_DR0p1To0p2;
675	>	Double_t fNeutralHadronIso_DR0p2To0p3;
676	>	Double_t fNeutralHadronIso_DR0p3To0p4;
677	>	Double_t fNeutralHadronIso_DR0p4To0p5;
678	>	Double_t fNeutralHadronIso_DR0p5To0p7;
679	>
680	>
681	>	//
682	>	//Loop over PF Candidates
683	>	//
684	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
685	>
686	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
687	>
688	>	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
689	>
690	>	Double_t deta = (mu->Eta() - pf->Eta());
691	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
692	>	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
693	>	if (dr > 1.0) continue;
694	>
695	>	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
696	>
697	>	//
698	>	// Lepton Footprint Removal
699	>	//
700	>	Bool_t IsLeptonFootprint = kFALSE;
701	>	if (dr < 1.0) {
702	>
703	>	//
704	>	// Check for electrons
705	>	//
706	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
707	>	const mithep::Electron *tmpele = electronsToVeto[q];
708	>	// 4l electron
709	>	if( pf->HasTrackerTrk() ) {
710	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
711	>	IsLeptonFootprint = kTRUE;
712	>	}
713	>	if( pf->HasGsfTrk() ) {
714	>	if( pf->GsfTrk() == tmpele->GsfTrk() )
715	>	IsLeptonFootprint = kTRUE;
716	>	}
717	>	// PF charged
718	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479
719	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
720	>	IsLeptonFootprint = kTRUE;
721	>	// PF gamma
722	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
723	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
724	>	IsLeptonFootprint = kTRUE;
725	>	} // loop over electrons
726	>
727	>	/* KH - commented for sync
728	>	//
729	>	// Check for muons
730	>	//
731	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
732	>	const mithep::Muon *tmpmu = muonsToVeto[q];
733	>	// 4l muon
734	>	if( pf->HasTrackerTrk() ) {
735	>	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
736	>	IsLeptonFootprint = kTRUE;
737	>	}
738	>	// PF charged
739	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
740	>	IsLeptonFootprint = kTRUE;
741	>	} // loop over muons
742	>	*/
743	>
744	>	if (IsLeptonFootprint)
745	>	continue;
746	>
747	>	//
748	>	// Charged Iso Rings
749	>	//
750	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
751	>
752	>	if( dr < 0.01 ) continue; // only for muon iso mva?
753	>	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
754	>
755	>	//       if( pf->HasTrackerTrk() ) {
756	>	//      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
757	>	//      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
758	>	//                            << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
759	>	//                            << dr << endl;
760	>	//       }
761	>	//       if( pf->HasGsfTrk() ) {
762	>	//      if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
763	>	//      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
764	>	//                            << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
765	>	//                            << dr << endl;
766	>	//       }
767	>
768	>	// Footprint Veto
769	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
770	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
771	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
772	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
773	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
774	>	if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
775	>	}
776	>
777	>	//
778	>	// Gamma Iso Rings
779	>	//
780	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
781	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
782	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
783	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
784	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
785	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
786	>	if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
787	>	}
788	>
789	>	//
790	>	// Other Neutral Iso Rings
791	>	//
792	>	else {
793	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
794	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
795	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
796	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
797	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
798	>	if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
799	>	}
800	>
801	>	}
802	>
803	>	}
804	>
805	>	fChargedIso_DR0p0To0p1   = fmin((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
806	>	fChargedIso_DR0p1To0p2   = fmin((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
807	>	fChargedIso_DR0p2To0p3   = fmin((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
808	>	fChargedIso_DR0p3To0p4   = fmin((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
809	>	fChargedIso_DR0p4To0p5   = fmin((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
810	>
811	>
812	>	//   double rho = 0;
813	>	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
814	>	//     rho = fPUEnergyDensity->At(0)->Rho();
815	>	//   if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
816	>	//     rho = fPUEnergyDensity->At(0)->RhoLowEta();
817	>
818	>	// WARNING!!!!
819	>	// hardcode for sync ...
820	>	EffectiveAreaVersion = muT.kMuEAData2011;
821	>	// WARNING!!!!
822	>
823	>
824	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
825	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p0To0p1,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
826	>	,2.5)
827	>	,0.0);
828	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
829	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p1To0p2,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
830	>	,2.5)
831	>	,0.0);
832	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
833	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p2To0p3,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
834	>	,2.5)
835	>	,0.0);
836	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
837	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p3To0p4,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
838	>	,2.5)
839	>	,0.0);
840	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
841	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p4To0p5,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
842	>	,2.5)
843	>	,0.0);
844	>
845	>
846	>
847	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
848	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p0To0p1,
849	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
850	>	, 2.5)
851	>	, 0.0);
852	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
853	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p1To0p2,
854	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
855	>	, 2.5)
856	>	, 0.0);
857	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
858	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p2To0p3,
859	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
860	>	, 2.5)
861	>	, 0.0);
862	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
863	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p3To0p4,
864	>	mu->Eta(), EffectiveAreaVersion))/mu->Pt()
865	>	, 2.5)
866	>	, 0.0);
867	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
868	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p4To0p5,
869	>	mu->Eta(), EffectiveAreaVersion))/mu->Pt()
870	>	, 2.5)
871	>	, 0.0);
872	>
873	>
874	>	double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
875	>	mu->Eta(),
876	>	mu->IsGlobalMuon(),
877	>	mu->IsTrackerMuon(),
878	>	fChargedIso_DR0p0To0p1,
879	>	fChargedIso_DR0p1To0p2,
880	>	fChargedIso_DR0p2To0p3,
881	>	fChargedIso_DR0p3To0p4,
882	>	fChargedIso_DR0p4To0p5,
883	>	fGammaIso_DR0p0To0p1,
884	>	fGammaIso_DR0p1To0p2,
885	>	fGammaIso_DR0p2To0p3,
886	>	fGammaIso_DR0p3To0p4,
887	>	fGammaIso_DR0p4To0p5,
888	>	fNeutralHadronIso_DR0p0To0p1,
889	>	fNeutralHadronIso_DR0p1To0p2,
890	>	fNeutralHadronIso_DR0p2To0p3,
891	>	fNeutralHadronIso_DR0p3To0p4,
892	>	fNeutralHadronIso_DR0p4To0p5,
893	>	ctrl.debug);
894	>
895	>	SelectionStatus status;
896	>	bool pass;
897	>
898	>	pass = false;
899	>	if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
900	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN0)   pass = true;
901	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
902	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN1)  pass = true;
903	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
904	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN2)  pass = true;
905	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
906	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN3)  pass = true;
907	>	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN4)  pass = true;
908	>	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN5)  pass = true;
909	>	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
910	>
911	>	/*
912	>	pass = false;
913	>	if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
914	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN0)   pass = true;
915	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
916	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN1)  pass = true;
917	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
918	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN2)  pass = true;
919	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
920	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN3)  pass = true;
921	>	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN4)  pass = true;
922	>	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN5)  pass = true;
923	>	if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
924	>	*/
925	>
926	>	//  pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
927	>
928	>	status.isoMVA = mvaval;
929	>
930	>	if(ctrl.debug)  {
931	>	cout << "returning status : " << hex << status.getStatus() << dec << endl;
932	>	cout << "MVAVAL : " << status.isoMVA << endl;
933		}
524	–	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
934		return status;
935
936		}
937
938	+
939		//--------------------------------------------------------------------------------------------------
940		void initMuonIsoMVA() {
941		//--------------------------------------------------------------------------------------------------
942		muIsoMVA = new mithep::MuonIDMVA();
943		vector<string> weightFiles;
944	<	weightFiles.push_back("../MitPhysics/data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_barrel_lowpt.weights.xml");
945	<	weightFiles.push_back("../MitPhysics/data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_barrel_highpt.weights.xml");
946	<	weightFiles.push_back("../MitPhysics/data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_endcap_lowpt.weights.xml");
947	<	weightFiles.push_back("../MitPhysics/data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_endcap_highpt.weights.xml");
948	<	weightFiles.push_back("../MitPhysics/data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_tracker.weights.xml");
949	<	weightFiles.push_back("../MitPhysics/data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_global.weights.xml");
944	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_barrel_lowpt.weights.xml");
945	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_barrel_highpt.weights.xml");
946	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_endcap_lowpt.weights.xml");
947	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_endcap_highpt.weights.xml");
948	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_tracker.weights.xml");
949	>	weightFiles.push_back("./data/MuonIsoMVAWeights/MuonIsoMVA_BDTG_V0_global.weights.xml");
950		muIsoMVA->Initialize( "MuonIsoMVA",
951		mithep::MuonIDMVA::kIsoRingsV0,
952		kTRUE, weightFiles);
#	Line 544 | Line 954 | void initMuonIsoMVA() {
954
955
956
957	+
958	+	//--------------------------------------------------------------------------------------------------
959	+	double  muonPFIso04(ControlFlags &ctrl,
960	+	const mithep::Muon * mu,
961	+	const mithep::Vertex * vtx,
962	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
963	+	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
964	+	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
965	+	vector<const mithep::Muon*> muonsToVeto,
966	+	vector<const mithep::Electron*> electronsToVeto)
967	+	//--------------------------------------------------------------------------------------------------
968	+	{
969	+
970	+	extern double gChargedIso;
971	+	extern double  gGammaIso;
972	+	extern double  gNeutralIso;
973	+
974	+	if( ctrl.debug ) {
975	+	cout << "muonIsoMVASelection :: muons to veto " << endl;
976	+	for( int i=0; i<muonsToVeto.size(); i++ ) {
977	+	const mithep::Muon * vmu = muonsToVeto[i];
978	+	cout << "\tpt: " << vmu->Pt()
979	+	<< "\teta: " << vmu->Eta()
980	+	<< "\tphi: " << vmu->Phi()
981	+	<< endl;
982	+	}
983	+	cout << "muonIsoMVASelection :: electrson to veto " << endl;
984	+	for( int i=0; i<electronsToVeto.size(); i++ ) {
985	+	const mithep::Electron * vel = electronsToVeto[i];
986	+	cout << "\tpt: " << vel->Pt()
987	+	<< "\teta: " << vel->Eta()
988	+	<< "\tphi: " << vel->Phi()
989	+	<< endl;
990	+	}
991	+	}
992	+
993	+	//
994	+	// final iso
995	+	//
996	+	Double_t fChargedIso  = 0.0;
997	+	Double_t fGammaIso  = 0.0;
998	+	Double_t fNeutralHadronIso  = 0.0;
999	+
1000	+	//
1001	+	//Loop over PF Candidates
1002	+	//
1003	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1004	+
1005	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1006	+	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1007	+
1008	+	Double_t deta = (mu->Eta() - pf->Eta());
1009	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
1010	+	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
1011	+	if (dr > 0.4) continue;
1012	+
1013	+	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
1014	+
1015	+	//
1016	+	// Lepton Footprint Removal
1017	+	//
1018	+	Bool_t IsLeptonFootprint = kFALSE;
1019	+	if (dr < 1.0) {
1020	+
1021	+	//
1022	+	// Check for electrons
1023	+	//
1024	+	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1025	+	const mithep::Electron *tmpele = electronsToVeto[q];
1026	+	// 4l electron
1027	+	if( pf->HasTrackerTrk() ) {
1028	+	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
1029	+	IsLeptonFootprint = kTRUE;
1030	+	}
1031	+	if( pf->HasGsfTrk() ) {
1032	+	if( pf->GsfTrk() == tmpele->GsfTrk() )
1033	+	IsLeptonFootprint = kTRUE;
1034	+	}
1035	+	// PF charged
1036	+	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1037	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1038	+	if( ctrl.debug) cout << "\tcharged trk, dR ("
1039	+	<< mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta())
1040	+	<< " matches 4L ele ..." << endl;
1041	+	IsLeptonFootprint = kTRUE;
1042	+	}
1043	+	// PF gamma
1044	+	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1045	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
1046	+	IsLeptonFootprint = kTRUE;
1047	+	} // loop over electrons
1048	+
1049	+	/* KH - comment for sync
1050	+	//
1051	+	// Check for muons
1052	+	//
1053	+	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1054	+	const mithep::Muon *tmpmu = muonsToVeto[q];
1055	+	// 4l muon
1056	+	if( pf->HasTrackerTrk() ) {
1057	+	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
1058	+	IsLeptonFootprint = kTRUE;
1059	+	}
1060	+	// PF charged
1061	+	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
1062	+	IsLeptonFootprint = kTRUE;
1063	+	} // loop over muons
1064	+	*/
1065	+
1066	+	if (IsLeptonFootprint)
1067	+	continue;
1068	+
1069	+	//
1070	+	// Charged Iso
1071	+	//
1072	+	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1073	+
1074	+	//if( dr < 0.01 ) continue; // only for muon iso mva?
1075	+	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1076	+
1077	+
1078	+	//       if( pf->HasTrackerTrk() ) {
1079	+	//      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1080	+	//      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1081	+	//                            << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1082	+	//                            << dr << endl;
1083	+	//       }
1084	+	//       if( pf->HasGsfTrk() ) {
1085	+	//      if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1086	+	//      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1087	+	//                            << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1088	+	//                            << dr << endl;
1089	+	//       }
1090	+
1091	+
1092	+	fChargedIso += pf->Pt();
1093	+	}
1094	+
1095	+	//
1096	+	// Gamma Iso
1097	+	//
1098	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1099	+	// KH, add to sync
1100	+	if( pf->Pt() > 0.5 )
1101	+	fGammaIso += pf->Pt();
1102	+	}
1103	+
1104	+	//
1105	+	// Other Neutrals
1106	+	//
1107	+	else {
1108	+	// KH, add to sync
1109	+	if( pf->Pt() > 0.5 )
1110	+	fNeutralHadronIso += pf->Pt();
1111	+	}
1112	+
1113	+	}
1114	+
1115	+	}
1116	+
1117	+	double rho=0;
1118	+	if( (EffectiveAreaVersion == mithep::MuonTools::kMuEAFall11MC) ||
1119	+	(EffectiveAreaVersion == mithep::MuonTools::kMuEAData2011) ) {
1120	+	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25()) ||
1121	+	isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25())))
1122	+	rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25();
1123	+	//rho = fPUEnergyDensity->At(0)->Rho();
1124	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1125	+	EffectiveAreaVersion  = mithep::MuonTools::kMuEAData2011;
1126	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1127	+	} else {
1128	+	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral()) ||
1129	+	isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral())))
1130	+	rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral();
1131	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1132	+	EffectiveAreaVersion  = mithep::MuonTools::kMuEAData2012;
1133	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1134	+	}
1135	+	if(ctrl.debug) cout << "rho: " << rho << endl;
1136	+
1137	+	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1138	+	-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1139	+	mu->Eta(),EffectiveAreaVersion)));
1140	+	gChargedIso = fChargedIso;
1141	+	gGammaIso   = fGammaIso;
1142	+	gNeutralIso = fNeutralHadronIso;
1143	+
1144	+	return pfIso;
1145	+	}
1146	+
1147	+
1148	+
1149	+
1150	+	//--------------------------------------------------------------------------------------------------
1151	+	// hacked version
1152	+	double  muonPFIso04(ControlFlags &ctrl,
1153	+	const mithep::Muon * mu,
1154	+	const mithep::Vertex * vtx,
1155	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1156	+	float rho,
1157	+	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1158	+	vector<const mithep::Muon*> muonsToVeto,
1159	+	vector<const mithep::Electron*> electronsToVeto)
1160	+	//--------------------------------------------------------------------------------------------------
1161	+	{
1162	+
1163	+	extern double gChargedIso;
1164	+	extern double  gGammaIso;
1165	+	extern double  gNeutralIso;
1166	+
1167	+	if( ctrl.debug ) {
1168	+	cout << "muonIsoMVASelection :: muons to veto " << endl;
1169	+	for( int i=0; i<muonsToVeto.size(); i++ ) {
1170	+	const mithep::Muon * vmu = muonsToVeto[i];
1171	+	cout << "\tpt: " << vmu->Pt()
1172	+	<< "\teta: " << vmu->Eta()
1173	+	<< "\tphi: " << vmu->Phi()
1174	+	<< endl;
1175	+	}
1176	+	cout << "muonIsoMVASelection :: electrson to veto " << endl;
1177	+	for( int i=0; i<electronsToVeto.size(); i++ ) {
1178	+	const mithep::Electron * vel = electronsToVeto[i];
1179	+	cout << "\tpt: " << vel->Pt()
1180	+	<< "\teta: " << vel->Eta()
1181	+	<< "\tphi: " << vel->Phi()
1182	+	<< endl;
1183	+	}
1184	+	}
1185	+
1186	+	//
1187	+	// final iso
1188	+	//
1189	+	Double_t fChargedIso  = 0.0;
1190	+	Double_t fGammaIso  = 0.0;
1191	+	Double_t fNeutralHadronIso  = 0.0;
1192	+
1193	+	//
1194	+	//Loop over PF Candidates
1195	+	//
1196	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1197	+
1198	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1199	+	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1200	+
1201	+	Double_t deta = (mu->Eta() - pf->Eta());
1202	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
1203	+	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
1204	+	if (dr > 0.4) continue;
1205	+
1206	+	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
1207	+
1208	+	//
1209	+	// Lepton Footprint Removal
1210	+	//
1211	+	Bool_t IsLeptonFootprint = kFALSE;
1212	+	if (dr < 1.0) {
1213	+
1214	+	//
1215	+	// Check for electrons
1216	+	//
1217	+	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1218	+	const mithep::Electron *tmpele = electronsToVeto[q];
1219	+	// 4l electron
1220	+	if( pf->HasTrackerTrk() ) {
1221	+	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
1222	+	IsLeptonFootprint = kTRUE;
1223	+	}
1224	+	if( pf->HasGsfTrk() ) {
1225	+	if( pf->GsfTrk() == tmpele->GsfTrk() )
1226	+	IsLeptonFootprint = kTRUE;
1227	+	}
1228	+	// PF charged
1229	+	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1230	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
1231	+	IsLeptonFootprint = kTRUE;
1232	+	// PF gamma
1233	+	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1234	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
1235	+	IsLeptonFootprint = kTRUE;
1236	+	} // loop over electrons
1237	+
1238	+	/* KH - comment for sync
1239	+	//
1240	+	// Check for muons
1241	+	//
1242	+	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1243	+	const mithep::Muon *tmpmu = muonsToVeto[q];
1244	+	// 4l muon
1245	+	if( pf->HasTrackerTrk() ) {
1246	+	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
1247	+	IsLeptonFootprint = kTRUE;
1248	+	}
1249	+	// PF charged
1250	+	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
1251	+	IsLeptonFootprint = kTRUE;
1252	+	} // loop over muons
1253	+	*/
1254	+
1255	+	if (IsLeptonFootprint)
1256	+	continue;
1257	+
1258	+	//
1259	+	// Charged Iso
1260	+	//
1261	+	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1262	+
1263	+	//if( dr < 0.01 ) continue; // only for muon iso mva?
1264	+	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1265	+
1266	+
1267	+	//       if( pf->HasTrackerTrk() ) {
1268	+	//      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1269	+	//      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1270	+	//                            << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1271	+	//                            << dr << endl;
1272	+	//       }
1273	+	//       if( pf->HasGsfTrk() ) {
1274	+	//      if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1275	+	//      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1276	+	//                            << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1277	+	//                            << dr << endl;
1278	+	//       }
1279	+
1280	+
1281	+	fChargedIso += pf->Pt();
1282	+	}
1283	+
1284	+	//
1285	+	// Gamma Iso
1286	+	//
1287	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1288	+	// KH, add to sync
1289	+	if( pf->Pt() > 0.5 )
1290	+	fGammaIso += pf->Pt();
1291	+	}
1292	+
1293	+	//
1294	+	// Other Neutrals
1295	+	//
1296	+	else {
1297	+	// KH, add to sync
1298	+	if( pf->Pt() > 0.5 )
1299	+	fNeutralHadronIso += pf->Pt();
1300	+	}
1301	+
1302	+	}
1303	+
1304	+	}
1305	+
1306	+	//   double rho = 0;
1307	+	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1308	+	//     rho = fPUEnergyDensity->At(0)->Rho();
1309	+
1310	+	// WARNING!!!!
1311	+	// hardcode for sync ...
1312	+	EffectiveAreaVersion = muT.kMuEAData2011;
1313	+	// WARNING!!!!
1314	+
1315	+
1316	+	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1317	+	-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1318	+	mu->Eta(),EffectiveAreaVersion)));
1319	+	gChargedIso = fChargedIso;
1320	+	gGammaIso   = fGammaIso;
1321	+	gNeutralIso = fNeutralHadronIso;
1322	+
1323	+	return pfIso;
1324	+	}
1325	+
1326	+
1327	+	//--------------------------------------------------------------------------------------------------
1328	+	SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1329	+	const mithep::Muon * mu,
1330	+	const mithep::Vertex * vtx,
1331	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1332	+	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1333	+	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1334	+	vector<const mithep::Muon*> muonsToVeto,
1335	+	vector<const mithep::Electron*> electronsToVeto)
1336	+	//--------------------------------------------------------------------------------------------------
1337	+	{
1338	+
1339	+	SelectionStatus status;
1340	+
1341	+	double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, fPUEnergyDensity,
1342	+	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1343	+	//  cout << "--------------> setting muon isoPF04 to" << pfIso << endl;
1344	+	status.isoPF04 = pfIso;
1345	+	status.chisoPF04 = gChargedIso;
1346	+	status.gaisoPF04 = gGammaIso;
1347	+	status.neisoPF04 = gNeutralIso;
1348	+
1349	+	bool pass = false;
1350	+	if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1351	+
1352	+	if( pass ) {
1353	+	status.orStatus(SelectionStatus::LOOSEISO);
1354	+	status.orStatus(SelectionStatus::TIGHTISO);
1355	+	}
1356	+	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1357	+	return status;
1358	+
1359	+	}
1360	+
1361	+
1362	+	//--------------------------------------------------------------------------------------------------
1363	+	// hacked version
1364	+	SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1365	+	const mithep::Muon * mu,
1366	+	const mithep::Vertex * vtx,
1367	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1368	+	float rho,
1369	+	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1370	+	vector<const mithep::Muon*> muonsToVeto,
1371	+	vector<const mithep::Electron*> electronsToVeto)
1372	+	//--------------------------------------------------------------------------------------------------
1373	+	{
1374	+
1375	+	SelectionStatus status;
1376	+
1377	+	double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, rho,
1378	+	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1379	+
1380	+	status.isoPF04 = pfIso;
1381	+	status.chisoPF04 = gChargedIso;
1382	+	status.gaisoPF04 = gGammaIso;
1383	+	status.neisoPF04 = gNeutralIso;
1384	+
1385	+	bool pass = false;
1386	+	if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1387	+
1388	+	if( pass ) {
1389	+	status.orStatus(SelectionStatus::LOOSEISO);
1390	+	status.orStatus(SelectionStatus::TIGHTISO);
1391	+	}
1392	+	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1393	+	return status;
1394	+
1395	+	}
1396	+
1397	+
1398	+
1399	+
1400		//--------------------------------------------------------------------------------------------------
1401		SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1402		const mithep::Electron * ele,
1403	<	const mithep::Vertex & vtx,
1403	>	const mithep::Vertex * vtx,
1404		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1405		const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1406		mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
#	Line 556 | Line 1409 | SelectionStatus electronIsoMVASelection(
1409		//--------------------------------------------------------------------------------------------------
1410		{
1411
1412	+	if( ctrl.debug ) {
1413	+	cout << "electronIsoMVASelection :: muons to veto " << endl;
1414	+	for( int i=0; i<muonsToVeto.size(); i++ ) {
1415	+	const mithep::Muon * vmu = muonsToVeto[i];
1416	+	cout << "\tpt: " << vmu->Pt()
1417	+	<< "\teta: " << vmu->Eta()
1418	+	<< "\tphi: " << vmu->Phi()
1419	+	<< endl;
1420	+	}
1421	+	cout << "electronIsoMVASelection :: electrson to veto " << endl;
1422	+	for( int i=0; i<electronsToVeto.size(); i++ ) {
1423	+	const mithep::Electron * vel = electronsToVeto[i];
1424	+	cout << "\tpt: " << vel->Pt()
1425	+	<< "\teta: " << vel->Eta()
1426	+	<< "\tphi: " << vel->Phi()
1427	+	<< "\ttrk: " << vel->TrackerTrk()
1428	+	<< endl;
1429	+	}
1430	+	}
1431	+
1432		bool failiso=false;
1433
1434		//
1435		// tmp iso rings
1436		//
1437	<	Double_t tmpChargedIso_DR0p0To0p05  = 0;
1438	<	Double_t tmpChargedIso_DR0p05To0p1  = 0;
1439	<	Double_t tmpChargedIso_DR0p1To0p15  = 0;
567	<	Double_t tmpChargedIso_DR0p15To0p2  = 0;
568	<	Double_t tmpChargedIso_DR0p2To0p25  = 0;
569	<	Double_t tmpChargedIso_DR0p25To0p3  = 0;
1437	>	Double_t tmpChargedIso_DR0p0To0p1  = 0;
1438	>	Double_t tmpChargedIso_DR0p1To0p2  = 0;
1439	>	Double_t tmpChargedIso_DR0p2To0p3  = 0;
1440		Double_t tmpChargedIso_DR0p3To0p4  = 0;
1441		Double_t tmpChargedIso_DR0p4To0p5  = 0;
1442
1443	<	Double_t tmpGammaIso_DR0p0To0p05  = 0;
1444	<	Double_t tmpGammaIso_DR0p05To0p1  = 0;
1445	<	Double_t tmpGammaIso_DR0p1To0p15  = 0;
576	<	Double_t tmpGammaIso_DR0p15To0p2  = 0;
577	<	Double_t tmpGammaIso_DR0p2To0p25  = 0;
578	<	Double_t tmpGammaIso_DR0p25To0p3  = 0;
1443	>	Double_t tmpGammaIso_DR0p0To0p1  = 0;
1444	>	Double_t tmpGammaIso_DR0p1To0p2  = 0;
1445	>	Double_t tmpGammaIso_DR0p2To0p3  = 0;
1446		Double_t tmpGammaIso_DR0p3To0p4  = 0;
1447		Double_t tmpGammaIso_DR0p4To0p5  = 0;
1448
1449	<	Double_t tmpNeutralHadronIso_DR0p0To0p05  = 0;
1450	<	Double_t tmpNeutralHadronIso_DR0p05To0p1  = 0;
1451	<	Double_t tmpNeutralHadronIso_DR0p1To0p15  = 0;
1452	<	Double_t tmpNeutralHadronIso_DR0p15To0p2  = 0;
586	<	Double_t tmpNeutralHadronIso_DR0p2To0p25  = 0;
587	<	Double_t tmpNeutralHadronIso_DR0p25To0p3  = 0;
1449	>
1450	>	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
1451	>	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
1452	>	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
1453		Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
1454		Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
1455	+
1456
591	–	Double_t tmp2ChargedIso_DR0p5To1p0  = 0;
1457
1458		//
1459		// final rings for the MVA
#	Line 616 | Line 1481 | SelectionStatus electronIsoMVASelection(
1481		//Loop over PF Candidates
1482		//
1483		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
619	–	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1484
1485	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1486	+
1487	+	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1488		Double_t deta = (ele->Eta() - pf->Eta());
1489		Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1490		Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1491		if (dr > 1.0) continue;
1492
1493	<	if (pf->PFType() == PFCandidate::eElectron && pf->TrackerTrk() == ele->TrackerTrk() ) continue;
1493	>	if(ctrl.debug) {
1494	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1495	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1496	>	cout << endl;
1497	>	}
1498	>
1499	>
1500	>	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
1501	>	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1502	>
1503
1504		//
1505		// Lepton Footprint Removal
#	Line 631 | Line 1507 | SelectionStatus electronIsoMVASelection(
1507		Bool_t IsLeptonFootprint = kFALSE;
1508		if (dr < 1.0) {
1509
1510	+
1511		//
1512		// Check for electrons
1513		//
1514	+
1515		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1516		const mithep::Electron *tmpele = electronsToVeto[q];
1517	<	// PF electron
1518	<	if( pf->PFType() == PFCandidate::eElectron && pf->TrackerTrk() == tmpele->TrackerTrk() )
1519	<	IsLeptonFootprint = kTRUE;
1517	>	double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1518	>
1519	>	// 4l electron
1520	>	if( pf->HasTrackerTrk()  ) {
1521	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1522	>	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1523	>	IsLeptonFootprint = kTRUE;
1524	>	}
1525	>	}
1526	>	if( pf->HasGsfTrk()  ) {
1527	>	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1528	>	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1529	>	IsLeptonFootprint = kTRUE;
1530	>	}
1531	>	}
1532		// PF charged
1533	<	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1534	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
1533	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1534	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1535		IsLeptonFootprint = kTRUE;
1536	+	}
1537		// PF gamma
1538	<	if (pf->PFType() == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1539	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
1538	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1539	>	&& tmpdr < 0.08) {
1540	>	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1541		IsLeptonFootprint = kTRUE;
1542	+	}
1543		} // loop over electrons
1544	<
1544	>
1545	>
1546	>	/* KH - comment for sync
1547		//
1548		// Check for muons
1549		//
1550		for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1551		const mithep::Muon *tmpmu = muonsToVeto[q];
1552	<	// PF muons
1553	<	if (pf->PFType() == PFCandidate::eMuon && pf->TrackerTrk() == tmpmu->TrackerTrk() )
1554	<	IsLeptonFootprint = kTRUE;
1552	>	// 4l muon
1553	>	if( pf->HasTrackerTrk() ) {
1554	>	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1555	>	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1556	>	IsLeptonFootprint = kTRUE;
1557	>	}
1558	>	}
1559		// PF charged
1560	<	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
1560	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1561	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1562		IsLeptonFootprint = kTRUE;
1563	+	}
1564		} // loop over muons
1565	<
1565	>	*/
1566
1567		if (IsLeptonFootprint)
1568		continue;
#	Line 669 | Line 1570 | SelectionStatus electronIsoMVASelection(
1570		//
1571		// Charged Iso Rings
1572		//
1573	<	if (pf->Charge() != 0 && pf->HasTrackerTrk() ) {
1573	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1574	>
1575	>	//       if( pf->HasGsfTrk() ) {
1576	>	//       if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1577	>	//       } else if( pf->HasTrackerTrk() ){
1578	>	//      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1579	>	//       }
1580
674	–	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
675	–
1581		// Veto any PFmuon, or PFEle
1582	<	if (pf->PFType() == PFCandidate::eElectron || pf->PFType() == PFCandidate::eMuon) continue;
1582	>	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1583
1584		// Footprint Veto
1585	<	if (dr < 0.01) continue;
1585	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1586	>
1587	>	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1588	>	<< "\ttype: " << pf->PFType()
1589	>	<< "\ttrk: " << pf->TrackerTrk() << endl;
1590	>
1591	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
1592	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
1593	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1594	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1595	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
1596
682	–	if (dr < 0.05)               tmpChargedIso_DR0p0To0p05 += pf->Pt();
683	–	if (dr >= 0.05 && dr < 0.10) tmpChargedIso_DR0p05To0p1 += pf->Pt();
684	–	if (dr >= 0.10 && dr < 0.15) tmpChargedIso_DR0p1To0p15 += pf->Pt();
685	–	if (dr >= 0.15 && dr < 0.20) tmpChargedIso_DR0p15To0p2 += pf->Pt();
686	–	if (dr >= 0.20 && dr < 0.25) tmpChargedIso_DR0p2To0p25 += pf->Pt();
687	–	if (dr >= 0.25 && dr < 0.3)  tmpChargedIso_DR0p25To0p3 += pf->Pt();
688	–	if (dr >= 0.3 && dr < 0.4)   tmpChargedIso_DR0p3To0p4  += pf->Pt();
689	–	if (dr >= 0.4 && dr < 0.5)   tmpChargedIso_DR0p4To0p5  += pf->Pt();
1597		}
1598
1599		//
1600		// Gamma Iso Rings
1601		//
1602	<	else if (pf->PFType() == PFCandidate::eGamma) {
1602	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1603
1604	<	if (dr < 0.05)               tmpGammaIso_DR0p0To0p05 += pf->Pt();
1605	<	if (dr >= 0.05 && dr < 0.10) tmpGammaIso_DR0p05To0p1 += pf->Pt();
1606	<	if (dr >= 0.10 && dr < 0.15) tmpGammaIso_DR0p1To0p15 += pf->Pt();
1607	<	if (dr >= 0.15 && dr < 0.20) tmpGammaIso_DR0p15To0p2 += pf->Pt();
1608	<	if (dr >= 0.20 && dr < 0.25) tmpGammaIso_DR0p2To0p25 += pf->Pt();
1609	<	if (dr >= 0.25 && dr < 0.3)  tmpGammaIso_DR0p25To0p3 += pf->Pt();
1610	<	if (dr >= 0.3 && dr < 0.4)   tmpGammaIso_DR0p3To0p4  += pf->Pt();
1611	<	if (dr >= 0.4 && dr < 0.5)   tmpGammaIso_DR0p4To0p5  += pf->Pt();
1604	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
1605	>
1606	>	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1607	>	<< dr << endl;
1608	>
1609	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
1610	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
1611	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1612	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1613	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
1614		}
1615
1616		//
1617		// Other Neutral Iso Rings
1618		//
1619		else {
1620	<	if (dr < 0.05)               tmpNeutralHadronIso_DR0p0To0p05 += pf->Pt();
1621	<	if (dr >= 0.05 && dr < 0.10) tmpNeutralHadronIso_DR0p05To0p1 += pf->Pt();
1622	<	if (dr >= 0.10 && dr < 0.15) tmpNeutralHadronIso_DR0p1To0p15 += pf->Pt();
1623	<	if (dr >= 0.15 && dr < 0.20) tmpNeutralHadronIso_DR0p15To0p2 += pf->Pt();
1624	<	if (dr >= 0.20 && dr < 0.25) tmpNeutralHadronIso_DR0p2To0p25 += pf->Pt();
1625	<	if (dr >= 0.25 && dr < 0.3)  tmpNeutralHadronIso_DR0p25To0p3 += pf->Pt();
1626	<	if (dr >= 0.3 && dr < 0.4)   tmpNeutralHadronIso_DR0p3To0p4  += pf->Pt();
718	<	if (dr >= 0.4 && dr < 0.5)   tmpNeutralHadronIso_DR0p4To0p5  += pf->Pt();
1620	>	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
1621	>	<< dr << endl;
1622	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
1623	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
1624	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1625	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1626	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1627		}
1628
1629		}
1630
1631		}
1632
1633	<	fChargedIso_DR0p0To0p1   = min((tmpChargedIso_DR0p0To0p05 + tmpChargedIso_DR0p05To0p1 )/ele->Pt(), 2.5);
1634	<	fChargedIso_DR0p1To0p2   = min((tmpChargedIso_DR0p1To0p15 + tmpChargedIso_DR0p15To0p2)/ele->Pt(), 2.5);
1635	<	fChargedIso_DR0p2To0p3   = min((tmpChargedIso_DR0p2To0p25 + tmpChargedIso_DR0p25To0p3)/ele->Pt(), 2.5);
1636	<	fChargedIso_DR0p3To0p4   = min((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1637	<	fChargedIso_DR0p4To0p5   = min((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1633	>	fChargedIso_DR0p0To0p1   = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1634	>	fChargedIso_DR0p1To0p2   = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1635	>	fChargedIso_DR0p2To0p3   = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1636	>	fChargedIso_DR0p3To0p4   = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1637	>	fChargedIso_DR0p4To0p5   = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1638	>
1639	>	if(ctrl.debug) {
1640	>	cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1  << endl;
1641	>	cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2  << endl;
1642	>	cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3  << endl;
1643	>	cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4  << endl;
1644	>	cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5  << endl;
1645	>	}
1646	>
1647
1648		double rho = 0;
1649		if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1650		rho = fPUEnergyDensity->At(0)->Rho();
1651	+	//   if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1652	+	//     rho = fPUEnergyDensity->At(0)->RhoLowEta();
1653
1654	<
1655	<	fGammaIso_DR0p0To0p1 = max(min((tmpGammaIso_DR0p0To0p05 + tmpGammaIso_DR0p05To0p1
1654	>	// WARNING!!!!
1655	>	// hardcode for sync ...
1656	>	EffectiveAreaVersion = eleT.kEleEAData2011;
1657	>	// WARNING!!!!
1658	>
1659	>	if( ctrl.debug) {
1660	>	cout << "RHO: " << rho << endl;
1661	>	cout << "eta: " << ele->SCluster()->Eta() << endl;
1662	>	cout << "target: " << EffectiveAreaVersion << endl;
1663	>	cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1664	>	ele->SCluster()->Eta(),
1665	>	EffectiveAreaVersion)
1666	>	<< endl;
1667	>	cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1668	>	ele->SCluster()->Eta(),
1669	>	EffectiveAreaVersion)
1670	>	<< endl;
1671	>	cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1672	>	ele->SCluster()->Eta(),
1673	>	EffectiveAreaVersion)
1674	>	<< endl;
1675	>	cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1676	>	ele->SCluster()->Eta(),
1677	>	EffectiveAreaVersion)
1678	>	<< endl;
1679	>	}
1680	>
1681	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
1682		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
1683	<	ele->Eta(),
1683	>	ele->SCluster()->Eta(),
1684		EffectiveAreaVersion))/ele->Pt()
1685		,2.5)
1686		,0.0);
1687	<	fGammaIso_DR0p1To0p2 = max(min((tmpGammaIso_DR0p1To0p15 + tmpGammaIso_DR0p15To0p2
1687	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
1688		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
1689	<	ele->Eta(),
1689	>	ele->SCluster()->Eta(),
1690		EffectiveAreaVersion))/ele->Pt()
1691		,2.5)
1692		,0.0);
1693	<	fGammaIso_DR0p2To0p3 = max(min((tmpGammaIso_DR0p2To0p25 + tmpGammaIso_DR0p25To0p3
1693	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
1694		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
1695	<	ele->Eta()
1695	>	ele->SCluster()->Eta()
1696		,EffectiveAreaVersion))/ele->Pt()
1697		,2.5)
1698		,0.0);
1699	<	fGammaIso_DR0p3To0p4 = max(min((tmpGammaIso_DR0p3To0p4
1699	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
1700		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
1701	<	ele->Eta(),
1701	>	ele->SCluster()->Eta(),
1702		EffectiveAreaVersion))/ele->Pt()
1703		,2.5)
1704		,0.0);
1705	<	fGammaIso_DR0p4To0p5 = max(min((tmpGammaIso_DR0p4To0p5
1705	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
1706		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
1707	<	ele->Eta(),
1707	>	ele->SCluster()->Eta(),
1708		EffectiveAreaVersion))/ele->Pt()
1709		,2.5)
1710		,0.0);
1711
1712
1713	<	fNeutralHadronIso_DR0p0To0p1 = max(min((tmpNeutralHadronIso_DR0p0To0p05 + tmpNeutralHadronIso_DR0p05To0p1
1713	>	if( ctrl.debug) {
1714	>	cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
1715	>	cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
1716	>	cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
1717	>	cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
1718	>	cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
1719	>	}
1720	>
1721	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
1722		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1723	<	ele->Eta(),EffectiveAreaVersion))/ele->Pt()
1723	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1724		, 2.5)
1725		, 0.0);
1726	<	fNeutralHadronIso_DR0p1To0p2 = max(min((tmpNeutralHadronIso_DR0p1To0p15 + tmpNeutralHadronIso_DR0p15To0p2
1726	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
1727		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1728	<	ele->Eta(),EffectiveAreaVersion))/ele->Pt()
1728	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1729		, 2.5)
1730		, 0.0);
1731	<	fNeutralHadronIso_DR0p2To0p3 = max(min((tmpNeutralHadronIso_DR0p2To0p25 + tmpNeutralHadronIso_DR0p25To0p3
1731	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
1732		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1733	<	ele->Eta(),EffectiveAreaVersion))/ele->Pt()
1733	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1734		, 2.5)
1735		, 0.0);
1736	<	fNeutralHadronIso_DR0p3To0p4 = max(min((tmpNeutralHadronIso_DR0p3To0p4
1736	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
1737		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1738	<	ele->Eta(), EffectiveAreaVersion))/ele->Pt()
1738	>	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1739		, 2.5)
1740		, 0.0);
1741	<	fNeutralHadronIso_DR0p4To0p5 = max(min((tmpNeutralHadronIso_DR0p4To0p5
1741	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
1742		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
1743	<	ele->Eta(), EffectiveAreaVersion))/ele->Pt()
1743	>	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1744		, 2.5)
1745		, 0.0);
1746
1747	+	if( ctrl.debug) {
1748	+	cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
1749	+	cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
1750	+	cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
1751	+	cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
1752	+	cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
1753	+	}
1754	+
1755		double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
1756	<	ele->Eta(),
1757	<	fChargedIso_DR0p0To0p1,
1758	<	fChargedIso_DR0p1To0p2,
1759	<	fChargedIso_DR0p2To0p3,
1760	<	fChargedIso_DR0p3To0p4,
1761	<	fChargedIso_DR0p4To0p5,
1762	<	fGammaIso_DR0p0To0p1,
1763	<	fGammaIso_DR0p1To0p2,
1764	<	fGammaIso_DR0p2To0p3,
1765	<	fGammaIso_DR0p3To0p4,
1766	<	fGammaIso_DR0p4To0p5,
1767	<	fNeutralHadronIso_DR0p0To0p1,
1768	<	fNeutralHadronIso_DR0p1To0p2,
1769	<	fNeutralHadronIso_DR0p2To0p3,
1770	<	fNeutralHadronIso_DR0p3To0p4,
1771	<	fNeutralHadronIso_DR0p4To0p5,
1772	<	ctrl.debug);
1756	>	ele->SCluster()->Eta(),
1757	>	fChargedIso_DR0p0To0p1,
1758	>	fChargedIso_DR0p1To0p2,
1759	>	fChargedIso_DR0p2To0p3,
1760	>	fChargedIso_DR0p3To0p4,
1761	>	fChargedIso_DR0p4To0p5,
1762	>	fGammaIso_DR0p0To0p1,
1763	>	fGammaIso_DR0p1To0p2,
1764	>	fGammaIso_DR0p2To0p3,
1765	>	fGammaIso_DR0p3To0p4,
1766	>	fGammaIso_DR0p4To0p5,
1767	>	fNeutralHadronIso_DR0p0To0p1,
1768	>	fNeutralHadronIso_DR0p1To0p2,
1769	>	fNeutralHadronIso_DR0p2To0p3,
1770	>	fNeutralHadronIso_DR0p3To0p4,
1771	>	fNeutralHadronIso_DR0p4To0p5,
1772	>	ctrl.debug);
1773
1774		SelectionStatus status;
1775	+	status.isoMVA = mvaval;
1776		bool pass = false;
1777
1778		Int_t subdet = 0;
1779		if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
1780		else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
1781		else subdet = 2;
1782	+
1783		Int_t ptBin = 0;
1784	<	if (ele->Pt() > 10.0) ptBin = 1;
1784	>	if (ele->Pt() >= 10.0) ptBin = 1;
1785
1786		Int_t MVABin = -1;
1787		if (subdet == 0 && ptBin == 0) MVABin = 0;
#	Line 827 | Line 1790 | SelectionStatus electronIsoMVASelection(
1790		if (subdet == 0 && ptBin == 1) MVABin = 3;
1791		if (subdet == 1 && ptBin == 1) MVABin = 4;
1792		if (subdet == 2 && ptBin == 1) MVABin = 5;
830	–
831	–	if( MVABin == 0 && mvaval > ELECTRON_ISOMVA_CUT_BIN0 ) pass = true;
832	–	if( MVABin == 1 && mvaval > ELECTRON_ISOMVA_CUT_BIN1 ) pass = true;
833	–	if( MVABin == 2 && mvaval > ELECTRON_ISOMVA_CUT_BIN2 ) pass = true;
834	–	if( MVABin == 3 && mvaval > ELECTRON_ISOMVA_CUT_BIN3 ) pass = true;
835	–	if( MVABin == 4 && mvaval > ELECTRON_ISOMVA_CUT_BIN4 ) pass = true;
836	–	if( MVABin == 5 && mvaval > ELECTRON_ISOMVA_CUT_BIN5 ) pass = true;
1793
1794	<	if( pass ) {
1795	<	status.orStatus(SelectionStatus::LOOSEISO);
1796	<	status.orStatus(SelectionStatus::TIGHTISO);
1797	<	}
1794	>	pass = false;
1795	>	if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN0 ) pass = true;
1796	>	if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN1 ) pass = true;
1797	>	if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN2 ) pass = true;
1798	>	if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN3 ) pass = true;
1799	>	if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN4 ) pass = true;
1800	>	if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN5 ) pass = true;
1801	>	//  pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
1802	>	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
1803	>
1804	>	//   pass = false;
1805	>	//   if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
1806	>	//   if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
1807	>	//   if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
1808	>	//   if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
1809	>	//   if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
1810	>	//   if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
1811	>	//   if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
1812	>
1813		if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1814		return status;
1815	+
1816	+	}
1817	+
1818	+
1819	+	//--------------------------------------------------------------------------------------------------
1820	+	SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1821	+	const mithep::Electron * ele,
1822	+	const mithep::Vertex * vtx,
1823	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1824	+	float rho,
1825	+	//const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1826	+	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1827	+	vector<const mithep::Muon*> muonsToVeto,
1828	+	vector<const mithep::Electron*> electronsToVeto)
1829	+	//--------------------------------------------------------------------------------------------------
1830	+	// hacked version
1831	+	{
1832	+	if( ctrl.debug ) {
1833	+	cout << "================> hacked ele Iso MVA <======================" << endl;
1834	+	}
1835	+
1836	+	if( ctrl.debug ) {
1837	+	cout << "electronIsoMVASelection :: muons to veto " << endl;
1838	+	for( int i=0; i<muonsToVeto.size(); i++ ) {
1839	+	const mithep::Muon * vmu = muonsToVeto[i];
1840	+	cout << "\tpt: " << vmu->Pt()
1841	+	<< "\teta: " << vmu->Eta()
1842	+	<< "\tphi: " << vmu->Phi()
1843	+	<< endl;
1844	+	}
1845	+	cout << "electronIsoMVASelection :: electrson to veto " << endl;
1846	+	for( int i=0; i<electronsToVeto.size(); i++ ) {
1847	+	const mithep::Electron * vel = electronsToVeto[i];
1848	+	cout << "\tpt: " << vel->Pt()
1849	+	<< "\teta: " << vel->Eta()
1850	+	<< "\tphi: " << vel->Phi()
1851	+	<< "\ttrk: " << vel->TrackerTrk()
1852	+	<< endl;
1853	+	}
1854	+	}
1855	+
1856	+	bool failiso=false;
1857	+
1858	+	//
1859	+	// tmp iso rings
1860	+	//
1861	+	Double_t tmpChargedIso_DR0p0To0p1  = 0;
1862	+	Double_t tmpChargedIso_DR0p1To0p2  = 0;
1863	+	Double_t tmpChargedIso_DR0p2To0p3  = 0;
1864	+	Double_t tmpChargedIso_DR0p3To0p4  = 0;
1865	+	Double_t tmpChargedIso_DR0p4To0p5  = 0;
1866	+
1867	+	Double_t tmpGammaIso_DR0p0To0p1  = 0;
1868	+	Double_t tmpGammaIso_DR0p1To0p2  = 0;
1869	+	Double_t tmpGammaIso_DR0p2To0p3  = 0;
1870	+	Double_t tmpGammaIso_DR0p3To0p4  = 0;
1871	+	Double_t tmpGammaIso_DR0p4To0p5  = 0;
1872	+
1873	+
1874	+	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
1875	+	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
1876	+	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
1877	+	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
1878	+	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
1879	+
1880	+
1881	+
1882	+	//
1883	+	// final rings for the MVA
1884	+	//
1885	+	Double_t fChargedIso_DR0p0To0p1;
1886	+	Double_t fChargedIso_DR0p1To0p2;
1887	+	Double_t fChargedIso_DR0p2To0p3;
1888	+	Double_t fChargedIso_DR0p3To0p4;
1889	+	Double_t fChargedIso_DR0p4To0p5;
1890	+
1891	+	Double_t fGammaIso_DR0p0To0p1;
1892	+	Double_t fGammaIso_DR0p1To0p2;
1893	+	Double_t fGammaIso_DR0p2To0p3;
1894	+	Double_t fGammaIso_DR0p3To0p4;
1895	+	Double_t fGammaIso_DR0p4To0p5;
1896	+
1897	+	Double_t fNeutralHadronIso_DR0p0To0p1;
1898	+	Double_t fNeutralHadronIso_DR0p1To0p2;
1899	+	Double_t fNeutralHadronIso_DR0p2To0p3;
1900	+	Double_t fNeutralHadronIso_DR0p3To0p4;
1901	+	Double_t fNeutralHadronIso_DR0p4To0p5;
1902	+
1903	+
1904	+	//
1905	+	//Loop over PF Candidates
1906	+	//
1907	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1908	+
1909	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1910	+
1911	+	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1912	+	Double_t deta = (ele->Eta() - pf->Eta());
1913	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1914	+	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1915	+	if (dr > 1.0) continue;
1916
1917	+	if(ctrl.debug) {
1918	+	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1919	+	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1920	+	cout << endl;
1921	+	}
1922	+
1923	+
1924	+	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
1925	+	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1926	+
1927	+
1928	+	//
1929	+	// Lepton Footprint Removal
1930	+	//
1931	+	Bool_t IsLeptonFootprint = kFALSE;
1932	+	if (dr < 1.0) {
1933	+
1934	+
1935	+	//
1936	+	// Check for electrons
1937	+	//
1938	+
1939	+	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1940	+	const mithep::Electron *tmpele = electronsToVeto[q];
1941	+	double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1942	+
1943	+	// 4l electron
1944	+	if( pf->HasTrackerTrk()  ) {
1945	+	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1946	+	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1947	+	IsLeptonFootprint = kTRUE;
1948	+	}
1949	+	}
1950	+	if( pf->HasGsfTrk()  ) {
1951	+	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1952	+	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1953	+	IsLeptonFootprint = kTRUE;
1954	+	}
1955	+	}
1956	+	// PF charged
1957	+	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1958	+	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1959	+	IsLeptonFootprint = kTRUE;
1960	+	}
1961	+	// PF gamma
1962	+	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1963	+	&& tmpdr < 0.08) {
1964	+	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1965	+	IsLeptonFootprint = kTRUE;
1966	+	}
1967	+	} // loop over electrons
1968	+
1969	+
1970	+	/* KH - comment for sync
1971	+	//
1972	+	// Check for muons
1973	+	//
1974	+	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1975	+	const mithep::Muon *tmpmu = muonsToVeto[q];
1976	+	// 4l muon
1977	+	if( pf->HasTrackerTrk() ) {
1978	+	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1979	+	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1980	+	IsLeptonFootprint = kTRUE;
1981	+	}
1982	+	}
1983	+	// PF charged
1984	+	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1985	+	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1986	+	IsLeptonFootprint = kTRUE;
1987	+	}
1988	+	} // loop over muons
1989	+	*/
1990	+
1991	+	if (IsLeptonFootprint)
1992	+	continue;
1993	+
1994	+	//
1995	+	// Charged Iso Rings
1996	+	//
1997	+	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1998	+
1999	+	//       if( pf->HasGsfTrk() ) {
2000	+	//       if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2001	+	//       } else if( pf->HasTrackerTrk() ){
2002	+	//      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2003	+	//       }
2004	+
2005	+	// Veto any PFmuon, or PFEle
2006	+	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
2007	+
2008	+	// Footprint Veto
2009	+	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
2010	+
2011	+	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
2012	+	<< "\ttype: " << pf->PFType()
2013	+	<< "\ttrk: " << pf->TrackerTrk() << endl;
2014	+
2015	+	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
2016	+	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
2017	+	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
2018	+	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
2019	+	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
2020	+
2021	+	}
2022	+
2023	+	//
2024	+	// Gamma Iso Rings
2025	+	//
2026	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2027	+
2028	+	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
2029	+
2030	+	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2031	+	<< dr << endl;
2032	+
2033	+	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
2034	+	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
2035	+	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
2036	+	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
2037	+	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
2038	+	}
2039	+
2040	+	//
2041	+	// Other Neutral Iso Rings
2042	+	//
2043	+	else {
2044	+	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2045	+	<< dr << endl;
2046	+	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
2047	+	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
2048	+	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
2049	+	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
2050	+	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
2051	+	}
2052	+
2053	+	}
2054	+
2055	+	}
2056	+
2057	+	fChargedIso_DR0p0To0p1   = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
2058	+	fChargedIso_DR0p1To0p2   = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
2059	+	fChargedIso_DR0p2To0p3   = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
2060	+	fChargedIso_DR0p3To0p4   = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
2061	+	fChargedIso_DR0p4To0p5   = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
2062	+
2063	+	if(ctrl.debug) {
2064	+	cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1  << endl;
2065	+	cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2  << endl;
2066	+	cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3  << endl;
2067	+	cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4  << endl;
2068	+	cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5  << endl;
2069	+	}
2070	+
2071	+
2072	+	//  rho=0;
2073	+	//  double rho = 0;
2074	+	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
2075	+	//     rho = fPUEnergyDensity->At(0)->Rho();
2076	+	//   if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
2077	+	//     rho = fPUEnergyDensity->At(0)->RhoLowEta();
2078	+
2079	+	// WARNING!!!!
2080	+	// hardcode for sync ...
2081	+	EffectiveAreaVersion = eleT.kEleEAData2011;
2082	+	// WARNING!!!!
2083	+
2084	+	if( ctrl.debug) {
2085	+	cout << "RHO: " << rho << endl;
2086	+	cout << "eta: " << ele->SCluster()->Eta() << endl;
2087	+	cout << "target: " << EffectiveAreaVersion << endl;
2088	+	cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
2089	+	ele->SCluster()->Eta(),
2090	+	EffectiveAreaVersion)
2091	+	<< endl;
2092	+	cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
2093	+	ele->SCluster()->Eta(),
2094	+	EffectiveAreaVersion)
2095	+	<< endl;
2096	+	cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
2097	+	ele->SCluster()->Eta(),
2098	+	EffectiveAreaVersion)
2099	+	<< endl;
2100	+	cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
2101	+	ele->SCluster()->Eta(),
2102	+	EffectiveAreaVersion)
2103	+	<< endl;
2104	+	}
2105	+
2106	+	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
2107	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
2108	+	ele->SCluster()->Eta(),
2109	+	EffectiveAreaVersion))/ele->Pt()
2110	+	,2.5)
2111	+	,0.0);
2112	+	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
2113	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
2114	+	ele->SCluster()->Eta(),
2115	+	EffectiveAreaVersion))/ele->Pt()
2116	+	,2.5)
2117	+	,0.0);
2118	+	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
2119	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
2120	+	ele->SCluster()->Eta()
2121	+	,EffectiveAreaVersion))/ele->Pt()
2122	+	,2.5)
2123	+	,0.0);
2124	+	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
2125	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
2126	+	ele->SCluster()->Eta(),
2127	+	EffectiveAreaVersion))/ele->Pt()
2128	+	,2.5)
2129	+	,0.0);
2130	+	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
2131	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
2132	+	ele->SCluster()->Eta(),
2133	+	EffectiveAreaVersion))/ele->Pt()
2134	+	,2.5)
2135	+	,0.0);
2136	+
2137	+
2138	+	if( ctrl.debug) {
2139	+	cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
2140	+	cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
2141	+	cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
2142	+	cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
2143	+	cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
2144	+	}
2145	+
2146	+	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
2147	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
2148	+	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2149	+	, 2.5)
2150	+	, 0.0);
2151	+	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
2152	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
2153	+	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2154	+	, 2.5)
2155	+	, 0.0);
2156	+	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
2157	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
2158	+	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2159	+	, 2.5)
2160	+	, 0.0);
2161	+	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
2162	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
2163	+	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2164	+	, 2.5)
2165	+	, 0.0);
2166	+	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
2167	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
2168	+	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2169	+	, 2.5)
2170	+	, 0.0);
2171	+
2172	+	if( ctrl.debug) {
2173	+	cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
2174	+	cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
2175	+	cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
2176	+	cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
2177	+	cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
2178	+	}
2179	+
2180	+	double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
2181	+	ele->SCluster()->Eta(),
2182	+	fChargedIso_DR0p0To0p1,
2183	+	fChargedIso_DR0p1To0p2,
2184	+	fChargedIso_DR0p2To0p3,
2185	+	fChargedIso_DR0p3To0p4,
2186	+	fChargedIso_DR0p4To0p5,
2187	+	fGammaIso_DR0p0To0p1,
2188	+	fGammaIso_DR0p1To0p2,
2189	+	fGammaIso_DR0p2To0p3,
2190	+	fGammaIso_DR0p3To0p4,
2191	+	fGammaIso_DR0p4To0p5,
2192	+	fNeutralHadronIso_DR0p0To0p1,
2193	+	fNeutralHadronIso_DR0p1To0p2,
2194	+	fNeutralHadronIso_DR0p2To0p3,
2195	+	fNeutralHadronIso_DR0p3To0p4,
2196	+	fNeutralHadronIso_DR0p4To0p5,
2197	+	ctrl.debug);
2198	+
2199	+	SelectionStatus status;
2200	+	status.isoMVA = mvaval;
2201	+	bool pass = false;
2202	+
2203	+	Int_t subdet = 0;
2204	+	if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
2205	+	else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
2206	+	else subdet = 2;
2207	+
2208	+	Int_t ptBin = 0;
2209	+	if (ele->Pt() >= 10.0) ptBin = 1;
2210	+
2211	+	Int_t MVABin = -1;
2212	+	if (subdet == 0 && ptBin == 0) MVABin = 0;
2213	+	if (subdet == 1 && ptBin == 0) MVABin = 1;
2214	+	if (subdet == 2 && ptBin == 0) MVABin = 2;
2215	+	if (subdet == 0 && ptBin == 1) MVABin = 3;
2216	+	if (subdet == 1 && ptBin == 1) MVABin = 4;
2217	+	if (subdet == 2 && ptBin == 1) MVABin = 5;
2218	+
2219	+	pass = false;
2220	+	if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN0 ) pass = true;
2221	+	if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN1 ) pass = true;
2222	+	if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN2 ) pass = true;
2223	+	if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN3 ) pass = true;
2224	+	if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN4 ) pass = true;
2225	+	if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN5 ) pass = true;
2226	+	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
2227	+
2228	+	//   pass = false;
2229	+	//   if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
2230	+	//   if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
2231	+	//   if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
2232	+	//   if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
2233	+	//   if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
2234	+	//   if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
2235	+	//   if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
2236	+
2237	+	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2238	+	return status;
2239	+
2240		}
2241
2242
#	Line 858 | Line 2253 | void initElectronIsoMVA() {
2253		mithep::ElectronIDMVA::kIsoRingsV0,
2254		kTRUE, weightFiles);
2255		}
2256	+
2257	+
2258	+
2259	+
2260	+	//--------------------------------------------------------------------------------------------------
2261	+	float electronPFIso04(ControlFlags &ctrl,
2262	+	const mithep::Electron * ele,
2263	+	const mithep::Vertex * vtx,
2264	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2265	+	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2266	+	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2267	+	vector<const mithep::Muon*> muonsToVeto,
2268	+	vector<const mithep::Electron*> electronsToVeto)
2269	+	//--------------------------------------------------------------------------------------------------
2270	+	{
2271	+	/*
2272	+	if( ctrl.debug ) {
2273	+	cout << "electronIsoMVASelection :: muons to veto " << endl;
2274	+	for( int i=0; i<muonsToVeto.size(); i++ ) {
2275	+	const mithep::Muon * vmu = muonsToVeto[i];
2276	+	cout << "\tpt: " << vmu->Pt()
2277	+	<< "\teta: " << vmu->Eta()
2278	+	<< "\tphi: " << vmu->Phi()
2279	+	<< endl;
2280	+	}
2281	+	cout << "electronIsoMVASelection :: electrons to veto " << endl;
2282	+	for( int i=0; i<electronsToVeto.size(); i++ ) {
2283	+	const mithep::Electron * vel = electronsToVeto[i];
2284	+	cout << "\tpt: " << vel->Pt()
2285	+	<< "\teta: " << vel->Eta()
2286	+	<< "\tphi: " << vel->Phi()
2287	+	<< "\ttrk: " << vel->TrackerTrk()
2288	+	<< endl;
2289	+	}
2290	+	}
2291	+	*/
2292	+
2293	+	//
2294	+	// final iso
2295	+	//
2296	+	Double_t fChargedIso = 0.0;
2297	+	Double_t fGammaIso = 0.0;
2298	+	Double_t fNeutralHadronIso = 0.0;
2299	+
2300	+
2301	+	//
2302	+	//Loop over PF Candidates
2303	+	//
2304	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2305	+
2306	+
2307	+	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2308	+	Double_t deta = (ele->Eta() - pf->Eta());
2309	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2310	+	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2311	+
2312	+	if (dr > 0.4) continue;
2313	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2314	+
2315	+	if(ctrl.debug) {
2316	+	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2317	+	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
2318	+	<< "\ttrk: " << pf->HasTrackerTrk()
2319	+	<< "\tgsf: " << pf->HasGsfTrk();
2320	+
2321	+	cout << endl;
2322	+	}
2323	+
2324	+
2325	+	//
2326	+	// sync : I don't think theyre doing this ...
2327	+	//
2328	+	//     if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
2329	+	//   (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2330	+	//       if( ctrl.debug ) cout << "\tskipping, matches to the electron ..."  << endl;
2331	+	//       continue;
2332	+	//     }
2333	+
2334	+
2335	+	//
2336	+	// Lepton Footprint Removal
2337	+	//
2338	+	Bool_t IsLeptonFootprint = kFALSE;
2339	+	if (dr < 1.0) {
2340	+
2341	+	//
2342	+	// Check for electrons
2343	+	//
2344	+	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2345	+	const mithep::Electron *tmpele = electronsToVeto[q];
2346	+	/*
2347	+	// 4l electron
2348	+	if( pf->HasTrackerTrk()  ) {
2349	+	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
2350	+	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
2351	+	IsLeptonFootprint = kTRUE;
2352	+	}
2353	+	}
2354	+	if( pf->HasGsfTrk()  ) {
2355	+	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
2356	+	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
2357	+	IsLeptonFootprint = kTRUE;
2358	+	}
2359	+	}
2360	+	*/
2361	+	// PF charged
2362	+	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2363	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
2364	+	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
2365	+	IsLeptonFootprint = kTRUE;
2366	+	}
2367	+	// PF gamma
2368	+	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
2369	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
2370	+	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
2371	+	IsLeptonFootprint = kTRUE;
2372	+	}
2373	+	} // loop over electrons
2374	+
2375	+	/* KH - comment for sync
2376	+	//
2377	+	// Check for muons
2378	+	//
2379	+	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
2380	+	const mithep::Muon *tmpmu = muonsToVeto[q];
2381	+	// 4l muon
2382	+	if( pf->HasTrackerTrk() ) {
2383	+	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
2384	+	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
2385	+	IsLeptonFootprint = kTRUE;
2386	+	}
2387	+	}
2388	+	// PF charged
2389	+	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
2390	+	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
2391	+	IsLeptonFootprint = kTRUE;
2392	+	}
2393	+	} // loop over muons
2394	+	*/
2395	+
2396	+	if (IsLeptonFootprint)
2397	+	continue;
2398	+
2399	+	//
2400	+	// Charged Iso
2401	+	//
2402	+	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
2403	+
2404	+	//       if( pf->HasTrackerTrk() )
2405	+	//      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2406	+	//       if( pf->HasGsfTrk() )
2407	+	//      if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2408	+
2409	+	// Veto any PFmuon, or PFEle
2410	+	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) {
2411	+	if( ctrl.debug ) cout << "\t skipping, pf is and ele or mu .." <<endl;
2412	+	continue;
2413	+	}
2414	+
2415	+	// Footprint Veto
2416	+	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
2417	+
2418	+	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
2419	+	<< "\ttype: " << pf->PFType()
2420	+	<< "\ttrk: " << pf->TrackerTrk() << endl;
2421	+
2422	+	fChargedIso += pf->Pt();
2423	+	}
2424	+
2425	+	//
2426	+	// Gamma Iso
2427	+	//
2428	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2429	+
2430	+	if (fabs(ele->SCluster()->Eta()) > 1.479) {
2431	+	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
2432	+	}
2433	+	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2434	+	<< dr << endl;
2435	+	// KH, add to sync
2436	+	//      if( pf->Pt() > 0.5 )
2437	+	fGammaIso += pf->Pt();
2438	+	}
2439	+
2440	+	//
2441	+	// Neutral Iso
2442	+	//
2443	+	else {
2444	+	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2445	+	<< dr << endl;
2446	+	// KH, add to sync
2447	+	//      if( pf->Pt() > 0.5 )
2448	+	fNeutralHadronIso += pf->Pt();
2449	+	}
2450	+
2451	+	}
2452	+
2453	+	}
2454	+
2455	+
2456	+	double rho=0;
2457	+	if( (EffectiveAreaVersion == mithep::ElectronTools::kEleEAFall11MC) ||
2458	+	(EffectiveAreaVersion == mithep::ElectronTools::kEleEAData2011) ) {
2459	+	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25()) ||
2460	+	isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25())))
2461	+	rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25();
2462	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2463	+	EffectiveAreaVersion  = mithep::ElectronTools::kEleEAData2011;
2464	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2465	+	} else {
2466	+	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJets()) ||
2467	+	isinf(fPUEnergyDensity->At(0)->RhoKt6PFJets())))
2468	+	rho = fPUEnergyDensity->At(0)->RhoKt6PFJets();
2469	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2470	+	EffectiveAreaVersion  = mithep::ElectronTools::kEleEAData2012;
2471	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2472	+	}
2473	+	if(ctrl.debug) cout << "rho: " << rho << endl;
2474	+
2475	+	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2476	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2477	+	ele->Eta(),EffectiveAreaVersion)));
2478	+
2479	+
2480	+	gChargedIso = fChargedIso;
2481	+	gGammaIso = fGammaIso;
2482	+	gNeutralIso = fNeutralHadronIso;
2483	+	return pfIso;
2484	+	}
2485	+
2486	+
2487	+
2488	+	//--------------------------------------------------------------------------------------------------
2489	+	// hacked version
2490	+	float electronPFIso04(ControlFlags &ctrl,
2491	+	const mithep::Electron * ele,
2492	+	const mithep::Vertex * vtx,
2493	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2494	+	float rho,
2495	+	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2496	+	vector<const mithep::Muon*> muonsToVeto,
2497	+	vector<const mithep::Electron*> electronsToVeto)
2498	+	//--------------------------------------------------------------------------------------------------
2499	+	{
2500	+
2501	+	if( ctrl.debug ) {
2502	+	cout << "electronIsoMVASelection :: muons to veto " << endl;
2503	+	for( int i=0; i<muonsToVeto.size(); i++ ) {
2504	+	const mithep::Muon * vmu = muonsToVeto[i];
2505	+	cout << "\tpt: " << vmu->Pt()
2506	+	<< "\teta: " << vmu->Eta()
2507	+	<< "\tphi: " << vmu->Phi()
2508	+	<< endl;
2509	+	}
2510	+	cout << "electronIsoMVASelection :: electrons to veto " << endl;
2511	+	for( int i=0; i<electronsToVeto.size(); i++ ) {
2512	+	const mithep::Electron * vel = electronsToVeto[i];
2513	+	cout << "\tpt: " << vel->Pt()
2514	+	<< "\teta: " << vel->Eta()
2515	+	<< "\tphi: " << vel->Phi()
2516	+	<< "\ttrk: " << vel->TrackerTrk()
2517	+	<< endl;
2518	+	}
2519	+	}
2520	+
2521	+
2522	+	//
2523	+	// final iso
2524	+	//
2525	+	Double_t fChargedIso = 0.0;
2526	+	Double_t fGammaIso = 0.0;
2527	+	Double_t fNeutralHadronIso = 0.0;
2528	+
2529	+
2530	+	//
2531	+	//Loop over PF Candidates
2532	+	//
2533	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2534	+
2535	+
2536	+	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2537	+	Double_t deta = (ele->Eta() - pf->Eta());
2538	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2539	+	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2540	+
2541	+	if (dr > 0.4) continue;
2542	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2543	+
2544	+	if(ctrl.debug) {
2545	+	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2546	+	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
2547	+	<< "\ttrk: " << pf->HasTrackerTrk()
2548	+	<< "\tgsf: " << pf->HasGsfTrk();
2549	+
2550	+	cout << endl;
2551	+	}
2552	+
2553	+
2554	+	//
2555	+	// sync : I don't think theyre doing this ...
2556	+	//
2557	+	//     if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
2558	+	//   (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2559	+	//       if( ctrl.debug ) cout << "\tskipping, matches to the electron ..."  << endl;
2560	+	//       continue;
2561	+	//     }
2562	+
2563	+
2564	+	//
2565	+	// Lepton Footprint Removal
2566	+	//
2567	+	Bool_t IsLeptonFootprint = kFALSE;
2568	+	if (dr < 1.0) {
2569	+
2570	+	//
2571	+	// Check for electrons
2572	+	//
2573	+	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2574	+	const mithep::Electron *tmpele = electronsToVeto[q];
2575	+	/*
2576	+	// 4l electron
2577	+	if( pf->HasTrackerTrk()  ) {
2578	+	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
2579	+	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
2580	+	IsLeptonFootprint = kTRUE;
2581	+	}
2582	+	}
2583	+	if( pf->HasGsfTrk()  ) {
2584	+	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
2585	+	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
2586	+	IsLeptonFootprint = kTRUE;
2587	+	}
2588	+	}
2589	+	*/
2590	+	// PF charged
2591	+	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2592	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
2593	+	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
2594	+	IsLeptonFootprint = kTRUE;
2595	+	}
2596	+	// PF gamma
2597	+	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
2598	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
2599	+	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
2600	+	IsLeptonFootprint = kTRUE;
2601	+	}
2602	+	} // loop over electrons
2603	+
2604	+	/* KH - comment for sync
2605	+	//
2606	+	// Check for muons
2607	+	//
2608	+	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
2609	+	const mithep::Muon *tmpmu = muonsToVeto[q];
2610	+	// 4l muon
2611	+	if( pf->HasTrackerTrk() ) {
2612	+	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
2613	+	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
2614	+	IsLeptonFootprint = kTRUE;
2615	+	}
2616	+	}
2617	+	// PF charged
2618	+	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
2619	+	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
2620	+	IsLeptonFootprint = kTRUE;
2621	+	}
2622	+	} // loop over muons
2623	+	*/
2624	+
2625	+	if (IsLeptonFootprint)
2626	+	continue;
2627	+
2628	+	//
2629	+	// Charged Iso
2630	+	//
2631	+	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
2632	+
2633	+	//       if( pf->HasTrackerTrk() )
2634	+	//      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2635	+	//       if( pf->HasGsfTrk() )
2636	+	//      if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2637	+
2638	+	// Veto any PFmuon, or PFEle
2639	+	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) {
2640	+	if( ctrl.debug ) cout << "\t skipping, pf is and ele or mu .." <<endl;
2641	+	continue;
2642	+	}
2643	+
2644	+	// Footprint Veto
2645	+	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
2646	+
2647	+	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
2648	+	<< "\ttype: " << pf->PFType()
2649	+	<< "\ttrk: " << pf->TrackerTrk() << endl;
2650	+
2651	+	fChargedIso += pf->Pt();
2652	+	}
2653	+
2654	+	//
2655	+	// Gamma Iso
2656	+	//
2657	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2658	+
2659	+	if (fabs(ele->SCluster()->Eta()) > 1.479) {
2660	+	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
2661	+	}
2662	+	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2663	+	<< dr << endl;
2664	+	// KH, add to sync
2665	+	//      if( pf->Pt() > 0.5 )
2666	+	fGammaIso += pf->Pt();
2667	+	}
2668	+
2669	+	//
2670	+	// Neutral Iso
2671	+	//
2672	+	else {
2673	+	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2674	+	<< dr << endl;
2675	+	// KH, add to sync
2676	+	//      if( pf->Pt() > 0.5 )
2677	+	fNeutralHadronIso += pf->Pt();
2678	+	}
2679	+
2680	+	}
2681	+
2682	+	}
2683	+
2684	+	//   double rho = 0;
2685	+	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
2686	+	//     rho = fPUEnergyDensity->At(0)->Rho();
2687	+
2688	+	// WARNING!!!!
2689	+	// hardcode for sync ...
2690	+	EffectiveAreaVersion = eleT.kEleEAData2011;
2691	+	// WARNING!!!!
2692	+
2693	+
2694	+	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2695	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2696	+	ele->Eta(),EffectiveAreaVersion)));
2697	+
2698	+
2699	+	gChargedIso = fChargedIso;
2700	+	gGammaIso = fGammaIso;
2701	+	gNeutralIso = fNeutralHadronIso;
2702	+	return pfIso;
2703	+	}
2704	+
2705	+
2706	+	//--------------------------------------------------------------------------------------------------
2707	+	SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2708	+	const mithep::Electron * ele,
2709	+	const mithep::Vertex * vtx,
2710	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2711	+	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2712	+	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2713	+	vector<const mithep::Muon*> muonsToVeto,
2714	+	vector<const mithep::Electron*> electronsToVeto)
2715	+	//--------------------------------------------------------------------------------------------------
2716	+	{
2717	+
2718	+	SelectionStatus status;
2719	+
2720	+	double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, fPUEnergyDensity,
2721	+	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2722	+	//  cout << "--------------> setting electron isoPF04 to " << pfIso << endl;
2723	+	status.isoPF04 = pfIso;
2724	+	status.chisoPF04 = gChargedIso;
2725	+	status.gaisoPF04 = gGammaIso;
2726	+	status.neisoPF04 = gNeutralIso;
2727	+
2728	+	bool pass = false;
2729	+	if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2730	+
2731	+	if( pass ) {
2732	+	status.orStatus(SelectionStatus::LOOSEISO);
2733	+	status.orStatus(SelectionStatus::TIGHTISO);
2734	+	}
2735	+	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2736	+	return status;
2737	+
2738	+	}
2739	+
2740	+
2741	+	//--------------------------------------------------------------------------------------------------
2742	+	// hacked version
2743	+	SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2744	+	const mithep::Electron * ele,
2745	+	const mithep::Vertex * vtx,
2746	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2747	+	float rho,
2748	+	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2749	+	vector<const mithep::Muon*> muonsToVeto,
2750	+	vector<const mithep::Electron*> electronsToVeto)
2751	+	//--------------------------------------------------------------------------------------------------
2752	+	{
2753	+
2754	+	SelectionStatus status;
2755	+
2756	+	double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, rho,
2757	+	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2758	+	status.isoPF04 = pfIso;
2759	+	status.chisoPF04 = gChargedIso;
2760	+	status.gaisoPF04 = gGammaIso;
2761	+	status.neisoPF04 = gNeutralIso;
2762	+	bool pass = false;
2763	+	if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2764	+
2765	+	if( pass ) {
2766	+	status.orStatus(SelectionStatus::LOOSEISO);
2767	+	status.orStatus(SelectionStatus::TIGHTISO);
2768	+	}
2769	+	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2770	+	return status;
2771	+
2772	+	}
2773	+
2774	+
2775	+
2776	+	//--------------------------------------------------------------------------------------------------
2777	+	double  dbetaCorrectedIsoDr03(ControlFlags & ctrl,
2778	+	const mithep::PFCandidate * photon,
2779	+	const mithep::Muon * lepton,
2780	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates)
2781	+	//--------------------------------------------------------------------------------------------------
2782	+	{
2783	+
2784	+	//
2785	+	// final iso
2786	+	//
2787	+	Double_t fChargedIso  = 0.0;
2788	+	Double_t fGammaIso  = 0.0;
2789	+	Double_t fNeutralHadronIso  = 0.0;
2790	+	Double_t fpfPU  = 0.0;
2791	+
2792	+	//
2793	+	// Loop over PF Candidates
2794	+	//
2795	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2796	+
2797	+	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2798	+
2799	+	Double_t deta = (photon->Eta() - pf->Eta());
2800	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2801	+	Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2802	+	if (dr > 0.3) continue;
2803	+
2804	+	if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2805	+	if( pf->Pt() >= 0.2 && dr > 0.01 )
2806	+	fpfPU += pf->Pt();
2807	+	continue;
2808	+	}
2809	+
2810	+	//
2811	+	// skip this photon
2812	+	//
2813	+	if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
2814	+	pf->Et() == photon->Et() ) continue;
2815	+
2816	+
2817	+	//
2818	+	// Charged Iso
2819	+	//
2820	+	if (pf->Charge() != 0 ) {
2821	+	if( dr > 0.01 && pf->Pt() >= 0.2 &&
2822	+	!(pf->TrackerTrk() == lepton->TrackerTrk()) )
2823	+	fChargedIso += pf->Pt();
2824	+	}
2825	+
2826	+	//
2827	+	// Gamma Iso
2828	+	//
2829	+	else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
2830	+	if( pf->Pt() > 0.5 && dr > 0.01)
2831	+	fGammaIso += pf->Pt();
2832	+	}
2833	+
2834	+	//
2835	+	// Other Neutrals
2836	+	//
2837	+	else {
2838	+	if( pf->Pt() > 0.5 && dr > 0.01)
2839	+	fNeutralHadronIso += pf->Pt();
2840	+	}
2841	+
2842	+	}
2843	+
2844	+	if( ctrl.debug ) {
2845	+	cout << "photon dbetaIso :: " << endl;
2846	+	cout << "\tfChargedIso: " << fChargedIso
2847	+	<< "\tfGammaIso: " << fGammaIso
2848	+	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
2849	+	<< "\tfpfPU: " << fpfPU
2850	+	<< endl;
2851	+	}
2852	+	double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso - 0.5*fpfPU;
2853	+	return pfIso/photon->Pt();
2854	+	}
2855	+
2856	+
2857	+	//--------------------------------------------------------------------------------------------------
2858	+	double  dbetaCorrectedIsoDr03(ControlFlags & ctrl,
2859	+	const mithep::PFCandidate * photon,
2860	+	const mithep::Electron * lepton,
2861	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates)
2862	+	//--------------------------------------------------------------------------------------------------
2863	+	{
2864	+
2865	+	//
2866	+	// final iso
2867	+	//
2868	+	Double_t fChargedIso  = 0.0;
2869	+	Double_t fGammaIso  = 0.0;
2870	+	Double_t fNeutralHadronIso  = 0.0;
2871	+	Double_t fpfPU  = 0.0;
2872	+
2873	+	//
2874	+	// Loop over PF Candidates
2875	+	//
2876	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2877	+
2878	+	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2879	+
2880	+	Double_t deta = (photon->Eta() - pf->Eta());
2881	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2882	+	Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2883	+	if (dr > 0.3) continue;
2884	+
2885	+	if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2886	+	if( pf->Pt() >= 0.2 && dr > 0.01 )
2887	+	fpfPU += pf->Pt();
2888	+	continue;
2889	+	}
2890	+
2891	+	//
2892	+	// skip this photon
2893	+	//
2894	+	if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
2895	+	pf->Et() == photon->Et() ) continue;
2896	+
2897	+
2898	+	//
2899	+	// Charged Iso
2900	+	//
2901	+	if (pf->Charge() != 0 ) {
2902	+	if( dr > 0.01 && pf->Pt() >= 0.2 &&
2903	+	!(pf->TrackerTrk() == lepton->TrackerTrk()) )
2904	+	fChargedIso += pf->Pt();
2905	+	}
2906	+
2907	+	//
2908	+	// Gamma Iso
2909	+	//
2910	+	else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
2911	+	if( pf->Pt() > 0.5 && dr > 0.01)
2912	+	fGammaIso += pf->Pt();
2913	+	}
2914	+
2915	+	//
2916	+	// Other Neutrals
2917	+	//
2918	+	else {
2919	+	if( pf->Pt() > 0.5 && dr > 0.01)
2920	+	fNeutralHadronIso += pf->Pt();
2921	+	}
2922	+
2923	+	}
2924	+
2925	+	if( ctrl.debug ) {
2926	+	cout << "photon dbetaIso :: " << endl;
2927	+	cout << "\tfChargedIso: " << fChargedIso
2928	+	<< "\tfGammaIso: " << fGammaIso
2929	+	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
2930	+	<< "\tfpfPU: " << fpfPU
2931	+	<< endl;
2932	+	}
2933	+	double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso - 0.5*fpfPU;
2934	+	return pfIso/photon->Pt();
2935	+	}
2936	+
2937	+
2938	+
2939	+
2940	+
2941	+	//--------------------------------------------------------------------------------------------------
2942	+	double  betaCorrectedIsoDr03(ControlFlags & ctrl,
2943	+	const mithep::PFCandidate * photon,
2944	+	const mithep::Muon * lepton,
2945	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates)
2946	+	//--------------------------------------------------------------------------------------------------
2947	+	{
2948	+
2949	+	//
2950	+	// final iso
2951	+	//
2952	+	Double_t fChargedIso  = 0.0;
2953	+	Double_t fGammaIso  = 0.0;
2954	+	Double_t fNeutralHadronIso  = 0.0;
2955	+	Double_t fpfPU  = 0.0;
2956	+
2957	+	//
2958	+	// Loop over PF Candidates
2959	+	//
2960	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2961	+
2962	+	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2963	+
2964	+	Double_t deta = (photon->Eta() - pf->Eta());
2965	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2966	+	Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2967	+	if (dr > 0.3) continue;
2968	+
2969	+	if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2970	+	if( pf->Pt() >= 0.2 && dr > 0.01 )
2971	+	fpfPU += pf->Pt();
2972	+	continue;
2973	+	}
2974	+
2975	+	//
2976	+	// skip this photon
2977	+	//
2978	+	if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
2979	+	pf->Et() == photon->Et() ) continue;
2980	+
2981	+
2982	+	//
2983	+	// Charged Iso
2984	+	//
2985	+	if (pf->Charge() != 0 ) {
2986	+	if( dr > 0.01 && pf->Pt() >= 0.2 &&
2987	+	!(pf->TrackerTrk() == lepton->TrackerTrk()) )
2988	+	fChargedIso += pf->Pt();
2989	+	}
2990	+
2991	+	//
2992	+	// Gamma Iso
2993	+	//
2994	+	else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
2995	+	if( pf->Pt() > 0.5 && dr > 0.01)
2996	+	fGammaIso += pf->Pt();
2997	+	}
2998	+
2999	+	//
3000	+	// Other Neutrals
3001	+	//
3002	+	else {
3003	+	if( pf->Pt() > 0.5 && dr > 0.01)
3004	+	fNeutralHadronIso += pf->Pt();
3005	+	}
3006	+
3007	+	}
3008	+
3009	+	if( ctrl.debug ) {
3010	+	cout << "photon dbetaIso :: " << endl;
3011	+	cout << "\tfChargedIso: " << fChargedIso
3012	+	<< "\tfGammaIso: " << fGammaIso
3013	+	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
3014	+	<< "\tfpfPU: " << fpfPU
3015	+	<< endl;
3016	+	}
3017	+	double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso + fpfPU;
3018	+	return pfIso/photon->Pt();
3019	+	}
3020	+
3021	+
3022	+	//--------------------------------------------------------------------------------------------------
3023	+	double  betaCorrectedIsoDr03(ControlFlags & ctrl,
3024	+	const mithep::PFCandidate * photon,
3025	+	const mithep::Electron * lepton,
3026	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates)
3027	+	//--------------------------------------------------------------------------------------------------
3028	+	{
3029	+
3030	+	//
3031	+	// final iso
3032	+	//
3033	+	Double_t fChargedIso  = 0.0;
3034	+	Double_t fGammaIso  = 0.0;
3035	+	Double_t fNeutralHadronIso  = 0.0;
3036	+	Double_t fpfPU  = 0.0;
3037	+
3038	+	//
3039	+	// Loop over PF Candidates
3040	+	//
3041	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
3042	+
3043	+	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
3044	+
3045	+	Double_t deta = (photon->Eta() - pf->Eta());
3046	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
3047	+	Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
3048	+	if (dr > 0.3) continue;
3049	+
3050	+	if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
3051	+	if( pf->Pt() >= 0.2 && dr > 0.01 )
3052	+	fpfPU += pf->Pt();
3053	+	continue;
3054	+	}
3055	+
3056	+	//
3057	+	// skip this photon
3058	+	//
3059	+	if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
3060	+	pf->Et() == photon->Et() ) continue;
3061	+
3062	+
3063	+	//
3064	+	// Charged Iso
3065	+	//
3066	+	if (pf->Charge() != 0 ) {
3067	+	if( dr > 0.01 && pf->Pt() >= 0.2 &&
3068	+	!(pf->TrackerTrk() == lepton->TrackerTrk()) )
3069	+	fChargedIso += pf->Pt();
3070	+	}
3071	+
3072	+	//
3073	+	// Gamma Iso
3074	+	//
3075	+	else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
3076	+	if( pf->Pt() > 0.5 && dr > 0.01)
3077	+	fGammaIso += pf->Pt();
3078	+	}
3079	+
3080	+	//
3081	+	// Other Neutrals
3082	+	//
3083	+	else {
3084	+	if( pf->Pt() > 0.5 && dr > 0.01)
3085	+	fNeutralHadronIso += pf->Pt();
3086	+	}
3087	+
3088	+	}
3089	+
3090	+	if( ctrl.debug ) {
3091	+	cout << "photon dbetaIso :: " << endl;
3092	+	cout << "\tfChargedIso: " << fChargedIso
3093	+	<< "\tfGammaIso: " << fGammaIso
3094	+	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
3095	+	<< "\tfpfPU: " << fpfPU
3096	+	<< endl;
3097	+	}
3098	+	double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso + fpfPU;
3099	+	return pfIso/photon->Pt();
3100	+	}
3101	+
3102	+
3103	+

Diff Legend

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