MuonServiceProxy.cc

Go to the documentation of this file.

// Class Header
#include "RecoMuon/TrackingTools/interface/MuonServiceProxy.h"

// Service Records
#include "Geometry/Records/interface/GlobalTrackingGeometryRecord.h"
#include "MagneticField/Records/interface/IdealMagneticFieldRecord.h"
#include "RecoMuon/Records/interface/MuonRecoGeometryRecord.h"
#include "RecoMuon/Navigation/interface/MuonNavigationSchool.h"
#include "TrackingTools/Records/interface/TrackingComponentsRecord.h"

// Framework Headers
#include "FWCore/Framework/interface/EventSetup.h"
#include "FWCore/ParameterSet/interface/ParameterSet.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"

// C++ Headers
#include <map>

using namespace std;
using namespace edm;

// Constructor
MuonServiceProxy::MuonServiceProxy(const edm::ParameterSet& par)
    : 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;
}

// Destructor
MuonServiceProxy::~MuonServiceProxy() {
  // FIXME: how do that?
  // delete theTrackingGeometry;
  // delete theMGField;
  // delete theDetLayerGeometry;

  // FIXME: is it enough?
  thePropagators.clear();
  if (theSchool)
    delete theSchool;
}

// Operations

// update the services each event
void MuonServiceProxy::update(const edm::EventSetup& setup) {
  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;
}

// get the propagator
ESHandle<Propagator> MuonServiceProxy::propagator(std::string propagatorName) const {
  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;
}