ACDCSampler.h

// -*- C++ -*-
//
// ACDCSampler.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_ACDCSampler_H
#define ThePEG_ACDCSampler_H
// This is the declaration of the ACDCSampler class.
 
#include "ThePEG/Handlers/SamplerBase.h"
#include "ThePEG/ACDC/ACDCGen.h"
#include "ThePEG/Handlers/StandardEventHandler.h"
#include "ThePEG/Repository/RandomGenerator.h"
#include "ThePEG/Repository/UseRandom.h"
#include "ThePEG/Utilities/SimplePhaseSpace.xh"
 
// #include "ACDCSampler.fh"
// #include "ACDCSampler.xh"
 
namespace ThePEG {
 
class ACDCSampler: public SamplerBase {
 
public:
 
  typedef ACDCGenerator::ACDCGen<UseRandom,tStdEHPtr> SamplerType;
 
  ACDCSampler() : theEps(100*Constants::epsilon), theMargin(1.1), theNTry(1000) {}
 
  ACDCSampler(const ACDCSampler & x)
    : SamplerBase(x), theSampler(),
      theEps(x.theEps), theMargin(x.theMargin),
      theNTry(x.theNTry) {}
 
  virtual ~ACDCSampler();
 
public:
 
  virtual void initialize();
 
  virtual double generate();
 
  virtual int lastBin() const;
 
  virtual void rejectLast();
 
  virtual CrossSection integratedXSec() const;
 
  virtual CrossSection integratedXSecErr() const;
 
  virtual double sumWeights() const;
 
  virtual double sumWeights2() const;
 
public:
 
  void persistentOutput(PersistentOStream & os) const;
 
  void persistentInput(PersistentIStream & is, int version);
 
  static void Init();
 
protected:
 
  virtual IBPtr clone() const;
 
  virtual IBPtr fullclone() const;
 
 
protected:
 
  virtual void doinitrun();
 
  virtual void dofinish();
 
private:
 
  SamplerType theSampler;
 
  double theEps;
 
  double theMargin;
 
  int theNTry;
 
protected:
 
  struct ACDCStillCompensating: public Exception {};
 
  struct EventInitNoXSec: public InitException {};
 
  struct EventLoopException: public Exception {};
private:
 
  static ClassDescription<ACDCSampler> initACDCSampler;
 
  ACDCSampler & operator=(const ACDCSampler &) = delete;
 
};
 
}
 
namespace ThePEG {
 
template <>
struct BaseClassTrait<ACDCSampler,1>: public ClassTraitsType {
  typedef SamplerBase NthBase;
};
 
template <>
struct ClassTraits<ACDCSampler>: public ClassTraitsBase<ACDCSampler> {
  static string className() { return "ThePEG::ACDCSampler"; }
  static string library() { return "ACDCSampler.so"; }
 
};
 
}
 
namespace ACDCGenerator {
 
template <>
struct ACDCFncTraits<ThePEG::tStdEHPtr>: public ACDCTraitsType {
  typedef ThePEG::tStdEHPtr tStdEHPtr;
  static inline double value(const tStdEHPtr & eh, const DVector & x) {
    using namespace ThePEG::Units;
    try {
      return eh->dSigDR(x)/nanobarn;
    }
    catch ( ThePEG::ImpossibleKinematics & v ) {
      breakThePEG();
    }
    catch ( std::exception & e ) {
      breakThePEG();
    }
    catch ( ... ) {
      breakThePEG();
    }
    return 0.0;
  }
 
};
 
template <>
struct ACDCRandomTraits<ThePEG::UseRandom>: public ACDCTraitsType {
  typedef ThePEG::UseRandom UseRandom;
 
  static inline double rnd(UseRandom *) { return UseRandom::rnd(); }
 
  static inline double rnd(UseRandom * r, double xl, double xu) {
    return xl + (xu - xl)*rnd(r);
  }
 
  template <typename InputIterator, typename OutputIterator>
  static inline void rnd(UseRandom * r,
                         InputIterator l, InputIterator lend,
                         InputIterator u, OutputIterator res) {
    for ( ; l != lend; ++l ) *res++ = *l + (*u++ - *l)*rnd(r);
  }
 
  template <typename OutputIterator>
  static inline void rnd(UseRandom * r, int D, OutputIterator res) {
    for ( int d = 0; d < D; ++d ) *res++ = rnd(r);
  }
 
  static inline bool rndBool(UseRandom, double x) {
    return UseRandom::rndbool(x);
  }
 
  static inline bool rndBool(UseRandom *, double x, double y) {
    return UseRandom::rndbool(x, y);
  }
 
  static inline long rndInt(UseRandom *, long x) {
    return UseRandom::irnd(x);
  }
 
};
 
}
 
#endif /* ThePEG_ACDCSampler_H */