Trk::SolenoidalIntersector Class Reference

#include <SolenoidalIntersector.h>

Inheritance diagram for Trk::SolenoidalIntersector:

Collaboration diagram for Trk::SolenoidalIntersector:

Classes
struct	Constants
	Constants of motion and other cached values. More...

Public Member Functions
	SolenoidalIntersector (const std::string &type, const std::string &name, const IInterface *parent)
virtual	~SolenoidalIntersector ()=default
virtual StatusCode	initialize () override
virtual StatusCode	finalize () override
virtual std::optional< TrackSurfaceIntersection >	intersectSurface (const Surface &surface, const TrackSurfaceIntersection &trackTrackSurfaceIntersection, const double qOverP) const override
	IIntersector interface method for general Surface type.
virtual std::optional< TrackSurfaceIntersection >	approachPerigeeSurface (const PerigeeSurface &surface, const TrackSurfaceIntersection &trackTrackSurfaceIntersection, const double qOverP) const override
	IIntersector interface method for specific Surface type : PerigeeSurface.
virtual std::optional< TrackSurfaceIntersection >	approachStraightLineSurface (const StraightLineSurface &surface, const TrackSurfaceIntersection &trackTrackSurfaceIntersection, const double qOverP) const override
	IIntersector interface method for specific Surface type : StraightLineSurface.
virtual std::optional< TrackSurfaceIntersection >	intersectCylinderSurface (const CylinderSurface &surface, const TrackSurfaceIntersection &trackTrackSurfaceIntersection, const double qOverP) const override
	IIntersector interface method for specific Surface type : CylinderSurface.
virtual std::optional< TrackSurfaceIntersection >	intersectDiscSurface (const DiscSurface &surface, const TrackSurfaceIntersection &trackTrackSurfaceIntersection, const double qOverP) const override
	IIntersector interface method for specific Surface type : DiscSurface.
virtual std::optional< TrackSurfaceIntersection >	intersectPlaneSurface (const PlaneSurface &surface, const TrackSurfaceIntersection &trackTrackSurfaceIntersection, const double qOverP) const override
	IIntersector interface method for specific Surface type : PlaneSurface.
virtual bool	isValid (Amg::Vector3D startPosition, Amg::Vector3D endPosition) const override
	IIntersector interface method to check validity of parametrization within extrapolation range.

Private Member Functions
void	throwMissingCondData () const
const SolenoidParametrization *	getSolenoidParametrization () const
double	circularArcLength (double, double, double, double, double, double, double &, double &) const
double	linearArcLength (const TrackSurfaceIntersection &isect, const Constants &com, const double radius2, const double endRadius) const
bool	extrapolateToR (TrackSurfaceIntersection &isect, double &radius2, Constants &com, const double endRadius) const
std::optional< TrackSurfaceIntersection >	intersection (TrackSurfaceIntersection &&isect, Constants &com, const Surface &surface) const

Static Private Member Functions
static bool	extrapolateToZ (TrackSurfaceIntersection &isect, Constants &com, const double endZ)
static std::optional< TrackSurfaceIntersection >	newIntersection (const TrackSurfaceIntersection &oldIsect, const SolenoidParametrization &solpar, const double qOverP, Constants *&com)

Private Attributes
SG::ReadCondHandleKey< SolenoidParametrization >	m_solenoidParametrizationKey
ToolHandle< IIntersector >	m_rungeKuttaIntersector
DoubleProperty	m_surfaceTolerance
std::atomic< unsigned long long >	m_countExtrapolations = 0
std::atomic< unsigned long long >	m_countRKSwitches = 0

Static Private Attributes
static constexpr double	m_deltaPhiTolerance = 0.01

Detailed Description

Definition at line 29 of file SolenoidalIntersector.h.

Constructor & Destructor Documentation

SolenoidalIntersector()

Trk::SolenoidalIntersector::SolenoidalIntersector	(	const std::string &	type,
		const std::string &	name,
		const IInterface *	parent )

Definition at line 38 of file SolenoidalIntersector.cxx.

  : base_class(type, name, parent) {}

~SolenoidalIntersector()

virtual Trk::SolenoidalIntersector::~SolenoidalIntersector ( )

virtualdefault

Member Function Documentation

approachPerigeeSurface()

std::optional< Trk::TrackSurfaceIntersection > Trk::SolenoidalIntersector::approachPerigeeSurface ( const PerigeeSurface & surface, const TrackSurfaceIntersection & trackTrackSurfaceIntersection, const double qOverP ) const

overridevirtual

IIntersector interface method for specific Surface type : PerigeeSurface.

Definition at line 99 of file SolenoidalIntersector.cxx.

{ return m_rungeKuttaIntersector->approachPerigeeSurface(surface, trackIntersection, qOverP); }

approachStraightLineSurface()

std::optional< Trk::TrackSurfaceIntersection > Trk::SolenoidalIntersector::approachStraightLineSurface ( const StraightLineSurface & surface, const TrackSurfaceIntersection & trackTrackSurfaceIntersection, const double qOverP ) const

overridevirtual

IIntersector interface method for specific Surface type : StraightLineSurface.

Definition at line 106 of file SolenoidalIntersector.cxx.

{ return m_rungeKuttaIntersector->approachStraightLineSurface(surface, trackIntersection, qOverP); }

circularArcLength()

double Trk::SolenoidalIntersector::circularArcLength ( double endRadius, double radiusOfCurvature, double xCentre, double yCentre, double cosPhi, double sinPhi, double & cosPhiIntersect, double & sinPhiIntersect ) const

inlineprivate

Definition at line 163 of file SolenoidalIntersector.h.

                                   {
  int trapped = 0;
  double radiusSquared = xCentre * xCentre + yCentre * yCentre;
  double term = 0.5 *
                (radiusSquared + radiusOfCurvature * radiusOfCurvature -
                 endRadius * endRadius) /
                (radiusSquared * radiusOfCurvature);
  if (std::abs(xCentre) < std::abs(yCentre)) {
    double dx2 = yCentre * yCentre * (1. / (radiusSquared * term * term) - 1.);
    if (dx2 < 0.) {
      trapped = 1;
    } else {
      if (yCentre * term > 0.) {
        sinPhiIntersect = term * (-xCentre + std::sqrt(dx2));
      } else {
        sinPhiIntersect = term * (-xCentre - std::sqrt(dx2));
      }
      cosPhiIntersect =
          (sinPhiIntersect * xCentre + radiusSquared * term) / yCentre;
    }
  } else {
    double dy2 = xCentre * xCentre * (1. / (radiusSquared * term * term) - 1.);
    if (dy2 < 0.) {
      trapped = 1;
    } else {
      if (xCentre * term > 0.) {
        cosPhiIntersect = term * (yCentre + std::sqrt(dy2));
      } else {
        cosPhiIntersect = term * (yCentre - std::sqrt(dy2));
      }
      sinPhiIntersect =
          (cosPhiIntersect * yCentre - radiusSquared * term) / xCentre;
    }
  }
  if (trapped == 0) {
    double deltaPhi;
    double sinDeltaPhi = sinPhiIntersect * cosPhi - cosPhiIntersect * sinPhi;
    if (std::abs(sinDeltaPhi) > 0.1) {
      deltaPhi = std::asin(sinDeltaPhi);
    } else {
      deltaPhi = sinDeltaPhi * (1. + 0.166667 * sinDeltaPhi * sinDeltaPhi);
    }
    return (radiusOfCurvature * deltaPhi);
  } else {
    cosPhiIntersect = cosPhi;
    sinPhiIntersect = sinPhi;
    return 0.;
  }
}

extrapolateToR()

bool Trk::SolenoidalIntersector::extrapolateToR ( TrackSurfaceIntersection & isect, double & radius2, Constants & com, const double endRadius ) const

private

Definition at line 261 of file SolenoidalIntersector.cxx.

{
    Amg::Vector3D& pos = isect.position();
    Amg::Vector3D& dir = isect.direction();
 
    double fieldComponent =
        com.m_solPar.fieldComponent(pos.z(), com.m_solParams);
    double curvature = fieldComponent * com.m_qOverPt;
    double arcLength = linearArcLength(isect, com, radius2, endR);
    if (std::abs(arcLength * curvature) > m_deltaPhiTolerance) {
      double radiusOfCurvature = 1. / curvature;
      double xCentre =
          pos.x() - radiusOfCurvature * dir.y() * com.m_oneOverSinTheta;
      double yCentre =
          pos.y() + radiusOfCurvature * dir.x() * com.m_oneOverSinTheta;
      double cosPhi;
      double sinPhi;
      arcLength =
          circularArcLength(endR, radiusOfCurvature, xCentre, yCentre,
                            dir.x() * com.m_oneOverSinTheta,
                            dir.y() * com.m_oneOverSinTheta, cosPhi, sinPhi);
      if (std::abs(arcLength * com.m_cotTheta) < m_surfaceTolerance) {
          pos.x() = xCentre + radiusOfCurvature * sinPhi;
          pos.y() = yCentre - radiusOfCurvature * cosPhi;
          pos.z() += arcLength * com.m_cotTheta;
          radius2 = endR * endR;
          dir.x() = cosPhi * com.m_sinTheta;
          dir.y() = sinPhi * com.m_sinTheta;
          isect.pathlength() += arcLength * com.m_oneOverSinTheta;
          arcLength = 0.;
      }
    }
 
    double deltaZ = arcLength * com.m_cotTheta;
    if (std::abs(deltaZ) < m_surfaceTolerance)  // avoid FPE with constant
                                                // curvature parabolic approx
    {
      double cosPhi = dir.x() * com.m_oneOverSinTheta;
      double sinPhi = dir.y() * com.m_oneOverSinTheta;
      if (std::abs(arcLength) > m_surfaceTolerance) {
          double sinDPhi = 0.5 * arcLength * curvature;
          double cosDPhi =
              1. - 0.5 * sinDPhi * sinDPhi * (1.0 + 0.25 * sinDPhi * sinDPhi);
          double temp = cosPhi;
          cosPhi = temp * cosDPhi - sinPhi * sinDPhi;
          sinPhi = temp * sinDPhi + sinPhi * cosDPhi;
          dir.x() = (cosPhi * cosDPhi - sinPhi * sinDPhi) * com.m_sinTheta;
          dir.y() = (sinPhi * cosDPhi + cosPhi * sinDPhi) * com.m_sinTheta;
      }
 
      pos.x() += arcLength * cosPhi;
      pos.y() += arcLength * sinPhi;
      pos.z() += arcLength * com.m_cotTheta;
      radius2 = endR * endR;
      isect.pathlength() += arcLength * com.m_oneOverSinTheta;
    } else {
      extrapolateToZ(isect, com, pos.z() + deltaZ);
      radius2 = pos.perp2();
      if (std::abs(endR - std::sqrt(radius2)) > m_surfaceTolerance) {
          deltaZ = linearArcLength(isect, com, radius2, endR) * com.m_cotTheta;
          extrapolateToZ(isect, com, pos.z() + deltaZ);
          radius2 = pos.perp2();
      }
    }
 
    return true;
}

extrapolateToZ()

bool Trk::SolenoidalIntersector::extrapolateToZ ( TrackSurfaceIntersection & isect, Constants & com, const double endZ )

staticprivate

Definition at line 333 of file SolenoidalIntersector.cxx.

{
    Amg::Vector3D& pos = isect.position();
    Amg::Vector3D& dir = isect.direction();
 
    double firstIntegral = 0.;
    double secondIntegral = 0.;
    com.m_solPar.fieldIntegrals(firstIntegral, secondIntegral, pos.z(), endZ,
                                com.m_solParams);
    double DFiMax = 0.1;
    double cosPhi = dir.x() * com.m_oneOverSinTheta;
    double sinPhi = dir.y() * com.m_oneOverSinTheta;
    double cosBeta;
    double sinBeta;
    double deltaPhi2 =
        secondIntegral * com.m_qOverPt / std::abs(com.m_cotTheta);
    if (std::abs(deltaPhi2) < DFiMax) {
      double deltaPhi2Squared = deltaPhi2 * deltaPhi2;
      sinBeta = 1. - 0.166667 * deltaPhi2Squared;
      cosBeta = -0.5 * deltaPhi2 * (1. - 0.083333 * deltaPhi2Squared);
    } else if (2. * std::abs(deltaPhi2) < M_PI) {
      sinBeta = std::sin(deltaPhi2) / deltaPhi2;
      cosBeta = (std::cos(deltaPhi2) - 1.) / deltaPhi2;
    } else {
      return false;
    }
 
    double radialDistance = (endZ - pos.z()) / com.m_cotTheta;
    pos.x() += radialDistance * (sinPhi * cosBeta + cosPhi * sinBeta);
    pos.y() += radialDistance * (sinPhi * sinBeta - cosPhi * cosBeta);
    pos.z() = endZ;
    isect.pathlength() += radialDistance * com.m_oneOverSinTheta;
 
    double cosAlpha;
    double sinAlpha;
    double deltaPhi1 = firstIntegral * com.m_qOverPt / std::abs(com.m_cotTheta);
    if (std::abs(deltaPhi1) < DFiMax) {
      double deltaPhi1Squared = deltaPhi1 * deltaPhi1;
      sinAlpha = deltaPhi1 * (1. - 0.166667 * deltaPhi1Squared);
      cosAlpha =
          1. - 0.5 * deltaPhi1Squared * (1. - 0.083333 * deltaPhi1Squared);
    } else {
      sinAlpha = std::sin(deltaPhi1);
      cosAlpha = std::cos(deltaPhi1);
    }
    dir.x() = (cosPhi * cosAlpha - sinPhi * sinAlpha) * com.m_sinTheta;
    dir.y() = (sinPhi * cosAlpha + cosPhi * sinAlpha) * com.m_sinTheta;
    return true;
}

finalize()

StatusCode Trk::SolenoidalIntersector::finalize ( )

overridevirtual

Definition at line 52 of file SolenoidalIntersector.cxx.

{
    ATH_MSG_DEBUG( "finalized after " << m_countExtrapolations << " extrapolations with "
          << m_countRKSwitches << " switches to RK integration");
 
    return StatusCode::SUCCESS;
}

getSolenoidParametrization()

const SolenoidParametrization * Trk::SolenoidalIntersector::getSolenoidParametrization ( ) const

inlineprivate

Definition at line 118 of file SolenoidalIntersector.h.

                                                                    {
    SG::ReadCondHandle<SolenoidParametrization> handle(
        m_solenoidParametrizationKey);
    if (!handle.isValid()) {
      throwMissingCondData();
    }
    return handle.cptr();
  }

initialize()

StatusCode Trk::SolenoidalIntersector::initialize ( )

overridevirtual

Definition at line 44 of file SolenoidalIntersector.cxx.

{
    ATH_CHECK( m_solenoidParametrizationKey.initialize() );
    ATH_CHECK(m_rungeKuttaIntersector.retrieve());
    return StatusCode::SUCCESS;
}

intersectCylinderSurface()

std::optional< Trk::TrackSurfaceIntersection > Trk::SolenoidalIntersector::intersectCylinderSurface ( const CylinderSurface & surface, const TrackSurfaceIntersection & trackTrackSurfaceIntersection, const double qOverP ) const

overridevirtual

IIntersector interface method for specific Surface type : CylinderSurface.

Definition at line 113 of file SolenoidalIntersector.cxx.

{
    const SolenoidParametrization* solenoidParametrization =
      getSolenoidParametrization();
 
    double endRadius        = surface.globalReferencePoint().perp();
    if (!solenoidParametrization || endRadius > solenoidParametrization->maximumR())
      return m_rungeKuttaIntersector->intersectCylinderSurface(surface, trackIntersection, qOverP);
 
    Constants* com = nullptr;
    std::optional<TrackSurfaceIntersection> isect = newIntersection(
        trackIntersection, *solenoidParametrization, qOverP, com);
    ++m_countExtrapolations;
 
    double radius2 = isect->position().perp2();
    if (std::abs(endRadius - sqrt(radius2)) > m_surfaceTolerance
        && ! extrapolateToR(*isect, radius2, *com, endRadius))  return std::nullopt;
 
    return intersection(std::move(*isect), *com, surface);
}

intersectDiscSurface()

std::optional< Trk::TrackSurfaceIntersection > Trk::SolenoidalIntersector::intersectDiscSurface ( const DiscSurface & surface, const TrackSurfaceIntersection & trackTrackSurfaceIntersection, const double qOverP ) const

overridevirtual

IIntersector interface method for specific Surface type : DiscSurface.

Definition at line 138 of file SolenoidalIntersector.cxx.

{
    const SolenoidParametrization* solenoidParametrization =
      getSolenoidParametrization();
 
    double endZ = surface.center().z();
    if (!solenoidParametrization || std::abs(endZ) > solenoidParametrization->maximumZ())
      return m_rungeKuttaIntersector->intersectDiscSurface(surface, trackIntersection, qOverP);
 
    Constants* com = nullptr;
    std::optional<TrackSurfaceIntersection> isect =
      newIntersection (trackIntersection,
                       *solenoidParametrization,
                       qOverP,
                       com);
                                                             
    ++m_countExtrapolations;
 
    if (std::abs(endZ -trackIntersection.position().z()) > m_surfaceTolerance
        && ! extrapolateToZ(*isect, *com, endZ))
    {
      return std::nullopt;
    }
    
    return intersection(std::move(*isect), *com, surface);
}

intersection()

std::optional< TrackSurfaceIntersection > Trk::SolenoidalIntersector::intersection ( TrackSurfaceIntersection && isect, Constants & com, const Surface & surface ) const

inlineprivate

Definition at line 239 of file SolenoidalIntersector.h.

                                  {
  // Improve the estimate of the intersection by calculating
  // the straight-line intersection.
  Intersection SLIntersect = surface.straightLineIntersection(
      isect.position(), isect.direction(), false, false);
  if (SLIntersect.valid) {
    // But first save our current position, so that we can
    // start from here on the next call.
    com.m_lastPosition = isect.position();
    isect.position() = SLIntersect.position;
    return std::move(isect);
  }
 
  return std::nullopt;
}

intersectPlaneSurface()

std::optional< Trk::TrackSurfaceIntersection > Trk::SolenoidalIntersector::intersectPlaneSurface ( const PlaneSurface & surface, const TrackSurfaceIntersection & trackTrackSurfaceIntersection, const double qOverP ) const

overridevirtual

IIntersector interface method for specific Surface type : PlaneSurface.

Definition at line 169 of file SolenoidalIntersector.cxx.

{
    const SolenoidParametrization* solenoidParametrization =
      getSolenoidParametrization();
 
    if (!solenoidParametrization ||
        std::abs(surface.center().z())  > solenoidParametrization->maximumZ()
        || surface.center().perp()  > solenoidParametrization->maximumR())
      return m_rungeKuttaIntersector->intersectPlaneSurface(surface, trackIntersection, qOverP);
 
    Constants* com = nullptr;
    std::optional<TrackSurfaceIntersection> isect =
      newIntersection (trackIntersection,
                       *solenoidParametrization,
                       qOverP,
                       com);
    Amg::Vector3D& pos = isect->position();
    Amg::Vector3D& dir = isect->direction();
    ++m_countExtrapolations;
    double radius2 = pos.perp2();
 
    // step until sufficiently near to plane surface
    // this gives wrong answer!
    // DistanceSolution solution    = surface.straightLineDistanceEstimate(pos,dir);
    // if (! solution.signedDistance())                     return 0;
    // double distance      = solution.currentDistance(true);
 
    int numberSteps = 0;
    double dot      = surface.normal().dot(dir);
    double offset   = surface.normal().dot(surface.center() - pos);
 
    while (std::abs(offset) > m_surfaceTolerance * std::abs(dot)) {
      // take care if grazing incidence - quit if looper
      if (std::abs(dot) < 0.0001)
        return std::nullopt;
      double distance = offset / dot;
 
      // extrapolate
      if (com->m_sinTheta < 0.9) {
        if (!extrapolateToZ(*isect, *com, pos.z() + distance * dir.z()))
          return std::nullopt;
        radius2 = pos.perp2();
      } else {
        if (!extrapolateToR(*isect, radius2, *com,
                            (pos + distance * dir).perp()))
          return std::nullopt;
      }
 
      // check we are getting closer to the plane, switch to RK in case of
      // difficulty
      dot = surface.normal().dot(dir);
      offset = surface.normal().dot(surface.center() - pos);
      if (std::abs(offset) > m_surfaceTolerance * std::abs(dot) &&
          (++numberSteps > 5 ||
           std::abs(offset) > 0.5 * std::abs(distance * dot))) {
        ++m_countRKSwitches;
        ATH_MSG_DEBUG(" switch to RK after "
                      << numberSteps << " steps at offset " << offset
                      << "   dot " << surface.normal().dot(dir));
 
        return m_rungeKuttaIntersector->intersectPlaneSurface(
            surface, trackIntersection, qOverP);
      }
    };
 
    return intersection(std::move(*isect), *com, surface);
}

intersectSurface()

std::optional< Trk::TrackSurfaceIntersection > Trk::SolenoidalIntersector::intersectSurface ( const Surface & surface, const TrackSurfaceIntersection & trackTrackSurfaceIntersection, const double qOverP ) const

overridevirtual

IIntersector interface method for general Surface type.

Definition at line 63 of file SolenoidalIntersector.cxx.

{
 
    const auto surfaceType = surface.type();
    if (surfaceType == Trk::SurfaceType::Plane) {
      return intersectPlaneSurface(static_cast<const PlaneSurface&>(surface),
                                   trackIntersection, qOverP);
    }
    if (surfaceType == Trk::SurfaceType::Line) {
      return m_rungeKuttaIntersector->approachStraightLineSurface(
          static_cast<const StraightLineSurface&>(surface), trackIntersection,
          qOverP);
    }
    if (surfaceType == Trk::SurfaceType::Cylinder) {
      return intersectCylinderSurface(
          static_cast<const CylinderSurface&>(surface), trackIntersection,
          qOverP);
    }
    if (surfaceType == Trk::SurfaceType::Disc) {
      return intersectDiscSurface(static_cast<const DiscSurface&>(surface),
                                  trackIntersection, qOverP);
    }
    if (surfaceType == Trk::SurfaceType::Perigee) {
      return m_rungeKuttaIntersector->approachPerigeeSurface(
          static_cast<const PerigeeSurface&>(surface), trackIntersection,
          qOverP);
    }
 
    ATH_MSG_WARNING( " unrecognized Surface" );
    return std::nullopt;
}

isValid()

bool Trk::SolenoidalIntersector::isValid ( Amg::Vector3D startPosition, Amg::Vector3D endPosition ) const

overridevirtual

IIntersector interface method to check validity of parametrization within extrapolation range.

Definition at line 241 of file SolenoidalIntersector.cxx.

{
    const SolenoidParametrization* solenoidParametrization =
      getSolenoidParametrization();
 
    // check cylinder bounds for valid parametrization
    return solenoidParametrization &&
 
        std::abs(endPosition.z())   < solenoidParametrization->maximumZ()
 
    && endPosition.perp()       < solenoidParametrization->maximumR()
 
    && getSolenoidParametrization()->validOrigin(startPosition);
}

linearArcLength()

double Trk::SolenoidalIntersector::linearArcLength ( const TrackSurfaceIntersection & isect, const Constants & com, const double radius2, const double endRadius ) const

inlineprivate

Definition at line 219 of file SolenoidalIntersector.h.

                                                        {
  const Amg::Vector3D& pos = isect.position();
  const Amg::Vector3D& dir = isect.direction();
 
  double arcLength =
      (-dir.x() * pos.x() - dir.y() * pos.y()) * com.m_oneOverSinTheta;
  double radiusSquared =
      endRadius * endRadius - radius2 + arcLength * arcLength;
  if (radiusSquared > 0.) {
    if (endRadius > 0.) {
      arcLength += std::sqrt(radiusSquared);
    } else {
      arcLength -= std::sqrt(radiusSquared);
    }
  }
  return arcLength;
}

newIntersection()

std::optional< TrackSurfaceIntersection > Trk::SolenoidalIntersector::newIntersection ( const TrackSurfaceIntersection & oldIsect, const SolenoidParametrization & solpar, const double qOverP, Constants *& com )

staticprivate

Definition at line 386 of file SolenoidalIntersector.cxx.

{
  const TrackSurfaceIntersection::IIntersectionCache* oldCache = isect.cache();
  std::unique_ptr<Constants> cache;
  Amg::Vector3D lastPosition;
  lastPosition.setZero();
 
  if (oldCache) {
      assert(typeid(*oldCache) == typeid(Constants));
      cache =
          std::make_unique<Constants>(*static_cast<const Constants*>(oldCache));
      lastPosition = cache->m_lastPosition;
  } else {
      cache = std::make_unique<Constants>(solpar, isect, qOverP);
  }
 
  // cppcheck-suppress danglingLifetime
  com = cache.get();
  auto newIsect =
      std::make_optional<TrackSurfaceIntersection>(isect, std::move(cache));
  if (oldCache) {
    newIsect->position() = lastPosition;
  }
  return newIsect;
}

throwMissingCondData()

void Trk::SolenoidalIntersector::throwMissingCondData ( ) const

private

Definition at line 415 of file SolenoidalIntersector.cxx.

                                                       {
   std::stringstream msg;
   msg << "Invalid read handle for SolenoidParametrization  " << m_solenoidParametrizationKey.key();
   throw std::logic_error(msg.str());
}

Member Data Documentation

m_countExtrapolations

std::atomic<unsigned long long> Trk::SolenoidalIntersector::m_countExtrapolations = 0

mutableprivate

Definition at line 157 of file SolenoidalIntersector.h.

m_countRKSwitches

std::atomic<unsigned long long> Trk::SolenoidalIntersector::m_countRKSwitches = 0

mutableprivate

Definition at line 158 of file SolenoidalIntersector.h.

m_deltaPhiTolerance

double Trk::SolenoidalIntersector::m_deltaPhiTolerance = 0.01

staticconstexprprivate

Definition at line 152 of file SolenoidalIntersector.h.

m_rungeKuttaIntersector

ToolHandle<IIntersector> Trk::SolenoidalIntersector::m_rungeKuttaIntersector

private

Initial value:

{this, "RungeKuttaIntersector",
    "Trk::RungeKuttaIntersector/RungeKuttaIntersector"}

Definition at line 149 of file SolenoidalIntersector.h.

                                                  {this, "RungeKuttaIntersector",
    "Trk::RungeKuttaIntersector/RungeKuttaIntersector"};

m_solenoidParametrizationKey

SG::ReadCondHandleKey<SolenoidParametrization> Trk::SolenoidalIntersector::m_solenoidParametrizationKey

private

Initial value:

{
      this, "SolenoidParameterizationKey", "SolenoidParametrization", ""}

Definition at line 147 of file SolenoidalIntersector.h.

                                                                           {
      this, "SolenoidParameterizationKey", "SolenoidParametrization", ""};

m_surfaceTolerance

DoubleProperty Trk::SolenoidalIntersector::m_surfaceTolerance

private

Initial value:

{this, "SurfaceTolerance",
    2.0 * Gaudi::Units::micrometer}

Definition at line 153 of file SolenoidalIntersector.h.

                                   {this, "SurfaceTolerance",
    2.0 * Gaudi::Units::micrometer};

---

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

• SolenoidalIntersector.h
• SolenoidalIntersector.cxx