CKFResult.h

/**************************************************************************
 * BASF2 (Belle Analysis Framework 2)                                     *
 * Copyright(C) 2017 - Belle II Collaboration                             *
 *                                                                        *
 * Author: The Belle II Collaboration                                     *
 * Contributors:  Nils Braun                                              *
 *                                                                        *
 * This software is provided "as is" without any warranty.                *
 **************************************************************************/
#pragma once
 
#include <tracking/trackFindingCDC/numerics/WithWeight.h>
 
#include <genfit/MeasuredStateOnPlane.h>
#include <TVector3.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();
      }
    }
 
    const std::vector<const AHit*>& getHits() const
    {
      return m_hits;
    }
 
    const ASeed* getSeed() const
    {
      return m_seed;
    }
 
    double getChi2() const
    {
      return m_chi2;
    }
 
    double getMaximalChi2() const
    {
      return m_maximalChi2;
    }
 
    double getMinimalChi2() const
    {
      return m_minimalChi2;
    }
 
    const TVector3& getPosition() const
    {
      return m_trackPosition;
    }
 
    const TVector3& getMomentum() const
    {
      return m_trackMomentum;
    }
 
    short getCharge() const
    {
      return m_trackCharge;
    }
 
    double getWeightSum() const
    {
      return m_weightSum;
    }
 
    const genfit::MeasuredStateOnPlane& getSeedMSoP() const
    {
      return m_seedMSoP;
    }
 
    const genfit::MeasuredStateOnPlane& getMSoP() const
    {
      return m_mSoP;
    }
 
  private:
    const ASeed* m_seed;
    std::vector<const AHit*> m_hits;
    double m_chi2 = 0;
    double m_maximalChi2 = NAN;
    double m_minimalChi2 = NAN;
    TVector3 m_trackPosition;
    TVector3 m_trackMomentum;
    short m_trackCharge = 0;
    TrackFindingCDC::Weight m_weightSum = 0;
    genfit::MeasuredStateOnPlane m_seedMSoP;
    genfit::MeasuredStateOnPlane m_mSoP;
  };
}