ATALS specific Implementation of the member functions needed by the measurement selector. More...

Inheritance diagram for AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >:

Collaboration diagram for AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >:

Classes
struct	CalibratedMeasurementTraits
struct	Empty

Public Types
using	BASE
using	traits = typename BASE::traits
template<std::size_t DIM>
using	Measurement = typename traits::template CalibratedMeasurement<DIM>
using	abstract_measurement_range_t = BASE::abstract_measurement_range_t
template<std::size_t DIM, typename measurement_t>
using	PreCalibrator
template<std::size_t DIM, typename measurement_t>
using	Calibrator
using	T_BoundState
using	TrackStateProxy
using	PostCalibrator
using	Base = MeasurementSelectorBase< NMeasMax, MeasurementSelectorTraits<derived_t>::s_dimMax, derived_t>
using	trajectory_t = typename Base::trajectory_t
using	Config

Public Member Functions
void	setMeasurementRangesForced (const ActsTrk::detail::MeasurementRangeListFlat *measurementRangesForced)
	AtlasMeasurementSelector (typename BASE::Config &&config, const ActsTrk::detail::MeasurementRangeList &measurementRanges)
template<std::size_t DIM, typename T_ValueType>
void	setCalibrator (const Calibrator< DIM, T_ValueType > &calibrator)
template<std::size_t DIM, typename T_ValueType>
void	setPreCalibrator (typename std::enable_if< s_CanPreCalibrate< DIM >, const PreCalibrator< DIM, T_ValueType > & >::type calibrator)
template<std::size_t DIM>
ParameterMapping::type< DIM >	parameterMap (const Acts::GeometryContext &geometryContext, const Acts::CalibrationContext &calibrationContext, const Acts::Surface &surface) const
template<std::size_t DIM, typename measurement_t>
const Calibrator< DIM, measurement_t > &	postCalibrator () const
template<std::size_t DIM, typename measurement_t>
auto	preCalibrator () const
std::tuple< const measurement_container_variant_t *, abstract_measurement_range_t, bool >	containerAndRange (const Acts::Surface &surface) const
bool	expectMeasurements (const Acts::Surface &surface, const measurement_container_variant_t *container_variant_ptr, const abstract_measurement_range_t &abstract_range) const
template<typename measurement_container_t>
auto	rangeForContainer (const measurement_container_t &concrete_container, const abstract_measurement_range_t &abstract_range) const
ParameterMapping::type< DIM >	parameterMap (const Acts::GeometryContext &, const Acts::CalibrationContext &, const Acts::Surface &)
Acts::Result< boost::container::small_vector< typename TrackStateProxy::IndexType, s_maxBranchesPerSurface > >	createTrackStates (const Acts::GeometryContext &geometryContext, const Acts::CalibrationContext &calibrationContext, const Acts::Surface &surface, const T_BoundState &boundState, typename TrackStateProxy::IndexType prevTip, std::vector< TrackStateProxy > &trackStateCandidates, trajectory_t &trajectory, const Acts::Logger &logger) const
std::tuple< std::size_t, std::pair< float, float > >	getCuts (const Acts::Surface &surface, const T_BoundState &boundState, const Acts::Logger &logger) const

Static Public Member Functions
template<typename MeasurementRangeList_t>
static std::tuple< const measurement_container_variant_t *, abstract_measurement_range_t, bool >	containerAndRangeSingle (const MeasurementRangeList_t &measurementRanges, const Acts::Surface &surface, bool forced)
static const MeasurementSelectorTraits< AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t > >::BoundTrackParameters &	boundParams (const T_BoundState &boundState)
static const MeasurementSelectorTraits< AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t > >::BoundMatrix &	boundJacobiMatrix (const T_BoundState &boundState)
static double	pathLength (const T_BoundState &boundState)
static const auto &	forwardToCalibrator (const T &a)
static auto	rangeForContainer (const measurement_container_t &concrete_container, const abstract_measurement_range_t &abstract_range)
	Create a range over elements of the given container from an abstract range.
static constexpr std::size_t	dimMax ()

Public Attributes
const ActsTrk::detail::MeasurementRangeList *	m_measurementRanges {}
const ActsTrk::detail::MeasurementRangeListFlat *	m_measurementRangesForced {}
ActsTrk::MeasurementParameterMap	m_projector {}
CalibratorRegistry< CalibratedMeasurementTraits, measurement_container_variant_t, typename traits::TrackStateProxy >	m_calibrators {}
std::conditional< s_fullPreCalibration, PreCalibratorRegistry< CalibratedMeasurementTraits, measurement_container_variant_t, typenametraits::BoundTrackParameters >, Empty >::type	m_preCalibrators {}
Config	m_config

Static Public Attributes
template<std::size_t DIM>
static constexpr bool	s_CanPreCalibrate
static constexpr std::size_t	s_maxBranchesPerSurface = Base::s_maxBranchesPerSurface

Protected Member Functions
const derived_t &	derived () const
unsigned int	makeOutlierFlag (bool value)
Acts::Result< boost::container::small_vector< typename TrackStateProxy::IndexType, s_maxBranchesPerSurface > >	selectMeasurementsCreateTrackStates (const Acts::GeometryContext &geometryContext, const Acts::CalibrationContext &calibrationContext, const Acts::Surface &surface, const T_BoundState &boundState, T_MeasurementRange &&measurement_range, std::size_t prevTip, trajectory_t &trajectory, const Acts::Logger &logger, const std::size_t numMeasurementsCut, const std::pair< float, float > &maxChi2Cut, bool forced) const

Static Protected Member Functions
static void	createStates (std::size_t n_new_states, const T_BoundState &boundState, std::size_t prevTip, trajectory_t &trajectory, const Acts::BoundSubspaceIndices &subspaceIndices, boost::container::small_vector< typename TrackStateProxy::IndexType, s_maxBranchesPerSurface > &track_states, const Acts::Logger &logger, bool outlier_states)
static std::size_t	getEtaBin (const parameters_t &boundParameters, const std::vector< float > &etaBins)

Detailed Description

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>
struct AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >

ATALS specific Implementation of the member functions needed by the measurement selector.

Definition at line 154 of file AtlasMeasurementSelector.cxx.

Member Typedef Documentation

◆ abstract_measurement_range_t

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>

using AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::abstract_measurement_range_t = BASE::abstract_measurement_range_t

Definition at line 169 of file AtlasMeasurementSelector.cxx.

◆ BASE

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>

using AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::BASE

Initial value:

MeasurementSelectorBaseImpl<NMeasMax,
     AtlasMeasurementSelector<NMeasMax, traj_t, measurement_container_variant_t> ,
                                           measurement_container_variant_t >

Definition at line 160 of file AtlasMeasurementSelector.cxx.

◆ Base

template<std::size_t NMeasMax, typename derived_t, typename measurement_container_variant_t>

using MeasurementSelectorWithDispatch< NMeasMax, derived_t, measurement_container_variant_t >::Base = MeasurementSelectorBase< NMeasMax, MeasurementSelectorTraits<derived_t>::s_dimMax, derived_t>

inherited

Definition at line 722 of file MeasurementSelector.h.

◆ Calibrator

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>

template<std::size_t DIM, typename measurement_t>

using AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::Calibrator

Initial value:

CalibratorTypeTraits<CalibratedMeasurementTraits,
                                          measurement_container_variant_t,
                                          typename traits::TrackStateProxy>::template Calibrator<DIM,measurement_t>

Definition at line 192 of file AtlasMeasurementSelector.cxx.

◆ Config

using MeasurementSelectorBase< NMeasMax, DIMMAX, derived_t >::Config

inherited

Definition at line 323 of file MeasurementSelector.h.

◆ Measurement

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>

template<std::size_t DIM>

using AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::Measurement = typename traits::template CalibratedMeasurement<DIM>

Definition at line 167 of file AtlasMeasurementSelector.cxx.

◆ PostCalibrator

using MeasurementSelectorBaseImpl< NMeasMax, AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >, measurement_container_variant_t >::PostCalibrator

inherited

Definition at line 867 of file MeasurementSelector.h.

◆ PreCalibrator

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>

template<std::size_t DIM, typename measurement_t>

using AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::PreCalibrator

Initial value:

PreCalibratorTypeTraits<CalibratedMeasurementTraits,
                                                measurement_container_variant_t,
                                                typename traits::BoundTrackParameters>::template Calibrator<DIM,measurement_t>

Definition at line 187 of file AtlasMeasurementSelector.cxx.

◆ T_BoundState

using MeasurementSelectorBaseImpl< NMeasMax, AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >, measurement_container_variant_t >::T_BoundState

inherited

Definition at line 800 of file MeasurementSelector.h.

◆ TrackStateProxy

using MeasurementSelectorBaseImpl< NMeasMax, AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >, measurement_container_variant_t >::TrackStateProxy

inherited

Definition at line 801 of file MeasurementSelector.h.

◆ traits

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>

using AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::traits = typename BASE::traits

Definition at line 164 of file AtlasMeasurementSelector.cxx.

◆ trajectory_t

template<std::size_t NMeasMax, typename derived_t, typename measurement_container_variant_t>

using MeasurementSelectorWithDispatch< NMeasMax, derived_t, measurement_container_variant_t >::trajectory_t = typename Base::trajectory_t

inherited

Definition at line 724 of file MeasurementSelector.h.

Constructor & Destructor Documentation

◆ AtlasMeasurementSelector()

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>

AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::AtlasMeasurementSelector	(	typename BASE::Config &&	config,
		const ActsTrk::detail::MeasurementRangeList &	measurementRanges )

inline

Definition at line 215 of file AtlasMeasurementSelector.cxx.

      : BASE{std::move(config)},
        m_measurementRanges(&measurementRanges)
   {}

Member Function Documentation

◆ boundJacobiMatrix()

const MeasurementSelectorTraits< AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t > >::BoundMatrix & MeasurementSelectorBaseImpl< NMeasMax, AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >, measurement_container_variant_t >::boundJacobiMatrix ( const T_BoundState & boundState )

inlinestaticinherited

Definition at line 810 of file MeasurementSelector.h.

                                                                                                                    {
      return std::get<1>(boundState);
   }

◆ boundParams()

const MeasurementSelectorTraits< AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t > >::BoundTrackParameters & MeasurementSelectorBaseImpl< NMeasMax, AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >, measurement_container_variant_t >::boundParams ( const T_BoundState & boundState )

inlinestaticinherited

Definition at line 805 of file MeasurementSelector.h.

                                                                                                                       {
      return std::get<0>(boundState);
   }

◆ containerAndRange()

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>

std::tuple< const measurement_container_variant_t *, abstract_measurement_range_t, bool > AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::containerAndRange ( const Acts::Surface & surface ) const

inline

Definition at line 280 of file AtlasMeasurementSelector.cxx.

                                                       {
      if (m_measurementRangesForced) {
          auto ret = containerAndRangeSingle(*m_measurementRangesForced, surface, true);
          if (std::get<0>(ret)) return ret;
      }
      return containerAndRangeSingle(*m_measurementRanges, surface, false);
   }

◆ containerAndRangeSingle()

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>

template<typename MeasurementRangeList_t>

std::tuple< const measurement_container_variant_t *, abstract_measurement_range_t, bool > AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::containerAndRangeSingle	(	const MeasurementRangeList_t &	measurementRanges,
		const Acts::Surface &	surface,
		bool	forced )

inlinestatic

Definition at line 291 of file AtlasMeasurementSelector.cxx.

                                                                                                                     {
      typename MeasurementRangeList_t::const_iterator range_iter = measurementRanges.find(surface.geometryId().value());
      if (range_iter == measurementRanges.end())
      {
         return {nullptr, abstract_measurement_range_t{}, forced};
      }
      else {
         abstract_measurement_range_t range{range_iter->second.elementBeginIndex(),
                                            range_iter->second.elementEndIndex()};
         assert( !range_iter->second.isMeasurementExpected() || range.begin() <= range.end());
         // if surface marked as defect
         return { forced || range_iter->second.isMeasurementExpected() ? &(measurementRanges.container(range_iter->second.containerIndex())) : nullptr,
                 std::move(range), forced};
      }
   }

◆ createStates()

void MeasurementSelectorBase< NMeasMax, DIMMAX, derived_t >::createStates	(	std::size_t	n_new_states,
		const T_BoundState &	boundState,
		std::size_t	prevTip,
		trajectory_t &	trajectory,
		const Acts::BoundSubspaceIndices &	subspaceIndices,
		boost::container::small_vector< typename TrackStateProxy::IndexType, s_maxBranchesPerSurface > &	track_states,
		const Acts::Logger &	logger,
		bool	outlier_states )

inlinestaticprotectedinherited

Definition at line 360 of file MeasurementSelector.h.

                                                 {
      // create track states for all compatible measurement candidates
      const auto &boundParams = derived_t::boundParams(boundState);
      const auto &pathLength = derived_t::pathLength(boundState);
 
      using PM = Acts::TrackStatePropMask;
 
      track_states.reserve( n_new_states );
      std::optional<TrackStateProxy> firstTrackState{
         std::nullopt};
      for (unsigned int state_i=0; state_i<n_new_states; ++state_i) {
         PM mask = PM::Predicted | PM::Filtered | PM::Jacobian | PM::Calibrated;
 
         if (firstTrackState.has_value()) {
            // subsequent track states don't need storage for these as they will
            // be shared
            mask &= ~PM::Predicted & ~PM::Jacobian;
         }
 
         if (outlier_states) {
            // outlier won't have separate filtered parameters
            mask &= ~PM::Filtered;
         }
 
         TrackStateProxy trackState = trajectory.makeTrackState(mask, prevTip);
         ACTS_VERBOSE("Create SourceLink output track state #"
                      << trackState.index() << " with mask: " << mask);
 
         if (firstTrackState.has_value()) {
            trackState.shareFrom(*firstTrackState, PM::Predicted);
            trackState.shareFrom(*firstTrackState, PM::Jacobian);
         }
         else {
            // only set these for first
            trackState.predicted() = boundParams.parameters();
            if (boundParams.covariance()) {
               trackState.predictedCovariance() = *boundParams.covariance();
            }
            trackState.jacobian() = derived_t::boundJacobiMatrix(boundState);
            firstTrackState = trackState;
         }
         trackState.pathLength() = pathLength;
 
         trackState.setReferenceSurface(boundParams.referenceSurface().getSharedPtr());
 
         trackState.setProjectorSubspaceIndices(subspaceIndices);
 
         auto typeFlags = trackState.typeFlags();
         if (trackState.referenceSurface().surfaceMaterial() != nullptr) {
            typeFlags.setHasMaterial();
         }
         typeFlags.setHasParameters();
 
         // @TODO these track states still need some additional processing. Should there be a special
         //       flag for this ?
         track_states.push_back( trackState.index());
      }
   }

◆ createTrackStates()

template<std::size_t NMeasMax, typename derived_t, typename measurement_container_variant_t>

Acts::Result< boost::container::small_vector< typename TrackStateProxy::IndexType, s_maxBranchesPerSurface > > MeasurementSelectorWithDispatch< NMeasMax, derived_t, measurement_container_variant_t >::createTrackStates	(	const Acts::GeometryContext &	geometryContext,
		const Acts::CalibrationContext &	calibrationContext,
		const Acts::Surface &	surface,
		const T_BoundState &	boundState,
		typename TrackStateProxy::IndexType	prevTip,
		std::vector< TrackStateProxy > &	trackStateCandidates,
		trajectory_t &	trajectory,
		const Acts::Logger &	logger ) const

inlineinherited

Definition at line 734 of file MeasurementSelector.h.

                                                    {
 
      Acts::Result<boost::container::small_vector< typename TrackStateProxy::IndexType, s_maxBranchesPerSurface> >
         result = Acts::CombinatorialKalmanFilterError::MeasurementSelectionFailed;
      // get associated measurement container and the relevant measurement range for the given surface.
      auto [a_measurement_container_variant_ptr, range, forced] = this->derived().containerAndRange(surface);
      if (!forced && !this->derived().expectMeasurements( surface, a_measurement_container_variant_ptr, range)) {
         result = result.failure(Acts::CombinatorialKalmanFilterError::NoMeasurementExpected);
         return result;
      }
      if (!range.empty()) {
         auto [numMeasurementsCut, maxChi2Cut] = this->getCuts(surface,boundState, logger);
         // numMeasurementsCut is == 0 in case getCuts failed
         // anyway cannot select anything if numMeasurementsCut==0;
         if (numMeasurementsCut>0) {
 
            result = std::visit( [this,
                                  &geometryContext,
                                  &calibrationContext,
                                  &surface,
                                  &boundState,
                                  &range,
                                  prevTip,
                                  &trajectory,
                                  &logger,
                                  numMeasurementsCut,
                                  &maxChi2Cut,
                                  forced] (const auto &measurement_container_with_dimension) {
               using ArgType = std::remove_cv_t<std::remove_reference_t< decltype(measurement_container_with_dimension) > >;
               constexpr std::size_t DIM = ArgType::dimension();
               auto measurement_range = this->derived().rangeForContainer(measurement_container_with_dimension,range);
               return
                  this->template
                  selectMeasurementsCreateTrackStates<DIM, decltype(measurement_range)>(geometryContext,
                                                           calibrationContext,
                                                           surface,
                                                           boundState,
                                                           std::move(measurement_range),
                                                           prevTip,
                                                           trajectory,
                                                           logger,
                                                           numMeasurementsCut,
                                                           maxChi2Cut,
                                                           forced);
            },
            *a_measurement_container_variant_ptr);
         }
      }
      else {
         result = Acts::Result<boost::container::small_vector< typename TrackStateProxy::IndexType, s_maxBranchesPerSurface> >::success({});
      }
      return result;
   }

◆ derived()

const derived_t & MeasurementSelectorBase< NMeasMax, DIMMAX, derived_t >::derived ( ) const

inlineprotectedinherited

Definition at line 334 of file MeasurementSelector.h.

334{ return *static_cast<const derived_t *>(this); }

◆ dimMax()

template<std::size_t NMeasMax, typename derived_t, typename measurement_container_variant_t>

constexpr std::size_t MeasurementSelectorWithDispatch< NMeasMax, derived_t, measurement_container_variant_t >::dimMax ( )

inlinestaticconstexprinherited

Definition at line 729 of file MeasurementSelector.h.

                                       {
      return MeasurementSelectorTraits<derived_t>::s_dimMax;
   }

◆ expectMeasurements()

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>

bool AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::expectMeasurements	(	const Acts::Surface &	surface,
		const measurement_container_variant_t *	container_variant_ptr,
		const abstract_measurement_range_t &	abstract_range ) const

inline

Definition at line 307 of file AtlasMeasurementSelector.cxx.

                                                                                     {
      return (abstract_range.begin()<=abstract_range.end());
   }

◆ forwardToCalibrator()

const auto & MeasurementSelectorBaseImpl< NMeasMax, AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >, measurement_container_variant_t >::forwardToCalibrator ( const T & a )

inlinestaticinherited

Definition at line 822 of file MeasurementSelector.h.

                                                      {
      if constexpr( std::is_same<T, std::remove_pointer_t<T> >::value ) {
         return a;
      }
      else {
         return *a;
      }
   }

◆ getCuts()

std::tuple< std::size_t, std::pair< float, float > > MeasurementSelectorBase< NMeasMax, DIMMAX, derived_t >::getCuts	(	const Acts::Surface &	surface,
		const T_BoundState &	boundState,
		const Acts::Logger &	logger ) const

inlineinherited

Definition at line 673 of file MeasurementSelector.h.

                                                                                             {
      std::tuple< std::size_t, std::pair<float,float> > result;
      std::size_t &numMeasurementsCut = std::get<0>(result);
      std::pair<float,float> &maxChi2Cut = std::get<1>(result);
      // Get geoID of this surface
      auto geoID = surface.geometryId();
      // Find the appropriate cuts
      auto cuts = m_config.find(geoID);
      if (cuts == m_config.end()) {
         // indicates failure
         numMeasurementsCut = 0;
      }
      else {
         // num measurement Cut
         // getchi2 cut
         std::size_t eta_bin = getEtaBin(derived().boundParams(boundState), cuts->etaBins);
         numMeasurementsCut = (!cuts->numMeasurementsCutOff.empty()
                               ? cuts->numMeasurementsCutOff[ std::min(cuts->numMeasurementsCutOff.size()-1, eta_bin) ]
                               : NMeasMax);
         maxChi2Cut = ! cuts->chi2CutOff.empty()
            ? cuts->chi2CutOff[ std::min(cuts->chi2CutOff.size()-1, eta_bin) ]
            : std::make_pair<float,float>(std::numeric_limits<float>::max(),
                                          std::numeric_limits<float>::max());
         ACTS_VERBOSE("Get cut for eta-bin="
                      << (eta_bin < cuts->etaBins.size() ? cuts->etaBins[eta_bin] : std::numeric_limits<float>::max())
                      << ": chi2 (max,max-outlier) " << maxChi2Cut.first << ", " << maxChi2Cut.second
                      << " max.meas." << numMeasurementsCut);
      }
      return result;
   }

◆ getEtaBin()

std::size_t MeasurementSelectorBase< NMeasMax, DIMMAX, derived_t >::getEtaBin	(	const parameters_t &	boundParameters,
		const std::vector< float > &	etaBins )

inlinestaticprotectedinherited

Definition at line 654 of file MeasurementSelector.h.

                                                                 {
      if (etaBins.empty()) {
         return 0u;  // shortcut if no etaBins
      }
      const float eta = std::abs(std::atanh(std::cos(boundParameters.parameters()[Acts::eBoundTheta])));
      std::size_t bin = 0;
      for (auto etaBin : etaBins) {
         if (etaBin >= eta) {
            break;
         }
         bin++;
      }
      return bin;
   }

◆ makeOutlierFlag()

unsigned int MeasurementSelectorBase< NMeasMax, DIMMAX, derived_t >::makeOutlierFlag ( bool value )

inlineprotectedinherited

Definition at line 446 of file MeasurementSelector.h.

446{ return static_cast<unsigned int>(value)<<2u; }

◆ parameterMap() [1/2]

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>

template<std::size_t DIM>

ParameterMapping::type< DIM > AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::parameterMap	(	const Acts::GeometryContext &	geometryContext,
		const Acts::CalibrationContext &	calibrationContext,
		const Acts::Surface &	surface ) const

inline

Definition at line 242 of file AtlasMeasurementSelector.cxx.

                                                  {
      return m_projector.parameterMap<DIM>(geometryContext,calibrationContext,surface);
   }

◆ parameterMap() [2/2]

ParameterMapping::type< DIM > MeasurementSelectorBaseImpl< NMeasMax, AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >, measurement_container_variant_t >::parameterMap	(	const Acts::GeometryContext &	,
		const Acts::CalibrationContext &	,
		const Acts::Surface &	)

inlineinherited

Definition at line 838 of file MeasurementSelector.h.

                                    {
      return ParameterMapping::identity<DIM>();
   }

◆ pathLength()

double MeasurementSelectorBaseImpl< NMeasMax, AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >, measurement_container_variant_t >::pathLength ( const T_BoundState & boundState )

inlinestaticinherited

Definition at line 814 of file MeasurementSelector.h.

                                                             {
      return std::get<2>(boundState);
   }

◆ postCalibrator()

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>

template<std::size_t DIM, typename measurement_t>

const Calibrator< DIM, measurement_t > & AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::postCalibrator ( ) const

inline

Definition at line 251 of file AtlasMeasurementSelector.cxx.

                          {
      return m_calibrators.template calibrator<DIM,measurement_t>();
   }

◆ preCalibrator()

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>

template<std::size_t DIM, typename measurement_t>

auto AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::preCalibrator ( ) const

inline

Definition at line 258 of file AtlasMeasurementSelector.cxx.

                         {
      if constexpr(s_fullPreCalibration) {
         // full calibration during selection
         return m_preCalibrators.template calibrator<DIM,measurement_t>();
      }
      else  {
         // no calibration is performed before the measurement selection, so just Eigen maps to the stored location
         // and covariance are returned.
         // @TODO unfortunately the Eigen Maps cannot be used directly because they are incompatible with the
         //       temporary measurement storage used in the measurement selector, so need to convert to the
         //       above ConstVectorMapWithInvalidDef etc. Does this introduce some overhead ?
         return []( [[maybe_unused]] const Acts::GeometryContext&,
                    [[maybe_unused]] const Acts::CalibrationContext&,
                    [[maybe_unused]] const Acts::Surface&,
                    const measurement_t &measurement,
                    [[maybe_unused]] const typename traits::BoundTrackParameters &) {
               return std::make_tuple( measurement.template localPosition<DIM>(), measurement.template localCovariance<DIM>(), 0u );
             };
      }
   }

◆ rangeForContainer() [1/2]

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>

template<typename measurement_container_t>

auto AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::rangeForContainer	(	const measurement_container_t &	concrete_container,
		const abstract_measurement_range_t &	abstract_range ) const

inline

Definition at line 315 of file AtlasMeasurementSelector.cxx.

                                                                               {
      unsigned int begin_idx = abstract_range.front();
      auto begin_iter = concrete_container.container().begin() + begin_idx;
      auto end_iter = begin_iter + static_cast<unsigned int>(abstract_range.size());
      return  std::ranges::subrange(begin_iter, end_iter);
   }

◆ rangeForContainer() [2/2]

auto MeasurementSelectorBaseImpl< NMeasMax, AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >, measurement_container_variant_t >::rangeForContainer	(	const measurement_container_t &	concrete_container,
		const abstract_measurement_range_t &	abstract_range )

staticinherited

Create a range over elements of the given container from an abstract range.

Template Parameters

measurement_container_t a concrete container type which is one of one of the possible types of measurement_container_variant_t

Parameters

abstract_range the range as returned by containerAndRange

Returns: an itrerable range over elements of the given specified by the abstract range.

◆ selectMeasurementsCreateTrackStates()

Acts::Result< boost::container::small_vector< typename TrackStateProxy::IndexType, s_maxBranchesPerSurface > > MeasurementSelectorBase< NMeasMax, DIMMAX, derived_t >::selectMeasurementsCreateTrackStates	(	const Acts::GeometryContext &	geometryContext,
		const Acts::CalibrationContext &	calibrationContext,
		const Acts::Surface &	surface,
		const T_BoundState &	boundState,
		T_MeasurementRange &&	measurement_range,
		std::size_t	prevTip,
		trajectory_t &	trajectory,
		const Acts::Logger &	logger,
		const std::size_t	numMeasurementsCut,
		const std::pair< float, float > &	maxChi2Cut,
		bool	forced ) const

inlineprotectedinherited

Definition at line 464 of file MeasurementSelector.h.

                                                          {
      Acts::Result<boost::container::small_vector< typename TrackStateProxy::IndexType, s_maxBranchesPerSurface> >
         result = boost::container::small_vector< typename TrackStateProxy::IndexType, s_maxBranchesPerSurface>{};
 
      using iterator_t = decltype(measurement_range.begin());
      using container_value_t  = typename MeasurementSelectorTraits<derived_t>::template MeasurementContainerTraits<iterator_t>::value_type;
      using BaseElementType = std::remove_cv_t<std::remove_pointer_t< container_value_t > >;
      // get calibrator
      using TheMatchingMeasurement = MatchingMeasurement<DIM, container_value_t >;
      using MeasCovPair = TheMatchingMeasurement::MeasCovPair;
 
      using Predicted = typename MeasurementSelectorTraits<derived_t>::template Predicted<DIM>;
      using PredictedCovariance = typename MeasurementSelectorTraits<derived_t>::template PredictedCovariance<DIM>;
 
 
 
      // get prediction in the measurement domain
      Acts::SubspaceIndices<DIM> parameter_map = derived().template parameterMap<DIM>(geometryContext,
                                                                                       calibrationContext,
                                                                                       surface);
      auto predicted
         = std::make_pair( project<DIM, Predicted>(parameter_map,
                                                   derived().boundParams(boundState).parameters()),
                           project<DIM, PredictedCovariance>(parameter_map,
                                                             derived().boundParams(boundState).covariance().value()));
 
      // select n measurents with the smallest chi2.
      auto preCalibrator = derived().template preCalibrator<DIM, BaseElementType>();
      auto postCalibrator = derived().template postCalibrator<DIM, BaseElementType>();
      TopCollection<NMeasMax, TheMatchingMeasurement > selected_measurements(numMeasurementsCut);
      for ( const auto &measurement : measurement_range ) {
         TheMatchingMeasurement &matching_measurement=selected_measurements.slot();
         if (forced && postCalibrator) {
            // skip preCalibrator and computeChi2, by doing everything else. We start with what's done if no preCalibrator.
            const auto &m = derived().forwardToCalibrator(measurement);
            matching_measurement.m_measurement = std::make_tuple( m.template localPosition<DIM>(), m.template localCovariance<DIM>(), 0u );
            matching_measurement.m_chi2 = 0.0f;
            matching_measurement.m_sourceLink=measurement;
            if (!selected_measurements.acceptNoSort()) break;
         } else {
            matching_measurement.m_measurement = preCalibrator(geometryContext,
                                                               calibrationContext,
                                                               surface,
                                                               derived().forwardToCalibrator(measurement),
                                                               derived().boundParams(boundState));
            matching_measurement.m_chi2 = computeChi2(matching_measurement.m_measurement.position(),
                                                      matching_measurement.m_measurement.covariance(),
                                                      predicted.first,
                                                      predicted.second);
            // only consider measurements which pass the outlier chi2 cut
            if (matching_measurement.m_chi2<maxChi2Cut.second) {
                matching_measurement.m_sourceLink=measurement;
                selected_measurements.acceptAndSort([](const TheMatchingMeasurement &a,
                                                       const TheMatchingMeasurement &b) {
                   return a.m_chi2 < b.m_chi2;
                });
            }
         }
      }
 
      if (selected_measurements.empty()) {
         auto config_for_surface = m_config.find(surface.geometryId());
         if (config_for_surface != m_config.end()) {
            if (config_for_surface->edgeTolerance.has_value()) {
               // if the  prediction failes the bound test, where the edgeTolerance is expected to be negative
               // then the "hole" is considered to be an edge hole which is not treated as a hole.
               auto local_coords  = derived().boundParams(boundState).parameters().template block<2,1>(0,0);
               if (!surface.insideBounds(local_coords,config_for_surface->edgeTolerance.value())) {
                  result = result.failure(Acts::CombinatorialKalmanFilterError::NoMeasurementExpected);
               }
            }
         }
      }
      else {
 
         // apply final calibration to n-best measurements
         // First Create states without setting information about the calibrated measurement for the selected measurements
         // @TODO first create state then copy measurements, or crete state by state and set measurements ?
         //       the lastter has the "advantage" that the outlier flag can be set individually
         //       the former has the advantage that part of the state creation code is independent of the
         //       the measurement.
 
         Acts::BoundSubspaceIndices boundSubspaceIndices;
         std::copy(parameter_map.begin(), parameter_map.end(), boundSubspaceIndices.begin());
         createStates( selected_measurements.size(),
                       boundState,
                       prevTip,
                       trajectory,
                       boundSubspaceIndices,
                       *result,
                       logger,
                       (!selected_measurements.empty()
                        ? selected_measurements.getSlot( *(selected_measurements.begin())).m_measurement.flags().isOutlier() || postCalibrator
                        : false) );
         assert( result->size() == selected_measurements.size() );
 
         if (postCalibrator) {
            // either run post selection calibrator which will set the calibrated position and covariance
            // directly to the state.
            auto predicted_pos_dbl = predicted.first.template cast<double>();
            auto predicted_cov_dbl = predicted.second.template cast<double>();
            unsigned int state_i=0u;
            for (typename TopCollection<NMeasMax, MeasCovPair >::IndexType
                    idx: selected_measurements) {
               assert( state_i < result->size());
               TrackStateProxy trackState( trajectory.getTrackState( (*result)[state_i] ) );
               TheMatchingMeasurement &a_selected_measurement = selected_measurements.getSlot(idx);
               trackState.setUncalibratedSourceLink(ActsTrk::detail::MeasurementCalibratorBase::pack(std::move(a_selected_measurement.m_sourceLink.value())));
 
               // apply the calibration
               postCalibrator(geometryContext,
                              calibrationContext,
                              derived().forwardToCalibrator(a_selected_measurement.m_sourceLink.value()),
                              trackState
                              );
               // update chi2 using calibrated measurement
               trackState.chi2() = computeChi2(trackState.template calibrated<DIM>(),
                                               trackState.template calibratedCovariance<DIM>(),
                                               predicted_pos_dbl,
                                               predicted_cov_dbl);
               // ... and set outlier flag
               // and share or create storage for filtered.
               bool is_outlier = !forced && trackState.chi2() >= maxChi2Cut.first;
               if (is_outlier) {
                  trackState.typeFlags().setIsOutlier();
                  trackState.shareFrom(trackState, Acts::TrackStatePropMask::Predicted,
                                       Acts::TrackStatePropMask::Filtered);
               } else {
                  trackState.typeFlags().setIsMeasurement();
                  trackState.addComponents(Acts::TrackStatePropMask::Filtered);
               }
               ++state_i;
            }
         }
         else {
            // or copy the pre-selection calibrated position and covariance to the
            // track states and adjust the flags.
            unsigned int state_i=0u;
            for (typename TopCollection<NMeasMax, MeasCovPair >::IndexType
                    idx: selected_measurements) {
               assert( state_i < result->size());
               TrackStateProxy trackState( trajectory.getTrackState( (*result)[state_i] ) );
               TheMatchingMeasurement &a_selected_measurement = selected_measurements.getSlot(idx);
 
               bool is_outlier = !forced && a_selected_measurement.m_chi2 >= maxChi2Cut.first;
               auto type_flags = trackState.typeFlags();
               if (is_outlier) {
                  // the filtered parameters will not be computed for outliers, so has to be shared from the prediction.
                  type_flags.setIsOutlier();
                  trackState.shareFrom(trackState, Acts::TrackStatePropMask::Predicted,
                                       Acts::TrackStatePropMask::Filtered);
               } else {
                  // for measurements the filtered parameters will be computed, so space needs to be allocated.
                  type_flags.setIsMeasurement();
                  trackState.addComponents(Acts::TrackStatePropMask::Filtered);
               }
               if (a_selected_measurement.m_measurement.flags().isSplitHit()) {
                  type_flags.setIsSplitHit();
               }
 
               trackState.setUncalibratedSourceLink(ActsTrk::detail::MeasurementCalibratorBase
                                                        ::pack(std::move(a_selected_measurement.m_sourceLink.value())));
 
               trackState.allocateCalibrated(DIM);
               trackState.template calibrated<DIM>()
                  = MeasurementSelectorMatrixTraits::matrixTypeCast<typename MeasurementSelectorTraits<derived_t>
                                                                    ::MatrixFloatType>(a_selected_measurement.m_measurement.position());
               trackState.template calibratedCovariance<DIM>()
                  = MeasurementSelectorMatrixTraits::matrixTypeCast<typename MeasurementSelectorTraits<derived_t>
                                                                    ::MatrixFloatType>(a_selected_measurement.m_measurement.covariance());
               trackState.chi2() = a_selected_measurement.m_chi2;
               ++state_i;
            }
         }
      }
 
      return result;
   }

◆ setCalibrator()

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>

template<std::size_t DIM, typename T_ValueType>

void AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::setCalibrator ( const Calibrator< DIM, T_ValueType > & calibrator )

inline

Definition at line 223 of file AtlasMeasurementSelector.cxx.

                                                                      {
      m_calibrators.template setCalibrator<DIM, T_ValueType>(calibrator);
   }

◆ setMeasurementRangesForced()

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>

void AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::setMeasurementRangesForced ( const ActsTrk::detail::MeasurementRangeListFlat * measurementRangesForced )

inline

Definition at line 200 of file AtlasMeasurementSelector.cxx.

                                                                                                         {
      m_measurementRangesForced = measurementRangesForced;
   }

◆ setPreCalibrator()

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>

template<std::size_t DIM, typename T_ValueType>

void AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::setPreCalibrator ( typename std::enable_if< s_CanPreCalibrate< DIM >, const PreCalibrator< DIM, T_ValueType > & >::type calibrator )

inline

Definition at line 234 of file AtlasMeasurementSelector.cxx.

                                                                                                                                {
      m_preCalibrators.template setCalibrator<DIM, T_ValueType>(calibrator);
   }

Member Data Documentation

◆ m_calibrators

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>

CalibratorRegistry< CalibratedMeasurementTraits, measurement_container_variant_t,typename traits::TrackStateProxy> AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::m_calibrators {}

Definition at line 208 of file AtlasMeasurementSelector.cxx.

208{};

◆ m_config

Config MeasurementSelectorBase< NMeasMax, DIMMAX, derived_t >::m_config

inherited

Definition at line 326 of file MeasurementSelector.h.

◆ m_measurementRanges

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>

const ActsTrk::detail::MeasurementRangeList* AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::m_measurementRanges {}

Definition at line 197 of file AtlasMeasurementSelector.cxx.

197{};

◆ m_measurementRangesForced

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>

const ActsTrk::detail::MeasurementRangeListFlat* AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::m_measurementRangesForced {}

Definition at line 198 of file AtlasMeasurementSelector.cxx.

198{};

◆ m_preCalibrators

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>

std::conditional<s_fullPreCalibration,PreCalibratorRegistry<CalibratedMeasurementTraits,measurement_container_variant_t,typenametraits::BoundTrackParameters>,Empty>::type AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::m_preCalibrators {}

Definition at line 212 of file AtlasMeasurementSelector.cxx.

212{};

◆ m_projector

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>

ActsTrk::MeasurementParameterMap AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::m_projector {}

Definition at line 207 of file AtlasMeasurementSelector.cxx.

207{};

◆ s_CanPreCalibrate

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>

template<std::size_t DIM>

bool AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::s_CanPreCalibrate

staticconstexpr

Initial value:

=    std::is_same< typename traits::template PreSelectionMeasurement<DIM>,
                   typename traits::template CalibratedMeasurement<DIM> >::value
  && std::is_same< typename traits::template PreSelectionMeasurementCovariance<DIM>,
                   typename traits::template CalibratedMeasurementCovariance<DIM> >::value

Definition at line 228 of file AtlasMeasurementSelector.cxx.

◆ s_maxBranchesPerSurface

template<std::size_t NMeasMax, typename derived_t, typename measurement_container_variant_t>

std::size_t MeasurementSelectorWithDispatch< NMeasMax, derived_t, measurement_container_variant_t >::s_maxBranchesPerSurface = Base::s_maxBranchesPerSurface

staticconstexprinherited

Definition at line 726 of file MeasurementSelector.h.

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

AtlasMeasurementSelector.cxx

Classes

Public Types

Public Member Functions

Static Public Member Functions

Public Attributes

Static Public Attributes

Protected Member Functions

Static Protected Member Functions

Detailed Description

Member Typedef Documentation

◆ abstract_measurement_range_t

◆ BASE

◆ Base

◆ Calibrator

◆ Config

◆ Measurement

◆ PostCalibrator

◆ PreCalibrator

◆ T_BoundState

◆ TrackStateProxy

◆ traits

◆ trajectory_t

Constructor & Destructor Documentation

◆ AtlasMeasurementSelector()

Member Function Documentation

◆ boundJacobiMatrix()

◆ boundParams()

◆ containerAndRange()

◆ containerAndRangeSingle()

◆ createStates()

◆ createTrackStates()

◆ derived()

◆ dimMax()

◆ expectMeasurements()

◆ forwardToCalibrator()

◆ getCuts()

◆ getEtaBin()

◆ makeOutlierFlag()

◆ parameterMap() [1/2]

◆ parameterMap() [2/2]

◆ pathLength()

◆ postCalibrator()

◆ preCalibrator()

◆ rangeForContainer() [1/2]

◆ rangeForContainer() [2/2]

◆ selectMeasurementsCreateTrackStates()

◆ setCalibrator()

◆ setMeasurementRangesForced()

◆ setPreCalibrator()

Member Data Documentation

◆ m_calibrators

◆ m_config

◆ m_measurementRanges

◆ m_measurementRangesForced

◆ m_preCalibrators

◆ m_projector

◆ s_CanPreCalibrate

◆ s_maxBranchesPerSurface