Trk::DiamondBounds Class Reference

#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 }

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

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

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

Private Attributes
std::vector< TDD_real_t >	m_boundValues
	Internal parameters stored in the geometry. More...
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 Function 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