[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.27 by khahn, Mon May 28 16:34:44 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	+
472	+	// if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
473	+	// rho = fPUEnergyDensity->At(0)->RhoLowEta();
474	+
475	+	// WARNING!!!!
476	+	// hardcode for sync ...
477	+	EffectiveAreaVersion = muT.kMuEAData2011;
478	+	// WARNING!!!!
479	+
480	+
481	+	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
482	+	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p0To0p1,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
483	+	,2.5)
484	+	,0.0);
485	+	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
486	+	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p1To0p2,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
487	+	,2.5)
488	+	,0.0);
489	+	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
490	+	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p2To0p3,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
491	+	,2.5)
492	+	,0.0);
493	+	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
494	+	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p3To0p4,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
495	+	,2.5)
496	+	,0.0);
497	+	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
498	+	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p4To0p5,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
499	+	,2.5)
500	+	,0.0);
501	+
502	+
503	+
504	+	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
505	+	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p0To0p1,
506	+	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
507	+	, 2.5)
508	+	, 0.0);
509	+	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
510	+	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p1To0p2,
511	+	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
512	+	, 2.5)
513	+	, 0.0);
514	+	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
515	+	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p2To0p3,
516	+	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
517	+	, 2.5)
518	+	, 0.0);
519	+	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
520	+	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p3To0p4,
521	+	mu->Eta(), EffectiveAreaVersion))/mu->Pt()
522	+	, 2.5)
523	+	, 0.0);
524	+	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
525	+	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p4To0p5,
526	+	mu->Eta(), EffectiveAreaVersion))/mu->Pt()
527	+	, 2.5)
528	+	, 0.0);
529	+
530	+
531	+	double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
532	+	mu->Eta(),
533	+	mu->IsGlobalMuon(),
534	+	mu->IsTrackerMuon(),
535	+	fChargedIso_DR0p0To0p1,
536	+	fChargedIso_DR0p1To0p2,
537	+	fChargedIso_DR0p2To0p3,
538	+	fChargedIso_DR0p3To0p4,
539	+	fChargedIso_DR0p4To0p5,
540	+	fGammaIso_DR0p0To0p1,
541	+	fGammaIso_DR0p1To0p2,
542	+	fGammaIso_DR0p2To0p3,
543	+	fGammaIso_DR0p3To0p4,
544	+	fGammaIso_DR0p4To0p5,
545	+	fNeutralHadronIso_DR0p0To0p1,
546	+	fNeutralHadronIso_DR0p1To0p2,
547	+	fNeutralHadronIso_DR0p2To0p3,
548	+	fNeutralHadronIso_DR0p3To0p4,
549	+	fNeutralHadronIso_DR0p4To0p5,
550	+	ctrl.debug);
551	+
552	+	SelectionStatus status;
553	+	bool pass;
554	+
555	+	pass = false;
556	+	if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
557	+	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN0) pass = true;
558	+	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
559	+	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN1) pass = true;
560	+	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
561	+	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN2) pass = true;
562	+	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
563	+	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN3) pass = true;
564	+	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN4) pass = true;
565	+	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN5) pass = true;
566	+	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
567	+
568	+	/*
569	+	pass = false;
570	+	if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
571	+	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN0) pass = true;
572	+	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
573	+	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN1) pass = true;
574	+	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
575	+	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN2) pass = true;
576	+	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
577	+	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN3) pass = true;
578	+	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN4) pass = true;
579	+	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN5) pass = true;
580	+	if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
581	+	*/
582	+
583	+	// pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
584	+
585	+	status.isoMVA = mvaval;
586	+
587	+	if(ctrl.debug) {
588	+	cout << "returning status : " << hex << status.getStatus() << dec << endl;
589	+	cout << "MVAVAL : " << status.isoMVA << endl;
590	+	}
591	+	return status;
592	+
593	+	}
594	+
595	+
596	+	//--------------------------------------------------------------------------------------------------
597	+	SelectionStatus muonIsoMVASelection(ControlFlags &ctrl,
598	+	const mithep::Muon * mu,
599	+	const mithep::Vertex * vtx,
600	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
601	+	float rho,
602	+	//const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
603	+	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
604	+	vector<const mithep::Muon*> muonsToVeto,
605	+	vector<const mithep::Electron*> electronsToVeto)
606	+	//--------------------------------------------------------------------------------------------------
607	+	// hacked version
608	+	{
609	+
610	+	if( ctrl.debug ) {
611	+	cout << "muonIsoMVASelection :: muons to veto " << endl;
612	+	for( int i=0; i<muonsToVeto.size(); i++ ) {
613	+	const mithep::Muon * vmu = muonsToVeto[i];
614	+	cout << "\tpt: " << vmu->Pt()
615	+	<< "\teta: " << vmu->Eta()
616	+	<< "\tphi: " << vmu->Phi()
617	+	<< endl;
618	+	}
619	+	cout << "muonIsoMVASelection :: electrson to veto " << endl;
620	+	for( int i=0; i<electronsToVeto.size(); i++ ) {
621	+	const mithep::Electron * vel = electronsToVeto[i];
622	+	cout << "\tpt: " << vel->Pt()
623	+	<< "\teta: " << vel->Eta()
624	+	<< "\tphi: " << vel->Phi()
625	+	<< endl;
626	+	}
627	+	}
628	+	bool failiso=false;
629	+
630	+	//
631	+	// tmp iso rings
632	+	//
633	+	Double_t tmpChargedIso_DR0p0To0p1 = 0;
634	+	Double_t tmpChargedIso_DR0p1To0p2 = 0;
635	+	Double_t tmpChargedIso_DR0p2To0p3 = 0;
636	+	Double_t tmpChargedIso_DR0p3To0p4 = 0;
637	+	Double_t tmpChargedIso_DR0p4To0p5 = 0;
638	+	Double_t tmpChargedIso_DR0p5To0p7 = 0;
639	+
640	+	Double_t tmpGammaIso_DR0p0To0p1 = 0;
641	+	Double_t tmpGammaIso_DR0p1To0p2 = 0;
642	+	Double_t tmpGammaIso_DR0p2To0p3 = 0;
643	+	Double_t tmpGammaIso_DR0p3To0p4 = 0;
644	+	Double_t tmpGammaIso_DR0p4To0p5 = 0;
645	+	Double_t tmpGammaIso_DR0p5To0p7 = 0;
646	+
647	+	Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
648	+	Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
649	+	Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
650	+	Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
651	+	Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
652	+	Double_t tmpNeutralHadronIso_DR0p5To0p7 = 0;
653	+
654	+
655	+
656	+	//
657	+	// final rings for the MVA
658	+	//
659	+	Double_t fChargedIso_DR0p0To0p1;
660	+	Double_t fChargedIso_DR0p1To0p2;
661	+	Double_t fChargedIso_DR0p2To0p3;
662	+	Double_t fChargedIso_DR0p3To0p4;
663	+	Double_t fChargedIso_DR0p4To0p5;
664	+	Double_t fChargedIso_DR0p5To0p7;
665	+
666	+	Double_t fGammaIso_DR0p0To0p1;
667	+	Double_t fGammaIso_DR0p1To0p2;
668	+	Double_t fGammaIso_DR0p2To0p3;
669	+	Double_t fGammaIso_DR0p3To0p4;
670	+	Double_t fGammaIso_DR0p4To0p5;
671	+	Double_t fGammaIso_DR0p5To0p7;
672	+
673	+	Double_t fNeutralHadronIso_DR0p0To0p1;
674	+	Double_t fNeutralHadronIso_DR0p1To0p2;
675	+	Double_t fNeutralHadronIso_DR0p2To0p3;
676	+	Double_t fNeutralHadronIso_DR0p3To0p4;
677	+	Double_t fNeutralHadronIso_DR0p4To0p5;
678	+	Double_t fNeutralHadronIso_DR0p5To0p7;
679	+
680	+
681	+	//
682	+	//Loop over PF Candidates
683	+	//
684	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
685	+
686	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
687	+
688	+	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
689	+
690	+	Double_t deta = (mu->Eta() - pf->Eta());
691	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
692	+	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
693	+	if (dr > 1.0) continue;
694	+
695	+	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
696	+
697	+	//
698	+	// Lepton Footprint Removal
699	+	//
700	+	Bool_t IsLeptonFootprint = kFALSE;
701	+	if (dr < 1.0) {
702	+
703	+	//
704	+	// Check for electrons
705	+	//
706	+	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
707	+	const mithep::Electron *tmpele = electronsToVeto[q];
708	+	// 4l electron
709	+	if( pf->HasTrackerTrk() ) {
710	+	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
711	+	IsLeptonFootprint = kTRUE;
712	+	}
713	+	if( pf->HasGsfTrk() ) {
714	+	if( pf->GsfTrk() == tmpele->GsfTrk() )
715	+	IsLeptonFootprint = kTRUE;
716	+	}
717	+	// PF charged
718	+	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479
719	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
720	+	IsLeptonFootprint = kTRUE;
721	+	// PF gamma
722	+	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
723	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
724	+	IsLeptonFootprint = kTRUE;
725	+	} // loop over electrons
726	+
727	+	/* KH - commented for sync
728	+	//
729	+	// Check for muons
730	+	//
731	+	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
732	+	const mithep::Muon *tmpmu = muonsToVeto[q];
733	+	// 4l muon
734	+	if( pf->HasTrackerTrk() ) {
735	+	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
736	+	IsLeptonFootprint = kTRUE;
737	+	}
738	+	// PF charged
739	+	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
740	+	IsLeptonFootprint = kTRUE;
741	+	} // loop over muons
742	+	*/
743	+
744	+	if (IsLeptonFootprint)
745	+	continue;
746	+
747	+	//
748	+	// Charged Iso Rings
749	+	//
750	+	if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
751	+
752	+	if( dr < 0.01 ) continue; // only for muon iso mva?
753	+	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
754	+
755	+	// if( pf->HasTrackerTrk() ) {
756	+	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
757	+	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
758	+	// << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
759	+	// << dr << endl;
760	+	// }
761	+	// if( pf->HasGsfTrk() ) {
762	+	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
763	+	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
764	+	// << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
765	+	// << dr << endl;
766	+	// }
767	+
768	+	// Footprint Veto
769	+	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
770	+	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
771	+	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
772	+	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
773	+	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
774	+	if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
775	+	}
776	+
777	+	//
778	+	// Gamma Iso Rings
779	+	//
780	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
781	+	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
782	+	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
783	+	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
784	+	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
785	+	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
786	+	if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
787	+	}
788	+
789	+	//
790	+	// Other Neutral Iso Rings
791	+	//
792	+	else {
793	+	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
794	+	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
795	+	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
796	+	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
797	+	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
798	+	if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
799	+	}
800	+
801	+	}
802	+
803	+	}
804	+
805	+	fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
806	+	fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
807	+	fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
808	+	fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
809	+	fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
810	+
811	+
812	+	// double rho = 0;
813	+	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
814	+	// rho = fPUEnergyDensity->At(0)->Rho();
815	+	// if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
816	+	// rho = fPUEnergyDensity->At(0)->RhoLowEta();
817
818	+	// WARNING!!!!
819	+	// hardcode for sync ...
820	+	EffectiveAreaVersion = muT.kMuEAData2011;
821	+	// WARNING!!!!
822	+
823
824	<	fGammaIso_DR0p0To0p1 = max(min((tmpGammaIso_DR0p0To0p1
824	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
825		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p0To0p1,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
826		,2.5)
827		,0.0);
828	<	fGammaIso_DR0p1To0p2 = max(min((tmpGammaIso_DR0p1To0p2
828	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
829		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p1To0p2,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
830		,2.5)
831		,0.0);
832	<	fGammaIso_DR0p2To0p3 = max(min((tmpGammaIso_DR0p2To0p3
832	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
833		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p2To0p3,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
834		,2.5)
835		,0.0);
836	<	fGammaIso_DR0p3To0p4 = max(min((tmpGammaIso_DR0p3To0p4
836	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
837		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p3To0p4,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
838		,2.5)
839		,0.0);
840	<	fGammaIso_DR0p4To0p5 = max(min((tmpGammaIso_DR0p4To0p5
840	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
841		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p4To0p5,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
842		,2.5)
843		,0.0);
844
845
846
847	<	fNeutralHadronIso_DR0p0To0p1 = max(min((tmpNeutralHadronIso_DR0p0To0p1
847	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
848		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p0To0p1,
849		mu->Eta(),EffectiveAreaVersion))/mu->Pt()
850		, 2.5)
851		, 0.0);
852	<	fNeutralHadronIso_DR0p1To0p2 = max(min((tmpNeutralHadronIso_DR0p1To0p2
852	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
853		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p1To0p2,
854		mu->Eta(),EffectiveAreaVersion))/mu->Pt()
855		, 2.5)
856		, 0.0);
857	<	fNeutralHadronIso_DR0p2To0p3 = max(min((tmpNeutralHadronIso_DR0p2To0p3
857	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
858		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p2To0p3,
859		mu->Eta(),EffectiveAreaVersion))/mu->Pt()
860		, 2.5)
861		, 0.0);
862	<	fNeutralHadronIso_DR0p3To0p4 = max(min((tmpNeutralHadronIso_DR0p3To0p4
862	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
863		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p3To0p4,
864		mu->Eta(), EffectiveAreaVersion))/mu->Pt()
865		, 2.5)
866		, 0.0);
867	<	fNeutralHadronIso_DR0p4To0p5 = max(min((tmpNeutralHadronIso_DR0p4To0p5
867	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
868		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p4To0p5,
869		mu->Eta(), EffectiveAreaVersion))/mu->Pt()
870		, 2.5)
#	Line 518 \| Line 872 \| SelectionStatus muonIsoMVASelection(Cont
872
873
874		double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
875	<	mu->Eta(),
876	<	fChargedIso_DR0p0To0p1,
877	<	fChargedIso_DR0p1To0p2,
878	<	fChargedIso_DR0p2To0p3,
879	<	fChargedIso_DR0p3To0p4,
880	<	fChargedIso_DR0p4To0p5,
881	<	fGammaIso_DR0p0To0p1,
882	<	fGammaIso_DR0p1To0p2,
883	<	fGammaIso_DR0p2To0p3,
884	<	fGammaIso_DR0p3To0p4,
885	<	fGammaIso_DR0p4To0p5,
886	<	fNeutralHadronIso_DR0p0To0p1,
887	<	fNeutralHadronIso_DR0p1To0p2,
888	<	fNeutralHadronIso_DR0p2To0p3,
889	<	fNeutralHadronIso_DR0p3To0p4,
890	<	fNeutralHadronIso_DR0p4To0p5,
891	<	ctrl.debug);
875	>	mu->Eta(),
876	>	mu->IsGlobalMuon(),
877	>	mu->IsTrackerMuon(),
878	>	fChargedIso_DR0p0To0p1,
879	>	fChargedIso_DR0p1To0p2,
880	>	fChargedIso_DR0p2To0p3,
881	>	fChargedIso_DR0p3To0p4,
882	>	fChargedIso_DR0p4To0p5,
883	>	fGammaIso_DR0p0To0p1,
884	>	fGammaIso_DR0p1To0p2,
885	>	fGammaIso_DR0p2To0p3,
886	>	fGammaIso_DR0p3To0p4,
887	>	fGammaIso_DR0p4To0p5,
888	>	fNeutralHadronIso_DR0p0To0p1,
889	>	fNeutralHadronIso_DR0p1To0p2,
890	>	fNeutralHadronIso_DR0p2To0p3,
891	>	fNeutralHadronIso_DR0p3To0p4,
892	>	fNeutralHadronIso_DR0p4To0p5,
893	>	ctrl.debug);
894
895		SelectionStatus status;
896		bool pass;
#	Line 552 \| Line 908 \| SelectionStatus muonIsoMVASelection(Cont
908		else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN5) pass = true;
909		if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
910
911	+	/*
912		pass = false;
913		if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
914		&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN0) pass = true;
#	Line 564 \| Line 921 \| SelectionStatus muonIsoMVASelection(Cont
921		else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN4) pass = true;
922		else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN5) pass = true;
923		if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
924	+	*/
925
926		// pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
927
928	<	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
928	>	status.isoMVA = mvaval;
929	>
930	>	if(ctrl.debug) {
931	>	cout << "returning status : " << hex << status.getStatus() << dec << endl;
932	>	cout << "MVAVAL : " << status.isoMVA << endl;
933	>	}
934		return status;
935
936		}
937
938	+
939		//--------------------------------------------------------------------------------------------------
940		void initMuonIsoMVA() {
941		//--------------------------------------------------------------------------------------------------
#	Line 589 \| Line 953 \| void initMuonIsoMVA() {
953		}
954
955
956	+
957	+
958		//--------------------------------------------------------------------------------------------------
959		double muonPFIso04(ControlFlags &ctrl,
960		const mithep::Muon * mu,
961	<	const mithep::Vertex & vtx,
961	>	const mithep::Vertex * vtx,
962		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
963		const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
964		mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
#	Line 600 \| Line 966 \| double muonPFIso04(ControlFlags &ctrl,
966		vector<const mithep::Electron*> electronsToVeto)
967		//--------------------------------------------------------------------------------------------------
968		{
969	+
970	+	extern double gChargedIso;
971	+	extern double gGammaIso;
972	+	extern double gNeutralIso;
973
974		if( ctrl.debug ) {
975		cout << "muonIsoMVASelection :: muons to veto " << endl;
#	Line 631 \| Line 1001 \| double muonPFIso04(ControlFlags &ctrl,
1001		//Loop over PF Candidates
1002		//
1003		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1004	+
1005	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1006		const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1007
1008		Double_t deta = (mu->Eta() - pf->Eta());
#	Line 662 \| Line 1034 \| double muonPFIso04(ControlFlags &ctrl,
1034		}
1035		// PF charged
1036		if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1037	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
1037	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1038	>	if( ctrl.debug) cout << "\tcharged trk, dR ("
1039	>	<< mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta())
1040	>	<< " matches 4L ele ..." << endl;
1041		IsLeptonFootprint = kTRUE;
1042	+	}
1043		// PF gamma
1044		if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1045		&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
1046		IsLeptonFootprint = kTRUE;
1047		} // loop over electrons
1048
1049	<	// KH, comment to sync
674	<	/*
1049	>	/* KH - comment for sync
1050		//
1051		// Check for muons
1052		//
#	Line 694 \| Line 1069 \| double muonPFIso04(ControlFlags &ctrl,
1069		//
1070		// Charged Iso
1071		//
1072	<	if (pf->Charge() != 0 ) {
1072	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1073
1074		//if( dr < 0.01 ) continue; // only for muon iso mva?
1075		if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
1076
1077	<	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	<	}
1077	>
1078	>	// if( pf->HasTrackerTrk() ) {
1079	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1080	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1081	>	// << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1082	>	// << dr << endl;
1083	>	// }
1084	>	// if( pf->HasGsfTrk() ) {
1085	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1086	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1087	>	// << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1088	>	// << dr << endl;
1089	>	// }
1090
1091
1092		fChargedIso += pf->Pt();
#	Line 737 \| Line 1113 \| double muonPFIso04(ControlFlags &ctrl,
1113		}
1114
1115		}
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();
746	–
747	–	// WARNING!!!!
748	–	// hardcode for sync ...
749	–	EffectiveAreaVersion = muT.kMuEAData2011;
750	–	// WARNING!!!!
1116
1117	+	double rho=0;
1118	+	if( (EffectiveAreaVersion == mithep::MuonTools::kMuEAFall11MC) \|\|
1119	+	(EffectiveAreaVersion == mithep::MuonTools::kMuEAData2011) ) {
1120	+	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25()) \|\|
1121	+	isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25())))
1122	+	rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25();
1123	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1124	+	EffectiveAreaVersion = mithep::MuonTools::kMuEAData2011;
1125	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1126	+	} else {
1127	+	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral()) \|\|
1128	+	isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral())))
1129	+	rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral();
1130	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1131	+	EffectiveAreaVersion = mithep::MuonTools::kMuEAData2011;
1132	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1133	+	}
1134	+	if(ctrl.debug) cout << "rho: " << rho << endl;
1135
1136	<	double pfIso = fChargedIso + max(0.0,(fGammaIso + fNeutralHadronIso
1136	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1137		-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1138		mu->Eta(),EffectiveAreaVersion)));
756	–
1139		gChargedIso = fChargedIso;
1140	<	gGammaIso = fGammaIso;
1141	<	gNeutralIso = fNeutralHadronIso;
1140	>	gGammaIso = fGammaIso;
1141	>	gNeutralIso = fNeutralHadronIso;
1142	>
1143		return pfIso;
1144		}
1145
1146
1147	+
1148	+
1149		//--------------------------------------------------------------------------------------------------
1150		// hacked version
1151		double muonPFIso04(ControlFlags &ctrl,
1152		const mithep::Muon * mu,
1153	<	const mithep::Vertex & vtx,
1153	>	const mithep::Vertex * vtx,
1154		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1155		float rho,
1156		mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
#	Line 808 \| Line 1193 \| double muonPFIso04(ControlFlags &ctrl,
1193		//Loop over PF Candidates
1194		//
1195		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1196	+
1197	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1198		const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1199
1200		Double_t deta = (mu->Eta() - pf->Eta());
#	Line 872 \| Line 1259 \| double muonPFIso04(ControlFlags &ctrl,
1259		//
1260		if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1261
1262	<	if( dr < 0.01 ) continue; // only for muon iso mva?
1262	>	//if( dr < 0.01 ) continue; // only for muon iso mva?
1263		if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
1264
1265	<	if( pf->HasTrackerTrk() ) {
1266	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1267	<	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1268	<	<< abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1269	<	<< dr << endl;
1270	<	}
1271	<	if( pf->HasGsfTrk() ) {
1272	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1273	<	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1274	<	<< abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1275	<	<< dr << endl;
1276	<	}
1265	>
1266	>	// if( pf->HasTrackerTrk() ) {
1267	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1268	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1269	>	// << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1270	>	// << dr << endl;
1271	>	// }
1272	>	// if( pf->HasGsfTrk() ) {
1273	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1274	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1275	>	// << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1276	>	// << dr << endl;
1277	>	// }
1278
1279
1280		fChargedIso += pf->Pt();
#	Line 896 \| Line 1284 \| double muonPFIso04(ControlFlags &ctrl,
1284		// Gamma Iso
1285		//
1286		else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1287	+	// KH, add to sync
1288	+	if( pf->Pt() > 0.5 )
1289		fGammaIso += pf->Pt();
1290		}
1291
#	Line 922 \| Line 1312 \| double muonPFIso04(ControlFlags &ctrl,
1312		// WARNING!!!!
1313
1314
1315	<	double pfIso = fChargedIso + max(0.0,(fGammaIso + fNeutralHadronIso
1315	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1316		-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1317		mu->Eta(),EffectiveAreaVersion)));
1318		gChargedIso = fChargedIso;
#	Line 936 \| Line 1326 \| double muonPFIso04(ControlFlags &ctrl,
1326		//--------------------------------------------------------------------------------------------------
1327		SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1328		const mithep::Muon * mu,
1329	<	const mithep::Vertex & vtx,
1329	>	const mithep::Vertex * vtx,
1330		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1331		const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1332		mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
#	Line 949 \| Line 1339 \| SelectionStatus muonReferenceIsoSelectio
1339
1340		double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, fPUEnergyDensity,
1341		EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1342	<	cout << "--------------> setting muon isoPF04 to" << pfIso << endl;
1342	>	// cout << "--------------> setting muon isoPF04 to" << pfIso << endl;
1343		status.isoPF04 = pfIso;
1344		status.chisoPF04 = gChargedIso;
1345		status.gaisoPF04 = gGammaIso;
#	Line 972 \| Line 1362 \| SelectionStatus muonReferenceIsoSelectio
1362		// hacked version
1363		SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1364		const mithep::Muon * mu,
1365	<	const mithep::Vertex & vtx,
1365	>	const mithep::Vertex * vtx,
1366		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1367		float rho,
1368		mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
#	Line 985 \| Line 1375 \| SelectionStatus muonReferenceIsoSelectio
1375
1376		double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, rho,
1377		EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1378	+
1379	+	status.isoPF04 = pfIso;
1380	+	status.chisoPF04 = gChargedIso;
1381	+	status.gaisoPF04 = gGammaIso;
1382	+	status.neisoPF04 = gNeutralIso;
1383	+
1384		bool pass = false;
1385		if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1386
#	Line 999 \| Line 1395 \| SelectionStatus muonReferenceIsoSelectio
1395
1396
1397
1398	+
1399		//--------------------------------------------------------------------------------------------------
1400		SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1401		const mithep::Electron * ele,
1402	<	const mithep::Vertex & vtx,
1402	>	const mithep::Vertex * vtx,
1403		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1404		const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1405		mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
#	Line 1041 \| Line 1438 \| SelectionStatus electronIsoMVASelection(
1438		Double_t tmpChargedIso_DR0p2To0p3 = 0;
1439		Double_t tmpChargedIso_DR0p3To0p4 = 0;
1440		Double_t tmpChargedIso_DR0p4To0p5 = 0;
1044	–	Double_t tmpChargedIso_DR0p5To0p7 = 0;
1441
1442		Double_t tmpGammaIso_DR0p0To0p1 = 0;
1443		Double_t tmpGammaIso_DR0p1To0p2 = 0;
1444		Double_t tmpGammaIso_DR0p2To0p3 = 0;
1445		Double_t tmpGammaIso_DR0p3To0p4 = 0;
1446		Double_t tmpGammaIso_DR0p4To0p5 = 0;
1447	<	Double_t tmpGammaIso_DR0p5To0p7 = 0;
1447	>
1448
1449		Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
1450		Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
1451		Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
1452		Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
1453		Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
1058	–	Double_t tmpNeutralHadronIso_DR0p5To0p7 = 0;
1454
1455
1456
#	Line 1085 \| Line 1480 \| SelectionStatus electronIsoMVASelection(
1480		//Loop over PF Candidates
1481		//
1482		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1483	+
1484	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1485	+
1486		const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1487		Double_t deta = (ele->Eta() - pf->Eta());
1488		Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1489		Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1490	<	if (dr >= 0.5) continue;
1490	>	if (dr > 1.0) continue;
1491	>
1492		if(ctrl.debug) {
1493		cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1494	<	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
1494	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1495		cout << endl;
1496		}
1497
#	Line 1107 \| Line 1506 \| SelectionStatus electronIsoMVASelection(
1506		Bool_t IsLeptonFootprint = kFALSE;
1507		if (dr < 1.0) {
1508
1509	+
1510		//
1511		// Check for electrons
1512		//
1513	+
1514		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1515		const mithep::Electron *tmpele = electronsToVeto[q];
1516	+	double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1517	+
1518		// 4l electron
1519		if( pf->HasTrackerTrk() ) {
1520		if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
#	Line 1126 \| Line 1529 \| SelectionStatus electronIsoMVASelection(
1529		}
1530		}
1531		// PF charged
1532	<	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1130	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1532	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1533		if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1534		IsLeptonFootprint = kTRUE;
1535		}
1536		// PF gamma
1537	<	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1538	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
1537	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1538	>	&& tmpdr < 0.08) {
1539		if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1540		IsLeptonFootprint = kTRUE;
1541		}
1542		} // loop over electrons
1543
1544	+
1545		/* KH - comment for sync
1546		//
1547		// Check for muons
#	Line 1168 \| Line 1571 \| SelectionStatus electronIsoMVASelection(
1571		//
1572		if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1573
1574	<	if( pf->HasTrackerTrk() )
1575	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1576	<	if( pf->HasGsfTrk() )
1577	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1574	>	// if( pf->HasGsfTrk() ) {
1575	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1576	>	// } else if( pf->HasTrackerTrk() ){
1577	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1578	>	// }
1579
1580		// Veto any PFmuon, or PFEle
1581		if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
#	Line 1188 \| Line 1592 \| SelectionStatus electronIsoMVASelection(
1592		if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1593		if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1594		if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
1191	–	if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
1595
1596		}
1597
#	Line 1197 \| Line 1600 \| SelectionStatus electronIsoMVASelection(
1600		//
1601		else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1602
1603	<	if (fabs(ele->SCluster()->Eta()) > 1.479) {
1201	<	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
1202	<	}
1603	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
1604
1605		if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1606		<< dr << endl;
#	Line 1209 \| Line 1610 \| SelectionStatus electronIsoMVASelection(
1610		if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1611		if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1612		if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
1212	–	if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
1213	–
1613		}
1614
1615		//
#	Line 1224 \| Line 1623 \| SelectionStatus electronIsoMVASelection(
1623		if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1624		if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1625		if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1227	–	if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
1626		}
1627
1628		}
1629
1630		}
1631
1632	<	fChargedIso_DR0p0To0p1 = min((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1633	<	fChargedIso_DR0p1To0p2 = min((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1634	<	fChargedIso_DR0p2To0p3 = min((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1635	<	fChargedIso_DR0p3To0p4 = min((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1636	<	fChargedIso_DR0p4To0p5 = min((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1632	>	fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1633	>	fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1634	>	fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1635	>	fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1636	>	fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1637	>
1638	>	if(ctrl.debug) {
1639	>	cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1 << endl;
1640	>	cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2 << endl;
1641	>	cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3 << endl;
1642	>	cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4 << endl;
1643	>	cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5 << endl;
1644	>	}
1645	>
1646
1647		double rho = 0;
1648		if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
1649		rho = fPUEnergyDensity->At(0)->Rho();
1650	+	// if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1651	+	// rho = fPUEnergyDensity->At(0)->RhoLowEta();
1652	+
1653	+	// WARNING!!!!
1654	+	// hardcode for sync ...
1655	+	EffectiveAreaVersion = eleT.kEleEAData2011;
1656	+	// WARNING!!!!
1657
1658		if( ctrl.debug) {
1659		cout << "RHO: " << rho << endl;
#	Line 1263 \| Line 1677 \| SelectionStatus electronIsoMVASelection(
1677		<< endl;
1678		}
1679
1680	<	fGammaIso_DR0p0To0p1 = max(min((tmpGammaIso_DR0p0To0p1
1680	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
1681		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
1682		ele->SCluster()->Eta(),
1683		EffectiveAreaVersion))/ele->Pt()
1684		,2.5)
1685		,0.0);
1686	<	fGammaIso_DR0p1To0p2 = max(min((tmpGammaIso_DR0p1To0p2
1686	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
1687		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
1688		ele->SCluster()->Eta(),
1689		EffectiveAreaVersion))/ele->Pt()
1690		,2.5)
1691		,0.0);
1692	<	fGammaIso_DR0p2To0p3 = max(min((tmpGammaIso_DR0p2To0p3
1692	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
1693		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
1694		ele->SCluster()->Eta()
1695		,EffectiveAreaVersion))/ele->Pt()
1696		,2.5)
1697		,0.0);
1698	<	fGammaIso_DR0p3To0p4 = max(min((tmpGammaIso_DR0p3To0p4
1698	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
1699		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
1700		ele->SCluster()->Eta(),
1701		EffectiveAreaVersion))/ele->Pt()
1702		,2.5)
1703		,0.0);
1704	<	fGammaIso_DR0p4To0p5 = max(min((tmpGammaIso_DR0p4To0p5
1704	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
1705		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
1706		ele->SCluster()->Eta(),
1707		EffectiveAreaVersion))/ele->Pt()
#	Line 1295 \| Line 1709 \| SelectionStatus electronIsoMVASelection(
1709		,0.0);
1710
1711
1712	<	fNeutralHadronIso_DR0p0To0p1 = max(min((tmpNeutralHadronIso_DR0p0To0p1
1712	>	if( ctrl.debug) {
1713	>	cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
1714	>	cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
1715	>	cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
1716	>	cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
1717	>	cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
1718	>	}
1719	>
1720	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
1721		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1722		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1723		, 2.5)
1724		, 0.0);
1725	<	fNeutralHadronIso_DR0p1To0p2 = max(min((tmpNeutralHadronIso_DR0p1To0p2
1725	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
1726		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1727		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1728		, 2.5)
1729		, 0.0);
1730	<	fNeutralHadronIso_DR0p2To0p3 = max(min((tmpNeutralHadronIso_DR0p2To0p3
1730	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
1731		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1732		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1733		, 2.5)
1734		, 0.0);
1735	<	fNeutralHadronIso_DR0p3To0p4 = max(min((tmpNeutralHadronIso_DR0p3To0p4
1735	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
1736		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1737		ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1738		, 2.5)
1739		, 0.0);
1740	<	fNeutralHadronIso_DR0p4To0p5 = max(min((tmpNeutralHadronIso_DR0p4To0p5
1740	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
1741		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
1742		ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1743		, 2.5)
1744		, 0.0);
1745
1746	+	if( ctrl.debug) {
1747	+	cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
1748	+	cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
1749	+	cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
1750	+	cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
1751	+	cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
1752	+	}
1753	+
1754		double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
1755		ele->SCluster()->Eta(),
1756		fChargedIso_DR0p0To0p1,
#	Line 1341 \| Line 1771 \| SelectionStatus electronIsoMVASelection(
1771		ctrl.debug);
1772
1773		SelectionStatus status;
1774	+	status.isoMVA = mvaval;
1775		bool pass = false;
1776
1777		Int_t subdet = 0;
1778		if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
1779		else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
1780		else subdet = 2;
1781	+
1782		Int_t ptBin = 0;
1783	<	if (ele->Pt() > 10.0) ptBin = 1;
1783	>	if (ele->Pt() >= 10.0) ptBin = 1;
1784	>
1785	>	Int_t MVABin = -1;
1786	>	if (subdet == 0 && ptBin == 0) MVABin = 0;
1787	>	if (subdet == 1 && ptBin == 0) MVABin = 1;
1788	>	if (subdet == 2 && ptBin == 0) MVABin = 2;
1789	>	if (subdet == 0 && ptBin == 1) MVABin = 3;
1790	>	if (subdet == 1 && ptBin == 1) MVABin = 4;
1791	>	if (subdet == 2 && ptBin == 1) MVABin = 5;
1792	>
1793	>	pass = false;
1794	>	if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN0 ) pass = true;
1795	>	if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN1 ) pass = true;
1796	>	if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN2 ) pass = true;
1797	>	if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN3 ) pass = true;
1798	>	if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN4 ) pass = true;
1799	>	if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN5 ) pass = true;
1800	>	// pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
1801	>	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
1802	>
1803	>	// pass = false;
1804	>	// if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
1805	>	// if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
1806	>	// if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
1807	>	// if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
1808	>	// if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
1809	>	// if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
1810	>	// if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
1811	>
1812	>	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1813	>	return status;
1814	>
1815	>	}
1816	>
1817	>
1818	>	//--------------------------------------------------------------------------------------------------
1819	>	SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1820	>	const mithep::Electron * ele,
1821	>	const mithep::Vertex * vtx,
1822	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1823	>	float rho,
1824	>	//const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1825	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1826	>	vector<const mithep::Muon*> muonsToVeto,
1827	>	vector<const mithep::Electron*> electronsToVeto)
1828	>	//--------------------------------------------------------------------------------------------------
1829	>	// hacked version
1830	>	{
1831	>	if( ctrl.debug ) {
1832	>	cout << "================> hacked ele Iso MVA <======================" << endl;
1833	>	}
1834	>
1835	>	if( ctrl.debug ) {
1836	>	cout << "electronIsoMVASelection :: muons to veto " << endl;
1837	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
1838	>	const mithep::Muon * vmu = muonsToVeto[i];
1839	>	cout << "\tpt: " << vmu->Pt()
1840	>	<< "\teta: " << vmu->Eta()
1841	>	<< "\tphi: " << vmu->Phi()
1842	>	<< endl;
1843	>	}
1844	>	cout << "electronIsoMVASelection :: electrson to veto " << endl;
1845	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
1846	>	const mithep::Electron * vel = electronsToVeto[i];
1847	>	cout << "\tpt: " << vel->Pt()
1848	>	<< "\teta: " << vel->Eta()
1849	>	<< "\tphi: " << vel->Phi()
1850	>	<< "\ttrk: " << vel->TrackerTrk()
1851	>	<< endl;
1852	>	}
1853	>	}
1854	>
1855	>	bool failiso=false;
1856	>
1857	>	//
1858	>	// tmp iso rings
1859	>	//
1860	>	Double_t tmpChargedIso_DR0p0To0p1 = 0;
1861	>	Double_t tmpChargedIso_DR0p1To0p2 = 0;
1862	>	Double_t tmpChargedIso_DR0p2To0p3 = 0;
1863	>	Double_t tmpChargedIso_DR0p3To0p4 = 0;
1864	>	Double_t tmpChargedIso_DR0p4To0p5 = 0;
1865	>
1866	>	Double_t tmpGammaIso_DR0p0To0p1 = 0;
1867	>	Double_t tmpGammaIso_DR0p1To0p2 = 0;
1868	>	Double_t tmpGammaIso_DR0p2To0p3 = 0;
1869	>	Double_t tmpGammaIso_DR0p3To0p4 = 0;
1870	>	Double_t tmpGammaIso_DR0p4To0p5 = 0;
1871	>
1872	>
1873	>	Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
1874	>	Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
1875	>	Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
1876	>	Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
1877	>	Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
1878	>
1879	>
1880	>
1881	>	//
1882	>	// final rings for the MVA
1883	>	//
1884	>	Double_t fChargedIso_DR0p0To0p1;
1885	>	Double_t fChargedIso_DR0p1To0p2;
1886	>	Double_t fChargedIso_DR0p2To0p3;
1887	>	Double_t fChargedIso_DR0p3To0p4;
1888	>	Double_t fChargedIso_DR0p4To0p5;
1889	>
1890	>	Double_t fGammaIso_DR0p0To0p1;
1891	>	Double_t fGammaIso_DR0p1To0p2;
1892	>	Double_t fGammaIso_DR0p2To0p3;
1893	>	Double_t fGammaIso_DR0p3To0p4;
1894	>	Double_t fGammaIso_DR0p4To0p5;
1895	>
1896	>	Double_t fNeutralHadronIso_DR0p0To0p1;
1897	>	Double_t fNeutralHadronIso_DR0p1To0p2;
1898	>	Double_t fNeutralHadronIso_DR0p2To0p3;
1899	>	Double_t fNeutralHadronIso_DR0p3To0p4;
1900	>	Double_t fNeutralHadronIso_DR0p4To0p5;
1901	>
1902	>
1903	>	//
1904	>	//Loop over PF Candidates
1905	>	//
1906	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1907	>
1908	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1909	>
1910	>	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1911	>	Double_t deta = (ele->Eta() - pf->Eta());
1912	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1913	>	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1914	>	if (dr > 1.0) continue;
1915	>
1916	>	if(ctrl.debug) {
1917	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1918	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1919	>	cout << endl;
1920	>	}
1921	>
1922	>
1923	>	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
1924	>	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1925	>
1926	>
1927	>	//
1928	>	// Lepton Footprint Removal
1929	>	//
1930	>	Bool_t IsLeptonFootprint = kFALSE;
1931	>	if (dr < 1.0) {
1932	>
1933	>
1934	>	//
1935	>	// Check for electrons
1936	>	//
1937	>
1938	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1939	>	const mithep::Electron *tmpele = electronsToVeto[q];
1940	>	double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1941	>
1942	>	// 4l electron
1943	>	if( pf->HasTrackerTrk() ) {
1944	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1945	>	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1946	>	IsLeptonFootprint = kTRUE;
1947	>	}
1948	>	}
1949	>	if( pf->HasGsfTrk() ) {
1950	>	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1951	>	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1952	>	IsLeptonFootprint = kTRUE;
1953	>	}
1954	>	}
1955	>	// PF charged
1956	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1957	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1958	>	IsLeptonFootprint = kTRUE;
1959	>	}
1960	>	// PF gamma
1961	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1962	>	&& tmpdr < 0.08) {
1963	>	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1964	>	IsLeptonFootprint = kTRUE;
1965	>	}
1966	>	} // loop over electrons
1967	>
1968	>
1969	>	/* KH - comment for sync
1970	>	//
1971	>	// Check for muons
1972	>	//
1973	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1974	>	const mithep::Muon *tmpmu = muonsToVeto[q];
1975	>	// 4l muon
1976	>	if( pf->HasTrackerTrk() ) {
1977	>	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1978	>	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1979	>	IsLeptonFootprint = kTRUE;
1980	>	}
1981	>	}
1982	>	// PF charged
1983	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1984	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1985	>	IsLeptonFootprint = kTRUE;
1986	>	}
1987	>	} // loop over muons
1988	>	*/
1989	>
1990	>	if (IsLeptonFootprint)
1991	>	continue;
1992	>
1993	>	//
1994	>	// Charged Iso Rings
1995	>	//
1996	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1997	>
1998	>	// if( pf->HasGsfTrk() ) {
1999	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2000	>	// } else if( pf->HasTrackerTrk() ){
2001	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2002	>	// }
2003	>
2004	>	// Veto any PFmuon, or PFEle
2005	>	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
2006	>
2007	>	// Footprint Veto
2008	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
2009	>
2010	>	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
2011	>	<< "\ttype: " << pf->PFType()
2012	>	<< "\ttrk: " << pf->TrackerTrk() << endl;
2013	>
2014	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
2015	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
2016	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
2017	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
2018	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
2019	>
2020	>	}
2021	>
2022	>	//
2023	>	// Gamma Iso Rings
2024	>	//
2025	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2026	>
2027	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
2028	>
2029	>	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2030	>	<< dr << endl;
2031	>
2032	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
2033	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
2034	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
2035	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
2036	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
2037	>	}
2038	>
2039	>	//
2040	>	// Other Neutral Iso Rings
2041	>	//
2042	>	else {
2043	>	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2044	>	<< dr << endl;
2045	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
2046	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
2047	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
2048	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
2049	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
2050	>	}
2051	>
2052	>	}
2053	>
2054	>	}
2055	>
2056	>	fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
2057	>	fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
2058	>	fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
2059	>	fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
2060	>	fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
2061	>
2062	>	if(ctrl.debug) {
2063	>	cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1 << endl;
2064	>	cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2 << endl;
2065	>	cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3 << endl;
2066	>	cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4 << endl;
2067	>	cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5 << endl;
2068	>	}
2069	>
2070	>
2071	>	// rho=0;
2072	>	// double rho = 0;
2073	>	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
2074	>	// rho = fPUEnergyDensity->At(0)->Rho();
2075	>	// if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
2076	>	// rho = fPUEnergyDensity->At(0)->RhoLowEta();
2077	>
2078	>	// WARNING!!!!
2079	>	// hardcode for sync ...
2080	>	EffectiveAreaVersion = eleT.kEleEAData2011;
2081	>	// WARNING!!!!
2082	>
2083	>	if( ctrl.debug) {
2084	>	cout << "RHO: " << rho << endl;
2085	>	cout << "eta: " << ele->SCluster()->Eta() << endl;
2086	>	cout << "target: " << EffectiveAreaVersion << endl;
2087	>	cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
2088	>	ele->SCluster()->Eta(),
2089	>	EffectiveAreaVersion)
2090	>	<< endl;
2091	>	cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
2092	>	ele->SCluster()->Eta(),
2093	>	EffectiveAreaVersion)
2094	>	<< endl;
2095	>	cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
2096	>	ele->SCluster()->Eta(),
2097	>	EffectiveAreaVersion)
2098	>	<< endl;
2099	>	cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
2100	>	ele->SCluster()->Eta(),
2101	>	EffectiveAreaVersion)
2102	>	<< endl;
2103	>	}
2104	>
2105	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
2106	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
2107	>	ele->SCluster()->Eta(),
2108	>	EffectiveAreaVersion))/ele->Pt()
2109	>	,2.5)
2110	>	,0.0);
2111	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
2112	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
2113	>	ele->SCluster()->Eta(),
2114	>	EffectiveAreaVersion))/ele->Pt()
2115	>	,2.5)
2116	>	,0.0);
2117	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
2118	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
2119	>	ele->SCluster()->Eta()
2120	>	,EffectiveAreaVersion))/ele->Pt()
2121	>	,2.5)
2122	>	,0.0);
2123	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
2124	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
2125	>	ele->SCluster()->Eta(),
2126	>	EffectiveAreaVersion))/ele->Pt()
2127	>	,2.5)
2128	>	,0.0);
2129	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
2130	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
2131	>	ele->SCluster()->Eta(),
2132	>	EffectiveAreaVersion))/ele->Pt()
2133	>	,2.5)
2134	>	,0.0);
2135	>
2136	>
2137	>	if( ctrl.debug) {
2138	>	cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
2139	>	cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
2140	>	cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
2141	>	cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
2142	>	cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
2143	>	}
2144	>
2145	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
2146	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
2147	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2148	>	, 2.5)
2149	>	, 0.0);
2150	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
2151	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
2152	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2153	>	, 2.5)
2154	>	, 0.0);
2155	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
2156	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
2157	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2158	>	, 2.5)
2159	>	, 0.0);
2160	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
2161	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
2162	>	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2163	>	, 2.5)
2164	>	, 0.0);
2165	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
2166	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
2167	>	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2168	>	, 2.5)
2169	>	, 0.0);
2170	>
2171	>	if( ctrl.debug) {
2172	>	cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
2173	>	cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
2174	>	cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
2175	>	cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
2176	>	cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
2177	>	}
2178	>
2179	>	double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
2180	>	ele->SCluster()->Eta(),
2181	>	fChargedIso_DR0p0To0p1,
2182	>	fChargedIso_DR0p1To0p2,
2183	>	fChargedIso_DR0p2To0p3,
2184	>	fChargedIso_DR0p3To0p4,
2185	>	fChargedIso_DR0p4To0p5,
2186	>	fGammaIso_DR0p0To0p1,
2187	>	fGammaIso_DR0p1To0p2,
2188	>	fGammaIso_DR0p2To0p3,
2189	>	fGammaIso_DR0p3To0p4,
2190	>	fGammaIso_DR0p4To0p5,
2191	>	fNeutralHadronIso_DR0p0To0p1,
2192	>	fNeutralHadronIso_DR0p1To0p2,
2193	>	fNeutralHadronIso_DR0p2To0p3,
2194	>	fNeutralHadronIso_DR0p3To0p4,
2195	>	fNeutralHadronIso_DR0p4To0p5,
2196	>	ctrl.debug);
2197	>
2198	>	SelectionStatus status;
2199	>	status.isoMVA = mvaval;
2200	>	bool pass = false;
2201	>
2202	>	Int_t subdet = 0;
2203	>	if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
2204	>	else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
2205	>	else subdet = 2;
2206	>
2207	>	Int_t ptBin = 0;
2208	>	if (ele->Pt() >= 10.0) ptBin = 1;
2209
2210		Int_t MVABin = -1;
2211		if (subdet == 0 && ptBin == 0) MVABin = 0;
#	Line 1367 \| Line 2224 \| SelectionStatus electronIsoMVASelection(
2224		if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN5 ) pass = true;
2225		if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
2226
2227	<	pass = false;
2228	<	if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
2229	<	if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
2230	<	if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
2231	<	if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
2232	<	if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
2233	<	if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
2234	<	if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
2227	>	// pass = false;
2228	>	// if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
2229	>	// if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
2230	>	// if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
2231	>	// if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
2232	>	// if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
2233	>	// if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
2234	>	// if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
2235
2236		if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2237		return status;
#	Line 1398 \| Line 2255 \| void initElectronIsoMVA() {
2255
2256
2257
2258	+
2259		//--------------------------------------------------------------------------------------------------
2260		float electronPFIso04(ControlFlags &ctrl,
2261	<	const mithep::Electron * ele,
2262	<	const mithep::Vertex & vtx,
2263	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2264	<	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2265	<	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2266	<	vector<const mithep::Muon*> muonsToVeto,
2267	<	vector<const mithep::Electron*> electronsToVeto)
2261	>	const mithep::Electron * ele,
2262	>	const mithep::Vertex * vtx,
2263	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2264	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2265	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2266	>	vector<const mithep::Muon*> muonsToVeto,
2267	>	vector<const mithep::Electron*> electronsToVeto)
2268		//--------------------------------------------------------------------------------------------------
2269		{
2270	<
2270	>	/*
2271		if( ctrl.debug ) {
2272		cout << "electronIsoMVASelection :: muons to veto " << endl;
2273		for( int i=0; i<muonsToVeto.size(); i++ ) {
#	Line 1419 \| Line 2277 \| float electronPFIso04(ControlFlags &ctrl
2277		<< "\tphi: " << vmu->Phi()
2278		<< endl;
2279		}
2280	<	cout << "electronIsoMVASelection :: electrson to veto " << endl;
2280	>	cout << "electronIsoMVASelection :: electrons to veto " << endl;
2281		for( int i=0; i<electronsToVeto.size(); i++ ) {
2282		const mithep::Electron * vel = electronsToVeto[i];
2283		cout << "\tpt: " << vel->Pt()
#	Line 1429 \| Line 2287 \| float electronPFIso04(ControlFlags &ctrl
2287		<< endl;
2288		}
2289		}
2290	<
2290	>	*/
2291
2292		//
2293		// final iso
#	Line 1443 \| Line 2301 \| float electronPFIso04(ControlFlags &ctrl
2301		//Loop over PF Candidates
2302		//
2303		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2304	+
2305	+
2306		const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
2307		Double_t deta = (ele->Eta() - pf->Eta());
2308		Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2309		Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2310	<	if (dr >= 0.4) continue;
2310	>
2311	>	if (dr > 0.4) continue;
2312	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2313	>
2314		if(ctrl.debug) {
2315	<	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
2316	<	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
2315	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2316	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
2317	>	<< "\ttrk: " << pf->HasTrackerTrk()
2318	>	<< "\tgsf: " << pf->HasGsfTrk();
2319	>
2320		cout << endl;
2321		}
2322
2323
2324	<	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
2325	<	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
2326	<
2324	>	//
2325	>	// sync : I don't think theyre doing this ...
2326	>	//
2327	>	// if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
2328	>	// (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2329	>	// if( ctrl.debug ) cout << "\tskipping, matches to the electron ..." << endl;
2330	>	// continue;
2331	>	// }
2332	>
2333
2334		//
2335		// Lepton Footprint Removal
#	Line 1470 \| Line 2342 \| float electronPFIso04(ControlFlags &ctrl
2342		//
2343		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2344		const mithep::Electron *tmpele = electronsToVeto[q];
2345	+	/*
2346		// 4l electron
2347		if( pf->HasTrackerTrk() ) {
2348		if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
#	Line 1483 \| Line 2356 \| float electronPFIso04(ControlFlags &ctrl
2356		IsLeptonFootprint = kTRUE;
2357		}
2358		}
2359	+	*/
2360		// PF charged
2361		if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2362		&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
#	Line 1497 \| Line 2371 \| float electronPFIso04(ControlFlags &ctrl
2371		}
2372		} // loop over electrons
2373
2374	<
2374	>	/* KH - comment for sync
2375		//
2376		// Check for muons
2377		//
#	Line 1516 \| Line 2390 \| float electronPFIso04(ControlFlags &ctrl
2390		IsLeptonFootprint = kTRUE;
2391		}
2392		} // loop over muons
2393	<
2393	>	*/
2394
2395		if (IsLeptonFootprint)
2396		continue;
#	Line 1524 \| Line 2398 \| float electronPFIso04(ControlFlags &ctrl
2398		//
2399		// Charged Iso
2400		//
2401	<	if (pf->Charge() != 0 ) {
2401	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
2402
2403	<	if( pf->HasTrackerTrk() )
2404	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2405	<	if( pf->HasGsfTrk() )
2406	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2403	>	// if( pf->HasTrackerTrk() )
2404	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2405	>	// if( pf->HasGsfTrk() )
2406	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2407
2408		// Veto any PFmuon, or PFEle
2409	<	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
2409	>	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) {
2410	>	if( ctrl.debug ) cout << "\t skipping, pf is and ele or mu .." <<endl;
2411	>	continue;
2412	>	}
2413
2414		// Footprint Veto
2415		if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
#	Line 1554 \| Line 2431 \| float electronPFIso04(ControlFlags &ctrl
2431		}
2432		if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2433		<< dr << endl;
2434	<	fGammaIso += pf->Pt();
2434	>	// KH, add to sync
2435	>	// if( pf->Pt() > 0.5 )
2436	>	fGammaIso += pf->Pt();
2437		}
2438
2439		//
#	Line 1563 \| Line 2442 \| float electronPFIso04(ControlFlags &ctrl
2442		else {
2443		if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2444		<< dr << endl;
2445	+	// KH, add to sync
2446	+	// if( pf->Pt() > 0.5 )
2447		fNeutralHadronIso += pf->Pt();
2448		}
2449
#	Line 1570 \| Line 2451 \| float electronPFIso04(ControlFlags &ctrl
2451
2452		}
2453
1573	–	double rho = 0;
1574	–	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
1575	–	// rho = fPUEnergyDensity->At(0)->Rho();
1576	–	if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1577	–	rho = fPUEnergyDensity->At(0)->RhoLowEta();
1578	–
1579	–	// WARNING!!!!
1580	–	// hardcode for sync ...
1581	–	EffectiveAreaVersion = eleT.kEleEAData2011;
1582	–	// WARNING!!!!
2454
2455	+	double rho=0;
2456	+	if( (EffectiveAreaVersion == mithep::ElectronTools::kEleEAFall11MC) \|\|
2457	+	(EffectiveAreaVersion == mithep::ElectronTools::kEleEAData2011) ) {
2458	+	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25()) \|\|
2459	+	isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25())))
2460	+	rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25();
2461	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2462	+	EffectiveAreaVersion = mithep::ElectronTools::kEleEAData2011;
2463	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2464	+	} else {
2465	+	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJets()) \|\|
2466	+	isinf(fPUEnergyDensity->At(0)->RhoKt6PFJets())))
2467	+	rho = fPUEnergyDensity->At(0)->RhoKt6PFJets();
2468	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2469	+	EffectiveAreaVersion = mithep::ElectronTools::kEleEAData2011;
2470	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2471	+	}
2472	+	if(ctrl.debug) cout << "rho: " << rho << endl;
2473	+
2474	+	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2475	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2476	+	ele->Eta(),EffectiveAreaVersion)));
2477
1585	–	double pfIso = fChargedIso +
1586	–	max(0.0,fGammaIso -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIso04,
1587	–	ele->Eta(),EffectiveAreaVersion)) +
1588	–	max(0.0,fNeutralHadronIso -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIso04,
1589	–	ele->Eta(),EffectiveAreaVersion)) ;
2478
2479		gChargedIso = fChargedIso;
2480		gGammaIso = fGammaIso;
2481		gNeutralIso = fNeutralHadronIso;
1594	–
2482		return pfIso;
2483		}
2484
2485	+
2486	+
2487		//--------------------------------------------------------------------------------------------------
2488		// hacked version
2489		float electronPFIso04(ControlFlags &ctrl,
2490		const mithep::Electron * ele,
2491	<	const mithep::Vertex & vtx,
2491	>	const mithep::Vertex * vtx,
2492		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2493		float rho,
2494		mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
#	Line 1617 \| Line 2506 \| float electronPFIso04(ControlFlags &ctrl
2506		<< "\tphi: " << vmu->Phi()
2507		<< endl;
2508		}
2509	<	cout << "electronIsoMVASelection :: electrson to veto " << endl;
2509	>	cout << "electronIsoMVASelection :: electrons to veto " << endl;
2510		for( int i=0; i<electronsToVeto.size(); i++ ) {
2511		const mithep::Electron * vel = electronsToVeto[i];
2512		cout << "\tpt: " << vel->Pt()
#	Line 1641 \| Line 2530 \| float electronPFIso04(ControlFlags &ctrl
2530		//Loop over PF Candidates
2531		//
2532		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2533	+
2534	+
2535		const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
2536		Double_t deta = (ele->Eta() - pf->Eta());
2537		Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2538		Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2539	<	if (dr >= 0.4) continue;
2539	>
2540	>	if (dr > 0.4) continue;
2541	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2542	>
2543		if(ctrl.debug) {
2544	<	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
2545	<	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
2544	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2545	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
2546	>	<< "\ttrk: " << pf->HasTrackerTrk()
2547	>	<< "\tgsf: " << pf->HasGsfTrk();
2548	>
2549		cout << endl;
2550		}
2551
2552
2553	<	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
2554	<	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
2555	<
2553	>	//
2554	>	// sync : I don't think theyre doing this ...
2555	>	//
2556	>	// if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
2557	>	// (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2558	>	// if( ctrl.debug ) cout << "\tskipping, matches to the electron ..." << endl;
2559	>	// continue;
2560	>	// }
2561	>
2562
2563		//
2564		// Lepton Footprint Removal
#	Line 1668 \| Line 2571 \| float electronPFIso04(ControlFlags &ctrl
2571		//
2572		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2573		const mithep::Electron *tmpele = electronsToVeto[q];
2574	+	/*
2575		// 4l electron
2576		if( pf->HasTrackerTrk() ) {
2577		if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
#	Line 1681 \| Line 2585 \| float electronPFIso04(ControlFlags &ctrl
2585		IsLeptonFootprint = kTRUE;
2586		}
2587		}
2588	+	*/
2589		// PF charged
2590		if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2591		&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
#	Line 1724 \| Line 2629 \| float electronPFIso04(ControlFlags &ctrl
2629		//
2630		if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
2631
2632	<	if( pf->HasTrackerTrk() )
2633	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2634	<	if( pf->HasGsfTrk() )
2635	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2632	>	// if( pf->HasTrackerTrk() )
2633	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2634	>	// if( pf->HasGsfTrk() )
2635	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2636
2637		// Veto any PFmuon, or PFEle
2638	<	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
2638	>	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) {
2639	>	if( ctrl.debug ) cout << "\t skipping, pf is and ele or mu .." <<endl;
2640	>	continue;
2641	>	}
2642
2643		// Footprint Veto
2644		if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
#	Line 1752 \| Line 2660 \| float electronPFIso04(ControlFlags &ctrl
2660		}
2661		if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2662		<< dr << endl;
2663	<	fGammaIso += pf->Pt();
2663	>	// KH, add to sync
2664	>	// if( pf->Pt() > 0.5 )
2665	>	fGammaIso += pf->Pt();
2666		}
2667
2668		//
#	Line 1762 \| Line 2672 \| float electronPFIso04(ControlFlags &ctrl
2672		if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2673		<< dr << endl;
2674		// KH, add to sync
2675	<	if( pf->Pt() > 0.5 )
2675	>	// if( pf->Pt() > 0.5 )
2676		fNeutralHadronIso += pf->Pt();
2677		}
2678
#	Line 1780 \| Line 2690 \| float electronPFIso04(ControlFlags &ctrl
2690		// WARNING!!!!
2691
2692
2693	<	double pfIso = fChargedIso +
2694	<	max(0.0,fGammaIso -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIso04,
2695	<	ele->Eta(),EffectiveAreaVersion)) +
2696	<	max(0.0,fNeutralHadronIso -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIso04,
2697	<	ele->Eta(),EffectiveAreaVersion)) ;
2693	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2694	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2695	>	ele->Eta(),EffectiveAreaVersion)));
2696	>
2697	>
2698	>	gChargedIso = fChargedIso;
2699	>	gGammaIso = fGammaIso;
2700	>	gNeutralIso = fNeutralHadronIso;
2701		return pfIso;
2702		}
2703
#	Line 1792 \| Line 2705 \| float electronPFIso04(ControlFlags &ctrl
2705		//--------------------------------------------------------------------------------------------------
2706		SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2707		const mithep::Electron * ele,
2708	<	const mithep::Vertex & vtx,
2708	>	const mithep::Vertex * vtx,
2709		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2710		const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2711		mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
#	Line 1805 \| Line 2718 \| SelectionStatus electronReferenceIsoSele
2718
2719		double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, fPUEnergyDensity,
2720		EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2721	<	cout << "--------------> setting electron isoPF04 to " << pfIso << endl;
2721	>	// cout << "--------------> setting electron isoPF04 to " << pfIso << endl;
2722		status.isoPF04 = pfIso;
2723		status.chisoPF04 = gChargedIso;
2724		status.gaisoPF04 = gGammaIso;
#	Line 1828 \| Line 2741 \| SelectionStatus electronReferenceIsoSele
2741		// hacked version
2742		SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2743		const mithep::Electron * ele,
2744	<	const mithep::Vertex & vtx,
2744	>	const mithep::Vertex * vtx,
2745		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2746		float rho,
2747		mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
#	Line 1841 \| Line 2754 \| SelectionStatus electronReferenceIsoSele
2754
2755		double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, rho,
2756		EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2757	+	status.isoPF04 = pfIso;
2758	+	status.chisoPF04 = gChargedIso;
2759	+	status.gaisoPF04 = gGammaIso;
2760	+	status.neisoPF04 = gNeutralIso;
2761		bool pass = false;
2762		if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2763

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.27 by khahn, Mon May 28 16:34:44 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.27 by khahn, Mon May 28 16:34:44 2012 UTC