CbmQaOnlineInterface.h

Go to the documentation of this file.

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

 
// TODO: move to more suitable place (histoserv, for example)
 
#pragma once
 
#include "Logger.h"
#include "TH1D.h"
#include "TH2D.h"
#include "TProfile.h"
#include "TProfile2D.h"
#include "algo/qa/Histogram.h"
 
//#include <log.hpp>
#include <type_traits>
 
namespace
{
  using cbm::algo::qa::H1D;
  using cbm::algo::qa::H2D;
  using cbm::algo::qa::Prof1D;
  using cbm::algo::qa::Prof2D;
}  // namespace
 
namespace cbm::qa
{
  template<class RootHistogram>
  class RootHistogramAccessor : public RootHistogram {
 
   public:
    template<class... Args>
    RootHistogramAccessor(Args... args) : RootHistogram(args...)
    {
    }

    template<class SourceQaHistogram>
    void AddSliceFromQaHistogram(const SourceQaHistogram& histo, double val);

    template<class QaHistogram>
    void SetFromQaHistogram(const QaHistogram& histo);
  };

  class OnlineInterface {
   public:
    // TODO: generalize
    static void AddSlice(const H1D& src, double value, TH2D* dst);

    static void AddSlice(const Prof1D& src, double value, TProfile2D* dst);

    static TH1D* ROOTHistogram(const H1D& hist);

    static TH2D* ROOTHistogram(const H2D& hist);

    static TProfile* ROOTHistogram(const Prof1D& prof);

    static TProfile2D* ROOTHistogram(const Prof2D& prof);

    static bool ConvertOutput(const std::string& inFilename, std::string outFilename = "");
  };
}  // namespace cbm::qa
 
 
namespace cbm::qa
{
  // -------------------------------------------------------------------------------------------------------------------
  //
  template<class RootHistogram>
  template<class QaHistogram>
  void RootHistogramAccessor<RootHistogram>::AddSliceFromQaHistogram(const QaHistogram& src, double val)
  {
    constexpr bool IsDstH2D    = std::is_same_v<RootHistogram, TH2D>;
    constexpr bool IsDstProf2D = std::is_same_v<RootHistogram, TProfile2D>;
    constexpr bool IsSrcH1D    = std::is_same_v<QaHistogram, H1D>;
    constexpr bool IsSrcProf1D = std::is_same_v<QaHistogram, Prof1D>;
 
    static_assert((IsDstH2D && IsSrcH1D) || (IsDstProf2D && IsSrcProf1D),
                  "function not implemented for a given (RootHistogram, QaHistogram) pair");
 
    auto iBinX = this->GetXaxis()->FindBin(val);
    for (int iBinY = 0; iBinY <= this->GetNbinsY() + 1; ++iBinY) {
      int iGlobBin = this->GetBin(iBinX, iBinY);
      auto binSrc  = src.GetBinAccumulator(iBinY);
      if constexpr (IsSrcH1D) {
        this->fArray[iGlobBin] += binSrc.value();
        if (this->fSumw2.fN) {
          this->fSumw2.fArray[iGlobBin] += binSrc.variance();
        }
      }
      else if constexpr (IsSrcProf1D) {
        this->fArray[iGlobBin] += binSrc.GetSumWV();
        this->fBinEntries.fArray[iGlobBin] += binSrc.GetSumW();
        this->fSumw2.fArray[iGlobBin] += binSrc.GetSumWV2();
        this->fBinSumw2.fArray[iGlobBin] += binSrc.GetSumW2();
        this->fTsumwz += binSrc.GetSumWV();
        this->fTsumwz2 += binSrc.GetSumWV2();
      }
    }
    this->fTsumw += src.GetTotSumW();
    this->fTsumw2 += src.GetTotSumW2();
    this->fTsumwx += src.GetTotSumWX();
    this->fTsumwx2 += src.GetTotSumWX2();
    this->SetEntries(this->GetEntries() + src.GetEntries());
  }
 
  // -------------------------------------------------------------------------------------------------------------------
  //
  template<class RootHistogram>
  template<class QaHistogram>
  void RootHistogramAccessor<RootHistogram>::SetFromQaHistogram(const QaHistogram& hist)
  {
    // Set individual bin properties
    if constexpr (std::is_same_v<RootHistogram, TProfile> || std::is_same_v<RootHistogram, TProfile2D>) {
      this->Sumw2();
      auto SetBin = [&](int iBinRoot, const auto& binQa) {
        this->fArray[iBinRoot]             = binQa.GetSumWV();
        this->fBinEntries.fArray[iBinRoot] = binQa.GetSumW();
        this->fSumw2.fArray[iBinRoot]      = binQa.GetSumWV2();
        this->fBinSumw2.fArray[iBinRoot]   = binQa.GetSumW2();
      };
      if constexpr (std::is_same_v<RootHistogram, TProfile>) {
        for (int iBinX = 0; iBinX <= this->GetNbinsX() + 1; ++iBinX) {
          int iBin = this->GetBin(iBinX);
          auto bin = hist.GetBinAccumulator(iBinX);
          SetBin(iBin, bin);
          this->fTsumwy += bin.GetSumWV();
          this->fTsumwy2 += bin.GetSumWV2();
        }
      }
      else if constexpr (std::is_same_v<RootHistogram, TProfile2D>) {
        for (int iBinX = 0; iBinX <= this->GetNbinsX() + 1; ++iBinX) {
          for (int iBinY = 0; iBinY <= this->GetNbinsY() + 1; ++iBinY) {
            int iBin = this->GetBin(iBinX, iBinY);
            auto bin = hist.GetBinAccumulator(iBinX, iBinY);
            SetBin(iBin, bin);
            this->fTsumwz += bin.GetSumWV();
            this->fTsumwz2 += bin.GetSumWV2();
          }
        }
      }
    }
    else if constexpr (std::is_same_v<RootHistogram, TH1D> || std::is_same_v<RootHistogram, TH2D>) {
      if (hist.GetTotSumW() != hist.GetTotSumW2()) {  // some of weights were not equal to 1.
        if (!this->fSumw2.fN) {
          this->Sumw2();
        }
      }
      auto SetBin = [&](int iBinRoot, const auto& binQa) {
        this->fArray[iBinRoot] = binQa.value();
        if (this->fSumw2.fN) {
          this->fSumw2.fArray[iBinRoot] = binQa.variance();
        }
      };
      if constexpr (std::is_same_v<RootHistogram, TH1D>) {
        for (int iBinX = 0; iBinX <= this->GetNbinsX() + 1; ++iBinX) {
          SetBin(this->GetBin(iBinX), hist.GetBinAccumulator(iBinX));
        }
      }
      else if constexpr (std::is_same_v<RootHistogram, TH2D>) {
        for (int iBinX = 0; iBinX <= this->GetNbinsX() + 1; ++iBinX) {
          for (int iBinY = 0; iBinY <= this->GetNbinsY() + 1; ++iBinY) {
            SetBin(this->GetBin(iBinX, iBinY), hist.GetBinAccumulator(iBinX, iBinY));
          }
        }
      }
    }
 
    // Set total sums
    if constexpr (std::is_base_of_v<TH2D, RootHistogram>) {
      this->fTsumwy  = hist.GetTotSumWY();
      this->fTsumwy2 = hist.GetTotSumWY2();
      this->fTsumwxy = hist.GetTotSumWXY();
    }
    this->fTsumw   = hist.GetTotSumW();
    this->fTsumw2  = hist.GetTotSumW2();
    this->fTsumwx  = hist.GetTotSumWX();
    this->fTsumwx2 = hist.GetTotSumWX2();
    this->SetEntries(hist.GetEntries());
  }
}  // namespace cbm::qa