CbmHistManager.h

Go to the documentation of this file.

/* Copyright (C) 2011-2021 GSI/JINR-LIT, Darmstadt/Dubna
   SPDX-License-Identifier: GPL-3.0-only
   Authors: Semen Lebedev, Andrey Lebedev [committer], Florian Uhlig */
 
#ifndef CBMHISTMANAGER_H_
#define CBMHISTMANAGER_H_
 
#include <Logger.h>  // for Logger, LOG
 
#include <Rtypes.h>      // for THashConsistencyHolder, ClassDef
#include <RtypesCore.h>  // for Double_t, Int_t, Bool_t, Option_t
#include <TCanvas.h>     // iwyu: keep for RootCling
#include <TGraph.h>      // for TGraph
#include <TGraph2D.h>    // for TGraph2D
#include <TH1.h>         // for TH1
#include <TH2.h>         // for TH2
#include <TH3.h>         // for TH3
#include <THnSparse.h>   // for THnSparse
#include <TNamed.h>      // for TNamed
#include <TObject.h>     // for TObject
#include <TProfile.h>    // for TProfile
#include <TProfile2D.h>  // for TProfile2D
 
#include <array>        // for array
#include <cassert>      // for assert
#include <map>          // for map, __map_const_iterator, operator!=
#include <ostream>      // for string, operator<<, ostream
#include <string>       // for operator<
#include <type_traits>  // for is_base_of
#include <utility>      // for pair, make_pair
#include <vector>       // for vector
 
class TFile;
 
class CbmHistManager : public TObject {
public:
  CbmHistManager();
 
  virtual ~CbmHistManager();
 
  void Add(const std::string& name, TNamed* object)
  {
 
    std::map<std::string, TNamed*>::iterator it = fMap.find(name);
    if (it != fMap.end()) {
      LOG(warn) << "CbmHistManager::Add Object with name:" << name << " was already added. Set new object.";
    }
 
    std::pair<std::string, TNamed*> newpair = std::make_pair(name, object);
    fMap.insert(newpair);
  }
 
  template<class T>
  void Create1(const std::string& name, const std::string& title, Int_t nofBins, Double_t minBin, Double_t maxBin)
  {
    T* h = new T(name.c_str(), title.c_str(), nofBins, minBin, maxBin);
    Add(name, h);
  }
 
  template<class T>
  void Create1(const std::string& name, const std::string& title, const std::vector<Double_t>& binsX)
  {
    T* h = new T(name.c_str(), title.c_str(), binsX.size() - 1, binsX.data());
    Add(name, h);
  }
 
  template<class T>
  void Create2(const std::string& name, const std::string& title, Int_t nofBinsX, Double_t minBinX, Double_t maxBinX,
               Int_t nofBinsY, Double_t minBinY, Double_t maxBinY)
  {
    T* h = new T(name.c_str(), title.c_str(), nofBinsX, minBinX, maxBinX, nofBinsY, minBinY, maxBinY);
    Add(name, h);
  }
 
  template<class T>
  void Create2(const std::string& name, const std::string& title, const std::vector<Double_t>& binsX,
               const std::vector<Double_t>& binsY)
  {
    T* h = new T(name.c_str(), title.c_str(), binsX.size() - 1, binsX.data(), binsY.size() - 1, binsY.data());
    Add(name, h);
  }
 
  template<class T>
  void Create3(const std::string& name, const std::string& title, Int_t nofBinsX, Double_t minBinX, Double_t maxBinX,
               Int_t nofBinsY, Double_t minBinY, Double_t maxBinY, Int_t nofBinsZ, Double_t minBinZ, Double_t maxBinZ)
  {
    T* h = new T(name.c_str(), title.c_str(), nofBinsX, minBinX, maxBinX, nofBinsY, minBinY, maxBinY, nofBinsZ, minBinZ,
                 maxBinZ);
    Add(name, h);
  }
 
  template<class T, int nDim>
  void CreateSparse(const std::string& name, const std::string& title, const std::array<Int_t, nDim>& nBins,
                    const std::array<Double_t, nDim>& minVals, const std::array<Double_t, nDim>& maxVals)
  {
    static_assert(std::is_base_of<THnSparse, T>::value, "Class must be derrived from THnSparse");
    T* h = new T(name.c_str(), title.c_str(), nDim, nBins.data(), minVals.data(), maxVals.data());
    Add(name, h);
  }
 
  TNamed* GetObject(const std::string& name) const
  {
    if (fMap.count(name) == 0) {  // Temporarily used for debugging
      LOG(error) << "CbmHistManager::GetObject(name): name=" << name;
    }
    assert(fMap.count(name) != 0);
    return fMap.find(name)->second;
  }
 
 
  TH1* H1(const std::string& name) const
  {
    if (fMap.count(name) == 0) {  // Temporarily used for debugging
      LOG(error) << "CbmHistManager::H1(name): name=" << name;
    }
    assert(fMap.count(name) != 0);
    return dynamic_cast<TH1*>(fMap.find(name)->second);
  }
 
  TH1* H1Clone(const std::string& name) const { return static_cast<TH1*>(H1(name)->Clone()); }
 
  std::vector<TH1*> H1Vector(const std::vector<std::string>& names) const;
 
 
  std::vector<TH1*> H1Vector(const std::string& pattern) const;
 
  TH2* H2(const std::string& name) const
  {
    if (fMap.count(name) == 0) {  // Temporarily used for debugging
      LOG(error) << "CbmHistManager::H2(name): name=" << name;
    }
    assert(fMap.count(name) != 0);
    return dynamic_cast<TH2*>(fMap.find(name)->second);
  }
 
  TH2* H2Clone(const std::string& name) const { return static_cast<TH2*>(H2(name)->Clone()); }
 
  std::vector<TH2*> H2Vector(const std::vector<std::string>& names) const;
 
  std::vector<TH2*> H2Vector(const std::string& pattern) const;
 
  TH3* H3(const std::string& name) const
  {
    if (fMap.count(name) == 0) {  // Temporarily used for debugging
      LOG(error) << "CbmHistManager::H3(name): name=" << name;
    }
    assert(fMap.count(name) != 0);
    return dynamic_cast<TH3*>(fMap.find(name)->second);
  }
 
  TH3* H3Clone(const std::string& name) const { return static_cast<TH3*>(H3(name)->Clone()); }
 
  THnSparse* HnSparse(const std::string& name) const
  {
    if (fMap.count(name) == 0) {  // Temporarily used for debugging
      LOG(error) << "CbmHistManager::HnSparse(name): name=" << name;
    }
    assert(fMap.count(name) != 0);
    return dynamic_cast<THnSparse*>(fMap.find(name)->second);
  }
 
  TGraph* G1(const std::string& name) const
  {
    if (fMap.count(name) == 0) {  // Temporarily used for debugging
      LOG(error) << "CbmHistManager::G1(name): name=" << name;
    }
    assert(fMap.count(name) != 0);
    return dynamic_cast<TGraph*>(fMap.find(name)->second);
  }
 
  std::vector<TGraph*> G1Vector(const std::vector<std::string>& names) const;
 
  std::vector<TGraph*> G1Vector(const std::string& pattern) const;
 
  TGraph2D* G2(const std::string& name) const
  {
    if (fMap.count(name) == 0) {  // Temporarily used for debugging
      LOG(error) << "CbmHistManager::G2(name): name=" << name;
    }
    assert(fMap.count(name) != 0);
    return dynamic_cast<TGraph2D*>(fMap.find(name)->second);
  }
 
  std::vector<TGraph2D*> G2Vector(const std::vector<std::string>& names) const;
 
  std::vector<TGraph2D*> G2Vector(const std::string& pattern) const;
 
  TProfile* P1(const std::string& name) const
  {
    if (fMap.count(name) == 0) {  // Temporarily used for debugging
      LOG(error) << "CbmHistManager::P1(name): name=" << name;
    }
    assert(fMap.count(name) != 0);
    return dynamic_cast<TProfile*>(fMap.find(name)->second);
  }
 
  std::vector<TProfile*> P1Vector(const std::vector<std::string>& names) const;
 
  std::vector<TProfile*> P1Vector(const std::string& pattern) const;
 
  TProfile2D* P2(const std::string& name) const
  {
    if (fMap.count(name) == 0) {  // Temporarily used for debugging
      LOG(error) << "CbmHistManager::P2(name): name=" << name;
    }
    assert(fMap.count(name) != 0);
    return dynamic_cast<TProfile2D*>(fMap.find(name)->second);
  }
 
  std::vector<TProfile2D*> P2Vector(const std::vector<std::string>& names) const;
 
  std::vector<TProfile2D*> P2Vector(const std::string& pattern) const;
 
  Bool_t Exists(const std::string& name) const { return (fMap.count(name) == 0) ? false : true; }
 
  void WriteToFile();
 
  void WriteCanvasToFile();
 
  void ReadFromFile(TFile* file);
 
  void AddTNamedObject(TObject* obj);
 
  void AddTDirectoryObject(TObject* obj);
 
  void Clear(Option_t* = "");
 
  void ShrinkEmptyBinsH1(const std::string& histName);
 
  void ShrinkEmptyBinsH1ByPattern(const std::string& pattern);
 
  void ShrinkEmptyBinsH2(const std::string& histName);
 
  void ShrinkEmptyBinsH2ByPattern(const std::string& pattern);
 
  void Scale(const std::string& histName, Double_t scale);
 
  void ScaleByPattern(const std::string& pattern, Double_t scale);
 
  void NormalizeToIntegral(const std::string& histName);
 
  void NormalizeToIntegralByPattern(const std::string& pattern);
 
  void Rebin(const std::string& histName, Int_t ngroup);
 
  void RebinByPattern(const std::string& pattern, Int_t ngroup);
 
  std::string ToString() const;
 
  friend std::ostream& operator<<(std::ostream& strm, const CbmHistManager& histManager)
  {
    strm << histManager.ToString();
    return strm;
  }
 
  TCanvas* CreateCanvas(const std::string& name, const std::string& title, Int_t width, Int_t height);
 
  void SaveCanvasToImage(const std::string& outputDir, const std::string& options = "png,eps");
 
private:
  template<class T>
  std::vector<T> ObjectVector(const std::string& pattern) const;
 
  template<class T>
  std::vector<T> ObjectVector(const std::vector<std::string>& names) const;
 
  std::map<std::string, TNamed*> fMap;  // Map of histogram (graph) name to its pointer
  std::vector<TCanvas*> fCanvases;      // Pointers to all created canvases
 
  ClassDef(CbmHistManager, 1)
};
 
#endif /* CBMHISTMANAGER_H_ */