SamplerBase.h

// -*- C++ -*-
//
// SamplerBase.h is a part of ThePEG - Toolkit for HEP Event Generation
// Copyright (C) 1999-2019 Leif Lonnblad
//
// ThePEG is licenced under version 3 of the GPL, see COPYING for details.
// Please respect the MCnet academic guidelines, see GUIDELINES for details.
//
#ifndef ThePEG_SamplerBase_H
#define ThePEG_SamplerBase_H
// This is the declaration of the SamplerBase class.
 
#include "ThePEG/Interface/Interfaced.h"
#include "SamplerBase.fh"
#include "ThePEG/Handlers/StandardEventHandler.fh"
// #include "SamplerBase.xh"
 
namespace ThePEG {
 
class SamplerBase: public Interfaced {
 
public:
 
 
  SamplerBase()
    : Interfaced(), 
      theIntegrationList("") {}
 
  virtual ~SamplerBase();
 
public:
 
  void setEventHandler(tStdEHPtr eh) { theEventHandler = eh; }
 
  virtual void initialize() = 0;
 
  virtual void prepare() {}
 
  virtual double generate() = 0;
 
  virtual void rejectLast() = 0;
 
  const vector<double> & lastPoint() const { return theLastPoint; }
 
  virtual int lastBin() const { return 0; }
 
  virtual CrossSection integratedXSec() const = 0;
 
  virtual CrossSection integratedXSecErr() const = 0;
 
  virtual CrossSection maxXSec() const {
    if ( sumWeights2() <= 0.0 ) return ZERO;
    return integratedXSec()*attempts()/sumWeights();
  }
 
  virtual double attempts() const {
    CrossSection sigma = integratedXSec();
    CrossSection esigma = integratedXSecErr();
    double sw = sumWeights(); double sw2 = sumWeights2();
    if ( sw2 <= 0.0 ) return 0.0;
    return 
      sqr(sw)*(sqr(esigma)-sqr(sigma))/(sqr(sw)*sqr(esigma) - sw2*sqr(sigma));
  }
 
  virtual double sumWeights() const = 0;
 
  virtual double sumWeights2() const = 0;
 
  virtual bool almostUnweighted() const { return false; }
 
 
  void integrationList(const string& newIntegrationList) { theIntegrationList = newIntegrationList; }
 
  const string& integrationList() const { return theIntegrationList; }
 
  enum RunLevels {
 
    UnknownMode = 0,
    InitMode,
    ReadMode,
    BuildMode,
    IntegrationMode,
    RunMode
 
  };
 
  static int runLevel() {
    return theRunLevel();
  }
 
  static void setRunLevel(int level) {
    theRunLevel() = level;
  }
 
  static bool hasSetupFile() {
    return theHasSetupFile();
  }
 
  static void setupFileUsed(bool yes = true) {
    theHasSetupFile() = yes;
  }
 
  static long seed() {
    return theSeed();
  }
 
  static void setSeed(long s) {
    theSeed() = s;
  }
 
  static unsigned int integratePerJob() {
    return theIntegratePerJob();
  }
 
  static void setIntegratePerJob(unsigned int s) {
    theIntegratePerJob() = s;
  }
 
  static unsigned int integrationJobs() {
    return theIntegrationJobs();
  }
 
  static void setIntegrationJobs(unsigned int s) {
    theIntegrationJobs() = s;
  }
 
 
protected:
 
  vector<double> & lastPoint() { return theLastPoint; }
 
  tStdEHPtr eventHandler() const { return theEventHandler; }
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
private:
 
  tStdEHPtr theEventHandler;
 
  vector<double> theLastPoint;
 
  string theIntegrationList;
 
  static int& theRunLevel() {
    static int lvl = UnknownMode;
    return lvl;
  }
 
  static bool& theHasSetupFile() {
    static bool flag = false;
    return flag;
  }
 
  static long& theSeed() {
    static long s = 0;
    return s;
  }
 
  static unsigned int& theIntegratePerJob() {
    static unsigned int s = 0;
    return s;
  }
 
  static unsigned int& theIntegrationJobs() {
    static unsigned int s = 0;
    return s;
  }
 
private:
 
  static AbstractClassDescription<SamplerBase> initSamplerBase;
 
  SamplerBase & operator=(const SamplerBase &) = delete;
 
};
 
}
 
 
namespace ThePEG {
 
template <>
struct BaseClassTrait<SamplerBase,1>: public ClassTraitsType {
  typedef Interfaced NthBase;
};
 
template <>
struct ClassTraits<SamplerBase>: public ClassTraitsBase<SamplerBase> {
  static string className() { return "ThePEG::SamplerBase"; }
 
};
 
}
 
#endif /* ThePEG_SamplerBase_H */