#include <MuonServiceProxy.h>

Classes
class	PropagatorInfo

Public Types
enum	UseEventSetupIn { UseEventSetupIn::Run, UseEventSetupIn::Event, UseEventSetupIn::RunAndEvent }

Public Member Functions
edm::ESHandle< MuonDetLayerGeometry >	detLayerGeometry () const
	get the detLayer geometry More...

const edm::EventSetup &	eventSetup () const

bool	isTrackingComponentsRecordChanged () const
	check if the MuonReco Geometry has been changed More...

edm::ESHandle< MagneticField >	magneticField () const
	get the magnetic field More...

const MuonNavigationSchool *	muonNavigationSchool () const

	MuonServiceProxy (const edm::ParameterSet &, edm::ConsumesCollector &&, UseEventSetupIn useEventSetupIn=UseEventSetupIn::Event)
	Constructor. More...

edm::ESHandle< Propagator >	propagator (std::string propagatorName) const
	get the propagator More...

edm::ESHandle< GlobalTrackingGeometry >	trackingGeometry () const
	get the tracking geometry More...

void	update (const edm::EventSetup &setup, bool duringEvent=true)
	update the services each event More...

virtual	~MuonServiceProxy ()
	Destructor. More...

Private Types
using	PropagatorMap = std::map< std::string, PropagatorInfo >

Private Attributes
edm::ESGetToken< GlobalTrackingGeometry, GlobalTrackingGeometryRecord >	globalTrackingGeometryEventToken_

edm::ESGetToken< GlobalTrackingGeometry, GlobalTrackingGeometryRecord >	globalTrackingGeometryRunToken_

edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	magneticFieldEventToken_

edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	magneticFieldRunToken_

edm::ESGetToken< MuonDetLayerGeometry, MuonRecoGeometryRecord >	muonDetLayerGeometryEventToken_

edm::ESGetToken< MuonDetLayerGeometry, MuonRecoGeometryRecord >	muonDetLayerGeometryRunToken_

unsigned long long	theCacheId_DG

unsigned long long	theCacheId_GTG

unsigned long long	theCacheId_MG

unsigned long long	theCacheId_P

bool	theChangeInTrackingComponentsRecord

bool	theCSCLayer

edm::ESHandle< MuonDetLayerGeometry >	theDetLayerGeometry

const edm::EventSetup *	theEventSetup

bool	theGEMLayer

bool	theME0Layer

edm::ESHandle< MagneticField >	theMGField

bool	theMuonNavigationFlag

PropagatorMap	thePropagators

bool	theRPCLayer

const MuonNavigationSchool *	theSchool

edm::ESHandle< GlobalTrackingGeometry >	theTrackingGeometry

Detailed Description

Class to handle the services needed by the muon reconstruction This class avoid the EventSetup percolation. The update method is called each event in order to update the pointers.

Author: N. Amapane - CERN nicol.nosp@m.a.am.nosp@m.apane.nosp@m.@cer.nosp@m.n.ch; R. Bellan - INFN Torino ricca.nosp@m.rdo..nosp@m.bella.nosp@m.n@ce.nosp@m.rn.ch

Modified by C. Calabria Modified by D. Nash

Class to handle the services needed by the muon reconstruction This class avoid the EventSetup percolation. The update method is called each event in order to update the pointers.

Author: N. Amapane - CERN nicol.nosp@m.a.am.nosp@m.apane.nosp@m.@cer.nosp@m.n.ch; R. Bellan - INFN Torino ricca.nosp@m.rdo..nosp@m.bella.nosp@m.n@ce.nosp@m.rn.ch

Modified by C. Calabria & A. Sharma Modified by D. Nash

Definition at line 38 of file MuonServiceProxy.h.

Member Typedef Documentation

◆ PropagatorMap

using MuonServiceProxy::PropagatorMap = std::map<std::string, PropagatorInfo>

private

Definition at line 91 of file MuonServiceProxy.h.

Member Enumeration Documentation

◆ UseEventSetupIn

enum MuonServiceProxy::UseEventSetupIn

strong

Enumerator
Run
Event
RunAndEvent

Definition at line 40 of file MuonServiceProxy.h.

40 { Run, Event, RunAndEvent };

Constructor & Destructor Documentation

◆ MuonServiceProxy()

MuonServiceProxy::MuonServiceProxy	(	const edm::ParameterSet &	par,
		edm::ConsumesCollector &&	iC,
		UseEventSetupIn	useEventSetupIn = `UseEventSetupIn::Event`
	)

Constructor.

Definition at line 27 of file MuonServiceProxy.cc.

     : theTrackingGeometry(nullptr),
       theMGField(nullptr),
       theDetLayerGeometry(nullptr),
       theEventSetup(nullptr),
       theSchool(nullptr) {
   theMuonNavigationFlag = par.getUntrackedParameter<bool>("UseMuonNavigation", true);
  
   if (theMuonNavigationFlag) {
     theRPCLayer = par.getParameter<bool>("RPCLayers");
  
     if (par.existsAs<bool>("CSCLayers"))
       theCSCLayer = par.getParameter<bool>("CSCLayers");
     else
       theCSCLayer = true;
  
     if (par.existsAs<bool>("GEMLayers"))
       theGEMLayer = par.getParameter<bool>("GEMLayers");
     else
       theGEMLayer = false;
  
     if (par.existsAs<bool>("ME0Layers"))
       theME0Layer = par.getParameter<bool>("ME0Layers");
     else
       theME0Layer = false;
  
   } else {
     theRPCLayer = true;
     theCSCLayer = true;
     theGEMLayer = true;
     theME0Layer = true;
   }
  
   // load the propagators map
   std::vector<std::string> noPropagators;
   std::vector<std::string> propagatorNames =
       par.getUntrackedParameter<std::vector<std::string>>("Propagators", noPropagators);
  
   if (propagatorNames.empty())
     LogDebug("Muon|RecoMuon|MuonServiceProxy") << "NO propagator(s) selected!";
  
   for (auto const& propagatorName : propagatorNames) {
     thePropagators[propagatorName] = PropagatorInfo();
   }
   theCacheId_GTG = 0;
   theCacheId_MG = 0;
   theCacheId_DG = 0;
   theCacheId_P = 0;
   theChangeInTrackingComponentsRecord = false;
  
   // Declare the products we get from the EventSetup and initialize the tokens used to get them
   if (useEventSetupIn == UseEventSetupIn::Event || useEventSetupIn == UseEventSetupIn::RunAndEvent) {
     globalTrackingGeometryEventToken_ = iC.esConsumes<GlobalTrackingGeometry, GlobalTrackingGeometryRecord>();
     magneticFieldEventToken_ = iC.esConsumes<MagneticField, IdealMagneticFieldRecord>();
     muonDetLayerGeometryEventToken_ = iC.esConsumes<MuonDetLayerGeometry, MuonRecoGeometryRecord>();
     for (auto& element : thePropagators) {
       element.second.eventToken_ =
           iC.esConsumes<Propagator, TrackingComponentsRecord>(edm::ESInputTag("", element.first));
     }
   }
   if (useEventSetupIn == UseEventSetupIn::Run || useEventSetupIn == UseEventSetupIn::RunAndEvent) {
     globalTrackingGeometryRunToken_ =
         iC.esConsumes<GlobalTrackingGeometry, GlobalTrackingGeometryRecord, edm::Transition::BeginRun>();
     magneticFieldRunToken_ = iC.esConsumes<MagneticField, IdealMagneticFieldRecord, edm::Transition::BeginRun>();
     muonDetLayerGeometryRunToken_ =
         iC.esConsumes<MuonDetLayerGeometry, MuonRecoGeometryRecord, edm::Transition::BeginRun>();
     for (auto& element : thePropagators) {
       element.second.runToken_ = iC.esConsumes<Propagator, TrackingComponentsRecord, edm::Transition::BeginRun>(
           edm::ESInputTag("", element.first));
     }
   }
 }

References edm::BeginRun, Event, edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), globalTrackingGeometryEventToken_, globalTrackingGeometryRunToken_, LogDebug, SiStripFineDelayHit_cfi::MagneticField, magneticFieldEventToken_, magneticFieldRunToken_, muonDetLayerGeometryEventToken_, muonDetLayerGeometryRunToken_, LaserSeedGenerator_cfi::Propagator, HLT_2018_cff::propagatorName, Run, RunAndEvent, theCacheId_DG, theCacheId_GTG, theCacheId_MG, theCacheId_P, theChangeInTrackingComponentsRecord, theCSCLayer, theGEMLayer, theME0Layer, theMuonNavigationFlag, thePropagators, and theRPCLayer.

◆ ~MuonServiceProxy()

MuonServiceProxy::~MuonServiceProxy ( )

virtual

Destructor.

Definition at line 103 of file MuonServiceProxy.cc.

                                     {
   if (theSchool)
     delete theSchool;
 }

References theSchool.

Member Function Documentation

◆ detLayerGeometry()

edm::ESHandle<MuonDetLayerGeometry> MuonServiceProxy::detLayerGeometry ( ) const

inline

get the detLayer geometry

Definition at line 62 of file MuonServiceProxy.h.

62 { return theDetLayerGeometry; }

References theDetLayerGeometry.

Referenced by MuonSimHitProducer::produce().

◆ eventSetup()

const edm::EventSetup& MuonServiceProxy::eventSetup ( ) const

inline

get the whole EventSetup (Note: this is a dangerous function. I would delete it if modules were not using it. If this function is called for an event where the function 'update' was not called, then the pointer stored in 'theEventSetup' will point to an object that no longer exists even if all the ESHandles are still valid! Be careful. As long as 'update' is called every event and this is only used while processing that single corresponding event, it will work OK... This function also makes it difficult to examine code in a module and understand which parts of a module use the EventSetup to get data.)

Definition at line 76 of file MuonServiceProxy.h.

76 { return *theEventSetup; }

References theEventSetup.

Referenced by TSGFromPropagation::init(), GlobalTrackQualityProducer::produce(), TSGFromPropagation::setEvent(), TSGForRoadSearch::setEvent(), GlobalTrajectoryBuilderBase::setEvent(), and TrackerSeedGenerator::trackerSeeds().

◆ isTrackingComponentsRecordChanged()

bool MuonServiceProxy::isTrackingComponentsRecordChanged ( ) const

inline

check if the MuonReco Geometry has been changed

Definition at line 79 of file MuonServiceProxy.h.

79 { return theChangeInTrackingComponentsRecord; }

References theChangeInTrackingComponentsRecord.

◆ magneticField()

edm::ESHandle<MagneticField> MuonServiceProxy::magneticField ( ) const

inline

get the magnetic field

Definition at line 56 of file MuonServiceProxy.h.

56 { return theMGField; }

References theMGField.

Referenced by GlobalTrajectoryBuilderBase::build(), GlobalTrajectoryBuilderBase::getTransientRecHits(), TSGFromPropagation::innerState(), TSGForRoadSearch::IPfts(), TSGFromPropagation::outerTkState(), MuonSeedCleaner::SeedMomentum(), and MuonSeedCleaner::SeedPosition().

◆ muonNavigationSchool()

const MuonNavigationSchool* MuonServiceProxy::muonNavigationSchool ( ) const

inline

Definition at line 81 of file MuonServiceProxy.h.

81 { return theSchool; }

References theSchool.

◆ propagator()

edm::ESHandle< Propagator > MuonServiceProxy::propagator ( std::string propagatorName ) const

get the propagator

Definition at line 177 of file MuonServiceProxy.cc.

                                                                                    {
   PropagatorMap::const_iterator prop = thePropagators.find(propagatorName);
  
   if (prop == thePropagators.end()) {
     edm::LogError("Muon|RecoMuon|MuonServiceProxy") << "MuonServiceProxy: propagator with name: " << propagatorName
                                                     << " not found! Please load it in the MuonServiceProxy.cff";
     return edm::ESHandle<Propagator>(nullptr);
   }
   return prop->second.esHandle_;
 }

References HLT_2018_cff::propagatorName, and thePropagators.

Referenced by MuonSimHitProducer::beginRun(), GlobalTrajectoryBuilderBase::getTransientRecHits(), TSGForRoadSearch::makeSeeds_0(), TSGForRoadSearch::makeSeeds_3(), TSGForRoadSearch::makeSeeds_4(), TSGFromPropagation::outerTkState(), CosmicMuonTrajectoryBuilder::propagator(), GlobalCosmicMuonTrajectoryBuilder::propagator(), TSGFromPropagation::propagator(), FastTSGFromPropagation::propagator(), CosmicMuonSmoother::propagatorAlong(), CosmicMuonTrajectoryBuilder::propagatorAlong(), CosmicMuonSmoother::propagatorOpposite(), CosmicMuonTrajectoryBuilder::propagatorOpposite(), and TSGForRoadSearch::pushTrajectorySeed().

◆ trackingGeometry()

edm::ESHandle<GlobalTrackingGeometry> MuonServiceProxy::trackingGeometry ( ) const

inline

get the tracking geometry

Definition at line 59 of file MuonServiceProxy.h.

59 { return theTrackingGeometry; }

References theTrackingGeometry.

Referenced by GlobalTrajectoryBuilderBase::build(), ResidualRefitting::CollectTrackHits(), GlobalTrajectoryBuilderBase::getTransientRecHits(), TSGFromPropagation::innerState(), MuonCosmicCompatibilityFiller::isOverlappingMuon(), MuonSeedCleaner::NChi2OfSegment(), ResidualRefitting::NewTrackMeasurements(), MuonSeedCleaner::NRecHitsFromSegment(), MuonSeedCleaner::OverlapSegments(), MuonSeedCleaner::SeedCandidates(), MuonSeedCleaner::SeedMomentum(), MuonSeedCleaner::SeedPosition(), ExhaustiveMuonTrajectoryBuilder::trajectories(), and ResidualRefitting::trkExtrap().

◆ update()

void MuonServiceProxy::update	(	const edm::EventSetup &	setup,
		bool	duringEvent = `true`
	)

update the services each event

Definition at line 111 of file MuonServiceProxy.cc.

                                                                           {
   const std::string metname = "Muon|RecoMuon|MuonServiceProxy";
  
   theEventSetup = &setup;
  
   // Global Tracking Geometry
   unsigned long long newCacheId_GTG = setup.get<GlobalTrackingGeometryRecord>().cacheIdentifier();
   if (newCacheId_GTG != theCacheId_GTG) {
     LogTrace(metname) << "GlobalTrackingGeometry changed!";
     theCacheId_GTG = newCacheId_GTG;
     if (duringEvent) {
       theTrackingGeometry = setup.getHandle(globalTrackingGeometryEventToken_);
     } else {
       theTrackingGeometry = setup.getHandle(globalTrackingGeometryRunToken_);
     }
   }
  
   // Magfield Field
   unsigned long long newCacheId_MG = setup.get<IdealMagneticFieldRecord>().cacheIdentifier();
   if (newCacheId_MG != theCacheId_MG) {
     LogTrace(metname) << "Magnetic Field changed!";
     theCacheId_MG = newCacheId_MG;
     if (duringEvent) {
       theMGField = setup.getHandle(magneticFieldEventToken_);
     } else {
       theMGField = setup.getHandle(magneticFieldRunToken_);
     }
   }
  
   // DetLayer Geometry
   unsigned long long newCacheId_DG = setup.get<MuonRecoGeometryRecord>().cacheIdentifier();
   if (newCacheId_DG != theCacheId_DG) {
     LogTrace(metname) << "Muon Reco Geometry changed!";
     theCacheId_DG = newCacheId_DG;
     if (duringEvent) {
       theDetLayerGeometry = setup.getHandle(muonDetLayerGeometryEventToken_);
     } else {
       theDetLayerGeometry = setup.getHandle(muonDetLayerGeometryRunToken_);
     }
     // MuonNavigationSchool should live until its validity expires, and then DELETE
     // the NavigableLayers (this is implemented in MuonNavigationSchool's dtor)
     if (theMuonNavigationFlag) {
       if (theSchool)
         delete theSchool;
       theSchool = new MuonNavigationSchool(&*theDetLayerGeometry, theRPCLayer, theCSCLayer, theGEMLayer, theME0Layer);
     }
   }
  
   // Propagators
   unsigned long long newCacheId_P = setup.get<TrackingComponentsRecord>().cacheIdentifier();
   if (newCacheId_P != theCacheId_P) {
     LogTrace(metname) << "Tracking Component changed!";
     theChangeInTrackingComponentsRecord = true;
     theCacheId_P = newCacheId_P;
     for (auto& element : thePropagators) {
       if (duringEvent) {
         element.second.esHandle_ = setup.getHandle(element.second.eventToken_);
       } else {
         element.second.esHandle_ = setup.getHandle(element.second.runToken_);
       }
     }
   } else
     theChangeInTrackingComponentsRecord = false;
 }