CylinderSurface.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
namespace Trk {
 
inline bool CylinderSurface::operator==(const CylinderSurface& csf) const
{
  if (this == &csf){
    return true;
  }
  bool transfEqual(transform().isApprox(csf.transform(), 10e-8));
  bool centerEqual = (transfEqual) ? (center() == csf.center()) : false;
  bool boundsEqual = (centerEqual) ? (bounds() == csf.bounds()) : false;
  return boundsEqual;
}
 
/** Return the surface type */
inline constexpr SurfaceType
CylinderSurface::type() const
{
  return CylinderSurface::staticType;
}
 
template<int DIM, class T>
std::unique_ptr<ParametersT<DIM, T, CylinderSurface>>
CylinderSurface::createUniqueParameters(
  double l1,
  double l2,
  double phi,
  double theta,
  double qop,
  std::optional<AmgSymMatrix(DIM)> cov) const
{
  return std::make_unique<ParametersT<DIM, T, CylinderSurface>>(
    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, CylinderSurface>>
CylinderSurface::createUniqueParameters(
  const Amg::Vector3D& position,
  const Amg::Vector3D& momentum,
  double charge,
  std::optional<AmgSymMatrix(DIM)> cov) const
{
  return std::make_unique<ParametersT<DIM, T, CylinderSurface>>(
    position, momentum, charge, *this, std::move(cov));
}
 
inline CylinderSurface*
CylinderSurface::clone() const
{
  return new CylinderSurface(*this);
}
 
inline Amg::Vector3D
CylinderSurface::normal(const Amg::Vector2D& lp) const
{
  double phi = lp[Trk::locRPhi] / (bounds().r());
  Amg::Vector3D localNormal(cos(phi), sin(phi), 0.);
  return Amg::Vector3D(transform().linear() * localNormal);
}
 
inline double
CylinderSurface::pathCorrection(const Amg::Vector3D& pos,
                                const Amg::Vector3D& mom) const
{
  // the global normal vector is pos-center.unit() - at the z of the position
  // @TODO make safe for tilt
  Amg::Vector3D pcT(pos.x() - center().x(), pos.y() - center().y(), 0.);
  Amg::Vector3D normalT(pcT.unit()); // transverse normal
  double cosAlpha = normalT.dot(mom.unit());
  return (cosAlpha != 0 ? std::abs(1. / cosAlpha)
                        : 1.); // ST undefined for cosAlpha=0
}
 
inline const CylinderBounds&
CylinderSurface::bounds() const
{
  return *(m_bounds.get());
}
 
inline bool
CylinderSurface::hasBounds() const
{
  return m_bounds.get() != nullptr;
}
 
inline bool
CylinderSurface::insideBounds(const Amg::Vector2D& locpos,
                              double tol1,
                              double tol2) const
{
  return bounds().inside(locpos, tol1, tol2);
}
 
inline bool
CylinderSurface::insideBoundsCheck(const Amg::Vector2D& locpos,
                                   const BoundaryCheck& bchk) const
{
  return bounds().inside(locpos, bchk);
}
 
inline Amg::Vector2D
CylinderSurface::localParametersToPosition(const LocalParameters& locpars) const
{
  if (locpars.contains(Trk::locRPhi) && locpars.contains(Trk::locZ))
    return Amg::Vector2D(locpars[Trk::locRPhi], locpars[Trk::locZ]);
  if (locpars.contains(Trk::locRPhi))
    return Amg::Vector2D(locpars[Trk::locRPhi], 0.);
  if (locpars.contains(Trk::locZ))
    return Amg::Vector2D(bounds().r(), locpars[Trk::locZ]);
  return Amg::Vector2D(bounds().r(), 0.);
}
 
inline std::string
CylinderSurface::name() const
{
  return "Trk::CylinderSurface";
}
 
}