EstimateStorage convenience class based on BinnedStorage. More...

#include <BinnedEstimate.h>

Inheritance diagram for YODA::EstimateStorage< AxisT >:

Public Types
using	BinType = BinT

Public Types inherited from YODA::BinnedStorage< Estimate, AxisT... >
using	BinningType = BinningT

using	BinType = BinT

using	BinDimension = std::integral_constant< size_t, sizeof...(AxisT)>

Public Types inherited from YODA::AnalysisObject
typedef std::map< std::string, std::string >	Annotations
	Collection type for annotations, as a string-string map.

Public Member Functions
Constructors
	EstimateStorage (const std::string &path="", const std::string &title="")
	Nullary constructor for unique pointers etc.

	EstimateStorage (std::vector< AxisT > &&... binsEdges, const std::string &path="", const std::string &title="")
	Constructor giving explicit bin edges as rvalue reference.

	EstimateStorage (const std::vector< AxisT > &... binsEdges, const std::string &path="", const std::string &title="")
	Constructor giving explicit bin edges as lvalue reference.

	EstimateStorage (std::initializer_list< AxisT > &&... binsEdges, const std::string &path="", const std::string &title="")
	Constructor giving explicit bin edges as initializer list.

template<typename EdgeT = double, typename = enable_if_all_CAxisT<EdgeT, AxisT...>>
	EstimateStorage (const std::vector< size_t > &nBins, const std::vector< std::pair< EdgeT, EdgeT > > &limitsLowUp, const std::string &path="", const std::string &title="")
	Constructor giving range and number of bins.

	EstimateStorage (const BinningT &binning, const std::string &path="", const std::string &title="")
	Constructor given a binning type.

	EstimateStorage (BinningT &&binning, const std::string &path="", const std::string &title="")
	Constructor given an rvalue BinningT.

template<typename EdgeT = double, typename = enable_if_all_CAxisT<EdgeT, AxisT...>>
	EstimateStorage (const ScatterND< sizeof...(AxisT)+1 > &s, const std::string &path="", const std::string &title="")
	Constructor given a scatter.

	EstimateStorage (const EstimateStorage &other, const std::string &path="")
	Copy constructor.

	EstimateStorage (EstimateStorage &&other, const std::string &path="")
	Move constructor.

EstimateStorage	clone () const noexcept
	Make a copy on the stack.

EstimateStorage *	newclone () const noexcept
	Make a copy on the heap.

Transformations
void	scale (const double scalefactor) noexcept
	Rescale as if all fill weights had been different by factor scalefactor.

template<size_t axisN>
void	rebinBy (unsigned int n, size_t begin=1, size_t end=UINT_MAX)
	Merge every group of n bins, from start to end inclusive.

template<size_t axisN>
void	rebin (unsigned int n, size_t begin=1, size_t end=UINT_MAX)
	Overloaded alias for rebinBy.

template<size_t axisN>
void	rebinTo (const std::vector< typename BinningT::template getAxisT< axisN >::EdgeT > &newedges)
	Rebin to the given list of bin edges.

template<size_t axisN>
void	rebin (const std::vector< typename BinningT::template getAxisT< axisN >::EdgeT > &newedges)
	Overloaded alias for rebinTo.

void	reset () noexcept
	Reset the EstimateStorage.

EstimateStorage &	operator= (const EstimateStorage &est) noexcept
	Copy assignment.

EstimateStorage &	operator= (EstimateStorage &&est) noexcept
	Move assignment.

EstimateStorage &	add (const EstimateStorage &est, const std::string &pat_uncorr="^stat\|^uncor")
	Add two EstimateStorages.

EstimateStorage &	operator+= (const EstimateStorage &est)

EstimateStorage &	add (EstimateStorage &&est, const std::string &pat_uncorr="^stat\|^uncor")
	Add two (rvalue) EstimateStorages.

EstimateStorage &	operator+= (EstimateStorage &&est)

EstimateStorage &	subtract (const EstimateStorage &est, const std::string &pat_uncorr="^stat\|^uncor")
	Subtract one EstimateStorages from another one.

EstimateStorage &	operator-= (const EstimateStorage &est)

EstimateStorage &	subtract (EstimateStorage &&est, const std::string &pat_uncorr="^stat\|^uncor")
	Subtract one (rvalue) EstimateStorages from another one.

EstimateStorage &	operator-= (EstimateStorage &&est)

Binning info.
size_t	dim () const noexcept
	Total dimension of the object (number of axes + estimate)

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

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

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

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

Whole EstimateStorage data
std::vector< double >	vals (const bool includeOverflows=false, const bool includeMaskedBins=false) const
	Get list of central values.

std::vector< std::string >	sources () const
	Get list of error sources.

double	areaUnderCurve (const bool includeBinVol=true, const bool includeOverflows=false, const bool includeMaskedBins=false) const
	Calculate the volume underneath the EstimateStorage.

double	auc (const bool includeBinVol=true, const bool includeOverflows=false, const bool includeMaskedBins=false) const
	Convenient alias for areaUnderCurve()

std::vector< std::vector< double > >	covarianceMatrix (const bool ignoreOffDiagonalTerms=false, const bool includeOverflows=false, const bool includeMaskedBins=false, const std::string &pat_uncorr="^stat\|^uncor") const
	Construct a covariance matrix from the error breakdown.

Type reductions
auto	mkScatter (const std::string &path="", const std::string &pat_match="", const bool includeOverflows=false, const bool includeMaskedBins=false) const
	Produce a ScatterND from a EstimateStorage.

template<size_t axisN, typename = std::enable_if_t< (axisN < sizeof...(AxisT) && sizeof...(AxisT)>=2) >>
auto	mkEstimates (const std::string &path="", const bool includeOverflows=false) const
	Split into vector of BinnedEstimates along axisN.

AnalysisObject *	mkInert (const std::string &path="", const std::string &source="") const noexcept
	Method returns clone of the estimate with streamlined error source.

MPI (de-)serialisation
size_t	lengthContent (bool fixed_length=false) const noexcept
	Length of serialized content vector for MPI reduce operations.

std::vector< double >	serializeContent (bool fixed_length=false) const noexcept
	Content serialisation for MPI reduce operations.

void	deserializeContent (const std::vector< double > &data)
	Content deserialisation for MPI reduce operations.

Public Member Functions inherited from YODA::BinnedStorage< Estimate, AxisT... >
	BinnedStorage ()
	Nullary constructor for unique pointers etc.

	BinnedStorage (const BinningT &binning)
	Constructs BinnedStorage from Binning.

	BinnedStorage (BinningT &&binning)
	Constructs BinnedStorage from Binning. Rvalue.

	BinnedStorage (const std::vector< AxisT > &... edges)
	Constructs binning from an adapter and vectors of axes' edges.

	BinnedStorage (std::vector< AxisT > &&... edges)
	Constructs binning from an adapter and Rvalue vectors of axes' edges.

	BinnedStorage (std::initializer_list< AxisT > &&... edges)
	Constructs binning from an adapter and Rvalue initializer lists of axes' edges.

	BinnedStorage (const Axis< AxisT > &... axes)
	Constructs binning from an adapter and a sequence of axes.

	BinnedStorage (Axis< AxisT > &&... axes)
	Constructs binning from an adapter and a sequence of Rvalue axes.

	BinnedStorage (const BinnedStorage &other)
	Copy constructor.

	BinnedStorage (BinnedStorage &&other)
	Move constructor.

size_t	dim () const noexcept
	Total dimension of the object ( = number of axes + content)

BinT &	bin (size_t idx) noexcept
	Returns reference to the bin at idx.

const BinT &	bin (size_t idx) const noexcept
	Returns Bin at idx.

BinT &	bin (const std::array< size_t, sizeof...(AxisT)> &idxLocal) noexcept
	Bin access using local bin indices.

const BinT &	bin (const std::array< size_t, sizeof...(AxisT)> &idxLocal) const noexcept
	Bin access using local bin indices.

BinT &	binAt (typename BinningT::EdgeTypesTuple &&coords) noexcept
	Returns reference to the bin at coordinates.

const BinT &	binAt (typename BinningT::EdgeTypesTuple &&coords) const noexcept
	Returns reference to the bin at coordinates (const version).

void	set (typename BinningT::EdgeTypesTuple &&coords, Estimate &&content) noexcept
	Sets the bin corresponding to coords with an rvalue content.

void	set (typename BinningT::EdgeTypesTuple &&coords, const Estimate &content) noexcept
	Sets the bin corresponding to coords with content.

void	set (const size_t binIdx, Estimate &&content) noexcept
	Sets the bin corresponding to binIndex with an rvalue content.

void	set (const size_t binIdx, const Estimate &content) noexcept
	Sets the bin corresponding to binIndex with content.

std::vector< size_t >	calcIndicesToSkip (const bool includeOverflows, const bool includeMaskedBins) const noexcept
	Calculates indices of bins which are marked or located in the overflow.

BinsVecWrapper< BinsVecT >	bins (const bool includeOverflows=false, const bool includeMaskedBins=false) noexcept
	Returns bins vector wrapper, which skips masked elements when iterated over.

const BinsVecWrapper< const BinsVecT >	bins (const bool includeOverflows=false, const bool includeMaskedBins=false) const noexcept
	Const version.

const BinningT &	binning () const noexcept
	Returns dimension underlying binning object reference.

size_t	binDim () const noexcept
	Returns dimension of binning.

size_t	numBins (const bool includeOverflows=false, const bool includeMaskedBins=false) const noexcept
	Number of bins in the BinnedStorage.

size_t	numBinsAt (const size_t axisN, const bool includeOverflows=false) const noexcept
	Number of bins in the BinnedStorage.

void	reset () noexcept
	Reset the BinnedStorage.

void	clearBins () noexcept
	Deletes all bins and creates empty new ones.

void	maskBins (const std::vector< size_t > &indicesToMask, const bool status=true) noexcept
	Mask a range of bins.

void	maskBin (const size_t indexToMask, const bool status=true) noexcept
	Mask a bin at a given index.

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

void	maskBinAt (typename BinningT::EdgeTypesTuple &&coords, const bool status=true) noexcept
	Mask a bin at a given set of corrdinates.

bool	isMasked (const size_t binIndex) const noexcept

std::vector< size_t >	maskedBins () const noexcept

bool	isVisible (const size_t binIndex) const noexcept

auto	mergeBins (std::decay_t< decltype(AxisNs, std::declval< std::pair< size_t, size_t > >())>... mergeRanges) noexcept -> std::enable_if_t< MetaUtils::is_detected_v< MetaUtils::operatorTraits::addition_assignment_t, Estimate >, RetT >
	Merge bins from A to B at G axis.

auto	mkBinnedSlices (Func &&how2add, const bool includeOverflows=false) const
	Split this BinnedStorage into a vector of BinnedStorages along axisN.

BinnedStorage &	operator= (const BinnedStorage &other) noexcept
	Copy assignment.

BinnedStorage &	operator= (BinnedStorage &&other) noexcept
	Move assignment.

bool	operator== (const BinnedStorage &other) const noexcept
	Compares BinnedStorages for equality, e.g. dimensions of underlying binnings and all axes edges are equal.

bool	operator!= (const BinnedStorage &other) const noexcept
	Compares BinnedStorages for inequality.

Public Member Functions inherited from YODA::AnalysisObject
	AnalysisObject ()
	Default constructor.

	AnalysisObject (const std::string &type, const std::string &path, const std::string &title="")
	Constructor giving a type, a path and an optional title.

	AnalysisObject (const std::string &type, const std::string &path, const AnalysisObject &ao, const std::string &title="")
	Constructor giving a type, a path, another AO to copy annotation from, and an optional title.

virtual	~AnalysisObject ()
	Default destructor.

virtual AnalysisObject &	operator= (const AnalysisObject &ao) noexcept
	Default copy assignment operator.

std::vector< std::string >	annotations () const

bool	hasAnnotation (const std::string &name) const
	Check if an annotation is defined.

const std::string &	annotation (const std::string &name) const
	Get an annotation by name (as a string)

const std::string &	annotation (const std::string &name, const std::string &defaultreturn) const
	Get an annotation by name (as a string) with a default in case the annotation is not found.

template<typename T >
const T	annotation (const std::string &name) const
	Get an annotation by name (copied to another type)

template<typename T >
const T	annotation (const std::string &name, const T &defaultreturn) const
	Get an annotation by name (copied to another type) with a default in case the annotation is not found.

template<typename T >
void	setAnnotation (const std::string &name, const T &value)
	Add or set an annotation by name (templated for remaining types)

void	setAnnotations (const Annotations &anns)
	Set all annotations at once.

template<typename T >
void	addAnnotation (const std::string &name, const T &value)
	Add or set an annotation by name.

void	rmAnnotation (const std::string &name)
	Delete an annotation by name.

void	clearAnnotations ()
	Delete an annotation by name.

const std::string	title () const
	Get the AO title.

void	setTitle (const std::string &title)
	Set the AO title.

const std::string	path () const
	Get the AO path.

void	setPath (const std::string &path)

const std::string	name () const

virtual std::string	type () const
	Get name of the analysis object type.

size_t	lengthMeta (const bool skipPath=true, const bool skipTitle=true) const noexcept
	Length of serialized meta-data vector for MPI reduce operations.

std::vector< std::string >	serializeMeta (const bool skipPath=true, const bool skipTitle=true) const noexcept
	Mate-data serialisation for MPI reduce operations.

virtual void	deserializeMeta (const std::vector< std::string > &data, const bool resetPath=false, const bool resetTitle=false)
	Mate-data deserialisation for MPI reduce operations.

Protected Types
using	BaseT = BinnedStorage< Estimate, AxisT... >

using	BinningT = typename BaseT::BinningT

using	BinT = typename BaseT::BinT

Protected Types inherited from YODA::BinnedStorage< Estimate, AxisT... >
using	BinningT = Binning< std::decay_t< decltype(std::declval< Axis< AxisT > >())>... >
	Convenience alias to be used in constructor.

using	BinT = Bin< sizeof...(AxisT), Estimate, BinningT >

using	BinsVecT = std::vector< BinT >

using	BaseT = BinnedStorage< Estimate, AxisT... >

Additional Inherited Members
Protected Member Functions inherited from YODA::BinnedStorage< Estimate, AxisT... >
void	fillBins () noexcept
	Fills bins with wrapped BinContent objects.

void	fillBins (const BinsVecT &bins) noexcept

void	fillBins (BinsVecT &&bins) noexcept

Detailed Description

template<typename... AxisT>
class YODA::EstimateStorage< AxisT >

EstimateStorage convenience class based on BinnedStorage.

Note: We use this abstraction layer to implement the bulk once and only once. The user-facing BinnedEstimate type will inherit all its methods from this base class along with a few axis-specifc mixins.

Definition at line 75 of file BinnedEstimate.h.

Member Typedef Documentation

◆ BaseT

template<typename... AxisT>

using YODA::EstimateStorage< AxisT >::BaseT = BinnedStorage<Estimate, AxisT...>

protected

Definition at line 80 of file BinnedEstimate.h.

◆ BinningT

template<typename... AxisT>

using YODA::EstimateStorage< AxisT >::BinningT = typename BaseT::BinningT

protected

Definition at line 81 of file BinnedEstimate.h.

◆ BinT

template<typename... AxisT>

using YODA::EstimateStorage< AxisT >::BinT = typename BaseT::BinT

protected

Definition at line 82 of file BinnedEstimate.h.

◆ BinType

template<typename... AxisT>

using YODA::EstimateStorage< AxisT >::BinType = BinT

Definition at line 86 of file BinnedEstimate.h.

Constructor & Destructor Documentation

◆ EstimateStorage() [1/10]

template<typename... AxisT>

YODA::EstimateStorage< AxisT >::EstimateStorage	(	const std::string &	path = `""`,
		const std::string &	title = `""`
	)

inline

Nullary constructor for unique pointers etc.

Definition at line 93 of file BinnedEstimate.h.

94 : BaseT(), AnalysisObject(mkTypeString<AxisT...>(), path, title) { }

YODA::AnalysisObject::title

const std::string title() const

Get the AO title.

Definition AnalysisObject.h:217

YODA::AnalysisObject::path

const std::string path() const

Get the AO path.

Definition AnalysisObject.h:230

YODA::AnalysisObject::AnalysisObject

AnalysisObject()

Default constructor.

Definition AnalysisObject.h:33

YODA::EstimateStorage::BaseT

BinnedStorage< Estimate, AxisT... > BaseT

Definition BinnedEstimate.h:80

◆ EstimateStorage() [2/10]

template<typename... AxisT>

YODA::EstimateStorage< AxisT >::EstimateStorage	(	std::vector< AxisT > &&...	binsEdges,
		const std::string &	path = `""`,
		const std::string &	title = `""`
	)

inline

Constructor giving explicit bin edges as rvalue reference.

Discrete axes have as many edges as bins. Continuous axes have bins.size()+1 edges, the last one being the upper bound of the last bin.

Definition at line 101 of file BinnedEstimate.h.

102 : BaseT(Axis<AxisT>(std::move(binsEdges))...), AnalysisObject(mkTypeString<AxisT...>(), path, title) { }

◆ EstimateStorage() [3/10]

template<typename... AxisT>

YODA::EstimateStorage< AxisT >::EstimateStorage	(	const std::vector< AxisT > &...	binsEdges,
		const std::string &	path = `""`,
		const std::string &	title = `""`
	)

inline

Constructor giving explicit bin edges as lvalue reference.

Discrete axes have as many edges as bins. Continuous axes have bins.size()+1 edges, the last one being the upper bound of the last bin.

Definition at line 109 of file BinnedEstimate.h.

110 : BaseT(Axis<AxisT>(binsEdges)...), AnalysisObject(mkTypeString<AxisT...>(), path, title) { }

◆ EstimateStorage() [4/10]

template<typename... AxisT>

YODA::EstimateStorage< AxisT >::EstimateStorage	(	std::initializer_list< AxisT > &&...	binsEdges,
		const std::string &	path = `""`,
		const std::string &	title = `""`
	)

inline

Constructor giving explicit bin edges as initializer list.

Discrete axes have as many edges as bins. Continuous axes have bins.size()+1 edges, the last one being the upper bound of the last bin.

Definition at line 117 of file BinnedEstimate.h.

118 : BaseT(Axis<AxisT>(std::move(binsEdges))...), AnalysisObject(mkTypeString<AxisT...>(), path, title) { }

◆ EstimateStorage() [5/10]

template<typename... AxisT>

template<typename EdgeT = double, typename = enable_if_all_CAxisT<EdgeT, AxisT...>>

YODA::EstimateStorage< AxisT >::EstimateStorage	(	const std::vector< size_t > &	nBins,
		const std::vector< std::pair< EdgeT, EdgeT > > &	limitsLowUp,
		const std::string &	path = `""`,
		const std::string &	title = `""`
	)

inline

Constructor giving range and number of bins.

Definition at line 122 of file BinnedEstimate.h.

126 : BaseT( _mkBinning(nBins, limitsLowUp, std::make_index_sequence<sizeof...(AxisT)>{}) ),

127 AnalysisObject(mkTypeString<AxisT...>(), path, title) { }

◆ EstimateStorage() [6/10]

template<typename... AxisT>

YODA::EstimateStorage< AxisT >::EstimateStorage	(	const BinningT &	binning,
		const std::string &	path = `""`,
		const std::string &	title = `""`
	)

inline

Constructor given a binning type.

Definition at line 130 of file BinnedEstimate.h.

131 : BaseT(binning), AnalysisObject(mkTypeString<AxisT...>(), path, title) { }

YODA::BinnedStorage< Estimate, AxisT... >::binning

const BinningT & binning() const noexcept

Returns dimension underlying binning object reference.

Definition BinnedStorage.h:321

◆ EstimateStorage() [7/10]

template<typename... AxisT>

YODA::EstimateStorage< AxisT >::EstimateStorage	(	BinningT &&	binning,
		const std::string &	path = `""`,
		const std::string &	title = `""`
	)

inline

Constructor given an rvalue BinningT.

Definition at line 134 of file BinnedEstimate.h.

135 : BaseT(std::move(binning)), AnalysisObject(mkTypeString<AxisT...>(), path, title) { }

◆ EstimateStorage() [8/10]

template<typename... AxisT>

template<typename EdgeT = double, typename = enable_if_all_CAxisT<EdgeT, AxisT...>>

YODA::EstimateStorage< AxisT >::EstimateStorage	(	const ScatterND< sizeof...(AxisT)+1 > &	s,
		const std::string &	path = `""`,
		const std::string &	title = `""`
	)

inline

Constructor given a scatter.

Definition at line 139 of file BinnedEstimate.h.

140 : BaseT(_mkBinning(s, std::make_index_sequence<sizeof...(AxisT)>{})),

141 AnalysisObject(mkTypeString<AxisT...>(), path, title) { }

◆ EstimateStorage() [9/10]

template<typename... AxisT>

YODA::EstimateStorage< AxisT >::EstimateStorage	(	const EstimateStorage< AxisT > &	other,
		const std::string &	path = `""`
	)

inline

Copy constructor.

Todo:: Also allow title setting from the constructor?

Definition at line 146 of file BinnedEstimate.h.

146 : BaseT(other),

147 AnalysisObject(mkTypeString<AxisT...>(), path!=""? path : other.path(), other, other.title()) { }

◆ EstimateStorage() [10/10]

template<typename... AxisT>

YODA::EstimateStorage< AxisT >::EstimateStorage	(	EstimateStorage< AxisT > &&	other,
		const std::string &	path = `""`
	)

inline

Move constructor.

Todo:: Also allow title setting from the constructor?

Definition at line 152 of file BinnedEstimate.h.

152 : BaseT(std::move(other)),

153 AnalysisObject(mkTypeString<AxisT...>(), path!=""? path : other.path(), other, other.title()) { }

Member Function Documentation

◆ add() [1/2]

template<typename... AxisT>

EstimateStorage & YODA::EstimateStorage< AxisT >::add	(	const EstimateStorage< AxisT > &	est,
		const std::string &	pat_uncorr = `"^stat\|^uncor"`
	)

inline

Add two EstimateStorages.

Note: Adding EstimateStorages will unset any ScaledBy attribute from previous calls to scale or normalize.

Definition at line 346 of file BinnedEstimate.h.

                                                                      {
      if (*this != est)
        throw BinningError("Arithmetic operation requires compatible binning!");
      if (AO::hasAnnotation("ScaledBy")) AO::rmAnnotation("ScaledBy");
      for (size_t i = 0; i< BaseT::numBins(true, true); ++i) {
        BaseT::bin(i).add(est.bin(i), pat_uncorr);
      }
      BaseT::maskBins(est.maskedBins(), true);
      return *this;
    }

References YODA::BinnedStorage< BinContentT, AxisT >::bin(), YODA::BinnedStorage< Estimate, AxisT... >::bin(), YODA::AnalysisObject::hasAnnotation(), YODA::BinnedStorage< Estimate, AxisT... >::maskBins(), YODA::BinnedStorage< BinContentT, AxisT >::maskedBins(), YODA::BinnedStorage< Estimate, AxisT... >::numBins(), and YODA::AnalysisObject::rmAnnotation().

Referenced by YODA::EstimateStorage< AxisT >::operator+=(), and YODA::EstimateStorage< AxisT >::operator+=().

◆ add() [2/2]

template<typename... AxisT>

EstimateStorage & YODA::EstimateStorage< AxisT >::add	(	EstimateStorage< AxisT > &&	est,
		const std::string &	pat_uncorr = `"^stat\|^uncor"`
	)

inline

Add two (rvalue) EstimateStorages.

Note: Adding EstimateStorages will unset any ScaledBy attribute from previous calls to scale or normalize.

Definition at line 366 of file BinnedEstimate.h.

                                                                      {
      if (*this != est)
        throw BinningError("Arithmetic operation requires compatible binning!");
      if (AO::hasAnnotation("ScaledBy")) AO::rmAnnotation("ScaledBy");
      for (size_t i = 0; i< BaseT::numBins(true, true); ++i) {
        BaseT::bin(i).add(std::move(est.bin(i)), pat_uncorr);
      }
      BaseT::maskBins(est.maskedBins(), true);
      return *this;
    }

References YODA::BinnedStorage< Estimate, AxisT... >::bin(), YODA::AnalysisObject::hasAnnotation(), YODA::BinnedStorage< Estimate, AxisT... >::maskBins(), YODA::BinnedStorage< Estimate, AxisT... >::numBins(), and YODA::AnalysisObject::rmAnnotation().

◆ areaUnderCurve()

template<typename... AxisT>

double YODA::EstimateStorage< AxisT >::areaUnderCurve	(	const bool	includeBinVol = `true`,
		const bool	includeOverflows = `false`,
		const bool	includeMaskedBins = `false`
	)		const

inline

Calculate the volume underneath the EstimateStorage.

Note: overflow bins have infinite bin width

Definition at line 507 of file BinnedEstimate.h.

                                                                    {
      double ret = 0.;
      for (const auto& b : BaseT::bins(includeOverflows, includeMaskedBins)) {
        const double val = fabs(b.val());
        const double vol = includeBinVol? b.dVol() : 1.0;
        if (std::isfinite(vol))  ret += val*vol; // aggregate bin volume
      }
      return ret;
    }

References YODA::BinnedStorage< Estimate, AxisT... >::bins().

Referenced by YODA::EstimateStorage< AxisT >::auc().

◆ auc()

template<typename... AxisT>

double YODA::EstimateStorage< AxisT >::auc	(	const bool	includeBinVol = `true`,
		const bool	includeOverflows = `false`,
		const bool	includeMaskedBins = `false`
	)		const

inline

Convenient alias for areaUnderCurve()

Definition at line 520 of file BinnedEstimate.h.

                                                         {
      return areaUnderCurve(includeBinVol, includeOverflows, includeMaskedBins);
    }

References YODA::EstimateStorage< AxisT >::areaUnderCurve().

◆ clone()

template<typename... AxisT>

EstimateStorage YODA::EstimateStorage< AxisT >::clone ( ) const

inlinenoexcept

Make a copy on the stack.

Definition at line 156 of file BinnedEstimate.h.

                                           {
      return EstimateStorage(*this);
    }

◆ covarianceMatrix()

template<typename... AxisT>

std::vector< std::vector< double > > YODA::EstimateStorage< AxisT >::covarianceMatrix	(	const bool	ignoreOffDiagonalTerms = `false`,
		const bool	includeOverflows = `false`,
		const bool	includeMaskedBins = `false`,
		const std::string &	pat_uncorr = `"^stat\|^uncor"`
	)		const

inline

Construct a covariance matrix from the error breakdown.

Definition at line 529 of file BinnedEstimate.h.

                                                                                                         {
      const size_t nBins = BaseT::numBins(includeOverflows,includeMaskedBins);
      std::vector<std::vector<double> > covM(nBins);
 
      // initialise cov matrix to be the right shape
      for (size_t i = 0; i < nBins; ++i) {
        covM[i] = std::vector<double>(nBins, 0.0);
      }
 
      const std::vector<std::string> error_sources = sources();
 
      // nominal-only case, i.e. total uncertainty, labelled as empty string
      if (error_sources.size() == 1 && error_sources[0] == "") {
        size_t i = 0;
        for (const auto& b : BaseT::bins(includeOverflows,includeMaskedBins)) {
          covM[i][i] = b.hasSource("")? sqr(0.5*(b.err("").first+b.err("").second)) : 1.0;
          ++i;
        }
        return covM;
      }
 
      // more interesting case where we actually have some uncertainty breakdown!
      std::smatch match;
      const std::regex re(pat_uncorr, std::regex_constants::icase);
      for (const std::string& sname : error_sources) {
        if (sname == "")  continue;
        std::vector<double> systErrs(nBins, 0.0);
        size_t k = 0;
        for (const auto& b : BaseT::bins(includeOverflows,includeMaskedBins)) {
          if (b.hasSource(sname)) {
            const auto& errs = b.err(sname); // dn-up pair
            systErrs[k] = 0.5 *( fabs(errs.first)+fabs(errs.second));
          }
          ++k;
        }
        const bool skipOffDiag = (ignoreOffDiagonalTerms
                                  || std::regex_search(sname, match, re));
        for (size_t i = 0; i < nBins; ++i) {
          for (size_t j = 0; j < nBins; ++j) {
            if (skipOffDiag && i != j)  continue;
            covM[i][j] += systErrs[i]*systErrs[j];
          }
        }
      }
 
      return covM;
    }

References YODA::BinnedStorage< Estimate, AxisT... >::bins(), YODA::BinnedStorage< Estimate, AxisT... >::numBins(), YODA::EstimateStorage< AxisT >::sources(), and YODA::sqr().

◆ deserializeContent()

template<typename... AxisT>

void YODA::EstimateStorage< AxisT >::deserializeContent ( const std::vector< double > & data )

inlinevirtual

Content deserialisation for MPI reduce operations.

Implements YODA::AnalysisObject.

Definition at line 714 of file BinnedEstimate.h.

                                                           {
 
      const size_t nBins = BaseT::numBins(true, true);
      const size_t minLen = 2*nBins;
      if (data.size() < minLen)
        throw UserError("Length of serialized data should be at least " + std::to_string(minLen)+"!");
 
      size_t i = 0;
      auto itr = data.cbegin();
      const auto itrEnd = data.cend();
      const bool fixedLen = data.size() == 2*minLen;
      while (itr != itrEnd) {
        // for estimates, the first element represents the central,
        // the subsequent value represents the number of error pairs
        const size_t nErrs = fixedLen? 1 : (*(itr + 1) + 0.5); // add 0.5 to avoid rounding issues
        auto last = itr + 2*(nErrs+1); // last element + 1
        BaseT::bin(i)._deserializeContent(std::vector<double>{itr, last}, fixedLen);
        // update for next iteration
        itr = last;
        ++i;
      }
    }

References YODA::BinnedStorage< Estimate, AxisT... >::bin(), and YODA::BinnedStorage< Estimate, AxisT... >::numBins().

◆ dim()

template<typename... AxisT>

size_t YODA::EstimateStorage< AxisT >::dim ( ) const

inlinevirtualnoexcept

Total dimension of the object (number of axes + estimate)

Implements YODA::AnalysisObject.

Definition at line 427 of file BinnedEstimate.h.

427{ return sizeof...(AxisT) + 1; }

◆ edges()

template<typename... AxisT>

template<size_t I, typename E = typename BinningT::template getEdgeT<I>>

std::vector< E > YODA::EstimateStorage< AxisT >::edges ( const bool includeOverflows = false ) const

inlinenoexcept

Templated version to get edges of axis N by value. +-inf edges are included.

Note: Needed by axis-specific verison from AxisMixin

Definition at line 437 of file BinnedEstimate.h.

                                                                           {
      return BaseT::_binning.template edges<I>(includeOverflows);
    }

◆ lengthContent()

template<typename... AxisT>

size_t YODA::EstimateStorage< AxisT >::lengthContent ( bool fixed_length = false ) const

inlinevirtualnoexcept

Length of serialized content vector for MPI reduce operations.

Implements YODA::AnalysisObject.

Definition at line 691 of file BinnedEstimate.h.

                                                                   {
      size_t rtn = 0;
      for (const auto& bin : BaseT::bins(true, true)) {
        rtn += bin._lengthContent(fixed_length);
      }
      return rtn;
    }

References YODA::BinnedStorage< Estimate, AxisT... >::bin(), and YODA::BinnedStorage< Estimate, AxisT... >::bins().

◆ max()

template<typename... AxisT>

template<size_t I, typename E = typename BinningT::template getEdgeT<I>>

std::enable_if_t< std::is_floating_point< E >::value, E > YODA::EstimateStorage< AxisT >::max ( ) const

inlinenoexcept

Get the highest non-overflow edge of the axis.

Note: This method is only supported for continuous axes

Definition at line 465 of file BinnedEstimate.h.

                                                                         {
      return BaseT::_binning.template max<I>();
    }

◆ min()

template<typename... AxisT>

template<size_t I, typename E = typename BinningT::template getEdgeT<I>>

std::enable_if_t< std::is_floating_point< E >::value, E > YODA::EstimateStorage< AxisT >::min ( ) const

inlinenoexcept

Get the lowest non-overflow edge of the axis.

Note: This method is only supported for continuous axes

Definition at line 457 of file BinnedEstimate.h.

                                                                         {
      return BaseT::_binning.template min<I>();
    }

◆ mkEstimates()

template<typename... AxisT>

template<size_t axisN, typename = std::enable_if_t< (axisN < sizeof...(AxisT) && sizeof...(AxisT)>=2) >>

auto YODA::EstimateStorage< AxisT >::mkEstimates	(	const std::string &	path = `""`,
		const bool	includeOverflows = `false`
	)		const

inline

Split into vector of BinnedEstimates along axisN.

The binning dimension of the returned objects are reduced by one unit.

Note: Requires at least two binning dimensions.

Definition at line 651 of file BinnedEstimate.h.

                                                                                        {
 
      // Need to provide a prescription for how to add the two bin contents
      auto how2add = [](auto& pivot, const BinType& toCopy) { pivot = toCopy; };
      auto rtn = BaseT::template mkBinnedSlices<axisN, BinnedEstimate>(how2add, includeOverflows);
      for (const std::string& a : annotations()) {
        if (a == "Type")  continue;
        for (size_t i = 0; i < rtn.size(); ++i) {
          rtn[i].setAnnotation(a, annotation(a));
        }
      }
      for (size_t i = 0; i < rtn.size(); ++i) {
        rtn[i].setAnnotation("Path", path);
      }
 
      return rtn;
    }

References YODA::AnalysisObject::annotation(), YODA::AnalysisObject::annotations(), and YODA::AnalysisObject::path().

◆ mkInert()

template<typename... AxisT>

AnalysisObject * YODA::EstimateStorage< AxisT >::mkInert	(	const std::string &	path = `""`,
		const std::string &	source = `""`
	)		const

inlinevirtualnoexcept

Method returns clone of the estimate with streamlined error source.

Reimplemented from YODA::AnalysisObject.

Definition at line 671 of file BinnedEstimate.h.

                                                                         {
      EstimateStorage* rtn = newclone();
      rtn->setPath(path);
      for (auto& b : rtn->bins(true, true)) {
        if (b.numErrs() == 1) {
          try {
            b.renameSource("", source);
          }
          catch (YODA::UserError& e) { }
        }
      }
      return rtn;
    }

References YODA::BinnedStorage< BinContentT, AxisT >::bins(), YODA::EstimateStorage< AxisT >::newclone(), YODA::AnalysisObject::path(), and YODA::AnalysisObject::setPath().

◆ mkScatter()

template<typename... AxisT>

auto YODA::EstimateStorage< AxisT >::mkScatter	(	const std::string &	path = `""`,
		const std::string &	pat_match = `""`,
		const bool	includeOverflows = `false`,
		const bool	includeMaskedBins = `false`
	)		const

inline

Produce a ScatterND from a EstimateStorage.

Definition at line 586 of file BinnedEstimate.h.

                                                                                         {
 
      constexpr size_t N = sizeof...(AxisT);
 
      ScatterND<N+1> rtn;
      for (const std::string& a : annotations()) {
        if (a != "Type")  rtn.setAnnotation(a, annotation(a));
      }
      rtn.setAnnotation("Path", path);
 
      const bool incOF = all_CAxes<AxisT...>::value && includeOverflows;
      for (const auto& b : BaseT::bins(incOF, includeMaskedBins)) {
 
        // Create the vector of coordinates
        Utils::ndarray<double, N+1> vals;
        // first fill bin centres, use bin index if axis non-arithmetic
        auto indexIfDiscrete = [&vals, &b](auto I) {
          using isContinuous = typename BinningT::template is_CAxis<I>;
          using isArithmetic = typename BinningT::template is_Arithmetic<I>;
          vals[I] = coordPicker<I>(b, std::integral_constant<bool, isArithmetic::value>{},
                                      std::integral_constant<bool, isContinuous::value>{});
        };
        MetaUtils::staticFor<BinningT::Dimension::value>(indexIfDiscrete);
        // then fill bin content
        vals[N] = b.val();
 
        // Create the vector of error pairs, use 0 if axis not continuous
        Utils::ndarray<std::pair<double,double>, N+1> errs;
        auto nullifyDiscrete = [&errs, &vals, &b](auto I) {
          using isContinuous = typename BinningT::template is_CAxis<I>;
          errs[I] = nullifyIfDisc<I>(b, vals[I], std::integral_constant<bool, isContinuous::value>{});
        };
        MetaUtils::staticFor<BinningT::Dimension::value>(nullifyDiscrete);
        const double tot = fabs(b.totalErrPos(pat_match)); // use positive error component
        errs[N] = { tot, tot };
 
        // Add the PointND
        rtn.addPoint( PointND<N+1>(vals, errs) );
      }
 
      // Decorate output scatter with the discrete edges
      const BinningT& binning = BaseT::_binning;
      auto decorateEdges = [&rtn, &binning](auto I) {
        using isContinuous = typename BinningT::template is_CAxis<I>;
        if constexpr( !isContinuous::value ) {
          const auto& axis  = binning.template axis<I>();
          if (axis.numBins()) {
            std::stringstream ss;
            axis._renderYODA(ss);
            rtn.setAnnotation("EdgesA" + std::to_string(I+1), ss.str());
          }
        }
      };
      MetaUtils::staticFor<BinningT::Dimension::value>(decorateEdges);
 
      return rtn;
    }

References YODA::ScatterND< N >::addPoint(), YODA::AnalysisObject::annotation(), YODA::AnalysisObject::annotations(), YODA::BinnedStorage< Estimate, AxisT... >::binning(), YODA::BinnedStorage< Estimate, AxisT... >::bins(), YODA::AnalysisObject::path(), YODA::AnalysisObject::setAnnotation(), and YODA::EstimateStorage< AxisT >::vals().

◆ newclone()

template<typename... AxisT>

EstimateStorage * YODA::EstimateStorage< AxisT >::newclone ( ) const

inlinevirtualnoexcept

Make a copy on the heap.

Implements YODA::AnalysisObject.

Definition at line 161 of file BinnedEstimate.h.

                                               {
      return new EstimateStorage(*this);
    }

Referenced by YODA::EstimateStorage< AxisT >::mkInert().

◆ operator+=() [1/2]

template<typename... AxisT>

EstimateStorage & YODA::EstimateStorage< AxisT >::operator+= ( const EstimateStorage< AxisT > & est )

inline

Definition at line 358 of file BinnedEstimate.h.

                                                              {
      return add(est);
    }

References YODA::EstimateStorage< AxisT >::add().

◆ operator+=() [2/2]

template<typename... AxisT>

EstimateStorage & YODA::EstimateStorage< AxisT >::operator+= ( EstimateStorage< AxisT > && est )

inline

Definition at line 378 of file BinnedEstimate.h.

                                                         {
      return add(std::move(est));
    }

References YODA::EstimateStorage< AxisT >::add().

◆ operator-=() [1/2]

template<typename... AxisT>

EstimateStorage & YODA::EstimateStorage< AxisT >::operator-= ( const EstimateStorage< AxisT > & est )

inline

Definition at line 399 of file BinnedEstimate.h.

                                                              {
      return subtract(est);
    }

References YODA::EstimateStorage< AxisT >::subtract().

◆ operator-=() [2/2]

template<typename... AxisT>

EstimateStorage & YODA::EstimateStorage< AxisT >::operator-= ( EstimateStorage< AxisT > && est )

inline

Definition at line 416 of file BinnedEstimate.h.

                                                         {
      return subtract(std::move(est));
    }

References YODA::EstimateStorage< AxisT >::subtract().

◆ operator=() [1/2]

template<typename... AxisT>

EstimateStorage & YODA::EstimateStorage< AxisT >::operator= ( const EstimateStorage< AxisT > & est )

inlinenoexcept

Copy assignment.

Definition at line 325 of file BinnedEstimate.h.

                                                                      {
      if (this != &est) {
        AnalysisObject::operator = (est);
        BaseT::operator = (est);
      }
      return *this;
    }

References YODA::AnalysisObject::operator=(), and YODA::BinnedStorage< Estimate, AxisT... >::operator=().

◆ operator=() [2/2]

template<typename... AxisT>

EstimateStorage & YODA::EstimateStorage< AxisT >::operator= ( EstimateStorage< AxisT > && est )

inlinenoexcept

Move assignment.

Definition at line 334 of file BinnedEstimate.h.

                                                                 {
      if (this != &est) {
        AnalysisObject::operator = (est);
        BaseT::operator = (std::move(est));
      }
      return *this;
    }

References YODA::AnalysisObject::operator=(), and YODA::BinnedStorage< Estimate, AxisT... >::operator=().

◆ rebin() [1/2]

template<typename... AxisT>

template<size_t axisN>

void YODA::EstimateStorage< AxisT >::rebin ( const std::vector< typename BinningT::template getAxisT< axisN >::EdgeT > & newedges )

inline

Overloaded alias for rebinTo.

Definition at line 315 of file BinnedEstimate.h.

                                                                                          {
      rebinTo<axisN>(std::move(newedges));
    }

◆ rebin() [2/2]

template<typename... AxisT>

template<size_t axisN>

void YODA::EstimateStorage< AxisT >::rebin	(	unsigned int	n,
		size_t	begin = `1`,
		size_t	end = `UINT_MAX`
	)

inline

Overloaded alias for rebinBy.

Definition at line 282 of file BinnedEstimate.h.

                                                                    {
      rebinBy<axisN>(n, begin, end);
    }

◆ rebinBy()

template<typename... AxisT>

template<size_t axisN>

void YODA::EstimateStorage< AxisT >::rebinBy	(	unsigned int	n,
		size_t	begin = `1`,
		size_t	end = `UINT_MAX`
	)

inline

Merge every group of n bins, from start to end inclusive.

If the number of bins is not a multiple of n, the last m < n bins on the RHS will also be merged, as the closest possible approach to factor
rebinning everywhere.

Note: Only visible bins are being rebinned. Underflow (index = 0) and overflow (index = numBins() + 1) are not included.

Definition at line 266 of file BinnedEstimate.h.

                                                                      {
      if (n < 1)  throw UserError("Rebinning requested in groups of 0!");
      if (!begin) throw UserError("Visible bins start with index 1!");
      if (end > BaseT::numBinsAt(axisN)+1)  end = BaseT::numBinsAt(axisN) + 1;
      for (size_t m = begin; m < end; ++m) {
        if (m > BaseT::numBinsAt(axisN)+1) break; // nothing to be done
        const size_t myend = (m+n-1 < BaseT::numBinsAt(axisN)+1) ? m+n-1 : BaseT::numBinsAt(axisN);
        if (myend > m) {
          BaseT::template mergeBins<axisN>({m, myend});
          end -= myend-m; //< reduce upper index by the number of removed bins
        }
      }
    }

References YODA::BinnedStorage< Estimate, AxisT... >::numBinsAt().

◆ rebinTo()

template<typename... AxisT>

template<size_t axisN>

void YODA::EstimateStorage< AxisT >::rebinTo ( const std::vector< typename BinningT::template getAxisT< axisN >::EdgeT > & newedges )

inline

Rebin to the given list of bin edges.

Definition at line 288 of file BinnedEstimate.h.

                                                                                            {
      if (newedges.size() < 2)
        throw UserError("Requested rebinning to an edge list which defines no bins");
      using thisAxisT = typename BinningT::template getAxisT<axisN>;
      using thisEdgeT = typename thisAxisT::EdgeT;
      // get list of shared edges
      thisAxisT& oldAxis = BaseT::_binning.template axis<axisN>();
      const thisAxisT newAxis(std::move(newedges));
      const std::vector<thisEdgeT> eshared = oldAxis.sharedEdges(newAxis);
      if (eshared.size() != newAxis.edges().size())
        throw BinningError("Requested rebinning to incompatible edges");
      // loop over new lower bin edges (= first bin index of merge range)
      for (size_t begin = 0; begin < eshared.size() - 1; ++begin) {
        // find index of upper edge along old axis
        // (subtracting 1 gives index of last bin to be merged)
        size_t end = oldAxis.index(eshared[begin+1]) - 1;
        // if the current edge is the last visible edge before the overflow
        // merge the remaining bins into the overflow
        if (begin == newAxis.numBins(true)-1)  end = oldAxis.numBins(true)-1;
        // merge this range
        if (end > begin)  BaseT::template mergeBins<axisN>({begin, end});
        if (eshared.size() == oldAxis.edges().size())  break; // we're done
      }
    }

◆ reset()

template<typename... AxisT>

void YODA::EstimateStorage< AxisT >::reset ( )

inlinevirtualnoexcept

Reset the EstimateStorage.

Keep the binning but set all bin contents and related quantities to zero

Implements YODA::AnalysisObject.

Definition at line 322 of file BinnedEstimate.h.

322{ BaseT::clearBins(); }

YODA::BinnedStorage< Estimate, AxisT... >::clearBins

void clearBins() noexcept

Deletes all bins and creates empty new ones.

Definition BinnedStorage.h:350

References YODA::BinnedStorage< Estimate, AxisT... >::clearBins().

◆ scale()

template<typename... AxisT>

void YODA::EstimateStorage< AxisT >::scale ( const double scalefactor )

inlinenoexcept

Rescale as if all fill weights had been different by factor scalefactor.

Definition at line 249 of file BinnedEstimate.h.

                                                  {
      setAnnotation("ScaledBy", annotation<double>("ScaledBy", 1.0) * scalefactor);
      for (auto& bin : BaseT::_bins) {
        bin.scale(scalefactor);
      }
    }

References YODA::BinnedStorage< Estimate, AxisT... >::bin(), and YODA::AnalysisObject::setAnnotation().

◆ serializeContent()

template<typename... AxisT>

std::vector< double > YODA::EstimateStorage< AxisT >::serializeContent ( bool fixed_length = false ) const

inlinevirtualnoexcept

Content serialisation for MPI reduce operations.

Implements YODA::AnalysisObject.

Definition at line 699 of file BinnedEstimate.h.

                                                                                 {
      std::vector<double> rtn;
      const size_t nBins = BaseT::numBins(true, true);
      rtn.reserve(nBins * 4);
      for (size_t i = 0; i < nBins; ++i) {
        const auto& b = BaseT::bin(i);
        std::vector<double> bdata = b._serializeContent(fixed_length);
        rtn.insert(std::end(rtn),
                   std::make_move_iterator(std::begin(bdata)),
                   std::make_move_iterator(std::end(bdata)));
      }
      return rtn;
    }

References YODA::BinnedStorage< Estimate, AxisT... >::bin(), and YODA::BinnedStorage< Estimate, AxisT... >::numBins().

◆ sources()

template<typename... AxisT>

std::vector< std::string > YODA::EstimateStorage< AxisT >::sources ( ) const

inline

Get list of error sources.

Definition at line 487 of file BinnedEstimate.h.

                                         {
      // Assemble union of error sources, as it's not guaranteed
      // that every bin has the same error breakdown
      std::vector<std::string> rtn;
 
      for (const auto& b : BaseT::bins(true)) {
        std::vector<std::string> keys = b.sources();
        rtn.insert(std::end(rtn),
                   std::make_move_iterator(std::begin(keys)),
                   std::make_move_iterator(std::end(keys)));
      }
      std::sort(rtn.begin(), rtn.end());
      rtn.erase( std::unique(rtn.begin(), rtn.end()), rtn.end() );
 
      return rtn;
    }

References YODA::BinnedStorage< Estimate, AxisT... >::bins().

Referenced by YODA::EstimateStorage< AxisT >::covarianceMatrix().

◆ subtract() [1/2]

template<typename... AxisT>

EstimateStorage & YODA::EstimateStorage< AxisT >::subtract	(	const EstimateStorage< AxisT > &	est,
		const std::string &	pat_uncorr = `"^stat\|^uncor"`
	)

inline

Subtract one EstimateStorages from another one.

Note: Subtracting EstimateStorages will unset any ScaledBy attribute from previous calls to scale or normalize.

Definition at line 387 of file BinnedEstimate.h.

                                                                           {
      if (*this != est)
        throw BinningError("Arithmetic operation requires compatible binning!");
      if (AO::hasAnnotation("ScaledBy")) AO::rmAnnotation("ScaledBy");
      for (size_t i = 0; i< BaseT::numBins(true, true); ++i) {
        BaseT::bin(i).subtract(est.bin(i), pat_uncorr);
      }
      BaseT::maskBins(est.maskedBins(), true);
      return *this;
    }

References YODA::BinnedStorage< BinContentT, AxisT >::bin(), YODA::BinnedStorage< Estimate, AxisT... >::bin(), YODA::AnalysisObject::hasAnnotation(), YODA::BinnedStorage< Estimate, AxisT... >::maskBins(), YODA::BinnedStorage< BinContentT, AxisT >::maskedBins(), YODA::BinnedStorage< Estimate, AxisT... >::numBins(), and YODA::AnalysisObject::rmAnnotation().

Referenced by YODA::EstimateStorage< AxisT >::operator-=(), and YODA::EstimateStorage< AxisT >::operator-=().

◆ subtract() [2/2]

template<typename... AxisT>

EstimateStorage & YODA::EstimateStorage< AxisT >::subtract	(	EstimateStorage< AxisT > &&	est,
		const std::string &	pat_uncorr = `"^stat\|^uncor"`
	)

inline

Subtract one (rvalue) EstimateStorages from another one.

Definition at line 404 of file BinnedEstimate.h.

                                                                           {
      if (*this != est)
        throw BinningError("Arithmetic operation requires compatible binning!");
      if (AO::hasAnnotation("ScaledBy")) AO::rmAnnotation("ScaledBy");
      for (size_t i = 0; i< BaseT::numBins(true, true); ++i) {
        BaseT::bin(i) -= std::move(est.bin(i), pat_uncorr);
      }
      BaseT::maskBins(est.maskedBins(), true);
      return *this;
    }

References YODA::BinnedStorage< Estimate, AxisT... >::bin(), YODA::AnalysisObject::hasAnnotation(), YODA::BinnedStorage< Estimate, AxisT... >::maskBins(), YODA::BinnedStorage< Estimate, AxisT... >::numBins(), and YODA::AnalysisObject::rmAnnotation().

◆ vals()

template<typename... AxisT>

std::vector< double > YODA::EstimateStorage< AxisT >::vals	(	const bool	includeOverflows = `false`,
		const bool	includeMaskedBins = `false`
	)		const

inline

Get list of central values.

Definition at line 476 of file BinnedEstimate.h.

                                                                       {
      std::vector<double> rtn;
      rtn.reserve(BaseT::numBins(includeOverflows, includeMaskedBins));
      for (const auto& b : BaseT::bins(includeOverflows, includeMaskedBins)) {
        rtn.push_back(b.val());
      }
      return rtn;
    }

References YODA::BinnedStorage< Estimate, AxisT... >::bins(), and YODA::BinnedStorage< Estimate, AxisT... >::numBins().

Referenced by YODA::EstimateStorage< AxisT >::mkScatter().

◆ widths()

template<typename... AxisT>

template<size_t I, typename E = typename BinningT::template getEdgeT<I>>

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

inlinenoexcept

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

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

Note: This version is only supported for continuous axes.

Definition at line 449 of file BinnedEstimate.h.

                                                               {
      return BaseT::_binning.template widths<I>(includeOverflows);
    }

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

include/YODA/BinnedEstimate.h

Public Types

Public Member Functions

Protected Types

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ BaseT

◆ BinningT

◆ BinT

◆ BinType

Constructor & Destructor Documentation

◆ EstimateStorage() [1/10]

◆ EstimateStorage() [2/10]

◆ EstimateStorage() [3/10]

◆ EstimateStorage() [4/10]

◆ EstimateStorage() [5/10]

◆ EstimateStorage() [6/10]

◆ EstimateStorage() [7/10]

◆ EstimateStorage() [8/10]

◆ EstimateStorage() [9/10]

◆ EstimateStorage() [10/10]

Member Function Documentation

◆ add() [1/2]

◆ add() [2/2]

◆ areaUnderCurve()

◆ auc()

◆ clone()

◆ covarianceMatrix()

◆ deserializeContent()

◆ dim()

◆ edges()

◆ lengthContent()

◆ max()

◆ min()

◆ mkEstimates()

◆ mkInert()

◆ mkScatter()

◆ newclone()

◆ operator+=() [1/2]

◆ operator+=() [2/2]

◆ operator-=() [1/2]

◆ operator-=() [2/2]

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ rebin() [1/2]

◆ rebin() [2/2]

◆ rebinBy()

◆ rebinTo()

◆ reset()

◆ scale()

◆ serializeContent()

◆ sources()

◆ subtract() [1/2]

◆ subtract() [2/2]

◆ vals()

◆ widths()