ConeBounds.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
namespace Trk {
inline bool ConeBounds::operator==(const ConeBounds& bo) const
{
  return *this == static_cast<const SurfaceBounds& >(bo);
}
 
inline ConeBounds*
ConeBounds::clone() const
{
  return new ConeBounds(*this);
}
 
inline bool
ConeBounds::inside(const Amg::Vector2D& locpo, double tol1, double tol2) const
{
  double z = locpo[locZ];
  bool insideZ = z > (m_boundValues[ConeBounds::bv_minZ] - tol2) &&
                 z < (m_boundValues[ConeBounds::bv_maxZ] + tol2);
  if (!insideZ)
    return false;
  // TODO: Do we need some sort of "R" tolerance also here (take
  // it off the z tol2 in that case?) or does the rphi tol1 cover
  // this? (Could argue either way)
  double coneR = z * m_tanAlpha;
  double minRPhi = coneR * minPhi() - tol1;
  double maxRPhi = coneR * maxPhi() + tol1;
  return minRPhi < locpo[locRPhi] && locpo[locRPhi] < maxRPhi;
}
 
inline bool
ConeBounds::inside(const Amg::Vector3D& glopo, double tol1, double tol2) const
{
  // coords are (rphi,z)
  return inside(
    Amg::Vector2D(glopo.perp() * glopo.phi(), glopo.z()), tol1, tol2);
}
 
inline bool
ConeBounds::inside(const Amg::Vector3D& glopo, const BoundaryCheck& bchk) const
{
  // coords are (rphi,z)
  return inside(Amg::Vector2D(glopo.perp() * glopo.phi(), glopo.z()),
                bchk.toleranceLoc1,
                bchk.toleranceLoc2);
}
 
inline bool
ConeBounds::inside(const Amg::Vector2D& locpo, const BoundaryCheck& bchk) const
{
  return ConeBounds::inside(locpo, bchk.toleranceLoc1, bchk.toleranceLoc2);
}
 
inline bool
ConeBounds::insideLoc1(const Amg::Vector2D& locpo, double tol1) const
{
  double z = locpo[locZ];
  double coneR = z * m_tanAlpha;
  double minRPhi = coneR * minPhi() - tol1;
  double maxRPhi = coneR * maxPhi() + tol1;
  return minRPhi < locpo[locRPhi] && locpo[locRPhi] < maxRPhi;
}
 
inline bool
ConeBounds::insideLoc2(const Amg::Vector2D& locpo, double tol2) const
{
  double z = locpo[locZ];
  return (z > (m_boundValues[ConeBounds::bv_minZ] - tol2) &&
          z < (m_boundValues[ConeBounds::bv_maxZ] + tol2));
}
 
inline double
ConeBounds::r() const
{
  double z = fabs(m_boundValues[ConeBounds::bv_maxZ]);
  double mz = fabs(m_boundValues[ConeBounds::bv_minZ]);
  if (mz > z)
    z = mz;
  return fabs(z * m_tanAlpha);
}
 
inline double
ConeBounds::r(double z) const
{
  return fabs(z * m_tanAlpha);
}
 
inline double
ConeBounds::tanAlpha() const
{
  return m_tanAlpha;
}
 
inline double
ConeBounds::sinAlpha() const
{
  return m_sinAlpha;
}
 
inline double
ConeBounds::cosAlpha() const
{
  return m_cosAlpha;
}
 
inline double
ConeBounds::alpha() const
{
  return m_boundValues[ConeBounds::bv_alpha];
}
 
inline double
ConeBounds::minZ() const
{
  return m_boundValues[ConeBounds::bv_minZ];
}
 
inline double
ConeBounds::maxZ() const
{
  return m_boundValues[ConeBounds::bv_maxZ];
}
 
inline double
ConeBounds::averagePhi() const
{
  return m_boundValues[ConeBounds::bv_averagePhi];
}
 
inline double
ConeBounds::halfPhiSector() const
{
  return m_boundValues[ConeBounds::bv_halfPhiSector];
}
 
}