CaloMuonMerger Class Reference

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
bool	hasAbilityToProduceInBeginLumis () const final
bool	hasAbilityToProduceInBeginRuns () const final
bool	hasAbilityToProduceInEndLumis () const final
bool	hasAbilityToProduceInEndRuns () const final

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

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::CaloMuonMerger ( const edm::ParameterSet &  iConfig )

explicit

Definition at line 45 of file CaloMuonMerger.cc.

    : 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>>();
}

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

~CaloMuonMerger()

CaloMuonMerger::~CaloMuonMerger ( )

inlineoverride

Definition at line 25 of file CaloMuonMerger.cc.

{}

Member Function Documentation

produce()

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

override

Definition at line 62 of file CaloMuonMerger.cc.

                                                                          {
  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));
}

References reco::Muon::CaloMuon, mergedMuons_cfi::caloMuons, caloMuonsCut_, caloMuonToken_, HCALHighEnergyHPDFilter_cfi::energy, Exception, mps_fire::i, iEvent, reco::isMuon(), mergeCaloMuons_, mergeTracks_, minCaloCompatibility_, eostools::move(), amptDefaultParameters_cff::mu, PDWG_BPHSkim_cff::muons, muonsCut_, muonToken_, MillePedeFileConverter_cfg::out, p4, mathSSE::sqrt(), HLT_2018_cff::track, PDWG_EXOHSCP_cff::tracks, tracksCut_, and trackToken_.

Member Data Documentation

caloMuons_

edm::InputTag CaloMuonMerger::caloMuons_

private

Definition at line 33 of file CaloMuonMerger.cc.

Referenced by CaloMuonMerger().

caloMuonsCut_

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

private

Definition at line 34 of file CaloMuonMerger.cc.

Referenced by produce().

caloMuonToken_

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

private

Definition at line 41 of file CaloMuonMerger.cc.

Referenced by CaloMuonMerger(), and produce().

mergeCaloMuons_

bool CaloMuonMerger::mergeCaloMuons_

private

Definition at line 32 of file CaloMuonMerger.cc.

Referenced by produce().

mergeTracks_

bool CaloMuonMerger::mergeTracks_

private

Definition at line 36 of file CaloMuonMerger.cc.

Referenced by produce().

minCaloCompatibility_

double CaloMuonMerger::minCaloCompatibility_

private

Definition at line 35 of file CaloMuonMerger.cc.

Referenced by produce().

muons_

edm::InputTag CaloMuonMerger::muons_

private

Definition at line 30 of file CaloMuonMerger.cc.

Referenced by CaloMuonMerger().

muonsCut_

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

private

Definition at line 31 of file CaloMuonMerger.cc.

Referenced by produce().

muonToken_

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

private

Definition at line 40 of file CaloMuonMerger.cc.

Referenced by CaloMuonMerger(), and produce().

tracks_

edm::InputTag CaloMuonMerger::tracks_

private

Definition at line 37 of file CaloMuonMerger.cc.

Referenced by CaloMuonMerger().

tracksCut_

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

private

Definition at line 38 of file CaloMuonMerger.cc.

Referenced by produce().

trackToken_

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

private

Definition at line 42 of file CaloMuonMerger.cc.

Referenced by CaloMuonMerger(), and produce().