TrackerToMuonPropagator Class Reference

#include <Alignment/TrackerToMuonPropagator/src/TrackerToMuonPropagator.cc>

Inheritance diagram for TrackerToMuonPropagator:

Public Member Functions
	TrackerToMuonPropagator (const edm::ParameterSet &)
	~TrackerToMuonPropagator () 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
void	produce (edm::Event &, const edm::EventSetup &) override

Private Attributes
const edm::ESGetToken< CSCGeometry, MuonGeometryRecord >	m_esTokenCSC
const edm::ESGetToken< DTGeometry, MuonGeometryRecord >	m_esTokenDT
const edm::ESGetToken< GlobalTrackingGeometry, GlobalTrackingGeometryRecord >	m_esTokenGTGeo
const edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	m_esTokenMF
const edm::ESGetToken< Propagator, TrackingComponentsRecord >	m_esTokenProp
const edm::ESGetToken< TrackerGeometry, TrackerDigiGeometryRecord >	m_esTokenTk
edm::InputTag	m_globalMuons
edm::InputTag	m_globalMuonTracks
bool	m_refitTracker
TrackTransformer *	m_trackTransformer

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

Description: <one line="" class="" summary>="">

Implementation: <Notes on="" implementation>="">

Definition at line 63 of file TrackerToMuonPropagator.cc.

Constructor & Destructor Documentation

TrackerToMuonPropagator()

TrackerToMuonPropagator::TrackerToMuonPropagator ( const edm::ParameterSet &  iConfig )

explicit

Definition at line 98 of file TrackerToMuonPropagator.cc.

References edm::ParameterSet::getParameter(), m_globalMuons, m_globalMuonTracks, m_refitTracker, m_trackTransformer, and HLT_2022v12_cff::TrackTransformer.

    : m_esTokenProp(esConsumes(edm::ESInputTag("", iConfig.getParameter<std::string>("propagator")))),
      m_esTokenTk(esConsumes()),
      m_esTokenDT(esConsumes()),
      m_esTokenCSC(esConsumes()),
      m_esTokenMF(esConsumes()),
      m_esTokenGTGeo(esConsumes()) {
  m_globalMuons = iConfig.getParameter<edm::InputTag>("globalMuons");
  m_globalMuonTracks = iConfig.getParameter<edm::InputTag>("globalMuonTracks");
  m_refitTracker = iConfig.getParameter<bool>("refitTrackerTrack");
  if (m_refitTracker) {
    m_trackTransformer =
        new TrackTransformer(iConfig.getParameter<edm::ParameterSet>("trackerTrackTransformer"), consumesCollector());
  } else
    m_trackTransformer = nullptr;

  produces<std::vector<Trajectory>>();
  produces<TrajTrackAssociationCollection>();
}

~TrackerToMuonPropagator()

TrackerToMuonPropagator::~TrackerToMuonPropagator ( )

override

Definition at line 118 of file TrackerToMuonPropagator.cc.

                                                  {
  // do anything here that needs to be done at desctruction time
  // (e.g. close files, deallocate resources etc.)
}

Member Function Documentation

produce()

void TrackerToMuonPropagator::produce ( edm::Event &  iEvent, const edm::EventSetup &  iSetup  )

overrideprivate

Definition at line 128 of file TrackerToMuonPropagator.cc.

References alongMomentum, MuonTransientTrackingRecHitBuilder::build(), ALCARECOTkAlJpsiMuMu_cff::charge, MuonSubdetId::CSC, MuonSubdetId::DT, MillePedeFileConverter_cfg::e, edm::OwnVector< T, P >::empty(), Exception, Trajectory::firstMeasurement(), TrajectoryMeasurement::forwardPredictedState(), edm::EventSetup::getData(), susybsm::HSCParticleType::globalMuon, globalMuons_cfi::globalMuons, mps_fire::i, DTGeometry::idToDet(), TrackerGeometry::idToDet(), CSCGeometry::idToDet(), iEvent, TrajectoryStateOnSurface::isValid(), m_esTokenCSC, m_esTokenDT, m_esTokenGTGeo, m_esTokenMF, m_esTokenProp, m_esTokenTk, m_globalMuons, m_globalMuonTracks, m_refitTracker, m_trackTransformer, HLT_2022v12_cff::magneticField, eostools::move(), DetId::Muon, trajectoryStateTransform::persistentState(), TrackCandidateProducer_cfi::propagator, Trajectory::push(), edm::OwnVector< T, P >::push_back(), DetId::rawId(), TrajectoryMeasurement::recHit(), TrackTransformer::setServices(), edm::OwnVector< T, P >::size(), GeomDet::surface(), and TrackTransformer::transform().

                                                                                   {
  if (m_trackTransformer)
    m_trackTransformer->setServices(iSetup);

  edm::Handle<reco::MuonCollection> globalMuons;
  iEvent.getByLabel(m_globalMuons, globalMuons);

  edm::Handle<reco::TrackCollection> globalMuonTracks;
  iEvent.getByLabel(m_globalMuonTracks, globalMuonTracks);

  const Propagator* propagator = &iSetup.getData(m_esTokenProp);
  const TrackerGeometry* trackerGeometry = &iSetup.getData(m_esTokenTk);
  const DTGeometry* dtGeometry = &iSetup.getData(m_esTokenDT);
  const CSCGeometry* cscGeometry = &iSetup.getData(m_esTokenCSC);
  const MagneticField* magneticField = &iSetup.getData(m_esTokenMF);
  const GlobalTrackingGeometry* globalGeometry = &iSetup.getData(m_esTokenGTGeo);

  // Create these factories once per event

  MuonTransientTrackingRecHitBuilder muonTransBuilder;

  // Create a collection of Trajectories, to put in the Event
  auto trajectoryCollection = std::make_unique<std::vector<Trajectory>>();

  // Remember which trajectory is associated with which track
  std::map<edm::Ref<std::vector<Trajectory>>::key_type, edm::Ref<reco::TrackCollection>::key_type> reference_map;
  edm::Ref<std::vector<Trajectory>>::key_type trajCounter = 0;

  for (reco::MuonCollection::const_iterator globalMuon = globalMuons->begin(); globalMuon != globalMuons->end();
       ++globalMuon) {
    // get the counter for this global muon (that's why we needed to extract the collection explicitly
    edm::Ref<reco::TrackCollection>::key_type trackCounter = 0;
    reco::TrackCollection::const_iterator globalMuonTrack = globalMuonTracks->begin();
    for (; globalMuonTrack != globalMuonTracks->end(); ++globalMuonTrack) {
      trackCounter++;
      if (fabs(globalMuon->combinedMuon()->phi() - globalMuonTrack->phi()) < 1e-10 &&
          fabs(globalMuon->combinedMuon()->eta() - globalMuonTrack->eta()) < 1e-10)
        break;
    }
    if (globalMuonTrack == globalMuonTracks->end()) {
      throw cms::Exception("BadConfig") << "The tracks label doesn't correspond to the same objects as the muons label"
                                        << std::endl;
    }

    TrajectoryStateOnSurface tracker_tsos;
    DetId outerDetId;
    if (m_refitTracker) {
      std::vector<Trajectory> trackerTrajectories = m_trackTransformer->transform(*globalMuon->track());
      if (trackerTrajectories.size() == 1) {
        const Trajectory trackerTrajectory = *(trackerTrajectories.begin());

        // surprisingly, firstMeasurement() corresponds to the outermost state of the tracker
        tracker_tsos = trackerTrajectory.firstMeasurement().forwardPredictedState();
        outerDetId = trackerTrajectory.firstMeasurement().recHit()->geographicalId();
      } else
        continue;
    } else {
      // get information about the outermost tracker hit
      GlobalPoint outerPosition(globalMuon->track()->outerPosition().x(),
                                globalMuon->track()->outerPosition().y(),
                                globalMuon->track()->outerPosition().z());
      GlobalVector outerMomentum(globalMuon->track()->outerMomentum().x(),
                                 globalMuon->track()->outerMomentum().y(),
                                 globalMuon->track()->outerMomentum().z());
      int charge = globalMuon->track()->charge();
      const reco::Track::CovarianceMatrix outerStateCovariance = globalMuon->track()->outerStateCovariance();
      outerDetId = DetId(globalMuon->track()->outerDetId());

      // construct the information necessary to make a TrajectoryStateOnSurface
      GlobalTrajectoryParameters globalTrajParams(outerPosition, outerMomentum, charge, magneticField);
      CurvilinearTrajectoryError curviError(outerStateCovariance);
      FreeTrajectoryState tracker_state(globalTrajParams, curviError);

      // starting point for propagation into the muon system
      tracker_tsos =
          TrajectoryStateOnSurface(globalTrajParams, curviError, trackerGeometry->idToDet(outerDetId)->surface());
    }

    TrajectoryStateOnSurface last_tsos = tracker_tsos;

    // loop over the muon hits, keeping track of the successful extrapolations
    edm::OwnVector<TrackingRecHit> muonHits;
    std::vector<TrajectoryStateOnSurface> TSOSes;
    for (auto const& hit : globalMuon->combinedMuon()->recHits()) {
      DetId id = hit->geographicalId();

      TrajectoryStateOnSurface extrapolation;
      bool extrapolated = false;
      if (id.det() == DetId::Muon && id.subdetId() == MuonSubdetId::DT) {
        extrapolation = propagator->propagate(last_tsos, dtGeometry->idToDet(id)->surface());
        extrapolated = true;
      } else if (id.det() == DetId::Muon && id.subdetId() == MuonSubdetId::CSC) {
        extrapolation = propagator->propagate(last_tsos, cscGeometry->idToDet(id)->surface());
        extrapolated = true;
      }

      if (extrapolated && extrapolation.isValid()) {
        muonHits.push_back(hit->clone());
        TSOSes.push_back(extrapolation);
      }
    }  // end loop over standAloneMuon hits

    // if it has any successful extrapolations, make them into a Trajectory
    if (!muonHits.empty()) {
      PTrajectoryStateOnDet const& PTraj = trajectoryStateTransform::persistentState(tracker_tsos, outerDetId.rawId());
      TrajectorySeed trajectorySeed(PTraj, muonHits, alongMomentum);
      Trajectory trajectory(trajectorySeed, alongMomentum);

      for (unsigned int i = 0; i < muonHits.size(); i++) {
        TrajectoryMeasurement::ConstRecHitPointer hitPtr(muonTransBuilder.build(&(muonHits[i]), globalGeometry));
        TrajectoryStateOnSurface TSOS = TSOSes[i];
        trajectory.push(TrajectoryMeasurement(TSOS, TSOS, TSOS, hitPtr));
      }  // end filling Trajectory

      trajectoryCollection->push_back(trajectory);

      // Remember which Trajectory is associated with which Track
      trajCounter++;
      reference_map[trajCounter] = trackCounter;

    }  // end if we have some good extrapolations

  }  // end loop over globalMuons

  unsigned int numTrajectories = trajectoryCollection->size();

  // insert the trajectories into the Event
  edm::OrphanHandle<std::vector<Trajectory>> ohTrajs = iEvent.put(std::move(trajectoryCollection));

  // create the trajectory <-> track association map
  auto trajTrackMap = std::make_unique<TrajTrackAssociationCollection>();

  for (trajCounter = 0; trajCounter < numTrajectories; trajCounter++) {
    edm::Ref<reco::TrackCollection>::key_type trackCounter = reference_map[trajCounter];

    trajTrackMap->insert(edm::Ref<std::vector<Trajectory>>(ohTrajs, trajCounter),
                         edm::Ref<reco::TrackCollection>(globalMuonTracks, trackCounter));
  }
  // and put it in the Event, also
  iEvent.put(std::move(trajTrackMap));
}

Member Data Documentation

m_esTokenCSC

const edm::ESGetToken<CSCGeometry, MuonGeometryRecord> TrackerToMuonPropagator::m_esTokenCSC

private

Definition at line 77 of file TrackerToMuonPropagator.cc.

Referenced by produce().

m_esTokenDT

const edm::ESGetToken<DTGeometry, MuonGeometryRecord> TrackerToMuonPropagator::m_esTokenDT

private

Definition at line 76 of file TrackerToMuonPropagator.cc.

Referenced by produce().

m_esTokenGTGeo

const edm::ESGetToken<GlobalTrackingGeometry, GlobalTrackingGeometryRecord> TrackerToMuonPropagator::m_esTokenGTGeo

private

Definition at line 79 of file TrackerToMuonPropagator.cc.

Referenced by produce().

m_esTokenMF

const edm::ESGetToken<MagneticField, IdealMagneticFieldRecord> TrackerToMuonPropagator::m_esTokenMF

private

Definition at line 78 of file TrackerToMuonPropagator.cc.

Referenced by produce().

m_esTokenProp

const edm::ESGetToken<Propagator, TrackingComponentsRecord> TrackerToMuonPropagator::m_esTokenProp

private

Definition at line 74 of file TrackerToMuonPropagator.cc.

Referenced by produce().

m_esTokenTk

const edm::ESGetToken<TrackerGeometry, TrackerDigiGeometryRecord> TrackerToMuonPropagator::m_esTokenTk

private

Definition at line 75 of file TrackerToMuonPropagator.cc.

Referenced by produce().

m_globalMuons

edm::InputTag TrackerToMuonPropagator::m_globalMuons

private

Definition at line 81 of file TrackerToMuonPropagator.cc.

Referenced by produce(), and TrackerToMuonPropagator().

m_globalMuonTracks

edm::InputTag TrackerToMuonPropagator::m_globalMuonTracks

private

Definition at line 81 of file TrackerToMuonPropagator.cc.

Referenced by produce(), and TrackerToMuonPropagator().

m_refitTracker

bool TrackerToMuonPropagator::m_refitTracker

private

Definition at line 83 of file TrackerToMuonPropagator.cc.

Referenced by produce(), and TrackerToMuonPropagator().

m_trackTransformer

TrackTransformer* TrackerToMuonPropagator::m_trackTransformer

private

Definition at line 84 of file TrackerToMuonPropagator.cc.

Referenced by produce(), and TrackerToMuonPropagator().