#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	hasAbilityToProduceInLumis () const final

bool	hasAbilityToProduceInRuns () 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 ( 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::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 ( )

override

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
	)

overrideprivate

Definition at line 73 of file MuonAssociatorEDProducer.cc.

References MuonAssociatorByHits::associateRecoToSim(), MuonAssociatorByHits::associateSimToReco(), associatorByHits, ignoreMissingTrackCollection, edm::InputTag::instance(), edm::InputTag::label(), LogTrace, eostools::move(), str, tpTag, tpToken_, findElectronsInSiStrips_cfi::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));
    }
 }