UseRandom.h

// -*- C++ -*-
//
// UseRandom.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_UseRandom_H
#define ThePEG_UseRandom_H
// This is the declaration of the UseRandom class.
 
#include "ThePEG/Repository/RandomGenerator.h"
 
namespace ThePEG {
 
class UseRandom {
 
public:
 
  UseRandom() : randomPushed(false) {}
 
  UseRandom(const UseRandom &) : randomPushed(false) {}
 
  UseRandom(const RanGenPtr & r) : randomPushed(false) {
    if ( r ) {
      theRandomStack.push_back(r);
      randomPushed = true;
    }
  }
 
  ~UseRandom() { if ( randomPushed ) theRandomStack.pop_back(); }
 
public:
 
  static RandomGenerator & current() { return *theRandomStack.back(); }
 
//  static RandomEngine * currentEngine() {
//    return &(current().randomGenerator());
//  }
 
  static double rnd() { return current().rnd(); }
 
  static RandomGenerator::RndVector rndvec(int n) {
    return current().rndvec(n);
  }
 
  template <typename Unit>
  static Unit rnd(Unit xu) { return current().rnd(xu); }
 
  template <typename Unit>
  static Unit rnd(Unit xl, Unit xu) { 
    return current().rnd(xl, xu); 
  }
  
  static bool rndbool(double p = 0.5) {
    return current().rndbool(p);
  }
 
  static bool prndbool(double p = 0.5) {
    return current().rndbool(p);
  }
 
  static bool rndbool(double p1, double p2) {
    return current().rndbool(p1, p2);
  }
 
  static bool prndbool(double p1, double p2) {
    return current().rndbool(p1, p2);
  }
 
  static int rndsign(double p1, double p2, double p3) {
    return current().rndsign(p1, p2, p3);
  }
 
  static int prndsign(double p1, double p2, double p3) {
    return current().rndsign(p1, p2, p3);
  }
 
  static int rnd2(double p0, double p1) {
    return current().rnd2(p0, p1);
  }
 
  static int rnd3(double p0, double p1, double p2) {
    return current().rnd3(p0, p1, p2);
  }
 
  static int rnd4(double p0, double p1, double p2, double p3) {
    return current().rnd4(p0, p1, p2, p3);
  }
 
  static int rnd5(double p0, double p1, double p2, double p3, double p4) {
    return current().rnd5(p0, p1, p2, p3, p4);
  }
 
  static long irnd(long xu = 2) { return long(rnd() * xu); }
 
  static long irnd(long xl, long xu) { return xl + irnd(xu-xl); }
  
  static double rndExp() { return current().rndExp(); }
 
  template <typename Unit>
  static Unit rndExp(Unit mean) { return current().rndExp(mean); }
 
  static double rndGauss() { return current().rndGauss(); }
 
  template <typename Unit>
  static Unit rndGauss(Unit sigma, Unit mean = Unit()) {
    return current().rndGauss(sigma, mean);
  }
 
  template <typename Unit>
  static Unit rndBW(Unit mean, Unit gamma) {
    return current().rndBW(mean, gamma);
  }
 
  template <typename Unit>
  static Unit rndBW(Unit mean, Unit gamma, Unit cut) {
    return current().rndBW(mean, gamma, cut);
  }
 
  template <typename Unit>
  static Unit rndRelBW(Unit mean, Unit gamma) {
    return current().rndRelBW(mean, gamma);
  }
 
  template <typename Unit>
  static Unit rndRelBW(Unit mean, Unit gamma, Unit cut) {
    return current().rndRelBW(mean, gamma, cut);
  }
 
  static long rndPoisson(double mean) {
    return current().rndPoisson(mean);
  }
 
private:
 
  static vector<RanGenPtr> theRandomStack;
 
  bool randomPushed;
 
private:
 
  UseRandom & operator=(const UseRandom &) = delete;
 
};
 
}
 
#endif /* ThePEG_UseRandom_H */