Trk::RotatedDiamondBounds Class Reference

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

#include <RotatedDiamondBounds.h>

Inheritance diagram for Trk::RotatedDiamondBounds:

Collaboration diagram for Trk::RotatedDiamondBounds:

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
	RotatedDiamondBounds ()
	Default Constructor, needed for persistency.
	RotatedDiamondBounds (const RotatedDiamondBounds &diabo)=default
	Copy constructor.
RotatedDiamondBounds &	operator= (const RotatedDiamondBounds &sbo)=default
	Assignment operator.
	RotatedDiamondBounds (RotatedDiamondBounds &&diabo) noexcept=default
	Move constructor.
RotatedDiamondBounds &	operator= (RotatedDiamondBounds &&sbo) noexcept=default
	Assignment operator.
virtual	~RotatedDiamondBounds ()=default
	Destructor.
	RotatedDiamondBounds (double minhalex, double medhalex, double maxhalex, double haley1, double haley2)
	Constructor for symmetric Diamond.
RotatedDiamondBounds *	clone () const override
	Virtual constructor.
virtual bool	operator== (const SurfaceBounds &diabo) const override
	Equality operator.
virtual BoundsType	type () const override
	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
	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
	The orientation of the Diamond is according to the figure.
virtual bool	inside (const Amg::Vector2D &locpo, const BoundaryCheck &bchk) const override
virtual bool	insideLoc1 (const Amg::Vector2D &locpo, double tol1=0.) const override
	This method checks inside bounds in loc1.
virtual bool	insideLoc2 (const Amg::Vector2D &locpo, double tol2=0.) const override
	This method checks inside bounds in loc2.
virtual double	minDistance (const Amg::Vector2D &pos) const override
	Minimal distance to boundary ( > 0 if outside and <=0 if inside)
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.

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	::RotatedDiamondBoundsCnv_p1

Detailed Description

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

The RotatedDiamondBounds Class specifies the same diamond as the DiamondBounds Class. The local X and Y coordinates will be interchanged internally for boundary checks. (This is opposed to the TrapezoidBounds, where X and Y are interchanged in the constructor.)

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, Peter.nosp@m..Klu.nosp@m.it@ce.nosp@m.rn.c.nosp@m.h, Alice.nosp@m..Alf.nosp@m.onsi@.nosp@m.cern.nosp@m..ch, Michi.nosp@m.el.J.nosp@m.an.Ve.nosp@m.en@c.nosp@m.ern.c.nosp@m.h

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

BoundValues for better readability.

Enumerator
bv_minHalfX
bv_medHalfX
bv_maxHalfX
bv_halfY1
bv_halfY2
bv_length

Definition at line 46 of file RotatedDiamondBounds.h.

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

Constructor & Destructor Documentation

RotatedDiamondBounds() [1/4]

Trk::RotatedDiamondBounds::RotatedDiamondBounds

(

)

Default Constructor, needed for persistency.

Definition at line 19 of file RotatedDiamondBounds.cxx.

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

RotatedDiamondBounds() [2/4]

Trk::RotatedDiamondBounds::RotatedDiamondBounds ( const RotatedDiamondBounds & diabo )

default

Copy constructor.

RotatedDiamondBounds() [3/4]

Trk::RotatedDiamondBounds::RotatedDiamondBounds ( RotatedDiamondBounds && diabo )

defaultnoexcept

Move constructor.

~RotatedDiamondBounds()

virtual Trk::RotatedDiamondBounds::~RotatedDiamondBounds ( )

virtualdefault

Destructor.

RotatedDiamondBounds() [4/4]

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

Constructor for symmetric Diamond.

Definition at line 26 of file RotatedDiamondBounds.cxx.

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

Member Function Documentation

alpha1()

double Trk::RotatedDiamondBounds::alpha1

(

)

const

This method returns the opening angle alpha in point A.

Definition at line 190 of file RotatedDiamondBounds.cxx.

{
  return m_alpha1;
}

alpha2()

double Trk::RotatedDiamondBounds::alpha2

(

)

const

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

Definition at line 197 of file RotatedDiamondBounds.cxx.

{
  return m_alpha2;
}

clone()

RotatedDiamondBounds * Trk::RotatedDiamondBounds::clone ( ) const

overridevirtual

Virtual constructor.

Implements Trk::SurfaceBounds.

dump() [1/2]

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

overridevirtual

Output Method for MsgStream.

Implements Trk::SurfaceBounds.

Definition at line 255 of file RotatedDiamondBounds.cxx.

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

dump() [2/2]

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

overridevirtual

Output Method for std::ostream.

Implements Trk::SurfaceBounds.

Definition at line 269 of file RotatedDiamondBounds.cxx.

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

halflengthY1()

double Trk::RotatedDiamondBounds::halflengthY1

(

)

const

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

halflengthY2()

double Trk::RotatedDiamondBounds::halflengthY2

(

)

const

initCache()

void Trk::RotatedDiamondBounds::initCache ( )

overrideprivatevirtual

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

Reimplemented from Trk::SurfaceBounds.

Definition at line 45 of file RotatedDiamondBounds.cxx.

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

inside() [1/2]

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

overridevirtual

Implements Trk::SurfaceBounds.

Definition at line 65 of file RotatedDiamondBounds.cxx.

{
  // locX and locY are interchanged wrt DiamondBounds
  if (bchk.bcType == 0)
    return RotatedDiamondBounds::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::locX] <
      -2 * m_boundValues[RotatedDiamondBounds::bv_halfY1] - limit)
    return false;
  if (locpo[Trk::locX] >
      2 * m_boundValues[RotatedDiamondBounds::bv_halfY2] + limit)
    return false;
  // a fast FALSE
  double fabsX = std::abs(locpo[Trk::locY]);
  if (fabsX > (m_boundValues[RotatedDiamondBounds::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[RotatedDiamondBounds::bv_minHalfX],
                    m_boundValues[RotatedDiamondBounds::bv_maxHalfX]) -
               limit))
    return true;
  // a fast TRUE
  if (std::abs(locpo[Trk::locX]) <
      (fmin(m_boundValues[RotatedDiamondBounds::bv_halfY1],
            m_boundValues[RotatedDiamondBounds::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 exchange locX and locY
  Amg::Vector2D locpoF;
  locpoF[0] = locpo[Trk::locY];
  locpoF[1] = locpo[Trk::locX];
  Amg::Vector2D p =
    Amg::Vector2D(-m_boundValues[RotatedDiamondBounds::bv_minHalfX],
                  -2. * m_boundValues[RotatedDiamondBounds::bv_halfY1]);
  elementP[0] = (rotMatrix * (p - locpoF));
  p = Amg::Vector2D (-m_boundValues[RotatedDiamondBounds::bv_medHalfX], 0.);
  elementP[1] = (rotMatrix * (p - locpoF));
  p = Amg::Vector2D (-m_boundValues[RotatedDiamondBounds::bv_maxHalfX],
                     2. * m_boundValues[RotatedDiamondBounds::bv_halfY2]);
  elementP[2] = (rotMatrix * (p - locpoF));
  p = Amg::Vector2D (m_boundValues[RotatedDiamondBounds::bv_maxHalfX],
                     2. * m_boundValues[RotatedDiamondBounds::bv_halfY2]);
  elementP[3] = (rotMatrix * (p - locpoF));
  p = Amg::Vector2D (m_boundValues[RotatedDiamondBounds::bv_medHalfX], 0.);
  elementP[4] = (rotMatrix * (p - locpoF));
  p = Amg::Vector2D (m_boundValues[RotatedDiamondBounds::bv_minHalfX],
                     -2. * m_boundValues[RotatedDiamondBounds::bv_halfY1]);
  elementP[5] = (rotMatrix * (p - locpoF));
  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::RotatedDiamondBounds::inside ( const Amg::Vector2D & locpo, double tol1 = 0., double tol2 = 0. ) const

overridevirtual

The orientation of the Diamond is according to the figure.

Implements Trk::SurfaceBounds.

Definition at line 155 of file RotatedDiamondBounds.cxx.

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

insideFull()

bool Trk::RotatedDiamondBounds::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 162 of file RotatedDiamondBounds.cxx.

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

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

insideLoc1()

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

overridevirtual

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::RotatedDiamondBounds::insideLoc2 ( const Amg::Vector2D & locpo, double tol2 = 0. ) const

overridevirtual

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::RotatedDiamondBounds::maxHalflengthX

(

)

const

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

medHalflengthX()

double Trk::RotatedDiamondBounds::medHalflengthX

(

)

const

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

minDistance()

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

overridevirtual

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

Implements Trk::SurfaceBounds.

Definition at line 203 of file RotatedDiamondBounds.cxx.

{
  const int Np = 6;
 
  double y1 = 2. * m_boundValues[RotatedDiamondBounds::bv_halfY1];
  double y2 = 2. * m_boundValues[RotatedDiamondBounds::bv_halfY2];
 
  double X[6] = { -m_boundValues[RotatedDiamondBounds::bv_minHalfX], -m_boundValues[RotatedDiamondBounds::bv_medHalfX],
                  -m_boundValues[RotatedDiamondBounds::bv_maxHalfX], m_boundValues[RotatedDiamondBounds::bv_maxHalfX],
                  m_boundValues[RotatedDiamondBounds::bv_medHalfX],  m_boundValues[RotatedDiamondBounds::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);
 
    // interchange locx and locy
    double x = X[i] - pos[1];
    double y = Y[i] - pos[0];
    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::RotatedDiamondBounds::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]

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

default

Assignment operator.

operator=() [2/2]

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

defaultnoexcept

Assignment operator.

operator==()

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

overridevirtual

Equality operator.

Implements Trk::SurfaceBounds.

Definition at line 55 of file RotatedDiamondBounds.cxx.

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

r()

virtual double Trk::RotatedDiamondBounds::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::RotatedDiamondBounds::type ( ) const

inlineoverridevirtual

Return the bounds type.

Implements Trk::SurfaceBounds.

Definition at line 84 of file RotatedDiamondBounds.h.

{ return SurfaceBounds::Diamond; }

Friends And Related Symbol Documentation

::RotatedDiamondBoundsCnv_p1

friend class ::RotatedDiamondBoundsCnv_p1

friend

Definition at line 136 of file RotatedDiamondBounds.h.

Member Data Documentation

m_alpha1

TDD_real_t Trk::RotatedDiamondBounds::m_alpha1

private

Definition at line 146 of file RotatedDiamondBounds.h.

m_alpha2

TDD_real_t Trk::RotatedDiamondBounds::m_alpha2

private

Definition at line 147 of file RotatedDiamondBounds.h.

m_boundValues

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

private

Internal parameters stored in the geometry.

Definition at line 145 of file RotatedDiamondBounds.h.

---

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

• RotatedDiamondBounds.h
• RotatedDiamondBounds.cxx