CbmQaIO.h

Go to the documentation of this file.

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

 
#ifndef CbmQaIO_h
#define CbmQaIO_h 1
 
#include "CbmQaCanvas.h"
#include "CbmQaEff.h"
#include "CbmQaTable.h"
#include "CbmYaml.h"
#include "Logger.h"
#include "TCanvas.h"
#include "TEfficiency.h"
#include "TH1.h"
#include "TH2.h"
#include "TH3.h"
#include "TObject.h"
#include "TParameter.h"
#include "TProfile.h"
#include "TProfile2D.h"
#include "TProfile3D.h"
#include "TROOT.h"
#include "TString.h"
 
#include <limits>
#include <optional>
#include <type_traits>
#include <vector>
 
#include <yaml-cpp/yaml.h>
 
class TFile;

class CbmQaIO {
 public:
  using ObjList_t = std::vector<std::pair<TObject*, TString>>;
 
  enum class EStoringMode
  {
    kSAMEDIR,  
    kSUBDIR    
  };

  CbmQaIO(TString prefixName, std::shared_ptr<ObjList_t> pObjList = nullptr);

  virtual ~CbmQaIO();

  CbmQaIO(const CbmQaIO&) = delete;

  CbmQaIO(CbmQaIO&&) = delete;

  CbmQaIO& operator=(const CbmQaIO&) = delete;

  CbmQaIO& operator=(CbmQaIO&&) = delete;
 

  const char* GetConfigName() const { return fsConfigName.Data(); }

  template<typename T, typename... Args>
  T* MakeQaObject(TString sName, TString sTitle, Args... args);

  void MakeQaDirectory(TString sName);

  void SetConfigName(const char* path);

  void SetRootFolderName(const TString& path) { fsRootFolderName = path.Strip(TString::kBoth, '/'); }

  void SetStoringMode(EStoringMode mode) { fStoringMode = mode; }
 
 protected:
  template<typename T>
  void CheckProperty(T&& property, const char* name) const;

  template<class Config>
  std::optional<Config> ReadSpecificConfig() const
  {
    std::optional<Config> res = std::nullopt;
    const auto& node          = fConfigNode["specific"];
    if (node) {
      res = std::make_optional(cbm::util::yaml::Read<Config>(node));
    }
    return res;
  }

  virtual void SetTH1Properties(TH1* pHist) const;

  virtual void SetTH2Properties(TH2* pHist) const;

  virtual void SetTProfile2DProperties(TProfile2D* pHist) const;

  virtual void SetCanvasProperties(TCanvas* pCanv) const;

  void WriteToFile(TFile* pOutFile) const;
 
  TString fsRootFolderName = "";  
  TString fsConfigName     = "";  
  TString fsPrefix         = "";  
 
  EStoringMode fStoringMode             = EStoringMode::kSUBDIR;  
  std::shared_ptr<ObjList_t> fpvObjList = nullptr;                
 
  YAML::Node fConfigNode{};  
 
 private:
  template<typename T, typename... Args>
  T* ConstructAndRegisterQaObject(TString name, Args... args);
};
 
 
// ---------------------------------------------------------------------------------------------------------------------
//
template<typename T>
void CbmQaIO::CheckProperty(T&& property, const char* name) const
{
  bool bPropertyUndefined = false;
  if constexpr (std::is_signed_v<T>) {
    bPropertyUndefined = property < 0;
  }
  else if constexpr (std::is_floating_point_v<T>) {
    bPropertyUndefined = std::isnan(property);
  }
 
  if (bPropertyUndefined) {
    std::stringstream msg;
    msg << "Property " << name << " is undefined in the configuration file";
    throw std::runtime_error(msg.str());
  }
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
template<typename T, typename... Args>
T* CbmQaIO::ConstructAndRegisterQaObject(TString sName, Args... args)
{
  if constexpr (std::is_base_of_v<CbmQaTable, T>) {
    static_assert(sizeof...(Args) == 3);
  }
 
  // Resolve directory name and object name
  auto iLastSlashPos = static_cast<int>(sName.Last('/'));
  TString sDirectory = TString(sName(0, iLastSlashPos)).Strip(TString::kBoth, '/');
  sName              = sName(iLastSlashPos + 1, sName.Length() - iLastSlashPos);
 
  // Create a new object
  T* pObj = new T(sName.Data(), args...);
 
  // Take object ownership from ROOT
  if constexpr (std::is_base_of_v<TH1, T>) {  // all kind of histograms
    pObj->SetDirectory(nullptr);
  }
 
  // apply user-defined properties
  if constexpr (std::is_same_v<TH1F, T> || std::is_same_v<TH1D, T> || std::is_same_v<TProfile, T>) {  // histograms
    SetTH1Properties(pObj);
  }
  else if constexpr (std::is_same_v<TH2F, T> || std::is_same_v<TH2D, T>) {  // histograms
    SetTH2Properties(pObj);
  }
  else if constexpr (std::is_same_v<TProfile2D, T>) {  // profile 2D
    SetTProfile2DProperties(pObj);
  }
  else if constexpr (std::is_base_of_v<TCanvas, T>) {  // canvases
    auto* pListOfCanvases = gROOT->GetListOfCanvases();
    if (-1 != pListOfCanvases->IndexOf(pObj)) {
      pListOfCanvases->Remove(pObj);
    }
    SetCanvasProperties(pObj);
  }
 
  // Define a "summary" subdirectory of canvases and tables
  if constexpr (std::is_base_of_v<CbmQaTable, T> || std::is_base_of_v<TCanvas, T>) {
    if (EStoringMode::kSUBDIR == fStoringMode) {
      sDirectory = TString("Summary/") + sDirectory;
    }
  }
 
  // Add parent directory
  if (fsRootFolderName.Length() != 0) {
    if (sDirectory.Length() != 0) {
      sDirectory = fsRootFolderName + "/" + sDirectory;
    }
    else {
      sDirectory = fsRootFolderName;
    }
  }
 
  // Register the object in the list
  fpvObjList->push_back(std::make_pair(static_cast<TObject*>(pObj), sDirectory));
 
  return pObj;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
template<typename T, typename... Args>
T* CbmQaIO::MakeQaObject(TString sName, TString sTitle, Args... args)
{
  if constexpr (std::is_base_of_v<CbmQaTable, T>) {
    static_assert(sizeof...(Args) == 2);
  }
 
  // Resolve configuration tag, if any
  auto iLastSepPos = static_cast<int>(sName.Last(';'));
  TString sTagName = sName(iLastSepPos + 1, sName.Length() - iLastSepPos);
  if (iLastSepPos != -1) {
    sName = sName(0, iLastSepPos);
  }
 
  bool bUseConfig = false;
  // Check, if parameters are provided for this tag
  if (fConfigNode) {
    if constexpr (std::is_base_of_v<TH1, T>) {
      if (fConfigNode["histograms"]) {
        if (fConfigNode["histograms"][sTagName.Data()]) {
          bUseConfig = true;
        }
      }
    }
    else if constexpr (std::is_base_of_v<TCanvas, T>) {
      if (fConfigNode["canvases"]) {
        if (fConfigNode["canvases"][sTagName.Data()]) {
          bUseConfig = true;
        }
      }
    }
  }
 
  //LOG(info) << "CbmQaIO: init ROOT object \"" << sName << '\"';  // Debug
 
  const char* title = sTitle.Data();
  if (bUseConfig) {
    if constexpr (std::is_base_of_v<TH1, T>) {
      const auto& tagNode = fConfigNode["histograms"][sTagName.Data()];
 
      [[maybe_unused]] int nBinsX  = -1;
      [[maybe_unused]] double minX = std::numeric_limits<double>::signaling_NaN();
      [[maybe_unused]] double maxX = std::numeric_limits<double>::signaling_NaN();
      [[maybe_unused]] int nBinsY  = -1;
      [[maybe_unused]] double minY = std::numeric_limits<double>::signaling_NaN();
      [[maybe_unused]] double maxY = std::numeric_limits<double>::signaling_NaN();
      [[maybe_unused]] int nBinsZ  = -1;
      [[maybe_unused]] double minZ = std::numeric_limits<double>::signaling_NaN();
      [[maybe_unused]] double maxZ = std::numeric_limits<double>::signaling_NaN();
 
      if (const auto& axisNode = tagNode["x"]) {
        nBinsX = axisNode["nbins"].as<int>();
        minX   = axisNode["min"].as<double>();
        maxX   = axisNode["max"].as<double>();
      }
      if (const auto& axisNode = tagNode["y"]) {
        nBinsY = axisNode["nbins"].as<int>();
        minY   = axisNode["min"].as<double>();
        maxY   = axisNode["max"].as<double>();
      }
      if (const auto& axisNode = tagNode["z"]) {
        nBinsZ = axisNode["nbins"].as<int>();
        minZ   = axisNode["min"].as<double>();
        maxZ   = axisNode["max"].as<double>();
      }
 
      if constexpr (std::is_base_of_v<CbmQaTable, T>) {
        return ConstructAndRegisterQaObject<T>(sName, title, args...);
      }
      else if constexpr (std::is_base_of_v<TProfile2D, T>) {
        CheckProperty(nBinsX, Form("qa/histograms/%s/x/nbins", sTagName.Data()));
        CheckProperty(minX, Form("qa/histograms/%s/x/min", sTagName.Data()));
        CheckProperty(maxX, Form("qa/histograms/%s/x/max", sTagName.Data()));
        CheckProperty(nBinsY, Form("qa/histograms/%s/y/nbins", sTagName.Data()));
        CheckProperty(minY, Form("qa/histograms/%s/y/min", sTagName.Data()));
        CheckProperty(maxY, Form("qa/histograms/%s/y/max", sTagName.Data()));
        CheckProperty(minZ, Form("qa/histograms/%s/z/min", sTagName.Data()));
        CheckProperty(maxZ, Form("qa/histograms/%s/z/max", sTagName.Data()));
        return ConstructAndRegisterQaObject<T>(sName, title, nBinsX, minX, maxX, nBinsY, minY, maxY, minZ, maxZ);
      }
      else if constexpr (std::is_base_of_v<TProfile, T>) {
        CheckProperty(nBinsX, Form("qa/histograms/%s/x/nbins", sTagName.Data()));
        CheckProperty(minX, Form("qa/histograms/%s/x/min", sTagName.Data()));
        CheckProperty(maxX, Form("qa/histograms/%s/x/max", sTagName.Data()));
        CheckProperty(minY, Form("qa/histograms/%s/y/min", sTagName.Data()));
        CheckProperty(maxY, Form("qa/histograms/%s/y/max", sTagName.Data()));
        return ConstructAndRegisterQaObject<T>(sName, title, nBinsX, minX, maxX, minY, maxY);
      }
      else if constexpr (std::is_base_of_v<TH3, T>) {
        CheckProperty(nBinsX, Form("qa/histograms/%s/x/nbins", sTagName.Data()));
        CheckProperty(minX, Form("qa/histograms/%s/x/min", sTagName.Data()));
        CheckProperty(maxX, Form("qa/histograms/%s/x/max", sTagName.Data()));
        CheckProperty(nBinsY, Form("qa/histograms/%s/y/nbins", sTagName.Data()));
        CheckProperty(minY, Form("qa/histograms/%s/y/min", sTagName.Data()));
        CheckProperty(maxY, Form("qa/histograms/%s/y/max", sTagName.Data()));
        CheckProperty(nBinsZ, Form("qa/histograms/%s/z/nbins", sTagName.Data()));
        CheckProperty(minZ, Form("qa/histograms/%s/z/min", sTagName.Data()));
        CheckProperty(maxZ, Form("qa/histograms/%s/z/max", sTagName.Data()));
        return ConstructAndRegisterQaObject<T>(sName, title, nBinsX, minX, maxX, nBinsY, minY, maxY, nBinsZ, minZ,
                                               maxZ);
      }
      else if constexpr (std::is_base_of_v<TH2, T>) {
        CheckProperty(nBinsX, Form("qa/histograms/%s/x/nbins", sTagName.Data()));
        CheckProperty(minX, Form("qa/histograms/%s/x/min", sTagName.Data()));
        CheckProperty(maxX, Form("qa/histograms/%s/x/max", sTagName.Data()));
        CheckProperty(nBinsY, Form("qa/histograms/%s/y/nbins", sTagName.Data()));
        CheckProperty(minY, Form("qa/histograms/%s/y/min", sTagName.Data()));
        CheckProperty(maxY, Form("qa/histograms/%s/y/max", sTagName.Data()));
        return ConstructAndRegisterQaObject<T>(sName, title, nBinsX, minX, maxX, nBinsY, minY, maxY);
      }
      else if constexpr (std::is_base_of_v<TH1, T>) {
        CheckProperty(nBinsX, Form("qa/histograms/%s/x/nbins", sTagName.Data()));
        CheckProperty(minX, Form("qa/histograms/%s/x/min", sTagName.Data()));
        CheckProperty(maxX, Form("qa/histograms/%s/x/max", sTagName.Data()));
        return ConstructAndRegisterQaObject<T>(sName, title, nBinsX, minX, maxX);
      }
    }
  }
 
  return ConstructAndRegisterQaObject<T>(sName, title, args...);
}
 
#endif  // CbmQaIO_h