KfMeasurementXy.h

Go to the documentation of this file.

/* Copyright (C) 2007-2022 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Sergey Gorbunov [committer], Sergei Zharko */

 
#pragma once  // include this header only once per compilation unit
 
 
#include "KfDefs.h"
#include "KfUtils.h"
 
#include <boost/serialization/access.hpp>
 
#include <string>
 
namespace cbm::algo::kf
{
  template<typename DataT>
  class alignas(VcMemAlign) MeasurementXy {
   public:
    friend class boost::serialization::access;

    MeasurementXy() = default;

    MeasurementXy(DataT x, DataT y, DataT dx2, DataT dy2, DataT dxy, DataT ndfX, DataT ndfY)
      : fX(x)
      , fY(y)
      , fDx2(dx2)
      , fDy2(dy2)
      , fDxy(dxy)
      , fNdfX(ndfX)
      , fNdfY(ndfY)
    {
    }
 

    template<typename DataTb>
    void Set(const MeasurementXy<DataTb>& m)
    {
      CopyBase<DataTb, true, true>(0, m, 0);
    }

    void Set(const MeasurementXy<fvec>& m, const int im) { CopyBase<fvec, true, false>(0, m, im); }

    template<typename DataTb>
    void SetOneEntry(const int i, const MeasurementXy<DataTb>& m)
    {
      CopyBase<DataTb, false, true>(i, m, 0);
    }

    void SetOneEntry(const int i, const MeasurementXy<fvec>& m, const int im)
    {
      CopyBase<fvec, false, false>(i, m, im);
    }
 

 
    void SetX(DataT x) { fX = x; }
    void SetY(DataT y) { fY = y; }
    void SetDx2(DataT dx2) { fDx2 = dx2; }
    void SetDy2(DataT dy2) { fDy2 = dy2; }
    void SetDxy(DataT dxy) { fDxy = dxy; }
    void SetNdfX(DataT ndfX) { fNdfX = ndfX; }
    void SetNdfY(DataT ndfY) { fNdfY = ndfY; }
    void SetCov(DataT dx2, DataT dxy, DataT dy2)
    {
      fDx2 = dx2;
      fDxy = dxy;
      fDy2 = dy2;
    }
 
    DataT X() const { return fX; }
    DataT Y() const { return fY; }
    DataT Dx2() const { return fDx2; }
    DataT Dy2() const { return fDy2; }
    DataT Dxy() const { return fDxy; }
    DataT NdfX() const { return fNdfX; }
    DataT NdfY() const { return fNdfY; }

 
    DataT& X() { return fX; }
    DataT& Y() { return fY; }
    DataT& Dx2() { return fDx2; }
    DataT& Dy2() { return fDy2; }
    DataT& Dxy() { return fDxy; }
    DataT& NdfX() { return fNdfX; }
    DataT& NdfY() { return fNdfY; }


    std::string ToString(int indentLevel = 0) const;

    bool IsFinite() const
    {
      return (utils::IsFinite(X()) && utils::IsFinite(Y()) && utils::IsFinite(Dx2()) && utils::IsFinite(Dy2())
              && utils::IsFinite(Dxy()) && utils::IsFinite(NdfX()) && utils::IsFinite(NdfY()));
    }

    bool IsUndefined() const
    {
      return (utils::IsUndefined(X()) || utils::IsUndefined(Y()) || utils::IsUndefined(Dx2())
              || utils::IsUndefined(Dy2()) || utils::IsUndefined(Dxy()) || utils::IsUndefined(NdfX())
              || utils::IsUndefined(NdfY()));
    }

    friend class boost::serialization::access;
    template<class Archive>
    void serialize(Archive& ar, const unsigned int)
    {
      ar& fX;
      ar& fY;
      ar& fDx2;
      ar& fDy2;
      ar& fDxy;
      ar& fNdfX;
      ar& fNdfY;
    }
 
   private:
    template<typename TdataB, bool TDoAllA, bool TDoAllB>
    void CopyBase(const int ia, const MeasurementXy<TdataB>& Tb, const int ib);
 
   private:
 
    // Initializing parameters with NANs spoils the track fit where
    // the masked-out SIMD entries are suppressed by a multication by 0.
    // Therefore, we initialize the data members here with finite numbers.
    // For the numerical safety, with some reasonable numbers.
 
    DataT fX{0.};    
    DataT fY{0.};    
    DataT fDx2{1.};  
    DataT fDy2{1.};  
    DataT fDxy{0.};  

 
    DataT fNdfX = 0.;  
    DataT fNdfY = 0.;  
 
  } _fvecalignment;
 
 
  // ---------------------------------------------------------------------------------------------------------------------
  //
  template<typename TdataA>
  template<typename TdataB, bool TDoAllA, bool TDoAllB>
  inline void MeasurementXy<TdataA>::CopyBase(const int ia, const MeasurementXy<TdataB>& Tb, const int ib)
  {
    auto copy = [&](TdataA& a, const TdataB& b) {
      utils::VecCopy<TdataA, TdataB, TDoAllA, TDoAllB>::CopyEntries(a, ia, b, ib);
    };
 
    copy(fX, Tb.X());
    copy(fY, Tb.Y());
    copy(fDx2, Tb.Dx2());
    copy(fDy2, Tb.Dy2());
    copy(fDxy, Tb.Dxy());
    copy(fNdfX, Tb.NdfX());
    copy(fNdfY, Tb.NdfY());
  }  // CopyBase
 
}  // namespace cbm::algo::kf