BinningHandler.cpp File Reference

#include "Samples/BinningHandler.h"

Include dependency graph for BinningHandler.cpp:

Go to the source code of this file.

Functions
auto	BinRangeToBinEdges (YAML::Node const &bin_range)
auto	BuildBinEdgesFromNode (YAML::Node const &bin_edges_node, bool &found_range_specifier)
	Builds a single dimension's bin edges from YAML::Node. More...
auto	UniformBinEdgeConfigParser (YAML::Node const &bin_edges_node, bool &found_range_specifier)
	Parses YAML node describing multidim uniform binning. More...

Function Documentation

BinRangeToBinEdges()

auto BinRangeToBinEdges

(

YAML::Node const &

bin_range

)

Definition at line 9 of file BinningHandler.cpp.

                                                   {
// ************************************************
  bool is_lin = true;
  YAML::Node bin_range_specifier;
  if (bin_range["linspace"]) {
    bin_range_specifier = bin_range["linspace"];
  } else if (bin_range["logspace"]) {
    is_lin = false;
    bin_range_specifier = bin_range["logspace"];
  } else {
    std::stringstream ss;
    ss << bin_range;
    MACH3LOG_ERROR("When parsing binning, expected bin range specifier with "
                   "key linspace or logspace, but found,\n{}",
                   ss.str());
    throw MaCh3Exception(__FILE__, __LINE__);
  }
 
  auto nb = Get<int>(bin_range_specifier["nb"], __FILE__, __LINE__);
  auto low = Get<double>(bin_range_specifier["low"], __FILE__, __LINE__);
  auto up = Get<double>(bin_range_specifier["up"], __FILE__, __LINE__);
 
  std::vector<double> edges(nb + 1, low);
  // force the last bin to be exactly as parsed to avoid numerical instabilities
  // not quite lining back up with the end of the range, which could
  // cause spurious errors or infinitesimally small bins for specifications
  // like: [ { logspace: { nb: 10, 1E-1, 10}, 10, 11} ]
  edges.back() = up;
 
  if (is_lin) {
    double bw = (up - low) / nb;
    for (int i = 0; i < (nb - 1); ++i) {
      edges[i + 1] = edges[i] + bw;
    }
  } else {
    double llow = std::log10(low);
    double lup = std::log10(up);
    double lbw = (lup - llow) / nb;
    for (int i = 0; i < (nb - 1); ++i) {
      edges[i + 1] = std::pow(10, llow + (i + 1) * lbw);
    }
  }
 
  return edges;
}

BuildBinEdgesFromNode()

auto BuildBinEdgesFromNode	(	YAML::Node const &	bin_edges_node,
		bool &	found_range_specifier
	)

Builds a single dimension's bin edges from YAML::Node.

BinEdges: [ <dim0bin0lowedge>, <dim0bin1upedge>, <dim0bin2upedge>, ... <dim0binNupedge> ] BinEdges: { linspace: { nb: 100, low: 0, up: 10} } BinEdges: { logspace: { nb: 100, low: 1E-1, up: 10} } BinEdges: [ { linspace: { nb: 100, low: 0, up: 10} }, 10, 15, { logspace: { nb: 5, low: 15, up: 100} } ]

Definition at line 63 of file BinningHandler.cpp.

                                                        {
// ************************************************
  if (bin_edges_node.IsMap()) {
    found_range_specifier = true;
    return BinRangeToBinEdges(bin_edges_node);
  }
  std::vector<double> edges_builder;
  if (!bin_edges_node.IsSequence()) {
    std::stringstream ss;
    ss << bin_edges_node;
    MACH3LOG_ERROR(
        "When parsing binning, expected to find a YAML map or sequence, "
        "but found:\n{}",
        ss.str());
    throw MaCh3Exception(__FILE__, __LINE__);
  }
  for (auto const &it : bin_edges_node) {
    if (it.IsScalar()) {
      edges_builder.push_back(it.as<double>());
    } else if (it.IsMap()) {
      found_range_specifier = true;
      auto range_edges = BinRangeToBinEdges(it);
      std::copy(range_edges.begin(), range_edges.end(),
                std::back_inserter(edges_builder));
    } else {
      std::stringstream ss;
      ss << bin_edges_node;
      MACH3LOG_ERROR(
          "When parsing binning, expected elements in outer sequence to all be "
          "either scalars or maps, but found:\n{}",
          ss.str());
      throw MaCh3Exception(__FILE__, __LINE__);
    }
  }
 
  // Check for duplicates or out-of-order bins
  std::vector<double> edges;
  for (size_t eb_it = 0; eb_it < edges_builder.size(); ++eb_it) {
    if (edges.size()) {
      if (edges_builder[eb_it] == edges.back()) { // remove duplicate edges
        continue;
      } else if (edges_builder[eb_it] < edges.back()) {
        std::stringstream ss;
        ss << "[ ";
        for(auto const & e : edges_builder){
          ss << fmt::format("{:.3g} ", e);
        }
        ss << "]";
        MACH3LOG_ERROR(
            "When parsing binning, found edges that were not monotonically "
            "increasing, problem bin at index: {}:\n{}",
            eb_it, ss.str());
        throw MaCh3Exception(__FILE__, __LINE__);
      }
    }
    edges.push_back(edges_builder[eb_it]);
  }
 
  return edges;
}

UniformBinEdgeConfigParser()

auto UniformBinEdgeConfigParser	(	YAML::Node const &	bin_edges_node,
		bool &	found_range_specifier
	)

Parses YAML node describing multidim uniform binning.

dimensional list implicit for 1D binnings

BinEdges: [<dim0bin0lowedge>, <dim0bin1upedge>, <dim0bin2upedge>, ... <dim0binNupedge>]

BinEdges: [ [<dim0bin0lowedge>, <dim0bin1upedge>, <dim0bin2upedge>, ... <dim0binNupedge>], ... [<dimNbin0lowedge>, <dimNbin1upedge>, <dimNbin2upedge>, ... <dimNbinNupedge>] ]

bin edge list implicit for 1D range-only binnings

BinEdges: { linspace: { nb: 100, low: 0, up: 10} }

mixed syntax binnings allowed

BinEdges: [ { linspace: { nb: 100, low: 0, up: 10} }, 10, 15, { logspace: { nb: 5, low: 15, up: 100} } ] # for ND range-only binnings, lists are required to disambiguate 1D mixed specifier binnings from ND binnings BinEdges: [ [ { linspace: { nb: 100, low: 0, up: 10} } ], ... [<dimNbin0lowedge>, <dimNbin1upedge>, <dimNbin2upedge>, ... <dimNbinNupedge>] ] BinEdges: [ [ { linspace: { nb: 100, low: 0, up: 10} }, 10, 15, { logspace: { nb: 5, low: 15, up: 100} } ], ... [<dimNbin0lowedge>, <dimNbin1upedge>, <dimNbin2upedge>, ... <dimNbinNupedge>] ]

Definition at line 153 of file BinningHandler.cpp.

                                                             {
// ************************************************
  if (bin_edges_node.IsMap()) {
    found_range_specifier = true;
    return std::vector<std::vector<double>>{
        BinRangeToBinEdges(bin_edges_node),
    };
  } else if (bin_edges_node.IsSequence()) {
    if (!bin_edges_node.size()) {
      std::stringstream ss;
      ss << bin_edges_node;
      MACH3LOG_ERROR("When parsing binning, found an empty sequence:\n{}",
                     ss.str());
      throw MaCh3Exception(__FILE__, __LINE__);
    }
    auto const &first_el = bin_edges_node[0];
    if (first_el.IsScalar() || first_el.IsMap()) { // 1D binning
      return std::vector<std::vector<double>>{
          BuildBinEdgesFromNode(bin_edges_node, found_range_specifier),
      };
    }
    // ND binning
    std::vector<std::vector<double>> dims;
    for (auto const &dim_node : bin_edges_node) {
      dims.push_back(BuildBinEdgesFromNode(dim_node, found_range_specifier));
    }
    return dims;
  } else {
    std::stringstream ss;
    ss << bin_edges_node;
    MACH3LOG_ERROR(
        "When parsing binning, expected to find a YAML map or sequence, "
        "but found:\n{}",
        ss.str());
    throw MaCh3Exception(__FILE__, __LINE__);
  }
}