#include <MuonAssociatorEDProducer.h>

Inheritance diagram for MuonAssociatorEDProducer:

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

	~MuonAssociatorEDProducer () override

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

bool	hasAbilityToProduceInBeginLumis () const final

bool	hasAbilityToProduceInBeginProcessBlocks () const final

bool	hasAbilityToProduceInBeginRuns () const final

bool	hasAbilityToProduceInEndLumis () const final

bool	hasAbilityToProduceInEndProcessBlocks () const final

bool	hasAbilityToProduceInEndRuns () const final

Private Member Functions
virtual void	beginJob ()

virtual void	endJob ()

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

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

Detailed Description

Definition at line 13 of file MuonAssociatorEDProducer.h.

Constructor & Destructor Documentation

◆ MuonAssociatorEDProducer()

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

explicit

Perform some sanity checks of the configuration

Definition at line 7 of file MuonAssociatorEDProducer.cc.

     : 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());
 }

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

◆ ~MuonAssociatorEDProducer()

MuonAssociatorEDProducer::~MuonAssociatorEDProducer ( )

override

Definition at line 65 of file MuonAssociatorEDProducer.cc.

65 {}

Member Function Documentation

◆ beginJob()

void MuonAssociatorEDProducer::beginJob ( void )

privatevirtual

Definition at line 67 of file MuonAssociatorEDProducer.cc.

67 {}

◆ endJob()

void MuonAssociatorEDProducer::endJob ( void )

privatevirtual

Definition at line 69 of file MuonAssociatorEDProducer.cc.

69 {}

◆ produce()

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

overrideprivate

Definition at line 71 of file MuonAssociatorEDProducer.cc.

                                                                                   {
   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 = std::make_unique<reco::RecoToSimCollection>(recSimColl);
     str = std::make_unique<reco::SimToRecoCollection>(simRecColl);
  
     event.put(std::move(rts));
     event.put(std::move(str));
   }
 }