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

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents):
Revision 1.17 by khahn, Fri May 11 20:26:43 2012 UTC vs.
Revision 1.25 by anlevin, Wed May 23 22:36:14 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 662 \| 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
1048	<	// KH, comment to sync
674	<	/*
1048	>	/* KH - comment for sync
1049		//
1050		// Check for muons
1051		//
#	Line 694 \| Line 1068 \| double muonPFIso04(ControlFlags &ctrl,
1068		//
1069		// Charged Iso
1070		//
1071	<	if (pf->Charge() != 0 ) {
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	<	if( pf->HasTrackerTrk() ) {
1077	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1078	<	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1079	<	<< abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1080	<	<< dr << endl;
1081	<	}
1082	<	if( pf->HasGsfTrk() ) {
1083	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1084	<	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1085	<	<< abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1086	<	<< dr << endl;
1087	<	}
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();
#	Line 737 \| Line 1112 \| double muonPFIso04(ControlFlags &ctrl,
1112		}
1113
1114		}
740	–
741	–	double rho = 0;
742	–	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
743	–	// rho = fPUEnergyDensity->At(0)->Rho();
744	–	if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
745	–	rho = fPUEnergyDensity->At(0)->RhoLowEta();
1115
1116	<	// WARNING!!!!
1117	<	// hardcode for sync ...
1118	<	EffectiveAreaVersion = muT.kMuEAData2011;
750	<	// WARNING!!!!
1116	>	double rho=0;
1117	>	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral()) \|\| isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral())))
1118	>	rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral();
1119
1120
1121	<	double pfIso = fChargedIso + max(0.0,(fGammaIso + fNeutralHadronIso
1121	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1122		-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1123		mu->Eta(),EffectiveAreaVersion)));
756	–
1124		gChargedIso = fChargedIso;
1125	<	gGammaIso = fGammaIso;
1126	<	gNeutralIso = fNeutralHadronIso;
1125	>	gGammaIso = fGammaIso;
1126	>	gNeutralIso = fNeutralHadronIso;
1127	>
1128		return pfIso;
1129		}
1130
1131
1132	+
1133	+
1134		//--------------------------------------------------------------------------------------------------
1135		// hacked version
1136		double muonPFIso04(ControlFlags &ctrl,
1137		const mithep::Muon * mu,
1138	<	const mithep::Vertex & vtx,
1138	>	const mithep::Vertex * vtx,
1139		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1140		float rho,
1141		mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
#	Line 808 \| Line 1178 \| double muonPFIso04(ControlFlags &ctrl,
1178		//Loop over PF Candidates
1179		//
1180		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1181	+
1182	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1183		const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1184
1185		Double_t deta = (mu->Eta() - pf->Eta());
#	Line 872 \| Line 1244 \| double muonPFIso04(ControlFlags &ctrl,
1244		//
1245		if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1246
1247	<	if( dr < 0.01 ) continue; // only for muon iso mva?
1247	>	//if( dr < 0.01 ) continue; // only for muon iso mva?
1248		if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
1249
1250	<	if( pf->HasTrackerTrk() ) {
1251	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1252	<	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1253	<	<< abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1254	<	<< dr << endl;
1255	<	}
1256	<	if( pf->HasGsfTrk() ) {
1257	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1258	<	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1259	<	<< abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1260	<	<< dr << endl;
1261	<	}
1250	>
1251	>	// if( pf->HasTrackerTrk() ) {
1252	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1253	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1254	>	// << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1255	>	// << dr << endl;
1256	>	// }
1257	>	// if( pf->HasGsfTrk() ) {
1258	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1259	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1260	>	// << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1261	>	// << dr << endl;
1262	>	// }
1263
1264
1265		fChargedIso += pf->Pt();
#	Line 896 \| Line 1269 \| double muonPFIso04(ControlFlags &ctrl,
1269		// Gamma Iso
1270		//
1271		else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1272	+	// KH, add to sync
1273	+	if( pf->Pt() > 0.5 )
1274		fGammaIso += pf->Pt();
1275		}
1276
#	Line 922 \| Line 1297 \| double muonPFIso04(ControlFlags &ctrl,
1297		// WARNING!!!!
1298
1299
1300	<	double pfIso = fChargedIso + max(0.0,(fGammaIso + fNeutralHadronIso
1300	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1301		-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1302		mu->Eta(),EffectiveAreaVersion)));
1303		gChargedIso = fChargedIso;
#	Line 936 \| Line 1311 \| double muonPFIso04(ControlFlags &ctrl,
1311		//--------------------------------------------------------------------------------------------------
1312		SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1313		const mithep::Muon * mu,
1314	<	const mithep::Vertex & vtx,
1314	>	const mithep::Vertex * vtx,
1315		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1316		const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1317		mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
#	Line 949 \| Line 1324 \| SelectionStatus muonReferenceIsoSelectio
1324
1325		double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, fPUEnergyDensity,
1326		EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1327	<	cout << "--------------> setting muon isoPF04 to" << pfIso << endl;
1327	>	// cout << "--------------> setting muon isoPF04 to" << pfIso << endl;
1328		status.isoPF04 = pfIso;
1329		status.chisoPF04 = gChargedIso;
1330		status.gaisoPF04 = gGammaIso;
#	Line 972 \| Line 1347 \| SelectionStatus muonReferenceIsoSelectio
1347		// hacked version
1348		SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1349		const mithep::Muon * mu,
1350	<	const mithep::Vertex & vtx,
1350	>	const mithep::Vertex * vtx,
1351		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1352		float rho,
1353		mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
#	Line 985 \| Line 1360 \| SelectionStatus muonReferenceIsoSelectio
1360
1361		double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, rho,
1362		EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1363	+
1364	+	status.isoPF04 = pfIso;
1365	+	status.chisoPF04 = gChargedIso;
1366	+	status.gaisoPF04 = gGammaIso;
1367	+	status.neisoPF04 = gNeutralIso;
1368	+
1369		bool pass = false;
1370		if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1371
#	Line 999 \| Line 1380 \| SelectionStatus muonReferenceIsoSelectio
1380
1381
1382
1383	+
1384		//--------------------------------------------------------------------------------------------------
1385		SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1386		const mithep::Electron * ele,
1387	<	const mithep::Vertex & vtx,
1387	>	const mithep::Vertex * vtx,
1388		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1389		const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1390		mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
#	Line 1041 \| Line 1423 \| SelectionStatus electronIsoMVASelection(
1423		Double_t tmpChargedIso_DR0p2To0p3 = 0;
1424		Double_t tmpChargedIso_DR0p3To0p4 = 0;
1425		Double_t tmpChargedIso_DR0p4To0p5 = 0;
1044	–	Double_t tmpChargedIso_DR0p5To0p7 = 0;
1426
1427		Double_t tmpGammaIso_DR0p0To0p1 = 0;
1428		Double_t tmpGammaIso_DR0p1To0p2 = 0;
1429		Double_t tmpGammaIso_DR0p2To0p3 = 0;
1430		Double_t tmpGammaIso_DR0p3To0p4 = 0;
1431		Double_t tmpGammaIso_DR0p4To0p5 = 0;
1432	<	Double_t tmpGammaIso_DR0p5To0p7 = 0;
1432	>
1433
1434		Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
1435		Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
1436		Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
1437		Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
1438		Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
1058	–	Double_t tmpNeutralHadronIso_DR0p5To0p7 = 0;
1439
1440
1441
#	Line 1085 \| Line 1465 \| SelectionStatus electronIsoMVASelection(
1465		//Loop over PF Candidates
1466		//
1467		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1468	+
1469	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1470	+
1471		const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1472		Double_t deta = (ele->Eta() - pf->Eta());
1473		Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1474		Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1475	<	if (dr >= 0.5) continue;
1475	>	if (dr > 1.0) continue;
1476	>
1477		if(ctrl.debug) {
1478		cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1479	<	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
1479	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1480		cout << endl;
1481		}
1482
#	Line 1107 \| Line 1491 \| SelectionStatus electronIsoMVASelection(
1491		Bool_t IsLeptonFootprint = kFALSE;
1492		if (dr < 1.0) {
1493
1494	+
1495		//
1496		// Check for electrons
1497		//
1498	+
1499		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1500		const mithep::Electron *tmpele = electronsToVeto[q];
1501	+	double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1502	+
1503		// 4l electron
1504		if( pf->HasTrackerTrk() ) {
1505		if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
#	Line 1126 \| Line 1514 \| SelectionStatus electronIsoMVASelection(
1514		}
1515		}
1516		// PF charged
1517	<	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1130	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1517	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1518		if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1519		IsLeptonFootprint = kTRUE;
1520		}
1521		// PF gamma
1522	<	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1523	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
1522	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1523	>	&& tmpdr < 0.08) {
1524		if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1525		IsLeptonFootprint = kTRUE;
1526		}
1527		} // loop over electrons
1528
1529	+
1530		/* KH - comment for sync
1531		//
1532		// Check for muons
#	Line 1168 \| Line 1556 \| SelectionStatus electronIsoMVASelection(
1556		//
1557		if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1558
1559	<	if( pf->HasTrackerTrk() )
1560	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1561	<	if( pf->HasGsfTrk() )
1562	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1559	>	// if( pf->HasGsfTrk() ) {
1560	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1561	>	// } else if( pf->HasTrackerTrk() ){
1562	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1563	>	// }
1564
1565		// Veto any PFmuon, or PFEle
1566		if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
#	Line 1188 \| Line 1577 \| SelectionStatus electronIsoMVASelection(
1577		if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1578		if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1579		if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
1191	–	if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
1580
1581		}
1582
#	Line 1197 \| Line 1585 \| SelectionStatus electronIsoMVASelection(
1585		//
1586		else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1587
1588	<	if (fabs(ele->SCluster()->Eta()) > 1.479) {
1201	<	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
1202	<	}
1588	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
1589
1590		if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1591		<< dr << endl;
#	Line 1209 \| Line 1595 \| SelectionStatus electronIsoMVASelection(
1595		if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1596		if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1597		if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
1212	–	if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
1213	–
1598		}
1599
1600		//
#	Line 1224 \| Line 1608 \| SelectionStatus electronIsoMVASelection(
1608		if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1609		if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1610		if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1227	–	if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
1611		}
1612
1613		}
1614
1615		}
1616
1617	<	fChargedIso_DR0p0To0p1 = min((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1618	<	fChargedIso_DR0p1To0p2 = min((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1619	<	fChargedIso_DR0p2To0p3 = min((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1620	<	fChargedIso_DR0p3To0p4 = min((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1621	<	fChargedIso_DR0p4To0p5 = min((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1617	>	fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1618	>	fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1619	>	fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1620	>	fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1621	>	fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1622	>
1623	>	if(ctrl.debug) {
1624	>	cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1 << endl;
1625	>	cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2 << endl;
1626	>	cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3 << endl;
1627	>	cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4 << endl;
1628	>	cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5 << endl;
1629	>	}
1630	>
1631
1632		double rho = 0;
1633		if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
1634		rho = fPUEnergyDensity->At(0)->Rho();
1635	+	// if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1636	+	// rho = fPUEnergyDensity->At(0)->RhoLowEta();
1637	+
1638	+	// WARNING!!!!
1639	+	// hardcode for sync ...
1640	+	EffectiveAreaVersion = eleT.kEleEAData2011;
1641	+	// WARNING!!!!
1642	+
1643	+	if( ctrl.debug) {
1644	+	cout << "RHO: " << rho << endl;
1645	+	cout << "eta: " << ele->SCluster()->Eta() << endl;
1646	+	cout << "target: " << EffectiveAreaVersion << endl;
1647	+	cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1648	+	ele->SCluster()->Eta(),
1649	+	EffectiveAreaVersion)
1650	+	<< endl;
1651	+	cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1652	+	ele->SCluster()->Eta(),
1653	+	EffectiveAreaVersion)
1654	+	<< endl;
1655	+	cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1656	+	ele->SCluster()->Eta(),
1657	+	EffectiveAreaVersion)
1658	+	<< endl;
1659	+	cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1660	+	ele->SCluster()->Eta(),
1661	+	EffectiveAreaVersion)
1662	+	<< endl;
1663	+	}
1664	+
1665	+	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
1666	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
1667	+	ele->SCluster()->Eta(),
1668	+	EffectiveAreaVersion))/ele->Pt()
1669	+	,2.5)
1670	+	,0.0);
1671	+	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
1672	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
1673	+	ele->SCluster()->Eta(),
1674	+	EffectiveAreaVersion))/ele->Pt()
1675	+	,2.5)
1676	+	,0.0);
1677	+	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
1678	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
1679	+	ele->SCluster()->Eta()
1680	+	,EffectiveAreaVersion))/ele->Pt()
1681	+	,2.5)
1682	+	,0.0);
1683	+	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
1684	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
1685	+	ele->SCluster()->Eta(),
1686	+	EffectiveAreaVersion))/ele->Pt()
1687	+	,2.5)
1688	+	,0.0);
1689	+	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
1690	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
1691	+	ele->SCluster()->Eta(),
1692	+	EffectiveAreaVersion))/ele->Pt()
1693	+	,2.5)
1694	+	,0.0);
1695	+
1696	+
1697	+	if( ctrl.debug) {
1698	+	cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
1699	+	cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
1700	+	cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
1701	+	cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
1702	+	cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
1703	+	}
1704	+
1705	+	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
1706	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1707	+	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1708	+	, 2.5)
1709	+	, 0.0);
1710	+	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
1711	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1712	+	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1713	+	, 2.5)
1714	+	, 0.0);
1715	+	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
1716	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1717	+	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1718	+	, 2.5)
1719	+	, 0.0);
1720	+	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
1721	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1722	+	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1723	+	, 2.5)
1724	+	, 0.0);
1725	+	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
1726	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
1727	+	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1728	+	, 2.5)
1729	+	, 0.0);
1730	+
1731	+	if( ctrl.debug) {
1732	+	cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
1733	+	cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
1734	+	cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
1735	+	cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
1736	+	cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
1737	+	}
1738	+
1739	+	double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
1740	+	ele->SCluster()->Eta(),
1741	+	fChargedIso_DR0p0To0p1,
1742	+	fChargedIso_DR0p1To0p2,
1743	+	fChargedIso_DR0p2To0p3,
1744	+	fChargedIso_DR0p3To0p4,
1745	+	fChargedIso_DR0p4To0p5,
1746	+	fGammaIso_DR0p0To0p1,
1747	+	fGammaIso_DR0p1To0p2,
1748	+	fGammaIso_DR0p2To0p3,
1749	+	fGammaIso_DR0p3To0p4,
1750	+	fGammaIso_DR0p4To0p5,
1751	+	fNeutralHadronIso_DR0p0To0p1,
1752	+	fNeutralHadronIso_DR0p1To0p2,
1753	+	fNeutralHadronIso_DR0p2To0p3,
1754	+	fNeutralHadronIso_DR0p3To0p4,
1755	+	fNeutralHadronIso_DR0p4To0p5,
1756	+	ctrl.debug);
1757	+
1758	+	SelectionStatus status;
1759	+	status.isoMVA = mvaval;
1760	+	bool pass = false;
1761	+
1762	+	Int_t subdet = 0;
1763	+	if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
1764	+	else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
1765	+	else subdet = 2;
1766	+
1767	+	Int_t ptBin = 0;
1768	+	if (ele->Pt() >= 10.0) ptBin = 1;
1769	+
1770	+	Int_t MVABin = -1;
1771	+	if (subdet == 0 && ptBin == 0) MVABin = 0;
1772	+	if (subdet == 1 && ptBin == 0) MVABin = 1;
1773	+	if (subdet == 2 && ptBin == 0) MVABin = 2;
1774	+	if (subdet == 0 && ptBin == 1) MVABin = 3;
1775	+	if (subdet == 1 && ptBin == 1) MVABin = 4;
1776	+	if (subdet == 2 && ptBin == 1) MVABin = 5;
1777	+
1778	+	pass = false;
1779	+	if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN0 ) pass = true;
1780	+	if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN1 ) pass = true;
1781	+	if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN2 ) pass = true;
1782	+	if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN3 ) pass = true;
1783	+	if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN4 ) pass = true;
1784	+	if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN5 ) pass = true;
1785	+	// pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
1786	+	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
1787	+
1788	+	// pass = false;
1789	+	// if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
1790	+	// if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
1791	+	// if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
1792	+	// if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
1793	+	// if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
1794	+	// if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
1795	+	// if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
1796	+
1797	+	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1798	+	return status;
1799	+
1800	+	}
1801	+
1802	+
1803	+	//--------------------------------------------------------------------------------------------------
1804	+	SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1805	+	const mithep::Electron * ele,
1806	+	const mithep::Vertex * vtx,
1807	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1808	+	float rho,
1809	+	//const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1810	+	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1811	+	vector<const mithep::Muon*> muonsToVeto,
1812	+	vector<const mithep::Electron*> electronsToVeto)
1813	+	//--------------------------------------------------------------------------------------------------
1814	+	// hacked version
1815	+	{
1816	+	if( ctrl.debug ) {
1817	+	cout << "================> hacked ele Iso MVA <======================" << endl;
1818	+	}
1819	+
1820	+	if( ctrl.debug ) {
1821	+	cout << "electronIsoMVASelection :: muons to veto " << endl;
1822	+	for( int i=0; i<muonsToVeto.size(); i++ ) {
1823	+	const mithep::Muon * vmu = muonsToVeto[i];
1824	+	cout << "\tpt: " << vmu->Pt()
1825	+	<< "\teta: " << vmu->Eta()
1826	+	<< "\tphi: " << vmu->Phi()
1827	+	<< endl;
1828	+	}
1829	+	cout << "electronIsoMVASelection :: electrson to veto " << endl;
1830	+	for( int i=0; i<electronsToVeto.size(); i++ ) {
1831	+	const mithep::Electron * vel = electronsToVeto[i];
1832	+	cout << "\tpt: " << vel->Pt()
1833	+	<< "\teta: " << vel->Eta()
1834	+	<< "\tphi: " << vel->Phi()
1835	+	<< "\ttrk: " << vel->TrackerTrk()
1836	+	<< endl;
1837	+	}
1838	+	}
1839	+
1840	+	bool failiso=false;
1841	+
1842	+	//
1843	+	// tmp iso rings
1844	+	//
1845	+	Double_t tmpChargedIso_DR0p0To0p1 = 0;
1846	+	Double_t tmpChargedIso_DR0p1To0p2 = 0;
1847	+	Double_t tmpChargedIso_DR0p2To0p3 = 0;
1848	+	Double_t tmpChargedIso_DR0p3To0p4 = 0;
1849	+	Double_t tmpChargedIso_DR0p4To0p5 = 0;
1850	+
1851	+	Double_t tmpGammaIso_DR0p0To0p1 = 0;
1852	+	Double_t tmpGammaIso_DR0p1To0p2 = 0;
1853	+	Double_t tmpGammaIso_DR0p2To0p3 = 0;
1854	+	Double_t tmpGammaIso_DR0p3To0p4 = 0;
1855	+	Double_t tmpGammaIso_DR0p4To0p5 = 0;
1856	+
1857	+
1858	+	Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
1859	+	Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
1860	+	Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
1861	+	Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
1862	+	Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
1863	+
1864	+
1865	+
1866	+	//
1867	+	// final rings for the MVA
1868	+	//
1869	+	Double_t fChargedIso_DR0p0To0p1;
1870	+	Double_t fChargedIso_DR0p1To0p2;
1871	+	Double_t fChargedIso_DR0p2To0p3;
1872	+	Double_t fChargedIso_DR0p3To0p4;
1873	+	Double_t fChargedIso_DR0p4To0p5;
1874	+
1875	+	Double_t fGammaIso_DR0p0To0p1;
1876	+	Double_t fGammaIso_DR0p1To0p2;
1877	+	Double_t fGammaIso_DR0p2To0p3;
1878	+	Double_t fGammaIso_DR0p3To0p4;
1879	+	Double_t fGammaIso_DR0p4To0p5;
1880	+
1881	+	Double_t fNeutralHadronIso_DR0p0To0p1;
1882	+	Double_t fNeutralHadronIso_DR0p1To0p2;
1883	+	Double_t fNeutralHadronIso_DR0p2To0p3;
1884	+	Double_t fNeutralHadronIso_DR0p3To0p4;
1885	+	Double_t fNeutralHadronIso_DR0p4To0p5;
1886	+
1887	+
1888	+	//
1889	+	//Loop over PF Candidates
1890	+	//
1891	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1892	+
1893	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1894	+
1895	+	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1896	+	Double_t deta = (ele->Eta() - pf->Eta());
1897	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1898	+	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1899	+	if (dr > 1.0) continue;
1900	+
1901	+	if(ctrl.debug) {
1902	+	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1903	+	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1904	+	cout << endl;
1905	+	}
1906	+
1907	+
1908	+	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
1909	+	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1910	+
1911	+
1912	+	//
1913	+	// Lepton Footprint Removal
1914	+	//
1915	+	Bool_t IsLeptonFootprint = kFALSE;
1916	+	if (dr < 1.0) {
1917	+
1918	+
1919	+	//
1920	+	// Check for electrons
1921	+	//
1922	+
1923	+	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1924	+	const mithep::Electron *tmpele = electronsToVeto[q];
1925	+	double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1926	+
1927	+	// 4l electron
1928	+	if( pf->HasTrackerTrk() ) {
1929	+	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1930	+	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1931	+	IsLeptonFootprint = kTRUE;
1932	+	}
1933	+	}
1934	+	if( pf->HasGsfTrk() ) {
1935	+	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1936	+	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1937	+	IsLeptonFootprint = kTRUE;
1938	+	}
1939	+	}
1940	+	// PF charged
1941	+	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1942	+	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1943	+	IsLeptonFootprint = kTRUE;
1944	+	}
1945	+	// PF gamma
1946	+	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1947	+	&& tmpdr < 0.08) {
1948	+	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1949	+	IsLeptonFootprint = kTRUE;
1950	+	}
1951	+	} // loop over electrons
1952	+
1953	+
1954	+	/* KH - comment for sync
1955	+	//
1956	+	// Check for muons
1957	+	//
1958	+	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1959	+	const mithep::Muon *tmpmu = muonsToVeto[q];
1960	+	// 4l muon
1961	+	if( pf->HasTrackerTrk() ) {
1962	+	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1963	+	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1964	+	IsLeptonFootprint = kTRUE;
1965	+	}
1966	+	}
1967	+	// PF charged
1968	+	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1969	+	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1970	+	IsLeptonFootprint = kTRUE;
1971	+	}
1972	+	} // loop over muons
1973	+	*/
1974	+
1975	+	if (IsLeptonFootprint)
1976	+	continue;
1977	+
1978	+	//
1979	+	// Charged Iso Rings
1980	+	//
1981	+	if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1982	+
1983	+	// if( pf->HasGsfTrk() ) {
1984	+	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1985	+	// } else if( pf->HasTrackerTrk() ){
1986	+	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1987	+	// }
1988	+
1989	+	// Veto any PFmuon, or PFEle
1990	+	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
1991	+
1992	+	// Footprint Veto
1993	+	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1994	+
1995	+	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1996	+	<< "\ttype: " << pf->PFType()
1997	+	<< "\ttrk: " << pf->TrackerTrk() << endl;
1998	+
1999	+	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
2000	+	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
2001	+	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
2002	+	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
2003	+	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
2004	+
2005	+	}
2006	+
2007	+	//
2008	+	// Gamma Iso Rings
2009	+	//
2010	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2011	+
2012	+	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
2013	+
2014	+	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2015	+	<< dr << endl;
2016	+
2017	+	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
2018	+	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
2019	+	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
2020	+	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
2021	+	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
2022	+	}
2023	+
2024	+	//
2025	+	// Other Neutral Iso Rings
2026	+	//
2027	+	else {
2028	+	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2029	+	<< dr << endl;
2030	+	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
2031	+	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
2032	+	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
2033	+	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
2034	+	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
2035	+	}
2036	+
2037	+	}
2038	+
2039	+	}
2040	+
2041	+	fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
2042	+	fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
2043	+	fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
2044	+	fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
2045	+	fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
2046	+
2047	+	if(ctrl.debug) {
2048	+	cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1 << endl;
2049	+	cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2 << endl;
2050	+	cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3 << endl;
2051	+	cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4 << endl;
2052	+	cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5 << endl;
2053	+	}
2054	+
2055	+
2056	+	// rho=0;
2057	+	// double rho = 0;
2058	+	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
2059	+	// rho = fPUEnergyDensity->At(0)->Rho();
2060	+	// if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
2061	+	// rho = fPUEnergyDensity->At(0)->RhoLowEta();
2062	+
2063	+	// WARNING!!!!
2064	+	// hardcode for sync ...
2065	+	EffectiveAreaVersion = eleT.kEleEAData2011;
2066	+	// WARNING!!!!
2067
2068		if( ctrl.debug) {
2069		cout << "RHO: " << rho << endl;
#	Line 1263 \| Line 2087 \| SelectionStatus electronIsoMVASelection(
2087		<< endl;
2088		}
2089
2090	<	fGammaIso_DR0p0To0p1 = max(min((tmpGammaIso_DR0p0To0p1
2090	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
2091		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
2092		ele->SCluster()->Eta(),
2093		EffectiveAreaVersion))/ele->Pt()
2094		,2.5)
2095		,0.0);
2096	<	fGammaIso_DR0p1To0p2 = max(min((tmpGammaIso_DR0p1To0p2
2096	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
2097		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
2098		ele->SCluster()->Eta(),
2099		EffectiveAreaVersion))/ele->Pt()
2100		,2.5)
2101		,0.0);
2102	<	fGammaIso_DR0p2To0p3 = max(min((tmpGammaIso_DR0p2To0p3
2102	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
2103		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
2104		ele->SCluster()->Eta()
2105		,EffectiveAreaVersion))/ele->Pt()
2106		,2.5)
2107		,0.0);
2108	<	fGammaIso_DR0p3To0p4 = max(min((tmpGammaIso_DR0p3To0p4
2108	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
2109		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
2110		ele->SCluster()->Eta(),
2111		EffectiveAreaVersion))/ele->Pt()
2112		,2.5)
2113		,0.0);
2114	<	fGammaIso_DR0p4To0p5 = max(min((tmpGammaIso_DR0p4To0p5
2114	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
2115		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
2116		ele->SCluster()->Eta(),
2117		EffectiveAreaVersion))/ele->Pt()
#	Line 1295 \| Line 2119 \| SelectionStatus electronIsoMVASelection(
2119		,0.0);
2120
2121
2122	<	fNeutralHadronIso_DR0p0To0p1 = max(min((tmpNeutralHadronIso_DR0p0To0p1
2122	>	if( ctrl.debug) {
2123	>	cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
2124	>	cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
2125	>	cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
2126	>	cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
2127	>	cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
2128	>	}
2129	>
2130	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
2131		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
2132		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2133		, 2.5)
2134		, 0.0);
2135	<	fNeutralHadronIso_DR0p1To0p2 = max(min((tmpNeutralHadronIso_DR0p1To0p2
2135	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
2136		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
2137		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2138		, 2.5)
2139		, 0.0);
2140	<	fNeutralHadronIso_DR0p2To0p3 = max(min((tmpNeutralHadronIso_DR0p2To0p3
2140	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
2141		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
2142		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2143		, 2.5)
2144		, 0.0);
2145	<	fNeutralHadronIso_DR0p3To0p4 = max(min((tmpNeutralHadronIso_DR0p3To0p4
2145	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
2146		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
2147		ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2148		, 2.5)
2149		, 0.0);
2150	<	fNeutralHadronIso_DR0p4To0p5 = max(min((tmpNeutralHadronIso_DR0p4To0p5
2150	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
2151		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
2152		ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2153		, 2.5)
2154		, 0.0);
2155
2156	+	if( ctrl.debug) {
2157	+	cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
2158	+	cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
2159	+	cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
2160	+	cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
2161	+	cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
2162	+	}
2163	+
2164		double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
2165		ele->SCluster()->Eta(),
2166		fChargedIso_DR0p0To0p1,
#	Line 1341 \| Line 2181 \| SelectionStatus electronIsoMVASelection(
2181		ctrl.debug);
2182
2183		SelectionStatus status;
2184	+	status.isoMVA = mvaval;
2185		bool pass = false;
2186
2187		Int_t subdet = 0;
2188		if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
2189		else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
2190		else subdet = 2;
2191	+
2192		Int_t ptBin = 0;
2193	<	if (ele->Pt() > 10.0) ptBin = 1;
2193	>	if (ele->Pt() >= 10.0) ptBin = 1;
2194
2195		Int_t MVABin = -1;
2196		if (subdet == 0 && ptBin == 0) MVABin = 0;
#	Line 1367 \| Line 2209 \| SelectionStatus electronIsoMVASelection(
2209		if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN5 ) pass = true;
2210		if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
2211
2212	<	pass = false;
2213	<	if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
2214	<	if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
2215	<	if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
2216	<	if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
2217	<	if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
2218	<	if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
2219	<	if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
2212	>	// pass = false;
2213	>	// if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
2214	>	// if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
2215	>	// if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
2216	>	// if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
2217	>	// if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
2218	>	// if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
2219	>	// if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
2220
2221		if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2222		return status;
#	Line 1398 \| Line 2240 \| void initElectronIsoMVA() {
2240
2241
2242
2243	+
2244		//--------------------------------------------------------------------------------------------------
2245		float electronPFIso04(ControlFlags &ctrl,
2246	<	const mithep::Electron * ele,
2247	<	const mithep::Vertex & vtx,
2248	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2249	<	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2250	<	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2251	<	vector<const mithep::Muon*> muonsToVeto,
2252	<	vector<const mithep::Electron*> electronsToVeto)
2246	>	const mithep::Electron * ele,
2247	>	const mithep::Vertex * vtx,
2248	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2249	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2250	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2251	>	vector<const mithep::Muon*> muonsToVeto,
2252	>	vector<const mithep::Electron*> electronsToVeto)
2253		//--------------------------------------------------------------------------------------------------
2254		{
2255	<
2255	>	/*
2256		if( ctrl.debug ) {
2257		cout << "electronIsoMVASelection :: muons to veto " << endl;
2258		for( int i=0; i<muonsToVeto.size(); i++ ) {
#	Line 1419 \| Line 2262 \| float electronPFIso04(ControlFlags &ctrl
2262		<< "\tphi: " << vmu->Phi()
2263		<< endl;
2264		}
2265	<	cout << "electronIsoMVASelection :: electrson to veto " << endl;
2265	>	cout << "electronIsoMVASelection :: electrons to veto " << endl;
2266		for( int i=0; i<electronsToVeto.size(); i++ ) {
2267		const mithep::Electron * vel = electronsToVeto[i];
2268		cout << "\tpt: " << vel->Pt()
#	Line 1429 \| Line 2272 \| float electronPFIso04(ControlFlags &ctrl
2272		<< endl;
2273		}
2274		}
2275	<
2275	>	*/
2276
2277		//
2278		// final iso
#	Line 1443 \| Line 2286 \| float electronPFIso04(ControlFlags &ctrl
2286		//Loop over PF Candidates
2287		//
2288		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2289	+
2290	+
2291		const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
2292		Double_t deta = (ele->Eta() - pf->Eta());
2293		Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2294		Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2295	<	if (dr >= 0.4) continue;
2295	>
2296	>	if (dr > 0.4) continue;
2297	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2298	>
2299		if(ctrl.debug) {
2300	<	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
2301	<	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
2300	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2301	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
2302	>	<< "\ttrk: " << pf->HasTrackerTrk()
2303	>	<< "\tgsf: " << pf->HasGsfTrk();
2304	>
2305		cout << endl;
2306		}
2307
2308
2309	<	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
2310	<	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
2311	<
2309	>	//
2310	>	// sync : I don't think theyre doing this ...
2311	>	//
2312	>	// if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
2313	>	// (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2314	>	// if( ctrl.debug ) cout << "\tskipping, matches to the electron ..." << endl;
2315	>	// continue;
2316	>	// }
2317	>
2318
2319		//
2320		// Lepton Footprint Removal
#	Line 1470 \| Line 2327 \| float electronPFIso04(ControlFlags &ctrl
2327		//
2328		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2329		const mithep::Electron *tmpele = electronsToVeto[q];
2330	+	/*
2331		// 4l electron
2332		if( pf->HasTrackerTrk() ) {
2333		if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
#	Line 1483 \| Line 2341 \| float electronPFIso04(ControlFlags &ctrl
2341		IsLeptonFootprint = kTRUE;
2342		}
2343		}
2344	+	*/
2345		// PF charged
2346		if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2347		&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
#	Line 1497 \| Line 2356 \| float electronPFIso04(ControlFlags &ctrl
2356		}
2357		} // loop over electrons
2358
2359	<
2359	>	/* KH - comment for sync
2360		//
2361		// Check for muons
2362		//
#	Line 1516 \| Line 2375 \| float electronPFIso04(ControlFlags &ctrl
2375		IsLeptonFootprint = kTRUE;
2376		}
2377		} // loop over muons
2378	<
2378	>	*/
2379
2380		if (IsLeptonFootprint)
2381		continue;
#	Line 1524 \| Line 2383 \| float electronPFIso04(ControlFlags &ctrl
2383		//
2384		// Charged Iso
2385		//
2386	<	if (pf->Charge() != 0 ) {
2386	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
2387
2388	<	if( pf->HasTrackerTrk() )
2389	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2390	<	if( pf->HasGsfTrk() )
2391	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2388	>	// if( pf->HasTrackerTrk() )
2389	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2390	>	// if( pf->HasGsfTrk() )
2391	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2392
2393		// Veto any PFmuon, or PFEle
2394	<	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
2394	>	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) {
2395	>	cout << "\t skipping, pf is and ele or mu .." <<endl;
2396	>	continue;
2397	>	}
2398
2399		// Footprint Veto
2400		if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
#	Line 1554 \| Line 2416 \| float electronPFIso04(ControlFlags &ctrl
2416		}
2417		if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2418		<< dr << endl;
2419	<	if( pf->Pt() > 0.5 )
2419	>	// KH, add to sync
2420	>	// if( pf->Pt() > 0.5 )
2421		fGammaIso += pf->Pt();
2422		}
2423
#	Line 1564 \| Line 2427 \| float electronPFIso04(ControlFlags &ctrl
2427		else {
2428		if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2429		<< dr << endl;
2430	<	if( pf->Pt() > 0.5 )
2430	>	// KH, add to sync
2431	>	// if( pf->Pt() > 0.5 )
2432		fNeutralHadronIso += pf->Pt();
2433		}
2434
#	Line 1572 \| Line 2436 \| float electronPFIso04(ControlFlags &ctrl
2436
2437		}
2438
1575	–	double rho = 0;
1576	–	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
1577	–	// rho = fPUEnergyDensity->At(0)->Rho();
1578	–	if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1579	–	rho = fPUEnergyDensity->At(0)->RhoLowEta();
2439
2440	<	// WARNING!!!!
2441	<	// hardcode for sync ...
2442	<	EffectiveAreaVersion = eleT.kEleEAData2011;
2443	<	// WARNING!!!!
2440	>	double rho=0;
2441	>	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJets()) \|\| isinf(fPUEnergyDensity->At(0)->RhoKt6PFJets())))
2442	>	rho = fPUEnergyDensity->At(0)->RhoKt6PFJets();
2443	>
2444
2445	+	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2446	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2447	+	ele->Eta(),EffectiveAreaVersion)));
2448
1587	–	double pfIso = fChargedIso +
1588	–	max(0.0,fGammaIso -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIso04,
1589	–	ele->Eta(),EffectiveAreaVersion)) +
1590	–	max(0.0,fNeutralHadronIso -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIso04,
1591	–	ele->Eta(),EffectiveAreaVersion)) ;
2449
2450		gChargedIso = fChargedIso;
2451		gGammaIso = fGammaIso;
2452		gNeutralIso = fNeutralHadronIso;
1596	–
2453		return pfIso;
2454		}
2455
2456	+
2457	+
2458		//--------------------------------------------------------------------------------------------------
2459		// hacked version
2460		float electronPFIso04(ControlFlags &ctrl,
2461		const mithep::Electron * ele,
2462	<	const mithep::Vertex & vtx,
2462	>	const mithep::Vertex * vtx,
2463		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2464		float rho,
2465		mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
#	Line 1619 \| Line 2477 \| float electronPFIso04(ControlFlags &ctrl
2477		<< "\tphi: " << vmu->Phi()
2478		<< endl;
2479		}
2480	<	cout << "electronIsoMVASelection :: electrson to veto " << endl;
2480	>	cout << "electronIsoMVASelection :: electrons to veto " << endl;
2481		for( int i=0; i<electronsToVeto.size(); i++ ) {
2482		const mithep::Electron * vel = electronsToVeto[i];
2483		cout << "\tpt: " << vel->Pt()
#	Line 1643 \| Line 2501 \| float electronPFIso04(ControlFlags &ctrl
2501		//Loop over PF Candidates
2502		//
2503		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2504	+
2505	+
2506		const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
2507		Double_t deta = (ele->Eta() - pf->Eta());
2508		Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2509		Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2510	<	if (dr >= 0.4) continue;
2510	>
2511	>	if (dr > 0.4) continue;
2512	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2513	>
2514		if(ctrl.debug) {
2515	<	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
2516	<	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
2515	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2516	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
2517	>	<< "\ttrk: " << pf->HasTrackerTrk()
2518	>	<< "\tgsf: " << pf->HasGsfTrk();
2519	>
2520		cout << endl;
2521		}
2522
2523
2524	<	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
2525	<	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
2526	<
2524	>	//
2525	>	// sync : I don't think theyre doing this ...
2526	>	//
2527	>	// if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
2528	>	// (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2529	>	// if( ctrl.debug ) cout << "\tskipping, matches to the electron ..." << endl;
2530	>	// continue;
2531	>	// }
2532	>
2533
2534		//
2535		// Lepton Footprint Removal
#	Line 1670 \| Line 2542 \| float electronPFIso04(ControlFlags &ctrl
2542		//
2543		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2544		const mithep::Electron *tmpele = electronsToVeto[q];
2545	+	/*
2546		// 4l electron
2547		if( pf->HasTrackerTrk() ) {
2548		if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
#	Line 1683 \| Line 2556 \| float electronPFIso04(ControlFlags &ctrl
2556		IsLeptonFootprint = kTRUE;
2557		}
2558		}
2559	+	*/
2560		// PF charged
2561		if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2562		&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
#	Line 1726 \| Line 2600 \| float electronPFIso04(ControlFlags &ctrl
2600		//
2601		if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
2602
2603	<	if( pf->HasTrackerTrk() )
2604	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2605	<	if( pf->HasGsfTrk() )
2606	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2603	>	// if( pf->HasTrackerTrk() )
2604	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2605	>	// if( pf->HasGsfTrk() )
2606	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2607
2608		// Veto any PFmuon, or PFEle
2609	<	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
2609	>	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) {
2610	>	cout << "\t skipping, pf is and ele or mu .." <<endl;
2611	>	continue;
2612	>	}
2613
2614		// Footprint Veto
2615		if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
#	Line 1754 \| Line 2631 \| float electronPFIso04(ControlFlags &ctrl
2631		}
2632		if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2633		<< dr << endl;
2634	<	fGammaIso += pf->Pt();
2634	>	// KH, add to sync
2635	>	// if( pf->Pt() > 0.5 )
2636	>	fGammaIso += pf->Pt();
2637		}
2638
2639		//
#	Line 1764 \| Line 2643 \| float electronPFIso04(ControlFlags &ctrl
2643		if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2644		<< dr << endl;
2645		// KH, add to sync
2646	<	if( pf->Pt() > 0.5 )
2646	>	// if( pf->Pt() > 0.5 )
2647		fNeutralHadronIso += pf->Pt();
2648		}
2649
#	Line 1782 \| Line 2661 \| float electronPFIso04(ControlFlags &ctrl
2661		// WARNING!!!!
2662
2663
2664	<	double pfIso = fChargedIso +
2665	<	max(0.0,fGammaIso -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIso04,
2666	<	ele->Eta(),EffectiveAreaVersion)) +
2667	<	max(0.0,fNeutralHadronIso -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIso04,
2668	<	ele->Eta(),EffectiveAreaVersion)) ;
2664	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2665	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2666	>	ele->Eta(),EffectiveAreaVersion)));
2667	>
2668	>
2669	>	gChargedIso = fChargedIso;
2670	>	gGammaIso = fGammaIso;
2671	>	gNeutralIso = fNeutralHadronIso;
2672		return pfIso;
2673		}
2674
#	Line 1794 \| Line 2676 \| float electronPFIso04(ControlFlags &ctrl
2676		//--------------------------------------------------------------------------------------------------
2677		SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2678		const mithep::Electron * ele,
2679	<	const mithep::Vertex & vtx,
2679	>	const mithep::Vertex * vtx,
2680		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2681		const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2682		mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
#	Line 1807 \| Line 2689 \| SelectionStatus electronReferenceIsoSele
2689
2690		double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, fPUEnergyDensity,
2691		EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2692	<	cout << "--------------> setting electron isoPF04 to " << pfIso << endl;
2692	>	// cout << "--------------> setting electron isoPF04 to " << pfIso << endl;
2693		status.isoPF04 = pfIso;
2694		status.chisoPF04 = gChargedIso;
2695		status.gaisoPF04 = gGammaIso;
#	Line 1830 \| Line 2712 \| SelectionStatus electronReferenceIsoSele
2712		// hacked version
2713		SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2714		const mithep::Electron * ele,
2715	<	const mithep::Vertex & vtx,
2715	>	const mithep::Vertex * vtx,
2716		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2717		float rho,
2718		mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
#	Line 1843 \| Line 2725 \| SelectionStatus electronReferenceIsoSele
2725
2726		double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, rho,
2727		EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2728	+	status.isoPF04 = pfIso;
2729	+	status.chisoPF04 = gChargedIso;
2730	+	status.gaisoPF04 = gGammaIso;
2731	+	status.neisoPF04 = gNeutralIso;
2732		bool pass = false;
2733		if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2734

Diff Legend

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

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents): Revision 1.17 by khahn, Fri May 11 20:26:43 2012 UTC vs. Revision 1.25 by anlevin, Wed May 23 22:36:14 2012 UTC

Diff Legend

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents):
Revision 1.17 by khahn, Fri May 11 20:26:43 2012 UTC vs.
Revision 1.25 by anlevin, Wed May 23 22:36:14 2012 UTC