CKFState.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/ca/AutomatonCell.h>
 
#include <genfit/MeasuredStateOnPlane.h>
#include <framework/logging/Logger.h>
 
#include <vxd/dataobjects/VxdID.h>
 
namespace Belle2 {
  template<class ASeed, class AHit>
  class CKFState {
  public:
    using Seed = ASeed;
    using Hit = AHit;
 
    CKFState() = default;
    CKFState(CKFState&&) = default;
    CKFState(const CKFState&) = delete;
    CKFState& operator=(const CKFState&) = delete;
    CKFState& operator=(CKFState&&) = default;
    ~CKFState() = default;
 
    explicit CKFState(const Seed* seed) : m_seed(seed)
    {
    }
 
    explicit CKFState(const Hit* hit) : m_hit(hit)
    {
    }
 
    const Seed* getSeed() const
    {
      return m_seed;
    }
 
    const Hit* getHit() const
    {
      return m_hit;
    }
 
    double getChi2() const
    {
      B2ASSERT("Chi2 is not set", isFitted());
      return m_chi2;
    }
 
    void setChi2(double chi2)
    {
      m_chi2 = chi2;
      m_isFitted = true;
    }
 
    void setMeasuredStateOnPlane(const genfit::MeasuredStateOnPlane& mSoP)
    {
      m_measuredStateOnPlane = mSoP;
      m_hasMSoP = true;
    }
 
    const genfit::MeasuredStateOnPlane& getMeasuredStateOnPlane() const
    {
      B2ASSERT("You are asking for an invalid variable!", mSoPSet());
      return m_measuredStateOnPlane;
    }
 
    bool isFitted() const
    {
      return m_isFitted;
    }
 
    bool mSoPSet() const
    {
      return m_hasMSoP;
    }
 
    void reset()
    {
      m_isFitted = false;
      m_hasMSoP = false;
    }
 
    TrackFindingCDC::AutomatonCell& getAutomatonCell()
    {
      return m_automatonCell;
    }
 
    struct stateCache {
      float ptSeed = 0.;
      float thetaSeed = 0.;
      float sensorCenterPhi = std::numeric_limits<float>::quiet_NaN();
      float phi = std::numeric_limits<float>::quiet_NaN();
      float theta = std::numeric_limits<float>::quiet_NaN();
      float perp = std::numeric_limits<float>::quiet_NaN();
      float localNormalizedu = std::numeric_limits<float>::quiet_NaN();
      float localNormalizedv = std::numeric_limits<float>::quiet_NaN();
      unsigned short geoLayer = std::numeric_limits<unsigned short>::quiet_NaN();
      unsigned short ladder = std::numeric_limits<unsigned short>::quiet_NaN();
      VxdID sensorID = VxdID(0);
      bool isHitState = false;
    };
 
  protected:
    stateCache m_stateCache;
 
 
  private:
    const Seed* m_seed = nullptr;
    const Hit* m_hit = nullptr;
    double m_chi2 = 0;
    genfit::MeasuredStateOnPlane m_measuredStateOnPlane;
    TrackFindingCDC::AutomatonCell m_automatonCell;
    bool m_isFitted = false;
    bool m_hasMSoP = false;
  };
}