MuonAssociatorEDProducer Class Reference

#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::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::~MuonAssociatorEDProducer ( )

override

Definition at line 72 of file MuonAssociatorEDProducer.cc.

{}

Member Function Documentation

beginJob()

void MuonAssociatorEDProducer::beginJob ( void  )

privatevirtual

Definition at line 74 of file MuonAssociatorEDProducer.cc.

{}

endJob()

void MuonAssociatorEDProducer::endJob ( void  )

privatevirtual

Definition at line 76 of file MuonAssociatorEDProducer.cc.

{}

produce()

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(), edm::RefVector< C, T, F >::push_back(), singleTopDQM_cfi::setup, edm::RefVector< C, T, F >::size(), str, tpRefVector, tpRefVectorToken_, tpTag, tpToken_, JetHT_cfg::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));
  }
}

Member Data Documentation

associatorByHits

MuonAssociatorByHits* MuonAssociatorEDProducer::associatorByHits

private

Definition at line 32 of file MuonAssociatorEDProducer.h.

Referenced by MuonAssociatorEDProducer(), and produce().

ignoreMissingTrackCollection

bool MuonAssociatorEDProducer::ignoreMissingTrackCollection

private

Definition at line 30 of file MuonAssociatorEDProducer.h.

Referenced by produce().

parset_

edm::ParameterSet MuonAssociatorEDProducer::parset_

private

Definition at line 31 of file MuonAssociatorEDProducer.h.

Referenced by MuonAssociatorEDProducer().

tpRefVector

bool MuonAssociatorEDProducer::tpRefVector

private

Definition at line 29 of file MuonAssociatorEDProducer.h.

Referenced by MuonAssociatorEDProducer(), and produce().

tpRefVectorToken_

edm::EDGetTokenT<TrackingParticleRefVector> MuonAssociatorEDProducer::tpRefVectorToken_

private

Definition at line 26 of file MuonAssociatorEDProducer.h.

Referenced by MuonAssociatorEDProducer(), and produce().

tpTag

edm::InputTag MuonAssociatorEDProducer::tpTag

private

Definition at line 24 of file MuonAssociatorEDProducer.h.

Referenced by MuonAssociatorEDProducer(), and produce().

tpToken_

edm::EDGetTokenT<TrackingParticleCollection> MuonAssociatorEDProducer::tpToken_

private

Definition at line 25 of file MuonAssociatorEDProducer.h.

Referenced by MuonAssociatorEDProducer(), and produce().

tracksTag

edm::InputTag MuonAssociatorEDProducer::tracksTag

private

Definition at line 23 of file MuonAssociatorEDProducer.h.

Referenced by MuonAssociatorEDProducer(), and produce().

tracksToken_

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

private

Definition at line 27 of file MuonAssociatorEDProducer.h.

Referenced by MuonAssociatorEDProducer(), and produce().