GXF::DiscSurface Class Reference

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

#include <DiscSurface.h>

Inheritance diagram for GXF::DiscSurface:

Collaboration diagram for GXF::DiscSurface:

Public Member Functions
	DiscSurface ()
	Default Constructor.
	DiscSurface (const DiscSurface &psf)
	Copy Constructor.
	DiscSurface (DiscSurface &&psf) noexcept=default
	Copy Constructor.
	DiscSurface (const Amg::Transform3D &htrans, double rmin, double rmax)
	Constructor for Discs from HepGeom::Transform3D, \( r_{min}, r_{max} \).
	DiscSurface (const Amg::Transform3D &htrans, double rmin, double rmax, double hphisec)
	Constructor for Discs from HepGeom::Transform3D, \( r_{min}, r_{max}, \phi_{hsec} \).
	DiscSurface (const Amg::Transform3D &htrans, double minhalfx, double maxhalfx, double maxR, double minR, double avephi, double stereo=0.)
	Constructor for Discs from HepGeom::Transform3D, \( r_{min}, r_{max}, hx_{min}, hx_{max} \) In this case you have DiscTrapezoidalBounds.
	DiscSurface (const Amg::Transform3D &htrans, std::shared_ptr< const DiscBounds > dbounds)
	Constructor for Discs from Amg::Transform3D and DiscBounds.
	DiscSurface (const Amg::Transform3D &htrans, std::shared_ptr< const DiscTrapezoidalBounds > dtbounds)
	Constructor for Discs from Amg::Transform3D and DiscTrapezoidalBounds.
	DiscSurface (const Amg::Transform3D &htrans, std::shared_ptr< const AnnulusBoundsPC > annpcbounds)
	Constructor for Discs from HepGeom::Transform3D and AnnulusBoundsPC.
	DiscSurface (const Amg::Transform3D &htrans, const AnnulusBounds &annbounds, const TrkDetElementBase *detElem=nullptr)
	Constructor for Discs from Transform3D and AnnulusBoundsPC This will use the converting factory in AnnulusBoundsPC to build an equivalent PC version.
	DiscSurface (const Amg::Transform3D &htrans)
	Constructor for Discs from HepGeom::Transform3D by unique_ptr.
	DiscSurface (const TrkDetElementBase &dmnt)
	Constructor for DiscSegment from DetectorElement.
	DiscSurface (const DiscSurface &psf, const Amg::Transform3D &transf)
	Copy Constructor with shift.
DiscSurface &	operator= (const DiscSurface &dsf)
	Assignement operator.
DiscSurface &	operator= (DiscSurface &&dsf) noexcept=default
	Assignement operator.
virtual	~DiscSurface ()
	Destructor.
virtual bool	operator== (const Surface &sf) const override
	Equality operator.
bool	operator== (const DiscSurface &cf) const
virtual DiscSurface *	clone () const override
	Virtual 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, DiscSurface > >	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, DiscSurface > >	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 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 Disc this is \( (R*cos(\phi), R*sin(\phi),0)*transform() \) Where \( r, \phi \) denote the r(), averagePhi() of the Bounds.
const SurfaceBounds &	bounds () const override final
	This method returns the bounds by reference.
virtual bool	insideBounds (const Amg::Vector2D &locpos, double tol1=0., double tol2=0.) const override
	This method calls the inside method of the bounds.
virtual bool	insideBoundsCheck (const Amg::Vector2D &locpos, const BoundaryCheck &bchk) const override final
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 Amg::Vector2D	localParametersToPosition (const LocalParameters &locpars) const override final
	Specialized for DiscSurface : LocalParameters to Vector2D.
virtual void	localToGlobal (const Amg::Vector2D &locp, const Amg::Vector3D &mom, Amg::Vector3D &glob) const override
	Specialized for DiscSurface: LocalToGlobal method without dynamic memory allocation.
virtual bool	globalToLocal (const Amg::Vector3D &glob, const Amg::Vector3D &mom, Amg::Vector2D &loc) const override
	Specialized for DiscSurface: GlobalToLocal method without dynamic memory allocation - boolean checks if on surface.
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 - standard: provides closest intersection and (signed) path length forceDir is to provide the closest forward solution
virtual DistanceSolution	straightLineDistanceEstimate (const Amg::Vector3D &pos, const Amg::Vector3D &dir) const override
	fast straight line distance evaluation to Surface
virtual DistanceSolution	straightLineDistanceEstimate (const Amg::Vector3D &pos, const Amg::Vector3D &dir, bool Bound) const override
	fast straight line distance evaluation to Surface - with bound option
virtual std::string	name () const override
	Return properly formatted class name for screen output.

Static Public Attributes
static constexpr SurfaceType	staticType = SurfaceType::Disc

Protected Attributes
std::shared_ptr< const SurfaceBounds >	m_bounds
	reference Point on the Surface
CxxUtils::CachedUniquePtr< Amg::Vector3D >	m_referencePoint
	static member for boundless approach

Static Protected Attributes
static const NoBounds	s_boundless

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 DiscSurface in the ATLAS detector.

It inherits from Surface.

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 53 of file DiscSurface.h.

Constructor & Destructor Documentation

DiscSurface() [1/13]

Trk::DiscSurface::DiscSurface

(

)

Default Constructor.

Definition at line 26 of file DiscSurface.cxx.

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

DiscSurface() [2/13]

Trk::DiscSurface::DiscSurface

(

const DiscSurface &

psf

)

Copy Constructor.

Definition at line 33 of file DiscSurface.cxx.

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

DiscSurface() [3/13]

Trk::DiscSurface::DiscSurface ( DiscSurface && psf )

defaultnoexcept

Copy Constructor.

DiscSurface() [4/13]

Trk::DiscSurface::DiscSurface	(	const Amg::Transform3D &	htrans,
		double	rmin,
		double	rmax )

Constructor for Discs from HepGeom::Transform3D, \( r_{min}, r_{max} \).

Definition at line 48 of file DiscSurface.cxx.

  : Trk::Surface(htrans)
  , m_bounds(std::make_shared<const Trk::DiscBounds>(rmin, rmax))
  , m_referencePoint(nullptr)
{}

DiscSurface() [5/13]

Trk::DiscSurface::DiscSurface	(	const Amg::Transform3D &	htrans,
		double	rmin,
		double	rmax,
		double	hphisec )

Constructor for Discs from HepGeom::Transform3D, \( r_{min}, r_{max}, \phi_{hsec} \).

Definition at line 57 of file DiscSurface.cxx.

  : Trk::Surface(htrans)
  , m_bounds(std::make_shared<Trk::DiscBounds>(rmin, rmax, hphisec))
  , m_referencePoint(nullptr)
{}

DiscSurface() [6/13]

Trk::DiscSurface::DiscSurface	(	const Amg::Transform3D &	htrans,
		double	minhalfx,
		double	maxhalfx,
		double	maxR,
		double	minR,
		double	avephi,
		double	stereo = 0. )

Constructor for Discs from HepGeom::Transform3D, \( r_{min}, r_{max}, hx_{min}, hx_{max} \) In this case you have DiscTrapezoidalBounds.

Definition at line 66 of file DiscSurface.cxx.

  : Trk::Surface(htrans)
  , m_bounds(std::make_shared<Trk::DiscTrapezoidalBounds>(minhalfx,
                                                          maxhalfx,
                                                          maxR,
                                                          minR,
                                                          avephi,
                                                          stereo))
  , m_referencePoint(nullptr)
{}

DiscSurface() [7/13]

Trk::DiscSurface::DiscSurface	(	const Amg::Transform3D &	htrans,
		std::shared_ptr< const DiscBounds >	dbounds )

Constructor for Discs from Amg::Transform3D and DiscBounds.

Definition at line 84 of file DiscSurface.cxx.

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

DiscSurface() [8/13]

Trk::DiscSurface::DiscSurface	(	const Amg::Transform3D &	htrans,
		std::shared_ptr< const DiscTrapezoidalBounds >	dtbounds )

Constructor for Discs from Amg::Transform3D and DiscTrapezoidalBounds.

Definition at line 92 of file DiscSurface.cxx.

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

DiscSurface() [9/13]

Trk::DiscSurface::DiscSurface	(	const Amg::Transform3D &	htrans,
		std::shared_ptr< const AnnulusBoundsPC >	annpcbounds )

Constructor for Discs from HepGeom::Transform3D and AnnulusBoundsPC.

• ownership of bounds is passed

Definition at line 99 of file DiscSurface.cxx.

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

DiscSurface() [10/13]

Trk::DiscSurface::DiscSurface	(	const Amg::Transform3D &	htrans,
		const AnnulusBounds &	annbounds,
		const TrkDetElementBase *	detElem = nullptr )

Constructor for Discs from Transform3D and AnnulusBoundsPC This will use the converting factory in AnnulusBoundsPC to build an equivalent PC version.

The overall transform of this object will be htrans and an additional rotation to overlay the two bounds implementations exactly.

Parameters

htrans	Base transform. This should be the transform of the PlaneSurface on which annbounds is located
annbounds	Cartesian annulus bounds to convert
detElem	Additional explicit detector element

Note

During testing, no conversion of the underlying detector element was implemented. This polar coordinate surface will therefore link back to the cartesian detector element.

Definition at line 106 of file DiscSurface.cxx.

  : Trk::Surface(htrans),
    m_referencePoint(nullptr)
{
 
  if(detElem != nullptr) {
    m_associatedDetElement = detElem;
    m_associatedDetElementId = m_associatedDetElement->identify();
  }
 
  // build AnnulusBoundsPC from XY AnnulusBounds
  std::pair<AnnulusBoundsPC, double> res = AnnulusBoundsPC::fromCartesian(annbounds);
  m_bounds = std::make_shared<AnnulusBoundsPC>(res.first);
  double phiShift = res.second;
  // construct shifted transform
  // we get the necessary rotation from ::fromCartesian(), and we need to make
  // the local coordinate system to be rotated correctly here
  Amg::Vector2D origin2D = res.first.moduleOrigin();
  Amg::Translation3D transl(Amg::Vector3D(origin2D.x(), origin2D.y(), 0));
  Amg::Rotation3D rot(Amg::AngleAxis3D(-phiShift, Amg::Vector3D::UnitZ()));
  Amg::Transform3D originTrf;
  originTrf = transl * rot;
 
  m_transforms->transform = m_transforms->transform * originTrf.inverse();
}

DiscSurface() [11/13]

Trk::DiscSurface::DiscSurface

(

const Amg::Transform3D &

htrans

)

Constructor for Discs from HepGeom::Transform3D by unique_ptr.

• bounds is not set

Definition at line 135 of file DiscSurface.cxx.

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

DiscSurface() [12/13]

Trk::DiscSurface::DiscSurface

(

const TrkDetElementBase &

dmnt

)

Constructor for DiscSegment from DetectorElement.

Definition at line 142 of file DiscSurface.cxx.

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

DiscSurface() [13/13]

Trk::DiscSurface::DiscSurface	(	const DiscSurface &	psf,
		const Amg::Transform3D &	transf )

Copy Constructor with shift.

Definition at line 40 of file DiscSurface.cxx.

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

~DiscSurface()

Trk::DiscSurface::~DiscSurface ( )

virtualdefault

Destructor.

Member Function Documentation

bounds()

const SurfaceBounds & Trk::DiscSurface::bounds ( ) const

finaloverridevirtual

This method returns the bounds by reference.

Implements Trk::Surface.

clone()

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

overridevirtual

Virtual constructor.

Implements Trk::Surface.

createUniqueNeutralParameters() [1/2]

Trk::Surface::NeutralTrackParametersUniquePtr Trk::DiscSurface::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 204 of file DiscSurface.cxx.

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

createUniqueNeutralParameters() [2/2]

Trk::Surface::NeutralTrackParametersUniquePtr Trk::DiscSurface::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 194 of file DiscSurface.cxx.

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

createUniqueParameters() [1/2]

template<int DIM, class T>

std::unique_ptr< ParametersT< DIM, T, DiscSurface > > Trk::DiscSurface::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, DiscSurface > > Trk::DiscSurface::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::DiscSurface::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 184 of file DiscSurface.cxx.

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

createUniqueTrackParameters() [2/2]

Trk::Surface::ChargedTrackParametersUniquePtr Trk::DiscSurface::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 175 of file DiscSurface.cxx.

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

globalReferencePoint()

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

finaloverridevirtual

Returns a global reference point: For the Disc this is \( (R*cos(\phi), R*sin(\phi),0)*transform() \) Where \( r, \phi \) denote the r(), averagePhi() of the Bounds.

Reimplemented from Trk::Surface.

Definition at line 212 of file DiscSurface.cxx.

{
  if (!m_referencePoint) {
    const Trk::DiscBounds* dbo =
      dynamic_cast<const Trk::DiscBounds*>(&(bounds()));
    if (dbo) {
      double rMedium = bounds().r();
      double phi = dbo->averagePhi();
      Amg::Vector3D gp(rMedium * cos(phi), rMedium * sin(phi), 0.);
      m_referencePoint.set(std::make_unique<Amg::Vector3D>(transform() * gp));
    } else {
      const Trk::DiscTrapezoidalBounds* dtbo =
        dynamic_cast<const Trk::DiscTrapezoidalBounds*>(&(bounds()));
      // double rMedium = dtbo ? bounds().r() : dtbo->rCenter() ; //nonsense, or
      // logic inverted?
      double rMedium = bounds().r();
      double phi = dtbo ? dtbo->averagePhi() : 0.;
      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::DiscSurface::globalToLocal ( const Amg::Vector3D & glob, const Amg::Vector3D & mom, Amg::Vector2D & loc ) const

overridevirtual

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

local<->global transformation in case of polar local coordinates

Implements Trk::Surface.

Definition at line 253 of file DiscSurface.cxx.

{
  Amg::Vector3D loc3Dframe = inverseTransformMultHelper(glopos);
  locpos = Amg::Vector2D(loc3Dframe.perp(), loc3Dframe.phi());
  return (std::fabs(loc3Dframe.z()) <= s_onSurfaceTolerance);
}

insideBounds()

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

overridevirtual

This method calls the inside method of the bounds.

Implements Trk::Surface.

insideBoundsCheck()

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

finaloverridevirtual

isOnSurface()

bool Trk::DiscSurface::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 290 of file DiscSurface.cxx.

{
  Amg::Vector3D loc3Dframe = inverseTransformMultHelper(glopo);
  if (std::abs(loc3Dframe.z()) > (s_onSurfaceTolerance + tol1)) {
    return false;
  }
  return (bchk
            ? bounds().inside(
                Amg::Vector2D(loc3Dframe.perp(), loc3Dframe.phi()), tol1, tol2)
            : true);
}

localParametersToPosition()

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

finaloverridevirtual

Specialized for DiscSurface : LocalParameters to Vector2D.

localToGlobal()

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

overridevirtual

Specialized for DiscSurface: LocalToGlobal method without dynamic memory allocation.

Implements Trk::Surface.

Definition at line 239 of file DiscSurface.cxx.

{
  // create the position in the local 3d frame
  Amg::Vector3D loc3Dframe(locpos[Trk::locR] * cos(locpos[Trk::locPhi]),
                           locpos[Trk::locR] * sin(locpos[Trk::locPhi]),
                           0.);
  // transport it to the globalframe
  glopos = transform() * loc3Dframe;
}

name()

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

overridevirtual

Return properly formatted class name for screen output.

Implements Trk::Surface.

operator=() [1/2]

Trk::DiscSurface & Trk::DiscSurface::operator=

(

const DiscSurface &

dsf

)

Assignement operator.

Definition at line 152 of file DiscSurface.cxx.

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

operator=() [2/2]

DiscSurface & Trk::DiscSurface::operator= ( DiscSurface && dsf )

defaultnoexcept

Assignement operator.

operator==() [1/2]

bool Trk::DiscSurface::operator==

(

const DiscSurface &

cf

)

const

operator==() [2/2]

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

overridevirtual

Equality operator.

Implements Trk::Surface.

Definition at line 163 of file DiscSurface.cxx.

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

straightLineDistanceEstimate() [1/2]

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

overridevirtual

fast straight line distance evaluation to Surface

distance to surface

Implements Trk::Surface.

Definition at line 307 of file DiscSurface.cxx.

{
  double tol = 0.001;
 
  const Amg::Vector3D& C = center();
  const Amg::Vector3D& N = normal();
 
  double S = C.dot(N);
  double b = S < 0. ? -1 : 1;
  double d = (pos - C).dot(N); // distance to surface
 
  double A = b * dir.dot(N);
  if (A == 0.) { // direction parallel to surface
    if (fabs(d) < tol) {
      return {1, 0., true, 0.};
    }
    return {0, d, true, 0.};
  }
 
  double D = b * (S - (pos.dot(N))) / A;
  return {1, d, true, D};
}

straightLineDistanceEstimate() [2/2]

Trk::DistanceSolution Trk::DiscSurface::straightLineDistanceEstimate ( const Amg::Vector3D & pos, const Amg::Vector3D & dir, bool Bound ) const

overridevirtual

fast straight line distance evaluation to Surface - with bound option

Implements Trk::Surface.

Definition at line 332 of file DiscSurface.cxx.

{
  const Amg::Transform3D& T = transform();
  const double Az[3] = { T(0, 2), T(1, 2), T(2, 2) };
 
  // Transformation to cylinder system coordinates
  //
  const double dx = pos[0] - T(0, 3);
  const double dy = pos[1] - T(1, 3);
  const double dz = pos[2] - T(2, 3);
  const double z = dx * Az[0] + dy * Az[1] + dz * Az[2];
  const double az = dir[0] * Az[0] + dir[1] * Az[1] + dir[2] * Az[2];
 
  // Step to surface
  //
  int ns = 0;
  double s = 0.;
  if (az != 0.) {
    s = -z / az;
    ns = 1;
  }
  double dist = std::abs(z);
  if (!bound) {
    return {ns, dist, true, s};
  }
 
  // Min distance to surface
  //
  const double x = dx * T(0, 0) + dy * T(1, 0) + dz * T(2, 0);
  const double y = dx * T(0, 1) + dy * T(1, 1) + dz * T(2, 1);
 
  Amg::Vector2D lp(sqrt(x * x + y * y), atan2(y, x));
 
  double d = bounds().minDistance(lp);
  if (d > 0.) {
    dist = std::sqrt(dist * dist + d * d);
  }
 
  return {ns, dist, true, s};
}

straightLineIntersection()

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

finaloverridevirtual

fast straight line intersection schema - standard: provides closest intersection and (signed) path length forceDir is to provide the closest forward solution

mathematical motivation:

the equation of the plane is given by:
\( \vec n \cdot \vec x = \vec n \cdot \vec p,\)
where \( \vec n = (n_{x}, n_{y}, n_{z})\) denotes the normal vector of the plane, \( \vec p = (p_{x}, p_{y}, p_{z})\) one specific point on the plane and \( \vec x = (x,y,z) \) all possible points on the plane.
Given a line with:
\( \vec l(u) = \vec l_{1} + u \cdot \vec v \),
the solution for \( u \) can be written: \( u = \frac{\vec n (\vec p - \vec l_{1})}{\vec n \vec v}\)
If the denominator is 0 then the line lies:

• either in the plane
• perpenticular to the normal of the plane

Implements Trk::Surface.

Definition at line 263 of file DiscSurface.cxx.

                                                                        {
  double denom = dir.dot(normal());
  if (denom) {
    double u = (normal().dot((center() - pos))) / (denom);
    Amg::Vector3D intersectPoint(pos + u * dir);
    // evaluate the intersection in terms of direction
    bool isValid = forceDir ? (u > 0.) : true;
    // evaluate (if necessary in terms of boundaries)
    isValid = bchk ? (isValid && isOnSurface(intersectPoint)) : isValid;
    // return the result
    return Trk::Intersection(intersectPoint, u, isValid);
  }
  return Trk::Intersection(pos, 0., false);
}

type()

virtual constexpr SurfaceType Trk::DiscSurface::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 280 of file DiscSurface.h.

::BoundSurfaceCnv_p2

template<class SURFACE, class BOUNDS_CNV>

friend class ::BoundSurfaceCnv_p2

friend

bounds (shared)

Definition at line 282 of file DiscSurface.h.

Member Data Documentation

m_bounds

std::shared_ptr<const SurfaceBounds> Trk::DiscSurface::m_bounds

protected

reference Point on the Surface

Definition at line 284 of file DiscSurface.h.

m_referencePoint

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

protected

static member for boundless approach

Definition at line 286 of file DiscSurface.h.

s_boundless

const Trk::NoBounds Trk::DiscSurface::s_boundless

staticprotected

Definition at line 288 of file DiscSurface.h.

staticType

SurfaceType Trk::DiscSurface::staticType = SurfaceType::Disc

staticconstexpr

Definition at line 57 of file DiscSurface.h.

---

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

• DiscSurface.h
• SlidingDiscSurface.cxx
• DiscSurface.cxx