CbmQaTask.h

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] */
 
 
#pragma once
 
#include "CbmEvent.h"
#include "CbmQaCompare.h"
#include "CbmQaIO.h"
#include "CbmQaTable.h"
#include "FairTask.h"
#include "Logger.h"
#include "TCanvas.h"
#include "TEfficiency.h"
#include "TFile.h"
#include "TFolder.h"
#include "TH1.h"
#include "TH2.h"
#include "TH3.h"
#include "TParameter.h"
#include "TProfile.h"
#include "TProfile2D.h"
#include "TProfile3D.h"
#include "TROOT.h"
#include "TString.h"
 
#include <algorithm>
#include <map>
#include <regex>
#include <string_view>
#include <tuple>
#include <type_traits>
 
#include <yaml-cpp/yaml.h>
 
class CbmEvent;
class TClonesArray;
 
class CbmQaTask : public FairTask, public CbmQaIO {
  struct CheckFlags {
    std::string fMsg = "";     
    bool fResult     = false;  
    bool fStatus     = false;  
  };
 
  struct ObjectComparisonConfig {
    uint8_t fPoint       = 0;
    uint8_t fRatio       = 0;
    uint8_t fStat        = 0;
    double fRatioMin     = 0;
    double fRatioMax     = std::numeric_limits<double>::max();
    double fChi2NdfMax   = std::numeric_limits<double>::max();
    std::string fStatOpt = "UU";
    std::string fCanvOpt = "";
  };
 
 public:
  CbmQaTask(const char* name, int verbose, bool isMCUsed, ECbmRecoMode recoMode = ECbmRecoMode::Timeslice);
 
  CbmQaTask() = delete;  // TODO: Let's see, what can happen, if one deletes default constructor
 
  virtual ~CbmQaTask() = default;
 
  CbmQaTask(const CbmQaTask&) = delete;
 
  CbmQaTask(CbmQaTask&&) = delete;
 
  CbmQaTask& operator=(const CbmQaTask&) = delete;
 
  CbmQaTask& operator=(CbmQaTask&&) = delete;
 
  virtual void Check() = 0;
 
  bool CompareQaObjects();
 
  void DisableEventMode();
 
 
  const std::map<std::string, CheckFlags>& GetCheckList() const { return fmCheckList; }
 
  const TString& GetDefaultTag() const { return fsDefaultTag; }
 
  const std::string& GetSetupName() const { return fsSetupName; }
 
  const TString& GetVersionTag() const { return fsVersionTag; }
 
 
  bool IsMCUsed() const { return fbUseMC; }
 
  void ReadCheckListFromConfig();
 
 
  void SetCheckFile(const std::shared_ptr<TFile>& pCheckFile) { fpBenchmarkInput = pCheckFile; }
 
  void SetCompareOutput(const std::shared_ptr<TFile>& pCompareOutput) { fpBenchmarkOutput = pCompareOutput; }
 
  void SetVersionTag(const TString& tag) { fsVersionTag = tag; }
 
  void SetDefaultTag(const TString& tag) { fsDefaultTag = tag; }
 
  void SetRecoMode(ECbmRecoMode recoMode) { fRecoMode = recoMode; }
 
  void SetSetupName(const char* setup) { fsSetupName = setup; }
 
 protected:
  virtual void DeInit() {}
 
  void Exec(Option_t* /*option*/) override final;
 
  void Finish() override final;
 
  InitStatus Init() override final;
 
  InitStatus ReInit() override final;
 
  virtual InitStatus InitQa() { return kSUCCESS; }
 
  virtual void CreateSummary() {}
 
  virtual void ExecQa() {}
 
  int GetEventNumber() const { return fNofEvents.GetVal(); }
 
  // ***********************
  // ** Utility functions **
  // ***********************
 
  template<typename T>
  bool CheckRange(std::string_view name, T var, T lo, T hi) const;
 
  template<typename T>
  bool CheckRange(std::string_view name, T var, T varErr, T lo, T hi) const;
 
  bool CheckRange(TH1* h, double meanMax, double rmsMin, double rmsMax);
 
  void PutSetupNameOnPad(double xMin, double yMin, double xMax, double yMax);
 
  CbmEvent* GetCurrentEvent() { return fpCurrentEvent; }
 
  void StoreCheckResult(const std::string& tag, bool result, const std::string& msg = "");
 
 private:
  void DeInitBase();
 
  template<class Obj>
  bool CompareTwoObjects(const TObject* pObjL, const TObject* pObjR, const TString& objName,
                         const ObjectComparisonConfig& cfg);
 
  bool fbUseMC = false;  
 
  ECbmRecoMode fRecoMode = ECbmRecoMode::Timeslice;  
 
  std::map<std::string, CheckFlags> fmCheckList;
 
  TClonesArray* fpBrEvents = nullptr;  
  CbmEvent* fpCurrentEvent = nullptr;  
  std::string fsSetupName = "";  
  TParameter<int> fNofEvents{"nEvents", 0};  
 
  TString fsVersionTag = "";  
  TString fsDefaultTag = "";  
 
  std::shared_ptr<TFile> fpBenchmarkInput  = nullptr;  
  std::shared_ptr<TFile> fpBenchmarkOutput = nullptr;  
 
  ClassDefOverride(CbmQaTask, 0);
};
 
 
// *************************************************
// ** Inline and template function implementation **
// *************************************************
 
// ---------------------------------------------------------------------------------------------------------------------
//
template<typename T>
bool CbmQaTask::CheckRange(std::string_view name, T var, T lo, T hi) const
{
  return CheckRange<T>(name, var, 0., lo, hi);
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
template<typename T>
bool CbmQaTask::CheckRange(std::string_view name, T var, T varErr, T lo, T hi) const
{
  bool ret = true;
  if (var + 3.5 * varErr < lo) {
    LOG(error) << fName << ": " << name << " is found to be under the lower limit (" << var << " +- 3.5 x " << varErr
               << " < " << lo << ')';
    ret = false;
  }
  if (var - 3.5 * varErr > hi) {
    LOG(error) << fName << ": " << name << " is found to be above the upper limit (" << var << " +-3.5 x " << varErr
               << " > " << hi << ')';
    ret = false;
  }
  if (ret) {
    LOG(debug) << fName << ": " << name << " is found to be within limit (" << lo << " <= " << var << " +- 3.5 x "
               << varErr << " <= " << hi << ')';
  }
  return ret;
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
template<class Obj>
bool CbmQaTask::CompareTwoObjects(const TObject* pObjL, const TObject* pObjR, const TString& objName,
                                  const ObjectComparisonConfig& cfg)
{
  const auto* pHistL = static_cast<const Obj*>(pObjL);
  const auto* pHistR = dynamic_cast<const Obj*>(pObjR);
  if (!pHistR) {
    LOG(error) << fName << "::CompareObjects(): the default " << pObjR->GetName()
               << " has different type to the new object";
    return false;
  }
  std::string opt = "";
  if (cfg.fPoint > 0) {
    opt += "p";
  }
  if (cfg.fRatio > 0) {
    opt += "r";
  }
  if (cfg.fStat > 0) {
    opt += "s";
  }
 
  auto comparator = CbmQaCompare<Obj>(pHistL, pHistR, 0);
  auto out        = comparator(opt, cfg.fStatOpt);
 
  if (!out.fConsistent) {
    LOG(info) << fName << ": This and default versions of the object " << pObjL->GetName() << " are incompatible";
    return false;
  }
 
  // Collect status and print log
  bool res = true;
  {
    std::stringstream msg;
    using std::setw;
    constexpr const char* kEqual = "\e[1;32mequal\e[0m";
    constexpr const char* kDiff  = "\e[1;32mdifferent\e[0m";
    msg << "\tobject " << setw(12) << pObjL->ClassName() << ' ' << setw(50) << objName;
    if (cfg.fPoint) {
      msg << ": point-by-point -> " << (out.fPointByPoint ? kEqual : kDiff);
      if (cfg.fPoint == 2) {
        res &= out.fPointByPoint;
      }
    }
    if (cfg.fRatio) {
      bool bOk = (out.fRatioLo >= cfg.fRatioMin && out.fRatioUp <= cfg.fRatioMax);
      msg << ", ratio -> " << (bOk ? kEqual : kDiff) << "(lo: " << out.fRatioLo << ", up: " << out.fRatioUp << ')';
      if (cfg.fRatio == 2) {
        res &= bOk;
      }
    }
    if (cfg.fStat) {
      bool bOk = out.fChi2NDF <= cfg.fChi2NdfMax;
      msg << ", stat. test -> " << (bOk ? kEqual : kDiff) << "(chi2/NDF: " << out.fChi2NDF << ')';
      if (cfg.fStat == 2) {
        res &= bOk;
      }
    }
    LOG(info) << msg.str();
  }
 
  // Write comparison result
  if (fpBenchmarkOutput.get()) {
    fpBenchmarkOutput->mkdir(objName);
    auto* pDir = fpBenchmarkOutput->GetDirectory(objName);
    pDir->cd();
    pObjL->Write(Form("%s_%s", pObjL->GetName(), fsVersionTag.Data()));
    pObjR->Write(Form("%s_%s", pObjL->GetName(), fsDefaultTag.Data()));
    if (true || !res) {  // Save canvas only if the histograms are different
      auto* pCanv = comparator.GetComparisonCanvas(cfg.fCanvOpt);
      if (pCanv) {
        pCanv->Write(Form("%s_cmp_canvas", pObjL->GetName()));
        delete pCanv;
      }
    }
  }
  return res;
}