PerigeeSurface.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
namespace Trk {
 
inline bool PerigeeSurface::operator==(const PerigeeSurface& persf) const
{
  if (this == &persf){
    return true;
  }
  return (center() == persf.center());
}
 
/** Return the surface type */
inline constexpr SurfaceType
PerigeeSurface::type() const
{
  return PerigeeSurface::staticType;
}
template<int DIM, class T>
std::unique_ptr<ParametersT<DIM, T, PerigeeSurface>>
PerigeeSurface::createUniqueParameters(
  double l1,
  double l2,
  double phi,
  double theta,
  double qop,
  std::optional<AmgSymMatrix(DIM)> cov) const
{
  return std::make_unique<ParametersT<DIM, T, PerigeeSurface>>(
    l1, l2, phi, theta, qop, *this, std::move(cov));
}
 
/** Use the Surface as a ParametersBase constructor, from global parameters */
template<int DIM, class T>
std::unique_ptr<ParametersT<DIM, T, PerigeeSurface>>
PerigeeSurface::createUniqueParameters(
  const Amg::Vector3D& position,
  const Amg::Vector3D& momentum,
  double charge,
  std::optional<AmgSymMatrix(DIM)> cov) const
{
  return std::make_unique<ParametersT<DIM, T, PerigeeSurface>>(
    position, momentum, charge, *this, std::move(cov));
}
 
inline PerigeeSurface*
PerigeeSurface::clone() const
{
  return new PerigeeSurface(*this);
}
 
inline const Amg::Vector3D&
PerigeeSurface::normal() const
{
  return s_xAxis;
}
 
inline Amg::Vector3D
PerigeeSurface::normal(const Amg::Vector2D&) const
{
  return Amg::Vector3D(normal());
}
 
inline bool
PerigeeSurface::insideBounds(const Amg::Vector2D&, double, double) const
{
  return true;
}
 
inline bool
PerigeeSurface::insideBoundsCheck(const Amg::Vector2D&,
                                  const BoundaryCheck&) const
{
  return true;
}
 
inline bool
PerigeeSurface::isOnSurface(const Amg::Vector3D&,
                            const BoundaryCheck&,
                            double,
                            double) const
{
  return true;
}
 
inline const NoBounds&
PerigeeSurface::bounds() const
{
  return s_perigeeBounds;
}
 
inline const Amg::Vector3D&
PerigeeSurface::lineDirection() const
{
  if (m_lineDirection.isValid()) {
    return *(m_lineDirection.ptr());
  }
 
  if (Surface::m_transforms) {
    if (!m_lineDirection.isValid()) {
      m_lineDirection.set(transform().linear().col(2));
      return *(m_lineDirection.ptr());
    }
  }
  return Trk::s_zAxis;
}
 
/** the pathCorrection for derived classes with thickness */
inline double
PerigeeSurface::pathCorrection(const Amg::Vector3D&, const Amg::Vector3D&) const
{
  return 1.;
}
 
/** Return properly formatted class name for screen output */
inline std::string
PerigeeSurface::name() const
{
  return "Trk::PerigeeSurface";
}
 
}