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
	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::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::~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.

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, mathSSE::sqrt(), HLT_2022v15_cff::track, tracks, tracksCut_, and trackToken_.

                                                                          {
  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

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().