#include <MuonServiceProxy.h>

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

const edm::EventSetup &	eventSetup () const
	get the whole EventSetup More...

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 &par)
	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)
	update the services each event More...

virtual	~MuonServiceProxy ()
	Destructor. More...

Private Types
typedef std::map< std::string, edm::ESHandle< Propagator > >	propagators

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

propagators	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 30 of file MuonServiceProxy.h.

Member Typedef Documentation

typedef std::map<std::string, edm::ESHandle<Propagator> > MuonServiceProxy::propagators

private

Definition at line 65 of file MuonServiceProxy.h.

Constructor & Destructor Documentation

MuonServiceProxy::MuonServiceProxy ( const edm::ParameterSet & par )

Constructor.

Definition at line 36 of file MuonServiceProxy.cc.

References edm::ParameterSet::existsAs(), edm::ParameterSet::getParameter(), edm::ParameterSet::getUntrackedParameter(), LogDebug, HLT_2018_cff::propagatorName, theCacheId_DG, theCacheId_GTG, theCacheId_MG, theCacheId_P, theChangeInTrackingComponentsRecord, theCSCLayer, theGEMLayer, theME0Layer, theMuonNavigationFlag, thePropagators, and theRPCLayer.

     : theTrackingGeometry(nullptr),
       theMGField(nullptr),
       theDetLayerGeometry(nullptr),
       theEventSetup(nullptr),
       theSchool(nullptr) {
   // load the propagators map
   vector<string> noPropagators;
   vector<string> propagatorNames;
 
   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;
   }
 
   propagatorNames = par.getUntrackedParameter<vector<string> >("Propagators", noPropagators);
 
   if (propagatorNames.empty())
     LogDebug("Muon|RecoMuon|MuonServiceProxy") << "NO propagator(s) selected!";
 
   for (vector<string>::iterator propagatorName = propagatorNames.begin(); propagatorName != propagatorNames.end();
        ++propagatorName)
     thePropagators[*propagatorName] = ESHandle<Propagator>(nullptr);
 
   theCacheId_GTG = 0;
   theCacheId_MG = 0;
   theCacheId_DG = 0;
   theCacheId_P = 0;
   theChangeInTrackingComponentsRecord = false;
 }

MuonServiceProxy::~MuonServiceProxy ( )

virtual

Destructor.

Definition at line 90 of file MuonServiceProxy.cc.

References thePropagators, and theSchool.

                                     {
   // FIXME: how do that?
   // delete theTrackingGeometry;
   // delete theMGField;
   // delete theDetLayerGeometry;
 
   // FIXME: is it enough?
   thePropagators.clear();
   if (theSchool)
     delete theSchool;
 }

Member Function Documentation

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

inline

get the detLayer geometry

Definition at line 50 of file MuonServiceProxy.h.

References TrackCandidateProducer_cfi::propagator, HLT_2018_cff::propagatorName, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by MuonSimHitProducer::produce().

50 { return theDetLayerGeometry; }

MuonServiceProxy::theDetLayerGeometry

edm::ESHandle< MuonDetLayerGeometry > theDetLayerGeometry

Definition: MuonServiceProxy.h:69

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

inline

get the whole EventSetup

Definition at line 56 of file MuonServiceProxy.h.

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

56 { return *theEventSetup; }

MuonServiceProxy::theEventSetup

const edm::EventSetup * theEventSetup

Definition: MuonServiceProxy.h:70

bool MuonServiceProxy::isTrackingComponentsRecordChanged ( ) const

inline

check if the MuonReco Geometry has been changed

Definition at line 59 of file MuonServiceProxy.h.

59 { return theChangeInTrackingComponentsRecord; }

MuonServiceProxy::theChangeInTrackingComponentsRecord

bool theChangeInTrackingComponentsRecord

Definition: MuonServiceProxy.h:85

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

inline

get the magnetic field

Definition at line 44 of file MuonServiceProxy.h.

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

44 { return theMGField; }

MuonServiceProxy::theMGField

edm::ESHandle< MagneticField > theMGField

Definition: MuonServiceProxy.h:68

const MuonNavigationSchool* MuonServiceProxy::muonNavigationSchool ( ) const

inline

Definition at line 61 of file MuonServiceProxy.h.

61 { return theSchool; }

MuonServiceProxy::theSchool

const MuonNavigationSchool * theSchool

Definition: MuonServiceProxy.h:76

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

get the propagator

Definition at line 154 of file MuonServiceProxy.cc.

References thePropagators.

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

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

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

inline

get the tracking geometry

Definition at line 47 of file MuonServiceProxy.h.

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().

47 { return theTrackingGeometry; }

MuonServiceProxy::theTrackingGeometry

edm::ESHandle< GlobalTrackingGeometry > theTrackingGeometry

Definition: MuonServiceProxy.h:67

void MuonServiceProxy::update ( const edm::EventSetup & setup )

update the services each event

Definition at line 105 of file MuonServiceProxy.cc.

References edm::EventSetup::get(), edm::eventsetup::DependentRecordImplementation< RecordT, ListT >::get(), LogTrace, metname, singleTopDQM_cfi::setup, AlCaHLTBitMon_QueryRunRegistry::string, theCacheId_DG, theCacheId_GTG, theCacheId_MG, theCacheId_P, theChangeInTrackingComponentsRecord, theCSCLayer, theDetLayerGeometry, theEventSetup, theGEMLayer, theME0Layer, theMGField, theMuonNavigationFlag, thePropagators, theRPCLayer, theSchool, and theTrackingGeometry.

Referenced by progressbar.ProgressBar::__next__(), MatrixUtil.Matrix::__setitem__(), MatrixUtil.Steps::__setitem__(), ResidualRefitting::analyze(), Vispa.Gui.VispaWidget.VispaWidget::autosize(), MuonSimHitProducer::beginRun(), Vispa.Views.LineDecayView.LineDecayContainer::createObject(), Vispa.Views.LineDecayView.LineDecayContainer::deselectAllObjects(), Vispa.Gui.VispaWidgetOwner.VispaWidgetOwner::deselectAllWidgets(), Vispa.Gui.VispaWidget.VispaWidget::enableAutosizing(), AlignmentMonitorTracksFromTrajectories::event(), progressbar.ProgressBar::finish(), Vispa.Gui.MenuWidget.MenuWidget::leaveEvent(), Vispa.Gui.VispaWidgetOwner.VispaWidgetOwner::mouseMoveEvent(), Vispa.Gui.MenuWidget.MenuWidget::mouseMoveEvent(), Vispa.Views.LineDecayView.LineDecayContainer::mouseMoveEvent(), Vispa.Gui.VispaWidgetOwner.VispaWidgetOwner::mouseReleaseEvent(), Vispa.Views.LineDecayView.LineDecayContainer::objectMoved(), MatrixUtil.Steps::overwrite(), GlobalCosmicMuonProducer::produce(), GlobalTrackQualityProducer::produce(), HIMuonTrackingRegionProducer::regions(), Vispa.Views.LineDecayView.LineDecayContainer::removeObject(), Vispa.Gui.ConnectableWidget.ConnectableWidget::removePorts(), Vispa.Gui.FindDialog.FindDialog::reset(), MuonSeedCleaner::seedCleaner(), Vispa.Gui.PortConnection.PointToPointConnection::select(), Vispa.Gui.VispaWidget.VispaWidget::select(), Vispa.Views.LineDecayView.LineDecayContainer::select(), Vispa.Gui.VispaWidget.VispaWidget::setText(), Vispa.Gui.VispaWidget.VispaWidget::setTitle(), Vispa.Gui.ZoomableWidget.ZoomableWidget::setZoom(), Vispa.Views.LineDecayView.LineDecayContainer::setZoom(), and Vispa.Gui.PortConnection.PointToPointConnection::updateConnection().

                                                         {
   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;
     setup.get<GlobalTrackingGeometryRecord>().get(theTrackingGeometry);
   }
 
   // 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;
     setup.get<IdealMagneticFieldRecord>().get(theMGField);
   }
 
   // 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;
     setup.get<MuonRecoGeometryRecord>().get(theDetLayerGeometry);
     // 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 (propagators::iterator prop = thePropagators.begin(); prop != thePropagators.end(); ++prop)
       setup.get<TrackingComponentsRecord>().get(prop->first, prop->second);
   } else
     theChangeInTrackingComponentsRecord = false;
 }