#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 &, edm::ConsumesCollector &)
	Constructor (for modules migrated to ES-consumes) More...

	TrackTransformer (const edm::ParameterSet &parameterSet, edm::ConsumesCollector &&iC)

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_TRH = 0

const bool	theDoPredictionsOnly

std::unique_ptr< TrajectoryFitter >	theFitter

const std::string	theFitterName

edm::ESGetToken< TrajectoryFitter, TrajectoryFitterRecord >	theFitterToken

edm::ESHandle< MagneticField >	theMGField

edm::ESGetToken< MagneticField, IdealMagneticFieldRecord >	theMGFieldToken

bool	theMtdAvailable

edm::ESHandle< TransientTrackingRecHitBuilder >	theMTDRecHitBuilder

const std::string	theMTDRecHitBuilderName

edm::ESGetToken< TransientTrackingRecHitBuilder, TransientRecHitRecord >	theMTDRecHitBuilderToken

edm::ESHandle< TransientTrackingRecHitBuilder >	theMuonRecHitBuilder

const std::string	theMuonRecHitBuilderName

edm::ESGetToken< TransientTrackingRecHitBuilder, TransientRecHitRecord >	theMuonRecHitBuilderToken

edm::ESHandle< Propagator >	thePropagator

const std::string	thePropagatorName

edm::ESGetToken< Propagator, TrackingComponentsRecord >	thePropagatorToken

const RefitDirection	theRefitDirection

const bool	theRPCInTheFit

std::unique_ptr< TrajectorySmoother >	theSmoother

const std::string	theSmootherName

edm::ESGetToken< TrajectorySmoother, TrajectoryFitterRecord >	theSmootherToken

const TransientTrackingRecHitBuilder *	theTrackerRecHitBuilder

const std::string	theTrackerRecHitBuilderName

edm::ESGetToken< TransientTrackingRecHitBuilder, TransientRecHitRecord >	theTrackerRecHitBuilderToken

edm::ESHandle< GlobalTrackingGeometry >	theTrackingGeometry

edm::ESGetToken< GlobalTrackingGeometry, GlobalTrackingGeometryRecord >	theTrackingGeometryToken

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 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 46 of file TrackTransformer.h.

Constructor & Destructor Documentation

◆ TrackTransformer() [1/2]

TrackTransformer::TrackTransformer	(	const edm::ParameterSet &	parameterSet,
		edm::ConsumesCollector &	iC
	)

explicit

Constructor (for modules migrated to ES-consumes)

Constructor.

Definition at line 32 of file TrackTransformer.cc.

References edm::ConsumesCollector::esConsumes(), theFitterName, theFitterToken, theMGFieldToken, theMTDRecHitBuilderName, theMTDRecHitBuilderToken, theMuonRecHitBuilderName, theMuonRecHitBuilderToken, thePropagatorName, thePropagatorToken, theSmootherName, theSmootherToken, theTrackerRecHitBuilderName, theTrackerRecHitBuilderToken, and theTrackingGeometryToken.

     : 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")) {
   theTrackingGeometryToken = iC.esConsumes();
   theMGFieldToken = iC.esConsumes();
   theFitterToken = iC.esConsumes(edm::ESInputTag("", theFitterName));
   theSmootherToken = iC.esConsumes(edm::ESInputTag("", theSmootherName));
   thePropagatorToken = iC.esConsumes(edm::ESInputTag("", thePropagatorName));
   theTrackerRecHitBuilderToken = iC.esConsumes(edm::ESInputTag("", theTrackerRecHitBuilderName));
   theMuonRecHitBuilderToken = iC.esConsumes(edm::ESInputTag("", theMuonRecHitBuilderName));
   theMTDRecHitBuilderToken = iC.esConsumes(edm::ESInputTag("", theMTDRecHitBuilderName));
 }

◆ TrackTransformer() [2/2]

TrackTransformer::TrackTransformer	(	const edm::ParameterSet &	parameterSet,
		edm::ConsumesCollector &&	iC
	)

inlineexplicit

Definition at line 50 of file TrackTransformer.h.

51 : TrackTransformer(parameterSet, iC) {}

edm::parameterSet

ParameterSet const & parameterSet(StableProvenance const &provenance, ProcessHistory const &history)

Definition: Provenance.cc:11

TrackTransformer::TrackTransformer

TrackTransformer(const edm::ParameterSet &, edm::ConsumesCollector &)

Constructor (for modules migrated to ES-consumes)

Definition: TrackTransformer.cc:32

◆ ~TrackTransformer()

TrackTransformer::~TrackTransformer ( )

override

Destructor.

Definition at line 53 of file TrackTransformer.cc.

53 {}

Member Function Documentation

◆ checkRecHitsOrdering()

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

private

Definition at line 135 of file TrackTransformer.cc.

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

Referenced by transform().

                                                                       {
   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;
 }

◆ 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 55 of file TrackTransformer.cc.

References submitPVResolutionJobs::desc, propagator(), smoother(), and AlCaHLTBitMon_QueryRunRegistry::string.

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

                                                                               {
   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);
 }

◆ getTransientRecHits()

TransientTrackingRecHit::ConstRecHitContainer TrackTransformer::getTransientRecHits ( const reco::TransientTrack & track ) const

Definition at line 107 of file TrackTransformer.cc.

References TransientTrackingRecHitBuilder::build(), Options::const, Exception, FastTime, DetId::Forward, LogTrace, DetId::Muon, mps_fire::result, theMtdAvailable, theMTDRecHitBuilder, theMuonRecHitBuilder, theRPCInTheFit, theTrackerRecHitBuilder, HLT_2024v14_cff::track, and DetId::Tracker.

Referenced by transform().

                                            {
   TransientTrackingRecHit::ConstRecHitContainer result;
   auto tkbuilder = static_cast<TkTransientTrackingRecHitBuilder const*>(theTrackerRecHitBuilder);
 
   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;
 }

◆ magneticField()

const MagneticField* TrackTransformer::magneticField ( ) const

inline

the magnetic field

Definition at line 80 of file TrackTransformer.h.

References theMGField.

Referenced by transform().

80 { return &*theMGField; }

TrackTransformer::theMGField

edm::ESHandle< MagneticField > theMGField

Definition: TrackTransformer.h:109

◆ propagator()

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

inlineprivate

Definition at line 121 of file TrackTransformer.h.

References thePropagator.

Referenced by fillPSetDescription(), and transform().

121 { return thePropagator; }

TrackTransformer::thePropagator

edm::ESHandle< Propagator > thePropagator

Definition: TrackTransformer.h:122

◆ refitter()

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

inline

the refitter used to refit the reco::Track

Definition at line 89 of file TrackTransformer.h.

References theFitter.

89 { return theFitter; }

TrackTransformer::theFitter

std::unique_ptr< TrajectoryFitter > theFitter

Definition: TrackTransformer.h:113

◆ setServices()

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

overridevirtual

set the services needed by the TrackTransformer

Implements TrackTransformerBase.

Definition at line 76 of file TrackTransformer.cc.

References Options::const, hitCloner, edm::ESHandleBase::isValid(), LogTrace, metname, singleTopDQM_cfi::setup, AlCaHLTBitMon_QueryRunRegistry::string, theCacheId_TRH, theFitter, theFitterToken, theMGField, theMGFieldToken, theMtdAvailable, theMTDRecHitBuilder, theMTDRecHitBuilderToken, theMuonRecHitBuilder, theMuonRecHitBuilderToken, thePropagator, thePropagatorToken, theSmoother, theSmootherToken, theTrackerRecHitBuilder, theTrackerRecHitBuilderToken, theTrackingGeometry, and theTrackingGeometryToken.

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

                                                           {
   const std::string metname = "Reco|TrackingTools|TrackTransformer";
 
   theFitter = setup.getData(theFitterToken).clone();
   theSmoother.reset(setup.getData(theSmootherToken).clone());
 
   thePropagator = setup.getHandle(thePropagatorToken);
 
   // Global Tracking Geometry
   theTrackingGeometry = setup.getHandle(theTrackingGeometryToken);
 
   // Magfield Field
   theMGField = setup.getHandle(theMGFieldToken);
 
   // 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!";
     theTrackerRecHitBuilder = &setup.getData(theTrackerRecHitBuilderToken);
     theMuonRecHitBuilder = setup.getHandle(theMuonRecHitBuilderToken);
     theMTDRecHitBuilder = setup.getHandle(theMTDRecHitBuilderToken);
     theMtdAvailable = theMTDRecHitBuilder.isValid();
     hitCloner = static_cast<TkTransientTrackingRecHitBuilder const*>(theTrackerRecHitBuilder)->cloner();
   }
   theFitter->setHitCloner(&hitCloner);
   theSmoother->setHitCloner(&hitCloner);
 }

◆ 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 92 of file TrackTransformer.h.

References theSmoother.

Referenced by fillPSetDescription().

92 { return theSmoother; }

TrackTransformer::theSmoother

std::unique_ptr< TrajectorySmoother > theSmoother

Definition: TrackTransformer.h:117

◆ trackingGeometry()

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

inline

the tracking geometry

Definition at line 83 of file TrackTransformer.h.

References theTrackingGeometry.

Referenced by checkRecHitsOrdering(), and transform().

83 { return theTrackingGeometry; }

TrackTransformer::theTrackingGeometry

edm::ESHandle< GlobalTrackingGeometry > theTrackingGeometry

Definition: TrackTransformer.h:108

◆ 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 154 of file TrackTransformer.cc.

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

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

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

◆ transform() [2/3]

vector< Trajectory > TrackTransformer::transform ( const reco::TrackRef & track ) const

Convert a reco::TrackRef into Trajectory.

Definition at line 105 of file TrackTransformer.cc.

References HLT_2024v14_cff::track, and transform().

105 { return transform(*track); }

HLT_2024v14_cff.track

track

Definition: HLT_2024v14_cff.py:9565

TrackTransformer::transform

std::vector< Trajectory > transform(const reco::Track &) const override

Convert a reco::Track into Trajectory.

Definition: TrackTransformer.cc:154

◆ 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 164 of file TrackTransformer.cc.

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, fileCollector::seed, AlCaHLTBitMon_QueryRunRegistry::string, TrajectoryStateOnSurface::surface(), theDoPredictionsOnly, theFitter, theRefitDirection, theSmoother, HLT_2024v14_cff::track, setupCalibrationTree_cff::trajectories, PV3DBase< T, PVType, FrameType >::x(), and PV3DBase< T, PVType, FrameType >::y().

                                                                                                                    {
   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({}, {}, 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;
 }