ATLAS Offline Software
Loading...
Searching...
No Matches
Classes | Public Types | Public Member Functions | Static Public Member Functions | Public Attributes | Static Public Attributes | Protected Member Functions | Static Protected Member Functions | List of all members
AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t > Struct Template Reference

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 Calibrator
using T_BoundState
using PreCalibrator
using PostCalibrator
using Base = MeasurementSelectorBase< NMeasMax, MeasurementSelectorTraits<derived_t>::s_dimMax, derived_t>
using trajectory_t = typename Base::trajectory_t
using TrackStateProxy = typename Base::TrackStateProxy
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 Calibrator< 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 T_Value>
static Acts::SourceLink makeSourceLink (T_Value &&value)
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, typename traits::BoundTrackParameters, measurement_container_variant_t > m_calibrators {}
std::conditional< s_fullPreCalibration, CalibratorRegistry< CalibratedMeasurementTraits, typenametraits::BoundTrackParameters, measurement_container_variant_t >, 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
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 155 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 170 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 >
AtlasMeasurementSelector::AtlasMeasurementSelector
AtlasMeasurementSelector(typename BASE::Config &&config, const ActsTrk::detail::MeasurementRangeList &measurementRanges)
Definition AtlasMeasurementSelector.cxx:214

Definition at line 161 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 716 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:
Acts::Delegate<
std::pair < typename traits::template CalibratedMeasurement<DIM>,
typename traits::template CalibratedMeasurementCovariance<DIM> >
(const Acts::GeometryContext&,
const Acts::CalibrationContext&,
const measurement_t &,
const typename traits::BoundTrackParameters &)>

Definition at line 174 of file AtlasMeasurementSelector.cxx.

◆ Config

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

Definition at line 318 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 168 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 856 of file MeasurementSelector.h.

◆ PreCalibrator

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

Definition at line 845 of file MeasurementSelector.h.

◆ T_BoundState

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

Definition at line 794 of file MeasurementSelector.h.

◆ TrackStateProxy

template<std::size_t NMeasMax, typename derived_t, typename measurement_container_variant_t>
using MeasurementSelectorWithDispatch< NMeasMax, derived_t, measurement_container_variant_t >::TrackStateProxy = typename Base::TrackStateProxy
inherited

Definition at line 719 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 165 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 718 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 214 of file AtlasMeasurementSelector.cxx.

216 : BASE{std::move(config)},
217 m_measurementRanges(&measurementRanges)
218 {}
AtlasMeasurementSelector
ATALS specific Implementation of the member functions needed by the measurement selector.
Definition AtlasMeasurementSelector.cxx:159
AtlasMeasurementSelector::BASE
MeasurementSelectorBaseImpl< NMeasMax, AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >, measurement_container_variant_t > BASE
Definition AtlasMeasurementSelector.cxx:161
AtlasMeasurementSelector::m_measurementRanges
const ActsTrk::detail::MeasurementRangeList * m_measurementRanges
Definition AtlasMeasurementSelector.cxx:196

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 803 of file MeasurementSelector.h.

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

◆ 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 798 of file MeasurementSelector.h.

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

◆ 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 287 of file AtlasMeasurementSelector.cxx.

287 {
288 if (m_measurementRangesForced) {
289 auto ret = containerAndRangeSingle(*m_measurementRangesForced, surface, true);
290 if (std::get<0>(ret)) return ret;
291 }
292 return containerAndRangeSingle(*m_measurementRanges, surface, false);
293 }
AtlasMeasurementSelector::m_measurementRangesForced
const ActsTrk::detail::MeasurementRangeListFlat * m_measurementRangesForced
Definition AtlasMeasurementSelector.cxx:197
AtlasMeasurementSelector::containerAndRangeSingle
static std::tuple< const measurement_container_variant_t *, abstract_measurement_range_t, bool > containerAndRangeSingle(const MeasurementRangeList_t &measurementRanges, const Acts::Surface &surface, bool forced)
Definition AtlasMeasurementSelector.cxx:298

◆ 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 298 of file AtlasMeasurementSelector.cxx.

298 {
299 typename MeasurementRangeList_t::const_iterator range_iter = measurementRanges.find(surface.geometryId().value());
300 if (range_iter == measurementRanges.end())
301 {
302 return {nullptr, abstract_measurement_range_t{}, forced};
303 }
304 else {
305 abstract_measurement_range_t range{range_iter->second.elementBeginIndex(),
306 range_iter->second.elementEndIndex()};
307 assert( !range_iter->second.isMeasurementExpected() || range.begin() <= range.end());
308 // if surface marked as defect
309 return { forced || range_iter->second.isMeasurementExpected() ? &(measurementRanges.container(range_iter->second.containerIndex())) : nullptr,
310 std::move(range), forced};
311 }
312 }
AtlasMeasurementSelector::abstract_measurement_range_t
BASE::abstract_measurement_range_t abstract_measurement_range_t
Definition AtlasMeasurementSelector.cxx:170

◆ 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 355 of file MeasurementSelector.h.

362 {
363 // create track states for all compatible measurement candidates
364 const auto &boundParams = derived_t::boundParams(boundState);
365 const auto &pathLength = derived_t::pathLength(boundState);
366
367 using PM = Acts::TrackStatePropMask;
368
369 track_states.reserve( n_new_states );
370 std::optional<TrackStateProxy> firstTrackState{
371 std::nullopt};
372 for (unsigned int state_i=0; state_i<n_new_states; ++state_i) {
373 PM mask = PM::Predicted | PM::Filtered | PM::Jacobian | PM::Calibrated;
374
375 if (firstTrackState.has_value()) {
376 // subsequent track states don't need storage for these as they will
377 // be shared
378 mask &= ~PM::Predicted & ~PM::Jacobian;
379 }
380
381 if (outlier_states) {
382 // outlier won't have separate filtered parameters
383 mask &= ~PM::Filtered;
384 }
385
386 TrackStateProxy trackState = trajectory.makeTrackState(mask, prevTip);
387 ACTS_VERBOSE("Create SourceLink output track state #"
388 << trackState.index() << " with mask: " << mask);
389
390 if (firstTrackState.has_value()) {
391 trackState.shareFrom(*firstTrackState, PM::Predicted);
392 trackState.shareFrom(*firstTrackState, PM::Jacobian);
393 }
394 else {
395 // only set these for first
396 trackState.predicted() = boundParams.parameters();
397 if (boundParams.covariance()) {
398 trackState.predictedCovariance() = *boundParams.covariance();
399 }
400 trackState.jacobian() = derived_t::boundJacobiMatrix(boundState);
401 firstTrackState = trackState;
402 }
403 trackState.pathLength() = pathLength;
404
405 trackState.setReferenceSurface(boundParams.referenceSurface().getSharedPtr());
406
407 trackState.setProjectorSubspaceIndices(subspaceIndices);
408
409 Acts::TrackStateType typeFlags = trackState.typeFlags();
410 if (trackState.referenceSurface().surfaceMaterial() != nullptr) {
411 typeFlags.set(Acts::TrackStateFlag::MaterialFlag);
412 }
413 typeFlags.set(Acts::TrackStateFlag::ParameterFlag);
414
415 // @TODO these track states still need some additional processing. Should there be a special
416 // flag for this ?
417 track_states.push_back( trackState.index());
418 }
419 }

◆ 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 728 of file MeasurementSelector.h.

735 {
736
737 Acts::Result<boost::container::small_vector< typename TrackStateProxy::IndexType, s_maxBranchesPerSurface> >
738 result = Acts::CombinatorialKalmanFilterError::MeasurementSelectionFailed;
739 // get associated measurement container and the relevant measurement range for the given surface.
740 auto [a_measurement_container_variant_ptr, range, forced] = this->derived().containerAndRange(surface);
741 if (!forced && !this->derived().expectMeasurements( surface, a_measurement_container_variant_ptr, range)) {
742 result = result.failure(Acts::CombinatorialKalmanFilterError::NoMeasurementExpected);
743 return result;
744 }
745 if (!range.empty()) {
746 auto [numMeasurementsCut, maxChi2Cut] = this->getCuts(surface,boundState, logger);
747 // numMeasurementsCut is == 0 in case getCuts failed
748 // anyway cannot select anything if numMeasurementsCut==0;
749 if (numMeasurementsCut>0) {
750
751 result = std::visit( [this,
752 &geometryContext,
753 &calibrationContext,
754 &surface,
755 &boundState,
756 &range,
757 prevTip,
758 &trajectory,
759 &logger,
760 numMeasurementsCut,
761 &maxChi2Cut,
762 forced] (const auto &measurement_container_with_dimension) {
763 using ArgType = std::remove_cv_t<std::remove_reference_t< decltype(measurement_container_with_dimension) > >;
764 constexpr std::size_t DIM = ArgType::dimension();
765 auto measurement_range = this->derived().rangeForContainer(measurement_container_with_dimension,range);
766 return
767 this->template
768 selectMeasurementsCreateTrackStates<DIM, decltype(measurement_range)>(geometryContext,
769 calibrationContext,
770 surface,
771 boundState,
772 std::move(measurement_range),
773 prevTip,
774 trajectory,
775 logger,
776 numMeasurementsCut,
777 maxChi2Cut,
778 forced);
779 },
780 *a_measurement_container_variant_ptr);
781 }
782 }
783 else {
784 result = Acts::Result<boost::container::small_vector< typename TrackStateProxy::IndexType, s_maxBranchesPerSurface> >::success({});
785 }
786 return result;
787 }
MeasurementSelectorBase< NMeasMax, MeasurementSelectorTraits< derived_t >::s_dimMax, derived_t >::getCuts
std::tuple< std::size_t, std::pair< float, float > > getCuts(const Acts::Surface &surface, const T_BoundState &boundState, const Acts::Logger &logger) const
Definition MeasurementSelector.h:667
MeasurementSelectorBase< NMeasMax, MeasurementSelectorTraits< derived_t >::s_dimMax, derived_t >::selectMeasurementsCreateTrackStates
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
Definition MeasurementSelector.h:440

◆ derived()

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

Definition at line 329 of file MeasurementSelector.h.

329{ 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 723 of file MeasurementSelector.h.

723 {
724 return MeasurementSelectorTraits<derived_t>::s_dimMax;
725 }

◆ 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 314 of file AtlasMeasurementSelector.cxx.

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

◆ 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 821 of file MeasurementSelector.h.

821 {
822 if constexpr( std::is_same<T, std::remove_pointer_t<T> >::value ) {
823 return a;
824 }
825 else {
826 return *a;
827 }
828 }

◆ 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 667 of file MeasurementSelector.h.

669 {
670 std::tuple< std::size_t, std::pair<float,float> > result;
671 std::size_t &numMeasurementsCut = std::get<0>(result);
672 std::pair<float,float> &maxChi2Cut = std::get<1>(result);
673 // Get geoID of this surface
674 auto geoID = surface.geometryId();
675 // Find the appropriate cuts
676 auto cuts = m_config.find(geoID);
677 if (cuts == m_config.end()) {
678 // indicats failure
679 numMeasurementsCut = 0;
680 }
681 else {
682 // num measurement Cut
683 // getchi2 cut
684 std::size_t eta_bin = getEtaBin(derived().boundParams(boundState), cuts->etaBins);
685 numMeasurementsCut = (!cuts->numMeasurementsCutOff.empty()
686 ? cuts->numMeasurementsCutOff[ std::min(cuts->numMeasurementsCutOff.size()-1, eta_bin) ]
687 : NMeasMax);
688 maxChi2Cut = ! cuts->chi2CutOff.empty()
689 ? cuts->chi2CutOff[ std::min(cuts->chi2CutOff.size()-1, eta_bin) ]
690 : std::make_pair<float,float>(std::numeric_limits<float>::max(),
691 std::numeric_limits<float>::max());
692 ACTS_VERBOSE("Get cut for eta-bin="
693 << (eta_bin < cuts->etaBins.size() ? cuts->etaBins[eta_bin] : std::numeric_limits<float>::max())
694 << ": chi2 (max,max-outlier) " << maxChi2Cut.first << ", " << maxChi2Cut.second
695 << " max.meas." << numMeasurementsCut);
696 }
697 return result;
698 }

◆ getEtaBin()

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

Definition at line 648 of file MeasurementSelector.h.

649 {
650 if (etaBins.empty()) {
651 return 0u; // shortcut if no etaBins
652 }
653 const float eta = std::abs(std::atanh(std::cos(boundParameters.parameters()[Acts::eBoundTheta])));
654 std::size_t bin = 0;
655 for (auto etaBin : etaBins) {
656 if (etaBin >= eta) {
657 break;
658 }
659 bin++;
660 }
661 return bin;
662 }

◆ makeSourceLink()

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>
template<typename T_Value>
Acts::SourceLink AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::makeSourceLink ( T_Value && value)
inlinestatic

Definition at line 239 of file AtlasMeasurementSelector.cxx.

239 {
240 // value is pointer
241 static_assert( !std::is_same<std::remove_pointer_t<T_Value>, T_Value>::value );
242 // ... and pointer to xAOD::UncalibgratedMeasurement
243 static_assert(std::is_base_of_v< xAOD::UncalibratedMeasurement, std::remove_cv_t<std::remove_pointer_t<T_Value> > > );
244 return Acts::SourceLink{ ActsTrk::makeATLASUncalibSourceLink(value) };
245 }
ActsTrk::makeATLASUncalibSourceLink
ATLASUncalibSourceLink makeATLASUncalibSourceLink(const xAOD::UncalibratedMeasurementContainer *container, std::size_t index, const EventContext &ctx)
Definition ATLASSourceLink.h:30

◆ 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 250 of file AtlasMeasurementSelector.cxx.

252 {
253 return m_projector.parameterMap<DIM>(geometryContext,calibrationContext,surface);
254 }
AtlasMeasurementSelector::m_projector
ActsTrk::MeasurementParameterMap m_projector
Definition AtlasMeasurementSelector.cxx:206

◆ 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 837 of file MeasurementSelector.h.

839 {
840 return ParameterMapping::identity<DIM>();
841 }
ParameterMapping::identity
static constexpr type< N > identity()
Definition MeasurementSelector.h:137

◆ 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 807 of file MeasurementSelector.h.

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

◆ 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 259 of file AtlasMeasurementSelector.cxx.

259 {
260 return m_calibrators.template calibrator<DIM,measurement_t>();
261 }
AtlasMeasurementSelector::m_calibrators
CalibratorRegistry< CalibratedMeasurementTraits, typename traits::BoundTrackParameters, measurement_container_variant_t > m_calibrators
Definition AtlasMeasurementSelector.cxx:207

◆ 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 266 of file AtlasMeasurementSelector.cxx.

266 {
267 if constexpr(s_fullPreCalibration) {
268 // full calibration during selection
269 return m_preCalibrators.template calibrator<DIM,measurement_t>();
270 }
271 else {
272 // no calibration is performed before the measurement selection, so just Eigen maps to the stored location
273 // and covariance are returned.
274 // @TODO unfortunately the Eigen Maps cannot be used directly because they are incompatible with the
275 // temporary measurement storage used in the measurement selector, so need to convert to the
276 // above ConstVectorMapWithInvalidDef etc. Does this introduce some overhead ?
277 return []( [[maybe_unused]] const Acts::GeometryContext&,
278 [[maybe_unused]] const Acts::CalibrationContext&,
279 const measurement_t &measurement,
280 [[maybe_unused]] const typename traits::BoundTrackParameters &) {
281 return std::make_pair( measurement.template localPosition<DIM>(), measurement.template localCovariance<DIM>() );
282 };
283 }
284 }
AtlasMeasurementSelector::m_preCalibrators
std::conditional< s_fullPreCalibration, CalibratorRegistry< CalibratedMeasurementTraits, typenametraits::BoundTrackParameters, measurement_container_variant_t >, Empty >::type m_preCalibrators
Definition AtlasMeasurementSelector.cxx:211

◆ 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 322 of file AtlasMeasurementSelector.cxx.

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

◆ 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_ta concrete container type which is one of one of the possible types of measurement_container_variant_t
Parameters
abstract_rangethe 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 440 of file MeasurementSelector.h.

450 {
451 Acts::Result<boost::container::small_vector< typename TrackStateProxy::IndexType, s_maxBranchesPerSurface> >
452 result = boost::container::small_vector< typename TrackStateProxy::IndexType, s_maxBranchesPerSurface>{};
453
454 using iterator_t = decltype(measurement_range.begin());
455 using container_value_t = typename MeasurementSelectorTraits<derived_t>::template MeasurementContainerTraits<iterator_t>::value_type;
456 using BaseElementType = std::remove_cv_t<std::remove_pointer_t< container_value_t > >;
457 // get calibrator
458 using TheMatchingMeasurement = MatchingMeasurement<DIM, container_value_t >;
459 using MeasCovPair = TheMatchingMeasurement::MeasCovPair;
460
461 using Predicted = typename MeasurementSelectorTraits<derived_t>::template Predicted<DIM>;
462 using PredictedCovariance = typename MeasurementSelectorTraits<derived_t>::template PredictedCovariance<DIM>;
463
464
465
466 // get prediction in the measurement domain
467 Acts::SubspaceIndices<DIM> parameter_map = derived().template parameterMap<DIM>(geometryContext,
468 calibrationContext,
469 surface);
470 auto predicted
471 = std::make_pair( project<DIM, Predicted>(parameter_map,
472 derived().boundParams(boundState).parameters()),
473 project<DIM, PredictedCovariance>(parameter_map,
474 derived().boundParams(boundState).covariance().value()));
475
476 // select n measurents with the smallest chi2.
477 auto preCalibrator = derived().template preCalibrator<DIM, BaseElementType>();
478 auto postCalibrator = derived().template postCalibrator<DIM, BaseElementType>();
479 TopCollection<NMeasMax, TheMatchingMeasurement > selected_measurements(numMeasurementsCut);
480 for ( const auto &measurement : measurement_range ) {
481 TheMatchingMeasurement &matching_measurement=selected_measurements.slot();
482 if (forced && postCalibrator) {
483 // skip preCalibrator and computeChi2, by doing everything else. We start with what's done if no preCalibrator.
484 const auto &m = derived().forwardToCalibrator(measurement);
485 matching_measurement.m_measurement = std::make_pair( m.template localPosition<DIM>(), m.template localCovariance<DIM>() );
486 matching_measurement.m_chi2 = 0.0f;
487 matching_measurement.m_sourceLink=measurement;
488 if (!selected_measurements.acceptNoSort()) break;
489 } else {
490 matching_measurement.m_measurement = preCalibrator(geometryContext,
491 calibrationContext,
492 derived().forwardToCalibrator(measurement),
493 derived().boundParams(boundState));
494 matching_measurement.m_chi2 = computeChi2(matching_measurement.m_measurement.first,
495 matching_measurement.m_measurement.second,
496 predicted.first,
497 predicted.second);
498 // only consider measurements which pass the outlier chi2 cut
499 if (matching_measurement.m_chi2<maxChi2Cut.second) {
500 matching_measurement.m_sourceLink=measurement;
501 selected_measurements.acceptAndSort([](const TheMatchingMeasurement &a,
502 const TheMatchingMeasurement &b) {
503 return a.m_chi2 < b.m_chi2;
504 });
505 }
506 }
507 }
508
509 // apply final calibration to n-best measurements
510 using post_calib_meas_cov_pair_t
511 = std::pair<typename MeasurementSelectorTraits<derived_t>::template CalibratedMeasurement<DIM>,
512 typename MeasurementSelectorTraits<derived_t>::template CalibratedMeasurementCovariance<DIM> >;
513
514 // need extra temporary buffer if the types to store "measurements" during measurement selection
515 // and calibrated measurements after the measurement selection are not identical
516 static constexpr bool pre_and_post_calib_types_agree
517 = std::is_same< typename MeasurementSelectorTraits<derived_t>::template CalibratedMeasurement<DIM>,
518 typename MeasurementSelectorTraits<derived_t>::template PreSelectionMeasurement<DIM> >::value
519 && std::is_same< typename MeasurementSelectorTraits<derived_t>::template CalibratedMeasurementCovariance<DIM>,
520 typename MeasurementSelectorTraits<derived_t>::template PreSelectionMeasurementCovariance<DIM> >::value;
521
522 using Empty = struct {};
523 typename std::conditional< !pre_and_post_calib_types_agree,
524 std::array< post_calib_meas_cov_pair_t, NMeasMax>, // @TODO could use boost static_vector instead
525 Empty>::type calibrated;
526 if (postCalibrator) {
527 typename std::conditional<!pre_and_post_calib_types_agree, unsigned int, Empty>::type calibrated_meas_cov_i{};
528
529 // apply final calibration, recompute chi2
530 for (typename TopCollection<NMeasMax, MeasCovPair >::IndexType
531 idx: selected_measurements) {
532 TheMatchingMeasurement &a_selected_measurement = selected_measurements.getSlot(idx);
533
534 // helper to select the destination storage which is the extra temporary buffer
535 // if the measurement storage types during and after selection are different.
536 post_calib_meas_cov_pair_t &calibrated_measurement
537 = [&calibrated, &a_selected_measurement, calibrated_meas_cov_i]() -> post_calib_meas_cov_pair_t & {
538 if constexpr(pre_and_post_calib_types_agree) {
539 (void) calibrated;
540 (void) calibrated_meas_cov_i;
541 return a_selected_measurement.m_measurement;
542 }
543 else {
544 (void) a_selected_measurement;
545 assert(calibrated_meas_cov_i < calibrated.size());
546 return calibrated[calibrated_meas_cov_i];
547 }
548 }();
549
550 // apply the calibration
551 calibrated_measurement = postCalibrator(geometryContext,
552 calibrationContext,
553 derived().forwardToCalibrator(a_selected_measurement.m_sourceLink.value()),
554 derived().boundParams(boundState));
555 // update chi2 using calibrated measurement
556 a_selected_measurement.m_chi2 = computeChi2(calibrated_measurement.first,
557 calibrated_measurement.second,
558 predicted.first,
559 predicted.second);
560 // ... and set outlier flag
561 a_selected_measurement.m_isOutLier = (!forced && a_selected_measurement.m_chi2 >= maxChi2Cut.first);
562 if constexpr(!pre_and_post_calib_types_agree) {
563 ++calibrated_meas_cov_i;
564 }
565 }
566 }
567 else {
568 // if no final calibration is performed only the outlier flag still needs to be set
569 for (typename TopCollection<NMeasMax, MeasCovPair >::IndexType
570 idx: selected_measurements) {
571 TheMatchingMeasurement &a_selected_measurement = selected_measurements.getSlot(idx);
572 a_selected_measurement.m_isOutLier = (!forced && a_selected_measurement.m_chi2 >= maxChi2Cut.first);
573 }
574 }
575
576 // First Create states without setting information about the calibrated measurement for the selected measurements
577 // @TODO first create state then copy measurements, or crete state by state and set measurements ?
578 // the lastter has the "advantage" that the outlier flag can be set individually
579 // the former has the advantage that part of the state creation code is independent of the
580 // the measurement.
581
582 Acts::BoundSubspaceIndices boundSubspaceIndices;
583 std::copy(parameter_map.begin(), parameter_map.end(), boundSubspaceIndices.begin());
584 createStates( selected_measurements.size(),
585 boundState,
586 prevTip,
587 trajectory,
588 boundSubspaceIndices,
589 *result,
590 logger,
591 (!selected_measurements.empty()
592 ? selected_measurements.getSlot( *(selected_measurements.begin())).m_isOutLier
593 : false) );
594 assert( result->size() == selected_measurements.size() );
595
596 // helper to determine whether calibrated storeage is to be used
597 auto use_calibrated_storage = [&postCalibrator]() -> bool {
598 if constexpr(pre_and_post_calib_types_agree) {
599 (void) postCalibrator;
600 return false;
601 }
602 else {
603 // this is only known during runtime
604 // but it should not be tested if the types agree.
605 return postCalibrator;
606 }
607 };
608
609 // copy selected measurements to pre-created states
610 unsigned int state_i=0;
611 for (typename TopCollection<NMeasMax, MeasCovPair >::IndexType
612 idx: selected_measurements) {
613 assert( state_i < result->size());
614 TrackStateProxy trackState( trajectory.getTrackState( (*result)[state_i] ) );
615 TheMatchingMeasurement &a_selected_measurement = selected_measurements.getSlot(idx);
616 trackState.setUncalibratedSourceLink(derived().makeSourceLink(std::move(a_selected_measurement.m_sourceLink.value())));
617 // flag outliers accordingly, so that they are handled correctly by the post processing
618 trackState.typeFlags().set( a_selected_measurement.m_isOutLier
619 ? Acts::TrackStateFlag::OutlierFlag
620 : Acts::TrackStateFlag::MeasurementFlag );
621 trackState.allocateCalibrated(DIM);
622 if (use_calibrated_storage()) {
623 // if the final clibration is performed after the selection then
624 // copy these measurements and covariances to the track states
625 assert( use_calibrated_storage() == !pre_and_post_calib_types_agree);
626 if constexpr(!pre_and_post_calib_types_agree) {
627 assert( state_i < calibrated.size());
628 trackState.template calibrated<DIM>()
629 = MeasurementSelectorMatrixTraits::matrixTypeCast<typename MeasurementSelectorTraits<derived_t>::MatrixFloatType>(calibrated[state_i].first);
630 trackState.template calibratedCovariance<DIM>()
631 = MeasurementSelectorMatrixTraits::matrixTypeCast<typename MeasurementSelectorTraits<derived_t>::MatrixFloatType>(calibrated[state_i].second);
632 trackState.chi2() = a_selected_measurement.m_chi2;
633 }
634 }
635 else {
636 trackState.template calibrated<DIM>()
637 = MeasurementSelectorMatrixTraits::matrixTypeCast<typename MeasurementSelectorTraits<derived_t>::MatrixFloatType>(a_selected_measurement.m_measurement.first);
638 trackState.template calibratedCovariance<DIM>()
639 = MeasurementSelectorMatrixTraits::matrixTypeCast<typename MeasurementSelectorTraits<derived_t>::MatrixFloatType>(a_selected_measurement.m_measurement.second);
640 trackState.chi2() = a_selected_measurement.m_chi2;
641 }
642 ++state_i;
643 }
644 return result;
645 }
computeChi2
double computeChi2(const measurement_vector_t &a, const measurement_cov_matrix_t &a_cov, const predicted_vector_t &b, const predicted_cov_matrix_t &b_cov)
Definition MeasurementSelector.h:188

◆ 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 222 of file AtlasMeasurementSelector.cxx.

222 {
223 m_calibrators.template setCalibrator<DIM, T_ValueType>(calibrator);
224 }
AtlasMeasurementSelector::setCalibrator
void setCalibrator(const Calibrator< DIM, T_ValueType > &calibrator)
Definition AtlasMeasurementSelector.cxx:222

◆ 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 199 of file AtlasMeasurementSelector.cxx.

199 {
200 m_measurementRangesForced = measurementRangesForced;
201 }

◆ 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 Calibrator< DIM, T_ValueType > & >::type calibrator)
inline

Definition at line 233 of file AtlasMeasurementSelector.cxx.

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

Member Data Documentation

◆ m_calibrators

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>
CalibratorRegistry< CalibratedMeasurementTraits, typename traits::BoundTrackParameters, measurement_container_variant_t> AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::m_calibrators {}

Definition at line 207 of file AtlasMeasurementSelector.cxx.

207{};

◆ m_config

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

Definition at line 321 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 196 of file AtlasMeasurementSelector.cxx.

196{};

◆ 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 197 of file AtlasMeasurementSelector.cxx.

197{};

◆ m_preCalibrators

template<std::size_t NMeasMax, typename traj_t, typename measurement_container_variant_t>
std::conditional<s_fullPreCalibration,CalibratorRegistry<CalibratedMeasurementTraits,typenametraits::BoundTrackParameters,measurement_container_variant_t>,Empty>::type AtlasMeasurementSelector< NMeasMax, traj_t, measurement_container_variant_t >::m_preCalibrators {}

Definition at line 211 of file AtlasMeasurementSelector.cxx.

211{};

◆ 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 206 of file AtlasMeasurementSelector.cxx.

206{};

◆ 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 227 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 720 of file MeasurementSelector.h.

The documentation for this struct was generated from the following file:
Generated on for ATLAS Offline Software by doxygen 1.14.0