CbmQaOnlineInterface.cxx

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] */

 
#include "CbmQaOnlineInterface.h"
//#include "Histogram.h"
 
#include "TFile.h"
#include "TH1D.h"
#include "TH2D.h"
#include "TProfile.h"
#include "TProfile2D.h"
#include "algo/qa/QaDataInputArchive.h"
 
#include <boost/filesystem.hpp>
 
using cbm::algo::qa::H1D;
using cbm::algo::qa::H2D;
using cbm::algo::qa::Prof1D;
using cbm::algo::qa::Prof2D;
using cbm::qa::OnlineInterface;
using cbm::qa::RootHistogramAccessor;
 
// ---------------------------------------------------------------------------------------------------------------------
//
void OnlineInterface::AddSlice(const H1D& src, double value, TH2D* dst)
{
  auto* pDst = static_cast<RootHistogramAccessor<TH2D>*>(dst);
  pDst->AddSliceFromQaHistogram<H1D>(src, value);
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
void OnlineInterface::AddSlice(const Prof1D& src, double value, TProfile2D* dst)
{
  auto* pDst = static_cast<RootHistogramAccessor<TProfile2D>*>(dst);
  pDst->AddSliceFromQaHistogram<Prof1D>(src, value);
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
TH1D* OnlineInterface::ROOTHistogram(const H1D& hist)
{
  int nBins   = hist.GetNbinsX();
  double xMin = hist.GetMinX();
  double xMax = hist.GetMaxX();
  bool add    = TH1::AddDirectoryStatus();
  TH1::AddDirectory(false);
  auto* pRes = new RootHistogramAccessor<TH1D>(hist.GetName().c_str(), hist.GetTitle().c_str(), nBins, xMin, xMax);
  TH1::AddDirectory(add);
  pRes->SetFromQaHistogram<H1D>(hist);
  return pRes;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
TH2D* OnlineInterface::ROOTHistogram(const H2D& hist)
{
  int nBinsX  = hist.GetNbinsX();
  double xMin = hist.GetMinX();
  double xMax = hist.GetMaxX();
  int nBinsY  = hist.GetNbinsY();
  double yMin = hist.GetMinY();
  double yMax = hist.GetMaxY();
  bool add    = TH1::AddDirectoryStatus();
  TH1::AddDirectory(false);
  auto* pRes = new RootHistogramAccessor<TH2D>(hist.GetName().c_str(), hist.GetTitle().c_str(), nBinsX, xMin, xMax,
                                               nBinsY, yMin, yMax);
  TH1::AddDirectory(add);
  pRes->SetFromQaHistogram<H2D>(hist);
  return pRes;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
TProfile* OnlineInterface::ROOTHistogram(const Prof1D& prof)
{
  const char* name = prof.GetName().c_str();
  const char* titl = prof.GetTitle().c_str();
  int nBinsX       = prof.GetNbinsX();
  double xMin      = prof.GetMinX();
  double xMax      = prof.GetMaxX();
  double yMin      = prof.GetMinY();
  double yMax      = prof.GetMaxY();
  bool add         = TH1::AddDirectoryStatus();
  TH1::AddDirectory(false);
  auto* pRes = new RootHistogramAccessor<TProfile>(name, titl, nBinsX, xMin, xMax, yMin, yMax);
  TH1::AddDirectory(add);
  pRes->SetFromQaHistogram<Prof1D>(prof);
  return pRes;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
TProfile2D* OnlineInterface::ROOTHistogram(const Prof2D& prof)
{
  const char* name = prof.GetName().c_str();
  const char* titl = prof.GetTitle().c_str();
  int nBinsX       = prof.GetNbinsX();
  double xMin      = prof.GetMinX();
  double xMax      = prof.GetMaxX();
  int nBinsY       = prof.GetNbinsY();
  double yMin      = prof.GetMinY();
  double yMax      = prof.GetMaxY();
  double zMin      = prof.GetMinZ();
  double zMax      = prof.GetMaxZ();
  bool add         = TH1::AddDirectoryStatus();
  TH1::AddDirectory(false);
  auto* pRes = new RootHistogramAccessor<TProfile2D>(name, titl, nBinsX, xMin, xMax, nBinsY, yMin, yMax, zMin, zMax);
  TH1::AddDirectory(add);
  pRes->SetFromQaHistogram<Prof2D>(prof);
  return pRes;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
bool OnlineInterface::ConvertOutput(const std::string& inFilename, std::string outFilename)
{
  //* Read instance of the qa::StorableData
  auto archive = std::make_unique<cbm::algo::qa::DataInputArchive>(inFilename);
  LOG(info) << "ConvertOutput: reading from input archive " << inFilename;
  auto desc = archive->descriptor();
  LOG(info) << "      - Time created: " << desc.time_created();
  LOG(info) << "      - Host name   : " << desc.hostname();
  LOG(info) << "      - User name   : " << desc.username();
 
  auto data = archive->get();
  if (!data) {
    LOG(error) << "ConvertOutput: failed to read qa::Data from archive";
    return false;
  }
 
  if (outFilename.empty()) {
    auto inPath = boost::filesystem::path(inFilename);
    outFilename = (inPath.parent_path() / (inPath.stem().string() + ".root")).string();
  }
  LOG(info) << "ConvertOutput: storing converted histograms in " << outFilename;
 
  TFile fileOut(outFilename.c_str(), "RECREATE");
 
  //* Loop over data contents and store the histograms
  auto ProcessHistograms = [&fileOut](const auto& container) {
    for (const auto& histogram : container) {
      std::string dirName  = "";
      std::string histName = histogram.GetName();
      LOG(info) << " - processing histogram " << histName;
 
      // FIXME: optimize directory access in outFile
      auto slashPos = histogram.GetName().rfind('/');
      if (slashPos != std::string::npos) {  // the histogram is in a subdirectory
        dirName  = histName.substr(0, slashPos);
        histName = histName.substr(slashPos + 1, std::string::npos);
      }
 
      auto* pDir = fileOut.GetDirectory(dirName.c_str());
      if (!pDir) {
        pDir = fileOut.mkdir(dirName.c_str());
      }
 
      auto* pRootHist = ROOTHistogram(histogram);
      pRootHist->SetName(histName.c_str());
      pRootHist->SetDirectory(pDir);
    }
  };
 
  ProcessHistograms(data->H1());
  ProcessHistograms(data->H2());
  ProcessHistograms(data->P1());
  ProcessHistograms(data->P2());
 
  fileOut.Write();
  fileOut.Close();
 
  return true;
}