#include <TrackParamsEstimationTool.h>

Inheritance diagram for ActsTrk::TrackParamsEstimationTool:

Collaboration diagram for ActsTrk::TrackParamsEstimationTool:

Public Member Functions
	TrackParamsEstimationTool (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~TrackParamsEstimationTool ()=default
virtual StatusCode	initialize () override
virtual std::pair< std::optional< Acts::BoundTrackParameters >, EstimationStatus >	estimateTrackParameters (const ActsTrk::Seed &seed, const Acts::GeometryContext &geoContext, const Acts::MagneticFieldContext &magFieldContext, const Acts::CalibrationContext &calContext, std::function< const Acts::Surface &(const ActsTrk::Seed &seed)> retrieveSurface) const override
virtual std::pair< std::optional< Acts::BoundTrackParameters >, EstimationStatus >	estimateTrackParameters (const ActsTrk::Seed &seed, const Acts::GeometryContext &geoContext, const Acts::MagneticFieldContext &magFieldContext, const Acts::CalibrationContext &calContext, const Acts::Surface &surface, const Acts::Vector3 &bField) const override
SpacePointIndicesFun_t	spacePointIndicesFun () const override

Private Types
using	Stepper = Acts::SympyStepper
using	Navigator = Acts::VoidNavigator
using	Extrapolator = Acts::Propagator<Stepper>

Private Member Functions
std::optional< Acts::BoundTrackParameters >	doRefit (const ActsTrk::Seed &measurement, const Acts::BoundTrackParameters &initialParameters, const Acts::GeometryContext &geometry, const Acts::MagneticFieldContext &magField, const Acts::CalibrationContext &calib) const
const Acts::Logger &	logger () const
	Private access to the logger.

Private Attributes
ToolHandle< ActsTrk::IFitterTool >	m_fitterTool {this, "FitterTool", "", "Fitter Tool for Seeds"}
ServiceHandle< ActsTrk::ITrackingGeometrySvc >	m_trackingGeometrySvc {this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"}
Gaudi::Property< double >	m_sigmaLoc0
Gaudi::Property< double >	m_sigmaLoc1
Gaudi::Property< double >	m_sigmaPhi
Gaudi::Property< double >	m_sigmaTheta
Gaudi::Property< double >	m_sigmaQOverP
Gaudi::Property< double >	m_sigmaT0
Gaudi::Property< double >	m_initialSigmaPtRel
Gaudi::Property< std::vector< double > >	m_initialVarInflation
Gaudi::Property< int >	m_parameterEstimationMode
Gaudi::Property< int >	m_bFieldMode
Gaudi::Property< std::size_t >	m_firstSp
Gaudi::Property< double >	m_minDeltaR
Gaudi::Property< bool >	m_allowPropagatorFailure
Gaudi::Property< std::size_t >	m_stripCalibrationIterations
Gaudi::Property< std::size_t >	m_geometricRefineIterations
Gaudi::Property< double >	m_spacePointWeightExponent
Gaudi::Property< bool >	m_refitSeeds {this, "refitSeeds", false, "Run KalmanFitter on seeds"}
detail::xAODUncalibMeasSurfAcc	m_uncalibMeasSurfAcc {}
std::optional< Extrapolator >	m_extrapolator
std::unique_ptr< const Acts::Logger >	m_logger
	logging instance
SpacePointIndicesFun_t	m_spacePointIndicesFun {}

Detailed Description

Definition at line 29 of file TrackParamsEstimationTool.h.

Member Typedef Documentation

◆ Extrapolator

using ActsTrk::TrackParamsEstimationTool::Extrapolator = Acts::Propagator<Stepper>

private

Definition at line 114 of file TrackParamsEstimationTool.h.

◆ Navigator

using ActsTrk::TrackParamsEstimationTool::Navigator = Acts::VoidNavigator

private

Definition at line 113 of file TrackParamsEstimationTool.h.

◆ Stepper

using ActsTrk::TrackParamsEstimationTool::Stepper = Acts::SympyStepper

private

Definition at line 112 of file TrackParamsEstimationTool.h.

Constructor & Destructor Documentation

◆ TrackParamsEstimationTool()

ActsTrk::TrackParamsEstimationTool::TrackParamsEstimationTool	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 163 of file TrackParamsEstimationTool.cxx.

166 : base_class(type, name, parent)

167 {}

◆ ~TrackParamsEstimationTool()

virtual ActsTrk::TrackParamsEstimationTool::~TrackParamsEstimationTool ( )

virtualdefault

Member Function Documentation

◆ doRefit()

std::optional< Acts::BoundTrackParameters > ActsTrk::TrackParamsEstimationTool::doRefit	(	const ActsTrk::Seed &	measurement,
		const Acts::BoundTrackParameters &	initialParameters,
		const Acts::GeometryContext &	geometry,
		const Acts::MagneticFieldContext &	magField,
		const Acts::CalibrationContext &	calib ) const

private

Definition at line 416 of file TrackParamsEstimationTool.cxx.

                                                 {
    // Perform KF before CKF
    // get the inner-most surface
    const Acts::Surface* targetSurface = m_uncalibMeasSurfAcc.get(measurement.sp().front()->measurements().front());
    if (not targetSurface) {
      ATH_MSG_WARNING("Could not identify the target surface for fitting the provided seed");
      return std::nullopt;
    }
    const auto fittedSeedCollection = m_fitterTool->fit(measurement, initialParameters,
                                                        geometry, magField, calib,
                                                        *targetSurface);
    if (not fittedSeedCollection) {
      ATH_MSG_VERBOSE("KF fit failure");
      return std::nullopt;
    }
    if (fittedSeedCollection->size() != 1) {
      ATH_MSG_WARNING("KF produced " << fittedSeedCollection->size() << " tracks but should produce 1!");
      return std::nullopt;
    }
    const auto fittedSeed = fittedSeedCollection->getTrack(0);
 
    // get the track state at the beginning of the track, where we started
    std::optional<typename decltype(fittedSeed)::ConstTrackStateProxy> trackState = fittedSeed.innermostTrackState();
    if (!trackState) {
      // if the track is not forward linked (fixed by #5666), then we need to search back to the innermost track state
      for (auto st : fittedSeed.trackStatesReversed()) {
        trackState = st;
      }
    }
 
    if (!trackState) {
      ATH_MSG_VERBOSE("Missing innermost track state");
      return std::nullopt;
    }
 
    // Return updated parameters
    return fittedSeed.createParametersFromState(trackState.value());
  };

◆ estimateTrackParameters() [1/2]

std::pair< std::optional< Acts::BoundTrackParameters >, TrackParamsEstimationTool::EstimationStatus > ActsTrk::TrackParamsEstimationTool::estimateTrackParameters	(	const ActsTrk::Seed &	seed,
		const Acts::GeometryContext &	geoContext,
		const Acts::MagneticFieldContext &	magFieldContext,
		const Acts::CalibrationContext &	calContext,
		const Acts::Surface &	surface,
		const Acts::Vector3 &	bField ) const

overridevirtual

Definition at line 245 of file TrackParamsEstimationTool.cxx.

  {
    // Get SPs
    const auto& sp_collection = seed.sp();
    const std::size_t nSp = sp_collection.size();
    if (nSp < 3) return {std::nullopt, kNoSeedRefit};
 
    // Function to extract the values from sp_collection
    const auto sp_collection_extract = std::views::transform([&sp_collection](std::size_t i) {
      return sp_collection.at(i);
    });
 
    // Compute free parameters
    Acts::FreeVector freeParams;
    if (m_parameterEstimationMode == 4) {
      const Acts::Result<Acts::FreeVector> freeParamsResult = estimateTrackParamsFromAllSpacePoints(
        std::views::iota(std::size_t{0}, nSp) | sp_collection_extract, bField, m_stripCalibrationIterations,
        m_geometricRefineIterations, m_spacePointWeightExponent);
      if (!freeParamsResult.ok()) {
        ATH_MSG_DEBUG("Fit of " << nSp << "-SP seed failed - " << freeParamsResult.error().message());
        return {std::nullopt, kNoSeedRefit};
      }
      freeParams = *freeParamsResult;
      // The fit cannot resolve the curvature of a straight seed, and a zero
      // q/p gives NaN in the covariance transport
      if (freeParams[Acts::eFreeQOverP] == 0) {
        ATH_MSG_DEBUG("Fit of " << nSp << "-SP seed did not resolve the curvature - skip seed");
        return {std::nullopt, kNoSeedRefit};
      }
    } else {
      freeParams = estimateTrackParamsFromSeed(m_spacePointIndicesFun(sp_collection) | sp_collection_extract, bField, m_stripCalibrationIterations);
    }
 
    if (m_parameterEstimationMode == 1 && nSp > 3ul) {
      const auto spacePointIndicesFun2 = [](std::size_t nSp) -> std::array<std::size_t, 3> {
        return {0, nSp / 2ul, nSp - 1};
      };
      const Acts::FreeVector freeParams2 = estimateTrackParamsFromSeed(spacePointIndicesFun2(nSp) | sp_collection_extract, bField, m_stripCalibrationIterations);
      ATH_MSG_DEBUG("update seed p = " << 1.0 / freeParams[Acts::eFreeQOverP] << " to " << 1.0 / freeParams2[Acts::eFreeQOverP]);
      freeParams[Acts::eFreeQOverP] = freeParams2[Acts::eFreeQOverP];
    }
 
    // Convert free params to curvilinear params for extrapolation
    Acts::BoundTrackParameters curvilinearParams = Acts::BoundTrackParameters::createCurvilinear(
      freeParams.segment<4>(Acts::eFreePos0),
      freeParams.segment<3>(Acts::eFreeDir0),
      freeParams[Acts::eFreeQOverP],
      std::nullopt,
      Acts::ParticleHypothesis::pion());
 
    // Extrapolate to surface
    Acts::PropagatorPlainOptions propOptions(geoContext, magFieldContext);
    propOptions.direction = Acts::Direction::fromScalarZeroAsPositive(
        surface.intersect(
          geoContext,
          freeParams.segment<3>(Acts::eFreePos0),
          freeParams.segment<3>(Acts::eFreeDir0)
        ).closest().pathLength());
 
    std::optional<Acts::BoundTrackParameters> boundParams;
    auto boundParamsResult =
        m_extrapolator->propagateToSurface(curvilinearParams, surface, propOptions);
 
    if (!boundParamsResult.ok()) {
      ATH_MSG_DEBUG("Extrapolation from " << seed.sp().size() << "-SP seed failed - "
                    << (m_allowPropagatorFailure ? "use curvilinear parameters" : "skip seed"));
      if (m_allowPropagatorFailure) {
        // Fallback: use curvilinear parameters instead of failing
        boundParams = curvilinearParams;
      } else {
        return {std::nullopt, kNoSeedRefit};
      }
    } else {
      boundParams = *boundParamsResult;
    }
 
    // Estimate covariance
    Acts::EstimateTrackParamCovarianceConfig covarianceEstimationConfig = {
      .initialSigmas = {m_sigmaLoc0, m_sigmaLoc1, m_sigmaPhi, m_sigmaTheta, m_sigmaQOverP, m_sigmaT0},
      .initialSigmaPtRel = m_initialSigmaPtRel,
      .initialVarInflation = Eigen::Map<const Acts::BoundVector>(m_initialVarInflation.value().data()),
      .noTimeVarInflation = 1.0,
    };
    boundParams->covariance() = Acts::estimateTrackParamCovariance(
      covarianceEstimationConfig,
      boundParams->parameters(),
      false);
 
    if (!m_refitSeeds) {
      ATH_MSG_DEBUG("estimateTrackParams from " << seed.sp().size() << "-SP seed succeeded");
      return {boundParams, kNoSeedRefit};
    }
 
    auto refitResult = doRefit(seed, *boundParams, geoContext, magFieldContext, calContext);
    ATH_MSG_DEBUG("Refit " << seed.sp().size() << "-SP seed " << (refitResult ? "succeeded" : "failed"));
    if (refitResult) {
      // The covariance of the refit is too small as an input to the CKF,
      // so use the same crude estimate as for the unfitted seed
      refitResult->covariance() = Acts::estimateTrackParamCovariance(
        covarianceEstimationConfig,
        refitResult->parameters(),
        false);
      return {refitResult, kSeedRefitSuccess};
    } else {
      return {boundParams, kSeedRefitFailed};
    }
 
  }

◆ estimateTrackParameters() [2/2]

std::pair< std::optional< Acts::BoundTrackParameters >, TrackParamsEstimationTool::EstimationStatus > ActsTrk::TrackParamsEstimationTool::estimateTrackParameters	(	const ActsTrk::Seed &	seed,
		const Acts::GeometryContext &	geoContext,
		const Acts::MagneticFieldContext &	magFieldContext,
		const Acts::CalibrationContext &	calContext,
		std::function< const Acts::Surface &(const ActsTrk::Seed &seed)>	retrieveSurface ) const

overridevirtual

Definition at line 211 of file TrackParamsEstimationTool.cxx.

  {
    const auto& sp_collection = seed.sp();
    if ( sp_collection.size() < 3 ) return {std::nullopt, kNoSeedRefit};
    const xAOD::SpacePoint* bottom_sp = sp_collection.front();
 
    // Magnetic Field
    ATLASMagneticFieldWrapper magneticField;
    Acts::MagneticFieldProvider::Cache magFieldCache = magneticField.makeCache( magFieldContext );
    Acts::Vector3 bField = *magneticField.getField( Acts::Vector3(bottom_sp->x(), bottom_sp->y(), bottom_sp->z()),
                                                    magFieldCache );
    if (m_bFieldMode == 1) {
        bField[0] = 0.0;
        bField[1] = 0.0;
    }
 
    // Get the surface
    const Acts::Surface& surface = retrieveSurface(seed);
 
    return estimateTrackParameters(
                   seed,
                   geoContext,
                   magFieldContext,
                   calContext,
                   surface,
                   bField);
  }

◆ initialize()

StatusCode ActsTrk::TrackParamsEstimationTool::initialize ( )

overridevirtual

Definition at line 169 of file TrackParamsEstimationTool.cxx.

  {
    ATH_MSG_INFO( "Initializing " << name() << "..." );
 
    ATH_MSG_DEBUG( "Properties Summary:" );
    ATH_MSG_DEBUG( "   " << m_sigmaLoc0 );
    ATH_MSG_DEBUG( "   " << m_sigmaLoc1 );
    ATH_MSG_DEBUG( "   " << m_sigmaPhi );
    ATH_MSG_DEBUG( "   " << m_sigmaTheta );
    ATH_MSG_DEBUG( "   " << m_sigmaQOverP );
    ATH_MSG_DEBUG( "   " << m_sigmaT0 );
    ATH_MSG_DEBUG( "   " << m_initialVarInflation );
    ATH_MSG_DEBUG( "   " << m_bFieldMode );
    ATH_MSG_DEBUG( "   " << m_firstSp );
    ATH_MSG_DEBUG( "   " << m_minDeltaR );
    ATH_MSG_DEBUG( "   " << m_stripCalibrationIterations );
    ATH_MSG_DEBUG( "   " << m_geometricRefineIterations );
    ATH_MSG_DEBUG( "   " << m_spacePointWeightExponent );
    ATH_MSG_DEBUG( "   " << m_refitSeeds );
 
    if (m_bFieldMode != 0 && m_bFieldMode != 1) {
      ATH_MSG_FATAL("bFieldMode must be 0 or 1, but is " << m_bFieldMode.value());
      return StatusCode::FAILURE;
    }
 
    ATH_CHECK(m_fitterTool.retrieve(EnableTool{m_refitSeeds}));
 
    m_logger = makeActsAthenaLogger(this, "Acts");
 
    m_extrapolator = Extrapolator(Stepper(std::make_shared<ATLASMagneticFieldWrapper>()), Navigator(), logger().cloneWithSuffix("Prop"));
 
    m_spacePointIndicesFun = spacePointIndicesFun();
 
    if (m_refitSeeds) {
      ATH_CHECK(m_trackingGeometrySvc.retrieve());
      m_uncalibMeasSurfAcc = detail::xAODUncalibMeasSurfAcc {m_trackingGeometrySvc.get()};
    }
 
    return StatusCode::SUCCESS;
  }

◆ logger()

const Acts::Logger & ActsTrk::TrackParamsEstimationTool::logger ( ) const

inlineprivate

Private access to the logger.

Definition at line 119 of file TrackParamsEstimationTool.h.

    {
      return *m_logger;
    }

◆ spacePointIndicesFun()

ITrackParamsEstimationTool::SpacePointIndicesFun_t ActsTrk::TrackParamsEstimationTool::spacePointIndicesFun ( ) const

override

Definition at line 361 of file TrackParamsEstimationTool.cxx.

                                                                                                         {
    // MinDeltaR
    if (m_parameterEstimationMode == 3) {
      const double minDeltaR = m_minDeltaR;
      return [minDeltaR](const ActsTrk::SpacePointRange& spacePoints) -> std::array<std::size_t, 3> {
        const std::size_t nSp = spacePoints.size();
        std::array<std::size_t, 3> indices{};
        std::size_t nSelected = 0;
        double lastDistance = 0.;
        for (std::size_t i = 0; i < nSp && nSelected < indices.size(); ++i) {
          const xAOD::SpacePoint* sp = spacePoints[i];
          const double distance = Acts::fastHypot(sp->x(), sp->y(), sp->z());
          if (nSelected > 0 && std::abs(distance - lastDistance) <= minDeltaR) {
            continue;
          }
          indices[nSelected++] = i;
          lastDistance = distance;
        }
        if (nSelected < indices.size()) {
          if (nSp > 3ul)
            return {0, nSp / 2ul, nSp - 1};
          else
            return {0, 1, 2};
        }
        return indices;
      };
    }
    // FirstMiddleLast. The fit of all SPs uses the same SPs to detect duplicate seeds.
    if (m_parameterEstimationMode == 2 || m_parameterEstimationMode == 4) {
      return [](const ActsTrk::SpacePointRange& spacePoints) -> std::array<std::size_t, 3> {
        const std::size_t nSp = spacePoints.size();
        if (nSp > 3ul)
          return {0, nSp / 2ul, nSp - 1};
        else
          return {0, 1, 2};
      };
    } else if (m_firstSp > 0ul) {
      std::size_t firstSp = m_firstSp;
      return [firstSp](const ActsTrk::SpacePointRange& spacePoints) -> std::array<std::size_t, 3> {
        const std::size_t nSp = spacePoints.size();
        if (nSp > 3ul) {
          std::size_t first = std::min(firstSp, nSp - 3ul);
          return {first, first + 1, first + 2};
        } else
          return {0, 1, 2};
      };
    } else {
      return [](const ActsTrk::SpacePointRange&) -> std::array<std::size_t, 3> {
        return {0, 1, 2};
      };
    }
  };

Member Data Documentation

◆ m_allowPropagatorFailure

Gaudi::Property<bool> ActsTrk::TrackParamsEstimationTool::m_allowPropagatorFailure

private

Initial value:

{this, "allowPropagatorFailure", false,

"Use curvilinear parameters when propagation fails instead of returning null"}

Definition at line 93 of file TrackParamsEstimationTool.h.

93 {this, "allowPropagatorFailure", false,

94 "Use curvilinear parameters when propagation fails instead of returning null"};

◆ m_bFieldMode

Gaudi::Property<int> ActsTrk::TrackParamsEstimationTool::m_bFieldMode

private

Initial value:

{this, "bFieldMode", 0,

"B-field mode: 0=B-field at the innermost SP; 1=z-component of B-field at the innermost SP"}

Definition at line 87 of file TrackParamsEstimationTool.h.

87 {this, "bFieldMode", 0,

88 "B-field mode: 0=B-field at the innermost SP; 1=z-component of B-field at the innermost SP"};

◆ m_extrapolator

std::optional<Extrapolator> ActsTrk::TrackParamsEstimationTool::m_extrapolator

private

Definition at line 116 of file TrackParamsEstimationTool.h.

◆ m_firstSp

Gaudi::Property<std::size_t> ActsTrk::TrackParamsEstimationTool::m_firstSp

private

Initial value:

{this, "firstSp", 0ul,

"Index of first SP to use"}

Definition at line 89 of file TrackParamsEstimationTool.h.

89 {this, "firstSp", 0ul,

90 "Index of first SP to use"};

detail::ul

unsigned long ul

Definition PrimitiveHelpers.h:47

◆ m_fitterTool

ToolHandle<ActsTrk::IFitterTool> ActsTrk::TrackParamsEstimationTool::m_fitterTool {this, "FitterTool", "", "Fitter Tool for Seeds"}

private

Definition at line 63 of file TrackParamsEstimationTool.h.

63{this, "FitterTool", "", "Fitter Tool for Seeds"};

◆ m_geometricRefineIterations

Gaudi::Property<std::size_t> ActsTrk::TrackParamsEstimationTool::m_geometricRefineIterations

private

Initial value:

{this, "geometricRefineIterations", 0ul,

"Number of geometric refinement iterations of the circle fit (parameterEstimationMode=4)"}

Definition at line 97 of file TrackParamsEstimationTool.h.

97 {this, "geometricRefineIterations", 0ul,

98 "Number of geometric refinement iterations of the circle fit (parameterEstimationMode=4)"};

◆ m_initialSigmaPtRel

Gaudi::Property< double > ActsTrk::TrackParamsEstimationTool::m_initialSigmaPtRel

private

Initial value:

{this, "initialSigmaPtRel", 0.1,

"Initial relative pT resolution"}

Definition at line 79 of file TrackParamsEstimationTool.h.

79 {this, "initialSigmaPtRel", 0.1,

80 "Initial relative pT resolution"};

◆ m_initialVarInflation

Gaudi::Property< std::vector<double> > ActsTrk::TrackParamsEstimationTool::m_initialVarInflation

private

Initial value:

{this, "initialVarInflation", {1., 1., 1., 1., 1., 1.},

"Inflate track variances"}

Definition at line 81 of file TrackParamsEstimationTool.h.

81 {this, "initialVarInflation", {1., 1., 1., 1., 1., 1.},

82 "Inflate track variances"};

◆ m_logger

std::unique_ptr<const Acts::Logger> ActsTrk::TrackParamsEstimationTool::m_logger

private

logging instance

Definition at line 125 of file TrackParamsEstimationTool.h.

◆ m_minDeltaR

Gaudi::Property<double> ActsTrk::TrackParamsEstimationTool::m_minDeltaR

private

Initial value:

{this, "minDeltaR", 15 * Acts::UnitConstants::mm,

"Minimum difference in distance from the origin between the SPs used for the estimate (parameterEstimationMode=3)"}

Definition at line 91 of file TrackParamsEstimationTool.h.

91 {this, "minDeltaR", 15 * Acts::UnitConstants::mm,

92 "Minimum difference in distance from the origin between the SPs used for the estimate (parameterEstimationMode=3)"};

◆ m_parameterEstimationMode

Gaudi::Property< int > ActsTrk::TrackParamsEstimationTool::m_parameterEstimationMode

private

Initial value:

{this, "parameterEstimationMode", 2,
        "0=use 1st 3 SPs, 1=use first,middle,last SPs to improve pT measurement, 2=use for all parameters, "
        "3=use 1st 3 SPs separated by more than minDeltaR, starting from the innermost SP, "
        "4=fit all SPs"}

Definition at line 83 of file TrackParamsEstimationTool.h.

                                                   {this, "parameterEstimationMode", 2,
        "0=use 1st 3 SPs, 1=use first,middle,last SPs to improve pT measurement, 2=use for all parameters, "
        "3=use 1st 3 SPs separated by more than minDeltaR, starting from the innermost SP, "
        "4=fit all SPs"};

◆ m_refitSeeds

Gaudi::Property<bool> ActsTrk::TrackParamsEstimationTool::m_refitSeeds {this, "refitSeeds", false, "Run KalmanFitter on seeds"}

private

Definition at line 101 of file TrackParamsEstimationTool.h.

101{this, "refitSeeds", false, "Run KalmanFitter on seeds"};

◆ m_sigmaLoc0

Gaudi::Property< double > ActsTrk::TrackParamsEstimationTool::m_sigmaLoc0

private

Initial value:

{this, "sigmaLoc0", 1 * Acts::UnitConstants::mm,

"Constant term of the loc0 resolution"}

Definition at line 67 of file TrackParamsEstimationTool.h.

67 {this, "sigmaLoc0", 1 * Acts::UnitConstants::mm,

68 "Constant term of the loc0 resolution"};

◆ m_sigmaLoc1

Gaudi::Property< double > ActsTrk::TrackParamsEstimationTool::m_sigmaLoc1

private

Initial value:

{this, "sigmaLoc1", 1 * Acts::UnitConstants::mm,

"Constant term of the loc1 resolution"}

Definition at line 69 of file TrackParamsEstimationTool.h.

69 {this, "sigmaLoc1", 1 * Acts::UnitConstants::mm,

70 "Constant term of the loc1 resolution"};

◆ m_sigmaPhi

Gaudi::Property< double > ActsTrk::TrackParamsEstimationTool::m_sigmaPhi

private

Initial value:

{this, "sigmaPhi", 0.1 * Acts::UnitConstants::degree,

"Phi angular resolution"}

Definition at line 71 of file TrackParamsEstimationTool.h.

71 {this, "sigmaPhi", 0.1 * Acts::UnitConstants::degree,

72 "Phi angular resolution"};

◆ m_sigmaQOverP

Gaudi::Property< double > ActsTrk::TrackParamsEstimationTool::m_sigmaQOverP

private

Initial value:

{this, "sigmaQOverP", 0.1 * Acts::UnitConstants::e / Acts::UnitConstants::GeV,

"q/p resolution"}

Definition at line 75 of file TrackParamsEstimationTool.h.

75 {this, "sigmaQOverP", 0.1 * Acts::UnitConstants::e / Acts::UnitConstants::GeV,

76 "q/p resolution"};

◆ m_sigmaT0

Gaudi::Property< double > ActsTrk::TrackParamsEstimationTool::m_sigmaT0

private

Initial value:

{this, "sigmaT0", 1 * Acts::UnitConstants::ns,

"Time resolution"}

Definition at line 77 of file TrackParamsEstimationTool.h.

77 {this, "sigmaT0", 1 * Acts::UnitConstants::ns,

78 "Time resolution"};

◆ m_sigmaTheta

Gaudi::Property< double > ActsTrk::TrackParamsEstimationTool::m_sigmaTheta

private

Initial value:

{this, "sigmaTheta", 0.1 * Acts::UnitConstants::degree,

"Theta angular resolution"}

Definition at line 73 of file TrackParamsEstimationTool.h.

73 {this, "sigmaTheta", 0.1 * Acts::UnitConstants::degree,

74 "Theta angular resolution"};

◆ m_spacePointIndicesFun

SpacePointIndicesFun_t ActsTrk::TrackParamsEstimationTool::m_spacePointIndicesFun {}

private

Definition at line 127 of file TrackParamsEstimationTool.h.

127{};

◆ m_spacePointWeightExponent

Gaudi::Property<double> ActsTrk::TrackParamsEstimationTool::m_spacePointWeightExponent

private

Initial value:

{this, "spacePointWeightExponent", 0.,

"Weight each SP in the fit by 1/r^exponent, where 0 gives uniform weights (parameterEstimationMode=4)"}

Definition at line 99 of file TrackParamsEstimationTool.h.

99 {this, "spacePointWeightExponent", 0.,

100 "Weight each SP in the fit by 1/r^exponent, where 0 gives uniform weights (parameterEstimationMode=4)"};

◆ m_stripCalibrationIterations

Gaudi::Property<std::size_t> ActsTrk::TrackParamsEstimationTool::m_stripCalibrationIterations

private

Initial value:

{this, "stripCalibrationIterations", 1ul,

"Number of strip calibration iterations"}

Definition at line 95 of file TrackParamsEstimationTool.h.

95 {this, "stripCalibrationIterations", 1ul,

96 "Number of strip calibration iterations"};

◆ m_trackingGeometrySvc

ServiceHandle<ActsTrk::ITrackingGeometrySvc> ActsTrk::TrackParamsEstimationTool::m_trackingGeometrySvc {this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"}

private

Definition at line 64 of file TrackParamsEstimationTool.h.

64{this, "TrackingGeometrySvc", "ActsTrackingGeometrySvc"};

◆ m_uncalibMeasSurfAcc

detail::xAODUncalibMeasSurfAcc ActsTrk::TrackParamsEstimationTool::m_uncalibMeasSurfAcc {}

private

Definition at line 110 of file TrackParamsEstimationTool.h.

110{};

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

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Extrapolator

◆ Navigator

◆ Stepper

Constructor & Destructor Documentation

◆ TrackParamsEstimationTool()

◆ ~TrackParamsEstimationTool()

Member Function Documentation

◆ doRefit()

◆ estimateTrackParameters() [1/2]

◆ estimateTrackParameters() [2/2]

◆ initialize()

◆ logger()

◆ spacePointIndicesFun()

Member Data Documentation

◆ m_allowPropagatorFailure

◆ m_bFieldMode

◆ m_extrapolator

◆ m_firstSp

◆ m_fitterTool

◆ m_geometricRefineIterations

◆ m_initialSigmaPtRel

◆ m_initialVarInflation

◆ m_logger

◆ m_minDeltaR

◆ m_parameterEstimationMode

◆ m_refitSeeds

◆ m_sigmaLoc0

◆ m_sigmaLoc1

◆ m_sigmaPhi

◆ m_sigmaQOverP

◆ m_sigmaT0

◆ m_sigmaTheta

◆ m_spacePointIndicesFun

◆ m_spacePointWeightExponent

◆ m_stripCalibrationIterations

◆ m_trackingGeometrySvc

◆ m_uncalibMeasSurfAcc