EllipseBounds.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
 
// EllipseBounds.h, c) ATLAS Detector software
// M. Wolter, June 2006
 
#ifndef TRKSURFACES_ELLIPSEBOUNDS_H
#define TRKSURFACES_ELLIPSEBOUNDS_H
 
// Trk
#include "GeoPrimitives/GeoPrimitives.h"
#include "TrkEventPrimitives/ParamDefs.h"
#include "TrkSurfaces/SurfaceBounds.h"
//
#include <cmath>
#include <cstdlib>
 
class MsgStream;
 
 
namespace Trk {
 
class EllipseBounds final: public SurfaceBounds
{
public:
  enum BoundValues
  {
    bv_rMinX = 0,
    bv_rMinY = 1,
    bv_rMaxX = 2,
    bv_rMaxY = 3,
    bv_averagePhi = 4,
    bv_halfPhiSector = 5,
    bv_length = 6
  };
  EllipseBounds();
 
  EllipseBounds(const EllipseBounds& discbo) = default;
 
  EllipseBounds& operator=(const EllipseBounds& discbo) = default;
 
  EllipseBounds(EllipseBounds&& discbo) noexcept = default;
 
  EllipseBounds& operator=(EllipseBounds&& discbo) noexcept = default;
 
  virtual ~EllipseBounds() = default;
 
  EllipseBounds(double minrad1, double minrad2, double maxrad1, double maxrad2, double hphisec = M_PI);
 
  EllipseBounds(double minrad1, double minrad2, double maxrad1, double maxrad2, double avephi, double hphisec);
 
 
  virtual bool operator==(const SurfaceBounds& sbo) const override;
 
  virtual EllipseBounds* clone() const override final;
 
  virtual BoundsType type() const override final { return SurfaceBounds::Ellipse; }
 
  virtual bool inside(const Amg::Vector2D& locpo, double tol1 = 0., double tol2 = 0.) const override final;
  virtual bool inside(const Amg::Vector2D& locpo, const BoundaryCheck& bchk) const override final;
 
  virtual bool insideLoc1(const Amg::Vector2D& locpo, double tol1 = 0.) const override final;
 
  virtual bool insideLoc2(const Amg::Vector2D& locpo, double tol2 = 0.) const override final;
 
  virtual double minDistance(const Amg::Vector2D& pos) const override final;
 
  double rMinX() const;
 
  double rMinY() const;
 
  double rMaxX() const;
 
  double rMaxY() const;
 
  virtual double r() const override final;
 
  double averagePhi() const;
 
  double halfPhiSector() const;
 
  virtual MsgStream& dump(MsgStream& sl) const override;
  virtual std::ostream& dump(std::ostream& sl) const override;
 
private:
  std::vector<TDD_real_t> m_boundValues;
 
  inline double square(double x) const { return x * x; };
};
 
inline EllipseBounds*
EllipseBounds::clone() const
{
  return new EllipseBounds(*this);
}
 
inline bool
EllipseBounds::inside(const Amg::Vector2D& locpo, double tol1, double tol2) const
{
  double alpha = acos(cos(locpo[locPhi] - m_boundValues[EllipseBounds::bv_averagePhi]));
  bool insidePhi = (m_boundValues[EllipseBounds::bv_halfPhiSector] + tol2 < M_PI)
                     ? (alpha <= (m_boundValues[EllipseBounds::bv_halfPhiSector] + tol2))
                     : 1;
  bool insideInner = (m_boundValues[EllipseBounds::bv_rMinX] <= tol1) ||
                     (m_boundValues[EllipseBounds::bv_rMinY] <= tol1) ||
                     (square(locpo[locX] / (m_boundValues[EllipseBounds::bv_rMinX] - tol1)) +
                        square(locpo[locY] / (m_boundValues[EllipseBounds::bv_rMinY] - tol1)) >
                      1);
  bool insideOuter = (square(locpo[locX] / (m_boundValues[EllipseBounds::bv_rMaxX] + tol1)) +
                        square(locpo[locY] / (m_boundValues[EllipseBounds::bv_rMaxY] + tol1)) <
                      1);
  return (insideInner && insideOuter && insidePhi);
}
 
inline bool
EllipseBounds::inside(const Amg::Vector2D& locpo, const BoundaryCheck& bchk) const
{
  return EllipseBounds::inside(locpo, bchk.toleranceLoc1, bchk.toleranceLoc2);
}
 
inline bool
EllipseBounds::insideLoc1(const Amg::Vector2D& locpo, double tol1) const
{
  bool insideInner = (m_boundValues[EllipseBounds::bv_rMinX] <= tol1) ||
                     (m_boundValues[EllipseBounds::bv_rMinY] <= tol1) ||
                     (square(locpo[locX] / (m_boundValues[EllipseBounds::bv_rMinX] - tol1)) +
                        square(locpo[locY] / (m_boundValues[EllipseBounds::bv_rMinY] - tol1)) >
                      1);
  bool insideOuter = (square(locpo[locX] / (m_boundValues[EllipseBounds::bv_rMaxX] + tol1)) +
                        square(locpo[locY] / (m_boundValues[EllipseBounds::bv_rMaxY] + tol1)) <
                      1);
  return (insideInner && insideOuter);
}
 
inline bool
EllipseBounds::insideLoc2(const Amg::Vector2D& locpo, double tol2) const
{
  double alpha = acos(cos(locpo[locPhi] - m_boundValues[EllipseBounds::bv_averagePhi]));
  bool insidePhi = (m_boundValues[EllipseBounds::bv_halfPhiSector] + tol2 < M_PI)
                     ? (alpha <= (m_boundValues[EllipseBounds::bv_halfPhiSector] + tol2))
                     : 1;
  return insidePhi;
}
 
inline double
EllipseBounds::rMinX() const
{
  return m_boundValues[EllipseBounds::bv_rMinX];
}
inline double
EllipseBounds::rMinY() const
{
  return m_boundValues[EllipseBounds::bv_rMinY];
}
inline double
EllipseBounds::rMaxX() const
{
  return m_boundValues[EllipseBounds::bv_rMaxX];
}
inline double
EllipseBounds::rMaxY() const
{
  return m_boundValues[EllipseBounds::bv_rMaxY];
}
inline double
EllipseBounds::r() const
{
  return std::max(m_boundValues[EllipseBounds::bv_rMaxX], m_boundValues[EllipseBounds::bv_rMaxY]);
}
inline double
EllipseBounds::averagePhi() const
{
  return m_boundValues[EllipseBounds::bv_averagePhi];
}
inline double
EllipseBounds::halfPhiSector() const
{
  return m_boundValues[EllipseBounds::bv_halfPhiSector];
}
 
} // end of namespace
 
#endif // TRKSURFACES_ELLIPSEBOUNDS_H