ViewVC Help

View File | Revision Log | Show Annotations | Root Listing

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

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents):
Revision 1.8 by khahn, Wed May 2 17:50:58 2012 UTC vs.
Revision 1.25 by anlevin, Wed May 23 22:36:14 2012 UTC

#	Line 16 | Line 16 | mithep::MuonTools       muT;
16		mithep::ElectronIDMVA * eleIsoMVA;
17		mithep::ElectronTools   eleT;
18
19	+	// global hack to sync
20	+	double gChargedIso;
21	+	double gGammaIso;
22	+	double gNeutralIso;
23	+
24	+	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 332 | Line 338 | SelectionStatus muonIsoMVASelection(Cont
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 362 | Line 371 | SelectionStatus muonIsoMVASelection(Cont
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 (abs(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		//
#	Line 385 | Line 395 | SelectionStatus muonIsoMVASelection(Cont
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 398 | Line 408 | SelectionStatus muonIsoMVASelection(Cont
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	<	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	<	}
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		// Footprint Veto
425		if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
#	Line 448 | Line 458 | SelectionStatus muonIsoMVASelection(Cont
458
459		}
460
461	<	fChargedIso_DR0p0To0p1   = min((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
462	<	fChargedIso_DR0p1To0p2   = min((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
463	<	fChargedIso_DR0p2To0p3   = min((tmpChargedIso_DR0p2To0p3)/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	+	//   if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
472	+	//     rho = fPUEnergyDensity->At(0)->RhoLowEta();
473
474	+	// WARNING!!!!
475	+	// hardcode for sync ...
476	+	EffectiveAreaVersion = muT.kMuEAData2011;
477	+	// WARNING!!!!
478	+
479
480	<	fGammaIso_DR0p0To0p1 = max(min((tmpGammaIso_DR0p0To0p1
480	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
481		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p0To0p1,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
482		,2.5)
483		,0.0);
484	<	fGammaIso_DR0p1To0p2 = max(min((tmpGammaIso_DR0p1To0p2
484	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
485		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p1To0p2,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
486		,2.5)
487		,0.0);
488	<	fGammaIso_DR0p2To0p3 = max(min((tmpGammaIso_DR0p2To0p3
488	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
489		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p2To0p3,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
490		,2.5)
491		,0.0);
492	<	fGammaIso_DR0p3To0p4 = max(min((tmpGammaIso_DR0p3To0p4
492	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
493		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p3To0p4,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
494		,2.5)
495		,0.0);
496	<	fGammaIso_DR0p4To0p5 = max(min((tmpGammaIso_DR0p4To0p5
496	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
497		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p4To0p5,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
498		,2.5)
499		,0.0);
500
501
502
503	<	fNeutralHadronIso_DR0p0To0p1 = max(min((tmpNeutralHadronIso_DR0p0To0p1
503	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
504		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p0To0p1,
505		mu->Eta(),EffectiveAreaVersion))/mu->Pt()
506		, 2.5)
507		, 0.0);
508	<	fNeutralHadronIso_DR0p1To0p2 = max(min((tmpNeutralHadronIso_DR0p1To0p2
508	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
509		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p1To0p2,
510		mu->Eta(),EffectiveAreaVersion))/mu->Pt()
511		, 2.5)
512		, 0.0);
513	<	fNeutralHadronIso_DR0p2To0p3 = max(min((tmpNeutralHadronIso_DR0p2To0p3
513	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
514		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p2To0p3,
515		mu->Eta(),EffectiveAreaVersion))/mu->Pt()
516		, 2.5)
517		, 0.0);
518	<	fNeutralHadronIso_DR0p3To0p4 = max(min((tmpNeutralHadronIso_DR0p3To0p4
518	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
519		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p3To0p4,
520		mu->Eta(), EffectiveAreaVersion))/mu->Pt()
521		, 2.5)
522		, 0.0);
523	<	fNeutralHadronIso_DR0p4To0p5 = max(min((tmpNeutralHadronIso_DR0p4To0p5
523	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
524		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p4To0p5,
525		mu->Eta(), EffectiveAreaVersion))/mu->Pt()
526		, 2.5)
#	Line 511 | Line 528 | SelectionStatus muonIsoMVASelection(Cont
528
529
530		double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
531	<	mu->Eta(),
532	<	fChargedIso_DR0p0To0p1,
533	<	fChargedIso_DR0p1To0p2,
534	<	fChargedIso_DR0p2To0p3,
535	<	fChargedIso_DR0p3To0p4,
536	<	fChargedIso_DR0p4To0p5,
537	<	fGammaIso_DR0p0To0p1,
538	<	fGammaIso_DR0p1To0p2,
539	<	fGammaIso_DR0p2To0p3,
540	<	fGammaIso_DR0p3To0p4,
541	<	fGammaIso_DR0p4To0p5,
542	<	fNeutralHadronIso_DR0p0To0p1,
543	<	fNeutralHadronIso_DR0p1To0p2,
544	<	fNeutralHadronIso_DR0p2To0p3,
545	<	fNeutralHadronIso_DR0p3To0p4,
546	<	fNeutralHadronIso_DR0p4To0p5,
547	<	ctrl.debug);
531	>	mu->Eta(),
532	>	mu->IsGlobalMuon(),
533	>	mu->IsTrackerMuon(),
534	>	fChargedIso_DR0p0To0p1,
535	>	fChargedIso_DR0p1To0p2,
536	>	fChargedIso_DR0p2To0p3,
537	>	fChargedIso_DR0p3To0p4,
538	>	fChargedIso_DR0p4To0p5,
539	>	fGammaIso_DR0p0To0p1,
540	>	fGammaIso_DR0p1To0p2,
541	>	fGammaIso_DR0p2To0p3,
542	>	fGammaIso_DR0p3To0p4,
543	>	fGammaIso_DR0p4To0p5,
544	>	fNeutralHadronIso_DR0p0To0p1,
545	>	fNeutralHadronIso_DR0p1To0p2,
546	>	fNeutralHadronIso_DR0p2To0p3,
547	>	fNeutralHadronIso_DR0p3To0p4,
548	>	fNeutralHadronIso_DR0p4To0p5,
549	>	ctrl.debug);
550
551		SelectionStatus status;
552	<	bool pass = false;
552	>	bool pass;
553
554	+	pass = false;
555		if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
556	<	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_FORPFID_CUT_BIN0)   pass = true;
556	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN0)   pass = true;
557		else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
558	<	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_FORPFID_CUT_BIN1)  pass = true;
558	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN1)  pass = true;
559		else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
560	<	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_FORPFID_CUT_BIN2)  pass = true;
560	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN2)  pass = true;
561		else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
562	<	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_FORPFID_CUT_BIN3)  pass = true;
563	<	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon()
564	<	&& mvaval >= MUON_ISOMVA_FORPFID_CUT_BIN4)
565	<	pass = true;
562	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN3)  pass = true;
563	>	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN4)  pass = true;
564	>	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN5)  pass = true;
565	>	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
566
567	+	/*
568	+	pass = false;
569	+	if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
570	+	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN0)   pass = true;
571	+	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
572	+	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN1)  pass = true;
573	+	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
574	+	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN2)  pass = true;
575	+	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
576	+	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN3)  pass = true;
577	+	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN4)  pass = true;
578	+	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN5)  pass = true;
579	+	if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
580	+	*/
581	+
582	+	//  pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
583	+
584	+	status.isoMVA = mvaval;
585	+
586	+	if(ctrl.debug)  {
587	+	cout << "returning status : " << hex << status.getStatus() << dec << endl;
588	+	cout << "MVAVAL : " << status.isoMVA << endl;
589	+	}
590	+	return status;
591
592	<	pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
592	>	}
593
594	<	if( pass ) {
595	<	status.orStatus(SelectionStatus::LOOSEISO);
596	<	status.orStatus(SelectionStatus::TIGHTISO);
594	>
595	>	//--------------------------------------------------------------------------------------------------
596	>	SelectionStatus muonIsoMVASelection(ControlFlags &ctrl,
597	>	const mithep::Muon * mu,
598	>	const mithep::Vertex * vtx,
599	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
600	>	float rho,
601	>	//const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
602	>	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
603	>	vector<const mithep::Muon*> muonsToVeto,
604	>	vector<const mithep::Electron*> electronsToVeto)
605	>	//--------------------------------------------------------------------------------------------------
606	>	// hacked version
607	>	{
608	>
609	>	if( ctrl.debug ) {
610	>	cout << "muonIsoMVASelection :: muons to veto " << endl;
611	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
612	>	const mithep::Muon * vmu = muonsToVeto[i];
613	>	cout << "\tpt: " << vmu->Pt()
614	>	<< "\teta: " << vmu->Eta()
615	>	<< "\tphi: " << vmu->Phi()
616	>	<< endl;
617	>	}
618	>	cout << "muonIsoMVASelection :: electrson to veto " << endl;
619	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
620	>	const mithep::Electron * vel = electronsToVeto[i];
621	>	cout << "\tpt: " << vel->Pt()
622	>	<< "\teta: " << vel->Eta()
623	>	<< "\tphi: " << vel->Phi()
624	>	<< endl;
625	>	}
626	>	}
627	>	bool failiso=false;
628	>
629	>	//
630	>	// tmp iso rings
631	>	//
632	>	Double_t tmpChargedIso_DR0p0To0p1  = 0;
633	>	Double_t tmpChargedIso_DR0p1To0p2  = 0;
634	>	Double_t tmpChargedIso_DR0p2To0p3  = 0;
635	>	Double_t tmpChargedIso_DR0p3To0p4  = 0;
636	>	Double_t tmpChargedIso_DR0p4To0p5  = 0;
637	>	Double_t tmpChargedIso_DR0p5To0p7  = 0;
638	>
639	>	Double_t tmpGammaIso_DR0p0To0p1  = 0;
640	>	Double_t tmpGammaIso_DR0p1To0p2  = 0;
641	>	Double_t tmpGammaIso_DR0p2To0p3  = 0;
642	>	Double_t tmpGammaIso_DR0p3To0p4  = 0;
643	>	Double_t tmpGammaIso_DR0p4To0p5  = 0;
644	>	Double_t tmpGammaIso_DR0p5To0p7  = 0;
645	>
646	>	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
647	>	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
648	>	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
649	>	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
650	>	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
651	>	Double_t tmpNeutralHadronIso_DR0p5To0p7  = 0;
652	>
653	>
654	>
655	>	//
656	>	// final rings for the MVA
657	>	//
658	>	Double_t fChargedIso_DR0p0To0p1;
659	>	Double_t fChargedIso_DR0p1To0p2;
660	>	Double_t fChargedIso_DR0p2To0p3;
661	>	Double_t fChargedIso_DR0p3To0p4;
662	>	Double_t fChargedIso_DR0p4To0p5;
663	>	Double_t fChargedIso_DR0p5To0p7;
664	>
665	>	Double_t fGammaIso_DR0p0To0p1;
666	>	Double_t fGammaIso_DR0p1To0p2;
667	>	Double_t fGammaIso_DR0p2To0p3;
668	>	Double_t fGammaIso_DR0p3To0p4;
669	>	Double_t fGammaIso_DR0p4To0p5;
670	>	Double_t fGammaIso_DR0p5To0p7;
671	>
672	>	Double_t fNeutralHadronIso_DR0p0To0p1;
673	>	Double_t fNeutralHadronIso_DR0p1To0p2;
674	>	Double_t fNeutralHadronIso_DR0p2To0p3;
675	>	Double_t fNeutralHadronIso_DR0p3To0p4;
676	>	Double_t fNeutralHadronIso_DR0p4To0p5;
677	>	Double_t fNeutralHadronIso_DR0p5To0p7;
678	>
679	>
680	>	//
681	>	//Loop over PF Candidates
682	>	//
683	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
684	>
685	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
686	>
687	>	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
688	>
689	>	Double_t deta = (mu->Eta() - pf->Eta());
690	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
691	>	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
692	>	if (dr > 1.0) continue;
693	>
694	>	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
695	>
696	>	//
697	>	// Lepton Footprint Removal
698	>	//
699	>	Bool_t IsLeptonFootprint = kFALSE;
700	>	if (dr < 1.0) {
701	>
702	>	//
703	>	// Check for electrons
704	>	//
705	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
706	>	const mithep::Electron *tmpele = electronsToVeto[q];
707	>	// 4l electron
708	>	if( pf->HasTrackerTrk() ) {
709	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
710	>	IsLeptonFootprint = kTRUE;
711	>	}
712	>	if( pf->HasGsfTrk() ) {
713	>	if( pf->GsfTrk() == tmpele->GsfTrk() )
714	>	IsLeptonFootprint = kTRUE;
715	>	}
716	>	// PF charged
717	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479
718	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
719	>	IsLeptonFootprint = kTRUE;
720	>	// PF gamma
721	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
722	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
723	>	IsLeptonFootprint = kTRUE;
724	>	} // loop over electrons
725	>
726	>	/* KH - commented for sync
727	>	//
728	>	// Check for muons
729	>	//
730	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
731	>	const mithep::Muon *tmpmu = muonsToVeto[q];
732	>	// 4l muon
733	>	if( pf->HasTrackerTrk() ) {
734	>	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
735	>	IsLeptonFootprint = kTRUE;
736	>	}
737	>	// PF charged
738	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
739	>	IsLeptonFootprint = kTRUE;
740	>	} // loop over muons
741	>	*/
742	>
743	>	if (IsLeptonFootprint)
744	>	continue;
745	>
746	>	//
747	>	// Charged Iso Rings
748	>	//
749	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
750	>
751	>	if( dr < 0.01 ) continue; // only for muon iso mva?
752	>	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
753	>
754	>	//       if( pf->HasTrackerTrk() ) {
755	>	//      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
756	>	//      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
757	>	//                            << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
758	>	//                            << dr << endl;
759	>	//       }
760	>	//       if( pf->HasGsfTrk() ) {
761	>	//      if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
762	>	//      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
763	>	//                            << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
764	>	//                            << dr << endl;
765	>	//       }
766	>
767	>	// Footprint Veto
768	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
769	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
770	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
771	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
772	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
773	>	if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
774	>	}
775	>
776	>	//
777	>	// Gamma Iso Rings
778	>	//
779	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
780	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
781	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
782	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
783	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
784	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
785	>	if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
786	>	}
787	>
788	>	//
789	>	// Other Neutral Iso Rings
790	>	//
791	>	else {
792	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
793	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
794	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
795	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
796	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
797	>	if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
798	>	}
799	>
800	>	}
801	>
802	>	}
803	>
804	>	fChargedIso_DR0p0To0p1   = fmin((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
805	>	fChargedIso_DR0p1To0p2   = fmin((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
806	>	fChargedIso_DR0p2To0p3   = fmin((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
807	>	fChargedIso_DR0p3To0p4   = fmin((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
808	>	fChargedIso_DR0p4To0p5   = fmin((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
809	>
810	>
811	>	//   double rho = 0;
812	>	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
813	>	//     rho = fPUEnergyDensity->At(0)->Rho();
814	>	//   if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
815	>	//     rho = fPUEnergyDensity->At(0)->RhoLowEta();
816	>
817	>	// WARNING!!!!
818	>	// hardcode for sync ...
819	>	EffectiveAreaVersion = muT.kMuEAData2011;
820	>	// WARNING!!!!
821	>
822	>
823	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
824	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p0To0p1,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
825	>	,2.5)
826	>	,0.0);
827	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
828	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p1To0p2,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
829	>	,2.5)
830	>	,0.0);
831	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
832	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p2To0p3,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
833	>	,2.5)
834	>	,0.0);
835	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
836	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p3To0p4,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
837	>	,2.5)
838	>	,0.0);
839	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
840	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p4To0p5,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
841	>	,2.5)
842	>	,0.0);
843	>
844	>
845	>
846	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
847	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p0To0p1,
848	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
849	>	, 2.5)
850	>	, 0.0);
851	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
852	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p1To0p2,
853	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
854	>	, 2.5)
855	>	, 0.0);
856	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
857	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p2To0p3,
858	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
859	>	, 2.5)
860	>	, 0.0);
861	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
862	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p3To0p4,
863	>	mu->Eta(), EffectiveAreaVersion))/mu->Pt()
864	>	, 2.5)
865	>	, 0.0);
866	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
867	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p4To0p5,
868	>	mu->Eta(), EffectiveAreaVersion))/mu->Pt()
869	>	, 2.5)
870	>	, 0.0);
871	>
872	>
873	>	double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
874	>	mu->Eta(),
875	>	mu->IsGlobalMuon(),
876	>	mu->IsTrackerMuon(),
877	>	fChargedIso_DR0p0To0p1,
878	>	fChargedIso_DR0p1To0p2,
879	>	fChargedIso_DR0p2To0p3,
880	>	fChargedIso_DR0p3To0p4,
881	>	fChargedIso_DR0p4To0p5,
882	>	fGammaIso_DR0p0To0p1,
883	>	fGammaIso_DR0p1To0p2,
884	>	fGammaIso_DR0p2To0p3,
885	>	fGammaIso_DR0p3To0p4,
886	>	fGammaIso_DR0p4To0p5,
887	>	fNeutralHadronIso_DR0p0To0p1,
888	>	fNeutralHadronIso_DR0p1To0p2,
889	>	fNeutralHadronIso_DR0p2To0p3,
890	>	fNeutralHadronIso_DR0p3To0p4,
891	>	fNeutralHadronIso_DR0p4To0p5,
892	>	ctrl.debug);
893	>
894	>	SelectionStatus status;
895	>	bool pass;
896	>
897	>	pass = false;
898	>	if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
899	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN0)   pass = true;
900	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
901	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN1)  pass = true;
902	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
903	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN2)  pass = true;
904	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
905	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN3)  pass = true;
906	>	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN4)  pass = true;
907	>	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN5)  pass = true;
908	>	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
909	>
910	>	/*
911	>	pass = false;
912	>	if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
913	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN0)   pass = true;
914	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
915	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN1)  pass = true;
916	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
917	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN2)  pass = true;
918	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
919	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN3)  pass = true;
920	>	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN4)  pass = true;
921	>	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN5)  pass = true;
922	>	if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
923	>	*/
924	>
925	>	//  pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
926	>
927	>	status.isoMVA = mvaval;
928	>
929	>	if(ctrl.debug)  {
930	>	cout << "returning status : " << hex << status.getStatus() << dec << endl;
931	>	cout << "MVAVAL : " << status.isoMVA << endl;
932		}
554	–	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
933		return status;
934
935		}
936
937	+
938		//--------------------------------------------------------------------------------------------------
939		void initMuonIsoMVA() {
940		//--------------------------------------------------------------------------------------------------
#	Line 574 | Line 953 | void initMuonIsoMVA() {
953
954
955
956	+
957	+	//--------------------------------------------------------------------------------------------------
958	+	double  muonPFIso04(ControlFlags &ctrl,
959	+	const mithep::Muon * mu,
960	+	const mithep::Vertex * vtx,
961	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
962	+	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
963	+	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
964	+	vector<const mithep::Muon*> muonsToVeto,
965	+	vector<const mithep::Electron*> electronsToVeto)
966	+	//--------------------------------------------------------------------------------------------------
967	+	{
968	+
969	+	extern double gChargedIso;
970	+	extern double  gGammaIso;
971	+	extern double  gNeutralIso;
972	+
973	+	if( ctrl.debug ) {
974	+	cout << "muonIsoMVASelection :: muons to veto " << endl;
975	+	for( int i=0; i<muonsToVeto.size(); i++ ) {
976	+	const mithep::Muon * vmu = muonsToVeto[i];
977	+	cout << "\tpt: " << vmu->Pt()
978	+	<< "\teta: " << vmu->Eta()
979	+	<< "\tphi: " << vmu->Phi()
980	+	<< endl;
981	+	}
982	+	cout << "muonIsoMVASelection :: electrson to veto " << endl;
983	+	for( int i=0; i<electronsToVeto.size(); i++ ) {
984	+	const mithep::Electron * vel = electronsToVeto[i];
985	+	cout << "\tpt: " << vel->Pt()
986	+	<< "\teta: " << vel->Eta()
987	+	<< "\tphi: " << vel->Phi()
988	+	<< endl;
989	+	}
990	+	}
991	+
992	+	//
993	+	// final iso
994	+	//
995	+	Double_t fChargedIso  = 0.0;
996	+	Double_t fGammaIso  = 0.0;
997	+	Double_t fNeutralHadronIso  = 0.0;
998	+
999	+	//
1000	+	//Loop over PF Candidates
1001	+	//
1002	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1003	+
1004	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1005	+	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1006	+
1007	+	Double_t deta = (mu->Eta() - pf->Eta());
1008	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
1009	+	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
1010	+	if (dr > 0.4) continue;
1011	+
1012	+	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
1013	+
1014	+	//
1015	+	// Lepton Footprint Removal
1016	+	//
1017	+	Bool_t IsLeptonFootprint = kFALSE;
1018	+	if (dr < 1.0) {
1019	+
1020	+	//
1021	+	// Check for electrons
1022	+	//
1023	+	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1024	+	const mithep::Electron *tmpele = electronsToVeto[q];
1025	+	// 4l electron
1026	+	if( pf->HasTrackerTrk() ) {
1027	+	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
1028	+	IsLeptonFootprint = kTRUE;
1029	+	}
1030	+	if( pf->HasGsfTrk() ) {
1031	+	if( pf->GsfTrk() == tmpele->GsfTrk() )
1032	+	IsLeptonFootprint = kTRUE;
1033	+	}
1034	+	// PF charged
1035	+	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1036	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1037	+	if( ctrl.debug) cout << "\tcharged trk, dR ("
1038	+	<< mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta())
1039	+	<< " matches 4L ele ..." << endl;
1040	+	IsLeptonFootprint = kTRUE;
1041	+	}
1042	+	// PF gamma
1043	+	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1044	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
1045	+	IsLeptonFootprint = kTRUE;
1046	+	} // loop over electrons
1047	+
1048	+	/* KH - comment for sync
1049	+	//
1050	+	// Check for muons
1051	+	//
1052	+	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1053	+	const mithep::Muon *tmpmu = muonsToVeto[q];
1054	+	// 4l muon
1055	+	if( pf->HasTrackerTrk() ) {
1056	+	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
1057	+	IsLeptonFootprint = kTRUE;
1058	+	}
1059	+	// PF charged
1060	+	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
1061	+	IsLeptonFootprint = kTRUE;
1062	+	} // loop over muons
1063	+	*/
1064	+
1065	+	if (IsLeptonFootprint)
1066	+	continue;
1067	+
1068	+	//
1069	+	// Charged Iso
1070	+	//
1071	+	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1072	+
1073	+	//if( dr < 0.01 ) continue; // only for muon iso mva?
1074	+	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1075	+
1076	+
1077	+	//       if( pf->HasTrackerTrk() ) {
1078	+	//      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1079	+	//      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1080	+	//                            << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1081	+	//                            << dr << endl;
1082	+	//       }
1083	+	//       if( pf->HasGsfTrk() ) {
1084	+	//      if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1085	+	//      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1086	+	//                            << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1087	+	//                            << dr << endl;
1088	+	//       }
1089	+
1090	+
1091	+	fChargedIso += pf->Pt();
1092	+	}
1093	+
1094	+	//
1095	+	// Gamma Iso
1096	+	//
1097	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1098	+	// KH, add to sync
1099	+	if( pf->Pt() > 0.5 )
1100	+	fGammaIso += pf->Pt();
1101	+	}
1102	+
1103	+	//
1104	+	// Other Neutrals
1105	+	//
1106	+	else {
1107	+	// KH, add to sync
1108	+	if( pf->Pt() > 0.5 )
1109	+	fNeutralHadronIso += pf->Pt();
1110	+	}
1111	+
1112	+	}
1113	+
1114	+	}
1115	+
1116	+	double rho=0;
1117	+	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral()) || isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral())))
1118	+	rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral();
1119	+
1120	+
1121	+	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1122	+	-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1123	+	mu->Eta(),EffectiveAreaVersion)));
1124	+	gChargedIso = fChargedIso;
1125	+	gGammaIso   = fGammaIso;
1126	+	gNeutralIso = fNeutralHadronIso;
1127	+
1128	+	return pfIso;
1129	+	}
1130	+
1131	+
1132	+
1133	+
1134	+	//--------------------------------------------------------------------------------------------------
1135	+	// hacked version
1136	+	double  muonPFIso04(ControlFlags &ctrl,
1137	+	const mithep::Muon * mu,
1138	+	const mithep::Vertex * vtx,
1139	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1140	+	float rho,
1141	+	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1142	+	vector<const mithep::Muon*> muonsToVeto,
1143	+	vector<const mithep::Electron*> electronsToVeto)
1144	+	//--------------------------------------------------------------------------------------------------
1145	+	{
1146	+
1147	+	extern double gChargedIso;
1148	+	extern double  gGammaIso;
1149	+	extern double  gNeutralIso;
1150	+
1151	+	if( ctrl.debug ) {
1152	+	cout << "muonIsoMVASelection :: muons to veto " << endl;
1153	+	for( int i=0; i<muonsToVeto.size(); i++ ) {
1154	+	const mithep::Muon * vmu = muonsToVeto[i];
1155	+	cout << "\tpt: " << vmu->Pt()
1156	+	<< "\teta: " << vmu->Eta()
1157	+	<< "\tphi: " << vmu->Phi()
1158	+	<< endl;
1159	+	}
1160	+	cout << "muonIsoMVASelection :: electrson to veto " << endl;
1161	+	for( int i=0; i<electronsToVeto.size(); i++ ) {
1162	+	const mithep::Electron * vel = electronsToVeto[i];
1163	+	cout << "\tpt: " << vel->Pt()
1164	+	<< "\teta: " << vel->Eta()
1165	+	<< "\tphi: " << vel->Phi()
1166	+	<< endl;
1167	+	}
1168	+	}
1169	+
1170	+	//
1171	+	// final iso
1172	+	//
1173	+	Double_t fChargedIso  = 0.0;
1174	+	Double_t fGammaIso  = 0.0;
1175	+	Double_t fNeutralHadronIso  = 0.0;
1176	+
1177	+	//
1178	+	//Loop over PF Candidates
1179	+	//
1180	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1181	+
1182	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1183	+	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1184	+
1185	+	Double_t deta = (mu->Eta() - pf->Eta());
1186	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
1187	+	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
1188	+	if (dr > 0.4) continue;
1189	+
1190	+	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
1191	+
1192	+	//
1193	+	// Lepton Footprint Removal
1194	+	//
1195	+	Bool_t IsLeptonFootprint = kFALSE;
1196	+	if (dr < 1.0) {
1197	+
1198	+	//
1199	+	// Check for electrons
1200	+	//
1201	+	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1202	+	const mithep::Electron *tmpele = electronsToVeto[q];
1203	+	// 4l electron
1204	+	if( pf->HasTrackerTrk() ) {
1205	+	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
1206	+	IsLeptonFootprint = kTRUE;
1207	+	}
1208	+	if( pf->HasGsfTrk() ) {
1209	+	if( pf->GsfTrk() == tmpele->GsfTrk() )
1210	+	IsLeptonFootprint = kTRUE;
1211	+	}
1212	+	// PF charged
1213	+	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1214	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
1215	+	IsLeptonFootprint = kTRUE;
1216	+	// PF gamma
1217	+	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1218	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
1219	+	IsLeptonFootprint = kTRUE;
1220	+	} // loop over electrons
1221	+
1222	+	/* KH - comment for sync
1223	+	//
1224	+	// Check for muons
1225	+	//
1226	+	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1227	+	const mithep::Muon *tmpmu = muonsToVeto[q];
1228	+	// 4l muon
1229	+	if( pf->HasTrackerTrk() ) {
1230	+	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
1231	+	IsLeptonFootprint = kTRUE;
1232	+	}
1233	+	// PF charged
1234	+	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
1235	+	IsLeptonFootprint = kTRUE;
1236	+	} // loop over muons
1237	+	*/
1238	+
1239	+	if (IsLeptonFootprint)
1240	+	continue;
1241	+
1242	+	//
1243	+	// Charged Iso
1244	+	//
1245	+	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1246	+
1247	+	//if( dr < 0.01 ) continue; // only for muon iso mva?
1248	+	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1249	+
1250	+
1251	+	//       if( pf->HasTrackerTrk() ) {
1252	+	//      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1253	+	//      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1254	+	//                            << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1255	+	//                            << dr << endl;
1256	+	//       }
1257	+	//       if( pf->HasGsfTrk() ) {
1258	+	//      if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1259	+	//      if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1260	+	//                            << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1261	+	//                            << dr << endl;
1262	+	//       }
1263	+
1264	+
1265	+	fChargedIso += pf->Pt();
1266	+	}
1267	+
1268	+	//
1269	+	// Gamma Iso
1270	+	//
1271	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1272	+	// KH, add to sync
1273	+	if( pf->Pt() > 0.5 )
1274	+	fGammaIso += pf->Pt();
1275	+	}
1276	+
1277	+	//
1278	+	// Other Neutrals
1279	+	//
1280	+	else {
1281	+	// KH, add to sync
1282	+	if( pf->Pt() > 0.5 )
1283	+	fNeutralHadronIso += pf->Pt();
1284	+	}
1285	+
1286	+	}
1287	+
1288	+	}
1289	+
1290	+	//   double rho = 0;
1291	+	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1292	+	//     rho = fPUEnergyDensity->At(0)->Rho();
1293	+
1294	+	// WARNING!!!!
1295	+	// hardcode for sync ...
1296	+	EffectiveAreaVersion = muT.kMuEAData2011;
1297	+	// WARNING!!!!
1298	+
1299	+
1300	+	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1301	+	-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1302	+	mu->Eta(),EffectiveAreaVersion)));
1303	+	gChargedIso = fChargedIso;
1304	+	gGammaIso   = fGammaIso;
1305	+	gNeutralIso = fNeutralHadronIso;
1306	+
1307	+	return pfIso;
1308	+	}
1309	+
1310	+
1311	+	//--------------------------------------------------------------------------------------------------
1312	+	SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1313	+	const mithep::Muon * mu,
1314	+	const mithep::Vertex * vtx,
1315	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1316	+	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1317	+	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1318	+	vector<const mithep::Muon*> muonsToVeto,
1319	+	vector<const mithep::Electron*> electronsToVeto)
1320	+	//--------------------------------------------------------------------------------------------------
1321	+	{
1322	+
1323	+	SelectionStatus status;
1324	+
1325	+	double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, fPUEnergyDensity,
1326	+	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1327	+	//  cout << "--------------> setting muon isoPF04 to" << pfIso << endl;
1328	+	status.isoPF04 = pfIso;
1329	+	status.chisoPF04 = gChargedIso;
1330	+	status.gaisoPF04 = gGammaIso;
1331	+	status.neisoPF04 = gNeutralIso;
1332	+
1333	+	bool pass = false;
1334	+	if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1335	+
1336	+	if( pass ) {
1337	+	status.orStatus(SelectionStatus::LOOSEISO);
1338	+	status.orStatus(SelectionStatus::TIGHTISO);
1339	+	}
1340	+	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1341	+	return status;
1342	+
1343	+	}
1344	+
1345	+
1346	+	//--------------------------------------------------------------------------------------------------
1347	+	// hacked version
1348	+	SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1349	+	const mithep::Muon * mu,
1350	+	const mithep::Vertex * vtx,
1351	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1352	+	float rho,
1353	+	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1354	+	vector<const mithep::Muon*> muonsToVeto,
1355	+	vector<const mithep::Electron*> electronsToVeto)
1356	+	//--------------------------------------------------------------------------------------------------
1357	+	{
1358	+
1359	+	SelectionStatus status;
1360	+
1361	+	double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, rho,
1362	+	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1363	+
1364	+	status.isoPF04 = pfIso;
1365	+	status.chisoPF04 = gChargedIso;
1366	+	status.gaisoPF04 = gGammaIso;
1367	+	status.neisoPF04 = gNeutralIso;
1368	+
1369	+	bool pass = false;
1370	+	if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1371	+
1372	+	if( pass ) {
1373	+	status.orStatus(SelectionStatus::LOOSEISO);
1374	+	status.orStatus(SelectionStatus::TIGHTISO);
1375	+	}
1376	+	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1377	+	return status;
1378	+
1379	+	}
1380	+
1381	+
1382	+
1383	+
1384		//--------------------------------------------------------------------------------------------------
1385		SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1386		const mithep::Electron * ele,
1387	<	const mithep::Vertex & vtx,
1387	>	const mithep::Vertex * vtx,
1388		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1389		const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1390		mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
#	Line 616 | Line 1423 | SelectionStatus electronIsoMVASelection(
1423		Double_t tmpChargedIso_DR0p2To0p3  = 0;
1424		Double_t tmpChargedIso_DR0p3To0p4  = 0;
1425		Double_t tmpChargedIso_DR0p4To0p5  = 0;
619	–	Double_t tmpChargedIso_DR0p5To0p7  = 0;
1426
1427		Double_t tmpGammaIso_DR0p0To0p1  = 0;
1428		Double_t tmpGammaIso_DR0p1To0p2  = 0;
1429		Double_t tmpGammaIso_DR0p2To0p3  = 0;
1430		Double_t tmpGammaIso_DR0p3To0p4  = 0;
1431		Double_t tmpGammaIso_DR0p4To0p5  = 0;
1432	<	Double_t tmpGammaIso_DR0p5To0p7  = 0;
1432	>
1433
1434		Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
1435		Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
1436		Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
1437		Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
1438		Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
633	–	Double_t tmpNeutralHadronIso_DR0p5To0p7  = 0;
1439
1440
1441
#	Line 660 | Line 1465 | SelectionStatus electronIsoMVASelection(
1465		//Loop over PF Candidates
1466		//
1467		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1468	+
1469	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1470	+
1471		const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1472		Double_t deta = (ele->Eta() - pf->Eta());
1473		Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1474		Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1475	<	if (dr >= 0.5) continue;
1475	>	if (dr > 1.0) continue;
1476	>
1477		if(ctrl.debug) {
1478		cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1479	<	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
1479	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1480		cout << endl;
1481		}
1482
#	Line 682 | Line 1491 | SelectionStatus electronIsoMVASelection(
1491		Bool_t IsLeptonFootprint = kFALSE;
1492		if (dr < 1.0) {
1493
1494	+
1495		//
1496		// Check for electrons
1497		//
1498	+
1499		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1500		const mithep::Electron *tmpele = electronsToVeto[q];
1501	+	double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1502	+
1503		// 4l electron
1504		if( pf->HasTrackerTrk()  ) {
1505		if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
#	Line 701 | Line 1514 | SelectionStatus electronIsoMVASelection(
1514		}
1515		}
1516		// PF charged
1517	<	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
705	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1517	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1518		if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1519		IsLeptonFootprint = kTRUE;
1520		}
1521		// PF gamma
1522	<	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1523	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
1522	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1523	>	&& tmpdr < 0.08) {
1524		if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1525		IsLeptonFootprint = kTRUE;
1526		}
1527		} // loop over electrons
1528	<
1528	>
1529	>
1530	>	/* KH - comment for sync
1531		//
1532		// Check for muons
1533		//
#	Line 732 | Line 1546 | SelectionStatus electronIsoMVASelection(
1546		IsLeptonFootprint = kTRUE;
1547		}
1548		} // loop over muons
1549	<
1549	>	*/
1550
1551		if (IsLeptonFootprint)
1552		continue;
#	Line 742 | Line 1556 | SelectionStatus electronIsoMVASelection(
1556		//
1557		if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1558
1559	<	if( pf->HasTrackerTrk() )
1560	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1561	<	if( pf->HasGsfTrk() )
1562	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1559	>	//       if( pf->HasGsfTrk() ) {
1560	>	//       if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1561	>	//       } else if( pf->HasTrackerTrk() ){
1562	>	//      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1563	>	//       }
1564
1565		// Veto any PFmuon, or PFEle
1566		if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
#	Line 762 | Line 1577 | SelectionStatus electronIsoMVASelection(
1577		if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1578		if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1579		if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
765	–	if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
1580
1581		}
1582
#	Line 771 | Line 1585 | SelectionStatus electronIsoMVASelection(
1585		//
1586		else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1587
1588	<	if (fabs(ele->SCluster()->Eta()) > 1.479) {
775	<	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
776	<	}
1588	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
1589
1590		if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1591		<< dr << endl;
#	Line 783 | Line 1595 | SelectionStatus electronIsoMVASelection(
1595		if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1596		if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1597		if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
786	–	if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
787	–
1598		}
1599
1600		//
#	Line 798 | Line 1608 | SelectionStatus electronIsoMVASelection(
1608		if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1609		if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1610		if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
801	–	if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
1611		}
1612
1613		}
1614
1615		}
1616
1617	<	fChargedIso_DR0p0To0p1   = min((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1618	<	fChargedIso_DR0p1To0p2   = min((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1619	<	fChargedIso_DR0p2To0p3   = min((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1620	<	fChargedIso_DR0p3To0p4   = min((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1621	<	fChargedIso_DR0p4To0p5   = min((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1617	>	fChargedIso_DR0p0To0p1   = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1618	>	fChargedIso_DR0p1To0p2   = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1619	>	fChargedIso_DR0p2To0p3   = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1620	>	fChargedIso_DR0p3To0p4   = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1621	>	fChargedIso_DR0p4To0p5   = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1622	>
1623	>	if(ctrl.debug) {
1624	>	cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1  << endl;
1625	>	cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2  << endl;
1626	>	cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3  << endl;
1627	>	cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4  << endl;
1628	>	cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5  << endl;
1629	>	}
1630	>
1631
1632		double rho = 0;
1633		if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
1634		rho = fPUEnergyDensity->At(0)->Rho();
1635	+	//   if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1636	+	//     rho = fPUEnergyDensity->At(0)->RhoLowEta();
1637	+
1638	+	// WARNING!!!!
1639	+	// hardcode for sync ...
1640	+	EffectiveAreaVersion = eleT.kEleEAData2011;
1641	+	// WARNING!!!!
1642
1643		if( ctrl.debug) {
1644		cout << "RHO: " << rho << endl;
#	Line 837 | Line 1662 | SelectionStatus electronIsoMVASelection(
1662		<< endl;
1663		}
1664
1665	<	fGammaIso_DR0p0To0p1 = max(min((tmpGammaIso_DR0p0To0p1
1665	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
1666		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
1667		ele->SCluster()->Eta(),
1668		EffectiveAreaVersion))/ele->Pt()
1669		,2.5)
1670		,0.0);
1671	<	fGammaIso_DR0p1To0p2 = max(min((tmpGammaIso_DR0p1To0p2
1671	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
1672		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
1673		ele->SCluster()->Eta(),
1674		EffectiveAreaVersion))/ele->Pt()
1675		,2.5)
1676		,0.0);
1677	<	fGammaIso_DR0p2To0p3 = max(min((tmpGammaIso_DR0p2To0p3
1677	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
1678		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
1679		ele->SCluster()->Eta()
1680		,EffectiveAreaVersion))/ele->Pt()
1681		,2.5)
1682		,0.0);
1683	<	fGammaIso_DR0p3To0p4 = max(min((tmpGammaIso_DR0p3To0p4
1683	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
1684		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
1685		ele->SCluster()->Eta(),
1686		EffectiveAreaVersion))/ele->Pt()
1687		,2.5)
1688		,0.0);
1689	<	fGammaIso_DR0p4To0p5 = max(min((tmpGammaIso_DR0p4To0p5
1689	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
1690		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
1691		ele->SCluster()->Eta(),
1692		EffectiveAreaVersion))/ele->Pt()
#	Line 869 | Line 1694 | SelectionStatus electronIsoMVASelection(
1694		,0.0);
1695
1696
1697	<	fNeutralHadronIso_DR0p0To0p1 = max(min((tmpNeutralHadronIso_DR0p0To0p1
1697	>	if( ctrl.debug) {
1698	>	cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
1699	>	cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
1700	>	cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
1701	>	cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
1702	>	cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
1703	>	}
1704	>
1705	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
1706		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1707		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1708		, 2.5)
1709		, 0.0);
1710	<	fNeutralHadronIso_DR0p1To0p2 = max(min((tmpNeutralHadronIso_DR0p1To0p2
1710	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
1711		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1712		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1713		, 2.5)
1714		, 0.0);
1715	<	fNeutralHadronIso_DR0p2To0p3 = max(min((tmpNeutralHadronIso_DR0p2To0p3
1715	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
1716		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1717		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1718		, 2.5)
1719		, 0.0);
1720	<	fNeutralHadronIso_DR0p3To0p4 = max(min((tmpNeutralHadronIso_DR0p3To0p4
1720	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
1721		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1722		ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1723		, 2.5)
1724		, 0.0);
1725	<	fNeutralHadronIso_DR0p4To0p5 = max(min((tmpNeutralHadronIso_DR0p4To0p5
1725	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
1726		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
1727		ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1728		, 2.5)
1729		, 0.0);
1730
1731	+	if( ctrl.debug) {
1732	+	cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
1733	+	cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
1734	+	cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
1735	+	cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
1736	+	cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
1737	+	}
1738	+
1739		double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
1740		ele->SCluster()->Eta(),
1741		fChargedIso_DR0p0To0p1,
#	Line 915 | Line 1756 | SelectionStatus electronIsoMVASelection(
1756		ctrl.debug);
1757
1758		SelectionStatus status;
1759	+	status.isoMVA = mvaval;
1760		bool pass = false;
1761
1762		Int_t subdet = 0;
1763		if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
1764		else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
1765		else subdet = 2;
1766	+
1767		Int_t ptBin = 0;
1768	<	if (ele->Pt() > 10.0) ptBin = 1;
1768	>	if (ele->Pt() >= 10.0) ptBin = 1;
1769
1770		Int_t MVABin = -1;
1771		if (subdet == 0 && ptBin == 0) MVABin = 0;
#	Line 931 | Line 1774 | SelectionStatus electronIsoMVASelection(
1774		if (subdet == 0 && ptBin == 1) MVABin = 3;
1775		if (subdet == 1 && ptBin == 1) MVABin = 4;
1776		if (subdet == 2 && ptBin == 1) MVABin = 5;
934	–
935	–	if( MVABin == 0 && mvaval > ELECTRON_ISOMVA_CUT_BIN0 ) pass = true;
936	–	if( MVABin == 1 && mvaval > ELECTRON_ISOMVA_CUT_BIN1 ) pass = true;
937	–	if( MVABin == 2 && mvaval > ELECTRON_ISOMVA_CUT_BIN2 ) pass = true;
938	–	if( MVABin == 3 && mvaval > ELECTRON_ISOMVA_CUT_BIN3 ) pass = true;
939	–	if( MVABin == 4 && mvaval > ELECTRON_ISOMVA_CUT_BIN4 ) pass = true;
940	–	if( MVABin == 5 && mvaval > ELECTRON_ISOMVA_CUT_BIN5 ) pass = true;
1777
1778	<	// pre-selection iso ...
1779	<	pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
1778	>	pass = false;
1779	>	if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN0 ) pass = true;
1780	>	if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN1 ) pass = true;
1781	>	if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN2 ) pass = true;
1782	>	if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN3 ) pass = true;
1783	>	if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN4 ) pass = true;
1784	>	if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN5 ) pass = true;
1785	>	//  pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
1786	>	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
1787	>
1788	>	//   pass = false;
1789	>	//   if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
1790	>	//   if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
1791	>	//   if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
1792	>	//   if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
1793	>	//   if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
1794	>	//   if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
1795	>	//   if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
1796
945	–	if( pass ) {
946	–	status.orStatus(SelectionStatus::LOOSEISO);
947	–	status.orStatus(SelectionStatus::TIGHTISO);
948	–	}
1797		if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1798		return status;
1799	+
1800	+	}
1801	+
1802	+
1803	+	//--------------------------------------------------------------------------------------------------
1804	+	SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1805	+	const mithep::Electron * ele,
1806	+	const mithep::Vertex * vtx,
1807	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1808	+	float rho,
1809	+	//const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1810	+	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1811	+	vector<const mithep::Muon*> muonsToVeto,
1812	+	vector<const mithep::Electron*> electronsToVeto)
1813	+	//--------------------------------------------------------------------------------------------------
1814	+	// hacked version
1815	+	{
1816	+	if( ctrl.debug ) {
1817	+	cout << "================> hacked ele Iso MVA <======================" << endl;
1818	+	}
1819	+
1820	+	if( ctrl.debug ) {
1821	+	cout << "electronIsoMVASelection :: muons to veto " << endl;
1822	+	for( int i=0; i<muonsToVeto.size(); i++ ) {
1823	+	const mithep::Muon * vmu = muonsToVeto[i];
1824	+	cout << "\tpt: " << vmu->Pt()
1825	+	<< "\teta: " << vmu->Eta()
1826	+	<< "\tphi: " << vmu->Phi()
1827	+	<< endl;
1828	+	}
1829	+	cout << "electronIsoMVASelection :: electrson to veto " << endl;
1830	+	for( int i=0; i<electronsToVeto.size(); i++ ) {
1831	+	const mithep::Electron * vel = electronsToVeto[i];
1832	+	cout << "\tpt: " << vel->Pt()
1833	+	<< "\teta: " << vel->Eta()
1834	+	<< "\tphi: " << vel->Phi()
1835	+	<< "\ttrk: " << vel->TrackerTrk()
1836	+	<< endl;
1837	+	}
1838	+	}
1839	+
1840	+	bool failiso=false;
1841	+
1842	+	//
1843	+	// tmp iso rings
1844	+	//
1845	+	Double_t tmpChargedIso_DR0p0To0p1  = 0;
1846	+	Double_t tmpChargedIso_DR0p1To0p2  = 0;
1847	+	Double_t tmpChargedIso_DR0p2To0p3  = 0;
1848	+	Double_t tmpChargedIso_DR0p3To0p4  = 0;
1849	+	Double_t tmpChargedIso_DR0p4To0p5  = 0;
1850	+
1851	+	Double_t tmpGammaIso_DR0p0To0p1  = 0;
1852	+	Double_t tmpGammaIso_DR0p1To0p2  = 0;
1853	+	Double_t tmpGammaIso_DR0p2To0p3  = 0;
1854	+	Double_t tmpGammaIso_DR0p3To0p4  = 0;
1855	+	Double_t tmpGammaIso_DR0p4To0p5  = 0;
1856
1857	+
1858	+	Double_t tmpNeutralHadronIso_DR0p0To0p1  = 0;
1859	+	Double_t tmpNeutralHadronIso_DR0p1To0p2  = 0;
1860	+	Double_t tmpNeutralHadronIso_DR0p2To0p3  = 0;
1861	+	Double_t tmpNeutralHadronIso_DR0p3To0p4  = 0;
1862	+	Double_t tmpNeutralHadronIso_DR0p4To0p5  = 0;
1863	+
1864	+
1865	+
1866	+	//
1867	+	// final rings for the MVA
1868	+	//
1869	+	Double_t fChargedIso_DR0p0To0p1;
1870	+	Double_t fChargedIso_DR0p1To0p2;
1871	+	Double_t fChargedIso_DR0p2To0p3;
1872	+	Double_t fChargedIso_DR0p3To0p4;
1873	+	Double_t fChargedIso_DR0p4To0p5;
1874	+
1875	+	Double_t fGammaIso_DR0p0To0p1;
1876	+	Double_t fGammaIso_DR0p1To0p2;
1877	+	Double_t fGammaIso_DR0p2To0p3;
1878	+	Double_t fGammaIso_DR0p3To0p4;
1879	+	Double_t fGammaIso_DR0p4To0p5;
1880	+
1881	+	Double_t fNeutralHadronIso_DR0p0To0p1;
1882	+	Double_t fNeutralHadronIso_DR0p1To0p2;
1883	+	Double_t fNeutralHadronIso_DR0p2To0p3;
1884	+	Double_t fNeutralHadronIso_DR0p3To0p4;
1885	+	Double_t fNeutralHadronIso_DR0p4To0p5;
1886	+
1887	+
1888	+	//
1889	+	//Loop over PF Candidates
1890	+	//
1891	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1892	+
1893	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1894	+
1895	+	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
1896	+	Double_t deta = (ele->Eta() - pf->Eta());
1897	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1898	+	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1899	+	if (dr > 1.0) continue;
1900	+
1901	+	if(ctrl.debug) {
1902	+	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1903	+	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1904	+	cout << endl;
1905	+	}
1906	+
1907	+
1908	+	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
1909	+	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1910	+
1911	+
1912	+	//
1913	+	// Lepton Footprint Removal
1914	+	//
1915	+	Bool_t IsLeptonFootprint = kFALSE;
1916	+	if (dr < 1.0) {
1917	+
1918	+
1919	+	//
1920	+	// Check for electrons
1921	+	//
1922	+
1923	+	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1924	+	const mithep::Electron *tmpele = electronsToVeto[q];
1925	+	double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1926	+
1927	+	// 4l electron
1928	+	if( pf->HasTrackerTrk()  ) {
1929	+	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1930	+	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1931	+	IsLeptonFootprint = kTRUE;
1932	+	}
1933	+	}
1934	+	if( pf->HasGsfTrk()  ) {
1935	+	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1936	+	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1937	+	IsLeptonFootprint = kTRUE;
1938	+	}
1939	+	}
1940	+	// PF charged
1941	+	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1942	+	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1943	+	IsLeptonFootprint = kTRUE;
1944	+	}
1945	+	// PF gamma
1946	+	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1947	+	&& tmpdr < 0.08) {
1948	+	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1949	+	IsLeptonFootprint = kTRUE;
1950	+	}
1951	+	} // loop over electrons
1952	+
1953	+
1954	+	/* KH - comment for sync
1955	+	//
1956	+	// Check for muons
1957	+	//
1958	+	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1959	+	const mithep::Muon *tmpmu = muonsToVeto[q];
1960	+	// 4l muon
1961	+	if( pf->HasTrackerTrk() ) {
1962	+	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1963	+	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1964	+	IsLeptonFootprint = kTRUE;
1965	+	}
1966	+	}
1967	+	// PF charged
1968	+	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1969	+	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1970	+	IsLeptonFootprint = kTRUE;
1971	+	}
1972	+	} // loop over muons
1973	+	*/
1974	+
1975	+	if (IsLeptonFootprint)
1976	+	continue;
1977	+
1978	+	//
1979	+	// Charged Iso Rings
1980	+	//
1981	+	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
1982	+
1983	+	//       if( pf->HasGsfTrk() ) {
1984	+	//       if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1985	+	//       } else if( pf->HasTrackerTrk() ){
1986	+	//      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1987	+	//       }
1988	+
1989	+	// Veto any PFmuon, or PFEle
1990	+	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) continue;
1991	+
1992	+	// Footprint Veto
1993	+	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1994	+
1995	+	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1996	+	<< "\ttype: " << pf->PFType()
1997	+	<< "\ttrk: " << pf->TrackerTrk() << endl;
1998	+
1999	+	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
2000	+	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
2001	+	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
2002	+	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
2003	+	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
2004	+
2005	+	}
2006	+
2007	+	//
2008	+	// Gamma Iso Rings
2009	+	//
2010	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2011	+
2012	+	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
2013	+
2014	+	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2015	+	<< dr << endl;
2016	+
2017	+	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
2018	+	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
2019	+	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
2020	+	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
2021	+	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
2022	+	}
2023	+
2024	+	//
2025	+	// Other Neutral Iso Rings
2026	+	//
2027	+	else {
2028	+	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2029	+	<< dr << endl;
2030	+	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
2031	+	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
2032	+	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
2033	+	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
2034	+	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
2035	+	}
2036	+
2037	+	}
2038	+
2039	+	}
2040	+
2041	+	fChargedIso_DR0p0To0p1   = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
2042	+	fChargedIso_DR0p1To0p2   = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
2043	+	fChargedIso_DR0p2To0p3   = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
2044	+	fChargedIso_DR0p3To0p4   = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
2045	+	fChargedIso_DR0p4To0p5   = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
2046	+
2047	+	if(ctrl.debug) {
2048	+	cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1  << endl;
2049	+	cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2  << endl;
2050	+	cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3  << endl;
2051	+	cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4  << endl;
2052	+	cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5  << endl;
2053	+	}
2054	+
2055	+
2056	+	//  rho=0;
2057	+	//  double rho = 0;
2058	+	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
2059	+	//     rho = fPUEnergyDensity->At(0)->Rho();
2060	+	//   if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) || isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
2061	+	//     rho = fPUEnergyDensity->At(0)->RhoLowEta();
2062	+
2063	+	// WARNING!!!!
2064	+	// hardcode for sync ...
2065	+	EffectiveAreaVersion = eleT.kEleEAData2011;
2066	+	// WARNING!!!!
2067	+
2068	+	if( ctrl.debug) {
2069	+	cout << "RHO: " << rho << endl;
2070	+	cout << "eta: " << ele->SCluster()->Eta() << endl;
2071	+	cout << "target: " << EffectiveAreaVersion << endl;
2072	+	cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
2073	+	ele->SCluster()->Eta(),
2074	+	EffectiveAreaVersion)
2075	+	<< endl;
2076	+	cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
2077	+	ele->SCluster()->Eta(),
2078	+	EffectiveAreaVersion)
2079	+	<< endl;
2080	+	cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
2081	+	ele->SCluster()->Eta(),
2082	+	EffectiveAreaVersion)
2083	+	<< endl;
2084	+	cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
2085	+	ele->SCluster()->Eta(),
2086	+	EffectiveAreaVersion)
2087	+	<< endl;
2088	+	}
2089	+
2090	+	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
2091	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
2092	+	ele->SCluster()->Eta(),
2093	+	EffectiveAreaVersion))/ele->Pt()
2094	+	,2.5)
2095	+	,0.0);
2096	+	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
2097	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
2098	+	ele->SCluster()->Eta(),
2099	+	EffectiveAreaVersion))/ele->Pt()
2100	+	,2.5)
2101	+	,0.0);
2102	+	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
2103	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
2104	+	ele->SCluster()->Eta()
2105	+	,EffectiveAreaVersion))/ele->Pt()
2106	+	,2.5)
2107	+	,0.0);
2108	+	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
2109	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
2110	+	ele->SCluster()->Eta(),
2111	+	EffectiveAreaVersion))/ele->Pt()
2112	+	,2.5)
2113	+	,0.0);
2114	+	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
2115	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
2116	+	ele->SCluster()->Eta(),
2117	+	EffectiveAreaVersion))/ele->Pt()
2118	+	,2.5)
2119	+	,0.0);
2120	+
2121	+
2122	+	if( ctrl.debug) {
2123	+	cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
2124	+	cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
2125	+	cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
2126	+	cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
2127	+	cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
2128	+	}
2129	+
2130	+	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
2131	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
2132	+	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2133	+	, 2.5)
2134	+	, 0.0);
2135	+	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
2136	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
2137	+	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2138	+	, 2.5)
2139	+	, 0.0);
2140	+	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
2141	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
2142	+	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2143	+	, 2.5)
2144	+	, 0.0);
2145	+	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
2146	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
2147	+	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2148	+	, 2.5)
2149	+	, 0.0);
2150	+	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
2151	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
2152	+	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2153	+	, 2.5)
2154	+	, 0.0);
2155	+
2156	+	if( ctrl.debug) {
2157	+	cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
2158	+	cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
2159	+	cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
2160	+	cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
2161	+	cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
2162	+	}
2163	+
2164	+	double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
2165	+	ele->SCluster()->Eta(),
2166	+	fChargedIso_DR0p0To0p1,
2167	+	fChargedIso_DR0p1To0p2,
2168	+	fChargedIso_DR0p2To0p3,
2169	+	fChargedIso_DR0p3To0p4,
2170	+	fChargedIso_DR0p4To0p5,
2171	+	fGammaIso_DR0p0To0p1,
2172	+	fGammaIso_DR0p1To0p2,
2173	+	fGammaIso_DR0p2To0p3,
2174	+	fGammaIso_DR0p3To0p4,
2175	+	fGammaIso_DR0p4To0p5,
2176	+	fNeutralHadronIso_DR0p0To0p1,
2177	+	fNeutralHadronIso_DR0p1To0p2,
2178	+	fNeutralHadronIso_DR0p2To0p3,
2179	+	fNeutralHadronIso_DR0p3To0p4,
2180	+	fNeutralHadronIso_DR0p4To0p5,
2181	+	ctrl.debug);
2182	+
2183	+	SelectionStatus status;
2184	+	status.isoMVA = mvaval;
2185	+	bool pass = false;
2186	+
2187	+	Int_t subdet = 0;
2188	+	if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
2189	+	else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
2190	+	else subdet = 2;
2191	+
2192	+	Int_t ptBin = 0;
2193	+	if (ele->Pt() >= 10.0) ptBin = 1;
2194	+
2195	+	Int_t MVABin = -1;
2196	+	if (subdet == 0 && ptBin == 0) MVABin = 0;
2197	+	if (subdet == 1 && ptBin == 0) MVABin = 1;
2198	+	if (subdet == 2 && ptBin == 0) MVABin = 2;
2199	+	if (subdet == 0 && ptBin == 1) MVABin = 3;
2200	+	if (subdet == 1 && ptBin == 1) MVABin = 4;
2201	+	if (subdet == 2 && ptBin == 1) MVABin = 5;
2202	+
2203	+	pass = false;
2204	+	if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN0 ) pass = true;
2205	+	if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN1 ) pass = true;
2206	+	if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN2 ) pass = true;
2207	+	if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN3 ) pass = true;
2208	+	if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN4 ) pass = true;
2209	+	if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN5 ) pass = true;
2210	+	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
2211	+
2212	+	//   pass = false;
2213	+	//   if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
2214	+	//   if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
2215	+	//   if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
2216	+	//   if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
2217	+	//   if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
2218	+	//   if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
2219	+	//   if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
2220	+
2221	+	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2222	+	return status;
2223	+
2224		}
2225
2226
#	Line 965 | Line 2237 | void initElectronIsoMVA() {
2237		mithep::ElectronIDMVA::kIsoRingsV0,
2238		kTRUE, weightFiles);
2239		}
2240	+
2241	+
2242	+
2243	+
2244	+	//--------------------------------------------------------------------------------------------------
2245	+	float electronPFIso04(ControlFlags &ctrl,
2246	+	const mithep::Electron * ele,
2247	+	const mithep::Vertex * vtx,
2248	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2249	+	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2250	+	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2251	+	vector<const mithep::Muon*> muonsToVeto,
2252	+	vector<const mithep::Electron*> electronsToVeto)
2253	+	//--------------------------------------------------------------------------------------------------
2254	+	{
2255	+	/*
2256	+	if( ctrl.debug ) {
2257	+	cout << "electronIsoMVASelection :: muons to veto " << endl;
2258	+	for( int i=0; i<muonsToVeto.size(); i++ ) {
2259	+	const mithep::Muon * vmu = muonsToVeto[i];
2260	+	cout << "\tpt: " << vmu->Pt()
2261	+	<< "\teta: " << vmu->Eta()
2262	+	<< "\tphi: " << vmu->Phi()
2263	+	<< endl;
2264	+	}
2265	+	cout << "electronIsoMVASelection :: electrons to veto " << endl;
2266	+	for( int i=0; i<electronsToVeto.size(); i++ ) {
2267	+	const mithep::Electron * vel = electronsToVeto[i];
2268	+	cout << "\tpt: " << vel->Pt()
2269	+	<< "\teta: " << vel->Eta()
2270	+	<< "\tphi: " << vel->Phi()
2271	+	<< "\ttrk: " << vel->TrackerTrk()
2272	+	<< endl;
2273	+	}
2274	+	}
2275	+	*/
2276	+
2277	+	//
2278	+	// final iso
2279	+	//
2280	+	Double_t fChargedIso = 0.0;
2281	+	Double_t fGammaIso = 0.0;
2282	+	Double_t fNeutralHadronIso = 0.0;
2283	+
2284	+
2285	+	//
2286	+	//Loop over PF Candidates
2287	+	//
2288	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2289	+
2290	+
2291	+	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2292	+	Double_t deta = (ele->Eta() - pf->Eta());
2293	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2294	+	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2295	+
2296	+	if (dr > 0.4) continue;
2297	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2298	+
2299	+	if(ctrl.debug) {
2300	+	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2301	+	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
2302	+	<< "\ttrk: " << pf->HasTrackerTrk()
2303	+	<< "\tgsf: " << pf->HasGsfTrk();
2304	+
2305	+	cout << endl;
2306	+	}
2307	+
2308	+
2309	+	//
2310	+	// sync : I don't think theyre doing this ...
2311	+	//
2312	+	//     if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
2313	+	//   (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2314	+	//       if( ctrl.debug ) cout << "\tskipping, matches to the electron ..."  << endl;
2315	+	//       continue;
2316	+	//     }
2317	+
2318	+
2319	+	//
2320	+	// Lepton Footprint Removal
2321	+	//
2322	+	Bool_t IsLeptonFootprint = kFALSE;
2323	+	if (dr < 1.0) {
2324	+
2325	+	//
2326	+	// Check for electrons
2327	+	//
2328	+	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2329	+	const mithep::Electron *tmpele = electronsToVeto[q];
2330	+	/*
2331	+	// 4l electron
2332	+	if( pf->HasTrackerTrk()  ) {
2333	+	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
2334	+	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
2335	+	IsLeptonFootprint = kTRUE;
2336	+	}
2337	+	}
2338	+	if( pf->HasGsfTrk()  ) {
2339	+	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
2340	+	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
2341	+	IsLeptonFootprint = kTRUE;
2342	+	}
2343	+	}
2344	+	*/
2345	+	// PF charged
2346	+	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2347	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
2348	+	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
2349	+	IsLeptonFootprint = kTRUE;
2350	+	}
2351	+	// PF gamma
2352	+	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
2353	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
2354	+	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
2355	+	IsLeptonFootprint = kTRUE;
2356	+	}
2357	+	} // loop over electrons
2358	+
2359	+	/* KH - comment for sync
2360	+	//
2361	+	// Check for muons
2362	+	//
2363	+	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
2364	+	const mithep::Muon *tmpmu = muonsToVeto[q];
2365	+	// 4l muon
2366	+	if( pf->HasTrackerTrk() ) {
2367	+	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
2368	+	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
2369	+	IsLeptonFootprint = kTRUE;
2370	+	}
2371	+	}
2372	+	// PF charged
2373	+	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
2374	+	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
2375	+	IsLeptonFootprint = kTRUE;
2376	+	}
2377	+	} // loop over muons
2378	+	*/
2379	+
2380	+	if (IsLeptonFootprint)
2381	+	continue;
2382	+
2383	+	//
2384	+	// Charged Iso
2385	+	//
2386	+	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
2387	+
2388	+	//       if( pf->HasTrackerTrk() )
2389	+	//      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2390	+	//       if( pf->HasGsfTrk() )
2391	+	//      if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2392	+
2393	+	// Veto any PFmuon, or PFEle
2394	+	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) {
2395	+	cout << "\t skipping, pf is and ele or mu .." <<endl;
2396	+	continue;
2397	+	}
2398	+
2399	+	// Footprint Veto
2400	+	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
2401	+
2402	+	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
2403	+	<< "\ttype: " << pf->PFType()
2404	+	<< "\ttrk: " << pf->TrackerTrk() << endl;
2405	+
2406	+	fChargedIso += pf->Pt();
2407	+	}
2408	+
2409	+	//
2410	+	// Gamma Iso
2411	+	//
2412	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2413	+
2414	+	if (fabs(ele->SCluster()->Eta()) > 1.479) {
2415	+	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
2416	+	}
2417	+	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2418	+	<< dr << endl;
2419	+	// KH, add to sync
2420	+	//      if( pf->Pt() > 0.5 )
2421	+	fGammaIso += pf->Pt();
2422	+	}
2423	+
2424	+	//
2425	+	// Neutral Iso
2426	+	//
2427	+	else {
2428	+	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2429	+	<< dr << endl;
2430	+	// KH, add to sync
2431	+	//      if( pf->Pt() > 0.5 )
2432	+	fNeutralHadronIso += pf->Pt();
2433	+	}
2434	+
2435	+	}
2436	+
2437	+	}
2438	+
2439	+
2440	+	double rho=0;
2441	+	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJets()) || isinf(fPUEnergyDensity->At(0)->RhoKt6PFJets())))
2442	+	rho = fPUEnergyDensity->At(0)->RhoKt6PFJets();
2443	+
2444	+
2445	+	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2446	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2447	+	ele->Eta(),EffectiveAreaVersion)));
2448	+
2449	+
2450	+	gChargedIso = fChargedIso;
2451	+	gGammaIso = fGammaIso;
2452	+	gNeutralIso = fNeutralHadronIso;
2453	+	return pfIso;
2454	+	}
2455	+
2456	+
2457	+
2458	+	//--------------------------------------------------------------------------------------------------
2459	+	// hacked version
2460	+	float electronPFIso04(ControlFlags &ctrl,
2461	+	const mithep::Electron * ele,
2462	+	const mithep::Vertex * vtx,
2463	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2464	+	float rho,
2465	+	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2466	+	vector<const mithep::Muon*> muonsToVeto,
2467	+	vector<const mithep::Electron*> electronsToVeto)
2468	+	//--------------------------------------------------------------------------------------------------
2469	+	{
2470	+
2471	+	if( ctrl.debug ) {
2472	+	cout << "electronIsoMVASelection :: muons to veto " << endl;
2473	+	for( int i=0; i<muonsToVeto.size(); i++ ) {
2474	+	const mithep::Muon * vmu = muonsToVeto[i];
2475	+	cout << "\tpt: " << vmu->Pt()
2476	+	<< "\teta: " << vmu->Eta()
2477	+	<< "\tphi: " << vmu->Phi()
2478	+	<< endl;
2479	+	}
2480	+	cout << "electronIsoMVASelection :: electrons to veto " << endl;
2481	+	for( int i=0; i<electronsToVeto.size(); i++ ) {
2482	+	const mithep::Electron * vel = electronsToVeto[i];
2483	+	cout << "\tpt: " << vel->Pt()
2484	+	<< "\teta: " << vel->Eta()
2485	+	<< "\tphi: " << vel->Phi()
2486	+	<< "\ttrk: " << vel->TrackerTrk()
2487	+	<< endl;
2488	+	}
2489	+	}
2490	+
2491	+
2492	+	//
2493	+	// final iso
2494	+	//
2495	+	Double_t fChargedIso = 0.0;
2496	+	Double_t fGammaIso = 0.0;
2497	+	Double_t fNeutralHadronIso = 0.0;
2498	+
2499	+
2500	+	//
2501	+	//Loop over PF Candidates
2502	+	//
2503	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2504	+
2505	+
2506	+	const mithep::PFCandidate *pf = (mithep::PFCandidate*)((*fPFCandidates)[k]);
2507	+	Double_t deta = (ele->Eta() - pf->Eta());
2508	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2509	+	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2510	+
2511	+	if (dr > 0.4) continue;
2512	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2513	+
2514	+	if(ctrl.debug) {
2515	+	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2516	+	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
2517	+	<< "\ttrk: " << pf->HasTrackerTrk()
2518	+	<< "\tgsf: " << pf->HasGsfTrk();
2519	+
2520	+	cout << endl;
2521	+	}
2522	+
2523	+
2524	+	//
2525	+	// sync : I don't think theyre doing this ...
2526	+	//
2527	+	//     if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) ||
2528	+	//   (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2529	+	//       if( ctrl.debug ) cout << "\tskipping, matches to the electron ..."  << endl;
2530	+	//       continue;
2531	+	//     }
2532	+
2533	+
2534	+	//
2535	+	// Lepton Footprint Removal
2536	+	//
2537	+	Bool_t IsLeptonFootprint = kFALSE;
2538	+	if (dr < 1.0) {
2539	+
2540	+	//
2541	+	// Check for electrons
2542	+	//
2543	+	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2544	+	const mithep::Electron *tmpele = electronsToVeto[q];
2545	+	/*
2546	+	// 4l electron
2547	+	if( pf->HasTrackerTrk()  ) {
2548	+	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
2549	+	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
2550	+	IsLeptonFootprint = kTRUE;
2551	+	}
2552	+	}
2553	+	if( pf->HasGsfTrk()  ) {
2554	+	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
2555	+	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
2556	+	IsLeptonFootprint = kTRUE;
2557	+	}
2558	+	}
2559	+	*/
2560	+	// PF charged
2561	+	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2562	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
2563	+	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
2564	+	IsLeptonFootprint = kTRUE;
2565	+	}
2566	+	// PF gamma
2567	+	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
2568	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
2569	+	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
2570	+	IsLeptonFootprint = kTRUE;
2571	+	}
2572	+	} // loop over electrons
2573	+
2574	+	/* KH - comment for sync
2575	+	//
2576	+	// Check for muons
2577	+	//
2578	+	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
2579	+	const mithep::Muon *tmpmu = muonsToVeto[q];
2580	+	// 4l muon
2581	+	if( pf->HasTrackerTrk() ) {
2582	+	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
2583	+	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
2584	+	IsLeptonFootprint = kTRUE;
2585	+	}
2586	+	}
2587	+	// PF charged
2588	+	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
2589	+	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
2590	+	IsLeptonFootprint = kTRUE;
2591	+	}
2592	+	} // loop over muons
2593	+	*/
2594	+
2595	+	if (IsLeptonFootprint)
2596	+	continue;
2597	+
2598	+	//
2599	+	// Charged Iso
2600	+	//
2601	+	if (pf->Charge() != 0 && (pf->HasTrackerTrk()||pf->HasGsfTrk()) ) {
2602	+
2603	+	//       if( pf->HasTrackerTrk() )
2604	+	//      if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2605	+	//       if( pf->HasGsfTrk() )
2606	+	//      if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2607	+
2608	+	// Veto any PFmuon, or PFEle
2609	+	if (abs(pf->PFType()) == PFCandidate::eElectron || abs(pf->PFType()) == PFCandidate::eMuon) {
2610	+	cout << "\t skipping, pf is and ele or mu .." <<endl;
2611	+	continue;
2612	+	}
2613	+
2614	+	// Footprint Veto
2615	+	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
2616	+
2617	+	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
2618	+	<< "\ttype: " << pf->PFType()
2619	+	<< "\ttrk: " << pf->TrackerTrk() << endl;
2620	+
2621	+	fChargedIso += pf->Pt();
2622	+	}
2623	+
2624	+	//
2625	+	// Gamma Iso
2626	+	//
2627	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2628	+
2629	+	if (fabs(ele->SCluster()->Eta()) > 1.479) {
2630	+	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
2631	+	}
2632	+	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2633	+	<< dr << endl;
2634	+	// KH, add to sync
2635	+	//      if( pf->Pt() > 0.5 )
2636	+	fGammaIso += pf->Pt();
2637	+	}
2638	+
2639	+	//
2640	+	// Neutral Iso
2641	+	//
2642	+	else {
2643	+	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2644	+	<< dr << endl;
2645	+	// KH, add to sync
2646	+	//      if( pf->Pt() > 0.5 )
2647	+	fNeutralHadronIso += pf->Pt();
2648	+	}
2649	+
2650	+	}
2651	+
2652	+	}
2653	+
2654	+	//   double rho = 0;
2655	+	//   if (!(isnan(fPUEnergyDensity->At(0)->Rho()) || isinf(fPUEnergyDensity->At(0)->Rho())))
2656	+	//     rho = fPUEnergyDensity->At(0)->Rho();
2657	+
2658	+	// WARNING!!!!
2659	+	// hardcode for sync ...
2660	+	EffectiveAreaVersion = eleT.kEleEAData2011;
2661	+	// WARNING!!!!
2662	+
2663	+
2664	+	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2665	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2666	+	ele->Eta(),EffectiveAreaVersion)));
2667	+
2668	+
2669	+	gChargedIso = fChargedIso;
2670	+	gGammaIso = fGammaIso;
2671	+	gNeutralIso = fNeutralHadronIso;
2672	+	return pfIso;
2673	+	}
2674	+
2675	+
2676	+	//--------------------------------------------------------------------------------------------------
2677	+	SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2678	+	const mithep::Electron * ele,
2679	+	const mithep::Vertex * vtx,
2680	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2681	+	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2682	+	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2683	+	vector<const mithep::Muon*> muonsToVeto,
2684	+	vector<const mithep::Electron*> electronsToVeto)
2685	+	//--------------------------------------------------------------------------------------------------
2686	+	{
2687	+
2688	+	SelectionStatus status;
2689	+
2690	+	double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, fPUEnergyDensity,
2691	+	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2692	+	//  cout << "--------------> setting electron isoPF04 to " << pfIso << endl;
2693	+	status.isoPF04 = pfIso;
2694	+	status.chisoPF04 = gChargedIso;
2695	+	status.gaisoPF04 = gGammaIso;
2696	+	status.neisoPF04 = gNeutralIso;
2697	+
2698	+	bool pass = false;
2699	+	if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2700	+
2701	+	if( pass ) {
2702	+	status.orStatus(SelectionStatus::LOOSEISO);
2703	+	status.orStatus(SelectionStatus::TIGHTISO);
2704	+	}
2705	+	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2706	+	return status;
2707	+
2708	+	}
2709	+
2710	+
2711	+	//--------------------------------------------------------------------------------------------------
2712	+	// hacked version
2713	+	SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2714	+	const mithep::Electron * ele,
2715	+	const mithep::Vertex * vtx,
2716	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2717	+	float rho,
2718	+	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2719	+	vector<const mithep::Muon*> muonsToVeto,
2720	+	vector<const mithep::Electron*> electronsToVeto)
2721	+	//--------------------------------------------------------------------------------------------------
2722	+	{
2723	+
2724	+	SelectionStatus status;
2725	+
2726	+	double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, rho,
2727	+	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2728	+	status.isoPF04 = pfIso;
2729	+	status.chisoPF04 = gChargedIso;
2730	+	status.gaisoPF04 = gGammaIso;
2731	+	status.neisoPF04 = gNeutralIso;
2732	+	bool pass = false;
2733	+	if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2734	+
2735	+	if( pass ) {
2736	+	status.orStatus(SelectionStatus::LOOSEISO);
2737	+	status.orStatus(SelectionStatus::TIGHTISO);
2738	+	}
2739	+	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2740	+	return status;
2741	+
2742	+	}

Diff Legend

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