[ViewVC] Diff of: cvsroot/UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents):
Revision 1.11 by khahn, Sat May 5 21:43:54 2012 UTC vs.
Revision 1.24 by anlevin, Wed May 23 22:06:39 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 = fmax(fmin((tmpGammaIso_DR0p0To0p1
481	+	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p0To0p1,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
482	+	,2.5)
483	+	,0.0);
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 = fmax(fmin((tmpGammaIso_DR0p2To0p3
489	+	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p2To0p3,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
490	+	,2.5)
491	+	,0.0);
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 = 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 = 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 = 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 = 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 = 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 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
524	+	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p4To0p5,
525	+	mu->Eta(), EffectiveAreaVersion))/mu->Pt()
526	+	, 2.5)
527	+	, 0.0);
528	+
529	+
530	+	double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
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;
553	+
554	+	pass = false;
555	+	if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
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_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_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_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	+	}
593	+
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 = max(min((tmpGammaIso_DR0p0To0p1
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 = max(min((tmpGammaIso_DR0p1To0p2
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 = max(min((tmpGammaIso_DR0p2To0p3
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 = max(min((tmpGammaIso_DR0p3To0p4
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 = max(min((tmpGammaIso_DR0p4To0p5
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 = max(min((tmpNeutralHadronIso_DR0p0To0p1
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 = max(min((tmpNeutralHadronIso_DR0p1To0p2
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 = max(min((tmpNeutralHadronIso_DR0p2To0p3
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 = max(min((tmpNeutralHadronIso_DR0p3To0p4
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 = max(min((tmpNeutralHadronIso_DR0p4To0p5
866	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
867		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p4To0p5,
868		mu->Eta(), EffectiveAreaVersion))/mu->Pt()
869		, 2.5)
#	Line 511 \| Line 871 \| SelectionStatus muonIsoMVASelection(Cont
871
872
873		double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
874	<	mu->Eta(),
875	<	fChargedIso_DR0p0To0p1,
876	<	fChargedIso_DR0p1To0p2,
877	<	fChargedIso_DR0p2To0p3,
878	<	fChargedIso_DR0p3To0p4,
879	<	fChargedIso_DR0p4To0p5,
880	<	fGammaIso_DR0p0To0p1,
881	<	fGammaIso_DR0p1To0p2,
882	<	fGammaIso_DR0p2To0p3,
883	<	fGammaIso_DR0p3To0p4,
884	<	fGammaIso_DR0p4To0p5,
885	<	fNeutralHadronIso_DR0p0To0p1,
886	<	fNeutralHadronIso_DR0p1To0p2,
887	<	fNeutralHadronIso_DR0p2To0p3,
888	<	fNeutralHadronIso_DR0p3To0p4,
889	<	fNeutralHadronIso_DR0p4To0p5,
890	<	ctrl.debug);
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;
#	Line 545 \| Line 907 \| SelectionStatus muonIsoMVASelection(Cont
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;
#	Line 557 \| Line 920 \| SelectionStatus muonIsoMVASelection(Cont
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	<	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
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	>	}
933		return status;
934
935		}
936
937	+
938		//--------------------------------------------------------------------------------------------------
939		void initMuonIsoMVA() {
940		//--------------------------------------------------------------------------------------------------
#	Line 582 \| Line 952 \| void initMuonIsoMVA() {
952		}
953
954
955	+
956	+
957		//--------------------------------------------------------------------------------------------------
958		double muonPFIso04(ControlFlags &ctrl,
959		const mithep::Muon * mu,
960	<	const mithep::Vertex & vtx,
960	>	const mithep::Vertex * vtx,
961		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
962		const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
963		mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
#	Line 593 \| Line 965 \| double muonPFIso04(ControlFlags &ctrl,
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;
#	Line 616 \| Line 992 \| double muonPFIso04(ControlFlags &ctrl,
992		//
993		// final iso
994		//
995	<	Double_t fChargedIso;
996	<	Double_t fGammaIso;
997	<	Double_t fNeutralHadronIso;
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());
#	Line 655 \| Line 1033 \| double muonPFIso04(ControlFlags &ctrl,
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)
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	<
1047	>
1048	>	/* KH - comment for sync
1049		//
1050		// Check for muons
1051		//
#	Line 677 \| Line 1060 \| double muonPFIso04(ControlFlags &ctrl,
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	+	// WARNING!!!!
1121	+	// hardcode for sync ...
1122	+	EffectiveAreaVersion = muT.kMuEAData2012;
1123	+	// WARNING!!!!
1124	+
1125	+
1126	+
1127	+	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1128	+	-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1129	+	mu->Eta(),EffectiveAreaVersion)));
1130	+	gChargedIso = fChargedIso;
1131	+	gGammaIso = fGammaIso;
1132	+	gNeutralIso = fNeutralHadronIso;
1133	+
1134	+	return pfIso;
1135	+	}
1136	+
1137	+
1138	+
1139	+
1140	+	//--------------------------------------------------------------------------------------------------
1141	+	// hacked version
1142	+	double muonPFIso04(ControlFlags &ctrl,
1143	+	const mithep::Muon * mu,
1144	+	const mithep::Vertex * vtx,
1145	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1146	+	float rho,
1147	+	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1148	+	vector<const mithep::Muon*> muonsToVeto,
1149	+	vector<const mithep::Electron*> electronsToVeto)
1150	+	//--------------------------------------------------------------------------------------------------
1151	+	{
1152	+
1153	+	extern double gChargedIso;
1154	+	extern double gGammaIso;
1155	+	extern double gNeutralIso;
1156	+
1157	+	if( ctrl.debug ) {
1158	+	cout << "muonIsoMVASelection :: muons to veto " << endl;
1159	+	for( int i=0; i<muonsToVeto.size(); i++ ) {
1160	+	const mithep::Muon * vmu = muonsToVeto[i];
1161	+	cout << "\tpt: " << vmu->Pt()
1162	+	<< "\teta: " << vmu->Eta()
1163	+	<< "\tphi: " << vmu->Phi()
1164	+	<< endl;
1165	+	}
1166	+	cout << "muonIsoMVASelection :: electrson to veto " << endl;
1167	+	for( int i=0; i<electronsToVeto.size(); i++ ) {
1168	+	const mithep::Electron * vel = electronsToVeto[i];
1169	+	cout << "\tpt: " << vel->Pt()
1170	+	<< "\teta: " << vel->Eta()
1171	+	<< "\tphi: " << vel->Phi()
1172	+	<< endl;
1173	+	}
1174	+	}
1175	+
1176	+	//
1177	+	// final iso
1178	+	//
1179	+	Double_t fChargedIso = 0.0;
1180	+	Double_t fGammaIso = 0.0;
1181	+	Double_t fNeutralHadronIso = 0.0;
1182	+
1183	+	//
1184	+	//Loop over PF Candidates
1185	+	//
1186	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1187	+
1188	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1189	+	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1190	+
1191	+	Double_t deta = (mu->Eta() - pf->Eta());
1192	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
1193	+	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
1194	+	if (dr > 0.4) continue;
1195	+
1196	+	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
1197	+
1198	+	//
1199	+	// Lepton Footprint Removal
1200	+	//
1201	+	Bool_t IsLeptonFootprint = kFALSE;
1202	+	if (dr < 1.0) {
1203	+
1204	+	//
1205	+	// Check for electrons
1206	+	//
1207	+	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1208	+	const mithep::Electron *tmpele = electronsToVeto[q];
1209	+	// 4l electron
1210	+	if( pf->HasTrackerTrk() ) {
1211	+	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
1212	+	IsLeptonFootprint = kTRUE;
1213	+	}
1214	+	if( pf->HasGsfTrk() ) {
1215	+	if( pf->GsfTrk() == tmpele->GsfTrk() )
1216	+	IsLeptonFootprint = kTRUE;
1217	+	}
1218	+	// PF charged
1219	+	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1220	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
1221	+	IsLeptonFootprint = kTRUE;
1222	+	// PF gamma
1223	+	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1224	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
1225	+	IsLeptonFootprint = kTRUE;
1226	+	} // loop over electrons
1227
1228	+	/* KH - comment for sync
1229	+	//
1230	+	// Check for muons
1231	+	//
1232	+	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1233	+	const mithep::Muon *tmpmu = muonsToVeto[q];
1234	+	// 4l muon
1235	+	if( pf->HasTrackerTrk() ) {
1236	+	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
1237	+	IsLeptonFootprint = kTRUE;
1238	+	}
1239	+	// PF charged
1240	+	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
1241	+	IsLeptonFootprint = kTRUE;
1242	+	} // loop over muons
1243	+	*/
1244
1245		if (IsLeptonFootprint)
1246		continue;
1247
1248		//
1249	<	// Charged Iso Rings
1249	>	// Charged Iso
1250		//
1251		if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1252
1253	<	if( dr < 0.01 ) continue; // only for muon iso mva?
1253	>	//if( dr < 0.01 ) continue; // only for muon iso mva?
1254		if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
1255
1256	<	if( pf->HasTrackerTrk() ) {
1257	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1258	<	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1259	<	<< abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1260	<	<< dr << endl;
1261	<	}
1262	<	if( pf->HasGsfTrk() ) {
1263	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1264	<	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1265	<	<< abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1266	<	<< dr << endl;
1267	<	}
1256	>
1257	>	// if( pf->HasTrackerTrk() ) {
1258	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1259	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1260	>	// << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1261	>	// << dr << endl;
1262	>	// }
1263	>	// if( pf->HasGsfTrk() ) {
1264	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1265	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1266	>	// << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1267	>	// << dr << endl;
1268	>	// }
1269
1270
1271		fChargedIso += pf->Pt();
#	Line 711 \| Line 1275 \| double muonPFIso04(ControlFlags &ctrl,
1275		// Gamma Iso
1276		//
1277		else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1278	+	// KH, add to sync
1279	+	if( pf->Pt() > 0.5 )
1280		fGammaIso += pf->Pt();
1281		}
1282
1283		//
1284	<	// Other Neutral Iso Rings
1284	>	// Other Neutrals
1285		//
1286		else {
1287	<	fNeutralHadronIso += pf->Pt();
1287	>	// KH, add to sync
1288	>	if( pf->Pt() > 0.5 )
1289	>	fNeutralHadronIso += pf->Pt();
1290		}
1291
1292		}
1293
1294		}
1295
1296	<	double rho = 0;
1297	<	if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
1298	<	rho = fPUEnergyDensity->At(0)->Rho();
1296	>	// double rho = 0;
1297	>	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
1298	>	// rho = fPUEnergyDensity->At(0)->Rho();
1299
1300		// WARNING!!!!
1301		// hardcode for sync ...
#	Line 735 \| Line 1303 \| double muonPFIso04(ControlFlags &ctrl,
1303		// WARNING!!!!
1304
1305
1306	<	double pfIso = fChargedIso + max(0.0,(fGammaIso + fNeutralHadronIso
1306	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1307		-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1308		mu->Eta(),EffectiveAreaVersion)));
1309	+	gChargedIso = fChargedIso;
1310	+	gGammaIso = fGammaIso;
1311	+	gNeutralIso = fNeutralHadronIso;
1312
1313		return pfIso;
1314		}
1315
1316	+
1317		//--------------------------------------------------------------------------------------------------
1318		SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1319		const mithep::Muon * mu,
1320	<	const mithep::Vertex & vtx,
1320	>	const mithep::Vertex * vtx,
1321		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1322		const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1323		mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
#	Line 755 \| Line 1327 \| SelectionStatus muonReferenceIsoSelectio
1327		{
1328
1329		SelectionStatus status;
1330	<
1330	>
1331		double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, fPUEnergyDensity,
1332		EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1333	+	// cout << "--------------> setting muon isoPF04 to" << pfIso << endl;
1334	+	status.isoPF04 = pfIso;
1335	+	status.chisoPF04 = gChargedIso;
1336	+	status.gaisoPF04 = gGammaIso;
1337	+	status.neisoPF04 = gNeutralIso;
1338	+
1339	+	bool pass = false;
1340	+	if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1341	+
1342	+	if( pass ) {
1343	+	status.orStatus(SelectionStatus::LOOSEISO);
1344	+	status.orStatus(SelectionStatus::TIGHTISO);
1345	+	}
1346	+	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1347	+	return status;
1348	+
1349	+	}
1350	+
1351	+
1352	+	//--------------------------------------------------------------------------------------------------
1353	+	// hacked version
1354	+	SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1355	+	const mithep::Muon * mu,
1356	+	const mithep::Vertex * vtx,
1357	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1358	+	float rho,
1359	+	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1360	+	vector<const mithep::Muon*> muonsToVeto,
1361	+	vector<const mithep::Electron*> electronsToVeto)
1362	+	//--------------------------------------------------------------------------------------------------
1363	+	{
1364	+
1365	+	SelectionStatus status;
1366	+
1367	+	double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, rho,
1368	+	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1369	+
1370	+	status.isoPF04 = pfIso;
1371	+	status.chisoPF04 = gChargedIso;
1372	+	status.gaisoPF04 = gGammaIso;
1373	+	status.neisoPF04 = gNeutralIso;
1374	+
1375		bool pass = false;
1376		if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1377
#	Line 772 \| Line 1386 \| SelectionStatus muonReferenceIsoSelectio
1386
1387
1388
1389	+
1390		//--------------------------------------------------------------------------------------------------
1391		SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1392		const mithep::Electron * ele,
1393	<	const mithep::Vertex & vtx,
1393	>	const mithep::Vertex * vtx,
1394		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1395		const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1396		mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
#	Line 814 \| Line 1429 \| SelectionStatus electronIsoMVASelection(
1429		Double_t tmpChargedIso_DR0p2To0p3 = 0;
1430		Double_t tmpChargedIso_DR0p3To0p4 = 0;
1431		Double_t tmpChargedIso_DR0p4To0p5 = 0;
817	–	Double_t tmpChargedIso_DR0p5To0p7 = 0;
1432
1433		Double_t tmpGammaIso_DR0p0To0p1 = 0;
1434		Double_t tmpGammaIso_DR0p1To0p2 = 0;
1435		Double_t tmpGammaIso_DR0p2To0p3 = 0;
1436		Double_t tmpGammaIso_DR0p3To0p4 = 0;
1437		Double_t tmpGammaIso_DR0p4To0p5 = 0;
1438	<	Double_t tmpGammaIso_DR0p5To0p7 = 0;
1438	>
1439
1440		Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
1441		Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
1442		Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
1443		Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
1444		Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
831	–	Double_t tmpNeutralHadronIso_DR0p5To0p7 = 0;
1445
1446
1447
#	Line 858 \| Line 1471 \| SelectionStatus electronIsoMVASelection(
1471		//Loop over PF Candidates
1472		//
1473		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1474	+
1475	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1476	+
1477		const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1478		Double_t deta = (ele->Eta() - pf->Eta());
1479		Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1480		Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1481	<	if (dr >= 0.5) continue;
1481	>	if (dr > 1.0) continue;
1482	>
1483		if(ctrl.debug) {
1484		cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1485	<	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
1485	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1486		cout << endl;
1487		}
1488
#	Line 880 \| Line 1497 \| SelectionStatus electronIsoMVASelection(
1497		Bool_t IsLeptonFootprint = kFALSE;
1498		if (dr < 1.0) {
1499
1500	+
1501		//
1502		// Check for electrons
1503		//
1504	+
1505		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1506		const mithep::Electron *tmpele = electronsToVeto[q];
1507	+	double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1508	+
1509		// 4l electron
1510		if( pf->HasTrackerTrk() ) {
1511		if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
#	Line 899 \| Line 1520 \| SelectionStatus electronIsoMVASelection(
1520		}
1521		}
1522		// PF charged
1523	<	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
903	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1523	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1524		if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1525		IsLeptonFootprint = kTRUE;
1526		}
1527		// PF gamma
1528	<	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1529	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
1528	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1529	>	&& tmpdr < 0.08) {
1530		if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1531		IsLeptonFootprint = kTRUE;
1532		}
1533		} // loop over electrons
1534	<
1534	>
1535	>
1536	>	/* KH - comment for sync
1537		//
1538		// Check for muons
1539		//
#	Line 930 \| Line 1552 \| SelectionStatus electronIsoMVASelection(
1552		IsLeptonFootprint = kTRUE;
1553		}
1554		} // loop over muons
1555	<
1555	>	*/
1556
1557		if (IsLeptonFootprint)
1558		continue;
#	Line 940 \| Line 1562 \| SelectionStatus electronIsoMVASelection(
1562		//
1563		if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1564
1565	<	if( pf->HasTrackerTrk() )
1566	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1567	<	if( pf->HasGsfTrk() )
1568	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1565	>	// if( pf->HasGsfTrk() ) {
1566	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1567	>	// } else if( pf->HasTrackerTrk() ){
1568	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1569	>	// }
1570
1571		// Veto any PFmuon, or PFEle
1572		if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
#	Line 960 \| Line 1583 \| SelectionStatus electronIsoMVASelection(
1583		if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1584		if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1585		if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
963	–	if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
1586
1587		}
1588
#	Line 969 \| Line 1591 \| SelectionStatus electronIsoMVASelection(
1591		//
1592		else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1593
1594	<	if (fabs(ele->SCluster()->Eta()) > 1.479) {
973	<	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
974	<	}
1594	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
1595
1596		if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1597		<< dr << endl;
#	Line 981 \| Line 1601 \| SelectionStatus electronIsoMVASelection(
1601		if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1602		if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1603		if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
984	–	if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
985	–
1604		}
1605
1606		//
#	Line 996 \| Line 1614 \| SelectionStatus electronIsoMVASelection(
1614		if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1615		if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1616		if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
999	–	if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
1617		}
1618
1619		}
1620
1621		}
1622
1623	<	fChargedIso_DR0p0To0p1 = min((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1624	<	fChargedIso_DR0p1To0p2 = min((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1625	<	fChargedIso_DR0p2To0p3 = min((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1626	<	fChargedIso_DR0p3To0p4 = min((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1627	<	fChargedIso_DR0p4To0p5 = min((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1623	>	fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1624	>	fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1625	>	fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1626	>	fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1627	>	fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1628	>
1629	>	if(ctrl.debug) {
1630	>	cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1 << endl;
1631	>	cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2 << endl;
1632	>	cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3 << endl;
1633	>	cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4 << endl;
1634	>	cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5 << endl;
1635	>	}
1636	>
1637
1638		double rho = 0;
1639		if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
1640		rho = fPUEnergyDensity->At(0)->Rho();
1641	+	// if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1642	+	// rho = fPUEnergyDensity->At(0)->RhoLowEta();
1643	+
1644	+	// WARNING!!!!
1645	+	// hardcode for sync ...
1646	+	EffectiveAreaVersion = eleT.kEleEAData2011;
1647	+	// WARNING!!!!
1648
1649		if( ctrl.debug) {
1650		cout << "RHO: " << rho << endl;
#	Line 1035 \| Line 1668 \| SelectionStatus electronIsoMVASelection(
1668		<< endl;
1669		}
1670
1671	<	fGammaIso_DR0p0To0p1 = max(min((tmpGammaIso_DR0p0To0p1
1671	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
1672		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
1673		ele->SCluster()->Eta(),
1674		EffectiveAreaVersion))/ele->Pt()
1675		,2.5)
1676		,0.0);
1677	<	fGammaIso_DR0p1To0p2 = max(min((tmpGammaIso_DR0p1To0p2
1677	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
1678		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
1679		ele->SCluster()->Eta(),
1680		EffectiveAreaVersion))/ele->Pt()
1681		,2.5)
1682		,0.0);
1683	<	fGammaIso_DR0p2To0p3 = max(min((tmpGammaIso_DR0p2To0p3
1683	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
1684		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
1685		ele->SCluster()->Eta()
1686		,EffectiveAreaVersion))/ele->Pt()
1687		,2.5)
1688		,0.0);
1689	<	fGammaIso_DR0p3To0p4 = max(min((tmpGammaIso_DR0p3To0p4
1689	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
1690		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
1691		ele->SCluster()->Eta(),
1692		EffectiveAreaVersion))/ele->Pt()
1693		,2.5)
1694		,0.0);
1695	<	fGammaIso_DR0p4To0p5 = max(min((tmpGammaIso_DR0p4To0p5
1695	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
1696		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
1697		ele->SCluster()->Eta(),
1698		EffectiveAreaVersion))/ele->Pt()
#	Line 1067 \| Line 1700 \| SelectionStatus electronIsoMVASelection(
1700		,0.0);
1701
1702
1703	<	fNeutralHadronIso_DR0p0To0p1 = max(min((tmpNeutralHadronIso_DR0p0To0p1
1703	>	if( ctrl.debug) {
1704	>	cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
1705	>	cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
1706	>	cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
1707	>	cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
1708	>	cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
1709	>	}
1710	>
1711	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
1712		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1713		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1714		, 2.5)
1715		, 0.0);
1716	<	fNeutralHadronIso_DR0p1To0p2 = max(min((tmpNeutralHadronIso_DR0p1To0p2
1716	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
1717		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1718		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1719		, 2.5)
1720		, 0.0);
1721	<	fNeutralHadronIso_DR0p2To0p3 = max(min((tmpNeutralHadronIso_DR0p2To0p3
1721	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
1722		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1723		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1724		, 2.5)
1725		, 0.0);
1726	<	fNeutralHadronIso_DR0p3To0p4 = max(min((tmpNeutralHadronIso_DR0p3To0p4
1726	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
1727		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1728		ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1729		, 2.5)
1730		, 0.0);
1731	<	fNeutralHadronIso_DR0p4To0p5 = max(min((tmpNeutralHadronIso_DR0p4To0p5
1731	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
1732		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
1733		ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1734		, 2.5)
1735		, 0.0);
1736
1737	+	if( ctrl.debug) {
1738	+	cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
1739	+	cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
1740	+	cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
1741	+	cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
1742	+	cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
1743	+	}
1744	+
1745		double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
1746		ele->SCluster()->Eta(),
1747		fChargedIso_DR0p0To0p1,
#	Line 1113 \| Line 1762 \| SelectionStatus electronIsoMVASelection(
1762		ctrl.debug);
1763
1764		SelectionStatus status;
1765	+	status.isoMVA = mvaval;
1766		bool pass = false;
1767
1768		Int_t subdet = 0;
1769		if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
1770		else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
1771		else subdet = 2;
1772	+
1773		Int_t ptBin = 0;
1774	<	if (ele->Pt() > 10.0) ptBin = 1;
1774	>	if (ele->Pt() >= 10.0) ptBin = 1;
1775	>
1776	>	Int_t MVABin = -1;
1777	>	if (subdet == 0 && ptBin == 0) MVABin = 0;
1778	>	if (subdet == 1 && ptBin == 0) MVABin = 1;
1779	>	if (subdet == 2 && ptBin == 0) MVABin = 2;
1780	>	if (subdet == 0 && ptBin == 1) MVABin = 3;
1781	>	if (subdet == 1 && ptBin == 1) MVABin = 4;
1782	>	if (subdet == 2 && ptBin == 1) MVABin = 5;
1783	>
1784	>	pass = false;
1785	>	if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN0 ) pass = true;
1786	>	if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN1 ) pass = true;
1787	>	if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN2 ) pass = true;
1788	>	if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN3 ) pass = true;
1789	>	if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN4 ) pass = true;
1790	>	if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN5 ) pass = true;
1791	>	// pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
1792	>	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
1793	>
1794	>	// pass = false;
1795	>	// if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
1796	>	// if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
1797	>	// if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
1798	>	// if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
1799	>	// if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
1800	>	// if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
1801	>	// if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
1802	>
1803	>	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1804	>	return status;
1805	>
1806	>	}
1807	>
1808	>
1809	>	//--------------------------------------------------------------------------------------------------
1810	>	SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1811	>	const mithep::Electron * ele,
1812	>	const mithep::Vertex * vtx,
1813	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1814	>	float rho,
1815	>	//const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1816	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1817	>	vector<const mithep::Muon*> muonsToVeto,
1818	>	vector<const mithep::Electron*> electronsToVeto)
1819	>	//--------------------------------------------------------------------------------------------------
1820	>	// hacked version
1821	>	{
1822	>	if( ctrl.debug ) {
1823	>	cout << "================> hacked ele Iso MVA <======================" << endl;
1824	>	}
1825	>
1826	>	if( ctrl.debug ) {
1827	>	cout << "electronIsoMVASelection :: muons to veto " << endl;
1828	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
1829	>	const mithep::Muon * vmu = muonsToVeto[i];
1830	>	cout << "\tpt: " << vmu->Pt()
1831	>	<< "\teta: " << vmu->Eta()
1832	>	<< "\tphi: " << vmu->Phi()
1833	>	<< endl;
1834	>	}
1835	>	cout << "electronIsoMVASelection :: electrson to veto " << endl;
1836	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
1837	>	const mithep::Electron * vel = electronsToVeto[i];
1838	>	cout << "\tpt: " << vel->Pt()
1839	>	<< "\teta: " << vel->Eta()
1840	>	<< "\tphi: " << vel->Phi()
1841	>	<< "\ttrk: " << vel->TrackerTrk()
1842	>	<< endl;
1843	>	}
1844	>	}
1845	>
1846	>	bool failiso=false;
1847	>
1848	>	//
1849	>	// tmp iso rings
1850	>	//
1851	>	Double_t tmpChargedIso_DR0p0To0p1 = 0;
1852	>	Double_t tmpChargedIso_DR0p1To0p2 = 0;
1853	>	Double_t tmpChargedIso_DR0p2To0p3 = 0;
1854	>	Double_t tmpChargedIso_DR0p3To0p4 = 0;
1855	>	Double_t tmpChargedIso_DR0p4To0p5 = 0;
1856	>
1857	>	Double_t tmpGammaIso_DR0p0To0p1 = 0;
1858	>	Double_t tmpGammaIso_DR0p1To0p2 = 0;
1859	>	Double_t tmpGammaIso_DR0p2To0p3 = 0;
1860	>	Double_t tmpGammaIso_DR0p3To0p4 = 0;
1861	>	Double_t tmpGammaIso_DR0p4To0p5 = 0;
1862	>
1863	>
1864	>	Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
1865	>	Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
1866	>	Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
1867	>	Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
1868	>	Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
1869	>
1870	>
1871	>
1872	>	//
1873	>	// final rings for the MVA
1874	>	//
1875	>	Double_t fChargedIso_DR0p0To0p1;
1876	>	Double_t fChargedIso_DR0p1To0p2;
1877	>	Double_t fChargedIso_DR0p2To0p3;
1878	>	Double_t fChargedIso_DR0p3To0p4;
1879	>	Double_t fChargedIso_DR0p4To0p5;
1880	>
1881	>	Double_t fGammaIso_DR0p0To0p1;
1882	>	Double_t fGammaIso_DR0p1To0p2;
1883	>	Double_t fGammaIso_DR0p2To0p3;
1884	>	Double_t fGammaIso_DR0p3To0p4;
1885	>	Double_t fGammaIso_DR0p4To0p5;
1886	>
1887	>	Double_t fNeutralHadronIso_DR0p0To0p1;
1888	>	Double_t fNeutralHadronIso_DR0p1To0p2;
1889	>	Double_t fNeutralHadronIso_DR0p2To0p3;
1890	>	Double_t fNeutralHadronIso_DR0p3To0p4;
1891	>	Double_t fNeutralHadronIso_DR0p4To0p5;
1892	>
1893	>
1894	>	//
1895	>	//Loop over PF Candidates
1896	>	//
1897	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1898	>
1899	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1900	>
1901	>	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1902	>	Double_t deta = (ele->Eta() - pf->Eta());
1903	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1904	>	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1905	>	if (dr > 1.0) continue;
1906	>
1907	>	if(ctrl.debug) {
1908	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1909	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1910	>	cout << endl;
1911	>	}
1912	>
1913	>
1914	>	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
1915	>	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1916	>
1917	>
1918	>	//
1919	>	// Lepton Footprint Removal
1920	>	//
1921	>	Bool_t IsLeptonFootprint = kFALSE;
1922	>	if (dr < 1.0) {
1923	>
1924	>
1925	>	//
1926	>	// Check for electrons
1927	>	//
1928	>
1929	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1930	>	const mithep::Electron *tmpele = electronsToVeto[q];
1931	>	double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1932	>
1933	>	// 4l electron
1934	>	if( pf->HasTrackerTrk() ) {
1935	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1936	>	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1937	>	IsLeptonFootprint = kTRUE;
1938	>	}
1939	>	}
1940	>	if( pf->HasGsfTrk() ) {
1941	>	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1942	>	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1943	>	IsLeptonFootprint = kTRUE;
1944	>	}
1945	>	}
1946	>	// PF charged
1947	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1948	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1949	>	IsLeptonFootprint = kTRUE;
1950	>	}
1951	>	// PF gamma
1952	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1953	>	&& tmpdr < 0.08) {
1954	>	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1955	>	IsLeptonFootprint = kTRUE;
1956	>	}
1957	>	} // loop over electrons
1958	>
1959	>
1960	>	/* KH - comment for sync
1961	>	//
1962	>	// Check for muons
1963	>	//
1964	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1965	>	const mithep::Muon *tmpmu = muonsToVeto[q];
1966	>	// 4l muon
1967	>	if( pf->HasTrackerTrk() ) {
1968	>	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1969	>	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1970	>	IsLeptonFootprint = kTRUE;
1971	>	}
1972	>	}
1973	>	// PF charged
1974	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1975	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1976	>	IsLeptonFootprint = kTRUE;
1977	>	}
1978	>	} // loop over muons
1979	>	*/
1980	>
1981	>	if (IsLeptonFootprint)
1982	>	continue;
1983	>
1984	>	//
1985	>	// Charged Iso Rings
1986	>	//
1987	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1988	>
1989	>	// if( pf->HasGsfTrk() ) {
1990	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1991	>	// } else if( pf->HasTrackerTrk() ){
1992	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1993	>	// }
1994	>
1995	>	// Veto any PFmuon, or PFEle
1996	>	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
1997	>
1998	>	// Footprint Veto
1999	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
2000	>
2001	>	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
2002	>	<< "\ttype: " << pf->PFType()
2003	>	<< "\ttrk: " << pf->TrackerTrk() << endl;
2004	>
2005	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
2006	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
2007	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
2008	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
2009	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
2010	>
2011	>	}
2012	>
2013	>	//
2014	>	// Gamma Iso Rings
2015	>	//
2016	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2017	>
2018	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
2019	>
2020	>	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2021	>	<< dr << endl;
2022	>
2023	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
2024	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
2025	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
2026	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
2027	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
2028	>	}
2029	>
2030	>	//
2031	>	// Other Neutral Iso Rings
2032	>	//
2033	>	else {
2034	>	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2035	>	<< dr << endl;
2036	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
2037	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
2038	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
2039	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
2040	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
2041	>	}
2042	>
2043	>	}
2044	>
2045	>	}
2046	>
2047	>	fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
2048	>	fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
2049	>	fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
2050	>	fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
2051	>	fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
2052	>
2053	>	if(ctrl.debug) {
2054	>	cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1 << endl;
2055	>	cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2 << endl;
2056	>	cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3 << endl;
2057	>	cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4 << endl;
2058	>	cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5 << endl;
2059	>	}
2060	>
2061	>
2062	>	// rho=0;
2063	>	// double rho = 0;
2064	>	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
2065	>	// rho = fPUEnergyDensity->At(0)->Rho();
2066	>	// if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
2067	>	// rho = fPUEnergyDensity->At(0)->RhoLowEta();
2068	>
2069	>	// WARNING!!!!
2070	>	// hardcode for sync ...
2071	>	EffectiveAreaVersion = eleT.kEleEAData2011;
2072	>	// WARNING!!!!
2073	>
2074	>	if( ctrl.debug) {
2075	>	cout << "RHO: " << rho << endl;
2076	>	cout << "eta: " << ele->SCluster()->Eta() << endl;
2077	>	cout << "target: " << EffectiveAreaVersion << endl;
2078	>	cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
2079	>	ele->SCluster()->Eta(),
2080	>	EffectiveAreaVersion)
2081	>	<< endl;
2082	>	cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
2083	>	ele->SCluster()->Eta(),
2084	>	EffectiveAreaVersion)
2085	>	<< endl;
2086	>	cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
2087	>	ele->SCluster()->Eta(),
2088	>	EffectiveAreaVersion)
2089	>	<< endl;
2090	>	cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
2091	>	ele->SCluster()->Eta(),
2092	>	EffectiveAreaVersion)
2093	>	<< endl;
2094	>	}
2095	>
2096	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
2097	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
2098	>	ele->SCluster()->Eta(),
2099	>	EffectiveAreaVersion))/ele->Pt()
2100	>	,2.5)
2101	>	,0.0);
2102	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
2103	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
2104	>	ele->SCluster()->Eta(),
2105	>	EffectiveAreaVersion))/ele->Pt()
2106	>	,2.5)
2107	>	,0.0);
2108	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
2109	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
2110	>	ele->SCluster()->Eta()
2111	>	,EffectiveAreaVersion))/ele->Pt()
2112	>	,2.5)
2113	>	,0.0);
2114	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
2115	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
2116	>	ele->SCluster()->Eta(),
2117	>	EffectiveAreaVersion))/ele->Pt()
2118	>	,2.5)
2119	>	,0.0);
2120	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
2121	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
2122	>	ele->SCluster()->Eta(),
2123	>	EffectiveAreaVersion))/ele->Pt()
2124	>	,2.5)
2125	>	,0.0);
2126	>
2127	>
2128	>	if( ctrl.debug) {
2129	>	cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
2130	>	cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
2131	>	cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
2132	>	cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
2133	>	cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
2134	>	}
2135	>
2136	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
2137	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
2138	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2139	>	, 2.5)
2140	>	, 0.0);
2141	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
2142	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
2143	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2144	>	, 2.5)
2145	>	, 0.0);
2146	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
2147	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
2148	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2149	>	, 2.5)
2150	>	, 0.0);
2151	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
2152	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
2153	>	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2154	>	, 2.5)
2155	>	, 0.0);
2156	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
2157	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
2158	>	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2159	>	, 2.5)
2160	>	, 0.0);
2161	>
2162	>	if( ctrl.debug) {
2163	>	cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
2164	>	cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
2165	>	cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
2166	>	cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
2167	>	cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
2168	>	}
2169	>
2170	>	double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
2171	>	ele->SCluster()->Eta(),
2172	>	fChargedIso_DR0p0To0p1,
2173	>	fChargedIso_DR0p1To0p2,
2174	>	fChargedIso_DR0p2To0p3,
2175	>	fChargedIso_DR0p3To0p4,
2176	>	fChargedIso_DR0p4To0p5,
2177	>	fGammaIso_DR0p0To0p1,
2178	>	fGammaIso_DR0p1To0p2,
2179	>	fGammaIso_DR0p2To0p3,
2180	>	fGammaIso_DR0p3To0p4,
2181	>	fGammaIso_DR0p4To0p5,
2182	>	fNeutralHadronIso_DR0p0To0p1,
2183	>	fNeutralHadronIso_DR0p1To0p2,
2184	>	fNeutralHadronIso_DR0p2To0p3,
2185	>	fNeutralHadronIso_DR0p3To0p4,
2186	>	fNeutralHadronIso_DR0p4To0p5,
2187	>	ctrl.debug);
2188	>
2189	>	SelectionStatus status;
2190	>	status.isoMVA = mvaval;
2191	>	bool pass = false;
2192	>
2193	>	Int_t subdet = 0;
2194	>	if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
2195	>	else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
2196	>	else subdet = 2;
2197	>
2198	>	Int_t ptBin = 0;
2199	>	if (ele->Pt() >= 10.0) ptBin = 1;
2200
2201		Int_t MVABin = -1;
2202		if (subdet == 0 && ptBin == 0) MVABin = 0;
#	Line 1139 \| Line 2215 \| SelectionStatus electronIsoMVASelection(
2215		if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN5 ) pass = true;
2216		if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
2217
2218	<	pass = false;
2219	<	if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
2220	<	if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
2221	<	if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
2222	<	if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
2223	<	if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
2224	<	if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
2225	<	if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
2218	>	// pass = false;
2219	>	// if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
2220	>	// if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
2221	>	// if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
2222	>	// if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
2223	>	// if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
2224	>	// if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
2225	>	// if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
2226
2227		if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2228		return status;
#	Line 1170 \| Line 2246 \| void initElectronIsoMVA() {
2246
2247
2248
2249	+
2250		//--------------------------------------------------------------------------------------------------
2251		float electronPFIso04(ControlFlags &ctrl,
2252	<	const mithep::Electron * ele,
2253	<	const mithep::Vertex & vtx,
2254	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2255	<	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2256	<	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2257	<	vector<const mithep::Muon*> muonsToVeto,
2258	<	vector<const mithep::Electron*> electronsToVeto)
2252	>	const mithep::Electron * ele,
2253	>	const mithep::Vertex * vtx,
2254	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2255	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2256	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2257	>	vector<const mithep::Muon*> muonsToVeto,
2258	>	vector<const mithep::Electron*> electronsToVeto)
2259	>	//--------------------------------------------------------------------------------------------------
2260	>	{
2261	>	/*
2262	>	if( ctrl.debug ) {
2263	>	cout << "electronIsoMVASelection :: muons to veto " << endl;
2264	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
2265	>	const mithep::Muon * vmu = muonsToVeto[i];
2266	>	cout << "\tpt: " << vmu->Pt()
2267	>	<< "\teta: " << vmu->Eta()
2268	>	<< "\tphi: " << vmu->Phi()
2269	>	<< endl;
2270	>	}
2271	>	cout << "electronIsoMVASelection :: electrons to veto " << endl;
2272	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
2273	>	const mithep::Electron * vel = electronsToVeto[i];
2274	>	cout << "\tpt: " << vel->Pt()
2275	>	<< "\teta: " << vel->Eta()
2276	>	<< "\tphi: " << vel->Phi()
2277	>	<< "\ttrk: " << vel->TrackerTrk()
2278	>	<< endl;
2279	>	}
2280	>	}
2281	>	*/
2282	>
2283	>	//
2284	>	// final iso
2285	>	//
2286	>	Double_t fChargedIso = 0.0;
2287	>	Double_t fGammaIso = 0.0;
2288	>	Double_t fNeutralHadronIso = 0.0;
2289	>
2290	>
2291	>	//
2292	>	//Loop over PF Candidates
2293	>	//
2294	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2295	>
2296	>
2297	>	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
2298	>	Double_t deta = (ele->Eta() - pf->Eta());
2299	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2300	>	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2301	>
2302	>	if (dr > 0.4) continue;
2303	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2304	>
2305	>	if(ctrl.debug) {
2306	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2307	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
2308	>	<< "\ttrk: " << pf->HasTrackerTrk()
2309	>	<< "\tgsf: " << pf->HasGsfTrk();
2310	>
2311	>	cout << endl;
2312	>	}
2313	>
2314	>
2315	>	//
2316	>	// sync : I don't think theyre doing this ...
2317	>	//
2318	>	// if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
2319	>	// (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2320	>	// if( ctrl.debug ) cout << "\tskipping, matches to the electron ..." << endl;
2321	>	// continue;
2322	>	// }
2323	>
2324	>
2325	>	//
2326	>	// Lepton Footprint Removal
2327	>	//
2328	>	Bool_t IsLeptonFootprint = kFALSE;
2329	>	if (dr < 1.0) {
2330	>
2331	>	//
2332	>	// Check for electrons
2333	>	//
2334	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2335	>	const mithep::Electron *tmpele = electronsToVeto[q];
2336	>	/*
2337	>	// 4l electron
2338	>	if( pf->HasTrackerTrk() ) {
2339	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
2340	>	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
2341	>	IsLeptonFootprint = kTRUE;
2342	>	}
2343	>	}
2344	>	if( pf->HasGsfTrk() ) {
2345	>	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
2346	>	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
2347	>	IsLeptonFootprint = kTRUE;
2348	>	}
2349	>	}
2350	>	*/
2351	>	// PF charged
2352	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2353	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
2354	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
2355	>	IsLeptonFootprint = kTRUE;
2356	>	}
2357	>	// PF gamma
2358	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
2359	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
2360	>	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
2361	>	IsLeptonFootprint = kTRUE;
2362	>	}
2363	>	} // loop over electrons
2364	>
2365	>	/* KH - comment for sync
2366	>	//
2367	>	// Check for muons
2368	>	//
2369	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
2370	>	const mithep::Muon *tmpmu = muonsToVeto[q];
2371	>	// 4l muon
2372	>	if( pf->HasTrackerTrk() ) {
2373	>	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
2374	>	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
2375	>	IsLeptonFootprint = kTRUE;
2376	>	}
2377	>	}
2378	>	// PF charged
2379	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
2380	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
2381	>	IsLeptonFootprint = kTRUE;
2382	>	}
2383	>	} // loop over muons
2384	>	*/
2385	>
2386	>	if (IsLeptonFootprint)
2387	>	continue;
2388	>
2389	>	//
2390	>	// Charged Iso
2391	>	//
2392	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
2393	>
2394	>	// if( pf->HasTrackerTrk() )
2395	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2396	>	// if( pf->HasGsfTrk() )
2397	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2398	>
2399	>	// Veto any PFmuon, or PFEle
2400	>	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) {
2401	>	cout << "\t skipping, pf is and ele or mu .." <<endl;
2402	>	continue;
2403	>	}
2404	>
2405	>	// Footprint Veto
2406	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
2407	>
2408	>	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
2409	>	<< "\ttype: " << pf->PFType()
2410	>	<< "\ttrk: " << pf->TrackerTrk() << endl;
2411	>
2412	>	fChargedIso += pf->Pt();
2413	>	}
2414	>
2415	>	//
2416	>	// Gamma Iso
2417	>	//
2418	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2419	>
2420	>	if (fabs(ele->SCluster()->Eta()) > 1.479) {
2421	>	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
2422	>	}
2423	>	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2424	>	<< dr << endl;
2425	>	// KH, add to sync
2426	>	// if( pf->Pt() > 0.5 )
2427	>	fGammaIso += pf->Pt();
2428	>	}
2429	>
2430	>	//
2431	>	// Neutral Iso
2432	>	//
2433	>	else {
2434	>	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2435	>	<< dr << endl;
2436	>	// KH, add to sync
2437	>	// if( pf->Pt() > 0.5 )
2438	>	fNeutralHadronIso += pf->Pt();
2439	>	}
2440	>
2441	>	}
2442	>
2443	>	}
2444	>
2445	>
2446	>	double rho=0;
2447	>	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJets()) \|\| isinf(fPUEnergyDensity->At(0)->RhoKt6PFJets())))
2448	>	rho = fPUEnergyDensity->At(0)->RhoKt6PFJets();
2449	>
2450	>
2451	>
2452	>	// WARNING!!!!
2453	>	// hardcode for sync ...
2454	>	EffectiveAreaVersion = eleT.kEleEAData2012;
2455	>	// WARNING!!!!
2456	>
2457	>	eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,ele->Eta(),EffectiveAreaVersion) << endl;
2458	>
2459	>
2460	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2461	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2462	>	ele->Eta(),EffectiveAreaVersion)));
2463	>
2464	>
2465	>	gChargedIso = fChargedIso;
2466	>	gGammaIso = fGammaIso;
2467	>	gNeutralIso = fNeutralHadronIso;
2468	>	return pfIso;
2469	>	}
2470	>
2471	>
2472	>
2473	>	//--------------------------------------------------------------------------------------------------
2474	>	// hacked version
2475	>	float electronPFIso04(ControlFlags &ctrl,
2476	>	const mithep::Electron * ele,
2477	>	const mithep::Vertex * vtx,
2478	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2479	>	float rho,
2480	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2481	>	vector<const mithep::Muon*> muonsToVeto,
2482	>	vector<const mithep::Electron*> electronsToVeto)
2483		//--------------------------------------------------------------------------------------------------
2484		{
2485
#	Line 1191 \| Line 2492 \| float electronPFIso04(ControlFlags &ctrl
2492		<< "\tphi: " << vmu->Phi()
2493		<< endl;
2494		}
2495	<	cout << "electronIsoMVASelection :: electrson to veto " << endl;
2495	>	cout << "electronIsoMVASelection :: electrons to veto " << endl;
2496		for( int i=0; i<electronsToVeto.size(); i++ ) {
2497		const mithep::Electron * vel = electronsToVeto[i];
2498		cout << "\tpt: " << vel->Pt()
#	Line 1206 \| Line 2507 \| float electronPFIso04(ControlFlags &ctrl
2507		//
2508		// final iso
2509		//
2510	<	Double_t fChargedIso;
2511	<	Double_t fGammaIso;
2512	<	Double_t fNeutralHadronIso;
2510	>	Double_t fChargedIso = 0.0;
2511	>	Double_t fGammaIso = 0.0;
2512	>	Double_t fNeutralHadronIso = 0.0;
2513
2514
2515		//
2516		//Loop over PF Candidates
2517		//
2518		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2519	+
2520	+
2521		const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
2522		Double_t deta = (ele->Eta() - pf->Eta());
2523		Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2524		Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2525	<	if (dr >= 0.4) continue;
2525	>
2526	>	if (dr > 0.4) continue;
2527	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2528	>
2529		if(ctrl.debug) {
2530	<	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
2531	<	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
2530	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2531	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
2532	>	<< "\ttrk: " << pf->HasTrackerTrk()
2533	>	<< "\tgsf: " << pf->HasGsfTrk();
2534	>
2535		cout << endl;
2536		}
2537
2538
2539	<	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
2540	<	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
2541	<
2539	>	//
2540	>	// sync : I don't think theyre doing this ...
2541	>	//
2542	>	// if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
2543	>	// (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2544	>	// if( ctrl.debug ) cout << "\tskipping, matches to the electron ..." << endl;
2545	>	// continue;
2546	>	// }
2547	>
2548
2549		//
2550		// Lepton Footprint Removal
#	Line 1242 \| Line 2557 \| float electronPFIso04(ControlFlags &ctrl
2557		//
2558		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2559		const mithep::Electron *tmpele = electronsToVeto[q];
2560	+	/*
2561		// 4l electron
2562		if( pf->HasTrackerTrk() ) {
2563		if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
#	Line 1255 \| Line 2571 \| float electronPFIso04(ControlFlags &ctrl
2571		IsLeptonFootprint = kTRUE;
2572		}
2573		}
2574	+	*/
2575		// PF charged
2576		if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2577		&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
#	Line 1268 \| Line 2585 \| float electronPFIso04(ControlFlags &ctrl
2585		IsLeptonFootprint = kTRUE;
2586		}
2587		} // loop over electrons
2588	<
2588	>
2589	>	/* KH - comment for sync
2590		//
2591		// Check for muons
2592		//
#	Line 1287 \| Line 2605 \| float electronPFIso04(ControlFlags &ctrl
2605		IsLeptonFootprint = kTRUE;
2606		}
2607		} // loop over muons
2608	<
2608	>	*/
2609
2610		if (IsLeptonFootprint)
2611		continue;
2612
2613		//
2614	<	// Charged Iso Rings
2614	>	// Charged Iso
2615		//
2616		if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
2617
2618	<	if( pf->HasTrackerTrk() )
2619	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2620	<	if( pf->HasGsfTrk() )
2621	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2618	>	// if( pf->HasTrackerTrk() )
2619	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2620	>	// if( pf->HasGsfTrk() )
2621	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2622
2623		// Veto any PFmuon, or PFEle
2624	<	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
2624	>	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) {
2625	>	cout << "\t skipping, pf is and ele or mu .." <<endl;
2626	>	continue;
2627	>	}
2628
2629		// Footprint Veto
2630		if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
#	Line 1325 \| Line 2646 \| float electronPFIso04(ControlFlags &ctrl
2646		}
2647		if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2648		<< dr << endl;
2649	<	fGammaIso += pf->Pt();
2649	>	// KH, add to sync
2650	>	// if( pf->Pt() > 0.5 )
2651	>	fGammaIso += pf->Pt();
2652		}
2653
2654		//
#	Line 1334 \| Line 2657 \| float electronPFIso04(ControlFlags &ctrl
2657		else {
2658		if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2659		<< dr << endl;
2660	<	fNeutralHadronIso += pf->Pt();
2660	>	// KH, add to sync
2661	>	// if( pf->Pt() > 0.5 )
2662	>	fNeutralHadronIso += pf->Pt();
2663		}
2664
2665		}
2666
2667		}
2668
2669	<	double rho = 0;
2670	<	if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
2671	<	rho = fPUEnergyDensity->At(0)->Rho();
2669	>	// double rho = 0;
2670	>	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
2671	>	// rho = fPUEnergyDensity->At(0)->Rho();
2672
2673		// WARNING!!!!
2674		// hardcode for sync ...
#	Line 1351 \| Line 2676 \| float electronPFIso04(ControlFlags &ctrl
2676		// WARNING!!!!
2677
2678
2679	<	double pfIso = fChargedIso +
2680	<	max(0.0,fGammaIso -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIso04,
2681	<	ele->Eta(),EffectiveAreaVersion)) +
2682	<	max(0.0,fNeutralHadronIso -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIso04,
2683	<	ele->Eta(),EffectiveAreaVersion)) ;
2679	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2680	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2681	>	ele->Eta(),EffectiveAreaVersion)));
2682	>
2683	>
2684	>	gChargedIso = fChargedIso;
2685	>	gGammaIso = fGammaIso;
2686	>	gNeutralIso = fNeutralHadronIso;
2687		return pfIso;
2688		}
2689
2690	+
2691		//--------------------------------------------------------------------------------------------------
2692		SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2693		const mithep::Electron * ele,
2694	<	const mithep::Vertex & vtx,
2694	>	const mithep::Vertex * vtx,
2695		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2696		const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2697		mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
#	Line 1375 \| Line 2704 \| SelectionStatus electronReferenceIsoSele
2704
2705		double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, fPUEnergyDensity,
2706		EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2707	+	// cout << "--------------> setting electron isoPF04 to " << pfIso << endl;
2708	+	status.isoPF04 = pfIso;
2709	+	status.chisoPF04 = gChargedIso;
2710	+	status.gaisoPF04 = gGammaIso;
2711	+	status.neisoPF04 = gNeutralIso;
2712	+
2713	+	bool pass = false;
2714	+	if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2715	+
2716	+	if( pass ) {
2717	+	status.orStatus(SelectionStatus::LOOSEISO);
2718	+	status.orStatus(SelectionStatus::TIGHTISO);
2719	+	}
2720	+	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2721	+	return status;
2722	+
2723	+	}
2724	+
2725	+
2726	+	//--------------------------------------------------------------------------------------------------
2727	+	// hacked version
2728	+	SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2729	+	const mithep::Electron * ele,
2730	+	const mithep::Vertex * vtx,
2731	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2732	+	float rho,
2733	+	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2734	+	vector<const mithep::Muon*> muonsToVeto,
2735	+	vector<const mithep::Electron*> electronsToVeto)
2736	+	//--------------------------------------------------------------------------------------------------
2737	+	{
2738	+
2739	+	SelectionStatus status;
2740	+
2741	+	double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, rho,
2742	+	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2743	+	status.isoPF04 = pfIso;
2744	+	status.chisoPF04 = gChargedIso;
2745	+	status.gaisoPF04 = gGammaIso;
2746	+	status.neisoPF04 = gNeutralIso;
2747		bool pass = false;
2748		if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2749

Diff Legend

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

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents): Revision 1.11 by khahn, Sat May 5 21:43:54 2012 UTC vs. Revision 1.24 by anlevin, Wed May 23 22:06:39 2012 UTC

Diff Legend

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents):
Revision 1.11 by khahn, Sat May 5 21:43:54 2012 UTC vs.
Revision 1.24 by anlevin, Wed May 23 22:06:39 2012 UTC