YODA::EstimateStorage< AxisT > Class Template Reference EstimateStorage convenience class based on BinnedStorage. More...
Inheritance diagram for YODA::EstimateStorage< AxisT >:
![]()
Detailed Descriptiontemplate<typename... AxisT> class YODA::EstimateStorage< AxisT > EstimateStorage convenience class based on BinnedStorage.
Definition at line 80 of file BinnedEstimate.h. Member Typedef Documentation◆ BaseT
template<typename... AxisT>
Definition at line 85 of file BinnedEstimate.h. ◆ BinningT
template<typename... AxisT>
Definition at line 86 of file BinnedEstimate.h. ◆ BinT
template<typename... AxisT>
Definition at line 87 of file BinnedEstimate.h. ◆ BinType
template<typename... AxisT>
Definition at line 88 of file BinnedEstimate.h. Constructor & Destructor Documentation◆ EstimateStorage() [1/10]
template<typename... AxisT>
Nullary constructor for unique pointers etc. Definition at line 95 of file BinnedEstimate.h. ◆ EstimateStorage() [2/10]
template<typename... AxisT>
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>
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. ◆ EstimateStorage() [4/10]
template<typename... AxisT>
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...>>
◆ EstimateStorage() [6/10]
template<typename... AxisT>
Constructor given a binning type. Definition at line 132 of file BinnedEstimate.h. const BinningT & binning() const noexcept Returns dimension underlying binning object reference. Definition BinnedStorage.h:321 ◆ EstimateStorage() [7/10]
template<typename... AxisT>
◆ EstimateStorage() [8/10]
template<typename... AxisT>
template<typename EdgeT = double, typename = enable_if_all_CAxisT<EdgeT, AxisT...>>
◆ EstimateStorage() [9/10]
template<typename... AxisT>
Copy constructor.
Definition at line 148 of file BinnedEstimate.h. ◆ EstimateStorage() [10/10]
template<typename... AxisT>
Move constructor.
Definition at line 154 of file BinnedEstimate.h. Member Function Documentation◆ add() [1/2]
template<typename... AxisT>
Add two EstimateStorages.
Definition at line 414 of file BinnedEstimate.h. 415 {
416 if (*this != est)
417 throw BinningError("Arithmetic operation requires compatible binning!");
420 BaseT::bin(i).add(est.bin(i), pat_uncorr);
421 }
423 return *this;
424 }
void rmAnnotation(const std::string &name) Delete an annotation by name. Definition AnalysisObject.h:214 bool hasAnnotation(const std::string &name) const Check if an annotation is defined. Definition AnalysisObject.h:132 void maskBins(const std::vector< size_t > &indicesToMask, const bool status=true) noexcept Mask a range of bins. Definition BinnedStorage.h:356 size_t numBins(const bool includeOverflows=false, const bool includeMaskedBins=false) const noexcept Number of bins in the BinnedStorage. Definition BinnedStorage.h:331 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>
Add two (rvalue) EstimateStorages.
Definition at line 434 of file BinnedEstimate.h. 435 {
436 if (*this != est)
437 throw BinningError("Arithmetic operation requires compatible binning!");
440 BaseT::bin(i).add(std::move(est.bin(i)), pat_uncorr);
441 }
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>
Calculate the volume underneath the EstimateStorage.
Definition at line 575 of file BinnedEstimate.h. 577 {
578 double ret = 0.;
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. Definition BinnedStorage.h:298 References YODA::BinnedStorage< Estimate, AxisT... >::bins(). Referenced by YODA::EstimateStorage< AxisT >::auc(). ◆ auc()
template<typename... AxisT>
Convenient alias for areaUnderCurve() Definition at line 588 of file BinnedEstimate.h. 590 {
592 }
double areaUnderCurve(const bool includeBinVol=true, const bool includeOverflows=false, const bool includeMaskedBins=false) const Calculate the volume underneath the EstimateStorage. Definition BinnedEstimate.h:575 References YODA::EstimateStorage< AxisT >::areaUnderCurve(). ◆ clone()
template<typename... AxisT>
Make a copy on the stack. Definition at line 158 of file BinnedEstimate.h. 158 {
160 }
EstimateStorage(const std::string &path="", const std::string &title="") Nullary constructor for unique pointers etc. Definition BinnedEstimate.h:95 ◆ covarianceMatrix()
template<typename... AxisT>
Construct a covariance matrix from the error breakdown. Definition at line 597 of file BinnedEstimate.h. 600 {
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
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;
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;
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 }
References YODA::BinnedStorage< Estimate, AxisT... >::bins(), YODA::BinnedStorage< Estimate, AxisT... >::numBins(), YODA::EstimateStorage< AxisT >::sources(), and YODA::sqr(). ◆ deserializeContent()
template<typename... AxisT>
Content deserialisation for MPI reduce operations. Implements YODA::AnalysisObject. Definition at line 782 of file BinnedEstimate.h. 782 {
783
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>
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>>
Templated version to get edges of axis N by value. +-inf edges are included.
Definition at line 505 of file BinnedEstimate.h. 505 {
506 return BaseT::_binning.template edges<I>(includeOverflows);
507 }
◆ lengthContent()
template<typename... AxisT>
Length of serialized content vector for MPI reduce operations. Implements YODA::AnalysisObject. Definition at line 759 of file BinnedEstimate.h. 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>>
Get the highest non-overflow edge of the axis.
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>>
Get the lowest non-overflow edge of the axis.
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) >>
Split into vector of BinnedEstimates along axisN. The binning dimension of the returned objects are reduced by one unit.
Definition at line 719 of file BinnedEstimate.h. 719 {
720
721 // Need to provide a prescription for how to add the two bin contents
723 auto rtn = BaseT::template mkBinnedSlices<axisN, BinnedEstimate>(how2add, includeOverflows);
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) {
732 }
733
734 return rtn;
735 }
std::vector< std::string > annotations() const Definition AnalysisObject.h:123 const std::string & annotation(const std::string &name) const Get an annotation by name (as a string) Definition AnalysisObject.h:138 References YODA::AnalysisObject::annotation(), YODA::AnalysisObject::annotations(), and YODA::AnalysisObject::path(). ◆ mkInert()
template<typename... AxisT>
Method returns clone of the estimate with streamlined error source. Reimplemented from YODA::AnalysisObject. Definition at line 739 of file BinnedEstimate.h. 740 {
742 rtn->setPath(path);
744 if (b.numErrs() == 1) {
745 try {
746 b.renameSource("", source);
747 }
749 }
750 }
751 return rtn;
752 }
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>
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;
663 }
665
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
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;
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
699 using isContinuous = typename BinningT::template is_CAxis<I>;
700 if constexpr( !isContinuous::value ) {
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. Definition BinnedEstimate.h:544 typename std::conjunction< std::is_floating_point< EdgeT >... > all_CAxes Definition BinningUtils.h:18 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>
Make a copy on the heap. Implements YODA::AnalysisObject. Definition at line 163 of file BinnedEstimate.h. Referenced by YODA::EstimateStorage< AxisT >::mkInert(). ◆ operator+=() [1/2]
template<typename... AxisT>
Definition at line 426 of file BinnedEstimate.h. 426 {
428 }
EstimateStorage & add(const EstimateStorage &est, const std::string &pat_uncorr="^stat|^uncor") Add two EstimateStorages. Definition BinnedEstimate.h:414 References YODA::EstimateStorage< AxisT >::add(). ◆ operator+=() [2/2]
template<typename... AxisT>
Definition at line 446 of file BinnedEstimate.h. References YODA::EstimateStorage< AxisT >::add(). ◆ operator-=() [1/2]
template<typename... AxisT>
Definition at line 467 of file BinnedEstimate.h. 467 {
469 }
EstimateStorage & subtract(const EstimateStorage &est, const std::string &pat_uncorr="^stat|^uncor") Subtract one EstimateStorages from another one. Definition BinnedEstimate.h:455 References YODA::EstimateStorage< AxisT >::subtract(). ◆ operator-=() [2/2]
template<typename... AxisT>
Definition at line 484 of file BinnedEstimate.h. References YODA::EstimateStorage< AxisT >::subtract(). ◆ operator=() [1/2]
template<typename... AxisT>
Copy assignment. Definition at line 393 of file BinnedEstimate.h. 393 {
394 if (this != &est) {
395 AnalysisObject::operator = (est);
396 BaseT::operator = (est);
397 }
398 return *this;
399 }
virtual AnalysisObject & operator=(const AnalysisObject &ao) noexcept Default copy assignment operator. Definition AnalysisObject.h:66 BinnedStorage & operator=(const BinnedStorage &other) noexcept Copy assignment. Definition BinnedStorage.h:481 References YODA::AnalysisObject::operator=(), and YODA::BinnedStorage< Estimate, AxisT... >::operator=(). ◆ operator=() [2/2]
template<typename... AxisT>
Move assignment. Definition at line 402 of file BinnedEstimate.h. 402 {
403 if (this != &est) {
404 AnalysisObject::operator = (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>
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>
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>
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
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!");
338 for (size_t m = begin; m < end; ++m) {
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. Definition BinnedStorage.h:339 References YODA::BinnedStorage< Estimate, AxisT... >::numBinsAt(). ◆ rebinTo()
template<typename... AxisT>
template<size_t axisN>
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>
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(); }
References YODA::BinnedStorage< Estimate, AxisT... >::clearBins(). ◆ scale()
template<typename... AxisT>
Rescale as if all fill weights had been different by factor scalefactor. Definition at line 317 of file BinnedEstimate.h. 317 {
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) Definition AnalysisObject.h:182 References YODA::BinnedStorage< Estimate, AxisT... >::bin(), and YODA::AnalysisObject::setAnnotation(). ◆ serializeContent()
template<typename... AxisT>
Content serialisation for MPI reduce operations. Implements YODA::AnalysisObject. Definition at line 767 of file BinnedEstimate.h. 767 {
768 std::vector<double> rtn;
770 rtn.reserve(nBins * 4);
771 for (size_t i = 0; i < nBins; ++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>
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
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>
Subtract one EstimateStorages from another one.
Definition at line 455 of file BinnedEstimate.h. 456 {
457 if (*this != est)
458 throw BinningError("Arithmetic operation requires compatible binning!");
461 BaseT::bin(i).subtract(est.bin(i), pat_uncorr);
462 }
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>
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!");
478 BaseT::bin(i) -= std::move(est.bin(i), pat_uncorr);
479 }
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>
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));
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>>
Templated version to get bin widths of axis N by value. Overflows are included depending on includeOverflows Needed by axis-specific version from AxisMixin
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:
Generated on Fri Mar 7 2025 09:06:40 for YODA - Yet more Objects for Data Analysis by |