#include <MuonAssociatorEDProducer.h>

Inheritance diagram for MuonAssociatorEDProducer:

Public Member Functions
	MuonAssociatorEDProducer (const edm::ParameterSet &)

	~MuonAssociatorEDProducer ()

Public Member Functions inherited from edm::stream::EDProducer<>
	EDProducer ()=default

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

ModuleDescription const &	moduleDescription () const

virtual	~EDProducerBase ()

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

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, std::unordered_multimap< std::string, edm::ProductResolverIndex > const &iIndicies, std::string const &moduleLabel)

virtual	~ProducerBase () noexcept(false)

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

	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 &	itemsToGetFromEvent () 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
virtual void	beginJob ()

virtual void	endJob ()

virtual void	produce (edm::Event &, const edm::EventSetup &)

Private Attributes
MuonAssociatorByHits *	associatorByHits

bool	ignoreMissingTrackCollection

edm::ParameterSet	parset_

edm::InputTag	tpTag

edm::EDGetTokenT < TrackingParticleCollection >	tpToken_

edm::InputTag	tracksTag

edm::EDGetTokenT< edm::View < reco::Track > >	tracksToken_

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

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

Public Types inherited from edm::ProducerBase
typedef ProductRegistryHelper::TypeLabelList	TypeLabelList

Public Types inherited from edm::EDConsumerBase
typedef ProductLabels	Labels

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

Definition at line 13 of file MuonAssociatorEDProducer.h.

Constructor & Destructor Documentation

MuonAssociatorEDProducer::MuonAssociatorEDProducer ( const edm::ParameterSet & parset )

explicit

Perform some sanity checks of the configuration

Definition at line 7 of file MuonAssociatorEDProducer.cc.

References edm::ParameterSet::addParameter(), associatorByHits, edm::EDConsumerBase::consumesCollector(), edm::ParameterSet::dump(), edm::ParameterSet::getParameter(), edm::InputTag::instance(), edm::InputTag::label(), LogTrace, parset_, AlCaHLTBitMon_QueryRunRegistry::string, tpTag, tpToken_, tracksTag, and tracksToken_.

                                                                                :
   tracksTag(parset.getParameter< edm::InputTag >("tracksTag")),
   tpTag(parset.getParameter< edm::InputTag >("tpTag")),
   ignoreMissingTrackCollection(parset.getUntrackedParameter<bool>("ignoreMissingTrackCollection",false)),
   parset_(parset)
 {
   
   edm::LogVerbatim("MuonAssociatorEDProducer") << "constructing  MuonAssociatorEDProducer";
   produces<reco::RecoToSimCollection>();
   produces<reco::SimToRecoCollection>();
   tpToken_=consumes<TrackingParticleCollection>(tpTag);
   tracksToken_=consumes<edm::View<reco::Track> >(tracksTag);
 
   LogTrace("MuonAssociatorEDProducer") << "constructing  MuonAssociatorByHits" << parset_.dump();
   edm::LogVerbatim("MuonAssociatorEDProducer") << "\n MuonAssociatorByHits will associate reco::Tracks with "<<tracksTag
                        << "\n\t\t and TrackingParticles with "<<tpTag;
   const std::string recoTracksLabel = tracksTag.label();
   const std::string recoTracksInstance = tracksTag.instance();
 
   // check and fix inconsistent input settings
   // tracks with hits only on muon detectors
   if (recoTracksLabel == "standAloneMuons" || recoTracksLabel == "standAloneSETMuons" ||
       recoTracksLabel == "cosmicMuons" || recoTracksLabel == "hltL2Muons") {
     if (parset_.getParameter<bool>("UseTracker")) {
       edm::LogWarning("MuonAssociatorEDProducer") 
     <<"\n*** WARNING : inconsistent input tracksTag = "<<tracksTag
     <<"\n with UseTracker = true"<<"\n ---> setting UseTracker = false ";
       parset_.addParameter<bool>("UseTracker",false);
     }
     if (!parset_.getParameter<bool>("UseMuon")) {
       edm::LogWarning("MuonAssociatorEDProducer") 
     <<"\n*** WARNING : inconsistent input tracksTag = "<<tracksTag
     <<"\n with UseMuon = false"<<"\n ---> setting UseMuon = true ";
       parset_.addParameter<bool>("UseMuon",true);
     }
   }
   // tracks with hits only on tracker
   if (recoTracksLabel == "generalTracks" || recoTracksLabel == "ctfWithMaterialTracksP5LHCNavigation" ||
       recoTracksLabel == "hltL3TkTracksFromL2" || 
       (recoTracksLabel == "hltL3Muons" && recoTracksInstance == "L2Seeded")) {
     if (parset_.getParameter<bool>("UseMuon")) {
       edm::LogWarning("MuonAssociatorEDProducer") 
     <<"\n*** WARNING : inconsistent input tracksTag = "<<tracksTag
     <<"\n with UseMuon = true"<<"\n ---> setting UseMuon = false ";
       parset_.addParameter<bool>("UseMuon",false);
     }
     if (!parset_.getParameter<bool>("UseTracker")) {
       edm::LogWarning("MuonAssociatorEDProducer") 
     <<"\n*** WARNING : inconsistent input tracksTag = "<<tracksTag
     <<"\n with UseTracker = false"<<"\n ---> setting UseTracker = true ";
       parset_.addParameter<bool>("UseTracker",true);
     }
   }
 
   LogTrace("MuonAssociatorEDProducer") << "MuonAssociatorEDProducer::beginJob : constructing MuonAssociatorByHits";
   associatorByHits = new MuonAssociatorByHits(parset_,consumesCollector());
 }

MuonAssociatorEDProducer::~MuonAssociatorEDProducer ( )

Definition at line 66 of file MuonAssociatorEDProducer.cc.

66 {}

Member Function Documentation

void MuonAssociatorEDProducer::beginJob ( void )

privatevirtual

Definition at line 68 of file MuonAssociatorEDProducer.cc.

68 {

69 }

void MuonAssociatorEDProducer::endJob ( void )

privatevirtual

Definition at line 71 of file MuonAssociatorEDProducer.cc.

71 {}

void MuonAssociatorEDProducer::produce	(	edm::Event &	event,
		const edm::EventSetup &	setup
	)

privatevirtual

Implements edm::stream::EDProducerBase.

Definition at line 73 of file MuonAssociatorEDProducer.cc.

References MuonAssociatorByHits::associateRecoToSim(), MuonAssociatorByHits::associateSimToReco(), associatorByHits, ignoreMissingTrackCollection, edm::InputTag::instance(), edm::InputTag::label(), LogTrace, eostools::move(), ecalTPGAnalyzer_cfg::TPCollection, tpTag, tpToken_, HLT_25ns10e33_v2_cff::trackCollection, tracksTag, and tracksToken_.

                                                                                   {
    using namespace edm;
 
    Handle<TrackingParticleCollection>  TPCollection ;
    LogTrace("MuonAssociatorEDProducer") <<"getting TrackingParticle collection - "<<tpTag;
    event.getByToken(tpToken_, TPCollection);
    LogTrace("MuonAssociatorEDProducer") <<"\t... size = "<<TPCollection->size();
 
    Handle<edm::View<reco::Track> > trackCollection;
    LogTrace("MuonAssociatorEDProducer") <<"getting reco::Track collection - "<<tracksTag;
    bool trackAvailable = event.getByToken (tracksToken_, trackCollection);
    if (trackAvailable) LogTrace("MuonAssociatorEDProducer") <<"\t... size = "<<trackCollection->size();
    else LogTrace("MuonAssociatorEDProducer") <<"\t... NOT FOUND.";
 
    std::unique_ptr<reco::RecoToSimCollection> rts;
    std::unique_ptr<reco::SimToRecoCollection> str;
 
    if (ignoreMissingTrackCollection && !trackAvailable) {
      //the track collection is not in the event and we're being told to ignore this.
      //do not output anything to the event, other wise this would be considered as inefficiency.
      LogTrace("MuonAssociatorEDProducer") << "\n ignoring missing track collection." << "\n";
    }   
    else {
      edm::LogVerbatim("MuonAssociatorEDProducer") 
        <<"\n >>> RecoToSim association <<< \n"
        <<"     Track collection : "
        <<tracksTag.label()<<":"<<tracksTag.instance()<<" (size = "<<trackCollection->size()<<") \n"
        <<"     TrackingParticle collection : "
        <<tpTag.label()<<":"<<tpTag.instance()<<" (size = "<<TPCollection->size()<<")";
      
      reco::RecoToSimCollection recSimColl = associatorByHits->associateRecoToSim(trackCollection,TPCollection,&event,&setup);
      
      edm::LogVerbatim("MuonAssociatorEDProducer") 
        <<"\n >>> SimToReco association <<< \n"
        <<"     TrackingParticle collection : "
        <<tpTag.label()<<":"<<tpTag.instance()<<" (size = "<<TPCollection->size()<<") \n"
        <<"     Track collection : "
        <<tracksTag.label()<<":"<<tracksTag.instance()<<" (size = "<<trackCollection->size()<<")";
      
      reco::SimToRecoCollection simRecColl = associatorByHits->associateSimToReco(trackCollection,TPCollection,&event,&setup);
      
      rts.reset(new reco::RecoToSimCollection(recSimColl));
      str.reset(new reco::SimToRecoCollection(simRecColl));
      
      event.put(std::move(rts));
      event.put(std::move(str));
    }
 }