UseRandom.h

// -*- C++ -*-
//
// UseRandom.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_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 rndbool(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 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 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 &);

};

}

#endif /* ThePEG_UseRandom_H */

---