Trk::RotatedTrapezoidBounds Class Reference

Bounds for a rotated trapezoidal, planar Surface. More...

#include <RotatedTrapezoidBounds.h>

Inheritance diagram for Trk::RotatedTrapezoidBounds:

Collaboration diagram for Trk::RotatedTrapezoidBounds:

Public Types
enum	BoundValues { bv_halfX = 0 , bv_minHalfY = 1 , bv_maxHalfY = 2 , bv_length = 3 }
	for readibility 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
	RotatedTrapezoidBounds ()
	Default Constructor, needed for persistency.
	RotatedTrapezoidBounds (const RotatedTrapezoidBounds &trabo)=default
	Copy constructor.
RotatedTrapezoidBounds &	operator= (const RotatedTrapezoidBounds &sbo)=default
	Assignment operator.
	RotatedTrapezoidBounds (RotatedTrapezoidBounds &&trabo) noexcept=default
	Move constructor.
RotatedTrapezoidBounds &	operator= (RotatedTrapezoidBounds &&sbo) noexcept=default
	Move Assignment operator.
virtual	~RotatedTrapezoidBounds ()=default
	Destructor.
	RotatedTrapezoidBounds (double halex, double minhalex, double maxhalex)
	Constructor for symmetric Trapezoid.
	RotatedTrapezoidBounds (double halex, double minhalex, double maxhalex, double alpha)
	Constructor for symmetric Trapezoid rotated around the X axis by alpha.
virtual RotatedTrapezoidBounds *	clone () const override
	Virtual constructor.
virtual BoundsType	type () const override
	Return the type of the bounds for persistency.
virtual bool	operator== (const SurfaceBounds &trabo) const override final
	Equality operator.
double	halflengthX () const
	This method returns the minimal halflength in X (first coordinate of local surface frame)
double	minHalflengthY () const
	This method returns the maximal halflength in X (first coordinate of local surface frame)
double	maxHalflengthY () const
	This method returns the halflength in Y (second coordinate of local surface frame)
virtual double	r () const override
	This method returns the maximal extension on the local plane.
virtual bool	inside (const Amg::Vector2D &locpo, double tol1=0., double tol2=0.) const override final
	The orientation of the Trapezoid is according to the figure above, in words: the shorter of the two parallel sides of the trapezoid intersects with the negative \( y \) - axis of the local frame.
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	isBelow (double locX, double fabsLocY, double tol1, double tol2) const
	isBelow() method for checking whether a point lies above or under a straight line
virtual void	initCache () override final
	Helper function for angle parameter initialization.
	AmgSymMatrix (2) m_rotMat
	Transformation matrix to define surface bounds which are tilted w.r.t.

Private Attributes
std::vector< TDD_real_t >	m_boundValues
	The internal storage of the bounds can be float/double.
TDD_real_t	m_kappa {0}
TDD_real_t	m_delta {0}

Friends
class	::RotatedTrapezoidBoundsCnv_p1

Detailed Description

Bounds for a rotated trapezoidal, planar Surface.

Contrary to the TrapezoidBounds the local x axis builds the symmetry axis for a symmetric Trapezoid.

An arbitrary rotated trapezoidal shape has not been implemented yet, the TrapezoidBounds may be taken instead.

Author

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

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

for readibility

Enumerator
bv_halfX
bv_minHalfY
bv_maxHalfY
bv_length

Definition at line 49 of file RotatedTrapezoidBounds.h.

  {
    bv_halfX = 0,
    bv_minHalfY = 1,
    bv_maxHalfY = 2,
    bv_length = 3
  };

Constructor & Destructor Documentation

RotatedTrapezoidBounds() [1/5]

Trk::RotatedTrapezoidBounds::RotatedTrapezoidBounds

(

)

Default Constructor, needed for persistency.

Definition at line 19 of file RotatedTrapezoidBounds.cxx.

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

RotatedTrapezoidBounds() [2/5]

Trk::RotatedTrapezoidBounds::RotatedTrapezoidBounds ( const RotatedTrapezoidBounds & trabo )

default

Copy constructor.

RotatedTrapezoidBounds() [3/5]

Trk::RotatedTrapezoidBounds::RotatedTrapezoidBounds ( RotatedTrapezoidBounds && trabo )

defaultnoexcept

Move constructor.

~RotatedTrapezoidBounds()

virtual Trk::RotatedTrapezoidBounds::~RotatedTrapezoidBounds ( )

virtualdefault

Destructor.

RotatedTrapezoidBounds() [4/5]

Trk::RotatedTrapezoidBounds::RotatedTrapezoidBounds	(	double	halex,
		double	minhalex,
		double	maxhalex )

Constructor for symmetric Trapezoid.

Definition at line 28 of file RotatedTrapezoidBounds.cxx.

  : m_boundValues(RotatedTrapezoidBounds::bv_length, 0.)
  
{
  m_boundValues[RotatedTrapezoidBounds::bv_halfX] = std::abs(halex);
  m_boundValues[RotatedTrapezoidBounds::bv_minHalfY] = std::abs(minhalex);
  m_boundValues[RotatedTrapezoidBounds::bv_maxHalfY] = std::abs(maxhalex);
  // swap if needed
  if (m_boundValues[RotatedTrapezoidBounds::bv_minHalfY] > m_boundValues[RotatedTrapezoidBounds::bv_maxHalfY])
    swap(m_boundValues[RotatedTrapezoidBounds::bv_minHalfY], m_boundValues[RotatedTrapezoidBounds::bv_maxHalfY]);
  // assign kappa and delta
  RotatedTrapezoidBounds::initCache();
}

RotatedTrapezoidBounds() [5/5]

Trk::RotatedTrapezoidBounds::RotatedTrapezoidBounds	(	double	halex,
		double	minhalex,
		double	maxhalex,
		double	alpha )

Constructor for symmetric Trapezoid rotated around the X axis by alpha.

Definition at line 24 of file RotatedTrapezoidBounds.cxx.

                                                                                                             :
    RotatedTrapezoidBounds(halex, minhalex, maxhalex){
    m_rotMat = Eigen::Rotation2D{alpha};
}

Member Function Documentation

AmgSymMatrix()

Trk::RotatedTrapezoidBounds::AmgSymMatrix ( 2 )

inlineprivate

Transformation matrix to define surface bounds which are tilted w.r.t.

the surfaces (e.g. Micromega stereo layers)

Definition at line 166 of file RotatedTrapezoidBounds.h.

{AmgSymMatrix(2)::Identity()};

clone()

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

overridevirtual

Virtual constructor.

Implements Trk::SurfaceBounds.

dump() [1/2]

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

finaloverridevirtual

Output Method for MsgStream.

Implements Trk::SurfaceBounds.

Definition at line 217 of file RotatedTrapezoidBounds.cxx.

{
  sl << std::setiosflags(std::ios::fixed);
  sl << std::setprecision(7);
  sl << "Trk::RotatedTrapezoidBounds:  (halfX, minHalfX, maxHalfY) = "
     << "(" << m_boundValues[RotatedTrapezoidBounds::bv_halfX] << ", "
     << m_boundValues[RotatedTrapezoidBounds::bv_minHalfY] << ", " << m_boundValues[RotatedTrapezoidBounds::bv_maxHalfY]
     << ")";
  sl << std::setprecision(-1);
  return sl;
}

dump() [2/2]

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

finaloverridevirtual

Output Method for std::ostream.

Implements Trk::SurfaceBounds.

Definition at line 230 of file RotatedTrapezoidBounds.cxx.

{
  sl << std::setiosflags(std::ios::fixed);
  sl << std::setprecision(7);
  sl << "Trk::RotatedTrapezoidBounds:  (halfX, minHalfX, maxHalfY) = "
     << "(" << m_boundValues[RotatedTrapezoidBounds::bv_halfX] << ", "
     << m_boundValues[RotatedTrapezoidBounds::bv_minHalfY] << ", " << m_boundValues[RotatedTrapezoidBounds::bv_maxHalfY]
     << ")";
  sl << std::setprecision(-1);
  return sl;
}

halflengthX()

double Trk::RotatedTrapezoidBounds::halflengthX

(

)

const

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

initCache()

void Trk::RotatedTrapezoidBounds::initCache ( )

finaloverrideprivatevirtual

Helper function for angle parameter initialization.

Reimplemented from Trk::SurfaceBounds.

Definition at line 42 of file RotatedTrapezoidBounds.cxx.

                                          {
  m_kappa = 0.5 *
            (m_boundValues[RotatedTrapezoidBounds::bv_maxHalfY] -
             m_boundValues[RotatedTrapezoidBounds::bv_minHalfY]) /
            m_boundValues[RotatedTrapezoidBounds::bv_halfX];
  m_delta = 0.5 * (m_boundValues[RotatedTrapezoidBounds::bv_minHalfY] +
                   m_boundValues[RotatedTrapezoidBounds::bv_maxHalfY]);
}

inside() [1/2]

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

finaloverridevirtual

Implements Trk::SurfaceBounds.

Definition at line 62 of file RotatedTrapezoidBounds.cxx.

{
  const Amg::Vector2D locpo = m_rotMat * pos;
  if (bchk.bcType == 0)
    return RotatedTrapezoidBounds::inside(
      locpo, bchk.toleranceLoc1, bchk.toleranceLoc2);
 
  // a fast FALSE
  const double fabsX = std::abs(locpo[Trk::locX]);
  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 (fabsX > (m_boundValues[RotatedTrapezoidBounds::bv_halfX] + limit))
    return false;
  // a fast FALSE
  const double fabsY = std::abs(locpo[Trk::locY]);
  if (fabsY > (m_boundValues[RotatedTrapezoidBounds::bv_maxHalfY] + 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 (fabsY < (m_boundValues[RotatedTrapezoidBounds::bv_minHalfY] + limit) &&
      fabsX < (m_boundValues[RotatedTrapezoidBounds::bv_halfX] + limit))
    return true;
 
  // compute KDOP and axes for surface polygon
  std::vector<KDOP> elementKDOP(3);
  std::vector<Amg::Vector2D> elementP(4);
  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[RotatedTrapezoidBounds::bv_halfX],
                  m_boundValues[RotatedTrapezoidBounds::bv_minHalfY]);
  elementP[0] = (rotMatrix * (p - locpo));
  p = Amg::Vector2D (-m_boundValues[RotatedTrapezoidBounds::bv_halfX],
                     -m_boundValues[RotatedTrapezoidBounds::bv_minHalfY]);
  elementP[1] = (rotMatrix * (p - locpo));
  p = Amg::Vector2D (m_boundValues[RotatedTrapezoidBounds::bv_halfX],
                     m_boundValues[RotatedTrapezoidBounds::bv_maxHalfY]);
  elementP[2] = (rotMatrix * (p - locpo));
  p = Amg::Vector2D (m_boundValues[RotatedTrapezoidBounds::bv_halfX],
                     -m_boundValues[RotatedTrapezoidBounds::bv_maxHalfY]);
  elementP[3] = (rotMatrix * (p - locpo));
  std::vector<Amg::Vector2D> axis = { normal * (elementP[1] - elementP[0]),
                                      normal * (elementP[3] - elementP[1]),
                                      normal * (elementP[2] - elementP[0]) };
  bchk.ComputeKDOP(elementP, axis, elementKDOP);
  // compute KDOP for error ellipse
  std::vector<KDOP> errelipseKDOP(3);
  bchk.ComputeKDOP(bchk.EllipseToPoly(3), axis, errelipseKDOP);
  // check if KDOPs overlap and return result
  return bchk.TestKDOPKDOP(elementKDOP, errelipseKDOP);
}

inside() [2/2]

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

finaloverridevirtual

The orientation of the Trapezoid is according to the figure above, in words: the shorter of the two parallel sides of the trapezoid intersects with the negative \( y \) - axis of the local frame.

The cases are:
(0) \( \eta \) or \( \phi \) bounds are 0 || 0
(1) LocalPosition is outside \( x \) bounds
(2) LocalPosition is inside \( x \) bounds, but outside maximum \( y \) bounds
(3) LocalPosition is inside \( x \) bounds AND inside minimum \( y \) bounds
(4) LocalPosition is inside \( x \) bounds AND inside maximum \( y \) bounds, so that it depends on the \( x \) coordinate (5) LocalPosition fails test of (4)

The inside check is done using single equations of straight lines and one has to take care if a point lies on the positive \( \phi \) half area(I) or the negative one(II). Denoting \( | y_{min}| \) and \( | y_{max} | \) as minHalfY respectively maxHalfX, such as \( | x_{H} | \) as halfX, the equations for the straing lines in (I) and (II) can be written as:

• (I): \( y = \kappa_{I} x + \delta_{I} \)
  
• (II): \( y = \kappa_{II} x + \delta_{II} \) ,
  
  where
  \( \kappa_{I} = - \kappa_{II} = \frac{y_{max}-y_{min}}{x_{H}} \)
  \( \delta_{I} = \frac{1}{2}\cdot (y_{max} + y_{min} ) \)
  

Implements Trk::SurfaceBounds.

Definition at line 134 of file RotatedTrapezoidBounds.cxx.

{
 
  // the cases:
  const Amg::Vector2D locpo = m_rotMat * pos;
  double fabsX = std::abs(locpo[Trk::locX]);
  double fabsY = std::abs(locpo[Trk::locY]);
  // (1) a fast FALSE
  if (fabsX > (m_boundValues[RotatedTrapezoidBounds::bv_halfX] + tol1))
    return false;
  // (2) a fast FALSE
  if (fabsY > (m_boundValues[RotatedTrapezoidBounds::bv_maxHalfY] + tol2))
    return false;
  // (3) a fast TRUE
  if (fabsY < (m_boundValues[RotatedTrapezoidBounds::bv_minHalfY] + tol2))
    return true;
  // (4) it is inside the rectangular shape solve the isBelow
  return (isBelow(locpo[Trk::locX], fabsY, tol1, tol2));
}

insideLoc1()

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

isBelow()

bool Trk::RotatedTrapezoidBounds::isBelow ( double locX, double fabsLocY, double tol1, double tol2 ) const

private

isBelow() method for checking whether a point lies above or under a straight line

Definition at line 156 of file RotatedTrapezoidBounds.cxx.

{
  // the most tolerant approach for tol1 and tol2
  return ((m_kappa * (locX + tol1) + m_delta) > fabsLocY - tol2);
}

maxHalflengthY()

double Trk::RotatedTrapezoidBounds::maxHalflengthY

(

)

const

This method returns the halflength in Y (second coordinate of local surface frame)

minDistance()

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

finaloverridevirtual

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

Implements Trk::SurfaceBounds.

Definition at line 163 of file RotatedTrapezoidBounds.cxx.

{
  const Amg::Vector2D pos = m_rotMat * locpo;
  constexpr int Np = 4;
 
  const std::array<double,4> X{ -m_boundValues[RotatedTrapezoidBounds::bv_halfX],
                  -m_boundValues[RotatedTrapezoidBounds::bv_halfX],
                  m_boundValues[RotatedTrapezoidBounds::bv_halfX],
                  m_boundValues[RotatedTrapezoidBounds::bv_halfX] };
  const std::array<double,4> Y{ -m_boundValues[RotatedTrapezoidBounds::bv_minHalfY],
                  m_boundValues[RotatedTrapezoidBounds::bv_minHalfY],
                  m_boundValues[RotatedTrapezoidBounds::bv_maxHalfY],
                  -m_boundValues[RotatedTrapezoidBounds::bv_maxHalfY] };
 
  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 -std::sqrt(dm);
  }
  return std::sqrt(dm);
}

minHalflengthY()

double Trk::RotatedTrapezoidBounds::minHalflengthY

(

)

const

This method returns the maximal halflength in X (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]

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

default

Assignment operator.

operator=() [2/2]

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

defaultnoexcept

Move Assignment operator.

operator==()

bool Trk::RotatedTrapezoidBounds::operator== ( const SurfaceBounds & trabo ) const

finaloverridevirtual

Equality operator.

Implements Trk::SurfaceBounds.

Definition at line 52 of file RotatedTrapezoidBounds.cxx.

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

r()

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

overridevirtual

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::RotatedTrapezoidBounds::type ( ) const

inlineoverridevirtual

Return the type of the bounds for persistency.

Implements Trk::SurfaceBounds.

Definition at line 85 of file RotatedTrapezoidBounds.h.

{ return SurfaceBounds::RotatedTrapezoid; }

Friends And Related Symbol Documentation

::RotatedTrapezoidBoundsCnv_p1

friend class ::RotatedTrapezoidBoundsCnv_p1

friend

Definition at line 152 of file RotatedTrapezoidBounds.h.

Member Data Documentation

m_boundValues

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

private

The internal storage of the bounds can be float/double.

Definition at line 161 of file RotatedTrapezoidBounds.h.

m_delta

TDD_real_t Trk::RotatedTrapezoidBounds::m_delta {0}

private

Definition at line 163 of file RotatedTrapezoidBounds.h.

{0};

m_kappa

TDD_real_t Trk::RotatedTrapezoidBounds::m_kappa {0}

private

Definition at line 162 of file RotatedTrapezoidBounds.h.

{0};

---

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

• RotatedTrapezoidBounds.h
• RotatedTrapezoidBounds.cxx