#include <MuonRadiationFilter.h>

Inheritance diagram for MuonRadiationFilter:

Public Member Functions
	MuonRadiationFilter (const edm::ParameterSet &)

	~MuonRadiationFilter ()

Public Member Functions inherited from edm::EDFilter
	EDFilter ()

ModuleDescription const &	moduleDescription () const

virtual	~EDFilter ()

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

	ProducerBase ()

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

virtual	~ProducerBase ()

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

	EDConsumerBase ()

ProductHolderIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductHolderIndexAndSkipBit > &) const

std::vector < ProductHolderIndexAndSkipBit > const &	itemsToGetFromEvent () const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesDependentUpon (const std::string &iProcessName, std::vector< const char * > &oModuleLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

bool	registeredToConsume (ProductHolderIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductHolderIndexHelper const &)

virtual	~EDConsumerBase ()

Private Types
typedef edm::View< edm::FwdPtr < reco::PFCandidate > >	PFView

Private Member Functions
bool	checkMuonRadiation (const reco::Candidate::LorentzVector &, const reco::Candidate::LorentzVector *, double, const PFView &, const PFView &, const reco::Candidate &, const reco::Candidate &)

double	compCaloEnECAL (const reco::Candidate::LorentzVector &, const PFView &)

double	compPFIso_puCorr (const reco::Candidate::LorentzVector &, const PFView &, const PFView &, const reco::Candidate::LorentzVector &, const reco::Candidate::LorentzVector &)

void	compPFIso_raw (const reco::Candidate::LorentzVector &, const PFView &, const reco::Candidate::LorentzVector &, const reco::Candidate::LorentzVector &, double &, double &, double &)

bool	filter (edm::Event &, const edm::EventSetup &)

Private Attributes
bool	addCaloEnECALhighPt_

bool	addCaloEnECALlowPt_

bool	applyMassWindowSelectionHighPt_

bool	applyMassWindowSelectionLowPt_

double	dRhighPt_

double	dRisoCone_

double	dRlowPt_

double	dRvetoCone_

bool	filter_

bool	invert_

double	maxMass_

double	maxRelIso_

double	minPtHigh_

double	minPtLow_

edm::InputTag	srcPFCandsNoPU_

edm::InputTag	srcPFCandsPU_

edm::InputTag	srcSelectedMuons_

int	verbosity_

Additional Inherited Members
Public Types inherited from edm::EDFilter
typedef EDFilter	ModuleType

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

Static Public Member Functions inherited from edm::EDFilter
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

Detailed Description

Veto events in which a muon from Z –> mu+ mu- decay radiates a photon: muon -> muon + photon

Author: Christian Veelken, LLR (based on python code developed by Mike Bachtis)

Version

Revision:: 1.3

Id:: MuonRadiationFilter.h,v 1.3 2012/11/25 15:43:13 veelken Exp

Definition at line 28 of file MuonRadiationFilter.h.

Member Typedef Documentation

typedef edm::View<edm::FwdPtr<reco::PFCandidate> > MuonRadiationFilter::PFView

private

Definition at line 37 of file MuonRadiationFilter.h.

Constructor & Destructor Documentation

MuonRadiationFilter::MuonRadiationFilter ( const edm::ParameterSet & cfg )

explicit

Definition at line 18 of file MuonRadiationFilter.cc.

References addCaloEnECALhighPt_, addCaloEnECALlowPt_, applyMassWindowSelectionHighPt_, applyMassWindowSelectionLowPt_, dRhighPt_, dRisoCone_, dRlowPt_, dRvetoCone_, edm::ParameterSet::exists(), filter_, edm::ParameterSet::getParameter(), invert_, maxMass_, maxRelIso_, minPtHigh_, minPtLow_, srcPFCandsNoPU_, srcPFCandsPU_, srcSelectedMuons_, and verbosity_.

 {
   srcSelectedMuons_               = cfg.getParameter<edm::InputTag>("srcSelectedMuons");
   srcPFCandsNoPU_                 = cfg.getParameter<edm::InputTag>("srcPFCandsNoPU");
   srcPFCandsPU_                   = cfg.getParameter<edm::InputTag>("srcPFCandsPU");
 
   minPtLow_                       = cfg.getParameter<double>("minPtLow");
   dRlowPt_                        = cfg.getParameter<double>("dRlowPt");
   addCaloEnECALlowPt_             = cfg.getParameter<bool>("addCaloEnECALlowPt");
   applyMassWindowSelectionLowPt_  = cfg.getParameter<bool>("applyMassWindowSelectionLowPt");
 
   minPtHigh_                      = cfg.getParameter<double>("minPtHigh");
   dRhighPt_                       = cfg.getParameter<double>("dRhighPt");  
   addCaloEnECALhighPt_            = cfg.getParameter<bool>("addCaloEnECALhighPt");
   applyMassWindowSelectionHighPt_ = cfg.getParameter<bool>("applyMassWindowSelectionHighPt");
 
   dRvetoCone_                     = cfg.getParameter<double>("dRvetoCone");
   dRisoCone_                      = cfg.getParameter<double>("dRisoCone");
   maxRelIso_                      = cfg.getParameter<double>("maxRelIso");
 
   maxMass_                        = cfg.getParameter<double>("maxMass");
   
   invert_                         = cfg.getParameter<bool>("invert");
   filter_                         = cfg.getParameter<bool>("filter");
   if ( !filter_ ) {
     produces<bool>();
   }
 
   verbosity_ = ( cfg.exists("verbosity") ) ?
     cfg.getParameter<int>("verbosity") : 0;
 }

MuonRadiationFilter::~MuonRadiationFilter ( )

inline

Definition at line 32 of file MuonRadiationFilter.h.

32 {}

Member Function Documentation

bool MuonRadiationFilter::checkMuonRadiation	(	const reco::Candidate::LorentzVector &	photonP4,
		const reco::Candidate::LorentzVector *	caloP4mu,
		double	dR,
		const PFView &	pfCandidatesNoPU,
		const PFView &	pfCandidatesPU,
		const reco::Candidate &	muPlus,
		const reco::Candidate &	muMinus
	)

private

Definition at line 223 of file MuonRadiationFilter.cc.

References Abs(), addCaloEnECALhighPt_, addCaloEnECALlowPt_, applyMassWindowSelectionHighPt_, applyMassWindowSelectionLowPt_, compPFIso_puCorr(), gather_cfg::cout, dRhighPt_, dRlowPt_, maxMass_, maxRelIso_, minPtHigh_, minPtLow_, nomMassZ, reco::Candidate::p4(), and verbosity_.

Referenced by filter().

 {
   bool isMuonRadiation = false;
   if ( dR < dRlowPt_ || dR < dRhighPt_ ) {
     reco::Candidate::LorentzVector muPlusP4_fromTrack  = makeMuonP4(muPlus,  verbosity_);
     reco::Candidate::LorentzVector muMinusP4_fromTrack = makeMuonP4(muMinus, verbosity_);
     double massWithoutPhoton = (muPlusP4_fromTrack + muMinusP4_fromTrack).mass();    
     reco::Candidate::LorentzVector photonP4sumLow = photonP4;
     if ( addCaloEnECALlowPt_ && caloP4mu ) photonP4sumLow += (*caloP4mu);
     if ( dR < dRlowPt_ && photonP4sumLow.pt() > minPtLow_ ) {
       double massWithPhoton = (muPlusP4_fromTrack + muMinusP4_fromTrack + photonP4sumLow).mass();
       if ( verbosity_ ) {
     std::cout << "low photon Pt threshold:" << std::endl;
     std::cout << " muon #1:" << "Pt = " << muPlusP4_fromTrack.pt() << ", eta = " << muPlusP4_fromTrack.eta() << ", phi = " << muPlusP4_fromTrack.phi() << std::endl;
     std::cout << " muon #2:" << "Pt = " << muMinusP4_fromTrack.pt() << ", eta = " << muMinusP4_fromTrack.eta() << ", phi = " << muMinusP4_fromTrack.phi() << std::endl;
     std::cout << " photon:" << "Pt = " << photonP4sumLow.pt() << ", eta = " << photonP4sumLow.eta() << ", phi = " << photonP4sumLow.phi() << " (dR = " << dR << ")" << std::endl;
     std::cout << " M(mu+mu) = " << massWithoutPhoton << ", M(mu+mu+gamma) = " << massWithPhoton << std::endl;
       }
       if ( (TMath::Abs(massWithPhoton - nomMassZ) < TMath::Abs(massWithoutPhoton - nomMassZ) && massWithPhoton < maxMass_) || !applyMassWindowSelectionLowPt_ ) {
     double pfIso = compPFIso_puCorr(photonP4sumLow, pfCandidatesNoPU, pfCandidatesPU, muPlus.p4(), muMinus.p4());
     if ( pfIso < (maxRelIso_*photonP4sumLow.pt()) ) isMuonRadiation = true;
       }
     }    
     reco::Candidate::LorentzVector photonP4sumHigh = photonP4;
     if ( addCaloEnECALhighPt_ && caloP4mu ) photonP4sumHigh += (*caloP4mu);
     if ( dR < dRhighPt_ && photonP4sumHigh.pt() > minPtHigh_ ) {
       double massWithPhoton = (muPlusP4_fromTrack + muMinusP4_fromTrack + photonP4sumHigh).mass();
       if ( verbosity_ ) {
     std::cout << "high photon Pt threshold:" << std::endl;
     std::cout << " muon #1:" << "Pt = " << muPlusP4_fromTrack.pt() << ", eta = " << muPlusP4_fromTrack.eta() << ", phi = " << muPlusP4_fromTrack.phi() << std::endl;
     std::cout << " muon #2:" << "Pt = " << muMinusP4_fromTrack.pt() << ", eta = " << muMinusP4_fromTrack.eta() << ", phi = " << muMinusP4_fromTrack.phi() << std::endl;
     std::cout << " photon:" << "Pt = " << photonP4sumHigh.pt() << ", eta = " << photonP4sumHigh.eta() << ", phi = " << photonP4sumHigh.phi() << " (dR = " << dR << ")" << std::endl;
     std::cout << " M(mu+mu) = " << massWithoutPhoton << ", M(mu+mu+gamma) = " << massWithPhoton << std::endl;
       }
       if ( (TMath::Abs(massWithPhoton - nomMassZ) < TMath::Abs(massWithoutPhoton - nomMassZ) && massWithPhoton < maxMass_) || !applyMassWindowSelectionHighPt_ ) {
     double pfIso = compPFIso_puCorr(photonP4sumHigh, pfCandidatesNoPU, pfCandidatesPU, muPlus.p4(), muMinus.p4());
     if ( pfIso < (maxRelIso_*photonP4sumHigh.pt()) ) isMuonRadiation = true;
       }
     }
   }
   return isMuonRadiation;
 }

double MuonRadiationFilter::compCaloEnECAL	(	const reco::Candidate::LorentzVector &	refP4,
		const PFView &	pfCandidates
	)

private

Definition at line 111 of file MuonRadiationFilter.cc.

References edm::View< T >::begin(), deltaR(), PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, dRvetoCone_, and edm::View< T >::end().

Referenced by filter().

 {
   double caloEnECAL = 0.;
   for ( PFView::const_iterator pfCandidate = pfCandidates.begin();
     pfCandidate != pfCandidates.end(); ++pfCandidate ) {
     double dR = deltaR(refP4, (*pfCandidate)->p4());
     if ( dR < dRvetoCone_ ) {
       caloEnECAL += (*pfCandidate)->ecalEnergy();
     }
   }
   return caloEnECAL;
 }

double MuonRadiationFilter::compPFIso_puCorr	(	const reco::Candidate::LorentzVector &	refP4,
		const PFView &	pfCandidatesNoPU,
		const PFView &	pfCandidatesPU,
		const reco::Candidate::LorentzVector &	muPlusP4,
		const reco::Candidate::LorentzVector &	muMinusP4
	)

private

Definition at line 160 of file MuonRadiationFilter.cc.

References compPFIso_raw(), gather_cfg::cout, Max(), and verbosity_.

Referenced by checkMuonRadiation().

 {
   if ( verbosity_ ) std::cout << "computing isoSum(NoPU)" << std::endl;
   double pfChargedCandIsoSumNoPU, pfGammaIsoSumNoPU, pfNeutralHadronIsoSumNoPU;
   compPFIso_raw(refP4, pfCandidatesNoPU, muPlusP4, muMinusP4, pfChargedCandIsoSumNoPU, pfGammaIsoSumNoPU, pfNeutralHadronIsoSumNoPU);
   
   if ( verbosity_ ) std::cout << "computing isoSum(PU)" << std::endl;
   double pfChargedCandIsoSumPU, pfGammaIsoSumPU, pfNeutralHadronIsoSumPU;
   compPFIso_raw(refP4, pfCandidatesPU, muPlusP4, muMinusP4, pfChargedCandIsoSumPU, pfGammaIsoSumPU, pfNeutralHadronIsoSumPU);
   
   // apply delta-beta PU correction to isolation Pt sum
   double pfIso = pfChargedCandIsoSumNoPU + TMath::Max(0., pfGammaIsoSumNoPU + pfNeutralHadronIsoSumNoPU - 0.5*pfChargedCandIsoSumPU);
   if ( verbosity_ ) {
     std::cout << " pfChargedCandIsoSumNoPU = " << pfChargedCandIsoSumNoPU << std::endl;
     std::cout << " pfGammaIsoSumNoPU = " << pfGammaIsoSumNoPU << std::endl;
     std::cout << " pfNeutralHadronIsoSumNoPU = " << pfNeutralHadronIsoSumNoPU << std::endl;
     std::cout << " pfChargedCandIsoSumPU = " << pfChargedCandIsoSumPU << std::endl;
     std::cout << "--> isolation of PFGamma = " << pfIso << std::endl;
   }
   return pfIso;
 }

void MuonRadiationFilter::compPFIso_raw	(	const reco::Candidate::LorentzVector &	refP4,
		const PFView &	pfCandidates,
		const reco::Candidate::LorentzVector &	muPlusP4,
		const reco::Candidate::LorentzVector &	muMinusP4,
		double &	pfChargedCandIsoSum,
		double &	pfGammaIsoSum,
		double &	pfNeutralHadronIsoSum
	)

private

Definition at line 124 of file MuonRadiationFilter.cc.

References Abs(), edm::View< T >::begin(), gather_cfg::cout, deltaR(), PFRecoTauDiscriminationAgainstElectronDeadECAL_cfi::dR, dRisoCone_, dRvetoCone_, edm::View< T >::end(), reco::PFCandidate::gamma, reco::PFCandidate::h0, and verbosity_.

Referenced by compPFIso_puCorr().

 {
   pfChargedCandIsoSum   = 0.;
   pfGammaIsoSum         = 0.;
   pfNeutralHadronIsoSum = 0.;
   for ( PFView::const_iterator pfCandidate = pfCandidates.begin();
     pfCandidate != pfCandidates.end(); ++pfCandidate ) {
     double dR = deltaR(refP4, (*pfCandidate)->p4());
     if ( dR < dRisoCone_ ) {
       bool isVeto = false;
       if ( dR < dRvetoCone_ ) {
     isVeto = true;
       } else {
     double dRmuPlus  = deltaR(muPlusP4,  (*pfCandidate)->p4());
     if ( dRmuPlus  < dRvetoCone_ ) isVeto = true;
     double dRmuMinus = deltaR(muMinusP4, (*pfCandidate)->p4());
     if ( dRmuMinus < dRvetoCone_ ) isVeto = true;
       }
       if ( isVeto ) continue;
       if ( TMath::Abs((*pfCandidate)->charge()) > 0.5 ) {
     if ( verbosity_ ) std::cout << " adding PFChargedCand: Pt = " << (*pfCandidate)->pt() << ", eta = " << (*pfCandidate)->eta() << ", phi = " << (*pfCandidate)->phi() << " (dR = " << dR << ")" << std::endl;
     pfChargedCandIsoSum += (*pfCandidate)->pt();
       } else if ( (*pfCandidate)->particleId() == reco::PFCandidate::gamma ) {
     if ( verbosity_ ) std::cout << " adding PFGamma: Pt = " << (*pfCandidate)->pt() << ", eta = " << (*pfCandidate)->eta() << ", phi = " << (*pfCandidate)->phi() << " (dR = " << dR << ")" << std::endl;
     pfGammaIsoSum += (*pfCandidate)->pt();
       } else if ( (*pfCandidate)->particleId() == reco::PFCandidate::h0 ) {
     if ( verbosity_ ) std::cout << " adding PFNeutralHadron: Pt = " << (*pfCandidate)->pt() << ", eta = " << (*pfCandidate)->eta() << ", phi = " << (*pfCandidate)->phi() << " (dR = " << dR << ")" << std::endl;
     pfNeutralHadronIsoSum += (*pfCandidate)->pt();
       } 
     }
   }
 }

bool MuonRadiationFilter::filter	(	edm::Event &	evt,
		const edm::EventSetup &	es
	)

privatevirtual

Implements edm::EDFilter.

Definition at line 62 of file MuonRadiationFilter.cc.

References checkMuonRadiation(), compCaloEnECAL(), gather_cfg::cout, deltaR(), reco::PFCandidate::e, filter_, reco::PFCandidate::gamma, edm::Event::getByLabel(), getSelMuons(), getTheMuMinus(), getTheMuPlus(), invert_, edm::RefToBase< T >::isNull(), reco::Candidate::p4(), edm::Event::put(), srcPFCandsNoPU_, srcPFCandsPU_, srcSelectedMuons_, and verbosity_.

 {
   if ( verbosity_ ) std::cout << "<MuonRadiationFilter::filter>:" << std::endl;
 
   std::vector<reco::CandidateBaseRef> selMuons = getSelMuons(evt, srcSelectedMuons_);
   const reco::CandidateBaseRef muPlus  = getTheMuPlus(selMuons);
   const reco::CandidateBaseRef muMinus = getTheMuMinus(selMuons);
 
   if ( muPlus.isNull() || muMinus.isNull() ) return false; // not selected Z --> mu+ mu- event: reject event
 
   edm::Handle<PFView> pfCandidatesNoPU;
   evt.getByLabel(srcPFCandsNoPU_, pfCandidatesNoPU);
   edm::Handle<PFView> pfCandidatesPU;
   evt.getByLabel(srcPFCandsPU_, pfCandidatesPU);
 
   double muPlusCaloEnECAL = compCaloEnECAL(muPlus->p4(), *pfCandidatesNoPU);
   if ( verbosity_ ) std::cout << "muPlusCaloEnECAL = " << muPlusCaloEnECAL << std::endl;
   reco::Candidate::LorentzVector caloP4muPlus = makeCaloEnP4(muPlus->p4(), muPlusCaloEnECAL);
   double muMinusCaloEnECAL = compCaloEnECAL(muMinus->p4(), *pfCandidatesNoPU);
   if ( verbosity_ ) std::cout << "muMinusCaloEnECAL = " << muMinusCaloEnECAL << std::endl;
   reco::Candidate::LorentzVector caloP4muMinus = makeCaloEnP4(muMinus->p4(), muMinusCaloEnECAL);
 
   bool isMuonRadiation = false;
   
   for ( PFView::const_iterator pfCandidate = pfCandidatesNoPU->begin();
     pfCandidate != pfCandidatesNoPU->end(); ++pfCandidate ) {
     if ( (*pfCandidate)->particleId() == reco::PFCandidate::gamma || (*pfCandidate)->particleId() == reco::PFCandidate::e ) { // CV: include converted photons
       double dRmuPlus = deltaR((*pfCandidate)->p4(), muPlus->p4());
       if ( checkMuonRadiation((*pfCandidate)->p4(), &caloP4muPlus,  dRmuPlus,  *pfCandidatesNoPU, *pfCandidatesPU, *muPlus, *muMinus) ) isMuonRadiation = true;
       double dRmuMinus = deltaR((*pfCandidate)->p4(), muMinus->p4());
       if ( checkMuonRadiation((*pfCandidate)->p4(), &caloP4muMinus, dRmuMinus, *pfCandidatesNoPU, *pfCandidatesPU, *muPlus, *muMinus) ) isMuonRadiation = true;
     }
   }
   
   if ( checkMuonRadiation(caloP4muPlus,  0, 0., *pfCandidatesNoPU, *pfCandidatesPU, *muPlus, *muMinus) ) isMuonRadiation = true;
   if ( checkMuonRadiation(caloP4muMinus, 0, 0., *pfCandidatesNoPU, *pfCandidatesPU, *muPlus, *muMinus) ) isMuonRadiation = true;
   
   if ( verbosity_ ) std::cout << "isMuonRadiation = " << isMuonRadiation << std::endl;
 
   if ( filter_ ) {
     if ( invert_ != isMuonRadiation ) return false; // reject events with muon -> muon + photon radiation
     else return true;
   } else {
     std::auto_ptr<bool> filter_result(new bool(invert_ != !isMuonRadiation));
     evt.put(filter_result);
     return true;
   }
 }