CbmHistManager.h

Go to the documentation of this file.

 
#ifndef CBMHISTMANAGER_H_
#define CBMHISTMANAGER_H_
 
#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 <TNamed.h>      // for TNamed
#include <TObject.h>     // for TObject
#include <TProfile.h>    // for TProfile
#include <TProfile2D.h>  // for TProfile2D
 
#include <FairLogger.h>  // for Logger, LOG
 
#include <cassert>  // for assert
#include <map>      // for map, __map_const_iterator, operator!=
#include <ostream>  // for string, operator<<, ostream
#include <string>   // for operator<
#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 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 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);
  }
 
  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);
  }
 
  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);
  }
 
  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);
  }
 
  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::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::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::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::string& pattern) const;
 
  Bool_t Exists(const std::string& name) const {
    return (fMap.count(name) == 0) ? false : true;
  }
 
  void WriteToFile();
 
  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;
 
  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_ */