PlaneSurface.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
namespace Trk {
 
inline bool PlaneSurface::operator==(const PlaneSurface& psf) const
{
  if (this == &psf){
    return true;
  }
  bool transfEqual(transform().isApprox(psf.transform(), 10e-8));
  bool centerEqual = center() == psf.center();
  bool boundsEqual = bounds() == psf.bounds();
  return transfEqual && centerEqual && boundsEqual;
}
 
inline constexpr SurfaceType
PlaneSurface::type() const
{
  return PlaneSurface::staticType;
}
 
/** Use the Surface as a ParametersBase constructor, from local parameters */
template<int DIM, class T>
std::unique_ptr<ParametersT<DIM, T, PlaneSurface>>
PlaneSurface::createUniqueParameters(double l1,
                                     double l2,
                                     double phi,
                                     double theta,
                                     double qop,
                                     std::optional<AmgSymMatrix(DIM)> cov) const
{
  return std::make_unique<ParametersT<DIM, T, PlaneSurface>>(
    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, PlaneSurface>>
PlaneSurface::createUniqueParameters(const Amg::Vector3D& position,
                                     const Amg::Vector3D& momentum,
                                     double charge,
                                     std::optional<AmgSymMatrix(DIM)> cov) const
{
  return std::make_unique<ParametersT<DIM, T, PlaneSurface>>(
    position, momentum, charge, *this, std::move(cov));
}
 
/** Return properly formatted class name for screen output */
inline std::string
PlaneSurface::name() const
{
  return "Trk::PlaneSurface";
}
 
inline PlaneSurface*
PlaneSurface::clone() const
{
  return new PlaneSurface(*this);
}
 
inline bool
PlaneSurface::insideBounds(const Amg::Vector2D& locpos,
                           double tol1,
                           double tol2) const
{
  return (bounds().inside(locpos, tol1, tol2));
}
 
inline bool
PlaneSurface::insideBoundsCheck(const Amg::Vector2D& locpos,
                                const BoundaryCheck& bchk) const
{
  return (bounds().inside(locpos, bchk));
}
 
inline const SurfaceBounds&
PlaneSurface::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;
}
}