Trk::DiamondBounds Class Reference

Bounds for a double trapezoidal ("diamond"), planar Surface. More...

#include <DiamondBounds.h>

Inheritance diagram for Trk::DiamondBounds:

Collaboration diagram for Trk::DiamondBounds:

Public Types
enum	BoundValues {   bv_minHalfX = 0 , bv_medHalfX = 1 , bv_maxHalfX = 2 , bv_halfY1 = 3 ,   bv_halfY2 = 4 , bv_length = 5 }
	BoundValues for better readability. More...
enum	BoundsType {   Cone = 0 , Cylinder = 1 , Diamond = 2 , Disc = 3 ,   Ellipse = 5 , Rectangle = 6 , RotatedTrapezoid = 7 , Trapezoid = 8 ,   Triangle = 9 , DiscTrapezoidal = 10 , Annulus = 11 , Other = 12 }
	This enumerator simplifies the persistency, by saving a dynamic_cast to happen. More...

Public Member Functions
	DiamondBounds ()
	Default Constructor, needed for persistency.
	DiamondBounds (const DiamondBounds &diabo)=default
	Copy constructor.
DiamondBounds &	operator= (const DiamondBounds &sbo)=default
	Assignment operator.
	DiamondBounds (DiamondBounds &&diabo) noexcept=default
	Copy constructor.
DiamondBounds &	operator= (DiamondBounds &&sbo) noexcept=default
	Assignment operator.
virtual	~DiamondBounds ()=default
	Destructor.
	DiamondBounds (double minhalex, double medhalex, double maxhalex, double haley1, double haley2)
	Constructor for symmetric Diamond.
DiamondBounds *	clone () const override
	Virtual constructor.
virtual bool	operator== (const SurfaceBounds &diabo) const override
	Equality operator.
virtual BoundsType	type () const override final
	Return the bounds type.
double	minHalflengthX () const
	This method returns the halflength in X at minimal Y (first coordinate of local surface frame)
double	medHalflengthX () const
	This method returns the (maximal) halflength in X (first coordinate of local surface frame)
double	maxHalflengthX () const
	This method returns the halflength in X at maximal Y (first coordinate of local surface frame)
double	halflengthY1 () const
	This method returns the halflength in Y of trapezoid at negative/positive Y (second coordinate)
double	halflengthY2 () const
virtual double	r () const override final
	This method returns the maximal extension on the local plane.
double	alpha1 () const
	This method returns the opening angle alpha in point A.
double	alpha2 () const
	This method returns the opening angle alpha in point A'.
virtual bool	inside (const Amg::Vector2D &locpo, double tol1=0., double tol2=0.) const override final
	The orientation of the Diamond is according to the figure.
virtual bool	inside (const Amg::Vector2D &locpo, const BoundaryCheck &bchk) const override final
virtual bool	insideLoc1 (const Amg::Vector2D &locpo, double tol1=0.) const override final
	This method checks inside bounds in loc1.
virtual bool	insideLoc2 (const Amg::Vector2D &locpo, double tol2=0.) const override final
	This method checks inside bounds in loc2.
virtual double	minDistance (const Amg::Vector2D &pos) const override final
	Minimal distance to boundary ( > 0 if outside and <=0 if inside)
virtual MsgStream &	dump (MsgStream &sl) const override final
	Output Method for MsgStream.
virtual std::ostream &	dump (std::ostream &sl) const override final
	Output Method for std::ostream.
virtual bool	operator!= (const SurfaceBounds &sb) const
	Non-Equality operator.

Protected Member Functions
void	swap (double &b1, double &b2)
	Swap method to be called from DiscBounds or TrapezoidalBounds.

Private Member Functions
bool	insideFull (const Amg::Vector2D &locpo, double tol1=0., double tol2=0.) const
	inside() method for a full symmetric diamond
virtual void	initCache () override
	initialize the alpha1/2 cache - needed also for object persistency

Private Attributes
std::vector< TDD_real_t >	m_boundValues
	Internal parameters stored in the geometry.
TDD_real_t	m_alpha1
TDD_real_t	m_alpha2

Friends
class	::DiamondBoundsCnv_p1

Detailed Description

Bounds for a double trapezoidal ("diamond"), planar Surface.

Author

Andre.nosp@m.as.S.nosp@m.alzbu.nosp@m.rger.nosp@m.@cern.nosp@m..ch, Sarka.nosp@m..Tod.nosp@m.orova.nosp@m.@cer.nosp@m.n.ch

Definition at line 36 of file DiamondBounds.h.

Member Enumeration Documentation

BoundsType

enum Trk::SurfaceBounds::BoundsType

inherited

This enumerator simplifies the persistency, by saving a dynamic_cast to happen.

Other is reserved for the GeometrySurfaces implementation.

Enumerator
Cone
Cylinder
Diamond
Disc
Ellipse
Rectangle
RotatedTrapezoid
Trapezoid
Triangle
DiscTrapezoidal
Annulus
Other

Definition at line 58 of file SurfaceBounds.h.

  {
    Cone = 0,
    Cylinder = 1,
    Diamond = 2,
    Disc = 3,
    Ellipse = 5,
    Rectangle = 6,
    RotatedTrapezoid = 7,
    Trapezoid = 8,
    Triangle = 9,
    DiscTrapezoidal = 10,
    Annulus = 11,
    Other = 12
 
  };

BoundValues

enum Trk::DiamondBounds::BoundValues

BoundValues for better readability.

Enumerator
bv_minHalfX
bv_medHalfX
bv_maxHalfX
bv_halfY1
bv_halfY2
bv_length

Definition at line 41 of file DiamondBounds.h.

  {
    bv_minHalfX = 0,
    bv_medHalfX = 1,
    bv_maxHalfX = 2,
    bv_halfY1 = 3,
    bv_halfY2 = 4,
    bv_length = 5
  };

Constructor & Destructor Documentation

DiamondBounds() [1/4]

Trk::DiamondBounds::DiamondBounds

(

)

Default Constructor, needed for persistency.

Definition at line 19 of file DiamondBounds.cxx.

  : m_boundValues(DiamondBounds::bv_length, 0.)
  , m_alpha1(0.)
  , m_alpha2(0.)
{}

DiamondBounds() [2/4]

Trk::DiamondBounds::DiamondBounds ( const DiamondBounds & diabo )

default

Copy constructor.

DiamondBounds() [3/4]

Trk::DiamondBounds::DiamondBounds ( DiamondBounds && diabo )

defaultnoexcept

Copy constructor.

~DiamondBounds()

virtual Trk::DiamondBounds::~DiamondBounds ( )

virtualdefault

Destructor.

DiamondBounds() [4/4]

Trk::DiamondBounds::DiamondBounds	(	double	minhalex,
		double	medhalex,
		double	maxhalex,
		double	haley1,
		double	haley2 )

Constructor for symmetric Diamond.

Definition at line 26 of file DiamondBounds.cxx.

    : m_boundValues(DiamondBounds::bv_length, 0.), m_alpha1(0.), m_alpha2(0.) {
  m_boundValues[DiamondBounds::bv_minHalfX] = minhalex;
  m_boundValues[DiamondBounds::bv_medHalfX] = medhalex;
  m_boundValues[DiamondBounds::bv_maxHalfX] = maxhalex;
  m_boundValues[DiamondBounds::bv_halfY1] = haley1;
  m_boundValues[DiamondBounds::bv_halfY2] = haley2;
  if (minhalex > maxhalex)
    swap(m_boundValues[DiamondBounds::bv_minHalfX],
         m_boundValues[DiamondBounds::bv_maxHalfX]);
  DiamondBounds::initCache();
}

Member Function Documentation

alpha1()

double Trk::DiamondBounds::alpha1

(

)

const

This method returns the opening angle alpha in point A.

Definition at line 179 of file DiamondBounds.cxx.

{
  return m_alpha1;
}

alpha2()

double Trk::DiamondBounds::alpha2

(

)

const

This method returns the opening angle alpha in point A'.

Definition at line 186 of file DiamondBounds.cxx.

{
  return m_alpha2;
}

clone()

DiamondBounds * Trk::DiamondBounds::clone ( ) const

overridevirtual

Virtual constructor.

Implements Trk::SurfaceBounds.

dump() [1/2]

MsgStream & Trk::DiamondBounds::dump ( MsgStream & sl ) const

finaloverridevirtual

Output Method for MsgStream.

Implements Trk::SurfaceBounds.

Definition at line 243 of file DiamondBounds.cxx.

{
  sl << std::setiosflags(std::ios::fixed);
  sl << std::setprecision(7);
  sl << "Trk::DiamondBounds:  (minHlenghtX, medHlengthX, maxHlengthX, hlengthY1, hlengthY2 ) = ";
  sl << "(" << m_boundValues[DiamondBounds::bv_minHalfX] << ", " << m_boundValues[DiamondBounds::bv_medHalfX] << ", "
     << m_boundValues[DiamondBounds::bv_maxHalfX] << ", " << m_boundValues[DiamondBounds::bv_halfY1] << ", "
     << m_boundValues[DiamondBounds::bv_halfY2] << ")";
  sl << std::setprecision(-1);
  return sl;
}

dump() [2/2]

std::ostream & Trk::DiamondBounds::dump ( std::ostream & sl ) const

finaloverridevirtual

Output Method for std::ostream.

Implements Trk::SurfaceBounds.

Definition at line 256 of file DiamondBounds.cxx.

{
  sl << std::setiosflags(std::ios::fixed);
  sl << std::setprecision(7);
  sl << "Trk::DiamondBounds:  (minHlenghtX, medHlengthX, maxHlengthX, hlengthY1, hlengthY2 ) = ";
  sl << "(" << m_boundValues[DiamondBounds::bv_minHalfX] << ", " << m_boundValues[DiamondBounds::bv_medHalfX] << ", "
     << m_boundValues[DiamondBounds::bv_maxHalfX] << ", " << m_boundValues[DiamondBounds::bv_halfY1] << ", "
     << m_boundValues[DiamondBounds::bv_halfY2] << ")";
  sl << std::setprecision(-1);
  return sl;
}

halflengthY1()

double Trk::DiamondBounds::halflengthY1

(

)

const

This method returns the halflength in Y of trapezoid at negative/positive Y (second coordinate)

halflengthY2()

double Trk::DiamondBounds::halflengthY2

(

)

const

initCache()

void Trk::DiamondBounds::initCache ( )

overrideprivatevirtual

initialize the alpha1/2 cache - needed also for object persistency

Reimplemented from Trk::SurfaceBounds.

Definition at line 40 of file DiamondBounds.cxx.

                                 {
  m_alpha1 = atan2(m_boundValues[DiamondBounds::bv_medHalfX] -
                       m_boundValues[DiamondBounds::bv_minHalfX],
                   2. * m_boundValues[DiamondBounds::bv_halfY1]);
  m_alpha2 = atan2(m_boundValues[DiamondBounds::bv_medHalfX] -
                       m_boundValues[DiamondBounds::bv_maxHalfX],
                   2. * m_boundValues[DiamondBounds::bv_halfY2]);
}

inside() [1/2]

bool Trk::DiamondBounds::inside ( const Amg::Vector2D & locpo, const BoundaryCheck & bchk ) const

finaloverridevirtual

Implements Trk::SurfaceBounds.

Definition at line 67 of file DiamondBounds.cxx.

{
  if (bchk.bcType == 0)
    return DiamondBounds::inside(locpo, bchk.toleranceLoc1, bchk.toleranceLoc2);
 
  // a fast FALSE
  double max_ell = bchk.lCovariance(0, 0) > bchk.lCovariance(1, 1)
                     ? bchk.lCovariance(0, 0)
                     : bchk.lCovariance(1, 1);
  double limit = bchk.nSigmas * sqrt(max_ell);
  if (locpo[Trk::locY] < -2 * m_boundValues[DiamondBounds::bv_halfY1] - limit)
    return false;
  if (locpo[Trk::locY] > 2 * m_boundValues[DiamondBounds::bv_halfY2] + limit)
    return false;
  // a fast FALSE
  double fabsX = std::abs(locpo[Trk::locX]);
  if (fabsX > (m_boundValues[DiamondBounds::bv_medHalfX] + limit))
    return false;
  // a fast TRUE
  double min_ell = bchk.lCovariance(0, 0) < bchk.lCovariance(1, 1)
                     ? bchk.lCovariance(0, 0)
                     : bchk.lCovariance(1, 1);
  limit = bchk.nSigmas * sqrt(min_ell);
  if (fabsX < (fmin(m_boundValues[DiamondBounds::bv_minHalfX],
                    m_boundValues[DiamondBounds::bv_maxHalfX]) -
               limit))
    return true;
  // a fast TRUE
  if (std::abs(locpo[Trk::locY]) < (fmin(m_boundValues[DiamondBounds::bv_halfY1],
                                     m_boundValues[DiamondBounds::bv_halfY2]) -
                                limit))
    return true;
 
  // compute KDOP and axes for surface polygon
  std::vector<KDOP> elementKDOP(5);
  std::vector<Amg::Vector2D> elementP(6);
  float theta =
    (bchk.lCovariance(1, 0) != 0 &&
     (bchk.lCovariance(1, 1) - bchk.lCovariance(0, 0)) != 0)
      ? .5 * bchk.FastArcTan(2 * bchk.lCovariance(1, 0) /
                             (bchk.lCovariance(1, 1) - bchk.lCovariance(0, 0)))
      : 0.;
  sincosCache scResult = bchk.FastSinCos(theta);
  AmgMatrix(2, 2) rotMatrix;
  rotMatrix << scResult.cosC, scResult.sinC, -scResult.sinC, scResult.cosC;
  AmgMatrix(2, 2) normal;
  // cppcheck-suppress constStatement
  normal << 0, -1, 1, 0;
  // ellipse is always at (0,0), surface is moved to ellipse position and then
  // rotated
  Amg::Vector2D p =
    Amg::Vector2D(-m_boundValues[DiamondBounds::bv_minHalfX],
                  -2. * m_boundValues[DiamondBounds::bv_halfY1]);
  elementP[0] = (rotMatrix * (p - locpo));
  p = Amg::Vector2D (-m_boundValues[DiamondBounds::bv_medHalfX], 0.);
  elementP[1] = (rotMatrix * (p - locpo));
  p = Amg::Vector2D (-m_boundValues[DiamondBounds::bv_maxHalfX],
                     2. * m_boundValues[DiamondBounds::bv_halfY2]);
  elementP[2] = (rotMatrix * (p - locpo));
  p = Amg::Vector2D (m_boundValues[DiamondBounds::bv_maxHalfX],
                     2. * m_boundValues[DiamondBounds::bv_halfY2]);
  elementP[3] = (rotMatrix * (p - locpo));
  p = Amg::Vector2D (m_boundValues[DiamondBounds::bv_medHalfX], 0.);
  elementP[4] = (rotMatrix * (p - locpo));
  p = Amg::Vector2D (m_boundValues[DiamondBounds::bv_minHalfX],
                     -2. * m_boundValues[DiamondBounds::bv_halfY1]);
  elementP[5] = (rotMatrix * (p - locpo));
  std::vector<Amg::Vector2D> axis = { normal * (elementP[1] - elementP[0]),
                                      normal * (elementP[2] - elementP[1]),
                                      normal * (elementP[3] - elementP[2]),
                                      normal * (elementP[4] - elementP[3]),
                                      normal * (elementP[5] - elementP[4]) };
  bchk.ComputeKDOP(elementP, axis, elementKDOP);
  // compute KDOP for error ellipse
  std::vector<KDOP> errelipseKDOP(5);
  bchk.ComputeKDOP(bchk.EllipseToPoly(3), axis, errelipseKDOP);
  // check if KDOPs overlap and return result
  return bchk.TestKDOPKDOP(elementKDOP, errelipseKDOP);
}

inside() [2/2]

bool Trk::DiamondBounds::inside ( const Amg::Vector2D & locpo, double tol1 = 0., double tol2 = 0. ) const

finaloverridevirtual

The orientation of the Diamond is according to the figure.

Implements Trk::SurfaceBounds.

Definition at line 61 of file DiamondBounds.cxx.

{
  return this->insideFull(locpo, tol1, tol2);
}

insideFull()

bool Trk::DiamondBounds::insideFull ( const Amg::Vector2D & locpo, double tol1 = 0., double tol2 = 0. ) const

private

inside() method for a full symmetric diamond

use basic calculation of a straight line

Definition at line 150 of file DiamondBounds.cxx.

{
  // validity check
  if (!m_boundValues[DiamondBounds::bv_halfY1] && !m_boundValues[DiamondBounds::bv_minHalfX]) return false;
 
  // quick False (radial direction)
  if (locpo[Trk::locY] < -2. * m_boundValues[DiamondBounds::bv_halfY1] - tol2) return false;
  if (locpo[Trk::locY] >  2. * m_boundValues[DiamondBounds::bv_halfY2] + tol2) return false;
 
  double absX = std::abs(locpo[Trk::locX]);
 
  // quick False (transverse directon)
  if (absX > m_boundValues[DiamondBounds::bv_medHalfX] + tol1) return false;
 
  // quick True
  if (absX < std::min(m_boundValues[DiamondBounds::bv_minHalfX], m_boundValues[DiamondBounds::bv_maxHalfX]) + tol1) return true;

  const double& halfBaseUp = locpo[Trk::locY] < 0 ? m_boundValues[DiamondBounds::bv_medHalfX] : m_boundValues[DiamondBounds::bv_maxHalfX];
  const double& halfBaseLo = locpo[Trk::locY] < 0 ? m_boundValues[DiamondBounds::bv_minHalfX] : m_boundValues[DiamondBounds::bv_medHalfX];
  const double& halfH      = locpo[Trk::locY] < 0 ? m_boundValues[DiamondBounds::bv_halfY1]   : m_boundValues[DiamondBounds::bv_halfY2];
  double k = halfH ? 0.5*(halfBaseUp - halfBaseLo)/halfH : 0.;
  double sign = (k < 0) ? -1. : 1.;   
  return (absX - tol1 <= m_boundValues[DiamondBounds::bv_medHalfX] + k * (locpo[Trk::locY] + sign*tol2));
 
}

insideLoc1()

virtual bool Trk::DiamondBounds::insideLoc1 ( const Amg::Vector2D & locpo, double tol1 = 0. ) const

finaloverridevirtual

This method checks inside bounds in loc1.

• loc1/loc2 correspond to the natural coordinates of the surface
• As loc1/loc2 are correlated the single check doesn't make sense : -> check is done on enclosing Rectangle !

Implements Trk::SurfaceBounds.

insideLoc2()

virtual bool Trk::DiamondBounds::insideLoc2 ( const Amg::Vector2D & locpo, double tol2 = 0. ) const

finaloverridevirtual

This method checks inside bounds in loc2.

• loc1/loc2 correspond to the natural coordinates of the surface
• As loc1/loc2 are correlated the single check doesn't make sense : -> check is done on enclosing Rectangle !

Implements Trk::SurfaceBounds.

maxHalflengthX()

double Trk::DiamondBounds::maxHalflengthX

(

)

const

This method returns the halflength in X at maximal Y (first coordinate of local surface frame)

medHalflengthX()

double Trk::DiamondBounds::medHalflengthX

(

)

const

This method returns the (maximal) halflength in X (first coordinate of local surface frame)

minDistance()

double Trk::DiamondBounds::minDistance ( const Amg::Vector2D & pos ) const

finaloverridevirtual

Minimal distance to boundary ( > 0 if outside and <=0 if inside)

Implements Trk::SurfaceBounds.

Definition at line 192 of file DiamondBounds.cxx.

{
  const int Np = 6;
 
  double y1 = 2. * m_boundValues[DiamondBounds::bv_halfY1];
  double y2 = 2. * m_boundValues[DiamondBounds::bv_halfY2];
 
  double X[6] = { -m_boundValues[DiamondBounds::bv_minHalfX], -m_boundValues[DiamondBounds::bv_medHalfX],
                  -m_boundValues[DiamondBounds::bv_maxHalfX], m_boundValues[DiamondBounds::bv_maxHalfX],
                  m_boundValues[DiamondBounds::bv_medHalfX],  m_boundValues[DiamondBounds::bv_minHalfX] };
  double Y[6] = { -y1, 0., y2, y2, 0., -y1 };
 
  double dm = 1.e+20;
  double Ao = 0.;
  bool in = true;
 
  for (int i = 0; i != Np; ++i) {
 
    int j = (i == Np-1 ? 0 : i+1);
 
    double x = X[i] - pos[0];
    double y = Y[i] - pos[1];
    double dx = X[j] - X[i];
    double dy = Y[j] - Y[i];
    double A = x * dy - y * dx;
    double S = -(x * dx + y * dy);
 
    if (S <= 0.) {
      double d = x * x + y * y;
      if (d < dm)
        dm = d;
    } else {
      double a = dx * dx + dy * dy;
      if (S <= a) {
        double d = (A * A) / a;
        if (d < dm)
          dm = d;
      }
    }
    if (i && in && Ao * A < 0.)
      in = false;
    Ao = A;
  }
  if (in)
    return -sqrt(dm);
  return sqrt(dm);
}

minHalflengthX()

double Trk::DiamondBounds::minHalflengthX

(

)

const

This method returns the halflength in X at minimal Y (first coordinate of local surface frame)

operator!=()

bool Trk::SurfaceBounds::operator!= ( const SurfaceBounds & sb ) const

inlinevirtualinherited

Non-Equality operator.

Reimplemented in Trk::InvalidBounds.

Definition at line 141 of file SurfaceBounds.h.

{
  return !((*this) == sb);
}

operator=() [1/2]

DiamondBounds & Trk::DiamondBounds::operator= ( const DiamondBounds & sbo )

default

Assignment operator.

operator=() [2/2]

DiamondBounds & Trk::DiamondBounds::operator= ( DiamondBounds && sbo )

defaultnoexcept

Assignment operator.

operator==()

bool Trk::DiamondBounds::operator== ( const SurfaceBounds & diabo ) const

overridevirtual

Equality operator.

Implements Trk::SurfaceBounds.

Definition at line 50 of file DiamondBounds.cxx.

{
  // check the type first not to compare apples with oranges
  const Trk::DiamondBounds* diabo = dynamic_cast<const Trk::DiamondBounds*>(&sbo);
  if (!diabo)
    return false;
  return (m_boundValues == diabo->m_boundValues);
}

r()

virtual double Trk::DiamondBounds::r ( ) const

finaloverridevirtual

This method returns the maximal extension on the local plane.

Implements Trk::SurfaceBounds.

swap()

void Trk::SurfaceBounds::swap ( double & b1, double & b2 )

inlineprotectedinherited

Swap method to be called from DiscBounds or TrapezoidalBounds.

Definition at line 133 of file SurfaceBounds.h.

{
  double tmp = b1;
  b1 = b2;
  b2 = tmp;
}

type()

virtual BoundsType Trk::DiamondBounds::type ( ) const

inlinefinaloverridevirtual

Return the bounds type.

Implements Trk::SurfaceBounds.

Definition at line 79 of file DiamondBounds.h.

{ return SurfaceBounds::Diamond; }

Friends And Related Symbol Documentation

::DiamondBoundsCnv_p1

friend class ::DiamondBoundsCnv_p1

friend

Definition at line 131 of file DiamondBounds.h.

Member Data Documentation

m_alpha1

TDD_real_t Trk::DiamondBounds::m_alpha1

private

Definition at line 141 of file DiamondBounds.h.

m_alpha2

TDD_real_t Trk::DiamondBounds::m_alpha2

private

Definition at line 142 of file DiamondBounds.h.

m_boundValues

std::vector<TDD_real_t> Trk::DiamondBounds::m_boundValues

private

Internal parameters stored in the geometry.

Definition at line 140 of file DiamondBounds.h.

---

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

• DiamondBounds.h
• DiamondBounds.cxx