ConeSurface.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
namespace Trk {
 
inline bool ConeSurface::operator==(const ConeSurface& csf) const
{
  //comparison with self
  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
ConeSurface::type() const
{
  return ConeSurface::staticType;
}
 
template<int DIM, class T>
std::unique_ptr<ParametersT<DIM, T, ConeSurface>>
ConeSurface::createUniqueParameters(double l1,
                                    double l2,
                                    double phi,
                                    double theta,
                                    double qop,
                                    std::optional<AmgSymMatrix(DIM)> cov) const
{
  return std::make_unique<ParametersT<DIM, T, ConeSurface>>(
    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, ConeSurface>>
ConeSurface::createUniqueParameters(const Amg::Vector3D& position,
                                    const Amg::Vector3D& momentum,
                                    double charge,
                                    std::optional<AmgSymMatrix(DIM)> cov) const
{
  return std::make_unique<ParametersT<DIM, T, ConeSurface>>(
    position, momentum, charge, *this, std::move(cov));
}
 
inline ConeSurface*
ConeSurface::clone() const
{
  return new ConeSurface(*this);
}
 
inline Amg::Vector3D
ConeSurface::normal(const Amg::Vector2D& lp) const
{
  // (cos phi cos alpha, sin phi cos alpha, sgn z sin alpha)
  double phi = lp[Trk::locRPhi] / (bounds().r(lp[Trk::locZ]));
  double sgn = lp[Trk::locZ] > 0 ? -1. : +1.;
  Amg::Vector3D localNormal(cos(phi) * bounds().cosAlpha(),
                            sin(phi) * bounds().cosAlpha(),
                            sgn * bounds().sinAlpha());
  return Amg::Vector3D(transform().rotation() * localNormal);
}
 
inline const ConeBounds&
ConeSurface::bounds() const
{
  return *(m_bounds.get());
}
 
inline bool
ConeSurface::insideBounds(const Amg::Vector2D& locpos,
                          double tol1,
                          double tol2) const
{
  return bounds().inside(locpos, tol1, tol2);
}
 
inline bool
ConeSurface::insideBoundsCheck(const Amg::Vector2D& locpos,
                               const BoundaryCheck& bchk) const
{
  return bounds().inside(locpos, bchk.toleranceLoc1, bchk.toleranceLoc2);
}
 
inline Amg::Vector2D
ConeSurface::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)) {
    // not obvious what one should do here with the "r" bit, so by definintion
    // take that r=1 if no z is given to fix down the r component
    double phi = locpars[Trk::locRPhi];
    return Amg::Vector2D(phi, locpars[Trk::locZ]);
  } else if (locpars.contains(Trk::locZ)) {
    double r = locpars[Trk::locZ] * bounds().tanAlpha();
    // by definition set it to M_PI/2
    return Amg::Vector2D(r * M_PI * 0.5, locpars[Trk::locZ]);
  }
  return Amg::Vector2D(0., 0.);
}
 
/** Return properly formatted class name for screen output */
inline std::string
ConeSurface::name() const
{
  return "Trk::ConeSurface";
}
 
}