Trk::RungeKuttaIntersector Class Reference

#include <RungeKuttaIntersector.h>

Inheritance diagram for Trk::RungeKuttaIntersector:

Collaboration diagram for Trk::RungeKuttaIntersector:

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

Private Member Functions
void	assignStepLength (const TrackSurfaceIntersection &isect, double &stepLength) const
void	debugFailure (TrackSurfaceIntersection &&isect, const Surface &surface, const double qOverP, const double rStart, const double zStart, const bool trapped) const
double	distanceToCylinder (const TrackSurfaceIntersection &isect, const double cylinderRadius, const double offsetRadius, const Amg::Vector3D &offset, double &stepLength) const
double	distanceToDisc (const TrackSurfaceIntersection &isect, const double discZ, double &stepLength) const
double	distanceToLine (const TrackSurfaceIntersection &isect, const Amg::Vector3D &linePosition, const Amg::Vector3D &lineDirection, double &stepLength) const
double	distanceToPlane (const TrackSurfaceIntersection &isect, const Amg::Vector3D &planePosition, const Amg::Vector3D &planeNormal, double &stepLength) const
Amg::Vector3D	field (const Amg::Vector3D &point, MagField::AtlasFieldCache &fieldCache) const
void	initializeFieldCache (MagField::AtlasFieldCache &fieldCache) const
std::optional< TrackSurfaceIntersection >	newIntersection (TrackSurfaceIntersection &&isect, const Surface &surface, const double qOverP, const double rStart, const double zStart) const
void	shortStep (TrackSurfaceIntersection &isect, const Amg::Vector3D &fieldValue, const double stepLength, const double qOverP) const
void	step (TrackSurfaceIntersection &isect, Amg::Vector3D &fieldValue, double &stepLength, const double qOverP, MagField::AtlasFieldCache &fieldCache) const

Private Attributes
SG::ReadCondHandleKey< AtlasFieldCacheCondObj >	m_fieldCacheCondObjInputKey
BooleanProperty	m_productionMode {this, "ProductionMode", true}
const double	m_caloR0 = 1900.*Gaudi::Units::mm
const double	m_caloR1 = 2500.*Gaudi::Units::mm
const double	m_caloR2 = 3500.*Gaudi::Units::mm
const double	m_caloR3 = 3700.*Gaudi::Units::mm
const double	m_caloR4 = 3800.*Gaudi::Units::mm
const double	m_caloZ0 = 2350.*Gaudi::Units::mm
const double	m_caloZ1 = 2600.*Gaudi::Units::mm
const double	m_caloZ2 = 3600.*Gaudi::Units::mm
const double	m_caloZ3 = 6000.*Gaudi::Units::mm
const double	m_inDetR0 = 400.*Gaudi::Units::mm
const double	m_inDetR1 = 350.*Gaudi::Units::mm
const double	m_inDetR2 = 800.*Gaudi::Units::mm
const double	m_inDetZ0 = 350.*Gaudi::Units::mm
const double	m_inDetZ1 = 420.*Gaudi::Units::mm
const double	m_inDetZ2 = 700.*Gaudi::Units::mm
const double	m_momentumThreshold = 1./20.*Gaudi::Units::MeV
const double	m_momentumWarnThreshold = 1./450.*Gaudi::Units::MeV
const double	m_muonR0 = 4300.*Gaudi::Units::mm
const double	m_muonZ0 = 6600.*Gaudi::Units::mm
double	m_shortStepMax = 3.0*Gaudi::Units::mm
const double	m_shortStepMin = 10.*Gaudi::Units::nanometer
const double	m_solenoidR = 1300.*Gaudi::Units::mm
const double	m_solenoidZ = 3500.*Gaudi::Units::mm
double	m_stepMax0 = 8.0*Gaudi::Units::mm
double	m_stepMax1 = 40.0*Gaudi::Units::mm
double	m_stepMax2 = 80.0*Gaudi::Units::mm
double	m_stepMax3 = 160.0*Gaudi::Units::mm
double	m_stepMax4 = 320.0*Gaudi::Units::mm
int	m_stepsUntilTrapped = 2000
const double	m_third = 1./3.
const double	m_toroidR0 = 1850.0*Gaudi::Units::mm
const double	m_toroidR1 = 3500.0*Gaudi::Units::mm
const double	m_toroidR2 = 6000.0*Gaudi::Units::mm
const double	m_toroidR3 = 6500.0*Gaudi::Units::mm
const double	m_toroidZ0 = 7000.0*Gaudi::Units::mm
const double	m_toroidZ1 = 8000.0*Gaudi::Units::mm
const double	m_toroidZ2 = 8700.0*Gaudi::Units::mm
const double	m_toroidZ3 = 9100.0*Gaudi::Units::mm
const double	m_toroidZ4 = 9500.0*Gaudi::Units::mm
const double	m_toroidZ5 = 9800.0*Gaudi::Units::mm
const double	m_toroidZ6 = 11400.0*Gaudi::Units::mm
const double	m_toroidZ7 = 12900.0*Gaudi::Units::mm
const double	m_toroidZ8 = 14000.0*Gaudi::Units::mm
std::atomic< unsigned long long >	m_countExtrapolations = 0
std::atomic< unsigned long long >	m_countShortStep = 0
std::atomic< unsigned long long >	m_countStep = 0
std::atomic< unsigned long long >	m_countStepReduction = 0

Detailed Description

Definition at line 28 of file RungeKuttaIntersector.h.

Constructor & Destructor Documentation

RungeKuttaIntersector()

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

Definition at line 50 of file RungeKuttaIntersector.cxx.

  : base_class      (type, name, parent) {}

~RungeKuttaIntersector()

virtual Trk::RungeKuttaIntersector::~RungeKuttaIntersector ( )

virtualdefault

Member Function Documentation

approachPerigeeSurface()

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

overridevirtual

IIntersector interface method for specific Surface type : PerigeeSurface.

Definition at line 142 of file RungeKuttaIntersector.cxx.

{
    ++m_countExtrapolations;
    TrackSurfaceIntersection isect = trackIntersection;
    const Amg::Vector3D& pos = isect.position();
    const double rStart = pos.perp();
    const double zStart = pos.z();
    MagField::AtlasFieldCache fieldCache;
    initializeFieldCache(fieldCache);
    Amg::Vector3D fieldValue = field(pos, fieldCache);
 
    // straight line distance along track to closest approach to line
    const Amg::Vector3D& lineDirection = (surface.transform().rotation()).col(2);
    double stepLength = 0;
    double distance = distanceToLine (isect, surface.center(),lineDirection, stepLength);
    unsigned long long stepsUntilTrapped =  m_stepsUntilTrapped;
    double previousDistance         = 1.1*distance;
 
    // integration loop (step)
    while (distance > m_shortStepMax)
    {
        if (isTrapped(distance, previousDistance, stepsUntilTrapped)) {
            // trapped
            if (msgLvl(MSG::DEBUG)) debugFailure (std::move(isect), surface, qOverP,
                                                  rStart, zStart, true);
            return std::nullopt;
        }
        assignStepLength(isect, stepLength);
        step(isect, fieldValue, stepLength, qOverP, fieldCache);
        distance = distanceToLine (isect, surface.center(),lineDirection, stepLength);
    }
 
    // if intersection OK: make short final step to surface - assuming constant field
    if (distance > m_shortStepMin)    shortStep(isect, fieldValue, stepLength, qOverP);
    return newIntersection(std::move(isect), surface, qOverP,
                           rStart, zStart);
}

approachStraightLineSurface()

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

overridevirtual

IIntersector interface method for specific Surface type : StraightLineSurface.

Definition at line 184 of file RungeKuttaIntersector.cxx.

{
    ++m_countExtrapolations;
    TrackSurfaceIntersection isect = trackIntersection;
    const Amg::Vector3D& pos = isect.position();
    const double rStart = pos.perp();
    const double zStart = pos.z();
    MagField::AtlasFieldCache fieldCache;
    initializeFieldCache(fieldCache);
    Amg::Vector3D fieldValue = field(pos, fieldCache);
 
    // straight line distance along track to closest approach to line
    const Amg::Vector3D& lineDirection = (surface.transform().rotation()).col(2);
    double stepLength = 0;
    double distance = distanceToLine (isect, surface.center(),lineDirection, stepLength);
    unsigned long long stepsUntilTrapped =  m_stepsUntilTrapped;
    double previousDistance         = 1.1*distance;
 
    // integration loop (step)
    while (distance > m_shortStepMax)
    {
        if (isTrapped(distance, previousDistance, stepsUntilTrapped)) {
            // trapped
            if (msgLvl(MSG::DEBUG)) debugFailure (std::move(isect), surface, qOverP,
                                                  rStart, zStart, true);
            return std::nullopt;
        }
        assignStepLength(isect, stepLength);
        step(isect, fieldValue, stepLength, qOverP,fieldCache);
        distance = distanceToLine (isect, surface.center(),lineDirection, stepLength);
    }
 
    // if intersection OK: make short final step assuming constant field
    if (distance > m_shortStepMin)    shortStep(isect, fieldValue, stepLength, qOverP);
    return newIntersection(std::move(isect), surface, qOverP,
                           rStart, zStart);
}

assignStepLength()

void Trk::RungeKuttaIntersector::assignStepLength ( const TrackSurfaceIntersection & isect, double & stepLength ) const

private

Definition at line 382 of file RungeKuttaIntersector.cxx.

{
    const Amg::Vector3D& pos = isect.position();
    const double sinTheta = isect.direction().perp();
 
    // step length assigned according to abs value of current rz position
    // use default (large) value for most regions of InDet and Calo
    // TODO: consider bounded steps acc region => solves in/outwards problem
    const double zCurrent = std::abs(pos.z());
    const double rCurrent = pos.perp();
    double stepMax = m_stepMax3;
    // m_stepFlag       = 0;
 
    // first treat InDet and Solenoid regions
    // TODO: so far validated out to R = 1.0m
    if (rCurrent < m_solenoidR && zCurrent < m_solenoidZ) {
        if (rCurrent < m_inDetR2) {
            // inner barrel, forward tracks and endcap regions generally happy
            // with long steps double number of steps for middle barrel and much
            // of the transition region
            if (zCurrent < m_inDetZ0 && rCurrent < m_inDetR0) {
            // inner barrel
            // stepMax = m_stepMax3;
            } else if (zCurrent > m_inDetZ2 || sinTheta < 0.35) {
            // endcap and far forward
            // stepMax = m_stepMax3;
            }
 
            // double number of steps for most of the remainder
            else if (zCurrent > m_inDetZ1 && sinTheta < 0.60) {
            // barrel:endcap transition
            stepMax = m_stepMax2;
            } else if (rCurrent > m_inDetR0) {
            // middle barrel
            stepMax = m_stepMax2;
            }
 
            // the remaining transition region requires much shorter steps
            else {
            if (rCurrent > m_inDetR1) {
              // middle/outer transition region
              stepMax = m_stepMax1;
            } else {
              // inner transition (anomalous behaviour causing low pt track
              // rotation)
              stepMax = m_stepMax0;
            }
            }
        }
        // take care when moving to region with shorter steps
 
        // field less uniform (approaching coil structure)
        else if (rCurrent < 1000.)  // 1000
        {
            if (zCurrent > 700.) {
            // stepMax = m_stepMax3;
            // exception at higher radii (influence of coil structure)
            if (rCurrent > 850.)
              stepMax = m_stepMax2;
            }
            // // double number of steps for most of the remainder
            else if (zCurrent > 420. && sinTheta < 0.60) {
            // barrel:endcap transition
            stepMax = m_stepMax2;
            } else {
            // decrease step length with increasing radius
            if (rCurrent > 900.) {
              // coil structure
              stepMax = m_stepMax0;
            } else {
              // middle
              stepMax = m_stepMax1;
            }
            }
        } else {
            // field less uniform in vicinity of solenoid coils
            stepMax = m_stepMax1;
            if (zCurrent < 3000.)
            stepMax = m_stepMax0;
        }
    }
 
    // secondly treat MuonSpectrometer regions
    // start with central barrel
    else if (rCurrent > m_muonR0 && zCurrent < m_toroidZ4)  // Z3
    {
        // ++m_count0;
        // optimize - only refresh phi occasionally
        double period = M_PI / 4.;
        double phi = pos.phi() + 0.5 * period;
        if (phi < 0.)
            phi += 2. * M_PI;
        int n = static_cast<int>(phi / period);
        phi -= static_cast<double>(n) * period;
        if (phi > 0.5 * period)
            phi = period - phi;
 
        // sol 1: 12.1 full steps, 0.34 reduc, 0 short
        // sol 2: 12.0 full steps, 0.34 reduc, 0 short
        // sol 3: 11.9 full steps, 0.34 reduc, 0 short  (tidy-up)
        double radius = rCurrent;
        if (stepLength < 0.)
            radius -= m_stepMax2;
        if (zCurrent > m_toroidZ3 && phi < 0.04) {
            // fringe and coil regions
            stepMax = m_stepMax1;  
                                   // m_stepFlag    = 22;
                                   // ++m_count5;
        } else if (radius < 5300.) {
            // fringe and coil regions
            stepMax = m_stepMax1;  
                                   // m_stepFlag    = 21;
                                   // ++m_count1;
        }
        // note: long sector (phi>0.175) has max 1/3 outer steps as finishes at
        // lower r try: phi-extended long sector with stepMax3 for all  r > 5500
        else if (phi > 0.04 ||
                 (radius > 5500. &&
                  (radius < 9000. ||
                   (phi > 0.028 && radius < 9350.))))  // (extended) long sector
        {
            // central 'aircore' between coils
            stepMax = m_stepMax3;  
                                   // m_stepFlag    = 27;
                                   // ++m_count2;
        } else if (radius > 5500. && radius < 9350.) {
            // outer coil fringe region
            stepMax = m_stepMax2;  
                                   // m_stepFlag    = 28;
                                   // ++m_count3;
        } else {
            // outer coil region
            stepMax = m_stepMax1;  
                                   // m_stepFlag    = 29;
                                   // ++m_count4;
        }
    } else if (rCurrent > m_muonR0 || zCurrent > m_muonZ0) {
        if (zCurrent > m_toroidZ4) {
            if (zCurrent > m_toroidZ8) {
            // essentially out of any toroid fields
            stepMax = m_stepMax4;
            } else if (zCurrent > m_toroidZ7) {
            // toroid exit fringe fields
            stepMax = m_stepMax3;
            } else if (rCurrent > m_toroidR0 && rCurrent < m_toroidR1 &&
                       zCurrent > m_toroidZ5 && zCurrent < m_toroidZ6) {
            // endcap toroid central field
            stepMax = m_stepMax3;
            } else {
            // endcap toroid high field gradient and barrel coil regions
            stepMax = m_stepMax1;
            }
        } else if (rCurrent > m_toroidR3) {
            // main region of barrel toroid :
            // generally take long steps but with care near coil end loop
            if (zCurrent < m_toroidZ2) {
            stepMax = m_stepMax4;
            // if (rCurrent > 9000.) stepMax = m_stepMax3;
            // if (rCurrent > 9400.) stepMax = m_stepMax2;
            } else if (zCurrent < m_toroidZ3) {
            stepMax = m_stepMax3;
            } else {
            stepMax = m_stepMax1;
            }
        } else if (rCurrent > m_toroidR2) {
            // toroid field after inner barrel or outer endcap coil
            stepMax = m_stepMax3;
        } else if (zCurrent < m_toroidZ0 || zCurrent > m_toroidZ1 ||
                   rCurrent > m_muonR0) {
            // small steps in toroid high field regions and near iron structures
            stepMax = m_stepMax1;
        } else {
            // endcap toroid entrance fringe fields
            stepMax = m_stepMax3;
        }
    }
 
    // finally assign Calo regions
    else {
        if ((rCurrent < m_solenoidR) ||
            (rCurrent > m_caloR0 && rCurrent < m_caloR1) ||
            rCurrent > m_caloR3 ||
            (zCurrent > m_caloZ1 && zCurrent < m_caloZ2) ||
            zCurrent > m_caloZ3) {
            stepMax = m_stepMax1;
        } else if ((rCurrent > m_caloR2 && rCurrent < m_caloR4) ||
                   zCurrent > m_caloZ0) {
            stepMax = m_stepMax2;
        }
    }
 
    // finally reset stepLength as necessary
    if (std::abs(stepLength) < stepMax)
        return;
    if (stepLength > 0.) {
        stepLength = stepMax;
    } else {
        stepLength = -stepMax;
    }
}

debugFailure()

void Trk::RungeKuttaIntersector::debugFailure ( TrackSurfaceIntersection && isect, const Surface & surface, const double qOverP, const double rStart, const double zStart, const bool trapped ) const

private

Definition at line 585 of file RungeKuttaIntersector.cxx.

{
    // forget low momentum (prone to looping...)
    if (std::abs(qOverP) > m_momentumWarnThreshold)    return;
 
    double pt = 1.E+8;
    const double sinTheta = isect.direction().perp();
    if (qOverP != 0.) pt = sinTheta/(qOverP*Gaudi::Units::GeV);
 
    const double rCurrent = isect.position().perp();
    
    MsgStream log(msgSvc(), name());
    if (rCurrent > rStart)
    {
      log << MSG::DEBUG << std::setiosflags(std::ios::fixed|std::ios::right)
        << " fail to intersect surface when extrapolating outwards from R,Z"
        << std::setw(8) << std::setprecision(1) << rStart << ","
        << std::setw(7) << std::setprecision(0) << zStart << " mm, with pt"
        << std::setw(7) << std::setprecision(2) << pt << " GeV, direction eta"
        << std::setw(5) << std::setprecision(2) << isect.direction().eta();
    }
    else
    {
      log << MSG::DEBUG << std::setiosflags(std::ios::fixed|std::ios::right)
        << " fail to intersect surface when extrapolating inwards from R,Z"
        << std::setw(8) << std::setprecision(1) << rStart << ","
        << std::setw(7) << std::setprecision(0) << zStart << " mm, with pt"
        << std::setw(7) << std::setprecision(2) << pt << " GeV, direction eta"
        << std::setw(5) << std::setprecision(2) << isect.direction().eta();
    }
    // if (trapped) log << MSG::DEBUG << " looping in mag field ";
    log << MSG::DEBUG << endmsg;
    
    if (dynamic_cast<const PlaneSurface*>(&surface))
    {
        double stepLength = 0;
        (void)distanceToPlane (isect, surface.center(),surface.normal(), stepLength);
        log << MSG::DEBUG << std::setiosflags(std::ios::fixed|std::ios::right) << "   PlaneSurface"
        << " at R,Z" << std::setw(8) << std::setprecision(1) << surface.center().perp() << ","
        << std::setw(7) << std::setprecision(0) << surface.center().z()
        << "  at line distance " << std::setw(9) << std::setprecision(1) << stepLength;
        // if (trapped) log << MSG::DEBUG << " looping in mag field ";
        log << MSG::DEBUG << endmsg;
    }
    else if (dynamic_cast<const CylinderSurface*>(&surface))
    {
      double cylinderRadius = (surface.globalReferencePoint() - surface.center()).perp();
      Amg::Vector3D offset   = surface.center() - isect.position();
      double rCurrent       = offset.perp();
        double stepLength = 0;
        double distance = distanceToCylinder (isect, cylinderRadius,rCurrent,offset, stepLength);
        if (distance < m_shortStepMin)
        {
          log << MSG::DEBUG << std::setiosflags(std::ios::fixed|std::ios::right)
            << "  closest approach to CylinderSurface at radius "
            << std::setw(9) << std::setprecision(4) << rCurrent
            << " mm.  Cylinder radius " << std::setw(9) << std::setprecision(4) << cylinderRadius << " mm"
            << endmsg;
        }
        else
        {
          log << MSG::DEBUG << std::setiosflags(std::ios::fixed|std::ios::right) << "  CylinderSurface"
            << "  radius " << std::setw(6) << std::setprecision(1) << cylinderRadius
            << "  rCurrent " << std::setw(6) << std::setprecision(1) << rCurrent
            << "  distance " << std::setw(6) << std::setprecision(1) << stepLength;
          if (trapped) log << MSG::DEBUG << " looping in mag field ";
          log << MSG::DEBUG << endmsg;
        }
    }
    else if (dynamic_cast<const DiscSurface*>(&surface))
    {
        double stepLength = 0;
        (void)distanceToDisc (isect, surface.center().z(), stepLength);
        log << MSG::DEBUG << std::setiosflags(std::ios::fixed|std::ios::right) << "   DiscSurface"
        << " at R,Z" << std::setw(8) << std::setprecision(1) << surface.center().perp() << ","
        << std::setw(7) << std::setprecision(0) << surface.center().z()
        << "  at line distance " << std::setw(9) << std::setprecision(1) << stepLength;
        if (trapped) log << MSG::DEBUG << " looping in mag field ";
        log << MSG::DEBUG << endmsg;
    }
    else if (dynamic_cast<const PerigeeSurface*>(&surface))
    {
      log << MSG::DEBUG << std::setiosflags(std::ios::fixed|std::ios::right) << "   PerigeeSurface  "
        << endmsg;
    }
    else if (dynamic_cast<const StraightLineSurface*>(&surface))
    {
      log << MSG::DEBUG << std::setiosflags(std::ios::fixed|std::ios::right) << "   StraightLineSurface  "
        << endmsg;
    }
    log << MSG::DEBUG << endmsg;
}

distanceToCylinder()

double Trk::RungeKuttaIntersector::distanceToCylinder ( const TrackSurfaceIntersection & isect, const double cylinderRadius, const double offsetRadius, const Amg::Vector3D & offset, double & stepLength ) const

inlineprivate

Definition at line 220 of file RungeKuttaIntersector.h.

                              {
  const Amg::Vector3D& dir = isect.direction();
 
  double sinThsqinv = 1. / dir.perp2();
  stepLength = (offset.x() * dir.x() + offset.y() * dir.y()) * sinThsqinv;
  double deltaRSq = (cylinderRadius - offsetRadius) *
                        (cylinderRadius + offsetRadius) * sinThsqinv +
                    stepLength * stepLength;
  if (deltaRSq > 0.)
    stepLength += sqrt(deltaRSq);
  return std::abs(stepLength);
}

distanceToDisc()

double Trk::RungeKuttaIntersector::distanceToDisc ( const TrackSurfaceIntersection & isect, const double discZ, double & stepLength ) const

inlineprivate

Definition at line 236 of file RungeKuttaIntersector.h.

                              {
  const Amg::Vector3D& pos = isect.position();
  const Amg::Vector3D& dir = isect.direction();
 
  double distance = discZ - pos.z();
  stepLength = distance / dir.z();
  return std::abs(distance);
}

distanceToLine()

double Trk::RungeKuttaIntersector::distanceToLine ( const TrackSurfaceIntersection & isect, const Amg::Vector3D & linePosition, const Amg::Vector3D & lineDirection, double & stepLength ) const

inlineprivate

Definition at line 247 of file RungeKuttaIntersector.h.

                                                                {
  // offset joining track to line is given by
  //   offset = linePosition + a*lineDirection - trackPosition -
  //   b*trackDirection
  //
  // offset is perpendicular to both line and track at solution i.e.
  //   lineDirection.dot(offset) = 0
  //   trackDirection.dot(offset) = 0
  const Amg::Vector3D& pos = isect.position();
  const Amg::Vector3D& dir = isect.direction();
 
  double cosAngle = lineDirection.dot(dir);
  stepLength = (linePosition - pos).dot(dir - lineDirection * cosAngle) /
               (1. - cosAngle * cosAngle);
  return std::abs(stepLength);
}

distanceToPlane()

double Trk::RungeKuttaIntersector::distanceToPlane ( const TrackSurfaceIntersection & isect, const Amg::Vector3D & planePosition, const Amg::Vector3D & planeNormal, double & stepLength ) const

inlineprivate

Definition at line 266 of file RungeKuttaIntersector.h.

                                                              {
  // take the normal component of the offset from track position to plane
  // position this is equal to the normal component of the required distance
  // along the track direction
  const Amg::Vector3D& pos = isect.position();
  const Amg::Vector3D& dir = isect.direction();
 
  double distance = planeNormal.dot(planePosition - pos);
  stepLength = distance / planeNormal.dot(dir);
  return std::abs(distance);
}

field()

Amg::Vector3D Trk::RungeKuttaIntersector::field ( const Amg::Vector3D & point, MagField::AtlasFieldCache & fieldCache ) const

inlineprivate

Definition at line 291 of file RungeKuttaIntersector.h.

                                               {
  Amg::Vector3D fieldValue;
  fieldCache.getField(position.data(), fieldValue.data());
  return fieldValue;
}

finalize()

StatusCode Trk::RungeKuttaIntersector::finalize ( )

overridevirtual

Definition at line 79 of file RungeKuttaIntersector.cxx.

{
    if (m_countExtrapolations)
    {
    msg(MSG::INFO)  << "finalized after " << m_countExtrapolations << " extrapolations,";
    double norm = 1./static_cast<double>(m_countExtrapolations);
    msg(MSG::INFO)   << std::setiosflags(std::ios::fixed)
             << " taking an average" << std::setw(7) << std::setprecision(1)
             << norm*static_cast<double>(m_countStep)
             << " full steps," << std::setw(5) << std::setprecision(2)
             << norm*static_cast<double>(m_countStepReduction)
             << " step reductions and" << std::setw(5) << std::setprecision(2)
             << norm*static_cast<double>(m_countShortStep)
             << " short final steps";
    msg(MSG::INFO)   << endmsg;
    }
 
    return StatusCode::SUCCESS;
}

initialize()

StatusCode Trk::RungeKuttaIntersector::initialize ( )

overridevirtual

Definition at line 56 of file RungeKuttaIntersector.cxx.

                                 {
    // print name and package version
    ATH_MSG_DEBUG( "RungeKuttaIntersector::initialize()" );
 
    // retrieve MagneticFieldTool and StraightLineIntersector
    ATH_CHECK( m_fieldCacheCondObjInputKey.initialize() );
 
    // productionMode gives steplengths tuned for use in production (adequate precision),
    // otherwise take very small steps for maximum precision but with a heavy execution penalty
    if (! m_productionMode){
      m_shortStepMax      = 500.*Gaudi::Units::nanometer;
      m_stepMax0      = 1.8*Gaudi::Units::mm;
      m_stepMax1      = 1.8*Gaudi::Units::mm;
      m_stepMax2      = 1.8*Gaudi::Units::mm;
      m_stepMax3      = 1.8*Gaudi::Units::mm;
      m_stepMax4      = 1.8*Gaudi::Units::mm;
      m_stepsUntilTrapped    = 20000;
    }
    
    return StatusCode::SUCCESS;
}

initializeFieldCache()

void Trk::RungeKuttaIntersector::initializeFieldCache ( MagField::AtlasFieldCache & fieldCache ) const

inlineprivate

Definition at line 280 of file RungeKuttaIntersector.h.

                                               {
  SG::ReadCondHandle<AtlasFieldCacheCondObj> fieldCondObj{
      m_fieldCacheCondObjInputKey};
  if (!fieldCondObj.isValid()) {
    ATH_MSG_FATAL("Failed to get magnetic field conditions data "
                  << m_fieldCacheCondObjInputKey.key());
  }
  fieldCondObj->getInitializedCache(fieldCache);
}

intersectCylinderSurface()

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

overridevirtual

IIntersector interface method for specific Surface type : CylinderSurface.

Definition at line 226 of file RungeKuttaIntersector.cxx.

{
    ++m_countExtrapolations;
    TrackSurfaceIntersection isect = trackIntersection;
    const Amg::Vector3D& pos = isect.position();
    const double rStart = pos.perp();
    const double zStart = pos.z();
    MagField::AtlasFieldCache fieldCache;
    initializeFieldCache(fieldCache);
    Amg::Vector3D fieldValue = field(pos, fieldCache);
 
    // calculate straight line distance along track to intersect with cylinder radius
    double cylinderRadius   = (surface.globalReferencePoint() - surface.center()).perp();
    Amg::Vector3D offset = surface.center() - isect.position();
    double rCurrent     = offset.perp();
    double stepLength = 0;
    double distance = distanceToCylinder (isect, cylinderRadius,rCurrent,offset, stepLength);
    unsigned long long stepsUntilTrapped =  m_stepsUntilTrapped;
    double previousDistance     = 1.1*distance;
    bool trapped = false;
 
    // integration loop (step)
    while (distance > m_shortStepMax)
    {
        if (isTrapped(distance, previousDistance, stepsUntilTrapped)) {
            trapped = true;
            break;
        }
        assignStepLength(isect, stepLength);
        double rPrevious= rCurrent;
        step(isect, fieldValue, stepLength, qOverP,fieldCache);
        offset        = surface.center() - isect.position();
        rCurrent    = offset.perp();
        double deltaR1  = rCurrent - rPrevious;
        double deltaR2   = cylinderRadius - rCurrent;    
        double scale       = 1.;
        if (deltaR1 != 0.) scale = deltaR2 / deltaR1;
        if (scale < 1.)
        {
          stepLength *= scale;
          if (scale < -1.) {
            trapped = true;
            break;
          }
        }
        distance    = std::abs(stepLength);
    }
 
    // if intersection OK: make short final step assuming constant field
    if (! trapped
        && std::abs(cylinderRadius - rCurrent) < m_shortStepMax)
    {
        distance = distanceToCylinder (isect, cylinderRadius,rCurrent,offset, stepLength);
        // protect against divergence (looping)
        if (distance < m_shortStepMax)
        {
          if (distance > m_shortStepMin) shortStep(isect, fieldValue, stepLength, qOverP);
          return newIntersection(std::move(isect), surface, qOverP,
                                 rStart, zStart);
        }
    }
 
    // trapped
    if (msgLvl(MSG::DEBUG)) debugFailure (std::move(isect), surface, qOverP,
                                          rStart, zStart, true);
    return std::nullopt;
}

intersectDiscSurface()

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

overridevirtual

IIntersector interface method for specific Surface type : DiscSurface.

Definition at line 298 of file RungeKuttaIntersector.cxx.

{
    ++m_countExtrapolations;
    TrackSurfaceIntersection isect = trackIntersection;
    const Amg::Vector3D& pos = isect.position();
    const double rStart = pos.perp();
    const double zStart = pos.z();
    MagField::AtlasFieldCache fieldCache;
    initializeFieldCache(fieldCache);
    Amg::Vector3D fieldValue = field(pos, fieldCache);
 
    // straight line distance along track to intersect with disc
    double stepLength = 0;
    double distance = distanceToDisc (isect, surface.center().z(), stepLength);
    unsigned long long stepsUntilTrapped =  m_stepsUntilTrapped;
    double previousDistance     = 1.1*distance;
    
    // integration loop
    while (std::abs(stepLength) > m_shortStepMax)
    {
        if (isTrapped(distance, previousDistance, stepsUntilTrapped)) {
            // trapped
            if (msgLvl(MSG::DEBUG)) debugFailure (std::move(isect), surface, qOverP,
                                                  rStart, zStart, true);
            return std::nullopt;
        }
        assignStepLength(isect, stepLength);
        step(isect, fieldValue, stepLength, qOverP,fieldCache);
        distance = distanceToDisc (isect, surface.center().z(), stepLength);
    }
 
    // if intersection OK: make short final step assuming constant field
    if (std::abs(stepLength) > m_shortStepMin)    shortStep(isect, fieldValue, stepLength, qOverP);
    return newIntersection(std::move(isect), surface, qOverP,
                           rStart, zStart);
}

intersectPlaneSurface()

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

overridevirtual

IIntersector interface method for specific Surface type : PlaneSurface.

Definition at line 339 of file RungeKuttaIntersector.cxx.

{
    ++m_countExtrapolations;
    TrackSurfaceIntersection isect = trackIntersection;
    const Amg::Vector3D& pos = isect.position();
    const double rStart = pos.perp();
    const double zStart = pos.z();
    MagField::AtlasFieldCache fieldCache;
    initializeFieldCache(fieldCache);
    Amg::Vector3D fieldValue = field(pos, fieldCache);
 
    // straight line distance along track to intersect with plane
    double stepLength = 0;
    double distance = distanceToPlane (isect, surface.center(),surface.normal(), stepLength);
    unsigned long long stepsUntilTrapped =  m_stepsUntilTrapped;
    double previousDistance = 1.1*distance;
    
    // integration loop (step)
    while (distance > m_shortStepMax)
    {
        if (isTrapped(distance, previousDistance, stepsUntilTrapped)) {
            // trapped
            if (msgLvl(MSG::DEBUG)) debugFailure (std::move(isect), surface, qOverP,
                                                  rStart, zStart, true);
            return std::nullopt;
        }
        assignStepLength(isect, stepLength);
        step(isect, fieldValue, stepLength, qOverP, fieldCache);
        distance = distanceToPlane (isect, surface.center(),surface.normal(), stepLength);
    }
 
    // if intersection OK: make short final step assuming constant field
    if (distance > m_shortStepMin)    shortStep(isect, fieldValue, stepLength, qOverP);
    return newIntersection(std::move(isect), surface, qOverP,
                           rStart, zStart);
}

intersectSurface()

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

overridevirtual

IIntersector interface method for general Surface type.

Definition at line 101 of file RungeKuttaIntersector.cxx.

{
    // trap low momentum
    if (std::abs(qOverP) > m_momentumThreshold)
    {
      ATH_MSG_DEBUG(" trapped as below momentum threshold" );
      return std::nullopt;
    }
 
    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 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 approachPerigeeSurface(static_cast<const PerigeeSurface&>(surface),
                                    trackIntersection, qOverP);
    }
 
    ATH_MSG_WARNING( " unrecognized Surface" );
    return std::nullopt;
}

isValid()

virtual bool Trk::RungeKuttaIntersector::isValid ( Amg::Vector3D , Amg::Vector3D  ) const

inlineoverridevirtual

IIntersector interface method for validity check over a particular extrapolation range.

Definition at line 77 of file RungeKuttaIntersector.h.

                                                     {
    return true;
  }

newIntersection()

std::optional< TrackSurfaceIntersection > Trk::RungeKuttaIntersector::newIntersection ( TrackSurfaceIntersection && isect, const Surface & surface, const double qOverP, const double rStart, const double zStart ) const

inlineprivate

Definition at line 299 of file RungeKuttaIntersector.h.

                                                                         {
  // ensure intersection is valid (ie. on surface)
  Intersection SLIntersect = surface.straightLineIntersection(
      isect.position(), isect.direction(), false, false);
  if (SLIntersect.valid) {
    isect.position() = SLIntersect.position;
    return std::move(isect);
  }
 
  // invalid: take care to invalidate cache!
  if (msgLvl(MSG::DEBUG)){
    debugFailure(std::move(isect), surface, qOverP, rStart, zStart, false);
  }
 
  return std::nullopt;
}

shortStep()

void Trk::RungeKuttaIntersector::shortStep ( TrackSurfaceIntersection & isect, const Amg::Vector3D & fieldValue, const double stepLength, const double qOverP ) const

private

Definition at line 684 of file RungeKuttaIntersector.cxx.

{
    Amg::Vector3D& pos = isect.position();
    Amg::Vector3D& dir = isect.direction();
    const double cOverP = Gaudi::Units::c_light*qOverP;
 
    // as step except for const field assumption
    double    stepOverP     =  0.5*stepLength*cOverP;
    Amg::Vector3D product0 =  stepOverP*dir.cross(fieldValue);
    // intermediate point (half way through step)
    Amg::Vector3D direction1   =  dir + product0;
    Amg::Vector3D product1 =  stepOverP*direction1.cross(fieldValue);
    Amg::Vector3D direction2   =  dir + product1;
    Amg::Vector3D product2 =  stepOverP*direction2.cross(fieldValue);
    // step end point
    pos              += stepLength*(dir + m_third*(product0+product1+product2));
    Amg::Vector3D direction3   =  dir + 2.*product2;
    Amg::Vector3D product3 =  stepOverP*direction3.cross(fieldValue);
    dir              += m_third*(product0+product3 + 2.*(product1+product2));
    isect.pathlength()      += stepLength;
    ++m_countShortStep;
}

step()

void Trk::RungeKuttaIntersector::step ( TrackSurfaceIntersection & isect, Amg::Vector3D & fieldValue, double & stepLength, const double qOverP, MagField::AtlasFieldCache & fieldCache ) const

private

Definition at line 711 of file RungeKuttaIntersector.cxx.

{
    Amg::Vector3D& pos = isect.position();
    Amg::Vector3D& dir = isect.direction();
    const double cOverP = Gaudi::Units::c_light*qOverP;
 
    double    stepOverP     =  0.5*stepLength*cOverP;
    Amg::Vector3D product0 =  stepOverP*dir.cross(fieldValue);
 
    // intermediate field look-up point (half way through step)
    Amg::Vector3D position1    =  pos + 0.5*stepLength*(dir + 0.5*product0);
    Amg::Vector3D fieldValue1  =  field(position1, fieldCache);
    Amg::Vector3D direction1   =  dir + product0;
    Amg::Vector3D product1 =  stepOverP*direction1.cross(fieldValue1);
    Amg::Vector3D direction2   =  dir + product1;
    Amg::Vector3D product2 =  stepOverP*direction2.cross(fieldValue1);
 
    // field look-up at step end point
    Amg::Vector3D offsetAtEnd  =  stepLength*(dir + m_third*(product0+product1+product2));
    Amg::Vector3D fieldAtEnd   =  field(pos+offsetAtEnd, fieldCache);
 
    // redo with reduced stepLength if non-uniform field derivative detected
    if ((fieldValue1 - 0.5 * (fieldValue + fieldAtEnd)).mag() > 0.00001 &&
        std::abs(stepLength) > m_stepMax0) {
      if (stepLength > 0.) {
          stepLength = m_stepMax0;
      } else {
          stepLength = -m_stepMax0;
      }
      ++m_countStepReduction;
      stepOverP = 0.5 * stepLength * cOverP;
      product0 = stepOverP * dir.cross(fieldValue);
      // intermediate point (half way through step)
      Amg::Vector3D position1p =
          pos + 0.5 * stepLength * (dir + 0.5 * product0);
      Amg::Vector3D fieldValue1p = field(position1p, fieldCache);
      Amg::Vector3D direction1p = dir + product0;
      product1 = stepOverP * direction1p.cross(fieldValue1p);
      Amg::Vector3D direction2p = dir + product1;
      product2 = stepOverP * direction2p.cross(fieldValue1p);
      // step end point
      offsetAtEnd =
          stepLength * (dir + m_third * (product0 + product1 + product2));
      fieldAtEnd = field(pos + offsetAtEnd, fieldCache);
    }
 
    Amg::Vector3D direction3 = dir + 2. * product2;
    Amg::Vector3D product3 = stepOverP * direction3.cross(fieldAtEnd);
    dir += m_third * (product0 + product3 + 2. * (product1 + product2));
    fieldValue = fieldAtEnd;
    pos += offsetAtEnd;
    isect.pathlength() += stepLength;
    ++m_countStep;
}

Member Data Documentation

m_caloR0

const double Trk::RungeKuttaIntersector::m_caloR0 = 1900.*Gaudi::Units::mm

private

Definition at line 134 of file RungeKuttaIntersector.h.

m_caloR1

const double Trk::RungeKuttaIntersector::m_caloR1 = 2500.*Gaudi::Units::mm

private

Definition at line 136 of file RungeKuttaIntersector.h.

m_caloR2

const double Trk::RungeKuttaIntersector::m_caloR2 = 3500.*Gaudi::Units::mm

private

Definition at line 138 of file RungeKuttaIntersector.h.

m_caloR3

const double Trk::RungeKuttaIntersector::m_caloR3 = 3700.*Gaudi::Units::mm

private

Definition at line 140 of file RungeKuttaIntersector.h.

m_caloR4

const double Trk::RungeKuttaIntersector::m_caloR4 = 3800.*Gaudi::Units::mm

private

Definition at line 142 of file RungeKuttaIntersector.h.

m_caloZ0

const double Trk::RungeKuttaIntersector::m_caloZ0 = 2350.*Gaudi::Units::mm

private

Definition at line 144 of file RungeKuttaIntersector.h.

m_caloZ1

const double Trk::RungeKuttaIntersector::m_caloZ1 = 2600.*Gaudi::Units::mm

private

Definition at line 146 of file RungeKuttaIntersector.h.

m_caloZ2

const double Trk::RungeKuttaIntersector::m_caloZ2 = 3600.*Gaudi::Units::mm

private

Definition at line 148 of file RungeKuttaIntersector.h.

m_caloZ3

const double Trk::RungeKuttaIntersector::m_caloZ3 = 6000.*Gaudi::Units::mm

private

Definition at line 150 of file RungeKuttaIntersector.h.

m_countExtrapolations

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

mutableprivate

Definition at line 212 of file RungeKuttaIntersector.h.

m_countShortStep

std::atomic<unsigned long long> Trk::RungeKuttaIntersector::m_countShortStep = 0

mutableprivate

Definition at line 213 of file RungeKuttaIntersector.h.

m_countStep

std::atomic<unsigned long long> Trk::RungeKuttaIntersector::m_countStep = 0

mutableprivate

Definition at line 214 of file RungeKuttaIntersector.h.

m_countStepReduction

std::atomic<unsigned long long> Trk::RungeKuttaIntersector::m_countStepReduction = 0

mutableprivate

Definition at line 215 of file RungeKuttaIntersector.h.

m_fieldCacheCondObjInputKey

SG::ReadCondHandleKey<AtlasFieldCacheCondObj> Trk::RungeKuttaIntersector::m_fieldCacheCondObjInputKey

private

Initial value:

{
      this, "AtlasFieldCacheCondObj", "fieldCondObj",
      "Name of the Magnetic Field conditions object key"}

Definition at line 125 of file RungeKuttaIntersector.h.

                                                                         {
      this, "AtlasFieldCacheCondObj", "fieldCondObj",
      "Name of the Magnetic Field conditions object key"};

m_inDetR0

const double Trk::RungeKuttaIntersector::m_inDetR0 = 400.*Gaudi::Units::mm

private

Definition at line 152 of file RungeKuttaIntersector.h.

m_inDetR1

const double Trk::RungeKuttaIntersector::m_inDetR1 = 350.*Gaudi::Units::mm

private

Definition at line 154 of file RungeKuttaIntersector.h.

m_inDetR2

const double Trk::RungeKuttaIntersector::m_inDetR2 = 800.*Gaudi::Units::mm

private

Definition at line 156 of file RungeKuttaIntersector.h.

m_inDetZ0

const double Trk::RungeKuttaIntersector::m_inDetZ0 = 350.*Gaudi::Units::mm

private

Definition at line 158 of file RungeKuttaIntersector.h.

m_inDetZ1

const double Trk::RungeKuttaIntersector::m_inDetZ1 = 420.*Gaudi::Units::mm

private

Definition at line 160 of file RungeKuttaIntersector.h.

m_inDetZ2

const double Trk::RungeKuttaIntersector::m_inDetZ2 = 700.*Gaudi::Units::mm

private

Definition at line 162 of file RungeKuttaIntersector.h.

m_momentumThreshold

const double Trk::RungeKuttaIntersector::m_momentumThreshold = 1./20.*Gaudi::Units::MeV

private

Definition at line 164 of file RungeKuttaIntersector.h.

m_momentumWarnThreshold

const double Trk::RungeKuttaIntersector::m_momentumWarnThreshold = 1./450.*Gaudi::Units::MeV

private

Definition at line 166 of file RungeKuttaIntersector.h.

m_muonR0

const double Trk::RungeKuttaIntersector::m_muonR0 = 4300.*Gaudi::Units::mm

private

Definition at line 168 of file RungeKuttaIntersector.h.

m_muonZ0

const double Trk::RungeKuttaIntersector::m_muonZ0 = 6600.*Gaudi::Units::mm

private

Definition at line 170 of file RungeKuttaIntersector.h.

m_productionMode

BooleanProperty Trk::RungeKuttaIntersector::m_productionMode {this, "ProductionMode", true}

private

Definition at line 130 of file RungeKuttaIntersector.h.

{this, "ProductionMode", true};

m_shortStepMax

double Trk::RungeKuttaIntersector::m_shortStepMax = 3.0*Gaudi::Units::mm

private

Definition at line 171 of file RungeKuttaIntersector.h.

m_shortStepMin

const double Trk::RungeKuttaIntersector::m_shortStepMin = 10.*Gaudi::Units::nanometer

private

Definition at line 172 of file RungeKuttaIntersector.h.

m_solenoidR

const double Trk::RungeKuttaIntersector::m_solenoidR = 1300.*Gaudi::Units::mm

private

Definition at line 174 of file RungeKuttaIntersector.h.

m_solenoidZ

const double Trk::RungeKuttaIntersector::m_solenoidZ = 3500.*Gaudi::Units::mm

private

Definition at line 176 of file RungeKuttaIntersector.h.

m_stepMax0

double Trk::RungeKuttaIntersector::m_stepMax0 = 8.0*Gaudi::Units::mm

private

Definition at line 177 of file RungeKuttaIntersector.h.

m_stepMax1

double Trk::RungeKuttaIntersector::m_stepMax1 = 40.0*Gaudi::Units::mm

private

Definition at line 178 of file RungeKuttaIntersector.h.

m_stepMax2

double Trk::RungeKuttaIntersector::m_stepMax2 = 80.0*Gaudi::Units::mm

private

Definition at line 179 of file RungeKuttaIntersector.h.

m_stepMax3

double Trk::RungeKuttaIntersector::m_stepMax3 = 160.0*Gaudi::Units::mm

private

Definition at line 180 of file RungeKuttaIntersector.h.

m_stepMax4

double Trk::RungeKuttaIntersector::m_stepMax4 = 320.0*Gaudi::Units::mm

private

Definition at line 181 of file RungeKuttaIntersector.h.

m_stepsUntilTrapped

int Trk::RungeKuttaIntersector::m_stepsUntilTrapped = 2000

private

Definition at line 182 of file RungeKuttaIntersector.h.

m_third

const double Trk::RungeKuttaIntersector::m_third = 1./3.

private

Definition at line 183 of file RungeKuttaIntersector.h.

m_toroidR0

const double Trk::RungeKuttaIntersector::m_toroidR0 = 1850.0*Gaudi::Units::mm

private

Definition at line 185 of file RungeKuttaIntersector.h.

m_toroidR1

const double Trk::RungeKuttaIntersector::m_toroidR1 = 3500.0*Gaudi::Units::mm

private

Definition at line 187 of file RungeKuttaIntersector.h.

m_toroidR2

const double Trk::RungeKuttaIntersector::m_toroidR2 = 6000.0*Gaudi::Units::mm

private

Definition at line 189 of file RungeKuttaIntersector.h.

m_toroidR3

const double Trk::RungeKuttaIntersector::m_toroidR3 = 6500.0*Gaudi::Units::mm

private

Definition at line 191 of file RungeKuttaIntersector.h.

m_toroidZ0

const double Trk::RungeKuttaIntersector::m_toroidZ0 = 7000.0*Gaudi::Units::mm

private

Definition at line 193 of file RungeKuttaIntersector.h.

m_toroidZ1

const double Trk::RungeKuttaIntersector::m_toroidZ1 = 8000.0*Gaudi::Units::mm

private

Definition at line 195 of file RungeKuttaIntersector.h.

m_toroidZ2

const double Trk::RungeKuttaIntersector::m_toroidZ2 = 8700.0*Gaudi::Units::mm

private

Definition at line 197 of file RungeKuttaIntersector.h.

m_toroidZ3

const double Trk::RungeKuttaIntersector::m_toroidZ3 = 9100.0*Gaudi::Units::mm

private

Definition at line 199 of file RungeKuttaIntersector.h.

m_toroidZ4

const double Trk::RungeKuttaIntersector::m_toroidZ4 = 9500.0*Gaudi::Units::mm

private

Definition at line 201 of file RungeKuttaIntersector.h.

m_toroidZ5

const double Trk::RungeKuttaIntersector::m_toroidZ5 = 9800.0*Gaudi::Units::mm

private

Definition at line 203 of file RungeKuttaIntersector.h.

m_toroidZ6

const double Trk::RungeKuttaIntersector::m_toroidZ6 = 11400.0*Gaudi::Units::mm

private

Definition at line 205 of file RungeKuttaIntersector.h.

m_toroidZ7

const double Trk::RungeKuttaIntersector::m_toroidZ7 = 12900.0*Gaudi::Units::mm

private

Definition at line 207 of file RungeKuttaIntersector.h.

m_toroidZ8

const double Trk::RungeKuttaIntersector::m_toroidZ8 = 14000.0*Gaudi::Units::mm

private

Definition at line 209 of file RungeKuttaIntersector.h.

---

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

• RungeKuttaIntersector.h
• RungeKuttaIntersector.cxx