AnnulusBounds.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2023 CERN for the benefit of the ATLAS collaboration
*/

// AnnulusBounds.h, (c) ATLAS Detector software
 
#ifndef TRKSURFACES_ANNULUSBOUNDS_H
#define TRKSURFACES_ANNULUSBOUNDS_H
 
#include "TrkSurfaces/SurfaceBounds.h"
//#include "TrkEventPrimitives/ParamDefs.h"
//#include <math.h>
#include <iosfwd> //ostream fwd declaration
#include <vector>
 
#include "GeoPrimitives/GeoPrimitives.h"
 
class MsgStream;
 
#ifdef TRKDETDESCR_USEFLOATPRECISON
typedef float TDD_real_t;
#else
typedef double TDD_real_t;
#endif
 
namespace Trk {

 
class AnnulusBounds final: public SurfaceBounds
{
 
public:
  enum BoundValues
  {
    bv_minR = 0,
    bv_maxR = 1,
    bv_R = 2,
    bv_phi = 3,
    bv_phiS = 4,
    bv_length = 5
  };

  AnnulusBounds();
  AnnulusBounds(double minR, double maxR, double R, double phi, double phiS);

  AnnulusBounds(const AnnulusBounds& annbo) = default;
  AnnulusBounds& operator=(const AnnulusBounds& sbo) = default;
  AnnulusBounds(AnnulusBounds&& annbo) = default;
  AnnulusBounds& operator=(AnnulusBounds&& sbo) = default;

  virtual ~AnnulusBounds() = default;

  virtual AnnulusBounds* clone() const override;

  virtual BoundsType type() const override { return SurfaceBounds::Annulus; }

  bool operator==(const SurfaceBounds& annbo) const override;

  double minR() const;

  double maxR() const;

  double waferCentreR() const;

  double phi() const;

  double phiS() const;

  std::array<std::pair<double, double>, 4> corners() const;

  virtual double r() const override;

  //      double alpha() const;

  //      double beta() const;

  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;

  virtual MsgStream& dump(MsgStream& sl) const override;

  virtual std::ostream& dump(std::ostream& sl) const override;

  std::array<TDD_real_t,4> getEdgeLines() const;
 
  const std::vector<TDD_real_t>& getBoundsValues() const;
 
private:
  //      bool m_forceCovEllipse;

 
  static bool isAbove(const Amg::Vector2D& locpo, double tol1, double tol2, double x1, double y1, double x2, double y2) ;
 
  static bool isRight(const Amg::Vector2D& locpo, double tol1, double tol2, double x1, double y1, double x2, double y2) ;
 
  static bool isLeft(const Amg::Vector2D& locpo, double tol1, double tol2, double x1, double y1, double x2, double y2) ;
 
  // check whether an ellipse intersects a line
  static bool EllipseIntersectLine(const Amg::Vector2D& locpo, double h, double k, double x1, double y1, double x2, double y2)
    ;

  static double distanceToLine(const Amg::Vector2D& locpo, const std::vector<TDD_real_t>& P1, const std::vector<TDD_real_t>& P2) ;

  static double distanceToArc(const Amg::Vector2D& locpo,
                       double R,
                       const std::vector<TDD_real_t>& sL,
                       const std::vector<TDD_real_t>& sR) ;

  static std::vector<double> circleLineIntersection(double R, double k, double d) ;
 
  std::vector<TDD_real_t> m_boundValues;
 
  TDD_real_t m_maxYout;
  TDD_real_t m_minYout;
  TDD_real_t m_maxXout;
  TDD_real_t m_minXout;
 
  TDD_real_t m_maxYin;
  TDD_real_t m_minYin;
  TDD_real_t m_maxXin;
  TDD_real_t m_minXin;
 
  TDD_real_t m_k_L;
  TDD_real_t m_k_R;
  TDD_real_t m_d_L;
  TDD_real_t m_d_R;
 
  std::vector<TDD_real_t> m_solution_L_min;
  std::vector<TDD_real_t> m_solution_L_max;
  std::vector<TDD_real_t> m_solution_R_min;
  std::vector<TDD_real_t> m_solution_R_max;
};
 
} // end of namespace
 
#include "TrkSurfaces/AnnulusBounds.icc"
#endif // TRKSURFACES_ANNULUSBOUNDS_H