GXF::CylinderSurface Class Reference

Class for a CylinderSurface in the ATLAS detector. More...

#include <CylinderSurface.h>

Inheritance diagram for GXF::CylinderSurface:

Collaboration diagram for GXF::CylinderSurface:

Public Member Functions
	CylinderSurface ()
	Default Constructor.
	CylinderSurface (const CylinderSurface &csf)
	Copy constructor.
	CylinderSurface (CylinderSurface &&csf) noexcept=default
	Move constructor.
	CylinderSurface (const Amg::Transform3D &htrans, double radius, double hlength)
	Constructor from EigenTransform, radius and halflength.
	CylinderSurface (const Amg::Transform3D &htrans, double radius, double hphi, double hlength)
	Constructor from EigenTransform, radius halfphi, and halflength.
	CylinderSurface (const Amg::Transform3D &htrans, std::shared_ptr< const CylinderBounds > cbounds)
	Constructor from EigenTransform and CylinderBounds.
	CylinderSurface (const Amg::Transform3D &htrans)
	Constructor from EigenTransform from unique_ptr.
	CylinderSurface (double radius, double hlength)
	Constructor from radius and halflength - speed optimized for concentric volumes.
	CylinderSurface (double radius, double hphi, double hlength)
	Constructor from radius halfphi, and halflength - speed optimized for concentric volumes.
	CylinderSurface (std::shared_ptr< const CylinderBounds > cbounds)
	Constructor from EigenTransform and CylinderBounds.
	CylinderSurface (const CylinderSurface &csf, const Amg::Transform3D &transf)
	Copy constructor with shift.
CylinderSurface &	operator= (const CylinderSurface &csf)
	Assignment operator.
CylinderSurface &	operator= (CylinderSurface &&csf) noexcept=default
	Move Assignment operator.
virtual	~CylinderSurface ()
	Destructor.
virtual bool	operator== (const Surface &sf) const override
	Equality operator.
bool	operator== (const CylinderSurface &cf) const
virtual CylinderSurface *	clone () const override
	Implicit Constructor.
virtual Surface::ChargedTrackParametersUniquePtr	createUniqueTrackParameters (double l1, double l2, double phi, double theta, double qop, std::optional< AmgSymMatrix(5)> cov=std::nullopt) const override final
	Use the Surface as a ParametersBase constructor, from local parameters - charged.
virtual Surface::ChargedTrackParametersUniquePtr	createUniqueTrackParameters (const Amg::Vector3D &position, const Amg::Vector3D &momentum, double charge, std::optional< AmgSymMatrix(5)> cov=std::nullopt) const override final
	Use the Surface as a ParametersBase constructor, from global parameters - charged.
virtual NeutralTrackParametersUniquePtr	createUniqueNeutralParameters (double l1, double l2, double phi, double theta, double qop, std::optional< AmgSymMatrix(5)> cov=std::nullopt) const override final
	Use the Surface as a ParametersBase constructor, from local parameters - neutral.
virtual NeutralTrackParametersUniquePtr	createUniqueNeutralParameters (const Amg::Vector3D &position, const Amg::Vector3D &momentum, double charge, std::optional< AmgSymMatrix(5)> cov=std::nullopt) const override final
	Use the Surface as a ParametersBase constructor, from global parameters - neutral.
template<int DIM, class T>
std::unique_ptr< ParametersT< DIM, T, CylinderSurface > >	createUniqueParameters (double l1, double l2, double phi, double theta, double qop, std::optional< AmgSymMatrix(DIM)> cov=std::nullopt) const
	Use the Surface as a ParametersBase constructor, from local parameters.
template<int DIM, class T>
std::unique_ptr< ParametersT< DIM, T, CylinderSurface > >	createUniqueParameters (const Amg::Vector3D &position, const Amg::Vector3D &momentum, double charge, std::optional< AmgSymMatrix(DIM)> cov=std::nullopt) const
	Use the Surface as a ParametersBase constructor, from global parameters.
virtual Amg::RotationMatrix3D	measurementFrame (const Amg::Vector3D &glopos, const Amg::Vector3D &glomom) const override final
	Return the measurement frame - this is needed for alignment, in particular for StraightLine and Perigee Surface.
virtual constexpr SurfaceType	type () const override final
	Return the surface type.
virtual const Amg::Vector3D &	globalReferencePoint () const override final
	Returns a global reference point: For the Cylinder this is \( (R*cos(\phi), R*sin(\phi),0)*transform() \) Where \( \phi \) denotes the averagePhi() of the cylinderBounds.
virtual Amg::Vector3D	normal (const Amg::Vector2D &locpo) const override final
	Return method for surface normal information at a given local point, overwrites the normal() from base class.
virtual const Amg::Vector3D &	normal () const
	Returns the normal vector of the Surface (i.e.
virtual const Amg::Vector3D &	rotSymmetryAxis () const
	Return method for the rotational symmetry axis - the z-Axis of the HepTransform.
virtual const CylinderBounds &	bounds () const override final
	This method returns the CylinderBounds by reference (NoBounds is not possible for cylinder)
bool	hasBounds () const
virtual bool	insideBounds (const Amg::Vector2D &locpos, double tol1=0., double tol2=0.) const override
	This method calls the inside method of CylinderBounds.
virtual bool	insideBoundsCheck (const Amg::Vector2D &locpos, const BoundaryCheck &bchk) const override final
virtual Amg::Vector2D	localParametersToPosition (const LocalParameters &locpars) const override final
	Specialized for CylinderSurface : LocalParameters to Vector2D.
virtual void	localToGlobal (const Amg::Vector2D &locp, const Amg::Vector3D &mom, Amg::Vector3D &glob) const override
	Specialized for CylinderSurface : LocalToGlobal method without dynamic memory allocation.
virtual bool	globalToLocal (const Amg::Vector3D &glob, const Amg::Vector3D &mom, Amg::Vector2D &loc) const override
	Specialized for CylinderSurface : GlobalToLocal method without dynamic memory allocation - boolean checks if on surface.
virtual bool	isOnSurface (const Amg::Vector3D &glopo, const BoundaryCheck &bchk=true, double tol1=0., double tol2=0.) const override
	This method returns true if the GlobalPosition is on the Surface for both, within or without check of whether the local position is inside boundaries or not.
virtual Intersection	straightLineIntersection (const Amg::Vector3D &pos, const Amg::Vector3D &dir, bool forceDir=false, Trk::BoundaryCheck bchk=false) const override final
	fast straight line intersection schema - provides closest intersection and (signed) path length
virtual DistanceSolution	straightLineDistanceEstimate (const Amg::Vector3D &pos, const Amg::Vector3D &dir) const override
	fast distance to Surface
virtual DistanceSolution	straightLineDistanceEstimate (const Amg::Vector3D &pos, const Amg::Vector3D &dir, bool bound) const override
	fast distance to Surface - with bounds directive
virtual double	pathCorrection (const Amg::Vector3D &pos, const Amg::Vector3D &mom) const override
	the pathCorrection for derived classes with thickness
virtual std::string	name () const override
	Return properly formatted class name for screen output.

Static Public Attributes
static constexpr SurfaceType	staticType = SurfaceType::Cylinder
	The surface type static constexpr.

Protected Attributes
std::shared_ptr< const CylinderBounds >	m_bounds
	The global reference point (== a point on the surface)
CxxUtils::CachedUniquePtr< Amg::Vector3D >	m_referencePoint
	The rotational symmetry axis.
CxxUtils::CachedUniquePtr< Amg::Vector3D >	m_rotSymmetryAxis

Friends
template<class SURFACE, class BOUNDS_CNV>
class	::BoundSurfaceCnv_p1
	< data members
template<class SURFACE, class BOUNDS_CNV>
class	::BoundSurfaceCnv_p2
	bounds (shared)

Detailed Description

Class for a CylinderSurface in the ATLAS detector.

It inherits from Surface.

The cylinder surface has a special role in the TrackingGeometry, since it builds the surfaces of all TrackingVolumes at container level, hence, to optimize speed in global to local transformations, constructors w/o transform is possible, assumint the identity transform to.

Todo

update for new Possibility of CylinderBounds

Author

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

Christos Anastopoulos (Thread safety and interface cleanup)

Shaun Roe (interface cleanup)

Definition at line 54 of file CylinderSurface.h.

Constructor & Destructor Documentation

CylinderSurface() [1/11]

Trk::CylinderSurface::CylinderSurface

(

)

Default Constructor.

Definition at line 21 of file CylinderSurface.cxx.

  : Trk::Surface()
  , m_bounds(nullptr)
  , m_referencePoint(nullptr)
  , m_rotSymmetryAxis(nullptr)
{}

CylinderSurface() [2/11]

Trk::CylinderSurface::CylinderSurface

(

const CylinderSurface &

csf

)

Copy constructor.

Definition at line 29 of file CylinderSurface.cxx.

  : Trk::Surface(csf)
  , m_bounds(csf.m_bounds)
  , m_referencePoint(nullptr)
  , m_rotSymmetryAxis(nullptr)
{}

CylinderSurface() [3/11]

Trk::CylinderSurface::CylinderSurface ( CylinderSurface && csf )

defaultnoexcept

Move constructor.

CylinderSurface() [4/11]

Trk::CylinderSurface::CylinderSurface	(	const Amg::Transform3D &	htrans,
		double	radius,
		double	hlength )

Constructor from EigenTransform, radius and halflength.

Definition at line 46 of file CylinderSurface.cxx.

  : Trk::Surface(htrans)
  , m_bounds(std::make_shared<const Trk::CylinderBounds>(radius, hlength))
  , m_referencePoint(nullptr)
  , m_rotSymmetryAxis(nullptr)
{}

CylinderSurface() [5/11]

Trk::CylinderSurface::CylinderSurface	(	const Amg::Transform3D &	htrans,
		double	radius,
		double	hphi,
		double	hlength )

Constructor from EigenTransform, radius halfphi, and halflength.

Definition at line 56 of file CylinderSurface.cxx.

  : Trk::Surface(htrans)
  , m_bounds(std::make_shared<Trk::CylinderBounds>(radius, hphi, hlength))
  , m_referencePoint(nullptr)
  , m_rotSymmetryAxis(nullptr)
{}

CylinderSurface() [6/11]

Trk::CylinderSurface::CylinderSurface	(	const Amg::Transform3D &	htrans,
		std::shared_ptr< const CylinderBounds >	cbounds )

Constructor from EigenTransform and CylinderBounds.

Definition at line 67 of file CylinderSurface.cxx.

  : Trk::Surface(htrans)
  , m_bounds(std::move(cbounds))
  , m_referencePoint(nullptr)
  , m_rotSymmetryAxis(nullptr)
{
}

CylinderSurface() [7/11]

Trk::CylinderSurface::CylinderSurface

(

const Amg::Transform3D &

htrans

)

Constructor from EigenTransform from unique_ptr.

• bounds is not set

Definition at line 77 of file CylinderSurface.cxx.

  : Trk::Surface(htrans)
  , m_bounds(nullptr)
  , m_referencePoint(nullptr)
  , m_rotSymmetryAxis(nullptr)
{}

CylinderSurface() [8/11]

Trk::CylinderSurface::CylinderSurface	(	double	radius,
		double	hlength )

Constructor from radius and halflength - speed optimized for concentric volumes.

Definition at line 85 of file CylinderSurface.cxx.

  : Trk::Surface()
  , m_bounds(std::make_shared<Trk::CylinderBounds>(radius, hlength))
  , m_referencePoint(nullptr)
  , m_rotSymmetryAxis(nullptr)
{}

CylinderSurface() [9/11]

Trk::CylinderSurface::CylinderSurface	(	double	radius,
		double	hphi,
		double	hlength )

Constructor from radius halfphi, and halflength - speed optimized for concentric volumes.

Definition at line 93 of file CylinderSurface.cxx.

  : Trk::Surface()
  , m_bounds(std::make_shared<Trk::CylinderBounds>(radius, hphi, hlength))
  , m_referencePoint(nullptr)
  , m_rotSymmetryAxis(nullptr)
{}

CylinderSurface() [10/11]

Trk::CylinderSurface::CylinderSurface

(

std::shared_ptr< const CylinderBounds >

cbounds

)

Constructor from EigenTransform and CylinderBounds.

• ownership of the bounds is passed
• speed optimized fron concentric volumes

Definition at line 103 of file CylinderSurface.cxx.

  : Trk::Surface()
  , m_bounds(std::move(cbounds))
  , m_referencePoint(nullptr)
  , m_rotSymmetryAxis(nullptr)
{
}

CylinderSurface() [11/11]

Trk::CylinderSurface::CylinderSurface	(	const CylinderSurface &	csf,
		const Amg::Transform3D &	transf )

Copy constructor with shift.

Definition at line 37 of file CylinderSurface.cxx.

  : Trk::Surface(csf, transf)
  , m_bounds(csf.m_bounds)
  , m_referencePoint(nullptr)
  , m_rotSymmetryAxis(nullptr)
{}

~CylinderSurface()

Trk::CylinderSurface::~CylinderSurface ( )

virtualdefault

Destructor.

Member Function Documentation

bounds()

virtual const CylinderBounds & Trk::CylinderSurface::bounds ( ) const

finaloverridevirtual

This method returns the CylinderBounds by reference (NoBounds is not possible for cylinder)

Implements Trk::Surface.

clone()

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

overridevirtual

Implicit Constructor.

Implements Trk::Surface.

createUniqueNeutralParameters() [1/2]

Trk::Surface::NeutralTrackParametersUniquePtr Trk::CylinderSurface::createUniqueNeutralParameters ( const Amg::Vector3D & position, const Amg::Vector3D & momentum, double charge, std::optional< AmgSymMatrix(5)> cov = std::nullopt ) const

finaloverridevirtual

Use the Surface as a ParametersBase constructor, from global parameters - neutral.

Implements Trk::Surface.

Definition at line 159 of file CylinderSurface.cxx.

                                            {
  return std::make_unique<ParametersT<5, Neutral, CylinderSurface>>(
      position, momentum, charge, *this, std::move(cov));
}

createUniqueNeutralParameters() [2/2]

Trk::Surface::NeutralTrackParametersUniquePtr Trk::CylinderSurface::createUniqueNeutralParameters ( double l1, double l2, double phi, double theta, double qop, std::optional< AmgSymMatrix(5)> cov = std::nullopt ) const

finaloverridevirtual

Use the Surface as a ParametersBase constructor, from local parameters - neutral.

Implements Trk::Surface.

Definition at line 149 of file CylinderSurface.cxx.

                                            {
  return std::make_unique<ParametersT<5, Neutral, CylinderSurface>>(
      l1, l2, phi, theta, qop, *this, std::move(cov));
}

createUniqueParameters() [1/2]

template<int DIM, class T>

std::unique_ptr< ParametersT< DIM, T, CylinderSurface > > Trk::CylinderSurface::createUniqueParameters	(	const Amg::Vector3D &	position,
		const Amg::Vector3D &	momentum,
		double	charge,
		std::optional< AmgSymMatrix(DIM)>	cov = std::nullopt ) const

Use the Surface as a ParametersBase constructor, from global parameters.

createUniqueParameters() [2/2]

template<int DIM, class T>

std::unique_ptr< ParametersT< DIM, T, CylinderSurface > > Trk::CylinderSurface::createUniqueParameters	(	double	l1,
		double	l2,
		double	phi,
		double	theta,
		double	qop,
		std::optional< AmgSymMatrix(DIM)>	cov = std::nullopt ) const

Use the Surface as a ParametersBase constructor, from local parameters.

createUniqueTrackParameters() [1/2]

Trk::Surface::ChargedTrackParametersUniquePtr Trk::CylinderSurface::createUniqueTrackParameters ( const Amg::Vector3D & position, const Amg::Vector3D & momentum, double charge, std::optional< AmgSymMatrix(5)> cov = std::nullopt ) const

finaloverridevirtual

Use the Surface as a ParametersBase constructor, from global parameters - charged.

Implements Trk::Surface.

Definition at line 139 of file CylinderSurface.cxx.

                                            {
  return std::make_unique<ParametersT<5, Charged, CylinderSurface>>(
      position, momentum, charge, *this, std::move(cov));
}

createUniqueTrackParameters() [2/2]

Trk::Surface::ChargedTrackParametersUniquePtr Trk::CylinderSurface::createUniqueTrackParameters ( double l1, double l2, double phi, double theta, double qop, std::optional< AmgSymMatrix(5)> cov = std::nullopt ) const

finaloverridevirtual

Use the Surface as a ParametersBase constructor, from local parameters - charged.

Implements Trk::Surface.

Definition at line 129 of file CylinderSurface.cxx.

                                            {
  return std::make_unique<ParametersT<5, Charged, CylinderSurface>>(
      l1, l2, phi, theta, qop, *this, std::move(cov));
}

globalReferencePoint()

const Amg::Vector3D & Trk::CylinderSurface::globalReferencePoint ( ) const

finaloverridevirtual

Returns a global reference point: For the Cylinder this is \( (R*cos(\phi), R*sin(\phi),0)*transform() \) Where \( \phi \) denotes the averagePhi() of the cylinderBounds.

Reimplemented from Trk::Surface.

Definition at line 167 of file CylinderSurface.cxx.

{
  if (!m_referencePoint) {
    double rMedium = bounds().r();
    double phi = bounds().averagePhi();
    Amg::Vector3D gp(rMedium * cos(phi), rMedium * sin(phi), 0.);
    m_referencePoint.set(std::make_unique<Amg::Vector3D>(transform() * gp));
  }
  return (*m_referencePoint);
}

globalToLocal()

bool Trk::CylinderSurface::globalToLocal ( const Amg::Vector3D & glob, const Amg::Vector3D & mom, Amg::Vector2D & loc ) const

overridevirtual

Specialized for CylinderSurface : GlobalToLocal method without dynamic memory allocation - boolean checks if on surface.

Implements Trk::Surface.

Definition at line 238 of file CylinderSurface.cxx.

{
  // get the transform & transform global position into cylinder frame
  // transform it to the globalframe: CylinderSurfaces are allowed to have 0
  // pointer transform
  double radius = 0.;
  double inttol = bounds().r() * 0.0001;
  if (inttol < 0.01)
    inttol = 0.01;
  // do the transformation or not
  if (Trk::Surface::m_transforms) {
    Amg::Vector3D loc3Dframe(inverseTransformMultHelper(glopos));
    locpos = Amg::Vector2D(bounds().r() * loc3Dframe.phi(), loc3Dframe.z());
    radius = loc3Dframe.perp();
  } else {
    locpos = Amg::Vector2D(bounds().r() * glopos.phi(), glopos.z());
    radius = glopos.perp();
  }
  // return true or false
  return (fabs(radius - bounds().r()) <= inttol);
}

hasBounds()

bool Trk::CylinderSurface::hasBounds

(

)

const

insideBounds()

virtual bool Trk::CylinderSurface::insideBounds ( const Amg::Vector2D & locpos, double tol1 = 0., double tol2 = 0. ) const

overridevirtual

This method calls the inside method of CylinderBounds.

Implements Trk::Surface.

insideBoundsCheck()

virtual bool Trk::CylinderSurface::insideBoundsCheck ( const Amg::Vector2D & locpos, const BoundaryCheck & bchk ) const

finaloverridevirtual

isOnSurface()

bool Trk::CylinderSurface::isOnSurface ( const Amg::Vector3D & glopo, const BoundaryCheck & bchk = true, double tol1 = 0., double tol2 = 0. ) const

overridevirtual

This method returns true if the GlobalPosition is on the Surface for both, within or without check of whether the local position is inside boundaries or not.

Reimplemented from Trk::Surface.

Definition at line 263 of file CylinderSurface.cxx.

{
  Amg::Vector3D loc3Dframe =
    Trk::Surface::m_transforms ? inverseTransformMultHelper(glopo) : glopo;
  return (bchk ? bounds().inside3D(loc3Dframe,
                                   tol1 + s_onSurfaceTolerance,
                                   tol2 + s_onSurfaceTolerance)
               : true);
}

localParametersToPosition()

virtual Amg::Vector2D Trk::CylinderSurface::localParametersToPosition ( const LocalParameters & locpars ) const

finaloverridevirtual

Specialized for CylinderSurface : LocalParameters to Vector2D.

localToGlobal()

ATH_FLATTEN void Trk::CylinderSurface::localToGlobal ( const Amg::Vector2D & locp, const Amg::Vector3D & mom, Amg::Vector3D & glob ) const

overridevirtual

Specialized for CylinderSurface : LocalToGlobal method without dynamic memory allocation.

Implements Trk::Surface.

Definition at line 223 of file CylinderSurface.cxx.

{
  // create the position in the local 3d frame
  double r = bounds().r();
  double phi = locpos[Trk::locRPhi] / r;
  glopos = Amg::Vector3D(r * cos(phi), r * sin(phi), locpos[Trk::locZ]);
  // transform it to the globalframe: CylinderSurfaces are allowed to have 0
  // pointer transform
  if (Trk::Surface::m_transforms)
    glopos = transform() * glopos;
}

measurementFrame()

Amg::RotationMatrix3D Trk::CylinderSurface::measurementFrame ( const Amg::Vector3D & glopos, const Amg::Vector3D & glomom ) const

finaloverridevirtual

Return the measurement frame - this is needed for alignment, in particular for StraightLine and Perigee Surface.

• the default implementation is the the RotationMatrix3D of the transform

Reimplemented from Trk::Surface.

Definition at line 190 of file CylinderSurface.cxx.

{
  Amg::RotationMatrix3D mFrame;
  // construct the measurement frame
  Amg::Vector3D measY(
    transform().rotation().col(2)); // measured Y is the z axis
  Amg::Vector3D measDepth =
    Amg::Vector3D(pos.x(), pos.y(), 0.)
      .unit(); // measured z is the position transverse normalized
  Amg::Vector3D measX(
    measY.cross(measDepth).unit()); // measured X is what comoes out of it
  // the columnes
  mFrame.col(0) = measX;
  mFrame.col(1) = measY;
  mFrame.col(2) = measDepth;
  // return the rotation matrix
  return mFrame;
}

name()

virtual std::string Trk::CylinderSurface::name ( ) const

overridevirtual

Return properly formatted class name for screen output.

Implements Trk::Surface.

normal() [1/2]

virtual const Amg::Vector3D & Trk::Surface::normal ( ) const

virtual

Returns the normal vector of the Surface (i.e.

in generall z-axis of rotation)

Reimplemented from Trk::Surface.

normal() [2/2]

virtual Amg::Vector3D Trk::CylinderSurface::normal ( const Amg::Vector2D & locpo ) const

finaloverridevirtual

Return method for surface normal information at a given local point, overwrites the normal() from base class.

Reimplemented from Trk::Surface.

operator=() [1/2]

Trk::CylinderSurface & Trk::CylinderSurface::operator=

(

const CylinderSurface &

csf

)

Assignment operator.

Definition at line 115 of file CylinderSurface.cxx.

{
  if (this != &csf) {
    Trk::Surface::operator=(csf);
    m_bounds = csf.m_bounds;
    m_referencePoint.store(nullptr);
    m_rotSymmetryAxis.store(nullptr);
  }
  return *this;
}

operator=() [2/2]

CylinderSurface & Trk::CylinderSurface::operator= ( CylinderSurface && csf )

defaultnoexcept

Move Assignment operator.

operator==() [1/2]

bool Trk::CylinderSurface::operator==

(

const CylinderSurface &

cf

)

const

operator==() [2/2]

bool Trk::CylinderSurface::operator== ( const Surface & sf ) const

overridevirtual

Equality operator.

Implements Trk::Surface.

Definition at line 179 of file CylinderSurface.cxx.

{
  // first check the type not to compare apples with oranges
  if (sf.type()!=Trk::SurfaceType::Cylinder){
      return false;
  }
  return (*this) == static_cast<const Trk::CylinderSurface&>(sf);
}

pathCorrection()

virtual double Trk::CylinderSurface::pathCorrection ( const Amg::Vector3D & pos, const Amg::Vector3D & mom ) const

overridevirtual

the pathCorrection for derived classes with thickness

Reimplemented from Trk::Surface.

rotSymmetryAxis()

const Amg::Vector3D & Trk::CylinderSurface::rotSymmetryAxis ( ) const

virtual

Return method for the rotational symmetry axis - the z-Axis of the HepTransform.

Definition at line 211 of file CylinderSurface.cxx.

{
  if (!m_rotSymmetryAxis) {
    Amg::Vector3D zAxis(transform().rotation().col(2));
    m_rotSymmetryAxis.set(std::make_unique<Amg::Vector3D>(zAxis));
  }
  return (*m_rotSymmetryAxis);
}

straightLineDistanceEstimate() [1/2]

ATH_FLATTEN Trk::DistanceSolution Trk::CylinderSurface::straightLineDistanceEstimate ( const Amg::Vector3D & pos, const Amg::Vector3D & dir ) const

overridevirtual

fast distance to Surface

distance to surface

Implements Trk::Surface.

Definition at line 377 of file CylinderSurface.cxx.

{
  double tol = 0.001;
 
  const Amg::Vector3D& X = center(); // point
  const Amg::Vector3D& S = normal(); // vector
 
  double radius = bounds().r();
  double sp = pos.dot(S);
  double sc = X.dot(S);
  double dp = dir.dot(S);
  Amg::Vector3D dx = X - pos - (sc - sp) * S; // vector
  Amg::Vector3D ax = dir - dp * S;            // vector
 
  double A = ax.dot(ax); // size of projected direction (squared)
  double B = ax.dot(dx); // dot product (->cos angle)
  double C = dx.dot(dx); // distance to axis (squared)
  double currDist = radius - sqrt(C);
 
  if (A == 0.) { // direction parallel to cylinder axis
    if (fabs(currDist) < tol) {
      return {1, 0., true, 0.}; // solution at surface
    }
    return {
      0, currDist, true, 0.}; // point of closest approach without intersection
  }
 
  // minimal distance to cylinder axis
  // The [[maybe_unused]] declaration is to suppress redundant division checking
  // here. Even a tiny change in rmin (~1e-13) can cause huge changes in the
  // reconstructed output, so don't change how it's evaluated.
  [[maybe_unused]] const double rmin_tmp = B * B / A;
  const double rmin2 = C - rmin_tmp;
  const double rmin = rmin2 < 0 ? 0 : sqrt(rmin2);
 
  if (rmin > radius) { // no intersection
    double first = B / A;
    return {
      0,
      currDist,
      true,
      first}; // point of closest approach without intersection
  }
  if (fabs(rmin - radius) <
      tol) { // tangential 'intersection' - return double solution
    double first = B / A;
    return {2, currDist, true, first, first};
  }
  // The [[maybe_unused]] declaration here suppresses redundant division
  // checking. We don't want to rewrite how this is evaluated due to
  // instabilities.
  [[maybe_unused]] const double b_a = B / A;
  const double x = sqrt((radius - rmin) * (radius + rmin) / A);
  double first = b_a - x;
  double second = b_a + x;
  if (first >= 0.) {
    return {2, currDist, true, first, second};
  }
  if (second <= 0.) {
    return {2, currDist, true, second, first};
  } // inside cylinder
  return {2, currDist, true, second, first};
}

straightLineDistanceEstimate() [2/2]

Trk::DistanceSolution Trk::CylinderSurface::straightLineDistanceEstimate ( const Amg::Vector3D & pos, const Amg::Vector3D & dir, bool bound ) const

overridevirtual

fast distance to Surface - with bounds directive

Implements Trk::Surface.

Definition at line 444 of file CylinderSurface.cxx.

{
  const double tolb = .01;
 
  const Amg::Transform3D& T = transform();
  //  double                Ax[3] = {T.xx(),T.yx(),T.zx()};
  //  double                Ay[3] = {T.xy(),T.yy(),T.zy()};
  //  double                Az[3] = {T.xz(),T.yz(),T.zz()};
 
  // Transformation to cylinder system coordinates
  //
 
  // BEGIN here is what i guess this might mean: BEGIN
  Amg::Vector3D Ax = T.rotation().col(0);
  Amg::Vector3D Ay = T.rotation().col(1);
  Amg::Vector3D Az = T.rotation().col(2);
 
  Amg::Vector3D dxyz = pos - T.translation();
  double x = dxyz.dot(Ax);
  double y = dxyz.dot(Ay);
  double z = dxyz.dot(Az);
  double ax = dir.dot(Ax);
  double ay = dir.dot(Ay);
  double at = ax * ax + ay * ay;
  double r = sqrt(x * x + y * y);
  double R = bounds().r();
 
  // END here is what i guessed this means END
 
  //  double dx  = pos[0]-T.dx()                         ;
  //  double dy  = pos[1]-T.dy()                         ;
  //  double dz  = pos[2]-T.dz()                         ;
  //  double x   = dx*Ax[0]+dy*Ax[1]+dz*Ax[2]            ;
  //  double y   = dx*Ay[0]+dy*Ay[1]+dz*Ay[2]            ;
  //  double z   = dx*Az[0]+dy*Az[1]+dz*Az[2]            ;
  //  double ax  = dir[0]*Ax[0]+dir[1]*Ax[1]+dir[2]*Ax[2];
  //  double ay  = dir[0]*Ay[0]+dir[1]*Ay[1]+dir[2]*Ay[2];
  //  double at  = ax*ax+ay*ay                           ;
  //  double r   = sqrt(x*x+y*y)                         ;
  //  double R   = bounds().r()                          ;
 
  // Step to surface
  //
  int ns = 0;
  double s1 = 0.;
  double s2 = 0.;
 
  if (at != 0.) {
 
    const double inv_at = 1. / at;
    double A = -(ax * x + ay * y) * inv_at;
    double B = A * A + (R - r) * (R - r) * inv_at;
 
    if (B >= 0.) {
 
      B = sqrt(B);
      if (B > tolb) {
        if (A > 0.) {
          s1 = A - B;
          s2 = A + B;
        } else {
          s1 = A + B;
          s2 = A - B;
        }
        ns = 2;
      } else {
        s1 = A;
        ns = 1;
      }
    }
  }
  double sr = r - R;
  if (!bound)
    return {ns, fabs(sr), true, s1, s2};
 
  // Min distance to surface
  //
  Amg::Vector2D lp(atan2(y, x) * R, 0.);
 
  double d = bounds().minDistance(lp);
  double sz = fabs(z) - bounds().halflengthZ();
  if (sz <= 0.)
    sz = 0.;
  double dist = sr * sr + sz * sz;
  if (d > 0.)
    dist += ((d * d) * (sr / R + 1.));
 
  return {ns, sqrt(dist), true, s1, s2};
}

straightLineIntersection()

Trk::Intersection Trk::CylinderSurface::straightLineIntersection ( const Amg::Vector3D & pos, const Amg::Vector3D & dir, bool forceDir = false, Trk::BoundaryCheck bchk = false ) const

finaloverridevirtual

fast straight line intersection schema - provides closest intersection and (signed) path length

mathematical motivation:

The calculation will be done in the 3-dim frame of the cylinder, i.e. the symmetry axis of the cylinder is the z-axis, x- and y-axis are perpenticular to the the z-axis. In this frame the cylinder is centered around the origin. Therefore the two points describing the line have to be first recalculated into the new frame. Suppose, this is done, the intersection is straight forward:
may \(p_{1}=(p_{1x}, p_{1y}, p_{1z}), p_{2}=(p_{2x}, p_{2y}, p_{2z}) \)@_fakenlthe two points describing the 3D-line, then the line in the \(x-y\)plane can be written as \(y=kx+d\), where \(k =\frac{p_{2y}-p_{1y}}{p_{2x}-p_{1x}}\)such as \(d=\frac{p_{2x}p_{1y}-p_{1x}p_{2y}}{p_{2x}-p_{1x}},\)
and intersects with the corresponding circle \(x^{2}+y^{2} = R^{2}. \)
The solutions can then be found by a simple quadratic equation and reinsertion into the line equation.

Implements Trk::Surface.

Definition at line 277 of file CylinderSurface.cxx.

{
  bool needsTransform = m_transforms || m_associatedDetElement;
  // create the hep points
  Amg::Vector3D point1 = pos;
  Amg::Vector3D direction = dir;
  if (needsTransform) {
    Amg::Transform3D invTrans = inverseTransformHelper();
    point1 = invTrans * pos;
    direction = invTrans.linear() * dir;
  }
  // the bounds radius
  double R = bounds().r();
  double t1 = 0.;
  double t2 = 0.;
  if (direction.x()) {
    // get line and circle constants
    double idirx = 1. / direction.x();
    double k = direction.y() * idirx;
    double d = point1.y() - point1.x() * k;
    // and solve the qaudratic equation
    Trk::RealQuadraticEquation pquad(1 + k * k, 2 * k * d, d * d - R * R);
    if (pquad.solutions != Trk::none) {
      // the solutions in the 3D frame of the cylinder
      t1 = (pquad.first - point1.x()) * idirx;
      t2 = (pquad.second - point1.x()) * idirx;
    } else // bail out if no solution exists
      return {pos, 0., false};
  } else if (direction.y()) {
    // x value is the one of point1
    // x^2 + y^2 = R^2
    // y = sqrt(R^2-x^2)
    double x = point1.x();
    double r2mx2 = R * R - x * x;
    // bail out if no solution
    if (r2mx2 < 0.)
      return {pos, 0., false};
    double y = sqrt(r2mx2);
    // assign parameters and solutions
    double idiry = 1. / direction.y();
    t1 = (y - point1.y()) * idiry;
    t2 = (-y - point1.y()) * idiry;
  } else {
    return {pos, 0., false};
  }
  Amg::Vector3D sol1raw(point1 + t1 * direction);
  Amg::Vector3D sol2raw(point1 + t2 * direction);
  // now reorder and return
  Amg::Vector3D solution(0, 0, 0);
  double path = 0.;
 
  // first check the validity of the direction
  bool isValid = true;
 
  // both solutions are of same sign, take the smaller, but flag as false if not
  // forward
  if (t1 * t2 > 0 || !forceDir) {
    // asign validity
    isValid = forceDir ? (t1 > 0.) : true;
    // assign the right solution
    if (t1 * t1 < t2 * t2) {
      solution = sol1raw;
      path = t1;
    } else {
      solution = sol2raw;
      path = t2;
    }
  } else {
    if (t1 > 0.) {
      solution = sol1raw;
      path = t1;
    } else {
      solution = sol2raw;
      path = t2;
    }
  }
  // the solution is still in the local 3D frame, direct check
  isValid =
    bchk ? (isValid && m_bounds->inside3D(solution,
                                          Trk::Surface::s_onSurfaceTolerance,
                                          Trk::Surface::s_onSurfaceTolerance))
         : isValid;
 
  // now return
  return needsTransform ? Intersection(transform() * solution, path, isValid)
                        : Intersection(solution, path, isValid);
}

type()

virtual constexpr SurfaceType Trk::CylinderSurface::type ( ) const

constexprfinaloverridevirtual

Return the surface type.

Implements Trk::Surface.

Friends And Related Symbol Documentation

::BoundSurfaceCnv_p1

template<class SURFACE, class BOUNDS_CNV>

friend class ::BoundSurfaceCnv_p1

friend

< data members

Definition at line 284 of file CylinderSurface.h.

::BoundSurfaceCnv_p2

template<class SURFACE, class BOUNDS_CNV>

friend class ::BoundSurfaceCnv_p2

friend

bounds (shared)

Definition at line 286 of file CylinderSurface.h.

Member Data Documentation

m_bounds

std::shared_ptr<const CylinderBounds> Trk::CylinderSurface::m_bounds

protected

The global reference point (== a point on the surface)

Definition at line 289 of file CylinderSurface.h.

m_referencePoint

CxxUtils::CachedUniquePtr<Amg::Vector3D> Trk::CylinderSurface::m_referencePoint

protected

The rotational symmetry axis.

Definition at line 291 of file CylinderSurface.h.

m_rotSymmetryAxis

CxxUtils::CachedUniquePtr<Amg::Vector3D> Trk::CylinderSurface::m_rotSymmetryAxis

protected

Definition at line 293 of file CylinderSurface.h.

staticType

SurfaceType Trk::CylinderSurface::staticType = SurfaceType::Cylinder

staticconstexpr

The surface type static constexpr.

Definition at line 59 of file CylinderSurface.h.

---

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

• CylinderSurface.h
• CylinderSurface.cxx