Trk::AnnulusBounds Class Reference

#include <AnnulusBounds.h>

Inheritance diagram for Trk::AnnulusBounds:

Collaboration diagram for Trk::AnnulusBounds:

Public Types
enum	BoundValues {   bv_minR = 0, bv_maxR = 1, bv_R = 2, bv_phi = 3,   bv_phiS = 4, bv_length = 5 }
	NB bv_R is the radius of the wafer centre which may different from the assumed surface centre. 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
	AnnulusBounds ()
	Default Constructor, needed for persistency. More...
	AnnulusBounds (double minR, double maxR, double R, double phi, double phiS)
	Constructor for AnnulusBounds. More...
	AnnulusBounds (const AnnulusBounds &annbo)=default
	Copy constructor. More...
AnnulusBounds &	operator= (const AnnulusBounds &sbo)=default
	Assignment operator. More...
	AnnulusBounds (AnnulusBounds &&annbo)=default
	Move constructor. More...
AnnulusBounds &	operator= (AnnulusBounds &&sbo)=default
	Move assignment. More...
virtual	~AnnulusBounds ()=default
	Destructor. More...
virtual AnnulusBounds *	clone () const override
	Virtual constructor. More...
virtual BoundsType	type () const override
	Return the type of the bounds for persistency. More...
bool	operator== (const SurfaceBounds &annbo) const override
	Equality operator. More...
double	minR () const
	This method returns the smaller radius. More...
double	maxR () const
	This method returns the bigger radius. More...
double	waferCentreR () const
	This method returns the R-parameter from design of sensors, which is the radius that the original centre of a silicon wafer ends up at. More...
double	phi () const
	This method returns the opening angle. More...
double	phiS () const
	This method returns the tilt angle. More...
std::array< std::pair< double, double >, 4 >	corners () const
	Returns the four corners of the bounds. 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
	This method returns the opening angle alpha in point A (negative local phi) 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
	Output Method for MsgStream. More...
virtual std::ostream &	dump (std::ostream &sl) const override
	Output Method for std::ostream. More...
std::array< TDD_real_t, 4 >	getEdgeLines () const
	Returns the gradient and y-intercept of the left and right module edges. More...
const std::vector< TDD_real_t > &	getBoundsValues ()
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...
virtual void	initCache ()
	virtual initCache method for object persistency More...

Static Private Member Functions
static bool	isAbove (const Amg::Vector2D &locpo, double tol1, double tol2, double x1, double y1, double x2, double y2)
	isAbove() method for checking whether a point lies above or under a straight line More...
static bool	isRight (const Amg::Vector2D &locpo, double tol1, double tol2, double x1, double y1, double x2, double y2)
static bool	isLeft (const Amg::Vector2D &locpo, double tol1, double tol2, double x1, double y1, double x2, double y2)
static bool	EllipseIntersectLine (const Amg::Vector2D &locpo, double h, double k, double x1, double y1, double x2, double y2)
static double	distanceToLine (const Amg::Vector2D &locpo, const std::vector< TDD_real_t > &P1, const std::vector< TDD_real_t > &P2)
	Distance to line. More...
static double	distanceToArc (const Amg::Vector2D &locpo, double R, const std::vector< TDD_real_t > &sL, const std::vector< TDD_real_t > &sR)
	Distance to arc. More...
static std::vector< double >	circleLineIntersection (double R, double k, double d)
	Circle and line intersection. More...

Private Attributes
std::vector< TDD_real_t >	m_boundValues
TDD_real_t	m_maxYout
TDD_real_t	m_minYout
TDD_real_t	m_maxXout
TDD_real_t	m_minXout
TDD_real_t	m_maxYin
TDD_real_t	m_minYin
TDD_real_t	m_maxXin
TDD_real_t	m_minXin
TDD_real_t	m_k_L
TDD_real_t	m_k_R
TDD_real_t	m_d_L
TDD_real_t	m_d_R
std::vector< TDD_real_t >	m_solution_L_min
std::vector< TDD_real_t >	m_solution_L_max
std::vector< TDD_real_t >	m_solution_R_min
std::vector< TDD_real_t >	m_solution_R_max

Detailed Description

Bounds for a annulus-like, planar Surface.

Todo:

can be speed optimized, inner radius check in inside() can be optimized

Author

Marci.nosp@m.n.Wo.nosp@m.lter@.nosp@m.cern.nosp@m..ch

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

NB bv_R is the radius of the wafer centre which may different from the assumed surface centre.

e.g. if a single wafer/sensor/mdodule has been split into multiple surfaces

• for readability

Enumerator
bv_minR
bv_maxR
bv_R
bv_phi
bv_phiS
bv_length

Definition at line 51 of file AnnulusBounds.h.

  {
    bv_minR = 0,
    bv_maxR = 1,
    bv_R = 2,
    bv_phi = 3,
    bv_phiS = 4,
    bv_length = 5
  };

Constructor & Destructor Documentation

AnnulusBounds() [1/4]

Trk::AnnulusBounds::AnnulusBounds

(

)

Default Constructor, needed for persistency.

Definition at line 127 of file AnnulusBounds.cxx.

  : //    Trk::SurfaceBounds()
  m_boundValues(AnnulusBounds::bv_length, 0.)
  , m_maxYout{}
  , m_minYout{}
  , m_maxXout{}
  , m_minXout{}
  , m_maxYin{}
  , m_minYin{}
  , m_maxXin{}
  , m_minXin{}
  , m_k_L{}
  , m_k_R{}
  , m_d_L{}
  , m_d_R{}
  , m_solution_L_min{}
  , m_solution_L_max{}
  , m_solution_R_min{}
  , m_solution_R_max{}
{
  //    nop
}

AnnulusBounds() [2/4]

Trk::AnnulusBounds::AnnulusBounds	(	double	minR,
		double	maxR,
		double	R,
		double	phi,
		double	phiS
	)

Constructor for AnnulusBounds.

Definition at line 151 of file AnnulusBounds.cxx.

  : m_boundValues(AnnulusBounds::bv_length, 0.)
{
  m_boundValues[AnnulusBounds::bv_minR] = std::fabs(minR);
  m_boundValues[AnnulusBounds::bv_maxR] = std::fabs(maxR);
  m_boundValues[AnnulusBounds::bv_R] = std::fabs(R);
  m_boundValues[AnnulusBounds::bv_phi] = std::fabs(phi);
  m_boundValues[AnnulusBounds::bv_phiS] = std::fabs(phiS);
  if (m_boundValues[AnnulusBounds::bv_minR] > m_boundValues[AnnulusBounds::bv_maxR])
    swap(m_boundValues[AnnulusBounds::bv_minR], m_boundValues[AnnulusBounds::bv_maxR]);
 
  m_k_L = std::tan((M_PI + phi) / 2. - phiS);
  m_k_R = std::tan((M_PI - phi) / 2. - phiS);
 
  m_d_L = R * std::sin(-phiS) * std::tan((M_PI - phi) / 2. + phiS) + R * (1. - std::cos(-phiS));
  m_d_R = R * std::sin(-phiS) * std::tan((M_PI + phi) / 2. + phiS) + R * (1. - std::cos(-phiS));
 
  // solving quadratic equation to find four corners of the AnnulusBounds
  m_solution_L_min = circleLineIntersection(minR, m_k_L, m_d_L); // Corner D
  m_solution_L_max = circleLineIntersection(maxR, m_k_L, m_d_L); // Corner C
  m_solution_R_min = circleLineIntersection(minR, m_k_R, m_d_R); // Corner A
  m_solution_R_max = circleLineIntersection(maxR, m_k_R, m_d_R); // Corner B
 
  std::vector<TDD_real_t> XX; // x co-ordinates of corners
  XX.push_back(m_solution_L_min[0]);
  XX.push_back(m_solution_L_max[0]);
  XX.push_back(m_solution_R_min[0]);
  XX.push_back(m_solution_R_max[0]);
 
  std::vector<TDD_real_t> YY; // y co-ordinates of corners
  YY.push_back(m_solution_L_min[1]);
  YY.push_back(m_solution_L_max[1]);
  YY.push_back(m_solution_R_min[1]);
  YY.push_back(m_solution_R_max[1]);
  YY.push_back(maxR);
 
  m_maxXout = *std::max_element(XX.begin(), XX.end());
  m_minXout = *std::min_element(XX.begin(), XX.end());
  m_maxYout = *std::max_element(YY.begin(), YY.end());
  m_minYout = *std::min_element(YY.begin(), YY.end());
 
  m_maxXin = std::min(m_solution_R_min[0], m_solution_R_max[0]);
  m_minXin = std::max(m_solution_L_min[0], m_solution_L_max[0]);
  m_maxYin = std::min(m_solution_R_max[1], m_solution_L_max[1]);
  m_minYin = minR;
}

AnnulusBounds() [3/4]

Trk::AnnulusBounds::AnnulusBounds ( const AnnulusBounds &  annbo )

default

Copy constructor.

AnnulusBounds() [4/4]

Trk::AnnulusBounds::AnnulusBounds ( AnnulusBounds &&  annbo )

default

Move constructor.

~AnnulusBounds()

virtual Trk::AnnulusBounds::~AnnulusBounds ( )

virtualdefault

Destructor.

Member Function Documentation

circleLineIntersection()

std::vector< double > Trk::AnnulusBounds::circleLineIntersection ( double  R, double  k, double  d  )

staticprivate

Circle and line intersection.

Circle is of radius R and centred at the origin. Line takes the form y = kx + d

Parameters

R	Radius of the circle
k	Gradient of the line
d	Intercept of the line

Returns

Co-ordinates of the intercept with highest y

Definition at line 461 of file AnnulusBounds.cxx.

{
  // change k, d -> phi, d
  // think: which of two intersection points to chose
  std::vector<double> solution;
  double x1;
  double y1;
  double x2;
  double y2;
 
  // Intersection of a line with an arc
  // equation:   (1+k^2)*x^2 + (2kd)x + d^2 - R^2 = 0
  //                a    x^2 +   b  x +     c     = 0
  double delta = 4. * k * d * k * d - 4. * (1 + k * k) * (d * d - R * R);
 
  if (delta < 0){
    return solution; // Does not intersect (imaginary solutions)
  }
    // at least 1 intersect
    // sol = (-b \pm sqrt(b^2 -4ac))/2a
    x1 = (-2. * k * d - std::sqrt(delta)) / (2. * (1 + k * k));
    x2 = (-2. * k * d + std::sqrt(delta)) / (2. * (1 + k * k)); 
    // y = grad*x * intercept
    y1 = k * x1 + d;
    y2 = k * x2 + d;
 
  // Set solution as the one with the highest y-co-ordinate
  if (y1 > y2) {
    solution.push_back(x1);
    solution.push_back(y1);
  } else {
    solution.push_back(x2);
    solution.push_back(y2);
  }
  return solution;
}

clone()

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

overridevirtual

Virtual constructor.

Implements Trk::SurfaceBounds.

corners()

std::array< std::pair< double, double >, 4 > Trk::AnnulusBounds::corners

(

)

const

Returns the four corners of the bounds.

Returns the module corners starting from the upper right (max R, pos locX) and proceding clock-wise, i.e. (max R; pos locX), (min R; pos locX), (min R; neg loc X), (max R; neg locX).

This method is only intended for debug purposes. If used for production code, this should be changed to a return-by-reference. This will necessitate the vector being stored in the class.

Returns

array of pairs of doubles giving the (R, x) of each corner clockwise from upper-right

Definition at line 615 of file AnnulusBounds.cxx.

                                                                     {
  
  std::array<std::pair<double, double>, 4> corners;
  
  corners[0]=std::make_pair(m_solution_R_max.at(0),m_solution_R_max.at(1));
  corners[1]=std::make_pair(m_solution_R_min.at(0),m_solution_R_min.at(1));
  corners[2]=std::make_pair(m_solution_L_min.at(0),m_solution_L_min.at(1));
  corners[3]=std::make_pair(m_solution_L_max.at(0),m_solution_L_max.at(1));
  
  return corners;
}

distanceToArc()

double Trk::AnnulusBounds::distanceToArc ( const Amg::Vector2D &  locpo, double  R, const std::vector< TDD_real_t > &  sL, const std::vector< TDD_real_t > &  sR  )

staticprivate

Distance to arc.

Definition at line 533 of file AnnulusBounds.cxx.

{
 
  double X = locpo[Trk::locX];
  double Y = locpo[Trk::locY];
 
  double tanlocPhi = X / Y;
  double tanPhi_L = sL[0] / sL[1];
  double tanPhi_R = sR[0] / sR[1];
 
  if (tanlocPhi > tanPhi_L && tanlocPhi < tanPhi_R){
    return std::fabs(std::sqrt(X * X + Y * Y) - R);
  }
 
  return 9999999999.;
}

distanceToLine()

double Trk::AnnulusBounds::distanceToLine ( const Amg::Vector2D &  locpo, const std::vector< TDD_real_t > &  P1, const std::vector< TDD_real_t > &  P2  )

staticprivate

Distance to line.

Definition at line 500 of file AnnulusBounds.cxx.

{
  double P1x = P1[0];
  double P1y = P1[1];
  double P2x = P2[0];
  double P2y = P2[1];
 
  double A = P2x - P1x;
  double B = P2y - P1y;
  double P3x;
  double P3y;
 
  double X = locpo[Trk::locX];
  double Y = locpo[Trk::locY];
 
  double u = (A * (X - P1x) + B * (Y - P1y)) / (A * A + B * B);
  if (u <= 0) {
    P3x = P1x;
    P3y = P1y;
  } else if (u >= 1) {
    P3x = P2x;
    P3y = P2y;
  } else {
    P3x = P1x + u * A;
    P3y = P1y + u * B;
  }
  return std::sqrt((X - P3x) * (X - P3x) + (Y - P3y) * (Y - P3y));
}

dump() [1/2]

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

overridevirtual

Output Method for MsgStream.

Implements Trk::SurfaceBounds.

Definition at line 628 of file AnnulusBounds.cxx.

{
  sl << std::setiosflags(std::ios::fixed);
  sl << std::setprecision(7);
  sl << "Trk::AnnulusBounds:  (minR, maxR, phi) = "
     << "(" << m_boundValues[AnnulusBounds::bv_minR] << ", " << m_boundValues[AnnulusBounds::bv_maxR] << ", "
     << m_boundValues[AnnulusBounds::bv_phi] << ")";
  sl << std::setprecision(-1);
  return sl;
}

dump() [2/2]

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

overridevirtual

Output Method for std::ostream.

Implements Trk::SurfaceBounds.

Definition at line 640 of file AnnulusBounds.cxx.

{
  sl << std::setiosflags(std::ios::fixed);
  sl << std::setprecision(7);
  sl << "Trk::AnnulusBounds:  (minR, maxR, phi) = "
     << "(" << m_boundValues[AnnulusBounds::bv_minR] << ", " << m_boundValues[AnnulusBounds::bv_maxR] << ", "
     << m_boundValues[AnnulusBounds::bv_phi] << ")";
  sl << std::setprecision(-1);
  return sl;
}

EllipseIntersectLine()

bool Trk::AnnulusBounds::EllipseIntersectLine ( const Amg::Vector2D &  locpo, double  h, double  k, double  x1, double  y1, double  x2, double  y2  )

staticprivate

Definition at line 555 of file AnnulusBounds.cxx.

{
  // h, k - ellipse axis (h - horizontal, k - vertical)
  // x1, y1, x2, y2 - define a line
 
  // Solving two equations
  // x*x/(h*h) + y*y/(k*k) = 1
  //
  // y = y1 + (y2-y1) * (x-x1) / (x2-x1)
  //
 
  // fast false - if the tolerance is zero
  if (h == 0 && k == 0)
    return false;
 
  double r;
  double s;
  double t;
  double m;
  double c;
  double d;
 
  x1 = x1 - locpo[Trk::locX];
  y1 = y1 - locpo[Trk::locY];
  x2 = x2 - locpo[Trk::locX];
  y2 = y2 - locpo[Trk::locY];
 
  //
  if (x1 != x2) {
    m = (y2 - y1) / (x2 - x1);
    c = y1 - m * x1;
 
    if (h == 0)
      return (std::fabs(c) < k);
    if (k == 0)
      return (std::fabs(c / m) < h);
 
    r = m * m * h * h + k * k;
    s = 2 * m * c * h * h;
    t = h * h * c * c - h * h * k * k;
 
    d = s * s - 4 * r * t;
 
  } else {
    //
    // vertical line case
    //
 
    d = std::fabs(x1) - h;
  }
 
  return (d >= 0.0); // intersection if d>=0
}

getBoundsValues()

const std::vector<TDD_real_t>& Trk::AnnulusBounds::getBoundsValues

(

)

getEdgeLines()

std::array< TDD_real_t, 4 > Trk::AnnulusBounds::getEdgeLines

(

)

const

Returns the gradient and y-intercept of the left and right module edges.

This method is only intended for debug purposes. If used for production code, this should be changed to a return-by-reference. This will necessitate the vector being stored in the class.

Returns

Vector with the gradients (m) and intercepts (c) of the left (_L) and right (_R) edges. [m_L, m_R, c_L, c_R]

This method is only intended for debug purposes. If used for production code, this should be changed to a return-by-reference. This will necessitate the vector being stored in the class.

Returns

Array with the gradients (m) and intercepts (c) of the left (_L) and right (_R) edges. [m_L, m_R, c_L, c_R]. Use as auto [m_L, m_R, c_L, c_R] = bounds.getEdgeLines();.

Definition at line 659 of file AnnulusBounds.cxx.

                                                            {
    std::array<TDD_real_t,4> returnArr{};
    returnArr[0]=m_k_L;
    returnArr[1]=m_k_R;
    returnArr[2]=m_d_L;
    returnArr[3]=m_d_R;
    return returnArr;
}

initCache()

virtual void Trk::SurfaceBounds::initCache ( )

inlineprotectedvirtualinherited

virtual initCache method for object persistency

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

Definition at line 129 of file SurfaceBounds.h.

{}

inside() [1/2]

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

finaloverridevirtual

Implements Trk::SurfaceBounds.

Definition at line 248 of file AnnulusBounds.cxx.

{
 
  if (bchk.bcType == 0 || bchk.nSigmas == 0)
    return AnnulusBounds::inside(locpo, bchk.toleranceLoc1, bchk.toleranceLoc2);
 
  sincosCache scResult = bchk.FastSinCos(locpo(1, 0));
 
  EllipseCollisionTest test(4);
 
  const Amg::Vector2D& locpoCar = locpo;
  AmgMatrix(2, 2) lCovarianceCar = bchk.lCovariance;
 
  // ellipse is always at (0,0), surface is moved to ellipse position and then rotated
  double w = bchk.nSigmas * std::sqrt(lCovarianceCar(0, 0));
  double h = bchk.nSigmas * std::sqrt(lCovarianceCar(1, 1));
 
  // a fast FALSE
  double maxTol = std::max(w, h);
  double minTol = std::min(w, h);
  double localY = locpo[Trk::locY];
  if (localY > (m_maxYout + maxTol) || localY < (m_minYout - maxTol))
    return false;
  // a fast FALSE
  double localX = locpo[Trk::locX];
  if (localX > (m_maxXout + maxTol) || localX < (m_minXout - maxTol))
    return false;
  // a fast TRUE
  if (localX > (m_minXin - minTol) && localX < (m_maxXin + minTol) && localY > (m_minYin - minTol) &&
      localY < (m_maxYin + minTol))
    return true;
 
  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 maxR = m_boundValues[AnnulusBounds::bv_maxR];
  double minR = m_boundValues[AnnulusBounds::bv_minR];
 
  bool condR = (test.collide(x0, y0, w, h, x1, y1, -minR) && test.collide(x0, y0, w, h, x1, y1, maxR));
 
  // compute KDOP and axes for surface polygon
  std::vector<KDOP> elementKDOP(4);
  std::vector<Amg::Vector2D> elementP(4);
 
  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;
  p << m_solution_L_min[0], m_solution_L_min[1];
  elementP[0] = (rotMatrix * (p - locpo));
 
  p << m_solution_L_max[0], m_solution_L_max[1];
  elementP[1] = (rotMatrix * (p - locpo));
 
  p << m_solution_R_max[0], m_solution_R_max[1];
  elementP[2] = (rotMatrix * (p - locpo));
 
  p << m_solution_R_min[0], m_solution_R_min[1];
  elementP[3] = (rotMatrix * (p - locpo));
 
  std::vector<Amg::Vector2D> axis = { normal * (elementP[0] - elementP[1]),
                                      normal * (elementP[1] - elementP[2]),
                                      normal * (elementP[2] - elementP[3]),
                                      normal * (elementP[3] - elementP[0]) };
  bchk.ComputeKDOP(elementP, axis, elementKDOP);
  // compute KDOP for error ellipse
  std::vector<KDOP> errelipseKDOP(4);
  bchk.ComputeKDOP(bchk.EllipseToPoly(4), axis, errelipseKDOP);
 
  bool condSide = bchk.TestKDOPKDOP(elementKDOP, errelipseKDOP);
 
  bool condLine =
    (isAbove(locpo, 0, 0, m_solution_L_max[0], m_solution_L_max[1], m_solution_R_max[0], m_solution_R_max[1]) &&
     isRight(locpo, 0, 0, m_solution_L_max[0], m_solution_L_max[1], m_solution_L_min[0], m_solution_L_min[1]) &&
     isLeft(locpo, 0, 0, m_solution_R_max[0], m_solution_R_max[1], m_solution_R_min[0], m_solution_R_min[1]));
 
  if (condLine){
    return condR;
  }
 
  return (condR && condSide);
}

inside() [2/2]

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

finaloverridevirtual

This method returns the opening angle alpha in point A (negative local phi)

This method returns the opening angle beta in point B (positive local phi) 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) \( y \) or \( x \) bounds are 0 || 0
(1) LocalPosition is outside \( y \) bounds
(2) LocalPosition is inside \( y \) bounds, but outside maximum \( x \) bounds
(3) LocalPosition is inside \( y \) bounds AND inside minimum \( x \) bounds
(4) LocalPosition is inside \( y \) bounds AND inside maximum \( x \) bounds, so that it depends on the \( eta \) 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 \( x \) half area(I) or the negative one(II). Denoting \( |x_{min}| \) and \( | x_{max} | \) as minHalfX respectively maxHalfX, such as \( | y_{H} | \) as halfY, 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} = 2 \frac{y_{H}}{x_{max} - x_{min}} \)
  and \( \delta_{I} = \delta_{II} = - \frac{1}{2}\kappa_{I}(x_{max} + x_{min}) \)
  

Implements Trk::SurfaceBounds.

Definition at line 210 of file AnnulusBounds.cxx.

{
  // a fast FALSE
  double localY = locpo[Trk::locY];
  if (localY > (m_maxYout + tol2) || localY < (m_minYout - tol2))
    return false;
  // a fast FALSE
  double localX = locpo[Trk::locX];
  if (localX > (m_maxXout + tol1) || localX < (m_minXout - tol1))
    return false;
  // a fast TRUE
  if (localX > (m_minXin - tol1) && localX < (m_maxXin + tol1) && localY > (m_minYin - tol2) &&
      localY < (m_maxYin + tol2))
    return true;
 
  //    if (this->minDistance(locpo)>std::max(tol1,tol2)) return false;
 
  double localR2 = localX * localX + localY * localY;
  double localR = std::sqrt(localR2);
  double localCos = localX / localR;
  double localSin = localY / localR;
  double deltaR = std::sqrt(tol2 * tol2 * localSin * localSin + tol1 * tol1 * localCos * localCos);
 
  double minR = m_boundValues[AnnulusBounds::bv_minR];
  double maxR = m_boundValues[AnnulusBounds::bv_maxR];
 
  bool condRad = (localR < maxR + deltaR && localR > minR - deltaR);
  bool condL =
    (isRight(locpo, tol1, tol2, m_solution_L_max[0], m_solution_L_max[1], m_solution_L_min[0], m_solution_L_min[1]));
  bool condR =
    (isLeft(locpo, tol1, tol2, m_solution_R_max[0], m_solution_R_max[1], m_solution_R_min[0], m_solution_R_min[1]));
 
  return (condRad && condL && condR);
}

insideLoc1()

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

isAbove()

bool Trk::AnnulusBounds::isAbove ( const Amg::Vector2D &  locpo, double  tol1, double  tol2, double  x1, double  y1, double  x2, double  y2  )

staticprivate

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

Definition at line 344 of file AnnulusBounds.cxx.

{
  if (x2 != x1) {
    double k = (y2 - y1) / (x2 - x1);
    double d = y1 - k * x1;
    // the most tolerant approach for tol1 and tol2
    double sign = k > 0. ? -1. : +1.;
    return (locpo[Trk::locY] + tol2 > (k * (locpo[Trk::locX] + sign * tol1) + d));
  }
    return false;
}

isLeft()

bool Trk::AnnulusBounds::isLeft ( const Amg::Vector2D &  locpo, double  tol1, double  tol2, double  x1, double  y1, double  x2, double  y2  )

staticprivate

Definition at line 394 of file AnnulusBounds.cxx.

{
 
  if (x1 != x2) {
    double k = (y2 - y1) / (x2 - x1);
    double d = y1 - k * x1;
 
    if (k < 0){
      return (locpo[Trk::locY] < (k * locpo[Trk::locX] + d) ||
              EllipseIntersectLine(locpo, tol1, tol2, x1, y1, x2, y2));
    }
    if (k > 0){
      return (locpo[Trk::locY] > (k * locpo[Trk::locX] + d) ||
              EllipseIntersectLine(locpo, tol1, tol2, x1, y1, x2, y2));
    }
 
    return false;
  }
  return (locpo[Trk::locX] < x1 ||
          EllipseIntersectLine(locpo, tol1, tol2, x1, y1, x2, y2));
}

isRight()

bool Trk::AnnulusBounds::isRight ( const Amg::Vector2D &  locpo, double  tol1, double  tol2, double  x1, double  y1, double  x2, double  y2  )

staticprivate

Definition at line 364 of file AnnulusBounds.cxx.

{
 
  if (x1 != x2) {
    double k = (y2 - y1) / (x2 - x1);
    double d = y1 - k * x1;
 
    if (k > 0){
      return (locpo[Trk::locY] < (k * locpo[Trk::locX] + d) ||
              EllipseIntersectLine(locpo, tol1, tol2, x1, y1, x2, y2));
    }
    if (k < 0){
      return (locpo[Trk::locY] > (k * locpo[Trk::locX] + d) ||
              EllipseIntersectLine(locpo, tol1, tol2, x1, y1, x2, y2));
    }
 
    return false;
  }
  return (locpo[Trk::locX] > x1 ||
          EllipseIntersectLine(locpo, tol1, tol2, x1, y1, x2, y2));
}

maxR()

double Trk::AnnulusBounds::maxR

(

)

const

This method returns the bigger radius.

minDistance()

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

finaloverridevirtual

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

Implements Trk::SurfaceBounds.

Definition at line 423 of file AnnulusBounds.cxx.

{
 
  // Calculate four corner points - crossings of an arc with a line
  double minR = m_boundValues[AnnulusBounds::bv_minR];
  double maxR = m_boundValues[AnnulusBounds::bv_maxR];
 
  // distance to left and right line
  double distLine_L = distanceToLine(locpo, m_solution_L_min, m_solution_L_max);
  double distLine_R = distanceToLine(locpo, m_solution_R_min, m_solution_R_max);
 
  double dist = std::min(distLine_L, distLine_R);
 
  // calculate distance to both arcs
  double distMin = distanceToArc(locpo, minR, m_solution_L_min, m_solution_R_min);
  double distMax = distanceToArc(locpo, maxR, m_solution_L_max, m_solution_R_max);
 
  double distArc = std::min(distMin, distMax);
 
  dist = std::min(dist, distArc);
 
  if (inside(locpo, 0., 0.)){
    dist = -dist;
  }
  return dist;
}

minR()

double Trk::AnnulusBounds::minR

(

)

const

This method returns the smaller radius.

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]

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

default

Move assignment.

operator=() [2/2]

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

default

Assignment operator.

operator==()

bool Trk::AnnulusBounds::operator== ( const SurfaceBounds &  annbo ) const

overridevirtual

Equality operator.

Implements Trk::SurfaceBounds.

Definition at line 199 of file AnnulusBounds.cxx.

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

phi()

double Trk::AnnulusBounds::phi

(

)

const

This method returns the opening angle.

phiS()

double Trk::AnnulusBounds::phiS

(

)

const

This method returns the tilt angle.

r()

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

inlineoverridevirtual

Return the type of the bounds for persistency.

Implements Trk::SurfaceBounds.

Definition at line 82 of file AnnulusBounds.h.

{ return SurfaceBounds::Annulus; }

waferCentreR()

double Trk::AnnulusBounds::waferCentreR

(

)

const

This method returns the R-parameter from design of sensors, which is the radius that the original centre of a silicon wafer ends up at.

It is therefore common to all surfaces on the same wafer and can be different from the assume surface centre

Member Data Documentation

m_boundValues

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

private

Definition at line 224 of file AnnulusBounds.h.

m_d_L

TDD_real_t Trk::AnnulusBounds::m_d_L

private

Definition at line 238 of file AnnulusBounds.h.

m_d_R

TDD_real_t Trk::AnnulusBounds::m_d_R

private

Definition at line 239 of file AnnulusBounds.h.

m_k_L

TDD_real_t Trk::AnnulusBounds::m_k_L

private

Definition at line 236 of file AnnulusBounds.h.

m_k_R

TDD_real_t Trk::AnnulusBounds::m_k_R

private

Definition at line 237 of file AnnulusBounds.h.

m_maxXin

TDD_real_t Trk::AnnulusBounds::m_maxXin

private

Definition at line 233 of file AnnulusBounds.h.

m_maxXout

TDD_real_t Trk::AnnulusBounds::m_maxXout

private

Definition at line 228 of file AnnulusBounds.h.

m_maxYin

TDD_real_t Trk::AnnulusBounds::m_maxYin

private

Definition at line 231 of file AnnulusBounds.h.

m_maxYout

TDD_real_t Trk::AnnulusBounds::m_maxYout

private

Definition at line 226 of file AnnulusBounds.h.

m_minXin

TDD_real_t Trk::AnnulusBounds::m_minXin

private

Definition at line 234 of file AnnulusBounds.h.

m_minXout

TDD_real_t Trk::AnnulusBounds::m_minXout

private

Definition at line 229 of file AnnulusBounds.h.

m_minYin

TDD_real_t Trk::AnnulusBounds::m_minYin

private

Definition at line 232 of file AnnulusBounds.h.

m_minYout

TDD_real_t Trk::AnnulusBounds::m_minYout

private

Definition at line 227 of file AnnulusBounds.h.

m_solution_L_max

std::vector<TDD_real_t> Trk::AnnulusBounds::m_solution_L_max

private

Definition at line 242 of file AnnulusBounds.h.

m_solution_L_min

std::vector<TDD_real_t> Trk::AnnulusBounds::m_solution_L_min

private

Definition at line 241 of file AnnulusBounds.h.

m_solution_R_max

std::vector<TDD_real_t> Trk::AnnulusBounds::m_solution_R_max

private

Definition at line 244 of file AnnulusBounds.h.

m_solution_R_min

std::vector<TDD_real_t> Trk::AnnulusBounds::m_solution_R_min

private

Definition at line 243 of file AnnulusBounds.h.

---

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

• AnnulusBounds.h
• AnnulusBounds.cxx