KfVertex.h

Go to the documentation of this file.

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

 
#ifndef KF_CORE_KfVertex_h
#define KF_CORE_KfVertex_h 1
 
#include "KfDefs.h"
#include "KfMath.h"
#include "KfMatrixSym.h"
#include "KfUtils.h"
 
#include <boost/serialization/access.hpp>
 
#include <iomanip>
#include <sstream>
#include <string>
 
#if !defined(NO_ROOT) && !XPU_IS_HIP_CUDA
#include <Rtypes.h>  // for ClassDef
#endif
 
namespace cbm::algo::kf
{
  template<typename T = double>
  class Vertex {
 
   public:
    static constexpr int kNofParameters{4};  
 
    using Parameters_t = std::array<T, kNofParameters>;  
    using CovMatrix_t  = MatrixSym<T, kNofParameters>;   
 
    static constexpr int kNofCovParameters{CovMatrix_t::kNofElements};  
 

    Vertex() = default;

    ~Vertex() = default;

 
    T X() const { return fParameters[0]; }             
    T Y() const { return fParameters[1]; }             
    T Z() const { return fParameters[2]; }             
    T Time() const { return fParameters[3]; }          
    T ChiSq() const { return fChiSq; }                 
    int32_t Ndf() const { return fNdf; }               
    T ChiSqTime() const { return fChiSqTime; }         
    int32_t NdfTime() const { return fNdfTime; }       
    int32_t NofTracks() const { return fNofTracks; };  
 
    T GetX() const { return fParameters[0]; }                          
    T GetY() const { return fParameters[1]; }                          
    T GetZ() const { return fParameters[2]; }                          
    T GetTime() const { return fParameters[3]; }                       
    T GetChiSq() const { return fChiSq; }                              
    int32_t GetNdf() const { return fNdf; }                            
    T GetChiSqTime() const { return fChiSqTime; }                      
    int32_t GetNdfTime() const { return fNdfTime; }                    
    int32_t GetNofTracks() const { return fNofTracks; };               
    const Parameters_t& GetParameters() const { return fParameters; }  
    const CovMatrix_t& GetCovMatrix() const { return fCovMatrix; }     
 

 
    T& X() { return fParameters[0]; }                   
    T& Y() { return fParameters[1]; }                   
    T& Z() { return fParameters[2]; }                   
    T& Time() { return fParameters[3]; }                
    T& ChiSq() { return fChiSq; }                       
    int32_t& Ndf() { return fNdf; }                     
    T& ChiSqTime() { return fChiSqTime; }               
    int32_t& NdfTime() { return fNdfTime; }             
    int32_t& NofTracks() { return fNofTracks; };        
    Parameters_t& Parameters() { return fParameters; }  
    CovMatrix_t& CovMatrix() { return fCovMatrix; }     

 
    void SetParameters(const Parameters_t& params) { fParameters = params; }  
    void SetCovMatrix(const CovMatrix_t& val) { fCovMatrix = val; }           
 
    void SetX(T v) { fParameters[0] = v; }             
    void SetY(T v) { fParameters[1] = v; }             
    void SetZ(T v) { fParameters[2] = v; }             
    void SetTime(T v) { fParameters[3] = v; }          
    void SetChiSq(T v) { fChiSq = v; }                 
    void SetNdf(int32_t v) { fNdf = v; }               
    void SetChiSqTime(T v) { fChiSqTime = v; }         
    void SetNdfTime(int32_t v) { fNdfTime = v; }       
    void SetNofTracks(int32_t v) { fNofTracks = v; };  


    void ResetErrors(T c00, T c11, T c22, T c33);

    std::string ToString() const;

    bool IsFinite() const { return IsFinite<DoPrintDebug::N>(nullptr); }

    bool IsConsistent() const { return IsConsistent<DoPrintDebug::N>(nullptr); }
 

    template<DoPrintDebug FlagPrintDebug = DoPrintDebug::Y>
    bool IsFinite(std::stringstream* ss) const;

    template<DoPrintDebug FlagPrintDebug = DoPrintDebug::Y>
    bool IsConsistent(std::stringstream* ss) const;
 

    template<class Archive>
    void serialize(Archive& ar, const unsigned int /*version*/)
    {
      ar& fParameters;
      ar& fCovMatrix;
      ar& fChiSq;
      ar& fNdf;
      ar& fChiSqTime;
      ar& fNdfTime;
      ar& fNofTracks;
    }
 
   private:
    Parameters_t fParameters{0., 0., 0., 0.};  
    CovMatrix_t fCovMatrix;                    
    T fChiSq{0.};                              
    T fChiSqTime{0.};                          
    int32_t fNdf{-3};                          
    int32_t fNdfTime{-1};                      
    int32_t fNofTracks{0};                     // number of tracks used for vertex fit
 
 
#if !defined(NO_ROOT) && !XPU_IS_HIP_CUDA
    ClassDefNV(Vertex, 1);
#endif
  };  // class Vertex
 
  using VertexS = Vertex<fscal>;
  using VertexD = Vertex<double>;
  using VertexF = Vertex<float>;
 
 
  template<typename T>
  inline void Vertex<T>::ResetErrors(T c00, T c11, T c22, T c33)
  {
    fCovMatrix.Reset(c00, c11, c22, c33);
    fChiSq     = 0.;
    fNdf       = -3;
    fChiSqTime = 0.;
    fNdfTime   = -1;
    fNofTracks = 0;
  }
 
  template<typename T>
  template<DoPrintDebug FlagPrintDebug>
  inline bool Vertex<T>::IsFinite(std::stringstream* ss) const
  {
    // verify that all the numbers in the object are valid floats
    bool ret = true;
 
    auto check = [&](const std::string& s, T val) {
      if (!utils::IsFinite(val)) {
        ret = false;
        if (FlagPrintDebug == DoPrintDebug::Y) {
          if (ss) {
            (*ss) << " Vertex parameter " << s << " is undefined: " << val << std::endl;
          }
        }
      }
    };
 
    check("x", X());
    check("y", Y());
    check("z", Z());
    check("t", T());
    check("chi2", ChiSq());
    check("ndf", Ndf());
    check("chi2time", ChiSqTime());
    check("ndfTime", NdfTime());
    check("nofTracks", static_cast<T>(NofTracks()));
    ret = ret && fCovMatrix.template IsFinite<FlagPrintDebug>(ss);
 
    return ret;
  }
 
 
  template<typename T>
  template<DoPrintDebug FlagPrintDebug>
  inline bool Vertex<T>::IsConsistent(std::stringstream* ss) const
  {
    // verify that all the numbers in the object are valid floats
 
    bool ok = IsFinite<FlagPrintDebug>(ss) && fCovMatrix.template IsConsistent<FlagPrintDebug>(ss);
    if (ok) {
      if ((Ndf() < -3) || (NdfTime() < -1) || (NofTracks() < 0) || (ChiSq() < 0.) || (ChiSqTime() < 0.)) {
        ok = false;
        if (FlagPrintDebug == DoPrintDebug::Y) {
          if (ss) {
            (*ss) << " Vertex: invalid chi2/ndf or nofTracks values: "
                  << " chi2=" << ChiSq() << ", ndf=" << Ndf() << ", chi2time=" << ChiSqTime()
                  << ", ndfTime=" << NdfTime() << ", nofTracks=" << NofTracks() << std::endl;
          }
        }
      }
    }
    return ok;
  }  // bool Vertex<T>::IsConsistent
 
}  // namespace cbm::algo::kf
 
 
#endif