[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.21 by khahn, Sun May 20 19:08:58 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,
#	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,
#	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	+	// if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
472	+	// rho = fPUEnergyDensity->At(0)->RhoLowEta();
473
474	+	// WARNING!!!!
475	+	// hardcode for sync ...
476	+	EffectiveAreaVersion = muT.kMuEAData2011;
477	+	// WARNING!!!!
478	+
479
480	<	fGammaIso_DR0p0To0p1 = max(min((tmpGammaIso_DR0p0To0p1
480	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
481		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p0To0p1,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
482		,2.5)
483		,0.0);
484	<	fGammaIso_DR0p1To0p2 = max(min((tmpGammaIso_DR0p1To0p2
484	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
485		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p1To0p2,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
486		,2.5)
487		,0.0);
488	<	fGammaIso_DR0p2To0p3 = max(min((tmpGammaIso_DR0p2To0p3
488	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
489		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p2To0p3,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
490		,2.5)
491		,0.0);
492	<	fGammaIso_DR0p3To0p4 = max(min((tmpGammaIso_DR0p3To0p4
492	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
493		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p3To0p4,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
494		,2.5)
495		,0.0);
496	<	fGammaIso_DR0p4To0p5 = max(min((tmpGammaIso_DR0p4To0p5
496	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
497		-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p4To0p5,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
498		,2.5)
499		,0.0);
500
501
502
503	<	fNeutralHadronIso_DR0p0To0p1 = max(min((tmpNeutralHadronIso_DR0p0To0p1
503	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
504		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p0To0p1,
505		mu->Eta(),EffectiveAreaVersion))/mu->Pt()
506		, 2.5)
507		, 0.0);
508	<	fNeutralHadronIso_DR0p1To0p2 = max(min((tmpNeutralHadronIso_DR0p1To0p2
508	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
509		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p1To0p2,
510		mu->Eta(),EffectiveAreaVersion))/mu->Pt()
511		, 2.5)
512		, 0.0);
513	<	fNeutralHadronIso_DR0p2To0p3 = max(min((tmpNeutralHadronIso_DR0p2To0p3
513	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
514		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p2To0p3,
515		mu->Eta(),EffectiveAreaVersion))/mu->Pt()
516		, 2.5)
517		, 0.0);
518	<	fNeutralHadronIso_DR0p3To0p4 = max(min((tmpNeutralHadronIso_DR0p3To0p4
518	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
519		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p3To0p4,
520		mu->Eta(), EffectiveAreaVersion))/mu->Pt()
521		, 2.5)
522		, 0.0);
523	<	fNeutralHadronIso_DR0p4To0p5 = max(min((tmpNeutralHadronIso_DR0p4To0p5
523	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
524		-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p4To0p5,
525		mu->Eta(), EffectiveAreaVersion))/mu->Pt()
526		, 2.5)
#	Line 511 \| Line 528 \| SelectionStatus muonIsoMVASelection(Cont
528
529
530		double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
531	<	mu->Eta(),
532	<	fChargedIso_DR0p0To0p1,
533	<	fChargedIso_DR0p1To0p2,
534	<	fChargedIso_DR0p2To0p3,
535	<	fChargedIso_DR0p3To0p4,
536	<	fChargedIso_DR0p4To0p5,
537	<	fGammaIso_DR0p0To0p1,
538	<	fGammaIso_DR0p1To0p2,
539	<	fGammaIso_DR0p2To0p3,
540	<	fGammaIso_DR0p3To0p4,
541	<	fGammaIso_DR0p4To0p5,
542	<	fNeutralHadronIso_DR0p0To0p1,
543	<	fNeutralHadronIso_DR0p1To0p2,
544	<	fNeutralHadronIso_DR0p2To0p3,
545	<	fNeutralHadronIso_DR0p3To0p4,
546	<	fNeutralHadronIso_DR0p4To0p5,
547	<	ctrl.debug);
531	>	mu->Eta(),
532	>	mu->IsGlobalMuon(),
533	>	mu->IsTrackerMuon(),
534	>	fChargedIso_DR0p0To0p1,
535	>	fChargedIso_DR0p1To0p2,
536	>	fChargedIso_DR0p2To0p3,
537	>	fChargedIso_DR0p3To0p4,
538	>	fChargedIso_DR0p4To0p5,
539	>	fGammaIso_DR0p0To0p1,
540	>	fGammaIso_DR0p1To0p2,
541	>	fGammaIso_DR0p2To0p3,
542	>	fGammaIso_DR0p3To0p4,
543	>	fGammaIso_DR0p4To0p5,
544	>	fNeutralHadronIso_DR0p0To0p1,
545	>	fNeutralHadronIso_DR0p1To0p2,
546	>	fNeutralHadronIso_DR0p2To0p3,
547	>	fNeutralHadronIso_DR0p3To0p4,
548	>	fNeutralHadronIso_DR0p4To0p5,
549	>	ctrl.debug);
550	>
551	>	SelectionStatus status;
552	>	bool pass;
553	>
554	>	pass = false;
555	>	if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
556	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN0) pass = true;
557	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
558	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN1) pass = true;
559	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
560	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN2) pass = true;
561	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
562	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN3) pass = true;
563	>	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN4) pass = true;
564	>	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_OPT_BIN5) pass = true;
565	>	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
566	>
567	>	/*
568	>	pass = false;
569	>	if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
570	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN0) pass = true;
571	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
572	>	&& fabs(mu->Eta()) <= 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN1) pass = true;
573	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
574	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN2) pass = true;
575	>	else if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
576	>	&& fabs(mu->Eta()) > 1.5 && mu->Pt() > 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN3) pass = true;
577	>	else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN4) pass = true;
578	>	else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN5) pass = true;
579	>	if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
580	>	*/
581	>
582	>	// pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
583	>
584	>	status.isoMVA = mvaval;
585	>
586	>	if(ctrl.debug) {
587	>	cout << "returning status : " << hex << status.getStatus() << dec << endl;
588	>	cout << "MVAVAL : " << status.isoMVA << endl;
589	>	}
590	>	return status;
591	>
592	>	}
593	>
594	>
595	>	//--------------------------------------------------------------------------------------------------
596	>	SelectionStatus muonIsoMVASelection(ControlFlags &ctrl,
597	>	const mithep::Muon * mu,
598	>	const mithep::Vertex & vtx,
599	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
600	>	float rho,
601	>	//const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
602	>	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
603	>	vector<const mithep::Muon*> muonsToVeto,
604	>	vector<const mithep::Electron*> electronsToVeto)
605	>	//--------------------------------------------------------------------------------------------------
606	>	// hacked version
607	>	{
608	>
609	>	if( ctrl.debug ) {
610	>	cout << "muonIsoMVASelection :: muons to veto " << endl;
611	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
612	>	const mithep::Muon * vmu = muonsToVeto[i];
613	>	cout << "\tpt: " << vmu->Pt()
614	>	<< "\teta: " << vmu->Eta()
615	>	<< "\tphi: " << vmu->Phi()
616	>	<< endl;
617	>	}
618	>	cout << "muonIsoMVASelection :: electrson to veto " << endl;
619	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
620	>	const mithep::Electron * vel = electronsToVeto[i];
621	>	cout << "\tpt: " << vel->Pt()
622	>	<< "\teta: " << vel->Eta()
623	>	<< "\tphi: " << vel->Phi()
624	>	<< endl;
625	>	}
626	>	}
627	>	bool failiso=false;
628	>
629	>	//
630	>	// tmp iso rings
631	>	//
632	>	Double_t tmpChargedIso_DR0p0To0p1 = 0;
633	>	Double_t tmpChargedIso_DR0p1To0p2 = 0;
634	>	Double_t tmpChargedIso_DR0p2To0p3 = 0;
635	>	Double_t tmpChargedIso_DR0p3To0p4 = 0;
636	>	Double_t tmpChargedIso_DR0p4To0p5 = 0;
637	>	Double_t tmpChargedIso_DR0p5To0p7 = 0;
638	>
639	>	Double_t tmpGammaIso_DR0p0To0p1 = 0;
640	>	Double_t tmpGammaIso_DR0p1To0p2 = 0;
641	>	Double_t tmpGammaIso_DR0p2To0p3 = 0;
642	>	Double_t tmpGammaIso_DR0p3To0p4 = 0;
643	>	Double_t tmpGammaIso_DR0p4To0p5 = 0;
644	>	Double_t tmpGammaIso_DR0p5To0p7 = 0;
645	>
646	>	Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
647	>	Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
648	>	Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
649	>	Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
650	>	Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
651	>	Double_t tmpNeutralHadronIso_DR0p5To0p7 = 0;
652	>
653	>
654	>
655	>	//
656	>	// final rings for the MVA
657	>	//
658	>	Double_t fChargedIso_DR0p0To0p1;
659	>	Double_t fChargedIso_DR0p1To0p2;
660	>	Double_t fChargedIso_DR0p2To0p3;
661	>	Double_t fChargedIso_DR0p3To0p4;
662	>	Double_t fChargedIso_DR0p4To0p5;
663	>	Double_t fChargedIso_DR0p5To0p7;
664	>
665	>	Double_t fGammaIso_DR0p0To0p1;
666	>	Double_t fGammaIso_DR0p1To0p2;
667	>	Double_t fGammaIso_DR0p2To0p3;
668	>	Double_t fGammaIso_DR0p3To0p4;
669	>	Double_t fGammaIso_DR0p4To0p5;
670	>	Double_t fGammaIso_DR0p5To0p7;
671	>
672	>	Double_t fNeutralHadronIso_DR0p0To0p1;
673	>	Double_t fNeutralHadronIso_DR0p1To0p2;
674	>	Double_t fNeutralHadronIso_DR0p2To0p3;
675	>	Double_t fNeutralHadronIso_DR0p3To0p4;
676	>	Double_t fNeutralHadronIso_DR0p4To0p5;
677	>	Double_t fNeutralHadronIso_DR0p5To0p7;
678	>
679	>
680	>	//
681	>	//Loop over PF Candidates
682	>	//
683	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
684	>
685	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
686	>
687	>	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
688	>
689	>	Double_t deta = (mu->Eta() - pf->Eta());
690	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
691	>	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
692	>	if (dr > 1.0) continue;
693	>
694	>	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
695	>
696	>	//
697	>	// Lepton Footprint Removal
698	>	//
699	>	Bool_t IsLeptonFootprint = kFALSE;
700	>	if (dr < 1.0) {
701	>
702	>	//
703	>	// Check for electrons
704	>	//
705	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
706	>	const mithep::Electron *tmpele = electronsToVeto[q];
707	>	// 4l electron
708	>	if( pf->HasTrackerTrk() ) {
709	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
710	>	IsLeptonFootprint = kTRUE;
711	>	}
712	>	if( pf->HasGsfTrk() ) {
713	>	if( pf->GsfTrk() == tmpele->GsfTrk() )
714	>	IsLeptonFootprint = kTRUE;
715	>	}
716	>	// PF charged
717	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479
718	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
719	>	IsLeptonFootprint = kTRUE;
720	>	// PF gamma
721	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
722	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
723	>	IsLeptonFootprint = kTRUE;
724	>	} // loop over electrons
725	>
726	>	/* KH - commented for sync
727	>	//
728	>	// Check for muons
729	>	//
730	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
731	>	const mithep::Muon *tmpmu = muonsToVeto[q];
732	>	// 4l muon
733	>	if( pf->HasTrackerTrk() ) {
734	>	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
735	>	IsLeptonFootprint = kTRUE;
736	>	}
737	>	// PF charged
738	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
739	>	IsLeptonFootprint = kTRUE;
740	>	} // loop over muons
741	>	*/
742	>
743	>	if (IsLeptonFootprint)
744	>	continue;
745	>
746	>	//
747	>	// Charged Iso Rings
748	>	//
749	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
750	>
751	>	if( dr < 0.01 ) continue; // only for muon iso mva?
752	>	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
753	>
754	>	// if( pf->HasTrackerTrk() ) {
755	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
756	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
757	>	// << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
758	>	// << dr << endl;
759	>	// }
760	>	// if( pf->HasGsfTrk() ) {
761	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
762	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
763	>	// << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
764	>	// << dr << endl;
765	>	// }
766	>
767	>	// Footprint Veto
768	>	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
769	>	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
770	>	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
771	>	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
772	>	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
773	>	if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
774	>	}
775	>
776	>	//
777	>	// Gamma Iso Rings
778	>	//
779	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
780	>	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
781	>	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
782	>	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
783	>	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
784	>	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
785	>	if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
786	>	}
787	>
788	>	//
789	>	// Other Neutral Iso Rings
790	>	//
791	>	else {
792	>	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
793	>	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
794	>	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
795	>	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
796	>	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
797	>	if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
798	>	}
799	>
800	>	}
801	>
802	>	}
803	>
804	>	fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/mu->Pt(), 2.5);
805	>	fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/mu->Pt(), 2.5);
806	>	fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/mu->Pt(), 2.5);
807	>	fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/mu->Pt(), 2.5);
808	>	fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/mu->Pt(), 2.5);
809	>
810	>
811	>	// double rho = 0;
812	>	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
813	>	// rho = fPUEnergyDensity->At(0)->Rho();
814	>	// if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
815	>	// rho = fPUEnergyDensity->At(0)->RhoLowEta();
816	>
817	>	// WARNING!!!!
818	>	// hardcode for sync ...
819	>	EffectiveAreaVersion = muT.kMuEAData2011;
820	>	// WARNING!!!!
821	>
822	>
823	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
824	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p0To0p1,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
825	>	,2.5)
826	>	,0.0);
827	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
828	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p1To0p2,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
829	>	,2.5)
830	>	,0.0);
831	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
832	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p2To0p3,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
833	>	,2.5)
834	>	,0.0);
835	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
836	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p3To0p4,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
837	>	,2.5)
838	>	,0.0);
839	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
840	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaIsoDR0p4To0p5,mu->Eta(),EffectiveAreaVersion))/mu->Pt()
841	>	,2.5)
842	>	,0.0);
843	>
844	>
845	>
846	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
847	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p0To0p1,
848	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
849	>	, 2.5)
850	>	, 0.0);
851	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
852	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p1To0p2,
853	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
854	>	, 2.5)
855	>	, 0.0);
856	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
857	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p2To0p3,
858	>	mu->Eta(),EffectiveAreaVersion))/mu->Pt()
859	>	, 2.5)
860	>	, 0.0);
861	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
862	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p3To0p4,
863	>	mu->Eta(), EffectiveAreaVersion))/mu->Pt()
864	>	, 2.5)
865	>	, 0.0);
866	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
867	>	-rho*muT.MuonEffectiveArea(muT.kMuNeutralHadronIsoDR0p4To0p5,
868	>	mu->Eta(), EffectiveAreaVersion))/mu->Pt()
869	>	, 2.5)
870	>	, 0.0);
871	>
872	>
873	>	double mvaval = muIsoMVA->MVAValue_IsoRings( mu->Pt(),
874	>	mu->Eta(),
875	>	mu->IsGlobalMuon(),
876	>	mu->IsTrackerMuon(),
877	>	fChargedIso_DR0p0To0p1,
878	>	fChargedIso_DR0p1To0p2,
879	>	fChargedIso_DR0p2To0p3,
880	>	fChargedIso_DR0p3To0p4,
881	>	fChargedIso_DR0p4To0p5,
882	>	fGammaIso_DR0p0To0p1,
883	>	fGammaIso_DR0p1To0p2,
884	>	fGammaIso_DR0p2To0p3,
885	>	fGammaIso_DR0p3To0p4,
886	>	fGammaIso_DR0p4To0p5,
887	>	fNeutralHadronIso_DR0p0To0p1,
888	>	fNeutralHadronIso_DR0p1To0p2,
889	>	fNeutralHadronIso_DR0p2To0p3,
890	>	fNeutralHadronIso_DR0p3To0p4,
891	>	fNeutralHadronIso_DR0p4To0p5,
892	>	ctrl.debug);
893
894		SelectionStatus status;
895		bool pass;
#	Line 545 \| Line 907 \| SelectionStatus muonIsoMVASelection(Cont
907		else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_LOOSE_FORPFID_CUT_BIN5) pass = true;
908		if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
909
910	+	/*
911		pass = false;
912		if( mu->IsGlobalMuon() && mu->IsTrackerMuon()
913		&& fabs(mu->Eta()) <= 1.5 && mu->Pt() <= 10 && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN0) pass = true;
#	Line 557 \| Line 920 \| SelectionStatus muonIsoMVASelection(Cont
920		else if( !(mu->IsGlobalMuon()) && mu->IsTrackerMuon() && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN4) pass = true;
921		else if( mu->IsGlobalMuon() && !(mu->IsTrackerMuon()) && mvaval >= MUON_ISOMVA_TIGHT_FORPFID_CUT_BIN5) pass = true;
922		if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
923	+	*/
924
925		// pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
926
927	<	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
927	>	status.isoMVA = mvaval;
928	>
929	>	if(ctrl.debug) {
930	>	cout << "returning status : " << hex << status.getStatus() << dec << endl;
931	>	cout << "MVAVAL : " << status.isoMVA << endl;
932	>	}
933		return status;
934
935		}
936
937	+
938		//--------------------------------------------------------------------------------------------------
939		void initMuonIsoMVA() {
940		//--------------------------------------------------------------------------------------------------
#	Line 582 \| Line 952 \| void initMuonIsoMVA() {
952		}
953
954
955	+
956	+
957		//--------------------------------------------------------------------------------------------------
958		double muonPFIso04(ControlFlags &ctrl,
959		const mithep::Muon * mu,
#	Line 593 \| Line 965 \| double muonPFIso04(ControlFlags &ctrl,
965		vector<const mithep::Electron*> electronsToVeto)
966		//--------------------------------------------------------------------------------------------------
967		{
968	+
969	+	extern double gChargedIso;
970	+	extern double gGammaIso;
971	+	extern double gNeutralIso;
972
973		if( ctrl.debug ) {
974		cout << "muonIsoMVASelection :: muons to veto " << endl;
#	Line 624 \| Line 1000 \| double muonPFIso04(ControlFlags &ctrl,
1000		//Loop over PF Candidates
1001		//
1002		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1003	+
1004	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1005		const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1006
1007		Double_t deta = (mu->Eta() - pf->Eta());
#	Line 662 \| Line 1040 \| double muonPFIso04(ControlFlags &ctrl,
1040		&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
1041		IsLeptonFootprint = kTRUE;
1042		} // loop over electrons
1043	<
1043	>
1044	>	/* KH - comment for sync
1045		//
1046		// Check for muons
1047		//
#	Line 677 \| Line 1056 \| double muonPFIso04(ControlFlags &ctrl,
1056		if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
1057		IsLeptonFootprint = kTRUE;
1058		} // loop over muons
1059	<
1059	>	*/
1060
1061		if (IsLeptonFootprint)
1062		continue;
1063
1064		//
1065	<	// Charged Iso Rings
1065	>	// Charged Iso
1066		//
1067		if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1068
1069	<	if( dr < 0.01 ) continue; // only for muon iso mva?
1069	>	//if( dr < 0.01 ) continue; // only for muon iso mva?
1070		if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
1071
1072	<	if( pf->HasTrackerTrk() ) {
1073	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1074	<	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1075	<	<< abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1076	<	<< dr << endl;
1077	<	}
1078	<	if( pf->HasGsfTrk() ) {
1079	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1080	<	if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1081	<	<< abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1082	<	<< dr << endl;
1083	<	}
1072	>
1073	>	// if( pf->HasTrackerTrk() ) {
1074	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1075	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1076	>	// << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1077	>	// << dr << endl;
1078	>	// }
1079	>	// if( pf->HasGsfTrk() ) {
1080	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1081	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1082	>	// << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1083	>	// << dr << endl;
1084	>	// }
1085
1086
1087		fChargedIso += pf->Pt();
#	Line 711 \| Line 1091 \| double muonPFIso04(ControlFlags &ctrl,
1091		// Gamma Iso
1092		//
1093		else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1094	+	// KH, add to sync
1095	+	if( pf->Pt() > 0.5 )
1096		fGammaIso += pf->Pt();
1097		}
1098
1099		//
1100	<	// Other Neutral Iso Rings
1100	>	// Other Neutrals
1101		//
1102		else {
1103	<	fNeutralHadronIso += pf->Pt();
1103	>	// KH, add to sync
1104	>	if( pf->Pt() > 0.5 )
1105	>	fNeutralHadronIso += pf->Pt();
1106		}
1107
1108		}
1109
1110		}
1111	<
1112	<	double rho = 0;
1111	>
1112	>	double rho=0;
1113		if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
1114		rho = fPUEnergyDensity->At(0)->Rho();
1115
#	Line 735 \| Line 1119 \| double muonPFIso04(ControlFlags &ctrl,
1119		// WARNING!!!!
1120
1121
1122	<	double pfIso = fChargedIso + max(0.0,(fGammaIso + fNeutralHadronIso
1122	>
1123	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1124	>	-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1125	>	mu->Eta(),EffectiveAreaVersion)));
1126	>	gChargedIso = fChargedIso;
1127	>	gGammaIso = fGammaIso;
1128	>	gNeutralIso = fNeutralHadronIso;
1129	>
1130	>	return pfIso;
1131	>	}
1132	>
1133	>
1134	>
1135	>
1136	>	//--------------------------------------------------------------------------------------------------
1137	>	// hacked version
1138	>	double muonPFIso04(ControlFlags &ctrl,
1139	>	const mithep::Muon * mu,
1140	>	const mithep::Vertex & vtx,
1141	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1142	>	float rho,
1143	>	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1144	>	vector<const mithep::Muon*> muonsToVeto,
1145	>	vector<const mithep::Electron*> electronsToVeto)
1146	>	//--------------------------------------------------------------------------------------------------
1147	>	{
1148	>
1149	>	extern double gChargedIso;
1150	>	extern double gGammaIso;
1151	>	extern double gNeutralIso;
1152	>
1153	>	if( ctrl.debug ) {
1154	>	cout << "muonIsoMVASelection :: muons to veto " << endl;
1155	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
1156	>	const mithep::Muon * vmu = muonsToVeto[i];
1157	>	cout << "\tpt: " << vmu->Pt()
1158	>	<< "\teta: " << vmu->Eta()
1159	>	<< "\tphi: " << vmu->Phi()
1160	>	<< endl;
1161	>	}
1162	>	cout << "muonIsoMVASelection :: electrson to veto " << endl;
1163	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
1164	>	const mithep::Electron * vel = electronsToVeto[i];
1165	>	cout << "\tpt: " << vel->Pt()
1166	>	<< "\teta: " << vel->Eta()
1167	>	<< "\tphi: " << vel->Phi()
1168	>	<< endl;
1169	>	}
1170	>	}
1171	>
1172	>	//
1173	>	// final iso
1174	>	//
1175	>	Double_t fChargedIso = 0.0;
1176	>	Double_t fGammaIso = 0.0;
1177	>	Double_t fNeutralHadronIso = 0.0;
1178	>
1179	>	//
1180	>	//Loop over PF Candidates
1181	>	//
1182	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1183	>
1184	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1185	>	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1186	>
1187	>	Double_t deta = (mu->Eta() - pf->Eta());
1188	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(mu->Phi()),Double_t(pf->Phi()));
1189	>	Double_t dr = mithep::MathUtils::DeltaR(mu->Phi(),mu->Eta(), pf->Phi(), pf->Eta());
1190	>	if (dr > 0.4) continue;
1191	>
1192	>	if (pf->HasTrackerTrk() && (pf->TrackerTrk() == mu->TrackerTrk()) ) continue;
1193	>
1194	>	//
1195	>	// Lepton Footprint Removal
1196	>	//
1197	>	Bool_t IsLeptonFootprint = kFALSE;
1198	>	if (dr < 1.0) {
1199	>
1200	>	//
1201	>	// Check for electrons
1202	>	//
1203	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1204	>	const mithep::Electron *tmpele = electronsToVeto[q];
1205	>	// 4l electron
1206	>	if( pf->HasTrackerTrk() ) {
1207	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() )
1208	>	IsLeptonFootprint = kTRUE;
1209	>	}
1210	>	if( pf->HasGsfTrk() ) {
1211	>	if( pf->GsfTrk() == tmpele->GsfTrk() )
1212	>	IsLeptonFootprint = kTRUE;
1213	>	}
1214	>	// PF charged
1215	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
1216	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015)
1217	>	IsLeptonFootprint = kTRUE;
1218	>	// PF gamma
1219	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1220	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08)
1221	>	IsLeptonFootprint = kTRUE;
1222	>	} // loop over electrons
1223	>
1224	>	/* KH - comment for sync
1225	>	//
1226	>	// Check for muons
1227	>	//
1228	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1229	>	const mithep::Muon *tmpmu = muonsToVeto[q];
1230	>	// 4l muon
1231	>	if( pf->HasTrackerTrk() ) {
1232	>	if( pf->TrackerTrk() == tmpmu->TrackerTrk() )
1233	>	IsLeptonFootprint = kTRUE;
1234	>	}
1235	>	// PF charged
1236	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01)
1237	>	IsLeptonFootprint = kTRUE;
1238	>	} // loop over muons
1239	>	*/
1240	>
1241	>	if (IsLeptonFootprint)
1242	>	continue;
1243	>
1244	>	//
1245	>	// Charged Iso
1246	>	//
1247	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1248	>
1249	>	//if( dr < 0.01 ) continue; // only for muon iso mva?
1250	>	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
1251	>
1252	>
1253	>	// if( pf->HasTrackerTrk() ) {
1254	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1255	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1256	>	// << abs(pf->TrackerTrk()->DzCorrected(vtx)) << " "
1257	>	// << dr << endl;
1258	>	// }
1259	>	// if( pf->HasGsfTrk() ) {
1260	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1261	>	// if( ctrl.debug ) cout << "charged:: " << pf->PFType() << " " << pf->Pt() << " "
1262	>	// << abs(pf->GsfTrk()->DzCorrected(vtx)) << " "
1263	>	// << dr << endl;
1264	>	// }
1265	>
1266	>
1267	>	fChargedIso += pf->Pt();
1268	>	}
1269	>
1270	>	//
1271	>	// Gamma Iso
1272	>	//
1273	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1274	>	// KH, add to sync
1275	>	if( pf->Pt() > 0.5 )
1276	>	fGammaIso += pf->Pt();
1277	>	}
1278	>
1279	>	//
1280	>	// Other Neutrals
1281	>	//
1282	>	else {
1283	>	// KH, add to sync
1284	>	if( pf->Pt() > 0.5 )
1285	>	fNeutralHadronIso += pf->Pt();
1286	>	}
1287	>
1288	>	}
1289	>
1290	>	}
1291	>
1292	>	// double rho = 0;
1293	>	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
1294	>	// rho = fPUEnergyDensity->At(0)->Rho();
1295	>
1296	>	// WARNING!!!!
1297	>	// hardcode for sync ...
1298	>	EffectiveAreaVersion = muT.kMuEAData2011;
1299	>	// WARNING!!!!
1300	>
1301	>
1302	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
1303		-rho*muT.MuonEffectiveArea(muT.kMuGammaAndNeutralHadronIso04,
1304		mu->Eta(),EffectiveAreaVersion)));
1305	+	gChargedIso = fChargedIso;
1306	+	gGammaIso = fGammaIso;
1307	+	gNeutralIso = fNeutralHadronIso;
1308
1309		return pfIso;
1310		}
1311
1312	+
1313		//--------------------------------------------------------------------------------------------------
1314		SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1315		const mithep::Muon * mu,
#	Line 755 \| Line 1323 \| SelectionStatus muonReferenceIsoSelectio
1323		{
1324
1325		SelectionStatus status;
1326	<
1326	>
1327		double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, fPUEnergyDensity,
1328		EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1329	+	// cout << "--------------> setting muon isoPF04 to" << pfIso << endl;
1330	+	status.isoPF04 = pfIso;
1331	+	status.chisoPF04 = gChargedIso;
1332	+	status.gaisoPF04 = gGammaIso;
1333	+	status.neisoPF04 = gNeutralIso;
1334	+
1335	+	bool pass = false;
1336	+	if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1337	+
1338	+	if( pass ) {
1339	+	status.orStatus(SelectionStatus::LOOSEISO);
1340	+	status.orStatus(SelectionStatus::TIGHTISO);
1341	+	}
1342	+	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1343	+	return status;
1344	+
1345	+	}
1346	+
1347	+
1348	+	//--------------------------------------------------------------------------------------------------
1349	+	// hacked version
1350	+	SelectionStatus muonReferenceIsoSelection(ControlFlags &ctrl,
1351	+	const mithep::Muon * mu,
1352	+	const mithep::Vertex & vtx,
1353	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1354	+	float rho,
1355	+	mithep::MuonTools::EMuonEffectiveAreaTarget EffectiveAreaVersion,
1356	+	vector<const mithep::Muon*> muonsToVeto,
1357	+	vector<const mithep::Electron*> electronsToVeto)
1358	+	//--------------------------------------------------------------------------------------------------
1359	+	{
1360	+
1361	+	SelectionStatus status;
1362	+
1363	+	double pfIso = muonPFIso04( ctrl, mu, vtx, fPFCandidates, rho,
1364	+	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
1365	+
1366	+	status.isoPF04 = pfIso;
1367	+	status.chisoPF04 = gChargedIso;
1368	+	status.gaisoPF04 = gGammaIso;
1369	+	status.neisoPF04 = gNeutralIso;
1370	+
1371		bool pass = false;
1372		if( (pfIso/mu->Pt()) < MUON_REFERENCE_PFISO_CUT ) pass = true;
1373
#	Line 772 \| Line 1382 \| SelectionStatus muonReferenceIsoSelectio
1382
1383
1384
1385	+
1386		//--------------------------------------------------------------------------------------------------
1387		SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1388		const mithep::Electron * ele,
#	Line 814 \| Line 1425 \| SelectionStatus electronIsoMVASelection(
1425		Double_t tmpChargedIso_DR0p2To0p3 = 0;
1426		Double_t tmpChargedIso_DR0p3To0p4 = 0;
1427		Double_t tmpChargedIso_DR0p4To0p5 = 0;
817	–	Double_t tmpChargedIso_DR0p5To0p7 = 0;
1428
1429		Double_t tmpGammaIso_DR0p0To0p1 = 0;
1430		Double_t tmpGammaIso_DR0p1To0p2 = 0;
1431		Double_t tmpGammaIso_DR0p2To0p3 = 0;
1432		Double_t tmpGammaIso_DR0p3To0p4 = 0;
1433		Double_t tmpGammaIso_DR0p4To0p5 = 0;
1434	<	Double_t tmpGammaIso_DR0p5To0p7 = 0;
1434	>
1435
1436		Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
1437		Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
1438		Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
1439		Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
1440		Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
831	–	Double_t tmpNeutralHadronIso_DR0p5To0p7 = 0;
1441
1442
1443
#	Line 858 \| Line 1467 \| SelectionStatus electronIsoMVASelection(
1467		//Loop over PF Candidates
1468		//
1469		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1470	+
1471	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1472	+
1473		const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1474		Double_t deta = (ele->Eta() - pf->Eta());
1475		Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1476		Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1477	<	if (dr >= 0.5) continue;
1477	>	if (dr > 1.0) continue;
1478	>
1479		if(ctrl.debug) {
1480		cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1481		if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
#	Line 880 \| Line 1493 \| SelectionStatus electronIsoMVASelection(
1493		Bool_t IsLeptonFootprint = kFALSE;
1494		if (dr < 1.0) {
1495
1496	+
1497		//
1498		// Check for electrons
1499		//
1500	+
1501		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1502		const mithep::Electron *tmpele = electronsToVeto[q];
1503	+	double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1504	+
1505		// 4l electron
1506		if( pf->HasTrackerTrk() ) {
1507		if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
#	Line 899 \| Line 1516 \| SelectionStatus electronIsoMVASelection(
1516		}
1517		}
1518		// PF charged
1519	<	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
903	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
1519	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1520		if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1521		IsLeptonFootprint = kTRUE;
1522		}
1523		// PF gamma
1524	<	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
1525	<	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
1524	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1525	>	&& tmpdr < 0.08) {
1526		if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1527		IsLeptonFootprint = kTRUE;
1528		}
1529		} // loop over electrons
1530	<
1530	>
1531	>
1532	>	/* KH - comment for sync
1533		//
1534		// Check for muons
1535		//
#	Line 930 \| Line 1548 \| SelectionStatus electronIsoMVASelection(
1548		IsLeptonFootprint = kTRUE;
1549		}
1550		} // loop over muons
1551	<
1551	>	*/
1552
1553		if (IsLeptonFootprint)
1554		continue;
#	Line 940 \| Line 1558 \| SelectionStatus electronIsoMVASelection(
1558		//
1559		if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1560
1561	<	if( pf->HasTrackerTrk() )
1562	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1563	<	if( pf->HasGsfTrk() )
1564	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1561	>	// if( pf->HasGsfTrk() ) {
1562	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1563	>	// } else if( pf->HasTrackerTrk() ){
1564	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1565	>	// }
1566
1567		// Veto any PFmuon, or PFEle
1568		if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
#	Line 960 \| Line 1579 \| SelectionStatus electronIsoMVASelection(
1579		if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
1580		if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
1581		if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
963	–	if (dr >= 0.5 && dr < 0.7) tmpChargedIso_DR0p5To0p7 += pf->Pt();
1582
1583		}
1584
#	Line 969 \| Line 1587 \| SelectionStatus electronIsoMVASelection(
1587		//
1588		else if (abs(pf->PFType()) == PFCandidate::eGamma) {
1589
1590	<	if (fabs(ele->SCluster()->Eta()) > 1.479) {
973	<	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
974	<	}
1590	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
1591
1592		if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
1593		<< dr << endl;
#	Line 981 \| Line 1597 \| SelectionStatus electronIsoMVASelection(
1597		if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
1598		if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
1599		if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
984	–	if (dr >= 0.5 && dr < 0.7) tmpGammaIso_DR0p5To0p7 += pf->Pt();
985	–
1600		}
1601
1602		//
#	Line 996 \| Line 1610 \| SelectionStatus electronIsoMVASelection(
1610		if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
1611		if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
1612		if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
999	–	if (dr >= 0.5 && dr < 0.7) tmpNeutralHadronIso_DR0p5To0p7 += pf->Pt();
1613		}
1614
1615		}
1616
1617		}
1618
1619	<	fChargedIso_DR0p0To0p1 = min((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1620	<	fChargedIso_DR0p1To0p2 = min((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1621	<	fChargedIso_DR0p2To0p3 = min((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1622	<	fChargedIso_DR0p3To0p4 = min((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1623	<	fChargedIso_DR0p4To0p5 = min((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1619	>	fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
1620	>	fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
1621	>	fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
1622	>	fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
1623	>	fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
1624	>
1625	>	if(ctrl.debug) {
1626	>	cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1 << endl;
1627	>	cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2 << endl;
1628	>	cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3 << endl;
1629	>	cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4 << endl;
1630	>	cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5 << endl;
1631	>	}
1632	>
1633
1634		double rho = 0;
1635		if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
1636		rho = fPUEnergyDensity->At(0)->Rho();
1637	+	// if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
1638	+	// rho = fPUEnergyDensity->At(0)->RhoLowEta();
1639	+
1640	+	// WARNING!!!!
1641	+	// hardcode for sync ...
1642	+	EffectiveAreaVersion = eleT.kEleEAData2011;
1643	+	// WARNING!!!!
1644	+
1645	+	if( ctrl.debug) {
1646	+	cout << "RHO: " << rho << endl;
1647	+	cout << "eta: " << ele->SCluster()->Eta() << endl;
1648	+	cout << "target: " << EffectiveAreaVersion << endl;
1649	+	cout << "effA 0-1: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1650	+	ele->SCluster()->Eta(),
1651	+	EffectiveAreaVersion)
1652	+	<< endl;
1653	+	cout << "effA 1-2: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1654	+	ele->SCluster()->Eta(),
1655	+	EffectiveAreaVersion)
1656	+	<< endl;
1657	+	cout << "effA 2-3: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1658	+	ele->SCluster()->Eta(),
1659	+	EffectiveAreaVersion)
1660	+	<< endl;
1661	+	cout << "effA 3-4: " << eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1662	+	ele->SCluster()->Eta(),
1663	+	EffectiveAreaVersion)
1664	+	<< endl;
1665	+	}
1666	+
1667	+	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
1668	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
1669	+	ele->SCluster()->Eta(),
1670	+	EffectiveAreaVersion))/ele->Pt()
1671	+	,2.5)
1672	+	,0.0);
1673	+	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
1674	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
1675	+	ele->SCluster()->Eta(),
1676	+	EffectiveAreaVersion))/ele->Pt()
1677	+	,2.5)
1678	+	,0.0);
1679	+	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
1680	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
1681	+	ele->SCluster()->Eta()
1682	+	,EffectiveAreaVersion))/ele->Pt()
1683	+	,2.5)
1684	+	,0.0);
1685	+	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
1686	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
1687	+	ele->SCluster()->Eta(),
1688	+	EffectiveAreaVersion))/ele->Pt()
1689	+	,2.5)
1690	+	,0.0);
1691	+	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
1692	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
1693	+	ele->SCluster()->Eta(),
1694	+	EffectiveAreaVersion))/ele->Pt()
1695	+	,2.5)
1696	+	,0.0);
1697	+
1698	+
1699	+	if( ctrl.debug) {
1700	+	cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
1701	+	cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
1702	+	cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
1703	+	cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
1704	+	cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
1705	+	}
1706	+
1707	+	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
1708	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
1709	+	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1710	+	, 2.5)
1711	+	, 0.0);
1712	+	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
1713	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
1714	+	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1715	+	, 2.5)
1716	+	, 0.0);
1717	+	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
1718	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
1719	+	ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
1720	+	, 2.5)
1721	+	, 0.0);
1722	+	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
1723	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
1724	+	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1725	+	, 2.5)
1726	+	, 0.0);
1727	+	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
1728	+	-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
1729	+	ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
1730	+	, 2.5)
1731	+	, 0.0);
1732	+
1733	+	if( ctrl.debug) {
1734	+	cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
1735	+	cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
1736	+	cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
1737	+	cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
1738	+	cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
1739	+	}
1740	+
1741	+	double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
1742	+	ele->SCluster()->Eta(),
1743	+	fChargedIso_DR0p0To0p1,
1744	+	fChargedIso_DR0p1To0p2,
1745	+	fChargedIso_DR0p2To0p3,
1746	+	fChargedIso_DR0p3To0p4,
1747	+	fChargedIso_DR0p4To0p5,
1748	+	fGammaIso_DR0p0To0p1,
1749	+	fGammaIso_DR0p1To0p2,
1750	+	fGammaIso_DR0p2To0p3,
1751	+	fGammaIso_DR0p3To0p4,
1752	+	fGammaIso_DR0p4To0p5,
1753	+	fNeutralHadronIso_DR0p0To0p1,
1754	+	fNeutralHadronIso_DR0p1To0p2,
1755	+	fNeutralHadronIso_DR0p2To0p3,
1756	+	fNeutralHadronIso_DR0p3To0p4,
1757	+	fNeutralHadronIso_DR0p4To0p5,
1758	+	ctrl.debug);
1759	+
1760	+	SelectionStatus status;
1761	+	status.isoMVA = mvaval;
1762	+	bool pass = false;
1763	+
1764	+	Int_t subdet = 0;
1765	+	if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
1766	+	else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
1767	+	else subdet = 2;
1768	+
1769	+	Int_t ptBin = 0;
1770	+	if (ele->Pt() >= 10.0) ptBin = 1;
1771	+
1772	+	Int_t MVABin = -1;
1773	+	if (subdet == 0 && ptBin == 0) MVABin = 0;
1774	+	if (subdet == 1 && ptBin == 0) MVABin = 1;
1775	+	if (subdet == 2 && ptBin == 0) MVABin = 2;
1776	+	if (subdet == 0 && ptBin == 1) MVABin = 3;
1777	+	if (subdet == 1 && ptBin == 1) MVABin = 4;
1778	+	if (subdet == 2 && ptBin == 1) MVABin = 5;
1779	+
1780	+	pass = false;
1781	+	if( MVABin == 0 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN0 ) pass = true;
1782	+	if( MVABin == 1 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN1 ) pass = true;
1783	+	if( MVABin == 2 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN2 ) pass = true;
1784	+	if( MVABin == 3 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN3 ) pass = true;
1785	+	if( MVABin == 4 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN4 ) pass = true;
1786	+	if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_OPT_BIN5 ) pass = true;
1787	+	// pass &= (fChargedIso_DR0p0To0p1 + fChargedIso_DR0p1To0p2 + fChargedIso_DR0p2To0p3 < 0.7);
1788	+	if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
1789	+
1790	+	// pass = false;
1791	+	// if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
1792	+	// if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
1793	+	// if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
1794	+	// if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
1795	+	// if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
1796	+	// if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
1797	+	// if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
1798	+
1799	+	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
1800	+	return status;
1801	+
1802	+	}
1803	+
1804	+
1805	+	//--------------------------------------------------------------------------------------------------
1806	+	SelectionStatus electronIsoMVASelection(ControlFlags &ctrl,
1807	+	const mithep::Electron * ele,
1808	+	const mithep::Vertex & vtx,
1809	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
1810	+	float rho,
1811	+	//const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
1812	+	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
1813	+	vector<const mithep::Muon*> muonsToVeto,
1814	+	vector<const mithep::Electron*> electronsToVeto)
1815	+	//--------------------------------------------------------------------------------------------------
1816	+	// hacked version
1817	+	{
1818	+	if( ctrl.debug ) {
1819	+	cout << "================> hacked ele Iso MVA <======================" << endl;
1820	+	}
1821	+
1822	+	if( ctrl.debug ) {
1823	+	cout << "electronIsoMVASelection :: muons to veto " << endl;
1824	+	for( int i=0; i<muonsToVeto.size(); i++ ) {
1825	+	const mithep::Muon * vmu = muonsToVeto[i];
1826	+	cout << "\tpt: " << vmu->Pt()
1827	+	<< "\teta: " << vmu->Eta()
1828	+	<< "\tphi: " << vmu->Phi()
1829	+	<< endl;
1830	+	}
1831	+	cout << "electronIsoMVASelection :: electrson to veto " << endl;
1832	+	for( int i=0; i<electronsToVeto.size(); i++ ) {
1833	+	const mithep::Electron * vel = electronsToVeto[i];
1834	+	cout << "\tpt: " << vel->Pt()
1835	+	<< "\teta: " << vel->Eta()
1836	+	<< "\tphi: " << vel->Phi()
1837	+	<< "\ttrk: " << vel->TrackerTrk()
1838	+	<< endl;
1839	+	}
1840	+	}
1841	+
1842	+	bool failiso=false;
1843	+
1844	+	//
1845	+	// tmp iso rings
1846	+	//
1847	+	Double_t tmpChargedIso_DR0p0To0p1 = 0;
1848	+	Double_t tmpChargedIso_DR0p1To0p2 = 0;
1849	+	Double_t tmpChargedIso_DR0p2To0p3 = 0;
1850	+	Double_t tmpChargedIso_DR0p3To0p4 = 0;
1851	+	Double_t tmpChargedIso_DR0p4To0p5 = 0;
1852	+
1853	+	Double_t tmpGammaIso_DR0p0To0p1 = 0;
1854	+	Double_t tmpGammaIso_DR0p1To0p2 = 0;
1855	+	Double_t tmpGammaIso_DR0p2To0p3 = 0;
1856	+	Double_t tmpGammaIso_DR0p3To0p4 = 0;
1857	+	Double_t tmpGammaIso_DR0p4To0p5 = 0;
1858	+
1859	+
1860	+	Double_t tmpNeutralHadronIso_DR0p0To0p1 = 0;
1861	+	Double_t tmpNeutralHadronIso_DR0p1To0p2 = 0;
1862	+	Double_t tmpNeutralHadronIso_DR0p2To0p3 = 0;
1863	+	Double_t tmpNeutralHadronIso_DR0p3To0p4 = 0;
1864	+	Double_t tmpNeutralHadronIso_DR0p4To0p5 = 0;
1865	+
1866	+
1867	+
1868	+	//
1869	+	// final rings for the MVA
1870	+	//
1871	+	Double_t fChargedIso_DR0p0To0p1;
1872	+	Double_t fChargedIso_DR0p1To0p2;
1873	+	Double_t fChargedIso_DR0p2To0p3;
1874	+	Double_t fChargedIso_DR0p3To0p4;
1875	+	Double_t fChargedIso_DR0p4To0p5;
1876	+
1877	+	Double_t fGammaIso_DR0p0To0p1;
1878	+	Double_t fGammaIso_DR0p1To0p2;
1879	+	Double_t fGammaIso_DR0p2To0p3;
1880	+	Double_t fGammaIso_DR0p3To0p4;
1881	+	Double_t fGammaIso_DR0p4To0p5;
1882	+
1883	+	Double_t fNeutralHadronIso_DR0p0To0p1;
1884	+	Double_t fNeutralHadronIso_DR0p1To0p2;
1885	+	Double_t fNeutralHadronIso_DR0p2To0p3;
1886	+	Double_t fNeutralHadronIso_DR0p3To0p4;
1887	+	Double_t fNeutralHadronIso_DR0p4To0p5;
1888	+
1889	+
1890	+	//
1891	+	//Loop over PF Candidates
1892	+	//
1893	+	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
1894	+
1895	+	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
1896	+
1897	+	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
1898	+	Double_t deta = (ele->Eta() - pf->Eta());
1899	+	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
1900	+	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
1901	+	if (dr > 1.0) continue;
1902	+
1903	+	if(ctrl.debug) {
1904	+	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
1905	+	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
1906	+	cout << endl;
1907	+	}
1908	+
1909	+
1910	+	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
1911	+	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
1912	+
1913	+
1914	+	//
1915	+	// Lepton Footprint Removal
1916	+	//
1917	+	Bool_t IsLeptonFootprint = kFALSE;
1918	+	if (dr < 1.0) {
1919	+
1920	+
1921	+	//
1922	+	// Check for electrons
1923	+	//
1924	+
1925	+	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
1926	+	const mithep::Electron *tmpele = electronsToVeto[q];
1927	+	double tmpdr = mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta());
1928	+
1929	+	// 4l electron
1930	+	if( pf->HasTrackerTrk() ) {
1931	+	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
1932	+	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
1933	+	IsLeptonFootprint = kTRUE;
1934	+	}
1935	+	}
1936	+	if( pf->HasGsfTrk() ) {
1937	+	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
1938	+	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
1939	+	IsLeptonFootprint = kTRUE;
1940	+	}
1941	+	}
1942	+	// PF charged
1943	+	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) >= 1.479 && tmpdr < 0.015) {
1944	+	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
1945	+	IsLeptonFootprint = kTRUE;
1946	+	}
1947	+	// PF gamma
1948	+	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) >= 1.479
1949	+	&& tmpdr < 0.08) {
1950	+	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
1951	+	IsLeptonFootprint = kTRUE;
1952	+	}
1953	+	} // loop over electrons
1954	+
1955	+
1956	+	/* KH - comment for sync
1957	+	//
1958	+	// Check for muons
1959	+	//
1960	+	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
1961	+	const mithep::Muon *tmpmu = muonsToVeto[q];
1962	+	// 4l muon
1963	+	if( pf->HasTrackerTrk() ) {
1964	+	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
1965	+	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
1966	+	IsLeptonFootprint = kTRUE;
1967	+	}
1968	+	}
1969	+	// PF charged
1970	+	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
1971	+	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
1972	+	IsLeptonFootprint = kTRUE;
1973	+	}
1974	+	} // loop over muons
1975	+	*/
1976	+
1977	+	if (IsLeptonFootprint)
1978	+	continue;
1979	+
1980	+	//
1981	+	// Charged Iso Rings
1982	+	//
1983	+	if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
1984	+
1985	+	// if( pf->HasGsfTrk() ) {
1986	+	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
1987	+	// } else if( pf->HasTrackerTrk() ){
1988	+	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
1989	+	// }
1990	+
1991	+	// Veto any PFmuon, or PFEle
1992	+	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
1993	+
1994	+	// Footprint Veto
1995	+	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
1996	+
1997	+	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
1998	+	<< "\ttype: " << pf->PFType()
1999	+	<< "\ttrk: " << pf->TrackerTrk() << endl;
2000	+
2001	+	if (dr < 0.1) tmpChargedIso_DR0p0To0p1 += pf->Pt();
2002	+	if (dr >= 0.1 && dr < 0.2) tmpChargedIso_DR0p1To0p2 += pf->Pt();
2003	+	if (dr >= 0.2 && dr < 0.3) tmpChargedIso_DR0p2To0p3 += pf->Pt();
2004	+	if (dr >= 0.3 && dr < 0.4) tmpChargedIso_DR0p3To0p4 += pf->Pt();
2005	+	if (dr >= 0.4 && dr < 0.5) tmpChargedIso_DR0p4To0p5 += pf->Pt();
2006	+
2007	+	}
2008	+
2009	+	//
2010	+	// Gamma Iso Rings
2011	+	//
2012	+	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2013	+
2014	+	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.08) continue;
2015	+
2016	+	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2017	+	<< dr << endl;
2018	+
2019	+	if (dr < 0.1) tmpGammaIso_DR0p0To0p1 += pf->Pt();
2020	+	if (dr >= 0.1 && dr < 0.2) tmpGammaIso_DR0p1To0p2 += pf->Pt();
2021	+	if (dr >= 0.2 && dr < 0.3) tmpGammaIso_DR0p2To0p3 += pf->Pt();
2022	+	if (dr >= 0.3 && dr < 0.4) tmpGammaIso_DR0p3To0p4 += pf->Pt();
2023	+	if (dr >= 0.4 && dr < 0.5) tmpGammaIso_DR0p4To0p5 += pf->Pt();
2024	+	}
2025	+
2026	+	//
2027	+	// Other Neutral Iso Rings
2028	+	//
2029	+	else {
2030	+	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2031	+	<< dr << endl;
2032	+	if (dr < 0.1) tmpNeutralHadronIso_DR0p0To0p1 += pf->Pt();
2033	+	if (dr >= 0.1 && dr < 0.2) tmpNeutralHadronIso_DR0p1To0p2 += pf->Pt();
2034	+	if (dr >= 0.2 && dr < 0.3) tmpNeutralHadronIso_DR0p2To0p3 += pf->Pt();
2035	+	if (dr >= 0.3 && dr < 0.4) tmpNeutralHadronIso_DR0p3To0p4 += pf->Pt();
2036	+	if (dr >= 0.4 && dr < 0.5) tmpNeutralHadronIso_DR0p4To0p5 += pf->Pt();
2037	+	}
2038	+
2039	+	}
2040	+
2041	+	}
2042	+
2043	+	fChargedIso_DR0p0To0p1 = fmin((tmpChargedIso_DR0p0To0p1)/ele->Pt(), 2.5);
2044	+	fChargedIso_DR0p1To0p2 = fmin((tmpChargedIso_DR0p1To0p2)/ele->Pt(), 2.5);
2045	+	fChargedIso_DR0p2To0p3 = fmin((tmpChargedIso_DR0p2To0p3)/ele->Pt(), 2.5);
2046	+	fChargedIso_DR0p3To0p4 = fmin((tmpChargedIso_DR0p3To0p4)/ele->Pt(), 2.5);
2047	+	fChargedIso_DR0p4To0p5 = fmin((tmpChargedIso_DR0p4To0p5)/ele->Pt(), 2.5);
2048	+
2049	+	if(ctrl.debug) {
2050	+	cout << "fChargedIso_DR0p0To0p1 : " << fChargedIso_DR0p0To0p1 << endl;
2051	+	cout << "fChargedIso_DR0p1To0p2 : " << fChargedIso_DR0p1To0p2 << endl;
2052	+	cout << "fChargedIso_DR0p2To0p3 : " << fChargedIso_DR0p2To0p3 << endl;
2053	+	cout << "fChargedIso_DR0p3To0p4 : " << fChargedIso_DR0p3To0p4 << endl;
2054	+	cout << "fChargedIso_DR0p4To0p5 : " << fChargedIso_DR0p4To0p5 << endl;
2055	+	}
2056	+
2057	+
2058	+	// rho=0;
2059	+	// double rho = 0;
2060	+	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
2061	+	// rho = fPUEnergyDensity->At(0)->Rho();
2062	+	// if (!(isnan(fPUEnergyDensity->At(0)->RhoLowEta()) \|\| isinf(fPUEnergyDensity->At(0)->RhoLowEta())))
2063	+	// rho = fPUEnergyDensity->At(0)->RhoLowEta();
2064	+
2065	+	// WARNING!!!!
2066	+	// hardcode for sync ...
2067	+	EffectiveAreaVersion = eleT.kEleEAData2011;
2068	+	// WARNING!!!!
2069
2070		if( ctrl.debug) {
2071		cout << "RHO: " << rho << endl;
#	Line 1035 \| Line 2089 \| SelectionStatus electronIsoMVASelection(
2089		<< endl;
2090		}
2091
2092	<	fGammaIso_DR0p0To0p1 = max(min((tmpGammaIso_DR0p0To0p1
2092	>	fGammaIso_DR0p0To0p1 = fmax(fmin((tmpGammaIso_DR0p0To0p1
2093		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p0To0p1,
2094		ele->SCluster()->Eta(),
2095		EffectiveAreaVersion))/ele->Pt()
2096		,2.5)
2097		,0.0);
2098	<	fGammaIso_DR0p1To0p2 = max(min((tmpGammaIso_DR0p1To0p2
2098	>	fGammaIso_DR0p1To0p2 = fmax(fmin((tmpGammaIso_DR0p1To0p2
2099		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p1To0p2,
2100		ele->SCluster()->Eta(),
2101		EffectiveAreaVersion))/ele->Pt()
2102		,2.5)
2103		,0.0);
2104	<	fGammaIso_DR0p2To0p3 = max(min((tmpGammaIso_DR0p2To0p3
2104	>	fGammaIso_DR0p2To0p3 = fmax(fmin((tmpGammaIso_DR0p2To0p3
2105		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p2To0p3,
2106		ele->SCluster()->Eta()
2107		,EffectiveAreaVersion))/ele->Pt()
2108		,2.5)
2109		,0.0);
2110	<	fGammaIso_DR0p3To0p4 = max(min((tmpGammaIso_DR0p3To0p4
2110	>	fGammaIso_DR0p3To0p4 = fmax(fmin((tmpGammaIso_DR0p3To0p4
2111		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p3To0p4,
2112		ele->SCluster()->Eta(),
2113		EffectiveAreaVersion))/ele->Pt()
2114		,2.5)
2115		,0.0);
2116	<	fGammaIso_DR0p4To0p5 = max(min((tmpGammaIso_DR0p4To0p5
2116	>	fGammaIso_DR0p4To0p5 = fmax(fmin((tmpGammaIso_DR0p4To0p5
2117		-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIsoDR0p4To0p5,
2118		ele->SCluster()->Eta(),
2119		EffectiveAreaVersion))/ele->Pt()
#	Line 1067 \| Line 2121 \| SelectionStatus electronIsoMVASelection(
2121		,0.0);
2122
2123
2124	<	fNeutralHadronIso_DR0p0To0p1 = max(min((tmpNeutralHadronIso_DR0p0To0p1
2124	>	if( ctrl.debug) {
2125	>	cout << "fGammaIso_DR0p0To0p1: " << fGammaIso_DR0p0To0p1 << endl;
2126	>	cout << "fGammaIso_DR0p1To0p2: " << fGammaIso_DR0p1To0p2 << endl;
2127	>	cout << "fGammaIso_DR0p2To0p3: " << fGammaIso_DR0p2To0p3 << endl;
2128	>	cout << "fGammaIso_DR0p3To0p4: " << fGammaIso_DR0p3To0p4 << endl;
2129	>	cout << "fGammaIso_DR0p4To0p5: " << fGammaIso_DR0p4To0p5 << endl;
2130	>	}
2131	>
2132	>	fNeutralHadronIso_DR0p0To0p1 = fmax(fmin((tmpNeutralHadronIso_DR0p0To0p1
2133		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p0To0p1,
2134		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2135		, 2.5)
2136		, 0.0);
2137	<	fNeutralHadronIso_DR0p1To0p2 = max(min((tmpNeutralHadronIso_DR0p1To0p2
2137	>	fNeutralHadronIso_DR0p1To0p2 = fmax(fmin((tmpNeutralHadronIso_DR0p1To0p2
2138		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p1To0p2,
2139		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2140		, 2.5)
2141		, 0.0);
2142	<	fNeutralHadronIso_DR0p2To0p3 = max(min((tmpNeutralHadronIso_DR0p2To0p3
2142	>	fNeutralHadronIso_DR0p2To0p3 = fmax(fmin((tmpNeutralHadronIso_DR0p2To0p3
2143		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p2To0p3,
2144		ele->SCluster()->Eta(),EffectiveAreaVersion))/ele->Pt()
2145		, 2.5)
2146		, 0.0);
2147	<	fNeutralHadronIso_DR0p3To0p4 = max(min((tmpNeutralHadronIso_DR0p3To0p4
2147	>	fNeutralHadronIso_DR0p3To0p4 = fmax(fmin((tmpNeutralHadronIso_DR0p3To0p4
2148		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p3To0p4,
2149		ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2150		, 2.5)
2151		, 0.0);
2152	<	fNeutralHadronIso_DR0p4To0p5 = max(min((tmpNeutralHadronIso_DR0p4To0p5
2152	>	fNeutralHadronIso_DR0p4To0p5 = fmax(fmin((tmpNeutralHadronIso_DR0p4To0p5
2153		-rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIsoDR0p4To0p5,
2154		ele->SCluster()->Eta(), EffectiveAreaVersion))/ele->Pt()
2155		, 2.5)
2156		, 0.0);
2157
2158	+	if( ctrl.debug) {
2159	+	cout << "fNeutralHadronIso_DR0p0To0p1: " << fNeutralHadronIso_DR0p0To0p1 << endl;
2160	+	cout << "fNeutralHadronIso_DR0p1To0p2: " << fNeutralHadronIso_DR0p1To0p2 << endl;
2161	+	cout << "fNeutralHadronIso_DR0p2To0p3: " << fNeutralHadronIso_DR0p2To0p3 << endl;
2162	+	cout << "fNeutralHadronIso_DR0p3To0p4: " << fNeutralHadronIso_DR0p3To0p4 << endl;
2163	+	cout << "fNeutralHadronIso_DR0p4To0p5: " << fNeutralHadronIso_DR0p4To0p5 << endl;
2164	+	}
2165	+
2166		double mvaval = eleIsoMVA->MVAValue_IsoRings( ele->Pt(),
2167		ele->SCluster()->Eta(),
2168		fChargedIso_DR0p0To0p1,
#	Line 1113 \| Line 2183 \| SelectionStatus electronIsoMVASelection(
2183		ctrl.debug);
2184
2185		SelectionStatus status;
2186	+	status.isoMVA = mvaval;
2187		bool pass = false;
2188
2189		Int_t subdet = 0;
2190		if (fabs(ele->SCluster()->Eta()) < 0.8) subdet = 0;
2191		else if (fabs(ele->SCluster()->Eta()) < 1.479) subdet = 1;
2192		else subdet = 2;
2193	+
2194		Int_t ptBin = 0;
2195	<	if (ele->Pt() > 10.0) ptBin = 1;
2195	>	if (ele->Pt() >= 10.0) ptBin = 1;
2196
2197		Int_t MVABin = -1;
2198		if (subdet == 0 && ptBin == 0) MVABin = 0;
#	Line 1139 \| Line 2211 \| SelectionStatus electronIsoMVASelection(
2211		if( MVABin == 5 && mvaval > ELECTRON_LOOSE_ISOMVA_CUT_BIN5 ) pass = true;
2212		if( pass ) status.orStatus(SelectionStatus::LOOSEISO);
2213
2214	<	pass = false;
2215	<	if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
2216	<	if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
2217	<	if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
2218	<	if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
2219	<	if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
2220	<	if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
2221	<	if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
2214	>	// pass = false;
2215	>	// if( MVABin == 0 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN0 ) pass = true;
2216	>	// if( MVABin == 1 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN1 ) pass = true;
2217	>	// if( MVABin == 2 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN2 ) pass = true;
2218	>	// if( MVABin == 3 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN3 ) pass = true;
2219	>	// if( MVABin == 4 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN4 ) pass = true;
2220	>	// if( MVABin == 5 && mvaval > ELECTRON_TIGHT_ISOMVA_CUT_BIN5 ) pass = true;
2221	>	// if( pass ) status.orStatus(SelectionStatus::TIGHTISO);
2222
2223		if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2224		return status;
#	Line 1170 \| Line 2242 \| void initElectronIsoMVA() {
2242
2243
2244
2245	+
2246		//--------------------------------------------------------------------------------------------------
2247	+	// hacked version
2248		float electronPFIso04(ControlFlags &ctrl,
2249	<	const mithep::Electron * ele,
2250	<	const mithep::Vertex & vtx,
2251	<	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2252	<	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2253	<	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2254	<	vector<const mithep::Muon*> muonsToVeto,
2255	<	vector<const mithep::Electron*> electronsToVeto)
2249	>	const mithep::Electron * ele,
2250	>	const mithep::Vertex & vtx,
2251	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2252	>	const mithep::Array<mithep::PileupEnergyDensity> * fPUEnergyDensity,
2253	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2254	>	vector<const mithep::Muon*> muonsToVeto,
2255	>	vector<const mithep::Electron*> electronsToVeto)
2256		//--------------------------------------------------------------------------------------------------
2257		{
2258
#	Line 1191 \| Line 2265 \| float electronPFIso04(ControlFlags &ctrl
2265		<< "\tphi: " << vmu->Phi()
2266		<< endl;
2267		}
2268	<	cout << "electronIsoMVASelection :: electrson to veto " << endl;
2268	>	cout << "electronIsoMVASelection :: electrons to veto " << endl;
2269		for( int i=0; i<electronsToVeto.size(); i++ ) {
2270		const mithep::Electron * vel = electronsToVeto[i];
2271		cout << "\tpt: " << vel->Pt()
#	Line 1215 \| Line 2289 \| float electronPFIso04(ControlFlags &ctrl
2289		//Loop over PF Candidates
2290		//
2291		for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2292	+
2293	+
2294		const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
2295		Double_t deta = (ele->Eta() - pf->Eta());
2296		Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2297		Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2298	<	if (dr >= 0.4) continue;
2298	>
2299	>	if (dr > 0.4) continue;
2300	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2301	>
2302		if(ctrl.debug) {
2303	<	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt();
2304	<	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx);
2303	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2304	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx)
2305	>	<< "\ttrk: " << pf->HasTrackerTrk()
2306	>	<< "\tgsf: " << pf->HasGsfTrk();
2307	>
2308		cout << endl;
2309		}
2310
2311
2312	<	if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
2313	<	(pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) continue;
2314	<
2312	>	//
2313	>	// sync : I don't think theyre doing this ...
2314	>	//
2315	>	// if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
2316	>	// (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2317	>	// if( ctrl.debug ) cout << "\tskipping, matches to the electron ..." << endl;
2318	>	// continue;
2319	>	// }
2320	>
2321
2322		//
2323		// Lepton Footprint Removal
#	Line 1242 \| Line 2330 \| float electronPFIso04(ControlFlags &ctrl
2330		//
2331		for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2332		const mithep::Electron *tmpele = electronsToVeto[q];
2333	+	/*
2334		// 4l electron
2335		if( pf->HasTrackerTrk() ) {
2336		if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
#	Line 1255 \| Line 2344 \| float electronPFIso04(ControlFlags &ctrl
2344		IsLeptonFootprint = kTRUE;
2345		}
2346		}
2347	+	*/
2348		// PF charged
2349		if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2350		&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
#	Line 1268 \| Line 2358 \| float electronPFIso04(ControlFlags &ctrl
2358		IsLeptonFootprint = kTRUE;
2359		}
2360		} // loop over electrons
2361	<
2361	>
2362	>	/* KH - comment for sync
2363		//
2364		// Check for muons
2365		//
#	Line 1287 \| Line 2378 \| float electronPFIso04(ControlFlags &ctrl
2378		IsLeptonFootprint = kTRUE;
2379		}
2380		} // loop over muons
2381	<
2381	>	*/
2382
2383		if (IsLeptonFootprint)
2384		continue;
2385
2386		//
2387	<	// Charged Iso Rings
2387	>	// Charged Iso
2388		//
2389		if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
2390
2391	<	if( pf->HasTrackerTrk() )
2392	<	if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2393	<	if( pf->HasGsfTrk() )
2394	<	if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2391	>	// if( pf->HasTrackerTrk() )
2392	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2393	>	// if( pf->HasGsfTrk() )
2394	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2395
2396		// Veto any PFmuon, or PFEle
2397	<	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) continue;
2397	>	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) {
2398	>	cout << "\t skipping, pf is and ele or mu .." <<endl;
2399	>	continue;
2400	>	}
2401
2402		// Footprint Veto
2403		if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
#	Line 1325 \| Line 2419 \| float electronPFIso04(ControlFlags &ctrl
2419		}
2420		if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2421		<< dr << endl;
2422	<	fGammaIso += pf->Pt();
2422	>	// KH, add to sync
2423	>	// if( pf->Pt() > 0.5 )
2424	>	fGammaIso += pf->Pt();
2425		}
2426
2427		//
#	Line 1334 \| Line 2430 \| float electronPFIso04(ControlFlags &ctrl
2430		else {
2431		if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2432		<< dr << endl;
2433	<	fNeutralHadronIso += pf->Pt();
2433	>	// KH, add to sync
2434	>	// if( pf->Pt() > 0.5 )
2435	>	fNeutralHadronIso += pf->Pt();
2436		}
2437
2438		}
2439
2440		}
2441
2442	<	double rho = 0;
2442	>
2443	>	double rho=0;
2444		if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
2445		rho = fPUEnergyDensity->At(0)->Rho();
2446
#	Line 1351 \| Line 2450 \| float electronPFIso04(ControlFlags &ctrl
2450		// WARNING!!!!
2451
2452
2453	<	double pfIso = fChargedIso +
2454	<	max(0.0,fGammaIso -rho*eleT.ElectronEffectiveArea(eleT.kEleGammaIso04,
2455	<	ele->Eta(),EffectiveAreaVersion)) +
2456	<	max(0.0,fNeutralHadronIso -rho*eleT.ElectronEffectiveArea(eleT.kEleNeutralHadronIso04,
2457	<	ele->Eta(),EffectiveAreaVersion)) ;
2453	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2454	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2455	>	ele->Eta(),EffectiveAreaVersion)));
2456	>
2457	>
2458	>	gChargedIso = fChargedIso;
2459	>	gGammaIso = fGammaIso;
2460	>	gNeutralIso = fNeutralHadronIso;
2461	>	return pfIso;
2462	>	}
2463	>
2464	>
2465	>
2466	>	//--------------------------------------------------------------------------------------------------
2467	>	// hacked version
2468	>	float electronPFIso04(ControlFlags &ctrl,
2469	>	const mithep::Electron * ele,
2470	>	const mithep::Vertex & vtx,
2471	>	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2472	>	float rho,
2473	>	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2474	>	vector<const mithep::Muon*> muonsToVeto,
2475	>	vector<const mithep::Electron*> electronsToVeto)
2476	>	//--------------------------------------------------------------------------------------------------
2477	>	{
2478	>
2479	>	if( ctrl.debug ) {
2480	>	cout << "electronIsoMVASelection :: muons to veto " << endl;
2481	>	for( int i=0; i<muonsToVeto.size(); i++ ) {
2482	>	const mithep::Muon * vmu = muonsToVeto[i];
2483	>	cout << "\tpt: " << vmu->Pt()
2484	>	<< "\teta: " << vmu->Eta()
2485	>	<< "\tphi: " << vmu->Phi()
2486	>	<< endl;
2487	>	}
2488	>	cout << "electronIsoMVASelection :: electrons to veto " << endl;
2489	>	for( int i=0; i<electronsToVeto.size(); i++ ) {
2490	>	const mithep::Electron * vel = electronsToVeto[i];
2491	>	cout << "\tpt: " << vel->Pt()
2492	>	<< "\teta: " << vel->Eta()
2493	>	<< "\tphi: " << vel->Phi()
2494	>	<< "\ttrk: " << vel->TrackerTrk()
2495	>	<< endl;
2496	>	}
2497	>	}
2498	>
2499	>
2500	>	//
2501	>	// final iso
2502	>	//
2503	>	Double_t fChargedIso = 0.0;
2504	>	Double_t fGammaIso = 0.0;
2505	>	Double_t fNeutralHadronIso = 0.0;
2506	>
2507	>
2508	>	//
2509	>	//Loop over PF Candidates
2510	>	//
2511	>	for(int k=0; k<fPFCandidates->GetEntries(); ++k) {
2512	>
2513	>
2514	>	const mithep::PFCandidate pf = (mithep::PFCandidate)((*fPFCandidates)[k]);
2515	>	Double_t deta = (ele->Eta() - pf->Eta());
2516	>	Double_t dphi = mithep::MathUtils::DeltaPhi(Double_t(ele->Phi()),Double_t(pf->Phi()));
2517	>	Double_t dr = mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta());
2518	>
2519	>	if (dr > 0.4) continue;
2520	>	if( !(PFnoPUflag[k]) ) continue; // my PF no PU hack
2521	>
2522	>	if(ctrl.debug) {
2523	>	cout << "pf :: type: " << pf->PFType() << "\tpt: " << pf->Pt() << "\tdR: " << dr;
2524	>	if( pf->HasTrackerTrk() ) cout << "\tdZ: " << pf->TrackerTrk()->DzCorrected(vtx)
2525	>	<< "\ttrk: " << pf->HasTrackerTrk()
2526	>	<< "\tgsf: " << pf->HasGsfTrk();
2527	>
2528	>	cout << endl;
2529	>	}
2530	>
2531	>
2532	>	//
2533	>	// sync : I don't think theyre doing this ...
2534	>	//
2535	>	// if ( (pf->HasTrackerTrk() && (pf->TrackerTrk() == ele->TrackerTrk())) \|\|
2536	>	// (pf->HasGsfTrk() && (pf->GsfTrk() == ele->GsfTrk()))) {
2537	>	// if( ctrl.debug ) cout << "\tskipping, matches to the electron ..." << endl;
2538	>	// continue;
2539	>	// }
2540	>
2541	>
2542	>	//
2543	>	// Lepton Footprint Removal
2544	>	//
2545	>	Bool_t IsLeptonFootprint = kFALSE;
2546	>	if (dr < 1.0) {
2547	>
2548	>	//
2549	>	// Check for electrons
2550	>	//
2551	>	for (Int_t q=0; q < electronsToVeto.size(); ++q) {
2552	>	const mithep::Electron *tmpele = electronsToVeto[q];
2553	>	/*
2554	>	// 4l electron
2555	>	if( pf->HasTrackerTrk() ) {
2556	>	if( pf->TrackerTrk() == tmpele->TrackerTrk() ) {
2557	>	if( ctrl.debug) cout << "\tcharged tktrk, matches 4L ele ..." << endl;
2558	>	IsLeptonFootprint = kTRUE;
2559	>	}
2560	>	}
2561	>	if( pf->HasGsfTrk() ) {
2562	>	if( pf->GsfTrk() == tmpele->GsfTrk() ) {
2563	>	if( ctrl.debug) cout << "\tcharged gsftrk, matches 4L ele ..." << endl;
2564	>	IsLeptonFootprint = kTRUE;
2565	>	}
2566	>	}
2567	>	*/
2568	>	// PF charged
2569	>	if (pf->Charge() != 0 && fabs(tmpele->SCluster()->Eta()) > 1.479
2570	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.015) {
2571	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L ele ..." << endl;
2572	>	IsLeptonFootprint = kTRUE;
2573	>	}
2574	>	// PF gamma
2575	>	if (abs(pf->PFType()) == PFCandidate::eGamma && fabs(tmpele->SCluster()->Eta()) > 1.479
2576	>	&& mithep::MathUtils::DeltaR(tmpele->Phi(),tmpele->Eta(), pf->Phi(), pf->Eta()) < 0.08) {
2577	>	if( ctrl.debug) cout << "\tPF gamma, matches 4L ele ..." << endl;
2578	>	IsLeptonFootprint = kTRUE;
2579	>	}
2580	>	} // loop over electrons
2581	>
2582	>	/* KH - comment for sync
2583	>	//
2584	>	// Check for muons
2585	>	//
2586	>	for (Int_t q=0; q < muonsToVeto.size(); ++q) {
2587	>	const mithep::Muon *tmpmu = muonsToVeto[q];
2588	>	// 4l muon
2589	>	if( pf->HasTrackerTrk() ) {
2590	>	if (pf->TrackerTrk() == tmpmu->TrackerTrk() ){
2591	>	if( ctrl.debug) cout << "\tmatches 4L mu ..." << endl;
2592	>	IsLeptonFootprint = kTRUE;
2593	>	}
2594	>	}
2595	>	// PF charged
2596	>	if (pf->Charge() != 0 && mithep::MathUtils::DeltaR(tmpmu->Phi(),tmpmu->Eta(), pf->Phi(), pf->Eta()) < 0.01) {
2597	>	if( ctrl.debug) cout << "\tcharged trk, dR matches 4L mu ..." << endl;
2598	>	IsLeptonFootprint = kTRUE;
2599	>	}
2600	>	} // loop over muons
2601	>	*/
2602	>
2603	>	if (IsLeptonFootprint)
2604	>	continue;
2605	>
2606	>	//
2607	>	// Charged Iso
2608	>	//
2609	>	if (pf->Charge() != 0 && (pf->HasTrackerTrk()\|\|pf->HasGsfTrk()) ) {
2610	>
2611	>	// if( pf->HasTrackerTrk() )
2612	>	// if (abs(pf->TrackerTrk()->DzCorrected(vtx)) > 0.2) continue;
2613	>	// if( pf->HasGsfTrk() )
2614	>	// if (abs(pf->GsfTrk()->DzCorrected(vtx)) > 0.2) continue;
2615	>
2616	>	// Veto any PFmuon, or PFEle
2617	>	if (abs(pf->PFType()) == PFCandidate::eElectron \|\| abs(pf->PFType()) == PFCandidate::eMuon) {
2618	>	cout << "\t skipping, pf is and ele or mu .." <<endl;
2619	>	continue;
2620	>	}
2621	>
2622	>	// Footprint Veto
2623	>	if (fabs(ele->SCluster()->Eta()) > 1.479 && dr < 0.015) continue;
2624	>
2625	>	if( ctrl.debug) cout << "charged:: pt: " << pf->Pt()
2626	>	<< "\ttype: " << pf->PFType()
2627	>	<< "\ttrk: " << pf->TrackerTrk() << endl;
2628	>
2629	>	fChargedIso += pf->Pt();
2630	>	}
2631	>
2632	>	//
2633	>	// Gamma Iso
2634	>	//
2635	>	else if (abs(pf->PFType()) == PFCandidate::eGamma) {
2636	>
2637	>	if (fabs(ele->SCluster()->Eta()) > 1.479) {
2638	>	if (mithep::MathUtils::DeltaR(ele->Phi(),ele->Eta(), pf->Phi(), pf->Eta()) < 0.08) continue;
2639	>	}
2640	>	if( ctrl.debug) cout << "gamma:: " << pf->Pt() << " "
2641	>	<< dr << endl;
2642	>	// KH, add to sync
2643	>	// if( pf->Pt() > 0.5 )
2644	>	fGammaIso += pf->Pt();
2645	>	}
2646	>
2647	>	//
2648	>	// Neutral Iso
2649	>	//
2650	>	else {
2651	>	if( ctrl.debug) cout << "neutral:: " << pf->Pt() << " "
2652	>	<< dr << endl;
2653	>	// KH, add to sync
2654	>	// if( pf->Pt() > 0.5 )
2655	>	fNeutralHadronIso += pf->Pt();
2656	>	}
2657	>
2658	>	}
2659	>
2660	>	}
2661	>
2662	>	// double rho = 0;
2663	>	// if (!(isnan(fPUEnergyDensity->At(0)->Rho()) \|\| isinf(fPUEnergyDensity->At(0)->Rho())))
2664	>	// rho = fPUEnergyDensity->At(0)->Rho();
2665	>
2666	>	// WARNING!!!!
2667	>	// hardcode for sync ...
2668	>	EffectiveAreaVersion = eleT.kEleEAData2011;
2669	>	// WARNING!!!!
2670	>
2671	>
2672	>	double pfIso = fChargedIso + fmax(0.0,(fGammaIso + fNeutralHadronIso
2673	>	-rho*eleT.ElectronEffectiveArea(eleT.kEleGammaAndNeutralHadronIso04,
2674	>	ele->Eta(),EffectiveAreaVersion)));
2675	>
2676	>
2677	>	gChargedIso = fChargedIso;
2678	>	gGammaIso = fGammaIso;
2679	>	gNeutralIso = fNeutralHadronIso;
2680		return pfIso;
2681		}
2682
2683	+
2684		//--------------------------------------------------------------------------------------------------
2685		SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2686		const mithep::Electron * ele,
#	Line 1375 \| Line 2697 \| SelectionStatus electronReferenceIsoSele
2697
2698		double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, fPUEnergyDensity,
2699		EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2700	+	// cout << "--------------> setting electron isoPF04 to " << pfIso << endl;
2701	+	status.isoPF04 = pfIso;
2702	+	status.chisoPF04 = gChargedIso;
2703	+	status.gaisoPF04 = gGammaIso;
2704	+	status.neisoPF04 = gNeutralIso;
2705	+
2706	+	bool pass = false;
2707	+	if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2708	+
2709	+	if( pass ) {
2710	+	status.orStatus(SelectionStatus::LOOSEISO);
2711	+	status.orStatus(SelectionStatus::TIGHTISO);
2712	+	}
2713	+	if(ctrl.debug) cout << "returning status : " << hex << status.getStatus() << dec << endl;
2714	+	return status;
2715	+
2716	+	}
2717	+
2718	+
2719	+	//--------------------------------------------------------------------------------------------------
2720	+	// hacked version
2721	+	SelectionStatus electronReferenceIsoSelection(ControlFlags &ctrl,
2722	+	const mithep::Electron * ele,
2723	+	const mithep::Vertex & vtx,
2724	+	const mithep::Array<mithep::PFCandidate> * fPFCandidates,
2725	+	float rho,
2726	+	mithep::ElectronTools::EElectronEffectiveAreaTarget EffectiveAreaVersion,
2727	+	vector<const mithep::Muon*> muonsToVeto,
2728	+	vector<const mithep::Electron*> electronsToVeto)
2729	+	//--------------------------------------------------------------------------------------------------
2730	+	{
2731	+
2732	+	SelectionStatus status;
2733	+
2734	+	double pfIso = electronPFIso04( ctrl, ele, vtx, fPFCandidates, rho,
2735	+	EffectiveAreaVersion, muonsToVeto ,electronsToVeto );
2736	+	status.isoPF04 = pfIso;
2737	+	status.chisoPF04 = gChargedIso;
2738	+	status.gaisoPF04 = gGammaIso;
2739	+	status.neisoPF04 = gNeutralIso;
2740		bool pass = false;
2741		if( (pfIso/ele->Pt()) < ELECTRON_REFERENCE_PFISO_CUT ) pass = true;
2742

Diff Legend

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

Comparing UserCode/MitHzz4l/LeptonSelection/src/IsolationSelection.cc (file contents): Revision 1.13 by khahn, Thu May 10 00:14:35 2012 UTC vs. Revision 1.21 by khahn, Sun May 20 19:08:58 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.21 by khahn, Sun May 20 19:08:58 2012 UTC