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

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents):
Revision 1.13 by khahn, Thu May 10 00:14:35 2012 UTC vs.
Revision 1.31 by khahn, Tue Jun 12 01:23:03 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 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,
965	+	vector<const mithep::PFCandidate*> photonsToVeto)
966	+	//--------------------------------------------------------------------------------------------------
967	+	{
968	+
969	+	extern double gChargedIso;
970	+	extern double gGammaIso;
971	+	extern double gNeutralIso;
972	+
973	+	//
974	+	// final iso
975	+	//
976	+	Double_t fChargedIso = 0.0;
977	+	Double_t fGammaIso = 0.0;
978	+	Double_t fNeutralHadronIso = 0.0;
979	+
980	+	//
981	+	//Loop over PF Candidates
982	+	//
983	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
984	+
985	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
986	+	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
987	+
988	+	//
989	+	// veto FSR recovered photons
990	+	//
991	+	bool vetoPhoton = false;
992	+	for( int p=0; p<photonsToVeto.size(); p++ ) {
993	+	if( pf == photonsToVeto[p] ) {
994	+	vetoPhoton = true;
995	+	break;
996	+	}
997	+	} if( vetoPhoton ) continue;
998	+	//
999	+	//
1000	+	//
1001	+
1002	+	Double_t deta = (mu->Eta() - pf->Eta());
1003	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
1004	+	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
1005	+	if (dr > 0.4) continue;
1006	+
1007	+	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
1008	+
1009	+	//
1010	+	// Charged Iso
1011	+	//
1012	+	if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1013	+
1014	+	//if( dr < 0.01 ) continue; // only for muon iso mva?
1015	+	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
1016	+	fChargedIso += pf->Pt();
1017	+	}
1018	+
1019	+	//
1020	+	// Gamma Iso
1021	+	//
1022	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1023	+	// KH, add to sync
1024	+	if( pf->Pt() > 0.5 )
1025	+	fGammaIso += pf->Pt();
1026	+	}
1027	+
1028	+	//
1029	+	// Other Neutrals
1030	+	//
1031	+	else {
1032	+	if( pf->Pt() > 0.5 )
1033	+	fNeutralHadronIso += pf->Pt();
1034	+	}
1035	+	}
1036	+
1037	+	double rho=0;
1038	+	if( (EffectiveAreaVersion == mithep::MuonTools::kMuEAFall11MC) \|\|
1039	+	(EffectiveAreaVersion == mithep::MuonTools::kMuEAData2011) ) {
1040	+	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25()) \|\|
1041	+	isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25())))
1042	+	rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25();
1043	+	//rho = fPUEnergyDensity->At(0)->Rho();
1044	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1045	+	EffectiveAreaVersion = mithep::MuonTools::kMuEAData2011;
1046	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1047	+	} else {
1048	+	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral()) \|\|
1049	+	isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral())))
1050	+	rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsCentralNeutral();
1051	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1052	+	EffectiveAreaVersion = mithep::MuonTools::kMuEAData2012;
1053	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
1054	+	}
1055	+	if(ctrl.debug) cout << "rho: " << rho << endl;
1056	+
1057	+	TLorentzVector tmpvec;
1058	+	tmpvec.SetPtEtaPhiM(mu->Pt(),mu->Eta(),mu->Phi(),mu->Mass());
1059	+	for( int p=0; p<photonsToVeto.size(); p++ ) {
1060	+	const mithep::PFCandidate * pf = photonsToVeto[p];
1061	+	TLorentzVector pfvec;
1062	+	pfvec.SetPtEtaPhiM(pf->Pt(),pf->Eta(),pf->Phi(),0.);
1063	+	tmpvec += pfvec;
1064	+	}
1065	+
1066	+	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1067	+	-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1068	+	//tmpvec.Eta(),EffectiveAreaVersion)));
1069	+	mu->Eta(),EffectiveAreaVersion)));
1070	+	gChargedIso = fChargedIso;
1071	+	gGammaIso = fGammaIso;
1072	+	gNeutralIso = fNeutralHadronIso;
1073	+
1074	+	if( ctrl.debug ) {
1075	+	cout << "PFiso: " << pfIso
1076	+	<< "\tfChargedIso: " << fChargedIso
1077	+	<< "\tfGammaIso: " << fGammaIso
1078	+	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
1079	+	<< endl;
1080	+	}
1081	+
1082	+	return pfIso;
1083	+	}
1084	+
1085	+
1086	+
1087	+
1088	+	//--------------------------------------------------------------------------------------------------
1089	+	// hacked version
1090	+	double muonPFIso04(ControlFlags &ctrl,
1091	+	const mithep::Muon * mu,
1092	+	const mithep::Vertex * vtx,
1093	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1094	+	float rho,
1095	+	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1096		vector<const mithep::Muon*> muonsToVeto,
1097		vector<const mithep::Electron*> electronsToVeto)
1098		//--------------------------------------------------------------------------------------------------
1099		{
1100	+
1101	+	extern double gChargedIso;
1102	+	extern double gGammaIso;
1103	+	extern double gNeutralIso;
1104
1105		if( ctrl.debug ) {
1106		cout << "muonIsoMVASelection :: muons to veto " << endl;
#	Line 624 \| Line 1132 \| double muonPFIso04(ControlFlags &ctrl,
1132		//Loop over PF Candidates
1133		//
1134		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1135	+
1136	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1137		const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1138
1139		Double_t deta = (mu->Eta() - pf->Eta());
#	Line 662 \| Line 1172 \| double muonPFIso04(ControlFlags &ctrl,
1172		&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
1173		IsLeptonFootprint = kTRUE;
1174		} // loop over electrons
1175	<
1175	>
1176	>	/* KH - comment for sync
1177		//
1178		// Check for muons
1179		//
#	Line 677 \| Line 1188 \| double muonPFIso04(ControlFlags &ctrl,
1188		if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
1189		IsLeptonFootprint = kTRUE;
1190		} // loop over muons
1191	<
1191	>	*/
1192
1193		if (IsLeptonFootprint)
1194		continue;
1195
1196		//
1197	<	// Charged Iso Rings
1197	>	// Charged Iso
1198		//
1199		if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1200
1201	<	if( dr < 0.01 ) continue; // only for muon iso mva?
1201	>	//if( dr < 0.01 ) continue; // only for muon iso mva?
1202		if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
1203
1204	<	if( pf->HasTrackerTrk() ) {
1205	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1206	<	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1207	<	<< abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1208	<	<< dr << endl;
1209	<	}
1210	<	if( pf->HasGsfTrk() ) {
1211	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1212	<	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1213	<	<< abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1214	<	<< dr << endl;
1215	<	}
1204	>
1205	>	// if( pf->HasTrackerTrk() ) {
1206	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1207	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1208	>	// << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1209	>	// << dr << endl;
1210	>	// }
1211	>	// if( pf->HasGsfTrk() ) {
1212	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1213	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1214	>	// << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1215	>	// << dr << endl;
1216	>	// }
1217
1218
1219		fChargedIso += pf->Pt();
#	Line 711 \| Line 1223 \| double muonPFIso04(ControlFlags &ctrl,
1223		// Gamma Iso
1224		//
1225		else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1226	+	// KH, add to sync
1227	+	if( pf->Pt() > 0.5 )
1228		fGammaIso += pf->Pt();
1229		}
1230
1231		//
1232	<	// Other Neutral Iso Rings
1232	>	// Other Neutrals
1233		//
1234		else {
1235	<	fNeutralHadronIso += pf->Pt();
1235	>	// KH, add to sync
1236	>	if( pf->Pt() > 0.5 )
1237	>	fNeutralHadronIso += pf->Pt();
1238		}
1239
1240		}
1241
1242		}
1243
1244	<	double rho = 0;
1245	<	if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
1246	<	rho = fPUEnergyDensity->At(0)->Rho();
1244	>	// double rho = 0;
1245	>	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
1246	>	// rho = fPUEnergyDensity->At(0)->Rho();
1247
1248		// WARNING!!!!
1249		// hardcode for sync ...
#	Line 735 \| Line 1251 \| double muonPFIso04(ControlFlags &ctrl,
1251		// WARNING!!!!
1252
1253
1254	<	double pfIso = fChargedIso + max(0.0,(fGammaIso + fNeutralHadronIso
1254	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1255		-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1256		mu->Eta(),EffectiveAreaVersion)));
1257	+	gChargedIso = fChargedIso;
1258	+	gGammaIso = fGammaIso;
1259	+	gNeutralIso = fNeutralHadronIso;
1260
1261		return pfIso;
1262		}
1263
1264	+
1265		//--------------------------------------------------------------------------------------------------
1266		SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1267		const mithep::Muon * mu,
1268	<	const mithep::Vertex & vtx,
1268	>	const mithep::Vertex * vtx,
1269		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1270		const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1271		mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1272	+	vector<const mithep::PFCandidate*> photonsToVeto)
1273	+	//--------------------------------------------------------------------------------------------------
1274	+	{
1275	+
1276	+	SelectionStatus status;
1277	+
1278	+	double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, fPUEnergyDensity,
1279	+	EffectiveAreaVersion, photonsToVeto);
1280	+	// cout << "--------------> setting muon isoPF04 to" << pfIso << endl;
1281	+	status.isoPF04 = pfIso;
1282	+	status.chisoPF04 = gChargedIso;
1283	+	status.gaisoPF04 = gGammaIso;
1284	+	status.neisoPF04 = gNeutralIso;
1285	+
1286	+	bool pass = false;
1287	+	if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1288	+
1289	+	if( pass ) {
1290	+	status.orStatus(SelectionStatus::LOOSEISO);
1291	+	status.orStatus(SelectionStatus::TIGHTISO);
1292	+	}
1293	+	if(ctrl.debug) {
1294	+	cout << "mu relpfIso: " << pfIso/mu->Pt() << endl;
1295	+	cout << "returning status : " << hex << status.getStatus() << dec << endl;
1296	+	}
1297	+	return status;
1298	+
1299	+	}
1300	+
1301	+
1302	+	//--------------------------------------------------------------------------------------------------
1303	+	// hacked version
1304	+	SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1305	+	const mithep::Muon * mu,
1306	+	const mithep::Vertex * vtx,
1307	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1308	+	float rho,
1309	+	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1310		vector<const mithep::Muon*> muonsToVeto,
1311		vector<const mithep::Electron*> electronsToVeto)
1312		//--------------------------------------------------------------------------------------------------
#	Line 756 \| Line 1314 \| SelectionStatus muonReferenceIsoSelectio
1314
1315		SelectionStatus status;
1316
1317	<	double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, fPUEnergyDensity,
1317	>	double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, rho,
1318		EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1319	+
1320	+	status.isoPF04 = pfIso;
1321	+	status.chisoPF04 = gChargedIso;
1322	+	status.gaisoPF04 = gGammaIso;
1323	+	status.neisoPF04 = gNeutralIso;
1324	+
1325		bool pass = false;
1326		if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1327
#	Line 772 \| Line 1336 \| SelectionStatus muonReferenceIsoSelectio
1336
1337
1338
1339	+
1340		//--------------------------------------------------------------------------------------------------
1341		SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1342		const mithep::Electron * ele,
1343	<	const mithep::Vertex & vtx,
1343	>	const mithep::Vertex * vtx,
1344		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1345		const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1346		mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
#	Line 814 \| Line 1379 \| SelectionStatus electronIsoMVASelection(
1379		Double_t tmpChargedIso_DR0p2To0p3 = 0;
1380		Double_t tmpChargedIso_DR0p3To0p4 = 0;
1381		Double_t tmpChargedIso_DR0p4To0p5 = 0;
817	–	Double_t tmpChargedIso_DR0p5To0p7 = 0;
1382
1383		Double_t tmpGammaIso_DR0p0To0p1 = 0;
1384		Double_t tmpGammaIso_DR0p1To0p2 = 0;
1385		Double_t tmpGammaIso_DR0p2To0p3 = 0;
1386		Double_t tmpGammaIso_DR0p3To0p4 = 0;
1387		Double_t tmpGammaIso_DR0p4To0p5 = 0;
1388	<	Double_t tmpGammaIso_DR0p5To0p7 = 0;
1388	>
1389
1390		Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
1391		Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
1392		Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
1393		Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
1394		Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
831	–	Double_t tmpNeutralHadronIso_DR0p5To0p7 = 0;
1395
1396
1397
#	Line 858 \| Line 1421 \| SelectionStatus electronIsoMVASelection(
1421		//Loop over PF Candidates
1422		//
1423		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1424	+
1425	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1426	+
1427		const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1428		Double_t deta = (ele->Eta() - pf->Eta());
1429		Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1430		Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1431	<	if (dr >= 0.5) continue;
1431	>	if (dr > 1.0) continue;
1432	>
1433		if(ctrl.debug) {
1434		cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1435	<	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
1435	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1436		cout << endl;
1437		}
1438
#	Line 880 \| Line 1447 \| SelectionStatus electronIsoMVASelection(
1447		Bool_t IsLeptonFootprint = kFALSE;
1448		if (dr < 1.0) {
1449
1450	+
1451		//
1452		// Check for electrons
1453		//
1454	+
1455		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1456		const mithep::Electron *tmpele = electronsToVeto[q];
1457	+	double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1458	+
1459		// 4l electron
1460		if( pf->HasTrackerTrk() ) {
1461		if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
#	Line 899 \| Line 1470 \| SelectionStatus electronIsoMVASelection(
1470		}
1471		}
1472		// PF charged
1473	<	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
903	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1473	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1474		if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1475		IsLeptonFootprint = kTRUE;
1476		}
1477		// PF gamma
1478	<	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1479	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
1478	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1479	>	&& tmpdr < 0.08) {
1480		if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1481		IsLeptonFootprint = kTRUE;
1482		}
1483		} // loop over electrons
1484	<
1484	>
1485	>
1486	>	/* KH - comment for sync
1487		//
1488		// Check for muons
1489		//
#	Line 930 \| Line 1502 \| SelectionStatus electronIsoMVASelection(
1502		IsLeptonFootprint = kTRUE;
1503		}
1504		} // loop over muons
1505	<
1505	>	*/
1506
1507		if (IsLeptonFootprint)
1508		continue;
#	Line 940 \| Line 1512 \| SelectionStatus electronIsoMVASelection(
1512		//
1513		if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1514
1515	<	if( pf->HasTrackerTrk() )
1516	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1517	<	if( pf->HasGsfTrk() )
1518	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1515	>	// if( pf->HasGsfTrk() ) {
1516	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1517	>	// } else if( pf->HasTrackerTrk() ){
1518	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1519	>	// }
1520
1521		// Veto any PFmuon, or PFEle
1522		if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
#	Line 960 \| Line 1533 \| SelectionStatus electronIsoMVASelection(
1533		if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1534		if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1535		if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
963	–	if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
1536
1537		}
1538
#	Line 969 \| Line 1541 \| SelectionStatus electronIsoMVASelection(
1541		//
1542		else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1543
1544	<	if (fabs(ele->SCluster()->Eta()) > 1.479) {
973	<	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
974	<	}
1544	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
1545
1546		if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1547		<< dr << endl;
#	Line 981 \| Line 1551 \| SelectionStatus electronIsoMVASelection(
1551		if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1552		if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1553		if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
984	–	if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
985	–
1554		}
1555
1556		//
#	Line 996 \| Line 1564 \| SelectionStatus electronIsoMVASelection(
1564		if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1565		if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1566		if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
999	–	if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
1567		}
1568
1569		}
1570
1571		}
1572
1573	<	fChargedIso_DR0p0To0p1 = min((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1574	<	fChargedIso_DR0p1To0p2 = min((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1575	<	fChargedIso_DR0p2To0p3 = min((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1576	<	fChargedIso_DR0p3To0p4 = min((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1577	<	fChargedIso_DR0p4To0p5 = min((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1573	>	fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1574	>	fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1575	>	fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1576	>	fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1577	>	fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1578	>
1579	>	if(ctrl.debug) {
1580	>	cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1 << endl;
1581	>	cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2 << endl;
1582	>	cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3 << endl;
1583	>	cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4 << endl;
1584	>	cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5 << endl;
1585	>	}
1586	>
1587
1588		double rho = 0;
1589		if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
1590		rho = fPUEnergyDensity->At(0)->Rho();
1591	+	// if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1592	+	// rho = fPUEnergyDensity->At(0)->RhoLowEta();
1593	+
1594	+	// WARNING!!!!
1595	+	// hardcode for sync ...
1596	+	EffectiveAreaVersion = eleT.kEleEAData2011;
1597	+	// WARNING!!!!
1598	+
1599	+	if( ctrl.debug) {
1600	+	cout << "RHO: " << rho << endl;
1601	+	cout << "eta: " << ele->SCluster()->Eta() << endl;
1602	+	cout << "target: " << EffectiveAreaVersion << endl;
1603	+	cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1604	+	ele->SCluster()->Eta(),
1605	+	EffectiveAreaVersion)
1606	+	<< endl;
1607	+	cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1608	+	ele->SCluster()->Eta(),
1609	+	EffectiveAreaVersion)
1610	+	<< endl;
1611	+	cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1612	+	ele->SCluster()->Eta(),
1613	+	EffectiveAreaVersion)
1614	+	<< endl;
1615	+	cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1616	+	ele->SCluster()->Eta(),
1617	+	EffectiveAreaVersion)
1618	+	<< endl;
1619	+	}
1620	+
1621	+	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
1622	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
1623	+	ele->SCluster()->Eta(),
1624	+	EffectiveAreaVersion))/ele->Pt()
1625	+	,2.5)
1626	+	,0.0);
1627	+	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
1628	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
1629	+	ele->SCluster()->Eta(),
1630	+	EffectiveAreaVersion))/ele->Pt()
1631	+	,2.5)
1632	+	,0.0);
1633	+	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
1634	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
1635	+	ele->SCluster()->Eta()
1636	+	,EffectiveAreaVersion))/ele->Pt()
1637	+	,2.5)
1638	+	,0.0);
1639	+	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
1640	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
1641	+	ele->SCluster()->Eta(),
1642	+	EffectiveAreaVersion))/ele->Pt()
1643	+	,2.5)
1644	+	,0.0);
1645	+	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
1646	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
1647	+	ele->SCluster()->Eta(),
1648	+	EffectiveAreaVersion))/ele->Pt()
1649	+	,2.5)
1650	+	,0.0);
1651	+
1652	+
1653	+	if( ctrl.debug) {
1654	+	cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
1655	+	cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
1656	+	cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
1657	+	cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
1658	+	cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
1659	+	}
1660	+
1661	+	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
1662	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1663	+	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1664	+	, 2.5)
1665	+	, 0.0);
1666	+	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
1667	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1668	+	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1669	+	, 2.5)
1670	+	, 0.0);
1671	+	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
1672	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1673	+	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1674	+	, 2.5)
1675	+	, 0.0);
1676	+	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
1677	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1678	+	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1679	+	, 2.5)
1680	+	, 0.0);
1681	+	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
1682	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
1683	+	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1684	+	, 2.5)
1685	+	, 0.0);
1686	+
1687	+	if( ctrl.debug) {
1688	+	cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
1689	+	cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
1690	+	cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
1691	+	cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
1692	+	cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
1693	+	}
1694	+
1695	+	double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
1696	+	ele->SCluster()->Eta(),
1697	+	fChargedIso_DR0p0To0p1,
1698	+	fChargedIso_DR0p1To0p2,
1699	+	fChargedIso_DR0p2To0p3,
1700	+	fChargedIso_DR0p3To0p4,
1701	+	fChargedIso_DR0p4To0p5,
1702	+	fGammaIso_DR0p0To0p1,
1703	+	fGammaIso_DR0p1To0p2,
1704	+	fGammaIso_DR0p2To0p3,
1705	+	fGammaIso_DR0p3To0p4,
1706	+	fGammaIso_DR0p4To0p5,
1707	+	fNeutralHadronIso_DR0p0To0p1,
1708	+	fNeutralHadronIso_DR0p1To0p2,
1709	+	fNeutralHadronIso_DR0p2To0p3,
1710	+	fNeutralHadronIso_DR0p3To0p4,
1711	+	fNeutralHadronIso_DR0p4To0p5,
1712	+	ctrl.debug);
1713	+
1714	+	SelectionStatus status;
1715	+	status.isoMVA = mvaval;
1716	+	bool pass = false;
1717	+
1718	+	Int_t subdet = 0;
1719	+	if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
1720	+	else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
1721	+	else subdet = 2;
1722	+
1723	+	Int_t ptBin = 0;
1724	+	if (ele->Pt() >= 10.0) ptBin = 1;
1725	+
1726	+	Int_t MVABin = -1;
1727	+	if (subdet == 0 && ptBin == 0) MVABin = 0;
1728	+	if (subdet == 1 && ptBin == 0) MVABin = 1;
1729	+	if (subdet == 2 && ptBin == 0) MVABin = 2;
1730	+	if (subdet == 0 && ptBin == 1) MVABin = 3;
1731	+	if (subdet == 1 && ptBin == 1) MVABin = 4;
1732	+	if (subdet == 2 && ptBin == 1) MVABin = 5;
1733	+
1734	+	pass = false;
1735	+	if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN0 ) pass = true;
1736	+	if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN1 ) pass = true;
1737	+	if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN2 ) pass = true;
1738	+	if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN3 ) pass = true;
1739	+	if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN4 ) pass = true;
1740	+	if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN5 ) pass = true;
1741	+	// pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
1742	+	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
1743	+
1744	+	// pass = false;
1745	+	// if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
1746	+	// if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
1747	+	// if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
1748	+	// if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
1749	+	// if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
1750	+	// if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
1751	+	// if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
1752	+
1753	+	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1754	+	return status;
1755	+
1756	+	}
1757	+
1758	+
1759	+	//--------------------------------------------------------------------------------------------------
1760	+	SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1761	+	const mithep::Electron * ele,
1762	+	const mithep::Vertex * vtx,
1763	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1764	+	float rho,
1765	+	//const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1766	+	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1767	+	vector<const mithep::Muon*> muonsToVeto,
1768	+	vector<const mithep::Electron*> electronsToVeto)
1769	+	//--------------------------------------------------------------------------------------------------
1770	+	// hacked version
1771	+	{
1772	+	if( ctrl.debug ) {
1773	+	cout << "================> hacked ele Iso MVA <======================" << endl;
1774	+	}
1775	+
1776	+	if( ctrl.debug ) {
1777	+	cout << "electronIsoMVASelection :: muons to veto " << endl;
1778	+	for( int i=0; i<muonsToVeto.size(); i++ ) {
1779	+	const mithep::Muon * vmu = muonsToVeto[i];
1780	+	cout << "\tpt: " << vmu->Pt()
1781	+	<< "\teta: " << vmu->Eta()
1782	+	<< "\tphi: " << vmu->Phi()
1783	+	<< endl;
1784	+	}
1785	+	cout << "electronIsoMVASelection :: electrson to veto " << endl;
1786	+	for( int i=0; i<electronsToVeto.size(); i++ ) {
1787	+	const mithep::Electron * vel = electronsToVeto[i];
1788	+	cout << "\tpt: " << vel->Pt()
1789	+	<< "\teta: " << vel->Eta()
1790	+	<< "\tphi: " << vel->Phi()
1791	+	<< "\ttrk: " << vel->TrackerTrk()
1792	+	<< endl;
1793	+	}
1794	+	}
1795	+
1796	+	bool failiso=false;
1797	+
1798	+	//
1799	+	// tmp iso rings
1800	+	//
1801	+	Double_t tmpChargedIso_DR0p0To0p1 = 0;
1802	+	Double_t tmpChargedIso_DR0p1To0p2 = 0;
1803	+	Double_t tmpChargedIso_DR0p2To0p3 = 0;
1804	+	Double_t tmpChargedIso_DR0p3To0p4 = 0;
1805	+	Double_t tmpChargedIso_DR0p4To0p5 = 0;
1806	+
1807	+	Double_t tmpGammaIso_DR0p0To0p1 = 0;
1808	+	Double_t tmpGammaIso_DR0p1To0p2 = 0;
1809	+	Double_t tmpGammaIso_DR0p2To0p3 = 0;
1810	+	Double_t tmpGammaIso_DR0p3To0p4 = 0;
1811	+	Double_t tmpGammaIso_DR0p4To0p5 = 0;
1812	+
1813	+
1814	+	Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
1815	+	Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
1816	+	Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
1817	+	Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
1818	+	Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
1819	+
1820	+
1821	+
1822	+	//
1823	+	// final rings for the MVA
1824	+	//
1825	+	Double_t fChargedIso_DR0p0To0p1;
1826	+	Double_t fChargedIso_DR0p1To0p2;
1827	+	Double_t fChargedIso_DR0p2To0p3;
1828	+	Double_t fChargedIso_DR0p3To0p4;
1829	+	Double_t fChargedIso_DR0p4To0p5;
1830	+
1831	+	Double_t fGammaIso_DR0p0To0p1;
1832	+	Double_t fGammaIso_DR0p1To0p2;
1833	+	Double_t fGammaIso_DR0p2To0p3;
1834	+	Double_t fGammaIso_DR0p3To0p4;
1835	+	Double_t fGammaIso_DR0p4To0p5;
1836	+
1837	+	Double_t fNeutralHadronIso_DR0p0To0p1;
1838	+	Double_t fNeutralHadronIso_DR0p1To0p2;
1839	+	Double_t fNeutralHadronIso_DR0p2To0p3;
1840	+	Double_t fNeutralHadronIso_DR0p3To0p4;
1841	+	Double_t fNeutralHadronIso_DR0p4To0p5;
1842	+
1843	+
1844	+	//
1845	+	//Loop over PF Candidates
1846	+	//
1847	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1848	+
1849	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1850	+
1851	+	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1852	+	Double_t deta = (ele->Eta() - pf->Eta());
1853	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1854	+	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1855	+	if (dr > 1.0) continue;
1856	+
1857	+	if(ctrl.debug) {
1858	+	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1859	+	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx);
1860	+	cout << endl;
1861	+	}
1862	+
1863	+
1864	+	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
1865	+	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1866	+
1867	+
1868	+	//
1869	+	// Lepton Footprint Removal
1870	+	//
1871	+	Bool_t IsLeptonFootprint = kFALSE;
1872	+	if (dr < 1.0) {
1873	+
1874	+
1875	+	//
1876	+	// Check for electrons
1877	+	//
1878	+
1879	+	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1880	+	const mithep::Electron *tmpele = electronsToVeto[q];
1881	+	double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1882	+
1883	+	// 4l electron
1884	+	if( pf->HasTrackerTrk() ) {
1885	+	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1886	+	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1887	+	IsLeptonFootprint = kTRUE;
1888	+	}
1889	+	}
1890	+	if( pf->HasGsfTrk() ) {
1891	+	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1892	+	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1893	+	IsLeptonFootprint = kTRUE;
1894	+	}
1895	+	}
1896	+	// PF charged
1897	+	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1898	+	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1899	+	IsLeptonFootprint = kTRUE;
1900	+	}
1901	+	// PF gamma
1902	+	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1903	+	&& tmpdr < 0.08) {
1904	+	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1905	+	IsLeptonFootprint = kTRUE;
1906	+	}
1907	+	} // loop over electrons
1908	+
1909	+
1910	+	/* KH - comment for sync
1911	+	//
1912	+	// Check for muons
1913	+	//
1914	+	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1915	+	const mithep::Muon *tmpmu = muonsToVeto[q];
1916	+	// 4l muon
1917	+	if( pf->HasTrackerTrk() ) {
1918	+	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1919	+	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1920	+	IsLeptonFootprint = kTRUE;
1921	+	}
1922	+	}
1923	+	// PF charged
1924	+	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1925	+	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1926	+	IsLeptonFootprint = kTRUE;
1927	+	}
1928	+	} // loop over muons
1929	+	*/
1930	+
1931	+	if (IsLeptonFootprint)
1932	+	continue;
1933	+
1934	+	//
1935	+	// Charged Iso Rings
1936	+	//
1937	+	if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1938	+
1939	+	// if( pf->HasGsfTrk() ) {
1940	+	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1941	+	// } else if( pf->HasTrackerTrk() ){
1942	+	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1943	+	// }
1944	+
1945	+	// Veto any PFmuon, or PFEle
1946	+	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
1947	+
1948	+	// Footprint Veto
1949	+	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1950	+
1951	+	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1952	+	<< "\ttype: " << pf->PFType()
1953	+	<< "\ttrk: " << pf->TrackerTrk() << endl;
1954	+
1955	+	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
1956	+	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
1957	+	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1958	+	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1959	+	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
1960	+
1961	+	}
1962	+
1963	+	//
1964	+	// Gamma Iso Rings
1965	+	//
1966	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1967	+
1968	+	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
1969	+
1970	+	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1971	+	<< dr << endl;
1972	+
1973	+	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
1974	+	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
1975	+	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1976	+	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1977	+	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
1978	+	}
1979	+
1980	+	//
1981	+	// Other Neutral Iso Rings
1982	+	//
1983	+	else {
1984	+	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
1985	+	<< dr << endl;
1986	+	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
1987	+	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
1988	+	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1989	+	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1990	+	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
1991	+	}
1992	+
1993	+	}
1994	+
1995	+	}
1996	+
1997	+	fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1998	+	fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1999	+	fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
2000	+	fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
2001	+	fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
2002	+
2003	+	if(ctrl.debug) {
2004	+	cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1 << endl;
2005	+	cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2 << endl;
2006	+	cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3 << endl;
2007	+	cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4 << endl;
2008	+	cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5 << endl;
2009	+	}
2010	+
2011	+
2012	+	// rho=0;
2013	+	// double rho = 0;
2014	+	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
2015	+	// rho = fPUEnergyDensity->At(0)->Rho();
2016	+	// if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
2017	+	// rho = fPUEnergyDensity->At(0)->RhoLowEta();
2018	+
2019	+	// WARNING!!!!
2020	+	// hardcode for sync ...
2021	+	EffectiveAreaVersion = eleT.kEleEAData2011;
2022	+	// WARNING!!!!
2023
2024		if( ctrl.debug) {
2025		cout << "RHO: " << rho << endl;
#	Line 1035 \| Line 2043 \| SelectionStatus electronIsoMVASelection(
2043		<< endl;
2044		}
2045
2046	<	fGammaIso_DR0p0To0p1 = max(min((tmpGammaIso_DR0p0To0p1
2046	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
2047		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
2048		ele->SCluster()->Eta(),
2049		EffectiveAreaVersion))/ele->Pt()
2050		,2.5)
2051		,0.0);
2052	<	fGammaIso_DR0p1To0p2 = max(min((tmpGammaIso_DR0p1To0p2
2052	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
2053		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
2054		ele->SCluster()->Eta(),
2055		EffectiveAreaVersion))/ele->Pt()
2056		,2.5)
2057		,0.0);
2058	<	fGammaIso_DR0p2To0p3 = max(min((tmpGammaIso_DR0p2To0p3
2058	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
2059		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
2060		ele->SCluster()->Eta()
2061		,EffectiveAreaVersion))/ele->Pt()
2062		,2.5)
2063		,0.0);
2064	<	fGammaIso_DR0p3To0p4 = max(min((tmpGammaIso_DR0p3To0p4
2064	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
2065		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
2066		ele->SCluster()->Eta(),
2067		EffectiveAreaVersion))/ele->Pt()
2068		,2.5)
2069		,0.0);
2070	<	fGammaIso_DR0p4To0p5 = max(min((tmpGammaIso_DR0p4To0p5
2070	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
2071		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
2072		ele->SCluster()->Eta(),
2073		EffectiveAreaVersion))/ele->Pt()
#	Line 1067 \| Line 2075 \| SelectionStatus electronIsoMVASelection(
2075		,0.0);
2076
2077
2078	<	fNeutralHadronIso_DR0p0To0p1 = max(min((tmpNeutralHadronIso_DR0p0To0p1
2078	>	if( ctrl.debug) {
2079	>	cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
2080	>	cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
2081	>	cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
2082	>	cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
2083	>	cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
2084	>	}
2085	>
2086	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
2087		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
2088		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2089		, 2.5)
2090		, 0.0);
2091	<	fNeutralHadronIso_DR0p1To0p2 = max(min((tmpNeutralHadronIso_DR0p1To0p2
2091	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
2092		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
2093		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2094		, 2.5)
2095		, 0.0);
2096	<	fNeutralHadronIso_DR0p2To0p3 = max(min((tmpNeutralHadronIso_DR0p2To0p3
2096	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
2097		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
2098		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2099		, 2.5)
2100		, 0.0);
2101	<	fNeutralHadronIso_DR0p3To0p4 = max(min((tmpNeutralHadronIso_DR0p3To0p4
2101	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
2102		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
2103		ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2104		, 2.5)
2105		, 0.0);
2106	<	fNeutralHadronIso_DR0p4To0p5 = max(min((tmpNeutralHadronIso_DR0p4To0p5
2106	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
2107		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
2108		ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2109		, 2.5)
2110		, 0.0);
2111
2112	+	if( ctrl.debug) {
2113	+	cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
2114	+	cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
2115	+	cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
2116	+	cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
2117	+	cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
2118	+	}
2119	+
2120		double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
2121		ele->SCluster()->Eta(),
2122		fChargedIso_DR0p0To0p1,
#	Line 1113 \| Line 2137 \| SelectionStatus electronIsoMVASelection(
2137		ctrl.debug);
2138
2139		SelectionStatus status;
2140	+	status.isoMVA = mvaval;
2141		bool pass = false;
2142
2143		Int_t subdet = 0;
2144		if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
2145		else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
2146		else subdet = 2;
2147	+
2148		Int_t ptBin = 0;
2149	<	if (ele->Pt() > 10.0) ptBin = 1;
2149	>	if (ele->Pt() >= 10.0) ptBin = 1;
2150
2151		Int_t MVABin = -1;
2152		if (subdet == 0 && ptBin == 0) MVABin = 0;
#	Line 1139 \| Line 2165 \| SelectionStatus electronIsoMVASelection(
2165		if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN5 ) pass = true;
2166		if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
2167
2168	<	pass = false;
2169	<	if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
2170	<	if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
2171	<	if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
2172	<	if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
2173	<	if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
2174	<	if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
2175	<	if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
2168	>	// pass = false;
2169	>	// if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
2170	>	// if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
2171	>	// if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
2172	>	// if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
2173	>	// if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
2174	>	// if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
2175	>	// if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
2176
2177		if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2178		return status;
#	Line 1170 \| Line 2196 \| void initElectronIsoMVA() {
2196
2197
2198
2199	+
2200	+	//--------------------------------------------------------------------------------------------------
2201	+	float electronPFIso04(ControlFlags &ctrl,
2202	+	const mithep::Electron * ele,
2203	+	const mithep::Vertex * vtx,
2204	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2205	+	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2206	+	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2207	+	vector<const mithep::PFCandidate*> photonsToVeto)
2208	+	//--------------------------------------------------------------------------------------------------
2209	+	{
2210	+
2211	+	//
2212	+	// final iso
2213	+	//
2214	+	Double_t fChargedIso = 0.0;
2215	+	Double_t fGammaIso = 0.0;
2216	+	Double_t fNeutralHadronIso = 0.0;
2217	+
2218	+
2219	+	//
2220	+	//Loop over PF Candidates
2221	+	//
2222	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2223	+
2224	+	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
2225	+
2226	+	//
2227	+	// veto FSR recovered photons
2228	+	//
2229	+	bool vetoPhoton = false;
2230	+	for( int p=0; p<photonsToVeto.size(); p++ ) {
2231	+	if( pf == photonsToVeto[p] ) {
2232	+	vetoPhoton = true;
2233	+	break;
2234	+	}
2235	+	} if( vetoPhoton ) continue;
2236	+
2237	+	Double_t deta = (ele->Eta() - pf->Eta());
2238	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2239	+	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2240	+
2241	+	if (dr > 0.4) continue;
2242	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2243	+
2244	+	if(ctrl.debug) {
2245	+	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2246	+	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
2247	+	<< "\ttrk: " << pf->HasTrackerTrk()
2248	+	<< "\tgsf: " << pf->HasGsfTrk();
2249	+
2250	+	cout << endl;
2251	+	}
2252	+
2253	+
2254	+	//
2255	+	// sync : I don't think theyre doing this ...
2256	+	//
2257	+	// if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
2258	+	// (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2259	+	// if( ctrl.debug ) cout << "\tskipping, matches to the electron ..." << endl;
2260	+	// continue;
2261	+	// }
2262	+
2263	+
2264	+	//
2265	+	// Lepton Footprint Removal
2266	+	//
2267	+	Bool_t IsLeptonFootprint = kFALSE;
2268	+	if (dr < 1.0) {
2269	+
2270	+
2271	+	//
2272	+	// Charged Iso
2273	+	//
2274	+	if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
2275	+
2276	+	// Veto any PFmuon, or PFEle
2277	+	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) {
2278	+	if( ctrl.debug ) cout << "\t skipping, pf is and ele or mu .." <<endl;
2279	+	continue;
2280	+	}
2281	+
2282	+	// Footprint Veto
2283	+	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
2284	+
2285	+	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
2286	+	<< "\ttype: " << pf->PFType()
2287	+	<< "\ttrk: " << pf->TrackerTrk() << endl;
2288	+
2289	+	fChargedIso += pf->Pt();
2290	+	}
2291	+
2292	+	//
2293	+	// Gamma Iso
2294	+	//
2295	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2296	+
2297	+	if (fabs(ele->SCluster()->Eta()) > 1.479) {
2298	+	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
2299	+	}
2300	+	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2301	+	<< dr << endl;
2302	+	// KH, add to sync
2303	+	// if( pf->Pt() > 0.5 )
2304	+	fGammaIso += pf->Pt();
2305	+	}
2306	+
2307	+	//
2308	+	// Neutral Iso
2309	+	//
2310	+	else {
2311	+	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2312	+	<< dr << endl;
2313	+	// KH, add to sync
2314	+	// if( pf->Pt() > 0.5 )
2315	+	fNeutralHadronIso += pf->Pt();
2316	+	}
2317	+
2318	+	}
2319	+
2320	+	}
2321	+
2322	+
2323	+	double rho=0;
2324	+	if( (EffectiveAreaVersion == mithep::ElectronTools::kEleEAFall11MC) \|\|
2325	+	(EffectiveAreaVersion == mithep::ElectronTools::kEleEAData2011) ) {
2326	+	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25()) \|\|
2327	+	isinf(fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25())))
2328	+	rho = fPUEnergyDensity->At(0)->RhoKt6PFJetsForIso25();
2329	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2330	+	EffectiveAreaVersion = mithep::ElectronTools::kEleEAData2011;
2331	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2332	+	} else {
2333	+	if (!(isnan(fPUEnergyDensity->At(0)->RhoKt6PFJets()) \|\|
2334	+	isinf(fPUEnergyDensity->At(0)->RhoKt6PFJets())))
2335	+	rho = fPUEnergyDensity->At(0)->RhoKt6PFJets();
2336	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2337	+	EffectiveAreaVersion = mithep::ElectronTools::kEleEAData2012;
2338	+	// !!!!!!!!!!!!! TMP HACK FOR SYNC !!!!!!!!!!!!!!!!!!!!!
2339	+	}
2340	+	if(ctrl.debug) cout << "rho: " << rho << endl;
2341	+
2342	+	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2343	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2344	+	ele->Eta(),EffectiveAreaVersion)));
2345	+
2346	+
2347	+	gChargedIso = fChargedIso;
2348	+	gGammaIso = fGammaIso;
2349	+	gNeutralIso = fNeutralHadronIso;
2350	+
2351	+	if( ctrl.debug ) {
2352	+	cout << "PFiso: " << pfIso
2353	+	<< "\tfChargedIso: " << fChargedIso
2354	+	<< "\tfGammaIso: " << fGammaIso
2355	+	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
2356	+	<< endl;
2357	+	}
2358	+
2359	+	return pfIso;
2360	+	}
2361	+
2362	+
2363	+
2364		//--------------------------------------------------------------------------------------------------
2365	+	// hacked version
2366		float electronPFIso04(ControlFlags &ctrl,
2367	<	const mithep::Electron * ele,
2368	<	const mithep::Vertex & vtx,
2369	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2370	<	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2371	<	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2372	<	vector<const mithep::Muon*> muonsToVeto,
2373	<	vector<const mithep::Electron*> electronsToVeto)
2367	>	const mithep::Electron * ele,
2368	>	const mithep::Vertex * vtx,
2369	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2370	>	float rho,
2371	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2372	>	vector<const mithep::Muon*> muonsToVeto,
2373	>	vector<const mithep::Electron*> electronsToVeto)
2374		//--------------------------------------------------------------------------------------------------
2375		{
2376
#	Line 1191 \| Line 2383 \| float electronPFIso04(ControlFlags &ctrl
2383		<< "\tphi: " << vmu->Phi()
2384		<< endl;
2385		}
2386	<	cout << "electronIsoMVASelection :: electrson to veto " << endl;
2386	>	cout << "electronIsoMVASelection :: electrons to veto " << endl;
2387		for( int i=0; i<electronsToVeto.size(); i++ ) {
2388		const mithep::Electron * vel = electronsToVeto[i];
2389		cout << "\tpt: " << vel->Pt()
#	Line 1215 \| Line 2407 \| float electronPFIso04(ControlFlags &ctrl
2407		//Loop over PF Candidates
2408		//
2409		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2410	+
2411	+
2412		const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
2413		Double_t deta = (ele->Eta() - pf->Eta());
2414		Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2415		Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2416	<	if (dr >= 0.4) continue;
2416	>
2417	>	if (dr > 0.4) continue;
2418	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2419	>
2420		if(ctrl.debug) {
2421	<	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
2422	<	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
2421	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2422	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(*vtx)
2423	>	<< "\ttrk: " << pf->HasTrackerTrk()
2424	>	<< "\tgsf: " << pf->HasGsfTrk();
2425	>
2426		cout << endl;
2427		}
2428
2429
2430	<	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
2431	<	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
2432	<
2430	>	//
2431	>	// sync : I don't think theyre doing this ...
2432	>	//
2433	>	// if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
2434	>	// (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2435	>	// if( ctrl.debug ) cout << "\tskipping, matches to the electron ..." << endl;
2436	>	// continue;
2437	>	// }
2438	>
2439
2440		//
2441		// Lepton Footprint Removal
#	Line 1242 \| Line 2448 \| float electronPFIso04(ControlFlags &ctrl
2448		//
2449		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2450		const mithep::Electron *tmpele = electronsToVeto[q];
2451	+	/*
2452		// 4l electron
2453		if( pf->HasTrackerTrk() ) {
2454		if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
#	Line 1255 \| Line 2462 \| float electronPFIso04(ControlFlags &ctrl
2462		IsLeptonFootprint = kTRUE;
2463		}
2464		}
2465	+	*/
2466		// PF charged
2467		if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2468		&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
#	Line 1268 \| Line 2476 \| float electronPFIso04(ControlFlags &ctrl
2476		IsLeptonFootprint = kTRUE;
2477		}
2478		} // loop over electrons
2479	<
2479	>
2480	>	/* KH - comment for sync
2481		//
2482		// Check for muons
2483		//
#	Line 1287 \| Line 2496 \| float electronPFIso04(ControlFlags &ctrl
2496		IsLeptonFootprint = kTRUE;
2497		}
2498		} // loop over muons
2499	<
2499	>	*/
2500
2501		if (IsLeptonFootprint)
2502		continue;
2503
2504		//
2505	<	// Charged Iso Rings
2505	>	// Charged Iso
2506		//
2507		if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
2508
2509	<	if( pf->HasTrackerTrk() )
2510	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2511	<	if( pf->HasGsfTrk() )
2512	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2509	>	// if( pf->HasTrackerTrk() )
2510	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2511	>	// if( pf->HasGsfTrk() )
2512	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2513
2514		// Veto any PFmuon, or PFEle
2515	<	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
2515	>	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) {
2516	>	if( ctrl.debug ) cout << "\t skipping, pf is and ele or mu .." <<endl;
2517	>	continue;
2518	>	}
2519
2520		// Footprint Veto
2521		if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
#	Line 1325 \| Line 2537 \| float electronPFIso04(ControlFlags &ctrl
2537		}
2538		if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2539		<< dr << endl;
2540	<	fGammaIso += pf->Pt();
2540	>	// KH, add to sync
2541	>	// if( pf->Pt() > 0.5 )
2542	>	fGammaIso += pf->Pt();
2543		}
2544
2545		//
#	Line 1334 \| Line 2548 \| float electronPFIso04(ControlFlags &ctrl
2548		else {
2549		if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2550		<< dr << endl;
2551	<	fNeutralHadronIso += pf->Pt();
2551	>	// KH, add to sync
2552	>	// if( pf->Pt() > 0.5 )
2553	>	fNeutralHadronIso += pf->Pt();
2554		}
2555
2556		}
2557
2558		}
2559
2560	<	double rho = 0;
2561	<	if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
2562	<	rho = fPUEnergyDensity->At(0)->Rho();
2560	>	// double rho = 0;
2561	>	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
2562	>	// rho = fPUEnergyDensity->At(0)->Rho();
2563
2564		// WARNING!!!!
2565		// hardcode for sync ...
#	Line 1351 \| Line 2567 \| float electronPFIso04(ControlFlags &ctrl
2567		// WARNING!!!!
2568
2569
2570	<	double pfIso = fChargedIso +
2571	<	max(0.0,fGammaIso -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIso04,
2572	<	ele->Eta(),EffectiveAreaVersion)) +
2573	<	max(0.0,fNeutralHadronIso -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIso04,
2574	<	ele->Eta(),EffectiveAreaVersion)) ;
2570	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2571	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2572	>	ele->Eta(),EffectiveAreaVersion)));
2573	>
2574	>
2575	>	gChargedIso = fChargedIso;
2576	>	gGammaIso = fGammaIso;
2577	>	gNeutralIso = fNeutralHadronIso;
2578		return pfIso;
2579		}
2580
2581	+
2582		//--------------------------------------------------------------------------------------------------
2583		SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2584		const mithep::Electron * ele,
2585	<	const mithep::Vertex & vtx,
2585	>	const mithep::Vertex * vtx,
2586		const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2587		const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2588		mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2589	+	vector<const mithep::PFCandidate*> photonsToVeto)
2590	+	//--------------------------------------------------------------------------------------------------
2591	+	{
2592	+
2593	+	SelectionStatus status;
2594	+
2595	+	double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, fPUEnergyDensity,
2596	+	EffectiveAreaVersion, photonsToVeto);
2597	+	// cout << "--------------> setting electron isoPF04 to " << pfIso << endl;
2598	+	status.isoPF04 = pfIso;
2599	+	status.chisoPF04 = gChargedIso;
2600	+	status.gaisoPF04 = gGammaIso;
2601	+	status.neisoPF04 = gNeutralIso;
2602	+
2603	+	bool pass = false;
2604	+	if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2605	+
2606	+	if( pass ) {
2607	+	status.orStatus(SelectionStatus::LOOSEISO);
2608	+	status.orStatus(SelectionStatus::TIGHTISO);
2609	+	}
2610	+	if(ctrl.debug) {
2611	+	cout << "el relpfIso: " << pfIso/ele->Pt() << endl;
2612	+	cout << "returning status : " << hex << status.getStatus() << dec << endl;
2613	+	}
2614	+	return status;
2615	+
2616	+	}
2617	+
2618	+
2619	+	//--------------------------------------------------------------------------------------------------
2620	+	// hacked version
2621	+	SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2622	+	const mithep::Electron * ele,
2623	+	const mithep::Vertex * vtx,
2624	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2625	+	float rho,
2626	+	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2627		vector<const mithep::Muon*> muonsToVeto,
2628		vector<const mithep::Electron*> electronsToVeto)
2629		//--------------------------------------------------------------------------------------------------
#	Line 1373 \| Line 2631 \| SelectionStatus electronReferenceIsoSele
2631
2632		SelectionStatus status;
2633
2634	<	double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, fPUEnergyDensity,
2634	>	double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, rho,
2635		EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2636	+	status.isoPF04 = pfIso;
2637	+	status.chisoPF04 = gChargedIso;
2638	+	status.gaisoPF04 = gGammaIso;
2639	+	status.neisoPF04 = gNeutralIso;
2640		bool pass = false;
2641		if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2642
#	Line 1386 \| Line 2648 \| SelectionStatus electronReferenceIsoSele
2648		return status;
2649
2650		}
2651	+
2652	+
2653	+
2654	+	//--------------------------------------------------------------------------------------------------
2655	+	double dbetaCorrectedIsoDr03(ControlFlags & ctrl,
2656	+	const mithep::PFCandidate * photon,
2657	+	const mithep::Muon * lepton,
2658	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates)
2659	+	//--------------------------------------------------------------------------------------------------
2660	+	{
2661	+
2662	+	//
2663	+	// final iso
2664	+	//
2665	+	Double_t fChargedIso = 0.0;
2666	+	Double_t fGammaIso = 0.0;
2667	+	Double_t fNeutralHadronIso = 0.0;
2668	+	Double_t fpfPU = 0.0;
2669	+
2670	+	//
2671	+	// Loop over PF Candidates
2672	+	//
2673	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2674	+
2675	+	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
2676	+
2677	+	Double_t deta = (photon->Eta() - pf->Eta());
2678	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2679	+	Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2680	+	if (dr > 0.3) continue;
2681	+
2682	+	if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2683	+	if( pf->Pt() >= 0.2 && dr > 0.01 )
2684	+	fpfPU += pf->Pt();
2685	+	continue;
2686	+	}
2687	+
2688	+	//
2689	+	// skip this photon
2690	+	//
2691	+	if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
2692	+	pf->Et() == photon->Et() ) continue;
2693	+
2694	+
2695	+	//
2696	+	// Charged Iso
2697	+	//
2698	+	if (pf->Charge() != 0 ) {
2699	+	if( dr > 0.01 && pf->Pt() >= 0.2 &&
2700	+	!(pf->TrackerTrk() == lepton->TrackerTrk()) )
2701	+	fChargedIso += pf->Pt();
2702	+	}
2703	+
2704	+	//
2705	+	// Gamma Iso
2706	+	//
2707	+	else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
2708	+	if( pf->Pt() > 0.5 && dr > 0.01)
2709	+	fGammaIso += pf->Pt();
2710	+	}
2711	+
2712	+	//
2713	+	// Other Neutrals
2714	+	//
2715	+	else {
2716	+	if( pf->Pt() > 0.5 && dr > 0.01)
2717	+	fNeutralHadronIso += pf->Pt();
2718	+	}
2719	+
2720	+	}
2721	+
2722	+	if( ctrl.debug ) {
2723	+	cout << "photon dbetaIso :: " << endl;
2724	+	cout << "\tfChargedIso: " << fChargedIso
2725	+	<< "\tfGammaIso: " << fGammaIso
2726	+	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
2727	+	<< "\tfpfPU: " << fpfPU
2728	+	<< endl;
2729	+	}
2730	+	double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso - 0.5*fpfPU;
2731	+	return pfIso/photon->Pt();
2732	+	}
2733	+
2734	+
2735	+	//--------------------------------------------------------------------------------------------------
2736	+	double dbetaCorrectedIsoDr03(ControlFlags & ctrl,
2737	+	const mithep::PFCandidate * photon,
2738	+	const mithep::Electron * lepton,
2739	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates)
2740	+	//--------------------------------------------------------------------------------------------------
2741	+	{
2742	+
2743	+	//
2744	+	// final iso
2745	+	//
2746	+	Double_t fChargedIso = 0.0;
2747	+	Double_t fGammaIso = 0.0;
2748	+	Double_t fNeutralHadronIso = 0.0;
2749	+	Double_t fpfPU = 0.0;
2750	+
2751	+	//
2752	+	// Loop over PF Candidates
2753	+	//
2754	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2755	+
2756	+	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
2757	+
2758	+	Double_t deta = (photon->Eta() - pf->Eta());
2759	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2760	+	Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2761	+	if (dr > 0.3) continue;
2762	+
2763	+	if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2764	+	if( pf->Pt() >= 0.2 && dr > 0.01 )
2765	+	fpfPU += pf->Pt();
2766	+	continue;
2767	+	}
2768	+
2769	+	//
2770	+	// skip this photon
2771	+	//
2772	+	if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
2773	+	pf->Et() == photon->Et() ) continue;
2774	+
2775	+
2776	+	//
2777	+	// Charged Iso
2778	+	//
2779	+	if (pf->Charge() != 0 ) {
2780	+	if( dr > 0.01 && pf->Pt() >= 0.2 &&
2781	+	!(pf->TrackerTrk() == lepton->TrackerTrk()) )
2782	+	fChargedIso += pf->Pt();
2783	+	}
2784	+
2785	+	//
2786	+	// Gamma Iso
2787	+	//
2788	+	else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
2789	+	if( pf->Pt() > 0.5 && dr > 0.01)
2790	+	fGammaIso += pf->Pt();
2791	+	}
2792	+
2793	+	//
2794	+	// Other Neutrals
2795	+	//
2796	+	else {
2797	+	if( pf->Pt() > 0.5 && dr > 0.01)
2798	+	fNeutralHadronIso += pf->Pt();
2799	+	}
2800	+
2801	+	}
2802	+
2803	+	if( ctrl.debug ) {
2804	+	cout << "photon dbetaIso :: " << endl;
2805	+	cout << "\tfChargedIso: " << fChargedIso
2806	+	<< "\tfGammaIso: " << fGammaIso
2807	+	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
2808	+	<< "\tfpfPU: " << fpfPU
2809	+	<< endl;
2810	+	}
2811	+	double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso - 0.5*fpfPU;
2812	+	return pfIso/photon->Pt();
2813	+	}
2814	+
2815	+
2816	+
2817	+
2818	+
2819	+	//--------------------------------------------------------------------------------------------------
2820	+	double nonCorrectedIsoDr03(ControlFlags & ctrl,
2821	+	const mithep::PFCandidate * photon,
2822	+	const mithep::Muon * lepton,
2823	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates)
2824	+	//--------------------------------------------------------------------------------------------------
2825	+	{
2826	+
2827	+	//
2828	+	// final iso
2829	+	//
2830	+	Double_t fChargedIso = 0.0;
2831	+	Double_t fGammaIso = 0.0;
2832	+	Double_t fNeutralHadronIso = 0.0;
2833	+	Double_t fpfPU = 0.0;
2834	+
2835	+	//
2836	+	// Loop over PF Candidates
2837	+	//
2838	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2839	+
2840	+	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
2841	+
2842	+	Double_t deta = (photon->Eta() - pf->Eta());
2843	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2844	+	Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2845	+	if (dr > 0.3) continue;
2846	+
2847	+	if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2848	+	if( pf->Pt() >= 0.2 && dr > 0.01 )
2849	+	fpfPU += pf->Pt();
2850	+	continue;
2851	+	}
2852	+
2853	+	//
2854	+	// skip this photon
2855	+	//
2856	+	if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
2857	+	pf->Et() == photon->Et() ) continue;
2858	+
2859	+
2860	+	//
2861	+	// Charged Iso
2862	+	//
2863	+	if (pf->Charge() != 0 ) {
2864	+	if( dr > 0.01 && pf->Pt() >= 0.2 &&
2865	+	!(pf->TrackerTrk() == lepton->TrackerTrk()) )
2866	+	fChargedIso += pf->Pt();
2867	+	}
2868	+
2869	+	//
2870	+	// Gamma Iso
2871	+	//
2872	+	else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
2873	+	if( pf->Pt() > 0.5 && dr > 0.01)
2874	+	fGammaIso += pf->Pt();
2875	+	}
2876	+
2877	+	//
2878	+	// Other Neutrals
2879	+	//
2880	+	else {
2881	+	if( pf->Pt() > 0.5 && dr > 0.01)
2882	+	fNeutralHadronIso += pf->Pt();
2883	+	}
2884	+
2885	+	}
2886	+
2887	+	if( ctrl.debug ) {
2888	+	cout << "photon dbetaIso :: " << endl;
2889	+	cout << "\tfChargedIso: " << fChargedIso
2890	+	<< "\tfGammaIso: " << fGammaIso
2891	+	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
2892	+	<< "\tfpfPU: " << fpfPU
2893	+	<< endl;
2894	+	}
2895	+	double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso + fpfPU;
2896	+	return pfIso/photon->Pt();
2897	+	}
2898	+
2899	+
2900	+
2901	+	//--------------------------------------------------------------------------------------------------
2902	+	double nonCorrectedIsoDr03(ControlFlags & ctrl,
2903	+	const mithep::PFCandidate * photon,
2904	+	const mithep::Electron * lepton,
2905	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates)
2906	+	//--------------------------------------------------------------------------------------------------
2907	+	{
2908	+
2909	+	//
2910	+	// final iso
2911	+	//
2912	+	Double_t fChargedIso = 0.0;
2913	+	Double_t fGammaIso = 0.0;
2914	+	Double_t fNeutralHadronIso = 0.0;
2915	+	Double_t fpfPU = 0.0;
2916	+
2917	+	//
2918	+	// Loop over PF Candidates
2919	+	//
2920	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2921	+
2922	+	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
2923	+
2924	+	Double_t deta = (photon->Eta() - pf->Eta());
2925	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(photon->Phi()),Double_t(pf->Phi()));
2926	+	Double_t dr = mithep::MathUtils::DeltaR(photon->Phi(),photon->Eta(), pf->Phi(), pf->Eta());
2927	+	if (dr > 0.3) continue;
2928	+
2929	+	if( !(PFnoPUflag[k]) && pf->Charge() != 0 ) {
2930	+	if( pf->Pt() >= 0.2 && dr > 0.01 )
2931	+	fpfPU += pf->Pt();
2932	+	continue;
2933	+	}
2934	+
2935	+	//
2936	+	// skip this photon
2937	+	//
2938	+	if( abs(pf->PFType()) == mithep::PFCandidate::eGamma &&
2939	+	pf->Et() == photon->Et() ) continue;
2940	+
2941	+
2942	+	//
2943	+	// Charged Iso
2944	+	//
2945	+	if (pf->Charge() != 0 ) {
2946	+	if( dr > 0.01 && pf->Pt() >= 0.2 &&
2947	+	!(pf->TrackerTrk() == lepton->TrackerTrk()) )
2948	+	fChargedIso += pf->Pt();
2949	+	}
2950	+
2951	+	//
2952	+	// Gamma Iso
2953	+	//
2954	+	else if (abs(pf->PFType()) == mithep::PFCandidate::eGamma) {
2955	+	if( pf->Pt() > 0.5 && dr > 0.01)
2956	+	fGammaIso += pf->Pt();
2957	+	}
2958	+
2959	+	//
2960	+	// Other Neutrals
2961	+	//
2962	+	else {
2963	+	if( pf->Pt() > 0.5 && dr > 0.01)
2964	+	fNeutralHadronIso += pf->Pt();
2965	+	}
2966	+
2967	+	}
2968	+
2969	+	if( ctrl.debug ) {
2970	+	cout << "photon dbetaIso :: " << endl;
2971	+	cout << "\tfChargedIso: " << fChargedIso
2972	+	<< "\tfGammaIso: " << fGammaIso
2973	+	<< "\tfNeutralHadronIso: " << fNeutralHadronIso
2974	+	<< "\tfpfPU: " << fpfPU
2975	+	<< endl;
2976	+	}
2977	+	double pfIso = fChargedIso + fGammaIso + fNeutralHadronIso + fpfPU;
2978	+	return pfIso/photon->Pt();
2979	+	}
2980	+
2981	+
2982	+

Diff Legend

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

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents): Revision 1.13 by khahn, Thu May 10 00:14:35 2012 UTC vs. Revision 1.31 by khahn, Tue Jun 12 01:23:03 2012 UTC

Diff Legend

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents):
Revision 1.13 by khahn, Thu May 10 00:14:35 2012 UTC vs.
Revision 1.31 by khahn, Tue Jun 12 01:23:03 2012 UTC