YODA::AOReader< BinnedDbn< DbnN, AxisT... > > Class Template Reference

#include <ReaderUtils.h>

Inheritance diagram for YODA::AOReader< BinnedDbn< DbnN, AxisT... > >:

Public Member Functions
void	parse (const string &line)
AnalysisObject *	assemble (const string &path="")
Public Member Functions inherited from YODA::AOReaderBase
	AOReaderBase ()
	Default constructor.
virtual	~AOReaderBase ()
	Default destructor.
template<typename T >
void	extractVector (const std::string &line, std::vector< T > &vec)

Additional Inherited Members
Protected Attributes inherited from YODA::AOReaderBase
aistringstream	aiss

Detailed Description

template<size_t DbnN, typename... AxisT>
class YODA::AOReader< BinnedDbn< DbnN, AxisT... > >

Definition at line 275 of file ReaderUtils.h.

Member Function Documentation

assemble()

template<size_t DbnN, typename... AxisT>

AnalysisObject * YODA::AOReader< BinnedDbn< DbnN, AxisT... > >::assemble ( const string &  path = "" )

inlinevirtual

Implements YODA::AOReaderBase.

Definition at line 415 of file ReaderUtils.h.

                                                      {
 
      auto args = std::tuple_cat(edges, std::make_tuple(path));
      BaseT* ao = make_from_tuple(std::move(args));
 
      size_t global_index = 0;
      if (isYODA1 && sizeof...(AxisT) == 2)  ++global_index; // no 2D overflow in Y1
      for (auto&& d : dbns) {
        ao->bin(global_index++).set(std::move(d));
      }
 
      if constexpr (sizeof...(AxisT) == 1) { // YODA1-style overflows
        if (isYODA1)  ao->bin(global_index).set(yoda1Overflow);
        yoda1Overflow = Dbn<DbnN>();
      }
 
      crossTerms.fill(0);
      maskedBins.clear();
      isYODA1 = false;
      clearEdges<0>();
      dbns.clear();
      axisCheck = 0;
      return ao;
    }

References YODA::BinnedStorage< BinContentT, AxisT >::bin().

parse()

template<size_t DbnN, typename... AxisT>

void YODA::AOReader< BinnedDbn< DbnN, AxisT... > >::parse ( const string &  line )

inlinevirtual

Implements YODA::AOReaderBase.

Definition at line 365 of file ReaderUtils.h.

                                   {
      if (line.find("Total") != string::npos) {
        isYODA1 = true;
        return; // YODA1 backwards compatibility
      }
      if (!line.rfind("Edges(A", 0)) { // parse binning
        readEdges<0>(line);
        ++axisCheck;
        return;
      }
      if (!line.rfind("MaskedBins: ", 0)) { // parse indices of masked bins
        extractVector<size_t>(line, maskedBins);
        return;
      }
      aiss.reset(line);
      if (line.find("Underflow") != string::npos || line.find("Overflow") != string::npos) {
        // This must be the YODA1-style format ...
        if constexpr (sizeof...(AxisT) == 1) {
          string tmp1, tmp2;
          aiss >> tmp1 >> tmp2; // not needed
        }
      }
      else if (isYODA1)  readEdges<0>();
      std::array<double,DbnN+1> sumW, sumW2;
      readDbn<0>(sumW, sumW2);
      for (size_t i = 0; i < crossTerms.size(); ++i) {
        double tmp(0.);
        aiss >> tmp;
        crossTerms.at(i) = tmp;
      }
      double numEntries(0);
      aiss >> numEntries;
      if (line.find("Overflow") != string::npos) {
        if constexpr (sizeof...(AxisT) == 1) {
          if constexpr (DbnN < 2)
            yoda1Overflow = Dbn<DbnN>(numEntries, sumW, sumW2);
          else
            yoda1Overflow = Dbn<DbnN>(numEntries, sumW, sumW2, crossTerms);
        }
      }
      else {
        if constexpr (DbnN < 2) {
          dbns.emplace_back(numEntries, sumW, sumW2);
        }
        else {
          dbns.emplace_back(numEntries, sumW, sumW2, crossTerms);
        }
      }
    }

---

The documentation for this class was generated from the following file:

• include/YODA/Utils/ReaderUtils.h