core/qa/CMakeLists.txt

@@ -11,6 +11,7 @@ set(SRCS
   CbmQaTable.cxx
   CbmQaTask.cxx
   CbmQaIO.cxx
+  CbmQaUtil.cxx
   checker/CbmQaCheckerCore.cxx
   checker/CbmQaCheckerFileHandler.cxx
   checker/CbmQaCheckerHist1DHandler.cxx
@@ -52,6 +53,7 @@ Install(FILES
         CbmQaHist.h
         CbmQaEff.h
         CbmQaPie.h
+        CbmQaUtil.h
         CbmQaConstants.h
         CbmQaCmpDrawer.h
         checker/CbmQaCheckerTypedefs.h

core/qa/CbmQaIO.cxx

@@ -13,25 +13,49 @@
 
 // ---------------------------------------------------------------------------------------------------------------------
 //
-CbmQaIO::CbmQaIO(const char* prefixName, std::shared_ptr<ObjList_t> pObjList)
-  : fsPrefix(prefixName)
-  , fpvObjList(pObjList)
+CbmQaIO::CbmQaIO(TString prefixName, std::shared_ptr<ObjList_t> pObjList) : fsPrefix(prefixName), fpvObjList(pObjList)
 {
+  if (!fsPrefix.IsNull()) { fsPrefix += "_"; }
   if (!fpvObjList.get()) { fpvObjList = std::make_shared<ObjList_t>(); }
 }
 
 // ---------------------------------------------------------------------------------------------------------------------
 //
-CbmQaIO::~CbmQaIO()
+CbmQaIO::~CbmQaIO() {}
+
+// ---------------------------------------------------------------------------------------------------------------------
+//
+void CbmQaIO::SetHistoProperties(TH1* pHist) { pHist->SetStats(true); }
+
+// ---------------------------------------------------------------------------------------------------------------------
+//
+void CbmQaIO::SetCanvasProperties(TCanvas* pCanv)
 {
+  constexpr double left   = 0.15;
+  constexpr double bottom = 0.15;
+  constexpr double right  = 0.10;
+  constexpr double top    = 0.10;
+  pCanv->SetMargin(left, right, bottom, top);
 }
 
 // ---------------------------------------------------------------------------------------------------------------------
 //
-void CbmQaIO::SetHistoProperties(TH1* pHist)
+void CbmQaIO::SetConfigName(const char* path)
 {
-  pHist->SetStats(true);
-  pHist->Sumw2();
+  fsConfigName = path;
+  try {
+    fConfigNode = YAML::LoadFile(path)["qa"][fsPrefix.Data()];
+  }
+  catch (const YAML::BadFile& exc) {
+    std::stringstream msg;
+    msg << "configuration file for QA \"" << path << "\" does not exist";
+    throw std::runtime_error(msg.str());
+  }
+  catch (const YAML::ParserException& exc) {
+    std::stringstream msg;
+    msg << "configuration file for QA \"" << path << "\" is improperly formatted";
+    throw std::runtime_error(msg.str());
+  }
 }
 
 // ---------------------------------------------------------------------------------------------------------------------
@@ -40,9 +64,9 @@ void CbmQaIO::WriteToFile(TFile* pOutFile) const
 {
   LOG(info) << "CbmQaIO: Writing objects in file \033[1;31m" << pOutFile->GetName() << "\033[0m";
   pOutFile->cd();
-  for (const auto& [pObject, sPath] : (*fpvObjList)) {
+  for (auto& [pObject, sPath] : (*fpvObjList)) {
     if (!pOutFile->GetDirectory(sPath)) { pOutFile->mkdir(sPath); }
     pOutFile->cd(sPath);
-    pObject->Write();
+    if (pObject) { pObject->Write(); }
   }
 }

core/qa/CbmQaIO.h

@@ -10,6 +10,8 @@
 #ifndef CbmQaIO_h
 #define CbmQaIO_h 1
 
+#include "CbmQaCanvas.h"
+#include "CbmQaEff.h"
 #include "CbmQaTable.h"
 
 #include "Logger.h"
@@ -27,8 +29,12 @@
 #include "TROOT.h"
 #include "TString.h"
 
+#include <limits>
+#include <type_traits>
 #include <vector>
 
+#include <yaml-cpp/yaml.h>
+
 class TFile;
 
 /// @brief  ROOT object IO interface for QA
@@ -40,14 +46,14 @@ public:
 
   enum class EStoringMode
   {
-    kSAMEDIR,  ///< Objects will be stored to root directory
-    kSUBDIR    ///< Objects will be stored to corresponding subdirectory
+    kSAMEDIR,  ///< Objects of different type will be stored to root directory
+    kSUBDIR    ///< Objects of different type will be stored in different subdirectories like histograms/ canvases/
   };
 
   /// @brief Constructor
   /// @param prefixName    Name of the unique prefix
-  /// @param pParentFolder Pointer to parent folder
-  CbmQaIO(const char* prefixName, std::shared_ptr<ObjList_t> pObjList = nullptr);
+  /// @param pObjList      List of already created objects
+  CbmQaIO(TString prefixName, std::shared_ptr<ObjList_t> pObjList = nullptr);
 
   /// @brief Destructor
   virtual ~CbmQaIO();
@@ -64,132 +70,244 @@ public:
   /// @brief Move assignment operator
   CbmQaIO& operator=(CbmQaIO&&) = delete;
 
-  /// @brief Creates, initializes and registers a canvas
-  /// @tparam  T     Type of the canvas: TCanvas or CbmQaCanvas (\note T should not be a pointer)
-  /// @param   name  Name of canvas
-  /// @param   args  The rest of the arguments, which will be passed to the canvas constructor
-  template<typename T, typename... Args>
-  T* MakeCanvas(const char* name, Args... args);
 
-  /// @brief Creates, initializes and registers an efficiency
-  /// @tparam  T     Type of the canvas: either TProfile, TProfile1D or TEfficiency (\note T should not be a pointer)
-  /// @param   name  Name of canvas
-  /// @param   args  The rest of the arguments, which will be passed to the efficiency constructor
+  /// @brief Gets config name
+  const char* GetConfigName() const { return fsConfigName.Data(); }
+
+  /// @brief Creates a QA (ROOT) object, using properties defined with a tag in config
+  /// @tparam T       Type of the object
+  /// @param sName    Name of the object
+  /// @param sTitle   Title of the object
+  /// @param args...  The rest of the arguments, which will be passed to the histogram constructor
+  /// @note Tag is defined after the last ';' symbol in the nameBase string
+  /// @example
+  ///    nambeBase = "/stations/station0/xy_occupancy;xy_station0" will be decayed into:
+  ///    1) subdirectory "stations/station0"
+  ///    2) name of histogram "catrd_hit_xy_occupancy"
+  ///    3) tag for configuration file "xy_station0"
+  /// If configuration file or tag are not defined, default parameters will be used
   template<typename T, typename... Args>
-  T* MakeEfficiency(const char* name, Args... args);
-
-  /// @brief Creates, initializes and registers a histogram
-  /// @tparam  T     Type of the histogram (\note T should not be a pointer)
-  /// @param   name  Name of histogram
-  /// @param   args  The rest of the arguments, which will be passed to the histogram constructor
-  template<typename T, typename... Args>
-  T* MakeHisto(const char* name, Args... args);
-
-  /// @brief Creates, initializes and registers a table
-  /// @param  name  Name of the table
-  /// @param  args  The rest of the arguments, which will be passed to the table constructor
-  template<typename... Args>
-  CbmQaTable* MakeTable(const char* name, Args... args);
+  T* MakeQaObject(TString sName, TString sTitle, Args... args);
 
   /// @brief Creates a ROOT object
-  /// @param name    Name of the object
-  /// @param args... Arguments passed to the object constructor
-  template<typename T, typename... Args>
-  T* MakeObject(const char* name, Args... args);
+  /// @brief Sets config name
+  /// @param name  A path to the config
+  void SetConfigName(const char* path);
 
   /// @brief Sets a common root path to the objects in the output file
   /// @param path  A path to the object
-  void SetRootFolderName(const char* path) { fsRootFolderName = path; }
+  void SetRootFolderName(const TString& path) { fsRootFolderName = path.Strip(TString::kBoth, '/'); }
+
+  /// @brief Set storing mode
+  void SetStoringMode(EStoringMode mode) { fStoringMode = mode; }
 
 protected:
-  /// @brief Applies properties on the histogram created with MakeHisto funciton
-  /// @param pHist  Pointer to histogram
-  virtual void SetHistoProperties(TH1* /*pHits*/);
+  /// @brief Function to check, if a property is defined
+  /// @param property  A property to be tested
+  /// @param name      A name of property (used for logging)
+  /// @note  Throws an exception, if property is undefined
+  template<typename T>
+  void CheckProperty(T&& property, const char* name) const;
+
+  /// @brief Applies properties on the histogram created with the MakeQaObject function
+  /// @param pHist  Pointer to the histogram
+  virtual void SetHistoProperties(TH1* pHist);
+
+  /// @brief Applies properties on the canvas created with the MakeQaObject funciton
+  /// @param pCanv  Pointer to the canvas
+  virtual void SetCanvasProperties(TCanvas* pCanv);
 
   /// @brief Writes objects into file
   /// @param pOutFile Pointer to output ROOT file
   void WriteToFile(TFile* pOutFile) const;
 
+
   TString fsRootFolderName = "";  ///< Name of root folder
+  TString fsConfigName     = "";  ///< Name of configuration file
   TString fsPrefix         = "";  ///< Unique prefix for all writeable root
 
   EStoringMode fStoringMode             = EStoringMode::kSUBDIR;  ///< Objects storing mode
   std::shared_ptr<ObjList_t> fpvObjList = nullptr;                ///< List of registered ROOT objects
+
+  YAML::Node fConfigNode {};  ///< Configuration node
+
+private:
+  /// @brief Creates and registers a ROOT object
+  /// @param name  A name of the ROOT object, which can contain a sub-directory
+  /// @param args  Other arguments, passed to the ROOT object constructor
+  template<typename T, typename... Args>
+  T* ConstructAndRegisterQaObject(TString name, Args... args);
 };
 
 
 // ---------------------------------------------------------------------------------------------------------------------
 //
-template<typename T, typename... Args>
-T* CbmQaIO::MakeCanvas(const char* nameBase, Args... args)
+template<typename T>
+void CbmQaIO::CheckProperty(T&& property, const char* name) const
 {
-  TString sFullName = EStoringMode::kSUBDIR == fStoringMode ? Form("canvases/%s", nameBase) : nameBase;
-  auto* pCanv       = MakeObject<T>(sFullName, args...);
-  return pCanv;
-}
+  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);
+  }
 
-// ---------------------------------------------------------------------------------------------------------------------
-//
-template<typename T, typename... Args>
-T* CbmQaIO::MakeEfficiency(const char* nameBase, Args... args)
-{
-  TString sFullName = EStoringMode::kSUBDIR == fStoringMode ? Form("efficiencies/%s", nameBase) : nameBase;
-  auto* pEff        = MakeObject<T>(sFullName, args...);
-  return pEff;
+  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::MakeHisto(const char* nameBase, Args... args)
+T* CbmQaIO::ConstructAndRegisterQaObject(TString sName, Args... args)
 {
-  TString sFullName = EStoringMode::kSUBDIR == fStoringMode ? Form("histograms/%s", nameBase) : nameBase;
-  auto* pHist       = MakeObject<T>(sFullName, args...);
-  pHist->SetDirectory(0);
-  SetHistoProperties(pHist);
-  return pHist;
-}
+  if constexpr (std::is_base_of_v<CbmQaTable, T>) { static_assert(sizeof...(Args) == 3); }
 
-// ---------------------------------------------------------------------------------------------------------------------
-//
-template<typename T, typename... Args>
-T* CbmQaIO::MakeObject(const char* name, Args... args)
-{
   // Resolve directory name and object name
-  TString sObjName   = name;
-  auto iLastSlashPos = static_cast<int>(sObjName.Last('/'));
-  TString sDirName   = sObjName(0, iLastSlashPos);
-  sObjName           = sObjName(iLastSlashPos + 1, sObjName.Length() - iLastSlashPos);
-
-  // Add unique prefix to the object name
-  sObjName = fsPrefix + "_" + sObjName;
-
-  // Add parent directory to the folder
-  if (fsRootFolderName.Length() != 0) { sDirName = fsRootFolderName + "/" + sDirName; }
-
-  // Check, if an object with the same name already exists
-  if (gROOT->FindObject(sObjName)) {
-    LOG(warn) << fsRootFolderName << ": A previously created object \"" << sObjName << "\" will be deleted";
-    auto* pObj = static_cast<T*>(gROOT->FindObject(sObjName));
-    delete pObj;
-  }
+  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(sObjName, args...);
+  T* pObj = new T(sName.Data(), args...);
+
+  // Take object ownership from ROOT and apply user-defined properties
+  if constexpr (std::is_base_of_v<TH1, T>) {  // histograms
+    pObj->SetDirectory(0);
+    SetHistoProperties(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) { sDirectory = fsRootFolderName + "/" + sDirectory; }
+
+  // Register the object in the list
+  fpvObjList->push_back(std::make_pair(static_cast<TObject*>(pObj), sDirectory));
 
-  // Register the object into an object list
-  fpvObjList->push_back(std::make_pair(static_cast<TObject*>(pObj), sDirName));
   return pObj;
 }
 
 // ---------------------------------------------------------------------------------------------------------------------
 //
-template<typename... Args>
-CbmQaTable* CbmQaIO::MakeTable(const char* nameBase, Args... args)
+template<typename T, typename... Args>
+T* CbmQaIO::MakeQaObject(TString sName, TString sTitle, Args... args)
 {
-  TString sFullName = EStoringMode::kSUBDIR == fStoringMode ? Form("tables/%s", nameBase) : nameBase;
-  auto* pTable      = MakeObject<CbmQaTable>(sFullName, args...);
-  return pTable;
+  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; }
+      }
+    }
+  }
+
+  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

core/qa/CbmQaIO.h.orig

+/* Copyright (C) 2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Sergei Zharko [committer] */
+
+/// @file   CbmQaIO.h
+/// @brief  Module for ROOT objects IO interface (header)
+/// @author S.Zharko <s.zharko@gsi.de>
+/// @since   29.03.2023
+
+#ifndef CbmQaIO_h
+#define CbmQaIO_h 1
+
+#include "CbmQaCanvas.h"
+#include "CbmQaEff.h"
+#include "CbmQaTable.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 <type_traits>
+#include <vector>
+
+<<<<<<< HEAD
+=======
+#include <yaml-cpp/yaml.h>
+>>>>>>> QA: Added posibility of configuring histogram binning in CbmQaTask; Clean-up of CbmCaInputQaTrd
+
+class TFile;
+
+/// @brief  ROOT object IO interface for QA
+///
+/// The class provides interface to write ROOT object into resulted files
+class CbmQaIO {
+public:
+  using ObjList_t = std::vector<std::pair<TObject*, TString>>;
+
+  enum class EStoringMode
+  {
+    kSAMEDIR,  ///< Objects of different type will be stored to root directory
+    kSUBDIR    ///< Objects of different type will be stored in different subdirectories like histograms/ canvases/
+  };
+
+  /// @brief Constructor
+  /// @param prefixName    Name of the unique prefix
+  /// @param pObjList      List of already created objects
+  CbmQaIO(TString prefixName, std::shared_ptr<ObjList_t> pObjList = nullptr);
+
+  /// @brief Destructor
+  virtual ~CbmQaIO();
+
+  /// @brief Copy constructor
+  CbmQaIO(const CbmQaIO&) = delete;
+
+  /// @brief Move constructor
+  CbmQaIO(CbmQaIO&&) = delete;
+
+  /// @brief Copy assignment operator
+  CbmQaIO& operator=(const CbmQaIO&) = delete;
+
+  /// @brief Move assignment operator
+  CbmQaIO& operator=(CbmQaIO&&) = delete;
+
+<<<<<<< HEAD
+  /// Set storing mode
+  void SetStoringMode(EStoringMode val) { fStoringMode = val; }
+
+  /// @brief Sets a common root path to the objects in the output file
+  /// @param path  A path to the object
+  void SetRootFolderName(TString path) { fsRootFolderName = path; }
+
+  /// @brief Creates a ROOT object
+  /// @param name    Name of the object including the path
+  /// @param args... Arguments passed to the object constructor
+  template<typename T, typename... Args>
+  T* MakeQaObject(TString name, Args... args);
+=======
+  /// @brief Gets config name
+  const char* GetConfigName() const { return fsConfigName.Data(); }
+>>>>>>> QA: Added posibility of configuring histogram binning in CbmQaTask; Clean-up of CbmCaInputQaTrd
+
+  /// @brief Creates, initializes and registers a canvas
+  /// @tparam  T     Type of the canvas: TCanvas or CbmQaCanvas (\note T should not be a pointer)
+  /// @param   name  Name of canvas
+  /// @param   args  The rest of the arguments, which will be passed to the canvas constructor
+  template<typename T, typename... Args>
+  T* MakeCanvas(TString name, Args... args);
+
+  /// @brief Creates, initializes and registers an efficiency
+  /// @tparam  T     Type of the canvas: either TProfile, TProfile1D or TEfficiency (\note T should not be a pointer)
+  /// @param   name  Name of canvas
+  /// @param   args  The rest of the arguments, which will be passed to the efficiency constructor
+  template<typename T, typename... Args>
+  T* MakeEfficiency(TString name, Args... args);
+
+  /// @brief Creates, initializes and registers a histogram
+  /// @tparam  T     Type of the histogram (\note T should not be a pointer)
+  /// @param   name  Name of histogram
+  /// @param   args  The rest of the arguments, which will be passed to the histogram constructor
+  template<typename T, typename... Args>
+  T* MakeHisto(TString name, Args... args);
+
+  /// @brief Creates histogram, using properties defined with a tag in config
+  /// @param nameBase  Name of the histogram
+  /// @param args      The rest of the arguments, which will be passed to the histogram constructor
+  /// @note Tag is defined after the last ';' symbol in the nameBase string
+  /// @example
+  ///    nambeBase = "/foo/bar/hit_xy_occupancy_station0;xy_station0" will be decayed into:
+  ///    1) subdirectory /foo/bar
+  ///    2) name of histogram "catrd_hit_xy_occupancy_station0"
+  ///    3) tag for configuration file "xy_station0"
+  /// If configuration file or tag are not defined, default parameters will be used
+  template<typename T, typename... Args>
+  T* MakeHistoConfig(const char* nameBase, const char* title, Args... args);
+
+  /// @brief Creates, initializes and registers a table
+  /// @param  name  Name of the table
+  /// @param  args  The rest of the arguments, which will be passed to the table constructor
+  template<typename... Args>
+  CbmQaTable* MakeTable(TString name, Args... args);
+
+<<<<<<< HEAD
+=======
+  /// @brief Creates a ROOT object
+  /// @param name    Name of the object
+  /// @param args... Arguments passed to the object constructor
+  template<typename T, typename... Args>
+  T* MakeObject(const char* name, Args... args);
+
+  /// @brief Sets config name
+  /// @param name  A path to the config
+  void SetConfigName(const char* path);
+
+  /// @brief Sets a common root path to the objects in the output file
+  /// @param path  A path to the object
+  void SetRootFolderName(const char* path) { fsRootFolderName = path; }
+>>>>>>> QA: Added posibility of configuring histogram binning in CbmQaTask; Clean-up of CbmCaInputQaTrd
+
+protected:
+  /// @brief Function to check, if a property is defined
+  /// @param property  A property to be tested
+  /// @param name      A name of property (used for logging)
+  /// @note  Throws an exception, if property is undefined
+  template<typename T>
+  void CheckProperty(T&& property, const char* name) const;
+
+  /// @brief Applies properties on the histogram created with MakeHisto funciton
+  /// @param pHist  Pointer to histogram
+  virtual void SetHistoProperties(TH1* /*pHits*/);
+
+  /// @brief Writes objects into file
+  /// @param pOutFile Pointer to output ROOT file
+  void WriteToFile(TFile* pOutFile) const;
+
+
+  TString fsRootFolderName = "";  ///< Name of root folder
+  TString fsConfigName     = "";  ///< Name of configuration file
+  TString fsPrefix         = "";  ///< Unique prefix for all writeable root
+
+  EStoringMode fStoringMode             = EStoringMode::kSUBDIR;  ///< Objects storing mode
+  std::shared_ptr<ObjList_t> fpvObjList = nullptr;                ///< List of registered ROOT objects
+
+  YAML::Node fConfigNode {};  ///< Configuration node
+};
+
+
+// ---------------------------------------------------------------------------------------------------------------------
+//
+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::MakeQaObject(TString sObjName, Args... args)
+{
+  // Resolve directory name and object name
+  auto iLastSlashPos = static_cast<int>(sObjName.Last('/'));
+  TString sDirName   = sObjName(0, iLastSlashPos);
+  sObjName           = sObjName(iLastSlashPos + 1, sObjName.Length() - iLastSlashPos);
+
+  // Add unique prefix to the object name
+  sObjName = fsPrefix + sObjName;
+
+  // Check, if an object with the same name already exists
+  // TODO: check if this makes sense and doesn't crash the memory
+  //if (gROOT->FindObject(sObjName)) {
+  //  LOG(warn) << fsRootFolderName << ": A previously created object \"" << sObjName << "\" will be deleted";
+  //  auto* pObj = static_cast<T*>(gROOT->FindObject(sObjName));
+  //  delete pObj;
+  //}
+
+  // Create a new object
+  T* pObj = new T(sObjName, args...);
+
+  // specific stuff for different kind of objects
+
+  TH1* pH1 = dynamic_cast<TH1*>(pObj);
+
+  if (pH1) {               // any kind of histogram
+    pH1->SetDirectory(0);  // don't let ROOT own the histogram. The user should take care on deleting it.
+    SetHistoProperties(pH1);
+  }
+
+  TString sPrefix = "";
+  if (EStoringMode::kSUBDIR == fStoringMode) {
+    if (dynamic_cast<CbmQaTable*>(pObj) || dynamic_cast<CbmQaCanvas*>(pObj)) { sPrefix = "summary/"; }
+  }
+
+  // Add parent directory to the folder
+  if (fsRootFolderName.Length() != 0) { sDirName = fsRootFolderName + "/" + sPrefix + sDirName; }
+
+  // Register the object into an object list
+  fpvObjList->push_back(std::make_pair(static_cast<TObject*>(pObj), sDirName));
+  return pObj;
+}
+
+
+// ---------------------------------------------------------------------------------------------------------------------
+//
+template<typename T, typename... Args>
+T* CbmQaIO::MakeCanvas(TString nameBase, Args... args)
+{
+  return MakeQaObject<T>(nameBase, args...);
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+//
+template<typename T, typename... Args>
+T* CbmQaIO::MakeEfficiency(TString nameBase, Args... args)
+{
+  return MakeQaObject<T>(nameBase, args...);
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+//
+template<typename T, typename... Args>
+<<<<<<< HEAD
+T* CbmQaIO::MakeHisto(TString nameBase, Args... args)
+=======
+T* CbmQaIO::MakeHistoConfig(const char* nameBase, const char* title, Args... args)
+{
+  TString sObjName = nameBase;
+  auto iLastSepPos = static_cast<int>(sObjName.Last(';'));
+  TString sTagName = sObjName(iLastSepPos + 1, sObjName.Length() - iLastSepPos);
+  sObjName         = sObjName(0, iLastSepPos);
+
+  bool bUseConfig = false;
+  // Check, if parameters are provided for this tag
+  if (fConfigNode) {
+    if (fConfigNode["histograms"]) {
+      if (fConfigNode["histograms"][sTagName.Data()]) { bUseConfig = true; }
+    }
+  }
+
+  if (bUseConfig) {
+    const auto& tagNode = fConfigNode["histograms"][sTagName.Data()];
+
+    int nBinsX                   = -1;
+    double minX                  = std::numeric_limits<double>::signaling_NaN();
+    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 (tagNode["x"]) {
+      nBinsX = tagNode["x"]["nbins"].as<int>();
+      minX   = tagNode["x"]["min"].as<double>();
+      maxX   = tagNode["x"]["max"].as<double>();
+    }
+    if (tagNode["y"]) {
+      nBinsY = tagNode["y"]["nbins"].as<int>();
+      minY   = tagNode["y"]["min"].as<double>();
+      maxY   = tagNode["y"]["max"].as<double>();
+    }
+    if (tagNode["z"]) {
+      nBinsZ = tagNode["z"]["nbins"].as<int>();
+      minZ   = tagNode["z"]["min"].as<double>();
+      maxZ   = tagNode["z"]["max"].as<double>();
+    }
+
+    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 MakeHisto<T>(sObjName.Data(), 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 MakeHisto<T>(sObjName.Data(), 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 MakeHisto<T>(sObjName.Data(), 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 MakeHisto<T>(sObjName.Data(), 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 MakeHisto<T>(sObjName.Data(), title, nBinsX, minX, maxX);
+    }
+  }
+  else {
+    return MakeHisto<T>(sObjName.Data(), title, args...);
+  }
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+//
+template<typename T, typename... Args>
+T* CbmQaIO::MakeObject(const char* name, Args... args)
+>>>>>>> QA: Added posibility of configuring histogram binning in CbmQaTask; Clean-up of CbmCaInputQaTrd
+{
+  return MakeQaObject<T>(nameBase, args...);
+}
+
+// ---------------------------------------------------------------------------------------------------------------------
+//
+template<typename... Args>
+CbmQaTable* CbmQaIO::MakeTable(TString nameBase, Args... args)
+{
+  return MakeQaObject<CbmQaTable>(nameBase, args...);
+}
+
+
+#endif  // CbmQaIO_h

core/qa/CbmQaTask.cxx

@@ -10,8 +10,6 @@
 
 #include "CbmQaTask.h"
 
-#include "CbmQaCanvas.h"
-
 #include "FairRootFileSink.h"
 #include "FairRootManager.h"
 #include "FairRunAna.h"
@@ -19,6 +17,7 @@
 #include "TAxis.h"
 #include "TCanvas.h"
 #include "TF1.h"
+#include "TString.h"
 
 #include <array>
 
@@ -28,7 +27,7 @@ ClassImp(CbmQaTask);
 //
 CbmQaTask::CbmQaTask(const char* name, const char* prefix, int verbose, bool isMCUsed)
   : FairTask(name, verbose)
-  , CbmQaIO(prefix)
+  , CbmQaIO(name)
   , fbUseMC(isMCUsed)
 {
   CbmQaIO::SetRootFolderName(name);
@@ -81,22 +80,6 @@ InitStatus CbmQaTask::Init()
   LOG_IF(info, fVerbose > 0) << fName << ": initializing task ...";
   InitStatus res = kSUCCESS;
 
-  // ----- Open configuration file
-  YAML::Node config;
-  if (fsConfigName.Length()) {
-    LOG(info) << fName << ": reading configuration from file \"" << fsConfigName << "\"";
-    try {
-      config        = YAML::LoadFile(fsConfigName.Data())["qa"][fName.Data()];
-      fpCurrentNode = &config;
-    }
-    catch (const YAML::BadFile& exc) {
-      LOG(fatal) << fName << ": configuration file \"" << fsConfigName << "\" does not exist";
-    }
-    catch (const YAML::ParserException& exc) {
-      LOG(fatal) << fName << ": configuration file \"" << fsConfigName << "\" is formatted improperly";
-    }
-  }
-
   // ----- Clear map of the histograms (note)
   DeInitBase();
 
@@ -110,7 +93,6 @@ InitStatus CbmQaTask::Init()
 
   fNofEvents.SetVal(0);
 
-  fpCurrentNode = nullptr;  // De-init pointer to
   return res;
 }
 
@@ -133,3 +115,25 @@ void CbmQaTask::DeInitBase()
   // De-initialize particular QA-task implementation
   DeInit();
 }
+
+
+// ---------------------------------------------------------------------------------------------------------------------
+//
+bool CbmQaTask::CheckRange(TH1* h, double meanMax, double rmsMin, double rmsMax)
+{
+  // Checks ranges for mean and standard deviation
+  // \return  False, if variable exits the range
+
+  double mean    = h->GetMean();
+  double meanErr = h->GetMeanError();
+
+  double rms    = h->GetStdDev();
+  double rmsErr = h->GetStdDevError();
+
+  bool res = true;
+  if (h->GetEntries() >= 10) {  // ask for some statistics, otherwise errors are not properly estimated
+    res = CheckRange(TString("Mean for ") + h->GetTitle(), mean, meanErr, -meanMax, meanMax) && res;
+    res = CheckRange(TString("RMS for ") + h->GetTitle(), rms, rmsErr, rmsMin, rmsMax) && res;
+  }
+  return res;
+}

core/qa/CbmQaTask.h

@@ -31,6 +31,7 @@
 #include <algorithm>
 #include <regex>
 #include <string_view>
+#include <tuple>
 #include <type_traits>
 
 #include <yaml-cpp/yaml.h>
@@ -73,14 +74,6 @@ public:
   /// FairTask: Defines action of the task in the end of run
   void Finish();
 
-  /// @brief Sets task configuration file
-  /// @param filename  Name of file
-  ///
-  /// Sets name of YAML configuration file, which defines parameters needed for the task. The file is assumed
-  /// to contain root branch "qa/[task name]". A subbranch "histograms" contains a list of histograms with pre defined
-  /// parameters: title, number of bins and axis ranges.
-  void SetConfigName(const char* filename) { fsConfigName = filename; }
-
   ClassDef(CbmQaTask, 0);
 
 protected:
@@ -124,19 +117,29 @@ protected:
   /// \param hi    Upper limit of the variable
   /// \return  False, if variable exits the range
   template<typename T>
-  bool CheckRange(std::string_view name, const T& var, const T& lo, const T& hi) const;
+  bool CheckRange(std::string_view name, T var, T lo, T hi) const;
+
+  /// Checks range of variable
+  /// \param name    Name of the variable
+  /// \param var     Variable to check
+  /// \param varErr  Standard Error of the variable
+  /// \param lo      Lower limit of the variable
+  /// \param hi      Upper limit of the variable
+  /// \return        False, if variable exits the range
+  template<typename T>
+  bool CheckRange(std::string_view name, T var, T varErr, T lo, T hi) const;
 
+  /// Checks ranges for mean and standard deviation
+  /// \return  False, if variable exits the range
+  bool CheckRange(TH1* h, double meanMax, double rmsMin, double rmsMax);
 
 private:
   /// @brief De-initializes this task
   void DeInitBase();
 
-  bool fbUseMC     = false;  ///< Flag, if MC is used
+  bool fbUseMC = false;  ///< Flag, if MC is used
 
   TParameter<int> fNofEvents {"nEvents", 0};  ///< Number of processed events
-
-  TString fsConfigName      = "";       ///< Name of YAML configuration file
-  YAML::Node* fpCurrentNode = nullptr;  ///< Pointer to current node of the configuration file
 };
 
 
@@ -147,17 +150,28 @@ private:
 // ---------------------------------------------------------------------------------------------------------------------
 //
 template<typename T>
-bool CbmQaTask::CheckRange(std::string_view name, const T& var, const T& lo, const T& hi) const
+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
 {
-  if (std::clamp(var, lo, hi) == lo) {
-    LOG(error) << fName << ": " << name << " is found to be under the lower limit (" << var << " < " << lo << ')';
-    return false;
+  bool ret = true;
+  if (var + 3.5 * varErr < lo) {
+    LOG(error) << fName << ": " << name << " is found to be under the lower limit (" << var << " +-" << varErr << " < "
+               << lo << ')';
+    ret = false;
   }
-  if (std::clamp(var, lo, hi) == hi) {
-    LOG(error) << fName << ": " << name << " is found to be above the upper limit (" << var << " > " << hi << ')';
-    return false;
+  if (var - 3.5 * varErr > hi) {
+    LOG(error) << fName << ": " << name << " is found to be above the upper limit (" << var << " +-" << varErr << " > "
+               << hi << ')';
+    ret = false;
   }
-  return true;
+  return ret;
 }
 
 #endif  // CbmQaTask_h

core/qa/CbmQaUtil.cxx

+/* Copyright (C) 2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Sergey Gorbunov [committer] */
+
+/// \file   CbmQaUtil.cxx
+/// \brief  Useful utilities for CBM QA tasks
+/// \author S.Gorbunov
+/// \data   31.07.2023
+
+
+#include "CbmQaUtil.h"
+
+#include "CbmQaCanvas.h"
+
+#include "TAxis.h"
+#include "TCanvas.h"
+#include "TF1.h"
+#include "TH1.h"
+#include "TPaveStats.h"
+#include "TVirtualPad.h"
+
+namespace cbm::qa::util
+{
+
+  // ---------------------------------------------------------------------------------------------------------------------
+  //
+  std::tuple<double, double> FitKaniadakisGaussian(TH1* pHist)
+  {
+    //
+    // Fit function - Kaniadakis Gaussian Distribution:
+    // https://en.wikipedia.org/wiki/Kaniadakis_Gaussian_distribution
+    //
+    // where exp_k(x) is calculated via arcsinh():
+    // https://en.wikipedia.org/wiki/Kaniadakis_statistics
+    //
+    // parameters:
+    //
+    // [0] - mean
+    // [1] - Std. Dev ( calculated after the fit )
+    // [2] - peak
+    // [3] - hwhm - half width at half maximum, scaled.  ( == standard deviation for a gaussian )
+    // [4] - k - Kaniadakis parameter, k in [0.,1.]. ( == 0.0 for a gaussian. The formula below breaks when k is exactly 0.)
+    //
+    // returns mean and std.dev
+    //
+
+    double xMin = pHist->GetXaxis()->GetXmin();
+    double xMax = pHist->GetXaxis()->GetXmax();
+
+    TF1 fit("FitKaniadakisGaussian", "[2] * TMath::Exp(TMath::ASinH(-0.5*[4]*((x-[0])/[3])**2)/[4]) + 0.0*[1]", xMin,
+            xMax, "NL");
+
+    fit.SetParName(0, "fit_Mean");
+    fit.SetParName(1, "fit_StdDev");
+    fit.SetParName(2, "fit_Peak");
+    fit.SetParName(3, "fit_Hwhm");
+    fit.SetParName(4, "fit_k");
+
+    // set reasonable initial values
+
+    double mean = pHist->GetMean();
+    double peak = pHist->GetBinContent(pHist->GetMaximumBin());
+    double hwhm = pHist->GetStdDev();
+
+    fit.SetParameters(mean, hwhm, peak, hwhm, .001);
+
+    // limit parameter k
+
+    fit.SetParLimits(4, 0.00001, 5.);
+
+    // fit in a quite mode
+
+    TVirtualPad* padsav = gPad;
+    CbmQaCanvas::GetDummyCanvas().cd();
+    pHist->SetStats(0);  // remove the old stat window
+    pHist->SetStats(1);  // set the flag to create the stat window during Draw()
+    //pHist->Draw();
+    //CbmQaCanvas::GetDummyCanvas().Update();
+
+    //pHist->Sumw2();
+    if (pHist->GetEntries() > 0) { pHist->Fit(&fit, "Q"); }
+    pHist->Draw();
+    CbmQaCanvas::GetDummyCanvas().Update();
+
+    TF1* f = pHist->GetFunction("FitKaniadakisGaussian");
+    if (nullptr != f) {
+
+      // calculate the Std Dev
+
+      f->SetParameter(1, sqrt(f->CentralMoment(2, xMin, xMax)));
+      f->SetParError(1, f->GetParError(3));
+
+      // fix some parameters to prevent them from showing up in the stat window
+
+      f->FixParameter(2, f->GetParameter(2));
+      f->FixParameter(3, f->GetParameter(3));
+      f->FixParameter(4, f->GetParameter(4));
+    }
+
+    TPaveStats* stats = (TPaveStats*) pHist->FindObject("stats");
+    assert(stats);
+
+    stats->SetX1NDC(0.7);
+    stats->SetY1NDC(0.5);
+    stats->SetOptStat(111110);
+    //stats->SetOptStat("eMRuo");
+    stats->SetOptFit(100001);
+
+    CbmQaCanvas::GetDummyCanvas().Clear();
+    if (padsav) padsav->cd();
+    return (nullptr != f) ? std::tuple(f->GetParameter(0), f->GetParameter(1)) : std::tuple(0., -1.);
+  }
+
+}  // namespace cbm::qa::util

core/qa/CbmQaUtil.h

+/* Copyright (C) 2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
+   SPDX-License-Identifier: GPL-3.0-only
+   Authors: Sergey Gorbunov [committer] */
+
+/// \file   CbmQaUtil.h
+/// \brief  Useful utilities for CBM QA tasks
+/// \author S.Gorbunov
+/// \data   31.07.2023
+
+#ifndef CbmQaUtil_h
+#define CbmQaUtil_h 1
+
+#include "TObject.h"
+
+#include <tuple>
+class TH1;
+
+/// namespace cbm::qa::util contains useful utilities for CBM QA tasks
+namespace cbm::qa::util
+{
+
+  /// @brief Fit a histogram with Kaniadakis Gaussian Distribution
+  /// @return  mean and std.dev of the fit
+  std::tuple<double, double> FitKaniadakisGaussian(TH1* pHist);
+}  // namespace cbm::qa::util
+
+#endif  // CbmQaUtil_h

macro/L1/configs/CMakeLists.txt

 Install(FILES config_ideal_hits_mcbm.yaml
               DESTINATION share/cbmroot/macro/L1/configs
        )
-#Install(DIRECTORY modules DESTINATION share/cbmroot/macro/L1/configs)

macro/L1/configs/config_ideal_hits_mcbm.yaml

@@ -2,7 +2,7 @@
 #  SPDX-License-Identifier: GPL-3.0-only
 #  Authors: Sergei Zharko [committer] 
 # 
-## @file   CbmCaIdealHitProducerConfig.yaml
+## @file   config_ideal_hits_mcbm.yaml
 ## @brief  Configuration file for ideal hit producers
 ## @since  28.06.2023
 ## @author Sergei Zharko <s.zharko@gsi.de>

macro/mcbm/mcbm_qa.C

@@ -36,7 +36,7 @@
 #endif
 
 void mcbm_qa(Int_t nEvents = 0, TString dataset = "data/mcbm_beam_2020_03_test",
-             TString setupName = "mcbm_beam_2020_03", Bool_t bUseMC = kTRUE)
+             TString setupName = "mcbm_beam_2020_03", Bool_t bUseMC = kTRUE, const TString& config = "")
 {
 
   // ========================================================================
@@ -51,6 +51,8 @@ void mcbm_qa(Int_t nEvents = 0, TString dataset = "data/mcbm_beam_2020_03_test",
   int verbose    = 6;                              // verbose level
   TString myName = "mcbm_qa";                      // this macro's name for screen output
   TString srcDir = gSystem->Getenv("VMCWORKDIR");  // top source directory
+  TString qaConfig = (config.Length() ? config : srcDir + "/macro/qa/configs/qa_tasks_config_mcbm.yaml");
+  // NOTE: SZh 28.07.2024: config can depend from the setup
   // ------------------------------------------------------------------------
 
   // -----   In- and output file names   ------------------------------------
@@ -221,6 +223,7 @@ void mcbm_qa(Int_t nEvents = 0, TString dataset = "data/mcbm_beam_2020_03_test",
     // CA Input QA
     auto* pCaInputTrd = new CbmCaInputQaTrd(verbose, bUseMC);
     pCaInputTrd->SetEfficiencyThrsh(0.5, 0, 100);
+    //pCaInputTrd->SetConfigName(qaConfig);
     run->AddTask(pCaInputTrd);
   }
   // ------------------------------------------------------------------------

macro/qa/CMakeLists.txt

+add_subdirectory(configs)
+
 # =====   Generate the needed shell scripts   ================================
 GENERATE_ROOT_TEST_SCRIPT(${CBMROOT_SOURCE_DIR}/macro/qa/qa_compare.C)
 
@@ -12,8 +14,8 @@ file(COPY ${CBMROOT_SOURCE_DIR}/macro/include/.rootrc
 # ============================================================================
 
 # Copy file-object map
-file(COPY ${CBMROOT_SOURCE_DIR}/macro/qa/objects.yaml
-	DESTINATION ${CBMROOT_BINARY_DIR}/macro/qa)
+file(COPY ${CBMROOT_SOURCE_DIR}/macro/qa/configs/objects.yaml
+	DESTINATION ${CBMROOT_BINARY_DIR}/macro/qa/configs)
 
 # =====   Define variables for tests   =======================================
 if(${CBM_TEST_MODEL} MATCHES Weekly)
@@ -79,7 +81,7 @@ foreach(setup IN LISTS cbm_setup)
   # --- Run QA tasks with Event-by-event reconstruction from time-based simulation
   # --- Real raw event builder
   set(testname qa_${sname}_compare)
-  add_test(${testname} ${MACRODIR}/qa_compare.sh \"objects.yaml\" \"${sname}\" \"../run/data\" \"../run/data/\" \"data/QACheckerOutput.${sname}.root\" )
+  add_test(${testname} ${MACRODIR}/qa_compare.sh \"configs/objects.yaml\" \"${sname}\" \"../run/data\" \"../run/data/\" \"data/QACheckerOutput.${sname}.root\" )
   set_tests_properties(${testname} PROPERTIES
   	TIMEOUT ${timeOutTime}
 	FAIL_REGULAR_EXPRESSION "segmentation violation"
@@ -91,7 +93,7 @@ foreach(setup IN LISTS cbm_setup)
 endforeach(setup IN LISTS cbm_setup)
 # ============================================================================
 
-Install(FILES ../run/.rootrc qa_compare.C objects.yaml
+Install(FILES ../run/.rootrc qa_compare.C
         DESTINATION share/cbmroot/macro/qa
        )
 #Install(CODE "FILE(MAKE_DIRECTORY \${CMAKE_INSTALL_PREFIX}/share/cbmroot/macro/run/data)")

macro/qa/configs/CMakeLists.txt

+Install(FILES objects.yaml
+              qa_tasks_config_mcbm.yaml
+              DESTINATION share/cbmroot/macro/qa/configs
+       )

macro/qa/configs/qa_tasks_config_mcbm.yaml

+#  Copyright (C) 2023 GSI Helmholtzzentrum fuer Schwerionenforschung, Darmstadt
+#  SPDX-License-Identifier: GPL-3.0-only
+#  Authors: Sergei Zharko [committer] 
+# 
+## @file   qa_task_config_mcbm.yaml
+## @brief  Configuration file for QA-tasks in mCBM
+## @since  27.07.2023
+## @author Sergei Zharko <s.zharko@gsi.de>
+
+qa:
+  CbmCaInputQaTrd:
+    histograms:
+      #xy_station0: 
+      #  x: { nbins: 500, min: -20., max: 20. }
+      #  y: { nbins: 500, min: -20., max: 20. }
+      #xy_station1: 
+      #  x: { nbins: 500, min: -100., max: 100. } 
+      #  y: { nbins: 500, min: -100., max: 100. }
+      #xy_station2: 
+      #  x: { nbins: 500, min: -100., max: 100. } 
+      #  y: { nbins: 500, min: -100., max: 100. }
+    profiles: none 
+
+...

macro/qa/qa_compare.C

@@ -21,7 +21,7 @@
 /// NOTE: Disable clang formatting to keep easy parameters overview
 /* clang-format off */
 int qa_compare( 
-                const char* configName         = "objects.yaml",
+                const char* configName         = "configs/objects.yaml",
                 const char* datasetName        = "s100e",
                 const char* oldVersionInputDir = "../run/data",          // NOTE: Files from external repository
                 const char* newVersionInputDir = "../run/data",          // NOTE: Files from preceding fixture

macro/run/run_qa.C

@@ -240,7 +240,6 @@ void run_qa(TString dataTra = "data/sis100_muon_jpsi_test", TString dataRaw = "d
     //run->AddTask(new CbmStsDigitizeQa()); //opens lots of windows
     run->AddTask(new CbmStsFindTracksQa());
     auto* pCaInputQaSts = new CbmCaInputQaSts(verbose, bUseMC);
-    pCaInputQaSts->SetEfficiencyThrsh(0.5, 0, 100);
     run->AddTask(pCaInputQaSts);
   }
   // ------------------------------------------------------------------------

reco/L1/qa/CbmCaInputQaBase.h

@@ -24,6 +24,9 @@ public:
   /// Default destructor
   ~CbmCaInputQaBase() = default;
 
+  /// Sets maximum allowed deviation of pull distribution mean from 0
+  /// \param devThrsh  Deviation threshold (- devThrsh, + devThrsh)
+  void SetPullMeanDeviationThrsh(double devThrsh) { fPullMeanThrsh = devThrsh; }
 
   /// Sets maximum allowed deviation of pull distribution width from unity
   /// \param devThrsh  Deviation threshold (1 - devThrsh, 1 + devThrsh)
@@ -54,7 +57,6 @@ public:
   /// \param mom Minimum absolute value of momentum
   void SetMinMomentum(double mom) { fMinMomentum = mom; }
 
-
 protected:
   // *********************
   // ** Data structures **
@@ -68,7 +70,9 @@ protected:
   };
 
   // ----- QA constants (thresholds, ranges etc.)
+  //TODO: remove check of residuals
   double fResMeanThrsh   = .5;   ///< Maximum allowed deviation of residual mean from zero [sigma]
+  double fPullMeanThrsh  = .05;  ///< Maximum allowed deviation of pull mean from zero
   double fPullWidthThrsh = .1;   ///< Maximum allowed deviation of pull width from unity
   double fEffThrsh       = .5;   ///< Threshold for hit efficiency in the selected range
   double fMaxDiffZStHit  = 1.;   ///< Maximum allowed difference between z-position of hit and station [cm]

reco/L1/qa/CbmCaInputQaMuch.cxx

@@ -126,7 +126,7 @@ bool CbmCaInputQaMuch::Check()
     LOG(info) << "-- Hit efficiency integrated over hit distance from station center";
     LOG(info) << "\tintegration range: [" << fEffRange[0] << ", " << fEffRange[1] << "] cm";
 
-    auto* pEffTable = MakeTable("eff_table", "Efficiency table", nSt, 2);
+    auto* pEffTable = MakeQaObject<CbmQaTable>("eff_table", "Efficiency table", nSt, 2);
     pEffTable->SetNamesOfCols({"Station ID", "Efficiency"});
     pEffTable->SetColWidth(20);
 
@@ -159,7 +159,8 @@ bool CbmCaInputQaMuch::Check()
       return result;
     };
 
-    auto* pResidualsTable = MakeTable("residuals_mean", "Residual mean values in different stations", nSt, 4);
+    auto* pResidualsTable =
+      MakeQaObject<CbmQaTable>("residuals_mean", "Residual mean values in different stations", nSt, 4);
     pResidualsTable->SetNamesOfCols({"Station ID", "Residual(x) [cm]", "Residual(y) [cm]", "Residual(t) [ns]"});
     pResidualsTable->SetColWidth(20);
 
@@ -202,7 +203,7 @@ bool CbmCaInputQaMuch::Check()
       return fit.GetParameter(2);
     };
 
-    auto* pPullsTable = MakeTable("pulls_rms", "Pulls std. dev. values in different stations", nSt, 4);
+    auto* pPullsTable = MakeQaObject<CbmQaTable>("pulls_rms", "Pulls std. dev. values in different stations", nSt, 4);
     pPullsTable->SetNamesOfCols({"Station ID", "Pull(x) sigm", "Pull(y) sigm", "Pull(z) sigm"});
     pPullsTable->SetColWidth(20);
 
@@ -581,7 +582,7 @@ InitStatus CbmCaInputQaMuch::InitCanvases()
   // ** Hit occupancies
 
   // ** Occupancy in XY plane
-  auto* pc_hit_ypos_vs_xpos = MakeCanvas<CbmQaCanvas>("hit_ypos_vs_xpos", "", 1600, 800);
+  auto* pc_hit_ypos_vs_xpos = MakeQaObject<CbmQaCanvas>("hit_ypos_vs_xpos", "", 1600, 800);
   pc_hit_ypos_vs_xpos->Divide2D(nSt);
   for (int iSt = 0; iSt < nSt; ++iSt) {
     pc_hit_ypos_vs_xpos->cd(iSt + 1);
@@ -618,7 +619,7 @@ InitStatus CbmCaInputQaMuch::InitCanvases()
   }
 
   // ----- Occupancy projections
-  auto* pc_hit_xpos = MakeCanvas<CbmQaCanvas>("hit_xpos", "", 1400, 800);
+  auto* pc_hit_xpos = MakeQaObject<CbmQaCanvas>("hit_xpos", "", 1400, 800);
   pc_hit_xpos->Divide2D(nSt);
   for (int iSt = 0; iSt < nSt; ++iSt) {
     pc_hit_xpos->cd(iSt + 1);
@@ -626,7 +627,7 @@ InitStatus CbmCaInputQaMuch::InitCanvases()
     phProj->DrawCopy();
   }
 
-  auto* pc_hit_ypos = MakeCanvas<CbmQaCanvas>("hit_ypos", "", 1400, 800);
+  auto* pc_hit_ypos = MakeQaObject<CbmQaCanvas>("hit_ypos", "", 1400, 800);
   pc_hit_ypos->Divide2D(nSt);
   for (int iSt = 0; iSt < nSt; ++iSt) {
     pc_hit_ypos->cd(iSt + 1);
@@ -636,7 +637,7 @@ InitStatus CbmCaInputQaMuch::InitCanvases()
 
 
   // ** Occupancy in XZ plane
-  MakeCanvas<CbmQaCanvas>("hit_xpos_vs_zpos", "", 600, 400);
+  MakeQaObject<CbmQaCanvas>("hit_xpos_vs_zpos", "", 600, 400);
   fvph_hit_xpos_vs_zpos[nSt]->DrawCopy("colz", "");
   for (int iSt = 0; iSt < nSt; ++iSt) {
     // Station positions in detector IFS
@@ -654,7 +655,7 @@ InitStatus CbmCaInputQaMuch::InitCanvases()
   }
 
   // ** Occupancy in YZ plane
-  MakeCanvas<CbmQaCanvas>("hit_ypos_vs_zpos", "", 600, 400);
+  MakeQaObject<CbmQaCanvas>("hit_ypos_vs_zpos", "", 600, 400);
   fvph_hit_ypos_vs_zpos[nSt]->DrawCopy("colz", "");
   for (int iSt = 0; iSt < nSt; ++iSt) {
     // Station positions in detector IFS
@@ -680,7 +681,7 @@ InitStatus CbmCaInputQaMuch::InitCanvases()
     // ** Point occupancies
 
     // ** Occupancy in XY plane
-    auto* pc_point_ypos_vs_xpos = MakeCanvas<CbmQaCanvas>("point_ypos_vs_xpos", "", 1600, 800);
+    auto* pc_point_ypos_vs_xpos = MakeQaObject<CbmQaCanvas>("point_ypos_vs_xpos", "", 1600, 800);
     pc_point_ypos_vs_xpos->Divide2D(nSt);
     for (int iSt = 0; iSt < nSt; ++iSt) {
       pc_point_ypos_vs_xpos->cd(iSt + 1);
@@ -716,7 +717,7 @@ InitStatus CbmCaInputQaMuch::InitCanvases()
     }
 
     // ** Occupancy in XZ plane
-    MakeCanvas<CbmQaCanvas>("point_xpos_vs_zpos", "", 600, 400);
+    MakeQaObject<CbmQaCanvas>("point_xpos_vs_zpos", "", 600, 400);
     fvph_point_xpos_vs_zpos[nSt]->SetStats(false);
     fvph_point_xpos_vs_zpos[nSt]->DrawCopy("colz", "");
     for (int iSt = 0; iSt < nSt; ++iSt) {
@@ -735,7 +736,7 @@ InitStatus CbmCaInputQaMuch::InitCanvases()
     }
 
     // ** Occupancy in YZ plane
-    MakeCanvas<CbmQaCanvas>("point_ypos_vs_zpos", "", 600, 400);
+    MakeQaObject<CbmQaCanvas>("point_ypos_vs_zpos", "", 600, 400);
     fvph_point_ypos_vs_zpos[nSt]->SetStats(false);
     fvph_point_ypos_vs_zpos[nSt]->DrawCopy("colz", "");
     for (int iSt = 0; iSt < nSt; ++iSt) {
@@ -757,7 +758,7 @@ InitStatus CbmCaInputQaMuch::InitCanvases()
     // ** Residuals
 
     // x-coordinate
-    auto* pc_res_x = MakeCanvas<CbmQaCanvas>("res_x", "Residuals for x coordinate", 1600, 800);
+    auto* pc_res_x = MakeQaObject<CbmQaCanvas>("res_x", "Residuals for x coordinate", 1600, 800);
     pc_res_x->Divide2D(nSt);
     for (int iSt = 0; iSt < nSt; ++iSt) {
       pc_res_x->cd(iSt + 1);
@@ -765,7 +766,7 @@ InitStatus CbmCaInputQaMuch::InitCanvases()
     }
 
     // y-coordinate
-    auto* pc_res_y = MakeCanvas<CbmQaCanvas>("res_y", "Residuals for y coordinate", 1600, 800);
+    auto* pc_res_y = MakeQaObject<CbmQaCanvas>("res_y", "Residuals for y coordinate", 1600, 800);
     pc_res_y->Divide2D(nSt);
     for (int iSt = 0; iSt < nSt; ++iSt) {
       pc_res_y->cd(iSt + 1);
@@ -773,7 +774,7 @@ InitStatus CbmCaInputQaMuch::InitCanvases()
     }
 
     // time
-    auto* pc_res_t = MakeCanvas<CbmQaCanvas>("res_t", "Residuals for time", 1600, 800);
+    auto* pc_res_t = MakeQaObject<CbmQaCanvas>("res_t", "Residuals for time", 1600, 800);
     pc_res_t->Divide2D(nSt);
     for (int iSt = 0; iSt < nSt; ++iSt) {
       pc_res_t->cd(iSt + 1);
@@ -785,7 +786,7 @@ InitStatus CbmCaInputQaMuch::InitCanvases()
     // ** Pulls
 
     // x-coordinate
-    auto* pc_pull_x = MakeCanvas<CbmQaCanvas>("pull_x", "Pulls for x coordinate", 1600, 800);
+    auto* pc_pull_x = MakeQaObject<CbmQaCanvas>("pull_x", "Pulls for x coordinate", 1600, 800);
     pc_pull_x->Divide2D(nSt);
     for (int iSt = 0; iSt < nSt; ++iSt) {
       pc_pull_x->cd(iSt + 1);
@@ -793,7 +794,7 @@ InitStatus CbmCaInputQaMuch::InitCanvases()
     }
 
     // y-coordinate
-    auto* pc_pull_y = MakeCanvas<CbmQaCanvas>("pull_y", "Pulls for y coordinate", 1600, 800);
+    auto* pc_pull_y = MakeQaObject<CbmQaCanvas>("pull_y", "Pulls for y coordinate", 1600, 800);
     pc_pull_y->Divide2D(nSt);
     for (int iSt = 0; iSt < nSt; ++iSt) {
       pc_pull_y->cd(iSt + 1);
@@ -801,7 +802,7 @@ InitStatus CbmCaInputQaMuch::InitCanvases()
     }
 
     // time
-    auto* pc_pull_t = MakeCanvas<CbmQaCanvas>("pull_t", "Pulls for time", 1600, 800);
+    auto* pc_pull_t = MakeQaObject<CbmQaCanvas>("pull_t", "Pulls for time", 1600, 800);
     pc_pull_t->Divide2D(nSt);
     for (int iSt = 0; iSt < nSt; ++iSt) {
       pc_pull_t->cd(iSt + 1);
@@ -813,7 +814,7 @@ InitStatus CbmCaInputQaMuch::InitCanvases()
     // ** Hit reconstruction efficiencies
 
     auto* pc_reco_eff_vs_r =
-      MakeCanvas<CbmQaCanvas>("reco_eff_vs_r", "Hit efficiencies wrt distance from center", 1600, 800);
+      MakeQaObject<CbmQaCanvas>("reco_eff_vs_r", "Hit efficiencies wrt distance from center", 1600, 800);
     pc_reco_eff_vs_r->Divide2D(nSt);
     for (int iSt = 0; iSt < nSt; ++iSt) {
       pc_reco_eff_vs_r->cd(iSt + 1);
@@ -821,7 +822,7 @@ InitStatus CbmCaInputQaMuch::InitCanvases()
       fvpe_reco_eff_vs_r[iSt]->DrawCopy("AP", "");
     }
 
-    auto* pc_reco_eff_vs_xy = MakeCanvas<CbmQaCanvas>("reco_eff_vs_xy", "Hit efficiencies wrt x and y", 1600, 800);
+    auto* pc_reco_eff_vs_xy = MakeQaObject<CbmQaCanvas>("reco_eff_vs_xy", "Hit efficiencies wrt x and y", 1600, 800);
     pc_reco_eff_vs_xy->Divide2D(nSt);
     for (int iSt = 0; iSt < nSt; ++iSt) {
       pc_reco_eff_vs_xy->cd(iSt + 1);
@@ -858,34 +859,36 @@ InitStatus CbmCaInputQaMuch::InitHistograms()
     // Hit occupancy
     sN                         = (TString) "hit_ypos_vs_xpos" + nsuff;
     sT                         = (TString) "Hit occupancy in xy-Plane" + tsuff + ";x_{hit} [cm];y_{hit} [cm]";
-    fvph_hit_ypos_vs_xpos[iSt] = MakeHisto<TH2F>(sN, sT, kNbins, kRHitX[0], kRHitX[1], kNbins, kRHitY[0], kRHitY[1]);
+    fvph_hit_ypos_vs_xpos[iSt] = MakeQaObject<TH2F>(sN, sT, kNbins, kRHitX[0], kRHitX[1], kNbins, kRHitY[0], kRHitY[1]);
 
     sN                         = (TString) "hit_xpos_vs_zpos" + nsuff;
     sT                         = (TString) "Hit occupancy in xz-Plane" + tsuff + ";z_{hit} [cm];x_{hit} [cm]";
-    fvph_hit_xpos_vs_zpos[iSt] = MakeHisto<TH2F>(sN, sT, kNbinsZ, kRHitZ[0], kRHitZ[1], kNbins, kRHitX[0], kRHitX[1]);
+    fvph_hit_xpos_vs_zpos[iSt] =
+      MakeQaObject<TH2F>(sN, sT, kNbinsZ, kRHitZ[0], kRHitZ[1], kNbins, kRHitX[0], kRHitX[1]);
 
     sN                         = (TString) "hit_ypos_vs_zpos" + nsuff;
     sT                         = (TString) "Hit occupancy in yz-plane" + tsuff + ";z_{hit} [cm];y_{hit} [cm]";
-    fvph_hit_ypos_vs_zpos[iSt] = MakeHisto<TH2F>(sN, sT, kNbinsZ, kRHitZ[0], kRHitZ[1], kNbins, kRHitY[0], kRHitY[1]);
+    fvph_hit_ypos_vs_zpos[iSt] =
+      MakeQaObject<TH2F>(sN, sT, kNbinsZ, kRHitZ[0], kRHitZ[1], kNbins, kRHitY[0], kRHitY[1]);
 
     // Hit errors
     sN               = (TString) "hit_dx" + nsuff;
     sT               = (TString) "Hit position error along x-axis" + tsuff + ";dx_{hit} [cm]";
-    fvph_hit_dx[iSt] = MakeHisto<TH1F>(sN, sT, kNbins, kRHitDx[0], kRHitDx[1]);
+    fvph_hit_dx[iSt] = MakeQaObject<TH1F>(sN, sT, kNbins, kRHitDx[0], kRHitDx[1]);
 
     sN               = (TString) "hit_dy" + nsuff;
     sT               = (TString) "Hit position error along y-axis" + tsuff + ";dy_{hit} [cm]";
-    fvph_hit_dy[iSt] = MakeHisto<TH1F>(sN, sT, kNbins, kRHitDy[0], kRHitDy[1]);
+    fvph_hit_dy[iSt] = MakeQaObject<TH1F>(sN, sT, kNbins, kRHitDy[0], kRHitDy[1]);
 
     sN               = (TString) "hit_dt" + nsuff;
     sT               = (TString) "Hit time error" + tsuff + ";dt_{hit} [ns]";
-    fvph_hit_dt[iSt] = MakeHisto<TH1F>(sN, sT, kNbins, kRHitDt[0], kRHitDt[1]);
+    fvph_hit_dt[iSt] = MakeQaObject<TH1F>(sN, sT, kNbins, kRHitDt[0], kRHitDt[1]);
 
     if (iSt == nSt) { continue; }  // Following histograms are defined only for separate station
 
     sN = (TString) "hit_station_delta_z" + nsuff;
     sT = (TString) "Different between hit and station z-positions" + tsuff + ";z_{hit} - z_{st} [cm]";
-    fvph_hit_station_delta_z[iSt] = MakeHisto<TH1F>(sN, sT, kNbins, -5., 5);
+    fvph_hit_station_delta_z[iSt] = MakeQaObject<TH1F>(sN, sT, kNbins, -5., 5);
 
   }  // loop over station index: end
 
@@ -920,85 +923,85 @@ InitStatus CbmCaInputQaMuch::InitHistograms()
 
       sN                         = (TString) "n_points_per_hit" + nsuff;
       sT                         = (TString) "Number of points per hit" + tsuff + ";N_{point}/hit";
-      fvph_n_points_per_hit[iSt] = MakeHisto<TH1F>(sN, sT, 10, -0.5, 9.5);
+      fvph_n_points_per_hit[iSt] = MakeQaObject<TH1F>(sN, sT, 10, -0.5, 9.5);
 
       // Point occupancy
       sN = (TString) "point_ypos_vs_xpos" + nsuff;
       sT = (TString) "Point occupancy in XY plane" + tsuff + ";x_{MC} [cm];y_{MC} [cm]";
       fvph_point_ypos_vs_xpos[iSt] =
-        MakeHisto<TH2F>(sN, sT, kNbins, kRHitX[0], kRHitX[1], kNbins, kRHitY[0], kRHitY[1]);
+        MakeQaObject<TH2F>(sN, sT, kNbins, kRHitX[0], kRHitX[1], kNbins, kRHitY[0], kRHitY[1]);
 
       sN = (TString) "point_xpos_vs_zpos" + nsuff;
       sT = (TString) "Point Occupancy in XZ plane" + tsuff + ";z_{MC} [cm];x_{MC} [cm]";
       fvph_point_xpos_vs_zpos[iSt] =
-        MakeHisto<TH2F>(sN, sT, kNbinsZ, kRHitZ[0], kRHitZ[1], kNbins, kRHitX[0], kRHitX[1]);
+        MakeQaObject<TH2F>(sN, sT, kNbinsZ, kRHitZ[0], kRHitZ[1], kNbins, kRHitX[0], kRHitX[1]);
 
       sN = (TString) "point_ypos_vs_zpos" + nsuff;
       sT = (TString) "Point Occupancy in YZ Plane" + tsuff + ";z_{MC} [cm];y_{MC} [cm]";
       fvph_point_ypos_vs_zpos[iSt] =
-        MakeHisto<TH2F>(sN, sT, kNbinsZ, kRHitZ[0], kRHitZ[1], kNbins, kRHitY[0], kRHitY[1]);
+        MakeQaObject<TH2F>(sN, sT, kNbinsZ, kRHitZ[0], kRHitZ[1], kNbins, kRHitY[0], kRHitY[1]);
 
       // Difference between MC input z and hit z coordinates
       sN = (TString) "point_hit_delta_z" + nsuff;
       sT = (TString) "Distance between point and hit along z axis" + tsuff + ";z_{reco} - z_{MC} [cm]";
-      fvph_point_hit_delta_z[iSt] = MakeHisto<TH1F>(sN, sT, kNbins, -0.04, 0.04);
+      fvph_point_hit_delta_z[iSt] = MakeQaObject<TH1F>(sN, sT, kNbins, -0.04, 0.04);
 
       sN              = (TString) "res_x" + nsuff;
       sT              = (TString) "Residuals for x-coordinate" + tsuff + ";x_{reco} - x_{MC} [cm]";
-      fvph_res_x[iSt] = MakeHisto<TH1F>(sN, sT, kNbins, kRResX[0], kRResX[1]);
+      fvph_res_x[iSt] = MakeQaObject<TH1F>(sN, sT, kNbins, kRResX[0], kRResX[1]);
 
       sN              = (TString) "res_y" + nsuff;
       sT              = (TString) "Residuals for y-coordinate" + tsuff + ";y_{reco} - y_{MC} [cm]";
-      fvph_res_y[iSt] = MakeHisto<TH1F>(sN, sT, kNbins, kRResY[0], kRResY[1]);
+      fvph_res_y[iSt] = MakeQaObject<TH1F>(sN, sT, kNbins, kRResY[0], kRResY[1]);
 
       sN              = (TString) "res_t" + nsuff;
       sT              = (TString) "Residuals for time" + tsuff + ";t_{reco} - t_{MC} [ns]";
-      fvph_res_t[iSt] = MakeHisto<TH1F>(sN, sT, kNbins, kRResT[0], kRResT[1]);
+      fvph_res_t[iSt] = MakeQaObject<TH1F>(sN, sT, kNbins, kRResT[0], kRResT[1]);
 
       sN               = (TString) "pull_x" + nsuff;
       sT               = (TString) "Pulls for x-coordinate" + tsuff + ";(x_{reco} - x_{MC}) / #sigma_{x}^{reco}";
-      fvph_pull_x[iSt] = MakeHisto<TH1F>(sN, sT, kNbins, kRPullX[0], kRPullX[1]);
+      fvph_pull_x[iSt] = MakeQaObject<TH1F>(sN, sT, kNbins, kRPullX[0], kRPullX[1]);
 
       sN               = (TString) "pull_y" + nsuff;
       sT               = (TString) "Pulls for y-coordinate" + tsuff + ";(y_{reco} - y_{MC}) / #sigma_{y}^{reco}";
-      fvph_pull_y[iSt] = MakeHisto<TH1F>(sN, sT, kNbins, kRPullY[0], kRPullY[1]);
+      fvph_pull_y[iSt] = MakeQaObject<TH1F>(sN, sT, kNbins, kRPullY[0], kRPullY[1]);
 
       sN               = (TString) "pull_t" + nsuff;
       sT               = (TString) "Pulls for time" + tsuff + ";(t_{reco} - t_{MC}) / #sigma_{t}^{reco}";
-      fvph_pull_t[iSt] = MakeHisto<TH1F>(sN, sT, kNbins, kRPullT[0], kRPullT[1]);
+      fvph_pull_t[iSt] = MakeQaObject<TH1F>(sN, sT, kNbins, kRPullT[0], kRPullT[1]);
 
       sN                   = (TString) "res_x_vs_x" + nsuff;
       sT                   = (TString) "Residuals for x-coordinate" + tsuff + ";x_{reco} [cm];x_{reco} - x_{MC} [cm]";
-      fvph_res_x_vs_x[iSt] = MakeHisto<TH2F>(sN, sT, kNbins, 0, 0, kNbins, kRResX[0], kRResX[1]);
+      fvph_res_x_vs_x[iSt] = MakeQaObject<TH2F>(sN, sT, kNbins, 0, 0, kNbins, kRResX[0], kRResX[1]);
 
       sN                   = (TString) "res_y_vs_y" + nsuff;
       sT                   = (TString) "Residuals for y-coordinate" + tsuff + ";y_{reco} [cm];y_{reco} - y_{MC} [cm]";
-      fvph_res_y_vs_y[iSt] = MakeHisto<TH2F>(sN, sT, kNbins, 0, 0, kNbins, kRResY[0], kRResY[1]);
+      fvph_res_y_vs_y[iSt] = MakeQaObject<TH2F>(sN, sT, kNbins, 0, 0, kNbins, kRResY[0], kRResY[1]);
 
       sN                   = (TString) "res_t_vs_t" + nsuff;
       sT                   = (TString) "Residuals for time" + tsuff + "t_{reco} [ns];t_{reco} - t_{MC} [ns]";
-      fvph_res_t_vs_t[iSt] = MakeHisto<TH2F>(sN, sT, kNbins, 0, 0, kNbins, kRResT[0], kRResT[1]);
+      fvph_res_t_vs_t[iSt] = MakeQaObject<TH2F>(sN, sT, kNbins, 0, 0, kNbins, kRResT[0], kRResT[1]);
 
       sN = (TString) "pull_x_vs_x" + nsuff;
       sT = (TString) "Pulls for x-coordinate" + tsuff + "x_{reco} [cm];(x_{reco} - x_{MC}) / #sigma_{x}^{reco}";
-      fvph_pull_x_vs_x[iSt] = MakeHisto<TH2F>(sN, sT, kNbins, 0, 0, kNbins, kRPullX[0], kRPullX[1]);
+      fvph_pull_x_vs_x[iSt] = MakeQaObject<TH2F>(sN, sT, kNbins, 0, 0, kNbins, kRPullX[0], kRPullX[1]);
 
       sN = (TString) "pull_y_vs_y" + nsuff;
       sT = (TString) "Pulls for y-coordinate" + tsuff + ";y_{reco} [cm];(y_{reco} - y_{MC}) / #sigma_{y}^{reco}";
-      fvph_pull_y_vs_y[iSt] = MakeHisto<TH2F>(sN, sT, kNbins, 0, 0, kNbins, kRPullY[0], kRPullY[1]);
+      fvph_pull_y_vs_y[iSt] = MakeQaObject<TH2F>(sN, sT, kNbins, 0, 0, kNbins, kRPullY[0], kRPullY[1]);
 
       sN = (TString) "pull_t_vs_t" + nsuff;
       sT = (TString) "Pulls for time" + tsuff + ";t_{reco} [ns];(t_{reco} - t_{MC}) / #sigma_{t}^{reco}";
-      fvph_pull_t_vs_t[iSt] = MakeHisto<TH2F>(sN, sT, kNbins, 0, 0, kNbins, kRPullT[0], kRPullT[1]);
+      fvph_pull_t_vs_t[iSt] = MakeQaObject<TH2F>(sN, sT, kNbins, 0, 0, kNbins, kRPullT[0], kRPullT[1]);
 
 
       sN                       = (TString) "reco_eff_vs_xy" + nsuff;
       sT                       = (TString) "Hit rec. efficiency" + tsuff + ";x_{MC} [cm];y_{MC} [cm];#epsilon";
-      fvpe_reco_eff_vs_xy[iSt] = MakeEfficiency<CbmQaEff>(sN, sT, 100, -50, 50, 100, -50, 50);
+      fvpe_reco_eff_vs_xy[iSt] = MakeQaObject<CbmQaEff>(sN, sT, 100, -50, 50, 100, -50, 50);
 
       sN                      = (TString) "reco_eff_vs_r" + nsuff;
       sT                      = (TString) "Hit rec. efficiency" + tsuff + ";r_{MC} [cm];#epsilon";
-      fvpe_reco_eff_vs_r[iSt] = MakeEfficiency<CbmQaEff>(sN, sT, 100, 0, 100);
+      fvpe_reco_eff_vs_r[iSt] = MakeQaObject<CbmQaEff>(sN, sT, 100, 0, 100);
     }
   }
   return kSUCCESS;