#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

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

virtual void	endJob ()

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

Private Attributes
MuonAssociatorByHits *	associatorByHits

bool	ignoreMissingTrackCollection

edm::ParameterSet	parset_

bool	tpRefVector

edm::EDGetTokenT < TrackingParticleRefVector >	tpRefVectorToken_

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

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::ParameterSet::dump(), edm::ParameterSet::getParameter(), edm::InputTag::label(), LogTrace, parset_, AlCaHLTBitMon_QueryRunRegistry::string, tpRefVector, tpRefVectorToken_, tpTag, tpToken_, tracksTag, and tracksToken_.

     : tracksTag(parset.getParameter<edm::InputTag>("tracksTag")),
       tpTag(parset.getParameter<edm::InputTag>("tpTag")),
       tpRefVector(parset.getParameter<bool>("tpRefVector")),
       ignoreMissingTrackCollection(parset.getUntrackedParameter<bool>("ignoreMissingTrackCollection", false)),
       parset_(parset) {
   edm::LogVerbatim("MuonAssociatorEDProducer") << "constructing  MuonAssociatorEDProducer";
   produces<reco::RecoToSimCollection>();
   produces<reco::SimToRecoCollection>();
   if (tpRefVector)
     tpRefVectorToken_ = consumes<TrackingParticleRefVector>(tpTag);
   else
     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();
 
   // check and fix inconsistent input settings
   // tracks with hits only on muon detectors
   if (recoTracksLabel == "seedsOfSTAmuons" || recoTracksLabel == "standAloneMuons" ||
       recoTracksLabel == "refittedStandAloneMuons" || recoTracksLabel == "seedsOfDisplacedSTAmuons" ||
       recoTracksLabel == "displacedStandAloneMuons" || recoTracksLabel == "cosmicMuons" ||
       recoTracksLabel == "cosmicMuons1Leg" || 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 == "probeTracks" || recoTracksLabel == "displacedTracks" ||
       recoTracksLabel == "extractGemMuons" || recoTracksLabel == "extractMe0Muons" ||
       recoTracksLabel == "ctfWithMaterialTracksP5LHCNavigation" || recoTracksLabel == "ctfWithMaterialTracksP5" ||
       recoTracksLabel == "hltIterL3OIMuonTrackSelectionHighPurity" || recoTracksLabel == "hltIterL3MuonMerged" ||
       recoTracksLabel == "hltIterL3MuonAndMuonFromL1Merged") {
     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 ( )

override

Definition at line 72 of file MuonAssociatorEDProducer.cc.

72 {}

Member Function Documentation

void MuonAssociatorEDProducer::beginJob ( void )

privatevirtual

Definition at line 74 of file MuonAssociatorEDProducer.cc.

74 {}

void MuonAssociatorEDProducer::endJob ( void )

privatevirtual

Definition at line 76 of file MuonAssociatorEDProducer.cc.

76 {}

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

overrideprivate

Definition at line 78 of file MuonAssociatorEDProducer.cc.

References MuonAssociatorByHits::associateRecoToSim(), MuonAssociatorByHits::associateSimToReco(), associatorByHits, mps_fire::i, ignoreMissingTrackCollection, edm::InputTag::instance(), edm::InputTag::label(), LogTrace, eostools::move(), edm::Handle< T >::product(), edm::RefToBaseVector< T >::push_back(), str, ecalTPGAnalyzer_cfg::TPCollection, tpRefVector, tpRefVectorToken_, tpTag, tpToken_, HLT_FULL_cff::trackCollection, tracksTag, and tracksToken_.

                                                                                   {
   using namespace edm;
 
   TrackingParticleRefVector tmpTP;
   const TrackingParticleRefVector *tmpTPptr = nullptr;
   Handle<TrackingParticleCollection> TPCollection;
   Handle<TrackingParticleRefVector> TPCollectionRefVector;
 
   if (tpRefVector) {
     event.getByToken(tpRefVectorToken_, TPCollectionRefVector);
     tmpTPptr = TPCollectionRefVector.product();
     //
     tmpTP = *tmpTPptr;
   } else {
     event.getByToken(tpToken_, TPCollection);
     size_t nTP = TPCollection->size();
     for (size_t i = 0; i < nTP; ++i) {
       tmpTP.push_back(TrackingParticleRef(TPCollection, i));
     }
     tmpTPptr = &tmpTP;
   }
 
   LogTrace("MuonAssociatorEDProducer") << "getting TrackingParticle collection - " << tpTag;
   LogTrace("MuonAssociatorEDProducer") << "\t... size = " << tmpTPptr->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::RefToBaseVector<reco::Track> tmpT;
     for (size_t i = 0; i < trackCollection->size(); ++i)
       tmpT.push_back(trackCollection->refAt(i));
 
     edm::LogVerbatim("MuonAssociatorEDProducer")
         << "\n >>> RecoToSim association <<< \n"
         << "     Track collection : " << tracksTag.label() << ":" << tracksTag.instance()
         << " (size = " << trackCollection->size() << ") \n"
         << "     TrackingParticle collection : " << tpTag.label() << ":" << tpTag.instance()
         << " (size = " << tmpTPptr->size() << ")";
 
     reco::RecoToSimCollection recSimColl = associatorByHits->associateRecoToSim(tmpT, tmpTP, &event, &setup);
 
     edm::LogVerbatim("MuonAssociatorEDProducer")
         << "\n >>> SimToReco association <<< \n"
         << "     TrackingParticle collection : " << tpTag.label() << ":" << tpTag.instance()
         << " (size = " << tmpTPptr->size() << ") \n"
         << "     Track collection : " << tracksTag.label() << ":" << tracksTag.instance()
         << " (size = " << trackCollection->size() << ")";
 
     reco::SimToRecoCollection simRecColl = associatorByHits->associateSimToReco(tmpT, tmpTP, &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));
   }
 }