UncertainParameterLine2D.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2016 - 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/LineParameters.h>
#include <tracking/trackFindingCDC/geometry/ParameterLine2D.h>
#include <tracking/trackFindingCDC/geometry/Vector2D.h>
#include <cstddef>
 
namespace Belle2 {
  namespace TrackFindingCDC {
 
    class UncertainParameterLine2D {
 
    public:
      UncertainParameterLine2D()
      {
      }
 
      explicit UncertainParameterLine2D(const ParameterLine2D& parameterLine2D,
                                        const LineCovariance& lineCovariance = LineUtil::identity(),
                                        const double chi2 = 0.0,
                                        const size_t ndf = 0)
        : m_parameterLine2D(parameterLine2D)
        , m_lineCovariance(lineCovariance)
        , m_chi2(chi2)
        , m_ndf(ndf)
      {
      }
 
      const ParameterLine2D* operator->() const
      {
        return &m_parameterLine2D;
      }
 
      operator ParameterLine2D() const
      {
        return m_parameterLine2D;
      }
 
    public:
      LineParameters lineParameters() const
      {
        using namespace NLineParameterIndices;
        LineParameters result;
        result(c_Phi0) = m_parameterLine2D.tangential().phi();
        result(c_I) = 0;
        return result;
      }
 
      void setLineCovariance(const LineCovariance& lineCovariance)
      {
        m_lineCovariance = lineCovariance;
      }
 
      const LineCovariance& lineCovariance() const
      {
        return m_lineCovariance;
      }
 
      double covariance(const ELineParameter& iRow, const ELineParameter& iCol) const
      {
        return lineCovariance()(iRow, iCol);
      }
 
      double variance(const ELineParameter& i) const
      {
        return lineCovariance()(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_parameterLine2D.invalidate();
        m_lineCovariance = LineUtil::identity();
        m_chi2 = 0.0;
        m_ndf = 0;
      }
 
    public:
      void reverse()
      {
        m_parameterLine2D.reverse();
        LineUtil::reverse(m_lineCovariance);
      }
 
      UncertainParameterLine2D reversed() const
      {
        return UncertainParameterLine2D(m_parameterLine2D.reversed(),
                                        LineUtil::reversed(lineCovariance()),
                                        m_chi2,
                                        m_ndf);
      }
 
    public:
      void passiveMoveBy(const Vector2D& by)
      {
        m_parameterLine2D.passiveMoveBy(by);
      }
 
      LineJacobian moveSupportByJacobian(double byAt) const
      {
        using namespace NLineParameterIndices;
        LineJacobian result = LineUtil::identity();
        result(c_I, c_Phi0) = -byAt * m_parameterLine2D.tangential().norm();
        return result;
      }
 
      void moveSupportBy(double byAt)
      {
        // Move the covariance matrix first to have access to the original parameters
        LineJacobian jacobian = moveSupportByJacobian(byAt);
        LineUtil::transport(jacobian, m_lineCovariance);
        m_parameterLine2D.passiveMoveAtBy(byAt);
      }
 
      LineCovariance movedSupportCovarianceBy(double byAt) const
      {
        LineJacobian jacobian = moveSupportByJacobian(byAt);
        return LineUtil::transported(jacobian, lineCovariance());
      }
 
    private:
      ParameterLine2D m_parameterLine2D;
 
      LineCovariance m_lineCovariance = LineUtil::identity();
 
      double m_chi2 = 0.0;
 
      size_t m_ndf = 0;
 
    };
 
  }
}