CbmQaCheckerFileHandler.cxx

Go to the documentation of this file.

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

 
#include "CbmQaCheckerFileHandler.h"
 
#include "CbmQaCheckerHist1DHandler.h"
#include "CbmQaCheckerHist2DHandler.h"
#include "CbmQaCheckerProfile1DHandler.h"
#include "Logger.h"
#include "TDirectoryFile.h"
#include "TFile.h"
#include "TFolder.h"
#include "TH1.h"
#include "TH2.h"
#include "TNamed.h"
#include "TProfile.h"
#include "TROOT.h"
 
#include <boost/algorithm/string.hpp>
 
#include <cstdlib>
#include <iomanip>
#include <sstream>
#include <string>
 
#include <yaml-cpp/yaml.h>
 
 
using cbm::qa::checker::ECmpInference;
using cbm::qa::checker::FileHandler;
 
// ---------------------------------------------------------------------------------------------------------------------
//
FileHandler::FileHandler(std::shared_ptr<ObjectDB>& pObjDB, int iDataset, int iFile)
  : fFileID(iFile)
  , fDatasetID(iDataset)
  , fpObjDB(pObjDB)
{
  ReOpenOutputFile();
  fpInputFiles = std::make_unique<TClonesArray>("TFile");
 
  for (int iVer = 0; iVer < fpObjDB->GetNofVersions(); ++iVer) {
    std::string filename = fpObjDB->GetInputFileName(iVer, fFileID, fDatasetID);
    auto* pInFile        = new ((*fpInputFiles)[iVer]) TFile(filename.data(), "READONLY");
    LOG(info) << "File: " << pInFile->GetName();
    LOG_IF(fatal, !pInFile->IsOpen()) << "FileHandler: file " << filename << " cannot be opened";
  }
 
  // Check registered folder
  LOG_IF(fatal, !fpObjDB.get()) << "FileHandler: attempt to register a null pointer for the object database";
  LOG_IF(fatal, !fpOutDir) << "FileHandler: attempt to register a null pointer for the output directory";
  LOG_IF(fatal, fDatasetID < 0) << "FileHandler: attempt to register undefined dataset index";
  LOG_IF(fatal, fFileID < 0) << "FileHandler: attempt to register undefined file index";
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
FileHandler::~FileHandler()
{
  // ----- Clean pointers
  fpInputFiles->Delete();
  fpInputFiles = nullptr;
  fpOutputFile->Close();
  fpOutputFile = nullptr;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
TDirectory* FileHandler::CreateNestedDirectory(const std::string& path)
{
  fpOutDir->mkdir(path.data());
  return fpOutDir->GetDirectory(path.data());
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
// Modified version of FileHandler::Process to use ObjectParameters
std::vector<Result> FileHandler::Process()
{
  std::vector<Result> bCmpResult;
  int nObjects  = fpObjDB->GetNofObjects(fFileID);
  int nVersions = fpObjDB->GetNofVersions();
  bCmpResult.resize(nVersions, Result(ECmpInference::StronglyEqual, true, 1., 1., 1.));
 
  if (!nObjects) {
    LOG(warn) << "FileHandler: No objects were passed to file \"" << nObjects << ". Skipping file";
    return bCmpResult;
  }
 
 
  LOG(info) << "Number of object parameters: " << fpObjDB->GetNofObjectParameters();
  LOG(info) << "FileHandler: processing objects: ...";
 
  // Initialize YAML node
  YAML::Node yamlRoot;
  yamlRoot["file_id"]    = fFileID;
  yamlRoot["dataset_id"] = fDatasetID;
 
  for (int iObj = 0; iObj < nObjects; ++iObj) {
    std::vector<TNamed*> vpObjects(nVersions, nullptr);
    bool skipObj = false;
    const auto& objPair        = fpObjDB->GetObject(fFileID, iObj);
    const std::string& objName = objPair.first;
    const uint32_t paramIndex  = objPair.second;
    const auto& params         = fpObjDB->GetObjectParameters(paramIndex);
 
 
    for (int iVer = 0; iVer < nVersions; ++iVer) {
      auto* pInputFile = static_cast<TFile*>(fpInputFiles->At(iVer));
      if (!pInputFile) {
        skipObj = true;
        continue;
      }
      vpObjects[iVer] = dynamic_cast<TNamed*>(pInputFile->Get(objName.c_str()));
      if (!vpObjects[iVer]) {
        skipObj = true;
      }
    }
 
    if (skipObj) continue;
 
    std::string sOption = params.compMethod;
    for (auto& ch : sOption)
      ch = std::tolower(ch);
    bool bSuppressCanvases = sOption.find("b") != std::string::npos;
    bool bForceCanvases    = sOption.find("c") != std::string::npos;
    bool bCmpExact         = sOption.find("e") != std::string::npos;
    bool bCmpChi2          = sOption.find("s") != std::string::npos;
    bool bCmpRatio         = sOption.find("u") != std::string::npos;
    bool bDumpResult       = sOption.find("o") != std::string::npos;
 
    if (iObj != 0 && iObj % 500 == 0) {
      ReOpenOutputFile();
      LOG(info) << "FileHandler: object " << iObj << " / " << nObjects;
    }
 
    std::unique_ptr<ObjectHandler> pObjHandler = nullptr;
 
    if (dynamic_cast<TProfile*>(vpObjects[0])) {
      pObjHandler = std::make_unique<Profile1DHandler>(iObj, fFileID, fDatasetID);
    }
    else if (dynamic_cast<TH2*>(vpObjects[0])) {
      pObjHandler = std::make_unique<Hist2DHandler>(iObj, fFileID, fDatasetID);
    }
    else if (dynamic_cast<TH1*>(vpObjects[0])) {
      pObjHandler = std::make_unique<Hist1DHandler>(iObj, fFileID, fDatasetID);
    }
    else {
      LOG(warn) << "FileHandler: Object " << objName << " has a type \"" << vpObjects[0]->ClassName()
                << "\", which is unknown to the checker framework, it will be skipped";
      continue;
    }
    if (bCmpExact) {
      pObjHandler->SetComparisonMethod(ECmpMethod::Exact);  // Compare point-by-point (exact equality)
    }
    if (bCmpChi2) {
      pObjHandler->SetComparisonMethod(ECmpMethod::Chi2);  // Compare with chi2 test
    }
    if (bCmpRatio) {
      pObjHandler->SetComparisonMethod(ECmpMethod::Ratio);
    }
    fpObjDB->SetRatioRange(params.ratioMin, params.ratioMax);
    fpObjDB->SetPvalThreshold(params.pvalThreshold);
    pObjHandler->SetObjectDB(fpObjDB);
    pObjHandler->SetOutputDirectory(CreateNestedDirectory(objName));
    pObjHandler->AddObjects(vpObjects);
    auto cmpResultObject = pObjHandler->CompareWithDefault();
 
 
    for (int iVer = 0; iVer < nVersions; ++iVer) {
      bCmpResult[iVer].SetCmpInference(
        std::max(cmpResultObject[iVer].GetCmpInference(), bCmpResult[iVer].GetCmpInference()));
    }
 
 
    if (!bSuppressCanvases
        && (bForceCanvases || std::any_of(cmpResultObject.begin(), cmpResultObject.end(), [](auto i) {
              return i.GetCmpInference() != ECmpInference::StronglyEqual;
            }))) {
      pObjHandler->CreateCanvases(sOption.c_str());
    }
    pObjHandler->Write();
 
    // Write the comparison result to file
    if (bDumpResult) {
      for (int iVer = 0; iVer < nVersions; ++iVer) {
        std::string name = "result_" + fpObjDB->GetVersionLabel(iVer);
        cmpResultObject[iVer].Write(name.c_str());
        //LOG(info) << "FileHandler: object " << iObj << " / " << nObjects
        //     << ", version " << iVer << ": " << cmpResultObject[iVer].GetPVal();
      }
    }
 
    gFile->Flush();
 
    for (auto*& pObj : vpObjects) {
      delete pObj;
      pObj = nullptr;
    }
  }
 
 
  LOG(info) << "FileHandler: processing objects: done";
  return bCmpResult;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
void FileHandler::ReOpenOutputFile()
{
  if (fpOutputFile.get()) {
    fpOutputFile->Flush();
    fpOutputFile->Close();
    fpOutputFile = nullptr;
    fpOutDir     = nullptr;
  }
  fpOutputFile    = std::make_unique<TFile>(fpObjDB->GetOutputPath().c_str(), "UPDATE");
  TString dirName = fpObjDB->GetDataset(fDatasetID) + "/" + fpObjDB->GetFileLabel(fFileID);
  fpOutDir        = fpOutputFile->Get<TDirectory>(dirName);
}