DiscSurface.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
namespace Trk {
inline bool DiscSurface::operator==(const DiscSurface& dsf) const
{
  if (this == &dsf){
    return true;
  }
  bool transfEqual(transform().isApprox(dsf.transform(), 10e-8));
  bool centerEqual = (transfEqual) ? (center() == dsf.center()) : false;
  bool boundsEqual = (centerEqual) ? (bounds() == dsf.bounds()) : false;
  return boundsEqual;
}
 
/** Return the surface type */
inline constexpr SurfaceType
DiscSurface::type() const
{
  return DiscSurface::staticType;
}
 
template<int DIM, class T>
std::unique_ptr<ParametersT<DIM, T, DiscSurface>>
DiscSurface::createUniqueParameters(double l1,
                                    double l2,
                                    double phi,
                                    double theta,
                                    double qop,
                                    std::optional<AmgSymMatrix(DIM)> cov) const
{
  return std::make_unique<ParametersT<DIM, T, DiscSurface>>(
    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, DiscSurface>>
DiscSurface::createUniqueParameters(const Amg::Vector3D& position,
                                    const Amg::Vector3D& momentum,
                                    double charge,
                                    std::optional<AmgSymMatrix(DIM)> cov) const
{
  return std::make_unique<ParametersT<DIM, T, DiscSurface>>(
    position, momentum, charge, *this, std::move(cov));
}
 
inline DiscSurface*
DiscSurface::clone() const
{
  return new DiscSurface(*this);
}
 
inline const SurfaceBounds&
DiscSurface::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
DiscSurface::insideBounds(const Amg::Vector2D& locpos,
                          double tol1,
                          double tol2) const
{
  return bounds().inside(locpos, tol1, tol2);
}
 
inline bool
DiscSurface::insideBoundsCheck(const Amg::Vector2D& locpos,
                               const BoundaryCheck& bchk) const
{
  return (bounds().inside(locpos, bchk));
}
 
inline Amg::Vector2D
DiscSurface::localParametersToPosition(const LocalParameters& locpars) const
{
  if (locpars.contains(Trk::locR) && locpars.contains(Trk::locPhi))
    return Amg::Vector2D(locpars[Trk::locR], locpars[Trk::locPhi]);
  if (locpars.contains(Trk::locR))
    return Amg::Vector2D(locpars[Trk::locR], 0.);
  if (locpars.contains(Trk::locPhi))
    return Amg::Vector2D(0.5 * bounds().r(), locpars[Trk::locPhi]);
  return Amg::Vector2D(0.5 * bounds().r(), 0.);
}
 
/** Return properly formatted class name for screen output */
inline std::string
DiscSurface::name() const
{
  return "Trk::DiscSurface";
}
 
}