Point on trajectory. More...

#include <GblPoint.h>

Public Member Functions
template<typename Derivative >
void	addGlobals (const std::vector< int > &aLabels, const Eigen::MatrixBase< Derivative > &aDerivatives)
	Add global derivatives to a point. More...

template<typename Derivative >
void	addLocals (const Eigen::MatrixBase< Derivative > &aDerivatives)
	Add local derivatives to a point. More...

template<typename Projection , typename Residuals , typename Precision , typename std::enable_if<(Residuals::ColsAtCompileTime==1)>::type * = nullptr, typename std::enable_if<(Precision::ColsAtCompileTime!=1)>::type * = nullptr>
void	addMeasurement (const Eigen::MatrixBase< Projection > &aProjection, const Eigen::MatrixBase< Residuals > &aResiduals, const Eigen::MatrixBase< Precision > &aPrecision, double minPrecision=0.)
	Add a measurement to a point. More...

template<typename Projection , typename Residuals , typename Precision , typename std::enable_if<(Residuals::ColsAtCompileTime==1)>::type * = nullptr, typename std::enable_if<(Precision::ColsAtCompileTime==1)>::type * = nullptr>
void	addMeasurement (const Eigen::MatrixBase< Projection > &aProjection, const Eigen::MatrixBase< Residuals > &aResiduals, const Eigen::MatrixBase< Precision > &aPrecision, double minPrecision=0.)

template<typename Residuals , typename Precision , typename std::enable_if<(Residuals::ColsAtCompileTime==1)>::type * = nullptr, typename std::enable_if<(Precision::ColsAtCompileTime!=1)>::type * = nullptr>
void	addMeasurement (const Eigen::MatrixBase< Residuals > &aResiduals, const Eigen::MatrixBase< Precision > &aPrecision, double minPrecision=0.)
	Add a measurement to a point. More...

template<typename Residuals , typename Precision , typename std::enable_if<(Residuals::ColsAtCompileTime==1)>::type * = nullptr, typename std::enable_if<(Precision::ColsAtCompileTime==1)>::type * = nullptr>
void	addMeasurement (const Eigen::MatrixBase< Residuals > &aResiduals, const Eigen::MatrixBase< Precision > &aPrecision, double minPrecision=0.)

void	addNextJacobian (const Matrix5d &aJac)
	Define jacobian to next scatterer (by GBLTrajectory constructor) More...

void	addPrevJacobian (const Matrix5d &aJac)
	Define jacobian to previous scatterer (by GBLTrajectory constructor) More...

template<typename Precision >
void	addScatterer (const Eigen::Vector2d &aResiduals, const Eigen::MatrixBase< Precision > &aPrecision)
	Add a (thin) scatterer to a point. More...

void	addScatterer (const Eigen::Vector2d &aResiduals, const Eigen::Vector2d &aPrecision)

	GblPoint (const Matrix5d &aJacobian)
	Create a point. More...

	GblPoint (const GblPoint &)=default

	GblPoint (GblPoint &&)=default

void	getDerivatives (int aDirection, Eigen::Matrix2d &matW, Eigen::Matrix2d &matWJ, Eigen::Vector2d &vecWd) const
	Retrieve derivatives of local track model. More...

void	getGlobalDerivatives (Eigen::MatrixXd &aDerivatives) const
	Retrieve global derivatives from a point. More...

void	getGlobalLabels (std::vector< int > &aLabels) const
	Retrieve global derivatives labels from a point. More...

void	getGlobalLabelsAndDerivatives (unsigned int aRow, std::vector< int > &aLabels, std::vector< double > &aDerivatives) const
	Retrieve global derivatives from a point for a single row. More...

unsigned int	getLabel () const
	Retrieve label of point. More...

const Eigen::MatrixXd &	getLocalDerivatives () const
	Retrieve local derivatives from a point. More...

double	getMeasPrecMin () const
	get precision cutoff. More...

void	getMeasTransformation (Eigen::MatrixXd &aTransformation) const
	Get measurement transformation (from diagonalization). More...

void	getMeasurement (Matrix5d &aProjection, Vector5d &aResiduals, Vector5d &aPrecision) const
	Retrieve measurement of a point. More...

unsigned int	getNumGlobals () const
	Retrieve number of global derivatives from a point. More...

unsigned int	getNumLocals () const
	Retrieve number of local derivatives from a point. More...

int	getOffset () const
	Retrieve offset for point. More...

const Matrix5d &	getP2pJacobian () const
	Retrieve point-to-(previous)point jacobian. More...

void	getScatterer (Eigen::Matrix2d &aTransformation, Eigen::Vector2d &aResiduals, Eigen::Vector2d &aPrecision) const
	Retrieve scatterer of a point. More...

void	getScatTransformation (Eigen::Matrix2d &aTransformation) const
	Get scatterer transformation (from diagonalization). More...

unsigned int	hasMeasurement () const
	Check for measurement at a point. More...

bool	hasScatterer () const
	Check for scatterer at a point. More...

GblPoint &	operator= (const GblPoint &)=default

GblPoint &	operator= (GblPoint &&)=default

void	printPoint (unsigned int level=0) const
	Print GblPoint. More...

void	setLabel (unsigned int aLabel)
	Define label of point (by GBLTrajectory constructor) More...

void	setOffset (int anOffset)
	Define offset for point (by GBLTrajectory constructor) More...

virtual	~GblPoint ()

Private Attributes
Eigen::MatrixXd	globalDerivatives
	Derivatives of measurement vs additional global (MP-II) parameters. More...

std::vector< int >	globalLabels
	Labels of global (MP-II) derivatives. More...

Eigen::MatrixXd	localDerivatives
	Derivatives of measurement vs additional local (fit) parameters. More...

unsigned int	measDim
	Dimension of measurement (1-5), 0 indicates absence of measurement. More...

Vector5d	measPrecision
	Measurement precision (diagonal of inverse covariance matrix) More...

double	measPrecMin
	Minimal measurement precision (for usage) More...

Matrix5d	measProjection
	Projection from measurement to local system. More...

Vector5d	measResiduals
	Measurement residuals. More...

Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor, 5, 5 >	measTransformation
	Transformation of diagonalization (of meas. precision matrix) More...

Matrix5d	nextJacobian
	Jacobian to next scatterer (or last measurement) More...

Matrix5d	p2pJacobian
	Point-to-point jacobian from previous point. More...

Matrix5d	prevJacobian
	Jacobian to previous scatterer (or first measurement) More...

bool	scatFlag
	Scatterer present? More...

Eigen::Vector2d	scatPrecision
	Scattering precision (diagonal of inverse covariance matrix) More...

Eigen::Vector2d	scatResiduals
	Scattering residuals (initial kinks if iterating) More...

Eigen::Matrix2d	scatTransformation
	Transformation of diagonalization (of scat. precision matrix) More...

unsigned int	theLabel
	Label identifying point. More...

int	theOffset
	Offset number at point if not negative (else interpolation needed) More...

bool	transFlag
	Transformation exists? More...

Detailed Description

Point on trajectory.

User supplied point on (initial) trajectory.

Must have jacobian for propagation from previous point. May have:

Measurement (1D - 5D)
Scatterer (thin, 2D kinks)
Additional local parameters (with derivatives). Fitted together with track parameters.
Additional global parameters (with labels and derivatives). Not fitted, only passed on to (binary) file for fitting with Millepede-II.

Definition at line 66 of file GblPoint.h.

Constructor & Destructor Documentation

gbl::GblPoint::GblPoint ( const Matrix5d & aJacobian )

Create a point.

Create point on (initial) trajectory. Needs transformation jacobian from previous point.

Parameters

[in] aJacobian Transformation jacobian from previous point

Definition at line 41 of file GblPoint.cc.

References globalDerivatives, globalLabels, mps_fire::i, localDerivatives, measDim, measPrecMin, measTransformation, p2pJacobian, scatFlag, theLabel, theOffset, and transFlag.

                                               :
     theLabel(0), theOffset(0), p2pJacobian(aJacobian), measDim(0),
     measPrecMin(0.), transFlag(false), measTransformation(), scatFlag(false),
     localDerivatives(), globalLabels(), globalDerivatives()
   {
   }

gbl::GblPoint::GblPoint ( const GblPoint & )

default

gbl::GblPoint::GblPoint ( GblPoint && )

default

gbl::GblPoint::~GblPoint ( )

virtual

Definition at line 68 of file GblPoint.cc.

References addMeasurement(), mps_fire::i, measDim, measPrecision, measPrecMin, measProjection, measResiduals, measTransformation, and transFlag.

68 {

69 }

Member Function Documentation

template<typename Derivative >

void gbl::GblPoint::addGlobals	(	const std::vector< int > &	aLabels,
		const Eigen::MatrixBase< Derivative > &	aDerivatives
	)

Add global derivatives to a point.

Point needs to have a measurement.

Parameters

[in]	aLabels	Global derivatives labels
[in]	aDerivatives	Global derivatives (matrix)

Definition at line 342 of file GblPoint.h.

References globalDerivatives, globalLabels, measDim, measTransformation, and transFlag.

Referenced by MillePedeAlignmentAlgorithm::addGlobalData(), and getLocalDerivatives().

   {
     if (measDim) {
       globalLabels = aLabels;
       globalDerivatives.resize(aDerivatives.rows(), aDerivatives.cols());
       if (transFlag) {
         globalDerivatives = measTransformation * aDerivatives;
       } else {
         globalDerivatives = aDerivatives;
       }
 
     }
   }

template<typename Derivative >

void gbl::GblPoint::addLocals ( const Eigen::MatrixBase< Derivative > & aDerivatives )

Add local derivatives to a point.

Point needs to have a measurement.

Parameters

[in] aDerivatives Local derivatives (matrix)

Definition at line 323 of file GblPoint.h.

References localDerivatives, measDim, measTransformation, and transFlag.

Referenced by getScatTransformation().

   {
     if (measDim) {
       localDerivatives.resize(aDerivatives.rows(), aDerivatives.cols());
       if (transFlag) {
         localDerivatives = measTransformation * aDerivatives;
       } else {
         localDerivatives = aDerivatives;
       }
     }
   }

template<typename Projection , typename Residuals , typename Precision , typename std::enable_if<(Residuals::ColsAtCompileTime==1)>::type * , typename std::enable_if<(Precision::ColsAtCompileTime==1)>::type * >

void gbl::GblPoint::addMeasurement	(	const Eigen::MatrixBase< Projection > &	aProjection,
		const Eigen::MatrixBase< Residuals > &	aResiduals,
		const Eigen::MatrixBase< Precision > &	aPrecision,
		double	minPrecision = `0.`
	)

Add a measurement to a point.

Add measurement (in meas. system) with diagonal or arbitrary precision (inverse covariance) matrix. Will be diagonalized. ((up to) 2D: position, 4D: slope+position, 5D: curvature+slope+position)

Parameters

[in]	aProjection	Projection from local to measurement system
[in]	aResiduals	Measurement residuals
[in]	aPrecision	Measurement precision (matrix)
[in]	minPrecision	Minimal precision to accept measurement

Add measurement (in meas. system) with diagonal or arbitrary precision (inverse covariance) matrix. Will be diagonalized. ((up to) 2D: position, 4D: slope+position, 5D: curvature+slope+position)

Parameters

[in]	aProjection	Projection from local to measurement system
[in]	aResiduals	Measurement residuals
[in]	aPrecision	Measurement precision (diagonal)
[in]	minPrecision	Minimal precision to accept measurement

Definition at line 194 of file GblPoint.h.

References measDim, measPrecision, measPrecMin, measProjection, measResiduals, measTransformation, and transFlag.

Referenced by ReferenceTrajectory::addMaterialEffectsCurvlinGbl(), ReferenceTrajectory::addMaterialEffectsLocalGbl(), addMeasurement(), and ~GblPoint().

   {
     measDim = aResiduals.rows();
     measPrecMin = minPrecision;
     // arbitrary precision matrix
     Eigen::SelfAdjointEigenSolver<typename Precision::PlainObject> measEigen{aPrecision};
     measTransformation = measEigen.eigenvectors().transpose();
     transFlag = true;
     measResiduals.tail(measDim) = measTransformation * aResiduals;
     measPrecision.tail(measDim) = measEigen.eigenvalues();
     measProjection.bottomRightCorner(measDim, measDim) =
       measTransformation * aProjection;
   }

template<typename Projection , typename Residuals , typename Precision , typename std::enable_if<(Residuals::ColsAtCompileTime==1)>::type * = nullptr, typename std::enable_if<(Precision::ColsAtCompileTime==1)>::type * = nullptr>

void gbl::GblPoint::addMeasurement	(	const Eigen::MatrixBase< Projection > &	aProjection,
		const Eigen::MatrixBase< Residuals > &	aResiduals,
		const Eigen::MatrixBase< Precision > &	aPrecision,
		double	minPrecision = `0.`
	)

template<typename Residuals , typename Precision , typename std::enable_if<(Residuals::ColsAtCompileTime==1)>::type * , typename std::enable_if<(Precision::ColsAtCompileTime==1)>::type * >

void gbl::GblPoint::addMeasurement	(	const Eigen::MatrixBase< Residuals > &	aResiduals,
		const Eigen::MatrixBase< Precision > &	aPrecision,
		double	minPrecision = `0.`
	)

Add a measurement to a point.

Add measurement in local system with diagonal or arbitrary precision (inverse covariance) matrix. Will be diagonalized. ((up to) 2D: position, 4D: slope+position, 5D: curvature+slope+position)

Parameters

[in]	aResiduals	Measurement residuals
[in]	aPrecision	Measurement precision (matrix)
[in]	minPrecision	Minimal precision to accept measurement

Add measurement in local system with diagonal or arbitrary precision (inverse covariance) matrix. Will be diagonalized. ((up to) 2D: position, 4D: slope+position, 5D: curvature+slope+position)

Parameters

[in]	aResiduals	Measurement residuals
[in]	aPrecision	Measurement precision (diagonal)
[in]	minPrecision	Minimal precision to accept measurement

Definition at line 249 of file GblPoint.h.

References addMeasurement(), measDim, measPrecision, measPrecMin, measProjection, measResiduals, measTransformation, and transFlag.

   {
     measDim = aResiduals.rows();
     measPrecMin = minPrecision;
     // arbitrary precision matrix
     Eigen::SelfAdjointEigenSolver<typename Precision::PlainObject> measEigen{aPrecision};
     measTransformation = measEigen.eigenvectors().transpose();
     transFlag = true;
     measResiduals.tail(measDim) = measTransformation * aResiduals;
     measPrecision.tail(measDim) = measEigen.eigenvalues();
     measProjection.bottomRightCorner(measDim, measDim) = measTransformation;
   }

template<typename Residuals , typename Precision , typename std::enable_if<(Residuals::ColsAtCompileTime==1)>::type * = nullptr, typename std::enable_if<(Precision::ColsAtCompileTime==1)>::type * = nullptr>

void gbl::GblPoint::addMeasurement	(	const Eigen::MatrixBase< Residuals > &	aResiduals,
		const Eigen::MatrixBase< Precision > &	aPrecision,
		double	minPrecision = `0.`
	)

void gbl::GblPoint::addNextJacobian ( const Matrix5d & aJac )

Define jacobian to next scatterer (by GBLTrajectory constructor)

Parameters

[in] aJac Jacobian

Definition at line 487 of file GblPoint.cc.

References nextJacobian.

Referenced by gbl::GblTrajectory::calcJacobians().

                                                      {
     nextJacobian = aJac;
   }

void gbl::GblPoint::addPrevJacobian ( const Matrix5d & aJac )

Define jacobian to previous scatterer (by GBLTrajectory constructor)

Parameters

[in] aJac Jacobian

Definition at line 472 of file GblPoint.cc.

References prevJacobian.

                                                      {
     // to optimize: need only two last rows of inverse
     //  prevJacobian = aJac.inverse();
     //  block matrix algebra
     Matrix23d CA = aJac.block<2, 3>(3, 0) * aJac.block<3, 3>(0, 0).inverse(); // C*A^-1
     Matrix2d DCAB = aJac.block<2, 2>(3, 3) - CA * aJac.block<3, 2>(0, 3); // D - C*A^-1 *B
     Matrix2d DCABInv = DCAB.inverse();
     prevJacobian.block<2, 2>(3, 3) = DCABInv;
     prevJacobian.block<2, 3>(3, 0) = -DCABInv * CA;
   }

template<typename Precision >

void gbl::GblPoint::addScatterer	(	const Eigen::Vector2d &	aResiduals,
		const Eigen::MatrixBase< Precision > &	aPrecision
	)

Add a (thin) scatterer to a point.

Add scatterer with diagonal or arbitrary precision (inverse covariance) matrix. Will be diagonalized. Changes local track direction.

The precision matrix for the local slopes is defined by the angular scattering error theta_0 and the scalar products c_1, c_2 of the offset directions in the local frame with the track direction:

       (1 - c_1*c_1 - c_2*c_2)   |  1 - c_1*c_1     - c_1*c_2  |
  P =  ----------------------- * |                             |
           theta_0*theta_0       |    - c_1*c_2   1 - c_2*c_2  |

Parameters

[in]	aResiduals	Scatterer residuals
[in]	aPrecision	Scatterer precision (vector (with diagonal) or (full) matrix)

Definition at line 305 of file GblPoint.h.

References scatFlag, scatPrecision, scatResiduals, and scatTransformation.

Referenced by ReferenceTrajectory::addMaterialEffectsCurvlinGbl(), ReferenceTrajectory::addMaterialEffectsLocalGbl(), and getMeasTransformation().

   {
     scatFlag = true;
     // arbitrary precision matrix
     Eigen::SelfAdjointEigenSolver<typename Precision::PlainObject> scatEigen{aPrecision};
     scatTransformation = scatEigen.eigenvectors();
     scatTransformation.transposeInPlace();
     scatResiduals = scatTransformation * aResiduals;
     scatPrecision = scatEigen.eigenvalues();
   }

void gbl::GblPoint::addScatterer	(	const Eigen::Vector2d &	aResiduals,
		const Eigen::Vector2d &	aPrecision
	)

void gbl::GblPoint::getDerivatives	(	int	aDirection,
		Eigen::Matrix2d &	matW,
		Eigen::Matrix2d &	matWJ,
		Eigen::Vector2d &	vecWd
	)		const

Retrieve derivatives of local track model.

Linearized track model: F_u(q/p,u',u) = J*u + S*u' + d*q/p, W is inverse of S, negated for backward propagation.

Parameters

[in]	aDirection	Propagation direction (>0 forward, else backward)
[out]	matW	W
[out]	matWJ	W*J
[out]	vecWd	W*d

Exceptions

std::overflow_error : matrix S is singular.

Definition at line 501 of file GblPoint.cc.

References gather_cfg::cout, nextJacobian, and prevJacobian.

Referenced by gbl::GblTrajectory::getFitToKinkJacobian(), and gbl::GblTrajectory::getFitToLocalJacobian().

                                                        {
 
     Matrix2d matJ;
     Vector2d vecd;
     if (aDirection < 1) {
       matJ = prevJacobian.block<2, 2>(3, 3);
       matW = -prevJacobian.block<2, 2>(3, 1);
       vecd = prevJacobian.block<2, 1>(3, 0);
     } else {
       matJ = nextJacobian.block<2, 2>(3, 3);
       matW = nextJacobian.block<2, 2>(3, 1);
       vecd = nextJacobian.block<2, 1>(3, 0);
     }
 
     if (!matW.determinant()) {
       std::cout << " GblPoint::getDerivatives failed to invert matrix "
                 << std::endl;
       std::cout
         << " Possible reason for singular matrix: multiple GblPoints at same arc-length"
         << std::endl;
       throw std::overflow_error("Singular matrix inversion exception");
     }
     matW = matW.inverse().eval();
     matWJ = matW * matJ;
     vecWd = matW * vecd;
   }

void gbl::GblPoint::getGlobalDerivatives ( Eigen::MatrixXd & aDerivatives ) const

Retrieve global derivatives from a point.

Parameters

[out] aDerivatives Global derivatives

Definition at line 417 of file GblPoint.cc.

References globalDerivatives.

                                                                   {
     aDerivatives = globalDerivatives;
   }

void gbl::GblPoint::getGlobalLabels ( std::vector< int > & aLabels ) const

Retrieve global derivatives labels from a point.

Parameters

[out] aLabels Global labels

Definition at line 409 of file GblPoint.cc.

References globalLabels.

                                                               {
     aLabels = globalLabels;
   }

void gbl::GblPoint::getGlobalLabelsAndDerivatives	(	unsigned int	aRow,
		std::vector< int > &	aLabels,
		std::vector< double > &	aDerivatives
	)		const

Retrieve global derivatives from a point for a single row.

Parameters

[in]	aRow	Row number
[out]	aLabels	Global labels
[out]	aDerivatives	Global derivatives

Definition at line 427 of file GblPoint.cc.

References globalDerivatives, globalLabels, and mps_fire::i.

                                                                                                                {
     aLabels.resize(globalDerivatives.cols());
     aDerivatives.resize(globalDerivatives.cols());
     for (unsigned int i = 0; i < globalDerivatives.cols(); ++i) {
       aLabels[i] = globalLabels[i];
       aDerivatives[i] = globalDerivatives(aRow, i);
     }
   }

unsigned int gbl::GblPoint::getLabel ( ) const

Retrieve label of point.

Definition at line 446 of file GblPoint.cc.

References theLabel.

                                         {
     return theLabel;
   }

const MatrixXd & gbl::GblPoint::getLocalDerivatives ( ) const

Retrieve local derivatives from a point.

Definition at line 367 of file GblPoint.cc.

References addGlobals(), globalDerivatives, globalLabels, mps_fire::i, localDerivatives, measDim, measTransformation, and transFlag.

                                                       {
     return localDerivatives;
   }

double gbl::GblPoint::getMeasPrecMin ( ) const

get precision cutoff.

Returns: minimal measurement precision (for usage)

Definition at line 197 of file GblPoint.cc.

References measPrecMin.

                                         {
     return measPrecMin;
   }

void gbl::GblPoint::getMeasTransformation ( Eigen::MatrixXd & aTransformation ) const

Get measurement transformation (from diagonalization).

Parameters

[out] aTransformation Transformation matrix

Definition at line 219 of file GblPoint.cc.

References addScatterer(), mps_fire::i, measDim, measTransformation, scatFlag, scatPrecision, scatResiduals, scatTransformation, and transFlag.

                                                                       {
     aTransformation.resize(measDim, measDim);
     if (transFlag) {
       aTransformation = measTransformation;
     } else {
       aTransformation.setIdentity();
     }
   }

void gbl::GblPoint::getMeasurement	(	Matrix5d &	aProjection,
		Vector5d &	aResiduals,
		Vector5d &	aPrecision
	)		const

Retrieve measurement of a point.

Parameters

[out]	aProjection	Projection from (diagonalized) measurement to local system
[out]	aResiduals	Measurement residuals
[out]	aPrecision	Measurement precision (diagonal)

Definition at line 207 of file GblPoint.cc.

References measDim, measPrecision, measProjection, and measResiduals.

                                                             {
     aProjection.bottomRightCorner(measDim, measDim) =
       measProjection.bottomRightCorner(measDim, measDim);
     aResiduals.tail(measDim) = measResiduals.tail(measDim);
     aPrecision.tail(measDim) = measPrecision.tail(measDim);
   }

unsigned int gbl::GblPoint::getNumGlobals ( ) const

Retrieve number of global derivatives from a point.

Definition at line 401 of file GblPoint.cc.

References globalDerivatives.

                                              {
     return globalDerivatives.cols();
   }

unsigned int gbl::GblPoint::getNumLocals ( ) const

Retrieve number of local derivatives from a point.

Definition at line 362 of file GblPoint.cc.

References localDerivatives.

                                             {
     return localDerivatives.cols();
   }

int gbl::GblPoint::getOffset ( ) const

Retrieve offset for point.

Definition at line 459 of file GblPoint.cc.

References theOffset.

Referenced by gbl::GblTrajectory::getFitToKinkJacobian(), and gbl::GblTrajectory::getFitToLocalJacobian().

                                 {
     return theOffset;
   }

const Matrix5d & gbl::GblPoint::getP2pJacobian ( ) const

Retrieve point-to-(previous)point jacobian.

Definition at line 464 of file GblPoint.cc.

References p2pJacobian.

Referenced by gbl::GblTrajectory::calcJacobians().

                                                  {
     return p2pJacobian;
   }

void gbl::GblPoint::getScatterer	(	Eigen::Matrix2d &	aTransformation,
		Eigen::Vector2d &	aResiduals,
		Eigen::Vector2d &	aPrecision
	)		const

Retrieve scatterer of a point.

Parameters

[out]	aTransformation	Scatterer transformation from diagonalization
[out]	aResiduals	Scatterer residuals
[out]	aPrecision	Scatterer precision (diagonal)

Definition at line 317 of file GblPoint.cc.

References scatPrecision, scatResiduals, and scatTransformation.

                                                           {
     aTransformation = scatTransformation;
     aResiduals = scatResiduals;
     aPrecision = scatPrecision;
   }

void gbl::GblPoint::getScatTransformation ( Eigen::Matrix2d & aTransformation ) const

Get scatterer transformation (from diagonalization).

Parameters

[out] aTransformation Transformation matrix

Definition at line 328 of file GblPoint.cc.

References addLocals(), mps_fire::i, localDerivatives, measDim, measTransformation, scatFlag, scatTransformation, and transFlag.

                                                                       {
     if (scatFlag) {
       aTransformation = scatTransformation;
     } else {
       aTransformation.setIdentity();
     }
   }

unsigned int gbl::GblPoint::hasMeasurement ( ) const

Check for measurement at a point.

Get dimension of measurement (0 = none).

Returns: measurement dimension

Definition at line 189 of file GblPoint.cc.

References measDim.

                                               {
     return measDim;
   }

bool gbl::GblPoint::hasScatterer ( ) const

Check for scatterer at a point.

Definition at line 307 of file GblPoint.cc.

References scatFlag.

                                     {
     return scatFlag;
   }

GblPoint& gbl::GblPoint::operator= ( const GblPoint & )

default

GblPoint& gbl::GblPoint::operator= ( GblPoint && )

default

void gbl::GblPoint::printPoint ( unsigned int level = 0 ) const

Print GblPoint.

Parameters

[in] level print level (0: minimum, >0: more)

Definition at line 533 of file GblPoint.cc.

References gather_cfg::cout, globalDerivatives, globalLabels, mps_fire::i, localDerivatives, measDim, measPrecision, measPrecMin, measProjection, measResiduals, nextJacobian, p2pJacobian, prevJacobian, scatFlag, scatPrecision, scatResiduals, theLabel, theOffset, and transFlag.

                                                     {
     std::cout << " GblPoint";
     if (theLabel) {
       std::cout << ", label " << theLabel;
       if (theOffset >= 0) {
         std::cout << ", offset " << theOffset;
       }
     }
     if (measDim) {
       std::cout << ", " << measDim << " measurements";
     }
     if (scatFlag) {
       std::cout << ", scatterer";
     }
     if (transFlag) {
       std::cout << ", diagonalized";
     }
     if (localDerivatives.cols()) {
       std::cout << ", " << localDerivatives.cols() << " local derivatives";
     }
     if (globalDerivatives.cols()) {
       std::cout << ", " << globalDerivatives.cols() << " global derivatives";
     }
     std::cout << std::endl;
     if (level > 0) {
       IOFormat CleanFmt(4, 0, ", ", "\n", "[", "]");
       if (measDim) {
         std::cout << "  Measurement" << std::endl;
         std::cout << "   Projection: " << std::endl
                   << measProjection.format(CleanFmt) << std::endl;
         std::cout << "   Residuals: "
                   << measResiduals.transpose().format(CleanFmt) << std::endl;
         std::cout << "   Precision (min.: " << measPrecMin << "): "
                   << measPrecision.transpose().format(CleanFmt) << std::endl;
       }
       if (scatFlag) {
         std::cout << "  Scatterer" << std::endl;
         std::cout << "   Residuals: "
                   << scatResiduals.transpose().format(CleanFmt) << std::endl;
         std::cout << "   Precision: "
                   << scatPrecision.transpose().format(CleanFmt) << std::endl;
       }
       if (localDerivatives.cols()) {
         std::cout << "  Local Derivatives:" << std::endl
                   << localDerivatives.format(CleanFmt) << std::endl;
       }
       if (globalDerivatives.cols()) {
         std::cout << "  Global Labels:";
         for (unsigned int i = 0; i < globalLabels.size(); ++i) {
           std::cout << " " << globalLabels[i];
         }
         std::cout << std::endl;
         std::cout << "  Global Derivatives:"
                   << globalDerivatives.format(CleanFmt) << std::endl;
       }
       std::cout << "  Jacobian " << std::endl;
       std::cout << "   Point-to-point " << std::endl
                 << p2pJacobian.format(CleanFmt) << std::endl;
       if (theLabel) {
         std::cout << "   To previous offset " << std::endl
                   << prevJacobian.format(CleanFmt) << std::endl;
         std::cout << "   To next offset " << std::endl
                   << nextJacobian.format(CleanFmt) << std::endl;
       }
     }
   }

void gbl::GblPoint::setLabel ( unsigned int aLabel )

Define label of point (by GBLTrajectory constructor)

Parameters

[in] aLabel Label identifying point

Definition at line 441 of file GblPoint.cc.

References theLabel.

Referenced by SequenceTypes.DummyModule::__init__(), SequenceTypes.DummyBooleanModule::__init__(), and Vispa.Gui.FindDialog.FindDialog::reset().

                                              {
     theLabel = aLabel;
   }

void gbl::GblPoint::setOffset ( int anOffset )

Define offset for point (by GBLTrajectory constructor)

Parameters

[in] anOffset Offset number

Definition at line 454 of file GblPoint.cc.

References theOffset.

                                        {
     theOffset = anOffset;
   }

Member Data Documentation

Eigen::MatrixXd gbl::GblPoint::globalDerivatives

private

Derivatives of measurement vs additional global (MP-II) parameters.

Definition at line 177 of file GblPoint.h.

Referenced by addGlobals(), GblPoint(), getGlobalDerivatives(), getGlobalLabelsAndDerivatives(), getLocalDerivatives(), getNumGlobals(), and printPoint().

std::vector<int> gbl::GblPoint::globalLabels

private

Labels of global (MP-II) derivatives.

Definition at line 176 of file GblPoint.h.

Referenced by addGlobals(), GblPoint(), getGlobalLabels(), getGlobalLabelsAndDerivatives(), getLocalDerivatives(), and printPoint().

Eigen::MatrixXd gbl::GblPoint::localDerivatives

private

Derivatives of measurement vs additional local (fit) parameters.

Definition at line 175 of file GblPoint.h.

Referenced by addLocals(), GblPoint(), getLocalDerivatives(), getNumLocals(), getScatTransformation(), and printPoint().

unsigned int gbl::GblPoint::measDim

private

Dimension of measurement (1-5), 0 indicates absence of measurement.

Definition at line 163 of file GblPoint.h.

Referenced by addGlobals(), addLocals(), addMeasurement(), GblPoint(), getLocalDerivatives(), getMeasTransformation(), getMeasurement(), getScatTransformation(), hasMeasurement(), printPoint(), and ~GblPoint().

Vector5d gbl::GblPoint::measPrecision

private

Measurement precision (diagonal of inverse covariance matrix)

Definition at line 167 of file GblPoint.h.

Referenced by addMeasurement(), getMeasurement(), printPoint(), and ~GblPoint().

double gbl::GblPoint::measPrecMin

private

Minimal measurement precision (for usage)

Definition at line 164 of file GblPoint.h.

Referenced by addMeasurement(), GblPoint(), getMeasPrecMin(), printPoint(), and ~GblPoint().

Matrix5d gbl::GblPoint::measProjection

private

Projection from measurement to local system.

Definition at line 165 of file GblPoint.h.

Referenced by addMeasurement(), getMeasurement(), printPoint(), and ~GblPoint().

Vector5d gbl::GblPoint::measResiduals

private

Measurement residuals.

Definition at line 166 of file GblPoint.h.

Referenced by addMeasurement(), getMeasurement(), printPoint(), and ~GblPoint().

Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, Eigen::ColMajor , 5, 5> gbl::GblPoint::measTransformation

private

Transformation of diagonalization (of meas. precision matrix)

Definition at line 170 of file GblPoint.h.

Referenced by addGlobals(), addLocals(), addMeasurement(), GblPoint(), getLocalDerivatives(), getMeasTransformation(), getScatTransformation(), and ~GblPoint().

Matrix5d gbl::GblPoint::nextJacobian

private

Jacobian to next scatterer (or last measurement)

Definition at line 162 of file GblPoint.h.

Referenced by addNextJacobian(), getDerivatives(), and printPoint().

Matrix5d gbl::GblPoint::p2pJacobian

private

Point-to-point jacobian from previous point.

Definition at line 160 of file GblPoint.h.

Referenced by GblPoint(), getP2pJacobian(), and printPoint().

Matrix5d gbl::GblPoint::prevJacobian

private

Jacobian to previous scatterer (or first measurement)

Definition at line 161 of file GblPoint.h.

Referenced by addPrevJacobian(), getDerivatives(), and printPoint().

bool gbl::GblPoint::scatFlag

private

Scatterer present?

Definition at line 171 of file GblPoint.h.

Referenced by addScatterer(), GblPoint(), getMeasTransformation(), getScatTransformation(), hasScatterer(), and printPoint().

Eigen::Vector2d gbl::GblPoint::scatPrecision

private

Scattering precision (diagonal of inverse covariance matrix)

Definition at line 174 of file GblPoint.h.

Referenced by addScatterer(), getMeasTransformation(), getScatterer(), and printPoint().

Eigen::Vector2d gbl::GblPoint::scatResiduals

private

Scattering residuals (initial kinks if iterating)

Definition at line 173 of file GblPoint.h.

Referenced by addScatterer(), getMeasTransformation(), getScatterer(), and printPoint().

Eigen::Matrix2d gbl::GblPoint::scatTransformation

private

Transformation of diagonalization (of scat. precision matrix)

Definition at line 172 of file GblPoint.h.

Referenced by addScatterer(), getMeasTransformation(), getScatterer(), and getScatTransformation().

unsigned int gbl::GblPoint::theLabel

private

Label identifying point.

Definition at line 158 of file GblPoint.h.

Referenced by GblPoint(), getLabel(), printPoint(), and setLabel().

int gbl::GblPoint::theOffset

private

Offset number at point if not negative (else interpolation needed)

Definition at line 159 of file GblPoint.h.

Referenced by GblPoint(), getOffset(), printPoint(), and setOffset().

bool gbl::GblPoint::transFlag

private

Transformation exists?

Definition at line 168 of file GblPoint.h.

Referenced by addGlobals(), addLocals(), addMeasurement(), GblPoint(), getLocalDerivatives(), getMeasTransformation(), getScatTransformation(), printPoint(), and ~GblPoint().

Public Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation