QaReportGenerator.cxx

Go to the documentation of this file.

/* Copyright (C) 2025 GSI/VECC,  Darmstadt/Kolkata
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Souvik Chattopadhyay[committer]  */
 
#include "QaReportGenerator.h"
 
#include "CbmQaReportBeamerEngine.h"
#include "CbmQaReportFigure.h"
#include "CbmQaReportHtmlEngine.h"
#include "CbmQaReportLatexEngine.h"
#include "CbmQaReportSection.h"
#include "CbmQaReportTable.h"
#include "Logger.h"
 
#include <TCanvas.h>
#include <TKey.h>
#include <TString.h>
#include <TSystem.h>
 
#include <algorithm>
#include <cstring>
#include <iostream>
 
#include <yaml-cpp/yaml.h>
 
using cbm::qa::checker::Result;
using namespace cbm::qa::report;
using cbm::qa::checker::ECmpInference;
 
 
// ---------------------------------------------------------------------
QaReportGenerator::QaReportGenerator(const std::string& qaFile, const std::string& setup, const std::string& outDir,
                                     EngineType engine, const std::string& figExt, bool ignoreSame)
  : fSetup(setup)
  , fOutDir(outDir)
  , fEngine(engine)
{
  fFile.reset(TFile::Open(qaFile.c_str(), "READONLY"));
  if (!fFile || !fFile->IsOpen()) {
    throw std::runtime_error("Cannot open input file: " + qaFile);
  }
 
  fIgnoreSame = ignoreSame;
  fReport     = std::make_unique<Builder>("QA Compare Status", outDir.c_str());
  fReport->GetHeader()->SetSubtitle("The CBM Collaboration");
  fReport->GetHeader()->SetAuthor(gSystem->Getenv("USER"));
  fReport->GetHeader()->SetSetup(setup.c_str());
  fReport->SetFigureExtention(figExt.c_str());
}
 
// ---------------------------------------------------------------------
void QaReportGenerator::Generate()
{
  std::string path = fFile->GetName();
 
 
  Process(path);
  switch (fEngine) {
    case EngineType::kHtml: {
      HtmlEngine e;
      fReport->CreateScript(e);
      break;
    }
    case EngineType::kBeamer: {
      BeamerEngine e;
      fReport->CreateScript(e);
      break;
    }
    case EngineType::kLatex:
    default: {
      LatexEngine e;
      fReport->CreateScript(e);
      break;
    }
  }
}
 
 
void QaReportGenerator::Process(const std::string& Path)
{
 
 
  LOG(info) << "Processing root file: " << Path;
  std::unique_ptr<TFile> f(TFile::Open(Path.c_str(), "READ"));
  if (!f || f->IsZombie()) {
    std::cerr << "Cannot open file\n";
    return;
  }
 
 
  TIter setups(f->GetListOfKeys());
  while (auto* setupKey = static_cast<TKey*>(setups())) {
    const std::string setupName = setupKey->GetName();
    LOG(info) << "Processing setup: " << setupName;
 
 
    auto* setupDir = dynamic_cast<TDirectory*>(f->GetDirectory(setupName.c_str()));
    if (!setupDir) {
      LOG(warn) << "  Not a folder, skipping: " << setupName;
      continue;
    }
 
 
    TIter fileLabels(setupDir->GetListOfKeys());
    while (auto* fileKey = static_cast<TKey*>(fileLabels())) {
      const std::string fileLabel = fileKey->GetName();
      LOG(info) << "  Found file label: " << fileLabel;
 
      auto* fileDir = dynamic_cast<TDirectory*>(setupDir->GetDirectory(fileLabel.c_str()));
      if (!fileDir) {
        LOG(warn) << "    Not a folder, skipping: " << fileLabel;
        continue;
      }
 
 
      TIter tasks(fileDir->GetListOfKeys());
      while (auto* taskKey = static_cast<TKey*>(tasks())) {
        const std::string taskName = taskKey->GetName();
        // Add section for task name
        std::string sectionName = "Comparison Results for " + taskName;
        auto section            = std::make_shared<Section>(taskName, sectionName);
        fReport->AddSection(section);
 
        LOG(info) << "    Found task: " << taskName << " in " << fileLabel;
        auto* taskDir            = dynamic_cast<TDirectory*>(fileDir->GetDirectory(taskName.c_str()));
        std::string currentRPath = taskName;
        // + "/" + taskName;
        // std::string currentRPath = "";
        GetResults(taskDir, currentRPath, taskName);
 
 
        Size_t nCols = fVersionLabel.size() + 1;  // +1 for the group name column
        Size_t nRows = fResults.size();
 
        LOG(info) << "  Creating table with " << nRows << " rows and " << nCols << " columns for task: " << taskName;
        auto table = std::make_shared<Table>(taskName, nRows, nCols, taskName);
        for (size_t i = 0; i < nCols; ++i) {
          if (i == 0) {
            table->SetColumnTitle(i, "Histogram");
          }
          else {
            table->SetColumnTitle(i, fVersionLabel[i - 1]);
          }
 
          for (size_t j = 0; j < nRows; ++j) {
            if (i == 0) {
              table->SetCell(j, i, fObjlist[j]);  // First column is the group name
            }
            else {
              const auto& result = fResults.at(fObjlist[j])[i - 1];
 
              std::string cellText = CmpInferenceToString(result.GetCmpInference());
              LOG(info) << "Processing result for group: " << fObjlist[j] << " | Version: " << fVersionLabel[i - 1]
                        << " | Result: " << cellText;
              table->SetCell(j, i, cellText);
            }
          }
        }
 
 
        section->Add(table);
        // Add canvas figures to the same section
        std::vector<std::string> canvasPaths = GetCanvasPaths(taskDir);
        for (const auto& path : canvasPaths) {
          if (auto* canv = dynamic_cast<TCanvas*>(taskDir->Get(path.c_str()))) {
            auto fig = std::make_shared<Figure>(path);
            fig->AddPlot(fReport->SaveCanvas(canv, path));
            section->Add(fig);
          }
        }
      }
    }
  }
 
  f->Close();
}
 
std::vector<std::string> QaReportGenerator::GetCanvasPaths(TDirectory* dir, const std::string& prefix)
{
  std::vector<std::string> paths;
  if (!dir) return paths;
 
  TIter nextKey(dir->GetListOfKeys());
  while (auto* key = static_cast<TKey*>(nextKey())) {
    const std::string keyName = key->GetName();
 
 
    auto* obj    = key->ReadObj();
    auto* subDir = dynamic_cast<TDirectory*>(obj);
 
    if (subDir) {
 
 
      TIter subIter(subDir->GetListOfKeys());
      while (auto* subKey = static_cast<TKey*>(subIter())) {
        auto* canvas = dynamic_cast<TCanvas*>(subKey->ReadObj());
        if (canvas) {
          std::string canvasPath = prefix + keyName + "/" + subKey->GetName();
          LOG(info) << "Found canvas: " << canvasPath;
          paths.push_back(canvasPath);
        }
      }
 
      const auto subPaths = GetCanvasPaths(subDir, prefix + keyName + "/");
      paths.insert(paths.end(), subPaths.begin(), subPaths.end());
    }
  }
  return paths;
}
 
// ---------------------------------------------------------------------
std::string QaReportGenerator::EscapeLatex(const std::string& text)
{
  std::string escaped            = text;
  const std::string specialChars = "#$%&_";
  for (char c : specialChars) {
    std::string toReplace(1, c);
    std::string replacement = "\\" + toReplace;
    size_t pos              = 0;
    while ((pos = escaped.find(toReplace, pos)) != std::string::npos) {
      escaped.replace(pos, toReplace.length(), replacement);
      pos += replacement.length();
    }
  }
  return escaped;
}
 
 
void QaReportGenerator::GetResults(TDirectory* dir, const std::string& currentPath, const std::string& taskName)
{
 
 
  TIter next(dir->GetListOfKeys());
  while (TKey* key = static_cast<TKey*>(next())) {
    TObject* obj         = key->ReadObj();
    std::string name     = key->GetName();
    std::string fullPath = currentPath + "/" + name;
    // LOG(info) << "Processing object: " << fullPath;
    //LOG(info) << "Object type: " << obj->ClassName();
    if (obj->InheritsFrom("TDirectory")) {
      auto subDir = static_cast<TDirectory*>(obj);
      GetResults(subDir, fullPath, taskName);
    }
    else if (auto* concreteObj = dynamic_cast<Result*>(obj)) {
      Result res(*concreteObj);
      LOG(info) << "Found Result object: " << name;
      LOG(info) << "full Path: " << fullPath;
      std::string groupName;
      std::string taskPrefix = taskName + "/";  // = "/CbmCaOutputQa/"
      LOG(info) << "Task prefix: " << taskPrefix;
      size_t pos = fullPath.find(taskPrefix);
 
      if (pos != std::string::npos) {
        size_t start = pos + taskPrefix.length();  // Start of group: just after "CbmCaOutputQa/"
        size_t end   = fullPath.rfind('/');        // End of group: before last component
        if (end != std::string::npos && end > start) {
          groupName = fullPath.substr(start, end - start);  // Extract "sec_mu/reco_tx"
        }
      }
      std::string versionLabel;
      std::string prefix = "result_";
      size_t posVer      = fullPath.rfind(prefix);
      if (posVer != std::string::npos) {
        versionLabel = fullPath.substr(posVer + prefix.length());
        LOG(info) << "Extracted version label: " << versionLabel;
      }
 
      LOG(info) << "Group name: " << groupName;
      fObjlist.push_back(groupName);
      fResults.at(groupName).emplace_back(res);
      if (std::find(fVersionLabel.begin(), fVersionLabel.end(), versionLabel) == fVersionLabel.end()) {
        fVersionLabel.push_back(versionLabel);
      }
 
      LOG(info) << "Added result to group: " << groupName << " | Total results: " << fResults.at(groupName).size();
    }
  }
}
std::string QaReportGenerator::CmpInferenceToString(cbm::qa::checker::ECmpInference inf)
{
 
  switch (inf) {
    case ECmpInference::StronglyEqual: return "Same";
    case ECmpInference::WeaklyEqual: return "Consistent";
    case ECmpInference::Different: return "Different";
    default: return "Unknown";
  }
}