PatternTrackParameters.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2024 CERN for the benefit of the ATLAS collaboration
*/
 
namespace Trk {
 
inline PatternTrackParameters::PatternTrackParameters()
    : ParametersCommon<5, Trk::Charged>() {
  m_parameters.setZero();
}
 
inline PatternTrackParameters::PatternTrackParameters(
    const PatternTrackParameters& P)
    : PatternTrackParameters() {
  *this = P;
}
 
inline PatternTrackParameters& PatternTrackParameters::operator=(
    const PatternTrackParameters& P) {
  if (&P != this) {
    if (P.m_surface != nullptr) {
      m_surface.reset(P.m_surface->isFree() ? P.m_surface->clone()
                                            : P.m_surface.get());
    } else {
      m_surface.reset(nullptr);
    }
 
    m_parameters = P.m_parameters;
 
    if (P.m_covariance != std::nullopt) {
      if (m_covariance == std::nullopt) {
        m_covariance = AmgSymMatrix(5)(*P.m_covariance);
      } else {
        *m_covariance = *P.m_covariance;
      }
    }
  }
 
  return (*this);
}
 
inline void PatternTrackParameters::setParameters(const Surface* s,
                                                  const double* p) {
  m_surface.reset(s && s->isFree() ? s->clone() : s);
  m_parameters[0] = p[0];
  m_parameters[1] = p[1];
  m_parameters[2] = p[2];
  m_parameters[3] = p[3];
  m_parameters[4] = p[4];
  m_covariance.reset();
}
 
inline void PatternTrackParameters::setCovariance(const double* c) {
  if (m_covariance == std::nullopt) {
    m_covariance.emplace();
  }
 
  m_covariance->fillSymmetric(0, 0, c[0]);
  m_covariance->fillSymmetric(0, 1, c[1]);
  m_covariance->fillSymmetric(1, 1, c[2]);
  m_covariance->fillSymmetric(0, 2, c[3]);
  m_covariance->fillSymmetric(1, 2, c[4]);
  m_covariance->fillSymmetric(2, 2, c[5]);
  m_covariance->fillSymmetric(0, 3, c[6]);
  m_covariance->fillSymmetric(1, 3, c[7]);
  m_covariance->fillSymmetric(2, 3, c[8]);
  m_covariance->fillSymmetric(3, 3, c[9]);
  m_covariance->fillSymmetric(0, 4, c[10]);
  m_covariance->fillSymmetric(1, 4, c[11]);
  m_covariance->fillSymmetric(2, 4, c[12]);
  m_covariance->fillSymmetric(3, 4, c[13]);
  m_covariance->fillSymmetric(4, 4, c[14]);
}
 
inline void PatternTrackParameters::setParametersWithCovariance(
    const Surface* s, const double* p, const double* c) {
  m_surface.reset(s && s->isFree() ? s->clone() : s);
  m_parameters[0] = p[0];
  m_parameters[1] = p[1];
  m_parameters[2] = p[2];
  m_parameters[3] = p[3];
  m_parameters[4] = p[4];
  setCovariance(c);
}
 
inline void PatternTrackParameters::setParametersWithCovariance(
    const Surface* s, const double* p, const AmgSymMatrix(5) & c) {
  double C[15] = {c(0, 0), c(1, 0), c(1, 1), c(2, 0), c(2, 1),
                  c(2, 2), c(3, 0), c(3, 1), c(3, 2), c(3, 3),
                  c(4, 0), c(4, 1), c(4, 2), c(4, 3), c(4, 4)};
  setParametersWithCovariance(s, p, C);
}
 
inline void PatternTrackParameters::diagonalization(double D) {
  if (m_covariance == std::nullopt) {
    return;
  }
 
  m_covariance->fillSymmetric(0, 1, 0);
  m_covariance->fillSymmetric(0, 2, 0);
  m_covariance->fillSymmetric(1, 2, 0);
  m_covariance->fillSymmetric(0, 3, 0);
  m_covariance->fillSymmetric(1, 3, 0);
  m_covariance->fillSymmetric(2, 3, 0);
  m_covariance->fillSymmetric(0, 4, 0);
  m_covariance->fillSymmetric(1, 4, 0);
  m_covariance->fillSymmetric(2, 4, 0);
  m_covariance->fillSymmetric(3, 4, 0);
 
  (*m_covariance)(0, 0) *= D;
  (*m_covariance)(1, 1) *= D;
  (*m_covariance)(2, 2) *= D;
  (*m_covariance)(3, 3) *= D;
  (*m_covariance)(4, 4) *= D;
}
 
inline void PatternTrackParameters::addNoise(const NoiseOnSurface& N,
                                             PropDirection D) {
  if (m_covariance != std::nullopt) {
    (*m_covariance)(2, 2) += N.covarianceAzim();
    (*m_covariance)(3, 3) += N.covariancePola();
    (*m_covariance)(4, 4) += N.covarianceIMom();
  }
 
  if (D > 0) {
    N.correctionIMom() > 1. ? m_parameters[4] *= N.correctionIMom()
                            : m_parameters[4] /= N.correctionIMom();
  } else {
    N.correctionIMom() > 1. ? m_parameters[4] /= N.correctionIMom()
                            : m_parameters[4] *= N.correctionIMom();
  }
}
 
inline void PatternTrackParameters::removeNoise(const NoiseOnSurface& N,
                                                PropDirection D) {
  if (m_covariance != std::nullopt) {
    (*m_covariance)(2, 2) -= N.covarianceAzim();
    (*m_covariance)(3, 3) -= N.covariancePola();
    (*m_covariance)(4, 4) -= N.covarianceIMom();
  }
 
  if (D > 0) {
    N.correctionIMom() > 1. ? m_parameters[4] /= N.correctionIMom()
                            : m_parameters[4] *= N.correctionIMom();
  } else {
    N.correctionIMom() > 1. ? m_parameters[4] *= N.correctionIMom()
                            : m_parameters[4] /= N.correctionIMom();
  }
}
 
inline double PatternTrackParameters::charge() const {
  if (m_parameters[4] > 0.0) {
    return 1.0;
  } else {
    return -1.0;
  }
}
 
inline double PatternTrackParameters::sinPhi() const {
  return std::sin(m_parameters[2]);
}
 
inline double PatternTrackParameters::cosPhi() const {
  return std::cos(m_parameters[2]);
}
 
inline double PatternTrackParameters::sinTheta() const {
  return std::sin(m_parameters[3]);
}
 
inline double PatternTrackParameters::cosTheta() const {
  return std::cos(m_parameters[3]);
}
 
inline double PatternTrackParameters::cotTheta() const {
  return (1. / std::tan(m_parameters[3]));
}
 
inline Amg::Vector3D PatternTrackParameters::momentum() const {
  return calculateMomentum();
}
 
inline double PatternTrackParameters::absoluteMomentum() const {
  return m_parameters[4] != 0. ? 1. / std::abs(m_parameters[4]) : 10e9;
}
 
inline double PatternTrackParameters::transverseMomentum() const {
  double p = absoluteMomentum();
  double Se = std::sin(m_parameters[3]);
  return p * Se;
}
 
inline const Surface& PatternTrackParameters::associatedSurface() const {
  return *m_surface;
}
 
inline bool PatternTrackParameters::hasSurface() const {
  return m_surface != nullptr;
}
 
inline Amg::RotationMatrix3D PatternTrackParameters::measurementFrame() const {
  return associatedSurface().measurementFrame(this->position(),
                                              this->momentum());
}
 
inline PatternTrackParameters* PatternTrackParameters::clone() const {
  return new PatternTrackParameters(*this);
}
 
inline constexpr ParametersType PatternTrackParameters::type() const {
  return Pattern;
}
 
inline SurfaceType PatternTrackParameters::surfaceType() const {
  return m_surface->type();
}
 
inline void PatternTrackParameters::updateParametersHelper(const AmgVector(5) & params) {
  m_parameters = params;
}
}  // end namespace Trk