#include <HistoAxis.h>

Public Types
typedef Axis	axis_type

enum	RebinType { SAMPLE = 0, SUM, AVERAGE }

typedef Numeric	value_type

Public Member Functions
template<typename Acc >
void	accumulateBinsInBox (const BoxND< double > &box, Acc *acc, bool calculateAverage=false) const

const std::string &	accumulatedDataLabel () const

template<class Point >
void	allBinCenters (std::vector< Point > *centers) const

const std::vector< Axis > &	axes () const

const Axis &	axis (const unsigned i) const

void	binBox (unsigned long binNumber, BoxND< double > *box) const

void	binCenter (unsigned long binNumber, double *coords, unsigned lenCoords) const

const ArrayND< Numeric > &	binContents () const

double	binVolume (unsigned long binNumber=0) const

BoxND< double >	boundingBox () const

void	clear ()

void	clearBinContents ()

void	clearOverflows ()

const Numeric &	closestBin (const double *coords, unsigned coordLength) const

unsigned	dim () const

template<typename Num2 , class Functor >
void	dispatch (const double *coords, unsigned coordLength, Num2 &weight, Functor &f)

const Numeric &	examine (const double *coords, unsigned coordLength) const

template<typename Num2 >
void	fill (const double *coords, unsigned coordLength, const Num2 &weight)

template<typename Num2 >
void	fillC (const double *coords, unsigned coordLength, const Num2 &weight)

unsigned long	getModCount () const

	HistoND (const std::vector< Axis > &axes, const char title=nullptr, const char accumulatedDataLabel=nullptr)

	HistoND (const Axis &xAxis, const char title=nullptr, const char accumulatedDataLabel=nullptr)

	HistoND (const Axis &xAxis, const Axis &yAxis, const char title=nullptr, const char accumulatedDataLabel=nullptr)

	HistoND (const Axis &xAxis, const Axis &yAxis, const Axis &zAxis, const char title=nullptr, const char accumulatedDataLabel=nullptr)

	HistoND (const Axis &xAxis, const Axis &yAxis, const Axis &zAxis, const Axis &tAxis, const char title=nullptr, const char accumulatedDataLabel=nullptr)

	HistoND (const Axis &xAxis, const Axis &yAxis, const Axis &zAxis, const Axis &tAxis, const Axis &vAxis, const char title=nullptr, const char accumulatedDataLabel=nullptr)

	HistoND (const ArrayShape &shape, const BoxND< double > &boundingBox, const char title=nullptr, const char accumulatedDataLabel=nullptr)

template<typename Num2 , class Functor >
	HistoND (const HistoND< Num2, Axis > &h, const Functor &f, const char title=nullptr, const char accumulatedDataLabel=nullptr)

template<typename Num2 >
	HistoND (const HistoND< Num2, Axis > &h, const unsigned indices, unsigned nIndices, const char title=nullptr)

template<typename Num2 >
	HistoND (const HistoND< Num2, Axis > &h, const Axis &newAxis, unsigned newAxisNumber, const char *title=nullptr)

template<typename Num2 >
	HistoND (const HistoND< Num2, Axis > &h, RebinType rType, const unsigned newBinCounts, unsigned lenNewBinCounts, const double shifts=nullptr, const char *title=nullptr)

	HistoND (const HistoND &)

	HistoND ()=delete

void	incrModCount ()

double	integral () const

bool	isSameData (const HistoND &) const

bool	isUniformlyBinned () const

unsigned long	nBins () const

unsigned long	nFillsInRange () const

unsigned long	nFillsOver () const

unsigned long	nFillsTotal () const

bool	operator!= (const HistoND &) const

template<typename Num2 >
HistoND &	operator*= (const Num2 &r)

template<typename Num2 >
HistoND< Numeric, Axis > &	operator*= (const Num2 &r)

template<typename Num2 >
HistoND &	operator+= (const HistoND< Num2, Axis > &r)

template<typename Num2 >
HistoND< Numeric, Axis > &	operator+= (const HistoND< Num2, Axis > &r)

template<typename Num2 >
HistoND &	operator-= (const HistoND< Num2, Axis > &r)

template<typename Num2 >
HistoND< Numeric, Axis > &	operator-= (const HistoND< Num2, Axis > &r)

template<typename Num2 >
HistoND &	operator/= (const Num2 &r)

template<typename Num2 >
HistoND< Numeric, Axis > &	operator/= (const Num2 &r)

HistoND &	operator= (const HistoND &)

bool	operator== (const HistoND &) const

const ArrayND< Numeric > &	overflows () const

void	recalculateNFillsFromData ()

void	setAccumulatedDataLabel (const char *newlabel)

void	setAxisLabel (const unsigned axisNum, const char *newlabel)

template<typename Num2 >
void	setBinContents (const Num2 *data, unsigned long dataLength, bool clearOverflows=true)

template<typename Num2 >
void	setBinsToConst (const Num2 &value)

template<typename Num2 >
void	setOverflows (const Num2 *data, unsigned long dataLength)

template<typename Num2 >
void	setOverflowsToConst (const Num2 &value)

void	setTitle (const char *newtitle)

const std::string &	title () const

HistoND	transpose (unsigned axisNum1, unsigned axisNum2) const

double	volume () const


template<typename Num2 >
void	fill (const Num2 &weight)

template<typename Num2 >
void	fill (double x0, const Num2 &weight)

template<typename Num2 >
void	fill (double x0, double x1, const Num2 &weight)

template<typename Num2 >
void	fill (double x0, double x1, double x2, const Num2 &weight)

template<typename Num2 >
void	fill (double x0, double x1, double x2, double x3, const Num2 &weight)

template<typename Num2 >
void	fill (double x0, double x1, double x2, double x3, double x4, const Num2 &weight)

template<typename Num2 >
void	fill (double x0, double x1, double x2, double x3, double x4, double x5, const Num2 &weight)

template<typename Num2 >
void	fill (double x0, double x1, double x2, double x3, double x4, double x5, double x6, const Num2 &weight)

template<typename Num2 >
void	fill (double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7, const Num2 &weight)

template<typename Num2 >
void	fill (double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7, double x8, const Num2 &weight)

template<typename Num2 >
void	fill (double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7, double x8, double x9, const Num2 &weight)


template<typename Num2 , class Functor >
void	dispatch (Num2 &weight, Functor &f)

template<typename Num2 , class Functor >
void	dispatch (double x0, Num2 &weight, Functor &f)

template<typename Num2 , class Functor >
void	dispatch (double x0, double x1, Num2 &weight, Functor &f)

template<typename Num2 , class Functor >
void	dispatch (double x0, double x1, double x2, Num2 &weight, Functor &f)

template<typename Num2 , class Functor >
void	dispatch (double x0, double x1, double x2, double x3, Num2 &weight, Functor &f)

template<typename Num2 , class Functor >
void	dispatch (double x0, double x1, double x2, double x3, double x4, Num2 &weight, Functor &f)

template<typename Num2 , class Functor >
void	dispatch (double x0, double x1, double x2, double x3, double x4, double x5, Num2 &weight, Functor &f)

template<typename Num2 , class Functor >
void	dispatch (double x0, double x1, double x2, double x3, double x4, double x5, double x6, Num2 &weight, Functor &f)

template<typename Num2 , class Functor >
void	dispatch (double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7, Num2 &weight, Functor &f)

template<typename Num2 , class Functor >
void	dispatch (double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7, double x8, Num2 &weight, Functor &f)

template<typename Num2 , class Functor >
void	dispatch (double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7, double x8, double x9, Num2 &weight, Functor &f)


const Numeric &	examine () const

const Numeric &	examine (double x0) const

const Numeric &	examine (double x0, double x1) const

const Numeric &	examine (double x0, double x1, double x2) const

const Numeric &	examine (double x0, double x1, double x2, double x3) const

const Numeric &	examine (double x0, double x1, double x2, double x3, double x4) const

const Numeric &	examine (double x0, double x1, double x2, double x3, double x4, double x5) const

const Numeric &	examine (double x0, double x1, double x2, double x3, double x4, double x5, double x6) const

const Numeric &	examine (double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7) const

const Numeric &	examine (double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7, double x8) const

const Numeric &	examine (double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7, double x8, double x9) const


const Numeric &	closestBin () const

const Numeric &	closestBin (double x0) const

const Numeric &	closestBin (double x0, double x1) const

const Numeric &	closestBin (double x0, double x1, double x2) const

const Numeric &	closestBin (double x0, double x1, double x2, double x3) const

const Numeric &	closestBin (double x0, double x1, double x2, double x3, double x4) const

const Numeric &	closestBin (double x0, double x1, double x2, double x3, double x4, double x5) const

const Numeric &	closestBin (double x0, double x1, double x2, double x3, double x4, double x5, double x6) const

const Numeric &	closestBin (double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7) const

const Numeric &	closestBin (double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7, double x8) const

const Numeric &	closestBin (double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7, double x8, double x9) const


template<typename Num2 >
void	fillC (const Num2 &weight)

template<typename Num2 >
void	fillC (double x0, const Num2 &weight)

template<typename Num2 >
void	fillC (double x0, double x1, const Num2 &weight)

template<typename Num2 >
void	fillC (double x0, double x1, double x2, const Num2 &weight)

template<typename Num2 >
void	fillC (double x0, double x1, double x2, double x3, const Num2 &weight)

template<typename Num2 >
void	fillC (double x0, double x1, double x2, double x3, double x4, const Num2 &weight)

template<typename Num2 >
void	fillC (double x0, double x1, double x2, double x3, double x4, double x5, const Num2 &weight)

template<typename Num2 >
void	fillC (double x0, double x1, double x2, double x3, double x4, double x5, double x6, const Num2 &weight)

template<typename Num2 >
void	fillC (double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7, const Num2 &weight)

template<typename Num2 >
void	fillC (double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7, double x8, const Num2 &weight)

template<typename Num2 >
void	fillC (double x0, double x1, double x2, double x3, double x4, double x5, double x6, double x7, double x8, double x9, const Num2 &weight)


template<typename Num2 >
void	setBin (const unsigned *index, unsigned indexLen, const Num2 &v)

template<typename Num2 >
void	setBin (const Num2 &v)

template<typename Num2 >
void	setBin (unsigned i0, const Num2 &v)

template<typename Num2 >
void	setBin (unsigned i0, unsigned i1, const Num2 &v)

template<typename Num2 >
void	setBin (unsigned i0, unsigned i1, unsigned i2, const Num2 &v)

template<typename Num2 >
void	setBin (unsigned i0, unsigned i1, unsigned i2, unsigned i3, const Num2 &v)

template<typename Num2 >
void	setBin (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, const Num2 &v)

template<typename Num2 >
void	setBin (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, const Num2 &v)

template<typename Num2 >
void	setBin (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6, const Num2 &v)

template<typename Num2 >
void	setBin (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6, unsigned i7, const Num2 &v)

template<typename Num2 >
void	setBin (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6, unsigned i7, unsigned i8, const Num2 &v)

template<typename Num2 >
void	setBin (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6, unsigned i7, unsigned i8, unsigned i9, const Num2 &v)

template<typename Num2 >
void	setLinearBin (const unsigned long index, const Num2 &v)


template<typename Num2 >
void	setBinAt (const unsigned *index, unsigned indexLen, const Num2 &v)

template<typename Num2 >
void	setBinAt (const Num2 &v)

template<typename Num2 >
void	setBinAt (unsigned i0, const Num2 &v)

template<typename Num2 >
void	setBinAt (unsigned i0, unsigned i1, const Num2 &v)

template<typename Num2 >
void	setBinAt (unsigned i0, unsigned i1, unsigned i2, const Num2 &v)

template<typename Num2 >
void	setBinAt (unsigned i0, unsigned i1, unsigned i2, unsigned i3, const Num2 &v)

template<typename Num2 >
void	setBinAt (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, const Num2 &v)

template<typename Num2 >
void	setBinAt (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, const Num2 &v)

template<typename Num2 >
void	setBinAt (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6, const Num2 &v)

template<typename Num2 >
void	setBinAt (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6, unsigned i7, const Num2 &v)

template<typename Num2 >
void	setBinAt (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6, unsigned i7, unsigned i8, const Num2 &v)

template<typename Num2 >
void	setBinAt (unsigned i0, unsigned i1, unsigned i2, unsigned i3, unsigned i4, unsigned i5, unsigned i6, unsigned i7, unsigned i8, unsigned i9, const Num2 &v)

template<typename Num2 >
void	setLinearBinAt (const unsigned long index, const Num2 &v)


void	setNFillsTotal (const unsigned long i)

void	setNFillsOver (const unsigned long i)


template<typename Num2 >
void	scaleBinContents (const Num2 *data, unsigned long dataLength)

template<typename Num2 >
void	scaleOverflows (const Num2 *data, unsigned long dataLength)


template<typename Num2 >
void	addToBinContents (const Num2 &weight)

template<typename Num2 >
void	addToOverflows (const Num2 &weight)


template<typename Num2 >
void	addToBinContents (const Num2 *data, unsigned long dataLength)

template<typename Num2 >
void	addToOverflows (const Num2 *data, unsigned long dataLength)


template<typename Num2 , typename Num3 >
void	addToProjection (HistoND< Num2, Axis > projection, AbsArrayProjector< Numeric, Num3 > &projector, const unsigned projectedIndices, unsigned nProjectedIndices) const

template<typename Num2 , typename Num3 >
void	addToProjection (HistoND< Num2, Axis > projection, AbsVisitor< Numeric, Num3 > &projector, const unsigned projectedIndices, unsigned nProjectedIndices) const


gs::ClassId	classId () const

bool	write (std::ostream &of) const

Static Public Member Functions
static const char *	classname ()

static HistoND *	read (const gs::ClassId &id, std::istream &in)

static unsigned	version ()

Private Member Functions
template<typename Acc >
void	accumulateBinsLoop (unsigned level, const BoxND< double > &box, unsigned idx, Acc accumulator, double overlapFraction, long double *wsum) const

template<typename Num2 >
void	fillPreservingCentroid (const Num2 &weight)

	HistoND (const HistoND &r, unsigned ax1, unsigned ax2)

Private Attributes
std::string	accumulatedDataLabel_

std::vector< Axis >	axes_

ArrayND< Numeric >	data_

unsigned	dim_

unsigned long	fillCount_

std::vector< unsigned >	indexBuf_

unsigned long	modCount_

unsigned long	overCount_

ArrayND< Numeric >	overflow_

std::string	title_

std::vector< double >	weightBuf_

Friends
template<typename Num2 , class Axis2 >
class	HistoND

Detailed Description

template<typename Numeric, class Axis = HistoAxis>
class npstat::HistoND< Numeric, Axis >

(Almost) arbitrary-dimensional histogram with binning determined by the second template parameter (typically HistoAxis or NUHistoAxis). The dimensionality must not exceed CHAR_BIT*sizeof(unsigned long)-1 which is normally 31/63 on 32/64-bit systems.

The template parameter class (Numeric) must be such that it can be used as the template parameter of ArrayND class. For a typical usage pattern, Numeric should also support operator += between itself and the weights with which the histogram is filled (see, however, the description of the "dispatch" method which is not subject to this recommendation).

If the "fillC" method is used to accumulate the data then the weights must support multiplication by a double, and then it must be possible to use the "+=" operator to add such a product to Numeric.

Note that there are no methods which would allow the user to examine the bin contents of the histogram using bin numbers. This is intentional: almost always such examinations are performed in a loop over indices, and it is more efficient to grab a reference to the underlying array using the "binContents()" method and then examine that array directly.

Definition at line 23 of file HistoAxis.h.

Member Typedef Documentation

◆ axis_type

template<typename Numeric, class Axis = HistoAxis>

typedef Axis npstat::HistoND< Numeric, Axis >::axis_type

Definition at line 49 of file HistoND.h.

◆ value_type

template<typename Numeric, class Axis = HistoAxis>

typedef Numeric npstat::HistoND< Numeric, Axis >::value_type

Definition at line 48 of file HistoND.h.

Member Enumeration Documentation

◆ RebinType

template<typename Numeric, class Axis = HistoAxis>

enum npstat::HistoND::RebinType

Enumerator
SAMPLE
SUM
AVERAGE

Definition at line 51 of file HistoND.h.

51 { SAMPLE = 0, SUM, AVERAGE };

npstat::HistoND::SAMPLE

Definition: HistoND.h:51

npstat::HistoND::SUM

Definition: HistoND.h:51

npstat::HistoND::AVERAGE

Definition: HistoND.h:51

Constructor & Destructor Documentation

◆ HistoND() [1/14]

template<typename Numeric , class Axis >

npstat::HistoND< Numeric, Axis >::HistoND	(	const std::vector< Axis > &	axes,
		const char *	title = `nullptr`,
		const char *	accumulatedDataLabel = `nullptr`
	)

explicit

Main constructor for arbitrary-dimensional histograms

Definition at line 1269 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::clear(), and npstat::HistoND< Numeric, Axis >::dim_.

       : title_(title ? title : ""),
         accumulatedDataLabel_(label ? label : ""),
         data_(Private::makeHistoShape(axesIn)),
         overflow_(ArrayShape(axesIn.size(), 3U)),
         axes_(axesIn),
         weightBuf_(axesIn.size()),
         indexBuf_(2U * axesIn.size()),
         modCount_(0UL),
         dim_(axesIn.size()) {
     if (dim_ >= CHAR_BIT * sizeof(unsigned long))
       throw npstat::NpstatInvalidArgument(
           "In npstat::HistoND constructor: requested histogram "
           "dimensionality is not supported (too large)");
     clear();
   }

◆ HistoND() [2/14]

template<typename Numeric , class Axis >

npstat::HistoND< Numeric, Axis >::HistoND	(	const Axis &	xAxis,
		const char *	title = `nullptr`,
		const char *	accumulatedDataLabel = `nullptr`
	)

explicit

Convenience constructor for 1-d histograms

Definition at line 1287 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::axes_, npstat::HistoND< Numeric, Axis >::clear(), npstat::HistoND< Numeric, Axis >::dim_, and HLT_2023v12_cff::xAxis.

       : title_(title ? title : ""),
         accumulatedDataLabel_(label ? label : ""),
         data_(Private::makeHistoShape(xAxis)),
         overflow_(ArrayShape(1U, 3U)),
         weightBuf_(1U),
         indexBuf_(2U * 1U),
         modCount_(0UL),
         dim_(1U) {
     axes_.reserve(dim_);
     axes_.push_back(xAxis);
     clear();
   }

◆ HistoND() [3/14]

template<typename Numeric , class Axis >

npstat::HistoND< Numeric, Axis >::HistoND	(	const Axis &	xAxis,
		const Axis &	yAxis,
		const char *	title = `nullptr`,
		const char *	accumulatedDataLabel = `nullptr`
	)

Convenience constructor for 2-d histograms

Definition at line 1302 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::axes_, npstat::HistoND< Numeric, Axis >::clear(), npstat::HistoND< Numeric, Axis >::dim_, HLT_2023v12_cff::xAxis, and HLT_2023v12_cff::yAxis.

       : title_(title ? title : ""),
         accumulatedDataLabel_(label ? label : ""),
         data_(Private::makeHistoShape(xAxis, yAxis)),
         overflow_(ArrayShape(2U, 3U)),
         weightBuf_(2U),
         indexBuf_(2U * 2U),
         modCount_(0UL),
         dim_(2U) {
     axes_.reserve(dim_);
     axes_.push_back(xAxis);
     axes_.push_back(yAxis);
     clear();
   }

◆ HistoND() [4/14]

template<typename Numeric , class Axis >

npstat::HistoND< Numeric, Axis >::HistoND	(	const Axis &	xAxis,
		const Axis &	yAxis,
		const Axis &	zAxis,
		const char *	title = `nullptr`,
		const char *	accumulatedDataLabel = `nullptr`
	)

Convenience constructor for 3-d histograms

Definition at line 1318 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::axes_, npstat::HistoND< Numeric, Axis >::clear(), npstat::HistoND< Numeric, Axis >::dim_, HLT_2023v12_cff::xAxis, HLT_2023v12_cff::yAxis, and HLT_2023v12_cff::zAxis.

       : title_(title ? title : ""),
         accumulatedDataLabel_(label ? label : ""),
         data_(Private::makeHistoShape(xAxis, yAxis, zAxis)),
         overflow_(ArrayShape(3U, 3U)),
         weightBuf_(3U),
         indexBuf_(2U * 3U),
         modCount_(0UL),
         dim_(3U) {
     axes_.reserve(dim_);
     axes_.push_back(xAxis);
     axes_.push_back(yAxis);
     axes_.push_back(zAxis);
     clear();
   }

◆ HistoND() [5/14]

template<typename Numeric , class Axis >

npstat::HistoND< Numeric, Axis >::HistoND	(	const Axis &	xAxis,
		const Axis &	yAxis,
		const Axis &	zAxis,
		const Axis &	tAxis,
		const char *	title = `nullptr`,
		const char *	accumulatedDataLabel = `nullptr`
	)

Convenience constructor for 4-d histograms

Definition at line 1336 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::axes_, npstat::HistoND< Numeric, Axis >::clear(), npstat::HistoND< Numeric, Axis >::dim_, HLT_2023v12_cff::xAxis, HLT_2023v12_cff::yAxis, and HLT_2023v12_cff::zAxis.

       : title_(title ? title : ""),
         accumulatedDataLabel_(label ? label : ""),
         data_(Private::makeHistoShape(xAxis, yAxis, zAxis, tAxis)),
         overflow_(ArrayShape(4U, 3U)),
         weightBuf_(4U),
         indexBuf_(2U * 4U),
         modCount_(0UL),
         dim_(4U) {
     axes_.reserve(dim_);
     axes_.push_back(xAxis);
     axes_.push_back(yAxis);
     axes_.push_back(zAxis);
     axes_.push_back(tAxis);
     clear();
   }

◆ HistoND() [6/14]

template<typename Numeric , class Axis >

npstat::HistoND< Numeric, Axis >::HistoND	(	const Axis &	xAxis,
		const Axis &	yAxis,
		const Axis &	zAxis,
		const Axis &	tAxis,
		const Axis &	vAxis,
		const char *	title = `nullptr`,
		const char *	accumulatedDataLabel = `nullptr`
	)

Convenience constructor for 5-d histograms

Definition at line 1355 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::axes_, npstat::HistoND< Numeric, Axis >::clear(), npstat::HistoND< Numeric, Axis >::dim_, HLT_2023v12_cff::xAxis, HLT_2023v12_cff::yAxis, and HLT_2023v12_cff::zAxis.

       : title_(title ? title : ""),
         accumulatedDataLabel_(label ? label : ""),
         data_(Private::makeHistoShape(xAxis, yAxis, zAxis, tAxis, vAxis)),
         overflow_(ArrayShape(5U, 3U)),
         weightBuf_(5U),
         indexBuf_(2U * 5U),
         modCount_(0UL),
         dim_(5U) {
     axes_.reserve(dim_);
     axes_.push_back(xAxis);
     axes_.push_back(yAxis);
     axes_.push_back(zAxis);
     axes_.push_back(tAxis);
     axes_.push_back(vAxis);
     clear();
   }

◆ HistoND() [7/14]

template<typename Numeric , class Axis >

npstat::HistoND< Numeric, Axis >::HistoND	(	const ArrayShape &	shape,
		const BoxND< double > &	boundingBox,
		const char *	title = `nullptr`,
		const char *	accumulatedDataLabel = `nullptr`
	)

Simple constructor for uniformly binned histograms without axis labels. Sequence size returned by the size() method of both "shape" and "boundingBox" arguments must be the same.

Definition at line 1380 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::axes_, npstat::HistoND< Numeric, Axis >::boundingBox(), npstat::HistoND< Numeric, Axis >::clear(), npstat::HistoND< Numeric, Axis >::dim_, mps_fire::i, SiStripPI::max, SiStripPI::min, and l1trig_cff::shape.

       : title_(title ? title : ""),
         accumulatedDataLabel_(label ? label : ""),
         data_(shape),
         overflow_(ArrayShape(shape.size(), 3U)),
         weightBuf_(shape.size()),
         indexBuf_(2U * shape.size()),
         modCount_(0UL),
         dim_(shape.size()) {
     if (boundingBox.size() != dim_)
       throw npstat::NpstatInvalidArgument(
           "In npstat::HistoND constructor: "
           "incompatible bounding box dimensionality");
     if (dim_ >= CHAR_BIT * sizeof(unsigned long))
       throw npstat::NpstatInvalidArgument(
           "In npstat::HistoND constructor: requested histogram "
           "dimensionality is not supported (too large)");
     axes_.reserve(dim_);
     for (unsigned i = 0; i < dim_; ++i)
       axes_.push_back(Axis(shape[i], boundingBox[i].min(), boundingBox[i].max()));
     clear();
   }

◆ HistoND() [8/14]

template<typename Numeric , class Axis >

template<typename Num2 , class Functor >

npstat::HistoND< Numeric, Axis >::HistoND	(	const HistoND< Num2, Axis > &	h,
		const Functor &	f,
		const char *	title = `nullptr`,
		const char *	accumulatedDataLabel = `nullptr`
	)

Converting constructor. The functor will be applied to all bins of the argument histogram to fill the bins of the constructed histogram. If the title and data label are not provided, they will be cleared.

Definition at line 1408 of file HistoND.h.

       : title_(title ? title : ""),
         accumulatedDataLabel_(label ? label : ""),
         data_(r.data_, f),
         overflow_(r.overflow_, f),
         axes_(r.axes_),
         weightBuf_(r.dim_),
         indexBuf_(2U * r.dim_),
         fillCount_(r.fillCount_),
         overCount_(r.overCount_),
         modCount_(0UL),
         dim_(r.dim_) {}

◆ HistoND() [9/14]

template<typename Numeric , class Axis >

template<typename Num2 >

npstat::HistoND< Numeric, Axis >::HistoND	(	const HistoND< Num2, Axis > &	h,
		const unsigned *	indices,
		unsigned	nIndices,
		const char *	title = `nullptr`
	)

A slicing constructor. The new histogram will be created by slicing another histogram. See the description of the slicing constructor in the "ArrayND" class for the meaning of arguments "indices" and "nIndices". The data of the newly created histogram is cleared.

Definition at line 1423 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::clear().

       : title_(title ? title : ""),
         accumulatedDataLabel_(h.accumulatedDataLabel_),
         data_(Private::shapeOfASlice(h.axes_, indices, nIndices)),
         overflow_(ArrayShape(data_.rank(), 3U)),
         axes_(Private::axesOfASlice(h.axes_, indices, nIndices)),
         weightBuf_(data_.rank()),
         indexBuf_(2U * data_.rank()),
         modCount_(0UL),
         dim_(data_.rank()) {
     clear();
   }

◆ HistoND() [10/14]

template<typename Numeric , class Axis >

template<typename Num2 >

npstat::HistoND< Numeric, Axis >::HistoND	(	const HistoND< Num2, Axis > &	h,
		const Axis &	newAxis,
		unsigned	newAxisNumber,
		const char *	title = `nullptr`
	)

A constructor that inserts a new axis into a histogram (as if the argument histogram was a slice of the new histogram). The "newAxisNumber" argument specifies the number of the new axis in the axis sequence of the constructed histogram. If the "newAxisNumber" exceeds the number of axes of the argument histogram, the new axis will become last. The data of the newly created histogram is cleared.

Definition at line 1441 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::clear(), and npstat::HistoND< Numeric, Axis >::dim_.

       : title_(title ? title : ""),
         accumulatedDataLabel_(h.accumulatedDataLabel_),
         data_(Private::shapeWithExtraAxis(h.axes_, newAxis, newAxisNumber)),
         overflow_(data_.rank(), 3U),
         axes_(Private::addAxis(h.axes_, newAxis, newAxisNumber)),
         weightBuf_(data_.rank()),
         indexBuf_(2U * data_.rank()),
         modCount_(0UL),
         dim_(data_.rank()) {
     if (dim_ >= CHAR_BIT * sizeof(unsigned long))
       throw npstat::NpstatInvalidArgument(
           "In npstat::HistoND constructor: requested histogram "
           "dimensionality is not supported (too large)");
     clear();
   }

◆ HistoND() [11/14]

template<typename Numeric , class Axis >

template<typename Num2 >

npstat::HistoND< Numeric, Axis >::HistoND	(	const HistoND< Num2, Axis > &	h,
		RebinType	rType,
		const unsigned *	newBinCounts,
		unsigned	lenNewBinCounts,
		const double *	shifts = `nullptr`,
		const char *	title = `nullptr`
	)

Create a rebinned histogram with the same axis coverage. Note that not all such operations will be meaningful if the bin contents do not belong to one of the floating point types. The "newBinCounts" argument specifies the new number of bins along each axis. The length of this array (provided by the "lenNewBinCounts" argument) should be equal to the input histogram dimensionality.

The "shifts" argument can be meaningfully specified with the "rType" argument set to "SAMPLE". These shifts will be added to the bin centers of the created histogram when the bin contents are looked up in the input histogram. This can be useful in case the bin center lookup without shifts would fall exactly on the bin edge. Naturally, the length of the "shifts" array should be equal to the input histogram dimensionality.

Definition at line 1463 of file HistoND.h.

       : title_(title ? title : h.title_.c_str()),
         accumulatedDataLabel_(h.accumulatedDataLabel_),
         data_(newBinCounts, lenNewBinCounts),
         overflow_(h.overflow_),
         axes_(Private::rebinAxes(h.axes_, newBinCounts, lenNewBinCounts)),
         weightBuf_(h.dim_),
         indexBuf_(2U * h.dim_),
         fillCount_(h.fillCount_),
         overCount_(h.overCount_),
         modCount_(0UL),
         dim_(h.dim_) {
     const unsigned long newBins = data_.length();
     const Axis* ax = &axes_[0];
     unsigned* ubuf = &indexBuf_[0];
 
     // Fill out the bins of the new histogram
     if (rType == SAMPLE) {
       double* buf = &weightBuf_[0];
       for (unsigned long ibin = 0; ibin < newBins; ++ibin) {
         data_.convertLinearIndex(ibin, ubuf, dim_);
         if (shifts)
           for (unsigned i = 0; i < dim_; ++i)
             buf[i] = ax[i].binCenter(ubuf[i]) + shifts[i];
         else
           for (unsigned i = 0; i < dim_; ++i)
             buf[i] = ax[i].binCenter(ubuf[i]);
         data_.linearValue(ibin) = h.examine(buf, dim_);
       }
     } else {
       const Numeric zero = Numeric();
       BoxND<double> binLimits(dim_);
       for (unsigned long ibin = 0; ibin < newBins; ++ibin) {
         data_.convertLinearIndex(ibin, ubuf, dim_);
         for (unsigned i = 0; i < dim_; ++i)
           binLimits[i] = ax[i].binInterval(ubuf[i]);
         Numeric& thisBin(data_.linearValue(ibin));
         thisBin = zero;
         h.accumulateBinsInBox(binLimits, &thisBin, rType == AVERAGE);
       }
     }
   }

◆ HistoND() [12/14]

template<typename Numeric , class Axis >

npstat::HistoND< Numeric, Axis >::HistoND ( const HistoND< Numeric, Axis > & r )

Copy constructor

Definition at line 3313 of file HistoND.h.

       : title_(r.title_),
         accumulatedDataLabel_(r.accumulatedDataLabel_),
         data_(r.data_),
         overflow_(r.overflow_),
         axes_(r.axes_),
         weightBuf_(r.weightBuf_),
         indexBuf_(r.indexBuf_),
         fillCount_(r.fillCount_),
         overCount_(r.overCount_),
         modCount_(0UL),
         dim_(r.dim_) {}

◆ HistoND() [13/14]

template<typename Numeric, class Axis = HistoAxis>

npstat::HistoND< Numeric, Axis >::HistoND ( )

delete

Default constructor not implemented

◆ HistoND() [14/14]

template<typename Numeric , class Axis >

npstat::HistoND< Numeric, Axis >::HistoND	(	const HistoND< Numeric, Axis > &	r,
		unsigned	ax1,
		unsigned	ax2
	)

private

Definition at line 3297 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::axes_, and edm::swap().

       : title_(r.title_),
         accumulatedDataLabel_(r.accumulatedDataLabel_),
         data_(r.data_.transpose(ax1, ax2)),
         overflow_(r.overflow_.transpose(ax1, ax2)),
         axes_(r.axes_),
         weightBuf_(r.weightBuf_),
         indexBuf_(r.indexBuf_),
         fillCount_(r.fillCount_),
         overCount_(r.overCount_),
         modCount_(0UL),
         dim_(r.dim_) {
     std::swap(axes_[ax1], axes_[ax2]);
   }

Member Function Documentation

◆ accumulateBinsInBox()

template<typename Numeric , class Axis >

template<typename Acc >

void npstat::HistoND< Numeric, Axis >::accumulateBinsInBox	(	const BoxND< double > &	box,
		Acc *	acc,
		bool	calculateAverage = `false`
	)		const

Add contents of all bins inside the given box to the accumulator. Note that Numeric type must support multiplication by a double in order for this function to work (it calculates the overlap fraction of each bin with the box and multiplies bin content by that fraction for subsequent accumulation). The operation Acc += Numeric must be defined.

Definition at line 1228 of file HistoND.h.

References mixOne_premix_on_sim_cfi::accumulator, cms::cuda::assert(), mps_fire::i, dttmaxenums::L, and mitigatedMETSequence_cff::U.

                                                                                       {
     if (box.size() != dim_)
       throw npstat::NpstatInvalidArgument(
           "In npstat::HistoND::accumulateBinsInBox: "
           "incompatible box dimensionality");
     assert(accumulator);
     if (dim_) {
       long double wsum = 0.0L;
       for (unsigned i = 0; i < dim_; ++i)
         indexBuf_[i] = 0U;
       accumulateBinsLoop(0U, box, &indexBuf_[0], accumulator, 1.0, &wsum);
       if (calculateAverage && wsum > 0.0L)
         *accumulator *= static_cast<double>(1.0L / wsum);
     } else
       *accumulator += 1.0 * data_();
   }

◆ accumulateBinsLoop()

template<typename Numeric , class Axis >

template<typename Acc >

void npstat::HistoND< Numeric, Axis >::accumulateBinsLoop	(	unsigned	level,
		const BoxND< double > &	box,
		unsigned *	idx,
		Acc *	accumulator,
		double	overlapFraction,
		long double *	wsum
	)		const

private

Definition at line 1203 of file HistoND.h.

References mixOne_premix_on_sim_cfi::accumulator, mps_fire::i, heavyIonCSV_trainingSettings::idx, personalPlayback::level, LaserClient_cfi::nbins, and mitigatedMETSequence_cff::U.

                                                                            {
     const Interval<double>& boxSide(box[level]);
     const Axis& axis(axes_[level]);
     const unsigned nbins = axis.nBins();
     const bool lastLevel = level == dim_ - 1U;
     for (unsigned i = 0; i < nbins; ++i) {
       const double over = overlapFraction * axis.binInterval(i).overlapFraction(boxSide);
       if (over > 0.0) {
         idx[level] = i;
         if (lastLevel) {
           *accumulator += over * data_.value(idx, dim_);
           *wsum += over;
         } else
           accumulateBinsLoop(level + 1U, box, idx, accumulator, over, wsum);
       }
     }
   }

◆ accumulatedDataLabel()

template<typename Numeric, class Axis = HistoAxis>

const std::string& npstat::HistoND< Numeric, Axis >::accumulatedDataLabel ( ) const

inline

Label associated with accumulated data

Definition at line 179 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::accumulatedDataLabel_.

179 { return accumulatedDataLabel_; }

npstat::HistoND::accumulatedDataLabel_

std::string accumulatedDataLabel_

Definition: HistoND.h:948

◆ addToBinContents() [1/2]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::addToBinContents ( const Num2 & weight )

In-place addition of a scalar to all bins. Equivalent to calling the "fill" function with the same weight once for every bin.

Definition at line 3361 of file HistoND.h.

References data, and mps_fire::i.

                                                                   {
     const unsigned long nDat = data_.length();
     Numeric* data = const_cast<Numeric*>(data_.data());
     for (unsigned long i = 0; i < nDat; ++i)
       data[i] += weight;
     fillCount_ += nDat;
     ++modCount_;
   }

◆ addToBinContents() [2/2]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::addToBinContents	(	const Num2 *	data,
		unsigned long	dataLength
	)

In-place addition of an array. Equivalent to calling the "fill" function once for every bin with the weight taken from the corresponding array element.

Definition at line 3384 of file HistoND.h.

References cms::cuda::assert(), data, and mps_fire::i.

                                                                                                 {
     if (dataLength != data_.length())
       throw npstat::NpstatInvalidArgument("In npstat::HistoND::addToBinContents: incompatible data length");
     assert(data);
     Numeric* dat = const_cast<Numeric*>(data_.data());
     for (unsigned long i = 0; i < dataLength; ++i)
       dat[i] += data[i];
     fillCount_ += dataLength;
     ++modCount_;
   }

◆ addToOverflows() [1/2]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::addToOverflows ( const Num2 & weight )

Definition at line 3372 of file HistoND.h.

References data, and mps_fire::i.

                                                                 {
     const unsigned long nOver = overflow_.length();
     Numeric* data = const_cast<Numeric*>(overflow_.data());
     for (unsigned long i = 0; i < nOver; ++i)
       data[i] += weight;
     overCount_ += nOver;
     fillCount_ += nOver;
     ++modCount_;
   }

◆ addToOverflows() [2/2]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::addToOverflows	(	const Num2 *	data,
		unsigned long	dataLength
	)

Definition at line 3397 of file HistoND.h.

References cms::cuda::assert(), data, and mps_fire::i.

                                                                                               {
     if (dataLength != overflow_.length())
       throw npstat::NpstatInvalidArgument("In npstat::HistoND::addToOverflows: incompatible data length");
     assert(data);
     Numeric* dat = const_cast<Numeric*>(overflow_.data());
     for (unsigned long i = 0; i < dataLength; ++i)
       dat[i] += data[i];
     overCount_ += dataLength;
     fillCount_ += dataLength;
     ++modCount_;
   }

◆ addToProjection() [1/2]

template<typename Numeric , class Axis >

template<typename Num2 , typename Num3 >

void npstat::HistoND< Numeric, Axis >::addToProjection	(	HistoND< Num2, Axis > *	projection,
		AbsArrayProjector< Numeric, Num3 > &	projector,
		const unsigned *	projectedIndices,
		unsigned	nProjectedIndices
	)		const

inline

Code for projecting one histogram onto another. For now, this is done for bin contents only, not for overflows. The projection should be created in advance from this histogram with the aid of the slicing constructor. The indices used in that constructor should be provided here as well.

Note that you might want to recalculate the number of fills from data after performing all projections needed.

Definition at line 3462 of file HistoND.h.

References cms::cuda::assert().

                                                                                               {
     assert(projection);
     data_.addToProjection(&projection->data_, projector, projectedIndices, nProjectedIndices);
     projection->fillCount_ += projection->nBins();
     projection->modCount_++;
   }

◆ addToProjection() [2/2]

template<typename Numeric , class Axis >

template<typename Num2 , typename Num3 >

void npstat::HistoND< Numeric, Axis >::addToProjection	(	HistoND< Num2, Axis > *	projection,
		AbsVisitor< Numeric, Num3 > &	projector,
		const unsigned *	projectedIndices,
		unsigned	nProjectedIndices
	)		const

inline

Definition at line 3474 of file HistoND.h.

References cms::cuda::assert().

                                                                                               {
     assert(projection);
     data_.addToProjection(&projection->data_, projector, projectedIndices, nProjectedIndices);
     projection->fillCount_ += projection->nBins();
     projection->modCount_++;
   }

◆ allBinCenters()

template<typename Numeric , class Axis >

template<class Point >

void npstat::HistoND< Numeric, Axis >::allBinCenters ( std::vector< Point > * centers ) const

Convenience function which fills out a vector of bin centers in the same order as the linear order of binContents(). The class "Point" must have a subscript operator, default constructor, copy constructor, and the size() method (use, for example, std::array).

Definition at line 1569 of file HistoND.h.

References cms::cuda::assert(), and mps_fire::i.

                                                                             {
     assert(centers);
     centers->clear();
     const unsigned long len = data_.length();
     centers->reserve(len);
     unsigned* ibuf = &indexBuf_[0];
     const Axis* ax = &axes_[0];
     Point center;
     if (center.size() < dim_)
       throw npstat::NpstatInvalidArgument(
           "In npstat::HistoND::allBinCenters: "
           "incompatible point dimensionality (too small)");
     typename Point::value_type* cdat = &center[0];
 
     for (unsigned long i = 0; i < len; ++i) {
       data_.convertLinearIndex(i, ibuf, dim_);
       for (unsigned idim = 0; idim < dim_; ++idim)
         cdat[idim] = ax[idim].binCenter(ibuf[idim]);
       centers->push_back(center);
     }
   }

◆ axes()

template<typename Numeric, class Axis = HistoAxis>

const std::vector<Axis>& npstat::HistoND< Numeric, Axis >::axes ( ) const

inline

Inspect histogram axes

Definition at line 188 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::axes_.

188 { return axes_; }

npstat::HistoND::axes_

std::vector< Axis > axes_

Definition: HistoND.h:951

◆ axis()

template<typename Numeric, class Axis = HistoAxis>

const Axis& npstat::HistoND< Numeric, Axis >::axis ( const unsigned i ) const

inline

Inspect a histogram axis for the given dimension

Definition at line 191 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::axes_, and mps_fire::i.

191 { return axes_.at(i); }

mps_fire.i

i

Definition: mps_fire.py:429

npstat::HistoND::axes_

std::vector< Axis > axes_

Definition: HistoND.h:951

◆ binBox()

template<typename Numeric , class Axis >

void npstat::HistoND< Numeric, Axis >::binBox	(	unsigned long	binNumber,
		BoxND< double > *	box
	)		const

Bounding box for the given bin

Definition at line 1592 of file HistoND.h.

References cms::cuda::assert(), plotT0FromHistos::binNumber(), and mps_fire::i.

                                                                                              {
     assert(box);
     box->clear();
     if (dim_) {
       box->reserve(dim_);
       data_.convertLinearIndex(binNumber, &indexBuf_[0], dim_);
       const Axis* ax = &axes_[0];
       for (unsigned i = 0; i < dim_; ++i)
         box->push_back(ax[i].binInterval(indexBuf_[i]));
     }
   }

◆ binCenter()

template<typename Numeric , class Axis >

void npstat::HistoND< Numeric, Axis >::binCenter	(	unsigned long	binNumber,
		double *	coords,
		unsigned	lenCoords
	)		const

Position of the bin center. Length of the "coords" array (filled on return) should be equal to the dimensionality of the histogram.

Definition at line 1551 of file HistoND.h.

References cms::cuda::assert(), plotT0FromHistos::binNumber(), and mps_fire::i.

Referenced by npstat::HistoND< Numeric, Axis >::HistoND().

                                                                          {
     if (dim_ != lenCoords)
       throw npstat::NpstatInvalidArgument(
           "In npstat::HistoND::binCenter: "
           "incompatible input point dimensionality");
     if (dim_) {
       assert(coords);
       data_.convertLinearIndex(binNumber, &indexBuf_[0], dim_);
       const Axis* ax = &axes_[0];
       for (unsigned i = 0; i < dim_; ++i)
         coords[i] = ax[i].binCenter(indexBuf_[i]);
     }
   }

◆ binContents()

template<typename Numeric, class Axis = HistoAxis>

const ArrayND<Numeric>& npstat::HistoND< Numeric, Axis >::binContents ( ) const

inline

Retrive a reference to the array of bin contents

Definition at line 182 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::data_.

Referenced by npstat::StorableHistoNDFunctor< Numeric, Axis, Converter >::table().

182 { return data_; }

npstat::HistoND::data_

ArrayND< Numeric > data_

Definition: HistoND.h:949

◆ binVolume()

template<typename Numeric , class Axis >

double npstat::HistoND< Numeric, Axis >::binVolume ( unsigned long binNumber = 0 ) const

This method returns width/area/volume/etc. of a single bin. 1.0 is returned for a dimensionless histogram.

Definition at line 1622 of file HistoND.h.

References plotT0FromHistos::binNumber(), mps_fire::i, and findQualityFiles::v.

                                                                               {
     double v = 1.0;
     if (dim_) {
       data_.convertLinearIndex(binNumber, &indexBuf_[0], dim_);
       const Axis* ax = &axes_[0];
       for (unsigned i = 0; i < dim_; ++i)
         v *= ax[i].binWidth(indexBuf_[i]);
     }
     return v;
   }

◆ boundingBox()

template<typename Numeric , class Axis >

BoxND< double > npstat::HistoND< Numeric, Axis >::boundingBox ( ) const

Bounding box for the whole histogram

Definition at line 1539 of file HistoND.h.

References mps_fire::i.

Referenced by npstat::HistoND< Numeric, Axis >::HistoND().

                                                           {
     BoxND<double> box;
     if (dim_) {
       box.reserve(dim_);
       const Axis* ax = &axes_[0];
       for (unsigned i = 0; i < dim_; ++i)
         box.push_back(ax[i].interval());
     }
     return box;
   }

◆ classId()

template<typename Numeric, class Axis = HistoAxis>

gs::ClassId npstat::HistoND< Numeric, Axis >::classId ( ) const

inline

Method related to "geners" I/O

Definition at line 924 of file HistoND.h.

924 { return gs::ClassId(*this); }

◆ classname()

template<typename Numeric , class Axis >

const char * npstat::HistoND< Numeric, Axis >::classname ( )

static

Definition at line 3485 of file HistoND.h.

References AlCaHLTBitMon_QueryRunRegistry::string.

                                                 {
     static const std::string myClass(gs::template_class_name<Numeric, Axis>("npstat::HistoND"));
     return myClass.c_str();
   }

◆ clear()

template<typename Numeric , class Axis >

void npstat::HistoND< Numeric, Axis >::clear ( void )

inline

Clear the histogram contents (both bins and overflows)

Definition at line 1262 of file HistoND.h.

Referenced by npstat::HistoND< Numeric, Axis >::HistoND().

                                             {
     clearBinContents();
     clearOverflows();
     ++modCount_;
   }

◆ clearBinContents()

template<typename Numeric , class Axis >

void npstat::HistoND< Numeric, Axis >::clearBinContents ( )

inline

This method clears the bin contents but not overflows

Definition at line 1248 of file HistoND.h.

                                                        {
     data_.clear();
     fillCount_ = 0UL;
     ++modCount_;
   }

◆ clearOverflows()

template<typename Numeric , class Axis >

void npstat::HistoND< Numeric, Axis >::clearOverflows ( )

inline

This method clears overflows but not the bin contents

Definition at line 1255 of file HistoND.h.

                                                      {
     overflow_.clear();
     overCount_ = 0UL;
     ++modCount_;
   }

◆ closestBin() [1/12]

template<typename Numeric , class Axis >

const Numeric & npstat::HistoND< Numeric, Axis >::closestBin	(	const double *	coords,
		unsigned	coordLength
	)		const

The "closestBin" functions are similar to the "examine" functions but always return a valid bin and never overflow. This can be useful for implementing lookup tables with constant extrapolation outside of the histogram range.

Definition at line 1723 of file HistoND.h.

References cms::cuda::assert(), mps_fire::i, and heavyIonCSV_trainingSettings::idx.

                                                                                                           {
     if (coordLength != dim_)
       throw npstat::NpstatInvalidArgument(
           "In npstat::HistoND::closestBin: "
           "incompatible input point dimensionality");
     if (coordLength) {
       assert(coords);
       unsigned* idx = &indexBuf_[0];
       const Axis* ax = &axes_[0];
       for (unsigned i = 0; i < dim_; ++i)
         idx[i] = ax[i].closestValidBin(coords[i]);
       return data_.value(idx, dim_);
     } else
       return data_();
   }

◆ closestBin() [2/12]

template<typename Numeric , class Axis >

const Numeric & npstat::HistoND< Numeric, Axis >::closestBin ( ) const

inline

Convenience "closestBin" method for histograms of corresponding dimensionality

Definition at line 1828 of file HistoND.h.

References npstat::Private::h_badargs().

                                                                  {
     if (dim_)
       Private::h_badargs("closestBin");
     return data_();
   }

◆ closestBin() [3/12]

template<typename Numeric , class Axis >

const Numeric & npstat::HistoND< Numeric, Axis >::closestBin ( double x0 ) const

inline

Definition at line 1896 of file HistoND.h.

References npstat::Private::h_badargs(), and mitigatedMETSequence_cff::U.

                                                                                 {
     if (dim_ != 1U)
       Private::h_badargs("closestBin");
     const unsigned i0 = axes_[0].closestValidBin(x0);
     return data_(i0);
   }

◆ closestBin() [4/12]

template<typename Numeric , class Axis >

const Numeric & npstat::HistoND< Numeric, Axis >::closestBin	(	double	x0,
		double	x1
	)		const

Definition at line 1973 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, and mitigatedMETSequence_cff::U.

                                                                                           {
     if (dim_ != 2U)
       Private::h_badargs("closestBin");
     const Axis* ax = &axes_[0];
     const unsigned i0 = ax[0].closestValidBin(x0);
     const unsigned i1 = ax[1].closestValidBin(x1);
     return data_(i0, i1);
   }

◆ closestBin() [5/12]

template<typename Numeric , class Axis >

const Numeric & npstat::HistoND< Numeric, Axis >::closestBin	(	double	x0,
		double	x1,
		double	x2
	)		const

Definition at line 2056 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, and mitigatedMETSequence_cff::U.

                                                                                                            {
     if (dim_ != 3U)
       Private::h_badargs("closestBin");
     const Axis* ax = &axes_[0];
     const unsigned i0 = ax[0].closestValidBin(x0);
     const unsigned i1 = ax[1].closestValidBin(x1);
     const unsigned i2 = ax[2].closestValidBin(x2);
     return data_(i0, i1, i2);
   }

◆ closestBin() [6/12]

template<typename Numeric , class Axis >

const Numeric & npstat::HistoND< Numeric, Axis >::closestBin	(	double	x0,
		double	x1,
		double	x2,
		double	x3
	)		const

Definition at line 2148 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, and mitigatedMETSequence_cff::U.

                                                                            {
     if (dim_ != 4U)
       Private::h_badargs("closestBin");
     const Axis* ax = &axes_[0];
     const unsigned i0 = ax[0].closestValidBin(x0);
     const unsigned i1 = ax[1].closestValidBin(x1);
     const unsigned i2 = ax[2].closestValidBin(x2);
     const unsigned i3 = ax[3].closestValidBin(x3);
     return data_(i0, i1, i2, i3);
   }

◆ closestBin() [7/12]

template<typename Numeric , class Axis >

const Numeric & npstat::HistoND< Numeric, Axis >::closestBin	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4
	)		const

Definition at line 2248 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, and mitigatedMETSequence_cff::U.

                                                                                                  {
     if (dim_ != 5U)
       Private::h_badargs("closestBin");
     const Axis* ax = &axes_[0];
     const unsigned i0 = ax[0].closestValidBin(x0);
     const unsigned i1 = ax[1].closestValidBin(x1);
     const unsigned i2 = ax[2].closestValidBin(x2);
     const unsigned i3 = ax[3].closestValidBin(x3);
     const unsigned i4 = ax[4].closestValidBin(x4);
     return data_(i0, i1, i2, i3, i4);
   }

◆ closestBin() [8/12]

template<typename Numeric , class Axis >

const Numeric & npstat::HistoND< Numeric, Axis >::closestBin	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5
	)		const

Definition at line 2367 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, and mitigatedMETSequence_cff::U.

                                                                                                                   {
     if (dim_ != 6U)
       Private::h_badargs("closestBin");
     const Axis* ax = &axes_[0];
     const unsigned i0 = ax[0].closestValidBin(x0);
     const unsigned i1 = ax[1].closestValidBin(x1);
     const unsigned i2 = ax[2].closestValidBin(x2);
     const unsigned i3 = ax[3].closestValidBin(x3);
     const unsigned i4 = ax[4].closestValidBin(x4);
     const unsigned i5 = ax[5].closestValidBin(x5);
     return data_(i0, i1, i2, i3, i4, i5);
   }

◆ closestBin() [9/12]

template<typename Numeric , class Axis >

const Numeric & npstat::HistoND< Numeric, Axis >::closestBin	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6
	)		const

Definition at line 2499 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, and mitigatedMETSequence_cff::U.

                                                                            {
     if (dim_ != 7U)
       Private::h_badargs("closestBin");
     const Axis* ax = &axes_[0];
     const unsigned i0 = ax[0].closestValidBin(x0);
     const unsigned i1 = ax[1].closestValidBin(x1);
     const unsigned i2 = ax[2].closestValidBin(x2);
     const unsigned i3 = ax[3].closestValidBin(x3);
     const unsigned i4 = ax[4].closestValidBin(x4);
     const unsigned i5 = ax[5].closestValidBin(x5);
     const unsigned i6 = ax[6].closestValidBin(x6);
     return data_(i0, i1, i2, i3, i4, i5, i6);
   }

◆ closestBin() [10/12]

template<typename Numeric , class Axis >

const Numeric & npstat::HistoND< Numeric, Axis >::closestBin	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6,
		double	x7
	)		const

Definition at line 2645 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, and mitigatedMETSequence_cff::U.

                                                                            {
     if (dim_ != 8U)
       Private::h_badargs("closestBin");
     const Axis* ax = &axes_[0];
     const unsigned i0 = ax[0].closestValidBin(x0);
     const unsigned i1 = ax[1].closestValidBin(x1);
     const unsigned i2 = ax[2].closestValidBin(x2);
     const unsigned i3 = ax[3].closestValidBin(x3);
     const unsigned i4 = ax[4].closestValidBin(x4);
     const unsigned i5 = ax[5].closestValidBin(x5);
     const unsigned i6 = ax[6].closestValidBin(x6);
     const unsigned i7 = ax[7].closestValidBin(x7);
     return data_(i0, i1, i2, i3, i4, i5, i6, i7);
   }

◆ closestBin() [11/12]

template<typename Numeric , class Axis >

const Numeric & npstat::HistoND< Numeric, Axis >::closestBin	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6,
		double	x7,
		double	x8
	)		const

Definition at line 2801 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, and mitigatedMETSequence_cff::U.

                                                                            {
     if (dim_ != 9U)
       Private::h_badargs("closestBin");
     const Axis* ax = &axes_[0];
     const unsigned i0 = ax[0].closestValidBin(x0);
     const unsigned i1 = ax[1].closestValidBin(x1);
     const unsigned i2 = ax[2].closestValidBin(x2);
     const unsigned i3 = ax[3].closestValidBin(x3);
     const unsigned i4 = ax[4].closestValidBin(x4);
     const unsigned i5 = ax[5].closestValidBin(x5);
     const unsigned i6 = ax[6].closestValidBin(x6);
     const unsigned i7 = ax[7].closestValidBin(x7);
     const unsigned i8 = ax[8].closestValidBin(x8);
     return data_(i0, i1, i2, i3, i4, i5, i6, i7, i8);
   }

◆ closestBin() [12/12]

template<typename Numeric , class Axis >

const Numeric & npstat::HistoND< Numeric, Axis >::closestBin	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6,
		double	x7,
		double	x8,
		double	x9
	)		const

Definition at line 2971 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, and mitigatedMETSequence_cff::U.

                                                                            {
     if (dim_ != 10U)
       Private::h_badargs("closestBin");
     const Axis* ax = &axes_[0];
     const unsigned i0 = ax[0].closestValidBin(x0);
     const unsigned i1 = ax[1].closestValidBin(x1);
     const unsigned i2 = ax[2].closestValidBin(x2);
     const unsigned i3 = ax[3].closestValidBin(x3);
     const unsigned i4 = ax[4].closestValidBin(x4);
     const unsigned i5 = ax[5].closestValidBin(x5);
     const unsigned i6 = ax[6].closestValidBin(x6);
     const unsigned i7 = ax[7].closestValidBin(x7);
     const unsigned i8 = ax[8].closestValidBin(x8);
     const unsigned i9 = ax[9].closestValidBin(x9);
     return data_(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9);
   }

◆ dim()

template<typename Numeric, class Axis = HistoAxis>

unsigned npstat::HistoND< Numeric, Axis >::dim ( ) const

inline

Histogram dimensionality

Definition at line 173 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::dim_.

Referenced by npstat::StorableHistoNDFunctor< Numeric, Axis, Converter >::minDim().

173 { return dim_; }

npstat::HistoND::dim_

unsigned dim_

Definition: HistoND.h:957

◆ dispatch() [1/12]

template<typename Numeric , class Axis >

template<typename Num2 , class Functor >

void npstat::HistoND< Numeric, Axis >::dispatch	(	const double *	coords,
		unsigned	coordLength,
		Num2 &	weight,
		Functor &	f
	)

Location-based dispatch method. The provided binary functor will be called with the approprite histogram bin value as the first argument and the weight as the second (functor return value is ignored). This allows for a very general use of the histogram binning functionality. For example, with a proper functor, the histogram bins can be filled with pointers to an arbitrary class (this is the only way to use classes which do not have default constructors as bin contents) and the functor can be used to dispatch class methods. Depending on the exact nature of the functor, multiple things might be modified as the result of this call: the bin value, the weight, and the functor internal state.

Definition at line 1674 of file HistoND.h.

References cms::cuda::assert(), f, mps_fire::i, heavyIonCSV_trainingSettings::idx, mitigatedMETSequence_cff::U, and w().

                                                                                                              {
     if (coordLength != dim_)
       throw npstat::NpstatInvalidArgument(
           "In npstat::HistoND::dispatch: "
           "incompatible input point dimensionality");
     if (coordLength) {
       assert(coords);
       unsigned* idx = &indexBuf_[0];
       unsigned* over = idx + dim_;
       const Axis* ax = &axes_[0];
       unsigned overflown = 0U;
       for (unsigned i = 0; i < dim_; ++i) {
         over[i] = ax[i].overflowIndex(coords[i], idx + i);
         overflown |= (over[i] - 1U);
       }
       if (overflown)
         f(overflow_.value(over, dim_), w);
       else
         f(data_.value(idx, dim_), w);
     } else
       f(data_(), w);
     ++modCount_;
   }

◆ dispatch() [2/12]

template<typename Numeric , class Axis >

template<typename Num2 , class Functor >

void npstat::HistoND< Numeric, Axis >::dispatch	(	Num2 &	weight,
		Functor &	f
	)

inline

Convenience "dispatch" method for histograms of corresponding dimensionality

Definition at line 1803 of file HistoND.h.

References f, npstat::Private::h_badargs(), and w().

                                                                   {
     if (dim_)
       Private::h_badargs("dispatch");
     f(data_(), w);
     ++modCount_;
   }

◆ dispatch() [3/12]

template<typename Numeric , class Axis >

template<typename Num2 , class Functor >

void npstat::HistoND< Numeric, Axis >::dispatch	(	double	x0,
		Num2 &	weight,
		Functor &	f
	)

Definition at line 1853 of file HistoND.h.

References f, npstat::Private::h_badargs(), mitigatedMETSequence_cff::U, and w().

                                                                             {
     if (dim_ != 1U)
       Private::h_badargs("dispatch");
     unsigned i0 = 0;
     const unsigned ov0 = axes_[0].overflowIndex(x0, &i0);
     if (ov0 == 1U)
       f(data_(i0), w);
     else
       f(overflow_(ov0), w);
     ++modCount_;
   }

◆ dispatch() [4/12]

template<typename Numeric , class Axis >

template<typename Num2 , class Functor >

void npstat::HistoND< Numeric, Axis >::dispatch	(	double	x0,
		double	x1,
		Num2 &	weight,
		Functor &	f
	)

Definition at line 1924 of file HistoND.h.

References f, npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                                                              {
     if (dim_ != 2U)
       Private::h_badargs("dispatch");
     unsigned i0 = 0, i1 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     if (o0 == 1U && o1 == 1U)
       f(data_(i0, i1), w);
     else
       f(overflow_(o0, o1), w);
     ++modCount_;
   }

◆ dispatch() [5/12]

template<typename Numeric , class Axis >

template<typename Num2 , class Functor >

void npstat::HistoND< Numeric, Axis >::dispatch	(	double	x0,
		double	x1,
		double	x2,
		Num2 &	weight,
		Functor &	f
	)

Definition at line 2004 of file HistoND.h.

References f, npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                                                                               {
     if (dim_ != 3U)
       Private::h_badargs("dispatch");
     unsigned i0 = 0, i1 = 0, i2 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     const unsigned o2 = ax[2].overflowIndex(x2, &i2);
     if (o0 == 1U && o1 == 1U && o2 == 1U)
       f(data_(i0, i1, i2), w);
     else
       f(overflow_(o0, o1, o2), w);
     ++modCount_;
   }

◆ dispatch() [6/12]

template<typename Numeric , class Axis >

template<typename Num2 , class Functor >

void npstat::HistoND< Numeric, Axis >::dispatch	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		Num2 &	weight,
		Functor &	f
	)

Definition at line 2089 of file HistoND.h.

References f, npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                                                                {
     if (dim_ != 4U)
       Private::h_badargs("dispatch");
     unsigned i0 = 0, i1 = 0, i2 = 0, i3 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     const unsigned o2 = ax[2].overflowIndex(x2, &i2);
     const unsigned o3 = ax[3].overflowIndex(x3, &i3);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U)
       f(data_(i0, i1, i2, i3), w);
     else
       f(overflow_(o0, o1, o2, o3), w);
     ++modCount_;
   }

◆ dispatch() [7/12]

template<typename Numeric , class Axis >

template<typename Num2 , class Functor >

void npstat::HistoND< Numeric, Axis >::dispatch	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		Num2 &	weight,
		Functor &	f
	)

Definition at line 2187 of file HistoND.h.

References f, npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                                                                                 {
     if (dim_ != 5U)
       Private::h_badargs("dispatch");
     unsigned i0 = 0, i1 = 0, i2 = 0, i3 = 0, i4 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     const unsigned o2 = ax[2].overflowIndex(x2, &i2);
     const unsigned o3 = ax[3].overflowIndex(x3, &i3);
     const unsigned o4 = ax[4].overflowIndex(x4, &i4);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U && o4 == 1U)
       f(data_(i0, i1, i2, i3, i4), w);
     else
       f(overflow_(o0, o1, o2, o3, o4), w);
     ++modCount_;
   }

◆ dispatch() [8/12]

template<typename Numeric , class Axis >

template<typename Num2 , class Functor >

void npstat::HistoND< Numeric, Axis >::dispatch	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		Num2 &	weight,
		Functor &	f
	)

Definition at line 2292 of file HistoND.h.

References f, npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                     {
     if (dim_ != 6U)
       Private::h_badargs("dispatch");
     unsigned i0 = 0, i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     const unsigned o2 = ax[2].overflowIndex(x2, &i2);
     const unsigned o3 = ax[3].overflowIndex(x3, &i3);
     const unsigned o4 = ax[4].overflowIndex(x4, &i4);
     const unsigned o5 = ax[5].overflowIndex(x5, &i5);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U && o4 == 1U && o5 == 1U)
       f(data_(i0, i1, i2, i3, i4, i5), w);
     else
       f(overflow_(o0, o1, o2, o3, o4, o5), w);
     ++modCount_;
   }

◆ dispatch() [9/12]

template<typename Numeric , class Axis >

template<typename Num2 , class Functor >

void npstat::HistoND< Numeric, Axis >::dispatch	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6,
		Num2 &	weight,
		Functor &	f
	)

Definition at line 2414 of file HistoND.h.

References f, npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                     {
     if (dim_ != 7U)
       Private::h_badargs("dispatch");
     unsigned i0 = 0, i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     const unsigned o2 = ax[2].overflowIndex(x2, &i2);
     const unsigned o3 = ax[3].overflowIndex(x3, &i3);
     const unsigned o4 = ax[4].overflowIndex(x4, &i4);
     const unsigned o5 = ax[5].overflowIndex(x5, &i5);
     const unsigned o6 = ax[6].overflowIndex(x6, &i6);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U && o4 == 1U && o5 == 1U && o6 == 1U)
       f(data_(i0, i1, i2, i3, i4, i5, i6), w);
     else
       f(overflow_(o0, o1, o2, o3, o4, o5, o6), w);
     ++modCount_;
   }

◆ dispatch() [10/12]

template<typename Numeric , class Axis >

template<typename Num2 , class Functor >

void npstat::HistoND< Numeric, Axis >::dispatch	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6,
		double	x7,
		Num2 &	weight,
		Functor &	f
	)

Definition at line 2554 of file HistoND.h.

References f, npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                     {
     if (dim_ != 8U)
       Private::h_badargs("dispatch");
     unsigned i0 = 0, i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     const unsigned o2 = ax[2].overflowIndex(x2, &i2);
     const unsigned o3 = ax[3].overflowIndex(x3, &i3);
     const unsigned o4 = ax[4].overflowIndex(x4, &i4);
     const unsigned o5 = ax[5].overflowIndex(x5, &i5);
     const unsigned o6 = ax[6].overflowIndex(x6, &i6);
     const unsigned o7 = ax[7].overflowIndex(x7, &i7);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U && o4 == 1U && o5 == 1U && o6 == 1U && o7 == 1U)
       f(data_(i0, i1, i2, i3, i4, i5, i6, i7), w);
     else
       f(overflow_(o0, o1, o2, o3, o4, o5, o6, o7), w);
     ++modCount_;
   }

◆ dispatch() [11/12]

template<typename Numeric , class Axis >

template<typename Num2 , class Functor >

void npstat::HistoND< Numeric, Axis >::dispatch	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6,
		double	x7,
		double	x8,
		Num2 &	weight,
		Functor &	f
	)

Definition at line 2704 of file HistoND.h.

References f, npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                     {
     if (dim_ != 9U)
       Private::h_badargs("dispatch");
     unsigned i0 = 0, i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     const unsigned o2 = ax[2].overflowIndex(x2, &i2);
     const unsigned o3 = ax[3].overflowIndex(x3, &i3);
     const unsigned o4 = ax[4].overflowIndex(x4, &i4);
     const unsigned o5 = ax[5].overflowIndex(x5, &i5);
     const unsigned o6 = ax[6].overflowIndex(x6, &i6);
     const unsigned o7 = ax[7].overflowIndex(x7, &i7);
     const unsigned o8 = ax[8].overflowIndex(x8, &i8);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U && o4 == 1U && o5 == 1U && o6 == 1U && o7 == 1U && o8 == 1U)
       f(data_(i0, i1, i2, i3, i4, i5, i6, i7, i8), w);
     else
       f(overflow_(o0, o1, o2, o3, o4, o5, o6, o7, o8), w);
     ++modCount_;
   }

◆ dispatch() [12/12]

template<typename Numeric , class Axis >

template<typename Num2 , class Functor >

void npstat::HistoND< Numeric, Axis >::dispatch	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6,
		double	x7,
		double	x8,
		double	x9,
		Num2 &	weight,
		Functor &	f
	)

Definition at line 2865 of file HistoND.h.

References f, npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                     {
     if (dim_ != 10U)
       Private::h_badargs("dispatch");
     unsigned i0 = 0, i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     const unsigned o2 = ax[2].overflowIndex(x2, &i2);
     const unsigned o3 = ax[3].overflowIndex(x3, &i3);
     const unsigned o4 = ax[4].overflowIndex(x4, &i4);
     const unsigned o5 = ax[5].overflowIndex(x5, &i5);
     const unsigned o6 = ax[6].overflowIndex(x6, &i6);
     const unsigned o7 = ax[7].overflowIndex(x7, &i7);
     const unsigned o8 = ax[8].overflowIndex(x8, &i8);
     const unsigned o9 = ax[9].overflowIndex(x9, &i9);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U && o4 == 1U && o5 == 1U && o6 == 1U && o7 == 1U && o8 == 1U &&
         o9 == 1U)
       f(data_(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9), w);
     else
       f(overflow_(o0, o1, o2, o3, o4, o5, o6, o7, o8, o9), w);
     ++modCount_;
   }

◆ examine() [1/12]

template<typename Numeric , class Axis >

const Numeric & npstat::HistoND< Numeric, Axis >::examine	(	const double *	coords,
		unsigned	coordLength
	)		const

The "examine" functions allow the user to access bin contents when bins are addressed by their coordinates. Use "binContents()" to access the data by bin numbers. Overflow bins will be accessed if the given coordinates fall outside the histogram range.

Definition at line 1699 of file HistoND.h.

References cms::cuda::assert(), mps_fire::i, heavyIonCSV_trainingSettings::idx, and mitigatedMETSequence_cff::U.

                                                                                                        {
     if (coordLength != dim_)
       throw npstat::NpstatInvalidArgument(
           "In npstat::HistoND::examine: "
           "incompatible input point dimensionality");
     if (coordLength) {
       assert(coords);
       unsigned* idx = &indexBuf_[0];
       unsigned* over = idx + dim_;
       const Axis* ax = &axes_[0];
       unsigned overflown = 0U;
       for (unsigned i = 0; i < dim_; ++i) {
         over[i] = ax[i].overflowIndex(coords[i], idx + i);
         overflown |= (over[i] - 1U);
       }
       if (overflown)
         return overflow_.value(over, dim_);
       else
         return data_.value(idx, dim_);
     } else
       return data_();
   }

◆ examine() [2/12]

template<typename Numeric , class Axis >

const Numeric & npstat::HistoND< Numeric, Axis >::examine ( ) const

inline

Convenience "examine" method for histograms of corresponding dimensionality

Definition at line 1821 of file HistoND.h.

References npstat::Private::h_badargs().

                                                               {
     if (dim_)
       Private::h_badargs("examine");
     return data_();
   }

◆ examine() [3/12]

template<typename Numeric , class Axis >

const Numeric & npstat::HistoND< Numeric, Axis >::examine ( double x0 ) const

inline

Definition at line 1884 of file HistoND.h.

References npstat::Private::h_badargs(), and mitigatedMETSequence_cff::U.

                                                                              {
     if (dim_ != 1U)
       Private::h_badargs("examine");
     unsigned i0 = 0;
     const unsigned ov0 = axes_[0].overflowIndex(x0, &i0);
     if (ov0 == 1U)
       return data_(i0);
     else
       return overflow_(ov0);
   }

◆ examine() [4/12]

template<typename Numeric , class Axis >

const Numeric & npstat::HistoND< Numeric, Axis >::examine	(	double	x0,
		double	x1
	)		const

Definition at line 1959 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, CastorDigiReco::o1, and mitigatedMETSequence_cff::U.

                                                                                        {
     if (dim_ != 2U)
       Private::h_badargs("examine");
     unsigned i0 = 0, i1 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     if (o0 == 1U && o1 == 1U)
       return data_(i0, i1);
     else
       return overflow_(o0, o1);
   }

◆ examine() [5/12]

template<typename Numeric , class Axis >

const Numeric & npstat::HistoND< Numeric, Axis >::examine	(	double	x0,
		double	x1,
		double	x2
	)		const

Definition at line 2041 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, CastorDigiReco::o1, and mitigatedMETSequence_cff::U.

                                                                                                         {
     if (dim_ != 3U)
       Private::h_badargs("examine");
     unsigned i0 = 0, i1 = 0, i2 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     const unsigned o2 = ax[2].overflowIndex(x2, &i2);
     if (o0 == 1U && o1 == 1U && o2 == 1U)
       return data_(i0, i1, i2);
     else
       return overflow_(o0, o1, o2);
   }

◆ examine() [6/12]

template<typename Numeric , class Axis >

const Numeric & npstat::HistoND< Numeric, Axis >::examine	(	double	x0,
		double	x1,
		double	x2,
		double	x3
	)		const

Definition at line 2129 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, CastorDigiReco::o1, and mitigatedMETSequence_cff::U.

                                                                         {
     if (dim_ != 4U)
       Private::h_badargs("examine");
     unsigned i0 = 0, i1 = 0, i2 = 0, i3 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     const unsigned o2 = ax[2].overflowIndex(x2, &i2);
     const unsigned o3 = ax[3].overflowIndex(x3, &i3);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U)
       return data_(i0, i1, i2, i3);
     else
       return overflow_(o0, o1, o2, o3);
   }

◆ examine() [7/12]

template<typename Numeric , class Axis >

const Numeric & npstat::HistoND< Numeric, Axis >::examine	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4
	)		const

Definition at line 2230 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, CastorDigiReco::o1, and mitigatedMETSequence_cff::U.

                                                                                                  {
     if (dim_ != 5U)
       Private::h_badargs("examine");
     unsigned i0 = 0, i1 = 0, i2 = 0, i3 = 0, i4 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     const unsigned o2 = ax[2].overflowIndex(x2, &i2);
     const unsigned o3 = ax[3].overflowIndex(x3, &i3);
     const unsigned o4 = ax[4].overflowIndex(x4, &i4);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U && o4 == 1U)
       return data_(i0, i1, i2, i3, i4);
     else
       return overflow_(o0, o1, o2, o3, o4);
   }

◆ examine() [8/12]

template<typename Numeric , class Axis >

const Numeric & npstat::HistoND< Numeric, Axis >::examine	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5
	)		const

Definition at line 2348 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, CastorDigiReco::o1, and mitigatedMETSequence_cff::U.

                                                                                                                   {
     if (dim_ != 6U)
       Private::h_badargs("examine");
     unsigned i0 = 0, i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     const unsigned o2 = ax[2].overflowIndex(x2, &i2);
     const unsigned o3 = ax[3].overflowIndex(x3, &i3);
     const unsigned o4 = ax[4].overflowIndex(x4, &i4);
     const unsigned o5 = ax[5].overflowIndex(x5, &i5);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U && o4 == 1U && o5 == 1U)
       return data_(i0, i1, i2, i3, i4, i5);
     else
       return overflow_(o0, o1, o2, o3, o4, o5);
   }

◆ examine() [9/12]

template<typename Numeric , class Axis >

const Numeric & npstat::HistoND< Numeric, Axis >::examine	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6
	)		const

Definition at line 2474 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, CastorDigiReco::o1, and mitigatedMETSequence_cff::U.

                                                                         {
     if (dim_ != 7U)
       Private::h_badargs("examine");
     unsigned i0 = 0, i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     const unsigned o2 = ax[2].overflowIndex(x2, &i2);
     const unsigned o3 = ax[3].overflowIndex(x3, &i3);
     const unsigned o4 = ax[4].overflowIndex(x4, &i4);
     const unsigned o5 = ax[5].overflowIndex(x5, &i5);
     const unsigned o6 = ax[6].overflowIndex(x6, &i6);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U && o4 == 1U && o5 == 1U && o6 == 1U)
       return data_(i0, i1, i2, i3, i4, i5, i6);
     else
       return overflow_(o0, o1, o2, o3, o4, o5, o6);
   }

◆ examine() [10/12]

template<typename Numeric , class Axis >

const Numeric & npstat::HistoND< Numeric, Axis >::examine	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6,
		double	x7
	)		const

Definition at line 2618 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, CastorDigiReco::o1, and mitigatedMETSequence_cff::U.

                                                                         {
     if (dim_ != 8U)
       Private::h_badargs("examine");
     unsigned i0 = 0, i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     const unsigned o2 = ax[2].overflowIndex(x2, &i2);
     const unsigned o3 = ax[3].overflowIndex(x3, &i3);
     const unsigned o4 = ax[4].overflowIndex(x4, &i4);
     const unsigned o5 = ax[5].overflowIndex(x5, &i5);
     const unsigned o6 = ax[6].overflowIndex(x6, &i6);
     const unsigned o7 = ax[7].overflowIndex(x7, &i7);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U && o4 == 1U && o5 == 1U && o6 == 1U && o7 == 1U)
       return data_(i0, i1, i2, i3, i4, i5, i6, i7);
     else
       return overflow_(o0, o1, o2, o3, o4, o5, o6, o7);
   }

◆ examine() [11/12]

template<typename Numeric , class Axis >

const Numeric & npstat::HistoND< Numeric, Axis >::examine	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6,
		double	x7,
		double	x8
	)		const

Definition at line 2772 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, CastorDigiReco::o1, and mitigatedMETSequence_cff::U.

                                                                         {
     if (dim_ != 9U)
       Private::h_badargs("examine");
     unsigned i0 = 0, i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     const unsigned o2 = ax[2].overflowIndex(x2, &i2);
     const unsigned o3 = ax[3].overflowIndex(x3, &i3);
     const unsigned o4 = ax[4].overflowIndex(x4, &i4);
     const unsigned o5 = ax[5].overflowIndex(x5, &i5);
     const unsigned o6 = ax[6].overflowIndex(x6, &i6);
     const unsigned o7 = ax[7].overflowIndex(x7, &i7);
     const unsigned o8 = ax[8].overflowIndex(x8, &i8);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U && o4 == 1U && o5 == 1U && o6 == 1U && o7 == 1U && o8 == 1U)
       return data_(i0, i1, i2, i3, i4, i5, i6, i7, i8);
     else
       return overflow_(o0, o1, o2, o3, o4, o5, o6, o7, o8);
   }

◆ examine() [12/12]

template<typename Numeric , class Axis >

const Numeric & npstat::HistoND< Numeric, Axis >::examine	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6,
		double	x7,
		double	x8,
		double	x9
	)		const

Definition at line 2939 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, CastorDigiReco::o1, and mitigatedMETSequence_cff::U.

                                                                         {
     if (dim_ != 10U)
       Private::h_badargs("examine");
     unsigned i0 = 0, i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     const unsigned o2 = ax[2].overflowIndex(x2, &i2);
     const unsigned o3 = ax[3].overflowIndex(x3, &i3);
     const unsigned o4 = ax[4].overflowIndex(x4, &i4);
     const unsigned o5 = ax[5].overflowIndex(x5, &i5);
     const unsigned o6 = ax[6].overflowIndex(x6, &i6);
     const unsigned o7 = ax[7].overflowIndex(x7, &i7);
     const unsigned o8 = ax[8].overflowIndex(x8, &i8);
     const unsigned o9 = ax[9].overflowIndex(x9, &i9);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U && o4 == 1U && o5 == 1U && o6 == 1U && o7 == 1U && o8 == 1U &&
         o9 == 1U)
       return data_(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9);
     else
       return overflow_(o0, o1, o2, o3, o4, o5, o6, o7, o8, o9);
   }

◆ fill() [1/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::fill	(	const double *	coords,
		unsigned	coordLength,
		const Num2 &	weight
	)

Fill function for histograms of arbitrary dimensionality. The length of the "coords" array should be equal to the histogram dimensionality. The Numeric type must have the "+=" operator defined with the Num2 type on the right side.

Definition at line 1646 of file HistoND.h.

References cms::cuda::assert(), mps_fire::i, heavyIonCSV_trainingSettings::idx, mitigatedMETSequence_cff::U, and w().

                                                                                                    {
     if (coordLength != dim_)
       throw npstat::NpstatInvalidArgument(
           "In npstat::HistoND::fill: "
           "incompatible input point dimensionality");
     if (coordLength) {
       assert(coords);
       unsigned* idx = &indexBuf_[0];
       unsigned* over = idx + dim_;
       const Axis* ax = &axes_[0];
       unsigned overflown = 0U;
       for (unsigned i = 0; i < dim_; ++i) {
         over[i] = ax[i].overflowIndex(coords[i], idx + i);
         overflown |= (over[i] - 1U);
       }
       if (overflown) {
         overflow_.value(over, dim_) += w;
         ++overCount_;
       } else
         data_.value(idx, dim_) += w;
     } else
       data_() += w;
     ++fillCount_;
     ++modCount_;
   }

◆ fill() [2/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::fill ( const Num2 & weight )

inline

Convenience "fill" method for histograms of corresponding dimensionality

Definition at line 1793 of file HistoND.h.

References npstat::Private::h_badargs(), and w().

                                                         {
     if (dim_)
       Private::h_badargs("fill");
     data_() += w;
     ++fillCount_;
     ++modCount_;
   }

◆ fill() [3/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::fill	(	double	x0,
		const Num2 &	weight
	)

Definition at line 1836 of file HistoND.h.

References npstat::Private::h_badargs(), mitigatedMETSequence_cff::U, and w().

                                                                   {
     if (dim_ != 1U)
       Private::h_badargs("fill");
     unsigned i0 = 0;
     const unsigned ov0 = axes_[0].overflowIndex(x0, &i0);
     if (ov0 == 1U)
       data_(i0) += w;
     else {
       overflow_(ov0) += w;
       ++overCount_;
     }
     ++fillCount_;
     ++modCount_;
   }

◆ fill() [4/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::fill	(	double	x0,
		double	x1,
		const Num2 &	weight
	)

Definition at line 1905 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                                                    {
     if (dim_ != 2U)
       Private::h_badargs("fill");
     unsigned i0 = 0, i1 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     if (o0 == 1U && o1 == 1U)
       data_(i0, i1) += w;
     else {
       overflow_(o0, o1) += w;
       ++overCount_;
     }
     ++fillCount_;
     ++modCount_;
   }

◆ fill() [5/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::fill	(	double	x0,
		double	x1,
		double	x2,
		const Num2 &	weight
	)

Definition at line 1984 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                                                                     {
     if (dim_ != 3U)
       Private::h_badargs("fill");
     unsigned i0 = 0, i1 = 0, i2 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     const unsigned o2 = ax[2].overflowIndex(x2, &i2);
     if (o0 == 1U && o1 == 1U && o2 == 1U)
       data_(i0, i1, i2) += w;
     else {
       overflow_(o0, o1, o2) += w;
       ++overCount_;
     }
     ++fillCount_;
     ++modCount_;
   }

◆ fill() [6/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::fill	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		const Num2 &	weight
	)

Definition at line 2068 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                                                                                      {
     if (dim_ != 4U)
       Private::h_badargs("fill");
     unsigned i0 = 0, i1 = 0, i2 = 0, i3 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     const unsigned o2 = ax[2].overflowIndex(x2, &i2);
     const unsigned o3 = ax[3].overflowIndex(x3, &i3);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U)
       data_(i0, i1, i2, i3) += w;
     else {
       overflow_(o0, o1, o2, o3) += w;
       ++overCount_;
     }
     ++fillCount_;
     ++modCount_;
   }

◆ fill() [7/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::fill	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		const Num2 &	weight
	)

Definition at line 2164 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                                                                           {
     if (dim_ != 5U)
       Private::h_badargs("fill");
     unsigned i0 = 0, i1 = 0, i2 = 0, i3 = 0, i4 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     const unsigned o2 = ax[2].overflowIndex(x2, &i2);
     const unsigned o3 = ax[3].overflowIndex(x3, &i3);
     const unsigned o4 = ax[4].overflowIndex(x4, &i4);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U && o4 == 1U)
       data_(i0, i1, i2, i3, i4) += w;
     else {
       overflow_(o0, o1, o2, o3, o4) += w;
       ++overCount_;
     }
     ++fillCount_;
     ++modCount_;
   }

◆ fill() [8/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::fill	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		const Num2 &	weight
	)

Definition at line 2263 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                    {
     if (dim_ != 6U)
       Private::h_badargs("fill");
     unsigned i0 = 0, i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     const unsigned o2 = ax[2].overflowIndex(x2, &i2);
     const unsigned o3 = ax[3].overflowIndex(x3, &i3);
     const unsigned o4 = ax[4].overflowIndex(x4, &i4);
     const unsigned o5 = ax[5].overflowIndex(x5, &i5);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U && o4 == 1U && o5 == 1U)
       data_(i0, i1, i2, i3, i4, i5) += w;
     else {
       overflow_(o0, o1, o2, o3, o4, o5) += w;
       ++overCount_;
     }
     ++fillCount_;
     ++modCount_;
   }

◆ fill() [9/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::fill	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6,
		const Num2 &	weight
	)

Definition at line 2383 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                    {
     if (dim_ != 7U)
       Private::h_badargs("fill");
     unsigned i0 = 0, i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     const unsigned o2 = ax[2].overflowIndex(x2, &i2);
     const unsigned o3 = ax[3].overflowIndex(x3, &i3);
     const unsigned o4 = ax[4].overflowIndex(x4, &i4);
     const unsigned o5 = ax[5].overflowIndex(x5, &i5);
     const unsigned o6 = ax[6].overflowIndex(x6, &i6);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U && o4 == 1U && o5 == 1U && o6 == 1U)
       data_(i0, i1, i2, i3, i4, i5, i6) += w;
     else {
       overflow_(o0, o1, o2, o3, o4, o5, o6) += w;
       ++overCount_;
     }
     ++fillCount_;
     ++modCount_;
   }

◆ fill() [10/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::fill	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6,
		double	x7,
		const Num2 &	weight
	)

Definition at line 2521 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                    {
     if (dim_ != 8U)
       Private::h_badargs("fill");
     unsigned i0 = 0, i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     const unsigned o2 = ax[2].overflowIndex(x2, &i2);
     const unsigned o3 = ax[3].overflowIndex(x3, &i3);
     const unsigned o4 = ax[4].overflowIndex(x4, &i4);
     const unsigned o5 = ax[5].overflowIndex(x5, &i5);
     const unsigned o6 = ax[6].overflowIndex(x6, &i6);
     const unsigned o7 = ax[7].overflowIndex(x7, &i7);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U && o4 == 1U && o5 == 1U && o6 == 1U && o7 == 1U)
       data_(i0, i1, i2, i3, i4, i5, i6, i7) += w;
     else {
       overflow_(o0, o1, o2, o3, o4, o5, o6, o7) += w;
       ++overCount_;
     }
     ++fillCount_;
     ++modCount_;
   }

◆ fill() [11/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::fill	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6,
		double	x7,
		double	x8,
		const Num2 &	weight
	)

Definition at line 2669 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                    {
     if (dim_ != 9U)
       Private::h_badargs("fill");
     unsigned i0 = 0, i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     const unsigned o2 = ax[2].overflowIndex(x2, &i2);
     const unsigned o3 = ax[3].overflowIndex(x3, &i3);
     const unsigned o4 = ax[4].overflowIndex(x4, &i4);
     const unsigned o5 = ax[5].overflowIndex(x5, &i5);
     const unsigned o6 = ax[6].overflowIndex(x6, &i6);
     const unsigned o7 = ax[7].overflowIndex(x7, &i7);
     const unsigned o8 = ax[8].overflowIndex(x8, &i8);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U && o4 == 1U && o5 == 1U && o6 == 1U && o7 == 1U && o8 == 1U)
       data_(i0, i1, i2, i3, i4, i5, i6, i7, i8) += w;
     else {
       overflow_(o0, o1, o2, o3, o4, o5, o6, o7, o8) += w;
       ++overCount_;
     }
     ++fillCount_;
     ++modCount_;
   }

◆ fill() [12/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::fill	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6,
		double	x7,
		double	x8,
		double	x9,
		const Num2 &	weight
	)

Definition at line 2827 of file HistoND.h.

References npstat::Private::h_badargs(), testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                    {
     if (dim_ != 10U)
       Private::h_badargs("fill");
     unsigned i0 = 0, i1 = 0, i2 = 0, i3 = 0, i4 = 0, i5 = 0, i6 = 0, i7 = 0, i8 = 0, i9 = 0;
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndex(x0, &i0);
     const unsigned o1 = ax[1].overflowIndex(x1, &i1);
     const unsigned o2 = ax[2].overflowIndex(x2, &i2);
     const unsigned o3 = ax[3].overflowIndex(x3, &i3);
     const unsigned o4 = ax[4].overflowIndex(x4, &i4);
     const unsigned o5 = ax[5].overflowIndex(x5, &i5);
     const unsigned o6 = ax[6].overflowIndex(x6, &i6);
     const unsigned o7 = ax[7].overflowIndex(x7, &i7);
     const unsigned o8 = ax[8].overflowIndex(x8, &i8);
     const unsigned o9 = ax[9].overflowIndex(x9, &i9);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U && o4 == 1U && o5 == 1U && o6 == 1U && o7 == 1U && o8 == 1U &&
         o9 == 1U)
       data_(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9) += w;
     else {
       overflow_(o0, o1, o2, o3, o4, o5, o6, o7, o8, o9) += w;
       ++overCount_;
     }
     ++fillCount_;
     ++modCount_;
   }

◆ fillC() [1/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::fillC	(	const double *	coords,
		unsigned	coordLength,
		const Num2 &	weight
	)

The "fillC" functions are similar to the "fill" methods but they preserve the centroid of the deposit. Note that, if the histogram dimensionality is high, "fillC" works significantly slower than the corresponding "fill". Also note that there must be at least 2 bins in each dimension in order for this function to work.

A word of caution. What is added to the bins is the input weight multiplied by another weight calculated using the bin proximity. If the input weight is just 1 (which happens quite often in practice), the product of the weights is normally less than 1. If the histogram template parameter is one of the integer types, operator += will convert this product to 0 before adding it to the bin! Therefore, it is best to use "fillC" only with floating point template parameters (float, double, etc).

Currently, the "fillC" methods work sensibly only in the case the binning is uniform (i.e., the second template parameter is HistoAxis rather than, let say, NUHistoAxis). They typically will not even compile if the binning is not uniform.

Definition at line 1764 of file HistoND.h.

References cms::cuda::assert(), mps_fire::i, heavyIonCSV_trainingSettings::idx, mitigatedMETSequence_cff::U, and w().

                                                                                                     {
     if (coordLength != dim_)
       throw npstat::NpstatInvalidArgument(
           "In npstat::HistoND::fillC: "
           "incompatible input point dimensionality");
     if (coordLength) {
       assert(coords);
       double* wg = &weightBuf_[0];
       unsigned* idx = &indexBuf_[0];
       unsigned* over = idx + dim_;
       const Axis* ax = &axes_[0];
       unsigned overflown = 0U;
       for (unsigned i = 0; i < dim_; ++i) {
         over[i] = ax[i].overflowIndexWeighted(coords[i], idx + i, wg + i);
         overflown |= (over[i] - 1U);
       }
       if (overflown) {
         overflow_.value(over, dim_) += w;
         ++overCount_;
       } else
         fillPreservingCentroid(w);
     } else
       data_() += w;
     ++fillCount_;
     ++modCount_;
   }

◆ fillC() [2/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::fillC ( const Num2 & weight )

inline

Convenience "fillC" method for histograms of corresponding dimensionality

Definition at line 1812 of file HistoND.h.

References npstat::Private::h_badargs(), and w().

                                                          {
     if (dim_)
       Private::h_badargs("fillC");
     data_() += w;
     ++fillCount_;
     ++modCount_;
   }

◆ fillC() [3/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::fillC	(	double	x0,
		const Num2 &	weight
	)

Definition at line 1867 of file HistoND.h.

References npstat::Private::h_badargs(), heavyIonCSV_trainingSettings::idx, mitigatedMETSequence_cff::U, and w().

                                                                    {
     if (dim_ != 1U)
       Private::h_badargs("fillC");
     double* wg = &weightBuf_[0];
     unsigned* idx = &indexBuf_[0];
     const unsigned ov0 = axes_[0].overflowIndexWeighted(x0, idx, wg);
     if (ov0 == 1U)
       fillPreservingCentroid(w);
     else {
       overflow_(ov0) += w;
       ++overCount_;
     }
     ++fillCount_;
     ++modCount_;
   }

◆ fillC() [4/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::fillC	(	double	x0,
		double	x1,
		const Num2 &	weight
	)

Definition at line 1940 of file HistoND.h.

References npstat::Private::h_badargs(), heavyIonCSV_trainingSettings::idx, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                                                     {
     if (dim_ != 2U)
       Private::h_badargs("fillC");
     double* wg = &weightBuf_[0];
     unsigned* idx = &indexBuf_[0];
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndexWeighted(x0, idx + 0, wg + 0);
     const unsigned o1 = ax[1].overflowIndexWeighted(x1, idx + 1, wg + 1);
     if (o0 == 1U && o1 == 1U)
       fillPreservingCentroid(w);
     else {
       overflow_(o0, o1) += w;
       ++overCount_;
     }
     ++fillCount_;
     ++modCount_;
   }

◆ fillC() [5/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::fillC	(	double	x0,
		double	x1,
		double	x2,
		const Num2 &	weight
	)

Definition at line 2021 of file HistoND.h.

References npstat::Private::h_badargs(), heavyIonCSV_trainingSettings::idx, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                                                                      {
     if (dim_ != 3U)
       Private::h_badargs("fillC");
     double* wg = &weightBuf_[0];
     unsigned* idx = &indexBuf_[0];
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndexWeighted(x0, idx + 0, wg + 0);
     const unsigned o1 = ax[1].overflowIndexWeighted(x1, idx + 1, wg + 1);
     const unsigned o2 = ax[2].overflowIndexWeighted(x2, idx + 2, wg + 2);
     if (o0 == 1U && o1 == 1U && o2 == 1U)
       fillPreservingCentroid(w);
     else {
       overflow_(o0, o1, o2) += w;
       ++overCount_;
     }
     ++fillCount_;
     ++modCount_;
   }

◆ fillC() [6/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::fillC	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		const Num2 &	weight
	)

Definition at line 2108 of file HistoND.h.

References npstat::Private::h_badargs(), heavyIonCSV_trainingSettings::idx, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                                                                                       {
     if (dim_ != 4U)
       Private::h_badargs("fillC");
     double* wg = &weightBuf_[0];
     unsigned* idx = &indexBuf_[0];
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndexWeighted(x0, idx + 0, wg + 0);
     const unsigned o1 = ax[1].overflowIndexWeighted(x1, idx + 1, wg + 1);
     const unsigned o2 = ax[2].overflowIndexWeighted(x2, idx + 2, wg + 2);
     const unsigned o3 = ax[3].overflowIndexWeighted(x3, idx + 3, wg + 3);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U)
       fillPreservingCentroid(w);
     else {
       overflow_(o0, o1, o2, o3) += w;
       ++overCount_;
     }
     ++fillCount_;
     ++modCount_;
   }

◆ fillC() [7/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::fillC	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		const Num2 &	weight
	)

Definition at line 2207 of file HistoND.h.

References npstat::Private::h_badargs(), heavyIonCSV_trainingSettings::idx, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                                                                           {
     if (dim_ != 5U)
       Private::h_badargs("fillC");
     double* wg = &weightBuf_[0];
     unsigned* idx = &indexBuf_[0];
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndexWeighted(x0, idx + 0, wg + 0);
     const unsigned o1 = ax[1].overflowIndexWeighted(x1, idx + 1, wg + 1);
     const unsigned o2 = ax[2].overflowIndexWeighted(x2, idx + 2, wg + 2);
     const unsigned o3 = ax[3].overflowIndexWeighted(x3, idx + 3, wg + 3);
     const unsigned o4 = ax[4].overflowIndexWeighted(x4, idx + 4, wg + 4);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U && o4 == 1U)
       fillPreservingCentroid(w);
     else {
       overflow_(o0, o1, o2, o3, o4) += w;
       ++overCount_;
     }
     ++fillCount_;
     ++modCount_;
   }

◆ fillC() [8/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::fillC	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		const Num2 &	weight
	)

Definition at line 2319 of file HistoND.h.

References npstat::Private::h_badargs(), heavyIonCSV_trainingSettings::idx, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                     {
     if (dim_ != 6U)
       Private::h_badargs("fillC");
     double* wg = &weightBuf_[0];
     unsigned* idx = &indexBuf_[0];
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndexWeighted(x0, idx + 0, wg + 0);
     const unsigned o1 = ax[1].overflowIndexWeighted(x1, idx + 1, wg + 1);
     const unsigned o2 = ax[2].overflowIndexWeighted(x2, idx + 2, wg + 2);
     const unsigned o3 = ax[3].overflowIndexWeighted(x3, idx + 3, wg + 3);
     const unsigned o4 = ax[4].overflowIndexWeighted(x4, idx + 4, wg + 4);
     const unsigned o5 = ax[5].overflowIndexWeighted(x5, idx + 5, wg + 5);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U && o4 == 1U && o5 == 1U)
       fillPreservingCentroid(w);
     else {
       overflow_(o0, o1, o2, o3, o4, o5) += w;
       ++overCount_;
     }
     ++fillCount_;
     ++modCount_;
   }

◆ fillC() [9/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::fillC	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6,
		const Num2 &	weight
	)

Definition at line 2443 of file HistoND.h.

References npstat::Private::h_badargs(), heavyIonCSV_trainingSettings::idx, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                     {
     if (dim_ != 7U)
       Private::h_badargs("fillC");
     double* wg = &weightBuf_[0];
     unsigned* idx = &indexBuf_[0];
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndexWeighted(x0, idx + 0, wg + 0);
     const unsigned o1 = ax[1].overflowIndexWeighted(x1, idx + 1, wg + 1);
     const unsigned o2 = ax[2].overflowIndexWeighted(x2, idx + 2, wg + 2);
     const unsigned o3 = ax[3].overflowIndexWeighted(x3, idx + 3, wg + 3);
     const unsigned o4 = ax[4].overflowIndexWeighted(x4, idx + 4, wg + 4);
     const unsigned o5 = ax[5].overflowIndexWeighted(x5, idx + 5, wg + 5);
     const unsigned o6 = ax[6].overflowIndexWeighted(x6, idx + 6, wg + 6);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U && o4 == 1U && o5 == 1U && o6 == 1U)
       fillPreservingCentroid(w);
     else {
       overflow_(o0, o1, o2, o3, o4, o5, o6) += w;
       ++overCount_;
     }
     ++fillCount_;
     ++modCount_;
   }

◆ fillC() [10/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::fillC	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6,
		double	x7,
		const Num2 &	weight
	)

Definition at line 2585 of file HistoND.h.

References npstat::Private::h_badargs(), heavyIonCSV_trainingSettings::idx, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                     {
     if (dim_ != 8U)
       Private::h_badargs("fillC");
     double* wg = &weightBuf_[0];
     unsigned* idx = &indexBuf_[0];
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndexWeighted(x0, idx + 0, wg + 0);
     const unsigned o1 = ax[1].overflowIndexWeighted(x1, idx + 1, wg + 1);
     const unsigned o2 = ax[2].overflowIndexWeighted(x2, idx + 2, wg + 2);
     const unsigned o3 = ax[3].overflowIndexWeighted(x3, idx + 3, wg + 3);
     const unsigned o4 = ax[4].overflowIndexWeighted(x4, idx + 4, wg + 4);
     const unsigned o5 = ax[5].overflowIndexWeighted(x5, idx + 5, wg + 5);
     const unsigned o6 = ax[6].overflowIndexWeighted(x6, idx + 6, wg + 6);
     const unsigned o7 = ax[7].overflowIndexWeighted(x7, idx + 7, wg + 7);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U && o4 == 1U && o5 == 1U && o6 == 1U && o7 == 1U)
       fillPreservingCentroid(w);
     else {
       overflow_(o0, o1, o2, o3, o4, o5, o6, o7) += w;
       ++overCount_;
     }
     ++fillCount_;
     ++modCount_;
   }

◆ fillC() [11/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::fillC	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6,
		double	x7,
		double	x8,
		const Num2 &	weight
	)

Definition at line 2737 of file HistoND.h.

References npstat::Private::h_badargs(), heavyIonCSV_trainingSettings::idx, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                     {
     if (dim_ != 9U)
       Private::h_badargs("fillC");
     double* wg = &weightBuf_[0];
     unsigned* idx = &indexBuf_[0];
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndexWeighted(x0, idx + 0, wg + 0);
     const unsigned o1 = ax[1].overflowIndexWeighted(x1, idx + 1, wg + 1);
     const unsigned o2 = ax[2].overflowIndexWeighted(x2, idx + 2, wg + 2);
     const unsigned o3 = ax[3].overflowIndexWeighted(x3, idx + 3, wg + 3);
     const unsigned o4 = ax[4].overflowIndexWeighted(x4, idx + 4, wg + 4);
     const unsigned o5 = ax[5].overflowIndexWeighted(x5, idx + 5, wg + 5);
     const unsigned o6 = ax[6].overflowIndexWeighted(x6, idx + 6, wg + 6);
     const unsigned o7 = ax[7].overflowIndexWeighted(x7, idx + 7, wg + 7);
     const unsigned o8 = ax[8].overflowIndexWeighted(x8, idx + 8, wg + 8);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U && o4 == 1U && o5 == 1U && o6 == 1U && o7 == 1U && o8 == 1U)
       fillPreservingCentroid(w);
     else {
       overflow_(o0, o1, o2, o3, o4, o5, o6, o7, o8) += w;
       ++overCount_;
     }
     ++fillCount_;
     ++modCount_;
   }

◆ fillC() [12/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::fillC	(	double	x0,
		double	x1,
		double	x2,
		double	x3,
		double	x4,
		double	x5,
		double	x6,
		double	x7,
		double	x8,
		double	x9,
		const Num2 &	weight
	)

Definition at line 2901 of file HistoND.h.

References npstat::Private::h_badargs(), heavyIonCSV_trainingSettings::idx, CastorDigiReco::o1, mitigatedMETSequence_cff::U, and w().

                                                     {
     if (dim_ != 10U)
       Private::h_badargs("fillC");
     double* wg = &weightBuf_[0];
     unsigned* idx = &indexBuf_[0];
     const Axis* ax = &axes_[0];
     const unsigned o0 = ax[0].overflowIndexWeighted(x0, idx + 0, wg + 0);
     const unsigned o1 = ax[1].overflowIndexWeighted(x1, idx + 1, wg + 1);
     const unsigned o2 = ax[2].overflowIndexWeighted(x2, idx + 2, wg + 2);
     const unsigned o3 = ax[3].overflowIndexWeighted(x3, idx + 3, wg + 3);
     const unsigned o4 = ax[4].overflowIndexWeighted(x4, idx + 4, wg + 4);
     const unsigned o5 = ax[5].overflowIndexWeighted(x5, idx + 5, wg + 5);
     const unsigned o6 = ax[6].overflowIndexWeighted(x6, idx + 6, wg + 6);
     const unsigned o7 = ax[7].overflowIndexWeighted(x7, idx + 7, wg + 7);
     const unsigned o8 = ax[8].overflowIndexWeighted(x8, idx + 8, wg + 8);
     const unsigned o9 = ax[9].overflowIndexWeighted(x9, idx + 9, wg + 9);
     if (o0 == 1U && o1 == 1U && o2 == 1U && o3 == 1U && o4 == 1U && o5 == 1U && o6 == 1U && o7 == 1U && o8 == 1U &&
         o9 == 1U)
       fillPreservingCentroid(w);
     else {
       overflow_(o0, o1, o2, o3, o4, o5, o6, o7, o8, o9) += w;
       ++overCount_;
     }
     ++fillCount_;
     ++modCount_;
   }

◆ fillPreservingCentroid()

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::fillPreservingCentroid ( const Num2 & weight )

private

Definition at line 1741 of file HistoND.h.

References mps_fire::i, mitigatedMETSequence_cff::U, w(), and hltDeepSecondaryVertexTagInfosPFPuppi_cfi::weights.

                                                                        {
     const double* weights = &weightBuf_[0];
     const unsigned* cell = &indexBuf_[0];
     const unsigned long* strides = data_.strides();
     const unsigned long maxcycle = 1UL << dim_;
     for (unsigned long icycle = 0; icycle < maxcycle; ++icycle) {
       double w = 1.0;
       unsigned long icell = 0UL;
       for (unsigned i = 0; i < dim_; ++i) {
         if (icycle & (1UL << i)) {
           w *= (1.0 - weights[i]);
           icell += strides[i] * (cell[i] + 1U);
         } else {
           w *= weights[i];
           icell += strides[i] * cell[i];
         }
       }
       data_.linearValue(icell) += (value * w);
     }
   }

◆ getModCount()

template<typename Numeric, class Axis = HistoAxis>

unsigned long npstat::HistoND< Numeric, Axis >::getModCount ( ) const

inline

This method returns the number of modifications performed on the histogram since its creation. This number is always increasing during the lifetime of the histogram object. Its main property is as follows: if the method "getModCount" returns the same number twice, there should be no changes in the histogram object (so that a drawing program does not need to redraw the histogram image).

This number is pure transient, it is not serialized and does not participate in histogram comparisons for equality.

Definition at line 913 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::modCount_.

913 { return modCount_; }

npstat::HistoND::modCount_

unsigned long modCount_

Definition: HistoND.h:956

◆ incrModCount()

template<typename Numeric, class Axis = HistoAxis>

void npstat::HistoND< Numeric, Axis >::incrModCount ( )

inline

Indicate that the histogram contents have changed. Should be used by any code which directly modifies histogram bins (after using const_cast on the relevant reference).

Definition at line 920 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::modCount_.

920 { ++modCount_; }

npstat::HistoND::modCount_

unsigned long modCount_

Definition: HistoND.h:956

◆ integral()

template<typename Numeric , class Axis >

double npstat::HistoND< Numeric, Axis >::integral ( ) const

Integral of the histogram

Definition at line 1520 of file HistoND.h.

References data, mps_fire::i, and mitigatedMETSequence_cff::U.

                                                 {
     typedef typename PreciseType<Numeric>::type Precise;
 
     if (dim_ == 0U)
       return 0.0;
     if (isUniformlyBinned()) {
       Precise sum = data_.template sum<Precise>();
       return static_cast<double>(sum) * binVolume();
     } else {
       Precise sum = Precise();
       const Numeric* data = data_.data();
       const unsigned long len = data_.length();
       for (unsigned long i = 0; i < len; ++i)
         sum += data[i] * binVolume(i);
       return static_cast<double>(sum);
     }
   }

◆ isSameData()

template<typename Numeric , class Axis >

bool npstat::HistoND< Numeric, Axis >::isSameData ( const HistoND< Numeric, Axis > & r ) const

inline

Check data for equality (both bin contents and overflows). Do not compare axes, labels, fill counts, etc.

Definition at line 1605 of file HistoND.h.

                                                                        {
     return dim_ == r.dim_ && overflow_ == r.overflow_ && data_ == r.data_;
   }

◆ isUniformlyBinned()

template<typename Numeric , class Axis >

bool npstat::HistoND< Numeric, Axis >::isUniformlyBinned ( ) const

This method returns "true" if the method isUniform() of each histogram axis returns "true"

Definition at line 1512 of file HistoND.h.

References mps_fire::i.

                                                        {
     for (unsigned i = 0; i < dim_; ++i)
       if (!axes_[i].isUniform())
         return false;
     return true;
   }

◆ nBins()

template<typename Numeric, class Axis = HistoAxis>

unsigned long npstat::HistoND< Numeric, Axis >::nBins ( ) const

inline

Total number of bins

Definition at line 194 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::data_, and npstat::ArrayND< Numeric, StackLen, StackDim >::length().

194 { return data_.length(); }

npstat::HistoND::data_

ArrayND< Numeric > data_

Definition: HistoND.h:949

npstat::ArrayND::length

unsigned long length() const

Definition: ArrayND.h:233

◆ nFillsInRange()

template<typename Numeric, class Axis = HistoAxis>

unsigned long npstat::HistoND< Numeric, Axis >::nFillsInRange ( ) const

inline

Total number of fills which fell inside the histogram range

Definition at line 200 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::fillCount_, and npstat::HistoND< Numeric, Axis >::overCount_.

200 { return fillCount_ - overCount_; }

npstat::HistoND::fillCount_

unsigned long fillCount_

Definition: HistoND.h:954

npstat::HistoND::overCount_

unsigned long overCount_

Definition: HistoND.h:955

◆ nFillsOver()

template<typename Numeric, class Axis = HistoAxis>

unsigned long npstat::HistoND< Numeric, Axis >::nFillsOver ( ) const

inline

Total number of fills which fell outside the histogram range

Definition at line 203 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::overCount_.

203 { return overCount_; }

npstat::HistoND::overCount_

unsigned long overCount_

Definition: HistoND.h:955

◆ nFillsTotal()

template<typename Numeric, class Axis = HistoAxis>

unsigned long npstat::HistoND< Numeric, Axis >::nFillsTotal ( ) const

inline

Total number of fills performed

Definition at line 197 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::fillCount_.

197 { return fillCount_; }

npstat::HistoND::fillCount_

unsigned long fillCount_

Definition: HistoND.h:954

◆ operator!=()

template<typename Numeric , class Axis >

bool npstat::HistoND< Numeric, Axis >::operator!= ( const HistoND< Numeric, Axis > & r ) const

inline

Logical negation of operator==

Definition at line 1617 of file HistoND.h.

                                                                        {
     return !(*this == r);
   }

◆ operator*=() [1/2]

template<typename Numeric, class Axis = HistoAxis>

template<typename Num2 >

HistoND& npstat::HistoND< Numeric, Axis >::operator*= ( const Num2 & r )

In-place multiplication by a scalar (scaling)

◆ operator*=() [2/2]

template<typename Numeric, class Axis = HistoAxis>

template<typename Num2 >

HistoND<Numeric, Axis>& npstat::HistoND< Numeric, Axis >::operator*= ( const Num2 & r )

inline

Definition at line 3280 of file HistoND.h.

                                                                                  {
     data_ *= r;
     overflow_ *= r;
     ++modCount_;
     return *this;
   }

◆ operator+=() [1/2]

template<typename Numeric, class Axis = HistoAxis>

template<typename Num2 >

HistoND& npstat::HistoND< Numeric, Axis >::operator+= ( const HistoND< Num2, Axis > & r )

Fill from another histogram. Compatibility of axis limits will not be checked, but compatibility of array shapes will be.

◆ operator+=() [2/2]

template<typename Numeric, class Axis = HistoAxis>

template<typename Num2 >

HistoND<Numeric, Axis>& npstat::HistoND< Numeric, Axis >::operator+= ( const HistoND< Num2, Axis > & r )

inline

Definition at line 3251 of file HistoND.h.

                                                                                                 {
     data_ += r.data_;
     overflow_ += r.overflow_;
     fillCount_ += r.fillCount_;
     overCount_ += r.overCount_;
     ++modCount_;
     return *this;
   }

◆ operator-=() [1/2]

template<typename Numeric, class Axis = HistoAxis>

template<typename Num2 >

HistoND& npstat::HistoND< Numeric, Axis >::operator-= ( const HistoND< Num2, Axis > & r )

Subtract contents of another histogram. Equivalent to multiplying the contents of the other histogram by -1 and then adding them. One of the consequences of this approach is that, for histograms "a" and "b", the sequence of operations "a += b; a -= b;" does not leave histogram "a" unchanged: although its bin contents will remain the same (up to round-off errors), the fill counts will increase by twice the fill counts of "b".

◆ operator-=() [2/2]

template<typename Numeric, class Axis = HistoAxis>

template<typename Num2 >

HistoND<Numeric, Axis>& npstat::HistoND< Numeric, Axis >::operator-= ( const HistoND< Num2, Axis > & r )

inline

Definition at line 3262 of file HistoND.h.

                                                                                                 {
     data_ -= r.data_;
     overflow_ -= r.overflow_;
 
     // Subtraction does not make much sense for fill counts.
     // We will assume that what we want should be equivalent
     // to the in-place multiplication of the other histogram
     // by -1 and then adding.
     //
     fillCount_ += r.fillCount_;
     overCount_ += r.overCount_;
 
     ++modCount_;
     return *this;
   }

◆ operator/=() [1/2]

template<typename Numeric, class Axis = HistoAxis>

template<typename Num2 >

HistoND& npstat::HistoND< Numeric, Axis >::operator/= ( const Num2 & r )

In-place division by a scalar

◆ operator/=() [2/2]

template<typename Numeric, class Axis = HistoAxis>

template<typename Num2 >

HistoND<Numeric, Axis>& npstat::HistoND< Numeric, Axis >::operator/= ( const Num2 & r )

inline

Definition at line 3289 of file HistoND.h.

                                                                                  {
     data_ /= r;
     overflow_ /= r;
     ++modCount_;
     return *this;
   }

◆ operator=()

template<typename Numeric , class Axis >

HistoND< Numeric, Axis > & npstat::HistoND< Numeric, Axis >::operator= ( const HistoND< Numeric, Axis > & r )

Assignment operator. Works even when the binning of the two histograms is not compatible.

Definition at line 3327 of file HistoND.h.

                                                                             {
     if (&r != this) {
       title_ = r.title_;
       accumulatedDataLabel_ = r.accumulatedDataLabel_;
       data_.uninitialize();
       data_ = r.data_;
       overflow_.uninitialize();
       overflow_ = r.overflow_;
       axes_ = r.axes_;
       weightBuf_ = r.weightBuf_;
       indexBuf_ = r.indexBuf_;
       fillCount_ = r.fillCount_;
       overCount_ = r.overCount_;
       dim_ = r.dim_;
       ++modCount_;
     }
     return *this;
   }

◆ operator==()

template<typename Numeric , class Axis >

bool npstat::HistoND< Numeric, Axis >::operator== ( const HistoND< Numeric, Axis > & r ) const

inline

Comparison for equality

Definition at line 1610 of file HistoND.h.

                                                                        {
     return dim_ == r.dim_ && fillCount_ == r.fillCount_ && overCount_ == r.overCount_ && title_ == r.title_ &&
            accumulatedDataLabel_ == r.accumulatedDataLabel_ && axes_ == r.axes_ && overflow_ == r.overflow_ &&
            data_ == r.data_;
   }

◆ overflows()

template<typename Numeric, class Axis = HistoAxis>

const ArrayND<Numeric>& npstat::HistoND< Numeric, Axis >::overflows ( ) const

inline

Retrive a reference to the array of overflows

Definition at line 185 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::overflow_.

185 { return overflow_; }

npstat::HistoND::overflow_

ArrayND< Numeric > overflow_

Definition: HistoND.h:950

◆ read()

template<typename Numeric , class Axis >

HistoND< Numeric, Axis > * npstat::HistoND< Numeric, Axis >::read	(	const gs::ClassId &	id,
		std::istream &	in
	)

static

Definition at line 3502 of file HistoND.h.

References data, recoMuon::in, npstat::ArrayND< Numeric, StackLen, StackDim >::restore(), mps_fire::result, AlCaHLTBitMon_QueryRunRegistry::string, and runGCPTkAlMap::title.

Referenced by edmIntegrityCheck.PublishToFileSystem::get().

                                                                                           {
     static const gs::ClassId current(gs::ClassId::makeId<HistoND<Numeric, Axis> >());
     current.ensureSameId(id);
 
     std::string title;
     gs::read_pod(in, &title);
 
     std::string accumulatedDataLabel;
     gs::read_pod(in, &accumulatedDataLabel);
 
     unsigned long fillCount = 0, overCount = 0;
     gs::read_pod(in, &fillCount);
     gs::read_pod(in, &overCount);
     if (in.fail())
       throw gs::IOReadFailure("In npstat::HistoND::read: input stream failure");
 
     std::vector<Axis> axes;
     gs::read_heap_obj_vector_as_placed(in, &axes);
     gs::ClassId ida(in, 1);
     ArrayND<Numeric> data, over;
     ArrayND<Numeric>::restore(ida, in, &data);
     ArrayND<Numeric>::restore(ida, in, &over);
     std::unique_ptr<HistoND<Numeric, Axis> > result(
         new HistoND<Numeric, Axis>(axes, title.c_str(), accumulatedDataLabel.c_str()));
     result->data_ = data;
     result->overflow_ = over;
     result->fillCount_ = fillCount;
     result->overCount_ = overCount;
     return result.release();
   }

◆ recalculateNFillsFromData()

template<typename Numeric , class Axis >

void npstat::HistoND< Numeric, Axis >::recalculateNFillsFromData ( )

inline

This member function instructs the histogram to recalculate the number of fills from data. It may be useful to call this function after "setBinContents" in case the contents are filled from another histogram.

Definition at line 3452 of file HistoND.h.

                                                                 {
     const long double nOver = overflow_.template sum<long double>();
     const long double nData = data_.template sum<long double>();
     overCount_ = static_cast<unsigned long>(nOver);
     fillCount_ = static_cast<unsigned long>(nData + nOver);
     ++modCount_;
   }

◆ scaleBinContents()

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::scaleBinContents	(	const Num2 *	data,
		unsigned long	dataLength
	)

Multiplication by a value which is different for every bin

Definition at line 3411 of file HistoND.h.

References cms::cuda::assert(), data, and mps_fire::i.

                                                                                                 {
     if (dataLength != data_.length())
       throw npstat::NpstatInvalidArgument("In npstat::HistoND::scaleBinContents: incompatible data length");
     assert(data);
     Numeric* dat = const_cast<Numeric*>(data_.data());
     for (unsigned long i = 0; i < dataLength; ++i)
       dat[i] *= data[i];
     ++modCount_;
   }

◆ scaleOverflows()

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::scaleOverflows	(	const Num2 *	data,
		unsigned long	dataLength
	)

Definition at line 3423 of file HistoND.h.

References cms::cuda::assert(), data, and mps_fire::i.

                                                                                               {
     if (dataLength != overflow_.length())
       throw npstat::NpstatInvalidArgument("In npstat::HistoND::scaleOverflows: incompatible data length");
     assert(data);
     Numeric* dat = const_cast<Numeric*>(overflow_.data());
     for (unsigned long i = 0; i < dataLength; ++i)
       dat[i] *= data[i];
     ++modCount_;
   }

◆ setAccumulatedDataLabel()

template<typename Numeric, class Axis = HistoAxis>

void npstat::HistoND< Numeric, Axis >::setAccumulatedDataLabel ( const char * newlabel )

inline

Modify the label associated with accumulated data

Definition at line 218 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::accumulatedDataLabel_, and npstat::HistoND< Numeric, Axis >::modCount_.

                                                               {
       accumulatedDataLabel_ = newlabel ? newlabel : "";
       ++modCount_;
     }

◆ setAxisLabel()

template<typename Numeric, class Axis = HistoAxis>

void npstat::HistoND< Numeric, Axis >::setAxisLabel	(	const unsigned	axisNum,
		const char *	newlabel
	)

inline

Modify the label for the histogram axis with the given number

Definition at line 224 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::axes_, and npstat::HistoND< Numeric, Axis >::modCount_.

                                                                            {
       axes_.at(axisNum).setLabel(newlabel);
       ++modCount_;
     }

◆ setBin() [1/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBin	(	const unsigned *	index,
		unsigned	indexLen,
		const Num2 &	v
	)

inline

Method to set contents of individual bins (no bounds checking)

Definition at line 2999 of file HistoND.h.

References findQualityFiles::v.

                                                                                                           {
     data_.value(index, indexLen) = v;
     ++modCount_;
   }

◆ setBin() [2/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBin ( const Num2 & v )

inline

Definition at line 3013 of file HistoND.h.

References findQualityFiles::v.

                                                           {
     data_() = v;
     ++modCount_;
   }

◆ setBin() [3/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBin	(	unsigned	i0,
		const Num2 &	v
	)

inline

Definition at line 3027 of file HistoND.h.

References findQualityFiles::v.

                                                                              {
     data_(i0) = v;
     ++modCount_;
   }

◆ setBin() [4/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBin	(	unsigned	i0,
		unsigned	i1,
		const Num2 &	v
	)

inline

Definition at line 3041 of file HistoND.h.

References testProducerWithPsetDescEmpty_cfi::i1, and findQualityFiles::v.

                                                                                                 {
     data_(i0, i1) = v;
     ++modCount_;
   }

◆ setBin() [5/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBin	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		const Num2 &	v
	)

inline

Definition at line 3055 of file HistoND.h.

References testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, and findQualityFiles::v.

                                                                                                                    {
     data_(i0, i1, i2) = v;
     ++modCount_;
   }

◆ setBin() [6/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBin	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		const Num2 &	v
	)

inline

Definition at line 3062 of file HistoND.h.

References testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, and findQualityFiles::v.

                                                                                                  {
     data_(i0, i1, i2, i3) = v;
     ++modCount_;
   }

◆ setBin() [7/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBin	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		const Num2 &	v
	)

inline

Definition at line 3070 of file HistoND.h.

References testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, and findQualityFiles::v.

                                                                                                                     {
     data_(i0, i1, i2, i3, i4) = v;
     ++modCount_;
   }

◆ setBin() [8/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBin	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		const Num2 &	v
	)

inline

Definition at line 3078 of file HistoND.h.

References testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, and findQualityFiles::v.

                                                             {
     data_(i0, i1, i2, i3, i4, i5) = v;
     ++modCount_;
   }

◆ setBin() [9/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBin	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		unsigned	i6,
		const Num2 &	v
	)

inline

Definition at line 3091 of file HistoND.h.

References testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, and findQualityFiles::v.

                                                             {
     data_(i0, i1, i2, i3, i4, i5, i6) = v;
     ++modCount_;
   }

◆ setBin() [10/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBin	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		unsigned	i6,
		unsigned	i7,
		const Num2 &	v
	)

inline

Definition at line 3105 of file HistoND.h.

References testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, and findQualityFiles::v.

                                                             {
     data_(i0, i1, i2, i3, i4, i5, i6, i7) = v;
     ++modCount_;
   }

◆ setBin() [11/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBin	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		unsigned	i6,
		unsigned	i7,
		unsigned	i8,
		const Num2 &	v
	)

inline

Definition at line 3120 of file HistoND.h.

References testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, and findQualityFiles::v.

                                                             {
     data_(i0, i1, i2, i3, i4, i5, i6, i7, i8) = v;
     ++modCount_;
   }

◆ setBin() [12/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBin	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		unsigned	i6,
		unsigned	i7,
		unsigned	i8,
		unsigned	i9,
		const Num2 &	v
	)

inline

Definition at line 3136 of file HistoND.h.

References testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, and findQualityFiles::v.

                                                             {
     data_(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9) = v;
     ++modCount_;
   }

◆ setBinAt() [1/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBinAt	(	const unsigned *	index,
		unsigned	indexLen,
		const Num2 &	v
	)

inline

Method to set contents of individual bins with bounds checking

Definition at line 3006 of file HistoND.h.

References findQualityFiles::v.

                                                                                                             {
     data_.valueAt(index, indexLen) = v;
     ++modCount_;
   }

◆ setBinAt() [2/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBinAt ( const Num2 & v )

inline

Definition at line 3020 of file HistoND.h.

References findQualityFiles::v.

                                                             {
     data_.at() = v;
     ++modCount_;
   }

◆ setBinAt() [3/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBinAt	(	unsigned	i0,
		const Num2 &	v
	)

inline

Definition at line 3034 of file HistoND.h.

References findQualityFiles::v.

                                                                                {
     data_.at(i0) = v;
     ++modCount_;
   }

◆ setBinAt() [4/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBinAt	(	unsigned	i0,
		unsigned	i1,
		const Num2 &	v
	)

inline

Definition at line 3048 of file HistoND.h.

References testProducerWithPsetDescEmpty_cfi::i1, and findQualityFiles::v.

                                                                                                   {
     data_.at(i0, i1) = v;
     ++modCount_;
   }

◆ setBinAt() [5/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBinAt	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		const Num2 &	v
	)

inline

Definition at line 3153 of file HistoND.h.

References testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, and findQualityFiles::v.

                                                                                                                      {
     data_.at(i0, i1, i2) = v;
     ++modCount_;
   }

◆ setBinAt() [6/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBinAt	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		const Num2 &	v
	)

inline

Definition at line 3160 of file HistoND.h.

References testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, and findQualityFiles::v.

                                                                                                  {
     data_.at(i0, i1, i2, i3) = v;
     ++modCount_;
   }

◆ setBinAt() [7/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBinAt	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		const Num2 &	v
	)

inline

Definition at line 3168 of file HistoND.h.

References testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, and findQualityFiles::v.

                                                                                                                     {
     data_.at(i0, i1, i2, i3, i4) = v;
     ++modCount_;
   }

◆ setBinAt() [8/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBinAt	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		const Num2 &	v
	)

inline

Definition at line 3176 of file HistoND.h.

References testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, and findQualityFiles::v.

                                                               {
     data_.at(i0, i1, i2, i3, i4, i5) = v;
     ++modCount_;
   }

◆ setBinAt() [9/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBinAt	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		unsigned	i6,
		const Num2 &	v
	)

inline

Definition at line 3189 of file HistoND.h.

References testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, and findQualityFiles::v.

                                                               {
     data_.at(i0, i1, i2, i3, i4, i5, i6) = v;
     ++modCount_;
   }

◆ setBinAt() [10/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBinAt	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		unsigned	i6,
		unsigned	i7,
		const Num2 &	v
	)

inline

Definition at line 3203 of file HistoND.h.

References testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, and findQualityFiles::v.

                                                               {
     data_.at(i0, i1, i2, i3, i4, i5, i6, i7) = v;
     ++modCount_;
   }

◆ setBinAt() [11/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBinAt	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		unsigned	i6,
		unsigned	i7,
		unsigned	i8,
		const Num2 &	v
	)

inline

Definition at line 3218 of file HistoND.h.

References testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, and findQualityFiles::v.

                                                               {
     data_.at(i0, i1, i2, i3, i4, i5, i6, i7, i8) = v;
     ++modCount_;
   }

◆ setBinAt() [12/12]

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBinAt	(	unsigned	i0,
		unsigned	i1,
		unsigned	i2,
		unsigned	i3,
		unsigned	i4,
		unsigned	i5,
		unsigned	i6,
		unsigned	i7,
		unsigned	i8,
		unsigned	i9,
		const Num2 &	v
	)

inline

Definition at line 3234 of file HistoND.h.

References testProducerWithPsetDescEmpty_cfi::i1, testProducerWithPsetDescEmpty_cfi::i2, testProducerWithPsetDescEmpty_cfi::i3, and findQualityFiles::v.

                                                               {
     data_.at(i0, i1, i2, i3, i4, i5, i6, i7, i8, i9) = v;
     ++modCount_;
   }

◆ setBinContents()

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBinContents	(	const Num2 *	data,
		unsigned long	dataLength,
		bool	clearOverflows = `true`
	)

inline

This method sets all bin contents in one fell swoop

Definition at line 3435 of file HistoND.h.

References data.

                                                                                    {
     data_.setData(data, dataLength);
     if (clearOverflowsNow)
       clearOverflows();
     ++modCount_;
   }

◆ setBinsToConst()

template<typename Numeric, class Axis = HistoAxis>

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setBinsToConst ( const Num2 & value )

inline

Setting bin contents to some constant value. The Num2 type should allow automatic conversion to Numeric.

Definition at line 783 of file HistoND.h.

References npstat::ArrayND< Numeric, StackLen, StackDim >::constFill(), npstat::HistoND< Numeric, Axis >::data_, and npstat::HistoND< Numeric, Axis >::modCount_.

                                                   {
       data_.constFill(value);
       ++modCount_;
     }

◆ setLinearBin()

template<typename Numeric, class Axis = HistoAxis>

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setLinearBin	(	const unsigned long	index,
		const Num2 &	v
	)

inline

Definition at line 691 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::data_, npstat::ArrayND< Numeric, StackLen, StackDim >::linearValue(), npstat::HistoND< Numeric, Axis >::modCount_, and findQualityFiles::v.

                                                                        {
       data_.linearValue(index) = v;
       ++modCount_;
     }

◆ setLinearBinAt()

template<typename Numeric, class Axis = HistoAxis>

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setLinearBinAt	(	const unsigned long	index,
		const Num2 &	v
	)

inline

Definition at line 764 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::data_, npstat::ArrayND< Numeric, StackLen, StackDim >::linearValueAt(), npstat::HistoND< Numeric, Axis >::modCount_, and findQualityFiles::v.

                                                                          {
       data_.linearValueAt(index) = v;
       ++modCount_;
     }

◆ setNFillsOver()

template<typename Numeric, class Axis = HistoAxis>

void npstat::HistoND< Numeric, Axis >::setNFillsOver ( const unsigned long i )

inline

Definition at line 815 of file HistoND.h.

References mps_fire::i, npstat::HistoND< Numeric, Axis >::modCount_, and npstat::HistoND< Numeric, Axis >::overCount_.

                                                      {
       overCount_ = i;
       ++modCount_;
     }

◆ setNFillsTotal()

template<typename Numeric, class Axis = HistoAxis>

void npstat::HistoND< Numeric, Axis >::setNFillsTotal ( const unsigned long i )

inline

This method is intended for data format conversion programs only, not for typical histogramming use

Definition at line 811 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::fillCount_, mps_fire::i, and npstat::HistoND< Numeric, Axis >::modCount_.

                                                       {
       fillCount_ = i;
       ++modCount_;
     }

◆ setOverflows()

template<typename Numeric , class Axis >

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setOverflows	(	const Num2 *	data,
		unsigned long	dataLength
	)

inline

This method sets all overflows in one fell swoop

Definition at line 3446 of file HistoND.h.

References data.

                                                                                                    {
     overflow_.setData(data, dataLength);
     ++modCount_;
   }

◆ setOverflowsToConst()

template<typename Numeric, class Axis = HistoAxis>

template<typename Num2 >

void npstat::HistoND< Numeric, Axis >::setOverflowsToConst ( const Num2 & value )

inline

Setting overflows to some constant value. The Num2 type should allow automatic conversion to Numeric.

Definition at line 793 of file HistoND.h.

References npstat::ArrayND< Numeric, StackLen, StackDim >::constFill(), npstat::HistoND< Numeric, Axis >::modCount_, and npstat::HistoND< Numeric, Axis >::overflow_.

                                                        {
       overflow_.constFill(value);
       ++modCount_;
     }

◆ setTitle()

template<typename Numeric, class Axis = HistoAxis>

void npstat::HistoND< Numeric, Axis >::setTitle ( const char * newtitle )

inline

Modify the histogram title

Definition at line 212 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::modCount_, and npstat::HistoND< Numeric, Axis >::title_.

                                                {
       title_ = newtitle ? newtitle : "";
       ++modCount_;
     }

◆ title()

template<typename Numeric, class Axis = HistoAxis>

const std::string& npstat::HistoND< Numeric, Axis >::title ( ) const

inline

Histogram title

Definition at line 176 of file HistoND.h.

References npstat::HistoND< Numeric, Axis >::title_.

176 { return title_; }

npstat::HistoND::title_

std::string title_

Definition: HistoND.h:947

◆ transpose()

template<typename Numeric , class Axis >

HistoND< Numeric, Axis > npstat::HistoND< Numeric, Axis >::transpose	(	unsigned	axisNum1,
		unsigned	axisNum2
	)		const

Transpose the histogram axes and bin contents

Definition at line 3347 of file HistoND.h.

                                                                                                                  {
     if (axisNum1 >= dim_ || axisNum2 >= dim_)
       throw npstat::NpstatOutOfRange(
           "In npstat::HistoND::transpose: "
           "axis number is out of range");
     if (axisNum1 == axisNum2)
       // Just make a copy
       return *this;
     else
       return HistoND(*this, axisNum1, axisNum2);
   }

◆ version()

template<typename Numeric, class Axis = HistoAxis>

static unsigned npstat::HistoND< Numeric, Axis >::version ( )

inlinestatic

Definition at line 929 of file HistoND.h.

Referenced by validation.Sample::datasetpattern(), and validation.Sample::filename().

929 { return 1; }

◆ volume()

template<typename Numeric , class Axis >

double npstat::HistoND< Numeric, Axis >::volume ( void ) const

Volume of the histogram bounding box (this direct call is faster than calling boundingBox().volume() ). This function returns 1.0 for 0-dim histogram, axis interval length for 1-d histogram, etc.

Definition at line 1634 of file HistoND.h.

References mps_fire::i, SiStripPI::max, SiStripPI::min, and findQualityFiles::v.

                                               {
     double v = 1.0;
     if (dim_) {
       const Axis* ax = &axes_[0];
       for (unsigned i = 0; i < dim_; ++i)
         v *= (ax[i].max() - ax[i].min());
     }
     return v;
   }

◆ write()

template<typename Numeric , class Axis >

bool npstat::HistoND< Numeric, Axis >::write ( std::ostream & of ) const

Definition at line 3491 of file HistoND.h.

References haddnano::of.

                                                          {
     gs::write_pod(of, title_);
     gs::write_pod(of, accumulatedDataLabel_);
     gs::write_pod(of, fillCount_);
     gs::write_pod(of, overCount_);
 
     return !of.fail() && gs::write_obj_vector(of, axes_) && data_.classId().write(of) && data_.write(of) &&
            overflow_.write(of);
   }

Friends And Related Function Documentation

◆ HistoND

template<typename Numeric, class Axis = HistoAxis>

template<typename Num2 , class Axis2 >

friend class HistoND

friend

Definition at line 45 of file HistoND.h.

Member Data Documentation

◆ accumulatedDataLabel_

template<typename Numeric, class Axis = HistoAxis>

std::string npstat::HistoND< Numeric, Axis >::accumulatedDataLabel_

private

Definition at line 948 of file HistoND.h.

Referenced by npstat::HistoND< Numeric, Axis >::accumulatedDataLabel(), and npstat::HistoND< Numeric, Axis >::setAccumulatedDataLabel().

◆ axes_

template<typename Numeric, class Axis = HistoAxis>

std::vector<Axis> npstat::HistoND< Numeric, Axis >::axes_

private

Definition at line 951 of file HistoND.h.

Referenced by npstat::HistoND< Numeric, Axis >::axes(), npstat::HistoND< Numeric, Axis >::axis(), npstat::HistoND< Numeric, Axis >::HistoND(), and npstat::HistoND< Numeric, Axis >::setAxisLabel().

◆ data_

template<typename Numeric, class Axis = HistoAxis>

ArrayND<Numeric> npstat::HistoND< Numeric, Axis >::data_

private

Definition at line 949 of file HistoND.h.

Referenced by npstat::HistoND< Numeric, Axis >::binContents(), npstat::HistoND< Numeric, Axis >::HistoND(), npstat::HistoND< Numeric, Axis >::nBins(), npstat::HistoND< Numeric, Axis >::setBinsToConst(), npstat::HistoND< Numeric, Axis >::setLinearBin(), and npstat::HistoND< Numeric, Axis >::setLinearBinAt().

◆ dim_

template<typename Numeric, class Axis = HistoAxis>

unsigned npstat::HistoND< Numeric, Axis >::dim_

private

Definition at line 957 of file HistoND.h.

Referenced by npstat::HistoND< Numeric, Axis >::dim(), and npstat::HistoND< Numeric, Axis >::HistoND().

◆ fillCount_

template<typename Numeric, class Axis = HistoAxis>

unsigned long npstat::HistoND< Numeric, Axis >::fillCount_

private

Definition at line 954 of file HistoND.h.

Referenced by npstat::HistoND< Numeric, Axis >::nFillsInRange(), npstat::HistoND< Numeric, Axis >::nFillsTotal(), and npstat::HistoND< Numeric, Axis >::setNFillsTotal().

◆ indexBuf_

template<typename Numeric, class Axis = HistoAxis>

std::vector<unsigned> npstat::HistoND< Numeric, Axis >::indexBuf_

mutableprivate

Definition at line 953 of file HistoND.h.

Referenced by npstat::HistoND< Numeric, Axis >::HistoND().

◆ modCount_

template<typename Numeric, class Axis = HistoAxis>

unsigned long npstat::HistoND< Numeric, Axis >::modCount_

private

Definition at line 956 of file HistoND.h.

◆ overCount_

template<typename Numeric, class Axis = HistoAxis>

unsigned long npstat::HistoND< Numeric, Axis >::overCount_

private

Definition at line 955 of file HistoND.h.

Referenced by npstat::HistoND< Numeric, Axis >::nFillsInRange(), npstat::HistoND< Numeric, Axis >::nFillsOver(), and npstat::HistoND< Numeric, Axis >::setNFillsOver().

◆ overflow_

template<typename Numeric, class Axis = HistoAxis>

ArrayND<Numeric> npstat::HistoND< Numeric, Axis >::overflow_

private

Definition at line 950 of file HistoND.h.

Referenced by npstat::HistoND< Numeric, Axis >::overflows(), and npstat::HistoND< Numeric, Axis >::setOverflowsToConst().

◆ title_

template<typename Numeric, class Axis = HistoAxis>

std::string npstat::HistoND< Numeric, Axis >::title_

private

Definition at line 947 of file HistoND.h.

Referenced by npstat::HistoND< Numeric, Axis >::setTitle(), and npstat::HistoND< Numeric, Axis >::title().

◆ weightBuf_

template<typename Numeric, class Axis = HistoAxis>

std::vector<double> npstat::HistoND< Numeric, Axis >::weightBuf_

mutableprivate

Definition at line 952 of file HistoND.h.

Referenced by npstat::HistoND< Numeric, Axis >::HistoND().

Public Types

Public Member Functions

Static Public Member Functions

Private Member Functions

Private Attributes

Friends

Detailed Description

template<typename Numeric, class Axis = HistoAxis> class npstat::HistoND< Numeric, Axis >

Member Typedef Documentation

◆ axis_type

◆ value_type

Member Enumeration Documentation

◆ RebinType

Constructor & Destructor Documentation

◆ HistoND() [1/14]

◆ HistoND() [2/14]

◆ HistoND() [3/14]

◆ HistoND() [4/14]

◆ HistoND() [5/14]

◆ HistoND() [6/14]

◆ HistoND() [7/14]

◆ HistoND() [8/14]

◆ HistoND() [9/14]

◆ HistoND() [10/14]

◆ HistoND() [11/14]

◆ HistoND() [12/14]

◆ HistoND() [13/14]

◆ HistoND() [14/14]

Member Function Documentation

◆ accumulateBinsInBox()

◆ accumulateBinsLoop()

◆ accumulatedDataLabel()

◆ addToBinContents() [1/2]

◆ addToBinContents() [2/2]

◆ addToOverflows() [1/2]

◆ addToOverflows() [2/2]

◆ addToProjection() [1/2]

◆ addToProjection() [2/2]

◆ allBinCenters()

◆ axes()

◆ axis()

◆ binBox()

◆ binCenter()

◆ binContents()

◆ binVolume()

◆ boundingBox()

◆ classId()

◆ classname()

◆ clear()

◆ clearBinContents()

◆ clearOverflows()

◆ closestBin() [1/12]

◆ closestBin() [2/12]

◆ closestBin() [3/12]

◆ closestBin() [4/12]

◆ closestBin() [5/12]

◆ closestBin() [6/12]

◆ closestBin() [7/12]

◆ closestBin() [8/12]

◆ closestBin() [9/12]

◆ closestBin() [10/12]

◆ closestBin() [11/12]

◆ closestBin() [12/12]

◆ dim()

◆ dispatch() [1/12]

◆ dispatch() [2/12]

◆ dispatch() [3/12]

◆ dispatch() [4/12]

◆ dispatch() [5/12]

◆ dispatch() [6/12]

◆ dispatch() [7/12]

◆ dispatch() [8/12]

◆ dispatch() [9/12]

◆ dispatch() [10/12]

◆ dispatch() [11/12]

◆ dispatch() [12/12]

◆ examine() [1/12]

◆ examine() [2/12]

◆ examine() [3/12]

◆ examine() [4/12]

template<typename Numeric, class Axis = HistoAxis>
class npstat::HistoND< Numeric, Axis >