GeneralStatistics.h

// -*- C++ -*-
//
// GeneralStatictis.h is a part of Herwig - A multi-purpose Monte Carlo event generator
// Copyright (C) 2002-2019 The Herwig Collaboration
//
// Herwig is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef Herwig_GeneralStatistics_H
#define Herwig_GeneralStatistics_H
//
// This is the declaration of the GeneralStatistics class.
//
 
#include "ThePEG/Persistency/PersistentOStream.h"
#include "ThePEG/Persistency/PersistentIStream.h"
 
#include "Herwig/Utilities/XML/Element.h"
 
namespace Herwig {
 
using namespace ThePEG;
 
class GeneralStatistics {
 
public:
 
  GeneralStatistics()
    : theMaxWeight(0.), theMinWeight(Constants::MaxDouble), 
      theSumWeights(0.), theSumSquaredWeights(0.), theSumAbsWeights(0.), 
      theSelectedPoints(0), theAcceptedPoints(0),
      theNanPoints(0), theAllPoints(0),
      theLastWeight(0.) {}
 
  virtual ~GeneralStatistics();
 
public:
 
  virtual double chi2() const { return 0.; }
 
  void reset() {
    *this = GeneralStatistics();
  }
 
public:
 
  double lastWeight() const { return theLastWeight; }
 
  double maxWeight() const { return theMaxWeight; }
 
  double minWeight() const { return theMinWeight; }
 
  void maxWeight(double w) { theMaxWeight = w; }
 
  void minWeight(double w) { theMinWeight = w; }
 
  double sumWeights() const { return theSumWeights; }
 
  double sumSquaredWeights() const { return theSumSquaredWeights; }
 
  double sumAbsWeights() const { return theSumAbsWeights; }
 
  unsigned long selectedPoints() const { return theSelectedPoints; }
 
  unsigned long acceptedPoints() const { return theAcceptedPoints; }
 
  unsigned long nanPoints() const { return theNanPoints; }
 
  unsigned long allPoints() const { return theAllPoints; }
 
  virtual double averageWeight() const {
    return selectedPoints() > 0 ? sumWeights()/selectedPoints() : 0.;
  }
 
  virtual double averageAbsWeight() const {
    return selectedPoints() > 0 ? sumAbsWeights()/selectedPoints() : 0.;
  }
 
  double weightVariance() const {
    return 
      selectedPoints() > 1 ? 
      abs(sumSquaredWeights() - sqr(sumWeights())/selectedPoints())/(selectedPoints()-1) : 0.;
  }
 
  double absWeightVariance() const {
    return 
      selectedPoints() > 1 ? 
      abs(sumSquaredWeights() - sqr(sumAbsWeights())/selectedPoints())/(selectedPoints()-1) : 0.;
  }
 
  virtual double averageWeightVariance() const {
    return selectedPoints() > 1 ? weightVariance()/selectedPoints() : 0.;
  }
 
  virtual double averageAbsWeightVariance() const {
    return selectedPoints() > 1 ? absWeightVariance()/selectedPoints() : 0;
  }
 
  virtual void select(double weight, bool doIntegral = true) {
    if ( ! isfinite(weight) ) {
      theLastWeight = weight;
      theNanPoints += 1;
      theAllPoints += 1;
      return;
    }
    theLastWeight = weight;
    theMaxWeight = max(theMaxWeight,abs(weight));
    theMinWeight = min(theMinWeight,abs(weight));
    if ( !doIntegral )
      return;
    theSumWeights += weight;
    theSumSquaredWeights += sqr(weight);
    theSumAbsWeights += abs(weight);
    theSelectedPoints += 1;
    theAllPoints += 1;
  }
 
  virtual void accept() {
    theAcceptedPoints += 1;
  }
 
  virtual void reject() {
    if ( ! isfinite(lastWeight()) ) {
      theNanPoints -= 1;
      theAllPoints -= 1;
      return;
    }
    theSumWeights -= lastWeight();
    theSumSquaredWeights -= sqr(lastWeight());
    theSumAbsWeights -= abs(lastWeight());
    theSelectedPoints -= 1;
    theAcceptedPoints -= 1;
    theAllPoints -= 1;
  }
 
public:
 
  void put(PersistentOStream & os) const;
 
  void get(PersistentIStream & is);
 
  void fromXML(const XML::Element&);
 
  XML::Element toXML() const;
 
private:
 
  double theMaxWeight;
 
  double theMinWeight;
 
  double theSumWeights;
 
  double theSumSquaredWeights;
 
  double theSumAbsWeights;
 
  unsigned long theSelectedPoints;
 
  unsigned long theAcceptedPoints;
 
  unsigned long theNanPoints;
 
  unsigned long theAllPoints;
 
  double theLastWeight;
 
};
 
inline PersistentOStream& operator<<(PersistentOStream& os, const GeneralStatistics& s) {
  s.put(os); return os;
}
 
inline PersistentIStream& operator>>(PersistentIStream& is, GeneralStatistics& s) {
  s.get(is); return is;
}
 
}
 
#endif /* Herwig_GeneralStatistics_H */