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	hasAbilityToProduceInLumis () const final
bool	hasAbilityToProduceInRuns () 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 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> >();
}

CaloMuonMerger::~CaloMuonMerger ( )

inlineoverride

Definition at line 26 of file CaloMuonMerger.cc.

References iEvent, and produce().

{ }

Member Function Documentation

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

override

Definition at line 68 of file CaloMuonMerger.cc.

References reco::Muon::caloCompatibility(), reco::Muon::CaloMuon, mergedMuons_cfi::caloMuons, caloMuonsCut_, caloMuonToken_, DEFINE_FWK_MODULE, 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, extraflags_cff::muons, muonsCut_, muonToken_, MillePedeFileConverter_cfg::out, p4, reco::LeafCandidate::pt(), edm::Event::put(), reco::Muon::setCalEnergy(), reco::Muon::setCaloCompatibility(), reco::Muon::setInnerTrack(), reco::Muon::setType(), mathSSE::sqrt(), HiIsolationCommonParameters_cff::track, reco::Muon::track(), l1t::tracks, tracksCut_, trackToken_, and reco::Muon::type().

Referenced by ~CaloMuonMerger().

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