tracking::reco::TrackExtrapolatorTool< propagator_t > Class Template Reference

Public Types
using	PropagatorOptions = typename propagator_t::template Options<ActionList>
	Method to extrapolate to a target surface given a set of BoundTrackParameters.

Public Member Functions
	TrackExtrapolatorTool (propagator_t propagator, const Acts::GeometryContext &gctx, const Acts::MagneticFieldContext &mctx)
void	setDebug (bool debug)
	Turn on/off internal debug flag.
void	setMaxStepSize (double step)
void	setPathLimit (double limit)
std::optional< Acts::BoundTrackParameters >	extrapolate (const Acts::BoundTrackParameters pars, const std::shared_ptr< Acts::Surface > &target_surface)
template<class track_t >
std::optional< Acts::BoundTrackParameters >	extrapolate (track_t track, const std::shared_ptr< Acts::Surface > &target_surface)
	Method to extrapolate to a target surface given a track The method computes which track state is closest to the surface to choose which one to use to extrapolate.
template<class track_t >
std::optional< Acts::BoundTrackParameters >	extrapolateToEcal (track_t track, const std::shared_ptr< Acts::Surface > &target_surface)
	Create an ldmx::TrackState to the extrapolated position.
template<class track_t >
bool	trackStateAtSurface (track_t track, const std::shared_ptr< Acts::Surface > &target_surface, ldmx::Track::TrackState &ts, ldmx::TrackStateType type)
	Create an ldmx::TrackState to the extrapolated position.

Private Attributes
propagator_t	propagator_
Acts::GeometryContext	gctx_
Acts::MagneticFieldContext	mctx_
bool	debug_ {false}
double	max_step_size_ {-1}
double	path_limit_ {-1}

Detailed Description

template<class propagator_t>
class tracking::reco::TrackExtrapolatorTool< propagator_t >

Definition at line 25 of file TrackExtrapolatorTool.h.

Member Typedef Documentation

PropagatorOptions

template<class propagator_t >

using tracking::reco::TrackExtrapolatorTool< propagator_t >::PropagatorOptions = typename propagator_t::template Options<ActionList>

Method to extrapolate to a target surface given a set of BoundTrackParameters.

Parameters

pars	Bound Track Parameters
target_target_surface	The target surface

Returns

optional with BoundTrackParameters

Definition at line 50 of file TrackExtrapolatorTool.h.

Constructor & Destructor Documentation

TrackExtrapolatorTool()

template<class propagator_t >

tracking::reco::TrackExtrapolatorTool< propagator_t >::TrackExtrapolatorTool ( propagator_t propagator, const Acts::GeometryContext & gctx, const Acts::MagneticFieldContext & mctx )

inline

Definition at line 28 of file TrackExtrapolatorTool.h.

      : propagator_(std::move(propagator)), gctx_(gctx), mctx_(mctx) {}

Member Function Documentation

extrapolate() [1/2]

template<class propagator_t >

std::optional< Acts::BoundTrackParameters > tracking::reco::TrackExtrapolatorTool< propagator_t >::extrapolate ( const Acts::BoundTrackParameters pars, const std::shared_ptr< Acts::Surface > & target_surface )

inline

Definition at line 52 of file TrackExtrapolatorTool.h.

                                                        {
    auto intersection = target_surface->intersect(gctx_, pars.position(gctx_),
                                                  pars.direction());
 
    PropagatorOptions p_options(gctx_, mctx_);
    if (max_step_size_ > 0) p_options.stepping.maxStepSize = max_step_size_;
    if (path_limit_ > 0) p_options.pathLimit = path_limit_;
 
    p_options.direction = intersection[0].pathLength() >= 0
                              ? Acts::Direction::Forward()
                              : Acts::Direction::Backward();
 
    auto result = propagator_.propagate(pars, *target_surface, p_options);
 
    // CHECK THE EXTRAPOLATION COVARIANCE MATRIX
 
    if (debug_) {
      if (result.ok()) {
        std::cout << "INITIAL COV MATRIX\n";
        std::cout << (*(pars.covariance())) << std::endl;
 
        std::cout << "FINAL COV MATRIX\n";
        auto opt_pars = *result->endParameters;
        std::cout << *(opt_pars.covariance()) << std::endl;
      }
    }
 
    if (result.ok())
      return *result->endParameters;
    else
      return std::nullopt;
  }  // end of extrapolate()

extrapolate() [2/2]

template<class propagator_t >

template<class track_t >

std::optional< Acts::BoundTrackParameters > tracking::reco::TrackExtrapolatorTool< propagator_t >::extrapolate ( track_t track, const std::shared_ptr< Acts::Surface > & target_surface )

inline

Method to extrapolate to a target surface given a track The method computes which track state is closest to the surface to choose which one to use to extrapolate.

This method doesn't use a measurement, but whatever first/last track state is defined.

Parameters

track	An Acts::Track
target_surface	The target surface

Returns

optional containing the bound track parameters.

Definition at line 98 of file TrackExtrapolatorTool.h.

                                                                       {
    if (debug_) {
      std::cout << "[TrackExtrapolatorTool] extrapolate START\n";
      std::cout << "[TrackExtrapolatorTool]   track.nTrackStates() = "
                << track.nTrackStates() << std::endl;
      std::cout << "[TrackExtrapolatorTool]   target_surface = "
                << target_surface.get() << std::endl;
    }
 
    if (track.nTrackStates() == 0) {
      return std::nullopt;
    }
 
    // Use ACTS's built-in helper to find the measurement track state
    // (first or last) that is closest to the target surface. This correctly
    // handles holes and material-only states which lack filtered parameters.
    auto state_result = Acts::findTrackStateForExtrapolation(
        gctx_, track, *target_surface,
        Acts::TrackExtrapolationStrategy::firstOrLast);
 
    if (!state_result.ok()) {
      return std::nullopt;
    }
 
    const auto& ts = state_result->first;
    const auto& surface = ts.referenceSurface();
 
    Acts::BoundVector params;
    Acts::BoundMatrix cov;
 
    if (ts.hasSmoothed()) {
      if (debug_)
        std::cout << "[TrackExtrapolatorTool]   Using smoothed parameters\n";
      params = ts.smoothed();
      cov = ts.smoothedCovariance();
    } else if (ts.hasFiltered()) {
      if (debug_)
        std::cout << "[TrackExtrapolatorTool]   Using filtered parameters\n";
      params = ts.filtered();
      cov = ts.filteredCovariance();
    } else {
      return std::nullopt;
    }
 
    if (debug_) {
      std::cout << "Surface::"
                << surface.localToGlobalTransform(gctx_).translation()
                << std::endl;
      std::cout << "HasSmoothed::" << ts.hasSmoothed() << std::endl;
      std::cout << "Parameters::" << params.transpose() << std::endl;
    }
 
    auto part_hypo{Acts::ParticleHypothesis::electron()};
    Acts::BoundTrackParameters sp(surface.getSharedPtr(), params, cov,
                                  part_hypo);
    if (debug_)
      std::cout << "[TrackExtrapolatorTool]   calling extrapolate(BTP)...\n";
    auto result = extrapolate(sp, target_surface);
    if (debug_) std::cout << "[TrackExtrapolatorTool]   extrapolate DONE\n";
    return result;
  }

extrapolateToEcal()

template<class propagator_t >

template<class track_t >

std::optional< Acts::BoundTrackParameters > tracking::reco::TrackExtrapolatorTool< propagator_t >::extrapolateToEcal ( track_t track, const std::shared_ptr< Acts::Surface > & target_surface )

inline

Create an ldmx::TrackState to the extrapolated position.

Parameters

track	Acts::Track
target_surface	extrapolation surface
ts	ldmx::Track::TrackState
type	TrackStateType

Returns

optional boolean to check if there was a problem in the extrapolation

Definition at line 171 of file TrackExtrapolatorTool.h.

                                                                       {
    // get last track state on the track.
    // Now.. I'm taking whatever it is. I'm not checking here if it is a
    // measurement.
 
    auto& tsc = track.container().trackStateContainer();
    auto begin = track.trackStates().begin();
    auto ts_last = *begin;
    const auto& surface = (ts_last).referenceSurface();
    const auto& smoothed = (ts_last).smoothed();
    const auto& cov = (ts_last).smoothedCovariance();
 
    // Get the BoundTrackStateParameters
    // assume electron for now
    auto part_hypo{Acts::ParticleHypothesis::electron()};
 
    Acts::BoundTrackParameters state_parameters(surface.getSharedPtr(),
                                                smoothed, cov, part_hypo);
 
    // One can also use directly the extrapolate method
    PropagatorOptions p_options(gctx_, mctx_);
    auto result =
        propagator_.propagate(state_parameters, *target_surface, p_options);
 
    if (result.ok())
      return *result->endParameters;
    else
      return std::nullopt;
  }

setDebug()

template<class propagator_t >

void tracking::reco::TrackExtrapolatorTool< propagator_t >::setDebug ( bool debug )

inline

Turn on/off internal debug flag.

Parameters

debug

Definition at line 38 of file TrackExtrapolatorTool.h.

{ debug_ = debug; }

setMaxStepSize()

template<class propagator_t >

void tracking::reco::TrackExtrapolatorTool< propagator_t >::setMaxStepSize ( double step )

inline

Definition at line 39 of file TrackExtrapolatorTool.h.

{ max_step_size_ = step; }

setPathLimit()

template<class propagator_t >

void tracking::reco::TrackExtrapolatorTool< propagator_t >::setPathLimit ( double limit )

inline

Definition at line 40 of file TrackExtrapolatorTool.h.

{ path_limit_ = limit; }

trackStateAtSurface()

template<class propagator_t >

template<class track_t >

bool tracking::reco::TrackExtrapolatorTool< propagator_t >::trackStateAtSurface ( track_t track, const std::shared_ptr< Acts::Surface > & target_surface, ldmx::Track::TrackState & ts, ldmx::TrackStateType type )

inline

Create an ldmx::TrackState to the extrapolated position.

Parameters

track	Acts::Track
target_surface	extrapolation surface
ts	ldmx::Track::TrackState
type	TrackStateType

Returns

boolean to check if there was a problem in the extrapolation

Definition at line 213 of file TrackExtrapolatorTool.h.

                                                    {
    if (debug_) {
      std::cout << "[TrackExtrapolatorTool] trackStateAtSurface START\n";
      std::cout << "[TrackExtrapolatorTool]   target_surface = "
                << target_surface.get() << std::endl;
      std::cout << "[TrackExtrapolatorTool]   track.nTrackStates() = "
                << track.nTrackStates() << std::endl;
      std::cout << "[TrackExtrapolatorTool]   TrackStateType = "
                << static_cast<int>(type) << std::endl;
      std::cout << "[TrackExtrapolatorTool]   About to call extrapolate...\n";
    }
 
    auto opt_pars = extrapolate(track, target_surface);
 
    if (debug_) {
      std::cout << "[TrackExtrapolatorTool]   extrapolate returned, "
                   "opt_pars.has_value() = "
                << opt_pars.has_value() << std::endl;
    }
 
    if (opt_pars) {
      if (debug_) {
        Acts::Vector3 surf_loc =
            target_surface->localToGlobalTransform(gctx_).translation();
        std::cout << "[TrackExtrapolatorTool]   Surface location: ("
                  << surf_loc(0) << ", " << surf_loc(1) << ", " << surf_loc(2)
                  << ")\n";
      }
 
      ts = tracking::sim::utils::makeTrackState(gctx_, *opt_pars, type);
      if (debug_)
        std::cout << "[TrackExtrapolatorTool]   trackStateAtSurface SUCCESS\n";
      return true;
    } else {
      if (debug_)
        std::cout << "[TrackExtrapolatorTool]   trackStateAtSurface FAILED - "
                     "opt_pars is empty\n";
      return false;
    }
  }

Member Data Documentation

debug_

template<class propagator_t >

bool tracking::reco::TrackExtrapolatorTool< propagator_t >::debug_ {false}

private

Definition at line 261 of file TrackExtrapolatorTool.h.

{false};

gctx_

template<class propagator_t >

Acts::GeometryContext tracking::reco::TrackExtrapolatorTool< propagator_t >::gctx_

private

Definition at line 259 of file TrackExtrapolatorTool.h.

max_step_size_

template<class propagator_t >

double tracking::reco::TrackExtrapolatorTool< propagator_t >::max_step_size_ {-1}

private

Definition at line 262 of file TrackExtrapolatorTool.h.

{-1};

mctx_

template<class propagator_t >

Acts::MagneticFieldContext tracking::reco::TrackExtrapolatorTool< propagator_t >::mctx_

private

Definition at line 260 of file TrackExtrapolatorTool.h.

path_limit_

template<class propagator_t >

double tracking::reco::TrackExtrapolatorTool< propagator_t >::path_limit_ {-1}

private

Definition at line 263 of file TrackExtrapolatorTool.h.

{-1};

propagator_

template<class propagator_t >

propagator_t tracking::reco::TrackExtrapolatorTool< propagator_t >::propagator_

private

Definition at line 258 of file TrackExtrapolatorTool.h.

---

The documentation for this class was generated from the following file:

• Tracking/include/Tracking/Reco/TrackExtrapolatorTool.h