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 */