KVDataAnalysisTreeHistoHandler.h

#pragma once
 
#include <optional>
#include "KVHashList.h"
#include "TH3.h"
#include "TProfile2D.h"
#include "TH2.h"
#include "TTree.h"
 
template<typename AnalysisClass>
class KVDataAnalysisTreeHistoHandler
{
   KVHashList fHistoList;        
   KVHashList fTreeList;         
 
   void FillTH1(TH1* h1, Double_t x, Double_t w)
   {
      // \param[in] h1 1D histogram to fill
      // \param[in] x value for x axis
      // \param[in] w weight
 
      h1->Fill(x, w);
   }
   void FillTProfile(TProfile* h1, Double_t x, Double_t y, Double_t w)
   {
      // \param[in] h1 TProfile to fill
      // \param[in] x value for x axis
      // \param[in] y value for y axis
      // \param[in] w weight
 
      h1->Fill(x, y, w);
   }
   void FillTH2(TH2* h2, Double_t x, Double_t y, Double_t w)
   {
      // \param[in] h2 TH2 to fill
      // \param[in] x value for x axis
      // \param[in] y value for y axis
      // \param[in] w weight
 
      h2->Fill(x, y, w);
   }
   void FillTProfile2D(TProfile2D* h2, Double_t x, Double_t y, Double_t z, Double_t w)
   {
      // \param[in] h2 TProfile2D to fill
      // \param[in] x value for x axis
      // \param[in] y value for y axis
      // \param[in] z value for z axis
      // \param[in] w weight
 
      h2->Fill(x,y,z,w);
   }
   void FillTH3(TH3* h3, Double_t x, Double_t y, Double_t z, Double_t w)
   {
      // \param[in] h2 TH3 to fill
      // \param[in] x value for x axis
      // \param[in] y value for y axis
      // \param[in] z value for z axis
      // \param[in] w weight
 
      h3->Fill(x,y,z,w);
   }
 
   protected:
   KVHashList& GetHistoList()
   {
      return fHistoList;
   }
   KVHashList& GetTreeList()
   {
      return fTreeList;
   }
   public:
   const KVHashList* GetHistoList() const
   {
      return &fHistoList;
   }
   const KVHashList* GetTreeList() const
   {
      return &fTreeList;
   }
 
   template<typename HistoType, typename... Args>
   HistoType* AddHisto(Args&& ... args)
   {
      auto h = new HistoType(std::forward<Args>(args)...);
      static_cast<AnalysisClass&>(*this).add_histo(h);
      return h;
   }
   TTree* AddTree(const TString& name, const TString& title = "")
   {
      auto t = new TTree(name, title);
      static_cast<AnalysisClass&>(*this).add_tree(t);
      return t;
   }
   TH1* GetHisto(const Char_t* name) const
   {
      return fHistoList.get_object<TH1>(name);
   }
 
   TTree* GetTree(const Char_t* name) const
   {
      auto t = fTreeList.get_object<TTree>(name);
      if (!t) KVError::Error(this, "GetTree()", "Tree %s not found: is this the right name?", name);
      return t;
   }
 
   void FillHisto(const Char_t* histo_name, Double_t x, Double_t y = 1, Double_t z = 1, Double_t w = 1)
   {
      TH1* h1 = nullptr;
      if ((h1 = GetHisto(histo_name))) {
         if (h1->InheritsFrom("TH3"))
            FillTH3((TH3*)h1, x, y, z, w);
         else if (h1->InheritsFrom("TProfile2D"))
            FillTProfile2D((TProfile2D*)h1, x, y, z, w);
         else if (h1->InheritsFrom("TH2"))
            FillTH2((TH2*)h1, x, y, z);
         else if (h1->InheritsFrom("TProfile"))
            FillTProfile((TProfile*)h1, x, y, z);
         else if (h1->InheritsFrom("TH1"))
            FillTH1(h1, x, y);
         else
            KVError::Warning(this, "FillHisto", "%s -> Unhandled class ...", h1->ClassName());
      }
      else {
         KVError::Warning(this, "FillHisto", "Histogram %s has not been defined", histo_name);
      }
   }
 
   void FillHisto(const Char_t* histo_name, const Char_t* label, Double_t weight = 1)
   {
      TH1* h1 = nullptr;
      if ((h1 = GetHisto(histo_name))) {
         h1->Fill(label, weight);
      }
      else {
         KVError::Warning(this, "FillHisto", "Histogram %s has not been defined", histo_name);
      }
   }
 
   void FillTree(std::optional<TString> tree_name = {})
   {
      if (!tree_name) {
         GetTreeList().R__FOR_EACH(TTree, Fill)();
      }
      else {
         TTree* tt = 0;
         if ((tt = GetTree(*tree_name))) {
            tt->Fill();
         }
         else {
            KVError::Warning(this, "FillTree", "%s unknown", tree_name->Data());
         }
      }
   }
   static const Char_t* Class_Name()
   {
      return "KVDataAnalysisTreeHistoHandler";
   }
};