ConvertToTH1.cxx

Go to the documentation of this file.

/// \file
/// \warning This is part of the %ROOT 7 prototype! It will change without notice. It might trigger earthquakes.
/// Feedback is welcome!
 
#include <ROOT/Hist/ConversionUtils.hxx>
#include <ROOT/Hist/ConvertToTH1.hxx>
#include <ROOT/RBinIndex.hxx>
#include <ROOT/RHist.hxx>
#include <ROOT/RHistEngine.hxx>
 
#include <TH1.h>
 
#include <cassert>
#include <cstddef>
#include <memory>
#include <stdexcept>
#include <type_traits>
#include <variant>
#include <vector>
 
using namespace ROOT::Experimental;
 
namespace {
template <typename Hist, typename T>
std::unique_ptr<Hist> ConvertToTH1Impl(const RHistEngine<T> &engine)
{
   if (engine.GetNDimensions() != 1) {
      throw std::invalid_argument("TH1 requires one dimension");
   }
 
   auto ret = std::make_unique<Hist>();
   ret->SetDirectory(nullptr);
 
   ROOT::Experimental::Hist::Internal::ConvertAxis(*ret->GetXaxis(), engine.GetAxes()[0]);
   ret->SetBinsLength();
 
   Double_t *sumw2 = nullptr;
   auto copyBinContent = [&ret, &engine, &sumw2](Int_t i, RBinIndex index) {
      if constexpr (std::is_same_v<T, RBinWithError>) {
         if (sumw2 == nullptr) {
            ret->Sumw2();
            sumw2 = ret->GetSumw2()->GetArray();
         }
         const RBinWithError &c = engine.GetBinContent(index);
         ret->GetArray()[i] = c.fSum;
         sumw2[i] = c.fSum2;
      } else {
         (void)sumw2;
         ret->GetArray()[i] = engine.GetBinContent(index);
      }
   };
 
   // Copy the bin contents, accounting for TH1 numbering conventions.
   const auto &axis = engine.GetAxes()[0];
   for (auto index : axis.GetFullRange()) {
      if (index.IsUnderflow()) {
         copyBinContent(0, index);
      } else if (index.IsOverflow()) {
         copyBinContent(axis.GetNNormalBins() + 1, index);
      } else {
         assert(index.IsNormal());
         copyBinContent(index.GetIndex() + 1, index);
      }
   }
 
   return ret;
}
 
template <typename Hist>
void ConvertGlobalStatistics(Hist &h, const RHistStats &stats)
{
   if (stats.IsTainted()) {
      return;
   }
 
   h.SetEntries(stats.GetNEntries());
 
   Double_t hStats[4] = {
      stats.GetSumW(),
      stats.GetSumW2(),
      0,
      0,
   };
   if (stats.IsEnabled(0)) {
      hStats[2] = stats.GetDimensionStats(0).fSumWX;
      hStats[3] = stats.GetDimensionStats(0).fSumWX2;
   }
   h.PutStats(hStats);
}
} // namespace
 
namespace ROOT {
namespace Experimental {
namespace Hist {
 
std::unique_ptr<TH1C> ConvertToTH1C(const RHistEngine<char> &engine)
{
   return ConvertToTH1Impl<TH1C>(engine);
}
 
std::unique_ptr<TH1S> ConvertToTH1S(const RHistEngine<short> &engine)
{
   return ConvertToTH1Impl<TH1S>(engine);
}
 
std::unique_ptr<TH1I> ConvertToTH1I(const RHistEngine<int> &engine)
{
   return ConvertToTH1Impl<TH1I>(engine);
}
 
std::unique_ptr<TH1L> ConvertToTH1L(const RHistEngine<long> &engine)
{
   return ConvertToTH1Impl<TH1L>(engine);
}
 
std::unique_ptr<TH1L> ConvertToTH1L(const RHistEngine<long long> &engine)
{
   return ConvertToTH1Impl<TH1L>(engine);
}
 
std::unique_ptr<TH1F> ConvertToTH1F(const RHistEngine<float> &engine)
{
   return ConvertToTH1Impl<TH1F>(engine);
}
 
std::unique_ptr<TH1D> ConvertToTH1D(const RHistEngine<double> &engine)
{
   return ConvertToTH1Impl<TH1D>(engine);
}
 
std::unique_ptr<TH1D> ConvertToTH1D(const RHistEngine<RBinWithError> &engine)
{
   return ConvertToTH1Impl<TH1D>(engine);
}
 
std::unique_ptr<TH1C> ConvertToTH1C(const RHist<char> &hist)
{
   auto ret = ConvertToTH1C(hist.GetEngine());
   ConvertGlobalStatistics(*ret, hist.GetStats());
   return ret;
}
 
std::unique_ptr<TH1S> ConvertToTH1S(const RHist<short> &hist)
{
   auto ret = ConvertToTH1S(hist.GetEngine());
   ConvertGlobalStatistics(*ret, hist.GetStats());
   return ret;
}
 
std::unique_ptr<TH1I> ConvertToTH1I(const RHist<int> &hist)
{
   auto ret = ConvertToTH1I(hist.GetEngine());
   ConvertGlobalStatistics(*ret, hist.GetStats());
   return ret;
}
 
std::unique_ptr<TH1L> ConvertToTH1L(const RHist<long> &hist)
{
   auto ret = ConvertToTH1L(hist.GetEngine());
   ConvertGlobalStatistics(*ret, hist.GetStats());
   return ret;
}
 
std::unique_ptr<TH1L> ConvertToTH1L(const RHist<long long> &hist)
{
   auto ret = ConvertToTH1L(hist.GetEngine());
   ConvertGlobalStatistics(*ret, hist.GetStats());
   return ret;
}
 
std::unique_ptr<TH1F> ConvertToTH1F(const RHist<float> &hist)
{
   auto ret = ConvertToTH1F(hist.GetEngine());
   ConvertGlobalStatistics(*ret, hist.GetStats());
   return ret;
}
 
std::unique_ptr<TH1D> ConvertToTH1D(const RHist<double> &hist)
{
   auto ret = ConvertToTH1D(hist.GetEngine());
   ConvertGlobalStatistics(*ret, hist.GetStats());
   return ret;
}
 
std::unique_ptr<TH1D> ConvertToTH1D(const RHist<RBinWithError> &hist)
{
   auto ret = ConvertToTH1D(hist.GetEngine());
   ConvertGlobalStatistics(*ret, hist.GetStats());
   return ret;
}
 
} // namespace Hist
} // namespace Experimental
} // namespace ROOT