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

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents):
Revision 1.11 by khahn, Sat May 5 21:43:54 2012 UTC vs.
Revision 1.29 by khahn, Sun Jun 3 15:51:51 2012 UTC

#	Line 16 \| Line 16 \| mithep::MuonTools muT;
16		mithep::ElectronIDMVA * eleIsoMVA;
17		mithep::ElectronTools eleT;
18
19	+	// global hack to sync
20	+	double gChargedIso;
21	+	double gGammaIso;
22	+	double gNeutralIso;
23	+
24	+	extern vector<bool> PFnoPUflag;
25	+
26		//--------------------------------------------------------------------------------------------------
27		Float_t computePFMuonIso(const mithep::Muon *muon,
28	<	const mithep::Vertex & vtx,
28	>	const mithep::Vertex * vtx,
29		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
30		const Double_t dRMax)
31		//--------------------------------------------------------------------------------------------------
#	Line 27 \| Line 34 \| Float_t computePFMuonIso(const mithep::M
34		const Double_t neuPtMin = 1.0;
35		const Double_t dzMax = 0.1;
36
37	<	Double_t zLepton = (muon->BestTrk()) ? muon->BestTrk()->DzCorrected(vtx) : 0.0;
37	>	Double_t zLepton = (muon->BestTrk()) ? muon->BestTrk()->DzCorrected(*vtx) : 0.0;
38
39		Float_t iso=0;
40		for(UInt_t ipf=0; ipf<fPFCandidates->GetEntries(); ipf++) {
#	Line 39 \| Line 46 \| Float_t computePFMuonIso(const mithep::M
46		if(pfcand->TrackerTrk() && muon->TrackerTrk() && (pfcand->TrackerTrk()==muon->TrackerTrk())) continue;
47
48		// dz cut
49	<	Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(vtx) - zLepton) : 0;
49	>	Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(*vtx) - zLepton) : 0;
50		if(dz >= dzMax) continue;
51
52		// check iso cone
#	Line 53 \| Line 60 \| Float_t computePFMuonIso(const mithep::M
60
61		//--------------------------------------------------------------------------------------------------
62		Float_t computePFEleIso(const mithep::Electron *electron,
63	<	const mithep::Vertex & fVertex,
63	>	const mithep::Vertex * fVertex,
64		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
65		const Double_t dRMax)
66		//--------------------------------------------------------------------------------------------------
#	Line 62 \| Line 69 \| Float_t computePFEleIso(const mithep::El
69		const Double_t neuPtMin = 1.0;
70		const Double_t dzMax = 0.1;
71
72	<	Double_t zLepton = (electron->BestTrk()) ? electron->BestTrk()->DzCorrected(fVertex) : 0.0;
72	>	Double_t zLepton = (electron->BestTrk()) ? electron->BestTrk()->DzCorrected(*fVertex) : 0.0;
73
74		Float_t iso=0;
75		for(UInt_t ipf=0; ipf<fPFCandidates->GetEntries(); ipf++) {
#	Line 71 \| Line 78 \| Float_t computePFEleIso(const mithep::El
78		if(!pfcand->HasTrk() && (pfcand->Pt()<=neuPtMin)) continue; // pT cut on neutral particles
79
80		// dz cut
81	<	Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(fVertex) - zLepton) : 0;
81	>	Double_t dz = (pfcand->BestTrk()) ? fabs(pfcand->BestTrk()->DzCorrected(*fVertex) - zLepton) : 0;
82		if(dz >= dzMax) continue;
83
84		// remove THE electron
#	Line 157 \| Line 164 \| bool pairwiseIsoSelection( ControlFlags
164
165		float isoEcal_corr_j = lepvec[j].isoEcal - (effArea_ecal_j*rho);
166		float isoHcal_corr_j = lepvec[j].isoHcal - (effArea_hcal_j*rho);
167	<	float RIso_i = (lepvec[i].isoTrk+isoEcal_corr_i+isoHcal_corr_i)/lepvec[i].vec->Pt();
168	<	float RIso_j = (lepvec[j].isoTrk+isoEcal_corr_j+isoHcal_corr_j)/lepvec[j].vec->Pt();
167	>	float RIso_i = (lepvec[i].isoTrk+isoEcal_corr_i+isoHcal_corr_i)/lepvec[i].vec.Pt();
168	>	float RIso_j = (lepvec[j].isoTrk+isoEcal_corr_j+isoHcal_corr_j)/lepvec[j].vec.Pt();
169		float comboIso = RIso_i + RIso_j;
170
171		if( comboIso > 0.35 ) {
#	Line 175 \| Line 182 \| bool pairwiseIsoSelection( ControlFlags
182		//--------------------------------------------------------------------------------------------------
183		SelectionStatus muonIsoSelection(ControlFlags &ctrl,
184		const mithep::Muon * mu,
185	<	const mithep::Vertex & vtx,
185	>	const mithep::Vertex * vtx,
186		const mithep::Array<mithep::PFCandidate> * fPFCandidateCol )
187		//--------------------------------------------------------------------------------------------------
188		{
#	Line 205 \| Line 212 \| SelectionStatus muonIsoSelection(Control
212		//--------------------------------------------------------------------------------------------------
213		SelectionStatus electronIsoSelection(ControlFlags &ctrl,
214		const mithep::Electron * ele,
215	<	const mithep::Vertex &fVertex,
215	>	const mithep::Vertex *fVertex,
216		const mithep::Array<mithep::PFCandidate> * fPFCandidates)
217		//--------------------------------------------------------------------------------------------------
218		{
#	Line 220 \| Line 227 \| SelectionStatus electronIsoSelection(Con
227		if( ele->IsEB() && ele->Pt() < 20 && reliso > PFISO_ELE_LOOSE_EB_LOWPT ) {
228		failiso = true;
229		}
223	–	if(ctrl.debug) cout << "before iso check ..." << endl;
230		if( !(ele->IsEB()) && ele->Pt() > 20 && reliso > PFISO_ELE_LOOSE_EE_HIGHPT ) {
225	–	if(ctrl.debug) cout << "\tit fails ..." << endl;
231		failiso = true;
232		}
233		if( !(ele->IsEB()) && ele->Pt() < 20 && reliso > PFISO_ELE_LOOSE_EE_LOWPT ) {
#	Line 245 \| Line 250 \| bool noIso(ControlFlags &, vector<Simple
250		return true;
251		}
252
253	+
254		//--------------------------------------------------------------------------------------------------
255		SelectionStatus muonIsoMVASelection(ControlFlags &ctrl,
256		const mithep::Muon * mu,
257	<	const mithep::Vertex & vtx,
257	>	const mithep::Vertex * vtx,
258		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
259		const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
260		mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
#	Line 332 \| Line 338 \| SelectionStatus muonIsoMVASelection(Cont
338		//Loop over PF Candidates
339		//
340		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
341	+
342	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
343	+
344		const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
345
346		Double_t deta = (mu->Eta() - pf->Eta());
#	Line 362 \| Line 371 \| SelectionStatus muonIsoMVASelection(Cont
371		IsLeptonFootprint = kTRUE;
372		}
373		// PF charged
374	<	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
374	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479
375		&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
376		IsLeptonFootprint = kTRUE;
377		// PF gamma
378	<	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
378	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
379		&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
380		IsLeptonFootprint = kTRUE;
381		} // loop over electrons
382
383	+	/* KH - commented for sync
384		//
385		// Check for muons
386		//
#	Line 385 \| Line 395 \| SelectionStatus muonIsoMVASelection(Cont
395		if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
396		IsLeptonFootprint = kTRUE;
397		} // loop over muons
398	<
398	>	*/
399
400		if (IsLeptonFootprint)
401		continue;
#	Line 398 \| Line 408 \| SelectionStatus muonIsoMVASelection(Cont
408		if( dr < 0.01 ) continue; // only for muon iso mva?
409		if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
410
411	<	if( pf->HasTrackerTrk() ) {
412	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
413	<	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
414	<	<< abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
415	<	<< dr << endl;
416	<	}
417	<	if( pf->HasGsfTrk() ) {
418	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
419	<	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
420	<	<< abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
421	<	<< dr << endl;
422	<	}
411	>	// if( pf->HasTrackerTrk() ) {
412	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
413	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
414	>	// << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
415	>	// << dr << endl;
416	>	// }
417	>	// if( pf->HasGsfTrk() ) {
418	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
419	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
420	>	// << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
421	>	// << dr << endl;
422	>	// }
423
424		// Footprint Veto
425		if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
#	Line 448 \| Line 458 \| SelectionStatus muonIsoMVASelection(Cont
458
459		}
460
461	<	fChargedIso_DR0p0To0p1 = min((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
462	<	fChargedIso_DR0p1To0p2 = min((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
463	<	fChargedIso_DR0p2To0p3 = min((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
464	<	fChargedIso_DR0p3To0p4 = min((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
465	<	fChargedIso_DR0p4To0p5 = min((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
461	>	fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
462	>	fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
463	>	fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
464	>	fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
465	>	fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
466
467
468		double rho = 0;
469		if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
470		rho = fPUEnergyDensity->At(0)->Rho();
471	+
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 511 \| 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 545 \| 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 557 \| 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 582 \| 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 593 \| 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 616 \| Line 993 \| double muonPFIso04(ControlFlags &ctrl,
993		//
994		// final iso
995		//
996	<	Double_t fChargedIso;
997	<	Double_t fGammaIso;
998	<	Double_t fNeutralHadronIso;
996	>	Double_t fChargedIso = 0.0;
997	>	Double_t fGammaIso = 0.0;
998	>	Double_t fNeutralHadronIso = 0.0;
999
1000		//
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 655 \| 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	<
1048	>
1049	>	/* KH - comment for sync
1050		//
1051		// Check for muons
1052		//
#	Line 677 \| Line 1061 \| double muonPFIso04(ControlFlags &ctrl,
1061		if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
1062		IsLeptonFootprint = kTRUE;
1063		} // loop over muons
1064	+	*/
1065	+
1066	+	if (IsLeptonFootprint)
1067	+	continue;
1068	+
1069	+	//
1070	+	// Charged Iso
1071	+	//
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	+
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();
1093	+	}
1094	+
1095	+	//
1096	+	// Gamma Iso
1097	+	//
1098	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1099	+	// KH, add to sync
1100	+	if( pf->Pt() > 0.5 )
1101	+	fGammaIso += pf->Pt();
1102	+	}
1103	+
1104	+	//
1105	+	// Other Neutrals
1106	+	//
1107	+	else {
1108	+	// KH, add to sync
1109	+	if( pf->Pt() > 0.5 )
1110	+	fNeutralHadronIso += pf->Pt();
1111	+	}
1112	+
1113	+	}
1114	+
1115	+	}
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	+	//rho = fPUEnergyDensity->At(0)->Rho();
1124	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1125	+	EffectiveAreaVersion = mithep::MuonTools::kMuEAData2011;
1126	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1127	+	} else {
1128	+	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral()) \|\|
1129	+	isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral())))
1130	+	rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral();
1131	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1132	+	EffectiveAreaVersion = mithep::MuonTools::kMuEAData2012;
1133	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1134	+	}
1135	+	if(ctrl.debug) cout << "rho: " << rho << endl;
1136	+
1137	+	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1138	+	-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1139	+	mu->Eta(),EffectiveAreaVersion)));
1140	+	gChargedIso = fChargedIso;
1141	+	gGammaIso = fGammaIso;
1142	+	gNeutralIso = fNeutralHadronIso;
1143	+
1144	+	return pfIso;
1145	+	}
1146	+
1147	+
1148	+
1149	+
1150	+	//--------------------------------------------------------------------------------------------------
1151	+	// hacked version
1152	+	double muonPFIso04(ControlFlags &ctrl,
1153	+	const mithep::Muon * mu,
1154	+	const mithep::Vertex * vtx,
1155	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1156	+	float rho,
1157	+	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1158	+	vector<const mithep::Muon*> muonsToVeto,
1159	+	vector<const mithep::Electron*> electronsToVeto)
1160	+	//--------------------------------------------------------------------------------------------------
1161	+	{
1162	+
1163	+	extern double gChargedIso;
1164	+	extern double gGammaIso;
1165	+	extern double gNeutralIso;
1166	+
1167	+	if( ctrl.debug ) {
1168	+	cout << "muonIsoMVASelection :: muons to veto " << endl;
1169	+	for( int i=0; i<muonsToVeto.size(); i++ ) {
1170	+	const mithep::Muon * vmu = muonsToVeto[i];
1171	+	cout << "\tpt: " << vmu->Pt()
1172	+	<< "\teta: " << vmu->Eta()
1173	+	<< "\tphi: " << vmu->Phi()
1174	+	<< endl;
1175	+	}
1176	+	cout << "muonIsoMVASelection :: electrson to veto " << endl;
1177	+	for( int i=0; i<electronsToVeto.size(); i++ ) {
1178	+	const mithep::Electron * vel = electronsToVeto[i];
1179	+	cout << "\tpt: " << vel->Pt()
1180	+	<< "\teta: " << vel->Eta()
1181	+	<< "\tphi: " << vel->Phi()
1182	+	<< endl;
1183	+	}
1184	+	}
1185	+
1186	+	//
1187	+	// final iso
1188	+	//
1189	+	Double_t fChargedIso = 0.0;
1190	+	Double_t fGammaIso = 0.0;
1191	+	Double_t fNeutralHadronIso = 0.0;
1192	+
1193	+	//
1194	+	//Loop over PF Candidates
1195	+	//
1196	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1197	+
1198	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1199	+	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1200	+
1201	+	Double_t deta = (mu->Eta() - pf->Eta());
1202	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
1203	+	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
1204	+	if (dr > 0.4) continue;
1205	+
1206	+	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
1207	+
1208	+	//
1209	+	// Lepton Footprint Removal
1210	+	//
1211	+	Bool_t IsLeptonFootprint = kFALSE;
1212	+	if (dr < 1.0) {
1213	+
1214	+	//
1215	+	// Check for electrons
1216	+	//
1217	+	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1218	+	const mithep::Electron *tmpele = electronsToVeto[q];
1219	+	// 4l electron
1220	+	if( pf->HasTrackerTrk() ) {
1221	+	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
1222	+	IsLeptonFootprint = kTRUE;
1223	+	}
1224	+	if( pf->HasGsfTrk() ) {
1225	+	if( pf->GsfTrk() == tmpele->GsfTrk() )
1226	+	IsLeptonFootprint = kTRUE;
1227	+	}
1228	+	// PF charged
1229	+	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1230	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
1231	+	IsLeptonFootprint = kTRUE;
1232	+	// PF gamma
1233	+	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1234	+	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
1235	+	IsLeptonFootprint = kTRUE;
1236	+	} // loop over electrons
1237
1238	+	/* KH - comment for sync
1239	+	//
1240	+	// Check for muons
1241	+	//
1242	+	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1243	+	const mithep::Muon *tmpmu = muonsToVeto[q];
1244	+	// 4l muon
1245	+	if( pf->HasTrackerTrk() ) {
1246	+	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
1247	+	IsLeptonFootprint = kTRUE;
1248	+	}
1249	+	// PF charged
1250	+	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
1251	+	IsLeptonFootprint = kTRUE;
1252	+	} // loop over muons
1253	+	*/
1254
1255		if (IsLeptonFootprint)
1256		continue;
1257
1258		//
1259	<	// Charged Iso Rings
1259	>	// Charged Iso
1260		//
1261		if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1262
1263	<	if( dr < 0.01 ) continue; // only for muon iso mva?
1263	>	//if( dr < 0.01 ) continue; // only for muon iso mva?
1264		if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
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	<	}
1266	>
1267	>	// if( pf->HasTrackerTrk() ) {
1268	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1269	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1270	>	// << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1271	>	// << dr << endl;
1272	>	// }
1273	>	// if( pf->HasGsfTrk() ) {
1274	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1275	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1276	>	// << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1277	>	// << dr << endl;
1278	>	// }
1279
1280
1281		fChargedIso += pf->Pt();
#	Line 711 \| Line 1285 \| double muonPFIso04(ControlFlags &ctrl,
1285		// Gamma Iso
1286		//
1287		else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1288	+	// KH, add to sync
1289	+	if( pf->Pt() > 0.5 )
1290		fGammaIso += pf->Pt();
1291		}
1292
1293		//
1294	<	// Other Neutral Iso Rings
1294	>	// Other Neutrals
1295		//
1296		else {
1297	<	fNeutralHadronIso += pf->Pt();
1297	>	// KH, add to sync
1298	>	if( pf->Pt() > 0.5 )
1299	>	fNeutralHadronIso += pf->Pt();
1300		}
1301
1302		}
1303
1304		}
1305
1306	<	double rho = 0;
1307	<	if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
1308	<	rho = fPUEnergyDensity->At(0)->Rho();
1306	>	// double rho = 0;
1307	>	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
1308	>	// rho = fPUEnergyDensity->At(0)->Rho();
1309
1310		// WARNING!!!!
1311		// hardcode for sync ...
#	Line 735 \| Line 1313 \| double muonPFIso04(ControlFlags &ctrl,
1313		// WARNING!!!!
1314
1315
1316	<	double pfIso = fChargedIso + max(0.0,(fGammaIso + fNeutralHadronIso
1316	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1317		-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1318		mu->Eta(),EffectiveAreaVersion)));
1319	+	gChargedIso = fChargedIso;
1320	+	gGammaIso = fGammaIso;
1321	+	gNeutralIso = fNeutralHadronIso;
1322
1323		return pfIso;
1324		}
1325
1326	+
1327		//--------------------------------------------------------------------------------------------------
1328		SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1329		const mithep::Muon * mu,
1330	<	const mithep::Vertex & vtx,
1330	>	const mithep::Vertex * vtx,
1331		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1332		const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1333		mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
#	Line 755 \| Line 1337 \| SelectionStatus muonReferenceIsoSelectio
1337		{
1338
1339		SelectionStatus status;
1340	<
1340	>
1341		double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, fPUEnergyDensity,
1342		EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1343	+	// cout << "--------------> setting muon isoPF04 to" << pfIso << endl;
1344	+	status.isoPF04 = pfIso;
1345	+	status.chisoPF04 = gChargedIso;
1346	+	status.gaisoPF04 = gGammaIso;
1347	+	status.neisoPF04 = gNeutralIso;
1348	+
1349	+	bool pass = false;
1350	+	if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1351	+
1352	+	if( pass ) {
1353	+	status.orStatus(SelectionStatus::LOOSEISO);
1354	+	status.orStatus(SelectionStatus::TIGHTISO);
1355	+	}
1356	+	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1357	+	return status;
1358	+
1359	+	}
1360	+
1361	+
1362	+	//--------------------------------------------------------------------------------------------------
1363	+	// hacked version
1364	+	SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1365	+	const mithep::Muon * mu,
1366	+	const mithep::Vertex * vtx,
1367	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1368	+	float rho,
1369	+	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1370	+	vector<const mithep::Muon*> muonsToVeto,
1371	+	vector<const mithep::Electron*> electronsToVeto)
1372	+	//--------------------------------------------------------------------------------------------------
1373	+	{
1374	+
1375	+	SelectionStatus status;
1376	+
1377	+	double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, rho,
1378	+	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1379	+
1380	+	status.isoPF04 = pfIso;
1381	+	status.chisoPF04 = gChargedIso;
1382	+	status.gaisoPF04 = gGammaIso;
1383	+	status.neisoPF04 = gNeutralIso;
1384	+
1385		bool pass = false;
1386		if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1387
#	Line 772 \| Line 1396 \| SelectionStatus muonReferenceIsoSelectio
1396
1397
1398
1399	+
1400		//--------------------------------------------------------------------------------------------------
1401		SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1402		const mithep::Electron * ele,
1403	<	const mithep::Vertex & vtx,
1403	>	const mithep::Vertex * vtx,
1404		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1405		const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1406		mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
#	Line 814 \| Line 1439 \| SelectionStatus electronIsoMVASelection(
1439		Double_t tmpChargedIso_DR0p2To0p3 = 0;
1440		Double_t tmpChargedIso_DR0p3To0p4 = 0;
1441		Double_t tmpChargedIso_DR0p4To0p5 = 0;
817	–	Double_t tmpChargedIso_DR0p5To0p7 = 0;
1442
1443		Double_t tmpGammaIso_DR0p0To0p1 = 0;
1444		Double_t tmpGammaIso_DR0p1To0p2 = 0;
1445		Double_t tmpGammaIso_DR0p2To0p3 = 0;
1446		Double_t tmpGammaIso_DR0p3To0p4 = 0;
1447		Double_t tmpGammaIso_DR0p4To0p5 = 0;
1448	<	Double_t tmpGammaIso_DR0p5To0p7 = 0;
1448	>
1449
1450		Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
1451		Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
1452		Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
1453		Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
1454		Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
831	–	Double_t tmpNeutralHadronIso_DR0p5To0p7 = 0;
1455
1456
1457
#	Line 858 \| Line 1481 \| SelectionStatus electronIsoMVASelection(
1481		//Loop over PF Candidates
1482		//
1483		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1484	+
1485	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1486	+
1487		const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1488		Double_t deta = (ele->Eta() - pf->Eta());
1489		Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1490		Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1491	<	if (dr >= 0.5) continue;
1491	>	if (dr > 1.0) continue;
1492	>
1493		if(ctrl.debug) {
1494		cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1495	<	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
1495	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1496		cout << endl;
1497		}
1498
#	Line 880 \| Line 1507 \| SelectionStatus electronIsoMVASelection(
1507		Bool_t IsLeptonFootprint = kFALSE;
1508		if (dr < 1.0) {
1509
1510	+
1511		//
1512		// Check for electrons
1513		//
1514	+
1515		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1516		const mithep::Electron *tmpele = electronsToVeto[q];
1517	+	double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1518	+
1519		// 4l electron
1520		if( pf->HasTrackerTrk() ) {
1521		if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
#	Line 899 \| Line 1530 \| SelectionStatus electronIsoMVASelection(
1530		}
1531		}
1532		// PF charged
1533	<	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
903	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1533	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1534		if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1535		IsLeptonFootprint = kTRUE;
1536		}
1537		// PF gamma
1538	<	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1539	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
1538	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1539	>	&& tmpdr < 0.08) {
1540		if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1541		IsLeptonFootprint = kTRUE;
1542		}
1543		} // loop over electrons
1544	<
1544	>
1545	>
1546	>	/* KH - comment for sync
1547		//
1548		// Check for muons
1549		//
#	Line 930 \| Line 1562 \| SelectionStatus electronIsoMVASelection(
1562		IsLeptonFootprint = kTRUE;
1563		}
1564		} // loop over muons
1565	<
1565	>	*/
1566
1567		if (IsLeptonFootprint)
1568		continue;
#	Line 940 \| Line 1572 \| SelectionStatus electronIsoMVASelection(
1572		//
1573		if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1574
1575	<	if( pf->HasTrackerTrk() )
1576	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1577	<	if( pf->HasGsfTrk() )
1578	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1575	>	// if( pf->HasGsfTrk() ) {
1576	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1577	>	// } else if( pf->HasTrackerTrk() ){
1578	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1579	>	// }
1580
1581		// Veto any PFmuon, or PFEle
1582		if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
#	Line 960 \| Line 1593 \| SelectionStatus electronIsoMVASelection(
1593		if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1594		if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1595		if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
963	–	if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
1596
1597		}
1598
#	Line 969 \| Line 1601 \| SelectionStatus electronIsoMVASelection(
1601		//
1602		else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1603
1604	<	if (fabs(ele->SCluster()->Eta()) > 1.479) {
973	<	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
974	<	}
1604	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
1605
1606		if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1607		<< dr << endl;
#	Line 981 \| Line 1611 \| SelectionStatus electronIsoMVASelection(
1611		if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1612		if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1613		if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
984	–	if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
985	–
1614		}
1615
1616		//
#	Line 996 \| Line 1624 \| SelectionStatus electronIsoMVASelection(
1624		if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1625		if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1626		if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
999	–	if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
1627		}
1628
1629		}
1630
1631		}
1632
1633	<	fChargedIso_DR0p0To0p1 = min((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1634	<	fChargedIso_DR0p1To0p2 = min((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1635	<	fChargedIso_DR0p2To0p3 = min((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1636	<	fChargedIso_DR0p3To0p4 = min((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1637	<	fChargedIso_DR0p4To0p5 = min((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1633	>	fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1634	>	fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1635	>	fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1636	>	fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1637	>	fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1638	>
1639	>	if(ctrl.debug) {
1640	>	cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1 << endl;
1641	>	cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2 << endl;
1642	>	cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3 << endl;
1643	>	cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4 << endl;
1644	>	cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5 << endl;
1645	>	}
1646	>
1647
1648		double rho = 0;
1649		if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
1650		rho = fPUEnergyDensity->At(0)->Rho();
1651	+	// if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1652	+	// rho = fPUEnergyDensity->At(0)->RhoLowEta();
1653	+
1654	+	// WARNING!!!!
1655	+	// hardcode for sync ...
1656	+	EffectiveAreaVersion = eleT.kEleEAData2011;
1657	+	// WARNING!!!!
1658
1659		if( ctrl.debug) {
1660		cout << "RHO: " << rho << endl;
#	Line 1035 \| Line 1678 \| SelectionStatus electronIsoMVASelection(
1678		<< endl;
1679		}
1680
1681	<	fGammaIso_DR0p0To0p1 = max(min((tmpGammaIso_DR0p0To0p1
1681	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
1682		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
1683		ele->SCluster()->Eta(),
1684		EffectiveAreaVersion))/ele->Pt()
1685		,2.5)
1686		,0.0);
1687	<	fGammaIso_DR0p1To0p2 = max(min((tmpGammaIso_DR0p1To0p2
1687	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
1688		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
1689		ele->SCluster()->Eta(),
1690		EffectiveAreaVersion))/ele->Pt()
1691		,2.5)
1692		,0.0);
1693	<	fGammaIso_DR0p2To0p3 = max(min((tmpGammaIso_DR0p2To0p3
1693	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
1694		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
1695		ele->SCluster()->Eta()
1696		,EffectiveAreaVersion))/ele->Pt()
1697		,2.5)
1698		,0.0);
1699	<	fGammaIso_DR0p3To0p4 = max(min((tmpGammaIso_DR0p3To0p4
1699	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
1700		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
1701		ele->SCluster()->Eta(),
1702		EffectiveAreaVersion))/ele->Pt()
1703		,2.5)
1704		,0.0);
1705	<	fGammaIso_DR0p4To0p5 = max(min((tmpGammaIso_DR0p4To0p5
1705	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
1706		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
1707		ele->SCluster()->Eta(),
1708		EffectiveAreaVersion))/ele->Pt()
#	Line 1067 \| Line 1710 \| SelectionStatus electronIsoMVASelection(
1710		,0.0);
1711
1712
1713	<	fNeutralHadronIso_DR0p0To0p1 = max(min((tmpNeutralHadronIso_DR0p0To0p1
1713	>	if( ctrl.debug) {
1714	>	cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
1715	>	cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
1716	>	cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
1717	>	cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
1718	>	cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
1719	>	}
1720	>
1721	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
1722		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1723		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1724		, 2.5)
1725		, 0.0);
1726	<	fNeutralHadronIso_DR0p1To0p2 = max(min((tmpNeutralHadronIso_DR0p1To0p2
1726	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
1727		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1728		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1729		, 2.5)
1730		, 0.0);
1731	<	fNeutralHadronIso_DR0p2To0p3 = max(min((tmpNeutralHadronIso_DR0p2To0p3
1731	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
1732		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1733		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1734		, 2.5)
1735		, 0.0);
1736	<	fNeutralHadronIso_DR0p3To0p4 = max(min((tmpNeutralHadronIso_DR0p3To0p4
1736	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
1737		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1738		ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1739		, 2.5)
1740		, 0.0);
1741	<	fNeutralHadronIso_DR0p4To0p5 = max(min((tmpNeutralHadronIso_DR0p4To0p5
1741	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
1742		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
1743		ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1744		, 2.5)
1745		, 0.0);
1746
1747	+	if( ctrl.debug) {
1748	+	cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
1749	+	cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
1750	+	cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
1751	+	cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
1752	+	cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
1753	+	}
1754	+
1755		double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
1756		ele->SCluster()->Eta(),
1757		fChargedIso_DR0p0To0p1,
#	Line 1113 \| Line 1772 \| SelectionStatus electronIsoMVASelection(
1772		ctrl.debug);
1773
1774		SelectionStatus status;
1775	+	status.isoMVA = mvaval;
1776		bool pass = false;
1777
1778		Int_t subdet = 0;
1779		if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
1780		else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
1781		else subdet = 2;
1782	+
1783		Int_t ptBin = 0;
1784	<	if (ele->Pt() > 10.0) ptBin = 1;
1784	>	if (ele->Pt() >= 10.0) ptBin = 1;
1785	>
1786	>	Int_t MVABin = -1;
1787	>	if (subdet == 0 && ptBin == 0) MVABin = 0;
1788	>	if (subdet == 1 && ptBin == 0) MVABin = 1;
1789	>	if (subdet == 2 && ptBin == 0) MVABin = 2;
1790	>	if (subdet == 0 && ptBin == 1) MVABin = 3;
1791	>	if (subdet == 1 && ptBin == 1) MVABin = 4;
1792	>	if (subdet == 2 && ptBin == 1) MVABin = 5;
1793	>
1794	>	pass = false;
1795	>	if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN0 ) pass = true;
1796	>	if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN1 ) pass = true;
1797	>	if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN2 ) pass = true;
1798	>	if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN3 ) pass = true;
1799	>	if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN4 ) pass = true;
1800	>	if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN5 ) pass = true;
1801	>	// pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
1802	>	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
1803	>
1804	>	// pass = false;
1805	>	// if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
1806	>	// if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
1807	>	// if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
1808	>	// if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
1809	>	// if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
1810	>	// if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
1811	>	// if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
1812	>
1813	>	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1814	>	return status;
1815	>
1816	>	}
1817	>
1818	>
1819	>	//--------------------------------------------------------------------------------------------------
1820	>	SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1821	>	const mithep::Electron * ele,
1822	>	const mithep::Vertex * vtx,
1823	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1824	>	float rho,
1825	>	//const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1826	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1827	>	vector<const mithep::Muon*> muonsToVeto,
1828	>	vector<const mithep::Electron*> electronsToVeto)
1829	>	//--------------------------------------------------------------------------------------------------
1830	>	// hacked version
1831	>	{
1832	>	if( ctrl.debug ) {
1833	>	cout << "================> hacked ele Iso MVA <======================" << endl;
1834	>	}
1835	>
1836	>	if( ctrl.debug ) {
1837	>	cout << "electronIsoMVASelection :: muons to veto " << endl;
1838	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
1839	>	const mithep::Muon * vmu = muonsToVeto[i];
1840	>	cout << "\tpt: " << vmu->Pt()
1841	>	<< "\teta: " << vmu->Eta()
1842	>	<< "\tphi: " << vmu->Phi()
1843	>	<< endl;
1844	>	}
1845	>	cout << "electronIsoMVASelection :: electrson to veto " << endl;
1846	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
1847	>	const mithep::Electron * vel = electronsToVeto[i];
1848	>	cout << "\tpt: " << vel->Pt()
1849	>	<< "\teta: " << vel->Eta()
1850	>	<< "\tphi: " << vel->Phi()
1851	>	<< "\ttrk: " << vel->TrackerTrk()
1852	>	<< endl;
1853	>	}
1854	>	}
1855	>
1856	>	bool failiso=false;
1857	>
1858	>	//
1859	>	// tmp iso rings
1860	>	//
1861	>	Double_t tmpChargedIso_DR0p0To0p1 = 0;
1862	>	Double_t tmpChargedIso_DR0p1To0p2 = 0;
1863	>	Double_t tmpChargedIso_DR0p2To0p3 = 0;
1864	>	Double_t tmpChargedIso_DR0p3To0p4 = 0;
1865	>	Double_t tmpChargedIso_DR0p4To0p5 = 0;
1866	>
1867	>	Double_t tmpGammaIso_DR0p0To0p1 = 0;
1868	>	Double_t tmpGammaIso_DR0p1To0p2 = 0;
1869	>	Double_t tmpGammaIso_DR0p2To0p3 = 0;
1870	>	Double_t tmpGammaIso_DR0p3To0p4 = 0;
1871	>	Double_t tmpGammaIso_DR0p4To0p5 = 0;
1872	>
1873	>
1874	>	Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
1875	>	Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
1876	>	Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
1877	>	Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
1878	>	Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
1879	>
1880	>
1881	>
1882	>	//
1883	>	// final rings for the MVA
1884	>	//
1885	>	Double_t fChargedIso_DR0p0To0p1;
1886	>	Double_t fChargedIso_DR0p1To0p2;
1887	>	Double_t fChargedIso_DR0p2To0p3;
1888	>	Double_t fChargedIso_DR0p3To0p4;
1889	>	Double_t fChargedIso_DR0p4To0p5;
1890	>
1891	>	Double_t fGammaIso_DR0p0To0p1;
1892	>	Double_t fGammaIso_DR0p1To0p2;
1893	>	Double_t fGammaIso_DR0p2To0p3;
1894	>	Double_t fGammaIso_DR0p3To0p4;
1895	>	Double_t fGammaIso_DR0p4To0p5;
1896	>
1897	>	Double_t fNeutralHadronIso_DR0p0To0p1;
1898	>	Double_t fNeutralHadronIso_DR0p1To0p2;
1899	>	Double_t fNeutralHadronIso_DR0p2To0p3;
1900	>	Double_t fNeutralHadronIso_DR0p3To0p4;
1901	>	Double_t fNeutralHadronIso_DR0p4To0p5;
1902	>
1903	>
1904	>	//
1905	>	//Loop over PF Candidates
1906	>	//
1907	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1908	>
1909	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1910	>
1911	>	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1912	>	Double_t deta = (ele->Eta() - pf->Eta());
1913	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1914	>	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1915	>	if (dr > 1.0) continue;
1916	>
1917	>	if(ctrl.debug) {
1918	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1919	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1920	>	cout << endl;
1921	>	}
1922	>
1923	>
1924	>	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
1925	>	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1926	>
1927	>
1928	>	//
1929	>	// Lepton Footprint Removal
1930	>	//
1931	>	Bool_t IsLeptonFootprint = kFALSE;
1932	>	if (dr < 1.0) {
1933	>
1934	>
1935	>	//
1936	>	// Check for electrons
1937	>	//
1938	>
1939	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1940	>	const mithep::Electron *tmpele = electronsToVeto[q];
1941	>	double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1942	>
1943	>	// 4l electron
1944	>	if( pf->HasTrackerTrk() ) {
1945	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1946	>	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1947	>	IsLeptonFootprint = kTRUE;
1948	>	}
1949	>	}
1950	>	if( pf->HasGsfTrk() ) {
1951	>	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1952	>	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1953	>	IsLeptonFootprint = kTRUE;
1954	>	}
1955	>	}
1956	>	// PF charged
1957	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1958	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1959	>	IsLeptonFootprint = kTRUE;
1960	>	}
1961	>	// PF gamma
1962	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1963	>	&& tmpdr < 0.08) {
1964	>	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1965	>	IsLeptonFootprint = kTRUE;
1966	>	}
1967	>	} // loop over electrons
1968	>
1969	>
1970	>	/* KH - comment for sync
1971	>	//
1972	>	// Check for muons
1973	>	//
1974	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1975	>	const mithep::Muon *tmpmu = muonsToVeto[q];
1976	>	// 4l muon
1977	>	if( pf->HasTrackerTrk() ) {
1978	>	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1979	>	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1980	>	IsLeptonFootprint = kTRUE;
1981	>	}
1982	>	}
1983	>	// PF charged
1984	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1985	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1986	>	IsLeptonFootprint = kTRUE;
1987	>	}
1988	>	} // loop over muons
1989	>	*/
1990	>
1991	>	if (IsLeptonFootprint)
1992	>	continue;
1993	>
1994	>	//
1995	>	// Charged Iso Rings
1996	>	//
1997	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1998	>
1999	>	// if( pf->HasGsfTrk() ) {
2000	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2001	>	// } else if( pf->HasTrackerTrk() ){
2002	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2003	>	// }
2004	>
2005	>	// Veto any PFmuon, or PFEle
2006	>	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
2007	>
2008	>	// Footprint Veto
2009	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
2010	>
2011	>	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
2012	>	<< "\ttype: " << pf->PFType()
2013	>	<< "\ttrk: " << pf->TrackerTrk() << endl;
2014	>
2015	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
2016	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
2017	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
2018	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
2019	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
2020	>
2021	>	}
2022	>
2023	>	//
2024	>	// Gamma Iso Rings
2025	>	//
2026	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2027	>
2028	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
2029	>
2030	>	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2031	>	<< dr << endl;
2032	>
2033	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
2034	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
2035	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
2036	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
2037	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
2038	>	}
2039	>
2040	>	//
2041	>	// Other Neutral Iso Rings
2042	>	//
2043	>	else {
2044	>	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2045	>	<< dr << endl;
2046	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
2047	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
2048	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
2049	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
2050	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
2051	>	}
2052	>
2053	>	}
2054	>
2055	>	}
2056	>
2057	>	fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
2058	>	fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
2059	>	fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
2060	>	fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
2061	>	fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
2062	>
2063	>	if(ctrl.debug) {
2064	>	cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1 << endl;
2065	>	cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2 << endl;
2066	>	cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3 << endl;
2067	>	cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4 << endl;
2068	>	cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5 << endl;
2069	>	}
2070	>
2071	>
2072	>	// rho=0;
2073	>	// double rho = 0;
2074	>	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
2075	>	// rho = fPUEnergyDensity->At(0)->Rho();
2076	>	// if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
2077	>	// rho = fPUEnergyDensity->At(0)->RhoLowEta();
2078	>
2079	>	// WARNING!!!!
2080	>	// hardcode for sync ...
2081	>	EffectiveAreaVersion = eleT.kEleEAData2011;
2082	>	// WARNING!!!!
2083	>
2084	>	if( ctrl.debug) {
2085	>	cout << "RHO: " << rho << endl;
2086	>	cout << "eta: " << ele->SCluster()->Eta() << endl;
2087	>	cout << "target: " << EffectiveAreaVersion << endl;
2088	>	cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
2089	>	ele->SCluster()->Eta(),
2090	>	EffectiveAreaVersion)
2091	>	<< endl;
2092	>	cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
2093	>	ele->SCluster()->Eta(),
2094	>	EffectiveAreaVersion)
2095	>	<< endl;
2096	>	cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
2097	>	ele->SCluster()->Eta(),
2098	>	EffectiveAreaVersion)
2099	>	<< endl;
2100	>	cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
2101	>	ele->SCluster()->Eta(),
2102	>	EffectiveAreaVersion)
2103	>	<< endl;
2104	>	}
2105	>
2106	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
2107	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
2108	>	ele->SCluster()->Eta(),
2109	>	EffectiveAreaVersion))/ele->Pt()
2110	>	,2.5)
2111	>	,0.0);
2112	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
2113	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
2114	>	ele->SCluster()->Eta(),
2115	>	EffectiveAreaVersion))/ele->Pt()
2116	>	,2.5)
2117	>	,0.0);
2118	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
2119	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
2120	>	ele->SCluster()->Eta()
2121	>	,EffectiveAreaVersion))/ele->Pt()
2122	>	,2.5)
2123	>	,0.0);
2124	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
2125	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
2126	>	ele->SCluster()->Eta(),
2127	>	EffectiveAreaVersion))/ele->Pt()
2128	>	,2.5)
2129	>	,0.0);
2130	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
2131	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
2132	>	ele->SCluster()->Eta(),
2133	>	EffectiveAreaVersion))/ele->Pt()
2134	>	,2.5)
2135	>	,0.0);
2136	>
2137	>
2138	>	if( ctrl.debug) {
2139	>	cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
2140	>	cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
2141	>	cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
2142	>	cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
2143	>	cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
2144	>	}
2145	>
2146	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
2147	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
2148	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2149	>	, 2.5)
2150	>	, 0.0);
2151	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
2152	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
2153	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2154	>	, 2.5)
2155	>	, 0.0);
2156	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
2157	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
2158	>	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2159	>	, 2.5)
2160	>	, 0.0);
2161	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
2162	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
2163	>	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2164	>	, 2.5)
2165	>	, 0.0);
2166	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
2167	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
2168	>	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2169	>	, 2.5)
2170	>	, 0.0);
2171	>
2172	>	if( ctrl.debug) {
2173	>	cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
2174	>	cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
2175	>	cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
2176	>	cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
2177	>	cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
2178	>	}
2179	>
2180	>	double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
2181	>	ele->SCluster()->Eta(),
2182	>	fChargedIso_DR0p0To0p1,
2183	>	fChargedIso_DR0p1To0p2,
2184	>	fChargedIso_DR0p2To0p3,
2185	>	fChargedIso_DR0p3To0p4,
2186	>	fChargedIso_DR0p4To0p5,
2187	>	fGammaIso_DR0p0To0p1,
2188	>	fGammaIso_DR0p1To0p2,
2189	>	fGammaIso_DR0p2To0p3,
2190	>	fGammaIso_DR0p3To0p4,
2191	>	fGammaIso_DR0p4To0p5,
2192	>	fNeutralHadronIso_DR0p0To0p1,
2193	>	fNeutralHadronIso_DR0p1To0p2,
2194	>	fNeutralHadronIso_DR0p2To0p3,
2195	>	fNeutralHadronIso_DR0p3To0p4,
2196	>	fNeutralHadronIso_DR0p4To0p5,
2197	>	ctrl.debug);
2198	>
2199	>	SelectionStatus status;
2200	>	status.isoMVA = mvaval;
2201	>	bool pass = false;
2202	>
2203	>	Int_t subdet = 0;
2204	>	if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
2205	>	else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
2206	>	else subdet = 2;
2207	>
2208	>	Int_t ptBin = 0;
2209	>	if (ele->Pt() >= 10.0) ptBin = 1;
2210
2211		Int_t MVABin = -1;
2212		if (subdet == 0 && ptBin == 0) MVABin = 0;
#	Line 1139 \| Line 2225 \| SelectionStatus electronIsoMVASelection(
2225		if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN5 ) pass = true;
2226		if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
2227
2228	<	pass = false;
2229	<	if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
2230	<	if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
2231	<	if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
2232	<	if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
2233	<	if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
2234	<	if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
2235	<	if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
2228	>	// pass = false;
2229	>	// if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
2230	>	// if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
2231	>	// if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
2232	>	// if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
2233	>	// if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
2234	>	// if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
2235	>	// if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
2236
2237		if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2238		return status;
#	Line 1170 \| Line 2256 \| void initElectronIsoMVA() {
2256
2257
2258
2259	+
2260		//--------------------------------------------------------------------------------------------------
2261		float electronPFIso04(ControlFlags &ctrl,
2262	<	const mithep::Electron * ele,
2263	<	const mithep::Vertex & vtx,
2264	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2265	<	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2266	<	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2267	<	vector<const mithep::Muon*> muonsToVeto,
2268	<	vector<const mithep::Electron*> electronsToVeto)
2262	>	const mithep::Electron * ele,
2263	>	const mithep::Vertex * vtx,
2264	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2265	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2266	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2267	>	vector<const mithep::Muon*> muonsToVeto,
2268	>	vector<const mithep::Electron*> electronsToVeto)
2269	>	//--------------------------------------------------------------------------------------------------
2270	>	{
2271	>	/*
2272	>	if( ctrl.debug ) {
2273	>	cout << "electronIsoMVASelection :: muons to veto " << endl;
2274	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
2275	>	const mithep::Muon * vmu = muonsToVeto[i];
2276	>	cout << "\tpt: " << vmu->Pt()
2277	>	<< "\teta: " << vmu->Eta()
2278	>	<< "\tphi: " << vmu->Phi()
2279	>	<< endl;
2280	>	}
2281	>	cout << "electronIsoMVASelection :: electrons to veto " << endl;
2282	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
2283	>	const mithep::Electron * vel = electronsToVeto[i];
2284	>	cout << "\tpt: " << vel->Pt()
2285	>	<< "\teta: " << vel->Eta()
2286	>	<< "\tphi: " << vel->Phi()
2287	>	<< "\ttrk: " << vel->TrackerTrk()
2288	>	<< endl;
2289	>	}
2290	>	}
2291	>	*/
2292	>
2293	>	//
2294	>	// final iso
2295	>	//
2296	>	Double_t fChargedIso = 0.0;
2297	>	Double_t fGammaIso = 0.0;
2298	>	Double_t fNeutralHadronIso = 0.0;
2299	>
2300	>
2301	>	//
2302	>	//Loop over PF Candidates
2303	>	//
2304	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2305	>
2306	>
2307	>	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
2308	>	Double_t deta = (ele->Eta() - pf->Eta());
2309	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2310	>	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2311	>
2312	>	if (dr > 0.4) continue;
2313	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2314	>
2315	>	if(ctrl.debug) {
2316	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2317	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
2318	>	<< "\ttrk: " << pf->HasTrackerTrk()
2319	>	<< "\tgsf: " << pf->HasGsfTrk();
2320	>
2321	>	cout << endl;
2322	>	}
2323	>
2324	>
2325	>	//
2326	>	// sync : I don't think theyre doing this ...
2327	>	//
2328	>	// if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
2329	>	// (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2330	>	// if( ctrl.debug ) cout << "\tskipping, matches to the electron ..." << endl;
2331	>	// continue;
2332	>	// }
2333	>
2334	>
2335	>	//
2336	>	// Lepton Footprint Removal
2337	>	//
2338	>	Bool_t IsLeptonFootprint = kFALSE;
2339	>	if (dr < 1.0) {
2340	>
2341	>	//
2342	>	// Check for electrons
2343	>	//
2344	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2345	>	const mithep::Electron *tmpele = electronsToVeto[q];
2346	>	/*
2347	>	// 4l electron
2348	>	if( pf->HasTrackerTrk() ) {
2349	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
2350	>	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
2351	>	IsLeptonFootprint = kTRUE;
2352	>	}
2353	>	}
2354	>	if( pf->HasGsfTrk() ) {
2355	>	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
2356	>	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
2357	>	IsLeptonFootprint = kTRUE;
2358	>	}
2359	>	}
2360	>	*/
2361	>	// PF charged
2362	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2363	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
2364	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
2365	>	IsLeptonFootprint = kTRUE;
2366	>	}
2367	>	// PF gamma
2368	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
2369	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
2370	>	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
2371	>	IsLeptonFootprint = kTRUE;
2372	>	}
2373	>	} // loop over electrons
2374	>
2375	>	/* KH - comment for sync
2376	>	//
2377	>	// Check for muons
2378	>	//
2379	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
2380	>	const mithep::Muon *tmpmu = muonsToVeto[q];
2381	>	// 4l muon
2382	>	if( pf->HasTrackerTrk() ) {
2383	>	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
2384	>	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
2385	>	IsLeptonFootprint = kTRUE;
2386	>	}
2387	>	}
2388	>	// PF charged
2389	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
2390	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
2391	>	IsLeptonFootprint = kTRUE;
2392	>	}
2393	>	} // loop over muons
2394	>	*/
2395	>
2396	>	if (IsLeptonFootprint)
2397	>	continue;
2398	>
2399	>	//
2400	>	// Charged Iso
2401	>	//
2402	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
2403	>
2404	>	// if( pf->HasTrackerTrk() )
2405	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2406	>	// if( pf->HasGsfTrk() )
2407	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2408	>
2409	>	// Veto any PFmuon, or PFEle
2410	>	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) {
2411	>	if( ctrl.debug ) cout << "\t skipping, pf is and ele or mu .." <<endl;
2412	>	continue;
2413	>	}
2414	>
2415	>	// Footprint Veto
2416	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
2417	>
2418	>	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
2419	>	<< "\ttype: " << pf->PFType()
2420	>	<< "\ttrk: " << pf->TrackerTrk() << endl;
2421	>
2422	>	fChargedIso += pf->Pt();
2423	>	}
2424	>
2425	>	//
2426	>	// Gamma Iso
2427	>	//
2428	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2429	>
2430	>	if (fabs(ele->SCluster()->Eta()) > 1.479) {
2431	>	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
2432	>	}
2433	>	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2434	>	<< dr << endl;
2435	>	// KH, add to sync
2436	>	// if( pf->Pt() > 0.5 )
2437	>	fGammaIso += pf->Pt();
2438	>	}
2439	>
2440	>	//
2441	>	// Neutral Iso
2442	>	//
2443	>	else {
2444	>	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2445	>	<< dr << endl;
2446	>	// KH, add to sync
2447	>	// if( pf->Pt() > 0.5 )
2448	>	fNeutralHadronIso += pf->Pt();
2449	>	}
2450	>
2451	>	}
2452	>
2453	>	}
2454	>
2455	>
2456	>	double rho=0;
2457	>	if( (EffectiveAreaVersion == mithep::ElectronTools::kEleEAFall11MC) \|\|
2458	>	(EffectiveAreaVersion == mithep::ElectronTools::kEleEAData2011) ) {
2459	>	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25()) \|\|
2460	>	isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25())))
2461	>	rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25();
2462	>	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2463	>	EffectiveAreaVersion = mithep::ElectronTools::kEleEAData2011;
2464	>	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2465	>	} else {
2466	>	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJets()) \|\|
2467	>	isinf(fPUEnergyDensity->At(0)->RhoKt6PFJets())))
2468	>	rho = fPUEnergyDensity->At(0)->RhoKt6PFJets();
2469	>	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2470	>	EffectiveAreaVersion = mithep::ElectronTools::kEleEAData2012;
2471	>	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2472	>	}
2473	>	if(ctrl.debug) cout << "rho: " << rho << endl;
2474	>
2475	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2476	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2477	>	ele->Eta(),EffectiveAreaVersion)));
2478	>
2479	>
2480	>	gChargedIso = fChargedIso;
2481	>	gGammaIso = fGammaIso;
2482	>	gNeutralIso = fNeutralHadronIso;
2483	>	return pfIso;
2484	>	}
2485	>
2486	>
2487	>
2488	>	//--------------------------------------------------------------------------------------------------
2489	>	// hacked version
2490	>	float electronPFIso04(ControlFlags &ctrl,
2491	>	const mithep::Electron * ele,
2492	>	const mithep::Vertex * vtx,
2493	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2494	>	float rho,
2495	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2496	>	vector<const mithep::Muon*> muonsToVeto,
2497	>	vector<const mithep::Electron*> electronsToVeto)
2498		//--------------------------------------------------------------------------------------------------
2499		{
2500
#	Line 1191 \| Line 2507 \| float electronPFIso04(ControlFlags &ctrl
2507		<< "\tphi: " << vmu->Phi()
2508		<< endl;
2509		}
2510	<	cout << "electronIsoMVASelection :: electrson to veto " << endl;
2510	>	cout << "electronIsoMVASelection :: electrons to veto " << endl;
2511		for( int i=0; i<electronsToVeto.size(); i++ ) {
2512		const mithep::Electron * vel = electronsToVeto[i];
2513		cout << "\tpt: " << vel->Pt()
#	Line 1206 \| Line 2522 \| float electronPFIso04(ControlFlags &ctrl
2522		//
2523		// final iso
2524		//
2525	<	Double_t fChargedIso;
2526	<	Double_t fGammaIso;
2527	<	Double_t fNeutralHadronIso;
2525	>	Double_t fChargedIso = 0.0;
2526	>	Double_t fGammaIso = 0.0;
2527	>	Double_t fNeutralHadronIso = 0.0;
2528
2529
2530		//
2531		//Loop over PF Candidates
2532		//
2533		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2534	+
2535	+
2536		const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
2537		Double_t deta = (ele->Eta() - pf->Eta());
2538		Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2539		Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2540	<	if (dr >= 0.4) continue;
2540	>
2541	>	if (dr > 0.4) continue;
2542	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2543	>
2544		if(ctrl.debug) {
2545	<	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
2546	<	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
2545	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2546	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
2547	>	<< "\ttrk: " << pf->HasTrackerTrk()
2548	>	<< "\tgsf: " << pf->HasGsfTrk();
2549	>
2550		cout << endl;
2551		}
2552
2553
2554	<	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
2555	<	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
2556	<
2554	>	//
2555	>	// sync : I don't think theyre doing this ...
2556	>	//
2557	>	// if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
2558	>	// (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2559	>	// if( ctrl.debug ) cout << "\tskipping, matches to the electron ..." << endl;
2560	>	// continue;
2561	>	// }
2562	>
2563
2564		//
2565		// Lepton Footprint Removal
#	Line 1242 \| Line 2572 \| float electronPFIso04(ControlFlags &ctrl
2572		//
2573		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2574		const mithep::Electron *tmpele = electronsToVeto[q];
2575	+	/*
2576		// 4l electron
2577		if( pf->HasTrackerTrk() ) {
2578		if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
#	Line 1255 \| Line 2586 \| float electronPFIso04(ControlFlags &ctrl
2586		IsLeptonFootprint = kTRUE;
2587		}
2588		}
2589	+	*/
2590		// PF charged
2591		if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2592		&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
#	Line 1268 \| Line 2600 \| float electronPFIso04(ControlFlags &ctrl
2600		IsLeptonFootprint = kTRUE;
2601		}
2602		} // loop over electrons
2603	<
2603	>
2604	>	/* KH - comment for sync
2605		//
2606		// Check for muons
2607		//
#	Line 1287 \| Line 2620 \| float electronPFIso04(ControlFlags &ctrl
2620		IsLeptonFootprint = kTRUE;
2621		}
2622		} // loop over muons
2623	<
2623	>	*/
2624
2625		if (IsLeptonFootprint)
2626		continue;
2627
2628		//
2629	<	// Charged Iso Rings
2629	>	// Charged Iso
2630		//
2631		if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
2632
2633	<	if( pf->HasTrackerTrk() )
2634	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2635	<	if( pf->HasGsfTrk() )
2636	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2633	>	// if( pf->HasTrackerTrk() )
2634	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2635	>	// if( pf->HasGsfTrk() )
2636	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2637
2638		// Veto any PFmuon, or PFEle
2639	<	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
2639	>	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) {
2640	>	if( ctrl.debug ) cout << "\t skipping, pf is and ele or mu .." <<endl;
2641	>	continue;
2642	>	}
2643
2644		// Footprint Veto
2645		if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
#	Line 1325 \| Line 2661 \| float electronPFIso04(ControlFlags &ctrl
2661		}
2662		if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2663		<< dr << endl;
2664	<	fGammaIso += pf->Pt();
2664	>	// KH, add to sync
2665	>	// if( pf->Pt() > 0.5 )
2666	>	fGammaIso += pf->Pt();
2667		}
2668
2669		//
#	Line 1334 \| Line 2672 \| float electronPFIso04(ControlFlags &ctrl
2672		else {
2673		if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2674		<< dr << endl;
2675	<	fNeutralHadronIso += pf->Pt();
2675	>	// KH, add to sync
2676	>	// if( pf->Pt() > 0.5 )
2677	>	fNeutralHadronIso += pf->Pt();
2678		}
2679
2680		}
2681
2682		}
2683
2684	<	double rho = 0;
2685	<	if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
2686	<	rho = fPUEnergyDensity->At(0)->Rho();
2684	>	// double rho = 0;
2685	>	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
2686	>	// rho = fPUEnergyDensity->At(0)->Rho();
2687
2688		// WARNING!!!!
2689		// hardcode for sync ...
#	Line 1351 \| Line 2691 \| float electronPFIso04(ControlFlags &ctrl
2691		// WARNING!!!!
2692
2693
2694	<	double pfIso = fChargedIso +
2695	<	max(0.0,fGammaIso -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIso04,
2696	<	ele->Eta(),EffectiveAreaVersion)) +
2697	<	max(0.0,fNeutralHadronIso -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIso04,
2698	<	ele->Eta(),EffectiveAreaVersion)) ;
2694	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2695	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2696	>	ele->Eta(),EffectiveAreaVersion)));
2697	>
2698	>
2699	>	gChargedIso = fChargedIso;
2700	>	gGammaIso = fGammaIso;
2701	>	gNeutralIso = fNeutralHadronIso;
2702		return pfIso;
2703		}
2704
2705	+
2706		//--------------------------------------------------------------------------------------------------
2707		SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2708		const mithep::Electron * ele,
2709	<	const mithep::Vertex & vtx,
2709	>	const mithep::Vertex * vtx,
2710		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2711		const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2712		mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
#	Line 1375 \| Line 2719 \| SelectionStatus electronReferenceIsoSele
2719
2720		double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, fPUEnergyDensity,
2721		EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2722	+	// cout << "--------------> setting electron isoPF04 to " << pfIso << endl;
2723	+	status.isoPF04 = pfIso;
2724	+	status.chisoPF04 = gChargedIso;
2725	+	status.gaisoPF04 = gGammaIso;
2726	+	status.neisoPF04 = gNeutralIso;
2727	+
2728		bool pass = false;
2729		if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2730
#	Line 1386 \| Line 2736 \| SelectionStatus electronReferenceIsoSele
2736		return status;
2737
2738		}
2739	+
2740	+
2741	+	//--------------------------------------------------------------------------------------------------
2742	+	// hacked version
2743	+	SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2744	+	const mithep::Electron * ele,
2745	+	const mithep::Vertex * vtx,
2746	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2747	+	float rho,
2748	+	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2749	+	vector<const mithep::Muon*> muonsToVeto,
2750	+	vector<const mithep::Electron*> electronsToVeto)
2751	+	//--------------------------------------------------------------------------------------------------
2752	+	{
2753	+
2754	+	SelectionStatus status;
2755	+
2756	+	double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, rho,
2757	+	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2758	+	status.isoPF04 = pfIso;
2759	+	status.chisoPF04 = gChargedIso;
2760	+	status.gaisoPF04 = gGammaIso;
2761	+	status.neisoPF04 = gNeutralIso;
2762	+	bool pass = false;
2763	+	if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2764	+
2765	+	if( pass ) {
2766	+	status.orStatus(SelectionStatus::LOOSEISO);
2767	+	status.orStatus(SelectionStatus::TIGHTISO);
2768	+	}
2769	+	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2770	+	return status;
2771	+
2772	+	}
2773	+
2774	+
2775	+
2776	+	//--------------------------------------------------------------------------------------------------
2777	+	double dbetaCorrectedIsoDr03(ControlFlags & ctrl,
2778	+	const mithep::PFCandidate * photon,
2779	+	const mithep::Muon * lepton,
2780	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates)
2781	+	//--------------------------------------------------------------------------------------------------
2782	+	{
2783	+
2784	+	//
2785	+	// final iso
2786	+	//
2787	+	Double_t fChargedIso = 0.0;
2788	+	Double_t fGammaIso = 0.0;
2789	+	Double_t fNeutralHadronIso = 0.0;
2790	+	Double_t fpfPU = 0.0;
2791	+
2792	+	//
2793	+	// Loop over PF Candidates
2794	+	//
2795	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2796	+
2797	+	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
2798	+
2799	+	Double_t deta = (photon->Eta() - pf->Eta());
2800	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2801	+	Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2802	+	if (dr > 0.3) continue;
2803	+
2804	+	if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2805	+	if( pf->Pt() >= 0.2 && dr > 0.01 )
2806	+	fpfPU += pf->Pt();
2807	+	continue;
2808	+	}
2809	+
2810	+	//
2811	+	// skip this photon
2812	+	//
2813	+	if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
2814	+	pf->Et() == photon->Et() ) continue;
2815	+
2816	+
2817	+	//
2818	+	// Charged Iso
2819	+	//
2820	+	if (pf->Charge() != 0 ) {
2821	+	if( dr > 0.01 && pf->Pt() >= 0.2 &&
2822	+	!(pf->TrackerTrk() == lepton->TrackerTrk()) )
2823	+	fChargedIso += pf->Pt();
2824	+	}
2825	+
2826	+	//
2827	+	// Gamma Iso
2828	+	//
2829	+	else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
2830	+	if( pf->Pt() > 0.5 && dr > 0.01)
2831	+	fGammaIso += pf->Pt();
2832	+	}
2833	+
2834	+	//
2835	+	// Other Neutrals
2836	+	//
2837	+	else {
2838	+	if( pf->Pt() > 0.5 && dr > 0.01)
2839	+	fNeutralHadronIso += pf->Pt();
2840	+	}
2841	+
2842	+	}
2843	+
2844	+	if( ctrl.debug ) {
2845	+	cout << "photon dbetaIso :: " << endl;
2846	+	cout << "\tfChargedIso: " << fChargedIso
2847	+	<< "\tfGammaIso: " << fGammaIso
2848	+	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
2849	+	<< "\tfpfPU: " << fpfPU
2850	+	<< endl;
2851	+	}
2852	+	double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso - 0.5*fpfPU;
2853	+	return pfIso/photon->Pt();
2854	+	}
2855	+
2856	+
2857	+	//--------------------------------------------------------------------------------------------------
2858	+	double dbetaCorrectedIsoDr03(ControlFlags & ctrl,
2859	+	const mithep::PFCandidate * photon,
2860	+	const mithep::Electron * lepton,
2861	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates)
2862	+	//--------------------------------------------------------------------------------------------------
2863	+	{
2864	+
2865	+	//
2866	+	// final iso
2867	+	//
2868	+	Double_t fChargedIso = 0.0;
2869	+	Double_t fGammaIso = 0.0;
2870	+	Double_t fNeutralHadronIso = 0.0;
2871	+	Double_t fpfPU = 0.0;
2872	+
2873	+	//
2874	+	// Loop over PF Candidates
2875	+	//
2876	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2877	+
2878	+	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
2879	+
2880	+	Double_t deta = (photon->Eta() - pf->Eta());
2881	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2882	+	Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2883	+	if (dr > 0.3) continue;
2884	+
2885	+	if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2886	+	if( pf->Pt() >= 0.2 && dr > 0.01 )
2887	+	fpfPU += pf->Pt();
2888	+	continue;
2889	+	}
2890	+
2891	+	//
2892	+	// skip this photon
2893	+	//
2894	+	if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
2895	+	pf->Et() == photon->Et() ) continue;
2896	+
2897	+
2898	+	//
2899	+	// Charged Iso
2900	+	//
2901	+	if (pf->Charge() != 0 ) {
2902	+	if( dr > 0.01 && pf->Pt() >= 0.2 &&
2903	+	!(pf->TrackerTrk() == lepton->TrackerTrk()) )
2904	+	fChargedIso += pf->Pt();
2905	+	}
2906	+
2907	+	//
2908	+	// Gamma Iso
2909	+	//
2910	+	else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
2911	+	if( pf->Pt() > 0.5 && dr > 0.01)
2912	+	fGammaIso += pf->Pt();
2913	+	}
2914	+
2915	+	//
2916	+	// Other Neutrals
2917	+	//
2918	+	else {
2919	+	if( pf->Pt() > 0.5 && dr > 0.01)
2920	+	fNeutralHadronIso += pf->Pt();
2921	+	}
2922	+
2923	+	}
2924	+
2925	+	if( ctrl.debug ) {
2926	+	cout << "photon dbetaIso :: " << endl;
2927	+	cout << "\tfChargedIso: " << fChargedIso
2928	+	<< "\tfGammaIso: " << fGammaIso
2929	+	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
2930	+	<< "\tfpfPU: " << fpfPU
2931	+	<< endl;
2932	+	}
2933	+	double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso - 0.5*fpfPU;
2934	+	return pfIso/photon->Pt();
2935	+	}
2936	+
2937	+
2938	+
2939	+
2940	+
2941	+	//--------------------------------------------------------------------------------------------------
2942	+	double betaCorrectedIsoDr03(ControlFlags & ctrl,
2943	+	const mithep::PFCandidate * photon,
2944	+	const mithep::Muon * lepton,
2945	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates)
2946	+	//--------------------------------------------------------------------------------------------------
2947	+	{
2948	+
2949	+	//
2950	+	// final iso
2951	+	//
2952	+	Double_t fChargedIso = 0.0;
2953	+	Double_t fGammaIso = 0.0;
2954	+	Double_t fNeutralHadronIso = 0.0;
2955	+	Double_t fpfPU = 0.0;
2956	+
2957	+	//
2958	+	// Loop over PF Candidates
2959	+	//
2960	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2961	+
2962	+	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
2963	+
2964	+	Double_t deta = (photon->Eta() - pf->Eta());
2965	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2966	+	Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2967	+	if (dr > 0.3) continue;
2968	+
2969	+	if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2970	+	if( pf->Pt() >= 0.2 && dr > 0.01 )
2971	+	fpfPU += pf->Pt();
2972	+	continue;
2973	+	}
2974	+
2975	+	//
2976	+	// skip this photon
2977	+	//
2978	+	if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
2979	+	pf->Et() == photon->Et() ) continue;
2980	+
2981	+
2982	+	//
2983	+	// Charged Iso
2984	+	//
2985	+	if (pf->Charge() != 0 ) {
2986	+	if( dr > 0.01 && pf->Pt() >= 0.2 &&
2987	+	!(pf->TrackerTrk() == lepton->TrackerTrk()) )
2988	+	fChargedIso += pf->Pt();
2989	+	}
2990	+
2991	+	//
2992	+	// Gamma Iso
2993	+	//
2994	+	else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
2995	+	if( pf->Pt() > 0.5 && dr > 0.01)
2996	+	fGammaIso += pf->Pt();
2997	+	}
2998	+
2999	+	//
3000	+	// Other Neutrals
3001	+	//
3002	+	else {
3003	+	if( pf->Pt() > 0.5 && dr > 0.01)
3004	+	fNeutralHadronIso += pf->Pt();
3005	+	}
3006	+
3007	+	}
3008	+
3009	+	if( ctrl.debug ) {
3010	+	cout << "photon dbetaIso :: " << endl;
3011	+	cout << "\tfChargedIso: " << fChargedIso
3012	+	<< "\tfGammaIso: " << fGammaIso
3013	+	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
3014	+	<< "\tfpfPU: " << fpfPU
3015	+	<< endl;
3016	+	}
3017	+	double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso + fpfPU;
3018	+	return pfIso/photon->Pt();
3019	+	}
3020	+
3021	+
3022	+	//--------------------------------------------------------------------------------------------------
3023	+	double betaCorrectedIsoDr03(ControlFlags & ctrl,
3024	+	const mithep::PFCandidate * photon,
3025	+	const mithep::Electron * lepton,
3026	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates)
3027	+	//--------------------------------------------------------------------------------------------------
3028	+	{
3029	+
3030	+	//
3031	+	// final iso
3032	+	//
3033	+	Double_t fChargedIso = 0.0;
3034	+	Double_t fGammaIso = 0.0;
3035	+	Double_t fNeutralHadronIso = 0.0;
3036	+	Double_t fpfPU = 0.0;
3037	+
3038	+	//
3039	+	// Loop over PF Candidates
3040	+	//
3041	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
3042	+
3043	+	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
3044	+
3045	+	Double_t deta = (photon->Eta() - pf->Eta());
3046	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
3047	+	Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
3048	+	if (dr > 0.3) continue;
3049	+
3050	+	if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
3051	+	if( pf->Pt() >= 0.2 && dr > 0.01 )
3052	+	fpfPU += pf->Pt();
3053	+	continue;
3054	+	}
3055	+
3056	+	//
3057	+	// skip this photon
3058	+	//
3059	+	if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
3060	+	pf->Et() == photon->Et() ) continue;
3061	+
3062	+
3063	+	//
3064	+	// Charged Iso
3065	+	//
3066	+	if (pf->Charge() != 0 ) {
3067	+	if( dr > 0.01 && pf->Pt() >= 0.2 &&
3068	+	!(pf->TrackerTrk() == lepton->TrackerTrk()) )
3069	+	fChargedIso += pf->Pt();
3070	+	}
3071	+
3072	+	//
3073	+	// Gamma Iso
3074	+	//
3075	+	else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
3076	+	if( pf->Pt() > 0.5 && dr > 0.01)
3077	+	fGammaIso += pf->Pt();
3078	+	}
3079	+
3080	+	//
3081	+	// Other Neutrals
3082	+	//
3083	+	else {
3084	+	if( pf->Pt() > 0.5 && dr > 0.01)
3085	+	fNeutralHadronIso += pf->Pt();
3086	+	}
3087	+
3088	+	}
3089	+
3090	+	if( ctrl.debug ) {
3091	+	cout << "photon dbetaIso :: " << endl;
3092	+	cout << "\tfChargedIso: " << fChargedIso
3093	+	<< "\tfGammaIso: " << fGammaIso
3094	+	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
3095	+	<< "\tfpfPU: " << fpfPU
3096	+	<< endl;
3097	+	}
3098	+	double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso + fpfPU;
3099	+	return pfIso/photon->Pt();
3100	+	}
3101	+
3102	+
3103	+

Diff Legend

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

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents): Revision 1.11 by khahn, Sat May 5 21:43:54 2012 UTC vs. Revision 1.29 by khahn, Sun Jun 3 15:51:51 2012 UTC

Diff Legend

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents):
Revision 1.11 by khahn, Sat May 5 21:43:54 2012 UTC vs.
Revision 1.29 by khahn, Sun Jun 3 15:51:51 2012 UTC