Trk::RotatedTrapezoidBounds Class Reference

#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 }
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
	RotatedTrapezoidBounds ()
	Default Constructor, needed for persistency. More...
	RotatedTrapezoidBounds (const RotatedTrapezoidBounds &trabo)=default
	Copy constructor. More...
RotatedTrapezoidBounds &	operator= (const RotatedTrapezoidBounds &sbo)=default
	Assignment operator. More...
	RotatedTrapezoidBounds (RotatedTrapezoidBounds &&trabo) noexcept=default
	Move constructor. More...
RotatedTrapezoidBounds &	operator= (RotatedTrapezoidBounds &&sbo) noexcept=default
	Move Assignment operator. More...
virtual	~RotatedTrapezoidBounds ()=default
	Destructor. More...
	RotatedTrapezoidBounds (double halex, double minhalex, double maxhalex)
	Constructor for symmetric Trapezoid. More...
	RotatedTrapezoidBounds (double halex, double minhalex, double maxhalex, double alpha)
	Constructor for symmetric Trapezoid rotated around the X axis by alpha. More...
virtual RotatedTrapezoidBounds *	clone () const override
	Virtual constructor. More...
virtual BoundsType	type () const override
	Return the type of the bounds for persistency. More...
virtual bool	operator== (const SurfaceBounds &trabo) const override final
	Equality operator. More...
double	halflengthX () const
	This method returns the minimal halflength in X (first coordinate of local surface frame) More...
double	minHalflengthY () const
	This method returns the maximal halflength in X (first coordinate of local surface frame) More...
double	maxHalflengthY () const
	This method returns the halflength in Y (second coordinate of local surface frame) More...
virtual double	r () const override
	This method returns the maximal extension on the local plane. More...
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. 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	isBelow (double locX, double fabsLocY, double tol1, double tol2) const
	isBelow() method for checking whether a point lies above or under a straight line More...
virtual void	initCache () override final
	Helper function for angle parameter initialization. More...
	AmgSymMatrix (2) m_rotMat
	Transformation matrix to define surface bounds which are tilted w.r.t. More...

Private Attributes
std::vector< TDD_real_t >	m_boundValues
	The internal storage of the bounds can be float/double. More...
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 Function 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.

m_kappa

TDD_real_t Trk::RotatedTrapezoidBounds::m_kappa {0}

private

Definition at line 162 of file RotatedTrapezoidBounds.h.

---

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

• RotatedTrapezoidBounds.h
• RotatedTrapezoidBounds.cxx