Trk::KalmanUpdatorSMatrix Class Reference

Implementation of Trk::IUpdator based on gain formalism and SMatrix mathlib. More...

#include <KalmanUpdatorSMatrix.h>

Inheritance diagram for Trk::KalmanUpdatorSMatrix:

Collaboration diagram for Trk::KalmanUpdatorSMatrix:

Public Member Functions
	KalmanUpdatorSMatrix (const std::string &, const std::string &, const IInterface *)
	AlgTool standard constuctor.
virtual	~KalmanUpdatorSMatrix ()
virtual StatusCode	initialize () override
	AlgTool initialisation.
virtual StatusCode	finalize () override
	AlgTool termination.
virtual std::unique_ptr< TrackParameters >	addToState (const TrackParameters &, const Amg::Vector2D &, const Amg::MatrixX &) const override final
	measurement updator for the KalmanFitter getting the meas't coord' from Amg::Vector2D (use eg with PRD)
virtual std::unique_ptr< TrackParameters >	addToState (const TrackParameters &, const LocalParameters &, const Amg::MatrixX &) const override final
	measurement updator for the KalmanFitter getting the coord' from LocalParameters (use for example with MeasurementBase, ROT)
virtual std::unique_ptr< TrackParameters >	addToState (const TrackParameters &, const Amg::Vector2D &, const Amg::MatrixX &, FitQualityOnSurface *&) const override final
	measurement updator interface for the KalmanFitter returning the fit quality of the state at the same time (Amg::Vector2D-version)
virtual std::unique_ptr< TrackParameters >	addToState (const TrackParameters &, const LocalParameters &, const Amg::MatrixX &, FitQualityOnSurface *&) const override final
	measurement updator interface for the KalmanFitter returning the fit quality of the state at the same time (LocalParameters-version)
virtual std::unique_ptr< TrackParameters >	removeFromState (const TrackParameters &, const Amg::Vector2D &, const Amg::MatrixX &) const override final
	reverse update eg for track property analysis (unbiased residuals) getting the measurement coordinates from the Amg::Vector2D class.
virtual std::unique_ptr< TrackParameters >	removeFromState (const TrackParameters &, const LocalParameters &, const Amg::MatrixX &) const override final
	reverse update eg for track property analysis (unbiased residuals) getting the measurement coordinates from the LocalParameters class.
virtual std::unique_ptr< TrackParameters >	removeFromState (const TrackParameters &, const Amg::Vector2D &, const Amg::MatrixX &, FitQualityOnSurface *&) const override final
	reverse update for Kalman filters and other applications using the interface with Amg::Vector2D and FitQualityOnSurface.
virtual std::unique_ptr< TrackParameters >	removeFromState (const TrackParameters &, const LocalParameters &, const Amg::MatrixX &, FitQualityOnSurface *&) const override final
	reverse update for Kalman filters and other applications using the interface with LocalParameters and FitQualityOnSurface.
virtual std::unique_ptr< TrackParameters >	combineStates (const TrackParameters &, const TrackParameters &) const override final
	trajectory state updator which combines two parts of a trajectory on a common surface.
virtual std::unique_ptr< TrackParameters >	combineStates (const TrackParameters &, const TrackParameters &, FitQualityOnSurface *&) const override final
	trajectory state updator which combines two parts of a trajectory on a common surface and provides the FitQuality.
virtual FitQualityOnSurface	fullStateFitQuality (const TrackParameters &, const Amg::Vector2D &, const Amg::MatrixX &) const override final
	estimator for FitQuality on Surface from a full track state, that is a state which contains the current hit (expressed as Amg::Vector2D).
virtual FitQualityOnSurface	fullStateFitQuality (const TrackParameters &, const LocalParameters &, const Amg::MatrixX &) const override final
	estimator for FitQuality on Surface from a full track state, that is a state which contains the current hit (expressed as LocalParameters).
virtual FitQualityOnSurface	predictedStateFitQuality (const TrackParameters &, const Amg::Vector2D &, const Amg::MatrixX &) const override final
	estimator for FitQuality on Surface from a predicted track state, that is a state which contains the current hit (expressed as Amg::Vector2D).
virtual FitQualityOnSurface	predictedStateFitQuality (const TrackParameters &, const LocalParameters &, const Amg::MatrixX &) const override final
	estimator for FitQuality on Surface from a predicted track state, that is a state which contains the current hit (expressed as LocalParameters).
virtual FitQualityOnSurface	predictedStateFitQuality (const TrackParameters &, const TrackParameters &) const override final
	estimator for FitQuality on Surface for the situation when a track is fitted to the parameters of another trajectory part extrapolated to the common surface.
virtual std::pair< AmgVector(5), AmgSymMatrix(5)> *	updateParameterDifference (const AmgVector(5) &, const AmgSymMatrix(5) &, const Amg::VectorX &, const Amg::MatrixX &, int, Trk::FitQualityOnSurface *&, bool) const override final
	interface for reference-track KF, not implemented
virtual std::vector< double >	initialErrors () const override final
	give back how updator is configured for inital covariances
ServiceHandle< StoreGateSvc > &	evtStore ()
	The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.
const ServiceHandle< StoreGateSvc > &	detStore () const
	The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.
virtual StatusCode	sysInitialize () override
	Perform system initialization for an algorithm.
virtual StatusCode	sysStart () override
	Handle START transition.
virtual std::vector< Gaudi::DataHandle * >	inputHandles () const override
	Return this algorithm's input handles.
virtual std::vector< Gaudi::DataHandle * >	outputHandles () const override
	Return this algorithm's output handles.
Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Property< T, V, H > &t)
void	updateVHKA (Gaudi::Details::PropertyBase &)
MsgStream &	msg () const
bool	msgLvl (const MSG::Level lvl) const

Static Public Member Functions
static const InterfaceID &	interfaceID ()
	Algtool infrastructure.

Protected Member Functions
void	renounceArray (SG::VarHandleKeyArray &handlesArray)
	remove all handles from I/O resolution
std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void >	renounce (T &h)
void	extraDeps_update_handler (Gaudi::Details::PropertyBase &ExtraDeps)
	Add StoreName to extra input/output deps as needed.

Private Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t

Private Member Functions
std::unique_ptr< TrackParameters >	prepareFilterStep (const TrackParameters &, const LocalParameters &, const Amg::MatrixX &, const int, FitQualityOnSurface *&, bool) const
	common code analysing the measurement's rank and calling the appropriate implementation for this rank.
std::unique_ptr< TrackParameters >	calculateFilterStep_1D (const TrackParameters &, const SParVector5 &, const SCovMatrix5 &, double, int, const Amg::MatrixX &, const int, FitQualityOnSurface *&, bool) const
	common maths calculation code for all addToState and removeFromState versions which happen to be called with 1-dim measurements.
std::unique_ptr< TrackParameters >	calculateFilterStep_2D (const TrackParameters &, const SParVector5 &, const SCovMatrix5 &, const SParVector2 &, int, const Amg::MatrixX &, const int, FitQualityOnSurface *&, bool) const
	common maths calculation code for all addToState and removeFromState versions which happen to be called with 2-dim measurements.
std::unique_ptr< TrackParameters >	calculateFilterStep_3D (const TrackParameters &, const SParVector5 &, const SCovMatrix5 &, const LocalParameters &, const Amg::MatrixX &, const int, FitQualityOnSurface *&, bool) const
	common maths calculation code for all addToState and removeFromState versions which happen to be called with 3-dim measurements.
std::unique_ptr< TrackParameters >	calculateFilterStep_4D (const TrackParameters &, const SParVector5 &, const SCovMatrix5 &, const LocalParameters &, const Amg::MatrixX &, const int, FitQualityOnSurface *&, bool) const
	common maths calculation code for all addToState and removeFromState versions which happen to be called with 4-dim measurements.
std::unique_ptr< TrackParameters >	calculateFilterStep_5D (const TrackParameters &, const SParVector5 &, const SCovMatrix5 &, const SParVector5 &, const Amg::MatrixX &, const int, FitQualityOnSurface *&, bool) const
	common maths calculation code for all addToState and removeFromState versions which happen to be called with 5-dim measurements or two track states.
bool	getStartCov (SCovMatrix5 &, const TrackParameters &, const int) const
	Helper method to transform Eigen cov matrix to SMatrix.
std::unique_ptr< TrackParameters >	convertToClonedTrackPars (const TrackParameters &, const SParVector5 &, const SCovMatrix5 &, int, bool, std::string_view) const
	Helper method to convert internal results from SMatrix to Eigen. *‍/.
FitQualityOnSurface	makeChi2_1D (const SParVector5 &, const AmgSymMatrix(5)&, double, double, int, int) const
	also the chi2 calculation and FitQuality object creation is combined in an extra method.
FitQualityOnSurface	makeChi2_2D (const SParVector5 &, const AmgSymMatrix(5)&, const SParVector2 &, const SCovMatrix2 &, int, int) const
FitQualityOnSurface	makeChi2_5D (const SParVector5 &, const AmgSymMatrix(5)&, const SParVector5 &, const AmgSymMatrix(5)&, int) const
FitQualityOnSurface	makeChi2Object (const Amg::VectorX &, const AmgSymMatrix(5)&, const Amg::MatrixX &, const Amg::MatrixX &, int) const
void	logStart (const std::string &, const TrackParameters &) const
	internal structuring: debugging output for start of method.
void	logInputCov (const SCovMatrix5 &, const Amg::VectorX &, const Amg::MatrixX &) const
	internal structuring: common logfile output of the inputs
void	logGainForm (int, const SParVector5 &, const SCovMatrix5 &, const SGenMatrix5 &) const
	internal structuring: common logfile output during calculation
void	logResult (const std::string &, const AmgVector(5) &, const AmgSymMatrix(5) &) const
	internal structuring: common logfile output after calculation
bool	consistentParamDimensions (const LocalParameters &, int) const
	method testing correct use of LocalParameters
bool	thetaPhiWithinRange_5D (const SParVector5 &V, const RangeCheckDef rcd) const
	Test if angles are inside boundaries.
bool	thetaWithinRange_5D (const SParVector5 &V) const
	Test if theta angle is inside boundaries. No differential-check option.
bool	correctThetaPhiRange_5D (SParVector5 &, SCovMatrix5 &, const RangeCheckDef) const
	method correcting the calculated angles back to their defined ranges phi (-pi, pi) and theta (0, pi).
Gaudi::Details::PropertyBase &	declareGaudiProperty (Gaudi::Property< T, V, H > &hndl, const SG::VarHandleKeyType &)
	specialization for handling Gaudi::Property<SG::VarHandleKey>

Static Private Member Functions
static SCovMatrix2	projection_2D (const SCovMatrix5 &, int)
	Avoid multiplications with sparse H matrices by cutting 2D rows&columns out of the full cov matrix.
static SCovMatrix2	projection_2D (const Amg::MatrixX &, int)
	Avoid multiplications with sparse H matrices by cutting 2D rows&columns out of the full cov matrix.
static SCovMatrix3	projection_3D (const SCovMatrix5 &, int)
	Avoid multiplications with sparse H matrices by cutting 3D rows&columns out of the full cov matrix.
static SCovMatrix4	projection_4D (const SCovMatrix5 &, int)
	Avoid multiplications with sparse H matrices by cutting 4D rows&columns out of the full cov matrix.

Private Attributes
std::vector< double >	m_cov_stdvec
	job options for initial cov values
SParVector5	m_cov0
	initial cov values in SMatrix object
bool	m_useFruehwirth8a
	job options controlling update formula for covariance matrix
float	m_thetaGainDampingValue
SCovMatrix5	m_unitMatrix
	avoid mem allocation at every call
StoreGateSvc_t	m_evtStore
	Pointer to StoreGate (event store by default)
StoreGateSvc_t	m_detStore
	Pointer to StoreGate (detector store by default)
std::vector< SG::VarHandleKeyArray * >	m_vhka
bool	m_varHandleArraysDeclared

Static Private Attributes
static const ParamDefsAccessor	s_enumAccessor

Detailed Description

Implementation of Trk::IUpdator based on gain formalism and SMatrix mathlib.

Tool providing calculations on track states, i.e. to add or remove a measured hit to the state vector. Contains the core maths for Kalman filters in ATLAS track reconstruction. The track state manipulations in this tool make use of the Kalman gain-matrix formalism .

Author

Wolfgang Liebig http://consult.cern.ch/xwho/people/54608

Definition at line 74 of file KalmanUpdatorSMatrix.h.

Member Typedef Documentation

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> AthCommonDataStore< AthCommonMsg< AlgTool > >::StoreGateSvc_t

privateinherited

Definition at line 388 of file AthCommonDataStore.h.

Constructor & Destructor Documentation

KalmanUpdatorSMatrix()

Trk::KalmanUpdatorSMatrix::KalmanUpdatorSMatrix	(	const std::string &	t,
		const std::string &	n,
		const IInterface *	p )

AlgTool standard constuctor.

Definition at line 33 of file KalmanUpdatorSMatrix.cxx.

                                                                                                       :
    AthAlgTool (t,n,p),
    m_cov_stdvec{250.,250.,0.25,0.25,0.000001}, // set defaults _before_ reading from job options
    m_thetaGainDampingValue(0.1),
    m_unitMatrix()
{
    // AlgTool stuff
    declareProperty("InitialCovariances",m_cov_stdvec,"default covariance to be used at start of filter");
    declareProperty("FastTrackStateCovCalculation",m_useFruehwirth8a=false,"toggles which formula to use for updated cov");
    declareInterface<IUpdator>( this );
}

~KalmanUpdatorSMatrix()

Trk::KalmanUpdatorSMatrix::~KalmanUpdatorSMatrix ( )

virtualdefault

Member Function Documentation

addToState() [1/4]

std::unique_ptr< Trk::TrackParameters > Trk::KalmanUpdatorSMatrix::addToState ( const TrackParameters & inputTrkPar, const Amg::Vector2D & measLocPos, const Amg::MatrixX & measLocCov ) const

finaloverridevirtual

measurement updator for the KalmanFitter getting the meas't coord' from Amg::Vector2D (use eg with PRD)

Implements Trk::IUpdator.

Definition at line 76 of file KalmanUpdatorSMatrix.cxx.

                                                                                                 {
  if (msgLvl(MSG::VERBOSE)) logStart("addToState(TP,LPOS,ERR)",inputTrkPar);
  FitQualityOnSurface*    fitQoS = nullptr;
  const int updatingSign = 1;
 
  SCovMatrix5 covTrk;
  if (!getStartCov(covTrk,inputTrkPar,updatingSign)) return nullptr;
 
 
  int nLocCoord = measLocCov.cols();
  if (nLocCoord == 1) {
    return calculateFilterStep_1D (inputTrkPar, // transmit the surface
                                   SParVector5(&inputTrkPar.parameters()[0],5),covTrk,
                                   measLocPos[0],1,measLocCov,
                                   updatingSign,fitQoS,false);
  } if (nLocCoord == 2) {
    return calculateFilterStep_2D (inputTrkPar,// transmit the surface
                                   SParVector5(&inputTrkPar.parameters()[0],5),covTrk,
                                   SParVector2(measLocPos[0],measLocPos[1]),3,
                                   measLocCov,
                                   updatingSign,fitQoS,false);
  }
    ATH_MSG_WARNING( " number (" << nLocCoord << ") of local coordinates must be 1 or 2, can not update!" );
    return nullptr;
 
}

addToState() [2/4]

std::unique_ptr< Trk::TrackParameters > Trk::KalmanUpdatorSMatrix::addToState ( const TrackParameters & inputTP, const Amg::Vector2D & measLocPos, const Amg::MatrixX & measLocCov, FitQualityOnSurface *& fitQoS ) const

finaloverridevirtual

measurement updator interface for the KalmanFitter returning the fit quality of the state at the same time (Amg::Vector2D-version)

Implements Trk::IUpdator.

Definition at line 115 of file KalmanUpdatorSMatrix.cxx.

                                                                                                 {
    const int updatingSign = 1;
    if (msgLvl(MSG::VERBOSE)) logStart("addToState(TP,LPOS,ERR,FQ)",inputTP);
    if (fitQoS) {
        ATH_MSG_WARNING( "expect nil FitQuality pointer, refuse operation to avoid mem leak!");
        return nullptr;
    }
 
      SCovMatrix5 covTrk;
      if (!getStartCov(covTrk,inputTP,updatingSign)) return nullptr;
 
      int nLocCoord = measLocCov.cols();
      if (nLocCoord == 1) {
        return calculateFilterStep_1D (inputTP,
                                       SParVector5(&inputTP.parameters()[0],5),covTrk,
                                       measLocPos[0],1,measLocCov,
                                       updatingSign,fitQoS,true);
      } if (nLocCoord == 2) {
        return calculateFilterStep_2D (inputTP,
                                       SParVector5(&inputTP.parameters()[0],5),covTrk,
                                       SParVector2(measLocPos[0],measLocPos[1]),3,
                                       measLocCov,
                                       updatingSign,fitQoS,true);
        }
        ATH_MSG_WARNING( " number (" << nLocCoord << ") of local coordinates must be 1 or 2, can not update!" );
        return nullptr;
 
 
}

addToState() [3/4]

std::unique_ptr< Trk::TrackParameters > Trk::KalmanUpdatorSMatrix::addToState ( const TrackParameters & trkPar, const LocalParameters & measmtPar, const Amg::MatrixX & measmtCov ) const

finaloverridevirtual

measurement updator for the KalmanFitter getting the coord' from LocalParameters (use for example with MeasurementBase, ROT)

Implements Trk::IUpdator.

Definition at line 106 of file KalmanUpdatorSMatrix.cxx.

                                                                                                {
    if (msgLvl(MSG::VERBOSE)) logStart("addToState(TP,LPAR,ERR)",trkPar);
    FitQualityOnSurface*    fitQoS = nullptr;
    return prepareFilterStep (trkPar, measmtPar, measmtCov, 1, fitQoS, false);
}

addToState() [4/4]

std::unique_ptr< Trk::TrackParameters > Trk::KalmanUpdatorSMatrix::addToState ( const TrackParameters & trkPar, const LocalParameters & measmtPar, const Amg::MatrixX & measmtCov, FitQualityOnSurface *& fitQoS ) const

finaloverridevirtual

measurement updator interface for the KalmanFitter returning the fit quality of the state at the same time (LocalParameters-version)

Implements Trk::IUpdator.

Definition at line 149 of file KalmanUpdatorSMatrix.cxx.

                                                                                                 {
    if (msgLvl(MSG::VERBOSE)) logStart("addToState(TP,LPAR,ERR,FQ)",trkPar);
    if (fitQoS) {
        ATH_MSG_WARNING( "expect nil FitQuality pointer, refuse operation to"
              << " avoid mem leak!" );
      return nullptr;
    }
      return prepareFilterStep (trkPar, measmtPar, measmtCov, 1, fitQoS, true);
 
}

calculateFilterStep_1D()

std::unique_ptr< Trk::TrackParameters > Trk::KalmanUpdatorSMatrix::calculateFilterStep_1D ( const TrackParameters & TP, const SParVector5 & trkPar, const SCovMatrix5 & trkCov, double measPar, int paramKey, const Amg::MatrixX & measCov, const int sign, Trk::FitQualityOnSurface *& fitQoS, bool createFQoS ) const

private

common maths calculation code for all addToState and removeFromState versions which happen to be called with 1-dim measurements.

Definition at line 590 of file KalmanUpdatorSMatrix.cxx.

                                                                           {
  // use measuring coordinate (variable "mk") instead of reduction matrix
  int mk=0;
  if (paramKey!=1) for (int i=0; i<5; ++i) if (paramKey & (1<<i)) mk=i;
 
  double r = measPar - trkPar(mk);
  double R = (sign * measCov(0,0)) + trkCov(mk,mk);
  if (R == 0.0) {
    ATH_MSG_DEBUG( "inversion of the error-on-the-residual failed.");
    return nullptr;
  } R = 1./R;
 
  // --- compute Kalman gain matrix
  ROOT::Math::SMatrix<double,5,1,ROOT::Math::MatRepStd<double, 5, 1> >
    K = trkCov.Sub<ROOT::Math::SMatrix<double,5,1,ROOT::Math::MatRepStd<double, 5, 1> > >(0,mk)*R;
  if (msgLvl(MSG::VERBOSE)) {
    ATH_MSG_VERBOSE("-U- residual: r = " << r );
    ATH_MSG_VERBOSE( "-U- inv. sigmaR = " << R);
    ATH_MSG_VERBOSE( "-U- gain mtx     K=("
          <<std::setiosflags(std::ios::fixed | std::ios::showpoint | std::ios::right)
          << std::setw(7) << std::setprecision(4) << K(0,0)<<", "
          << std::setw(7) << std::setprecision(4) << K(1,0)<<", "
          << std::setw(7) << std::setprecision(4) << K(2,0)<<", "
          << std::setw(7) << std::setprecision(4) << K(3,0)<<", "
          << std::setw(7) << std::setprecision(4) << K(4,0)<<")"
          << std::resetiosflags(std::ios::fixed));
  }
 
  // --- compute local filtered state, here = TP+K*r = TP + TCov * H.T * R * r
  SParVector5 newPar = trkPar + trkCov.Col(mk) * R * r;
 
  if (!thetaWithinRange_5D(newPar)) {
    if ( mk!=Trk::theta &&
      (std::abs(R*r)>1.0 || trkCov(Trk::theta,Trk::theta) > 0.1*m_cov0(Trk::theta))) {
      ATH_MSG_DEBUG( "calculateFS_1D(): decided to damp update of theta and re-calculate." );
      SParVector5 dampedCov = trkCov.Col(mk);
      dampedCov(Trk::theta) = dampedCov(Trk::theta)*m_thetaGainDampingValue;
      newPar = trkPar + dampedCov * R * r;
      K(Trk::theta,0) = K(Trk::theta,0)*m_thetaGainDampingValue;
      ATH_MSG_DEBUG( "-U- damped gain  K=("
            <<std::setiosflags(std::ios::fixed | std::ios::showpoint | std::ios::right)
            << std::setw(7) << std::setprecision(4) << K(0,0)<<", "
            << std::setw(7) << std::setprecision(4) << K(1,0)<<", "
            << std::setw(7) << std::setprecision(4) << K(2,0)<<", "
            << std::setw(7) << std::setprecision(4) << K(3,0)<<", "
            << std::setw(7) << std::setprecision(4) << K(4,0)<<")"
            << std::resetiosflags(std::ios::fixed) );
    } else {
      ATH_MSG_DEBUG( "-U- theta out of range but can not damp this update.");
    }
  }
 
  // --- compute covariance matrix of local filteres state
  SGenMatrix5 KtimesH ; KtimesH.Place_at(K,0,mk);
  SGenMatrix5 M(m_unitMatrix - KtimesH);
  ATH_MSG_VERBOSE( "-U- matrix M: diag=("
                                 << M(0,0)<<"," << M(1,1)<<","
                                 << M(2,2)<<"," << M(3,3)<<","
                                 << M(4,4)               <<")" );
  SCovMatrix5 newCov;
  if (!m_useFruehwirth8a) {
    // either: use formula C = M * trkCov * M.T() +/- K * covRio * K.T()
    SCovMatrix1 measuredSMatrix1D(measCov(0,0));
    newCov = ROOT::Math::Similarity(M,trkCov)
      + sign*(ROOT::Math::Similarity(K,measuredSMatrix1D));
  } else {
    // or: original Fruehwirth eq. 8a is simpler, expression checked to be symm.
    // C = (1 - K*H) * trkCov
    /*    SGenMatrix5 KtimesH ; KtimesH.Place_at(K,0,mk);
          SCovMatrix5 M;
          ROOT::Math::AssignSym::Evaluate(M, KtimesH * trkCov);
          newCov -= M;*/
    ROOT::Math::AssignSym::Evaluate(newCov, M * trkCov);
  }
  if ( (!thetaPhiWithinRange_5D(newPar, Trk::absoluteCheck)) ?
       !correctThetaPhiRange_5D(newPar, newCov, Trk::absoluteCheck) : false ) {
    ATH_MSG_WARNING("calculateFS_1D(): bad angles in filtered state!");
    return nullptr;
  }
 
 
  if (createFQoS) {
    double predictedResidual = (sign<0) ?r:measPar - newPar(mk);
    SCovMatrix5 updatedCov   = (sign<0) ?
      trkCov                             : // when removing, the input are updated par
      newCov                             ; // when adding, chi2 is made from upd. par
 
    // for both signs (add/remove) the chi2 is now calculated like for updated states
    double chiSquared = measCov(0,0) - updatedCov(mk,mk);
    if (chiSquared == 0.0)
        ATH_MSG_DEBUG( "division by zero in 1D chi2, set chi2 to 0.0 instead" );
    else {
      // get chi2 = r.T() * R^-1 * r
      chiSquared = predictedResidual*predictedResidual/chiSquared;
      ATH_MSG_VERBOSE( "-U- fitQuality of "<< (sign>0?" added ":"removed")
              <<" state, chi2 :" << chiSquared << " / ndof= 1" );
    }
    fitQoS = new FitQualityOnSurface(chiSquared, 1);
  }
  return convertToClonedTrackPars(TP,newPar,newCov,sign,createFQoS,"1D");
}

calculateFilterStep_2D()

std::unique_ptr< Trk::TrackParameters > Trk::KalmanUpdatorSMatrix::calculateFilterStep_2D ( const TrackParameters & TP, const SParVector5 & trkPar, const SCovMatrix5 & trkCov, const SParVector2 & SmeasPar, int paramKey, const Amg::MatrixX & measCov, const int sign, Trk::FitQualityOnSurface *& fitQoS, bool createFQoS ) const

private

common maths calculation code for all addToState and removeFromState versions which happen to be called with 2-dim measurements.

Definition at line 702 of file KalmanUpdatorSMatrix.cxx.

                                                                           {
  // make reduction matrix H from LocalParameters
  ROOT::Math::SMatrix<double,2,5,ROOT::Math::MatRepStd<double, 2, 5> > H;
  // and transform EDM to new math lib
  SCovMatrix2 SmeasCov;
  for (int i=0, irow=0; i<5; ++i) {
    if (paramKey & (1<<i)) {
      SParVector5 v; v(i)=1.0;
      H.Place_in_row(v, irow, 0);
      SmeasCov(0,irow) = measCov(0,irow);
      SmeasCov(1,irow) = measCov(1,irow);
      ++irow;
    }
  }
  SParVector2 r = SmeasPar - H * trkPar;
  //  FIXME catchPiPi;
  SCovMatrix2 R = sign * SmeasCov + projection_2D(trkCov,paramKey);
  if (!R.Invert()) {
    ATH_MSG_DEBUG( "inversion of residual error matrix (2D) failed.");
    return nullptr;
  }
 
  // --- compute Kalman gain matrix
  ROOT::Math::SMatrix<double,5,2,ROOT::Math::MatRepStd<double, 5, 2> >
    K = trkCov * ROOT::Math::Transpose(H) * R;
  if (msgLvl(MSG::VERBOSE)) {
    SParVector5 trans_r; SCovMatrix5 trans_R; SGenMatrix5 trans_K;
    logGainForm (2,  trans_r.Place_at(r,0),
                 trans_R.Place_at(R,0,0),
                 trans_K.Place_at(K,0,0));
  }
 
  // --- compute local filtered state
  SParVector5 newPar = trkPar + K * r;
  if (!thetaWithinRange_5D(newPar)) {
    if (H(0,Trk::theta) != 1.0 && H(1,Trk::theta) != 1.0 &&
        ( std::abs(R(0,0)*r(0))>1.0 || std::abs(R(1,1)*r(1))>1.0 ||
          trkCov(Trk::theta,Trk::theta) > 0.1*m_cov0(Trk::theta))) {
      ATH_MSG_DEBUG( "calculateFS_2D(): decided to damp update of theta and re-calculate.");
      K(Trk::theta,0) = K(Trk::theta,0)*m_thetaGainDampingValue;
      K(Trk::theta,1) = K(Trk::theta,1)*m_thetaGainDampingValue;
      newPar = trkPar + K * r;
      if (msgLvl(MSG::DEBUG)) {
        msg(MSG::DEBUG) << "-U- damped gain K0=("
              <<std::setiosflags(std::ios::fixed | std::ios::showpoint | std::ios::right)
              << std::setw(7) << std::setprecision(4) << K(0,0)<<", "
              << std::setw(7) << std::setprecision(4) << K(1,0)<<", "
              << std::setw(7) << std::setprecision(4) << K(2,0)<<", "
              << std::setw(7) << std::setprecision(4) << K(3,0)<<", "
              << std::setw(7) << std::setprecision(4) << K(4,0)<<")"
              << std::resetiosflags(std::ios::fixed) << endmsg;
        msg(MSG::DEBUG) << "-U-             K1=("
              <<std::setiosflags(std::ios::fixed | std::ios::showpoint | std::ios::right)
              << std::setw(7) << std::setprecision(4) << K(0,1)<<", "
              << std::setw(7) << std::setprecision(4) << K(1,1)<<", "
              << std::setw(7) << std::setprecision(4) << K(2,1)<<", "
              << std::setw(7) << std::setprecision(4) << K(3,1)<<", "
              << std::setw(7) << std::setprecision(4) << K(4,1)<<")"
              << std::resetiosflags(std::ios::fixed) << endmsg;
      }
    } else {
      ATH_MSG_DEBUG( "-U- theta out of range but can not damp this update.");
    }
  }
 
  // --- compute filtered covariance matrix
  SGenMatrix5 M = m_unitMatrix - K * H;
  SCovMatrix5 newCov;
  if (!m_useFruehwirth8a) {
    // compute covariance matrix of local filteres state
    //   C = M * covTrk * M.T() +/- K * covRio * K.T()
    newCov = ROOT::Math::Similarity(M,trkCov)
      + sign*(ROOT::Math::Similarity(K,SmeasCov));
  } else {
    //   C = (1 - KH) trkCov = trkCov - K*H*trkCov
    /*    SGenMatrix5 KtimesH = K*H;
    SCovMatrix5 M;
    ROOT::Math::AssignSym::Evaluate(M, KtimesH * trkCov);
    newCov -= M; */
    ROOT::Math::AssignSym::Evaluate(newCov, M * trkCov);
  }
  if ( (!thetaPhiWithinRange_5D(newPar, Trk::absoluteCheck)) ?
       !correctThetaPhiRange_5D(newPar, newCov, Trk::absoluteCheck) : false ) {
    ATH_MSG_WARNING( "calculateFS_2D(): bad angles in filtered state!" );
    return nullptr;
  }
 
  if (createFQoS) {      // get chi2 = r.T() * R2^-1 * r
    double  chiSquared = (sign>0) ?
    // when adding, the r and R are ready to for calculating the predicted chi2
    ROOT::Math::Similarity(r,R) :
    // when removing the r and -R are ready for calculating the updated chi2.
    ROOT::Math::Similarity(r,-R);
    ATH_MSG_DEBUG( "-U- fitQuality of "<< (sign>0?" added ":"removed")
            <<" state, chi2 :" << chiSquared << " / ndof= 2" );
    fitQoS = new FitQualityOnSurface(chiSquared, 2);
  }
  return convertToClonedTrackPars(TP,newPar,newCov,sign,createFQoS,"2D");
}

calculateFilterStep_3D()

std::unique_ptr< Trk::TrackParameters > Trk::KalmanUpdatorSMatrix::calculateFilterStep_3D ( const TrackParameters & TP, const SParVector5 & trkPar, const SCovMatrix5 & trkCov, const LocalParameters & measPar, const Amg::MatrixX & measCov, const int sign, Trk::FitQualityOnSurface *& fitQoS, bool createFQoS ) const

private

common maths calculation code for all addToState and removeFromState versions which happen to be called with 3-dim measurements.

Definition at line 812 of file KalmanUpdatorSMatrix.cxx.

                                                                           {
  // transform EDM to new math lib
  SParVector3 SmeasPar(measPar[Trk::locX],measPar[Trk::locY],measPar[Trk::phi]);
  SCovMatrix3 SmeasCov;
  // make reduction matrix H from LocalParameters
  ROOT::Math::SMatrix<double,3,5,ROOT::Math::MatRepStd<double, 3, 5> > H;
  for (int i=0, irow=0; i<5; ++i) {
    if (measPar.parameterKey() & (1<<i)) {
      SParVector5 v; v(i)=1.0;
      H.Place_in_row(v, irow, 0);
      SmeasCov(0,irow) = measCov(0,irow);
      SmeasCov(1,irow) = measCov(1,irow);
      SmeasCov(2,irow) = measCov(2,irow);
      ++irow;
    }
  }
  SParVector3 r = SmeasPar - H * trkPar;
  //  FIXME catchPiPi;
  SCovMatrix3 R = sign * SmeasCov + projection_3D(trkCov,measPar.parameterKey());
  if (!R.Invert()) {
    ATH_MSG_DEBUG( "inversion of residual error matrix (3D) failed.");
    return nullptr;
  }
 
  // compute Kalman gain matrix
  ROOT::Math::SMatrix<double,5,3,ROOT::Math::MatRepStd<double, 5, 3> >
    K = trkCov * ROOT::Math::Transpose(H) * R;
  SGenMatrix5 M = m_unitMatrix - K * H;
  if (msgLvl(MSG::VERBOSE)) {
    SParVector5 trans_r; SCovMatrix5 trans_R; SGenMatrix5 trans_K;
    logGainForm (3,  trans_r.Place_at(r,0),
                 trans_R.Place_at(R,0,0), trans_K.Place_at(K,0,0));
  }
 
  // compute local filtered state
  SParVector5 newPar = trkPar + K * r;
 
  SCovMatrix5 newCov;
  if (!m_useFruehwirth8a) {
    // compute covariance matrix of local filteres state
    //   C = M * covTrk * M.T() +/- K * covRio * K.T()
    newCov = ROOT::Math::Similarity(M,trkCov)
      + sign*(ROOT::Math::Similarity(K,SmeasCov));
  } else {
    //   C = (1 - KH) trkCov = trkCov - K*H*trkCov
    /*    SGenMatrix5 KtimesH = K*H;
    SCovMatrix5 M;
    ROOT::Math::AssignSym::Evaluate(M, KtimesH * trkCov);
    newCov -= M; */
    ROOT::Math::AssignSym::Evaluate(newCov, M * trkCov);
  }
 
  if ( (!thetaPhiWithinRange_5D(newPar,Trk::absoluteCheck)) ?
       !correctThetaPhiRange_5D(newPar,newCov,Trk::absoluteCheck) : false ) {
    ATH_MSG_WARNING( "calculateFS_3D(): bad angles in filtered state!" );
    return nullptr;
  }
 
  if (createFQoS) {
    SParVector3 predictedResidual = (sign<0) ?
      r                                      :
      SmeasPar - H * newPar                  ;
    SCovMatrix5 updatedCov   = (sign<0) ?
      trkCov                            : // when removing, the input are updated par
      newCov                            ; // when adding, chi2 is made from upd. par
 
    // for both signs (add/remove) the chi2 is now calculated like for updated states
    SCovMatrix3 R2 = SmeasCov - projection_3D(updatedCov,measPar.parameterKey());
    double  chiSquared;
    if ( !R2.Invert() ) {
      ATH_MSG_DEBUG( "matrix (3D) inversion not possible, set chi2 to zero");
      chiSquared = 0.f;
    } else {
      // get chi2 = r.T() * R2^-1 * r
      chiSquared = ROOT::Math::Similarity(predictedResidual,R2);
      ATH_MSG_VERBOSE( "-U- fitQuality of "<< (sign>0?" added ":"removed")
              <<" state, chi2 :" << chiSquared << " / ndof= 3" );
    }
    fitQoS = new FitQualityOnSurface(chiSquared, 3);
  }
  return convertToClonedTrackPars(TP,newPar,newCov,sign,createFQoS,"3D");
}

calculateFilterStep_4D()

std::unique_ptr< Trk::TrackParameters > Trk::KalmanUpdatorSMatrix::calculateFilterStep_4D ( const TrackParameters & TP, const SParVector5 & trkPar, const SCovMatrix5 & trkCov, const LocalParameters & measPar, const Amg::MatrixX & measCov, const int sign, Trk::FitQualityOnSurface *& fitQoS, bool createFQoS ) const

private

common maths calculation code for all addToState and removeFromState versions which happen to be called with 4-dim measurements.

Definition at line 904 of file KalmanUpdatorSMatrix.cxx.

                                                                    {
  // transform EDM to new math lib
  SParVector4 SmeasPar(measPar[Trk::d0],measPar[Trk::z0],
                       measPar[Trk::phi0],measPar[Trk::theta]);
  SCovMatrix4 SmeasCov;
 
  // make reduction matrix H from LocalParameters
  ROOT::Math::SMatrix<double,4,5,ROOT::Math::MatRepStd<double, 4, 5> > H;
  for (int i=0, irow=0; i<5; ++i) {
    if (measPar.parameterKey() & (1<<i)) {
      SParVector5 v; v(i)=1.0;
      H.Place_in_row(v, irow, 0);
      SmeasCov(0,irow) = measCov(0,irow);
      SmeasCov(1,irow) = measCov(1,irow);
      SmeasCov(2,irow) = measCov(2,irow);
      SmeasCov(3,irow) = measCov(3,irow);
      ++irow;
    }
  }
  SParVector4 r = SmeasPar - H * trkPar;
  //  FIXME catchPiPi;
  SCovMatrix4 R = sign * SmeasCov + projection_4D(trkCov,measPar.parameterKey());
  if (!R.Invert()) {
    ATH_MSG_DEBUG( "inversion of residual error matrix (4D) failed." );
    return nullptr;
  }
 
  // compute Kalman gain matrix
  ROOT::Math::SMatrix<double,5,4,ROOT::Math::MatRepStd<double, 5, 4> >
    K = trkCov * ROOT::Math::Transpose(H) * R;
  SGenMatrix5 M = m_unitMatrix - K * H;
  if (msgLvl(MSG::VERBOSE)) {
    SParVector5 trans_r; SCovMatrix5 trans_R; SGenMatrix5 trans_K;
    logGainForm (4,  trans_r.Place_at(r,0),
                 trans_R.Place_at(R,0,0), trans_K.Place_at(K,0,0));
  }
 
  // compute local filtered state
  SParVector5 newPar = trkPar + K * r;
 
  SCovMatrix5 newCov;
  if (!m_useFruehwirth8a) {
    // compute covariance matrix of local filteres state
    //   C = M * covTrk * M.T() +/- K * covRio * K.T()
    newCov = ROOT::Math::Similarity(M,trkCov)
      + sign*(ROOT::Math::Similarity(K,SmeasCov));
  } else {
    //   C = (1 - KH) trkCov = trkCov - K*H*trkCov
    /*    SGenMatrix5 KtimesH = K*H;
    SCovMatrix5 M;
    ROOT::Math::AssignSym::Evaluate(M, KtimesH * trkCov);
    newCov -= M; */
    ROOT::Math::AssignSym::Evaluate(newCov, M * trkCov);
  }
 
  if ( (!thetaPhiWithinRange_5D(newPar,Trk::absoluteCheck)) ?
       !correctThetaPhiRange_5D(newPar,newCov,Trk::absoluteCheck) : false ) {
    ATH_MSG_WARNING( "calculateFS_4D(): bad angles in filtered state!" );
    return nullptr;
  }
 
  if (createFQoS) {
    SParVector4 predictedResidual = (sign<0) ?r:SmeasPar - H * newPar;
    SCovMatrix5 updatedCov   = (sign<0) ?
      trkCov                            : // when removing, the input are updated par
      newCov                            ; // when adding, chi2 is made from upd. par
 
    // for both signs (add/remove) the chi2 is now calculated like for updated states
    SCovMatrix4 R2 = SmeasCov - projection_4D(updatedCov,measPar.parameterKey());
    double  chiSquared;
    if ( !R2.Invert() ) {
      ATH_MSG_DEBUG( "matrix (4D) inversion not possible, set chi2 to zero");
      chiSquared = 0.f;
    } else {
      // get chi2 = r.T() * R2^-1 * r
      chiSquared = ROOT::Math::Similarity(predictedResidual,R2);
      ATH_MSG_VERBOSE( "-U- fitQuality of "<< (sign>0?" added ":"removed")
              <<" state, chi2 :" << chiSquared << " / ndof= 4" );
    }
    fitQoS = new FitQualityOnSurface(chiSquared, 4);
  }
  return convertToClonedTrackPars(TP,newPar,newCov,sign,createFQoS,"4D");
}

calculateFilterStep_5D()

std::unique_ptr< Trk::TrackParameters > Trk::KalmanUpdatorSMatrix::calculateFilterStep_5D ( const TrackParameters & TP, const SParVector5 & trkParOne, const SCovMatrix5 & trkCovOne, const SParVector5 & trkParTwo, const Amg::MatrixX & measCov, const int sign, Trk::FitQualityOnSurface *& fitQoS, bool createFQoS ) const

private

common maths calculation code for all addToState and removeFromState versions which happen to be called with 5-dim measurements or two track states.

For 5-dim track states the ParameterKey is known to be 31 and does not need to be passed through the interface.

Definition at line 997 of file KalmanUpdatorSMatrix.cxx.

                                                                    {
  SCovMatrix5 trkCovTwo;   // transform EDM to new math lib
  for (int i=0; i<5; ++i)
    for (int j=0; j<=i; ++j) {
      trkCovTwo(j,i) = measCov(j,i);
    }
 
  // this update is symmetric in state and measurement parameters, H == 1.
  SCovMatrix5 R = sign * trkCovTwo + trkCovOne;
  if (!R.Invert()) {
    ATH_MSG_DEBUG( "inversion of residual error matrix (5D) failed." );
    return nullptr;
  }
 
  SParVector5 r = trkParTwo - trkParOne;
  if ( (!thetaPhiWithinRange_5D(r,Trk::differentialCheck)) ?
       !correctThetaPhiRange_5D(r,R,Trk::differentialCheck) : false ) {
    ATH_MSG_WARNING( "calculateFS_5D(): bad angles in intermediate residual!" );
    return nullptr;
  }
  SGenMatrix5 K = trkCovOne * R;
  if (msgLvl(MSG::VERBOSE)) logGainForm (5,  r, R, K);
 
  // compute local filtered state
  SParVector5 newPar = trkParOne + K * r;
  SCovMatrix5 newCov;
  /*  if (!m_useFruehwirth8a) {
    SGenMatrix5 M = m_unitMatrix - K;
    // compute covariance matrix of local filtered state
    //   C = M * covTrk * M.T() +/- K * covRio * K.T()
    newCov = ROOT::Math::Similarity(M,trkCovOne)
      + sign*(ROOT::Math::Similarity(K,trkCovTwo));
      } else { */
    // original Fruehwirth eq. 8a is simpler, expression checked to be symm.
    ROOT::Math::AssignSym::Evaluate(newCov, K * trkCovTwo);
    //  }
 
  if ( (!thetaPhiWithinRange_5D(newPar,Trk::absoluteCheck)) ?
       !correctThetaPhiRange_5D(newPar,newCov,Trk::absoluteCheck) : false ) {
    ATH_MSG_WARNING( "calculateFS_5D(): bad angles in filtered state!" );
    return nullptr;
  }
 
  bool goodMatrix(true);
  for (int i=0; i<5; ++i) {
    if (newCov(i,i) < 0.0 && goodMatrix ) goodMatrix=false;
  }
  if (!goodMatrix) {
    SGenMatrix5 M = m_unitMatrix - K;
    // compute covariance matrix of local filtered state
    //   C = M * covTrk * M.T() +/- K * covRio * K.T()
    newCov = ROOT::Math::Similarity(M,trkCovOne)
      + sign*(ROOT::Math::Similarity(K,trkCovTwo));
    goodMatrix = true;
    for (int i=0; i<5; ++i) {
      if (newCov(i,i) < 0.0 && goodMatrix ) goodMatrix=false;
      if (!goodMatrix) {
        ATH_MSG_DEBUG("calculateFS_5D(): unphysical cov!");
        return nullptr;
      }
    }
  }
 
  if (createFQoS) {      // get chi2 = r.T() * R2^-1 * r
    double  chiSquared = (sign>0) ?
      // when adding, the r and R are ready to for calculating the predicted chi2
      ROOT::Math::Similarity(r,R) :
      // when removing the r and -R are ready for calculating the updated chi2.
      ROOT::Math::Similarity(r,-R);
    ATH_MSG_VERBOSE( "-U- fitQuality of "<< (sign>0?" added ":"removed")
            <<" state, chi2 :" << chiSquared << " / ndof= 5" );
    fitQoS = new FitQualityOnSurface(chiSquared, 5);
  }
  return convertToClonedTrackPars(TP,newPar,newCov,sign,createFQoS,"5D");
}

combineStates() [1/2]

std::unique_ptr< Trk::TrackParameters > Trk::KalmanUpdatorSMatrix::combineStates ( const TrackParameters & one, const TrackParameters & two ) const

finaloverridevirtual

trajectory state updator which combines two parts of a trajectory on a common surface.

Make sure that the TPs' surfaces are identical and that the local hit is not duplicated in both trajectories!

Implements Trk::IUpdator.

Definition at line 252 of file KalmanUpdatorSMatrix.cxx.

                                                                                                     {
    // try if both Track Parameters are measured ones ?
    const AmgSymMatrix(5)* covOne = one.covariance();
    const AmgSymMatrix(5)* covTwo = two.covariance();
 
    // remember, either one OR two might have no error, but not both !
    if (!covOne && ! covTwo) {
        ATH_MSG_WARNING( "both parameters have no errors, invalid use of Updator::combineStates()" );
        return nullptr;
    }
    // if only one of two has an error, return that one
    if (!covOne) {
      if (msgLvl(MSG::VERBOSE)) logResult("combineStates(TP,TP)",two.parameters(),*covTwo);
      return std::unique_ptr<Trk::TrackParameters>(two.clone());
    }
    if (!covTwo) {
      if (msgLvl(MSG::VERBOSE)) logResult("combineStates(TP,TP)",one.parameters(),*covOne);
      return std::unique_ptr<Trk::TrackParameters>(one.clone());
    }
 
    // ... FIXME - TRT is so difficult, need to check that both parameters are in the same frame
    //             otherwise go into frame of one !
 
    // call 5dim updator to combine using gain matrix formalism
    SCovMatrix5 covOneSM;
    for (int i=0; i<5; ++i)
      for (int j=0; j<=i; ++j) {
        covOneSM(j,i) = (*covOne)(j,i);
      }
 
    FitQualityOnSurface*    fitQoS = nullptr;
    return calculateFilterStep_5D(one,SParVector5(&one.parameters()[0],5),covOneSM,
                                  SParVector5(&two.parameters()[0],5),
                                  *covTwo,
                                  +1,fitQoS,false);
}

combineStates() [2/2]

std::unique_ptr< Trk::TrackParameters > Trk::KalmanUpdatorSMatrix::combineStates ( const TrackParameters & one, const TrackParameters & two, FitQualityOnSurface *& fitQoS ) const

finaloverridevirtual

trajectory state updator which combines two parts of a trajectory on a common surface and provides the FitQuality.

Make sure that the TPs' surfaces are identical and that the local hit is not duplicated!

Implements Trk::IUpdator.

Definition at line 291 of file KalmanUpdatorSMatrix.cxx.

                                                                                                    {
    // try if both Track Parameters are measured ones ?
    const AmgSymMatrix(5)* covOne = one.covariance();
    const AmgSymMatrix(5)* covTwo = two.covariance();
 
    // remember, either one OR two might have no error, but not both !
    if (!covOne && ! covTwo) {
        ATH_MSG_WARNING( "both parameters have no errors, invalid use of Updator::combineStates()" );
        return nullptr;
    }
 
    if (fitQoS) {
        ATH_MSG_WARNING( "expect nil FitQuality pointer, refuse operation to avoid mem leak!");
        return nullptr;
    }
 
    // if only one of two has an error, return that one
    if (!covOne) {
      if (msgLvl(MSG::VERBOSE)) logResult("combineStates(TP,TP)",two.parameters(),*covTwo);
      return std::unique_ptr<Trk::TrackParameters>(two.clone());
    }
    if (!covTwo) {
      if (msgLvl(MSG::VERBOSE)) logResult("combineStates(TP,TP)",one.parameters(),*covOne);
      return std::unique_ptr<Trk::TrackParameters>(one.clone());
    }
 
    // call 5dim updator to combine using gain matrix formalism
    SCovMatrix5 covOneSM;
    for (int i=0; i<5; ++i)
      for (int j=0; j<=i; ++j) {
        covOneSM(j,i) = (*covOne)(j,i);
    }
 
    return calculateFilterStep_5D(one,SParVector5(&one.parameters()[0],5),covOneSM,
                                  SParVector5(&two.parameters()[0],5),
                                  (*covTwo),
                                  +1,fitQoS,true);
}

consistentParamDimensions()

bool Trk::KalmanUpdatorSMatrix::consistentParamDimensions ( const LocalParameters & P, int dimCov ) const

private

method testing correct use of LocalParameters

Definition at line 1310 of file KalmanUpdatorSMatrix.cxx.

                                                                            {
  if (P.dimension() != dimCov ) {
    ATH_MSG_WARNING ("Inconsistency in dimension of local coord - problem with LocalParameters object?");
    ATH_MSG_WARNING ("dim of local parameters: "<<P.dimension()<<" vs. dim of error matrix: "<<dimCov);
    return false;
  } return true;
}

convertToClonedTrackPars()

std::unique_ptr< Trk::TrackParameters > Trk::KalmanUpdatorSMatrix::convertToClonedTrackPars ( const TrackParameters & TP, const SParVector5 & par, const SCovMatrix5 & covpar, int sign, bool createFQoS, std::string_view ndtext ) const

private

Helper method to convert internal results from SMatrix to Eigen. *‍/.

Definition at line 1159 of file KalmanUpdatorSMatrix.cxx.

                                                                                 {
  AmgSymMatrix(5) C;
  C.setZero();
  for (int i=0; i<5; ++i) {
    for (int j=0; j<=i; ++j) {
      C.fillSymmetric(i,j, covpar(i,j));
    }
  }
 
  std::unique_ptr<Trk::TrackParameters> resultPar =
    TP.associatedSurface().createUniqueTrackParameters(par[0],par[1],par[2],par[3],par[4],C);
 
  if (msgLvl(MSG::VERBOSE) && resultPar) {
    char reportCalledInterface[80];
    char ndtext2[5];
    memset(ndtext2, '\0', 5 ); ndtext.copy(ndtext2,2); // convert char to string
    if (sign>0)
      sprintf(reportCalledInterface,"%s-%s,%s)",
              (ndtext=="5D"?"combineStates(TP,TP":"addToState(TP,Meas"),
              ndtext2,(createFQoS?"Err,FQ":"Err"));
    else
      sprintf(reportCalledInterface,"%s,Meas-%s,%s)","removeFromState(TP,",
              ndtext2,(createFQoS?"Err,FQ":"Err"));
    logResult((std::string)reportCalledInterface, resultPar->parameters(),C);
  }
 
  return resultPar;
}

correctThetaPhiRange_5D()

bool Trk::KalmanUpdatorSMatrix::correctThetaPhiRange_5D ( SParVector5 & V, SCovMatrix5 & M, const RangeCheckDef rcd ) const

private

method correcting the calculated angles back to their defined ranges phi (-pi, pi) and theta (0, pi).

Only works if the excess is not far from the defined range, as it happens e.g. when the update moves across the phi= +/-pi boundary.

Definition at line 1319 of file KalmanUpdatorSMatrix.cxx.

{
  static const SParVector2 thetaMin(0.0, -M_PI);
 
  // correct theta coordinate
  if ( V(Trk::theta)<thetaMin((int)rcd) || V(Trk::theta)> M_PI ) {
    ATH_MSG_DEBUG ("-U- theta angle out of range: theta= "<<V(Trk::theta)<<", phi= "<<V(Trk::phi));
    // absolute theta: repair if between -pi and +2pi.
    // differential theta: repair if between -pi and +pi
    if ( ( V(Trk::theta) < -M_PI ) ||
         ( V(Trk::theta) > (rcd==Trk::differentialCheck ? M_PI : 2*M_PI) )
         ) {
      ATH_MSG_WARNING ("-U- track theta = "<<V(Trk::theta)<<" -> this is too far from defined range, stop update.");
      return false;
    }
    if (V(Trk::theta) > M_PI) {
      V(Trk::theta) = 2*M_PI - V(Trk::theta);
      V(Trk::phi)  += (V(Trk::phi)>0.0) ? -M_PI : M_PI;
    } else if (V(Trk::theta) < 0.0) {
      V(Trk::theta) = -V(Trk::theta);
      V(Trk::phi)  += (V(Trk::phi)>0.0) ? -M_PI : M_PI;
    }
    // correct also cov matrix:
    M(0,3) = -M(0,3); // cov(polar,locX)
    M(1,3) = -M(1,3); // cov(polar,locY)
    M(2,3) = -M(2,3); // cov(polar,azimuthal)
    M(3,4) = -M(3,4); // cov(polar,qOverP)
    ATH_MSG_DEBUG ("-U- now use corrected value phi= "<<V(Trk::phi)<<" theta = "<<V(Trk::theta));
  }
 
 
  // correct phi coordinate if necessary
  if ( (V(Trk::phi) > M_PI) ) {
    if (msgLvl(MSG::DEBUG)) msg(MSG::DEBUG) << "-U- phi = " << V(Trk::phi);
    V(Trk::phi) = std::fmod(V(Trk::phi)+M_PI,2*M_PI)-M_PI;
    ATH_MSG_DEBUG( " out of range, now corrected to " << V(Trk::phi) );
  } else if( (V(Trk::phi)<-M_PI) ) {
    ATH_MSG_DEBUG( "-U- phi = " << V(Trk::phi));
    V(Trk::phi) = std::fmod(V(Trk::phi)-M_PI,2*M_PI)+M_PI;
    ATH_MSG_DEBUG( " out of range, now corrected to " << V(Trk::phi) );
  }
 
  return true;
}

declareGaudiProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareGaudiProperty ( Gaudi::Property< T, V, H > & hndl, const SG::VarHandleKeyType &  )

inlineprivateinherited

specialization for handling Gaudi::Property<SG::VarHandleKey>

Definition at line 156 of file AthCommonDataStore.h.

  {
    return *AthCommonDataStore<PBASE>::declareProperty(hndl.name(),
                                                       hndl.value(), 
                                                       hndl.documentation());
 
  }

declareProperty()

Gaudi::Details::PropertyBase & AthCommonDataStore< AthCommonMsg< AlgTool > >::declareProperty ( Gaudi::Property< T, V, H > & t )

inlineinherited

Definition at line 145 of file AthCommonDataStore.h.

                                                                     {
    typedef typename SG::HandleClassifier<T>::type htype;
    return AthCommonDataStore<PBASE>::declareGaudiProperty(t, htype());
  }

detStore()

const ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::detStore ( ) const

inlineinherited

The standard StoreGateSvc/DetectorStore Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 95 of file AthCommonDataStore.h.

{ return m_detStore; }

evtStore()

ServiceHandle< StoreGateSvc > & AthCommonDataStore< AthCommonMsg< AlgTool > >::evtStore ( )

inlineinherited

The standard StoreGateSvc (event store) Returns (kind of) a pointer to the StoreGateSvc.

Definition at line 85 of file AthCommonDataStore.h.

{ return m_evtStore; }

extraDeps_update_handler()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::extraDeps_update_handler ( Gaudi::Details::PropertyBase & ExtraDeps )

protectedinherited

Add StoreName to extra input/output deps as needed.

use the logic of the VarHandleKey to parse the DataObjID keys supplied via the ExtraInputs and ExtraOuputs Properties to add the StoreName if it's not explicitly given

finalize()

StatusCode Trk::KalmanUpdatorSMatrix::finalize ( )

overridevirtual

AlgTool termination.

Definition at line 70 of file KalmanUpdatorSMatrix.cxx.

{
    return StatusCode::SUCCESS;
}

fullStateFitQuality() [1/2]

Trk::FitQualityOnSurface Trk::KalmanUpdatorSMatrix::fullStateFitQuality ( const TrackParameters & trkPar, const Amg::Vector2D & locPos, const Amg::MatrixX & covRio ) const

finaloverridevirtual

estimator for FitQuality on Surface from a full track state, that is a state which contains the current hit (expressed as Amg::Vector2D).

Implements Trk::IUpdator.

Definition at line 335 of file KalmanUpdatorSMatrix.cxx.

                                                                         {
  ATH_MSG_DEBUG( "--> entered KalmanUpdatorSMatrix::fullStateFitQuality(TP,LPOS,ERR)" );
    // try if Track Parameters are measured ones ?
    if (!trkPar.covariance()) {
      ATH_MSG_ERROR( "updated track state has no error matrix" );
      return {};
    }
    // For the LocalPos. version, need to get # meas. coord. from covariance matrix.
    int nLocCoord = covRio.cols();
    if (nLocCoord == 1) {
      return makeChi2_1D(SParVector5(&trkPar.parameters()[0],5),
                         (*trkPar.covariance()),
                         locPos[Trk::locX],covRio(0,0),
                         1,-1); // key=1, signForUpdatedChi2 = -1
    } if (nLocCoord == 2) {
      SCovMatrix2 SmeasCov;
      SmeasCov(0,0) = covRio(0,0);
      SmeasCov(1,0) = covRio(0,1);
      SmeasCov(1,1) = covRio(1,1);
      return makeChi2_2D(SParVector5(&trkPar.parameters()[0],5),
                         (*trkPar.covariance()),
                         SParVector2(locPos[Trk::locX],locPos[Trk::locY]),
                         SmeasCov, 2,-1);
    }
      ATH_MSG_WARNING( "Error in local position - must be 1D or 2D!" );
      return {};
 
}

fullStateFitQuality() [2/2]

Trk::FitQualityOnSurface Trk::KalmanUpdatorSMatrix::fullStateFitQuality ( const TrackParameters & trkPar, const LocalParameters & parRio, const Amg::MatrixX & covRio ) const

finaloverridevirtual

estimator for FitQuality on Surface from a full track state, that is a state which contains the current hit (expressed as LocalParameters).

Implements Trk::IUpdator.

Definition at line 369 of file KalmanUpdatorSMatrix.cxx.

                                                                                {
  ATH_MSG_VERBOSE( "--> entered KalmanUpdatorSMatrix::fullStateFitQuality(TP,LPAR,ERR)" );
 
    // try if Track Parameters are measured ones ?
    if (!trkPar.covariance()) {
        ATH_MSG_ERROR( "updated track state has no error matrix" );
        return {};
    }
    int nLocCoord = parRio.dimension();
    if ( ! consistentParamDimensions(parRio,covRio.cols()) ) return {};
    // local params can NOT be accessed like vector[i], therefore need some acrobatics:
    ROOT::Math::SVector<int,5>  intAccessor;
    for (int i=0,k=0; i<5; ++i) { if (parRio.parameterKey() & (1<<i)) intAccessor(k++)=i; }
    if (nLocCoord == 1) {
      return makeChi2_1D(SParVector5(&trkPar.parameters()[0],5),
                         (*trkPar.covariance()),
                         parRio[Trk::ParamDefsAccessor::pardef[intAccessor(0)]],covRio(0,0),
                         parRio.parameterKey(),-1);
    } if (nLocCoord == 2) {
      SCovMatrix2 SmeasCov;
      for (int i=0, irow=0; i<5; ++i) {
        if (parRio.parameterKey() & (1<<i)) {
          SmeasCov(0,irow) = covRio(0,irow);
          SmeasCov(1,irow) = covRio(1,irow);
          ++irow;
        }
      }
      return makeChi2_2D(SParVector5(&trkPar.parameters()[0],5),
                         (*trkPar.covariance()),
                         SParVector2(parRio[Trk::ParamDefsAccessor::pardef[intAccessor(0)]],
                                     parRio[Trk::ParamDefsAccessor::pardef[intAccessor(1)]]),
                         SmeasCov, parRio.parameterKey(),-1);
    } if (nLocCoord == 5) {
      return makeChi2_5D(SParVector5(&trkPar.parameters()[0],5),
                         (*trkPar.covariance()),
                         SParVector5(parRio[Trk::locX],parRio[Trk::locY],
                                     parRio[Trk::phi0],parRio[Trk::theta],
                                     parRio[Trk::qOverP]),
                         covRio,-1);
    } // stay with Eigen for other cases
 
      // State to measurement dimensional reduction Matrix ( n x m )
      const Amg::MatrixX& H = parRio.expansionMatrix();
 
      // residuals
      Amg::VectorX r;
      if (parRio.parameterKey()==31) r = (parRio - trkPar.parameters());
      else r = (parRio - H*trkPar.parameters());
 
      // all the rest is outsourced to a common chi2 routine
      return makeChi2Object(r,(*trkPar.covariance()),covRio,H,-1);
 
}

getStartCov()

bool Trk::KalmanUpdatorSMatrix::getStartCov ( SCovMatrix5 & M, const TrackParameters & inputParameters, const int isign ) const

private

Helper method to transform Eigen cov matrix to SMatrix.

Definition at line 1259 of file KalmanUpdatorSMatrix.cxx.

{
 
  const AmgSymMatrix(5)* covariance = inputParameters.covariance();
  if (!covariance) {
    if (isign<0) {
      ATH_MSG_WARNING ("MeasuredTrackParameters == Null, can not calculate updated parameter state.");
      return false;
    }
      // no error given - use a huge error matrix for the time
      ATH_MSG_VERBOSE ("-U- no covTrk at input - assign large error matrix for the time being.");
      M.SetDiagonal(m_cov0);
 
  } else {
    //    int k = measTrkPar->localAmg::MatrixX().covariance().cols(); is always 5
    for (int i=0; i<5; ++i) {
      for (int j=0; j<=i; ++j) {
        M(i,j) = (*covariance)(i,j); // can improve speed by apply() access
      }
    }
  }
  return true;
}

initialErrors()

std::vector< double > Trk::KalmanUpdatorSMatrix::initialErrors ( ) const

finaloverridevirtual

give back how updator is configured for inital covariances

Implements Trk::IUpdator.

Definition at line 541 of file KalmanUpdatorSMatrix.cxx.

                                                               {
  std::vector<double> E(5);
  for (int i=0; i<5; ++i) E[i] = std::sqrt(m_cov0(i));
  return E;
}

initialize()

StatusCode Trk::KalmanUpdatorSMatrix::initialize ( )

overridevirtual

AlgTool initialisation.

Definition at line 50 of file KalmanUpdatorSMatrix.cxx.

{
    if (m_cov_stdvec.size() < 5) {
      ATH_MSG_WARNING( "Wrong-sized initial covariance given, so set to default: ");
      m_cov_stdvec = {250.,250.,0.25, 0.25, 0.000001};
    }
    m_cov0 = SParVector5(&m_cov_stdvec[0],5);
    if (m_useFruehwirth8a) {
      ATH_MSG_DEBUG( "Fast computation will be used for track state cov matrices (Fruehwirth-1987 eq. 8a)." );
    } else{
      ATH_MSG_DEBUG( "Track state cov matrix will be calculated according to Gelb-1975 p305." );
    }
 
    const SParVector5 IV(1.0, 1.0, 1.0, 1.0, 1.0);
    m_unitMatrix.SetDiagonal(IV);
 
    return StatusCode::SUCCESS;
}

inputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::inputHandles ( ) const

overridevirtualinherited

Return this algorithm's input handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

interfaceID()

const InterfaceID & Trk::IUpdator::interfaceID ( )

inlinestaticinherited

Algtool infrastructure.

Definition at line 227 of file IUpdator.h.

{
  return IID_IUpdator;
}

logGainForm()

void Trk::KalmanUpdatorSMatrix::logGainForm ( int nc, const SParVector5 & r, const SCovMatrix5 & R, const SGenMatrix5 & K ) const

private

internal structuring: common logfile output during calculation

Definition at line 1401 of file KalmanUpdatorSMatrix.cxx.

{
  // again some verbose debug output showing internals of updating
  msg(MSG::VERBOSE) << "-U- residual: r=("<<r(0);
  for (int i=1; i<nc; i++) msg(MSG::VERBOSE) <<","<<r(i);
  msg(MSG::VERBOSE) << ")\n";
  msg(MSG::VERBOSE) << "-U- inv. sigmaR=("<< R(0,0);
  for (int i=1; i<nc; i++) msg(MSG::VERBOSE) << "," << R(i,i);
  msg(MSG::VERBOSE) << ")\n";
  for (int i=0; i<nc; i++)
    msg(MSG::VERBOSE) // K is a row x col = 5 x nc matrix.
          << ( i==0 ? "-U- gain mtx  K=(" : "                (" )
          << std::setiosflags(std::ios::fixed | std::ios::showpoint | std::ios::right )
          << std::setw(7) << std::setprecision(4) << K(0,i)<<", "
          << std::setw(7) << std::setprecision(4) << K(1,i)<<", "
          << std::setw(7) << std::setprecision(4) << K(2,i)<<", "
          << std::setw(7) << std::setprecision(4) << K(3,i)<<", "
          << std::setw(7) << std::setprecision(4) << K(4,i)<<")"
          << std::resetiosflags(std::ios::fixed) << "\n";
}

logInputCov()

void Trk::KalmanUpdatorSMatrix::logInputCov ( const SCovMatrix5 & covTrk, const Amg::VectorX & parRio, const Amg::MatrixX & covRio ) const

private

internal structuring: common logfile output of the inputs

Definition at line 1375 of file KalmanUpdatorSMatrix.cxx.

{
  ATH_MSG_VERBOSE( "-U- cov    "<<std::setiosflags(std::ios::right)<<std::setprecision(3)
        << std::setw(9)<<covTrk(0,0)<<" "<< std::setw(9)<<covTrk(0,1)<<" "
        << std::setw(9)<<covTrk(0,2)<<" "<< std::setw(9)<<covTrk(0,3)<<" "
        << std::setw(9)<<covTrk(0,4));
  ATH_MSG_VERBOSE( "                                      " << "          " << "           "
        << std::setw(9)<<covTrk(1,1)<<" "<< std::setw(9)<<covTrk(1,2)<<" "
        << std::setw(9)<<covTrk(1,3)<<" "<< std::setw(9)<<covTrk(1,4));
  ATH_MSG_VERBOSE( "  covariance matrix                   " << "          " << "                     "
        << std::setw(9)<<covTrk(2,2)<<" "<< std::setw(9)<<covTrk(2,3)<<" "
        << std::setw(9)<<covTrk(2,4));
  ATH_MSG_VERBOSE( "  of the PREDICTED track pars         " << "          " << "                               "
        << std::setw(9)<<covTrk(3,3)<<" "<< std::setw(9)<<covTrk(3,4));
  ATH_MSG_VERBOSE("                                      " << "          " << "                                         "
        << std::setw(9)<<covTrk(4,4)<<std::setprecision(6));
 
  int nLocCoord = covRio.cols();
  ATH_MSG_VERBOSE( "-U- measurement locPar: ");
  for (int i=0; i<nLocCoord; i++) ATH_MSG_VERBOSE(parRio[i]);
  msg(MSG::VERBOSE) << "-U- measurement (err)^2: " <<std::setprecision(4)<<covRio(0,0);
  for (int i=1; i<nLocCoord; i++) msg(MSG::VERBOSE) << ", "<<covRio(i,i);
  msg(MSG::VERBOSE) << std::setprecision(6)<<"\n";
}

logResult()

void Trk::KalmanUpdatorSMatrix::logResult ( const std::string & , const AmgVector(5) & , const AmgSymMatrix(5) &  ) const

private

internal structuring: common logfile output after calculation

Definition at line 1424 of file KalmanUpdatorSMatrix.cxx.

{
    // again some verbose debug output
    msg(MSG::VERBOSE) << "-U- ==> result for KalmanUpdatorSMatrix::"<<methodName<<endmsg;
    msg(MSG::VERBOSE) << "-U- new par"<<std::setiosflags(std::ios::right)<<std::setprecision(4)
          << std::setw( 9)<<par[0]<< std::setw(10)<<par[1]<<std::setprecision(5)
          << std::setw(10)<<par[2]<< std::setw(10)<<par[3]<<std::setprecision(4)
          << std::setw(10)<<par[4]                <<"\n";
    msg(MSG::VERBOSE) << "-U- new cov" <<std::setiosflags(std::ios::right)<<std::setprecision(3)
          << std::setw(9)<<(covPar)(0,0)<<" "<< std::setw(9)<<(covPar)(0,1)<<" "
          << std::setw(9)<<(covPar)(0,2)<<" "<< std::setw(9)<<(covPar)(0,3)
          << " " << std::setw(9)<<(covPar)(0,4)<< "\n";
    msg(MSG::VERBOSE) << "                                      " << "           " << "          "
          << std::setw(9)<<(covPar)(1,1)<<" "<< std::setw(9)<<(covPar)(1,2)<<" "
          << std::setw(9)<<(covPar)(1,3)<<" "<< std::setw(9)<<(covPar)(1,4)<< "\n";
    msg(MSG::VERBOSE) << "  covariance matrix                   " << "           " << "                    "
          << std::setw(9)<<(covPar)(2,2) <<" "<< std::setw(9)<<(covPar)(2,3) <<" "
          << std::setw(9)<<(covPar)(2,4) << "\n";
    msg(MSG::VERBOSE) << "  of the UPDATED   track pars         " << "           "
          << "                              " <<std::setw(9)<<(covPar)(3,3) << " "
          << std::setw(9)<<(covPar)(3,4) << "\n";
    msg(MSG::VERBOSE) << "                                      " << "           "
          << "                                        "
          << std::setw(9)<<(covPar)(4,4) <<std::setprecision(6)<< "\n";
}

logStart()

void Trk::KalmanUpdatorSMatrix::logStart ( const std::string & IDstring, const TrackParameters & tp ) const

private

internal structuring: debugging output for start of method.

Definition at line 1365 of file KalmanUpdatorSMatrix.cxx.

{
  ATH_MSG_DEBUG( "--> entered KalmanUpdatorSMatrix::" << IDstring );
  ATH_MSG_VERBOSE( "-U- TrkPar:" << std::setiosflags(std::ios::right)<<std::setprecision(4)
        << std::setw( 9)<<tp.parameters()[0]<< std::setw(10)<<tp.parameters()[1]<<std::setprecision(5)
        << std::setw(10)<<tp.parameters()[2]<< std::setw(10)<<tp.parameters()[3]<<std::setprecision(4)
        << std::setw(10)<<tp.parameters()[4]);
}

makeChi2_1D()

Trk::FitQualityOnSurface Trk::KalmanUpdatorSMatrix::makeChi2_1D ( const SParVector5 & parTrk, const AmgSymMatrix(5)& covTrk, double valRio, double covRio, int key, int sign ) const

private

also the chi2 calculation and FitQuality object creation is combined in an extra method.

It is called by all the XXX-FitQuality() methods - SMatrix version for 1D, 2D, 5D and Eigen for 3D, 4D. The calculateFilterStep() have the code duplicated to avoid re-computing the residual-error matrix. The sign controls the calculation in case a predicted input track state (sign=+1) or smoothed/updated input track state (sign=-1).

Definition at line 1081 of file KalmanUpdatorSMatrix.cxx.

{   // sign: -1 = updated, +1 = predicted parameters.
  int mk=0;
  if (key!=1) for (int i=0; i<5; ++i) if (key & (1<<i)) mk=i;
  double r = valRio - parTrk(mk);
  //  if (mk==3) catchPiPi;
  double chiSquared = covRio + sign * covTrk(mk,mk);
  if (chiSquared == 0.0) {
    ATH_MSG_DEBUG( "inversion of the error-on-the-residual failed." );
    return {};
  }
    chiSquared = r*r/chiSquared;
 
  return {chiSquared, 1};
}

makeChi2_2D()

Trk::FitQualityOnSurface Trk::KalmanUpdatorSMatrix::makeChi2_2D ( const SParVector5 & parTrk, const AmgSymMatrix(5)& covTrk, const SParVector2 & parRio, const SCovMatrix2 & covRio, int key, int sign ) const

private

Definition at line 1103 of file KalmanUpdatorSMatrix.cxx.

{   // sign: -1 = updated, +1 = predicted parameters.
 
  ROOT::Math::SVector<int,2> index(0,1); // locX and Y if key==3
  if (key != 3) { // other localPar expansion vector if not key==3.
    for (int i=0, irow=0; i<5; ++i)
      if (key & (1<<i)) index(irow++) = i;
  }
  SParVector2 r(-parTrk(index(0)),-parTrk(index(1))); r += parRio;
  SCovMatrix2 R = sign*projection_2D(covTrk,key);     R += covRio;
  double chiSquared = 0.0;
  if (!R.Invert()) {
    ATH_MSG_DEBUG( "matrix inversion not possible, set chi2 to zero" );
  } else {
    chiSquared = ROOT::Math::Similarity(r,R);
    ATH_MSG_VERBOSE( "-U- fitQuality of "<< (sign>0?"predicted":"updated")
            <<" state, chi2 :" << chiSquared << " / ndof= 2" );
  }
  return {chiSquared, 2};
}

makeChi2_5D()

Trk::FitQualityOnSurface Trk::KalmanUpdatorSMatrix::makeChi2_5D ( const SParVector5 & parOne, const AmgSymMatrix(5)& covOne, const SParVector5 & parTwo, const AmgSymMatrix(5)& covTwo, int sign ) const

private

Definition at line 1130 of file KalmanUpdatorSMatrix.cxx.

{   // sign: -1 = updated, +1 = predicted parameters.
 
  SCovMatrix5 ScovOne;
  SCovMatrix5 ScovTwo; // trafo EDM to new math lib
  for (int i=0; i<5; ++i)
    for (int j=0; j<=i; ++j) {
      ScovOne(i,j) = covOne(i,j);
      ScovTwo(i,j) = covTwo(i,j);
    }
  SParVector5 r = parTwo - parOne;
  SCovMatrix5 R = sign*ScovOne + ScovTwo;
  double chiSquared = 0.0;
  if (!R.Invert()) {
    ATH_MSG_DEBUG( "matrix inversion not possible, set chi2 to zero" );
  } else {
    chiSquared = ROOT::Math::Similarity(r,R);
    ATH_MSG_VERBOSE( "-U- fitQuality of "<< (sign>0?"predicted":"updated")
            <<" state, chi2 :" << chiSquared << " / ndof= 2" );
  }
  return {chiSquared, 5};
}

makeChi2Object()

Trk::FitQualityOnSurface Trk::KalmanUpdatorSMatrix::makeChi2Object ( const Amg::VectorX & residual, const AmgSymMatrix(5)& covTrk, const Amg::MatrixX & covRio, const Amg::MatrixX & H, int sign ) const

private

< TODO check on inverse failure ?

Definition at line 1286 of file KalmanUpdatorSMatrix.cxx.

{   // sign: -1 = updated, +1 = predicted parameters.
    Amg::MatrixX R = covRio + sign * covTrk.similarity(H);
    double chiSquared = 0.;
    if (false) { 
        ATH_MSG_DEBUG( "matrix inversion not possible, set chi2 to zero" );
        chiSquared = 0.f;
    } else {
      // get chi2 = r.T() * R^-1 * r
      chiSquared = Amg::chi2(R.inverse(), residual);
      ATH_MSG_VERBOSE( "-U- fitQuality of "<< (sign>0?"predicted":"updated")
              <<" state, chi2 :" << chiSquared << " / ndof= " << covRio.cols() );
    }
 
    // number of degree of freedom added
    int     numberDoF  = covRio.cols();
 
   return {chiSquared, numberDoF};
}

msg()

MsgStream & AthCommonMsg< AlgTool >::msg ( ) const

inlineinherited

Definition at line 24 of file AthCommonMsg.h.

                                {
    return this->msgStream();
  }

msgLvl()

bool AthCommonMsg< AlgTool >::msgLvl ( const MSG::Level lvl ) const

inlineinherited

Definition at line 30 of file AthCommonMsg.h.

                                               {
    return this->msgLevel(lvl);
  }

outputHandles()

virtual std::vector< Gaudi::DataHandle * > AthCommonDataStore< AthCommonMsg< AlgTool > >::outputHandles ( ) const

overridevirtualinherited

Return this algorithm's output handles.

We override this to include handle instances from key arrays if they have not yet been declared. See comments on updateVHKA.

predictedStateFitQuality() [1/3]

Trk::FitQualityOnSurface Trk::KalmanUpdatorSMatrix::predictedStateFitQuality ( const TrackParameters & predPar, const Amg::Vector2D & rioLocPos, const Amg::MatrixX & covRio ) const

finaloverridevirtual

estimator for FitQuality on Surface from a predicted track state, that is a state which contains the current hit (expressed as Amg::Vector2D).

Implements Trk::IUpdator.

Definition at line 427 of file KalmanUpdatorSMatrix.cxx.

                                                                                     {
  ATH_MSG_VERBOSE( "--> entered KalmanUpdatorSMatrix::predictedStateFitQuality(TP,LPOS,ERR)" );
    // try if Track Parameters are measured ones ?
    if (!predPar.covariance()) {
        ATH_MSG_WARNING( "input state has no error matrix in predictedStateFitQuality()" );
      return {};
    }
    // For the LocalPos. version, need to get # meas. coord. from covariance matrix.
    int nLocCoord = covRio.cols();
    if (nLocCoord == 1) {
      return makeChi2_1D(SParVector5(&predPar.parameters()[0],5),
                         (*predPar.covariance()),
                         rioLocPos[Trk::locX],covRio(0,0),
                         1,+1); // key=1, signForUpdatedChi2 = +1
    } if (nLocCoord == 2) {
      SCovMatrix2 SmeasCov;
      SmeasCov(0,0) = covRio(0,0);
      SmeasCov(1,0) = covRio(1,0);
      SmeasCov(1,1) = covRio(1,1);
      return makeChi2_2D(SParVector5(&predPar.parameters()[0],5),
                         (*predPar.covariance()),
                         SParVector2(rioLocPos[Trk::locX],rioLocPos[Trk::locY]),
                         SmeasCov, 2,+1);
    }
      ATH_MSG_WARNING( "Error in local position - must be 1D or 2D!" );
      return {};
 
}

predictedStateFitQuality() [2/3]

Trk::FitQualityOnSurface Trk::KalmanUpdatorSMatrix::predictedStateFitQuality ( const TrackParameters & predPar, const LocalParameters & parRio, const Amg::MatrixX & covRio ) const

finaloverridevirtual

estimator for FitQuality on Surface from a predicted track state, that is a state which contains the current hit (expressed as LocalParameters).

Implements Trk::IUpdator.

Definition at line 460 of file KalmanUpdatorSMatrix.cxx.

                                                                                     {
  ATH_MSG_VERBOSE( "--> entered KalmanUpdatorSMatrix::predictedStateFitQuality(TP,LPAR,ERR)" );
 
    // try if Track Parameters are measured ones ?
    if (!predPar.covariance()) {
        ATH_MSG_WARNING( "input state has no error matrix in predictedStateFitQuality()" );
      return {};
    }
    int nLocCoord = parRio.dimension();
    if ( ! consistentParamDimensions(parRio,covRio.cols()) ) return {};
 
    ROOT::Math::SVector<int,5>  intAccessor;
    for (int i=0,k=0; i<5; ++i) { if (parRio.parameterKey() & (1<<i)) intAccessor(k++)=i; }
    if (nLocCoord == 1) {
      return makeChi2_1D(SParVector5(&predPar.parameters()[0],5),
                         (*predPar.covariance()),
                         parRio[Trk::ParamDefsAccessor::pardef[intAccessor(0)]],covRio(0,0),
                         parRio.parameterKey(),+1);
    } if (nLocCoord == 2) {
      SCovMatrix2 SmeasCov;
      for (int i=0, irow=0; i<5; ++i) {
        if (parRio.parameterKey() & (1<<i)) {
          SmeasCov(0,irow) = covRio(0,irow);
          SmeasCov(1,irow) = covRio(1,irow);
          ++irow;
        }
      }
      return makeChi2_2D(SParVector5(&predPar.parameters()[0],5),
                         (*predPar.covariance()),
                         SParVector2(parRio[Trk::ParamDefsAccessor::pardef[intAccessor(0)]],
                                     parRio[Trk::ParamDefsAccessor::pardef[intAccessor(1)]]),
                         SmeasCov, parRio.parameterKey(),+1);
    } if (nLocCoord == 5 ) {
      return makeChi2_5D(SParVector5(&predPar.parameters()[0],5),
                         (*predPar.covariance()),
                         SParVector5(parRio[Trk::locX],parRio[Trk::locY],
                                     parRio[Trk::phi0],parRio[Trk::theta],
                                     parRio[Trk::qOverP]),
                         covRio,+1);
    } // stay with CLHEP for other cases
 
      // State to measurement dimensional reduction Matrix ( n x m )
      const Amg::MatrixX& H = parRio.expansionMatrix();
 
      // residuals
      Amg::VectorX r;
      if (parRio.parameterKey()==31) r = parRio - predPar.parameters();
      else r = parRio - H * predPar.parameters();
 
      // all the rest is outsourced to a common chi2 routine
      return makeChi2Object(r,(*predPar.covariance()),
                            covRio,H,+1);
 
}

predictedStateFitQuality() [3/3]

Trk::FitQualityOnSurface Trk::KalmanUpdatorSMatrix::predictedStateFitQuality ( const TrackParameters & trkParOne, const TrackParameters & trkParTwo ) const

finaloverridevirtual

estimator for FitQuality on Surface for the situation when a track is fitted to the parameters of another trajectory part extrapolated to the common surface.

Implements Trk::IUpdator.

Definition at line 519 of file KalmanUpdatorSMatrix.cxx.

                                                                                                {
  ATH_MSG_VERBOSE("--> entered KalmanUpdatorSMatrix::predictedStateFitQuality(TP,TP)");
    // try if both Track Parameters are measured ones ?
  const AmgSymMatrix(5)* covOne = trkParOne.covariance();
    const AmgSymMatrix(5)* covTwo = trkParTwo.covariance();
  // remember, either one OR two might have no error, but not both !
    if (!covOne && ! covTwo) {
        ATH_MSG_WARNING( "both parameters have no errors, invalid use of Updator::fitQuality()" );
        return {};
    }
    // if only one of two has an error, place a message.
    if (!covOne || ! covTwo) {
        ATH_MSG_DEBUG( "One parameter does not have uncertainties, assume initial state and return chi2=0.0");
        return {0.f, 5};
    }
    return makeChi2_5D(SParVector5(&trkParOne.parameters()[0],5),
                       *covOne,
                       SParVector5(&trkParTwo.parameters()[0],5),
                       *covTwo, +1);
}

prepareFilterStep()

std::unique_ptr< Trk::TrackParameters > Trk::KalmanUpdatorSMatrix::prepareFilterStep ( const TrackParameters & inputTrkPar, const LocalParameters & parRio, const Amg::MatrixX & covRio, const int sign, Trk::FitQualityOnSurface *& fitQoS, bool createFQoS ) const

private

common code analysing the measurement's rank and calling the appropriate implementation for this rank.

Definition at line 548 of file KalmanUpdatorSMatrix.cxx.

                                                                                            {
 
    // try if Track Parameters are measured ones ?
    SCovMatrix5 covTrk;
    if (!getStartCov(covTrk,inputTrkPar,sign)) return nullptr;
 
    int nLocCoord = covRio.cols();
    if ( ! consistentParamDimensions(parRio,nLocCoord) ) return nullptr;
    if (msgLvl(MSG::VERBOSE)) logInputCov(covTrk,parRio,covRio);
 
    // local params can NOT be accessed like vector[i], therefore need some acrobatics:
    ROOT::Math::SVector<int,5>  intAccessor;
    for (int i=0,k=0; i<5; ++i) { if (parRio.parameterKey() & (1<<i)) intAccessor(k++)=i; }
 
    if (nLocCoord==1) return calculateFilterStep_1D (inputTrkPar,SParVector5(&inputTrkPar.parameters()[0],5),covTrk,
                                                     parRio[Trk::ParamDefsAccessor::pardef[intAccessor(0)]],
                                                     parRio.parameterKey(),covRio,
                                                     sign,fitQoS,createFQoS);
    if (nLocCoord==2) return calculateFilterStep_2D (inputTrkPar,SParVector5(&inputTrkPar.parameters()[0],5),covTrk,
                                                     SParVector2(parRio[Trk::ParamDefsAccessor::pardef[intAccessor(0)]],parRio[Trk::ParamDefsAccessor::pardef[intAccessor(1)]]),
                                                     parRio.parameterKey(),covRio,
                                                     sign,fitQoS,createFQoS);
 
    if (nLocCoord==3) return calculateFilterStep_3D (inputTrkPar,SParVector5(&inputTrkPar.parameters()[0],5),covTrk,
                                                     parRio,covRio,
                                                     sign,fitQoS,createFQoS);
    if (nLocCoord==4) return calculateFilterStep_4D (inputTrkPar,SParVector5(&inputTrkPar.parameters()[0],5),covTrk,
                                                     parRio,covRio,
                                                     sign,fitQoS,createFQoS);
    if (nLocCoord==5) return calculateFilterStep_5D (inputTrkPar,SParVector5(&inputTrkPar.parameters()[0],5),covTrk,
                                                     SParVector5(&(parRio[Trk::loc1]),5),covRio,
                                                     sign,fitQoS,createFQoS);
    return nullptr;
}

projection_2D() [1/2]

SCovMatrix2 Trk::KalmanUpdatorSMatrix::projection_2D ( const Amg::MatrixX & M, int key )

staticprivate

Avoid multiplications with sparse H matrices by cutting 2D rows&columns out of the full cov matrix.

Definition at line 1211 of file KalmanUpdatorSMatrix.cxx.

{
    ROOT::Math::SVector<int,2>  iv;
    for (int i=0,k=0; i<5; ++i) { if (key & (1<<i)) iv(k++)=i; }
    SCovMatrix2 covSubMatrix;
    for (int i=0; i<2; ++i) {
      for (int j=0; j<2; ++j) {
        covSubMatrix(i,j) = M(iv(i),iv(j));
      }
    }
    return covSubMatrix;
}

projection_2D() [2/2]

SCovMatrix2 Trk::KalmanUpdatorSMatrix::projection_2D ( const SCovMatrix5 & M, int key )

staticprivate

Avoid multiplications with sparse H matrices by cutting 2D rows&columns out of the full cov matrix.

Definition at line 1193 of file KalmanUpdatorSMatrix.cxx.

{
  if (key == 3) { // shortcut the most-used case
    SCovMatrix2 S = M.Sub<SCovMatrix2> (0,0);
    return S;
  }
    ROOT::Math::SVector<int,2>  iv;
    for (int i=0,k=0; i<5; ++i) { if (key & (1<<i)) iv(k++)=i; }
    SCovMatrix2 covSubMatrix;
    for (int i=0; i<2; ++i) {
      for (int j=0; j<2; ++j) {
        covSubMatrix(i,j) = M(iv(i),iv(j));
      }
    }
    return covSubMatrix;
 
}

projection_3D()

SCovMatrix3 Trk::KalmanUpdatorSMatrix::projection_3D ( const SCovMatrix5 & M, int key )

staticprivate

Avoid multiplications with sparse H matrices by cutting 3D rows&columns out of the full cov matrix.

Definition at line 1225 of file KalmanUpdatorSMatrix.cxx.

{
  if (key == 7) { // shortcut the most-used case
    return M.Sub<SCovMatrix3> (0,0);
  }
    ROOT::Math::SVector<int,3>  iv;
    for (int i=0,k=0; i<5; ++i) { if (key & (1<<i)) iv(k++)=i; }
    SCovMatrix3 covSubMatrix;
    for (int i=0; i<3; ++i) {
      for (int j=0; j<3; ++j) {
        covSubMatrix(i,j) = M(iv(i),iv(j));
      }
    }
    return covSubMatrix;
 
}

projection_4D()

SCovMatrix4 Trk::KalmanUpdatorSMatrix::projection_4D ( const SCovMatrix5 & M, int key )

staticprivate

Avoid multiplications with sparse H matrices by cutting 4D rows&columns out of the full cov matrix.

Definition at line 1242 of file KalmanUpdatorSMatrix.cxx.

{
  if (key == 15) { // shortcut the most-used case
    return M.Sub<SCovMatrix4> (0,0);
  }
    ROOT::Math::SVector<int,4> iv;
    for (int i=0,k=0; i<5; ++i) { if (key & (1<<i)) iv(k++)=i; }
    SCovMatrix4 covSubMatrix;
    for (int i=0; i<4; ++i) {
      for (int j=0; j<4; ++j) {
        covSubMatrix(i,j) = M(iv(i),iv(j));
      }
    }
    return covSubMatrix;
 
}

removeFromState() [1/4]

std::unique_ptr< Trk::TrackParameters > Trk::KalmanUpdatorSMatrix::removeFromState ( const TrackParameters & inputTP, const Amg::Vector2D & measLocPos, const Amg::MatrixX & measLocCov ) const

finaloverridevirtual

reverse update eg for track property analysis (unbiased residuals) getting the measurement coordinates from the Amg::Vector2D class.

Implements Trk::IUpdator.

Definition at line 164 of file KalmanUpdatorSMatrix.cxx.

                                                                                                      {
    if (msgLvl(MSG::VERBOSE)) logStart("removeFromState(TP,LPOS,ERR)",inputTP);
    FitQualityOnSurface*    fitQoS = nullptr;
    const int updatingSign = -1;
    SCovMatrix5 covTrk;
    if (!getStartCov(covTrk,inputTP,updatingSign)) return nullptr;
 
    int nLocCoord = measLocCov.cols();
    if (nLocCoord == 1) {
      return calculateFilterStep_1D (inputTP,
                                     SParVector5(&inputTP.parameters()[0],5),covTrk,
                                     measLocPos[0],1,measLocCov,
                                     updatingSign,fitQoS,false);
    } if (nLocCoord == 2) {
      return calculateFilterStep_2D (inputTP,
                                     SParVector5(&inputTP.parameters()[0],5),covTrk,
                                     SParVector2(measLocPos[0],measLocPos[1]),3,
                                     measLocCov,
                                     updatingSign,fitQoS,false);
    }
      ATH_MSG_WARNING( " number (" << nLocCoord << ") of local coordinates "
            << "must be 1 or 2, can not un-update!" );
      return nullptr;
 
}

removeFromState() [2/4]

std::unique_ptr< Trk::TrackParameters > Trk::KalmanUpdatorSMatrix::removeFromState ( const TrackParameters & inputTP, const Amg::Vector2D & measLocPos, const Amg::MatrixX & measLocCov, FitQualityOnSurface *& fitQoS ) const

finaloverridevirtual

reverse update for Kalman filters and other applications using the interface with Amg::Vector2D and FitQualityOnSurface.

Implements Trk::IUpdator.

Definition at line 202 of file KalmanUpdatorSMatrix.cxx.

                                                                                                      {
    const int updatingSign = -1;
    if (msgLvl(MSG::VERBOSE)) logStart("removeFromState(TP,LPOS,ERR,FQ)",inputTP);
    if (fitQoS) {
      msg(MSG::WARNING) << "expect nil FitQuality pointer, refuse operation to"
            << " avoid mem leak!" << endmsg;
      return nullptr;
    }
      SCovMatrix5 covTrk;
 
      if (!getStartCov(covTrk,inputTP,updatingSign)) return nullptr;
 
      int nLocCoord = measLocCov.cols();
      if (nLocCoord == 1) {
        return calculateFilterStep_1D (inputTP,
                                       SParVector5(&inputTP.parameters()[0],5),covTrk,
                                       measLocPos[0],1,measLocCov,
                                       updatingSign,fitQoS,true);
      } if (nLocCoord == 2) {
        return calculateFilterStep_2D (inputTP,
                                       SParVector5(&inputTP.parameters()[0],5),covTrk,
                                       SParVector2(measLocPos[0],measLocPos[1]),3,
                                       measLocCov,
                                       updatingSign,fitQoS,true);
      }
        ATH_MSG_WARNING( " number (" << nLocCoord << ") of local coordinates"
              << " must be 1 or 2, can not un-update!" );
        return nullptr;
 
 
}

removeFromState() [3/4]

std::unique_ptr< Trk::TrackParameters > Trk::KalmanUpdatorSMatrix::removeFromState ( const TrackParameters & trkPar, const LocalParameters & measmtPar, const Amg::MatrixX & measmtCov ) const

finaloverridevirtual

reverse update eg for track property analysis (unbiased residuals) getting the measurement coordinates from the LocalParameters class.

Implements Trk::IUpdator.

Definition at line 193 of file KalmanUpdatorSMatrix.cxx.

                                                                                                     {
    if (msgLvl(MSG::DEBUG)) logStart("removeFromState(TP,LPAR,ERR)",trkPar);
    FitQualityOnSurface*    fitQoS = nullptr;
    return prepareFilterStep (trkPar, measmtPar, measmtCov,-1,fitQoS, false);
}

removeFromState() [4/4]

std::unique_ptr< Trk::TrackParameters > Trk::KalmanUpdatorSMatrix::removeFromState ( const TrackParameters & trkPar, const LocalParameters & measmtPar, const Amg::MatrixX & measmtCov, FitQualityOnSurface *& fitQoS ) const

finaloverridevirtual

reverse update for Kalman filters and other applications using the interface with LocalParameters and FitQualityOnSurface.

Implements Trk::IUpdator.

Definition at line 238 of file KalmanUpdatorSMatrix.cxx.

                                                                                                      {
    if (msgLvl(MSG::VERBOSE)) logStart("removeFromState(TP,LPAR,ERR,FQ)",trkPar);
    if (fitQoS) {
        ATH_MSG_WARNING( "expect nil FitQuality pointer, refuse operation to avoid mem leak!" );
        return nullptr;
    }
        return prepareFilterStep (trkPar, measmtPar, measmtCov, -1, fitQoS, true);
 
}

renounce()

std::enable_if_t< std::is_void_v< std::result_of_t< decltype(&T::renounce)(T)> > &&!std::is_base_of_v< SG::VarHandleKeyArray, T > &&std::is_base_of_v< Gaudi::DataHandle, T >, void > AthCommonDataStore< AthCommonMsg< AlgTool > >::renounce ( T & h )

inlineprotectedinherited

Definition at line 380 of file AthCommonDataStore.h.

  {
    h.renounce();
    PBASE::renounce (h);
  }

renounceArray()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::renounceArray ( SG::VarHandleKeyArray & handlesArray )

inlineprotectedinherited

remove all handles from I/O resolution

Definition at line 364 of file AthCommonDataStore.h.

                                                          {
    handlesArray.renounce();
  }

sysInitialize()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysInitialize ( )

overridevirtualinherited

Perform system initialization for an algorithm.

We override this to declare all the elements of handle key arrays at the end of initialization. See comments on updateVHKA.

Reimplemented in asg::AsgMetadataTool, AthCheckedComponent< AthAlgTool >, AthCheckedComponent<::AthAlgTool >, and DerivationFramework::CfAthAlgTool.

sysStart()

virtual StatusCode AthCommonDataStore< AthCommonMsg< AlgTool > >::sysStart ( )

overridevirtualinherited

Handle START transition.

We override this in order to make sure that conditions handle keys can cache a pointer to the conditions container.

thetaPhiWithinRange_5D()

bool Trk::KalmanUpdatorSMatrix::thetaPhiWithinRange_5D ( const SParVector5 & V, const RangeCheckDef rcd ) const

inlineprivate

Test if angles are inside boundaries.

Absolute phi values should be in [-pi, pi] (how about endpoints?) absolute theta values should be in [0, +pi] phi differences should also be in [-pi, pi] - else go other way round, theta differences should be smaller than pi but can be negative => other constraint than absolute theta.

Definition at line 389 of file KalmanUpdatorSMatrix.h.

{
  static const SParVector2 thetaMin(0.0, -M_PI);
  return ((std::abs(V(Trk::phi)) <= M_PI) &&
          (V(Trk::theta) >= thetaMin((int)rcd)) && (V(Trk::theta) <= M_PI));
}

thetaWithinRange_5D()

bool Trk::KalmanUpdatorSMatrix::thetaWithinRange_5D ( const SParVector5 & V ) const

inlineprivate

Test if theta angle is inside boundaries. No differential-check option.

Definition at line 398 of file KalmanUpdatorSMatrix.h.

{
  return (V(Trk::theta) >= 0.0 && (V(Trk::theta) <= M_PI));
}

updateParameterDifference()

virtual std::pair< AmgVector(5), AmgSymMatrix(5)> * Trk::KalmanUpdatorSMatrix::updateParameterDifference ( const AmgVector(5) & , const AmgSymMatrix(5) & , const Amg::VectorX & , const Amg::MatrixX & , int , Trk::FitQualityOnSurface *& , bool  ) const

inlinefinaloverridevirtual

interface for reference-track KF, not implemented

Implements Trk::IUpdator.

Definition at line 198 of file KalmanUpdatorSMatrix.h.

  {
    return nullptr;
  }

updateVHKA()

void AthCommonDataStore< AthCommonMsg< AlgTool > >::updateVHKA ( Gaudi::Details::PropertyBase & )

inlineinherited

Definition at line 308 of file AthCommonDataStore.h.

                                               {
    // debug() << "updateVHKA for property " << p.name() << " " << p.toString() 
    //         << "  size: " << m_vhka.size() << endmsg;
    for (auto &a : m_vhka) {
      std::vector<SG::VarHandleKey*> keys = a->keys();
      for (auto k : keys) {
        k->setOwner(this);
      }
    }
  }

Member Data Documentation

m_cov0

SParVector5 Trk::KalmanUpdatorSMatrix::m_cov0

private

initial cov values in SMatrix object

Definition at line 380 of file KalmanUpdatorSMatrix.h.

m_cov_stdvec

std::vector<double> Trk::KalmanUpdatorSMatrix::m_cov_stdvec

private

job options for initial cov values

Definition at line 379 of file KalmanUpdatorSMatrix.h.

m_detStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_detStore

privateinherited

Pointer to StoreGate (detector store by default)

Definition at line 393 of file AthCommonDataStore.h.

m_evtStore

StoreGateSvc_t AthCommonDataStore< AthCommonMsg< AlgTool > >::m_evtStore

privateinherited

Pointer to StoreGate (event store by default)

Definition at line 390 of file AthCommonDataStore.h.

m_thetaGainDampingValue

float Trk::KalmanUpdatorSMatrix::m_thetaGainDampingValue

private

Definition at line 383 of file KalmanUpdatorSMatrix.h.

m_unitMatrix

SCovMatrix5 Trk::KalmanUpdatorSMatrix::m_unitMatrix

private

avoid mem allocation at every call

Definition at line 385 of file KalmanUpdatorSMatrix.h.

m_useFruehwirth8a

bool Trk::KalmanUpdatorSMatrix::m_useFruehwirth8a

private

job options controlling update formula for covariance matrix

Definition at line 381 of file KalmanUpdatorSMatrix.h.

m_varHandleArraysDeclared

bool AthCommonDataStore< AthCommonMsg< AlgTool > >::m_varHandleArraysDeclared

privateinherited

Definition at line 399 of file AthCommonDataStore.h.

m_vhka

std::vector<SG::VarHandleKeyArray*> AthCommonDataStore< AthCommonMsg< AlgTool > >::m_vhka

privateinherited

Definition at line 398 of file AthCommonDataStore.h.

s_enumAccessor

const Trk::ParamDefsAccessor Trk::KalmanUpdatorSMatrix::s_enumAccessor

staticprivate

Definition at line 386 of file KalmanUpdatorSMatrix.h.

---

The documentation for this class was generated from the following files:

• KalmanUpdatorSMatrix.h
• KalmanUpdatorSMatrix.cxx