XSecStat.h

// -*- C++ -*-
//
// XSecStat.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2007 Leif Lonnblad
//
// ThePEG is licenced under version 2 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef THEPEG_XSecStat_H
#define THEPEG_XSecStat_H
//
// This is the declaration of the XSecStat class.
//

#include "ThePEG/Config/ThePEG.h"

namespace ThePEG {

class XSecStat {

public:

  XSecStat() 
    : theMaxXSec(ZERO), theAttempts(0), theAccepted(0),
      theSumWeights(0.0), theSumWeights2(0.0) {}

  XSecStat(CrossSection xsecmax) 
    : theMaxXSec(xsecmax), theAttempts(0), theAccepted(0),
      theSumWeights(0.0), theSumWeights2(0.0) {}

  XSecStat & operator=(const XSecStat & x) {
    theMaxXSec = x.theMaxXSec;
    theAttempts = x.theAttempts;
    theAccepted = x.theAccepted;
    theSumWeights = x.theSumWeights;
    theSumWeights2 = x.theSumWeights2;
    return *this;
  }

  XSecStat & operator+=(const XSecStat & x) {
    theMaxXSec += x.theMaxXSec;
    theAttempts += x.theAttempts;
    theAccepted += x.theAccepted;
    theSumWeights += x.theSumWeights;
    theSumWeights2 += x.theSumWeights2;
    return *this;
  }

  void reset() {
    theAttempts = theAccepted = 0;
    theSumWeights = theSumWeights2 = 0.0;
  }


public:


  void accept() { ++theAccepted; }

  void select(double weight) {
    ++theAttempts;
    theSumWeights += weight;
    theSumWeights2 += sqr(weight);
  }

  void reject(double weight = 1.0) {
    theSumWeights -= weight;
    theSumWeights2 -= sqr(weight);
    --theAccepted;
  }

  CrossSection xSec() const {
    return attempts() ? maxXSec()*sumWeights()/attempts() : maxXSec();
  }


  CrossSection xSecErr() const {
    return attempts() ? maxXSec()*sqrt(sumWeights2())/attempts() : maxXSec();
  }

  CrossSection maxXSec() const { return theMaxXSec; }

  double sumWeights() const { return theSumWeights; }

  double sumWeights2() const { return theSumWeights2; }

  long attempts() const { return theAttempts; }

  long accepted() const { return theAccepted; }

  void maxXSec(CrossSection x) { theMaxXSec = x; }

public:

  void output(PersistentOStream & os) const;

  void input(PersistentIStream & is);

private:

  CrossSection theMaxXSec;

  long theAttempts;

  long theAccepted;

  double theSumWeights;

  double theSumWeights2;

};

PersistentOStream & operator<<(PersistentOStream &, const XSecStat &);

PersistentIStream & operator>>(PersistentIStream &, XSecStat &);

inline XSecStat operator+(const XSecStat & x1, const XSecStat & x2) {
  XSecStat x = x1;
  return x += x2;
}

}

#endif /* THEPEG_XSecStat_H */

---