SampleBinningInfo Struct Reference

KS: Struct storing all information required for sample binning. More...

#include <Samples/SampleStructs.h>

Collaboration diagram for SampleBinningInfo:

Public Member Functions
void	InitUniform (const std::vector< std::vector< double >> &InputEdges)
	Initialise Uniform Binning. More...
void	CheckBinsDoNotOverlap (const std::vector< BinInfo > &TestedBins) const
	Check that non-uniform bin extents do not overlap. More...
void	CheckBinsHaveNoGaps (const std::vector< BinInfo > &TestedBins, const std::vector< double > &MinVal, const std::vector< double > &MaxVal, size_t ValidationBinsPerDim=100) const
	Check that non-uniform bins fully cover the bounding box (no gaps) More...
void	InitialiseGridMapping ()
	Initialise Non-Uniform Binning. More...
void	InitNonUniform (const std::vector< std::vector< std::vector< double >>> &InputBins)
	Initialise Non-Uniform Binning. More...
int	GetBinSafe (const std::vector< int > &BinIndices) const
	Get linear bin index from ND bin indices with additional checks. More...
int	GetBin (const std::vector< int > &BinIndices) const
	Convert N-dimensional bin indices to a linear bin index. More...
int	FindBin (const int Dimension, const double Var, const int NomBin) const
	DB Find the relevant bin in the PDF for each event. More...
int	FindBin (const double KinVar, const int NomBin, const int N_Bins, const std::vector< double > &Bin_Edges, const std::vector< BinShiftLookup > &Bin_Lookup) const
	DB Find the relevant bin in the PDF for each event. More...
void	InitialiseLookUpSingleDimension (std::vector< BinShiftLookup > &Bin_Lookup, const std::vector< double > &Bin_Edges, const int TotBins)
	Initializes lookup arrays for efficient bin migration in a single dimension. More...
void	InitialiseStrides (const int Dimension)
	Initialise stride factors for linear bin index calculation. More...
void	InitialiseBinMigrationLookUp (const int Dimension)
	Initialise special lookup arrays allowing to more efficiently perform bin-migration These arrays store the lower and upper edges of each bin and their neighboring bins. More...

Public Attributes
std::vector< std::vector< double > >	BinEdges
	Vector to hold N-axis bin-edges. More...
std::vector< int >	AxisNBins
	Number of N-axis bins in the histogram used for likelihood calculation. More...
int	nBins = M3::_BAD_INT_
	Number of total bins. More...
int	GlobalOffset = M3::_BAD_INT_
	If you have binning for multiple samples and trying to define 1D vector let's. More...
std::vector< std::vector< BinShiftLookup > >	BinLookup
	Bin lookups for all dimensions. More...
std::vector< int >	Strides
	Stride factors for converting N-dimensional bin indices to a linear index. More...
bool	Uniform = true
	Tells whether to use inform binning grid or non-uniform. More...
std::vector< BinInfo >	Bins
	Bins used only for non-uniform. More...
std::vector< std::vector< int > >	BinGridMapping
	This grid tells what bins are associated with with what BinEdges of Grid Binnins. More...

Detailed Description

KS: Struct storing all information required for sample binning.

This struct encapsulates the full binning definition for a single analysis sample. It stores the bin edges, number of bins per dimension, stride factors, and lookup tables required to efficiently map multi-dimensional kinematic variables to linear bin indices.

Author

Kamil Skwarczynski

Definition at line 232 of file SampleStructs.h.

Member Function Documentation

CheckBinsDoNotOverlap()

void SampleBinningInfo::CheckBinsDoNotOverlap ( const std::vector< BinInfo > &  TestedBins ) const

inline

Check that non-uniform bin extents do not overlap.

Definition at line 290 of file SampleStructs.h.

                                                                         {
    if (TestedBins.empty()) return;
 
    const size_t ExtentDim = TestedBins[0].Extent.size();
 
    for (size_t i = 0; i < TestedBins.size(); ++i) {
      for (size_t j = i + 1; j < TestedBins.size(); ++j) {
        bool OverlapsInAllDims = true;
 
        for (size_t iDim = 0; iDim < ExtentDim; ++iDim) {
          const double a_lo = TestedBins[i].Extent[iDim][0];
          const double a_hi = TestedBins[i].Extent[iDim][1];
          const double b_lo = TestedBins[j].Extent[iDim][0];
          const double b_hi = TestedBins[j].Extent[iDim][1];
 
          // [low, high) overlap check
          if (!(a_lo < b_hi && b_lo < a_hi)) {
            OverlapsInAllDims = false;
            break;
          }
        }
 
        if (OverlapsInAllDims) {
          MACH3LOG_ERROR("Overlapping non-uniform bins detected: Bin {} and Bin {}", i, j);
          for (size_t iDim = 0; iDim < ExtentDim; ++iDim) {
            MACH3LOG_ERROR("  Dim {}: Bin {} [{}, {}), Bin {} [{}, {})",
                           iDim,
                           i, TestedBins[i].Extent[iDim][0], TestedBins[i].Extent[iDim][1],
                           j, TestedBins[j].Extent[iDim][0], TestedBins[j].Extent[iDim][1]);
          }
          throw MaCh3Exception(__FILE__, __LINE__);
        }
      }
    }
  }

CheckBinsHaveNoGaps()

void SampleBinningInfo::CheckBinsHaveNoGaps ( const std::vector< BinInfo > &  TestedBins, const std::vector< double > &  MinVal, const std::vector< double > &  MaxVal, size_t  ValidationBinsPerDim = 100  ) const

inline

Check that non-uniform bins fully cover the bounding box (no gaps)

The idea is:

1. Build a Cartesian test grid from all bin edges (TestGridEdges)
2. For every N-dimensional grid cell, test its midpoint
3. If any midpoint is not inside at least one bin, a gap exists

Definition at line 332 of file SampleStructs.h.

                                                                    {
    bool gap_found = false;
    if (TestedBins.empty()) return;
    const size_t Dim = TestedBins[0].Extent.size();
    if (MinVal.size() != Dim || MaxVal.size() != Dim) {
      MACH3LOG_ERROR("MinVal/MaxVal size does not match dimension of bins");
      throw MaCh3Exception(__FILE__, __LINE__);
    }
 
    // Build a fine validation grid from the provided min/max
    std::vector<std::vector<double>> TestGridEdges(Dim);
    for (size_t d = 0; d < Dim; ++d) {
      TestGridEdges[d].resize(ValidationBinsPerDim + 1);
      const double width = (MaxVal[d] - MinVal[d]) / static_cast<double>(ValidationBinsPerDim);
      for (size_t i = 0; i <= ValidationBinsPerDim; ++i)
        TestGridEdges[d][i] = MinVal[d] + static_cast<double>(i) * width;
    }
    // Precompute midpoints of each test cell
    std::vector<size_t> indices(Dim, 0);
 
    std::function<void(size_t)> scan = [&](size_t d) {
      if (gap_found) return; // stop recursion
 
      // Base case: we have selected a cell in every dimension
      if (d == Dim) {
        std::vector<double> point(Dim);
 
        // Compute the midpoint of the current N-D grid cell
        for (size_t i = 0; i < Dim; ++i) {
          const double lo = TestGridEdges[i][indices[i]];
          const double hi = TestGridEdges[i][indices[i] + 1];
          point[i] = 0.5 * (lo + hi);
        }
 
        // Check coverage
        for (const auto& bin : TestedBins) {
          if (bin.IsEventInside(point)) {
            return; // covered
          }
        }
 
        // Not covered by any bin → gap
        MACH3LOG_WARN("Gap detected in non-uniform binning at point [{:.2f}]", fmt::join(point, ", "));
        gap_found = true;
        return;
      }
 
      for (size_t i = 0; i + 1 < TestGridEdges[d].size(); ++i) {
        indices[d] = i;
        scan(d + 1);
      }
    };
    // Start recursion at dimension 0
    scan(0);
  }

FindBin() [1/2]

int SampleBinningInfo::FindBin ( const double  KinVar, const int  NomBin, const int  N_Bins, const std::vector< double > &  Bin_Edges, const std::vector< BinShiftLookup > &  Bin_Lookup  ) const

inline

DB Find the relevant bin in the PDF for each event.

Parameters

KinVar	The value of the kinematic variable for the event.
NomBin	The nominal bin index where the event would fall without any shifts.
N_Bins	The total number of bins in this dimension.
Bin_Edges	Vector of bin edge values (size = N_Bins + 1).
Bin_Lookup	Vector of BinShiftLookup structs providing precomputed lower and upper edges for the nominal bin and its neighbors to efficiently handle shifted events

Definition at line 575 of file SampleStructs.h.

                                                                 {
    //DB Check to see if momentum shift has moved bins
    //DB - First , check to see if the event is outside of the binning range and skip event if it is
    if (KinVar < Bin_Edges[0] || KinVar >= Bin_Edges[N_Bins]) {
      return M3::UnderOverFlowBin;
    }
    // KS: If NomBin is UnderOverFlowBin we must do binary search :(
    if(NomBin > M3::UnderOverFlowBin) {
      // KS: Get reference to avoid repeated indexing and help with performance
      const BinShiftLookup& _restrict_ Bin = Bin_Lookup[NomBin];
      const double lower = Bin.lower_binedge;
      const double upper = Bin.upper_binedge;
      const double lower_lower = Bin.lower_lower_binedge;
      const double upper_upper = Bin.upper_upper_binedge;
 
      //DB - Second, check to see if the event is still in the nominal bin
      if (KinVar < upper && KinVar >= lower) {
        return NomBin;
      }
      //DB - Thirdly, check the adjacent bins first as Eb+CC+EScale shifts aren't likely to move an Erec more than 1bin width
      //Shifted down one bin from the event bin at nominal
      if (KinVar < lower && KinVar >= lower_lower) {
        return NomBin-1;
      }
      //Shifted up one bin from the event bin at nominal
      if (KinVar < upper_upper && KinVar >= upper) {
        return NomBin+1;
      }
    }
    //DB - If we end up in this loop, the event has been shifted outside of its nominal bin, but is still within the allowed binning range
    // KS: Perform binary search to find correct bin. We already checked if isn't outside of bounds
    return static_cast<int>(std::distance(Bin_Edges.begin(), std::upper_bound(Bin_Edges.begin(), Bin_Edges.end(), KinVar)) - 1);
  }

FindBin() [2/2]

int SampleBinningInfo::FindBin ( const int  Dimension, const double  Var, const int  NomBin  ) const

inline

DB Find the relevant bin in the PDF for each event.

Definition at line 563 of file SampleStructs.h.

                                                                             {
    return FindBin(Var, NomBin, AxisNBins[Dimension], BinEdges[Dimension], BinLookup[Dimension]);
  }

GetBin()

int SampleBinningInfo::GetBin ( const std::vector< int > &  BinIndices ) const

inline

Convert N-dimensional bin indices to a linear bin index.

Parameters

BinIndices

Vector of bin indices along each dimension

Mapping follows row-major order:

• 1D: xBin
• 2D: yBin * nXBins + xBin
• 3D: zBin * nXBins * nYBins + yBin * nXBins + xBin

Definition at line 554 of file SampleStructs.h.

                                                     {
    int BinNumber = 0;
    for(size_t i = 0; i < BinIndices.size(); ++i) {
      BinNumber += BinIndices[i]*Strides[i];
    }
    return BinNumber;
  }

GetBinSafe()

int SampleBinningInfo::GetBinSafe ( const std::vector< int > &  BinIndices ) const

inline

Get linear bin index from ND bin indices with additional checks.

Parameters

BinIndices

Vector of bin indices along each dimension

Warning

this performs additional checks so do not use in parts of code used during fit

Definition at line 536 of file SampleStructs.h.

                                                         {
    for(int iDim = 0; iDim < static_cast<int>(BinIndices.size()); iDim++){
      if (BinIndices[iDim] < 0 || BinIndices[iDim] >= AxisNBins[iDim]) {
        MACH3LOG_ERROR("{}: Bin indices out of range: Dim = {}, Bin={}, max Ndim Bin={}",
                       __func__, iDim, BinIndices[iDim], AxisNBins[iDim]);
        throw MaCh3Exception(__FILE__, __LINE__);
      }
    }
    return GetBin(BinIndices);
  }

InitialiseBinMigrationLookUp()

void SampleBinningInfo::InitialiseBinMigrationLookUp ( const int  Dimension )

inline

Initialise special lookup arrays allowing to more efficiently perform bin-migration These arrays store the lower and upper edges of each bin and their neighboring bins.

Definition at line 666 of file SampleStructs.h.

                                                         {
    BinLookup.resize(Dimension);
    for (int i = 0; i < Dimension; ++i) {
      InitialiseLookUpSingleDimension(BinLookup[i], BinEdges[i], AxisNBins[i]);
    }
 
    InitialiseStrides(Dimension);
  }

InitialiseGridMapping()

void SampleBinningInfo::InitialiseGridMapping ( )

inline

Initialise Non-Uniform Binning.

Definition at line 392 of file SampleStructs.h.

                               {
    const size_t Dim = BinEdges.size();
 
    // Compute total number of "mega bins"
    int NGridBins = 1;
    for (size_t d = 0; d < Dim; ++d) {
      NGridBins *= AxisNBins[d];
    }
    BinGridMapping.resize(NGridBins);
 
    // Helper: convert linear index to multi-dimensional index
    std::vector<int> MultiIndex(Dim, 0);
 
    std::function<void(size_t, int)> scan;
    scan = [&](size_t d, int LinearIndex) {
      if (d == Dim) {
        // Compute the edges of the current mega-bin
        std::vector<std::array<double, 2>> CellEdges(Dim);
        for (size_t i = 0; i < Dim; ++i) {
          CellEdges[i][0] = BinEdges[i][MultiIndex[i]];
          CellEdges[i][1] = BinEdges[i][MultiIndex[i] + 1];
        }
 
        // Check overlap with all non-uniform bins
        for (size_t iBin = 0; iBin < Bins.size(); ++iBin) {
          auto& bin = Bins[iBin];
          bool overlap = true;
          for (size_t i = 0; i < Dim; ++i) {
            const double a_lo = bin.Extent[i][0];
            const double a_hi = bin.Extent[i][1];
            const double b_lo = CellEdges[i][0];
            const double b_hi = CellEdges[i][1];
            if (!(a_hi > b_lo && a_lo < b_hi)) { // overlap condition
              overlap = false;
              break;
            }
          }
          if (overlap) {
            BinGridMapping[LinearIndex].push_back(static_cast<int>(iBin));
 
            // Debug statement: show both small bin extent AND mega-bin edges
            std::vector<std::string> bin_extent_str(Dim);
            std::vector<std::string> mega_edges_str(Dim);
 
            for (size_t i = 0; i < Dim; ++i) {
              bin_extent_str[i] = fmt::format("[{:.3f}, {:.3f}]", bin.Extent[i][0], bin.Extent[i][1]);
              mega_edges_str[i]  = fmt::format("[{:.3f}, {:.3f}]", CellEdges[i][0], CellEdges[i][1]);
            }
 
            MACH3LOG_DEBUG("MegaBin {} (multi-index [{}], edges {}) assigned Bin {} with extents {}",
                           LinearIndex, fmt::join(MultiIndex, ","), fmt::join(mega_edges_str, ", "),
                           iBin, fmt::join(bin_extent_str, ", "));
          }
        }
        return;
      }
 
      // Loop over all bins along this dimension
      for (int i = 0; i < AxisNBins[d]; ++i) {
        MultiIndex[d] = i;
        int NewLinearIndex = LinearIndex;
        if (d > 0) {
          int stride = 1;
          for (size_t s = 0; s < d; ++s) stride *= AxisNBins[s];
          NewLinearIndex += i * stride;
        } else {
          NewLinearIndex = i;
        }
        scan(d + 1, NewLinearIndex);
      }
    };
    // Start the recursive scan over all dimensions, beginning at dimension 0 with linear index 0
    scan(0, 0);
  }

InitialiseLookUpSingleDimension()

void SampleBinningInfo::InitialiseLookUpSingleDimension ( std::vector< BinShiftLookup > &  Bin_Lookup, const std::vector< double > &  Bin_Edges, const int  TotBins  )

inline

Initializes lookup arrays for efficient bin migration in a single dimension.

Parameters

Bin_Lookup	Reference to the BinShiftLookup struct to be initialized.
Bin_Edges	Vector of bin edges defining the bin boundaries.
TotBins	Number of bins in the dimension.

Definition at line 617 of file SampleStructs.h.

                                                                                                                                     {
    Bin_Lookup.resize(TotBins);
    //Set rw_pdf_bin and upper_binedge and lower_binedge for each skmc_base
    for(int bin_i = 0; bin_i < TotBins; bin_i++){
      double low_lower_edge = M3::_DEFAULT_RETURN_VAL_;
      double low_edge = Bin_Edges[bin_i];
      double upper_edge = Bin_Edges[bin_i+1];
      double upper_upper_edge = M3::_DEFAULT_RETURN_VAL_;
 
      if (bin_i == 0) {
        low_lower_edge = Bin_Edges[0];
      } else {
        low_lower_edge = Bin_Edges[bin_i-1];
      }
 
      if (bin_i + 2 < TotBins) {
        upper_upper_edge = Bin_Edges[bin_i + 2];
      } else if (bin_i + 1 < TotBins) {
        upper_upper_edge = Bin_Edges[bin_i + 1];
      }
 
      Bin_Lookup[bin_i].lower_binedge = low_edge;
      Bin_Lookup[bin_i].upper_binedge = upper_edge;
      Bin_Lookup[bin_i].lower_lower_binedge = low_lower_edge;
      Bin_Lookup[bin_i].upper_upper_binedge = upper_upper_edge;
    }
  }

InitialiseStrides()

void SampleBinningInfo::InitialiseStrides ( const int  Dimension )

inline

Initialise stride factors for linear bin index calculation.

Strides define how N-dimensional bin indices are converted into a single linear bin index using row-major ordering.

For example:

• 1D: stride[0] = 1
• 2D: stride[1] = nXBins
• 3D: stride[2] = nXBins * nYBins

Definition at line 654 of file SampleStructs.h.

                                              {
    Strides.resize(Dimension);
    int stride = 1;
    for (int i = 0; i < Dimension; ++i) {
      Strides[i] = stride;
      // Multiply stride by the number of bins in this axis
      stride *= AxisNBins[i];
    }
  }

InitNonUniform()

void SampleBinningInfo::InitNonUniform ( const std::vector< std::vector< std::vector< double >>> &  InputBins )

inline

Initialise Non-Uniform Binning.

Todo:

KS: Now we create "Large Bins" automatically, in future we can expand to add more user control

prepare special histograms used for event migration

Lastly GridMap

Definition at line 468 of file SampleStructs.h.

                                                                                {
    Uniform = false;
    nBins = 0;
    Bins.resize(InputBins.size());
 
    size_t ExtentDim = InputBins[0].size();
    if (ExtentDim == 1) {
      MACH3LOG_ERROR("Trying to initialise Non-Uniform binning for single dimension, this is silly...");
      throw MaCh3Exception(__FILE__, __LINE__);
    }
    for(size_t iBin = 0; iBin < InputBins.size(); iBin++) {
      const auto& NewExtent = InputBins[iBin];
      if (NewExtent.size() != ExtentDim) {
        MACH3LOG_ERROR("Dimension of Bin {} is {}, while others have {}", iBin, NewExtent.size(), ExtentDim);
        throw MaCh3Exception(__FILE__, __LINE__);
      }
 
      BinInfo NewBin;
      for (const auto& extent : NewExtent) {
        if (extent.size() != 2) {
          MACH3LOG_ERROR("Extent size is not 2 for Bin {}", iBin);
          throw MaCh3Exception(__FILE__, __LINE__);
        }
        NewBin.Extent.push_back({extent[0], extent[1]});
        MACH3LOG_DEBUG("Adding extent for Bin {} Dim {}: [{:.2f}, {:.2f}]",
                       iBin, NewBin.Extent.size()-1, NewBin.Extent.back()[0], NewBin.Extent.back()[1]);
      }
      Bins[iBin] = std::move(NewBin);
      nBins++;
    }
    // Ensure we do not have weird overlaps
    CheckBinsDoNotOverlap(Bins);
    constexpr int BinsPerDimension = 10;
    // Now we create huge map, which will allow to easily find non uniform bins
    BinEdges.resize(ExtentDim);
    AxisNBins.resize(ExtentDim);
    std::vector<double> MinVal(ExtentDim), MaxVal(ExtentDim);
    for (size_t iDim = 0; iDim < ExtentDim; iDim++) {
      MinVal[iDim] = std::numeric_limits<double>::max();
      MaxVal[iDim] = std::numeric_limits<double>::lowest();
 
      // Find min and max for this dimension
      for (const auto& bin : Bins) {
        MinVal[iDim] = std::min(MinVal[iDim], bin.Extent[iDim][0]);
        MaxVal[iDim] = std::max(MaxVal[iDim], bin.Extent[iDim][1]);
      }
 
      MACH3LOG_DEBUG("Mapping binning: Dim {} Min = {:.2f}, Max = {:.2f}", iDim, MinVal[iDim], MaxVal[iDim]);
      BinEdges[iDim].resize(BinsPerDimension + 1);
      double BinWidth = (MaxVal[iDim] - MinVal[iDim]) / static_cast<double>(BinsPerDimension);
      for (size_t iEdge = 0; iEdge <= BinsPerDimension; iEdge++) {
        BinEdges[iDim][iEdge] = MinVal[iDim] + static_cast<double>(iEdge) * BinWidth;
      }
      AxisNBins[iDim] = BinsPerDimension;
      MACH3LOG_DEBUG("Mapping binning: Dim {} BinEdges = [{:.2f}]", iDim, fmt::join(BinEdges[iDim], ", "));
    }
    CheckBinsHaveNoGaps(Bins, MinVal, MaxVal, 200);
    GlobalOffset = 0;
    InitialiseBinMigrationLookUp(static_cast<int>(BinEdges.size()));
    InitialiseGridMapping();
  }

InitUniform()

void SampleBinningInfo::InitUniform ( const std::vector< std::vector< double >> &  InputEdges )

inline

Initialise Uniform Binning.

Lastly prepare special histograms used for event migration

Definition at line 255 of file SampleStructs.h.

                                                                   {
    BinEdges = InputEdges;
    Uniform = true;
    AxisNBins.resize(BinEdges.size());
 
    nBins = 1;
    for(size_t iDim = 0; iDim < BinEdges.size(); iDim++)
    {
      const auto& Edges = BinEdges[iDim];
      if (!std::is_sorted(Edges.begin(), Edges.end())) {
        MACH3LOG_ERROR("VarBins for Dim {} must be in increasing order in sample config, VarBins: [{}]",
                       iDim, fmt::join(Edges, ", "));
        throw MaCh3Exception(__FILE__, __LINE__);
      }
 
      //Sanity check that some binning has been specified
      if(BinEdges[iDim].size() == 0){
        MACH3LOG_ERROR("No binning specified for Dim {} of sample binning, please add some binning to the sample config", iDim);
        MACH3LOG_ERROR("Please ensure BinEdges are correctly configured for all dimensions");
        throw MaCh3Exception(__FILE__, __LINE__);
      }
 
      // Set the number of bins for this dimension
      AxisNBins[iDim] = static_cast<int>(BinEdges[iDim].size()) - 1;
      // Update total number of bins
      nBins *= AxisNBins[iDim];
 
      MACH3LOG_INFO("{}-Dim Binning: [{:.2f}]", iDim, fmt::join(BinEdges[iDim], ", "));
    }
    GlobalOffset = 0;
    InitialiseBinMigrationLookUp(static_cast<int>(BinEdges.size()));
  }

Member Data Documentation

AxisNBins

std::vector<int> SampleBinningInfo::AxisNBins

Number of N-axis bins in the histogram used for likelihood calculation.

Definition at line 237 of file SampleStructs.h.

BinEdges

std::vector<std::vector<double> > SampleBinningInfo::BinEdges

Vector to hold N-axis bin-edges.

Definition at line 235 of file SampleStructs.h.

BinGridMapping

std::vector<std::vector<int> > SampleBinningInfo::BinGridMapping

This grid tells what bins are associated with with what BinEdges of Grid Binnins.

Definition at line 252 of file SampleStructs.h.

BinLookup

std::vector<std::vector<BinShiftLookup> > SampleBinningInfo::BinLookup

Bin lookups for all dimensions.

Definition at line 244 of file SampleStructs.h.

Bins

std::vector<BinInfo> SampleBinningInfo::Bins

Bins used only for non-uniform.

Definition at line 250 of file SampleStructs.h.

GlobalOffset

int SampleBinningInfo::GlobalOffset = M3::_BAD_INT_

If you have binning for multiple samples and trying to define 1D vector let's.

Definition at line 242 of file SampleStructs.h.

nBins

int SampleBinningInfo::nBins = M3::_BAD_INT_

Number of total bins.

Definition at line 240 of file SampleStructs.h.

Strides

std::vector<int> SampleBinningInfo::Strides

Stride factors for converting N-dimensional bin indices to a linear index.

Definition at line 246 of file SampleStructs.h.

Uniform

bool SampleBinningInfo::Uniform = true

Tells whether to use inform binning grid or non-uniform.

Definition at line 248 of file SampleStructs.h.

---

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

• Samples/SampleStructs.h