GXF::DiscBounds Class Reference

Class to describe the bounds for a planar DiscSurface. More...

#include <DiscBounds.h>

Inheritance diagram for GXF::DiscBounds:

Collaboration diagram for GXF::DiscBounds:

Public Types
enum	BoundValues {   bv_rMin = 0 , bv_rMax = 1 , bv_averagePhi = 2 , bv_halfPhiSector = 3 ,   bv_length = 4 }
	enumeration for 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
	DiscBounds ()
	Default Constructor.
	DiscBounds (const DiscBounds &)=default
	Default copy constructor.
	DiscBounds (DiscBounds &&discbo) noexcept=default
	Default move constructor.
	DiscBounds (double minrad, double maxrad, double hphisec=M_PI)
	Constructor for full disc of symmetric disc around phi=0.
	DiscBounds (double minrad, double maxrad, double avephi, double hphisec)
	Constructor for a symmetric disc around phi != 0.
DiscBounds &	operator= (const DiscBounds &discbo)=default
	Default assignment operator.
DiscBounds &	operator= (DiscBounds &&discbo) noexcept=default
	Default move assignment operator.
virtual	~DiscBounds ()=default
	Destructor.
virtual bool	operator== (const SurfaceBounds &sbo) const override
	Equality operator.
virtual DiscBounds *	clone () const override final
	Virtual constructor.
virtual SurfaceBounds::BoundsType	type () const override final
	Return the type - mainly for persistency.
virtual bool	inside (const Amg::Vector2D &locpo, double tol1=0., double tol2=0.) const override final
	This method cheks if the radius given in the LocalPosition is inside [rMin,rMax] if only tol1 is given and additional in the phi sector is tol2 is given.
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)
double	rMin () const
	This method returns inner radius.
double	rMax () const
	This method returns outer radius.
virtual double	r () const override final
	This method returns the maximum expansion on the plane (=rMax)
double	averagePhi () const
	This method returns the average phi.
double	halfPhiSector () const
	This method returns the halfPhiSector which is covered by the disc.
virtual MsgStream &	dump (MsgStream &sl) const override
	Output Method for MsgStream.
virtual std::ostream &	dump (std::ostream &sl) const override
	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.
virtual void	initCache ()
	virtual initCache method for object persistency

Private Attributes
std::vector< TDD_real_t >	m_boundValues
	Internal members of the bounds (float/double)

Detailed Description

Class to describe the bounds for a planar DiscSurface.

By providing an argument for hphisec, the bounds can be restricted to a phirange around the center position.

Author

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

Definition at line 43 of file DiscBounds.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::DiscBounds::BoundValues

enumeration for readability

Enumerator
bv_rMin
bv_rMax
bv_averagePhi
bv_halfPhiSector
bv_length

Definition at line 48 of file DiscBounds.h.

  {
    bv_rMin = 0,
    bv_rMax = 1,
    bv_averagePhi = 2,
    bv_halfPhiSector = 3,
    bv_length = 4
  };

Constructor & Destructor Documentation

DiscBounds() [1/5]

Trk::DiscBounds::DiscBounds

(

)

Default Constructor.

Definition at line 17 of file DiscBounds.cxx.

  : m_boundValues(DiscBounds::bv_length, 0.)
{}

DiscBounds() [2/5]

Trk::DiscBounds::DiscBounds ( const DiscBounds & )

default

Default copy constructor.

DiscBounds() [3/5]

Trk::DiscBounds::DiscBounds ( DiscBounds && discbo )

defaultnoexcept

Default move constructor.

DiscBounds() [4/5]

Trk::DiscBounds::DiscBounds	(	double	minrad,
		double	maxrad,
		double	hphisec = M_PI )

Constructor for full disc of symmetric disc around phi=0.

Definition at line 21 of file DiscBounds.cxx.

  : m_boundValues(DiscBounds::bv_length, 0.)
{
  m_boundValues[DiscBounds::bv_rMin] = minrad;
  m_boundValues[DiscBounds::bv_rMax] = maxrad;
  m_boundValues[DiscBounds::bv_averagePhi] = 0.;
  m_boundValues[DiscBounds::bv_halfPhiSector] = hphisec;
  if (m_boundValues[DiscBounds::bv_rMin] > m_boundValues[DiscBounds::bv_rMax])
    swap(m_boundValues[DiscBounds::bv_rMin], m_boundValues[DiscBounds::bv_rMax]);
}

DiscBounds() [5/5]

Trk::DiscBounds::DiscBounds	(	double	minrad,
		double	maxrad,
		double	avephi,
		double	hphisec )

Constructor for a symmetric disc around phi != 0.

Definition at line 32 of file DiscBounds.cxx.

  : m_boundValues(DiscBounds::bv_length, 0.)
{
  m_boundValues[DiscBounds::bv_rMin] = minrad;
  m_boundValues[DiscBounds::bv_rMax] = maxrad;
  m_boundValues[DiscBounds::bv_averagePhi] = avephi;
  m_boundValues[DiscBounds::bv_halfPhiSector] = hphisec;
  if (m_boundValues[DiscBounds::bv_rMin] > m_boundValues[DiscBounds::bv_rMax])
    swap(m_boundValues[DiscBounds::bv_rMin], m_boundValues[DiscBounds::bv_rMax]);
}

~DiscBounds()

virtual Trk::DiscBounds::~DiscBounds ( )

virtualdefault

Destructor.

Member Function Documentation

averagePhi()

double Trk::DiscBounds::averagePhi

(

)

const

This method returns the average phi.

clone()

virtual DiscBounds * Trk::DiscBounds::clone ( ) const

finaloverridevirtual

Virtual constructor.

Implements Trk::SurfaceBounds.

dump() [1/2]

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

overridevirtual

Output Method for MsgStream.

Implements Trk::SurfaceBounds.

Definition at line 310 of file DiscBounds.cxx.

{
  sl << std::setiosflags(std::ios::fixed);
  sl << std::setprecision(7);
  sl << "Trk::DiscBounds:  (innerRadius, outerRadius, averagePhi, hPhiSector) = ";
  sl << "(" << this->rMin() << ", " << this->rMax() << ", " << this->averagePhi() << ", " << this->halfPhiSector()
     << ")";
  sl << std::setprecision(-1);
  return sl;
}

dump() [2/2]

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

overridevirtual

Output Method for std::ostream.

Implements Trk::SurfaceBounds.

Definition at line 322 of file DiscBounds.cxx.

{
  sl << std::setiosflags(std::ios::fixed);
  sl << std::setprecision(7);
  sl << "Trk::DiscBounds:  (innerRadius, outerRadius, hPhiSector) = ";
  sl << "(" << this->rMin() << ", " << this->rMax() << ", " << this->averagePhi() << ", " << this->halfPhiSector()
     << ")";
  sl << std::setprecision(-1);
  return sl;
}

halfPhiSector()

double Trk::DiscBounds::halfPhiSector

(

)

const

This method returns the halfPhiSector which is covered by the disc.

initCache()

virtual void Trk::SurfaceBounds::initCache ( )

inlineprotectedvirtualinherited

virtual initCache method for object persistency

Reimplemented in Trk::ConeBounds, Trk::DiamondBounds, Trk::RotatedDiamondBounds, and Trk::RotatedTrapezoidBounds.

Definition at line 129 of file SurfaceBounds.h.

{}

inside() [1/2]

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

finaloverridevirtual

Implements Trk::SurfaceBounds.

Definition at line 68 of file DiscBounds.cxx.

{
  if (bchk.bcType == 0 || bchk.nSigmas == 0 ||
      m_boundValues[DiscBounds::bv_rMin] != 0 ||
      m_boundValues[DiscBounds::bv_halfPhiSector] != M_PI)
    return DiscBounds::inside(locpo, bchk.toleranceLoc1, bchk.toleranceLoc2);
 
  // a fast FALSE
  sincosCache scResult = bchk.FastSinCos(locpo(1, 0));
  double dx = bchk.nSigmas * sqrt(bchk.lCovariance(0, 0));
  double dy =
    bchk.nSigmas * sqrt(scResult.sinC * scResult.sinC * bchk.lCovariance(0, 0) +
                        locpo(0, 0) * locpo(0, 0) * scResult.cosC *
                          scResult.cosC * bchk.lCovariance(1, 1) +
                        2 * scResult.cosC * scResult.sinC * locpo(0, 0) *
                          bchk.lCovariance(0, 1));
  double max_ell = dx > dy ? dx : dy;
  if (locpo(0, 0) > (m_boundValues[DiscBounds::bv_rMax] + max_ell))
    return false;
  // a fast TRUE
  double min_ell = dx < dy ? dx : dy;
  if (locpo(0, 0) < (m_boundValues[DiscBounds::bv_rMax] + min_ell))
    return true;
 
  // we are not using the KDOP approach here but rather a highly optimized one
  class EllipseCollisionTest
  {
  private:
    int m_maxIterations;
    bool iterate(double x,
                 double y,
                 double c0x,
                 double c0y,
                 double c2x,
                 double c2y,
                 double rr) const
    {
      std::vector<double> innerPolygonCoef(m_maxIterations + 1);
      std::vector<double> outerPolygonCoef(m_maxIterations + 1);
      /*
         t2______t4
     --_        \
          --_    \                                  /¨¨¨ ¨¨\
                    t1 = (0, 0)                (     t   )
                        | \ \__ _ /
                        |   \
                        |    t3
                    |   /
                    | /
                 t0
      */
      for (int t = 1; t <= m_maxIterations; t++) {
        int numNodes = 4 << t;
        innerPolygonCoef[t] = 0.5 / cos(2.0*M_PI / numNodes);
        double c1x = (c0x + c2x) * innerPolygonCoef[t];
        double c1y = (c0y + c2y) * innerPolygonCoef[t];
        double tx = x - c1x; // t indicates a translated coordinate
        double ty = y - c1y;
        if (tx * tx + ty * ty <= rr) {
          return true; // collision with t1
        }
        double t2x = c2x - c1x;
        double t2y = c2y - c1y;
        if (tx * t2x + ty * t2y >= 0 &&
            tx * t2x + ty * t2y <= t2x * t2x + t2y * t2y &&
            (ty * t2x - tx * t2y >= 0 ||
             rr * (t2x * t2x + t2y * t2y) >=
               (ty * t2x - tx * t2y) * (ty * t2x - tx * t2y))) {
          return true; // collision with t1---t2
        }
        double t0x = c0x - c1x;
        double t0y = c0y - c1y;
        if (tx * t0x + ty * t0y >= 0 &&
            tx * t0x + ty * t0y <= t0x * t0x + t0y * t0y &&
            (ty * t0x - tx * t0y <= 0 ||
             rr * (t0x * t0x + t0y * t0y) >=
               (ty * t0x - tx * t0y) * (ty * t0x - tx * t0y))) {
          return true; // collision with t1---t0
        }
        outerPolygonCoef[t] =
          0.5 / (std::cos(M_PI / numNodes) * std::cos(M_PI / numNodes));
        double c3x = (c0x + c1x) * outerPolygonCoef[t];
        double c3y = (c0y + c1y) * outerPolygonCoef[t];
        if ((c3x - x) * (c3x - x) + (c3y - y) * (c3y - y) < rr) {
          c2x = c1x;
          c2y = c1y;
          continue; // t3 is inside circle
        }
        double c4x = c1x - c3x + c1x;
        double c4y = c1y - c3y + c1y;
        if ((c4x - x) * (c4x - x) + (c4y - y) * (c4y - y) < rr) {
          c0x = c1x;
          c0y = c1y;
          continue; // t4 is inside circle
        }
        double t3x = c3x - c1x;
        double t3y = c3y - c1y;
        if (ty * t3x - tx * t3y <= 0 ||
            rr * (t3x * t3x + t3y * t3y) >
              (ty * t3x - tx * t3y) * (ty * t3x - tx * t3y)) {
          if (tx * t3x + ty * t3y > 0) {
            if (std::abs(tx * t3x + ty * t3y) <= t3x * t3x + t3y * t3y ||
                (x - c3x) * (c0x - c3x) + (y - c3y) * (c0y - c3y) >= 0) {
              c2x = c1x;
              c2y = c1y;
              continue; // circle center is inside t0---t1---t3
            }
          } else if (-(tx * t3x + ty * t3y) <= t3x * t3x + t3y * t3y ||
                     (x - c4x) * (c2x - c4x) + (y - c4y) * (c2y - c4y) >= 0) {
            c0x = c1x;
            c0y = c1y;
            continue; // circle center is inside t1---t2---t4
          }
        }
        return false; // no collision possible
      }
      return false; // out of iterations so it is unsure if there was a
                    // collision. But have to return something.
    }
 
  public:
    // test for collision between an ellipse of horizontal radius w and vertical
    // radius h at (x0, y0) and a circle of radius r at (x1, y1)
    bool collide(double x0,
                 double y0,
                 double w,
                 double h,
                 double x1,
                 double y1,
                 double r) const
    {
      double x = std::abs(x1 - x0);
      double y = std::abs(y1 - y0);
      if (x * x + (h - y) * (h - y) <= r * r ||
          (w - x) * (w - x) + y * y <= r * r ||
          x * h + y * w <= w * h // collision with (0, h)
          || ((x * h + y * w - w * h) * (x * h + y * w - w * h) <=
                r * r * (w * w + h * h) &&
              x * w - y * h >= -h * h &&
              x * w - y * h <= w * w)) { // collision with (0, h)---(w, 0)
        return true;
      } else {
        if ((x - w) * (x - w) + (y - h) * (y - h) <= r * r ||
            (x <= w && y - r <= h) || (y <= h && x - r <= w)) {
          return iterate(
            x, y, w, 0, 0, h, r * r); // collision within triangle (0, h) (w, h)
                                      // (0, 0) is possible
        }
        return false;
      }
    }
    explicit EllipseCollisionTest(int maxIterations) : m_maxIterations(maxIterations)
    {
      
    }
  };
 
  EllipseCollisionTest test(4);
  // convert to cartesian coordinates
  AmgMatrix(2, 2) covRotMatrix;
  // cppcheck-suppress constStatement
  covRotMatrix << scResult.cosC, -locpo(0, 0) * scResult.sinC, scResult.sinC,
    locpo(0, 0) * scResult.cosC;
  AmgMatrix(2, 2) lCovarianceCar =
    covRotMatrix * bchk.lCovariance * covRotMatrix.transpose();
  Amg::Vector2D locpoCar(covRotMatrix(1, 1), -covRotMatrix(0, 1));
 
  // ellipse is always at (0,0), surface is moved to ellipse position and then
  // rotated
  double w = bchk.nSigmas * sqrt(lCovarianceCar(0, 0));
  double h = bchk.nSigmas * sqrt(lCovarianceCar(1, 1));
  double x0 = 0;
  double y0 = 0;
  float theta =
    (lCovarianceCar(1, 0) != 0 &&
     (lCovarianceCar(1, 1) - lCovarianceCar(0, 0)) != 0)
      ? .5 * bchk.FastArcTan(2 * lCovarianceCar(1, 0) /
                             (lCovarianceCar(1, 1) - lCovarianceCar(0, 0)))
      : 0.;
  scResult = bchk.FastSinCos(theta);
  AmgMatrix(2, 2) rotMatrix;
  rotMatrix << scResult.cosC, scResult.sinC, -scResult.sinC, scResult.cosC;
  Amg::Vector2D tmp = rotMatrix * (-locpoCar);
  double x1 = tmp(0, 0);
  double y1 = tmp(1, 0);
  double r = m_boundValues[DiscBounds::bv_rMax];
  // check if ellipse and circle overlap and return result
  return test.collide(x0, y0, w, h, x1, y1, r);
}

inside() [2/2]

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

finaloverridevirtual

This method cheks if the radius given in the LocalPosition is inside [rMin,rMax] if only tol1 is given and additional in the phi sector is tol2 is given.

Implements Trk::SurfaceBounds.

Definition at line 55 of file DiscBounds.cxx.

{
  double alpha = std::abs(locpo[locPhi] - m_boundValues[DiscBounds::bv_averagePhi]);
  if (alpha > M_PI)
    alpha = 2 * M_PI - alpha;
  bool insidePhi =
    (alpha <= (m_boundValues[DiscBounds::bv_halfPhiSector] + tol2));
  return (locpo[locR] > (m_boundValues[DiscBounds::bv_rMin] - tol1) &&
          locpo[locR] < (m_boundValues[DiscBounds::bv_rMax] + tol1) &&
          insidePhi);
}

insideLoc1()

virtual bool Trk::DiscBounds::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

Implements Trk::SurfaceBounds.

insideLoc2()

virtual bool Trk::DiscBounds::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

Implements Trk::SurfaceBounds.

minDistance()

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

finaloverridevirtual

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

Implements Trk::SurfaceBounds.

Definition at line 259 of file DiscBounds.cxx.

{
  const double pi2 = 2. * M_PI;
 
  double r = pos[locR];
  if (r == 0.)
    return m_boundValues[DiscBounds::bv_rMin];
  double sf = 0.;
  double dF = 0.;
 
  if (m_boundValues[DiscBounds::bv_halfPhiSector] < M_PI) {
 
    dF = std::abs(pos[locPhi] - m_boundValues[DiscBounds::bv_averagePhi]);
    if (dF > M_PI)
      dF = pi2 - dF;
    dF -= m_boundValues[DiscBounds::bv_halfPhiSector];
    sf = r * sin(dF);
    if (dF > 0.)
      r *= cos(dF);
 
  } else {
    sf = -1.e+10;
  }
 
  if (sf <= 0.) {
 
    double sr0 = m_boundValues[DiscBounds::bv_rMin] - r;
    if (sr0 > 0.)
      return sr0;
    double sr1 = r - m_boundValues[DiscBounds::bv_rMax];
    if (sr1 > 0.)
      return sr1;
    if (sf < sr0)
      sf = sr0;
    if (sf < sr1)
      sf = sr1;
    return sf;
  }
 
  double sr0 = m_boundValues[DiscBounds::bv_rMin] - r;
  if (sr0 > 0.)
    return sqrt(sr0 * sr0 + sf * sf);
  double sr1 = r - m_boundValues[DiscBounds::bv_rMax];
  if (sr1 > 0.)
    return sqrt(sr1 * sr1 + sf * sf);
  return sf;
}

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]

DiscBounds & Trk::DiscBounds::operator= ( const DiscBounds & discbo )

default

Default assignment operator.

operator=() [2/2]

DiscBounds & Trk::DiscBounds::operator= ( DiscBounds && discbo )

defaultnoexcept

Default move assignment operator.

operator==()

bool Trk::DiscBounds::operator== ( const SurfaceBounds & sbo ) const

overridevirtual

Equality operator.

Implements Trk::SurfaceBounds.

Definition at line 45 of file DiscBounds.cxx.

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

r()

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

finaloverridevirtual

This method returns the maximum expansion on the plane (=rMax)

Implements Trk::SurfaceBounds.

rMax()

double Trk::DiscBounds::rMax

(

)

const

This method returns outer radius.

rMin()

double Trk::DiscBounds::rMin

(

)

const

This method returns inner radius.

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 SurfaceBounds::BoundsType Trk::DiscBounds::type ( ) const

inlinefinaloverridevirtual

Return the type - mainly for persistency.

Implements Trk::SurfaceBounds.

Definition at line 87 of file DiscBounds.h.

{ return SurfaceBounds::Disc; }

Member Data Documentation

m_boundValues

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

private

Internal members of the bounds (float/double)

Definition at line 128 of file DiscBounds.h.

---

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

• DiscBounds.h
• DiscBounds.cxx