Amg Namespace Reference

Definition of ATLAS Math & Geometry primitives (Amg) More...

Classes
struct	Vector3DComparer
	comparison of two Vector3D, needed for the definition of a std::set<Amg::Vector3D> More...
struct	VectorVector3DComparer

Typedefs
using	Rotation3D = Eigen::Quaternion<double>
using	Translation3D = Eigen::Translation<double, 3>
using	AngleAxis3D = Eigen::AngleAxisd
using	Transform3D = Eigen::Affine3d
using	Vector3D = Eigen::Matrix<double, 3, 1>
using	Vector2D = Eigen::Matrix<double, 2, 1>
using	RotationMatrix3D = Eigen::Matrix<double, 3, 3>
using	SetVector3D = std::set<Amg::Vector3D, Vector3DComparer>
using	SetVectorVector3D = std::set< std::vector< Amg::Vector3D>, VectorVector3DComparer>
using	MatrixX = Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>
	Dynamic Matrix - dynamic allocation.
using	SymMatrixX = Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>
using	VectorX = Eigen::Matrix<double, Eigen::Dynamic, 1>
	Dynamic Vector - dynamic allocation.
template<int MaxRows, int MaxCols>
using	MatrixMaxX
	Fixed capacity dynamic size types.
template<int MaxDim>
using	SymMatrixMaxX
template<int MaxRows>
using	VectorMaxX = Eigen::Matrix<double, Eigen::Dynamic, 1, 0, MaxRows, 1>

Enumerations
enum	AxisDefs {   x = 0 , y = 1 , z = 2 , px = 0 ,   py = 1 , pz = 2 }
	element for code readability More...

Functions
template<class T>
std::string	AsString (const T &m)
	write an Amg Eigen object to std::string
Amg::Transform3D	CLHEPTransformToEigen (const HepGeom::Transform3D &CLHEPtransf)
	Converts a CLHEP-based HepGeom::Transform3D into an Eigen Amg::Transform3D.
RotationMatrix3D	CLHEPRotationToEigen (const CLHEP::HepRotation &CLHEProtation)
	Converts a CLHEP::HepRotation into an Eigen-based Amg::RotationMatrix3D.
Amg::Translation3D	CLHEPTranslationToEigen (const CLHEP::Hep3Vector &CLHEPtranslation)
	Converts a CLHEP::Hep3Vector into an Eigen-based Amg::Translation3D.
Amg::Transform3D	CLHEPTranslate3DToEigen (const HepGeom::Translate3D &CLHEPtranslate3D)
	Converts a CLHEP-based HepGeom::Translate3 into an Eigen-based Amg::Transform3D.
HepGeom::Transform3D	EigenTransformToCLHEP (const Amg::Transform3D &eigenTransf)
	Converts an Eigen-based Amg::Transform3D into a CLHEP-based HepGeom::Transform3D.
Amg::Vector3D	Hep3VectorToEigen (const CLHEP::Hep3Vector &CLHEPvector)
	Converts a CLHEP-based CLHEP::Hep3Vector into an Eigen-based Amg::Vector3D.
CLHEP::Hep3Vector	EigenToHep3Vector (const Amg::Vector3D &eigenvector)
	Converts an Eigen-based Amg::Vector3D into a CLHEP-based CLHEP::Hep3Vector.
Amg::Vector3D	convert_CLHEPPhiThetaPsi_to_EigenEulerAngles (Amg::Vector3D clhep_angles, int convention=0)
	Convert CLEHP Phi,Theta,Psi angles to Eigen euler angles using Z-X-Z convention.
Amg::Vector3D	convert_EigenEulerAngles_to_CLHEPPhiThetaPsi (Amg::Vector3D eigen_angles, int convention=0)
	Convert Eigen euler angles to CLEHP Phi,Theta,Psi angles.
Amg::Vector3D	getPhiThetaPsi (Amg::RotationMatrix3D mat, int convention=0)
	Get the equivalents to CLHEP Phi, Theta, Psi Euler angles.
Amg::RotationMatrix3D	setPhi (Amg::RotationMatrix3D mat, double angle, int convention=0)
double	angle (const Amg::Vector3D &v1, const Amg::Vector3D &v2)
	calculates the opening angle between two vectors
float	distance2 (const Amg::Vector3D &p1, const Amg::Vector3D &p2)
	calculates the squared distance between two point in 3D space
float	distance (const Amg::Vector3D &p1, const Amg::Vector3D &p2)
	calculates the distance between two point in 3D space
void	setPhi (Amg::Vector3D &v, double phi)
	sets the phi angle of a vector without changing theta nor the magnitude
void	setThetaPhi (Amg::Vector3D &v, double theta, double phi)
	sets the theta and phi angle of a vector without changing the magnitude
void	setRThetaPhi (Amg::Vector3D &v, double r, double theta, double phi)
	sets radius, the theta and phi angle of a vector.
void	setTheta (Amg::Vector3D &v, double theta)
	sets the theta of a vector without changing phi nor the magnitude
void	setPerp (Amg::Vector3D &v, double perp)
	scales the vector in the xy plane without changing the z coordinate nor the angles
void	setMag (Amg::Vector3D &v, double mag)
	scales the vector length without changing the angles
double	deltaPhi (const Amg::Vector3D &v1, const Amg::Vector3D &v2)
double	deltaR (const Amg::Vector3D &v1, const Amg::Vector3D &v2)
void	setVector3DCartesian (Amg::Vector3D &v1, double x1, double y1, double z1)
	Sets components in cartesian coordinate system.
double	mag2Vector3D (const Amg::Vector3D &v1)
	Gets magnitude squared of the vector.
double	magVector3D (const Amg::Vector3D &v1)
	Gets magnitude of the vector.
double	rVector3D (const Amg::Vector3D &v1)
	Gets r-component in spherical coordinate system.
Amg::Vector3D	transform (Amg::Vector3D &v, Amg::Transform3D &tr)
	Transform a point from a Trasformation3D.
Amg::Transform3D	getTransformFromRotTransl (Amg::RotationMatrix3D rot, Amg::Vector3D transl_vec)
void	getAngleAxisFromRotation (Amg::RotationMatrix3D &rotation, double &rotationAngle, Amg::Vector3D &rotationAxis)
Amg::Vector3D	getTranslationVectorFromTransform (const Amg::Transform3D &tr)
	Get the Translation vector out of a Transformation.
Amg::Rotation3D	getRotation3DfromAngleAxis (double angle, Amg::Vector3D &axis)
	get a AngleAxis from an angle and an axis.
Amg::Transform3D	getRotateX3D (double angle)
	get a rotation transformation around X-axis
Amg::Transform3D	getRotateY3D (double angle)
	get a rotation transformation around Y-axis
Amg::Transform3D	getRotateZ3D (double angle)
	get a rotation transformation around Z-axis
Amg::Transform3D	getTranslateX3D (const double X)
	: Returns a shift transformation along the x-axis
Amg::Transform3D	getTranslateY3D (const double Y)
	: Returns a shift transformation along the y-axis
Amg::Transform3D	getTranslateZ3D (const double Z)
	: Returns a shift transformation along the z-axis
Amg::Transform3D	getTranslate3D (const double X, const double Y, const double Z)
	: Returns a shift transformation along an arbitrary axis
Amg::Transform3D	getTranslate3D (const Amg::Vector3D &v)
	: Returns a shift transformation along an arbitrary axis
Amg::Vector3D	dirFromAngles (const double phi, const double theta)
	Constructs a direction vector from the azimuthal & polar angles.
template<int N>
double	lineDistance (const AmgVector(N)&posA, const AmgVector(N)&dirA, const AmgVector(N)&posB, const AmgVector(N)&dirB)
	: Calculates the shortest distance between two lines
double	signedDistance (const Amg::Vector3D &posA, const Amg::Vector3D &dirA, const Amg::Vector3D &posB, const Amg::Vector3D &dirB)
	Calculates the signed distance between two lines in 3D space.
template<int N>
std::optional< double >	intersect (const AmgVector(N)&posA, const AmgVector(N)&dirA, const AmgVector(N)&posB, const AmgVector(N)&dirB)
	Calculates the point B' along the line B that's closest to a second line A.
template<int N>
std::optional< double >	intersect (const AmgVector(N)&pos, const AmgVector(N)&dir, const AmgVector(N)&planeNorm, const double offset)
	Intersects a line parametrized as A + lambda * B with the (N-1) dimensional hyperplane that's given in the Hesse normal form <P, N> - C = 0.
bool	doesNotDeform (const Amg::Transform3D &trans)
	Checks whether the linear part of the transformation rotates or stetches any of the basis vectors.
bool	isIdentity (const Amg::Transform3D &trans)
	Checks whether the transformation is the Identity transformation.
std::string	toString (const Translation3D &translation, int precision=4)
	GeoPrimitvesToStringConverter.
std::string	toString (const Transform3D &transform, int precision=4, const std::string &rotOffSet="")
std::string	toString (const CLHEP::HepRotation &rot, int precision=4, const std::string &offset="")
std::string	toString (const CLHEP::Hep3Vector &translation, int precision=4)
std::string	toString (const CLHEP::Hep2Vector &translation, int precision=4)
std::string	toString (const HepGeom::Transform3D &transf, int precision=4, const std::string &offset="")
bool	saneCovarianceElement (double ele)
	A covariance matrix formally needs to be positive semi definite.
template<int N>
bool	hasPositiveOrZeroDiagElems (const AmgSymMatrix(N) &mat)
	Returns true if all diagonal elements of the covariance matrix are finite aka sane in the above definition.
bool	hasPositiveOrZeroDiagElems (const Amg::MatrixX &mat)
template<int N>
bool	hasPositiveDiagElems (const AmgSymMatrix(N) &mat)
	Returns true if all diagonal elements of the covariance matrix are finite aka sane in the above definition.
bool	hasPositiveDiagElems (const Amg::MatrixX &mat)
template<int N>
bool	isPositiveSemiDefinite (const AmgSymMatrix(N) &mat)
	Check if is positive semidefinit using that fact that is needed for Cholesky decomposition.
bool	isPositiveSemiDefinite (const Amg::MatrixX &mat)
template<int N>
bool	isPositiveDefinite (const AmgSymMatrix(N) &mat)
	Check if is positive semidefinit using that fact that is needed for Cholesky decomposition.
bool	isPositiveDefinite (const Amg::MatrixX &mat)
template<int N>
bool	isPositiveSemiDefiniteSlow (const AmgSymMatrix(N) &mat)
	These are the slow test following the definition.
bool	isPositiveSemiDefiniteSlow (const Amg::MatrixX &mat)
template<int N>
bool	isPositiveDefiniteSlow (const AmgSymMatrix(N) &mat)
bool	isPositiveDefiniteSlow (const Amg::MatrixX &mat)
template<typename T, typename U>
double	chi2 (const T &precision, const U &residual, const int sign=1)
template<int N>
bool	saneVector (const AmgVector(N) &vec)
double	error (const Amg::MatrixX &mat, int index)
	return diagonal error of the matrix caller should ensure the matrix is symmetric and the index is in range
template<int N>
double	error (const AmgSymMatrix(N) &mat, int index)
constexpr int	CalculateCompressedSize (int n)
template<int N>
void	compress (const AmgSymMatrix(N) &covMatrix, std::vector< float > &vec)
void	compress (const MatrixX &covMatrix, std::vector< float > &vec)
template<int N>
void	expand (std::vector< float >::const_iterator it, std::vector< float >::const_iterator, AmgSymMatrix(N) &covMatrix)
void	expand (std::vector< float >::const_iterator it, std::vector< float >::const_iterator it_end, MatrixX &covMatrix)
template<int N>
std::pair< int, int >	compare (const AmgSymMatrix(N) &m1, const AmgSymMatrix(N) &m2, double precision=1e-9, bool relative=false)
	compare two matrices, returns the indices of the first element that fails the condition, returns <-1,-1> if all is ok Users can provide the required precision and whether the difference should be evaluate relative to the values or absolutely
template<int N>
int	compare (const AmgVector(N) &m1, const AmgVector(N) &m2, double precision=1e-9, bool relative=false)
	compare two vectors, returns the indices of the first element that fails the condition, returns <-1,-1> if all is ok Users can provide the required precision and whether the difference should be evaluate relative to the values or absolutely
double	roundWithPrecision (double val, int precision)
	EventPrimitvesToStringConverter.
std::string	toString (const MatrixX &matrix, int precision=4, const std::string &offset="")

Detailed Description

Definition of ATLAS Math & Geometry primitives (Amg)

Event primitives helper functions.

Event Primitives Covariance Helper Functions.

Geometry primitives helper functions.

This is based on the Eigen geometry module: http://eigen.tuxfamily.org/dox/group__Geometry__Module.html

Author

Robert Johannes Langenberg rober.nosp@m.t.la.nosp@m.ngenb.nosp@m.erg@.nosp@m.cern..nosp@m.ch

Andreas Salzburger Andre.nosp@m.as.S.nosp@m.alzbu.nosp@m.rger.nosp@m.@cern.nosp@m..ch

Riccardo Maria BIANCHI ricca.nosp@m.rdo..nosp@m.maria.nosp@m..bia.nosp@m.nchi@.nosp@m.cern.nosp@m..ch

Niels van Eldik

Robert Johannes Langenberg rober.nosp@m.t.la.nosp@m.ngenb.nosp@m.erg@.nosp@m.cern..nosp@m.ch

Andreas Salzburger Andre.nosp@m.as.S.nosp@m.alzbu.nosp@m.rger.nosp@m.@cern.nosp@m..ch

Christos Anastopoulos

Johannes Junggeburth

Niels van Eldik

Robert Johannes Langenberg

Andreas Salzburger

Johannes Junggeburth

Typedef Documentation

AngleAxis3D

using Amg::AngleAxis3D = Eigen::AngleAxisd

Definition at line 45 of file GeoPrimitives.h.

MatrixMaxX

template<int MaxRows, int MaxCols>

using Amg::MatrixMaxX

Initial value:

 
    Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, 0, MaxRows, MaxCols>

Fixed capacity dynamic size types.

Avoid dynamic allocations. Helpfull if we do not know the exact but a max size. But we potentially waste some space

Definition at line 36 of file EventPrimitives.h.

MatrixX

using Amg::MatrixX = Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>

Dynamic Matrix - dynamic allocation.

Definition at line 27 of file EventPrimitives.h.

Rotation3D

using Amg::Rotation3D = Eigen::Quaternion<double>

Definition at line 43 of file GeoPrimitives.h.

RotationMatrix3D

using Amg::RotationMatrix3D = Eigen::Matrix<double, 3, 3>

Definition at line 49 of file GeoPrimitives.h.

SetVector3D

using Amg::SetVector3D = std::set<Amg::Vector3D, Vector3DComparer>

Definition at line 35 of file GeoPrimitivesHelpers.h.

SetVectorVector3D

using Amg::SetVectorVector3D = std::set< std::vector< Amg::Vector3D>, VectorVector3DComparer>

Definition at line 36 of file GeoPrimitivesHelpers.h.

SymMatrixMaxX

template<int MaxDim>

using Amg::SymMatrixMaxX

Initial value:

 
    Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic, 0, MaxDim, MaxDim>

Definition at line 40 of file EventPrimitives.h.

SymMatrixX

using Amg::SymMatrixX = Eigen::Matrix<double, Eigen::Dynamic, Eigen::Dynamic>

Definition at line 28 of file EventPrimitives.h.

Transform3D

using Amg::Transform3D = Eigen::Affine3d

Definition at line 46 of file GeoPrimitives.h.

Translation3D

using Amg::Translation3D = Eigen::Translation<double, 3>

Definition at line 44 of file GeoPrimitives.h.

Vector2D

using Amg::Vector2D = Eigen::Matrix<double, 2, 1>

Definition at line 48 of file GeoPrimitives.h.

Vector3D

using Amg::Vector3D = Eigen::Matrix<double, 3, 1>

Definition at line 47 of file GeoPrimitives.h.

VectorMaxX

template<int MaxRows>

using Amg::VectorMaxX = Eigen::Matrix<double, Eigen::Dynamic, 1, 0, MaxRows, 1>

Definition at line 44 of file EventPrimitives.h.

VectorX

using Amg::VectorX = Eigen::Matrix<double, Eigen::Dynamic, 1>

Dynamic Vector - dynamic allocation.

Definition at line 30 of file EventPrimitives.h.

Enumeration Type Documentation

AxisDefs

enum Amg::AxisDefs

element for code readability

• please use these for access to the member variables if needed, e.g. double z = position[Amg::z]; double px = momentum[Amg::px];

Enumerator
x
y
z
px
py
pz

Definition at line 32 of file GeoPrimitives.h.

                  {
        // position access
        x = 0,
        y = 1,
        z = 2,
        // momentum access
        px = 0,
        py = 1,
        pz = 2
    };

Function Documentation

angle()

double Amg::angle ( const Amg::Vector3D & v1, const Amg::Vector3D & v2 )

inline

calculates the opening angle between two vectors

Definition at line 41 of file GeoPrimitivesHelpers.h.

                                                                  {
    const double dp = std::clamp(v1.dot(v2) / (v1.mag() * v2.mag()), -1. ,1.);
    return std::acos(dp);
}

AsString()

template<class T>

std::string Amg::AsString

(

const T &

m

)

write an Amg Eigen object to std::string

Definition at line 26 of file AmgStringHelpers.h.

                               {
    std::stringstream tmp;
    tmp << m; // we just use eigen classes capability to write to std::ostream
    return tmp.str();
}

CalculateCompressedSize()

int Amg::CalculateCompressedSize ( int n )

inlineconstexpr

Definition at line 51 of file EventPrimitivesHelpers.h.

                                                    {
  return (n * (n + 1)) / 2;
}

chi2()

template<typename T, typename U>

double Amg::chi2 ( const T & precision, const U & residual, const int sign = 1 )

inline

Definition at line 221 of file EventPrimitivesCovarianceHelpers.h.

                                                                              {
  return sign * residual.transpose() * precision * residual;
}

CLHEPRotationToEigen()

RotationMatrix3D Amg::CLHEPRotationToEigen ( const CLHEP::HepRotation & CLHEProtation )

inline

Converts a CLHEP::HepRotation into an Eigen-based Amg::RotationMatrix3D.

Parameters

CLHEProtation

A CLHEP::HepRotation.

Returns

An Eigen-based Amg::RotationMatrix3D.

Definition at line 63 of file CLHEPtoEigenConverter.h.

                                                   {
        Amg::RotationMatrix3D t;
 
        t(0, 0) = CLHEProtation(0, 0);
        t(0, 1) = CLHEProtation(0, 1);
        t(0, 2) = CLHEProtation(0, 2);
        t(1, 0) = CLHEProtation(1, 0);
        t(1, 1) = CLHEProtation(1, 1);
        t(1, 2) = CLHEProtation(1, 2);
        t(2, 0) = CLHEProtation(2, 0);
        t(2, 1) = CLHEProtation(2, 1);
        t(2, 2) = CLHEProtation(2, 2);
        return t;
    }

CLHEPTransformToEigen()

Amg::Transform3D Amg::CLHEPTransformToEigen ( const HepGeom::Transform3D & CLHEPtransf )

inline

Converts a CLHEP-based HepGeom::Transform3D into an Eigen Amg::Transform3D.

Parameters

CLHEPtransf

A CLHEP-based HepGeom::Transform3D.

Returns

An Eigen-based Amg::Transform3D.

Definition at line 38 of file CLHEPtoEigenConverter.h.

                                                   {
        Amg::Transform3D t = Amg::Transform3D();
        //loop unrolled for performance
        t(0, 0) = CLHEPtransf(0, 0);
        t(0, 1) = CLHEPtransf(0, 1);
        t(0, 2) = CLHEPtransf(0, 2);
        t(1, 0) = CLHEPtransf(1, 0);
        t(1, 1) = CLHEPtransf(1, 1);
        t(1, 2) = CLHEPtransf(1, 2);
        t(2, 0) = CLHEPtransf(2, 0);
        t(2, 1) = CLHEPtransf(2, 1);
        t(2, 2) = CLHEPtransf(2, 2);
        t(0, 3) = CLHEPtransf(0, 3);
        t(1, 3) = CLHEPtransf(1, 3);
        t(2, 3) = CLHEPtransf(2, 3);
        return t;
    }

CLHEPTranslate3DToEigen()

Amg::Transform3D Amg::CLHEPTranslate3DToEigen ( const HepGeom::Translate3D & CLHEPtranslate3D )

inline

Converts a CLHEP-based HepGeom::Translate3 into an Eigen-based Amg::Transform3D.

Parameters

CLHEPtranslate3D

A CLHEP-based HepGeom::Translate3.

Returns

An Eigen-based Amg::Transform3D.

Definition at line 99 of file CLHEPtoEigenConverter.h.

    {
        // from: http://proj-clhep.web.cern.ch/proj-clhep/doc/CLHEP_2_0_4_7/doxygen/html/classHepGeom_1_1Translate3D.html#f2df65781931c7df9cc2858de2c89151
        //Amg::Transform3D(1, 0, 0, CLHEPtranslate3D[0],
        //                 0, 1, 0, CLHEPtranslate3D[1],
        //                 0, 0, 1, CLHEPtranslate3D[2]);
        Amg::Transform3D t = Amg::Transform3D();
        t.setIdentity();
        t(0, 3) = CLHEPtranslate3D(0, 3);
        t(1, 3) = CLHEPtranslate3D(1, 3);
        t(2, 3) = CLHEPtranslate3D(2, 3);
        return t;
    }

CLHEPTranslationToEigen()

Amg::Translation3D Amg::CLHEPTranslationToEigen ( const CLHEP::Hep3Vector & CLHEPtranslation )

inline

Converts a CLHEP::Hep3Vector into an Eigen-based Amg::Translation3D.

Parameters

CLHEPtranslation

A CLHEP::Hep3Vector.

Returns

An Eigen-based Amg::Translation3D.

Definition at line 85 of file CLHEPtoEigenConverter.h.

                                                     {
        return Amg::Translation3D(
                Vector3D(CLHEPtranslation[0], CLHEPtranslation[1],
                        CLHEPtranslation[2]));
    }

compare() [1/2]

template<int N>

std::pair< int, int > Amg::compare	(	const AmgSymMatrix(N) &	m1,
		const AmgSymMatrix(N) &	m2,
		double	precision = 1e-9,
		bool	relative = false )

compare two matrices, returns the indices of the first element that fails the condition, returns <-1,-1> if all is ok Users can provide the required precision and whether the difference should be evaluate relative to the values or absolutely

Definition at line 109 of file EventPrimitivesHelpers.h.

                                                   {
  for (int i = 0; i < N; ++i) {
    for (int j = 0; j < N; ++j) {
      if (relative) {
        if (0.5 * std::abs(m1(i, j) - m2(i, j)) / (m1(i, j) + m2(i, j)) >
            precision) {
          return std::make_pair(i, j);
        }
      } else {
        if (std::abs(m1(i, j) - m2(i, j)) > precision) {
          return std::make_pair(i, j);
        }
      }
    }
  }
  return std::make_pair(-1, -1);
}

compare() [2/2]

template<int N>

int Amg::compare	(	const AmgVector(N) &	m1,
		const AmgVector(N) &	m2,
		double	precision = 1e-9,
		bool	relative = false )

compare two vectors, returns the indices of the first element that fails the condition, returns <-1,-1> if all is ok Users can provide the required precision and whether the difference should be evaluate relative to the values or absolutely

Definition at line 135 of file EventPrimitivesHelpers.h.

                                                            {
  for (int i = 0; i < N; ++i) {
    if (relative) {
      if (0.5 * std::abs(m1(i) - m2(i)) / (m1(i) + m2(i)) > precision)
        return i;
    } else {
      if (std::abs(m1(i) - m2(i)) > precision)
        return i;
    }
  }
  return -1;
}

compress() [1/2]

template<int N>

void Amg::compress ( const AmgSymMatrix(N) & covMatrix, std::vector< float > & vec )

inline

Definition at line 56 of file EventPrimitivesHelpers.h.

                                            {
  vec.reserve(CalculateCompressedSize(N));
  for (unsigned int i = 0; i < N; ++i)
    for (unsigned int j = 0; j <= i; ++j)
      vec.emplace_back(covMatrix(i, j));
}

compress() [2/2]

void Amg::compress ( const MatrixX & covMatrix, std::vector< float > & vec )

inline

Definition at line 64 of file EventPrimitivesHelpers.h.

                                                                      {
  int rows = covMatrix.rows();
  vec.reserve(CalculateCompressedSize(rows));
  for (int i = 0; i < rows; ++i) {
    for (int j = 0; j <= i; ++j) {
      vec.emplace_back(covMatrix(i, j));
    }
  }
}

convert_CLHEPPhiThetaPsi_to_EigenEulerAngles()

Amg::Vector3D Amg::convert_CLHEPPhiThetaPsi_to_EigenEulerAngles ( Amg::Vector3D clhep_angles, int convention = 0 )

inline

Convert CLEHP Phi,Theta,Psi angles to Eigen euler angles using Z-X-Z convention.

N.B. if "convention = 0" --> "Z-X-Z" convention ==> DEFAULT!! if "convention = 1" --> "Z-Y-Z"

Definition at line 34 of file CLHEPtoEigenEulerAnglesConverters.h.

{
    Amg::Vector3D eigen_angles;
 
    // using Z-X-Z convention (CLHEP): (2,0,2) == "Z,X,Z". // DEFAULT
    if (convention == 0) {
        eigen_angles(2) = -clhep_angles(0); // Phi-->Z
        eigen_angles(1) = -clhep_angles(1); // Theta-->X
        eigen_angles(0) = -clhep_angles(2); // Psi-->Z
    }
    // using Z-Y-Z convention: (2,1,2) == "Z,Y,Z"
    else {
        eigen_angles(0) = -0.5 * clhep_angles(0); // Phi-->Z
        eigen_angles(1) = clhep_angles(1); // Theta-->Y
        eigen_angles(2) = clhep_angles(2); // Psi-->Z
    }
 
    return eigen_angles;
}

convert_EigenEulerAngles_to_CLHEPPhiThetaPsi()

Amg::Vector3D Amg::convert_EigenEulerAngles_to_CLHEPPhiThetaPsi ( Amg::Vector3D eigen_angles, int convention = 0 )

inline

Convert Eigen euler angles to CLEHP Phi,Theta,Psi angles.

N.B. if "convention = 0" --> "Z-X-Z" convention ==> DEFAULT!! if "convention = 1" --> "Z-Y-Z" convention

Note: as explained in: eigen / Eigen / src / Geometry / EulerAngles.h the returned angles are in the ranges [0:pi]x[-pi:pi]x[-pi:pi]

(source here: https://bitbucket.org/eigen/eigen/src/42e011583bceb055a43fa688622e828fbbabf818/Eigen/src/Geometry/EulerAngles.h)

N.B.!! CLHEP's Phi, Theta, Psi correspond to eulerAngles[2], [1] and [0] respectively, with the sign inverted.

Definition at line 62 of file CLHEPtoEigenEulerAnglesConverters.h.

{
    Amg::Vector3D clhep_angles;
 
    double phi;
    double theta;
    double psi;

    // using Z-X-Z convention: (2,0,2) == "Z,X,Z".  // DEFAULT
    if (convention == 0) {
        phi   = -eigen_angles(2); // Z-->Phi
        theta = -eigen_angles(1); // X-->Theta
        psi   = -eigen_angles(0); // Z-->Psi
    }
    // using Z-Y-Z convention: (2,1,2) == "Z,Y,Z"
    else {
        phi   = -2 * eigen_angles(0); // Z-->Phi
        theta = eigen_angles(1); // Y-->Theta
        psi   = eigen_angles(2); // Z-->Psi
    }
 
    clhep_angles(0) = phi;
    clhep_angles(1) = theta;
    clhep_angles(2) = psi;
 
    return clhep_angles;
 
}

deltaPhi()

double Amg::deltaPhi ( const Amg::Vector3D & v1, const Amg::Vector3D & v2 )

inline

Definition at line 113 of file GeoPrimitivesHelpers.h.

                                                                     {
    double dphi = v2.phi() - v1.phi();
    if (dphi > M_PI) {
        dphi -= M_PI*2;
    } else if (dphi <= -M_PI) {
        dphi += M_PI*2;
    }
    return dphi;
}

deltaR()

double Amg::deltaR ( const Amg::Vector3D & v1, const Amg::Vector3D & v2 )

inline

Definition at line 122 of file GeoPrimitivesHelpers.h.

                                                                  {
    double a = v1.eta() - v2.eta();
    double b = deltaPhi(v1,v2);
    return sqrt(a*a + b*b);
}

dirFromAngles()

Amg::Vector3D Amg::dirFromAngles ( const double phi, const double theta )

inline

Constructs a direction vector from the azimuthal & polar angles.

Parameters

phi	Polar angle in the x-y plane
theta	Azimuthal angle in the r-z plane

Definition at line 299 of file GeoPrimitivesHelpers.h.

                                                                       {
    const CxxUtils::sincos thetaCS{theta}, phiCS{phi};
    return Amg::Vector3D{phiCS.cs * thetaCS.sn, phiCS.sn* thetaCS.sn, thetaCS.cs};
}

distance()

float Amg::distance ( const Amg::Vector3D & p1, const Amg::Vector3D & p2 )

inline

calculates the distance between two point in 3D space

Definition at line 54 of file GeoPrimitivesHelpers.h.

                                                                    {
    return std::sqrt( distance2(p1, p2) );
}

distance2()

float Amg::distance2 ( const Amg::Vector3D & p1, const Amg::Vector3D & p2 )

inline

calculates the squared distance between two point in 3D space

Definition at line 48 of file GeoPrimitivesHelpers.h.

                                                                     {
    float dx = p2.x()-p1.x(), dy = p2.y()-p1.y(), dz = p2.z()-p1.z();
    return dx*dx + dy*dy + dz*dz;
}

doesNotDeform()

bool Amg::doesNotDeform ( const Amg::Transform3D & trans )

inline

Checks whether the linear part of the transformation rotates or stetches any of the basis vectors.

Definition at line 383 of file GeoPrimitivesHelpers.h.

                                                       {
    for (unsigned int d = 0; d < 3 ; ++d) {
        const double defLength = Amg::Vector3D::Unit(d).dot(trans.linear() * Amg::Vector3D::Unit(d));
        if (std::abs(defLength - 1.) > std::numeric_limits<float>::epsilon()) {
            return false;
        }
    }
    return true;
}

EigenToHep3Vector()

CLHEP::Hep3Vector Amg::EigenToHep3Vector ( const Amg::Vector3D & eigenvector )

inline

Converts an Eigen-based Amg::Vector3D into a CLHEP-based CLHEP::Hep3Vector.

Parameters

eigenvector

An Eigen-based Amg::Vector3D.

Returns

A CLHEP-based CLHEP::Hep3Vector.

Definition at line 147 of file CLHEPtoEigenConverter.h.

                                                                             {
        return CLHEP::Hep3Vector(eigenvector[0], eigenvector[1], eigenvector[2]);
    }

EigenTransformToCLHEP()

HepGeom::Transform3D Amg::EigenTransformToCLHEP ( const Amg::Transform3D & eigenTransf )

inline

Converts an Eigen-based Amg::Transform3D into a CLHEP-based HepGeom::Transform3D.

Parameters

eigenTransf

An Eigen-based Amg::Transform3D.

Returns

A CLHEP-based HepGeom::Transform3D.

Definition at line 120 of file CLHEPtoEigenConverter.h.

                                               {
        CLHEP::HepRotation rotation(
                CLHEP::Hep3Vector(eigenTransf(0, 0), eigenTransf(1, 0), eigenTransf(2, 0)),
                CLHEP::Hep3Vector(eigenTransf(0, 1), eigenTransf(1, 1), eigenTransf(2, 1)),
                CLHEP::Hep3Vector(eigenTransf(0, 2), eigenTransf(1, 2), eigenTransf(2, 2)));
        CLHEP::Hep3Vector translation(eigenTransf(0, 3), eigenTransf(1, 3), eigenTransf(2, 3));
        HepGeom::Transform3D t(rotation, translation);
        return t;
    }

error() [1/2]

double Amg::error ( const Amg::MatrixX & mat, int index )

inline

return diagonal error of the matrix caller should ensure the matrix is symmetric and the index is in range

Definition at line 40 of file EventPrimitivesHelpers.h.

                                                      {
  return std::sqrt(mat(index, index));
}

error() [2/2]

template<int N>

double Amg::error ( const AmgSymMatrix(N) & mat, int index )

inline

Definition at line 44 of file EventPrimitivesHelpers.h.

                                                            {
  assert(index < N);
  return std::sqrt(mat(index, index));
}

expand() [1/2]

void Amg::expand ( std::vector< float >::const_iterator it, std::vector< float >::const_iterator it_end, MatrixX & covMatrix )

inline

Definition at line 86 of file EventPrimitivesHelpers.h.

                                       {
  unsigned int dist = std::distance(it, it_end);
  unsigned int n;
  for (n = 1; dist > n; ++n) {
    dist = dist - n;
  }
  covMatrix = MatrixX(n, n);
  for (unsigned int i = 0; i < n; ++i) {
    for (unsigned int j = 0; j <= i; ++j) {
      covMatrix.fillSymmetric(i, j, *it);
      ++it;
    }
  }
}

expand() [2/2]

template<int N>

void Amg::expand ( std::vector< float >::const_iterator it, std::vector< float >::const_iterator , AmgSymMatrix(N) & covMatrix )

inline

Definition at line 75 of file EventPrimitivesHelpers.h.

                                                {
  for (unsigned int i = 0; i < N; ++i) {
    for (unsigned int j = 0; j <= i; ++j) {
      covMatrix.fillSymmetric(i, j, *it);
      ++it;
    }
  }
}

getAngleAxisFromRotation()

void Amg::getAngleAxisFromRotation ( Amg::RotationMatrix3D & rotation, double & rotationAngle, Amg::Vector3D & rotationAxis )

inline

Definition at line 192 of file GeoPrimitivesHelpers.h.

{
    rotationAngle = 0.;
 
    double xx = rotation(0,0);
    double yy = rotation(1,1);
    double zz = rotation(2,2);
 
    double cosa  = 0.5 * (xx + yy + zz - 1);
    double cosa1 = 1 - cosa;
 
    if (cosa1 <= 0) {
        rotationAngle = 0;
        rotationAxis  = Amg::Vector3D(0,0,1);
    }
    else{
        double x=0, y=0, z=0;
        if (xx > cosa) x = std::sqrt((xx-cosa)/cosa1);
        if (yy > cosa) y = std::sqrt((yy-cosa)/cosa1);
        if (zz > cosa) z = std::sqrt((zz-cosa)/cosa1);
        if (rotation(2,1) < rotation(1,2)) x = -x;
        if (rotation(0,2) < rotation(2,0)) y = -y;
        if (rotation(1,0) < rotation(0,1)) z = -z;
        rotationAngle = (cosa < -1.) ? std::acos(-1.) : std::acos(cosa);
        rotationAxis  = Amg::Vector3D(x,y,z);
    }
 
    return;
}

getPhiThetaPsi()

Amg::Vector3D Amg::getPhiThetaPsi ( Amg::RotationMatrix3D mat, int convention = 0 )

inline

Get the equivalents to CLHEP Phi, Theta, Psi Euler angles.

phi = vector[0] theta = vector[1] psi = vector[2]

N.B. if "convention = 0" --> "Z-X-Z" convention ==> DEFAULT!! if "convention = 1" --> "Z-Y-Z" convention

N.B.!! for normal usage, use the default notation (simply leave it empty, or use convention=0), or, alternatively, be sure to use the same convention in both setPhi() and getPhiThetaPsi().

we extract the Euler Angles from the Eigen matrix,

Definition at line 41 of file EulerAnglesHelpers.h.

{
    double phi;
    double theta;
    double psi;
 
    Amg::Vector3D ea; // euler angles vector

    // using Z-X-Z convention: (2,0,2) == "Z,X,Z"
    if (convention == 0) {
        ea = mat.eulerAngles(2, 0, 2); // (using Z-X-Z convention) // DEFAULT
    }
    // using Z-Y-Z convention: (2,1,2) == "Z,Y,Z"
    else {
        ea = mat.eulerAngles(2, 1, 2); // (using Z-Y-Z convention)
    }
 
    // convert the values from Eigen convention to CLHEP convention
    ea = convert_EigenEulerAngles_to_CLHEPPhiThetaPsi( ea, convention );
 
    phi = ea[0];
    theta = ea[1];
    psi = ea[2];
 
    Amg::Vector3D phiThetaPsi_angles;
    phiThetaPsi_angles(0) = phi;
    phiThetaPsi_angles(1) = theta;
    phiThetaPsi_angles(2) = psi;
 
    return phiThetaPsi_angles;
 
} // end of getPhiThetaPsi()

getRotateX3D()

Amg::Transform3D Amg::getRotateX3D ( double angle )

inline

get a rotation transformation around X-axis

Definition at line 252 of file GeoPrimitivesHelpers.h.

                                                 {
    Amg::Transform3D transf;
    Amg::AngleAxis3D angleaxis(angle, Amg::Vector3D::UnitX());
    transf = angleaxis;
    return transf;
}

getRotateY3D()

Amg::Transform3D Amg::getRotateY3D ( double angle )

inline

get a rotation transformation around Y-axis

Definition at line 261 of file GeoPrimitivesHelpers.h.

                                                 {
    Amg::Transform3D transf;
    Amg::AngleAxis3D angleaxis(angle, Amg::Vector3D::UnitY());
    transf = angleaxis;
    return transf;
}

getRotateZ3D()

Amg::Transform3D Amg::getRotateZ3D ( double angle )

inline

get a rotation transformation around Z-axis

Definition at line 270 of file GeoPrimitivesHelpers.h.

                                                 {
    Amg::Transform3D transf;
    Amg::AngleAxis3D angleaxis(angle, Amg::Vector3D::UnitZ());
    transf = angleaxis;
    return transf;
}

getRotation3DfromAngleAxis()

Amg::Rotation3D Amg::getRotation3DfromAngleAxis ( double angle, Amg::Vector3D & axis )

inline

get a AngleAxis from an angle and an axis.

to replace the CLHEP constructor: CLHEP::Rotate3D::Rotate3D(double a, cconst Vector3D< double > & v)

Definition at line 237 of file GeoPrimitivesHelpers.h.

{
    AngleAxis3D t;
    t = Eigen::AngleAxis<double>(angle,axis);
 
    Amg::Rotation3D rot;
    rot = t;
 
    return rot;
}

getTransformFromRotTransl()

Amg::Transform3D Amg::getTransformFromRotTransl ( Amg::RotationMatrix3D rot, Amg::Vector3D transl_vec )

inline

Definition at line 172 of file GeoPrimitivesHelpers.h.

{
    Amg::Transform3D trans = Amg::Transform3D::Identity();
    trans = trans * rot;
    trans.translation() = transl_vec;
    return trans;
}

getTranslate3D() [1/2]

Amg::Transform3D Amg::getTranslate3D ( const Amg::Vector3D & v )

inline

: Returns a shift transformation along an arbitrary axis

Definition at line 293 of file GeoPrimitivesHelpers.h.

                                                           {
    return Amg::Transform3D{Amg::Translation3D{v}};
}

getTranslate3D() [2/2]

Amg::Transform3D Amg::getTranslate3D ( const double X, const double Y, const double Z )

inline

: Returns a shift transformation along an arbitrary axis

Definition at line 289 of file GeoPrimitivesHelpers.h.

                                                                                     {
    return getTranslateX3D(X) * getTranslateY3D(Y) * getTranslateZ3D(Z);
}

getTranslateX3D()

Amg::Transform3D Amg::getTranslateX3D ( const double X )

inline

: Returns a shift transformation along the x-axis

Definition at line 277 of file GeoPrimitivesHelpers.h.

                                                      {
    return Amg::Transform3D{Amg::Translation3D{X * Amg::Vector3D::UnitX()}};
}

getTranslateY3D()

Amg::Transform3D Amg::getTranslateY3D ( const double Y )

inline

: Returns a shift transformation along the y-axis

Definition at line 281 of file GeoPrimitivesHelpers.h.

                                                      {
    return Amg::Transform3D{Amg::Translation3D{Y * Amg::Vector3D::UnitY()}};
}

getTranslateZ3D()

Amg::Transform3D Amg::getTranslateZ3D ( const double Z )

inline

: Returns a shift transformation along the z-axis

Definition at line 285 of file GeoPrimitivesHelpers.h.

                                                      {
    return Amg::Transform3D{Amg::Translation3D{Z * Amg::Vector3D::UnitZ()}};
}

getTranslationVectorFromTransform()

Amg::Vector3D Amg::getTranslationVectorFromTransform ( const Amg::Transform3D & tr )

inline

Get the Translation vector out of a Transformation.

Definition at line 225 of file GeoPrimitivesHelpers.h.

                                                                               {
    return Amg::Vector3D(tr(0,3),tr(1,3),tr(2,3));
} // TODO: check! it's perhaps useless, you acn use the transform.translation() method

hasPositiveDiagElems() [1/2]

bool Amg::hasPositiveDiagElems ( const Amg::MatrixX & mat )

inline

Definition at line 105 of file EventPrimitivesCovarianceHelpers.h.

                                                        {
  constexpr double MIN_COV_EPSILON = std::numeric_limits<float>::min();
  int dim = mat.rows();
  for (int i = 0; i < dim; ++i) {
    if (mat(i, i) < MIN_COV_EPSILON || !saneCovarianceElement(mat(i, i)))
      return false;
  }
  return true;
}

hasPositiveDiagElems() [2/2]

template<int N>

bool Amg::hasPositiveDiagElems ( const AmgSymMatrix(N) & mat )

inline

Returns true if all diagonal elements of the covariance matrix are finite aka sane in the above definition.

And positive. Instead of just positive we check that we are above the float epsilon

Definition at line 96 of file EventPrimitivesCovarianceHelpers.h.

                                                              {
  constexpr double MIN_COV_EPSILON = std::numeric_limits<float>::min();
  constexpr int dim = N;
  for (int i = 0; i < dim; ++i) {
    if (mat(i, i) < MIN_COV_EPSILON || !saneCovarianceElement(mat(i, i)))
      return false;
  }
  return true;
}

hasPositiveOrZeroDiagElems() [1/2]

bool Amg::hasPositiveOrZeroDiagElems ( const Amg::MatrixX & mat )

inline

Definition at line 82 of file EventPrimitivesCovarianceHelpers.h.

                                                              {
  int dim = mat.rows();
  for (int i = 0; i < dim; ++i) {
    if (mat(i, i) < 0.0 || !saneCovarianceElement(mat(i, i)))
      return false;
  }
  return true;
}

hasPositiveOrZeroDiagElems() [2/2]

template<int N>

bool Amg::hasPositiveOrZeroDiagElems ( const AmgSymMatrix(N) & mat )

inline

Returns true if all diagonal elements of the covariance matrix are finite aka sane in the above definition.

And equal or greater than 0.

Definition at line 73 of file EventPrimitivesCovarianceHelpers.h.

                                                                    {
  constexpr int dim = N;
  for (int i = 0; i < dim; ++i) {
    if (mat(i, i) < 0.0 || !saneCovarianceElement(mat(i, i)))
      return false;
  }
  return true;
}

Hep3VectorToEigen()

Amg::Vector3D Amg::Hep3VectorToEigen ( const CLHEP::Hep3Vector & CLHEPvector )

inline

Converts a CLHEP-based CLHEP::Hep3Vector into an Eigen-based Amg::Vector3D.

Parameters

CLHEPvector

A CLHEP-based CLHEP::Hep3Vector.

Returns

An Eigen-based Amg::Vector3D.

Definition at line 137 of file CLHEPtoEigenConverter.h.

                                                                             {
        return Amg::Vector3D(CLHEPvector[0], CLHEPvector[1], CLHEPvector[2]);
    }

intersect() [1/2]

template<int N>

std::optional< double > Amg::intersect	(	const AmgVector(N)&	pos,
		const AmgVector(N)&	dir,
		const AmgVector(N)&	planeNorm,
		const double	offset )

Intersects a line parametrized as A + lambda * B with the (N-1) dimensional hyperplane that's given in the Hesse normal form <P, N> - C = 0.

<P, N> - C = 0 --> <A + lambda *B , N> - C = 0 --> lambda = (C - <A,N> ) / <N, B>

Definition at line 369 of file GeoPrimitivesHelpers.h.

                                                     {
    const double normDot = planeNorm.dot(dir); 
    if (std::abs(normDot) < std::numeric_limits<double>::epsilon()) return std::nullopt;
    return (offset - pos.dot(planeNorm)) / normDot;
}

intersect() [2/2]

template<int N>

std::optional< double > Amg::intersect	(	const AmgVector(N)&	posA,
		const AmgVector(N)&	dirA,
		const AmgVector(N)&	posB,
		const AmgVector(N)&	dirB )

Calculates the point B' along the line B that's closest to a second line A.

Parameters

posA	offset point of line A
dirA	orientation of line A (unit length)
posB	offset point of line B
dirB	orientation of line B (unit length)

Use the formula A + lambda dirA = B + mu dirB (A-B) + lambda dirA = mu dirB <A-B, dirB> + lambda <dirA,dirB> = mu A + lambda dirA = B + (<A-B, dirB> + lambda <dirA,dirB>)dirB <A-B,dirA> + lambda <dirA, dirA> = <A-B, dirB><dirA,dirB> + lamda<dirA,dirB><dirA,dirB> -> lambda = -(<A-B, dirA> - <A-B, dirB> * <dirA, dirB>) / (1- <dirA,dirB>^2) --> mu = (<A-B, dirB> - <A-B, dirA> * <dirA, dirB>) / (1- <dirA,dirB>^2)

If the two directions are parallel to each other there's no way of intersection

Definition at line 347 of file GeoPrimitivesHelpers.h.

                                                                           {
    const double dirDots = dirA.dot(dirB);
    const double divisor = (1. - dirDots * dirDots);
    if (std::abs(divisor) < std::numeric_limits<double>::epsilon()) return std::nullopt;
    const AmgVector(N) AminusB = posA - posB;
    return (AminusB.dot(dirB) - AminusB.dot(dirA) * dirDots) / divisor;
}

isIdentity()

bool Amg::isIdentity ( const Amg::Transform3D & trans )

inline

Checks whether the transformation is the Identity transformation.

Definition at line 393 of file GeoPrimitivesHelpers.h.

                                                    {
    return doesNotDeform(trans) && 
           trans.translation().mag() < std::numeric_limits<float>::epsilon();
}

isPositiveDefinite() [1/2]

bool Amg::isPositiveDefinite ( const Amg::MatrixX & mat )

inline

Definition at line 146 of file EventPrimitivesCovarianceHelpers.h.

                                                      {
  if (!hasPositiveDiagElems(mat)) {
    // fast check for necessary condition
    return false;
  }
  Eigen::LLT<Amg::MatrixX> lltCov(mat);
  return (lltCov.info() == Eigen::Success);
}

isPositiveDefinite() [2/2]

template<int N>

bool Amg::isPositiveDefinite ( const AmgSymMatrix(N) & mat )

inline

Check if is positive semidefinit using that fact that is needed for Cholesky decomposition.

We use LLT from Eigen

Definition at line 138 of file EventPrimitivesCovarianceHelpers.h.

                                                            {
  if (!hasPositiveDiagElems(mat)) {
    // fast check for necessary condition
    return false;
  }
  Eigen::LLT<AmgSymMatrix(N)> lltCov(mat);
  return (lltCov.info() == Eigen::Success);
}

isPositiveDefiniteSlow() [1/2]

bool Amg::isPositiveDefiniteSlow ( const Amg::MatrixX & mat )

inline

Definition at line 202 of file EventPrimitivesCovarianceHelpers.h.

                                                          {
  if (!hasPositiveDiagElems(mat)) {
    // fast check for necessary condition
    return false;
  }
  Eigen::SelfAdjointEigenSolver<Amg::MatrixX> eigensolver(mat);
  auto res = eigensolver.eigenvalues();
  int dim = mat.rows();
  for (int i = 0; i < dim; ++i) {
    if (res[i] <= 0) {
      return false;
    }
  }
  return true;
}

isPositiveDefiniteSlow() [2/2]

template<int N>

bool Amg::isPositiveDefiniteSlow ( const AmgSymMatrix(N) & mat )

inline

Definition at line 188 of file EventPrimitivesCovarianceHelpers.h.

                                                                {
  if (!hasPositiveDiagElems(mat)) {
    // fast check for necessary condition
    return false;
  }
  Eigen::SelfAdjointEigenSolver<AmgSymMatrix(5)> eigensolver(mat);
  auto res = eigensolver.eigenvalues();
  for (size_t i = 0; i < N; ++i) {
    if (res[i] <= 0) {
      return false;
    }
  }
  return true;
}

isPositiveSemiDefinite() [1/2]

bool Amg::isPositiveSemiDefinite ( const Amg::MatrixX & mat )

inline

Definition at line 126 of file EventPrimitivesCovarianceHelpers.h.

                                                          {
  if (!hasPositiveOrZeroDiagElems(mat)) {
    // fast check for necessary condition
    return false;
  }
  Eigen::LDLT<Amg::MatrixX> ldltCov(mat);
  return (ldltCov.info() == Eigen::Success && ldltCov.isPositive());
}

isPositiveSemiDefinite() [2/2]

template<int N>

bool Amg::isPositiveSemiDefinite ( const AmgSymMatrix(N) & mat )

inline

Check if is positive semidefinit using that fact that is needed for Cholesky decomposition.

We have to use LDLT from Eigen

Definition at line 118 of file EventPrimitivesCovarianceHelpers.h.

                                                                {
  if (!hasPositiveOrZeroDiagElems(mat)) {
    // fast check for necessary condition
    return false;
  }
  Eigen::LDLT<AmgSymMatrix(N)> ldltCov(mat);
  return (ldltCov.info() == Eigen::Success && ldltCov.isPositive());
}

isPositiveSemiDefiniteSlow() [1/2]

bool Amg::isPositiveSemiDefiniteSlow ( const Amg::MatrixX & mat )

inline

Definition at line 172 of file EventPrimitivesCovarianceHelpers.h.

                                                              {
  if (!hasPositiveOrZeroDiagElems(mat)) {
    // fast check for necessary condition
    return false;
  }
  Eigen::SelfAdjointEigenSolver<Amg::MatrixX> eigensolver(mat);
  auto res = eigensolver.eigenvalues();
  int dim = mat.rows();
  for (int i = 0; i < dim; ++i) {
    if (res[i] < 0) {
      return false;
    }
  }
  return true;
}

isPositiveSemiDefiniteSlow() [2/2]

template<int N>

bool Amg::isPositiveSemiDefiniteSlow ( const AmgSymMatrix(N) & mat )

inline

These are the slow test following the definition.

Indented mainly for testing/

Definition at line 158 of file EventPrimitivesCovarianceHelpers.h.

                                                                    {
  if (!hasPositiveOrZeroDiagElems(mat)) {
    // fast check for necessary condition
    return false;
  }
  Eigen::SelfAdjointEigenSolver<AmgSymMatrix(5)> eigensolver(mat);
  auto res = eigensolver.eigenvalues();
  for (size_t i = 0; i < N; ++i) {
    if (res[i] < 0) {
      return false;
    }
  }
  return true;
}

lineDistance()

template<int N>

double Amg::lineDistance	(	const AmgVector(N)&	posA,
		const AmgVector(N)&	dirA,
		const AmgVector(N)&	posB,
		const AmgVector(N)&	dirB )

: Calculates the shortest distance between two lines

Parameters

posA	offset point of line A
dirA	orientation of line A (unit length)
posB	offset point of line B
dirB	orientation of line B (unit length)

Definition at line 308 of file GeoPrimitivesHelpers.h.

                                                              {
 
    const double dirDots = dirA.dot(dirB);
    const double divisor = (1. - dirDots * dirDots);
    const AmgVector(N) AminusB = posA - posB;
    if (std::abs(divisor) < std::numeric_limits<double>::epsilon()) {
        const AmgVector(N) d = AminusB - dirA.dot(AminusB)*dirA;
        return std::sqrt(d.dot(d));
    }
    const AmgVector(N) lineTravel = AminusB.dot(dirA) * dirA -
                                    AminusB.dot(dirB) * dirB;
    return std::sqrt(std::max(0., AminusB.dot(AminusB) - lineTravel.dot(lineTravel) / divisor));
}

mag2Vector3D()

double Amg::mag2Vector3D ( const Amg::Vector3D & v1 )

inline

Gets magnitude squared of the vector.

Definition at line 140 of file GeoPrimitivesHelpers.h.

{ return v1.x()*v1.x() + v1.y()*v1.y() + v1.z()*v1.z(); }

magVector3D()

double Amg::magVector3D ( const Amg::Vector3D & v1 )

inline

Gets magnitude of the vector.

Definition at line 144 of file GeoPrimitivesHelpers.h.

{ return std::sqrt(mag2Vector3D(v1)); }

roundWithPrecision()

double Amg::roundWithPrecision ( double val, int precision )

inline

EventPrimitvesToStringConverter.

inline methods for conversion of EventPrimitives (Matrix) to std::string.

This is to enhance formatted screen ouput and for ASCII based testing.

The offset can be used to offset the lines (starting from line 2) wrt to the zero position for formatting reasons.

Author

Niels.nosp@m..Van.nosp@m..Eldi.nosp@m.k@ce.nosp@m.rn.ch

Definition at line 35 of file EventPrimitivesToStringConverter.h.

                                                            {
  if (val < 0 && std::abs(val) * std::pow(10, precision) < 1.)
    return -val;
  return val;
}

rVector3D()

double Amg::rVector3D ( const Amg::Vector3D & v1 )

inline

Gets r-component in spherical coordinate system.

Definition at line 148 of file GeoPrimitivesHelpers.h.

{ return magVector3D(v1); }

saneCovarianceElement()

bool Amg::saneCovarianceElement ( double ele )

inline

A covariance matrix formally needs to be positive semi definite.

Not positive definite just positive semi definite.

A symmetric matrix M with real entries is positive-definite if the real number x^T M x is positive for every nonzero real column vector x. Positive-semidefinite means x^T M x non zero for every nonzero real column vector x

A symmetric matrix is positive semidefinite if all its eigenvalues are non negative.

A symmetric matrix is positive definite if all its eigenvalues are positive

Positive Definite and Positive Semi Definit matrices Have a Cholesky decomposition. The Positive (semi) definiteness is a necessary and sufficient condition

A positive (semi)-definite matrix can not have non-positive (negative) diagonal elements. If A_ii < 0 we could choose an x vector with all entries 0 bar x_i and the x^T M x would be negative.

Having positive (positive or 0) diagonal elements is necessary but not sufficient condition. As we could have positive diagonal elements and have a vector x that still could result in x^T M x being negative. Matrix A in the test shows this issue

What follows are methods to check for these

We can

• Just check for the necessary condition (relatively fast)
• Check using Cholosky decomposition (still not too slow)
• Solve for all eigenvalues and check none is zero (slow) Avoid nan, inf, and elements above float max

Definition at line 63 of file EventPrimitivesCovarianceHelpers.h.

                                              {
  constexpr double upper_covariance_cutoff = std::numeric_limits<float>::max();
  return !(std::isnan(ele) || std::isinf(ele) ||
           std::abs(ele) > upper_covariance_cutoff);
}

saneVector()

template<int N>

bool Amg::saneVector ( const AmgVector(N) & vec )

inline

Definition at line 28 of file EventPrimitivesHelpers.h.

                                                 {
  for (int i = 0; i < N; ++i) {
    if (std::isnan(vec[i]) || std::isinf(vec[i]))
      return false;
  }
  constexpr double max_length2 = 1.e16;
  return vec.dot(vec) < max_length2;
}

setMag()

void Amg::setMag ( Amg::Vector3D & v, double mag )

inline

scales the vector length without changing the angles

Definition at line 104 of file GeoPrimitivesHelpers.h.

                                               {
    double p = v.mag();
    if (p != 0.0) {
        double scale = mag / p;
        v[0] *= scale;
        v[1] *= scale;
        v[2] *= scale;
    }
}

setPerp()

void Amg::setPerp ( Amg::Vector3D & v, double perp )

inline

scales the vector in the xy plane without changing the z coordinate nor the angles

Definition at line 94 of file GeoPrimitivesHelpers.h.

                                                 {
    double p = v.perp();
    if (p != 0.0) {
        double scale = perp / p;
        v[0] *= scale;
        v[1] *= scale;
    }
}

setPhi() [1/2]

Amg::RotationMatrix3D Amg::setPhi ( Amg::RotationMatrix3D mat, double angle, int convention = 0 )

inline

Definition at line 102 of file EulerAnglesHelpers.h.

{
 
 
    Amg::Vector3D phi_theta_psi;
 
 
    // using Z-X-Z convention: (2,0,2) == "Z,X,Z". ==>  DEFAULT!
    if (convention == 0) {
        phi_theta_psi = getPhiThetaPsi(mat, 0); // using Z-X-Z ((2,0,2) convention // DEFAULT
    }
    else { // using Z-Y-Z convention: (2,1,2) == "Z,Y,Z"
        phi_theta_psi = getPhiThetaPsi(mat, 1); // using Z-Y-Z ((2,1,2) convention
    }
 
    double phi = phi_theta_psi(0);
    double theta = phi_theta_psi(1);
    double psi = phi_theta_psi(2);
 
 
    /*
     * set a new Phi angle, from user's settings
     */
    phi = angle;
 
    /*
     * get Eigen Euler angles from CLEHP style Phi, Theta, Psi
     */
    Amg::Vector3D clhep_phiThetaPsi(phi, theta, psi); // a vector with CLHEP angles
    Amg::Vector3D eigen_euler_angles;
    // converting the CLHEP angles to Eigen angles
    if (convention == 0) { // using Z-X-Z convention: (2,0,2) == "Z,X,Z". ==>  DEFAULT!
        eigen_euler_angles = convert_CLHEPPhiThetaPsi_to_EigenEulerAngles(clhep_phiThetaPsi, 0); // using Z-X-Z ((2,0,2) convention // DEFAULT
    }
    else { // using Z-Y-Z convention: (2,1,2) == "Z,Y,Z"
        eigen_euler_angles = convert_CLHEPPhiThetaPsi_to_EigenEulerAngles(clhep_phiThetaPsi, 1); // using Z-Y-Z ((2,1,2) convention
    }
 
    /*
     * create a new rotation matrix from AngleAxis
     *
     * N.B.!!
     * to match CLHEP results,
     * we have to invert the order of the rotation operations,
     * compared to the order in CLHEP.
     * The matrix here below is equal to:
     * ---
     * CLHEP::HepRotation localRot;
     * localRot.rotateZ(angC);
     * localRot.rotateY(angB);
     * localRot.rotateZ(angA);
     * ---
     *
     */
 
    if (convention == 0) { // using Z-X-Z convention: (2,0,2) == "Z,X,Z". ==>  DEFAULT!
        mat = Amg::AngleAxis3D(eigen_euler_angles(0), Amg::Vector3D::UnitZ())
        * Amg::AngleAxis3D(eigen_euler_angles(1), Amg::Vector3D::UnitX())
        * Amg::AngleAxis3D(eigen_euler_angles(2), Amg::Vector3D::UnitZ());
    }
    else { // using Z-Y-Z convention: (2,1,2) == "Z,Y,Z"
        mat = Amg::AngleAxis3D(eigen_euler_angles(0), Amg::Vector3D::UnitZ())
        * Amg::AngleAxis3D(eigen_euler_angles(1), Amg::Vector3D::UnitY())
        * Amg::AngleAxis3D(eigen_euler_angles(2), Amg::Vector3D::UnitZ());
    }
 
    return mat;
 
} // end of SetPhi()

setPhi() [2/2]

void Amg::setPhi ( Amg::Vector3D & v, double phi )

inline

sets the phi angle of a vector without changing theta nor the magnitude

Definition at line 62 of file GeoPrimitivesHelpers.h.

                                               {
    double xy = v.perp();
    CxxUtils::sincos sc(phi);
    v[0] = xy * sc.cs;
    v[1] = xy * sc.sn;
}

setRThetaPhi()

void Amg::setRThetaPhi ( Amg::Vector3D & v, double r, double theta, double phi )

inline

sets radius, the theta and phi angle of a vector.

Angles are measured in RADIANS

Definition at line 80 of file GeoPrimitivesHelpers.h.

                                                                             {
    CxxUtils::sincos sc(phi);
    CxxUtils::sincos sct(theta);
    v[0] = r * sct.sn * sc.cs;
    v[1] = r * sct.sn * sc.sn;
    v[2] = r * sct.cs;
}

setTheta()

void Amg::setTheta ( Amg::Vector3D & v, double theta )

inline

sets the theta of a vector without changing phi nor the magnitude

Definition at line 89 of file GeoPrimitivesHelpers.h.

                                                   {
    setThetaPhi(v, theta, v.phi());
}

setThetaPhi()

void Amg::setThetaPhi ( Amg::Vector3D & v, double theta, double phi )

inline

sets the theta and phi angle of a vector without changing the magnitude

Definition at line 70 of file GeoPrimitivesHelpers.h.

                                                                  {
    double mag = v.mag();
    CxxUtils::sincos sc(phi);
    CxxUtils::sincos sct(theta);
    v[0] = mag * sct.sn * sc.cs;
    v[1] = mag * sct.sn * sc.sn;
    v[2] = mag * sct.cs;
}

setVector3DCartesian()

void Amg::setVector3DCartesian ( Amg::Vector3D & v1, double x1, double y1, double z1 )

inline

Sets components in cartesian coordinate system.

Definition at line 136 of file GeoPrimitivesHelpers.h.

{ v1[0] = x1; v1[1] = y1; v1[2] = z1; }

signedDistance()

double Amg::signedDistance ( const Amg::Vector3D & posA, const Amg::Vector3D & dirA, const Amg::Vector3D & posB, const Amg::Vector3D & dirB )

inline

Calculates the signed distance between two lines in 3D space.

Parameters

posA	offset point of line A
dirA	orientation of line A (unit length)
posB	offset point of line B
dirB	orientation of line B (unit length)

Project the first direction onto the second & renormalize to a unit vector

Definition at line 329 of file GeoPrimitivesHelpers.h.

                                                      {
    const double dirDots = dirA.dot(dirB);
    const Amg::Vector3D AminusB = posA - posB;
    if (std::abs(dirDots -1.) < std::numeric_limits<float>::epsilon()){
        return (AminusB - dirA.dot(AminusB)*dirA).mag();
    }
    const Amg::Vector3D projDir = (dirA - dirDots*dirB).unit();
    return AminusB.cross(dirB).dot(projDir);
}  

toString() [1/7]

std::string Amg::toString ( const CLHEP::Hep2Vector & translation, int precision = 4 )

inline

Definition at line 100 of file GeoPrimitivesToStringConverter.h.

                                                                                   {
    std::ostringstream sout;
    sout << std::setiosflags(std::ios::fixed) << std::setprecision(precision);
    for( int j=0;j<2;++j ){
      if( j == 0 ) sout << "(";
      double val = roundWithPrecision( translation[j],precision);
      sout << val;
      if( j == 1 ) sout << ")";
      else         sout << ", ";
    }
    return sout.str();
  }

toString() [2/7]

std::string Amg::toString ( const CLHEP::Hep3Vector & translation, int precision = 4 )

inline

Definition at line 87 of file GeoPrimitivesToStringConverter.h.

                                                                                   {
    std::ostringstream sout;
    sout << std::setiosflags(std::ios::fixed) << std::setprecision(precision);
    for( int j=0;j<3;++j ){
      if( j == 0 ) sout << "(";
      double val = roundWithPrecision( translation[j],precision);
      sout << val;
      if( j == 2 ) sout << ")";
      else         sout << ", ";
    }
    return sout.str();
  }

toString() [3/7]

std::string Amg::toString ( const CLHEP::HepRotation & rot, int precision = 4, const std::string & offset = "" )

inline

Definition at line 66 of file GeoPrimitivesToStringConverter.h.

                                                                                                         {
    std::ostringstream sout;
 
    sout << std::setiosflags(std::ios::fixed) << std::setprecision(precision);
    for( int i=0;i<3;++i ){
      for( int j=0;j<3;++j ){
    if( j == 0 ) sout << "(";
    double val = roundWithPrecision(rot(i,j),precision);
    sout << val;
    if( j == 2 ) sout << ")";
    else         sout << ", ";
      }
      if( i != 2 ) {
    sout << std::endl;
    sout << offset;    
      }       
    }    
    return sout.str();
  }

toString() [4/7]

std::string Amg::toString ( const HepGeom::Transform3D & transf, int precision = 4, const std::string & offset = "" )

inline

Definition at line 113 of file GeoPrimitivesToStringConverter.h.

                                                                                                             {
    std::ostringstream sout;
    sout << "Translation : " << toString( transf.getTranslation(), precision ) << std::endl;
    std::string rotationOffset = offset + "              ";
    sout << offset << "Rotation    : " << toString( transf.getRotation(), precision+2, rotationOffset );
    return sout.str();
  }

toString() [5/7]

std::string Amg::toString ( const MatrixX & matrix, int precision = 4, const std::string & offset = "" )

inline

Definition at line 41 of file EventPrimitivesToStringConverter.h.

                                                          {
  std::ostringstream sout;
 
  sout << std::setiosflags(std::ios::fixed) << std::setprecision(precision);
  if (matrix.cols() == 1) {
    sout << "(";
    for (int i = 0; i < matrix.rows(); ++i) {
      double val = roundWithPrecision(matrix(i, 0), precision);
      sout << val;
      if (i != matrix.rows() - 1)
        sout << ", ";
    }
    sout << ")";
  } else {
    for (int i = 0; i < matrix.rows(); ++i) {
      for (int j = 0; j < matrix.cols(); ++j) {
        if (j == 0)
          sout << "(";
        double val = roundWithPrecision(matrix(i, j), precision);
        sout << val;
        if (j == matrix.cols() - 1)
          sout << ")";
        else
          sout << ", ";
      }
      if (i != matrix.rows() -
                   1) {  // make the end line and the offset in the next line
        sout << std::endl;
        sout << offset;
      }
    }
  }
  return sout.str();
}

toString() [6/7]

std::string Amg::toString ( const Transform3D & transform, int precision = 4, const std::string & rotOffSet = "" )

inline

Definition at line 46 of file GeoPrimitivesToStringConverter.h.

                                                                                                               {
    std::stringstream sstr{};
    bool printed{false};
    if (transform.translation().mag() > std::numeric_limits<float>::epsilon()) {
        sstr<<"translation: "<<toString(transform.translation(), precision);
        printed = true;
    }
    if (!Amg::doesNotDeform(transform)) {
        if (printed) sstr<<rotOffSet<<", ";
        sstr<<"rotation: {"<<toString(transform.linear()*Vector3D::UnitX(), precision)<<",";
        sstr<<toString(transform.linear()*Vector3D::UnitY(), precision)<<",";
        sstr<<toString(transform.linear()*Vector3D::UnitZ(), precision)<<"}";
        printed = true;
    }
    if (!printed) sstr<<"Identity matrix ";
    return sstr.str();
}

toString() [7/7]

std::string Amg::toString ( const Translation3D & translation, int precision = 4 )

inline

GeoPrimitvesToStringConverter.

static methods for conversion of GeoPrimitives and will call the EventPrimitives converter (Matrix) to std::string.

This is to enhance formatted screen ouput and for ASCII based testing.

The offset can be used to offset the lines (starting from line 2) wrt to the zero position for formatting reasons.

Author

Niels.nosp@m..Van.nosp@m..Eldi.nosp@m.k@ce.nosp@m.rn.ch

Definition at line 40 of file GeoPrimitivesToStringConverter.h.

                                                                                  {
    Vector3D trans{translation.x(), translation.y(), translation.z()};
    return toString( trans, precision );
  }

transform()

Amg::Vector3D Amg::transform ( Amg::Vector3D & v, Amg::Transform3D & tr )

inline

Transform a point from a Trasformation3D.

from CLHEP::Point3D::transform: http://proj-clhep.web.cern.ch/proj-clhep/doc/CLHEP_2_0_4_7/doxygen/html/Point3D_8cc-source.html#l00032

Definition at line 156 of file GeoPrimitivesHelpers.h.

                                                                   {
    Amg::Vector3D vect;
    double vx = v.x(), vy = v.y(), vz = v.z();
    setVector3DCartesian( vect,
            tr(0,0)*vx + tr(0,1)*vy + tr(0,2)*vz + tr(0,3),
            tr(1,0)*vx + tr(1,1)*vy + tr(1,2)*vz + tr(1,3),
            tr(2,0)*vx + tr(2,1)*vy + tr(2,2)*vz + tr(2,3));
    return vect;
}