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)

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

	~CaloMuonMerger () override

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

	EDProducer (const EDProducer &)=delete

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

const EDProducer &	operator= (const EDProducer &)=delete

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<>
using	CacheTypes = CacheContexts< T...>

using	GlobalCache = typename CacheTypes::GlobalCache

using	HasAbility = AbilityChecker< T...>

using	InputProcessBlockCache = typename CacheTypes::InputProcessBlockCache

using	LuminosityBlockCache = typename CacheTypes::LuminosityBlockCache

using	LuminosityBlockContext = LuminosityBlockContextT< LuminosityBlockCache, RunCache, GlobalCache >

using	LuminosityBlockSummaryCache = typename CacheTypes::LuminosityBlockSummaryCache

using	RunCache = typename CacheTypes::RunCache

using	RunContext = RunContextT< RunCache, GlobalCache >

using	RunSummaryCache = typename CacheTypes::RunSummaryCache

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 22 of file CaloMuonMerger.cc.

Constructor & Destructor Documentation

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

explicit

Definition at line 45 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>>();
 }

CaloMuonMerger::~CaloMuonMerger ( )

inlineoverride

Definition at line 25 of file CaloMuonMerger.cc.

25 {}

Member Function Documentation

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

override

Definition at line 62 of file CaloMuonMerger.cc.

References reco::Muon::caloCompatibility(), reco::Muon::CaloMuon, caloMuonsCut_, caloMuonToken_, relval_parameters_module::energy, reco::LeafCandidate::eta(), Exception, edm::Event::getByToken(), mps_fire::i, reco::Muon::isCaloCompatibilityValid(), reco::isMuon(), edm::Ref< C, T, F >::isNonnull(), mergeCaloMuons_, mergeTracks_, minCaloCompatibility_, eostools::move(), RPCpg::mu, HLT_FULL_cff::muon, patZpeak::muons, muonsCut_, muonToken_, submitPVResolutionJobs::out, reco::LeafCandidate::pt(), edm::Event::put(), reco::Muon::setCalEnergy(), reco::Muon::setCaloCompatibility(), reco::Muon::setInnerTrack(), reco::Muon::setType(), mathSSE::sqrt(), reco::Muon::track(), HLT_FULL_cff::track, 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);
 
   auto out = std::make_unique<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(std::move(out));
 }

Member Data Documentation

edm::InputTag CaloMuonMerger::caloMuons_

private

Definition at line 33 of file CaloMuonMerger.cc.

Referenced by CaloMuonMerger().

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

private

Definition at line 34 of file CaloMuonMerger.cc.

Referenced by produce().

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

private

Definition at line 41 of file CaloMuonMerger.cc.

Referenced by CaloMuonMerger(), and produce().

bool CaloMuonMerger::mergeCaloMuons_

private

Definition at line 32 of file CaloMuonMerger.cc.

Referenced by produce().

bool CaloMuonMerger::mergeTracks_

private

Definition at line 36 of file CaloMuonMerger.cc.

Referenced by produce().

double CaloMuonMerger::minCaloCompatibility_

private

Definition at line 35 of file CaloMuonMerger.cc.

Referenced by produce().

edm::InputTag CaloMuonMerger::muons_

private

Definition at line 30 of file CaloMuonMerger.cc.

Referenced by CaloMuonMerger().

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

private

Definition at line 31 of file CaloMuonMerger.cc.

Referenced by produce().

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

private

Definition at line 40 of file CaloMuonMerger.cc.

Referenced by CaloMuonMerger(), and produce().

edm::InputTag CaloMuonMerger::tracks_

private

Definition at line 37 of file CaloMuonMerger.cc.

Referenced by CaloMuonMerger().

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

private

Definition at line 38 of file CaloMuonMerger.cc.

Referenced by produce().

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

private

Definition at line 42 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