#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. More...

virtual std::optional< TrackSurfaceIntersection >	approachPerigeeSurface (const PerigeeSurface &surface, const TrackSurfaceIntersection &trackIntersection, const double qOverP) const override
	IIntersector interface method for specific Surface type : PerigeeSurface. More...

virtual std::optional< TrackSurfaceIntersection >	approachStraightLineSurface (const StraightLineSurface &surface, const TrackSurfaceIntersection &trackIntersection, const double qOverP) const override
	IIntersector interface method for specific Surface type : StraightLineSurface. More...

virtual std::optional< TrackSurfaceIntersection >	intersectCylinderSurface (const CylinderSurface &surface, const TrackSurfaceIntersection &trackIntersection, const double qOverP) const override
	IIntersector interface method for specific Surface type : CylinderSurface. More...

virtual std::optional< TrackSurfaceIntersection >	intersectDiscSurface (const DiscSurface &surface, const TrackSurfaceIntersection &trackIntersection, const double qOverP) const override
	IIntersector interface method for specific Surface type : DiscSurface. More...

virtual std::optional< TrackSurfaceIntersection >	intersectPlaneSurface (const PlaneSurface &surface, const TrackSurfaceIntersection &trackIntersection, const double qOverP) const override
	IIntersector interface method for specific Surface type : PlaneSurface. More...

virtual bool	isValid (Amg::Vector3D, Amg::Vector3D) const override
	IIntersector interface method for validity check over a particular extrapolation range. More...

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.

53 : 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.

◆ 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.

◆ 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:

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ RungeKuttaIntersector()

◆ ~RungeKuttaIntersector()

Member Function Documentation

◆ approachPerigeeSurface()

◆ approachStraightLineSurface()

◆ assignStepLength()

◆ debugFailure()

◆ distanceToCylinder()

◆ distanceToDisc()

◆ distanceToLine()

◆ distanceToPlane()

◆ field()

◆ finalize()

◆ initialize()

◆ initializeFieldCache()

◆ intersectCylinderSurface()

◆ intersectDiscSurface()

◆ intersectPlaneSurface()

◆ intersectSurface()

◆ isValid()

◆ newIntersection()

◆ shortStep()

◆ step()

Member Data Documentation

◆ m_caloR0

◆ m_caloR1

◆ m_caloR2

◆ m_caloR3

◆ m_caloR4

◆ m_caloZ0

◆ m_caloZ1

◆ m_caloZ2

◆ m_caloZ3

◆ m_countExtrapolations

◆ m_countShortStep

◆ m_countStep

◆ m_countStepReduction

◆ m_fieldCacheCondObjInputKey

◆ m_inDetR0

◆ m_inDetR1

◆ m_inDetR2

◆ m_inDetZ0

◆ m_inDetZ1

◆ m_inDetZ2

◆ m_momentumThreshold

◆ m_momentumWarnThreshold

◆ m_muonR0

◆ m_muonZ0

◆ m_productionMode

◆ m_shortStepMax

◆ m_shortStepMin

◆ m_solenoidR

◆ m_solenoidZ

◆ m_stepMax0

◆ m_stepMax1

◆ m_stepMax2

◆ m_stepMax3

◆ m_stepMax4

◆ m_stepsUntilTrapped

◆ m_third

◆ m_toroidR0

◆ m_toroidR1

◆ m_toroidR2

◆ m_toroidR3

◆ m_toroidZ0

◆ m_toroidZ1

◆ m_toroidZ2

◆ m_toroidZ3

◆ m_toroidZ4

◆ m_toroidZ5

◆ m_toroidZ6

◆ m_toroidZ7

◆ m_toroidZ8