CDCTrajectory2D.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2012 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors: Oliver Frost                                             *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
 
#include <tracking/trackFindingCDC/topology/ISuperLayer.h>
 
#include <tracking/trackFindingCDC/geometry/UncertainPerigeeCircle.h>
#include <tracking/trackFindingCDC/geometry/PerigeeCircle.h>
#include <tracking/trackFindingCDC/geometry/PerigeeParameters.h>
#include <tracking/trackFindingCDC/geometry/Vector3D.h>
#include <tracking/trackFindingCDC/geometry/Vector2D.h>
 
#include <tracking/trackFindingCDC/numerics/EForwardBackward.h>
#include <tracking/trackFindingCDC/numerics/ERightLeft.h>
#include <tracking/trackFindingCDC/numerics/ESign.h>
 
#include <TMath.h>
#include <cmath>
#include <cstddef>
#include <iosfwd>
 
namespace Belle2 {
  namespace TrackFindingCDC {
    class WireLine;
 
    class CDCTrajectory2D  {
 
    public:
      CDCTrajectory2D();
 
      explicit CDCTrajectory2D(const UncertainPerigeeCircle& perigeeCircle);
 
      CDCTrajectory2D(const Vector2D& localOrigin,
                      const UncertainPerigeeCircle& localPerigeeCircle,
                      double flightTime = NAN);
 
      CDCTrajectory2D(const Vector2D& pos2D,
                      double time,
                      const Vector2D& mom2D,
                      double charge,
                      double bZ);
 
      CDCTrajectory2D(const Vector2D& pos2D, double time, const Vector2D& mom2D, double charge);
 
    public:
      bool isFitted() const;
 
      void clear();
 
    public:
      void reverse();
 
      CDCTrajectory2D reversed() const;
 
    public:
      std::array<double, 2> reconstructBothZ(const WireLine& wireLine, double distance = 0.0, double z = 0) const;
 
      double reconstructZ(const WireLine& wireLine, double distance = 0.0, double z = 0) const;
 
      std::array<Vector3D, 2> reconstructBoth3D(const WireLine& wireLine, double distance = 0.0, double z = 0) const;
 
      Vector3D reconstruct3D(const WireLine& wireLine, double distance = 0.0, double z = 0) const;
 
      Vector2D getClosest(const Vector2D& point) const;
 
    private:
      ISuperLayer getISuperLayerAfter(ISuperLayer iSuperLayer, bool movingOutward) const;
 
      ISuperLayer getISuperLayerAfterStart(bool movingOutward) const;
 
      ISuperLayer getISuperLayerAfterStart(EForwardBackward forwardBackwardInfo) const;
 
      ISuperLayer getAxialISuperLayerAfterStart(EForwardBackward forwardBackwardInfo) const;
 
    public:
      ISuperLayer getNextISuperLayer() const;
 
      ISuperLayer getPreviousISuperLayer() const;
 
      ISuperLayer getNextAxialISuperLayer() const;
 
      ISuperLayer getPreviousAxialISuperLayer() const;
 
      ISuperLayer getMaximalISuperLayer() const;
 
      ISuperLayer getStartISuperLayer() const;
 
      ISuperLayer getMinimalISuperLayer() const;
 
    public:
      template <class AHits>
      EForwardBackward isForwardOrBackwardTo(const AHits& hits) const
      {
        return static_cast<EForwardBackward>(sign(getTotalArcLength2D(hits)));
      }
 
      template <class AFromHits, class AToHits>
      double getArcLength2DGap(const AFromHits& fromHits, const AToHits& toHits) const
      {
        const Vector2D& fromRecoPos2D = fromHits.back().getRecoPos2D();
        const Vector2D& toRecoPos2D = toHits.front().getRecoPos2D();
        return calcArcLength2DBetween(fromRecoPos2D, toRecoPos2D);
      }
 
      template <class AFromHits, class AToHits>
      double getArcLength2DFrontOffset(const AFromHits& fromHits, const AToHits& toHits) const
      {
        const Vector2D& fromRecoPos2D = fromHits.front().getRecoPos2D();
        const Vector2D& toRecoPos2D = toHits.front().getRecoPos2D();
        return calcArcLength2DBetween(fromRecoPos2D, toRecoPos2D);
      }
 
      template <class AFromHits, class AToHits>
      double getArcLength2DBackOffset(const AFromHits& fromHits, const AToHits& toHits) const
      {
        const Vector2D& fromRecoPos2D = fromHits.back().getRecoPos2D();
        const Vector2D& toRecoPos2D = toHits.back().getRecoPos2D();
        return calcArcLength2DBetween(fromRecoPos2D, toRecoPos2D);
      }
 
      template <class AHits>
      double getTotalArcLength2D(const AHits& hits) const
      {
        Vector2D frontRecoPos2D = hits.front().getRecoPos2D();
        Vector2D backRecoPos2D = hits.back().getRecoPos2D();
        return calcArcLength2DBetween(frontRecoPos2D, backRecoPos2D);
      }
 
      double calcArcLength2D(const Vector2D& point) const
      {
        return getLocalCircle()->arcLengthBetween(Vector2D(0.0, 0.0), point - getLocalOrigin());
      }
 
      double calcArcLength2DBetween(const Vector2D& fromPoint, const Vector2D& toPoint) const
      {
        return getLocalCircle()->arcLengthBetween(fromPoint - getLocalOrigin(),
                                                  toPoint - getLocalOrigin());
      }
      double getArcLength2DPeriod() const
      {
        return getLocalCircle()->arcLengthPeriod();
      }
 
    public:
      void setPosMom2D(const Vector2D& pos2D, const Vector2D& mom2D, double charge);
 
      ESign getChargeSign() const;
 
      double getAbsMom2D(double bZ) const;
 
      double getAbsMom2D() const;
 
      Vector2D getMom2DAtSupport(const double bZ) const
      {
        return getFlightDirection2DAtSupport() *= getAbsMom2D(bZ);
      }
 
      Vector2D getMom2DAtSupport() const
      {
        return getFlightDirection2DAtSupport() *= getAbsMom2D();
      }
 
      Vector2D getFlightDirection2D(const Vector2D& point) const
      {
        return getLocalCircle()->tangential(point - getLocalOrigin());
      }
 
      Vector2D getFlightDirection2DAtSupport() const
      {
        return getLocalCircle()->tangential();
      }
 
      bool isMovingOutward() const
      {
        return getFlightDirection2DAtSupport().dot(getSupport()) > 0;
      }
 
      Vector2D getPos2DAtArcLength2D(double arcLength2D)
      {
        return getLocalOrigin() + getLocalCircle()->atArcLength(arcLength2D);
      }
 
      Vector2D getSupport() const
      {
        return getLocalCircle()->perigee() + getLocalOrigin();
      }
 
      Vector2D getGlobalPerigee() const
      {
        return getLocalCircle()->closest(-m_localOrigin) + m_localOrigin;
      }
 
      Vector2D getGlobalCenter() const
      {
        return getLocalCircle()->center() + m_localOrigin;
      }
 
      Vector2D getOuterExit(double factor = 1) const;
 
      Vector2D getInnerExit() const;
 
      Vector2D getExit() const;
 
      bool isCurler(double factor = 1) const;
 
      bool isOriginer(double factor = 1) const;
 
      double getMaximalCylindricalR() const
      {
        return std::fabs(getGlobalImpact() + 2 * getLocalCircle()->radius());
      }
 
      double getMinimalCylindricalR() const
      {
        return std::fabs(getGlobalImpact());
      }
 
      double getGlobalImpact() const
      {
        return getLocalCircle()->distance(-m_localOrigin);
      }
 
      double getDist2D(const Vector2D& point) const
      {
        return getLocalCircle()->distance(point - getLocalOrigin());
      }
 
      ERightLeft isRightOrLeft(const Vector2D& point) const
      {
        return getLocalCircle()->isRightOrLeft(point - getLocalOrigin());
      }
 
    public:
      double getCurvature() const
      {
        return getLocalCircle()->curvature();
      }
 
      double getLocalCovariance(EPerigeeParameter iRow, EPerigeeParameter iCol) const
      {
        return getLocalCircle().covariance(iRow, iCol);
      }
 
      double getLocalVariance(EPerigeeParameter i) const
      {
        return getLocalCircle().variance(i);
      }
 
      PerigeeCircle getGlobalCircle() const
      {
        PerigeeCircle result = getLocalCircle();
        result.passiveMoveBy(-getLocalOrigin());
        return result;
      }
 
      void setGlobalCircle(const UncertainPerigeeCircle& perigeeCircle)
      {
        m_localPerigeeCircle = perigeeCircle;
        m_localPerigeeCircle.passiveMoveBy(getLocalOrigin());
      }
 
      const UncertainPerigeeCircle& getLocalCircle() const
      {
        return m_localPerigeeCircle;
      }
 
      double getPValue() const
      {
        return TMath::Prob(getChi2(), getNDF());
      }
 
      double getChi2() const
      {
        return getLocalCircle().chi2();
      }
 
      void setChi2(const double chi2)
      {
        return m_localPerigeeCircle.setChi2(chi2);
      }
 
      size_t getNDF() const
      {
        return getLocalCircle().ndf();
      }
 
      void setNDF(std::size_t ndf)
      {
        return m_localPerigeeCircle.setNDF(ndf);
      }
 
      void setLocalCircle(const UncertainPerigeeCircle& localPerigeeCircle)
      {
        m_localPerigeeCircle = localPerigeeCircle;
      }
 
      const Vector2D& getLocalOrigin() const
      {
        return m_localOrigin;
      }
 
      double setLocalOrigin(const Vector2D& localOrigin);
 
      double getFlightTime() const
      {
        return m_flightTime;
      }
 
      void setFlightTime(double flightTime)
      {
        m_flightTime = flightTime;
      }
 
    private:
      Vector2D m_localOrigin;
 
      UncertainPerigeeCircle m_localPerigeeCircle;
 
      double m_flightTime = NAN;
    };
 
    std::ostream& operator<<(std::ostream& output, const CDCTrajectory2D& trajectory2D);
  }
}