Trk::AnnulusBoundsPC Class Reference

Class that implements the asymmetric shape of the ITk strip endcap modules. More...

#include <AnnulusBoundsPC.h>

Inheritance diagram for Trk::AnnulusBoundsPC:

Collaboration diagram for Trk::AnnulusBoundsPC:

Public Types
enum	BoundValues {   bv_minR , bv_maxR , bv_phiMin , bv_phiMax ,   bv_phiAvg , bv_originX , bv_originY }
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
	AnnulusBoundsPC (double minR, double maxR, double phiMin, double phiMax, Amg::Vector2D moduleOrigin={0, 0}, double phiAvg=0)
	Default constructor from parameters.
	AnnulusBoundsPC (const AnnulusBoundsPC &annbo)=default
	Copy constructor.
AnnulusBoundsPC &	operator= (const AnnulusBoundsPC &sbo)=default
	Assignment operator.
	AnnulusBoundsPC (AnnulusBoundsPC &&annbo)=default
	Move constructor.
AnnulusBoundsPC &	operator= (AnnulusBoundsPC &&sbo)=default
	Move assignment.
virtual AnnulusBoundsPC *	clone () const override
	clone() method to make deep copy in Surface copy constructor and for assigment operator of the Surface class.
bool	operator== (const SurfaceBounds &sb) const override
	Equality operator.
SurfaceBounds::BoundsType	type () const override
	Return the bounds type - for persistency optimization.
bool	inside (const Amg::Vector2D &locpo, double tol1=0., double tol2=0.) const override final
	Returns if a point in local coordinates is inside the bounds.
bool	inside (const Amg::Vector2D &locpo, const BoundaryCheck &bchk) const override final
	Returns if a point in local coordinates is inside the bounds.
bool	insideLoc1 (const Amg::Vector2D &locpo, double tol1=0.) const override final
	Check if local point is inside of r bounds.
bool	insideLoc2 (const Amg::Vector2D &locpo, double tol2=0.) const override final
	Check if local point is inside of phi bounds.
double	minDistance (const Amg::Vector2D &locpo) const override final
	Return minimum distance a point is away from the bounds.
double	r () const override
	Returns middle radius.
double	rMin () const
	Returns inner radial bounds (module system)
double	rMax () const
	Returns outer radial bounds (module system)
double	phiMin () const
	Returns the right angular edge of the module.
double	phiMax () const
	Returns the left angular edge of the module.
Amg::Vector2D	moduleOrigin () const
	Returns moduleOrigin, but rotated out, so avgPhi is already considered.
MsgStream &	dump (MsgStream &sl) const override
	helper which dumps the configuration into a stream.
std::ostream &	dump (std::ostream &sl) const override
	Output Method for std::ostream, to be overloaded by child classes.
std::array< std::pair< double, double >, 4 >	corners () const
	Returns the four corners of the bounds.
virtual bool	operator!= (const SurfaceBounds &sb) const
	Non-Equality operator.

Static Public Member Functions
static std::pair< AnnulusBoundsPC, double >	fromCartesian (const AnnulusBounds &annbo)
	Static factory method to produce an instance of this class from the cartesian implementation.

Protected Member Functions
void	swap (double &b1, double &b2)
	Swap method to be called from DiscBounds or TrapezoidalBounds.
virtual void	initCache ()
	virtual initCache method for object persistency

Private Types
using	Rotation2D = Eigen::Rotation2D<double>
using	Transform2D = Eigen::Transform<double, 2, Eigen::Affine>
using	Matrix2D = Eigen::Matrix<double, 2, 2>

Private Member Functions
Amg::Vector2D	stripXYToModulePC (const Amg::Vector2D &vStripXY) const

Static Private Member Functions
static Amg::Vector2D	closestOnSegment (const Amg::Vector2D &a, const Amg::Vector2D &b, const Amg::Vector2D &p, const Eigen::Matrix< double, 2, 2 > &weight)
static double	squaredNorm (const Amg::Vector2D &v, const Eigen::Matrix< double, 2, 2 > &weight)

Private Attributes
friend	AnnulusTestAlg
double	m_minR
double	m_maxR
double	m_phiMin
double	m_phiMax
Amg::Vector2D	m_moduleOrigin
Amg::Vector2D	m_shiftXY
Amg::Vector2D	m_shiftPC
double	m_phiAvg
Transform2D	m_rotationStripPC
Transform2D	m_translation
Amg::Vector2D	m_outLeftStripPC
Amg::Vector2D	m_inLeftStripPC
Amg::Vector2D	m_outRightStripPC
Amg::Vector2D	m_inRightStripPC
Amg::Vector2D	m_outLeftModulePC
Amg::Vector2D	m_inLeftModulePC
Amg::Vector2D	m_outRightModulePC
Amg::Vector2D	m_inRightModulePC
Amg::Vector2D	m_outLeftStripXY
Amg::Vector2D	m_inLeftStripXY
Amg::Vector2D	m_outRightStripXY
Amg::Vector2D	m_inRightStripXY
std::vector< TDD_real_t >	m_boundValues

Detailed Description

Class that implements the asymmetric shape of the ITk strip endcap modules.

Definition at line 30 of file AnnulusBoundsPC.h.

Member Typedef Documentation

Matrix2D

using Trk::AnnulusBoundsPC::Matrix2D = Eigen::Matrix<double, 2, 2>

private

Definition at line 34 of file AnnulusBoundsPC.h.

Rotation2D

using Trk::AnnulusBoundsPC::Rotation2D = Eigen::Rotation2D<double>

private

Definition at line 32 of file AnnulusBoundsPC.h.

Transform2D

using Trk::AnnulusBoundsPC::Transform2D = Eigen::Transform<double, 2, Eigen::Affine>

private

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

Enumerator
bv_minR
bv_maxR
bv_phiMin
bv_phiMax
bv_phiAvg
bv_originX
bv_originY

Definition at line 40 of file AnnulusBoundsPC.h.

                   {
    bv_minR,
    bv_maxR,
    bv_phiMin,
    bv_phiMax,
    bv_phiAvg,
    bv_originX,
    bv_originY
  };

Constructor & Destructor Documentation

AnnulusBoundsPC() [1/3]

Trk::AnnulusBoundsPC::AnnulusBoundsPC	(	double	minR,
		double	maxR,
		double	phiMin,
		double	phiMax,
		Amg::Vector2D	moduleOrigin = {0, 0},
		double	phiAvg = 0 )

Default constructor from parameters.

Parameters

minR	inner radius, in module system
maxR	outer radius, in module system
phiMin	right angular edge, in strip system
phiMax	left angular edge, in strip system
moduleOrigin	The origin offset between the two systems.
phiAvg	(Optional) internal rotation of this bounds object's local frame

Note

For moduleOrigin you need to actually calculate the cartesian offset

Definition at line 11 of file AnnulusBoundsPC.cxx.

  : m_minR(minR),
    m_maxR(maxR),
    m_phiMin(phiMin),
    m_phiMax(phiMax),
    m_moduleOrigin(moduleOrigin),
    m_phiAvg(phiAvg)
{
 
  m_boundValues.resize(7);
  m_boundValues[AnnulusBoundsPC::bv_minR] = minR;
  m_boundValues[AnnulusBoundsPC::bv_maxR] = maxR;
  m_boundValues[AnnulusBoundsPC::bv_phiMin] = phiMin;
  m_boundValues[AnnulusBoundsPC::bv_phiMax] = phiMax;
  m_boundValues[AnnulusBoundsPC::bv_phiAvg] = phiAvg;
  m_boundValues[AnnulusBoundsPC::bv_originX] = moduleOrigin.x();
  m_boundValues[AnnulusBoundsPC::bv_originY] = moduleOrigin.y();
 
  m_rotationStripPC = Eigen::Translation<double, 2>(Amg::Vector2D(0, -m_phiAvg));
  m_translation = Eigen::Translation<double, 2>(m_moduleOrigin);
 
  m_shiftXY = m_moduleOrigin * -1;
  m_shiftPC = Amg::Vector2D(m_shiftXY.perp(), m_shiftXY.phi());
 
  // we need the corner points of the module to do the inside
  // checking, calculate them here once, they don't change
 
  // find inner outter radius at edges in STRIP PC
  auto circIx = [](double O_x, double O_y, double r, double phi)
    -> Amg::Vector2D {
    //                      _____________________________________________
    //                     /      2  2                    2    2  2    2
    //     O_x + O_y*m - \/  - O_x *m  + 2*O_x*O_y*m - O_y  + m *r  + r
    // x = --------------------------------------------------------------
    //                                  2
    //                                 m  + 1
    //
    // y = m*x
    //
    double m = std::tan(phi);
    Amg::Vector2D dir(std::cos(phi), std::sin(phi));
    double x1 = (O_x + O_y*m - std::sqrt(-std::pow(O_x, 2)*std::pow(m, 2) + 2*O_x*O_y*m - std::pow(O_y, 2) + std::pow(m, 2)*std::pow(r, 2) + std::pow(r, 2)))/(std::pow(m, 2) + 1);
    double x2 = (O_x + O_y*m + std::sqrt(-std::pow(O_x, 2)*std::pow(m, 2) + 2*O_x*O_y*m - std::pow(O_y, 2) + std::pow(m, 2)*std::pow(r, 2) + std::pow(r, 2)))/(std::pow(m, 2) + 1);
 
    Amg::Vector2D v1(x1, m*x1);
    if(v1.dot(dir) > 0) return v1;
    return {x2, m*x2};
  };
 
  // calculate corners in STRIP XY, keep them we need them for minDistance()
  m_outLeftStripXY = circIx(m_moduleOrigin[Trk::locX], m_moduleOrigin[Trk::locY], m_maxR, m_phiMax);
  m_inLeftStripXY = circIx(m_moduleOrigin[Trk::locX], m_moduleOrigin[Trk::locY], m_minR, m_phiMax);
  m_outRightStripXY = circIx(m_moduleOrigin[Trk::locX], m_moduleOrigin[Trk::locY], m_maxR, m_phiMin);
  m_inRightStripXY = circIx(m_moduleOrigin[Trk::locX], m_moduleOrigin[Trk::locY], m_minR, m_phiMin);
 
  m_outLeftStripPC = {m_outLeftStripXY.norm(), m_outLeftStripXY.phi()};
  m_inLeftStripPC = {m_inLeftStripXY.norm(), m_inLeftStripXY.phi()};
  m_outRightStripPC = {m_outRightStripXY.norm(), m_outRightStripXY.phi()};
  m_inRightStripPC= {m_inRightStripXY.norm(), m_inRightStripXY.phi()};
 
  m_outLeftModulePC = stripXYToModulePC(m_outLeftStripXY);
  m_inLeftModulePC = stripXYToModulePC(m_inLeftStripXY);
  m_outRightModulePC = stripXYToModulePC(m_outRightStripXY);
  m_inRightModulePC = stripXYToModulePC(m_inRightStripXY);
}

AnnulusBoundsPC() [2/3]

Trk::AnnulusBoundsPC::AnnulusBoundsPC ( const AnnulusBoundsPC & annbo )

default

Copy constructor.

AnnulusBoundsPC() [3/3]

Trk::AnnulusBoundsPC::AnnulusBoundsPC ( AnnulusBoundsPC && annbo )

default

Move constructor.

Member Function Documentation

clone()

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

overridevirtual

clone() method to make deep copy in Surface copy constructor and for assigment operator of the Surface class.

Implements Trk::SurfaceBounds.

closestOnSegment()

Amg::Vector2D Trk::AnnulusBoundsPC::closestOnSegment ( const Amg::Vector2D & a, const Amg::Vector2D & b, const Amg::Vector2D & p, const Eigen::Matrix< double, 2, 2 > & weight )

staticprivate

Definition at line 505 of file AnnulusBoundsPC.cxx.

{
  // connecting vector
  auto     n       = b - a;
  // squared norm of line
  auto     f       = (n.transpose() * weight * n).value();
  // weighted scalar product of line to point and segment line
  auto     u       = ((p - a).transpose() * weight * n).value() / f;
  // clamp to [0, 1], convert to point
  return std::min(std::max(u, 0.0), 1.0) * n + a;
}

corners()

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

(

)

const

Returns the four corners of the bounds.

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

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, phi) of each corner clockwise from upper-right

Definition at line 480 of file AnnulusBoundsPC.cxx.

                                  {
  auto rot = m_rotationStripPC.inverse();
 
  auto to_pair = [](const Amg::Vector2D& v) -> std::pair<double, double>
  {
    return {v[0], v[1]};
  };
 
  return {
    to_pair(rot * m_outRightStripPC),
    to_pair(rot * m_outLeftStripPC),
    to_pair(rot * m_inLeftStripPC),
    to_pair(rot * m_inRightStripPC)
  };
 
}

dump() [1/2]

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

overridevirtual

helper which dumps the configuration into a stream.

Parameters

sl	The stream

Returns

the stream given in sl

Implements Trk::SurfaceBounds.

Definition at line 454 of file AnnulusBoundsPC.cxx.

{
  std::stringstream ss;
  dump(ss);
  sl << ss.str();
  return sl;
}

dump() [2/2]

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

overridevirtual

Output Method for std::ostream, to be overloaded by child classes.

Implements Trk::SurfaceBounds.

Definition at line 462 of file AnnulusBoundsPC.cxx.

{
  sl << std::setiosflags(std::ios::fixed);
  sl << std::setprecision(7);
  sl << "Trk::AnnulusBoundsPC:  (minR, maxR, phiMin, phiMax, phiAvg, origin(x, y)) = " << "(" ;
  sl << m_boundValues[AnnulusBoundsPC::bv_minR] << ", ";
  sl << m_boundValues[AnnulusBoundsPC::bv_maxR] << ", ";
  sl << m_boundValues[AnnulusBoundsPC::bv_phiMin] << ", ";
  sl << m_boundValues[AnnulusBoundsPC::bv_phiMax] << ", ";
  sl << m_boundValues[AnnulusBoundsPC::bv_phiAvg] << ", ";
  sl << m_boundValues[AnnulusBoundsPC::bv_originX] << ", ";
  sl << m_boundValues[AnnulusBoundsPC::bv_originY];
  sl << ")";
  sl << std::setprecision(-1);
  return sl;
}

fromCartesian()

std::pair< Trk::AnnulusBoundsPC, double > Trk::AnnulusBoundsPC::fromCartesian ( const AnnulusBounds & annbo )

static

Static factory method to produce an instance of this class from the cartesian implementation.

Parameters

annbo

A reference to the original cartesian bounds object

Returns

pair containing the PC bounds, and an angular shift phiShift

Note

The local frame of the cartesian implementation is such that the module sits around the y-axis. This implementation sits around the x axis. The local frame needs to be rotated to account for this. phiShift contains necessary information to (re)construct a transform that will perform this rotation.

Definition at line 83 of file AnnulusBoundsPC.cxx.

{
  auto [k_L, k_R, d_L, d_R] = annbo.getEdgeLines();
 
  double O_x = (d_L - d_R) / (k_R - k_L);
  double O_y = std::fma(O_x, k_L, d_L); // O_x * k_L + d_L
  Amg::Vector2D originStripXY(-O_x, -O_y);
 
  const auto& bounds = annbo.getBoundsValues();
 
  double minR = bounds[AnnulusBounds::bv_minR];
  double maxR = bounds[AnnulusBounds::bv_maxR];
  double phi = bounds[AnnulusBounds::bv_phi];
  double phiS = bounds[AnnulusBounds::bv_phiS];
  double phiAvg = 0; // phiAvg is the bounds-internal local rotation. We don't want one
 
  // phi is the total opening angle, set up symmetric phi bounds
  double phiMax = phi/2.0;
  double phiMin = -phiMax;
 
  // need to rotate pi/2 to reproduce ABCartesian orientation, phiS so that phi=0 is center and symmetric
  double phiShift = M_PI_2 - phiS;
 
  // we need to rotate the origin into the bounds local coordinate system
  Transform2D avgPhiRotation;
  avgPhiRotation = Rotation2D(-phiShift);
  Amg::Vector2D originStripXYRotated = avgPhiRotation * originStripXY;
 
  AnnulusBoundsPC abpc(minR,
                       maxR,
                       phiMin,
                       phiMax,
                       originStripXYRotated,
                       phiAvg);
 
  return std::make_pair(std::move(abpc), phiShift);
}

initCache()

virtual void Trk::SurfaceBounds::initCache ( )

inlineprotectedvirtualinherited

virtual initCache method for object persistency

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

Definition at line 129 of file SurfaceBounds.h.

{}

inside() [1/2]

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

finaloverridevirtual

Returns if a point in local coordinates is inside the bounds.

Parameters

locpo	Local position
bchk	The boundary check object to consult for inside checks

Returns

true if is inside, false if not

Implements Trk::SurfaceBounds.

Definition at line 161 of file AnnulusBoundsPC.cxx.

{
 
  // locpo is PC in STRIP SYSTEM
 
  if(bchk.bcType == BoundaryCheck::absolute) {
    // unpack tolerances and use other methods
    if(bchk.checkLoc1 && bchk.checkLoc2) {
      return inside(locpo, bchk.toleranceLoc1, bchk.toleranceLoc2);
    }
    else {
      if(bchk.checkLoc1) {
        return insideLoc1(locpo, bchk.toleranceLoc1);
      }
      else /* bchk.checkLoc2 */ {
        return insideLoc2(locpo, bchk.toleranceLoc2);
      }
    }
  }
  else {
    // first check if inside. We don't need to look into the covariance if inside
    if(inside(locpo)) {
      return true;
    }
 
    // we need to rotated the locpo
    Amg::Vector2D locpo_rotated = m_rotationStripPC * locpo;
 
    // covariance is given in STRIP SYSTEM in PC
    // we need to convert the covariance to the MODULE SYSTEM in PC
    // via jacobian.
    // The following transforms into STRIP XY, does the shift into MODULE XY,
    // and then transforms into MODULE PC
    double dphi = m_phiAvg;
    double phi_strip = locpo_rotated[Trk::locPhi];
    double r_strip = locpo_rotated[Trk::locR];
    double O_x = m_shiftXY[Trk::locX];
    double O_y = m_shiftXY[Trk::locY];
 
    // For a transformation from cartesian into polar coordinates
    //
    //              [         _________      ]
    //              [        /  2    2       ]
    //              [      \/  x  + y        ]
    //     [ r' ]   [                        ]
    // v = [    ] = [      /       y        \]
    //     [phi']   [2*atan|----------------|]
    //              [      |       _________|]
    //              [      |      /  2    2 |]
    //              [      \x + \/  x  + y  /]
    //
    // Where x, y are polar coordinates that can be rotated by dPhi
    //
    // [x]   [O_x + r*cos(dPhi - phi)]
    // [ ] = [                       ]
    // [y]   [O_y - r*sin(dPhi - phi)]
    //
    // The general jacobian is:
    //
    //        [d        d      ]
    //        [--(f_x)  --(f_x)]
    //        [dx       dy     ]
    // Jgen = [                ]
    //        [d        d      ]
    //        [--(f_y)  --(f_y)]
    //        [dx       dy     ]
    //
    // which means in this case:
    //
    //     [     d                   d           ]
    //     [ ----------(rMod)    ---------(rMod) ]
    //     [ dr_{strip}          dphiStrip       ]
    // J = [                                     ]
    //     [    d                   d            ]
    //     [----------(phiMod)  ---------(phiMod)]
    //     [dr_{strip}          dphiStrip        ]
    //
    // Performing the derivative one gets:
    //
    //     [B*O_x + C*O_y + rStrip  rStrip*(B*O_y + O_x*sin(dPhi - phiStrip))]
    //     [----------------------  -----------------------------------------]
    //     [          ___                               ___                  ]
    //     [        \/ A                              \/ A                   ]
    // J = [                                                                 ]
    //     [  -(B*O_y - C*O_x)           rStrip*(B*O_x + C*O_y + rStrip)     ]
    //     [  -----------------          -------------------------------     ]
    //     [          A                                 A                    ]
    //
    // where
    //        2                                          2                                             2
    // A = O_x  + 2*O_x*rStrip*cos(dPhi - phiStrip) + O_y  - 2*O_y*rStrip*sin(dPhi - phiStrip) + rStrip
    // B = cos(dPhi - phiStrip)
    // C = -sin(dPhi - phiStrip)
 
    double cosDPhiPhiStrip = std::cos(dphi - phi_strip);
    double sinDPhiPhiStrip = std::sin(dphi - phi_strip);
 
    double A = O_x*O_x + 2*O_x*r_strip*cosDPhiPhiStrip
      + O_y*O_y - 2*O_y*r_strip*sinDPhiPhiStrip
      + r_strip*r_strip;
    double sqrtA = std::sqrt(A);
 
 
    double B = cosDPhiPhiStrip;
    double C = -sinDPhiPhiStrip;
    Eigen::Matrix<double, 2, 2> jacobianStripPCToModulePC;
    jacobianStripPCToModulePC(0, 0) = (B*O_x + C*O_y + r_strip)/sqrtA;
    jacobianStripPCToModulePC(0, 1) = r_strip*(B*O_y + O_x*sinDPhiPhiStrip)/sqrtA;
    jacobianStripPCToModulePC(1, 0) = -(B*O_y - C*O_x)/A;
    jacobianStripPCToModulePC(1, 1) = r_strip*(B*O_x + C*O_y + r_strip)/A;
 
    // covariance is given in STRIP PC
    Matrix2D covStripPC = bchk.lCovariance;
    // calculate covariance in MODULE PC using jacobian from above
    Matrix2D covModulePC;
    covModulePC = jacobianStripPCToModulePC * covStripPC * jacobianStripPCToModulePC.transpose();
 
    // Mahalanobis distance uses inverse covariance as weights
    Matrix2D weightStripPC = covStripPC.inverse();
    Matrix2D weightModulePC = covModulePC.inverse();
 
 
    double minDist = std::numeric_limits<double>::max();
 
    Amg::Vector2D currentClosest;
    double currentDist{0.0}; // initialise to zero
 
    // do projection in STRIP PC
 
    // first: STRIP system. locpo is in STRIP PC already
    currentClosest = closestOnSegment(m_inLeftStripPC, m_outLeftStripPC, locpo_rotated, weightStripPC);
    currentDist = squaredNorm(locpo_rotated-currentClosest, weightStripPC);
    minDist = currentDist;
 
    currentClosest = closestOnSegment(m_inRightStripPC, m_outRightStripPC, locpo_rotated, weightStripPC);
    currentDist = squaredNorm(locpo_rotated-currentClosest, weightStripPC);
    if(currentDist < minDist) {
      minDist = currentDist;
    }
 
    // now: MODULE system. Need to transform locpo to MODULE PC
    //  transform is STRIP PC -> STRIP XY -> MODULE XY -> MODULE PC
    Amg::Vector2D locpoStripXY(locpo_rotated[Trk::locR]*std::cos(locpo_rotated[Trk::locPhi]),
                               locpo_rotated[Trk::locR]*std::sin(locpo_rotated[Trk::locPhi]));
    Amg::Vector2D locpoModulePC = stripXYToModulePC(locpoStripXY);
 
 
    // now check edges in MODULE PC (inner and outer circle)
    // assuming Mahalanobis distances are of same unit if covariance
    // is correctly transformed
    currentClosest = closestOnSegment(m_inLeftModulePC, m_inRightModulePC, locpoModulePC, weightModulePC);
    currentDist = squaredNorm(locpoModulePC-currentClosest, weightModulePC);
    if(currentDist < minDist) {
      minDist = currentDist;
    }
 
    currentClosest = closestOnSegment(m_outLeftModulePC, m_outRightModulePC, locpoModulePC, weightModulePC);
    currentDist = squaredNorm(locpoModulePC-currentClosest, weightModulePC);
    if(currentDist < minDist) {
      minDist = currentDist;
    }
 
    // compare resulting Mahalanobis distance to configured
    // "number of sigmas"
    // we square it b/c we never took the square root of the distance
    return minDist < bchk.nSigmas*bchk.nSigmas;
  }
}

inside() [2/2]

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

finaloverridevirtual

Returns if a point in local coordinates is inside the bounds.

Parameters

locpo	Local position
tol1	Tolerance in r
tol2	Tolerance in phi

Returns

true if is inside, false if not

Implements Trk::SurfaceBounds.

Definition at line 122 of file AnnulusBoundsPC.cxx.

{
  // locpo is PC in STRIP SYSTEM
  // need to perform internal rotation induced by m_phiAvg
  Amg::Vector2D locpo_rotated = m_rotationStripPC * locpo;
  double tolR = tol1;
  double tolPhi = tol2;
  double phiLoc = locpo_rotated[Trk::locPhi];
  double rLoc = locpo_rotated[Trk::locR];
 
  if (phiLoc < (m_phiMin - tolPhi) || phiLoc > (m_phiMax + tolPhi)) {
    return false;
  }
 
  // calculate R in MODULE SYSTEM to evaluate R-bounds
  if (tolR == 0.) {
    // don't need R, can use R^2
    double r_mod2 = m_shiftPC[Trk::locR]*m_shiftPC[Trk::locR]
        + rLoc*rLoc + 2*m_shiftPC[Trk::locR]*rLoc * std::cos(phiLoc - m_shiftPC[Trk::locPhi]);
 
    if (r_mod2 < m_minR*m_minR || r_mod2 > m_maxR*m_maxR) {
      return false;
    }
  }
  else {
    // use R
    double r_mod = std::sqrt(m_shiftPC[Trk::locR]*m_shiftPC[Trk::locR]
        + rLoc*rLoc + 2*m_shiftPC[Trk::locR]*rLoc * cos(phiLoc - m_shiftPC[Trk::locPhi]));
 
    if (r_mod < (m_minR - tolR) || r_mod > (m_maxR + tolR)) {
      return false;
    }
  }
 
  return true;
}

insideLoc1()

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

finaloverridevirtual

Check if local point is inside of r bounds.

Parameters

locpo	Local position
tol1	Tolerance in r

Returns

true if is inside, false if not

Implements Trk::SurfaceBounds.

Definition at line 342 of file AnnulusBoundsPC.cxx.

{
  // locpo is PC in STRIP SYSTEM
  // need to perform internal rotation induced by m_phiAvg
  Amg::Vector2D locpo_rotated = m_rotationStripPC * locpo;
  double tolR = tol1;
  double phiLoc = locpo_rotated[Trk::locPhi];
  double rLoc = locpo_rotated[Trk::locR];
 
  // calculate R in MODULE SYSTEM to evaluate R-bounds
  if (tolR == 0.) {
    // don't need R, can use R^2
    double r_mod2 = m_shiftPC[Trk::locR]*m_shiftPC[Trk::locR]
        + rLoc*rLoc + 2.0*m_shiftPC[Trk::locR]*rLoc * std::cos(phiLoc - m_shiftPC[Trk::locPhi]);
 
    if (r_mod2 < m_minR*m_minR || r_mod2 > m_maxR*m_maxR) {
      return false;
    }
  }
  else {
    // use R
    double r_mod = sqrt(m_shiftPC[Trk::locR]*m_shiftPC[Trk::locR]
        + rLoc*rLoc + 2.0*m_shiftPC[Trk::locR]*rLoc * std::cos(phiLoc - m_shiftPC[Trk::locPhi]));
 
    if (r_mod < (m_minR - tolR) || r_mod > (m_maxR + tolR)) {
      return false;
    }
  }
 
  return true;
}

insideLoc2()

bool Trk::AnnulusBoundsPC::insideLoc2 ( const Amg::Vector2D & locpo, double tol2 = 0. ) const

finaloverridevirtual

Check if local point is inside of phi bounds.

Parameters

locpo	Local position
tol2	Tolerance in phi

Returns

true if is inside, false if not

Implements Trk::SurfaceBounds.

Definition at line 331 of file AnnulusBoundsPC.cxx.

{
  // locpo is PC in STRIP SYSTEM
  // need to perform internal rotation induced by m_phiAvg
  Amg::Vector2D locpo_rotated = m_rotationStripPC * locpo;
  double tolPhi = tol2;
  double phiLoc = locpo_rotated[Trk::locPhi];
 
  return phiLoc >= (m_phiMin - tolPhi) && phiLoc < (m_phiMax + tolPhi);
}

minDistance()

double Trk::AnnulusBoundsPC::minDistance ( const Amg::Vector2D & locpo ) const

finaloverridevirtual

Return minimum distance a point is away from the bounds.

Parameters

locpo

Local position

Note

Even though locpo is considered in STRIP system, the distance will be calculated with cartesian metric.

Implements Trk::SurfaceBounds.

Definition at line 375 of file AnnulusBoundsPC.cxx.

{
  // find the closest point on all edges, calculate distance
  // return smallest one
  // closest distance is cartesian, we want the result in mm.
 
  Amg::Vector2D locpo_rotated = m_rotationStripPC * locpo;
 
  // locpo is given in STRIP PC, we need it in STRIP XY and possibly MODULE XY
  double rStrip = locpo_rotated[Trk::locR];
  double phiStrip = locpo_rotated[Trk::locPhi];
  Amg::Vector2D locpoStripXY(rStrip*std::cos(phiStrip), rStrip*std::sin(phiStrip));
  Amg::Vector2D locpoModuleXY = locpoStripXY + m_shiftXY;
  double rMod = locpoModuleXY.norm();
  double phiMod = locpoModuleXY.phi();
 
  Amg::Vector2D closestStripPC;
  double minDist = std::numeric_limits<double>::max();;
  double curDist{0.0}; // initialise to 0
 
  // for rmin
  if (m_inRightModulePC[Trk::locPhi] <= phiMod && phiMod < m_inLeftModulePC[Trk::locPhi]) {
    // is inside phi bounds, to comparison to rmin and r max
    // r min
    curDist = std::abs(m_minR - rMod);
    minDist = std::min(minDist, curDist);
  }
  else {
    // is outside phi bounds, closest can only be the edge points here
 
    // in left
    curDist = (m_inLeftStripXY - locpoStripXY).norm();
    minDist = std::min(minDist, curDist);
 
    // in right
    curDist = (m_inRightStripXY - locpoStripXY).norm();
    minDist = std::min(minDist, curDist);
  }
 
  if (m_phiMin <= phiStrip && phiStrip < m_phiMax) {
    // r max
    curDist = std::abs(m_maxR - rMod);
    minDist = std::min(minDist, curDist);
  }
  else {
    // out left
    curDist = (m_outLeftStripXY - locpoStripXY).norm();
    minDist = std::min(minDist, curDist);
 
    // out right
    curDist = (m_outRightStripXY - locpoStripXY).norm();
    minDist = std::min(minDist, curDist);
  }
 
  Matrix2D weight = Matrix2D::Identity();
 
  // phi left
  Amg::Vector2D closestLeft = closestOnSegment(m_inLeftStripXY, m_outLeftStripXY, locpoStripXY, weight);
  curDist = (closestLeft - locpoStripXY).norm();
  if (curDist < minDist) {
    minDist = curDist;
  }
 
  // phi right
  Amg::Vector2D closestRight = closestOnSegment(m_inRightStripXY, m_outRightStripXY, locpoStripXY, weight);
  curDist = (closestRight - locpoStripXY).norm();
  if (curDist < minDist) {
    minDist = curDist;
  }
 
  return minDist;
}

moduleOrigin()

Amg::Vector2D Trk::AnnulusBoundsPC::moduleOrigin

(

)

const

Returns moduleOrigin, but rotated out, so avgPhi is already considered.

The module origin needs to consider the rotation introduced by avgPhi

Returns

The origin of the local frame

Definition at line 527 of file AnnulusBoundsPC.cxx.

{
  return Eigen::Rotation2D<double>(m_phiAvg) * m_moduleOrigin;
}

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]

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

default

Move assignment.

operator=() [2/2]

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

default

Assignment operator.

operator==()

bool Trk::AnnulusBoundsPC::operator== ( const SurfaceBounds & sb ) const

overridevirtual

Equality operator.

Implements Trk::SurfaceBounds.

phiMax()

double Trk::AnnulusBoundsPC::phiMax ( ) const

inline

Returns the left angular edge of the module.

Returns

The left side angle

Definition at line 143 of file AnnulusBoundsPC.h.

{ return m_phiMax + m_phiAvg; }

phiMin()

double Trk::AnnulusBoundsPC::phiMin ( ) const

inline

Returns the right angular edge of the module.

Returns

The right side angle

Definition at line 139 of file AnnulusBoundsPC.h.

{ return m_phiMin + m_phiAvg; }

r()

double Trk::AnnulusBoundsPC::r ( ) const

overridevirtual

Returns middle radius.

Returns

The middle radius

Implements Trk::SurfaceBounds.

Definition at line 449 of file AnnulusBoundsPC.cxx.

{
  return (rMax() + rMin()) * 0.5;
}

rMax()

double Trk::AnnulusBoundsPC::rMax ( ) const

inline

Returns outer radial bounds (module system)

Returns

The outer radius

Definition at line 135 of file AnnulusBoundsPC.h.

{ return m_maxR; }

rMin()

double Trk::AnnulusBoundsPC::rMin ( ) const

inline

Returns inner radial bounds (module system)

Returns

The inner radius

Definition at line 131 of file AnnulusBoundsPC.h.

{ return m_minR; }

squaredNorm()

double Trk::AnnulusBoundsPC::squaredNorm ( const Amg::Vector2D & v, const Eigen::Matrix< double, 2, 2 > & weight )

staticprivate

Definition at line 521 of file AnnulusBoundsPC.cxx.

{
  return (v.transpose() * weight * v).value();
}

stripXYToModulePC()

Amg::Vector2D Trk::AnnulusBoundsPC::stripXYToModulePC ( const Amg::Vector2D & vStripXY ) const

private

Definition at line 498 of file AnnulusBoundsPC.cxx.

{
  Amg::Vector2D vecModuleXY = vStripXY + m_shiftXY;
  return {vecModuleXY.norm(), vecModuleXY.phi()};
}

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()

SurfaceBounds::BoundsType Trk::AnnulusBoundsPC::type ( ) const

overridevirtual

Return the bounds type - for persistency optimization.

Implements Trk::SurfaceBounds.

Member Data Documentation

AnnulusTestAlg

friend Trk::AnnulusBoundsPC::AnnulusTestAlg

private

Definition at line 36 of file AnnulusBoundsPC.h.

m_boundValues

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

private

Definition at line 198 of file AnnulusBoundsPC.h.

m_inLeftModulePC

Amg::Vector2D Trk::AnnulusBoundsPC::m_inLeftModulePC

private

Definition at line 189 of file AnnulusBoundsPC.h.

m_inLeftStripPC

Amg::Vector2D Trk::AnnulusBoundsPC::m_inLeftStripPC

private

Definition at line 184 of file AnnulusBoundsPC.h.

m_inLeftStripXY

Amg::Vector2D Trk::AnnulusBoundsPC::m_inLeftStripXY

private

Definition at line 194 of file AnnulusBoundsPC.h.

m_inRightModulePC

Amg::Vector2D Trk::AnnulusBoundsPC::m_inRightModulePC

private

Definition at line 191 of file AnnulusBoundsPC.h.

m_inRightStripPC

Amg::Vector2D Trk::AnnulusBoundsPC::m_inRightStripPC

private

Definition at line 186 of file AnnulusBoundsPC.h.

m_inRightStripXY

Amg::Vector2D Trk::AnnulusBoundsPC::m_inRightStripXY

private

Definition at line 196 of file AnnulusBoundsPC.h.

m_maxR

double Trk::AnnulusBoundsPC::m_maxR

private

Definition at line 171 of file AnnulusBoundsPC.h.

m_minR

double Trk::AnnulusBoundsPC::m_minR

private

Definition at line 170 of file AnnulusBoundsPC.h.

m_moduleOrigin

Amg::Vector2D Trk::AnnulusBoundsPC::m_moduleOrigin

private

Definition at line 175 of file AnnulusBoundsPC.h.

m_outLeftModulePC

Amg::Vector2D Trk::AnnulusBoundsPC::m_outLeftModulePC

private

Definition at line 188 of file AnnulusBoundsPC.h.

m_outLeftStripPC

Amg::Vector2D Trk::AnnulusBoundsPC::m_outLeftStripPC

private

Definition at line 183 of file AnnulusBoundsPC.h.

m_outLeftStripXY

Amg::Vector2D Trk::AnnulusBoundsPC::m_outLeftStripXY

private

Definition at line 193 of file AnnulusBoundsPC.h.

m_outRightModulePC

Amg::Vector2D Trk::AnnulusBoundsPC::m_outRightModulePC

private

Definition at line 190 of file AnnulusBoundsPC.h.

m_outRightStripPC

Amg::Vector2D Trk::AnnulusBoundsPC::m_outRightStripPC

private

Definition at line 185 of file AnnulusBoundsPC.h.

m_outRightStripXY

Amg::Vector2D Trk::AnnulusBoundsPC::m_outRightStripXY

private

Definition at line 195 of file AnnulusBoundsPC.h.

m_phiAvg

double Trk::AnnulusBoundsPC::m_phiAvg

private

Definition at line 178 of file AnnulusBoundsPC.h.

m_phiMax

double Trk::AnnulusBoundsPC::m_phiMax

private

Definition at line 173 of file AnnulusBoundsPC.h.

m_phiMin

double Trk::AnnulusBoundsPC::m_phiMin

private

Definition at line 172 of file AnnulusBoundsPC.h.

m_rotationStripPC

Transform2D Trk::AnnulusBoundsPC::m_rotationStripPC

private

Definition at line 179 of file AnnulusBoundsPC.h.

m_shiftPC

Amg::Vector2D Trk::AnnulusBoundsPC::m_shiftPC

private

Definition at line 177 of file AnnulusBoundsPC.h.

m_shiftXY

Amg::Vector2D Trk::AnnulusBoundsPC::m_shiftXY

private

Definition at line 176 of file AnnulusBoundsPC.h.

m_translation

Transform2D Trk::AnnulusBoundsPC::m_translation

private

Definition at line 180 of file AnnulusBoundsPC.h.

---

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

• AnnulusBoundsPC.h
• AnnulusBoundsPC.cxx