---

ForeverAverageCounter.cc

Go to the documentation of this file.

#include "EventFilter/StorageManager/interface/ForeverAverageCounter.h"
#include <math.h>

using namespace stor;

ForeverAverageCounter::ForeverAverageCounter():
  sampleCount_(0),
  currentTotal_(0.0),
  currentTotalSquares_(0.0),
  currentMin_(9999999999.0),
  currentMax_(-1.0)
{
}

void ForeverAverageCounter::addSample(double value)
{
  boost::recursive_mutex::scoped_lock sl(dataMutex_);

  currentTotal_ += value;
  currentTotalSquares_ += value*value;
  ++sampleCount_;
  if(value < currentMin_) currentMin_ = value;
  if(value > currentMax_) currentMax_ = value;
}

void ForeverAverageCounter::reset()
{
  boost::recursive_mutex::scoped_lock sl(dataMutex_);

  sampleCount_ = 0;
  currentTotal_ = 0.0;
  currentTotalSquares_ = 0.0;
  currentMin_ = 9999999999.0;
  currentMax_ = -1.0;
}

long long ForeverAverageCounter::getSampleCount()
{
  boost::recursive_mutex::scoped_lock sl(dataMutex_);

  return sampleCount_;
}

double ForeverAverageCounter::getValueSum() {
  boost::recursive_mutex::scoped_lock sl(dataMutex_);

  return currentTotal_;
}

double ForeverAverageCounter::getValueSumSquares() {
  boost::recursive_mutex::scoped_lock sl(dataMutex_);

  return currentTotalSquares_;
}

double ForeverAverageCounter::getValueAverage()
{
  boost::recursive_mutex::scoped_lock sl(dataMutex_);

  if (sampleCount_ > 0) {
    return ((double) currentTotal_) / ((double) sampleCount_);
  }
  else {
    return 0.0;
  }
}

double ForeverAverageCounter::getValueRMS()
{
  boost::recursive_mutex::scoped_lock sl(dataMutex_);

  if (sampleCount_ > 0) {
    double ave_squares = (currentTotalSquares_ / (double) sampleCount_);
    double ave = (currentTotal_ / (double) sampleCount_);
    double sig_squared = ave_squares - ave*ave;
    if(sig_squared > 0.0) 
       return sqrt(sig_squared);
    else
       return 0.0;
  }
  else {
    return 0.0;
  }
}

double ForeverAverageCounter::getValueMin() {
  boost::recursive_mutex::scoped_lock sl(dataMutex_);

  return currentMin_;
}

double ForeverAverageCounter::getValueMax() {
  boost::recursive_mutex::scoped_lock sl(dataMutex_);

  return currentMax_;
}

---