CKFResult.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/trackFindingCDC/numerics/WithWeight.h>
 
#include <genfit/MeasuredStateOnPlane.h>
#include <Math/Vector3D.h>
 
#include <vector>
 
namespace Belle2 {
  template <class ASeed, class AHit>
  class CKFResult {
 
  public:
    using Seed = ASeed;
    using Hit = AHit;

    template <class AState>
    CKFResult(const std::vector<TrackFindingCDC::WithWeight<const AState*>>& path, const genfit::MeasuredStateOnPlane& mSoP)
      : m_seed(path.front()->getSeed()),
        m_trackPosition(mSoP.getPos()),
        m_trackMomentum(mSoP.getMom()),
        m_trackCharge(static_cast<short>(mSoP.getCharge())),
        m_seedMSoP(path.front()->getMeasuredStateOnPlane()),
        m_mSoP(mSoP)
    {
      m_hits.reserve(path.size());
 
      for (const TrackFindingCDC::WithWeight<const AState*> state : path) {
        const Hit* hit = state->getHit();
        if (hit) {
          m_hits.push_back(hit);
        }
 
        if (state->isFitted()) {
          const double stateChi2 = state->getChi2();
          m_chi2 += stateChi2;
 
          // The initial value of the maximal and minimal chi2 is NAN, so we always override this default value.
          if (stateChi2 > m_maximalChi2 or std::isnan(m_maximalChi2)) {
            m_maximalChi2 = stateChi2;
          }
 
          if (stateChi2 < m_minimalChi2 or std::isnan(m_minimalChi2)) {
            m_minimalChi2 = stateChi2;
          }
        }
 
        m_weightSum += state.getWeight();
      }
    }
    CKFResult(const std::vector<TrackFindingCDC::WithWeight<const AState*>>& path, const genfit::MeasuredStateOnPlane& mSoP) {…}

    const std::vector<const AHit*>& getHits() const
    {
      return m_hits;
    }
    const std::vector<const AHit*>& getHits() const {…}

    const ASeed* getSeed() const
    {
      return m_seed;
    }
    const ASeed* getSeed() const {…}

    double getChi2() const
    {
      return m_chi2;
    }
    double getChi2() const {…}

    double getMaximalChi2() const
    {
      return m_maximalChi2;
    }
    double getMaximalChi2() const {…}

    double getMinimalChi2() const
    {
      return m_minimalChi2;
    }
    double getMinimalChi2() const {…}

    const ROOT::Math::XYZVector& getPosition() const
    {
      return m_trackPosition;
    }
    const ROOT::Math::XYZVector& getPosition() const {…}

    const ROOT::Math::XYZVector& getMomentum() const
    {
      return m_trackMomentum;
    }
    const ROOT::Math::XYZVector& getMomentum() const {…}

    short getCharge() const
    {
      return m_trackCharge;
    }
    short getCharge() const {…}

    double getWeightSum() const
    {
      return m_weightSum;
    }
    double getWeightSum() const {…}

    const genfit::MeasuredStateOnPlane& getSeedMSoP() const
    {
      return m_seedMSoP;
    }
    const genfit::MeasuredStateOnPlane& getSeedMSoP() const {…}

    const genfit::MeasuredStateOnPlane& getMSoP() const
    {
      return m_mSoP;
    }
    const genfit::MeasuredStateOnPlane& getMSoP() const {…}
 
  private:
    const ASeed* m_seed;
    std::vector<const AHit*> m_hits;
    double m_chi2 = 0;
    double m_maximalChi2 = NAN;
    double m_minimalChi2 = NAN;
    ROOT::Math::XYZVector m_trackPosition;
    ROOT::Math::XYZVector m_trackMomentum;
    short m_trackCharge = 0;
    TrackFindingCDC::Weight m_weightSum = 0;
    genfit::MeasuredStateOnPlane m_seedMSoP;
    genfit::MeasuredStateOnPlane m_mSoP;
  };
  class CKFResult {…};

}