#include <MuonProducer.h>

Inheritance diagram for MuonProducer:

Public Types
typedef std::vector< edm::InputTag >	InputTags

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

Public Types inherited from edm::stream::EDProducerBase
typedef EDProducerAdaptorBase	ModuleType

Public Types inherited from edm::ProducerBase
using	ModuleToResolverIndicies = std::unordered_multimap< std::string, std::tuple< edm::TypeID const , const char , edm::ProductResolverIndex >>

typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

Public Member Functions inherited from edm::stream::EDProducerBase
	EDProducerBase ()

ModuleDescription const &	moduleDescription () const

	~EDProducerBase () override

Public Member Functions inherited from edm::ProducerBase
void	callWhenNewProductsRegistered (std::function< void(BranchDescription const &)> const &func)

std::vector< edm::ProductResolverIndex > const &	indiciesForPutProducts (BranchType iBranchType) const

	ProducerBase ()

std::vector< edm::ProductResolverIndex > const &	putTokenIndexToProductResolverIndex () const

void	registerProducts (ProducerBase , ProductRegistry , ModuleDescription const &)

std::function< void(BranchDescription const &)>	registrationCallback () const
	used by the fwk to register list of products More...

void	resolvePutIndicies (BranchType iBranchType, ModuleToResolverIndicies const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

Public Member Functions inherited from edm::EDConsumerBase
std::vector< ConsumesInfo >	consumesInfo () const

void	convertCurrentProcessAlias (std::string const &processName)
	Convert "@currentProcess" in InputTag process names to the actual current process name. More...

	EDConsumerBase ()

	EDConsumerBase (EDConsumerBase const &)=delete

	EDConsumerBase (EDConsumerBase &&)=default

ProductResolverIndexAndSkipBit	indexFrom (EDGetToken, BranchType, TypeID const &) const

void	itemsMayGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

void	itemsToGet (BranchType, std::vector< ProductResolverIndexAndSkipBit > &) const

std::vector< ProductResolverIndexAndSkipBit > const &	itemsToGetFrom (BranchType iType) const

void	labelsForToken (EDGetToken iToken, Labels &oLabels) const

void	modulesWhoseProductsAreConsumed (std::vector< ModuleDescription const * > &modules, ProductRegistry const &preg, std::map< std::string, ModuleDescription const * > const &labelsToDesc, std::string const &processName) const

EDConsumerBase const &	operator= (EDConsumerBase const &)=delete

EDConsumerBase &	operator= (EDConsumerBase &&)=default

bool	registeredToConsume (ProductResolverIndex, bool, BranchType) const

bool	registeredToConsumeMany (TypeID const &, BranchType) const

void	updateLookup (BranchType iBranchType, ProductResolverIndexHelper const &, bool iPrefetchMayGet)

virtual	~EDConsumerBase () noexcept(false)

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_

Additional Inherited Members
Static Public Member Functions inherited from edm::stream::EDProducerBase
static const std::string &	baseType ()

static void	fillDescriptions (ConfigurationDescriptions &descriptions)

static void	prevalidate (ConfigurationDescriptions &descriptions)

Protected Member Functions inherited from edm::EDConsumerBase
template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	consumes (edm::InputTag const &tag)

EDGetToken	consumes (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	consumes (TypeToGet const &id, edm::InputTag const &tag)

ConsumesCollector	consumesCollector ()
	Use a ConsumesCollector to gather consumes information from helper functions. More...

template<typename ProductType , BranchType B = InEvent>
void	consumesMany ()

void	consumesMany (const TypeToGet &id)

template<BranchType B>
void	consumesMany (const TypeToGet &id)

template<typename ProductType , BranchType B = InEvent>
EDGetTokenT< ProductType >	mayConsume (edm::InputTag const &tag)

EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

template<BranchType B>
EDGetToken	mayConsume (const TypeToGet &id, edm::InputTag const &tag)

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

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

Definition at line 61 of file MuonProducer.h.

Constructor & Destructor Documentation

MuonProducer::MuonProducer ( const edm::ParameterSet & pSet )

Constructor.

Definition at line 33 of file MuonProducer.cc.

References computeStandardSelectors_, edm::EDConsumerBase::consumes(), edm::EDConsumerBase::consumesCollector(), fastLabelling_, fillCosmicsIdMap_, fillDetectorBasedIsolation_, fillPFIsolation_, fillPFMomentum_, fillSelectors_, fillShoweringInfo_, fillTimingInfo_, edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), diffTwoXMLs::label, labelOrInstance(), genParticles_cff::map, pfIsoMapNames, pfIsoMapTokens_, edm::ProductRegistryHelper::produces(), setAlias(), AlCaHLTBitMon_QueryRunRegistry::string, GlobalPosition_Frontier_DevDB_cff::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 ( )

override

Destructor.

Definition at line 187 of file MuonProducer.cc.

References fillPFIsolation_, and thePFIsoHelper.

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

Member Function Documentation

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 504 of file MuonProducer.cc.

References objects.autophobj::filler, 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);
 }

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

private

Definition at line 521 of file MuonProducer.cc.

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

Referenced by MuonProducer(), and produce().

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

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

override

reconstruct muons

Definition at line 193 of file MuonProducer.cc.

References funct::abs(), begin, MuPFIsoHelper::beginEvent(), computeStandardSelectors_, dout, MuPFIsoHelper::embedPFIsolation(), event(), fillCosmicsIdMap_, fillDetectorBasedIsolation_, fillPFIsolation_, fillPFMomentum_, fillSelectors_, fillShoweringInfo_, fillTimingInfo_, mps_fire::i, edm::OrphanHandleBase::id(), edm::Ref< C, T, F >::id(), calomuons_cfi::inputMuons, edm::InputTag::instance(), reco::Muon::isGlobalMuon(), reco::Muon::isPFMuon(), reco::Muon::isStandAloneMuon(), reco::Muon::isTrackerMuon(), edm::Ref< C, T, F >::key(), labelOrInstance(), genParticles_cff::map, metname, eostools::move(), jets_cff::nMuons, reco::LeafCandidate::p4(), slimmedMuons_cfi::pfCandidates, pfIsoMapNames, pfIsoMapTokens_, reco::Muon::pfP4(), jets_cff::primaryVertices, alignCSCRings::s, reco::Muon::setBestTrack(), reco::LeafCandidate::setCharge(), muon::setCutBasedSelectorFlags(), reco::LeafCandidate::setP4(), reco::LeafCandidate::setPdgId(), reco::Muon::setPFP4(), reco::Muon::setSelectors(), AlCaHLTBitMon_QueryRunRegistry::string, GlobalPosition_Frontier_DevDB_cff::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_, 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;
    foreach(const reco::Muon &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);
        muon::setCutBasedSelectorFlags(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);
    
  
 }

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

inlineprivate

Definition at line 74 of file MuonProducer.h.

References met_cff::alias, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by MuonProducer().

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

Member Data Documentation

bool MuonProducer::computeStandardSelectors_

private

Definition at line 102 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

bool MuonProducer::debug_

private

Definition at line 82 of file MuonProducer.h.

bool MuonProducer::fastLabelling_

private

Definition at line 83 of file MuonProducer.h.

Referenced by labelOrInstance(), and MuonProducer().

bool MuonProducer::fillCosmicsIdMap_

private

Definition at line 96 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

bool MuonProducer::fillDetectorBasedIsolation_

private

Definition at line 99 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

bool MuonProducer::fillIsolation_

private

Definition at line 93 of file MuonProducer.h.

bool MuonProducer::fillPFIsolation_

private

Definition at line 98 of file MuonProducer.h.

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

bool MuonProducer::fillPFMomentum_

private

Definition at line 97 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

bool MuonProducer::fillSelectors_

private

Definition at line 95 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

bool MuonProducer::fillShoweringInfo_

private

Definition at line 100 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

bool MuonProducer::fillTimingInfo_

private

Definition at line 101 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

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

private

Definition at line 138 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

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

private

Definition at line 139 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

std::string MuonProducer::theAlias

private

Definition at line 72 of file MuonProducer.h.

Referenced by MuonProducer().

edm::InputTag MuonProducer::theCosmicCompMapName

private

Definition at line 124 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

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

private

Definition at line 126 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

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

private

Definition at line 125 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

edm::InputTag MuonProducer::theEcalDepositName

private

Definition at line 105 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

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

private

Definition at line 111 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

edm::InputTag MuonProducer::theHcalDepositName

private

Definition at line 106 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

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

private

Definition at line 112 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

edm::InputTag MuonProducer::theHoDepositName

private

Definition at line 107 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

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

private

Definition at line 113 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

edm::InputTag MuonProducer::theJetDepositName

private

Definition at line 108 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

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

private

Definition at line 114 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

edm::InputTag MuonProducer::theMuonsCollectionLabel

private

Definition at line 85 of file MuonProducer.h.

Referenced by labelOrInstance(), and MuonProducer().

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

private

Definition at line 86 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

std::string MuonProducer::theMuToMuMapName

private

Definition at line 127 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

edm::InputTag MuonProducer::thePFCandLabel

private

Definition at line 88 of file MuonProducer.h.

Referenced by MuonProducer().

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

private

Definition at line 89 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

MuPFIsoHelper* MuonProducer::thePFIsoHelper

private

Definition at line 129 of file MuonProducer.h.

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

InputTags MuonProducer::theSelectorMapNames

private

Definition at line 117 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

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

private

Definition at line 118 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

edm::InputTag MuonProducer::theShowerMapName

private

Definition at line 121 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

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

private

Definition at line 122 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

edm::InputTag MuonProducer::theTrackDepositName

private

Definition at line 104 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

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

private

Definition at line 110 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

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

private

Definition at line 131 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

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

private

Definition at line 133 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

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

private

Definition at line 132 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

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

private

Definition at line 141 of file MuonProducer.h.

Referenced by MuonProducer(), and produce().

bool MuonProducer::writeIsoDeposits_

private

Definition at line 94 of file MuonProducer.h.

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation