Counter.h

Go to the documentation of this file.

// -*- C++ -*-
//
// This file is part of YODA -- Yet more Objects for Data Analysis
// Copyright (C) 2008-2024 The YODA collaboration (see AUTHORS for details)
//
#ifndef YODA_Counter_h
#define YODA_Counter_h
 
#include "YODA/AnalysisObject.h"
#include "YODA/Fillable.h"
#include "YODA/Dbn.h"
#include "YODA/Point.h"
#include "YODA/Estimate0D.h"
#include "YODA/Scatter.h"
#include "YODA/Exceptions.h"
#include <vector>
#include <string>
#include <map>
#include <tuple>
#include <memory>
 
namespace YODA {
 
 
  class Counter : public AnalysisObject, public Fillable {
  public:
 
 
    using FillType = std::tuple<>;
    using Ptr = std::shared_ptr<Counter>;
    using AnalysisObject::operator =;
 
 
    Counter(const std::string& path="", const std::string& title="")
      : AnalysisObject("Counter", path, title) { }
 
 
    Counter(const Dbn0D& dbn,
            const std::string& path="", const std::string& title="")
            : AnalysisObject("Counter", path, title), _dbn(dbn) { }
 
 
    Counter(Dbn0D&& dbn,
            const std::string& path="", const std::string& title="")
            : AnalysisObject("Counter", path, title), _dbn(std::move(dbn)) { }
 
 
    Counter(double w,
            const std::string& path="", const std::string& title="")
            : AnalysisObject("Counter", path, title) { _dbn.fill(w); }
 
 
    Counter(const Counter& c, const std::string& path="")
            : AnalysisObject("Counter", (path.size() == 0) ? c.path() : path, c, c.title()),
              _dbn(c._dbn) { }
 
    Counter(Counter&& c, const std::string& path="")
            : AnalysisObject("Counter", (path.size() == 0) ? c.path() : path, c, c.title()),
              _dbn(std::move(c._dbn)) { }
 
 
    Counter& operator = (const Counter& c) noexcept {
      if (this != &c) {
        AnalysisObject::operator = (c);
        _dbn = c._dbn;
      }
      return *this;
    }
 
    Counter& operator = (Counter&& c) noexcept {
      if (this != &c) {
        AnalysisObject::operator = (c);
        _dbn = std::move(c._dbn);
      }
      return *this;
    }
 
    Counter clone() const {
      return Counter(*this);
    }
 
    Counter* newclone() const {
      return new Counter(*this);
    }
 
 
 
 
    // @brief Render information about this AO
    void _renderYODA(std::ostream& os, const int width = 13) const noexcept {
      os << std::setw(width) << std::left << "# sumW" << "\t"
         << std::setw(width) << std::left << "sumW2"  << "\t"
         << "numEntries\n";
      os << std::setw(width) << std::left << sumW() << "\t";
      os << std::setw(width) << std::left << sumW2() << "\t";
      os << std::setw(width) << std::left << numEntries() << "\n";
    }
 
    // @brief Render scatter-like information about this AO
    void _renderFLAT(std::ostream& os, const int width) const noexcept {
      Scatter1D tmp = this->mkScatter();
      tmp._renderYODA(os, width);
    }
 
 
 
 
    size_t dim() const noexcept { return 1; }
 
    size_t fillDim() const noexcept { return 0; }
 
 
 
 
    virtual int fill(double weight=1.0, double fraction=1.0) {
      _dbn.fill(weight, fraction);
      return 0;
    }
 
    virtual int fill(FillType&&, double weight=1.0, double fraction=1.0) {
      return fill(weight, fraction);
    }
 
    virtual void reset() {
      _dbn.reset();
    }
 
 
    void scaleW(double scalefactor) {
      setAnnotation("ScaledBy", annotation<double>("ScaledBy", 1.0) * scalefactor);
      _dbn.scaleW(scalefactor);
    }
 
 
 
 
    double numEntries(bool=false) const { return _dbn.numEntries(); }
 
    double effNumEntries(bool=false) const { return _dbn.effNumEntries(); }
 
    double sumW(bool=false) const { return _dbn.sumW(); }
 
    double sumW2(bool=false) const { return _dbn.sumW2(); }
 
    double val(bool=false) const { return sumW(); }
 
    double err() const { return sqrt(sumW2()); }
 
    // double err() const { return _dbn.err(); }
    double relErr() const {
      return sumW2() != 0 ? err()/sumW() : 0;
    }
 
 
 
 
    const Dbn0D& dbn() const {
      return _dbn;
    }
 
    void setDbn(const Dbn0D& dbn) {
      _dbn = dbn;
    }
 
    void setDbn(Dbn0D&& dbn) {
      _dbn = std::move(dbn);
    }
 
    void set(const double numEntries, const double sumW, const double sumW2) {
      _dbn.set(numEntries, sumW, sumW2);
    }
 
    // /// Set the whole object state
    // void setState(const Dbn0D& dbn, const AnalysisObject::Annotations& anns=AnalysisObject::Annotations()) {
    //   setDbn(dbn);
    //   setAnnotations(anns);
    // }
 
 
 
 
    Counter& operator += (const Counter& toAdd) {
      if (AO::hasAnnotation("ScaledBy")) AO::rmAnnotation("ScaledBy");
      _dbn += toAdd._dbn;
      return *this;
    }
    //
    Counter& operator += (Counter&& toAdd) {
      if (AO::hasAnnotation("ScaledBy")) AO::rmAnnotation("ScaledBy");
      _dbn += std::move(toAdd._dbn);
      return *this;
    }
 
    Counter& operator -= (const Counter& toSubtract) {
      if (AO::hasAnnotation("ScaledBy")) AO::rmAnnotation("ScaledBy");
      _dbn -= toSubtract._dbn;
      return *this;
    }
    //
    Counter& operator -= (Counter&& toSubtract) {
      if (AO::hasAnnotation("ScaledBy")) AO::rmAnnotation("ScaledBy");
      _dbn -= std::move(toSubtract._dbn);
      return *this;
    }
 
    Counter& operator ++ () {
      if (AO::hasAnnotation("ScaledBy")) AO::rmAnnotation("ScaledBy");
      *this += 1;
      return *this;
    }
 
    Counter& operator -- () {
      if (AO::hasAnnotation("ScaledBy")) AO::rmAnnotation("ScaledBy");
      *this -= 1;
      return *this;
    }
 
    Counter& operator *= (double s) {
      if (AO::hasAnnotation("ScaledBy")) AO::rmAnnotation("ScaledBy");
      scaleW(s);
      return *this;
    }
 
    Counter& operator /= (double s) {
      if (AO::hasAnnotation("ScaledBy")) AO::rmAnnotation("ScaledBy");
      scaleW(1/s);
      return *this;
    }
 
 
 
    inline Estimate0D mkEstimate(const std::string& path = "", const std::string& source = "") const {
      Estimate0D rtn;
      for (const std::string& a : annotations()) {
        if (a != "Type")  rtn.setAnnotation(a, annotation(a));
      }
      rtn.setAnnotation("Path", path);
 
      rtn.setVal(val());
      if (numEntries()) { // only set uncertainty for filled Dbns
        rtn.setErr(err(), source);
      }
      return rtn;
    }
 
    inline Scatter1D mkScatter(const std::string& path = "") const {
      Scatter1D rtn;
      for (const std::string& a : annotations()) {
        if (a != "Type")  rtn.setAnnotation(a, annotation(a));
      }
      rtn.setAnnotation("Path", path);
 
      rtn.addPoint(Point1D(val(), err()));
      return rtn;
    }
 
    AnalysisObject* mkInert(const std::string& path = "",
                            const std::string& source = "") const noexcept {
      return mkEstimate(path, source).newclone();
    }
 
 
 
 
    size_t lengthContent(bool = false) const noexcept {
      return _dbn._lengthContent();
    }
 
    std::vector<double> serializeContent(bool = false) const noexcept {
      return _dbn._serializeContent();
    }
 
    void deserializeContent(const std::vector<double>& data) {
      _dbn._deserializeContent(data);
    }
 
    // @}
 
  private:
 
 
    Dbn0D _dbn;
 
 
  };
 
 
 
  inline Counter operator + (Counter first, const Counter& second) {
    first += second;
    return first;
  }
 
  inline Counter operator + (Counter first, Counter&& second) {
    first += std::move(second);
    return first;
  }
 
  inline Counter operator - (Counter first, const Counter& second) {
    first -= second;
    return first;
  }
 
  inline Counter operator - (Counter first, Counter&& second) {
    first -= std::move(second);
    return first;
  }
 
  Estimate0D divide(const Counter& numer, const Counter& denom);
 
  inline Estimate0D operator / (const Counter& numer, const Counter& denom) {
    return divide(numer, denom);
  }
 
  inline Estimate0D operator / (Counter&& numer, const Counter& denom) {
    return divide(std::move(numer), denom);
  }
 
  inline Estimate0D operator / (const Counter& numer, Counter&& denom) {
    return divide(numer, std::move(denom));
  }
 
  inline Estimate0D operator / (Counter&& numer, Counter&& denom) {
    return divide(std::move(numer), std::move(denom));
  }
 
 
  Estimate0D efficiency(const Counter& accepted, const Counter& total);
 
 
 
}
 
#endif