Merges reco::CaloMuons, reco::Muons and optionally reco::Tracks avoiding innerTrack duplications in a single reco::Muon collection. More...

#include "RecoMuon/MuonIdentification/plugins/CaloMuonMerger.cc"

Inheritance diagram for CaloMuonMerger:

Public Member Functions
	CaloMuonMerger (const edm::ParameterSet &iConfig)

virtual void	produce (edm::Event &iEvent, const edm::EventSetup &iSetup) override

virtual	~CaloMuonMerger ()

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

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 (std::string const &iProcessName, std::string const &iModuleLabel, bool iPrint, std::vector< char const * > &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 Attributes
edm::InputTag	caloMuons_

StringCutObjectSelector < reco::CaloMuon, false >	caloMuonsCut_

edm::EDGetTokenT< std::vector < reco::CaloMuon > >	caloMuonToken_

bool	mergeCaloMuons_

bool	mergeTracks_

double	minCaloCompatibility_

edm::InputTag	muons_

StringCutObjectSelector < reco::Muon, false >	muonsCut_

edm::EDGetTokenT< std::vector < reco::Muon > >	muonToken_

edm::InputTag	tracks_

StringCutObjectSelector < reco::TrackRef, false >	tracksCut_

edm::EDGetTokenT< std::vector < reco::Track > >	trackToken_

Additional Inherited Members
Public Types inherited from edm::stream::EDProducer<>
typedef CacheContexts< T...>	CacheTypes

typedef CacheTypes::GlobalCache	GlobalCache

typedef AbilityChecker< T...>	HasAbility

typedef CacheTypes::LuminosityBlockCache	LuminosityBlockCache

typedef LuminosityBlockContextT < LuminosityBlockCache, RunCache, GlobalCache >	LuminosityBlockContext

typedef CacheTypes::LuminosityBlockSummaryCache	LuminosityBlockSummaryCache

typedef CacheTypes::RunCache	RunCache

typedef RunContextT< RunCache, GlobalCache >	RunContext

typedef CacheTypes::RunSummaryCache	RunSummaryCache

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	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::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

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

Merges reco::CaloMuons, reco::Muons and optionally reco::Tracks avoiding innerTrack duplications in a single reco::Muon collection.

Author: Giovanni Petrucciani

Definition at line 23 of file CaloMuonMerger.cc.

Constructor & Destructor Documentation

CaloMuonMerger::CaloMuonMerger ( const edm::ParameterSet & iConfig )

explicit

Definition at line 50 of file CaloMuonMerger.cc.

References caloMuons_, caloMuonToken_, muons_, muonToken_, tracks_, and trackToken_.

                                                               :
     muons_(iConfig.getParameter<edm::InputTag>("muons")),
     muonsCut_(iConfig.existsAs<std::string>("muonsCut") ? iConfig.getParameter<std::string>("muonsCut") : ""),
     mergeCaloMuons_(iConfig.existsAs<bool>("mergeCaloMuons") ? iConfig.getParameter<bool>("mergeCaloMuons") : true),
     caloMuons_(iConfig.getParameter<edm::InputTag>("caloMuons")),
     caloMuonsCut_(iConfig.existsAs<std::string>("caloMuonsCut") ? iConfig.getParameter<std::string>("caloMuonsCut") : ""),
     minCaloCompatibility_(mergeCaloMuons_ ? iConfig.getParameter<double>("minCaloCompatibility") : 0),
     mergeTracks_(iConfig.existsAs<bool>("mergeTracks") ? iConfig.getParameter<bool>("mergeTracks") : false),
     tracks_(mergeTracks_ ? iConfig.getParameter<edm::InputTag>("tracks") : edm::InputTag()),
     tracksCut_(iConfig.existsAs<std::string>("tracksCut") ? iConfig.getParameter<std::string>("tracksCut") : "")
 {
   muonToken_ = consumes<std::vector<reco::Muon> >(muons_);
   caloMuonToken_=consumes<std::vector<reco::CaloMuon> >(caloMuons_);
   trackToken_ = consumes<std::vector<reco::Track> > (tracks_);
   produces<std::vector<reco::Muon> >();
 }

virtual CaloMuonMerger::~CaloMuonMerger ( )

inlinevirtual

Definition at line 26 of file CaloMuonMerger.cc.

26 { }

Member Function Documentation

void CaloMuonMerger::produce	(	edm::Event &	iEvent,
		const edm::EventSetup &	iSetup
	)

overridevirtual

Implements edm::stream::EDProducerBase.

Definition at line 68 of file CaloMuonMerger.cc.

References reco::Muon::caloCompatibility(), reco::Muon::CaloMuon, caloMuonsCut_, caloMuonToken_, relval_parameters_module::energy, reco::LeafCandidate::eta(), Exception, edm::Event::getByToken(), i, reco::Muon::isCaloCompatibilityValid(), reco::isMuon(), edm::Ref< C, T, F >::isNonnull(), mergeCaloMuons_, mergeTracks_, minCaloCompatibility_, RPCpg::mu, metsig::muon, patZpeak::muons, muonsCut_, muonToken_, GenerateHcalLaserBadRunList::out, p4, reco::LeafCandidate::pt(), edm::Event::put(), reco::Muon::setCalEnergy(), reco::Muon::setCaloCompatibility(), reco::Muon::setInnerTrack(), reco::Muon::setType(), mathSSE::sqrt(), reco::Muon::track(), testEve_cfg::tracks, tracksCut_, trackToken_, and reco::Muon::type().

                                                                        {
     edm::Handle<std::vector<reco::Muon> > muons;
     edm::Handle<std::vector<reco::CaloMuon> > caloMuons;
     edm::Handle<std::vector<reco::Track> > tracks;
 
     iEvent.getByToken(muonToken_,muons);
     if(mergeCaloMuons_) iEvent.getByToken(caloMuonToken_,caloMuons);
       if(mergeTracks_) iEvent.getByToken(trackToken_,tracks);
 
     std::auto_ptr<std::vector<reco::Muon> >  out(new std::vector<reco::Muon>());
     out->reserve(muons->size() + (mergeTracks_?tracks->size():0));
 
     // copy reco::Muons, turning on the CaloCompatibility flag if enabled and possible
     for (std::vector<reco::Muon>::const_iterator it = muons->begin(), ed = muons->end(); it != ed; ++it) {
         if(!muonsCut_(*it)) continue;
         out->push_back(*it);
         reco::Muon & mu = out->back();
         if (mergeCaloMuons_ && mu.track().isNonnull()) {
             if (mu.isCaloCompatibilityValid()) {
                 if (mu.caloCompatibility() >= minCaloCompatibility_) {
                     mu.setType(mu.type() | reco::Muon::CaloMuon);
                 }
             } else throw cms::Exception("Boh") << "Muon with track and no CaloCompatibility; pt = " << mu.pt() << ", eta = " << mu.eta() << ", type = " << mu.type() << "\n";
         }
     }
 
     if (mergeCaloMuons_) {
         // copy reco::CaloMuon 
         for (std::vector<reco::CaloMuon>::const_iterator it = caloMuons->begin(), ed = caloMuons->end(); it != ed; ++it) {
             if(!caloMuonsCut_(*it)) continue;
             // make a reco::Muon
             reco::TrackRef track = it->track();
             double energy = sqrt(track->p() * track->p() + 0.011163691);
             math::XYZTLorentzVector p4(track->px(), track->py(), track->pz(), energy);
             out->push_back(reco::Muon(track->charge(), p4, track->vertex()));
             reco::Muon & mu = out->back();
             // fill info 
             mu.setCalEnergy( it->calEnergy() );
             mu.setCaloCompatibility( it->caloCompatibility() );
             mu.setInnerTrack( track );
             mu.setType( reco::Muon::CaloMuon );
         }
     }
 
     // merge reco::Track avoiding duplication of innerTracks
     if(mergeTracks_){
         for (size_t i = 0; i < tracks->size(); i++) {
             reco::TrackRef track(tracks, i);
             if(!tracksCut_(track)) continue;
             // check if it is a muon or calomuon
             bool isMuon = false;
             for(std::vector<reco::Muon>::const_iterator muon = muons->begin(); muon < muons->end(); muon++){
                 if(muon->innerTrack() == track){
                     isMuon = true;
                     break;
                 }
             }
             if(isMuon) continue;
             if (mergeCaloMuons_) {
                 bool isCaloMuon = false;
                 for(std::vector<reco::CaloMuon>::const_iterator muon = caloMuons->begin(); muon < caloMuons->end(); muon++){
                     if(muon->innerTrack() == track){
                         isCaloMuon = true;
                         break;
                     }
                 }
                 if(isCaloMuon) continue;
             }
             // make a reco::Muon
             double energy = sqrt(track->p() * track->p() + 0.011163691);
             math::XYZTLorentzVector p4(track->px(), track->py(), track->pz(), energy);
             out->push_back(reco::Muon(track->charge(), p4, track->vertex()));
             reco::Muon & mu = out->back();
             // fill info 
             mu.setInnerTrack( track );
         }
     }
 
     iEvent.put(out);
 }

Member Data Documentation

edm::InputTag CaloMuonMerger::caloMuons_

private

Definition at line 34 of file CaloMuonMerger.cc.

Referenced by CaloMuonMerger().

StringCutObjectSelector<reco::CaloMuon, false> CaloMuonMerger::caloMuonsCut_

private

Definition at line 35 of file CaloMuonMerger.cc.

Referenced by produce().

edm::EDGetTokenT<std::vector<reco::CaloMuon> > CaloMuonMerger::caloMuonToken_

private

Definition at line 42 of file CaloMuonMerger.cc.

Referenced by CaloMuonMerger(), and produce().

bool CaloMuonMerger::mergeCaloMuons_

private

Definition at line 33 of file CaloMuonMerger.cc.

Referenced by produce().

bool CaloMuonMerger::mergeTracks_

private

Definition at line 37 of file CaloMuonMerger.cc.

Referenced by produce().

double CaloMuonMerger::minCaloCompatibility_

private

Definition at line 36 of file CaloMuonMerger.cc.

Referenced by produce().

edm::InputTag CaloMuonMerger::muons_

private

Definition at line 31 of file CaloMuonMerger.cc.

Referenced by CaloMuonMerger().

StringCutObjectSelector<reco::Muon, false> CaloMuonMerger::muonsCut_

private

Definition at line 32 of file CaloMuonMerger.cc.

Referenced by produce().

edm::EDGetTokenT<std::vector<reco::Muon> > CaloMuonMerger::muonToken_

private

Definition at line 41 of file CaloMuonMerger.cc.

Referenced by CaloMuonMerger(), and produce().

edm::InputTag CaloMuonMerger::tracks_

private

Definition at line 38 of file CaloMuonMerger.cc.

Referenced by CaloMuonMerger().

StringCutObjectSelector<reco::TrackRef, false> CaloMuonMerger::tracksCut_

private

Definition at line 39 of file CaloMuonMerger.cc.

Referenced by produce().

edm::EDGetTokenT<std::vector<reco::Track> > CaloMuonMerger::trackToken_

private

Definition at line 43 of file CaloMuonMerger.cc.

Referenced by CaloMuonMerger(), and produce().

Public Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation