CylinderBounds.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
namespace Trk {
inline bool CylinderBounds::operator==(const CylinderBounds& bo) const
{
  return *this == static_cast<const SurfaceBounds &>(bo);
}
 
inline CylinderBounds*
CylinderBounds::clone() const
{
  return new CylinderBounds(*this);
}
 
inline bool
CylinderBounds::inside(const Amg::Vector2D& locpo,
                       double tol1,
                       double tol2) const
{
  double z = locpo[locZ];
  bool insideZ = insideLocZ(z, tol2);
  if (!insideZ)
    return false;
  // no check on Phi neccesary
  if (!m_checkPhi)
    return true;
  // now check insidePhi
  double localPhi =
    (locpo[locRPhi] / m_boundValues[CylinderBounds::bv_radius]) -
    m_boundValues[CylinderBounds::bv_averagePhi];
  localPhi -= (localPhi > M_PI) ? 2. * M_PI : 0.;
  return (localPhi * localPhi <
          (m_boundValues[CylinderBounds::bv_halfPhiSector] + tol1) *
            (m_boundValues[CylinderBounds::bv_halfPhiSector] + tol1));
}
 
inline bool
CylinderBounds::inside(const Amg::Vector2D& locpo,
                       const BoundaryCheck& bchk) const
{
  if (bchk.bcType == 0 || bchk.nSigmas == 0 ||
      m_boundValues[CylinderBounds::bv_halfPhiSector] != M_PI)
    return CylinderBounds::inside(
      locpo, bchk.toleranceLoc1, bchk.toleranceLoc2);
 
  float theta =
    (bchk.lCovariance(1, 0) != 0 &&
     (bchk.lCovariance(1, 1) - bchk.lCovariance(0, 0)) != 0)
      ? .5 * bchk.FastArcTan(2 * bchk.lCovariance(1, 0) /
                             (bchk.lCovariance(1, 1) - bchk.lCovariance(0, 0)))
      : 0.;
  sincosCache scResult = bchk.FastSinCos(theta);
  double dphi = scResult.sinC * scResult.sinC * bchk.lCovariance(0, 0);
  double dz = scResult.cosC * scResult.cosC * bchk.lCovariance(0, 1);
  double max_ell = dphi > dz ? dphi : dz;
  double limit = bchk.nSigmas * sqrt(max_ell);
  return insideLocZ(locpo[locZ], limit);
}
 
inline bool
CylinderBounds::inside3D(const Amg::Vector3D& glopo,
                         double tol1,
                         double tol2) const
{
  return inside(glopo.perp(), glopo.phi(), glopo.z(), tol1, tol2);
}
 
inline bool
CylinderBounds::inside(double r, double phi, double z, double tol1, double tol2)
  const
{
 
  bool insideZ = insideLocZ(z, tol2);
  if (!insideZ)
    return false;
  double diffR = (m_boundValues[CylinderBounds::bv_radius] - r);
  bool insideR = diffR * diffR < tol1 * tol1;
  if (!insideR)
    return false;
  // now check insidePhi if needed
  if (!m_checkPhi)
    return true;
  // phi needs to be checked
  double localPhi = phi - m_boundValues[CylinderBounds::bv_averagePhi];
  localPhi -= (localPhi > M_PI) ? 2. * M_PI : 0.;
  return (localPhi * localPhi <
          m_boundValues[CylinderBounds::bv_halfPhiSector] *
            m_boundValues[CylinderBounds::bv_halfPhiSector]);
}
 
inline bool
CylinderBounds::insideLocZ(double z, double tol2) const
{
  return (m_boundValues[CylinderBounds::bv_halfZ] + tol2) - fabs(z) > 0.;
}
 
inline bool
CylinderBounds::insideLoc1(const Amg::Vector2D& locpo, double tol1) const
{
  bool insideRphi = false;
  if (fabs(m_boundValues[CylinderBounds::bv_averagePhi]) < 10e-7)
    insideRphi =
      (fabs(locpo[locRPhi] / m_boundValues[CylinderBounds::bv_radius]) <
       (m_boundValues[CylinderBounds::bv_halfPhiSector] + tol1));
  else {
    double localPhi =
      (locpo[locRPhi] / m_boundValues[CylinderBounds::bv_radius]) -
      m_boundValues[CylinderBounds::bv_averagePhi];
    localPhi -= (localPhi > M_PI) ? 2. * M_PI : 0.;
    insideRphi =
      (localPhi < (m_boundValues[CylinderBounds::bv_halfPhiSector] + tol1));
  }
  return (insideRphi);
}
 
inline bool
CylinderBounds::insideLoc2(const Amg::Vector2D& locpo, double tol2) const
{
  return insideLocZ(locpo[locZ], tol2);
}
 
inline bool
CylinderBounds::insideRadius(const Amg::Vector2D& locpo, double tol) const
{
  return (this->inside(locpo, tol, 0) &&
          fabs(locpo[locR]) < m_boundValues[CylinderBounds::bv_radius] + tol);
}
 
inline double
CylinderBounds::r() const
{
  return m_boundValues[CylinderBounds::bv_radius];
}
 
inline double
CylinderBounds::averagePhi() const
{
  return m_boundValues[CylinderBounds::bv_averagePhi];
}
 
inline double
CylinderBounds::halfPhiSector() const
{
  return m_boundValues[CylinderBounds::bv_halfPhiSector];
}
 
inline double
CylinderBounds::halflengthZ() const
{
  return m_boundValues[CylinderBounds::bv_halfZ];
}
 
}