Acts::MutableTrackStateProxyConcept Concept Reference

#include <Acts/EventData/TrackStateProxyConcept.hpp>

Concept definition

template<typename T>
concept Acts::MutableTrackStateProxyConcept = 
    TrackStateProxyConcept<T> &&
    requires(T v, HashedString key, TrackStatePropMask mask,
             TrackIndexType index, std::shared_ptr<const Surface> surface,
             Eigen::Matrix<double, 3, 6> projector,
             ProjectorBitset projectorBitset, SourceLink sl,
             std::size_t measdim) {
      { v.unset(mask) };
 
      
      {
        v.template component<int, hashString("blubb")>()
      } -> std::same_as<int&>;
 
      { v.template component<int>(key) } -> std::same_as<int&>;
 
      { v.predicted() } -> std::same_as<detail::Parameters>;
      { v.predictedCovariance() } -> std::same_as<detail::Covariance>;
 
      { v.filtered() } -> std::same_as<detail::Parameters>;
      { v.filteredCovariance() } -> std::same_as<detail::Covariance>;
 
      { v.smoothed() } -> std::same_as<detail::Parameters>;
      { v.smoothedCovariance() } -> std::same_as<detail::Covariance>;
 
      { v.jacobian() } -> std::same_as<detail::Covariance>;
 
      requires requires(BoundSubspaceIndices m) {
        v.setProjectorSubspaceIndices(m);
      };
 
      { v.setUncalibratedSourceLink(std::move(sl)) };
 
      { v.template calibrated<2>() } -> std::same_as<detail::Measurement>;
      {
        v.template calibratedCovariance<2>()
      } -> std::same_as<detail::MeasurementCovariance>;
 
      { v.effectiveCalibrated() } -> std::same_as<detail::DynamicMeasurement>;
      {
        v.effectiveCalibratedCovariance()
      } -> std::same_as<detail::DynamicMeasurementCovariance>;
 
      { v.allocateCalibrated(measdim) };
 
      { v.allocateCalibrated(ActsVector<1>{}, ActsSquareMatrix<1>{}) };
      
      {
        v.allocateCalibrated(ActsVector<eBoundSize>{},
                             ActsSquareMatrix<eBoundSize>{})
      };
 
      { v.chi2() } -> std::same_as<float&>;
 
      { v.pathLength() } -> std::same_as<double&>;
 
      { v.typeFlags() } -> std::same_as<MutableTrackStateTypeMap>;
    }