MeasurementSelectorWithDispatch< NMeasMax, derived_t, measurement_container_variant_t > Struct Template Reference

#include <MeasurementSelector.h>

Inheritance diagram for MeasurementSelectorWithDispatch< NMeasMax, derived_t, measurement_container_variant_t >:

Collaboration diagram for MeasurementSelectorWithDispatch< NMeasMax, derived_t, measurement_container_variant_t >:

Public Types
using	Base = MeasurementSelectorBase< NMeasMax, MeasurementSelectorTraits< derived_t >::s_dimMax, derived_t >
using	T_BoundState = typename Base::T_BoundState
using	trajectory_t = typename Base::trajectory_t
using	TrackStateProxy = typename Base::TrackStateProxy
using	Config = Acts::GeometryHierarchyMap< AtlasMeasurementSelectorCuts >
using	traits = MeasurementSelectorTraits< derived_t >

Public Member Functions
template<typename source_link_iterator_t >
Acts::Result< boost::container::small_vector< typename TrackStateProxy::IndexType, s_maxBranchesPerSurface > >	createSourceLinkTrackStates (const Acts::GeometryContext &geometryContext, const Acts::CalibrationContext &calibrationContext, const Acts::Surface &surface, const T_BoundState &boundState, source_link_iterator_t sourceLinkBegin, source_link_iterator_t sourceLinkEnd, typename TrackStateProxy::IndexType prevTip, [[maybe_unused]] trajectory_t &trajectory_buffer, [[maybe_unused]] 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
static constexpr std::size_t	dimMax ()

Public Attributes
Config	m_config

Static Public Attributes
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, const source_link_iterator_t &sourceLinkBegin, const source_link_iterator_t &sourceLinkEnd, std::size_t prevTip, trajectory_t &trajectory, const Acts::Logger &logger, const std::size_t numMeasurementsCut, const std::pair< float, float > &maxChi2Cut, const T_Container &container) 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 derived_t, typename measurement_container_variant_t>
struct MeasurementSelectorWithDispatch< NMeasMax, derived_t, measurement_container_variant_t >

Definition at line 715 of file MeasurementSelector.h.

Member Typedef Documentation

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>

Definition at line 717 of file MeasurementSelector.h.

Config

using MeasurementSelectorBase< NMeasMax, DIMMAX, derived_t >::Config = Acts::GeometryHierarchyMap<AtlasMeasurementSelectorCuts>

inherited

Definition at line 302 of file MeasurementSelector.h.

T_BoundState

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

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

Definition at line 718 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

Definition at line 720 of file MeasurementSelector.h.

traits

using MeasurementSelectorBase< NMeasMax, DIMMAX, derived_t >::traits = MeasurementSelectorTraits<derived_t>

inherited

Definition at line 303 of file MeasurementSelector.h.

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

Definition at line 719 of file MeasurementSelector.h.

Member Function Documentation

createSourceLinkTrackStates()

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

template<typename source_link_iterator_t >

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

inline

Definition at line 730 of file MeasurementSelector.h.

                                                               {
      Acts::Result<boost::container::small_vector< typename TrackStateProxy::IndexType, s_maxBranchesPerSurface> >
         result = Acts::CombinatorialKalmanFilterError::MeasurementSelectionFailed;
      if (sourceLinkBegin != sourceLinkEnd) {
         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) {
            const std::vector<measurement_container_variant_t> &
               measurementContainer = sourceLinkBegin.m_iterator.measurementContainerList();
 
            assert( sourceLinkBegin.m_iterator.containerIndex() == sourceLinkEnd.m_iterator.containerIndex() );
            const measurement_container_variant_t &a_measurement_container_variant = measurementContainer.at(sourceLinkBegin.m_iterator.containerIndex());
            result = std::visit( [this,
                                  &geometryContext,
                                  &calibrationContext,
                                  &surface,
                                  &boundState,
                                  &sourceLinkBegin,
                                  &sourceLinkEnd,
                                  prevTip,
                                  &trajectory,
                                  &logger,
                                  numMeasurementsCut,
                                  &maxChi2Cut] (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();
               return this->template selectMeasurementsCreateTrackStates<DIM>(geometryContext,
                                                                             calibrationContext,
                                                                             surface,
                                                                             boundState,
                                                                             sourceLinkBegin,
                                                                             sourceLinkEnd,
                                                                             prevTip,
                                                                             trajectory,
                                                                             logger,
                                                                             numMeasurementsCut,
                                                                             maxChi2Cut,
                                                                             measurement_container_with_dimension.container());
            },
                                  a_measurement_container_variant);
         }
      }
      return result;
   }

createStates()

static 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 339 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);
 
         Acts::TrackStateType typeFlags = trackState.typeFlags();
         if (trackState.referenceSurface().surfaceMaterial() != nullptr) {
            typeFlags.set(Acts::TrackStateFlag::MaterialFlag);
         }
         typeFlags.set(Acts::TrackStateFlag::ParameterFlag);
 
         // @TODO these track states still need some additional processing. Should there be a special
         //       flag for this ?
         track_states.push_back( trackState.index());
      }
   }

derived()

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

inlineprotectedinherited

Definition at line 313 of file MeasurementSelector.h.

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

dimMax()

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

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

inlinestaticconstexpr

Definition at line 724 of file MeasurementSelector.h.

                                       {
      return MeasurementSelectorTraits<derived_t>::s_dimMax;
   }

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 668 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()) {
         // indicats 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()

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

inlinestaticprotectedinherited

Definition at line 649 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;
   }

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, const source_link_iterator_t &  sourceLinkBegin, const source_link_iterator_t &  sourceLinkEnd, std::size_t  prevTip, trajectory_t &  trajectory, const Acts::Logger &  logger, const std::size_t  numMeasurementsCut, const std::pair< float, float > &  maxChi2Cut, const T_Container &  container  ) const

inlineprotectedinherited

Definition at line 449 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 container_value_t  = typename MeasurementSelectorTraits<derived_t>::template MeasurementContainerTraits<T_Container>::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>();
      TopCollection<NMeasMax, TheMatchingMeasurement > selected_measurements(numMeasurementsCut);
      {
         for ( const auto &measurement : MeasurementRange<T_Container>(container, sourceLinkBegin, sourceLinkEnd) ) {
            TheMatchingMeasurement &matching_measurement=selected_measurements.slot();
            matching_measurement.m_measurement = preCalibrator(geometryContext,
                                                               calibrationContext,
                                                               derived().template forwardToCalibrator(measurement),
                                                               derived().boundParams(boundState));
            matching_measurement.m_chi2 = computeChi2(matching_measurement.m_measurement.first,
                                                      matching_measurement.m_measurement.second,
                                                      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;
                });
            }
         }
      }
 
      // apply final calibration to n-best measurements
      auto postCalibrator = derived().template postCalibrator<DIM, BaseElementType>();
      using post_calib_meas_cov_pair_t
         = std::pair<typename MeasurementSelectorTraits<derived_t>::template CalibratedMeasurement<DIM>,
                     typename MeasurementSelectorTraits<derived_t>::template CalibratedMeasurementCovariance<DIM> >;
 
      // need extra temporary buffer if the types to store "measurements" during measurement selection
      // and calibrated measurements after the measurement selection are not identical
      static constexpr bool pre_and_post_calib_types_agree
         = std::is_same< typename MeasurementSelectorTraits<derived_t>::template CalibratedMeasurement<DIM>,
                         typename MeasurementSelectorTraits<derived_t>::template PreSelectionMeasurement<DIM> >::value
          && std::is_same< typename MeasurementSelectorTraits<derived_t>::template CalibratedMeasurementCovariance<DIM>,
                           typename MeasurementSelectorTraits<derived_t>::template PreSelectionMeasurementCovariance<DIM> >::value;
 
      using Empty = struct {};
      typename std::conditional< !pre_and_post_calib_types_agree,
                                 std::array< post_calib_meas_cov_pair_t, NMeasMax>, // @TODO could use boost static_vector instead
                                 Empty>::type calibrated;
      if (postCalibrator) {
         typename std::conditional<!pre_and_post_calib_types_agree, unsigned int, Empty>::type calibrated_meas_cov_i{};
 
         // apply final calibration, recompute chi2
         for (typename TopCollection<NMeasMax, MeasCovPair >::IndexType
                 idx: selected_measurements) {
            TheMatchingMeasurement &a_selected_measurement = selected_measurements.getSlot(idx);
 
            // helper to select the destination storage which is the extra temporary buffer
            // if the measurement storage types during and after selection are different.
            post_calib_meas_cov_pair_t &calibrated_measurement
               = [&calibrated, &a_selected_measurement, calibrated_meas_cov_i]() -> post_calib_meas_cov_pair_t & {
                  if constexpr(pre_and_post_calib_types_agree) {
                     (void) calibrated;
                     (void) calibrated_meas_cov_i;
                     return a_selected_measurement.m_measurement;
                  }
                  else {
                     (void) a_selected_measurement;
                     assert(calibrated_meas_cov_i < calibrated.size());
                     return calibrated[calibrated_meas_cov_i];
                  }
               }();
 
            // apply the calibration
            calibrated_measurement = postCalibrator(geometryContext,
                                                      calibrationContext,
                                                      derived().template forwardToCalibrator(a_selected_measurement.m_sourceLink.value()),
                                                      derived().boundParams(boundState));
            // update chi2 using calibrated measurement
            a_selected_measurement.m_chi2 = computeChi2(calibrated_measurement.first,
                                                        calibrated_measurement.second,
                                                        predicted.first,
                                                        predicted.second);
            // ... and set outlier flag
            a_selected_measurement.m_isOutLier =  (a_selected_measurement.m_chi2 >= maxChi2Cut.first);
            if constexpr(!pre_and_post_calib_types_agree) {
               ++calibrated_meas_cov_i;
            }
         }
      }
      else {
         // if no final calibration is performed only the outlier flag still needs to be set
         for (typename TopCollection<NMeasMax, MeasCovPair >::IndexType
                 idx: selected_measurements) {
            TheMatchingMeasurement &a_selected_measurement = selected_measurements.getSlot(idx);
            a_selected_measurement.m_isOutLier =  (a_selected_measurement.m_chi2 >= maxChi2Cut.first);
         }
      }
 
      // 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_isOutLier
                     : false) );
      assert( result->size() == selected_measurements.size() );
 
      // helper to determine whether calibrated storeage is to be used
      auto use_calibrated_storage = [&postCalibrator]() -> bool {
         if constexpr(pre_and_post_calib_types_agree) {
            (void) postCalibrator;
            return false;
         }
         else {
            // this is only known during runtime
            // but it should not be tested if the types agree.
            return postCalibrator;
         }
      };
 
      // copy selected measurements to pre-created states
      unsigned int state_i=0;
      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(derived().makeSourceLink(std::move(a_selected_measurement.m_sourceLink.value())));
         // flag outliers accordingly, so that they are handled correctly by the post processing
         trackState.typeFlags().set( a_selected_measurement.m_isOutLier
                                     ? Acts::TrackStateFlag::OutlierFlag
                                     : Acts::TrackStateFlag::MeasurementFlag );
         trackState.allocateCalibrated(DIM);
         if (use_calibrated_storage()) {
            // if the final clibration is performed after the selection then
            // copy these measurements and covariances to the track states
            assert( use_calibrated_storage() == !pre_and_post_calib_types_agree);
            if constexpr(!pre_and_post_calib_types_agree) {
               assert( state_i < calibrated.size());
               trackState.template calibrated<DIM>()
                  = MeasurementSelectorMatrixTraits::matrixTypeCast<typename MeasurementSelectorTraits<derived_t>::MatrixFloatType>(calibrated[state_i].first);
               trackState.template calibratedCovariance<DIM>()
                  = MeasurementSelectorMatrixTraits::matrixTypeCast<typename MeasurementSelectorTraits<derived_t>::MatrixFloatType>(calibrated[state_i].second);
               trackState.chi2() = a_selected_measurement.m_chi2;
            }
         }
         else {
            trackState.template calibrated<DIM>()
               = MeasurementSelectorMatrixTraits::matrixTypeCast<typename MeasurementSelectorTraits<derived_t>::MatrixFloatType>(a_selected_measurement.m_measurement.first);
            trackState.template calibratedCovariance<DIM>()
               = MeasurementSelectorMatrixTraits::matrixTypeCast<typename MeasurementSelectorTraits<derived_t>::MatrixFloatType>(a_selected_measurement.m_measurement.second);
            trackState.chi2() = a_selected_measurement.m_chi2;
         }
         ++state_i;
      }
      return result;
   }

Member Data Documentation

m_config

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

inherited

Definition at line 305 of file MeasurementSelector.h.

s_maxBranchesPerSurface

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 >::s_maxBranchesPerSurface = Base::s_maxBranchesPerSurface

staticconstexpr

Definition at line 721 of file MeasurementSelector.h.

---

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

• MeasurementSelector.h