Trk::SolenoidParametrization Class Reference

#include <SolenoidParametrization.h>

Collaboration diagram for Trk::SolenoidParametrization:

Classes
class	BinParameters
class	Parameters

Public Member Functions
	SolenoidParametrization (const AtlasFieldCacheCondObj &field_cond_obj)
	~SolenoidParametrization ()=default
double	centralField () const
double	fieldComponent (double z, const Parameters &parms) const
double	fieldComponent (double r, double z, double cotTheta, MagField::AtlasFieldCache &fieldCache) const
void	fieldIntegrals (double &firstIntegral, double &secondIntegral, double zBegin, double zEnd, Parameters &parms) const
double	maximumR () const
double	maximumZ () const
void	printFieldIntegrals (MsgStream &m) const
void	printParametersForEtaLine (double eta, double z_origin, MsgStream &msg) const
void	printResidualForEtaLine (double eta, double zOrigin, MsgStream &msg) const
bool	validOrigin (const Amg::Vector3D &origin) const
bool	currentMatches (double current) const

Private Member Functions
void	integrate (double &firstIntegral, double &secondIntegral, double zBegin, double zEnd, const Parameters &parms) const
double	interpolate (int key1, int key2, int key3, int key4, const Parameters &parms) const
void	parametrizeSolenoid ()
void	setTerms (int, Parameters &parms) const
	SolenoidParametrization (const SolenoidParametrization &)=delete
SolenoidParametrization &	operator= (const SolenoidParametrization &)=delete

Static Private Member Functions
static int	fieldKey (BinParameters &parms)

Private Attributes
const AtlasFieldCacheCondObj *	m_fieldCondObj
double	m_currentMin {}
double	m_currentMax {}
double	m_centralField
double	m_parameters [14688]

Static Private Attributes
static const double	s_binInvSizeTheta = 1./0.1
static const double	s_binInvSizeZ = 1./20.*Gaudi::Units::mm
static const double	s_binZeroTheta = 0.
static const double	s_binZeroZ = -160.*Gaudi::Units::mm
static const double	s_lightSpeed = -1.*299792458*Gaudi::Units::m/Gaudi::Units::s
static const int	s_maxBinTheta = 72
static const int	s_maxBinZ = 17
static const double	s_maximumImpactAtOrigin = 30.*Gaudi::Units::mm
static const double	s_maximumZatOrigin = 250.*Gaudi::Units::mm
static const int	s_numberParameters = 6
static const double	s_rInner = 570.*Gaudi::Units::mm
static const double	s_rOuter = 1050.*Gaudi::Units::mm
static const double	s_zInner = 2150.0*Gaudi::Units::mm
static const double	s_zOuter = 2800.0*Gaudi::Units::mm

Friends
class	Parameters

Detailed Description

Definition at line 30 of file SolenoidParametrization.h.

Constructor & Destructor Documentation

SolenoidParametrization() [1/2]

Trk::SolenoidParametrization::SolenoidParametrization

(

const AtlasFieldCacheCondObj &

field_cond_obj

)

Definition at line 92 of file SolenoidParametrization.cxx.

  : m_fieldCondObj      (&field_cond_obj),
    m_parameters            ()
{
 
    MagField::AtlasFieldCache fieldCache;
    m_fieldCondObj->getInitializedCache (fieldCache);
    m_centralField      = fieldComponent(0.,0.,0., fieldCache);
    // now parametrise field - if requested
    {
      parametrizeSolenoid();
    }
}

~SolenoidParametrization()

Trk::SolenoidParametrization::~SolenoidParametrization ( )

default

SolenoidParametrization() [2/2]

Trk::SolenoidParametrization::SolenoidParametrization ( const SolenoidParametrization & )

privatedelete

Member Function Documentation

centralField()

double Trk::SolenoidParametrization::centralField ( void ) const

inline

Definition at line 221 of file SolenoidParametrization.h.

{ return m_centralField; }

currentMatches()

bool Trk::SolenoidParametrization::currentMatches

(

double

current

)

const

fieldComponent() [1/2]

double Trk::SolenoidParametrization::fieldComponent ( double r, double z, double cotTheta, MagField::AtlasFieldCache & fieldCache ) const

inline

Definition at line 236 of file SolenoidParametrization.h.

{
    Amg::Vector3D field;
    Amg::Vector3D position(r, 0., z);
    fieldCache.getField(position.data(),field.data());
    return  s_lightSpeed*(field.z() - field.perp()*cotTheta);
}

fieldComponent() [2/2]

double Trk::SolenoidParametrization::fieldComponent ( double z, const Parameters & parms ) const

inline

Definition at line 225 of file SolenoidParametrization.h.

{
    double  z_local     = parms.m_signTheta*z - parms.m_zAtAxis;
    double  z_squared   = z_local*z_local;
    double      value       = parms.m_fieldAtOrigin +
                  parms.m_quadraticTerm*z_squared +
                  parms.m_cubicTerm*z_squared*z_local;
    return value;
}

fieldIntegrals()

void Trk::SolenoidParametrization::fieldIntegrals ( double & firstIntegral, double & secondIntegral, double zBegin, double zEnd, Parameters & parms ) const

inline

Definition at line 245 of file SolenoidParametrization.h.

{
    zBegin  = parms.m_signTheta*zBegin;
    zEnd    = parms.m_signTheta*zEnd;
    if (zEnd < s_zInner || zBegin > s_zInner)
    {
    integrate(firstIntegral,secondIntegral,zBegin-parms.m_zAtAxis,zEnd-parms.m_zAtAxis, parms);
    }
    else
    {
    integrate(firstIntegral,secondIntegral,zBegin-parms.m_zAtAxis,s_zInner, parms);
    int key = fieldKey(parms) + s_numberParameters/2;
    setTerms(key, parms);
    integrate(firstIntegral,secondIntegral,s_zInner,zEnd-parms.m_zAtAxis,parms);
    }
}

fieldKey()

int Trk::SolenoidParametrization::fieldKey ( BinParameters & parms )

inlinestaticprivate

Definition at line 131 of file SolenoidParametrization.h.

{
    double  z   = parms.m_zAtAxis - s_binZeroZ;
    int     zBin    = static_cast<int>(s_binInvSizeZ*z);
    parms.m_interpolateZ = z*s_binInvSizeZ - double(zBin);
    if (zBin < 0)
    {
    parms.m_interpolateZ    = 0.;
    zBin        = 0;
    }
    else if (zBin > s_maxBinZ - 2)
    {
    parms.m_interpolateZ    = 0.;
    zBin        = s_maxBinZ - 1;
    }
    parms.m_complementZ = 1. - parms.m_interpolateZ;
    
    int thetaBin    = static_cast<int>(s_binInvSizeTheta*parms.m_cotTheta);
    parms.m_interpolateTheta = parms.m_cotTheta*s_binInvSizeTheta - double(thetaBin);
    if (thetaBin > s_maxBinTheta - 3)
    {
    parms.m_interpolateTheta    = 0.;
    thetaBin        = s_maxBinTheta - 2;
    }
    parms.m_complementTheta = 1. - parms.m_interpolateTheta;
    return 2*s_numberParameters*(s_maxBinTheta*zBin + thetaBin);
}

integrate()

void Trk::SolenoidParametrization::integrate ( double & firstIntegral, double & secondIntegral, double zBegin, double zEnd, const Parameters & parms ) const

inlineprivate

Definition at line 160 of file SolenoidParametrization.h.

{ 
    double  zDiff   =  zEnd - zBegin;
    double  zBeg2   =  zBegin*zBegin;
    double  zBeg3   =  zBeg2*zBegin;
    double  zEnd2   =  zEnd*zEnd;
    double  zEnd3   =  zEnd2*zEnd;
    double  zDiff4  =  0.25*(zEnd2 + zBeg2)*(zEnd2 - zBeg2);
    
    firstIntegral   += parms.m_fieldAtOrigin*zDiff +
               parms.m_quadraticTerm*(zEnd3 - zBeg3)*0.333333333333 +
               parms.m_cubicTerm*zDiff4;
    double   zDiffInv   =  1./zDiff;
    secondIntegral  += parms.m_fieldAtOrigin*zDiff +
               parms.m_quadraticTerm*(zDiffInv*zDiff4 - zBeg3)*0.666666666667 +
               parms.m_cubicTerm*(0.1*zDiffInv*(zEnd2*zEnd3 - zBeg2*zBeg3) - 0.5*zBeg2*zBeg2);
}

interpolate()

double Trk::SolenoidParametrization::interpolate ( int key1, int key2, int key3, int key4, const Parameters & parms ) const

inlineprivate

Definition at line 183 of file SolenoidParametrization.h.

{
    return ((m_parameters[key1]*parms.m_complementZ +
         m_parameters[key2]*parms.m_interpolateZ)*parms.m_complementTheta +
        (m_parameters[key3]*parms.m_complementZ +
         m_parameters[key4]*parms.m_interpolateZ)*parms.m_interpolateTheta);
}

maximumR()

double Trk::SolenoidParametrization::maximumR ( void ) const

inline

Definition at line 267 of file SolenoidParametrization.h.

{ return s_rInner; }

maximumZ()

double Trk::SolenoidParametrization::maximumZ ( void ) const

inline

Definition at line 271 of file SolenoidParametrization.h.

{ return s_zInner; }

operator=()

SolenoidParametrization & Trk::SolenoidParametrization::operator= ( const SolenoidParametrization & )

privatedelete

parametrizeSolenoid()

void Trk::SolenoidParametrization::parametrizeSolenoid ( void )

private

Definition at line 109 of file SolenoidParametrization.cxx.

                                                {
  // set parametrisation granularity (up to cotTheta = 7.)
  // get value of cubic term for approx: Bz = Bcentral*(1 - term * z^3)
  // 'fit' to average over cotTheta lines
  double    smallOffset = 0.0000000000001; // avoid FPE
  double zAtAxis    = s_binZeroZ;   // + smallOffset ? 
  MagField::AtlasFieldCache fieldCache;
  m_fieldCondObj->getInitializedCache (fieldCache);
  
  constexpr int n = 200;
  Amg::VectorX difference(n);  // it is filled below in the loop over n
  Amg::MatrixX derivative(n,s_numberParameters); //set zero below
  for (int binZ = 0; binZ < s_maxBinZ; ++binZ){ 
    double cotTheta = smallOffset;
    for (int binTheta = 0; binTheta < s_maxBinTheta - 1; ++binTheta) {
      double    r       = 0.;
      double    z       = zAtAxis;
      double    dr;
      if (cotTheta < s_zOuter/s_rOuter){
        dr = s_rOuter/double(n);
      } else {
        dr = s_zOuter/(cotTheta*double(n));
      }
      derivative.setZero();
      for (int k = 0; k < n; ++k){
        r           += dr;
        z           += dr*cotTheta;
        double  w       = (n - k)*(n - k);
        double  zLocal      = z - zAtAxis;
        if (r > s_rInner || z > s_zInner){
            derivative(k,3) = w;
            derivative(k,4) = w*zLocal*zLocal;
            derivative(k,5) = w*zLocal*zLocal*zLocal;
        } else {
            derivative(k,0) = w;
            derivative(k,1) = w*zLocal*zLocal;
            derivative(k,2) = w*zLocal*zLocal*zLocal;
        }
        difference(k)       = w*(fieldComponent(r,z,cotTheta, fieldCache) - m_centralField);
      }
      // solve for parametrization coefficients
      Amg::VectorX solution = derivative.colPivHouseholderQr().solve(difference);
      BinParameters parms (zAtAxis, cotTheta);
      int           key         = fieldKey(parms);
      assert (m_parameters[key] == 0.);
      m_parameters[key++]       = m_centralField + solution(0);
      m_parameters[key++]       = solution(1);
      m_parameters[key++]       = solution(2);
      m_parameters[key++]       = m_centralField + solution(3);
      m_parameters[key++]       = solution(4);
      m_parameters[key++]       = solution(5);
      // duplicate last z-bin for contiguous neighbour lookup
      if (binZ == s_maxBinZ - 1){
        assert (m_parameters[key] == 0.);
        m_parameters[key++]     = m_centralField + solution(0);
        m_parameters[key++]     = solution(1);
        m_parameters[key++]     = solution(2);
        m_parameters[key++]     = m_centralField + solution(3);
        m_parameters[key++]     = solution(4);
        m_parameters[key++]     = solution(5);
        key -= s_numberParameters;
      }
 
      // duplicate next to previous z-bin for contiguous neighbour lookup
      if (binZ > 0){
        key -= 2*s_numberParameters*s_maxBinTheta;
        assert (m_parameters[key] == 0.);
        m_parameters[key++]     = m_centralField + solution(0);
        m_parameters[key++]     = solution(1);
        m_parameters[key++]     = solution(2);
        m_parameters[key++]     = m_centralField + solution(3);
        m_parameters[key++]     = solution(4);
        m_parameters[key++]     = solution(5);
      }
      cotTheta  += 1./s_binInvSizeTheta;
    }  // Loop over binTheta
    zAtAxis     += 1./s_binInvSizeZ;
  }
  //
  // duplicate end theta-bins for contiguous neighbour lookup
  zAtAxis   = s_binZeroZ;   // + smallOffset ?? 
  for (int binZ = 0; binZ < s_maxBinZ; ++binZ){ 
    double cotTheta = double(s_maxBinTheta)/s_binInvSizeTheta;
    BinParameters parms (zAtAxis, cotTheta);
    int key     = fieldKey(parms);
    for (int k = 0; k < 2*s_numberParameters; ++k){
      assert (m_parameters[key+2*s_numberParameters] == 0.);
      m_parameters[key+2*s_numberParameters] = m_parameters[key];
      ++key;
    }
    zAtAxis     += 1./s_binInvSizeZ;
  }
}

printFieldIntegrals()

void Trk::SolenoidParametrization::printFieldIntegrals

(

MsgStream &

m

)

const

Definition at line 206 of file SolenoidParametrization.cxx.

{
    // integrate along lines of const eta from origin to r = 1m or |z| = 2.65m
    // direction normalised st transverse component = 1 (equiv to a fixed pt)
    msg << __func__<<"\n"
        << std::setiosflags(std::ios::fixed)
          << "   eta    rEnd   mean(Bz) max(dBz/dR)     mean(Bt) max(dBt/dR)      "
          << "min(Bt) max(Bt)  reverse-bend(z)  integrals: Bt.dR   Bl.dR"
          << "     asymm: x        y        z"
          << "      " << std::endl
          << "             m          T         T/m            T         T/m      "
          << "      T       T                m               T.m     T.m"
          << "            T        T        T"
          << "/n";
    
    double maxR     = 1000.*Gaudi::Units::mm;
    double maxZ     = 2650.*Gaudi::Units::mm;
    int numSteps    = 1000;
 
    MagField::AtlasFieldCache fieldCache;
    m_fieldCondObj->getInitializedCache (fieldCache);
 
    // step through eta-range
    double eta  = 0.;
    for (int i = 0; i != 31; ++i)
    {
    double phi      =  0.;
    double cotTheta     =  std::sinh(eta);
    Amg::Vector3D direction(std::cos(phi),std::sin(phi),cotTheta);
    double rEnd     =  maxR;
    if (std::abs(cotTheta) > maxZ/maxR) rEnd =  maxZ/direction.z();
    double step     =  rEnd/static_cast<double>(numSteps);  // radial step in mm
    Amg::Vector3D position(0.,0.,0.);
    double meanBL       = 0.;
    double meanBT       = 0.;
    double meanBZ       = 0.;
    double maxBT        = 0.;
    double minBT        = 9999.;
    double maxGradBT    = 0.;
    double maxGradBZ    = 0.;
    double prevBT       = 0.;
    double prevBZ       = 0.;
    double reverseZ     = 0.;
 
    // look up field along eta-line
    for (int j = 0; j != numSteps; ++j)
    {
        position            += 0.5*step*direction;
        Amg::Vector3D field;
        fieldCache.getField(position.data(),field.data());
        Amg::Vector3D vCrossB   =  direction.cross(field);
        position            += 0.5*step*direction;
        double BZ           =  field.z();
        double BT           =  vCrossB.x()*direction.y() - vCrossB.y()*direction.x();
        double BL           =  std::sqrt(vCrossB.mag2() - BT*BT);
        meanBL          += BL;
        meanBT          += BT;
        meanBZ          += BZ;
        if (BT > maxBT) maxBT = BT;
        if (BT < minBT) minBT = BT;
        if (j > 0)
        {
        if (BT*prevBT < 0.) reverseZ = position.z() - step*direction.z();
        double grad = std::abs(BT - prevBT);
        if (grad > maxGradBT) maxGradBT = grad;
        grad = std::abs(BZ - prevBZ);
        if (grad > maxGradBZ) maxGradBZ = grad;
        }
        prevBT      =  BT;
        prevBZ      =  BZ;
    }
 
    // normalize
    maxGradBT       *= static_cast<double>(numSteps)/step;
    maxGradBZ       *= static_cast<double>(numSteps)/step;
    meanBL          /= static_cast<double>(numSteps);
    meanBT          /= static_cast<double>(numSteps);
    meanBZ          /= static_cast<double>(numSteps);
    double integralBL   = meanBL*rEnd; 
    double integralBT   = meanBT*rEnd;
    
    msg << std::setw(6) << std::setprecision(2) << eta
          << std::setw(8)   << std::setprecision(3) << rEnd /Gaudi::Units::meter
          << std::setw(11)  << std::setprecision(4) << meanBZ /Gaudi::Units::tesla
          << std::setw(12)  << std::setprecision(3) << maxGradBZ /Gaudi::Units::tesla
          << std::setw(13)  << std::setprecision(4) << meanBT /Gaudi::Units::tesla
          << std::setw(12)  << std::setprecision(3) << maxGradBT /Gaudi::Units::tesla
          << std::setw(13)  << std::setprecision(4) << minBT /Gaudi::Units::tesla
          << std::setw(8)   << std::setprecision(4) << maxBT /Gaudi::Units::tesla;
    if (reverseZ > 0.)
    {
        msg << std::setw(17)    << std::setprecision(2) << reverseZ /Gaudi::Units::meter
              << std::setw(18)  << std::setprecision(4) << integralBT /(Gaudi::Units::tesla*Gaudi::Units::meter)
              << std::setw(8)   << std::setprecision(4) << integralBL /(Gaudi::Units::tesla*Gaudi::Units::meter)
              << "    ";
    }
    else
    {
        msg << std::setw(35)    << std::setprecision(4) << integralBT /(Gaudi::Units::tesla*Gaudi::Units::meter)
              << std::setw(8)   << std::setprecision(4) << integralBL /(Gaudi::Units::tesla*Gaudi::Units::meter)
              << "    ";
    }
 
    // check symmetry (reflect in each axis)
    for (int k = 0; k != 3; ++k)
    {
        if (k == 0) direction = Amg::Vector3D(-std::cos(phi),std::sin(phi),cotTheta);
        if (k == 1) direction = Amg::Vector3D(std::cos(phi),-std::sin(phi),cotTheta);
        if (k == 2) direction = Amg::Vector3D(std::cos(phi),std::sin(phi),-cotTheta);
        position        = Amg::Vector3D(0.,0.,0.);
        double asymm    = 0.;
        // look up field along eta-line
        for (int j = 0; j != numSteps; ++j)
        {
        position        += 0.5*step*direction;
        Amg::Vector3D field;
        fieldCache.getField(position.data(),field.data());
        Amg::Vector3D vCrossB   =  direction.cross(field);
        position        += 0.5*step*direction;
        double BT       =  vCrossB.x()*direction.y() - vCrossB.y()*direction.x();
        asymm           += BT;
        }
        asymm   = asymm/static_cast<double>(numSteps) - meanBT;
        msg << std::setw(9) << std::setprecision(4) << asymm /Gaudi::Units::tesla;
    }
    msg<<"/n";
    eta += 0.1;
    }
}

printParametersForEtaLine()

void Trk::SolenoidParametrization::printParametersForEtaLine	(	double	eta,
		double	z_origin,
		MsgStream &	msg ) const

Definition at line 337 of file SolenoidParametrization.cxx.

{
    double cotTheta = 1./std::tan(2.*std::atan(1./std::exp(eta)));
    BinParameters parms (z_origin, cotTheta);
    int     key     = fieldKey(parms);
    double  z_max;
    if (cotTheta < s_zInner/s_rInner)
    {
    z_max = s_rInner*cotTheta;
    }
    else
    {
    z_max = s_zInner;
    }
    msg <<__func__<<"\n"
        << std::setiosflags(std::ios::fixed)
          << "SolenoidParametrization:  line with eta "  << std::setw(6) << std::setprecision(2) << eta
          << "   from (r,z)  0.0,"         << std::setw(6) << std::setprecision(1) << z_origin
          << "   inner terms:  z0 "<< std::setw(6) << std::setprecision(2)
          << m_parameters[key]/m_centralField
          << "   z^2 "<< std::setw(6) << std::setprecision(3)
          << m_parameters[key+1]*z_max*z_max/m_centralField
          << "   z^3 "  << std::setw(6) << std::setprecision(3)
          << m_parameters[key+2]*z_max*z_max*z_max/m_centralField
          << "    outer terms:  z0 "<< std::setw(6) << std::setprecision(3)
          << m_parameters[key+3]/m_centralField
          << "   z^2 "<< std::setw(6) << std::setprecision(3)
          << m_parameters[key+4]*z_max*z_max/m_centralField
          << "   z^3 "  << std::setw(6) << std::setprecision(3)
          << m_parameters[key+5]*z_max*z_max*z_max/m_centralField
          << std::resetiosflags(std::ios::fixed) << "\n";
}

printResidualForEtaLine()

void Trk::SolenoidParametrization::printResidualForEtaLine	(	double	eta,
		double	zOrigin,
		MsgStream &	msg ) const

Definition at line 371 of file SolenoidParametrization.cxx.

{
    double  cotTheta    = 1./std::tan(2.*std::atan(1./std::exp(std::abs(eta))));
    double  z       = zOrigin;
    double  r       = 0.;
    int     n           = 200;
    double  dr;
    if (cotTheta < s_zOuter/s_rOuter)
    {
    dr = s_rOuter/double(n);
    }
    else
    {
    dr = s_zOuter/(cotTheta*double(n));
    }
    double  chiSquareIn = 0.;
    double  chiSquareOut    = 0.;
    double  nIn     = 0.;
    double  nOut        = 0.;
    double  worstBCalc      = 0.;
    double  worstBTrue      = 0.;
    double  worstDiff       = -1.;
    double  worstR      = 0.;
    double  worstZ      = 0.;
    MagField::AtlasFieldCache fieldCache;
    m_fieldCondObj->getInitializedCache (fieldCache);
    for (int k = 0; k < n; ++k)
    {
       double   b   = fieldComponent(r,z,cotTheta,fieldCache);
        Parameters parms (*this, r, z, cotTheta);
    double  diff    = (fieldComponent(z, parms) - b)/s_lightSpeed;
    
    if (r > s_rInner || z > s_zInner)
    {
        chiSquareOut+= diff*diff;
        nOut    += 1.;
    }
    else
    {
        chiSquareIn += diff*diff;
        nIn     += 1.;
    }
    
    if (std::abs(diff) > worstDiff)
    {
        worstDiff   = std::abs(diff);
        worstBCalc  = fieldComponent(z, parms);
        worstBTrue  = b;
        worstR  = r;
        worstZ  = z;
    }
    r   += dr;
    z   += dr*cotTheta;
    } 
    if ((nIn == 0) or (nOut == 0)){
      msg <<__func__<<"nIn = "<<nIn<<"; nOut = "<<nOut<<".\n";
      return;
    }
    
    msg <<__func__<<"\n"
        << std::setiosflags(std::ios::fixed)
          << "SolenoidParametrization:  line with eta "     << std::setw(6) << std::setprecision(2) << eta
          << "   from (r,z)  0.0, "     << std::setw(6) << std::setprecision(1) << zOrigin
          << "   rms diff inner/outer " << std::setw(6) << std::setprecision(3)
          << std::sqrt(chiSquareIn/nIn) /Gaudi::Units::tesla << " " << std::setw(6) << std::setprecision(3)
          << std::sqrt(chiSquareOut/nOut) /Gaudi::Units::tesla << std::endl
          << "            worst residual at:  (r,z) "
          << std::setw(6) << std::setprecision(1) << worstR
          << ", " << std::setw(6) << std::setprecision(1) << worstZ
          << "   with B true/calc " << std::setw(6) << std::setprecision(3)
          << worstBTrue/s_lightSpeed /Gaudi::Units::tesla
          << "  " << std::setw(6) << std::setprecision(3) << worstBCalc/s_lightSpeed /Gaudi::Units::tesla
          << std::resetiosflags(std::ios::fixed) << "\n";
}

setTerms()

void Trk::SolenoidParametrization::setTerms ( int key1, Parameters & parms ) const

inlineprivate

Definition at line 196 of file SolenoidParametrization.h.

{
    int     key2    = key1 + s_numberParameters;
    int     key3    = key2 + s_numberParameters;
    int     key4    = key3 + s_numberParameters;
 
    assert (key1 >= 0);
    assert (key4 < 14688);
    assert (m_parameters[key1] != 0.);
    assert (m_parameters[key3] != 0.);
    if (parms.m_cotTheta < 7.)
    {
    assert (m_parameters[key2] != 0.);
    assert (m_parameters[key4] != 0.);
    }
    
    
    parms.m_fieldAtOrigin   = interpolate(key1++,key2++,key3++,key4++,parms);
    parms.m_quadraticTerm   = interpolate(key1++,key2++,key3++,key4++,parms);
    parms.m_cubicTerm           = interpolate(key1,key2,key3,key4,parms);
}

validOrigin()

bool Trk::SolenoidParametrization::validOrigin ( const Amg::Vector3D & origin ) const

inline

Definition at line 275 of file SolenoidParametrization.h.

{ return (origin.perp()         < s_maximumImpactAtOrigin
      && std::abs(origin.z())   < s_maximumZatOrigin); }

Friends And Related Symbol Documentation

Parameters

friend class Parameters

friend

Definition at line 88 of file SolenoidParametrization.h.

Member Data Documentation

m_centralField

double Trk::SolenoidParametrization::m_centralField

private

Definition at line 120 of file SolenoidParametrization.h.

m_currentMax

double Trk::SolenoidParametrization::m_currentMax {}

private

Definition at line 119 of file SolenoidParametrization.h.

{};

m_currentMin

double Trk::SolenoidParametrization::m_currentMin {}

private

Definition at line 118 of file SolenoidParametrization.h.

{};

m_fieldCondObj

const AtlasFieldCacheCondObj* Trk::SolenoidParametrization::m_fieldCondObj

private

Definition at line 117 of file SolenoidParametrization.h.

m_parameters

double Trk::SolenoidParametrization::m_parameters[14688]

private

Definition at line 121 of file SolenoidParametrization.h.

s_binInvSizeTheta

const double Trk::SolenoidParametrization::s_binInvSizeTheta = 1./0.1

staticprivate

Definition at line 102 of file SolenoidParametrization.h.

s_binInvSizeZ

const double Trk::SolenoidParametrization::s_binInvSizeZ = 1./20.*Gaudi::Units::mm

staticprivate

Definition at line 103 of file SolenoidParametrization.h.

s_binZeroTheta

const double Trk::SolenoidParametrization::s_binZeroTheta = 0.

staticprivate

Definition at line 104 of file SolenoidParametrization.h.

s_binZeroZ

const double Trk::SolenoidParametrization::s_binZeroZ = -160.*Gaudi::Units::mm

staticprivate

Definition at line 105 of file SolenoidParametrization.h.

s_lightSpeed

const double Trk::SolenoidParametrization::s_lightSpeed = -1.*299792458*Gaudi::Units::m/Gaudi::Units::s

staticprivate

Definition at line 106 of file SolenoidParametrization.h.

s_maxBinTheta

const int Trk::SolenoidParametrization::s_maxBinTheta = 72

staticprivate

Definition at line 107 of file SolenoidParametrization.h.

s_maxBinZ

const int Trk::SolenoidParametrization::s_maxBinZ = 17

staticprivate

Definition at line 108 of file SolenoidParametrization.h.

s_maximumImpactAtOrigin

const double Trk::SolenoidParametrization::s_maximumImpactAtOrigin = 30.*Gaudi::Units::mm

staticprivate

Definition at line 109 of file SolenoidParametrization.h.

s_maximumZatOrigin

const double Trk::SolenoidParametrization::s_maximumZatOrigin = 250.*Gaudi::Units::mm

staticprivate

Definition at line 110 of file SolenoidParametrization.h.

s_numberParameters

const int Trk::SolenoidParametrization::s_numberParameters = 6

staticprivate

Definition at line 111 of file SolenoidParametrization.h.

s_rInner

const double Trk::SolenoidParametrization::s_rInner = 570.*Gaudi::Units::mm

staticprivate

Definition at line 112 of file SolenoidParametrization.h.

s_rOuter

const double Trk::SolenoidParametrization::s_rOuter = 1050.*Gaudi::Units::mm

staticprivate

Definition at line 113 of file SolenoidParametrization.h.

s_zInner

const double Trk::SolenoidParametrization::s_zInner = 2150.0*Gaudi::Units::mm

staticprivate

Definition at line 114 of file SolenoidParametrization.h.

s_zOuter

const double Trk::SolenoidParametrization::s_zOuter = 2800.0*Gaudi::Units::mm

staticprivate

Definition at line 115 of file SolenoidParametrization.h.

---

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

• SolenoidParametrization.h
• SolenoidParametrization.cxx