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

 
#ifndef CbmQaCmpDrawer_h
#define CbmQaCmpDrawer_h 1
 
#include "Logger.h"
#include "TH1.h"
#include "TH2.h"
#include "TH3.h"
#include "TLegend.h"
#include "TPad.h"
 
#include <algorithm>
#include <limits>
#include <type_traits>
#include <vector>

template<class Obj>
class CbmQaCmpDrawer {
 public:
  CbmQaCmpDrawer();

  ~CbmQaCmpDrawer() = default;

  CbmQaCmpDrawer(const CbmQaCmpDrawer&) = delete;

  CbmQaCmpDrawer(CbmQaCmpDrawer&&) = delete;

  CbmQaCmpDrawer& operator=(const CbmQaCmpDrawer&) = delete;

  CbmQaCmpDrawer& operator=(CbmQaCmpDrawer&&) = delete;

  void Clear();

  void RegisterObject(const Obj* pObj, const char* title = nullptr);

  void Draw(Option_t* opt) const;

  void SetMinimum(double min) { fMinimum = min; }

  void SetMaximum(double max) { fMaximum = max; }
 
 private:
  // Some constant expressions (TODO: move to a separate header)
  static constexpr double kLegEntryHight = 0.06;  
  static constexpr double kLegEntryWidth = 0.35;  
  static constexpr double kLegRightBound = 0.99;  
  static constexpr double kLegTopBound   = 0.90;  
  static constexpr double kLegTextSize   = 0.04;  
  static constexpr double kIndentFromMax = 0.1;   
 
  double fMinimum = std::numeric_limits<double>::signaling_NaN();
  double fMaximum = std::numeric_limits<double>::signaling_NaN();
 
  std::vector<Obj*> fvpObjects;        
  std::vector<TString> fvsLegEntries;  
};
 
 
// ****************************
// **     Implementation     **
// ****************************
 
// ---------------------------------------------------------------------------------------------------------------------
//
template<class Obj>
CbmQaCmpDrawer<Obj>::CbmQaCmpDrawer()
{
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
template<class Obj>
void CbmQaCmpDrawer<Obj>::Clear()
{
  fvpObjects.clear();
  fvsLegEntries.clear();
  fMinimum = std::numeric_limits<double>::signaling_NaN();
  fMaximum = std::numeric_limits<double>::signaling_NaN();
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
template<class Obj>
void CbmQaCmpDrawer<Obj>::RegisterObject(const Obj* pObj, const char* title)
{
  if (!pObj) {
    LOG(info) << "CbmQaCmpDrawer: attempt to register a nullptr (" << title << "), ignored";
    return;
  }
 
  // Add entry to objects array
  auto* pObjClone = static_cast<Obj*>(pObj->Clone());
  fvpObjects.push_back(pObjClone);
 
  // Add entry to legend
  TString legEntryName = title ? title : pObj->GetTitle();
  fvsLegEntries.push_back(legEntryName);
}
 
// ---------------------------------------------------------------------------------------------------------------------
//
template<class Obj>
void CbmQaCmpDrawer<Obj>::Draw(Option_t* /*opt*/) const
{
  // TH1, TProfile
  if constexpr (std::is_base_of_v<TH1, Obj> && !std::is_base_of_v<TH2, Obj> && !std::is_base_of_v<TH3, Obj>) {
    // Maximum and minimum
    double maxY = fMaximum;
    if (std::isnan(maxY)) {
      auto HistMax = [](const Obj* lhs, const Obj* rhs) { return lhs->GetMaximum() < rhs->GetMaximum(); };
      maxY         = (*std::max_element(fvpObjects.cbegin(), fvpObjects.cend(), HistMax))->GetMaximum();
      maxY *= (1. + kIndentFromMax);
    }
    double minY = fMinimum;
    if (std::isnan(minY)) {
      auto HistMin = [](const Obj* lhs, const Obj* rhs) { return lhs->GetMinimum() < rhs->GetMinimum(); };
      minY         = (*std::min_element(fvpObjects.cbegin(), fvpObjects.cend(), HistMin))->GetMaximum();
      minY         = (minY < 0.) ? minY : 0.;
    }
 
    // Draw a stack of histograms
    for (auto it = fvpObjects.begin(); it != fvpObjects.end(); ++it) {
      (*it)->SetStats(false);
      (*it)->SetMinimum(minY);
      (*it)->SetMaximum(maxY);
      (*it)->Draw(it == fvpObjects.begin() ? "" : "same");
    }
  }
  else if constexpr (std::is_base_of_v<TH2, Obj> || std::is_base_of_v<TH3, Obj>) {
    int nObjects = fvpObjects.size();
    int nRows    = static_cast<int>(std::sqrt(nObjects));
    int nCols    = nObjects / nRows;
    if (nCols * nRows < nObjects) {
      ++nCols;
    }
    gPad->Divide(nCols, nRows);
 
    for (auto it = fvpObjects.begin(); it != fvpObjects.end(); ++it) {
      if constexpr (std::is_base_of_v<TH2, Obj>) {
        (*it)->Draw("colz");
      }
      else {
        (*it)->Draw();
      }
    }
    return;  // do not draw legend
  }
 
  // Draw legend
  double legX0 = kLegRightBound - kLegEntryWidth;
  double legX1 = kLegRightBound;
  double legY0 = kLegTopBound - kLegEntryHight * fvpObjects.size();
  double legY1 = kLegTopBound;
 
  auto* pLeg = new TLegend(legX0, legY0, legX1, legY1);
  pLeg->SetTextSize(kLegTextSize);
  for (int iObj = 0; iObj < (int) fvpObjects.size(); ++iObj) {
    pLeg->AddEntry(fvpObjects[iObj], fvsLegEntries[iObj], "lp");
  }
  pLeg->Draw();
}
 
#endif  // CbmQaCmpDrawer_h