Circle2D.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
#pragma once
 
#include <tracking/trackingUtilities/geometry/VectorUtil.h>
 
#include <tracking/trackingUtilities/numerics/ERightLeft.h>
#include <tracking/trackingUtilities/numerics/ERotation.h>
#include <tracking/trackingUtilities/numerics/ESign.h>
 
#include <framework/geometry/VectorUtil.h>
 
#include <Math/Vector2D.h>
#include <Math/VectorUtil.h>
 
#include <cmath>
 
namespace Belle2 {
  namespace TrackingUtilities {

    class Circle2D {
 
    public:
      Circle2D()
        : m_center(0.0, 0.0)
        , m_radius(0.0)
      {
      }

      Circle2D(const ROOT::Math::XYVector& center, const double radius)
        : m_center(center)
        , m_radius(radius)
      {
      }

      Circle2D(const ROOT::Math::XYVector& center, const double absRadius, const ERotation ccwInfo)
        : m_center(center)
        , m_radius(fabs(absRadius) * static_cast<double>(ccwInfo))
      {
      }
 
    public:
      void reverse()
      {
        m_radius *= -1;
      }

      Circle2D reversed() const
      {
        return Circle2D(center(), -radius());
      }

      void conformalTransform()
      {
        double denominator = 1 / (center().Mag2() - radius() * radius());
        m_center *= denominator;
        m_radius *= -denominator;
      }

      Circle2D conformalTransformed() const
      {
        double denominator = 1 / (center().Mag2() - radius() * radius());
        return Circle2D(center() * denominator, -radius() * denominator);
      }
 
    public:
      double distance(const ROOT::Math::XYVector& point) const
      {
        return copysign(VectorUtil::Distance(center(), point), radius()) - radius();
      }

      double impact() const
      {
        return copysign(center().R(), radius()) - radius();
      }

      double absDistance(const ROOT::Math::XYVector& point) const
      {
        return fabs(VectorUtil::Distance(center(), point) - absRadius());
      }

      ERightLeft isRightOrLeft(const ROOT::Math::XYVector& point) const
      {
        return static_cast<ERightLeft>(sign(distance(point)));
      }

      bool isLeft(const ROOT::Math::XYVector& rhs) const
      {
        return isRightOrLeft(rhs) == ERightLeft::c_Left;
      }

      bool isRight(const ROOT::Math::XYVector& rhs) const
      {
        return isRightOrLeft(rhs) == ERightLeft::c_Right;
      }

      ROOT::Math::XYVector closest(const ROOT::Math::XYVector& point) const
      {
        ROOT::Math::XYVector connection = point - center();
        if (connection.R() != 0.0) {
          connection *= (absRadius() / connection.R());
        }
        connection += center();
        return connection;
      }

      ROOT::Math::XYVector perigee() const
      {
        ROOT::Math::XYVector connection = center();
        if (connection.R() != 0.0) {
          connection *= (-absRadius() / connection.R());
        }
        connection += center();
        return connection;
      }

      ROOT::Math::XYVector tangential() const
      {
        return VectorUtil::unit(tangential(ROOT::Math::XYVector(0.0, 0.0)));
      }

      double tangentialPhi() const
      {
        return tangential().Phi();
      }

      ROOT::Math::XYVector gradient(const ROOT::Math::XYVector& point) const
      {
        ROOT::Math::XYVector connection = (point - center()) * orientation();
        return VectorUtil::unit(connection);
      }

      ROOT::Math::XYVector normal(const ROOT::Math::XYVector& point) const
      {
        return VectorUtil::unit(gradient(point));
      }

      ROOT::Math::XYVector tangential(const ROOT::Math::XYVector& point) const
      {
        return VectorUtil::Orthogonal(normal(point));
      }

      double openingAngle(const ROOT::Math::XYVector& from, const ROOT::Math::XYVector& to) const
      {
        return ROOT::Math::VectorUtil::DeltaPhi(gradient(from), gradient(to));
      } // can be optimized in the number of computations

      double arcLengthBetween(const ROOT::Math::XYVector& from, const ROOT::Math::XYVector& to) const
      {
        return openingAngle(from, to) * radius();
      }

      double radius() const
      {
        return m_radius;
      }

      double radiusSquared() const
      {
        return radius() * radius();
      }

      double absRadius() const
      {
        return fabs(radius());
      }

      ERotation orientation() const
      {
        return static_cast<ERotation>(sign(radius()));
      }

      ROOT::Math::XYVector center() const
      {
        return m_center;
      }

      void moveBy(const ROOT::Math::XYVector& by)
      {
        m_center += by;
      }

      void moveAlongFirst(const double first)
      {
        m_center.SetX(m_center.X() + first);
      }

      void moveAlongSecond(const double second)
      {
        m_center.SetY(m_center.Y() + second);
      }

      void passiveMoveBy(const ROOT::Math::XYVector& by)
      {
        m_center -= by;
      }

      void passiveMoveAlongFirst(const double first)
      {
        m_center.SetX(m_center.X() - first);
      }

      void passiveMoveAlongSecond(const double second)
      {
        m_center.SetY(m_center.Y() - second);
      }

 
    private:
      ROOT::Math::XYVector m_center;

      double m_radius;
 
    };
  }
}