MeasurementSelector.h File Reference

#include "Acts/Utilities/Result.hpp"
#include "Acts/Utilities/Delegate.hpp"
#include "Acts/EventData/SourceLink.hpp"
#include "Acts/TrackFinding/CombinatorialKalmanFilterError.hpp"
#include "Acts/Surfaces/Surface.hpp"
#include "Acts/Geometry/GeometryHierarchyMap.hpp"
#include "Acts/EventData/Types.hpp"
#include "Acts/EventData/TrackStatePropMask.hpp"
#include "boost/container/small_vector.hpp"
#include "Acts/EventData/TrackStateProxy.hpp"
#include "Acts/Utilities/CalibrationContext.hpp"
#include "Acts/EventData/TrackParameters.hpp"
#include "Acts/EventData/MultiTrajectory.hpp"
#include <utility>
#include <type_traits>

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	MeasurementSelectorTraits< derived_t >
struct	MeasurementSelectorTraits< derived_t >::MeasurementContainerTraits< T_MeasurementRangeIterator >
struct	MeasurementSelectorMatrixTraits
struct	ParameterMapping
struct	TopCollection< N, PayloadType >
struct	AtlasMeasurementSelectorCuts
struct	MeasurementSelectorBase< NMeasMax, DIMMAX, derived_t >
struct	MeasurementSelectorBase< NMeasMax, DIMMAX, derived_t >::ProjectorBitSetMaker
struct	MeasurementSelectorBase< NMeasMax, DIMMAX, derived_t >::MatchingMeasurement< DIM, T_SourceLink >
struct	MeasurementSelectorWithDispatch< NMeasMax, derived_t, measurement_container_variant_t >
struct	MeasurementSelectorBaseImpl< NMeasMax, derived_t, measurement_container_variant_t >

Functions
template<std::size_t N, class T_ResultType, class T_Matrix>
T_ResultType	project (ParameterMapping::type< N > parameter_map, const T_Matrix &matrix)
template<typename measurement_vector_t, typename measurement_cov_matrix_t, typename predicted_vector_t, typename predicted_cov_matrix_t>
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)

Function Documentation

computeChi2()

template<typename measurement_vector_t, typename measurement_cov_matrix_t, typename predicted_vector_t, typename predicted_cov_matrix_t>

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 at line 188 of file MeasurementSelector.h.

                                                        {
 
   // just sum sanity checks that a and b have the correct dimensions and that
   // the chi2 can actually be computed.
   static_assert( MeasurementSelectorMatrixTraits::matrixColumns<measurement_vector_t>() == 1); // a is vector
   static_assert( MeasurementSelectorMatrixTraits::matrixColumns<predicted_vector_t>() == 1); // b is vector
   static_assert( MeasurementSelectorMatrixTraits::matrixRows<measurement_cov_matrix_t>()
                  == MeasurementSelectorMatrixTraits::matrixColumns<measurement_cov_matrix_t>() ); // a is square matrix
   static_assert( MeasurementSelectorMatrixTraits::matrixRows<predicted_cov_matrix_t>()
                  == MeasurementSelectorMatrixTraits::matrixColumns<predicted_cov_matrix_t>() ); // b is square matrix
   static_assert( MeasurementSelectorMatrixTraits::matrixRows<measurement_cov_matrix_t>()
                  == MeasurementSelectorMatrixTraits::matrixRows<measurement_vector_t>() );        // a vector matches matrix
   static_assert( MeasurementSelectorMatrixTraits::matrixRows<predicted_cov_matrix_t>()
                  == MeasurementSelectorMatrixTraits::matrixRows<predicted_vector_t>() );        // b vector matches matrix
   static_assert( MeasurementSelectorMatrixTraits::matrixRows<measurement_cov_matrix_t>()
                  == MeasurementSelectorMatrixTraits::matrixRows<predicted_cov_matrix_t>() );    // a and b match
 
   // @TODO remove abstraction i.e. assume matrix has the interface of an eigen matrix
   auto inv_ab_cov( MeasurementSelectorMatrixTraits::invert(a_cov+b_cov) );
   auto  diff( a-b);
   return (MeasurementSelectorMatrixTraits::transpose(diff) * inv_ab_cov * diff)(0,0);
}

project()

template<std::size_t N, class T_ResultType, class T_Matrix>

T_ResultType project	(	ParameterMapping::type< N >	parameter_map,
		const T_Matrix &	matrix )

Definition at line 149 of file MeasurementSelector.h.

{
   using MatrixIndexMapType = unsigned char; // "char" to reduce the size of the map, and if not wide enough this entire
                                             //        concept is likely inefficient.
   using MatrixIndexType = unsigned int;     // @TODO or std::size_t ? does not matter
 
   // ensure that index types are wide enough
   static_assert( MeasurementSelectorMatrixTraits::matrixRows<T_Matrix>() < std::numeric_limits<MatrixIndexMapType>::max());
   static_assert( N*MeasurementSelectorMatrixTraits::matrixRows<T_Matrix>() < std::numeric_limits<MatrixIndexType>::max());
 
   T_ResultType ret;
   if constexpr(MeasurementSelectorMatrixTraits::matrixColumns<T_Matrix>() == 1) {
      // handle projection of paramteter vector
      for (MatrixIndexType meas_i=0; meas_i<N; ++meas_i) {
         assert( meas_i < parameter_map.size() );
         ret(meas_i,0) = matrix( parameter_map[meas_i], 0);
      }
   }
   else {
      // handle projection of covariance matrix
      // "project" matrix
      for (MatrixIndexType meas_i=0; meas_i<N; ++meas_i) {
         assert( meas_i < parameter_map.size());
         MatrixIndexType param_i = parameter_map[meas_i];
         for (MatrixIndexType meas_j=0; meas_j<N; ++meas_j) {
            assert( meas_j < parameter_map.size());
            ret(meas_i,meas_j) = matrix(param_i, parameter_map[meas_j]);
         }
      }
   }
   return ret;
}