MuonProducer Class Reference

#include <MuonProducer.h>

Inheritance diagram for MuonProducer:

Public Types
typedef std::vector< edm::InputTag >	InputTags
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

Public Member Functions
	MuonProducer (const edm::ParameterSet &)
	Constructor. More...
void	produce (edm::Event &, const edm::EventSetup &) override
	reconstruct muons More...
	~MuonProducer () override
	Destructor. More...
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 Member Functions
template<typename TYPE >
void	fillMuonMap (edm::Event &event, const edm::OrphanHandle< reco::MuonCollection > &muonHandle, const std::vector< TYPE > &muonExtra, const std::string &label)
std::string	labelOrInstance (const edm::InputTag &) const
void	setAlias (std::string alias)

Private Attributes
bool	computeStandardSelectors_
bool	debug_
bool	fastLabelling_
bool	fillCosmicsIdMap_
bool	fillDetectorBasedIsolation_
bool	fillIsolation_
bool	fillPFIsolation_
bool	fillPFMomentum_
bool	fillSelectors_
bool	fillShoweringInfo_
bool	fillTimingInfo_
std::vector< std::map< std::string, edm::InputTag > >	pfIsoMapNames
std::vector< std::map< std::string, edm::EDGetTokenT< edm::ValueMap< double > > > >	pfIsoMapTokens_
std::string	theAlias
edm::InputTag	theCosmicCompMapName
edm::EDGetTokenT< edm::ValueMap< reco::MuonCosmicCompatibility > >	theCosmicCompMapToken_
edm::EDGetTokenT< edm::ValueMap< unsigned int > >	theCosmicIdMapToken_
edm::InputTag	theEcalDepositName
edm::EDGetTokenT< reco::IsoDepositMap >	theEcalDepositToken_
edm::InputTag	theHcalDepositName
edm::EDGetTokenT< reco::IsoDepositMap >	theHcalDepositToken_
edm::InputTag	theHoDepositName
edm::EDGetTokenT< reco::IsoDepositMap >	theHoDepositToken_
edm::InputTag	theJetDepositName
edm::EDGetTokenT< reco::IsoDepositMap >	theJetDepositToken_
edm::InputTag	theMuonsCollectionLabel
edm::EDGetTokenT< reco::MuonCollection >	theMuonsCollectionToken_
std::string	theMuToMuMapName
edm::InputTag	thePFCandLabel
edm::EDGetTokenT< reco::PFCandidateCollection >	thePFCandToken_
MuPFIsoHelper *	thePFIsoHelper
InputTags	theSelectorMapNames
std::vector< edm::EDGetTokenT< edm::ValueMap< bool > > >	theSelectorMapTokens_
edm::InputTag	theShowerMapName
edm::EDGetTokenT< edm::ValueMap< reco::MuonShower > >	theShowerMapToken_
edm::InputTag	theTrackDepositName
edm::EDGetTokenT< reco::IsoDepositMap >	theTrackDepositToken_
edm::EDGetTokenT< reco::MuonTimeExtraMap >	timeMapCmbToken_
edm::EDGetTokenT< reco::MuonTimeExtraMap >	timeMapCSCToken_
edm::EDGetTokenT< reco::MuonTimeExtraMap >	timeMapDTToken_
edm::EDGetTokenT< reco::VertexCollection >	vertexes_
bool	writeIsoDeposits_

Detailed Description

See header file.

Author

R. Bellan - UCSB ricca.nosp@m.rdo..nosp@m.bella.nosp@m.n@ce.nosp@m.rn.ch

Producer meant for the Post PF reconstruction.

This class takes the muon collection produced before the PF is run (muons1Step) and the information calculated after that the entire event has been reconstructed. The collections produced here are meant to be used for the final analysis (or as PAT input). The previous muon collection is meant to be transient.

Author

R. Bellan - UCSB ricca.nosp@m.rdo..nosp@m.bella.nosp@m.n@ce.nosp@m.rn.ch

Definition at line 48 of file MuonProducer.h.

Member Typedef Documentation

InputTags

typedef std::vector<edm::InputTag> MuonProducer::InputTags

Definition at line 59 of file MuonProducer.h.

Constructor & Destructor Documentation

MuonProducer()

MuonProducer::MuonProducer

(

const edm::ParameterSet &

pSet

)

Constructor.

Definition at line 29 of file MuonProducer.cc.

References computeStandardSelectors_, fastLabelling_, fillCosmicsIdMap_, fillDetectorBasedIsolation_, fillPFIsolation_, fillPFMomentum_, fillSelectors_, fillShoweringInfo_, fillTimingInfo_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), ProducerED_cfi::InputTag, edm::InputTag::instance(), dqmiolumiharvest::j, label, edm::InputTag::label(), labelOrInstance(), genParticles_cff::map, pfIsoMapNames, pfIsoMapTokens_, setAlias(), AlCaHLTBitMon_QueryRunRegistry::string, makeGlobalPositionRcd_cfg::tag, theAlias, theCosmicCompMapName, theCosmicCompMapToken_, theCosmicIdMapToken_, theEcalDepositName, theEcalDepositToken_, theHcalDepositName, theHcalDepositToken_, theHoDepositName, theHoDepositToken_, theJetDepositName, theJetDepositToken_, theMuonsCollectionLabel, theMuonsCollectionToken_, theMuToMuMapName, thePFCandLabel, thePFCandToken_, thePFIsoHelper, theSelectorMapNames, theSelectorMapTokens_, theShowerMapName, theShowerMapToken_, theTrackDepositName, theTrackDepositToken_, timeMapCmbToken_, timeMapCSCToken_, timeMapDTToken_, and vertexes_.

    : debug_(pSet.getUntrackedParameter<bool>("ActivateDebug", false)) {
  setAlias(pSet.getParameter<std::string>("@module_label"));

  fastLabelling_ = pSet.getUntrackedParameter<bool>("FastLabelling", true);

  theMuonsCollectionLabel = pSet.getParameter<edm::InputTag>("InputMuons");
  theMuonsCollectionToken_ = consumes<reco::MuonCollection>(theMuonsCollectionLabel);

  thePFCandLabel = pSet.getParameter<edm::InputTag>("PFCandidates");
  thePFCandToken_ = consumes<reco::PFCandidateCollection>(thePFCandLabel);

  // Variables to switch on-off the differnt parts
  fillSelectors_ = pSet.getParameter<bool>("FillSelectorMaps");
  fillCosmicsIdMap_ = pSet.getParameter<bool>("FillCosmicsIdMap");
  fillPFMomentum_ = pSet.getParameter<bool>("FillPFMomentumAndAssociation");
  fillPFIsolation_ = pSet.getParameter<bool>("FillPFIsolation");
  fillDetectorBasedIsolation_ = pSet.getParameter<bool>("FillDetectorBasedIsolation");
  fillShoweringInfo_ = pSet.getParameter<bool>("FillShoweringInfo");
  fillTimingInfo_ = pSet.getParameter<bool>("FillTimingInfo");
  computeStandardSelectors_ = pSet.getParameter<bool>("ComputeStandardSelectors");

  produces<reco::MuonCollection>();

  if (fillTimingInfo_) {
    timeMapCmbToken_ = consumes<reco::MuonTimeExtraMap>(edm::InputTag(theMuonsCollectionLabel.label(), "combined"));
    timeMapDTToken_ = consumes<reco::MuonTimeExtraMap>(edm::InputTag(theMuonsCollectionLabel.label(), "dt"));
    timeMapCSCToken_ = consumes<reco::MuonTimeExtraMap>(edm::InputTag(theMuonsCollectionLabel.label(), "csc"));

    produces<reco::MuonTimeExtraMap>("combined");
    produces<reco::MuonTimeExtraMap>("dt");
    produces<reco::MuonTimeExtraMap>("csc");
  }

  if (fillDetectorBasedIsolation_) {
    theTrackDepositName = pSet.getParameter<edm::InputTag>("TrackIsoDeposits");
    theTrackDepositToken_ = consumes<reco::IsoDepositMap>(theTrackDepositName);
    produces<reco::IsoDepositMap>(labelOrInstance(theTrackDepositName));

    theJetDepositName = pSet.getParameter<edm::InputTag>("JetIsoDeposits");
    theJetDepositToken_ = consumes<reco::IsoDepositMap>(theJetDepositName);
    produces<reco::IsoDepositMap>(labelOrInstance(theJetDepositName));

    theEcalDepositName = pSet.getParameter<edm::InputTag>("EcalIsoDeposits");
    theEcalDepositToken_ = consumes<reco::IsoDepositMap>(theEcalDepositName);
    produces<reco::IsoDepositMap>(theEcalDepositName.instance());

    theHcalDepositName = pSet.getParameter<edm::InputTag>("HcalIsoDeposits");
    theHcalDepositToken_ = consumes<reco::IsoDepositMap>(theHcalDepositName);
    produces<reco::IsoDepositMap>(theHcalDepositName.instance());

    theHoDepositName = pSet.getParameter<edm::InputTag>("HoIsoDeposits");
    theHoDepositToken_ = consumes<reco::IsoDepositMap>(theHoDepositName);

    produces<reco::IsoDepositMap>(theHoDepositName.instance());
  }

  if (fillSelectors_) {
    theSelectorMapNames = pSet.getParameter<InputTags>("SelectorMaps");

    for (InputTags::const_iterator tag = theSelectorMapNames.begin(); tag != theSelectorMapNames.end(); ++tag) {
      theSelectorMapTokens_.push_back(consumes<edm::ValueMap<bool>>(*tag));
      produces<edm::ValueMap<bool>>(labelOrInstance(*tag));
    }
  }

  if (fillShoweringInfo_) {
    theShowerMapName = pSet.getParameter<edm::InputTag>("ShowerInfoMap");
    theShowerMapToken_ = consumes<reco::MuonShowerMap>(theShowerMapName);
    produces<edm::ValueMap<reco::MuonShower>>(labelOrInstance(theShowerMapName));
  }

  if (fillCosmicsIdMap_) {
    theCosmicCompMapName = pSet.getParameter<edm::InputTag>("CosmicIdMap");
    theCosmicIdMapToken_ = consumes<edm::ValueMap<unsigned int>>(theCosmicCompMapName);
    theCosmicCompMapToken_ = consumes<edm::ValueMap<reco::MuonCosmicCompatibility>>(theCosmicCompMapName);

    produces<edm::ValueMap<reco::MuonCosmicCompatibility>>(labelOrInstance(theCosmicCompMapName));
    produces<edm::ValueMap<unsigned int>>(labelOrInstance(theCosmicCompMapName));
  }

  theMuToMuMapName = theMuonsCollectionLabel.label() + "2" + theAlias + "sMap";
  produces<edm::ValueMap<reco::MuonRef>>(theMuToMuMapName);

  if (fillPFIsolation_) {
    edm::ParameterSet pfIsoPSet = pSet.getParameter<edm::ParameterSet>("PFIsolation");

    //Define a map between the isolation and the PSet for the PFHelper
    std::map<std::string, edm::ParameterSet> psetMap;

    //First declare what isolation you are going to read
    std::vector<std::string> isolationLabels;
    isolationLabels.push_back("pfIsolationR03");
    isolationLabels.push_back("pfIsoMeanDRProfileR03");
    isolationLabels.push_back("pfIsoSumDRProfileR03");
    isolationLabels.push_back("pfIsolationR04");
    isolationLabels.push_back("pfIsoMeanDRProfileR04");
    isolationLabels.push_back("pfIsoSumDRProfileR04");

    //Fill the label,pet map and initialize MuPFIsoHelper
    for (std::vector<std::string>::const_iterator label = isolationLabels.begin(); label != isolationLabels.end();
         ++label)
      psetMap[*label] = pfIsoPSet.getParameter<edm::ParameterSet>(*label);

    thePFIsoHelper = new MuPFIsoHelper(psetMap, consumesCollector());

    //Now loop on the mass read for each PSet the parameters and save them to the mapNames for later

    for (std::map<std::string, edm::ParameterSet>::const_iterator map = psetMap.begin(); map != psetMap.end(); ++map) {
      std::map<std::string, edm::InputTag> isoMap;
      isoMap["chargedParticle"] = map->second.getParameter<edm::InputTag>("chargedParticle");
      isoMap["chargedHadron"] = map->second.getParameter<edm::InputTag>("chargedHadron");
      isoMap["neutralHadron"] = map->second.getParameter<edm::InputTag>("neutralHadron");
      isoMap["neutralHadronHighThreshold"] = map->second.getParameter<edm::InputTag>("neutralHadronHighThreshold");
      isoMap["photon"] = map->second.getParameter<edm::InputTag>("photon");
      isoMap["photonHighThreshold"] = map->second.getParameter<edm::InputTag>("photonHighThreshold");
      isoMap["pu"] = map->second.getParameter<edm::InputTag>("pu");

      std::map<std::string, edm::EDGetTokenT<edm::ValueMap<double>>> isoMapToken;
      isoMapToken["chargedParticle"] = consumes<edm::ValueMap<double>>(isoMap["chargedParticle"]);
      isoMapToken["chargedHadron"] = consumes<edm::ValueMap<double>>(isoMap["chargedHadron"]);
      isoMapToken["neutralHadron"] = consumes<edm::ValueMap<double>>(isoMap["neutralHadron"]);
      isoMapToken["neutralHadronHighThreshold"] = consumes<edm::ValueMap<double>>(isoMap["neutralHadronHighThreshold"]);
      isoMapToken["photon"] = consumes<edm::ValueMap<double>>(isoMap["photon"]);
      isoMapToken["photonHighThreshold"] = consumes<edm::ValueMap<double>>(isoMap["photonHighThreshold"]);
      isoMapToken["pu"] = consumes<edm::ValueMap<double>>(isoMap["pu"]);

      pfIsoMapNames.push_back(isoMap);
      pfIsoMapTokens_.push_back(isoMapToken);
    }

    for (unsigned int j = 0; j < pfIsoMapNames.size(); ++j) {
      for (std::map<std::string, edm::InputTag>::const_iterator map = pfIsoMapNames.at(j).begin();
           map != pfIsoMapNames.at(j).end();
           ++map)
        produces<edm::ValueMap<double>>(labelOrInstance(map->second));
    }
  }

  if (computeStandardSelectors_) {
    vertexes_ = consumes<reco::VertexCollection>(pSet.getParameter<edm::InputTag>("vertices"));
  }
}

~MuonProducer()

MuonProducer::~MuonProducer ( )

override

Destructor.

Definition at line 174 of file MuonProducer.cc.

References fillPFIsolation_, and thePFIsoHelper.

                            {
  if (fillPFIsolation_ && thePFIsoHelper)
    delete thePFIsoHelper;
}

Member Function Documentation

fillMuonMap()

template<typename TYPE >

void MuonProducer::fillMuonMap ( edm::Event &  event, const edm::OrphanHandle< reco::MuonCollection > &  muonHandle, const std::vector< TYPE > &  muonExtra, const std::string &  label  )

private

Definition at line 483 of file MuonProducer.cc.

References trigObjTnPSource_cfi::filler, label, and eostools::move().

                                                       {
  typedef typename edm::ValueMap<TYPE>::Filler FILLER;

  auto muonMap = std::make_unique<edm::ValueMap<TYPE>>();
  if (!muonExtra.empty()) {
    FILLER filler(*muonMap);
    filler.insert(muonHandle, muonExtra.begin(), muonExtra.end());
    filler.fill();
  }
  event.put(std::move(muonMap), label);
}

labelOrInstance()

std::string MuonProducer::labelOrInstance ( const edm::InputTag &  input ) const

private

Definition at line 498 of file MuonProducer.cc.

References fastLabelling_, input, edm::InputTag::label(), and theMuonsCollectionLabel.

Referenced by MuonProducer(), and produce().

                                                                      {
  if (fastLabelling_)
    return input.label();

  return input.label() != theMuonsCollectionLabel.label() ? input.label() : input.instance();
}

produce()

void MuonProducer::produce ( edm::Event &  event, const edm::EventSetup &  eventSetup  )

override

reconstruct muons

Definition at line 180 of file MuonProducer.cc.

References funct::abs(), MuPFIsoHelper::beginEvent(), computeStandardSelectors_, dout, MuPFIsoHelper::embedPFIsolation(), edmPickEvents::event, fillCosmicsIdMap_, fillDetectorBasedIsolation_, fillPFIsolation_, fillPFMomentum_, fillSelectors_, fillShoweringInfo_, fillTimingInfo_, mps_fire::i, edm::Ref< C, T, F >::id(), calomuons_cfi::inputMuons, edm::InputTag::instance(), reco::Muon::isGlobalMuon(), reco::Muon::isPFMuon(), reco::Muon::isStandAloneMuon(), reco::Muon::isTrackerMuon(), dqmiolumiharvest::j, edm::Ref< C, T, F >::key(), labelOrInstance(), muon::makeSelectorBitset(), genParticles_cff::map, metname, eostools::move(), custom_jme_cff::nMuons, reco::LeafCandidate::p4(), zmumugammaAnalyzer_cfi::pfCandidates, pfIsoMapNames, pfIsoMapTokens_, reco::Muon::pfP4(), HLT_2023v12_cff::primaryVertices, alignCSCRings::s, reco::Muon::setBestTrack(), reco::LeafCandidate::setCharge(), reco::LeafCandidate::setP4(), reco::LeafCandidate::setPdgId(), reco::Muon::setPFP4(), reco::Muon::setSelectors(), AlCaHLTBitMon_QueryRunRegistry::string, makeGlobalPositionRcd_cfg::tag, theCosmicCompMapName, theCosmicCompMapToken_, theCosmicIdMapToken_, theEcalDepositName, theEcalDepositToken_, theHcalDepositName, theHcalDepositToken_, theHoDepositName, theHoDepositToken_, theJetDepositName, theJetDepositToken_, theMuonsCollectionToken_, theMuToMuMapName, thePFCandToken_, thePFIsoHelper, theSelectorMapNames, theSelectorMapTokens_, theShowerMapName, theShowerMapToken_, theTrackDepositName, theTrackDepositToken_, timeMapCmbToken_, timeMapCSCToken_, timeMapDTToken_, bphysicsOniaDQM_cfi::vertex, and vertexes_.

                                                                           {
  const std::string metname = "Muon|RecoMuon|MuonIdentification|MuonProducer";

  // the muon collection, it will be loaded in the event
  auto outputMuons = std::make_unique<reco::MuonCollection>();
  reco::MuonRefProd outputMuonsRefProd = event.getRefBeforePut<reco::MuonCollection>();

  edm::Handle<reco::MuonCollection> inputMuons;
  event.getByToken(theMuonsCollectionToken_, inputMuons);
  edm::OrphanHandle<reco::MuonCollection> inputMuonsOH(inputMuons.product(), inputMuons.id());

  edm::Handle<reco::PFCandidateCollection> pfCandidates;
  event.getByToken(thePFCandToken_, pfCandidates);

  edm::Handle<reco::VertexCollection> primaryVertices;
  const reco::Vertex* vertex(nullptr);
  if (computeStandardSelectors_) {
    event.getByToken(vertexes_, primaryVertices);
    if (!primaryVertices->empty())
      vertex = &(primaryVertices->front());
  }

  // fetch collections for PFIso
  if (fillPFIsolation_)
    thePFIsoHelper->beginEvent(event);

  // Fill timing information
  edm::Handle<reco::MuonTimeExtraMap> timeMapCmb;
  edm::Handle<reco::MuonTimeExtraMap> timeMapDT;
  edm::Handle<reco::MuonTimeExtraMap> timeMapCSC;

  int nMuons = inputMuons->size();

  std::vector<reco::MuonTimeExtra> dtTimeColl(nMuons);
  std::vector<reco::MuonTimeExtra> cscTimeColl(nMuons);
  std::vector<reco::MuonTimeExtra> combinedTimeColl(nMuons);

  if (fillTimingInfo_) {
    event.getByToken(timeMapCmbToken_, timeMapCmb);
    event.getByToken(timeMapDTToken_, timeMapDT);
    event.getByToken(timeMapCSCToken_, timeMapCSC);
  }

  std::vector<reco::IsoDeposit> trackDepColl(nMuons);
  std::vector<reco::IsoDeposit> ecalDepColl(nMuons);
  std::vector<reco::IsoDeposit> hcalDepColl(nMuons);
  std::vector<reco::IsoDeposit> hoDepColl(nMuons);
  std::vector<reco::IsoDeposit> jetDepColl(nMuons);

  edm::Handle<reco::IsoDepositMap> trackIsoDepMap;
  edm::Handle<reco::IsoDepositMap> ecalIsoDepMap;
  edm::Handle<reco::IsoDepositMap> hcalIsoDepMap;
  edm::Handle<reco::IsoDepositMap> hoIsoDepMap;
  edm::Handle<reco::IsoDepositMap> jetIsoDepMap;

  if (fillDetectorBasedIsolation_) {
    event.getByToken(theTrackDepositToken_, trackIsoDepMap);
    event.getByToken(theEcalDepositToken_, ecalIsoDepMap);
    event.getByToken(theHcalDepositToken_, hcalIsoDepMap);
    event.getByToken(theHoDepositToken_, hoIsoDepMap);
    event.getByToken(theJetDepositToken_, jetIsoDepMap);
  }

  std::vector<std::map<std::string, edm::Handle<edm::ValueMap<double>>>> pfIsoMaps;
  std::vector<std::map<std::string, std::vector<double>>> pfIsoMapVals;

  if (fillPFIsolation_) {
    for (unsigned int j = 0; j < pfIsoMapNames.size(); ++j) {
      std::map<std::string, std::vector<double>> mapVals;
      std::map<std::string, edm::Handle<edm::ValueMap<double>>> maps;
      for (std::map<std::string, edm::InputTag>::const_iterator map = pfIsoMapNames.at(j).begin();
           map != pfIsoMapNames.at(j).end();
           ++map) {
        edm::Handle<edm::ValueMap<double>> handleTmp;
        event.getByToken(pfIsoMapTokens_.at(j)[map->first], handleTmp);
        maps[map->first] = handleTmp;
        mapVals[map->first].resize(nMuons);
      }
      pfIsoMapVals.push_back(mapVals);
      pfIsoMaps.push_back(maps);
    }
  }

  std::vector<edm::Handle<edm::ValueMap<bool>>> selectorMaps(fillSelectors_ ? theSelectorMapNames.size() : 0);
  std::vector<std::vector<bool>> selectorMapResults(fillSelectors_ ? theSelectorMapNames.size() : 0);
  if (fillSelectors_) {
    unsigned int s = 0;
    for (InputTags::const_iterator tag = theSelectorMapNames.begin(); tag != theSelectorMapNames.end(); ++tag, ++s) {
      event.getByToken(theSelectorMapTokens_.at(s), selectorMaps[s]);
      selectorMapResults[s].resize(nMuons);
    }
  }

  edm::Handle<reco::MuonShowerMap> showerInfoMap;
  if (fillShoweringInfo_)
    event.getByToken(theShowerMapToken_, showerInfoMap);

  std::vector<reco::MuonShower> showerInfoColl(nMuons);

  edm::Handle<edm::ValueMap<unsigned int>> cosmicIdMap;
  if (fillCosmicsIdMap_)
    event.getByToken(theCosmicIdMapToken_, cosmicIdMap);
  std::vector<unsigned int> cosmicIdColl(fillCosmicsIdMap_ ? nMuons : 0);

  edm::Handle<edm::ValueMap<reco::MuonCosmicCompatibility>> cosmicCompMap;
  if (fillCosmicsIdMap_)
    event.getByToken(theCosmicCompMapToken_, cosmicCompMap);
  std::vector<reco::MuonCosmicCompatibility> cosmicCompColl(fillCosmicsIdMap_ ? nMuons : 0);

  std::vector<reco::MuonRef> muonRefColl(nMuons);

  if (inputMuons->empty()) {
    edm::OrphanHandle<reco::MuonCollection> muonHandle = event.put(std::move(outputMuons));

    if (fillTimingInfo_) {
      fillMuonMap<reco::MuonTimeExtra>(event, muonHandle, combinedTimeColl, "combined");
      fillMuonMap<reco::MuonTimeExtra>(event, muonHandle, dtTimeColl, "dt");
      fillMuonMap<reco::MuonTimeExtra>(event, muonHandle, cscTimeColl, "csc");
    }

    if (fillDetectorBasedIsolation_) {
      fillMuonMap<reco::IsoDeposit>(event, muonHandle, trackDepColl, labelOrInstance(theTrackDepositName));
      fillMuonMap<reco::IsoDeposit>(event, muonHandle, jetDepColl, labelOrInstance(theJetDepositName));
      fillMuonMap<reco::IsoDeposit>(event, muonHandle, ecalDepColl, theEcalDepositName.instance());
      fillMuonMap<reco::IsoDeposit>(event, muonHandle, hcalDepColl, theHcalDepositName.instance());
      fillMuonMap<reco::IsoDeposit>(event, muonHandle, hoDepColl, theHoDepositName.instance());
    }

    if (fillSelectors_) {
      unsigned int s = 0;
      for (InputTags::const_iterator tag = theSelectorMapNames.begin(); tag != theSelectorMapNames.end(); ++tag, ++s) {
        fillMuonMap<bool>(event, muonHandle, selectorMapResults[s], labelOrInstance(*tag));
      }
    }

    if (fillShoweringInfo_)
      fillMuonMap<reco::MuonShower>(event, muonHandle, showerInfoColl, labelOrInstance(theShowerMapName));

    if (fillCosmicsIdMap_) {
      fillMuonMap<unsigned int>(event, muonHandle, cosmicIdColl, labelOrInstance(theCosmicCompMapName));
      fillMuonMap<reco::MuonCosmicCompatibility>(
          event, muonHandle, cosmicCompColl, labelOrInstance(theCosmicCompMapName));
    }

    fillMuonMap<reco::MuonRef>(event, inputMuonsOH, muonRefColl, theMuToMuMapName);

    if (fillPFIsolation_) {
      for (unsigned int j = 0; j < pfIsoMapNames.size(); ++j)
        for (std::map<std::string, edm::InputTag>::const_iterator map = pfIsoMapNames.at(j).begin();
             map != pfIsoMapNames.at(j).end();
             ++map) {
          fillMuonMap<double>(event, muonHandle, pfIsoMapVals.at(j)[map->first], labelOrInstance(map->second));
        }
    }
    return;
  }

  // FIXME: add the option to swith off the Muon-PF "info association".

  MuToPFMap muToPFMap;

  if (fillPFMomentum_) {
    dout << "Number of PFCandidates: " << pfCandidates->size() << endl;
    for (unsigned int i = 0; i < pfCandidates->size(); ++i)
      if (abs(pfCandidates->at(i).pdgId()) == 13) {
        muToPFMap[pfCandidates->at(i).muonRef()] = i;
        dout << "MuonRef: " << pfCandidates->at(i).muonRef().id() << " " << pfCandidates->at(i).muonRef().key()
             << " PF p4: " << pfCandidates->at(i).p4() << endl;
      }
    dout << "Number of PFMuons: " << muToPFMap.size() << endl;
    dout << "Number of Muons in the original collection: " << inputMuons->size() << endl;
  }

  reco::MuonRef::key_type muIndex = 0;
  unsigned int i = 0;
  for (auto const& inMuon : *inputMuons) {
    reco::MuonRef muRef(inputMuons, muIndex);
    muonRefColl[i] = reco::MuonRef(outputMuonsRefProd, muIndex++);

    // Copy the muon
    reco::Muon outMuon = inMuon;

    if (fillPFMomentum_) {
      // search for the corresponding pf candidate
      MuToPFMap::iterator iter = muToPFMap.find(muRef);
      if (iter != muToPFMap.end()) {
        const auto& pfMu = pfCandidates->at(iter->second);
        outMuon.setPFP4(pfMu.p4());
        outMuon.setP4(pfMu.p4());          //PF is the default
        outMuon.setCharge(pfMu.charge());  //PF is the default
        outMuon.setPdgId(-13 * pfMu.charge());
        outMuon.setBestTrack(pfMu.bestMuonTrackType());
        muToPFMap.erase(iter);
        dout << "MuonRef: " << muRef.id() << " " << muRef.key() << " Is it PF? " << outMuon.isPFMuon()
             << " PF p4: " << outMuon.pfP4() << endl;
      }

      dout << "MuonRef: " << muRef.id() << " " << muRef.key() << " Is it PF? " << outMuon.isPFMuon() << endl;

      dout << "GLB " << outMuon.isGlobalMuon() << " TM " << outMuon.isTrackerMuon() << " STA "
           << outMuon.isStandAloneMuon() << " p4 " << outMuon.p4() << endl;
    }

    // Add PF isolation info
    if (fillPFIsolation_) {
      thePFIsoHelper->embedPFIsolation(outMuon, muRef);

      for (unsigned int j = 0; j < pfIsoMapNames.size(); ++j) {
        for (std::map<std::string, edm::InputTag>::const_iterator map = pfIsoMapNames[j].begin();
             map != pfIsoMapNames[j].end();
             ++map) {
          (pfIsoMapVals[j])[map->first][i] = (*pfIsoMaps[j][map->first])[muRef];
        }
      }
    }

    // Fill timing information
    if (fillTimingInfo_) {
      combinedTimeColl[i] = (*timeMapCmb)[muRef];
      dtTimeColl[i] = (*timeMapDT)[muRef];
      cscTimeColl[i] = (*timeMapCSC)[muRef];
    }

    if (fillDetectorBasedIsolation_) {
      trackDepColl[i] = (*trackIsoDepMap)[muRef];
      ecalDepColl[i] = (*ecalIsoDepMap)[muRef];
      hcalDepColl[i] = (*hcalIsoDepMap)[muRef];
      hoDepColl[i] = (*hoIsoDepMap)[muRef];
      jetDepColl[i] = (*jetIsoDepMap)[muRef];
      ;
    }

    if (fillSelectors_) {
      unsigned int s = 0;
      for (InputTags::const_iterator tag = theSelectorMapNames.begin(); tag != theSelectorMapNames.end(); ++tag, ++s)
        selectorMapResults[s][i] = (*selectorMaps[s])[muRef];
    }

    // Fill the Showering Info
    if (fillShoweringInfo_)
      showerInfoColl[i] = (*showerInfoMap)[muRef];

    if (fillCosmicsIdMap_) {
      cosmicIdColl[i] = (*cosmicIdMap)[muRef];
      cosmicCompColl[i] = (*cosmicCompMap)[muRef];
    }

    // Standard Selectors - keep it at the end so that all inputs are available
    if (computeStandardSelectors_) {
      outMuon.setSelectors(0);  // reset flags
      bool isRun2016BCDEF = (272728 <= event.run() && event.run() <= 278808);
      outMuon.setSelectors(muon::makeSelectorBitset(outMuon, vertex, isRun2016BCDEF));
    }

    outputMuons->push_back(outMuon);
    ++i;
  }

  dout << "Number of Muons in the new muon collection: " << outputMuons->size() << endl;
  edm::OrphanHandle<reco::MuonCollection> muonHandle = event.put(std::move(outputMuons));

  if (fillTimingInfo_) {
    fillMuonMap<reco::MuonTimeExtra>(event, muonHandle, combinedTimeColl, "combined");
    fillMuonMap<reco::MuonTimeExtra>(event, muonHandle, dtTimeColl, "dt");
    fillMuonMap<reco::MuonTimeExtra>(event, muonHandle, cscTimeColl, "csc");
  }

  if (fillDetectorBasedIsolation_) {
    fillMuonMap<reco::IsoDeposit>(event, muonHandle, trackDepColl, labelOrInstance(theTrackDepositName));
    fillMuonMap<reco::IsoDeposit>(event, muonHandle, jetDepColl, labelOrInstance(theJetDepositName));
    fillMuonMap<reco::IsoDeposit>(event, muonHandle, ecalDepColl, theEcalDepositName.instance());
    fillMuonMap<reco::IsoDeposit>(event, muonHandle, hcalDepColl, theHcalDepositName.instance());
    fillMuonMap<reco::IsoDeposit>(event, muonHandle, hoDepColl, theHoDepositName.instance());
  }

  if (fillPFIsolation_) {
    for (unsigned int j = 0; j < pfIsoMapNames.size(); ++j) {
      for (std::map<std::string, edm::InputTag>::const_iterator map = pfIsoMapNames[j].begin();
           map != pfIsoMapNames[j].end();
           ++map)
        fillMuonMap<double>(event, muonHandle, pfIsoMapVals[j][map->first], labelOrInstance(map->second));
    }
  }

  if (fillSelectors_) {
    unsigned int s = 0;
    for (InputTags::const_iterator tag = theSelectorMapNames.begin(); tag != theSelectorMapNames.end(); ++tag, ++s)
      fillMuonMap<bool>(event, muonHandle, selectorMapResults[s], labelOrInstance(*tag));
  }

  if (fillShoweringInfo_)
    fillMuonMap<reco::MuonShower>(event, muonHandle, showerInfoColl, labelOrInstance(theShowerMapName));

  if (fillCosmicsIdMap_) {
    fillMuonMap<unsigned int>(event, muonHandle, cosmicIdColl, labelOrInstance(theCosmicCompMapName));
    fillMuonMap<reco::MuonCosmicCompatibility>(
        event, muonHandle, cosmicCompColl, labelOrInstance(theCosmicCompMapName));
  }

  fillMuonMap<reco::MuonRef>(event, inputMuonsOH, muonRefColl, theMuToMuMapName);
}

setAlias()

void MuonProducer::setAlias ( std::string  alias )

inlineprivate

Definition at line 71 of file MuonProducer.h.

References SiStripOfflineCRack_cfg::alias, and theAlias.

Referenced by MuonProducer().

                                 {
    alias.erase(alias.size() - 1, alias.size());
    theAlias = alias;
  }

Member Data Documentation

computeStandardSelectors_

bool MuonProducer::computeStandardSelectors_

private

Definition at line 97 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

debug_

bool MuonProducer::debug_

private

Definition at line 79 of file MuonProducer.h.

fastLabelling_

bool MuonProducer::fastLabelling_

private

Definition at line 80 of file MuonProducer.h.

Referenced by labelOrInstance(), and MuonProducer().

fillCosmicsIdMap_

bool MuonProducer::fillCosmicsIdMap_

private

Definition at line 91 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

fillDetectorBasedIsolation_

bool MuonProducer::fillDetectorBasedIsolation_

private

Definition at line 94 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

fillIsolation_

bool MuonProducer::fillIsolation_

private

Definition at line 88 of file MuonProducer.h.

fillPFIsolation_

bool MuonProducer::fillPFIsolation_

private

Definition at line 93 of file MuonProducer.h.

Referenced by MuonProducer(), produce(), and ~MuonProducer().

fillPFMomentum_

bool MuonProducer::fillPFMomentum_

private

Definition at line 92 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

fillSelectors_

bool MuonProducer::fillSelectors_

private

Definition at line 90 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

fillShoweringInfo_

bool MuonProducer::fillShoweringInfo_

private

Definition at line 95 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

fillTimingInfo_

bool MuonProducer::fillTimingInfo_

private

Definition at line 96 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

pfIsoMapNames

std::vector<std::map<std::string, edm::InputTag> > MuonProducer::pfIsoMapNames

private

Definition at line 128 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

pfIsoMapTokens_

std::vector<std::map<std::string, edm::EDGetTokenT<edm::ValueMap<double> > > > MuonProducer::pfIsoMapTokens_

private

Definition at line 129 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

theAlias

std::string MuonProducer::theAlias

private

Definition at line 69 of file MuonProducer.h.

Referenced by MuonProducer(), and setAlias().

theCosmicCompMapName

edm::InputTag MuonProducer::theCosmicCompMapName

private

Definition at line 117 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

theCosmicCompMapToken_

edm::EDGetTokenT<edm::ValueMap<reco::MuonCosmicCompatibility> > MuonProducer::theCosmicCompMapToken_

private

Definition at line 119 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

theCosmicIdMapToken_

edm::EDGetTokenT<edm::ValueMap<unsigned int> > MuonProducer::theCosmicIdMapToken_

private

Definition at line 118 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

theEcalDepositName

edm::InputTag MuonProducer::theEcalDepositName

private

Definition at line 100 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

theEcalDepositToken_

edm::EDGetTokenT<reco::IsoDepositMap> MuonProducer::theEcalDepositToken_

private

Definition at line 106 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

theHcalDepositName

edm::InputTag MuonProducer::theHcalDepositName

private

Definition at line 101 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

theHcalDepositToken_

edm::EDGetTokenT<reco::IsoDepositMap> MuonProducer::theHcalDepositToken_

private

Definition at line 107 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

theHoDepositName

edm::InputTag MuonProducer::theHoDepositName

private

Definition at line 102 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

theHoDepositToken_

edm::EDGetTokenT<reco::IsoDepositMap> MuonProducer::theHoDepositToken_

private

Definition at line 108 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

theJetDepositName

edm::InputTag MuonProducer::theJetDepositName

private

Definition at line 103 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

theJetDepositToken_

edm::EDGetTokenT<reco::IsoDepositMap> MuonProducer::theJetDepositToken_

private

Definition at line 109 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

theMuonsCollectionLabel

edm::InputTag MuonProducer::theMuonsCollectionLabel

private

Definition at line 82 of file MuonProducer.h.

Referenced by labelOrInstance(), and MuonProducer().

theMuonsCollectionToken_

edm::EDGetTokenT<reco::MuonCollection> MuonProducer::theMuonsCollectionToken_

private

Definition at line 83 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

theMuToMuMapName

std::string MuonProducer::theMuToMuMapName

private

Definition at line 120 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

thePFCandLabel

edm::InputTag MuonProducer::thePFCandLabel

private

Definition at line 85 of file MuonProducer.h.

Referenced by MuonProducer().

thePFCandToken_

edm::EDGetTokenT<reco::PFCandidateCollection> MuonProducer::thePFCandToken_

private

Definition at line 86 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

thePFIsoHelper

MuPFIsoHelper* MuonProducer::thePFIsoHelper

private

Definition at line 122 of file MuonProducer.h.

Referenced by MuonProducer(), produce(), and ~MuonProducer().

theSelectorMapNames

InputTags MuonProducer::theSelectorMapNames

private

Definition at line 111 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

theSelectorMapTokens_

std::vector<edm::EDGetTokenT<edm::ValueMap<bool> > > MuonProducer::theSelectorMapTokens_

private

Definition at line 112 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

theShowerMapName

edm::InputTag MuonProducer::theShowerMapName

private

Definition at line 114 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

theShowerMapToken_

edm::EDGetTokenT<edm::ValueMap<reco::MuonShower> > MuonProducer::theShowerMapToken_

private

Definition at line 115 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

theTrackDepositName

edm::InputTag MuonProducer::theTrackDepositName

private

Definition at line 99 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

theTrackDepositToken_

edm::EDGetTokenT<reco::IsoDepositMap> MuonProducer::theTrackDepositToken_

private

Definition at line 105 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

timeMapCmbToken_

edm::EDGetTokenT<reco::MuonTimeExtraMap> MuonProducer::timeMapCmbToken_

private

Definition at line 124 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

timeMapCSCToken_

edm::EDGetTokenT<reco::MuonTimeExtraMap> MuonProducer::timeMapCSCToken_

private

Definition at line 126 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

timeMapDTToken_

edm::EDGetTokenT<reco::MuonTimeExtraMap> MuonProducer::timeMapDTToken_

private

Definition at line 125 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

vertexes_

edm::EDGetTokenT<reco::VertexCollection> MuonProducer::vertexes_

private

Definition at line 131 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

writeIsoDeposits_

bool MuonProducer::writeIsoDeposits_

private

Definition at line 89 of file MuonProducer.h.