trkf Namespace Reference

Classes
class	CCTrackMaker
class	CosmicTracker
class	CosmicTrackerAlg
class	FeatureTracker
class	Geometric3DVertexFitter
	3D vertex fitter based on the geometric properties (start position, direction, covariance) of the tracks. More...
class	HitState
	Class for a measurement on a recob::tracking::Plane (plane defined by a wire and the drift direction). More...
class	InteractGeneral
class	Interactor
class	InteractPlane
class	KalmanFilterAlg
class	KalmanFilterFinalTrackFitter
class	KalmanFilterTrajectoryFitter
struct	KalmanInput
struct	KalmanOutput
class	KETrack
class	KFitTrack
class	KFTrackState
	Extension of a TrackState to perform KalmanFilter calculations. More...
struct	KGMatrix
	Kalman gain matrix, dimension 5xN. More...
class	KGTrack
class	KHit
class	KHitBase
class	KHitContainer
class	KHitContainerWireLine
class	KHitContainerWireX
class	KHitGroup
class	KHitMulti
class	KHitsTrack
class	KHitTrack
class	KHitWireLine
class	KHitWireX
struct	KHMatrix
	Kalman H-matrix, dimension Nx5. More...
struct	KMatrix
	General matrix, dimension NxM. More...
struct	KSymMatrix
	Symmetric matrix, dimension NxN. More...
class	KTrack
struct	KVector
	Define a shortened alias for ublas namespace. More...
class	LinFitAlg
class	MCSFitProducer
	Producer for TrajectoryMCSFitter. More...
class	PMAlgTrackMaker
class	PMAlgTrajFitter
class	Propagator
class	PropAny
class	PropXYZPlane
class	PropYZLine
class	PropYZPlane
class	SeedAna
class	SeedFinderAlgorithm
class	SeedFinderModule
struct	SortByWire
class	SpacePointAlg
class	SpacePointAna
class	SpacePointCheater
class	SpacePointFinder
class	SpacePts
class	StitchAlg
class	Surface
class	SurfLine
class	SurfPlane
class	SurfWireLine
class	SurfWireX
class	SurfXYZPlane
class	SurfYZLine
class	SurfYZPlane
class	TCTrack
class	Track3DKalman
class	Track3DKalmanHit
class	Track3DKalmanHitAlg
class	Track3DKalmanSPS
class	Track3Dreco
class	TrackAna
class	TrackAnaCT
class	TrackCheater
class	TrackKalmanCheater
class	TrackKalmanFitter
	Fit tracks using Kalman Filter fit+smooth. More...
class	TrackLineFitAlg
class	TrackMomentumCalculator
class	TrackState
	Class for track parameters (and errors) defined on a recob::tracking::Plane. More...
class	TrackStatePropagator
	Class for propagation of a trkf::TrackState to a recob::tracking::Plane. More...
class	TrackStitcher
class	TrackTrajectoryAlg
class	TrajectoryMCSFitter
	Class for Maximum Likelihood fit of Multiple Coulomb Scattering angles between segments within a Track or Trajectory. More...
class	VertexFitAlg
class	VertexFitter
	Module for fitting a vertex using the Geometric3DVertexFitter. More...
class	VertexWrapper
	Wrapper class to facilitate vertex production. More...

Typedefs
typedef KVector< 5 >::type	TrackVector
	Track state vector, dimension 5. More...
typedef KSymMatrix< 5 >::type	TrackError
	Track error matrix, dimension 5x5. More...
typedef KMatrix< 5, 5 >::type	TrackMatrix
	General 5x5 matrix. More...
using	SVector5 = recob::tracking::SVector5
using	SVector6 = recob::tracking::SVector6
using	SMatrix55 = recob::tracking::SMatrix55
using	SMatrixSym55 = recob::tracking::SMatrixSym55
using	SMatrixSym66 = recob::tracking::SMatrixSym66
using	Plane = recob::tracking::Plane
using	Point_t = recob::tracking::Point_t
using	Vector_t = recob::tracking::Vector_t
using	PropDirection = TrackStatePropagator::PropDirection
using	SMatrixSym22 = recob::tracking::SMatrixSym22
using	SVector2 = recob::tracking::SVector2
using	SMatrixSym33 = recob::tracking::SMatrixSym33
using	SVector3 = recob::tracking::SVector3
typedef std::vector< KalmanInput >	KalmanInputs
typedef art::PtrVector< recob::Hit >	Hits
typedef std::vector< std::reference_wrapper< const recob::Track > >	TrackRefVec

Functions
template<class T , class TRI , class L , class A >
bool	syminvert (ublas::symmetric_matrix< T, TRI, L, A > &m)
template<class T , class L , class A >
bool	invert (ublas::matrix< T, L, A > &m)
template<class M >
M::value_type	trace (const M &m)
std::ostream &	operator<< (std::ostream &out, const KGTrack &trg)
	Output operator. More...
std::ostream &	operator<< (std::ostream &out, const KHitBase &trk)
	Output operator. More...
void	fill (const art::PtrVector< recob::Hit > &hits, int only_plane)
std::ostream &	operator<< (std::ostream &out, const KTrack &trk)
	Output operator. More...
std::ostream &	operator<< (std::ostream &out, const Surface &surf)
	Output operator. More...

Detailed Description

LinFitAlg class

Bruce Baller, balle.nosp@m.r@fn.nosp@m.al.go.nosp@m.v

Algorithm for fitting a 2D line

TrackLineFitAlg class

Bruce Baller, balle.nosp@m.r@fn.nosp@m.al.go.nosp@m.v

Algorithm for fitting a 3D line given a number of points in 3 wire planes

TrackTrajectoryAlg class

Bruce Baller, balle.nosp@m.r@fn.nosp@m.al.go.nosp@m.v

Algorithm fitting a 3D trajectory through a set of hits

VertexFitAlg class

Bruce Baller, balle.nosp@m.r@fn.nosp@m.al.go.nosp@m.v

Algorithm for fitting a 3D vertex given a set of track hits

Typedef Documentation

typedef art::PtrVector<recob::Hit> trkf::Hits

Definition at line 42 of file Track3DKalmanHit.h.

typedef std::vector<KalmanInput> trkf::KalmanInputs

Definition at line 41 of file Track3DKalmanHit.h.

using trkf::Plane = typedef recob::tracking::Plane

Definition at line 17 of file TrackState.h.

using trkf::Point_t = typedef recob::tracking::Point_t

Definition at line 18 of file TrackState.h.

using trkf::PropDirection = typedef TrackStatePropagator::PropDirection

Definition at line 27 of file TrackStatePropagator.cxx.

using trkf::SMatrix55 = typedef recob::tracking::SMatrix55

Definition at line 14 of file TrackState.h.

using trkf::SMatrixSym22 = typedef recob::tracking::SMatrixSym22

Definition at line 21 of file Geometric3DVertexFitter.h.

using trkf::SMatrixSym33 = typedef recob::tracking::SMatrixSym33

Definition at line 23 of file Geometric3DVertexFitter.h.

using trkf::SMatrixSym55 = typedef recob::tracking::SMatrixSym55

Definition at line 15 of file TrackState.h.

using trkf::SMatrixSym66 = typedef recob::tracking::SMatrixSym66

Definition at line 16 of file TrackState.h.

using trkf::SVector2 = typedef recob::tracking::SVector2

Definition at line 22 of file Geometric3DVertexFitter.h.

using trkf::SVector3 = typedef recob::tracking::SVector3

Definition at line 24 of file Geometric3DVertexFitter.h.

using trkf::SVector5 = typedef recob::tracking::SVector5

Definition at line 12 of file TrackState.h.

using trkf::SVector6 = typedef recob::tracking::SVector6

Definition at line 13 of file TrackState.h.

typedef KSymMatrix<5>::type trkf::TrackError

Track error matrix, dimension 5x5.

Definition at line 93 of file KalmanLinearAlgebra.h.

typedef KMatrix<5,5>::type trkf::TrackMatrix

General 5x5 matrix.

Definition at line 96 of file KalmanLinearAlgebra.h.

typedef std::vector<std::reference_wrapper<const recob::Track> > trkf::TrackRefVec

Definition at line 26 of file VertexWrapper.h.

typedef KVector<5>::type trkf::TrackVector

Track state vector, dimension 5.

Definition at line 90 of file KalmanLinearAlgebra.h.

using trkf::Vector_t = typedef recob::tracking::Vector_t

Definition at line 19 of file TrackState.h.

Function Documentation

void trkf::fill	(	const art::PtrVector< recob::Hit > &	hits,
		int	only_plane
	)

Definition at line 18 of file KHitContainer.cxx.

  {}

template<class T , class L , class A >

bool trkf::invert

(

ublas::matrix< T, L, A > &

m

)

Invert general square matrix by LU decomposition with partial pivoting. Return false if singular or not square.

Definition at line 193 of file KalmanLinearAlgebra.h.

  {
    // Make sure matrix is square.

    if(m.size1() != m.size2())
      return false;

    // Create permutation matrix for pivoting.

    ublas::permutation_matrix<std::size_t> pm(m.size1());

    // Make temp copy of input matrix.

    ublas::matrix<T, L, A> mcopy(m);

    // Do LU factorization with partial pivoting.
    // This step will fail if matrix is singular.

    int res = lu_factorize(mcopy, pm);
    if( res != 0 )
      return false;

    // Set original matrix to the identity matrix.

    m.assign(ublas::identity_matrix<T>(m.size1()));

    // Do backsubstitution.

    lu_substitute(mcopy, pm, m);

    // Done (success).

    return true;
  }

std::ostream & trkf::operator<<	(	std::ostream &	out,
		const Surface &	surf
	)

Output operator.

Definition at line 24 of file Surface.cxx.

  {
    return surf.Print(out);
  }

std::ostream & trkf::operator<<	(	std::ostream &	out,
		const KHitBase &	trk
	)

Output operator.

Definition at line 46 of file KHitBase.cxx.

  {
    return trk.Print(out);
  }

std::ostream & trkf::operator<<	(	std::ostream &	out,
		const KTrack &	trk
	)

Output operator.

Definition at line 263 of file KTrack.cxx.

  {
    return trk.Print(out);
  }

std::ostream & trkf::operator<<	(	std::ostream &	out,
		const KGTrack &	trg
	)

Output operator.

Definition at line 309 of file KGTrack.cxx.

  {
    return trg.Print(out);
  }

template<class T , class TRI , class L , class A >

bool trkf::syminvert

(

ublas::symmetric_matrix< T, TRI, L, A > &

m

)

Invert symmetric matrix (return false if singular).

The method used is Cholesky decomposition. This method is efficient and stable for positive-definite matrices. In case the matrix is not positive-definite, this method will usually work, but there can be some numerical pathologies, including "false singular" failures, and numerical instability. In the Kalman filter, we expect that this method will be used exclusively for positive-definite matrices.

Definition at line 109 of file KalmanLinearAlgebra.h.

  {
    typedef typename ublas::symmetric_matrix<T, TRI, L, A>::size_type size_type;
    typedef typename ublas::symmetric_matrix<T, TRI, L, A>::value_type value_type;

    // In situ Cholesky decomposition m = LDL^T.
    // D is diagonal matrix.
    // L is lower triangular with ones on the diagonal (ones not stored).

    for(size_type i = 0; i < m.size1(); ++i) {
      for(size_type j = 0; j <= i; ++j) {

        value_type ele = m(i,j);

        for(size_type k = 0; k < j; ++k)
          ele -= m(k,k) * m(i,k) * m(j,k);

        // Diagonal elements (can't have zeroes).

        if(i == j) {
          if(ele == 0.)
            return false;
        }

        // Off-diagonal elements.

        else
          ele = ele / m(j,j);

        // Replace element.

        m(i,j) = ele;
      }
    }

    // In situ inversion of D by simple division.
    // In situ inversion of L by back-substitution.

    for(size_type i = 0; i < m.size1(); ++i) {
      for(size_type j = 0; j <= i; ++j) {

        value_type ele = m(i,j);

        // Diagonal elements.

        if(i == j)
          m(i,i) = 1./ele;

        // Off diagonal elements.

        else {
          value_type sum = -ele;
          for(size_type k = j+1; k < i; ++k)
            sum -= m(i,k) * m(k,j);
          m(i,j) = sum;
        }
      }
    }

    // Recompose the inverse matrix in situ by matrix multiplication m = L^T DL.

    for(size_type i = 0; i < m.size1(); ++i) {
      for(size_type j = 0; j <= i; ++j) {

        value_type sum = m(i,i);
        if(i != j)
          sum *= m(i,j);

        for(size_type k = i+1; k < m.size1(); ++k)
          sum += m(k,k) * m(k,i) * m(k,j);

        m(i,j) = sum;
      }
    }

    // Done (success).

    return true;
  }

template<class M >

M::value_type trkf::trace

(

const M &

m

)

Trace of matrix.

Definition at line 231 of file KalmanLinearAlgebra.h.

  {
    typename M::size_type n = std::min(m.size1(), m.size2());
    typename M::value_type result = 0.;

    for(typename M::size_type i = 0; i < n; ++i)
      result += m(i,i);

    return result;
  }