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

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents):
Revision 1.16 by khahn, Thu May 10 22:53:21 2012 UTC vs.
Revision 1.22 by anlevin, Tue May 22 22:31:17 2012 UTC

#	Line 21 \| Line 21 \| 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 33 \| 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 45 \| 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 59 \| 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 68 \| 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 77 \| 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 181 \| 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 211 \| 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 226 \| Line 227 \| SelectionStatus electronIsoSelection(Con
227		if( ele->IsEB() && ele->Pt() < 20 && reliso > PFISO_ELE_LOOSE_EB_LOWPT ) {
228		failiso = true;
229		}
229	–	if(ctrl.debug) cout << "before iso check ..." << endl;
230		if( !(ele->IsEB()) && ele->Pt() > 20 && reliso > PFISO_ELE_LOOSE_EE_HIGHPT ) {
231	–	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 251 \| 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 338 \| 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 368 \| 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
#	Line 405 \| 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 455 \| 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 518 \| 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 552 \| 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 564 \| 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 589 \| 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 600 \| 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 631 \| Line 1000 \| double muonPFIso04(ControlFlags &ctrl,
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 670 \| Line 1041 \| double muonPFIso04(ControlFlags &ctrl,
1041		IsLeptonFootprint = kTRUE;
1042		} // loop over electrons
1043
1044	<	// KH, comment to sync
674	<	/*
1044	>	/* KH - comment for sync
1045		//
1046		// Check for muons
1047		//
#	Line 694 \| Line 1064 \| double muonPFIso04(ControlFlags &ctrl,
1064		//
1065		// Charged Iso
1066		//
1067	<	if (pf->Charge() != 0 ) {
1067	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1068
1069		//if( dr < 0.01 ) continue; // only for muon iso mva?
1070		if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
1071
1072	<	if( pf->HasTrackerTrk() ) {
1073	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1074	<	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1075	<	<< abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1076	<	<< dr << endl;
1077	<	}
1078	<	if( pf->HasGsfTrk() ) {
1079	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1080	<	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1081	<	<< abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1082	<	<< dr << endl;
1083	<	}
1072	>
1073	>	// if( pf->HasTrackerTrk() ) {
1074	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1075	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1076	>	// << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1077	>	// << dr << endl;
1078	>	// }
1079	>	// if( pf->HasGsfTrk() ) {
1080	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1081	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1082	>	// << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1083	>	// << dr << endl;
1084	>	// }
1085
1086
1087		fChargedIso += pf->Pt();
#	Line 737 \| Line 1108 \| double muonPFIso04(ControlFlags &ctrl,
1108		}
1109
1110		}
1111	<
1112	<	double rho = 0;
1113	<	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
1114	<	// rho = fPUEnergyDensity->At(0)->Rho();
744	<	if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
745	<	rho = fPUEnergyDensity->At(0)->RhoLowEta();
1111	>
1112	>	double rho=0;
1113	>	if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
1114	>	rho = fPUEnergyDensity->At(0)->Rho();
1115
1116		// WARNING!!!!
1117		// hardcode for sync ...
#	Line 750 \| Line 1119 \| double muonPFIso04(ControlFlags &ctrl,
1119		// WARNING!!!!
1120
1121
1122	<	double pfIso = fChargedIso + max(0.0,(fGammaIso + fNeutralHadronIso
1122	>
1123	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1124		-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1125		mu->Eta(),EffectiveAreaVersion)));
756	–
1126		gChargedIso = fChargedIso;
1127	<	gGammaIso = fGammaIso;
1128	<	gNeutralIso = fNeutralHadronIso;
1127	>	gGammaIso = fGammaIso;
1128	>	gNeutralIso = fNeutralHadronIso;
1129	>
1130		return pfIso;
1131		}
1132
1133
1134	+
1135	+
1136		//--------------------------------------------------------------------------------------------------
1137		// hacked version
1138		double muonPFIso04(ControlFlags &ctrl,
1139		const mithep::Muon * mu,
1140	<	const mithep::Vertex & vtx,
1140	>	const mithep::Vertex * vtx,
1141		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1142		float rho,
1143		mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
#	Line 808 \| Line 1180 \| double muonPFIso04(ControlFlags &ctrl,
1180		//Loop over PF Candidates
1181		//
1182		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1183	+
1184	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1185		const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1186
1187		Double_t deta = (mu->Eta() - pf->Eta());
#	Line 872 \| Line 1246 \| double muonPFIso04(ControlFlags &ctrl,
1246		//
1247		if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1248
1249	<	if( dr < 0.01 ) continue; // only for muon iso mva?
1249	>	//if( dr < 0.01 ) continue; // only for muon iso mva?
1250		if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
1251
1252	<	if( pf->HasTrackerTrk() ) {
1253	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1254	<	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1255	<	<< abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1256	<	<< dr << endl;
1257	<	}
1258	<	if( pf->HasGsfTrk() ) {
1259	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1260	<	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1261	<	<< abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1262	<	<< dr << endl;
1263	<	}
1252	>
1253	>	// if( pf->HasTrackerTrk() ) {
1254	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1255	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1256	>	// << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1257	>	// << dr << endl;
1258	>	// }
1259	>	// if( pf->HasGsfTrk() ) {
1260	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1261	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1262	>	// << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1263	>	// << dr << endl;
1264	>	// }
1265
1266
1267		fChargedIso += pf->Pt();
#	Line 896 \| Line 1271 \| double muonPFIso04(ControlFlags &ctrl,
1271		// Gamma Iso
1272		//
1273		else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1274	+	// KH, add to sync
1275	+	if( pf->Pt() > 0.5 )
1276		fGammaIso += pf->Pt();
1277		}
1278
#	Line 922 \| Line 1299 \| double muonPFIso04(ControlFlags &ctrl,
1299		// WARNING!!!!
1300
1301
1302	<	double pfIso = fChargedIso + max(0.0,(fGammaIso + fNeutralHadronIso
1302	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1303		-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1304		mu->Eta(),EffectiveAreaVersion)));
1305		gChargedIso = fChargedIso;
#	Line 936 \| Line 1313 \| double muonPFIso04(ControlFlags &ctrl,
1313		//--------------------------------------------------------------------------------------------------
1314		SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1315		const mithep::Muon * mu,
1316	<	const mithep::Vertex & vtx,
1316	>	const mithep::Vertex * vtx,
1317		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1318		const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1319		mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
#	Line 949 \| Line 1326 \| SelectionStatus muonReferenceIsoSelectio
1326
1327		double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, fPUEnergyDensity,
1328		EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1329	<	cout << "--------------> setting muon isoPF04 to" << pfIso << endl;
1329	>	// cout << "--------------> setting muon isoPF04 to" << pfIso << endl;
1330		status.isoPF04 = pfIso;
1331		status.chisoPF04 = gChargedIso;
1332		status.gaisoPF04 = gGammaIso;
#	Line 972 \| Line 1349 \| SelectionStatus muonReferenceIsoSelectio
1349		// hacked version
1350		SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1351		const mithep::Muon * mu,
1352	<	const mithep::Vertex & vtx,
1352	>	const mithep::Vertex * vtx,
1353		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1354		float rho,
1355		mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
#	Line 985 \| Line 1362 \| SelectionStatus muonReferenceIsoSelectio
1362
1363		double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, rho,
1364		EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1365	+
1366	+	status.isoPF04 = pfIso;
1367	+	status.chisoPF04 = gChargedIso;
1368	+	status.gaisoPF04 = gGammaIso;
1369	+	status.neisoPF04 = gNeutralIso;
1370	+
1371		bool pass = false;
1372		if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1373
#	Line 999 \| Line 1382 \| SelectionStatus muonReferenceIsoSelectio
1382
1383
1384
1385	+
1386		//--------------------------------------------------------------------------------------------------
1387		SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1388		const mithep::Electron * ele,
1389	<	const mithep::Vertex & vtx,
1389	>	const mithep::Vertex * vtx,
1390		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1391		const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1392		mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
#	Line 1041 \| Line 1425 \| SelectionStatus electronIsoMVASelection(
1425		Double_t tmpChargedIso_DR0p2To0p3 = 0;
1426		Double_t tmpChargedIso_DR0p3To0p4 = 0;
1427		Double_t tmpChargedIso_DR0p4To0p5 = 0;
1044	–	Double_t tmpChargedIso_DR0p5To0p7 = 0;
1428
1429		Double_t tmpGammaIso_DR0p0To0p1 = 0;
1430		Double_t tmpGammaIso_DR0p1To0p2 = 0;
1431		Double_t tmpGammaIso_DR0p2To0p3 = 0;
1432		Double_t tmpGammaIso_DR0p3To0p4 = 0;
1433		Double_t tmpGammaIso_DR0p4To0p5 = 0;
1434	<	Double_t tmpGammaIso_DR0p5To0p7 = 0;
1434	>
1435
1436		Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
1437		Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
1438		Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
1439		Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
1440		Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
1058	–	Double_t tmpNeutralHadronIso_DR0p5To0p7 = 0;
1441
1442
1443
#	Line 1085 \| Line 1467 \| SelectionStatus electronIsoMVASelection(
1467		//Loop over PF Candidates
1468		//
1469		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1470	+
1471	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1472	+
1473		const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1474		Double_t deta = (ele->Eta() - pf->Eta());
1475		Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1476		Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1477	<	if (dr >= 0.5) continue;
1477	>	if (dr > 1.0) continue;
1478	>
1479		if(ctrl.debug) {
1480		cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1481	<	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
1481	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1482		cout << endl;
1483		}
1484
#	Line 1107 \| Line 1493 \| SelectionStatus electronIsoMVASelection(
1493		Bool_t IsLeptonFootprint = kFALSE;
1494		if (dr < 1.0) {
1495
1496	+
1497		//
1498		// Check for electrons
1499		//
1500	+
1501		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1502		const mithep::Electron *tmpele = electronsToVeto[q];
1503	+	double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1504	+
1505		// 4l electron
1506		if( pf->HasTrackerTrk() ) {
1507		if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
#	Line 1126 \| Line 1516 \| SelectionStatus electronIsoMVASelection(
1516		}
1517		}
1518		// PF charged
1519	<	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1130	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1519	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1520		if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1521		IsLeptonFootprint = kTRUE;
1522		}
1523		// PF gamma
1524	<	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1525	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
1524	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1525	>	&& tmpdr < 0.08) {
1526		if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1527		IsLeptonFootprint = kTRUE;
1528		}
1529		} // loop over electrons
1530
1531	+
1532		/* KH - comment for sync
1533		//
1534		// Check for muons
#	Line 1168 \| Line 1558 \| SelectionStatus electronIsoMVASelection(
1558		//
1559		if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1560
1561	<	if( pf->HasTrackerTrk() )
1562	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1563	<	if( pf->HasGsfTrk() )
1564	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1561	>	// if( pf->HasGsfTrk() ) {
1562	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1563	>	// } else if( pf->HasTrackerTrk() ){
1564	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1565	>	// }
1566
1567		// Veto any PFmuon, or PFEle
1568		if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
#	Line 1188 \| Line 1579 \| SelectionStatus electronIsoMVASelection(
1579		if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1580		if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1581		if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
1191	–	if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
1582
1583		}
1584
#	Line 1197 \| Line 1587 \| SelectionStatus electronIsoMVASelection(
1587		//
1588		else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1589
1590	<	if (fabs(ele->SCluster()->Eta()) > 1.479) {
1201	<	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
1202	<	}
1590	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
1591
1592		if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1593		<< dr << endl;
#	Line 1209 \| Line 1597 \| SelectionStatus electronIsoMVASelection(
1597		if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1598		if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1599		if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
1212	–	if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
1213	–
1600		}
1601
1602		//
#	Line 1224 \| Line 1610 \| SelectionStatus electronIsoMVASelection(
1610		if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1611		if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1612		if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1227	–	if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
1613		}
1614
1615		}
1616
1617		}
1618
1619	<	fChargedIso_DR0p0To0p1 = min((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1620	<	fChargedIso_DR0p1To0p2 = min((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1621	<	fChargedIso_DR0p2To0p3 = min((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1622	<	fChargedIso_DR0p3To0p4 = min((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1623	<	fChargedIso_DR0p4To0p5 = min((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1619	>	fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1620	>	fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1621	>	fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1622	>	fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1623	>	fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1624	>
1625	>	if(ctrl.debug) {
1626	>	cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1 << endl;
1627	>	cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2 << endl;
1628	>	cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3 << endl;
1629	>	cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4 << endl;
1630	>	cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5 << endl;
1631	>	}
1632	>
1633
1634		double rho = 0;
1635		if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
1636		rho = fPUEnergyDensity->At(0)->Rho();
1637	+	// if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1638	+	// rho = fPUEnergyDensity->At(0)->RhoLowEta();
1639	+
1640	+	// WARNING!!!!
1641	+	// hardcode for sync ...
1642	+	EffectiveAreaVersion = eleT.kEleEAData2011;
1643	+	// WARNING!!!!
1644
1645		if( ctrl.debug) {
1646		cout << "RHO: " << rho << endl;
#	Line 1263 \| Line 1664 \| SelectionStatus electronIsoMVASelection(
1664		<< endl;
1665		}
1666
1667	<	fGammaIso_DR0p0To0p1 = max(min((tmpGammaIso_DR0p0To0p1
1667	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
1668		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
1669		ele->SCluster()->Eta(),
1670		EffectiveAreaVersion))/ele->Pt()
1671		,2.5)
1672		,0.0);
1673	<	fGammaIso_DR0p1To0p2 = max(min((tmpGammaIso_DR0p1To0p2
1673	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
1674		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
1675		ele->SCluster()->Eta(),
1676		EffectiveAreaVersion))/ele->Pt()
1677		,2.5)
1678		,0.0);
1679	<	fGammaIso_DR0p2To0p3 = max(min((tmpGammaIso_DR0p2To0p3
1679	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
1680		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
1681		ele->SCluster()->Eta()
1682		,EffectiveAreaVersion))/ele->Pt()
1683		,2.5)
1684		,0.0);
1685	<	fGammaIso_DR0p3To0p4 = max(min((tmpGammaIso_DR0p3To0p4
1685	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
1686		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
1687		ele->SCluster()->Eta(),
1688		EffectiveAreaVersion))/ele->Pt()
1689		,2.5)
1690		,0.0);
1691	<	fGammaIso_DR0p4To0p5 = max(min((tmpGammaIso_DR0p4To0p5
1691	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
1692		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
1693		ele->SCluster()->Eta(),
1694		EffectiveAreaVersion))/ele->Pt()
#	Line 1295 \| Line 1696 \| SelectionStatus electronIsoMVASelection(
1696		,0.0);
1697
1698
1699	<	fNeutralHadronIso_DR0p0To0p1 = max(min((tmpNeutralHadronIso_DR0p0To0p1
1699	>	if( ctrl.debug) {
1700	>	cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
1701	>	cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
1702	>	cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
1703	>	cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
1704	>	cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
1705	>	}
1706	>
1707	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
1708		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1709		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1710		, 2.5)
1711		, 0.0);
1712	<	fNeutralHadronIso_DR0p1To0p2 = max(min((tmpNeutralHadronIso_DR0p1To0p2
1712	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
1713		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1714		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1715		, 2.5)
1716		, 0.0);
1717	<	fNeutralHadronIso_DR0p2To0p3 = max(min((tmpNeutralHadronIso_DR0p2To0p3
1717	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
1718		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1719		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1720		, 2.5)
1721		, 0.0);
1722	<	fNeutralHadronIso_DR0p3To0p4 = max(min((tmpNeutralHadronIso_DR0p3To0p4
1722	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
1723		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1724		ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1725		, 2.5)
1726		, 0.0);
1727	<	fNeutralHadronIso_DR0p4To0p5 = max(min((tmpNeutralHadronIso_DR0p4To0p5
1727	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
1728		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
1729		ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1730		, 2.5)
1731		, 0.0);
1732
1733	+	if( ctrl.debug) {
1734	+	cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
1735	+	cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
1736	+	cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
1737	+	cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
1738	+	cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
1739	+	}
1740	+
1741		double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
1742		ele->SCluster()->Eta(),
1743		fChargedIso_DR0p0To0p1,
#	Line 1341 \| Line 1758 \| SelectionStatus electronIsoMVASelection(
1758		ctrl.debug);
1759
1760		SelectionStatus status;
1761	+	status.isoMVA = mvaval;
1762		bool pass = false;
1763
1764		Int_t subdet = 0;
1765		if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
1766		else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
1767		else subdet = 2;
1768	+
1769		Int_t ptBin = 0;
1770	<	if (ele->Pt() > 10.0) ptBin = 1;
1770	>	if (ele->Pt() >= 10.0) ptBin = 1;
1771	>
1772	>	Int_t MVABin = -1;
1773	>	if (subdet == 0 && ptBin == 0) MVABin = 0;
1774	>	if (subdet == 1 && ptBin == 0) MVABin = 1;
1775	>	if (subdet == 2 && ptBin == 0) MVABin = 2;
1776	>	if (subdet == 0 && ptBin == 1) MVABin = 3;
1777	>	if (subdet == 1 && ptBin == 1) MVABin = 4;
1778	>	if (subdet == 2 && ptBin == 1) MVABin = 5;
1779	>
1780	>	pass = false;
1781	>	if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN0 ) pass = true;
1782	>	if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN1 ) pass = true;
1783	>	if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN2 ) pass = true;
1784	>	if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN3 ) pass = true;
1785	>	if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN4 ) pass = true;
1786	>	if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN5 ) pass = true;
1787	>	// pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
1788	>	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
1789	>
1790	>	// pass = false;
1791	>	// if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
1792	>	// if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
1793	>	// if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
1794	>	// if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
1795	>	// if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
1796	>	// if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
1797	>	// if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
1798	>
1799	>	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1800	>	return status;
1801	>
1802	>	}
1803	>
1804	>
1805	>	//--------------------------------------------------------------------------------------------------
1806	>	SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1807	>	const mithep::Electron * ele,
1808	>	const mithep::Vertex * vtx,
1809	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1810	>	float rho,
1811	>	//const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1812	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1813	>	vector<const mithep::Muon*> muonsToVeto,
1814	>	vector<const mithep::Electron*> electronsToVeto)
1815	>	//--------------------------------------------------------------------------------------------------
1816	>	// hacked version
1817	>	{
1818	>	if( ctrl.debug ) {
1819	>	cout << "================> hacked ele Iso MVA <======================" << endl;
1820	>	}
1821	>
1822	>	if( ctrl.debug ) {
1823	>	cout << "electronIsoMVASelection :: muons to veto " << endl;
1824	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
1825	>	const mithep::Muon * vmu = muonsToVeto[i];
1826	>	cout << "\tpt: " << vmu->Pt()
1827	>	<< "\teta: " << vmu->Eta()
1828	>	<< "\tphi: " << vmu->Phi()
1829	>	<< endl;
1830	>	}
1831	>	cout << "electronIsoMVASelection :: electrson to veto " << endl;
1832	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
1833	>	const mithep::Electron * vel = electronsToVeto[i];
1834	>	cout << "\tpt: " << vel->Pt()
1835	>	<< "\teta: " << vel->Eta()
1836	>	<< "\tphi: " << vel->Phi()
1837	>	<< "\ttrk: " << vel->TrackerTrk()
1838	>	<< endl;
1839	>	}
1840	>	}
1841	>
1842	>	bool failiso=false;
1843	>
1844	>	//
1845	>	// tmp iso rings
1846	>	//
1847	>	Double_t tmpChargedIso_DR0p0To0p1 = 0;
1848	>	Double_t tmpChargedIso_DR0p1To0p2 = 0;
1849	>	Double_t tmpChargedIso_DR0p2To0p3 = 0;
1850	>	Double_t tmpChargedIso_DR0p3To0p4 = 0;
1851	>	Double_t tmpChargedIso_DR0p4To0p5 = 0;
1852	>
1853	>	Double_t tmpGammaIso_DR0p0To0p1 = 0;
1854	>	Double_t tmpGammaIso_DR0p1To0p2 = 0;
1855	>	Double_t tmpGammaIso_DR0p2To0p3 = 0;
1856	>	Double_t tmpGammaIso_DR0p3To0p4 = 0;
1857	>	Double_t tmpGammaIso_DR0p4To0p5 = 0;
1858	>
1859	>
1860	>	Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
1861	>	Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
1862	>	Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
1863	>	Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
1864	>	Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
1865	>
1866	>
1867	>
1868	>	//
1869	>	// final rings for the MVA
1870	>	//
1871	>	Double_t fChargedIso_DR0p0To0p1;
1872	>	Double_t fChargedIso_DR0p1To0p2;
1873	>	Double_t fChargedIso_DR0p2To0p3;
1874	>	Double_t fChargedIso_DR0p3To0p4;
1875	>	Double_t fChargedIso_DR0p4To0p5;
1876	>
1877	>	Double_t fGammaIso_DR0p0To0p1;
1878	>	Double_t fGammaIso_DR0p1To0p2;
1879	>	Double_t fGammaIso_DR0p2To0p3;
1880	>	Double_t fGammaIso_DR0p3To0p4;
1881	>	Double_t fGammaIso_DR0p4To0p5;
1882	>
1883	>	Double_t fNeutralHadronIso_DR0p0To0p1;
1884	>	Double_t fNeutralHadronIso_DR0p1To0p2;
1885	>	Double_t fNeutralHadronIso_DR0p2To0p3;
1886	>	Double_t fNeutralHadronIso_DR0p3To0p4;
1887	>	Double_t fNeutralHadronIso_DR0p4To0p5;
1888	>
1889	>
1890	>	//
1891	>	//Loop over PF Candidates
1892	>	//
1893	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1894	>
1895	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1896	>
1897	>	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1898	>	Double_t deta = (ele->Eta() - pf->Eta());
1899	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1900	>	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1901	>	if (dr > 1.0) continue;
1902	>
1903	>	if(ctrl.debug) {
1904	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1905	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1906	>	cout << endl;
1907	>	}
1908	>
1909	>
1910	>	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
1911	>	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1912	>
1913	>
1914	>	//
1915	>	// Lepton Footprint Removal
1916	>	//
1917	>	Bool_t IsLeptonFootprint = kFALSE;
1918	>	if (dr < 1.0) {
1919	>
1920	>
1921	>	//
1922	>	// Check for electrons
1923	>	//
1924	>
1925	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1926	>	const mithep::Electron *tmpele = electronsToVeto[q];
1927	>	double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1928	>
1929	>	// 4l electron
1930	>	if( pf->HasTrackerTrk() ) {
1931	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1932	>	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1933	>	IsLeptonFootprint = kTRUE;
1934	>	}
1935	>	}
1936	>	if( pf->HasGsfTrk() ) {
1937	>	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1938	>	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1939	>	IsLeptonFootprint = kTRUE;
1940	>	}
1941	>	}
1942	>	// PF charged
1943	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1944	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1945	>	IsLeptonFootprint = kTRUE;
1946	>	}
1947	>	// PF gamma
1948	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1949	>	&& tmpdr < 0.08) {
1950	>	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1951	>	IsLeptonFootprint = kTRUE;
1952	>	}
1953	>	} // loop over electrons
1954	>
1955	>
1956	>	/* KH - comment for sync
1957	>	//
1958	>	// Check for muons
1959	>	//
1960	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1961	>	const mithep::Muon *tmpmu = muonsToVeto[q];
1962	>	// 4l muon
1963	>	if( pf->HasTrackerTrk() ) {
1964	>	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1965	>	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1966	>	IsLeptonFootprint = kTRUE;
1967	>	}
1968	>	}
1969	>	// PF charged
1970	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1971	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1972	>	IsLeptonFootprint = kTRUE;
1973	>	}
1974	>	} // loop over muons
1975	>	*/
1976	>
1977	>	if (IsLeptonFootprint)
1978	>	continue;
1979	>
1980	>	//
1981	>	// Charged Iso Rings
1982	>	//
1983	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1984	>
1985	>	// if( pf->HasGsfTrk() ) {
1986	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1987	>	// } else if( pf->HasTrackerTrk() ){
1988	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1989	>	// }
1990	>
1991	>	// Veto any PFmuon, or PFEle
1992	>	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
1993	>
1994	>	// Footprint Veto
1995	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1996	>
1997	>	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1998	>	<< "\ttype: " << pf->PFType()
1999	>	<< "\ttrk: " << pf->TrackerTrk() << endl;
2000	>
2001	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
2002	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
2003	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
2004	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
2005	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
2006	>
2007	>	}
2008	>
2009	>	//
2010	>	// Gamma Iso Rings
2011	>	//
2012	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2013	>
2014	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
2015	>
2016	>	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2017	>	<< dr << endl;
2018	>
2019	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
2020	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
2021	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
2022	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
2023	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
2024	>	}
2025	>
2026	>	//
2027	>	// Other Neutral Iso Rings
2028	>	//
2029	>	else {
2030	>	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2031	>	<< dr << endl;
2032	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
2033	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
2034	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
2035	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
2036	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
2037	>	}
2038	>
2039	>	}
2040	>
2041	>	}
2042	>
2043	>	fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
2044	>	fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
2045	>	fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
2046	>	fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
2047	>	fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
2048	>
2049	>	if(ctrl.debug) {
2050	>	cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1 << endl;
2051	>	cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2 << endl;
2052	>	cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3 << endl;
2053	>	cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4 << endl;
2054	>	cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5 << endl;
2055	>	}
2056	>
2057	>
2058	>	// rho=0;
2059	>	// double rho = 0;
2060	>	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
2061	>	// rho = fPUEnergyDensity->At(0)->Rho();
2062	>	// if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
2063	>	// rho = fPUEnergyDensity->At(0)->RhoLowEta();
2064	>
2065	>	// WARNING!!!!
2066	>	// hardcode for sync ...
2067	>	EffectiveAreaVersion = eleT.kEleEAData2011;
2068	>	// WARNING!!!!
2069	>
2070	>	if( ctrl.debug) {
2071	>	cout << "RHO: " << rho << endl;
2072	>	cout << "eta: " << ele->SCluster()->Eta() << endl;
2073	>	cout << "target: " << EffectiveAreaVersion << endl;
2074	>	cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
2075	>	ele->SCluster()->Eta(),
2076	>	EffectiveAreaVersion)
2077	>	<< endl;
2078	>	cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
2079	>	ele->SCluster()->Eta(),
2080	>	EffectiveAreaVersion)
2081	>	<< endl;
2082	>	cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
2083	>	ele->SCluster()->Eta(),
2084	>	EffectiveAreaVersion)
2085	>	<< endl;
2086	>	cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
2087	>	ele->SCluster()->Eta(),
2088	>	EffectiveAreaVersion)
2089	>	<< endl;
2090	>	}
2091	>
2092	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
2093	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
2094	>	ele->SCluster()->Eta(),
2095	>	EffectiveAreaVersion))/ele->Pt()
2096	>	,2.5)
2097	>	,0.0);
2098	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
2099	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
2100	>	ele->SCluster()->Eta(),
2101	>	EffectiveAreaVersion))/ele->Pt()
2102	>	,2.5)
2103	>	,0.0);
2104	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
2105	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
2106	>	ele->SCluster()->Eta()
2107	>	,EffectiveAreaVersion))/ele->Pt()
2108	>	,2.5)
2109	>	,0.0);
2110	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
2111	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
2112	>	ele->SCluster()->Eta(),
2113	>	EffectiveAreaVersion))/ele->Pt()
2114	>	,2.5)
2115	>	,0.0);
2116	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
2117	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
2118	>	ele->SCluster()->Eta(),
2119	>	EffectiveAreaVersion))/ele->Pt()
2120	>	,2.5)
2121	>	,0.0);
2122	>
2123	>
2124	>	if( ctrl.debug) {
2125	>	cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
2126	>	cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
2127	>	cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
2128	>	cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
2129	>	cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
2130	>	}
2131	>
2132	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
2133	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
2134	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2135	>	, 2.5)
2136	>	, 0.0);
2137	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
2138	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
2139	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2140	>	, 2.5)
2141	>	, 0.0);
2142	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
2143	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
2144	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2145	>	, 2.5)
2146	>	, 0.0);
2147	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
2148	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
2149	>	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2150	>	, 2.5)
2151	>	, 0.0);
2152	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
2153	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
2154	>	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2155	>	, 2.5)
2156	>	, 0.0);
2157	>
2158	>	if( ctrl.debug) {
2159	>	cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
2160	>	cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
2161	>	cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
2162	>	cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
2163	>	cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
2164	>	}
2165	>
2166	>	double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
2167	>	ele->SCluster()->Eta(),
2168	>	fChargedIso_DR0p0To0p1,
2169	>	fChargedIso_DR0p1To0p2,
2170	>	fChargedIso_DR0p2To0p3,
2171	>	fChargedIso_DR0p3To0p4,
2172	>	fChargedIso_DR0p4To0p5,
2173	>	fGammaIso_DR0p0To0p1,
2174	>	fGammaIso_DR0p1To0p2,
2175	>	fGammaIso_DR0p2To0p3,
2176	>	fGammaIso_DR0p3To0p4,
2177	>	fGammaIso_DR0p4To0p5,
2178	>	fNeutralHadronIso_DR0p0To0p1,
2179	>	fNeutralHadronIso_DR0p1To0p2,
2180	>	fNeutralHadronIso_DR0p2To0p3,
2181	>	fNeutralHadronIso_DR0p3To0p4,
2182	>	fNeutralHadronIso_DR0p4To0p5,
2183	>	ctrl.debug);
2184	>
2185	>	SelectionStatus status;
2186	>	status.isoMVA = mvaval;
2187	>	bool pass = false;
2188	>
2189	>	Int_t subdet = 0;
2190	>	if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
2191	>	else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
2192	>	else subdet = 2;
2193	>
2194	>	Int_t ptBin = 0;
2195	>	if (ele->Pt() >= 10.0) ptBin = 1;
2196
2197		Int_t MVABin = -1;
2198		if (subdet == 0 && ptBin == 0) MVABin = 0;
#	Line 1367 \| Line 2211 \| SelectionStatus electronIsoMVASelection(
2211		if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN5 ) pass = true;
2212		if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
2213
2214	<	pass = false;
2215	<	if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
2216	<	if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
2217	<	if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
2218	<	if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
2219	<	if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
2220	<	if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
2221	<	if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
2214	>	// pass = false;
2215	>	// if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
2216	>	// if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
2217	>	// if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
2218	>	// if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
2219	>	// if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
2220	>	// if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
2221	>	// if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
2222
2223		if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2224		return status;
#	Line 1398 \| Line 2242 \| void initElectronIsoMVA() {
2242
2243
2244
2245	+
2246		//--------------------------------------------------------------------------------------------------
2247	+	// hacked version
2248		float electronPFIso04(ControlFlags &ctrl,
2249	<	const mithep::Electron * ele,
2250	<	const mithep::Vertex & vtx,
2251	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2252	<	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2253	<	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2254	<	vector<const mithep::Muon*> muonsToVeto,
2255	<	vector<const mithep::Electron*> electronsToVeto)
2249	>	const mithep::Electron * ele,
2250	>	const mithep::Vertex * vtx,
2251	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2252	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2253	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2254	>	vector<const mithep::Muon*> muonsToVeto,
2255	>	vector<const mithep::Electron*> electronsToVeto)
2256		//--------------------------------------------------------------------------------------------------
2257		{
2258
#	Line 1419 \| Line 2265 \| float electronPFIso04(ControlFlags &ctrl
2265		<< "\tphi: " << vmu->Phi()
2266		<< endl;
2267		}
2268	<	cout << "electronIsoMVASelection :: electrson to veto " << endl;
2268	>	cout << "electronIsoMVASelection :: electrons to veto " << endl;
2269		for( int i=0; i<electronsToVeto.size(); i++ ) {
2270		const mithep::Electron * vel = electronsToVeto[i];
2271		cout << "\tpt: " << vel->Pt()
#	Line 1443 \| Line 2289 \| float electronPFIso04(ControlFlags &ctrl
2289		//Loop over PF Candidates
2290		//
2291		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2292	+
2293	+
2294		const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
2295		Double_t deta = (ele->Eta() - pf->Eta());
2296		Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2297		Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2298	<	if (dr >= 0.4) continue;
2298	>
2299	>	if (dr > 0.4) continue;
2300	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2301	>
2302		if(ctrl.debug) {
2303	<	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
2304	<	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
2303	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2304	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
2305	>	<< "\ttrk: " << pf->HasTrackerTrk()
2306	>	<< "\tgsf: " << pf->HasGsfTrk();
2307	>
2308		cout << endl;
2309		}
2310
2311
2312	<	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
2313	<	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
2314	<
2312	>	//
2313	>	// sync : I don't think theyre doing this ...
2314	>	//
2315	>	// if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
2316	>	// (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2317	>	// if( ctrl.debug ) cout << "\tskipping, matches to the electron ..." << endl;
2318	>	// continue;
2319	>	// }
2320	>
2321
2322		//
2323		// Lepton Footprint Removal
#	Line 1470 \| Line 2330 \| float electronPFIso04(ControlFlags &ctrl
2330		//
2331		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2332		const mithep::Electron *tmpele = electronsToVeto[q];
2333	+	/*
2334		// 4l electron
2335		if( pf->HasTrackerTrk() ) {
2336		if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
#	Line 1483 \| Line 2344 \| float electronPFIso04(ControlFlags &ctrl
2344		IsLeptonFootprint = kTRUE;
2345		}
2346		}
2347	+	*/
2348		// PF charged
2349		if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2350		&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
#	Line 1497 \| Line 2359 \| float electronPFIso04(ControlFlags &ctrl
2359		}
2360		} // loop over electrons
2361
2362	<
2362	>	/* KH - comment for sync
2363		//
2364		// Check for muons
2365		//
#	Line 1516 \| Line 2378 \| float electronPFIso04(ControlFlags &ctrl
2378		IsLeptonFootprint = kTRUE;
2379		}
2380		} // loop over muons
2381	<
2381	>	*/
2382
2383		if (IsLeptonFootprint)
2384		continue;
#	Line 1524 \| Line 2386 \| float electronPFIso04(ControlFlags &ctrl
2386		//
2387		// Charged Iso
2388		//
2389	<	if (pf->Charge() != 0 ) {
2389	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
2390
2391	<	if( pf->HasTrackerTrk() )
2392	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2393	<	if( pf->HasGsfTrk() )
2394	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2391	>	// if( pf->HasTrackerTrk() )
2392	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2393	>	// if( pf->HasGsfTrk() )
2394	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2395
2396		// Veto any PFmuon, or PFEle
2397	<	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
2397	>	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) {
2398	>	cout << "\t skipping, pf is and ele or mu .." <<endl;
2399	>	continue;
2400	>	}
2401
2402		// Footprint Veto
2403		if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
#	Line 1554 \| Line 2419 \| float electronPFIso04(ControlFlags &ctrl
2419		}
2420		if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2421		<< dr << endl;
2422	<	fGammaIso += pf->Pt();
2422	>	// KH, add to sync
2423	>	// if( pf->Pt() > 0.5 )
2424	>	fGammaIso += pf->Pt();
2425		}
2426
2427		//
#	Line 1563 \| Line 2430 \| float electronPFIso04(ControlFlags &ctrl
2430		else {
2431		if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2432		<< dr << endl;
2433	+	// KH, add to sync
2434	+	// if( pf->Pt() > 0.5 )
2435		fNeutralHadronIso += pf->Pt();
2436		}
2437
#	Line 1570 \| Line 2439 \| float electronPFIso04(ControlFlags &ctrl
2439
2440		}
2441
2442	<	double rho = 0;
2443	<	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
2444	<	// rho = fPUEnergyDensity->At(0)->Rho();
2445	<	if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1577	<	rho = fPUEnergyDensity->At(0)->RhoLowEta();
2442	>
2443	>	double rho=0;
2444	>	if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
2445	>	rho = fPUEnergyDensity->At(0)->Rho();
2446
2447		// WARNING!!!!
2448		// hardcode for sync ...
#	Line 1582 \| Line 2450 \| float electronPFIso04(ControlFlags &ctrl
2450		// WARNING!!!!
2451
2452
2453	<	double pfIso = fChargedIso +
2454	<	max(0.0,fGammaIso -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIso04,
2455	<	ele->Eta(),EffectiveAreaVersion)) +
2456	<	max(0.0,fNeutralHadronIso -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIso04,
1589	<	ele->Eta(),EffectiveAreaVersion)) ;
2453	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2454	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2455	>	ele->Eta(),EffectiveAreaVersion)));
2456	>
2457
2458		gChargedIso = fChargedIso;
2459		gGammaIso = fGammaIso;
2460		gNeutralIso = fNeutralHadronIso;
1594	–
2461		return pfIso;
2462		}
2463
2464	+
2465	+
2466		//--------------------------------------------------------------------------------------------------
2467		// hacked version
2468		float electronPFIso04(ControlFlags &ctrl,
2469		const mithep::Electron * ele,
2470	<	const mithep::Vertex & vtx,
2470	>	const mithep::Vertex * vtx,
2471		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2472		float rho,
2473		mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
#	Line 1617 \| Line 2485 \| float electronPFIso04(ControlFlags &ctrl
2485		<< "\tphi: " << vmu->Phi()
2486		<< endl;
2487		}
2488	<	cout << "electronIsoMVASelection :: electrson to veto " << endl;
2488	>	cout << "electronIsoMVASelection :: electrons to veto " << endl;
2489		for( int i=0; i<electronsToVeto.size(); i++ ) {
2490		const mithep::Electron * vel = electronsToVeto[i];
2491		cout << "\tpt: " << vel->Pt()
#	Line 1641 \| Line 2509 \| float electronPFIso04(ControlFlags &ctrl
2509		//Loop over PF Candidates
2510		//
2511		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2512	+
2513	+
2514		const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
2515		Double_t deta = (ele->Eta() - pf->Eta());
2516		Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2517		Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2518	<	if (dr >= 0.4) continue;
2518	>
2519	>	if (dr > 0.4) continue;
2520	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2521	>
2522		if(ctrl.debug) {
2523	<	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
2524	<	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
2523	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2524	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
2525	>	<< "\ttrk: " << pf->HasTrackerTrk()
2526	>	<< "\tgsf: " << pf->HasGsfTrk();
2527	>
2528		cout << endl;
2529		}
2530
2531
2532	<	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
2533	<	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
2534	<
2532	>	//
2533	>	// sync : I don't think theyre doing this ...
2534	>	//
2535	>	// if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
2536	>	// (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2537	>	// if( ctrl.debug ) cout << "\tskipping, matches to the electron ..." << endl;
2538	>	// continue;
2539	>	// }
2540	>
2541
2542		//
2543		// Lepton Footprint Removal
#	Line 1668 \| Line 2550 \| float electronPFIso04(ControlFlags &ctrl
2550		//
2551		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2552		const mithep::Electron *tmpele = electronsToVeto[q];
2553	+	/*
2554		// 4l electron
2555		if( pf->HasTrackerTrk() ) {
2556		if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
#	Line 1681 \| Line 2564 \| float electronPFIso04(ControlFlags &ctrl
2564		IsLeptonFootprint = kTRUE;
2565		}
2566		}
2567	+	*/
2568		// PF charged
2569		if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2570		&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
#	Line 1724 \| Line 2608 \| float electronPFIso04(ControlFlags &ctrl
2608		//
2609		if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
2610
2611	<	if( pf->HasTrackerTrk() )
2612	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2613	<	if( pf->HasGsfTrk() )
2614	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2611	>	// if( pf->HasTrackerTrk() )
2612	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2613	>	// if( pf->HasGsfTrk() )
2614	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2615
2616		// Veto any PFmuon, or PFEle
2617	<	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
2617	>	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) {
2618	>	cout << "\t skipping, pf is and ele or mu .." <<endl;
2619	>	continue;
2620	>	}
2621
2622		// Footprint Veto
2623		if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
#	Line 1752 \| Line 2639 \| float electronPFIso04(ControlFlags &ctrl
2639		}
2640		if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2641		<< dr << endl;
2642	<	fGammaIso += pf->Pt();
2642	>	// KH, add to sync
2643	>	// if( pf->Pt() > 0.5 )
2644	>	fGammaIso += pf->Pt();
2645		}
2646
2647		//
#	Line 1762 \| Line 2651 \| float electronPFIso04(ControlFlags &ctrl
2651		if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2652		<< dr << endl;
2653		// KH, add to sync
2654	<	if( pf->Pt() > 0.5 )
2654	>	// if( pf->Pt() > 0.5 )
2655		fNeutralHadronIso += pf->Pt();
2656		}
2657
#	Line 1780 \| Line 2669 \| float electronPFIso04(ControlFlags &ctrl
2669		// WARNING!!!!
2670
2671
2672	<	double pfIso = fChargedIso +
2673	<	max(0.0,fGammaIso -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIso04,
2674	<	ele->Eta(),EffectiveAreaVersion)) +
2675	<	max(0.0,fNeutralHadronIso -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIso04,
2676	<	ele->Eta(),EffectiveAreaVersion)) ;
2672	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2673	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2674	>	ele->Eta(),EffectiveAreaVersion)));
2675	>
2676	>
2677	>	gChargedIso = fChargedIso;
2678	>	gGammaIso = fGammaIso;
2679	>	gNeutralIso = fNeutralHadronIso;
2680		return pfIso;
2681		}
2682
#	Line 1792 \| Line 2684 \| float electronPFIso04(ControlFlags &ctrl
2684		//--------------------------------------------------------------------------------------------------
2685		SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2686		const mithep::Electron * ele,
2687	<	const mithep::Vertex & vtx,
2687	>	const mithep::Vertex * vtx,
2688		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2689		const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2690		mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
#	Line 1805 \| Line 2697 \| SelectionStatus electronReferenceIsoSele
2697
2698		double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, fPUEnergyDensity,
2699		EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2700	<	cout << "--------------> setting electron isoPF04 to " << pfIso << endl;
2700	>	// cout << "--------------> setting electron isoPF04 to " << pfIso << endl;
2701		status.isoPF04 = pfIso;
2702		status.chisoPF04 = gChargedIso;
2703		status.gaisoPF04 = gGammaIso;
#	Line 1828 \| Line 2720 \| SelectionStatus electronReferenceIsoSele
2720		// hacked version
2721		SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2722		const mithep::Electron * ele,
2723	<	const mithep::Vertex & vtx,
2723	>	const mithep::Vertex * vtx,
2724		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2725		float rho,
2726		mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
#	Line 1841 \| Line 2733 \| SelectionStatus electronReferenceIsoSele
2733
2734		double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, rho,
2735		EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2736	+	status.isoPF04 = pfIso;
2737	+	status.chisoPF04 = gChargedIso;
2738	+	status.gaisoPF04 = gGammaIso;
2739	+	status.neisoPF04 = gNeutralIso;
2740		bool pass = false;
2741		if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2742

Diff Legend

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

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents): Revision 1.16 by khahn, Thu May 10 22:53:21 2012 UTC vs. Revision 1.22 by anlevin, Tue May 22 22:31:17 2012 UTC

Diff Legend

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents):
Revision 1.16 by khahn, Thu May 10 22:53:21 2012 UTC vs.
Revision 1.22 by anlevin, Tue May 22 22:31:17 2012 UTC