UncertainPerigeeCircle.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/PerigeeCircle.h>
#include <tracking/trackingUtilities/geometry/PerigeeParameters.h>
 
#include <Math/Vector2D.h>
 
#include <cstddef>
#include <iosfwd>
 
namespace Belle2 {
 
  namespace TrackingUtilities {
    class GeneralizedCircle;

    class UncertainPerigeeCircle {
 
    public:
      UncertainPerigeeCircle()
      {
      }

      UncertainPerigeeCircle(const double curvature,
                             const double phi0Vec,
                             const double impact,
                             const PerigeeCovariance& perigeeCovariance = PerigeeUtil::identity(),
                             const double chi2 = 0.0,
                             std::size_t ndf = 0)
        : m_perigeeCircle(curvature, phi0Vec, impact)
        , m_perigeeCovariance(perigeeCovariance)
        , m_chi2(chi2)
        , m_ndf(ndf)
      {
      }

      UncertainPerigeeCircle(const double curvature,
                             const ROOT::Math::XYVector& phi0,
                             const double impact,
                             const PerigeeCovariance& perigeeCovariance = PerigeeUtil::identity(),
                             const double chi2 = 0.0,
                             std::size_t ndf = 0)
        : m_perigeeCircle(curvature, phi0, impact)
        , m_perigeeCovariance(perigeeCovariance)
        , m_chi2(chi2)
        , m_ndf(ndf)
      {
      }

      explicit UncertainPerigeeCircle(const PerigeeCircle& perigeeCircle,
                                      const PerigeeCovariance& perigeeCovariance = PerigeeUtil::identity(),
                                      const double chi2 = 0.0,
                                      std::size_t ndf = 0)
        : m_perigeeCircle(perigeeCircle)
        , m_perigeeCovariance(perigeeCovariance)
        , m_chi2(chi2)
        , m_ndf(ndf)
      {
      }

      explicit UncertainPerigeeCircle(const GeneralizedCircle& generalizedCircle,
                                      const PerigeeCovariance& perigeeCovariance = PerigeeUtil::identity(),
                                      const double chi2 = 0.0,
                                      std::size_t ndf = 0)
        : m_perigeeCircle(generalizedCircle)
        , m_perigeeCovariance(perigeeCovariance)
        , m_chi2(chi2)
        , m_ndf(ndf)
      {
      }

      explicit UncertainPerigeeCircle(
        const PerigeeParameters& parameters,
        const PerigeeCovariance& perigeeCovariance = PerigeeUtil::identity(),
        const double chi2 = 0.0,
        std::size_t ndf = 0)
        : m_perigeeCircle(parameters)
        , m_perigeeCovariance(perigeeCovariance)
        , m_chi2(chi2)
        , m_ndf(ndf)
      {
      }

      static UncertainPerigeeCircle average(const UncertainPerigeeCircle& fromPerigeeCircle,
                                            const UncertainPerigeeCircle& toPerigeeCircle);
 
    public:
      const PerigeeCircle* operator->() const
      {
        return &m_perigeeCircle;
      }

      operator const PerigeeCircle& () const
      {
        return m_perigeeCircle;
      }

      const PerigeeCircle& perigeeCircle() const
      {
        return m_perigeeCircle;
      }

      PerigeeParameters perigeeParameters() const
      {
        return m_perigeeCircle.perigeeParameters();
      }
 
    public:
      void setPerigeeCovariance(const PerigeeCovariance& perigeeCovariance)
      {
        m_perigeeCovariance = perigeeCovariance;
      }

      const PerigeeCovariance& perigeeCovariance() const
      {
        return m_perigeeCovariance;
      }

      double covariance(const EPerigeeParameter& iRow, const EPerigeeParameter& iCol) const
      {
        return perigeeCovariance()(iRow, iCol);
      }

      double variance(const EPerigeeParameter& i) const
      {
        return perigeeCovariance()(i, i);
      }

      double chi2() const
      {
        return m_chi2;
      }

      void setChi2(const double chi2)
      {
        m_chi2 = chi2;
      }

      std::size_t ndf() const
      {
        return m_ndf;
      }

      void setNDF(std::size_t ndf)
      {
        m_ndf = ndf;
      }

      void invalidate()
      {
        m_perigeeCircle.invalidate();
        m_perigeeCovariance = PerigeeUtil::identity();
        m_chi2 = 0.0;
      }
 
    public:
      void reverse()
      {
        m_perigeeCircle.reverse();
        PerigeeUtil::reverse(m_perigeeCovariance);
      }

      UncertainPerigeeCircle reversed() const
      {
        return UncertainPerigeeCircle(m_perigeeCircle.reversed(),
                                      PerigeeUtil::reversed(perigeeCovariance()),
                                      chi2(),
                                      ndf());
      }
 
    public:
      void passiveMoveBy(const ROOT::Math::XYVector& by)
      {
        // Move the covariance matrix first to have access to the original parameters
        PerigeeJacobian jacobian = m_perigeeCircle.passiveMoveByJacobian(by);
        PerigeeUtil::transport(jacobian, m_perigeeCovariance);
        m_perigeeCircle.passiveMoveBy(by);
      }

      PerigeeCovariance passiveMovedCovarianceBy(const ROOT::Math::XYVector& by) const
      {
        PerigeeJacobian jacobian = m_perigeeCircle.passiveMoveByJacobian(by);
        return PerigeeUtil::transported(jacobian, perigeeCovariance());
      }
 
    private:
      PerigeeCircle m_perigeeCircle;

      PerigeeCovariance m_perigeeCovariance = PerigeeUtil::identity();

      double m_chi2 = 0.0;

      size_t m_ndf = 0.0;
 
    };

    std::ostream& operator<<(std::ostream& output, const UncertainPerigeeCircle& circle);
  }
}