UncertainPerigeeCircle.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2014 - 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/geometry/PerigeeCircle.h>
#include <tracking/trackFindingCDC/geometry/PerigeeParameters.h>
 
#include <cstddef>
#include <iosfwd>
 
namespace Belle2 {
  namespace TrackFindingCDC {
    class GeneralizedCircle;
    class Vector2D;
 
    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 Vector2D& 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 Vector2D& 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 Vector2D& 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);
  }
}