StraightLineSurface.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
namespace Trk {
 
inline bool StraightLineSurface::operator==(const StraightLineSurface& slsf) const
{
  if(this == &slsf){
    return true;
  }
  bool transfEqual(transform().isApprox(slsf.transform(), 10e-8));
  bool centerEqual = (transfEqual) ? (center() == slsf.center()) : false;
  bool boundsEqual = (centerEqual) ? (bounds() == slsf.bounds()) : false;
  return boundsEqual;
}
 
/** Return the surface type */
inline constexpr SurfaceType
StraightLineSurface::type() const
{
  return StraightLineSurface::staticType;
}
 
template<int DIM, class T>
std::unique_ptr<ParametersT<DIM, T, StraightLineSurface>>
StraightLineSurface::createUniqueParameters(
  double l1,
  double l2,
  double phi,
  double theta,
  double qop,
  std::optional<AmgSymMatrix(DIM)> cov) const
{
  return std::make_unique<ParametersT<DIM, T, StraightLineSurface>>(
    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, StraightLineSurface>>
StraightLineSurface::createUniqueParameters(
  const Amg::Vector3D& position,
  const Amg::Vector3D& momentum,
  double charge,
  std::optional<AmgSymMatrix(DIM)> cov) const
{
  return std::make_unique<ParametersT<DIM, T, StraightLineSurface>>(
    position, momentum, charge, *this, std::move(cov));
}
 
inline StraightLineSurface*
StraightLineSurface::clone() const
{
  return new StraightLineSurface(*this);
}
 
inline const SurfaceBounds&
StraightLineSurface::bounds() const
{
  if (m_bounds.get())
    return *(m_bounds.get());
  if (Surface::m_associatedDetElement &&
      Surface::m_associatedDetElementId.is_valid()) {
    return m_associatedDetElement->bounds(Surface::m_associatedDetElementId);
  }
  if (Surface::m_associatedDetElement)
    return m_associatedDetElement->bounds();
  return s_boundless;
}
 
inline bool
StraightLineSurface::insideBounds(const Amg::Vector2D& locpos,
                                  double tol1,
                                  double tol2) const
{
  if (!(m_bounds.get()) && !Surface::m_associatedDetElement)
    return true;
  return (std::abs(locpos[locR]) < bounds().r() + tol1 &&
          bounds().insideLoc2(locpos, tol2));
}
 
inline bool
StraightLineSurface::insideBoundsCheck(const Amg::Vector2D& locpos,
                                       const BoundaryCheck& bchk) const
{
  return StraightLineSurface::insideBounds(
    locpos, bchk.toleranceLoc1, bchk.toleranceLoc2);
}
 
inline const Amg::Vector3D&
StraightLineSurface::lineDirection() const
{
  if (!m_lineDirection.isValid()) {
    m_lineDirection.set(transform().rotation().col(2));
  }
  return *(m_lineDirection.ptr());
}
 
/** the pathCorrection for derived classes with thickness */
inline double
StraightLineSurface::pathCorrection(const Amg::Vector3D&,
                                    const Amg::Vector3D&) const
{
  return 1.;
}
 
/** Return properly formatted class name for screen output */
inline std::string
StraightLineSurface::name() const
{
  return "Trk::StraightLineSurface";
}
 
}