#include <Binning.h>

Public Member Functions
template<size_t I>
const Binning< Axes... >::template getAxisT< I > &	axis () const noexcept

template<size_t I>
Binning< Axes... >::template getAxisT< I > &	axis () noexcept

Constructors
	Binning ()
	Nullary constructor for unique pointers etc.

	Binning (const std::initializer_list< typename Axes::EdgeT > &... edges)
	Constructs binning from vectors of axes' edges.

	Binning (std::initializer_list< typename Axes::EdgeT > &&... edges)
	Constructs binning from Rvalue vectors of axes' edges.

	Binning (const Axes &... axes)
	Constructs binning from a sequence of axes.

	Binning (Axes &&... axes)
	Constructs binning from a sequence of Rvalue axes.

	Binning (const Binning &other)
	Copy constructor.

	Binning (Binning &&other)
	Move constructor.

Binning &	operator= (const Binning &other)
	Copy assignment.

Binning &	operator= (Binning &&other)
	Move assignment.

Indexing methods
size_t	localToGlobalIndex (const IndexArr &localIndices) const
	calculates global index from array of local indices

IndexArr	globalToLocalIndices (size_t globalIndex) const
	calculates array of local indices from a global index

IndexArr	localIndicesAt (const EdgeTypesTuple &coords) const
	assembles array of local indices for an array of input values

size_t	globalIndexAt (const EdgeTypesTuple &coords) const
	calculates global index for a given array of input values

std::vector< size_t >	calcOverflowBinsIndices () const noexcept
	Calculates indices of overflow bins.

size_t	countOverflowBins (const size_t axisN) const noexcept
	Count number of overflow bins.

std::vector< size_t >	maskedBins () const noexcept
	Calculates indices of masked bins.

void	clearMaskedBins () noexcept
	Clear masked bins.

void	maskBin (const size_t index, const bool status=true)
	Mask/Unmask bin with global index index.

void	maskBin (const IndexArr &localIndices, const bool status=true)
	Mask/Unmask bin with local localIndices.

void	maskBinAt (const EdgeTypesTuple &coords, const bool status=true) noexcept
	Mask/Unmask bin at set of @ coords.

void	maskBins (const std::vector< size_t > &indices, const bool status=true)
	Mask/Unmask bins in list of global indices.

void	maskSlice (const size_t dim, const size_t idx, const bool status=true)
	Mask a slice of the binning at local bin index idx along axis dimesnion dim.

bool	isMasked (const size_t i) const noexcept
	Check if bin is masked.

bool	isVisible (const size_t i) const noexcept
	Check if bin is in visible range.

size_t	calcSliceSize (const size_t pivotAxisN) const noexcept
	Calculates size of a binning slice.

std::vector< size_t >	sliceIndices (std::vector< std::pair< size_t, std::vector< size_t > > >) const noexcept
	Calculates indices of bins located in the specified slices.

std::vector< size_t >	sliceIndices (size_t axisN, size_t binN) const noexcept
	Calculates indices of bins located in the slice corresponding to bin at nBin at axis N.

void	updateMaskedBins () noexcept
	Helper function to extract and mask index slices corresponding to masked bins along the axes.

Transformations
template<size_t... AxisNs>
void	mergeBins (std::decay_t< decltype(AxisNs, std::declval< std::pair< size_t, size_t > >())>... mergeRanges) noexcept

Comparisons to other Binning objects
bool	isCompatible (const Binning< Axes... > &other) const noexcept
	checks if Binnings are compatible

Getters
template<size_t I>
const getAxisT< I > &	axis () const noexcept
	Extracts axis corresponding to dimension. Const version.

template<size_t I>
getAxisT< I > &	axis () noexcept
	Extracts axis corresponding to dimension. Non-const version.

size_t	dim () const noexcept
	get dimension of Binning

size_t	numBins (const bool includeOverflows=true, const bool includeMaskedBins=true) const noexcept
	get total number of bins in Binning

size_t	numBinsAt (const size_t axisN, const bool includeOverflows=true) const noexcept
	get number of bins at axis

EdgeTypesTuple	edgeTuple (const size_t index) const noexcept
	Return a coordinate tuple for bin index.

template<size_t I, typename E = getEdgeT<I>>
std::vector< E >	edges (const bool includeOverflows=false) const noexcept
	Templated version to get edges of axis N by value.

template<size_t I, typename E = getEdgeT<I>>
std::enable_if_t< std::is_floating_point< E >::value, std::vector< E > >	widths (const bool includeOverflows=false) const noexcept
	Templated version to get bin widths of axis N by reference.

template<size_t I, typename E = getEdgeT<I>>
std::enable_if_t< std::is_floating_point< E >::value, E >	min () const noexcept
	Get the lowest non-overflow edge of the axis.

template<size_t I, typename E = getEdgeT<I>>
std::enable_if_t< std::is_floating_point< E >::value, E >	max () const noexcept
	Get the highest non-overflow edge of the axis.

double	dVol (const size_t index) const
	Return the differential volume for bin index.

Utilities
using	IndexArr = std::array< size_t, sizeof...(Axes)>

template<size_t I>
using	getAxisT = std::tuple_element_t< I, std::tuple< Axes... > >

template<size_t I>
using	getEdgeT = typename getAxisT< I >::EdgeT

template<size_t I>
using	is_CAxis = typename std::is_floating_point< getEdgeT< I > >

template<size_t I>
using	is_Arithmetic = typename std::is_arithmetic< getEdgeT< I > >

using	all_CAxes = typename std::conjunction< std::is_floating_point< typename Axes::EdgeT >... >

using	EdgeTypesTuple = decltype(std::tuple_cat(std::declval< std::tuple< typename Axes::EdgeT > >()...))

using	Dimension = std::integral_constant< size_t, sizeof...(Axes)>

Detailed Description

template<typename... Axes>
class YODA::Binning< Axes >

Definition at line 48 of file Binning.h.

Member Typedef Documentation

◆ all_CAxes

template<typename... Axes>

using YODA::Binning< Axes >::all_CAxes = typename std::conjunction<std::is_floating_point<typename Axes::EdgeT>...>

Definition at line 82 of file Binning.h.

◆ Dimension

template<typename... Axes>

using YODA::Binning< Axes >::Dimension = std::integral_constant<size_t, sizeof...(Axes)>

Definition at line 87 of file Binning.h.

◆ EdgeTypesTuple

template<typename... Axes>

using YODA::Binning< Axes >::EdgeTypesTuple = decltype( std::tuple_cat(std::declval<std::tuple<typename Axes::EdgeT> >()...))

Definition at line 84 of file Binning.h.

◆ getAxisT

template<typename... Axes>

template<size_t I>

using YODA::Binning< Axes >::getAxisT = std::tuple_element_t<I, std::tuple<Axes...> >

Definition at line 71 of file Binning.h.

◆ getEdgeT

template<typename... Axes>

template<size_t I>

using YODA::Binning< Axes >::getEdgeT = typename getAxisT::EdgeT

Definition at line 74 of file Binning.h.

◆ IndexArr

template<typename... Axes>

using YODA::Binning< Axes >::IndexArr = std::array<size_t, sizeof...(Axes)>

protected

Definition at line 61 of file Binning.h.

◆ is_Arithmetic

template<typename... Axes>

template<size_t I>

using YODA::Binning< Axes >::is_Arithmetic = typename std::is_arithmetic<getEdgeT >

Definition at line 80 of file Binning.h.

◆ is_CAxis

template<typename... Axes>

template<size_t I>

using YODA::Binning< Axes >::is_CAxis = typename std::is_floating_point<getEdgeT >

Definition at line 77 of file Binning.h.

Constructor & Destructor Documentation

◆ Binning() [1/7]

template<typename... Axes>

YODA::Binning< Axes >::Binning ( )

inline

Nullary constructor for unique pointers etc.

Definition at line 95 of file Binning.h.

95{ }

◆ Binning() [2/7]

template<typename... Axes>

YODA::Binning< Axes >::Binning ( const std::initializer_list< typename Axes::EdgeT > &... edges )

inline

Constructs binning from vectors of axes' edges.

Definition at line 98 of file Binning.h.

        : _axes(Axes(edges)...) {
      updateMaskedBins();
    }

References YODA::Binning< Axes >::updateMaskedBins().

◆ Binning() [3/7]

template<typename... Axes>

YODA::Binning< Axes >::Binning ( std::initializer_list< typename Axes::EdgeT > &&... edges )

inline

Constructs binning from Rvalue vectors of axes' edges.

Definition at line 104 of file Binning.h.

        : _axes(Axes(std::move(edges))...) {
      updateMaskedBins();
    }

References YODA::Binning< Axes >::updateMaskedBins().

◆ Binning() [4/7]

template<typename... Axes>

YODA::Binning< Axes >::Binning ( const Axes &... axes )

inline

Constructs binning from a sequence of axes.

Definition at line 110 of file Binning.h.

        : _axes(axes...) {
      updateMaskedBins();
    }

References YODA::Binning< Axes >::updateMaskedBins().

◆ Binning() [5/7]

template<typename... Axes>

YODA::Binning< Axes >::Binning ( Axes &&... axes )

inline

Constructs binning from a sequence of Rvalue axes.

Definition at line 116 of file Binning.h.

        : _axes(std::move(axes)...) {
      updateMaskedBins();
    }

References YODA::Binning< Axes >::updateMaskedBins().

◆ Binning() [6/7]

template<typename... Axes>

YODA::Binning< Axes >::Binning ( const Binning< Axes > & other )

inline

Copy constructor.

Definition at line 122 of file Binning.h.

122: _axes(other._axes), _maskedIndices(other._maskedIndices) {}

◆ Binning() [7/7]

template<typename... Axes>

YODA::Binning< Axes >::Binning ( Binning< Axes > && other )

inline

Move constructor.

Definition at line 125 of file Binning.h.

125: _axes(std::move(other._axes)), _maskedIndices(std::move(other._maskedIndices)) {}

Member Function Documentation

◆ axis() [1/4]

template<typename... Axes>

template<size_t I>

const getAxisT & YODA::Binning< Axes >::axis ( ) const

noexcept

Extracts axis corresponding to dimension. Const version.

Referenced by YODA::Binning< Axes >::edges(), YODA::Binning< Axes >::max(), YODA::Binning< Axes >::min(), YODA::Binning< Axes >::updateMaskedBins(), and YODA::Binning< Axes >::widths().

◆ axis() [2/4]

template<typename... Axes>

template<size_t I>

const Binning< Axes... >::template getAxisT & YODA::Binning< Axes >::axis ( ) const

noexcept

Definition at line 678 of file Binning.h.

                                        {
    return std::get<I>(_axes);
  }

◆ axis() [3/4]

template<typename... Axes>

template<size_t I>

getAxisT & YODA::Binning< Axes >::axis ( )

noexcept

Extracts axis corresponding to dimension. Non-const version.

◆ axis() [4/4]

template<typename... Axes>

template<size_t I>

Binning< Axes... >::template getAxisT & YODA::Binning< Axes >::axis ( )

noexcept

Definition at line 685 of file Binning.h.

                                  {
    return std::get<I>(_axes);
  }

◆ calcOverflowBinsIndices()

template<typename... Axes>

std::vector< size_t > YODA::Binning< Axes >::calcOverflowBinsIndices ( ) const

noexcept

Calculates indices of overflow bins.

Definition at line 451 of file Binning.h.

                                                                             {
    IndexArr axesSizes = _getAxesSizes();
    std::vector<bool> isCAxis;
 
    auto getCAxisIndices = [&isCAxis](auto I){
      using isContinuous = typename Binning::template is_CAxis<I>;
      isCAxis.emplace_back(isContinuous::value);
    };
 
    MetaUtils::staticFor<Dimension::value>(getCAxisIndices);
 
    std::vector<std::pair<size_t, std::vector<size_t>>> slicePivots;
    slicePivots.reserve(isCAxis.size());
 
    for (size_t axisN = 0; axisN < isCAxis.size(); ++axisN) {
      if (isCAxis[axisN])
        slicePivots.push_back({axisN, {0, axesSizes[axisN]-1} });
      else
        slicePivots.push_back({axisN, {0} });
    }
 
    std::vector<size_t> res = sliceIndices(slicePivots);
    std::sort(res.begin(), res.end());
    res.erase( std::unique(res.begin(), res.end()), res.end() );
    return res;
  }

◆ calcSliceSize()

template<typename... Axes>

size_t YODA::Binning< Axes >::calcSliceSize ( const size_t pivotAxisN ) const

noexcept

Calculates size of a binning slice.

Definition at line 561 of file Binning.h.

                                                                               {
    const IndexArr axesSizes = _getAxesSizes();
    size_t sliceSize = 1;
    for (size_t iDim = 0; iDim < _dim; ++iDim) {
      if (iDim == pivotAxisN)
        continue;
      sliceSize *= (axesSizes[iDim]);
    }
    return sliceSize;
  }

◆ clearMaskedBins()

template<typename... Axes>

void YODA::Binning< Axes >::clearMaskedBins ( )

inlinenoexcept

Clear masked bins.

Definition at line 172 of file Binning.h.

172{ _maskedIndices.clear(); }

◆ countOverflowBins()

template<typename... Axes>

size_t YODA::Binning< Axes >::countOverflowBins ( const size_t axisN ) const

noexcept

Count number of overflow bins.

Helper function to count the number of under/other/overflow bins for a given axis axisN.

Continuous axes have an underflow and an overflow bin (= 2). Discrete axes have an otherflow bin (= 1).

Definition at line 485 of file Binning.h.

                                                                              {
    std::vector<bool> CAxisIndices;
 
    auto getCAxisIndices = [&CAxisIndices](auto I){
      using isContinuous = typename Binning::template is_CAxis<I>;
      CAxisIndices.emplace_back(isContinuous::value);
    };
 
    MetaUtils::staticFor<Dimension::value>(getCAxisIndices);
    return CAxisIndices.at(axisN) + 1;
  }

◆ dim()

template<typename... Axes>

size_t YODA::Binning< Axes >::dim ( ) const

noexcept

get dimension of Binning

Definition at line 711 of file Binning.h.

                                              {
    return _dim;
  }

◆ dVol()

template<typename... Axes>

double YODA::Binning< Axes >::dVol ( const size_t index ) const

Return the differential volume for bin index.

Definition at line 784 of file Binning.h.

                                                        {
    double rtn = 1.0;
    IndexArr indices = globalToLocalIndices(index);
 
    auto getCAxisWidths = [&rtn, &indices, &axes = _axes](auto I){
      using isContinuous = typename Binning::template is_CAxis<I>;
      if constexpr (isContinuous::value) {
        const auto& axis = std::get<I>(axes);
        const size_t idx = std::get<I>(indices);
        rtn *= axis.width(idx);
      }
    };
    MetaUtils::staticFor<Binning::Dimension::value>(getCAxisWidths);
 
    return rtn;
  }

◆ edges()

template<typename... Axes>

template<size_t I, typename E = getEdgeT>

std::vector< E > YODA::Binning< Axes >::edges ( const bool includeOverflows = false ) const

inlinenoexcept

Templated version to get edges of axis N by value.

+-inf edges are included, depending on the value of includeOverflows Needed by axis-specific version from StatsMixin

Definition at line 286 of file Binning.h.

                                                                           {
      const auto& axis = std::get<I>(_axes);
      if (!includeOverflows && Binning::template is_CAxis<I>::value) {
        auto&& all_edges = axis.edges();
        typename std::vector<E> rtn;
        const size_t offset = all_edges.size() - 1;
        rtn.insert(rtn.end(), std::make_move_iterator(all_edges.begin()+1),
                              std::make_move_iterator(all_edges.begin()+offset));
        return rtn;
      }
      return axis.edges();
    }

References YODA::Binning< Axes >::axis().

◆ edgeTuple()

template<typename... Axes>

Binning< Axes... >::EdgeTypesTuple YODA::Binning< Axes >::edgeTuple ( const size_t index ) const

noexcept

Return a coordinate tuple for bin index.

Definition at line 762 of file Binning.h.

                                                               {
 
    EdgeTypesTuple coords;
    IndexArr indices = globalToLocalIndices(index);
 
    auto setCoords = [&coords, &indices, &axes = _axes](auto I) {
      using isContinuous = typename Binning::template is_CAxis<I>;
      const auto& axis = std::get<I>(axes);
      const size_t idx = std::get<I>(indices);
      if constexpr(isContinuous::value) {
        std::get<I>(coords) = axis.mid(idx);
      }
      else {
        std::get<I>(coords) = axis.edge(idx);
      }
    };
    MetaUtils::staticFor<Dimension::value>(setCoords);
 
    return coords;
  }

◆ globalIndexAt()

template<typename... Axes>

size_t YODA::Binning< Axes >::globalIndexAt ( const EdgeTypesTuple & coords ) const

calculates global index for a given array of input values

Definition at line 446 of file Binning.h.

                                                                           {
    return localToGlobalIndex(localIndicesAt(coords));
  }

Referenced by YODA::Binning< Axes >::maskBinAt().

◆ globalToLocalIndices()

template<typename... Axes>

Binning< Axes... >::IndexArr YODA::Binning< Axes >::globalToLocalIndices ( size_t globalIndex ) const

calculates array of local indices from a global index

Definition at line 408 of file Binning.h.

                                                                 {
    if (globalIndex >= numBins(true, true))  throw RangeError("Global index outside bin range");
    IndexArr localIndices{};
 
    IndexArr axesSizes = _getAxesSizes();
 
    for (ssize_t iIndex = localIndices.size()-1 ; iIndex >= 0; --iIndex){
      size_t productOfNestedBinSizes = 1;
 
      for (ssize_t iBinnedAxis = iIndex - 1; iBinnedAxis >= 0; --iBinnedAxis) {
        productOfNestedBinSizes *= (axesSizes[iBinnedAxis]);
      }
 
      // integer division to get the multiplier
      localIndices[iIndex] = globalIndex / productOfNestedBinSizes;
      // then left with only the remainder
      globalIndex = globalIndex % productOfNestedBinSizes;
    }
    return localIndices;
  }

◆ isCompatible()

template<typename... Axes>

bool YODA::Binning< Axes >::isCompatible ( const Binning< Axes... > & other ) const

noexcept

checks if Binnings are compatible

Binnings are compatible if they have the same number of axes, and those axes have the same bin edges

If one comparison fails, isEqal will stay false

Definition at line 717 of file Binning.h.

                                                                                  {
    // compatible if they have the same number of axes,
    // and those axes have the same bin edges
    if (_dim != other.dim())
      return false;
 
    std::array<bool, 1> isEqual{true};
    auto isEqAxes =
      [&isEqual, &axes1 = _axes, &axes2 = other._axes](auto I) {
        const auto& axis_lhs = std::get<I>(axes1);
        const auto& axis_rhs = std::get<I>(axes2);
 
        isEqual[0] &= axis_lhs.hasSameEdges(axis_rhs);
    };
 
    MetaUtils::staticFor<Dimension::value>(isEqAxes);
 
    return isEqual[0];
  }

◆ isMasked()

template<typename... Axes>

bool YODA::Binning< Axes >::isMasked ( const size_t i ) const

noexcept

Check if bin is masked.

Definition at line 547 of file Binning.h.

                                                               {
    const auto& itEnd = _maskedIndices.cend();
    return  std::find(_maskedIndices.cbegin(), itEnd, i) != itEnd;
  }

◆ isVisible()

template<typename... Axes>

bool YODA::Binning< Axes >::isVisible ( const size_t i ) const

noexcept

Check if bin is in visible range.

Definition at line 554 of file Binning.h.

                                                                {
    const std::vector<size_t> overflows = calcOverflowBinsIndices();
    const auto& itEnd = overflows.cend();
    return  std::find(overflows.cbegin(), itEnd, i) == itEnd;
  }

◆ localIndicesAt()

template<typename... Axes>

Binning< Axes... >::IndexArr YODA::Binning< Axes >::localIndicesAt ( const EdgeTypesTuple & coords ) const

assembles array of local indices for an array of input values

Definition at line 431 of file Binning.h.

                                                                     {
    IndexArr localIndices{};
    auto extractIndices = [&localIndices, &coords, &axes = _axes](auto I) {
                               const auto& coord = std::get<I>(coords);
                               const auto& axis  = std::get<I>(axes);
 
                               localIndices[I] = axis.index(coord);
                             };
 
    MetaUtils::staticFor<Dimension::value>(extractIndices);
 
    return localIndices;
  }

◆ localToGlobalIndex()

template<typename... Axes>

size_t YODA::Binning< Axes >::localToGlobalIndex ( const IndexArr & localIndices ) const

calculates global index from array of local indices

x + y*width + z*width*height + w*width*height*depth + ...

Definition at line 386 of file Binning.h.

                                                                                {
    size_t gIndex = 0;
    // std::string st_indices = "";
    // for (size_t iIndex = 0; iIndex < localIndices.size(); ++iIndex) {
    //   st_indices += "|";
    //   st_indices += std::to_string(localIndices[iIndex]);
    // }
 
    IndexArr axesSizes = _getAxesSizes();
    for (size_t iIndex = 0; iIndex < localIndices.size(); ++iIndex) {
      size_t productOfBinSizes = 1;
      for (ssize_t iBinnedAxis = iIndex - 1; iBinnedAxis >= 0; --iBinnedAxis) {
        productOfBinSizes *= (axesSizes[iBinnedAxis]);
      }
      gIndex += localIndices[iIndex] * productOfBinSizes;
    }
    return gIndex;
  }

Referenced by YODA::Binning< Axes >::maskBin().

◆ maskBin() [1/2]

template<typename... Axes>

void YODA::Binning< Axes >::maskBin	(	const IndexArr &	localIndices,
		const bool	status = `true`
	)

Mask/Unmask bin with local localIndices.

Definition at line 517 of file Binning.h.

                                                                                {
    const size_t gIndex = Binning<Axes...>::localToGlobalIndex(localIndices);
    Binning<Axes...>::maskBins({{gIndex}}, status);
  }

References YODA::Binning< Axes >::localToGlobalIndex(), and YODA::Binning< Axes >::maskBins().

◆ maskBin() [2/2]

template<typename... Axes>

void YODA::Binning< Axes >::maskBin	(	const size_t	index,
		const bool	status = `true`
	)

Mask/Unmask bin with global index index.

Only visible in this translation unit.

Definition at line 512 of file Binning.h.

                                                                      {
    Binning<Axes...>::maskBins({{index}}, status);
  }

References YODA::Binning< Axes >::maskBins().

◆ maskBinAt()

template<typename... Axes>

void YODA::Binning< Axes >::maskBinAt	(	const EdgeTypesTuple &	coords,
		const bool	status = `true`
	)

noexcept

Mask/Unmask bin at set of @ coords.

Definition at line 523 of file Binning.h.

                                                                                           {
    const size_t gIndex = Binning<Axes...>::globalIndexAt(coords);
    Binning<Axes...>::maskBins({{gIndex}}, status);
  }

References YODA::Binning< Axes >::globalIndexAt(), and YODA::Binning< Axes >::maskBins().

◆ maskBins()

template<typename... Axes>

void YODA::Binning< Axes >::maskBins	(	const std::vector< size_t > &	indices,
		const bool	status = `true`
	)

Mask/Unmask bins in list of global indices.

Definition at line 529 of file Binning.h.

                                                                                     {
    for (size_t i : indices) {
      const auto& itEnd = this->_maskedIndices.cend();
      const auto& res = std::find(this->_maskedIndices.cbegin(), itEnd, i);
      if (status && res == itEnd)  this->_maskedIndices.push_back(i);
      else if (!status && res != itEnd)  this->_maskedIndices.erase(res);
    }
  }

Referenced by YODA::Binning< Axes >::maskBin(), YODA::Binning< Axes >::maskBin(), YODA::Binning< Axes >::maskBinAt(), and YODA::Binning< Axes >::maskSlice().

◆ maskedBins()

template<typename... Axes>

std::vector< size_t > YODA::Binning< Axes >::maskedBins ( ) const

inlinenoexcept

Calculates indices of masked bins.

Definition at line 169 of file Binning.h.

169{ return _maskedIndices; }

◆ maskSlice()

template<typename... Axes>

void YODA::Binning< Axes >::maskSlice	(	const size_t	dim,
		const size_t	idx,
		const bool	status = `true`
	)

Mask a slice of the binning at local bin index idx along axis dimesnion dim.

Definition at line 539 of file Binning.h.

                                                                                        {
    //_binning.maskSlice(dim, idx, status);
    std::vector<std::pair<size_t, std::vector<size_t>>> slicePivot{{dim,{idx}}};
    std::vector<size_t> indices = Binning<Axes...>::sliceIndices(slicePivot);
    Binning<Axes...>::maskBins(indices, status);
  }

References YODA::Binning< Axes >::maskBins(), and YODA::Binning< Axes >::sliceIndices().

◆ max()

template<typename... Axes>

template<size_t I, typename E = getEdgeT>

std::enable_if_t< std::is_floating_point< E >::value, E > YODA::Binning< Axes >::max ( ) const

inlinenoexcept

Get the highest non-overflow edge of the axis.

Note: This method is only supported for continuous axes

Definition at line 326 of file Binning.h.

                                                                         {
      const auto& axis = std::get<I>(_axes);
      assert(axis.numBins(true) > 2); // More than 2 overflow bins.
      return axis.min(axis.numBins(true)-1); // Bin 0 is the underflow bin.
    }

References YODA::Binning< Axes >::axis().

◆ mergeBins()

template<typename... Axes>

template<size_t... AxisNs>

void YODA::Binning< Axes >::mergeBins ( std::decay_t< decltype(AxisNs, std::declval< std::pair< size_t, size_t > >())>... mergeRanges )

noexcept

Definition at line 666 of file Binning.h.

                                                                                                 {
 
    ((void)axis<AxisNs>().mergeBins(mergeRanges), ...);
    updateMaskedBins();
 
  }

◆ min()

template<typename... Axes>

template<size_t I, typename E = getEdgeT>

std::enable_if_t< std::is_floating_point< E >::value, E > YODA::Binning< Axes >::min ( ) const

inlinenoexcept

Get the lowest non-overflow edge of the axis.

Note: This method is only supported for continuous axes

Definition at line 316 of file Binning.h.

                                                                         {
      const auto& axis = std::get<I>(_axes);
      assert(axis.numBins(true) > 2); // More than 2 overflow bins.
      return axis.min(1); // Bin 0 is the underflow bin.
    }

References YODA::Binning< Axes >::axis().

◆ numBins()

template<typename... Axes>

size_t YODA::Binning< Axes >::numBins	(	const bool	includeOverflows = `true`,
		const bool	includeMaskedBins = `true`
	)		const

noexcept

get total number of bins in Binning

Definition at line 739 of file Binning.h.

                                                                                                           {
    size_t nBins = 0;
    IndexArr axesSizes = _getAxesSizes(includeOverflows);
    assert(axesSizes.size() > 0);
    nBins = axesSizes[0];
    if constexpr (sizeof...(Axes) > 1) {
      for (size_t iDim = 1; iDim < _dim; ++iDim) {
        nBins *= (axesSizes[iDim]);
      }
    }
    const size_t maskedBins = includeMaskedBins? 0 : _maskedIndices.size();
    return nBins - maskedBins;
  }

◆ numBinsAt()

template<typename... Axes>

size_t YODA::Binning< Axes >::numBinsAt	(	const size_t	axisN,
		const bool	includeOverflows = `true`
	)		const

noexcept

get number of bins at axis

Definition at line 754 of file Binning.h.

                                                                                                   {
    IndexArr axesSizes = _getAxesSizes(includeOverflows);
    assert(axesSizes.size() > 0);
    return axesSizes[axisN];
  }

◆ operator=() [1/2]

template<typename... Axes>

Binning & YODA::Binning< Axes >::operator= ( Binning< Axes > && other )

inline

Move assignment.

Definition at line 137 of file Binning.h.

                                        {
      if (this != &other) {
        _axes = std::move(other._axes);
        _maskedIndices = std::move(other._maskedIndices);
      }
      return *this;
    }

◆ operator=() [2/2]

template<typename... Axes>

Binning & YODA::Binning< Axes >::operator= ( const Binning< Axes > & other )

inline

Copy assignment.

Definition at line 128 of file Binning.h.

                                             {
      if (this != &other) {
        _axes = other._axes;
        _maskedIndices = other._maskedIndices;
      }
      return *this;
    }

◆ sliceIndices() [1/2]

template<typename... Axes>

std::vector< size_t > YODA::Binning< Axes >::sliceIndices	(	size_t	axisN,
		size_t	binN
	)		const

noexcept

Calculates indices of bins located in the slice corresponding to bin at nBin at axis N.

x + y*width + (const value of pivot bin)*width*height + w*width*height*depth + ...

Definition at line 612 of file Binning.h.

                                                                                                       {
    if(sizeof...(Axes) == 1) {
      return {binN};
    }
    const IndexArr axesSizes = _getAxesSizes();
    const size_t sliceSize = calcSliceSize(axisN);
 
    IndexArr multiIdx{};
    multiIdx[axisN] = binN;
    std::vector<size_t> slicedIndices;
 
    assert(axesSizes.size() != 0);
    slicedIndices.reserve(sliceSize);
 
    /* @note Iteratively generates permutations of multindex for fixed
    */
    size_t idxShift = axisN == 0 ? 1 : 0;
 
    size_t idx = idxShift;
 
    while (true) {
      slicedIndices.emplace_back(localToGlobalIndex(multiIdx));
 
      multiIdx[idx]++;
 
      while (multiIdx[idx] == axesSizes[idx] || idx == axisN) {
        // Overflow, we're done
        if (idx == axesSizes.size() - 1) {
          return slicedIndices;
        }
 
        if(idx != axisN)
          multiIdx[idx] = 0;
 
        idx++;
 
        if(idx != axisN)
          multiIdx[idx]++;
      }
 
      idx = idxShift;
    }
 
    return slicedIndices;
  }

◆ sliceIndices() [2/2]

template<typename... Axes>

std::vector< size_t > YODA::Binning< Axes >::sliceIndices ( std::vector< std::pair< size_t, std::vector< size_t > > > slicePivots ) const

noexcept

Calculates indices of bins located in the specified slices.

Note: Accept vector of pairs where pair.first is index of axis, and pair.second is slice pivot bins on this axis.

Definition at line 574 of file Binning.h.

                                                                                                         {
 
    std::vector<size_t> slicesSizes;
    slicesSizes.reserve(slicePivots.size());
    size_t slicedIndicesVecSize = 0;
 
    for (const auto& slicePivot : slicePivots) {
      if(slicePivot.second.size() == 0)
        continue;
 
      const size_t& sliceSize = calcSliceSize(slicePivot.first);
 
      slicesSizes.emplace_back(sliceSize);
      slicedIndicesVecSize += sliceSize;
    }
 
    std::vector<size_t> slicedIndices;
    slicedIndices.reserve(slicedIndicesVecSize);
 
    auto appendSliceIndices = [&slicedIndices](std::vector<size_t>&& overflowSlice) {
      slicedIndices.insert(std::end(slicedIndices),
                           std::make_move_iterator(std::begin(overflowSlice)),
                           std::make_move_iterator(std::end(overflowSlice)));
    };
 
    for (const auto& slicePivot : slicePivots) {
      const size_t axisN = slicePivot.first;
      const auto& binPivots = slicePivot.second;
 
      for(const auto& binPivot : binPivots) {
        appendSliceIndices(sliceIndices(axisN, binPivot));
      }
    }
 
    return slicedIndices;
  }

Referenced by YODA::Binning< Axes >::maskSlice(), YODA::BinnedStorage< BinContentT, AxisT >::mergeBins(), and YODA::Binning< Axes >::updateMaskedBins().

◆ updateMaskedBins()

template<typename... Axes>

void YODA::Binning< Axes >::updateMaskedBins ( )

inlinenoexcept

Helper function to extract and mask index slices corresponding to masked bins along the axes.

Definition at line 209 of file Binning.h.

                                     {
 
      std::vector<std::pair<size_t, std::vector<size_t>>> slicePivots;
      auto extractMaskedBins = [&slicePivots, &axes = _axes](auto I) {
        using isContinuous = typename Binning::template is_CAxis<I>;
 
        if constexpr(isContinuous::value) {
          const auto& axis = std::get<I>(axes);
          slicePivots.push_back({I, {axis.maskedBins()} });
        }
      };
 
      // apply for all axes
      MetaUtils::staticFor<Dimension::value>(extractMaskedBins);
 
      // get indices along slice pivots and remove duplicates
      _maskedIndices = sliceIndices(slicePivots);
      std::sort(_maskedIndices.begin(), _maskedIndices.end());
      _maskedIndices.erase( std::unique(_maskedIndices.begin(), _maskedIndices.end()),
                            _maskedIndices.end() );
    }

References YODA::Binning< Axes >::axis(), and YODA::Binning< Axes >::sliceIndices().

Referenced by YODA::Binning< Axes >::Binning(), YODA::Binning< Axes >::Binning(), YODA::Binning< Axes >::Binning(), and YODA::Binning< Axes >::Binning().

◆ widths()

template<typename... Axes>

template<size_t I, typename E = getEdgeT>

std::enable_if_t< std::is_floating_point< E >::value, std::vector< E > > YODA::Binning< Axes >::widths ( const bool includeOverflows = false ) const

inlinenoexcept

Templated version to get bin widths of axis N by reference.

Overflows are included depending on includeOverflows Needed by axis-specific version from AxisMixin

Note: This version is only supported for continuous axes.

Definition at line 307 of file Binning.h.

                                                               {
      const auto& axis = std::get<I>(_axes);
      return axis.widths(includeOverflows);
    }

References YODA::Binning< Axes >::axis().

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

include/YODA/Binning.h

Public Member Functions

Utilities

Detailed Description

Member Typedef Documentation

◆ all_CAxes

◆ Dimension

◆ EdgeTypesTuple

◆ getAxisT

◆ getEdgeT

◆ IndexArr

◆ is_Arithmetic

◆ is_CAxis

Constructor & Destructor Documentation

◆ Binning() [1/7]

◆ Binning() [2/7]

◆ Binning() [3/7]

◆ Binning() [4/7]

◆ Binning() [5/7]

◆ Binning() [6/7]

◆ Binning() [7/7]

Member Function Documentation

◆ axis() [1/4]

◆ axis() [2/4]

◆ axis() [3/4]

◆ axis() [4/4]

◆ calcOverflowBinsIndices()

◆ calcSliceSize()

◆ clearMaskedBins()

◆ countOverflowBins()

◆ dim()

◆ dVol()

◆ edges()

◆ edgeTuple()

◆ globalIndexAt()

◆ globalToLocalIndices()

◆ isCompatible()

◆ isMasked()

◆ isVisible()

◆ localIndicesAt()

◆ localToGlobalIndex()

◆ maskBin() [1/2]

◆ maskBin() [2/2]

◆ maskBinAt()

◆ maskBins()

◆ maskedBins()

◆ maskSlice()

◆ max()

◆ mergeBins()

◆ min()

◆ numBins()

◆ numBinsAt()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ sliceIndices() [1/2]

◆ sliceIndices() [2/2]

◆ updateMaskedBins()

◆ widths()