yoda is hosted by Hepforge, IPPP Durham
YODA - Yet more Objects for Data Analysis 2.1.0
YODA::EstimateStorage< AxisT > Class Template Reference

EstimateStorage convenience class based on BinnedStorage. More...

#include <BinnedEstimate.h>

Inheritance diagram for YODA::EstimateStorage< AxisT >:
YODA::BinnedStorage< Estimate, AxisT... > YODA::AnalysisObject YODA::BinnedEstimate< AxisT >

Public Types

using BaseT = BinnedStorage< Estimate, AxisT... >
 
using BinningT = typename BaseT::BinningT
 
using BinT = typename BaseT::BinT
 
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.
 
EstimateStoragenewclone () 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.
 
EstimateStorageoperator= (const EstimateStorage &est) noexcept
 Copy assignment.
 
EstimateStorageoperator= (EstimateStorage &&est) noexcept
 Move assignment.
 
EstimateStorageadd (const EstimateStorage &est, const std::string &pat_uncorr="^stat|^uncor")
 Add two EstimateStorages.
 
EstimateStorageoperator+= (const EstimateStorage &est)
 
EstimateStorageadd (EstimateStorage &&est, const std::string &pat_uncorr="^stat|^uncor")
 Add two (rvalue) EstimateStorages.
 
EstimateStorageoperator+= (EstimateStorage &&est)
 
EstimateStoragesubtract (const EstimateStorage &est, const std::string &pat_uncorr="^stat|^uncor")
 Subtract one EstimateStorages from another one.
 
EstimateStorageoperator-= (const EstimateStorage &est)
 
EstimateStoragesubtract (EstimateStorage &&est, const std::string &pat_uncorr="^stat|^uncor")
 Subtract one (rvalue) EstimateStorages from another one.
 
EstimateStorageoperator-= (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.
 
AnalysisObjectmkInert (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)
 
BinTbin (size_t idx) noexcept
 Returns reference to the bin at idx.
 
const BinTbin (size_t idx) const noexcept
 Returns Bin at idx.
 
BinTbin (const std::array< size_t, sizeof...(AxisT)> &idxLocal) noexcept
 Bin access using local bin indices.
 
const BinTbin (const std::array< size_t, sizeof...(AxisT)> &idxLocal) const noexcept
 Bin access using local bin indices.
 
BinTbinAt (typename BinningT::EdgeTypesTuple &&coords) noexcept
 Returns reference to the bin at coordinates.
 
const BinTbinAt (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< BinsVecTbins (const bool includeOverflows=false, const bool includeMaskedBins=false) noexcept
 Returns bins vector wrapper, which skips masked elements when iterated over.
 
const BinsVecWrapper< const BinsVecTbins (const bool includeOverflows=false, const bool includeMaskedBins=false) const noexcept
 Const version.
 
const BinningTbinning () 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.
 
BinnedStorageoperator= (const BinnedStorage &other) noexcept
 Copy assignment.
 
BinnedStorageoperator= (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 AnalysisObjectoperator= (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
 Meta-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.
 

Additional Inherited Members

- 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... >
 
- 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 80 of file BinnedEstimate.h.

Member Typedef Documentation

◆ BaseT

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

Definition at line 85 of file BinnedEstimate.h.

◆ BinningT

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

Definition at line 86 of file BinnedEstimate.h.

◆ BinT

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

Definition at line 87 of file BinnedEstimate.h.

◆ BinType

template<typename... AxisT>
using YODA::EstimateStorage< AxisT >::BinType = BinT

Definition at line 88 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 95 of file BinnedEstimate.h.

96 : BaseT(), AnalysisObject(mkTypeString<AxisT...>(), path, title) { }
const std::string title() const
Get the AO title.
const std::string path() const
Get the AO path.
AnalysisObject()
Default constructor.
BinnedStorage< Estimate, AxisT... > BaseT

◆ 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 103 of file BinnedEstimate.h.

104 : 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 111 of file BinnedEstimate.h.

112 : 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 119 of file BinnedEstimate.h.

120 : 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 124 of file BinnedEstimate.h.

128 : BaseT( _mkBinning(nBins, limitsLowUp, std::make_index_sequence<sizeof...(AxisT)>{}) ),
129 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 132 of file BinnedEstimate.h.

133 : BaseT(binning), AnalysisObject(mkTypeString<AxisT...>(), path, title) { }
const BinningT & binning() const noexcept
Returns dimension underlying binning object reference.

◆ 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 136 of file BinnedEstimate.h.

137 : 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 141 of file BinnedEstimate.h.

142 : BaseT(_mkBinning(s, std::make_index_sequence<sizeof...(AxisT)>{})),
143 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 148 of file BinnedEstimate.h.

148 : BaseT(other),
149 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 154 of file BinnedEstimate.h.

154 : BaseT(std::move(other)),
155 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 414 of file BinnedEstimate.h.

415 {
416 if (*this != est)
417 throw BinningError("Arithmetic operation requires compatible binning!");
418 if (AO::hasAnnotation("ScaledBy")) AO::rmAnnotation("ScaledBy");
419 for (size_t i = 0; i< BaseT::numBins(true, true); ++i) {
420 BaseT::bin(i).add(est.bin(i), pat_uncorr);
421 }
422 BaseT::maskBins(est.maskedBins(), true);
423 return *this;
424 }
void rmAnnotation(const std::string &name)
Delete an annotation by name.
bool hasAnnotation(const std::string &name) const
Check if an annotation is defined.
BinT & bin(size_t idx) noexcept
Returns reference to the bin at idx.
void maskBins(const std::vector< size_t > &indicesToMask, const bool status=true) noexcept
Mask a range of bins.
size_t numBins(const bool includeOverflows=false, const bool includeMaskedBins=false) const noexcept
Number of bins in the BinnedStorage.

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 434 of file BinnedEstimate.h.

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

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 575 of file BinnedEstimate.h.

577 {
578 double ret = 0.;
579 for (const auto& b : BaseT::bins(includeOverflows, includeMaskedBins)) {
580 const double val = fabs(b.val());
581 const double vol = includeBinVol? b.dVol() : 1.0;
582 if (std::isfinite(vol)) ret += val*vol; // aggregate bin volume
583 }
584 return ret;
585 }
BinsVecWrapper< BinsVecT > bins(const bool includeOverflows=false, const bool includeMaskedBins=false) noexcept
Returns bins vector wrapper, which skips masked elements when iterated over.

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 588 of file BinnedEstimate.h.

590 {
591 return areaUnderCurve(includeBinVol, includeOverflows, includeMaskedBins);
592 }
double areaUnderCurve(const bool includeBinVol=true, const bool includeOverflows=false, const bool includeMaskedBins=false) const
Calculate the volume underneath the EstimateStorage.

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 158 of file BinnedEstimate.h.

158 {
159 return EstimateStorage(*this);
160 }
EstimateStorage(const std::string &path="", const std::string &title="")
Nullary constructor for unique pointers etc.

◆ 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 597 of file BinnedEstimate.h.

600 {
601 const size_t nBins = BaseT::numBins(includeOverflows,includeMaskedBins);
602 std::vector<std::vector<double> > covM(nBins);
603
604 // initialise cov matrix to be the right shape
605 for (size_t i = 0; i < nBins; ++i) {
606 covM[i] = std::vector<double>(nBins, 0.0);
607 }
608
609 const std::vector<std::string> error_sources = sources();
610
611 // nominal-only case, i.e. total uncertainty, labelled as empty string
612 if (error_sources.size() == 1 && error_sources[0] == "") {
613 size_t i = 0;
614 for (const auto& b : BaseT::bins(includeOverflows,includeMaskedBins)) {
615 covM[i][i] = b.hasSource("")? sqr(0.5*(b.err("").first+b.err("").second)) : 1.0;
616 ++i;
617 }
618 return covM;
619 }
620
621 // more interesting case where we actually have some uncertainty breakdown!
622 std::smatch match;
623 const std::regex re(pat_uncorr, std::regex_constants::icase);
624 for (const std::string& sname : error_sources) {
625 if (sname == "") continue;
626 std::vector<double> systErrs(nBins, 0.0);
627 size_t k = 0;
628 for (const auto& b : BaseT::bins(includeOverflows,includeMaskedBins)) {
629 if (b.hasSource(sname)) {
630 const auto& errs = b.err(sname); // dn-up pair
631 systErrs[k] = 0.5 *( fabs(errs.first)+fabs(errs.second));
632 }
633 ++k;
634 }
635 const bool skipOffDiag = (ignoreOffDiagonalTerms
636 || std::regex_search(sname, match, re));
637 for (size_t i = 0; i < nBins; ++i) {
638 for (size_t j = 0; j < nBins; ++j) {
639 if (skipOffDiag && i != j) continue;
640 covM[i][j] += systErrs[i]*systErrs[j];
641 }
642 }
643 }
644
645 return covM;
646 }
std::vector< std::string > sources() const
Get list of error sources.
NUM sqr(NUM a)
Named number-type squaring operation.
Definition MathUtils.h:216

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 782 of file BinnedEstimate.h.

782 {
783
784 const size_t nBins = BaseT::numBins(true, true);
785 const size_t minLen = 2*nBins;
786 if (data.size() < minLen)
787 throw UserError("Length of serialized data should be at least " + std::to_string(minLen)+"!");
788
789 size_t i = 0;
790 auto itr = data.cbegin();
791 const auto itrEnd = data.cend();
792 const bool fixedLen = data.size() == 2*minLen;
793 while (itr != itrEnd) {
794 // for estimates, the first element represents the central,
795 // the subsequent value represents the number of error pairs
796 const size_t nErrs = fixedLen? 1 : (*(itr + 1) + 0.5); // add 0.5 to avoid rounding issues
797 auto last = itr + 2*(nErrs+1); // last element + 1
798 BaseT::bin(i)._deserializeContent(std::vector<double>{itr, last}, fixedLen);
799 // update for next iteration
800 itr = last;
801 ++i;
802 }
803 }

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 495 of file BinnedEstimate.h.

495{ 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 505 of file BinnedEstimate.h.

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

◆ 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 759 of file BinnedEstimate.h.

759 {
760 size_t rtn = 0;
761 for (const auto& bin : BaseT::bins(true, true)) {
762 rtn += bin._lengthContent(fixed_length);
763 }
764 return rtn;
765 }

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 533 of file BinnedEstimate.h.

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

◆ 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 525 of file BinnedEstimate.h.

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

◆ 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 719 of file BinnedEstimate.h.

719 {
720
721 // Need to provide a prescription for how to add the two bin contents
722 auto how2add = [](auto& pivot, const BinType& toCopy) { pivot = toCopy; };
723 auto rtn = BaseT::template mkBinnedSlices<axisN, BinnedEstimate>(how2add, includeOverflows);
724 for (const std::string& a : annotations()) {
725 if (a == "Type") continue;
726 for (size_t i = 0; i < rtn.size(); ++i) {
727 rtn[i].setAnnotation(a, annotation(a));
728 }
729 }
730 for (size_t i = 0; i < rtn.size(); ++i) {
731 rtn[i].setAnnotation("Path", path);
732 }
733
734 return rtn;
735 }
std::vector< std::string > annotations() const
const std::string & annotation(const std::string &name) const
Get an annotation by name (as a string)

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 739 of file BinnedEstimate.h.

740 {
741 EstimateStorage* rtn = newclone();
742 rtn->setPath(path);
743 for (auto& b : rtn->bins(true, true)) {
744 if (b.numErrs() == 1) {
745 try {
746 b.renameSource("", source);
747 }
748 catch (YODA::UserError& e) { }
749 }
750 }
751 return rtn;
752 }
EstimateStorage * newclone() const noexcept
Make a copy on the heap.
Error for problems introduced outside YODA, to put it nicely.
Definition Exceptions.h:86

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 654 of file BinnedEstimate.h.

656 {
657
658 constexpr size_t N = sizeof...(AxisT);
659
660 ScatterND<N+1> rtn;
661 for (const std::string& a : annotations()) {
662 if (a != "Type") rtn.setAnnotation(a, annotation(a));
663 }
664 rtn.setAnnotation("Path", path);
665
666 const bool incOF = all_CAxes<AxisT...>::value && includeOverflows;
667 for (const auto& b : BaseT::bins(incOF, includeMaskedBins)) {
668
669 // Create the vector of coordinates
670 Utils::ndarray<double, N+1> vals;
671 // first fill bin centres, use bin index if axis non-arithmetic
672 auto indexIfDiscrete = [&vals, &b](auto I) {
673 using isContinuous = typename BinningT::template is_CAxis<I>;
674 using isArithmetic = typename BinningT::template is_Arithmetic<I>;
675 vals[I] = coordPicker<I>(b, std::integral_constant<bool, isArithmetic::value>{},
676 std::integral_constant<bool, isContinuous::value>{});
677 };
678 MetaUtils::staticFor<BinningT::Dimension::value>(indexIfDiscrete);
679 // then fill bin content
680 vals[N] = b.val();
681
682 // Create the vector of error pairs, use 0 if axis not continuous
683 Utils::ndarray<std::pair<double,double>, N+1> errs;
684 auto nullifyDiscrete = [&errs, &vals, &b](auto I) {
685 using isContinuous = typename BinningT::template is_CAxis<I>;
686 errs[I] = nullifyIfDisc<I>(b, vals[I], std::integral_constant<bool, isContinuous::value>{});
687 };
688 MetaUtils::staticFor<BinningT::Dimension::value>(nullifyDiscrete);
689 const double tot = fabs(b.totalErrPos(pat_match)); // use positive error component
690 errs[N] = { tot, tot };
691
692 // Add the PointND
693 rtn.addPoint( PointND<N+1>(vals, errs) );
694 }
695
696 // Decorate output scatter with the discrete edges
697 const BinningT& binning = BaseT::_binning;
698 auto decorateEdges = [&rtn, &binning](auto I) {
699 using isContinuous = typename BinningT::template is_CAxis<I>;
700 if constexpr( !isContinuous::value ) {
701 const auto& axis = binning.template axis<I>();
702 if (axis.numBins()) {
703 std::stringstream ss;
704 axis._renderYODA(ss);
705 rtn.setAnnotation("EdgesA" + std::to_string(I+1), ss.str());
706 }
707 }
708 };
709 MetaUtils::staticFor<BinningT::Dimension::value>(decorateEdges);
710
711 return rtn;
712 }
std::vector< double > vals(const bool includeOverflows=false, const bool includeMaskedBins=false) const
Get list of central values.
typename BaseT::BinningT BinningT
typename std::conjunction< std::is_floating_point< EdgeT >... > all_CAxes

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 163 of file BinnedEstimate.h.

163 {
164 return new EstimateStorage(*this);
165 }

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 426 of file BinnedEstimate.h.

426 {
427 return add(est);
428 }
EstimateStorage & add(const EstimateStorage &est, const std::string &pat_uncorr="^stat|^uncor")
Add two EstimateStorages.

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

◆ operator+=() [2/2]

template<typename... AxisT>
EstimateStorage & YODA::EstimateStorage< AxisT >::operator+= ( EstimateStorage< AxisT > &&  est)
inline

Definition at line 446 of file BinnedEstimate.h.

446 {
447 return add(std::move(est));
448 }

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

◆ operator-=() [1/2]

template<typename... AxisT>
EstimateStorage & YODA::EstimateStorage< AxisT >::operator-= ( const EstimateStorage< AxisT > &  est)
inline

Definition at line 467 of file BinnedEstimate.h.

467 {
468 return subtract(est);
469 }
EstimateStorage & subtract(const EstimateStorage &est, const std::string &pat_uncorr="^stat|^uncor")
Subtract one EstimateStorages from another one.

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

◆ operator-=() [2/2]

template<typename... AxisT>
EstimateStorage & YODA::EstimateStorage< AxisT >::operator-= ( EstimateStorage< AxisT > &&  est)
inline

Definition at line 484 of file BinnedEstimate.h.

484 {
485 return subtract(std::move(est));
486 }

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 393 of file BinnedEstimate.h.

393 {
394 if (this != &est) {
397 }
398 return *this;
399 }
virtual AnalysisObject & operator=(const AnalysisObject &ao) noexcept
Default copy assignment operator.
BinnedStorage & operator=(const BinnedStorage &other) noexcept
Copy assignment.

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 402 of file BinnedEstimate.h.

402 {
403 if (this != &est) {
405 BaseT::operator = (std::move(est));
406 }
407 return *this;
408 }

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 383 of file BinnedEstimate.h.

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

◆ 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 350 of file BinnedEstimate.h.

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

◆ 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 334 of file BinnedEstimate.h.

334 {
335 if (n < 1) throw UserError("Rebinning requested in groups of 0!");
336 if (!begin) throw UserError("Visible bins start with index 1!");
337 if (end > BaseT::numBinsAt(axisN)+1) end = BaseT::numBinsAt(axisN) + 1;
338 for (size_t m = begin; m < end; ++m) {
339 if (m > BaseT::numBinsAt(axisN)+1) break; // nothing to be done
340 const size_t myend = (m+n-1 < BaseT::numBinsAt(axisN)+1) ? m+n-1 : BaseT::numBinsAt(axisN);
341 if (myend > m) {
342 BaseT::template mergeBins<axisN>({m, myend});
343 end -= myend-m; //< reduce upper index by the number of removed bins
344 }
345 }
346 }
size_t numBinsAt(const size_t axisN, const bool includeOverflows=false) const noexcept
Number of bins in the BinnedStorage.

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 356 of file BinnedEstimate.h.

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

◆ 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 390 of file BinnedEstimate.h.

390{ BaseT::clearBins(); }
void clearBins() noexcept
Deletes all bins and creates empty new ones.

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 317 of file BinnedEstimate.h.

317 {
318 setAnnotation("ScaledBy", annotation<double>("ScaledBy", 1.0) * scalefactor);
319 for (auto& bin : BaseT::_bins) {
320 bin.scale(scalefactor);
321 }
322 }
void setAnnotation(const std::string &name, const T &value)
Add or set an annotation by name (templated for remaining types)

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 767 of file BinnedEstimate.h.

767 {
768 std::vector<double> rtn;
769 const size_t nBins = BaseT::numBins(true, true);
770 rtn.reserve(nBins * 4);
771 for (size_t i = 0; i < nBins; ++i) {
772 const auto& b = BaseT::bin(i);
773 std::vector<double> bdata = b._serializeContent(fixed_length);
774 rtn.insert(std::end(rtn),
775 std::make_move_iterator(std::begin(bdata)),
776 std::make_move_iterator(std::end(bdata)));
777 }
778 return rtn;
779 }

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 555 of file BinnedEstimate.h.

555 {
556 // Assemble union of error sources, as it's not guaranteed
557 // that every bin has the same error breakdown
558 std::vector<std::string> rtn;
559
560 for (const auto& b : BaseT::bins(true)) {
561 std::vector<std::string> keys = b.sources();
562 rtn.insert(std::end(rtn),
563 std::make_move_iterator(std::begin(keys)),
564 std::make_move_iterator(std::end(keys)));
565 }
566 std::sort(rtn.begin(), rtn.end());
567 rtn.erase( std::unique(rtn.begin(), rtn.end()), rtn.end() );
568
569 return rtn;
570 }

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 455 of file BinnedEstimate.h.

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

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 472 of file BinnedEstimate.h.

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

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 544 of file BinnedEstimate.h.

545 {
546 std::vector<double> rtn;
547 rtn.reserve(BaseT::numBins(includeOverflows, includeMaskedBins));
548 for (const auto& b : BaseT::bins(includeOverflows, includeMaskedBins)) {
549 rtn.push_back(b.val());
550 }
551 return rtn;
552 }

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 517 of file BinnedEstimate.h.

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

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