TrackTransformer Class Reference

#include <TrackTransformer.h>

Inheritance diagram for TrackTransformer:

Public Member Functions
TransientTrackingRecHit::ConstRecHitContainer	getTransientRecHits (const reco::TransientTrack &track) const
const MagneticField *	magneticField () const
	the magnetic field More...
std::unique_ptr< TrajectoryFitter > const &	refitter () const
	the refitter used to refit the reco::Track More...
void	setServices (const edm::EventSetup &) override
	set the services needed by the TrackTransformer More...
std::unique_ptr< TrajectorySmoother > const &	smoother () const
	the smoother used to smooth the trajectory which came from the refitting step More...
edm::ESHandle< GlobalTrackingGeometry >	trackingGeometry () const
	the tracking geometry More...
	TrackTransformer (const edm::ParameterSet &)
	Constructor. More...
std::vector< Trajectory >	transform (const reco::Track &) const override
	Convert a reco::Track into Trajectory. More...
std::vector< Trajectory >	transform (const reco::TrackRef &) const
	Convert a reco::TrackRef into Trajectory. More...
std::vector< Trajectory >	transform (const reco::TransientTrack &, TransientTrackingRecHit::ConstRecHitContainer &) const
	Convert a reco::TrackRef into Trajectory, refit with a new set of hits. More...
	~TrackTransformer () override
	Destructor. More...
Public Member Functions inherited from TrackTransformerBase
	TrackTransformerBase ()
	Constructor. More...
virtual	~TrackTransformerBase ()
	Destructor. More...

Static Public Member Functions
static void	fillPSetDescription (edm::ParameterSetDescription &descriptions, bool DoPredictionsOnly=false, const std::string &Fitter="KFFitterForRefitInsideOut", const std::string &Smoother="KFSmootherForRefitInsideOut", const std::string &Propagator="SmartPropagatorAnyRK", const std::string &RefitDirection="alongMomentum", bool RefitRPCHits=true, const std::string &TrackerRecHitBuilder="WithTrackAngle", const std::string &MuonRecHitBuilder="MuonRecHitBuilder", const std::string &MTDRecHitBuilder="MTDRecHitBuilder")
	fillDescriptions More...

Private Member Functions
RefitDirection::GeometricalDirection	checkRecHitsOrdering (TransientTrackingRecHit::ConstRecHitContainer const &) const
edm::ESHandle< Propagator > const &	propagator () const

Private Attributes
TkClonerImpl	hitCloner
unsigned long long	theCacheId_GTG = 0
unsigned long long	theCacheId_MG = 0
unsigned long long	theCacheId_TC = 0
unsigned long long	theCacheId_TRH = 0
const bool	theDoPredictionsOnly
std::unique_ptr< TrajectoryFitter >	theFitter
const std::string	theFitterName
edm::ESHandle< MagneticField >	theMGField
bool	theMtdAvailable
edm::ESHandle< TransientTrackingRecHitBuilder >	theMTDRecHitBuilder
const std::string	theMTDRecHitBuilderName
edm::ESHandle< TransientTrackingRecHitBuilder >	theMuonRecHitBuilder
const std::string	theMuonRecHitBuilderName
edm::ESHandle< Propagator >	thePropagator
const std::string	thePropagatorName
const RefitDirection	theRefitDirection
const bool	theRPCInTheFit
std::unique_ptr< TrajectorySmoother >	theSmoother
const std::string	theSmootherName
edm::ESHandle< TransientTrackingRecHitBuilder >	theTrackerRecHitBuilder
const std::string	theTrackerRecHitBuilderName
edm::ESHandle< GlobalTrackingGeometry >	theTrackingGeometry

Detailed Description

This class takes a reco::Track and refits the rechits inside it. The final result is a Trajectory refitted and smoothed. To make the refitting (and the smoothing) the usual KF tools are used.

CAVEAT: till now (it will be changed in the near future) the class stores the pointers to the services, therefore EACH event the setServices(const edm::EventSetup&) method MUST be called in the code in which the TrackTransformer is used.

Author

R. Bellan - INFN Torino ricca.nosp@m.rdo..nosp@m.bella.nosp@m.n@ce.nosp@m.rn.ch

This class takes a reco::Track and refits the rechits inside it. The final result is a Trajectory refitted and smoothed. To make the refitting (and the smoothing) the usual KF tools are used.

CAVEAT: till now (it will be changed in the near future) the class stores the pointers to the services, therefore EACH event the setServices(const edm::EventSetup&) method MUST be called in the code in which the TrackTransformer is used.

Rec hits are ordered in rank of increasing |z| assuing muons are coming from the top of the detector.

$Date: 2009/01/15 \original author R. Bellan - CERN ricca.nosp@m.rdo..nosp@m.bella.nosp@m.n@ce.nosp@m.rn.ch modified for zed ordering by N. Kypreos - UF nicho.nosp@m.las..nosp@m.theod.nosp@m.ore..nosp@m.kypre.nosp@m.os@c.nosp@m.ern.c.nosp@m.h

This class takes a reco::Track and refits the rechits inside it. The final result is a Trajectory refitted and smoothed. To make the refitting (and the smoothing) the usual KF tools are used.

CAVEAT: till now (it will be changed in the near future) the class stores the pointers to the services, therefore EACH event the setServices(const edm::EventSetup&) method MUST be called in the code in which the TrackTransformer is used.

Author

R. Bellan - CERN ricca.nosp@m.rdo..nosp@m.bella.nosp@m.n@ce.nosp@m.rn.ch

Definition at line 44 of file TrackTransformer.h.

Constructor & Destructor Documentation

TrackTransformer()

TrackTransformer::TrackTransformer ( const edm::ParameterSet &  parameterSet )

explicit

Constructor.

Definition at line 31 of file TrackTransformer.cc.

    : theRPCInTheFit(parameterSet.getParameter<bool>("RefitRPCHits")),
      theDoPredictionsOnly(parameterSet.getParameter<bool>("DoPredictionsOnly")),
      theRefitDirection(parameterSet.getParameter<string>("RefitDirection")),
      theFitterName(parameterSet.getParameter<string>("Fitter")),
      theSmootherName(parameterSet.getParameter<string>("Smoother")),
      thePropagatorName(parameterSet.getParameter<string>("Propagator")),
      theTrackerRecHitBuilderName(parameterSet.getParameter<string>("TrackerRecHitBuilder")),
      theMuonRecHitBuilderName(parameterSet.getParameter<string>("MuonRecHitBuilder")),
      theMTDRecHitBuilderName(parameterSet.getParameter<string>("MTDRecHitBuilder")) {}

~TrackTransformer()

TrackTransformer::~TrackTransformer ( )

override

Destructor.

Definition at line 43 of file TrackTransformer.cc.

{}

Member Function Documentation

checkRecHitsOrdering()

RefitDirection::GeometricalDirection TrackTransformer::checkRecHitsOrdering ( TransientTrackingRecHit::ConstRecHitContainer const &  recHits ) const

private

Definition at line 145 of file TrackTransformer.cc.

                                                                      {
  if (!recHits.empty()) {
    GlobalPoint first = trackingGeometry()->idToDet(recHits.front()->geographicalId())->position();
    GlobalPoint last = trackingGeometry()->idToDet(recHits.back()->geographicalId())->position();
 
    // maybe perp2?
    auto rFirst = first.mag2();
    auto rLast = last.mag2();
    if (rFirst < rLast)
      return RefitDirection::insideOut;
    if (rFirst > rLast)
      return RefitDirection::outsideIn;
  }
  LogDebug("Reco|TrackingTools|TrackTransformer") << "Impossible to determine the rechits order" << endl;
  return RefitDirection::undetermined;
}

References dqmdumpme::first, GlobalTrackingGeometry::idToDet(), RefitDirection::insideOut, dqmdumpme::last, LogDebug, RefitDirection::outsideIn, position, FastTrackerRecHitMaskProducer_cfi::recHits, trackingGeometry(), and RefitDirection::undetermined.

Referenced by transform().

fillPSetDescription()

void TrackTransformer::fillPSetDescription ( edm::ParameterSetDescription &  descriptions, bool  DoPredictionsOnly = false, const std::string &  Fitter = "KFFitterForRefitInsideOut", const std::string &  Smoother = "KFSmootherForRefitInsideOut", const std::string &  Propagator = "SmartPropagatorAnyRK", const std::string &  RefitDirection = "alongMomentum", bool  RefitRPCHits = true, const std::string &  TrackerRecHitBuilder = "WithTrackAngle", const std::string &  MuonRecHitBuilder = "MuonRecHitBuilder", const std::string &  MTDRecHitBuilder = "MTDRecHitBuilder"  )

static

fillDescriptions

Definition at line 45 of file TrackTransformer.cc.

                                                                              {
  desc.add<bool>("DoPredictionsOnly", DoPredictionsOnly);
  desc.add<std::string>("Fitter", Fitter);
  desc.add<std::string>("Smoother", Smoother);
  desc.add<std::string>("Propagator", Propagator);
  desc.add<std::string>("RefitDirection", RefitDirection);
  desc.add<bool>("RefitRPCHits", RefitRPCHits);
  desc.add<std::string>("TrackerRecHitBuilder", TrackerRecHitBuilder);
  desc.add<std::string>("MuonRecHitBuilder", MuonRecHitBuilder);
  desc.add<std::string>("MTDRecHitBuilder", MTDRecHitBuilder);
}

References edm::ParameterSetDescription::add(), trackingRecoMaterialAnalyzer_cfi::DoPredictionsOnly, HLTSiStripMonitoring_cff::Fitter, trackingRecoMaterialAnalyzer_cfi::MTDRecHitBuilder, trackingRecoMaterialAnalyzer_cfi::MuonRecHitBuilder, LaserSeedGenerator_cfi::Propagator, trackingRecoMaterialAnalyzer_cfi::RefitDirection, MuonAlignmentFromReference_cff::RefitRPCHits, HLTSiStripMonitoring_cff::Smoother, AlCaHLTBitMon_QueryRunRegistry::string, and trackingRecoMaterialAnalyzer_cfi::TrackerRecHitBuilder.

Referenced by L3MuonProducer::fillDescriptions(), and TrackExtenderWithMTDT< TrackCollection >::fillDescriptions().

getTransientRecHits()

TransientTrackingRecHit::ConstRecHitContainer TrackTransformer::getTransientRecHits

(

const reco::TransientTrack &

track

)

const

Definition at line 117 of file TrackTransformer.cc.

                                           {
  TransientTrackingRecHit::ConstRecHitContainer result;
  auto tkbuilder = static_cast<TkTransientTrackingRecHitBuilder const*>(theTrackerRecHitBuilder.product());
 
  for (auto hit = track.recHitsBegin(); hit != track.recHitsEnd(); ++hit) {
    if ((*hit)->isValid()) {
      if ((*hit)->geographicalId().det() == DetId::Tracker) {
        result.emplace_back((**hit).cloneForFit(*tkbuilder->geometry()->idToDet((**hit).geographicalId())));
      } else if ((*hit)->geographicalId().det() == DetId::Muon) {
        if ((*hit)->geographicalId().subdetId() == 3 && !theRPCInTheFit) {
          LogTrace("Reco|TrackingTools|TrackTransformer") << "RPC Rec Hit discarged";
          continue;
        }
        result.push_back(theMuonRecHitBuilder->build(&**hit));
      } else if ((*hit)->geographicalId().det() == DetId::Forward && (*hit)->geographicalId().subdetId() == FastTime) {
        if (theMtdAvailable)
          result.push_back(theMTDRecHitBuilder->build(&**hit));
        else
          throw cms::Exception("TrackTransformer") << "MTD hit encountered but MTD not available!";
      }
    }
  }
 
  return result;
}

References TransientTrackingRecHitBuilder::build(), Exception, FastTime, DetId::Forward, LogTrace, DetId::Muon, edm::ESHandle< T >::product(), mps_fire::result, theMtdAvailable, theMTDRecHitBuilder, theMuonRecHitBuilder, theRPCInTheFit, theTrackerRecHitBuilder, HLT_2018_cff::track, and DetId::Tracker.

Referenced by transform().

magneticField()

const MagneticField* TrackTransformer::magneticField ( ) const

inline

the magnetic field

Definition at line 76 of file TrackTransformer.h.

{ return &*theMGField; }

References theMGField.

Referenced by transform().

propagator()

edm::ESHandle<Propagator> const& TrackTransformer::propagator ( ) const

inlineprivate

Definition at line 115 of file TrackTransformer.h.

{ return thePropagator; }

References thePropagator.

Referenced by transform().

refitter()

std::unique_ptr<TrajectoryFitter> const& TrackTransformer::refitter ( ) const

inline

the refitter used to refit the reco::Track

Definition at line 85 of file TrackTransformer.h.

{ return theFitter; }

References theFitter.

setServices()

void TrackTransformer::setServices ( const edm::EventSetup &  setup )

overridevirtual

set the services needed by the TrackTransformer

Implements TrackTransformerBase.

Definition at line 66 of file TrackTransformer.cc.

                                                          {
  const std::string metname = "Reco|TrackingTools|TrackTransformer";
 
  edm::ESHandle<TrajectoryFitter> aFitter;
  edm::ESHandle<TrajectorySmoother> aSmoother;
  setup.get<TrajectoryFitter::Record>().get(theFitterName, aFitter);
  setup.get<TrajectoryFitter::Record>().get(theSmootherName, aSmoother);
  theFitter = aFitter->clone();
  theSmoother.reset(aSmoother->clone());
 
  unsigned long long newCacheId_TC = setup.get<TrackingComponentsRecord>().cacheIdentifier();
 
  if (newCacheId_TC != theCacheId_TC) {
    LogTrace(metname) << "Tracking Component changed!";
    theCacheId_TC = newCacheId_TC;
    setup.get<TrackingComponentsRecord>().get(thePropagatorName, thePropagator);
  }
 
  // 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);
  }
 
  // Transient Rechit Builders
  unsigned long long newCacheId_TRH = setup.get<TransientRecHitRecord>().cacheIdentifier();
  if (newCacheId_TRH != theCacheId_TRH) {
    theCacheId_TRH = newCacheId_TRH;
    LogTrace(metname) << "TransientRecHitRecord changed!";
    setup.get<TransientRecHitRecord>().get(theTrackerRecHitBuilderName, theTrackerRecHitBuilder);
    setup.get<TransientRecHitRecord>().get(theMuonRecHitBuilderName, theMuonRecHitBuilder);
    setup.get<TransientRecHitRecord>().get(theMTDRecHitBuilderName, theMTDRecHitBuilder);
    theMtdAvailable = theMTDRecHitBuilder.isValid();
    hitCloner = static_cast<TkTransientTrackingRecHitBuilder const*>(theTrackerRecHitBuilder.product())->cloner();
  }
  theFitter->setHitCloner(&hitCloner);
  theSmoother->setHitCloner(&hitCloner);
}

References TrajectorySmoother::clone(), TrajectoryFitter::clone(), get, hitCloner, edm::ESHandleBase::isValid(), LogTrace, metname, edm::ESHandle< T >::product(), singleTopDQM_cfi::setup, AlCaHLTBitMon_QueryRunRegistry::string, theCacheId_GTG, theCacheId_MG, theCacheId_TC, theCacheId_TRH, theFitter, theFitterName, theMGField, theMtdAvailable, theMTDRecHitBuilder, theMTDRecHitBuilderName, theMuonRecHitBuilder, theMuonRecHitBuilderName, thePropagator, thePropagatorName, theSmoother, theSmootherName, theTrackerRecHitBuilder, theTrackerRecHitBuilderName, and theTrackingGeometry.

Referenced by TrackingRecoMaterialAnalyser::analyze(), MuonKinkFinder::init(), MuonReSeeder::produce(), TrackerToMuonPropagator::produce(), CSCOverlapsAlignmentAlgorithm::run(), and GlobalTrajectoryBuilderBase::setEvent().

smoother()

std::unique_ptr<TrajectorySmoother> const& TrackTransformer::smoother ( ) const

inline

the smoother used to smooth the trajectory which came from the refitting step

Definition at line 88 of file TrackTransformer.h.

{ return theSmoother; }

References theSmoother.

trackingGeometry()

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

inline

the tracking geometry

Definition at line 79 of file TrackTransformer.h.

{ return theTrackingGeometry; }

References theTrackingGeometry.

Referenced by checkRecHitsOrdering(), and transform().

transform() [1/3]

vector< Trajectory > TrackTransformer::transform ( const reco::Track &  newTrack ) const

overridevirtual

Convert a reco::Track into Trajectory.

Convert Tracks into Trajectories.

Implements TrackTransformerBase.

Definition at line 164 of file TrackTransformer.cc.

                                                                              {
  const std::string metname = "Reco|TrackingTools|TrackTransformer";
 
  reco::TransientTrack track(newTrack, magneticField(), trackingGeometry());
 
  auto recHitsForReFit = getTransientRecHits(track);
  return transform(track, recHitsForReFit);
}

References getTransientRecHits(), magneticField(), metname, AlCaHLTBitMon_QueryRunRegistry::string, HLT_2018_cff::track, and trackingGeometry().

Referenced by TrackingRecoMaterialAnalyser::analyze(), GlobalTrajectoryBuilderBase::build(), CSCPairResidualsConstraint::dphidzFromTrack(), MuonKinkFinder::fillTrkKink(), MuonReSeeder::produce(), TrackerToMuonPropagator::produce(), and transform().

transform() [2/3]

vector< Trajectory > TrackTransformer::transform

(

const reco::TrackRef &

track

)

const

Convert a reco::TrackRef into Trajectory.

Definition at line 115 of file TrackTransformer.cc.

{ return transform(*track); }

References HLT_2018_cff::track, and transform().

transform() [3/3]

vector< Trajectory > TrackTransformer::transform	(	const reco::TransientTrack &	track,
		TransientTrackingRecHit::ConstRecHitContainer &	recHitsForReFit
	)		const

Convert a reco::TrackRef into Trajectory, refit with a new set of hits.

Convert Tracks into Trajectories with a given set of hits.

Definition at line 174 of file TrackTransformer.cc.

                                                                                                                   {
  const std::string metname = "Reco|TrackingTools|TrackTransformer";
 
  if (recHitsForReFit.size() < 2)
    return vector<Trajectory>();
 
  // 8 cases are foreseen:
  // [RH = rec hit order, P = momentum dir, FD = fit direction. IO/OI = inside-out/outside-in, AM/OM = along momentum/opposite to momentum]
  // (1) RH IO | P IO | FD AM  ---> Start from IN
  // (2) RH IO | P IO | FD OM  ---> Reverse RH and start from OUT
  // (3) RH IO | P OI | FD AM  ---> Reverse RH and start from IN
  // (4) RH IO | P OI | FD OM  ---> Start from OUT
  // (5) RH OI | P IO | FD AM  ---> Reverse RH and start from IN
  // (6) RH OI | P IO | FD OM  ---> Start from OUT
  // (7) RH OI | P OI | FD AM  ---> Start from IN
  // (8) RH OI | P OI | FD OM  ---> Reverse RH and start from OUT
  //
  // *** Rules: ***
  // -A- If RH-FD agree (IO-AM,OI-OM) do not reverse the RH
  // -B- If FD along momentum start from innermost state, otherwise use outermost
 
  // Other special cases can be handled:
  // (1 bis) RH IO | P IO | GFD IO => FD AM  ---> Start from IN
  // (2 bis) RH IO | P IO | GFD OI => FD OM  ---> Reverse RH and start from OUT
  // (3 bis) RH IO | P OI | GFD OI => FD AM  ---> Reverse RH and start from OUT
  // (4 bis) RH IO | P OI | GFD IO => FD OM  ---> Start from IN
  // (5 bis) RH OI | P IO | GFD IO => FD AM  ---> Reverse RH and start from IN
  // (6 bis) RH OI | P IO | GFD OI => FD OM  ---> Start from OUT
  // (7 bis) RH OI | P OI | GFD OI => FD AM  ---> Start from OUT
  // (8 bis) RH OI | P OI | GFD IO => FD OM  ---> Reverse RH and start from IN
  //
  // *** Additional rule: ***
  // -A0- If P and GFD agree, then FD is AM otherwise is OM
  // -A00- rechit must be ordered as GFD in order to handle the case of cosmics
  // -B0- The starting state is decided by GFD
 
  // Determine the RH order
  RefitDirection::GeometricalDirection recHitsOrder =
      checkRecHitsOrdering(recHitsForReFit);  // FIXME change nome of the *type*  --> RecHit order!
  LogTrace(metname) << "RH order (0-insideOut, 1-outsideIn): " << recHitsOrder;
 
  PropagationDirection propagationDirection = theRefitDirection.propagationDirection();
 
  // Apply rule -A0-
  if (propagationDirection == anyDirection) {
    GlobalVector momentum = track.innermostMeasurementState().globalMomentum();
    GlobalVector position = track.innermostMeasurementState().globalPosition() - GlobalPoint(0, 0, 0);
    RefitDirection::GeometricalDirection p = (momentum.x() * position.x() > 0 || momentum.y() * position.y() > 0)
                                                 ? RefitDirection::insideOut
                                                 : RefitDirection::outsideIn;
 
    propagationDirection = p == theRefitDirection.geometricalDirection() ? alongMomentum : oppositeToMomentum;
    LogTrace(metname) << "P  (0-insideOut, 1-outsideIn): " << p;
    LogTrace(metname) << "FD (0-OM, 1-AM, 2-ANY): " << propagationDirection;
  }
  // -A0-
 
  // Apply rule -A-
  if (theRefitDirection.propagationDirection() != anyDirection) {
    if ((recHitsOrder == RefitDirection::insideOut && propagationDirection == oppositeToMomentum) ||
        (recHitsOrder == RefitDirection::outsideIn && propagationDirection == alongMomentum))
      reverse(recHitsForReFit.begin(), recHitsForReFit.end());
  }
  // -A-
  // Apply rule -A00-
  else {
    // reorder the rechit as defined in theRefitDirection.geometricalDirection();
    if (theRefitDirection.geometricalDirection() != recHitsOrder)
      reverse(recHitsForReFit.begin(), recHitsForReFit.end());
  }
  // -A00-
 
  // Apply rule -B-
  TrajectoryStateOnSurface firstTSOS = track.innermostMeasurementState();
  unsigned int innerId = track.track().innerDetId();
  if (theRefitDirection.propagationDirection() != anyDirection) {
    if (propagationDirection == oppositeToMomentum) {
      innerId = track.track().outerDetId();
      firstTSOS = track.outermostMeasurementState();
    }
  } else {  // if(theRefitDirection.propagationDirection() == anyDirection)
    // Apply rule -B0-
    if (theRefitDirection.geometricalDirection() == RefitDirection::outsideIn) {
      innerId = track.track().outerDetId();
      firstTSOS = track.outermostMeasurementState();
    }
    // -B0-
  }
  // -B-
 
  if (!firstTSOS.isValid()) {
    LogTrace(metname) << "Error wrong initial state!" << endl;
    return vector<Trajectory>();
  }
 
  TrajectorySeed seed(PTrajectoryStateOnDet(), TrajectorySeed::recHitContainer(), propagationDirection);
 
  if (recHitsForReFit.front()->geographicalId() != DetId(innerId)) {
    LogTrace(metname) << "Propagation occured" << endl;
    firstTSOS = propagator()->propagate(firstTSOS, recHitsForReFit.front()->det()->surface());
    if (!firstTSOS.isValid()) {
      LogTrace(metname) << "Propagation error!" << endl;
      return vector<Trajectory>();
    }
  }
 
  if (theDoPredictionsOnly) {
    Trajectory aTraj(seed, propagationDirection);
    TrajectoryStateOnSurface predTSOS = firstTSOS;
    for (auto const& hit : recHitsForReFit) {
      predTSOS = propagator()->propagate(predTSOS, hit->det()->surface());
      if (predTSOS.isValid())
        aTraj.push(TrajectoryMeasurement(predTSOS, hit));
    }
    return vector<Trajectory>(1, aTraj);
  }
 
  auto const& trajectories = theFitter->fit(seed, recHitsForReFit, firstTSOS);
 
  if (trajectories.empty()) {
    LogTrace(metname) << "No Track refitted!" << endl;
    return trajectories;
  }
 
  auto const& trajectoryBW = trajectories.front();
 
  auto const& trajectoriesSM = theSmoother->trajectories(trajectoryBW);
 
  if (trajectoriesSM.empty()) {
    LogTrace(metname) << "No Track smoothed!" << endl;
  }
 
  return trajectoriesSM;
}

References alongMomentum, anyDirection, checkRecHitsOrdering(), RefitDirection::geometricalDirection(), RefitDirection::insideOut, TrajectoryStateOnSurface::isValid(), LogTrace, metname, oppositeToMomentum, RefitDirection::outsideIn, AlCaHLTBitMon_ParallelJobs::p, position, Propagator::propagate(), RefitDirection::propagationDirection(), propagator(), Trajectory::push(), groupFilesInBlocks::reverse, SurveyInfoScenario_cff::seed, AlCaHLTBitMon_QueryRunRegistry::string, TrajectoryStateOnSurface::surface(), theDoPredictionsOnly, theFitter, theRefitDirection, theSmoother, HLT_2018_cff::track, FastTrackerRecHitMaskProducer_cfi::trajectories, PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

Member Data Documentation

hitCloner

TkClonerImpl TrackTransformer::hitCloner

private

Definition at line 120 of file TrackTransformer.h.

Referenced by setServices().

theCacheId_GTG

unsigned long long TrackTransformer::theCacheId_GTG = 0

private

Definition at line 96 of file TrackTransformer.h.

Referenced by setServices().

theCacheId_MG

unsigned long long TrackTransformer::theCacheId_MG = 0

private

Definition at line 97 of file TrackTransformer.h.

Referenced by setServices().

theCacheId_TC

unsigned long long TrackTransformer::theCacheId_TC = 0

private

Definition at line 95 of file TrackTransformer.h.

Referenced by setServices().

theCacheId_TRH

unsigned long long TrackTransformer::theCacheId_TRH = 0

private

Definition at line 98 of file TrackTransformer.h.

Referenced by setServices().

theDoPredictionsOnly

const bool TrackTransformer::theDoPredictionsOnly

private

Definition at line 102 of file TrackTransformer.h.

Referenced by transform().

theFitter

std::unique_ptr<TrajectoryFitter> TrackTransformer::theFitter

private

Definition at line 109 of file TrackTransformer.h.

Referenced by refitter(), setServices(), and transform().

theFitterName

const std::string TrackTransformer::theFitterName

private

Definition at line 108 of file TrackTransformer.h.

Referenced by setServices().

theMGField

edm::ESHandle<MagneticField> TrackTransformer::theMGField

private

Definition at line 106 of file TrackTransformer.h.

Referenced by magneticField(), and setServices().

theMtdAvailable

bool TrackTransformer::theMtdAvailable

private

Definition at line 126 of file TrackTransformer.h.

Referenced by getTransientRecHits(), and setServices().

theMTDRecHitBuilder

edm::ESHandle<TransientTrackingRecHitBuilder> TrackTransformer::theMTDRecHitBuilder

private

Definition at line 127 of file TrackTransformer.h.

Referenced by getTransientRecHits(), and setServices().

theMTDRecHitBuilderName

const std::string TrackTransformer::theMTDRecHitBuilderName

private

Definition at line 125 of file TrackTransformer.h.

Referenced by setServices().

theMuonRecHitBuilder

edm::ESHandle<TransientTrackingRecHitBuilder> TrackTransformer::theMuonRecHitBuilder

private

Definition at line 123 of file TrackTransformer.h.

Referenced by getTransientRecHits(), and setServices().

theMuonRecHitBuilderName

const std::string TrackTransformer::theMuonRecHitBuilderName

private

Definition at line 122 of file TrackTransformer.h.

Referenced by setServices().

thePropagator

edm::ESHandle<Propagator> TrackTransformer::thePropagator

private

Definition at line 116 of file TrackTransformer.h.

Referenced by propagator(), and setServices().

thePropagatorName

const std::string TrackTransformer::thePropagatorName

private

Definition at line 114 of file TrackTransformer.h.

Referenced by setServices().

theRefitDirection

const RefitDirection TrackTransformer::theRefitDirection

private

Definition at line 103 of file TrackTransformer.h.

Referenced by transform().

theRPCInTheFit

const bool TrackTransformer::theRPCInTheFit

private

Definition at line 100 of file TrackTransformer.h.

Referenced by getTransientRecHits().

theSmoother

std::unique_ptr<TrajectorySmoother> TrackTransformer::theSmoother

private

Definition at line 112 of file TrackTransformer.h.

Referenced by setServices(), smoother(), and transform().

theSmootherName

const std::string TrackTransformer::theSmootherName

private

Definition at line 111 of file TrackTransformer.h.

Referenced by setServices().

theTrackerRecHitBuilder

edm::ESHandle<TransientTrackingRecHitBuilder> TrackTransformer::theTrackerRecHitBuilder

private

Definition at line 119 of file TrackTransformer.h.

Referenced by getTransientRecHits(), and setServices().

theTrackerRecHitBuilderName

const std::string TrackTransformer::theTrackerRecHitBuilderName

private

Definition at line 118 of file TrackTransformer.h.

Referenced by setServices().

theTrackingGeometry

edm::ESHandle<GlobalTrackingGeometry> TrackTransformer::theTrackingGeometry

private

Definition at line 105 of file TrackTransformer.h.

Referenced by setServices(), and trackingGeometry().