CLHEP::RanluxppEngine Class Reference

#include <RanluxppEngine.h>

Inheritance diagram for CLHEP::RanluxppEngine:

Public Member Functions
	RanluxppEngine ()
	RanluxppEngine (long seed)
	RanluxppEngine (std::istream &is)
virtual	~RanluxppEngine ()
double	flat () override
void	flatArray (const int size, double *vect) override
void	setSeed (long seed, int dummy=0) override
void	setSeeds (const long *seeds, int dummy=0) override
void	skip (uint64_t n)
void	saveStatus (const char filename[]="Ranluxpp.conf") const override
void	restoreStatus (const char filename[]="Ranluxpp.conf") override
void	showStatus () const override
std::string	name () const override
std::ostream &	put (std::ostream &os) const override
std::istream &	get (std::istream &is) override
std::istream &	getState (std::istream &is) override
std::vector< unsigned long >	put () const override
bool	get (const std::vector< unsigned long > &v) override
bool	getState (const std::vector< unsigned long > &v) override
	operator double () override
	operator float () override
	operator unsigned int () override
Public Member Functions inherited from CLHEP::HepRandomEngine
	HepRandomEngine ()
virtual	~HepRandomEngine ()
bool	operator== (const HepRandomEngine &engine)
bool	operator!= (const HepRandomEngine &engine)
long	getSeed () const
const long *	getSeeds () const

Static Public Member Functions
static std::string	engineName ()
static std::string	beginTag ()
Static Public Member Functions inherited from CLHEP::HepRandomEngine
static std::string	beginTag ()
static HepRandomEngine *	newEngine (std::istream &is)
static HepRandomEngine *	newEngine (const std::vector< unsigned long > &v)

Static Public Attributes
static const unsigned int	VECTOR_STATE_SIZE = 21

Additional Inherited Members
Static Protected Member Functions inherited from CLHEP::HepRandomEngine
static double	exponent_bit_32 ()
static double	mantissa_bit_12 ()
static double	mantissa_bit_24 ()
static double	mantissa_bit_32 ()
static double	twoToMinus_32 ()
static double	twoToMinus_48 ()
static double	twoToMinus_49 ()
static double	twoToMinus_53 ()
static double	nearlyTwoToMinus_54 ()
static bool	checkFile (std::istream &file, const std::string &filename, const std::string &classname, const std::string &methodname)
Protected Attributes inherited from CLHEP::HepRandomEngine
long	theSeed
const long *	theSeeds

Detailed Description

Author

Jonas Hahnfeld

Definition at line 35 of file RanluxppEngine.h.

Constructor & Destructor Documentation

RanluxppEngine() [1/3]

CLHEP::RanluxppEngine::RanluxppEngine

(

)

Definition at line 64 of file RanluxppEngine.cc.

                               : HepRandomEngine() {
  int numEngines = ++numberOfEngines;
  setSeed(numEngines);
}

RanluxppEngine() [2/3]

CLHEP::RanluxppEngine::RanluxppEngine

(

long

seed

)

Definition at line 69 of file RanluxppEngine.cc.

                                        : HepRandomEngine() {
  theSeed = seed;
  setSeed(seed);
}

RanluxppEngine() [3/3]

CLHEP::RanluxppEngine::RanluxppEngine

(

std::istream &

is

)

Definition at line 74 of file RanluxppEngine.cc.

                                             : HepRandomEngine() {
  get(is);
}

~RanluxppEngine()

CLHEP::RanluxppEngine::~RanluxppEngine ( )

virtualdefault

Member Function Documentation

beginTag()

std::string CLHEP::RanluxppEngine::beginTag ( )

static

Definition at line 224 of file RanluxppEngine.cc.

{ return "RanluxppEngine-begin"; }

Referenced by get(), and put().

engineName()

std::string CLHEP::RanluxppEngine::engineName ( )

static

Definition at line 222 of file RanluxppEngine.cc.

{ return "RanluxppEngine"; }

Referenced by name().

flat()

double CLHEP::RanluxppEngine::flat ( )

overridevirtual

Implements CLHEP::HepRandomEngine.

Definition at line 112 of file RanluxppEngine.cc.

                            {
  // RandomEngine wants a "double random values ranging between ]0,1[", so
  // exclude all zero bits.
  uint64_t random;
  do {
    random = nextRandomBits();
  } while (random == 0);
 
  static constexpr double div = 1.0 / (uint64_t(1) << kBits);
  return random * div;
}

Referenced by flatArray(), operator double(), and operator float().

flatArray()

void CLHEP::RanluxppEngine::flatArray ( const int size, double * vect )

overridevirtual

Implements CLHEP::HepRandomEngine.

Definition at line 124 of file RanluxppEngine.cc.

                                                           {
  for (int i = 0; i < size; i++) {
    vect[i] = flat();
  }
}

get() [1/2]

bool CLHEP::RanluxppEngine::get ( const std::vector< unsigned long > & v )

overridevirtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 278 of file RanluxppEngine.cc.

                                                          {
  if (v[0] != engineIDulong<RanluxppEngine>()) {
    std::cerr << "RanluxppEngine::get(): "
              << "vector has wrong ID word - state unchanged" << std::endl;
    return false;
  }
  return getState(v);
}

get() [2/2]

std::istream & CLHEP::RanluxppEngine::get ( std::istream & is )

overridevirtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 235 of file RanluxppEngine.cc.

                                              {
  std::string tag;
  is >> tag;
  if (tag != beginTag()) {
    is.clear(std::ios::badbit | is.rdstate());
    std::cerr << "No RanluxppEngine found at current position\n";
    return is;
  }
  return getState(is);
}

Referenced by RanluxppEngine(), and restoreStatus().

getState() [1/2]

bool CLHEP::RanluxppEngine::getState ( const std::vector< unsigned long > & v )

overridevirtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 287 of file RanluxppEngine.cc.

                                                               {
  if (v.size() != VECTOR_STATE_SIZE) {
    std::cerr << "RanluxppEngine::getState(): "
              << "vector has wrong length - state unchanged" << std::endl;
    return false;
  }
 
  // Assemble the state vector (see RanluxppEngine::put).
  for (int i = 0; i < 9; i++) {
    uint64_t lower = v[2 * i + 1];
    uint64_t upper = v[2 * i + 2];
    fState[i] = (upper << 32) + lower;
  }
  fCarry = (unsigned int)v[19];
  fPosition = (int)v[20];
 
  return true;
}

getState() [2/2]

std::istream & CLHEP::RanluxppEngine::getState ( std::istream & is )

overridevirtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 246 of file RanluxppEngine.cc.

                                                   {
  std::vector<unsigned long> state;
  state.reserve(VECTOR_STATE_SIZE);
  for (unsigned int i = 0; i < VECTOR_STATE_SIZE; i++) {
    unsigned long v;
    is >> v;
    state.push_back(v);
  }
 
  getState(state);
  return is;
}

Referenced by get(), get(), and getState().

name()

std::string CLHEP::RanluxppEngine::name ( ) const

overridevirtual

Implements CLHEP::HepRandomEngine.

Definition at line 220 of file RanluxppEngine.cc.

{ return engineName(); }

operator double()

CLHEP::RanluxppEngine::operator double ( )

inlineoverridevirtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 86 of file RanluxppEngine.h.

{ return flat(); }

operator float()

CLHEP::RanluxppEngine::operator float ( )

inlineoverridevirtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 87 of file RanluxppEngine.h.

{ return float(flat()); }

operator unsigned int()

CLHEP::RanluxppEngine::operator unsigned int ( )

inlineoverridevirtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 88 of file RanluxppEngine.h.

{ return (unsigned int)nextRandomBits(); }

put() [1/2]

std::vector< unsigned long > CLHEP::RanluxppEngine::put ( ) const

overridevirtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 259 of file RanluxppEngine.cc.

                                                   {
  std::vector<unsigned long> v;
  v.reserve(VECTOR_STATE_SIZE);
  v.push_back(engineIDulong<RanluxppEngine>());
 
  // unsigned long is only guaranteed to be 32 bit wide, so chop up the 64 bit
  // values in fState.
  for (int i = 0; i < 9; i++) {
    unsigned long lower = static_cast<uint32_t>(fState[i]);
    v.push_back(lower);
    unsigned long upper = static_cast<uint32_t>(fState[i] >> 32);
    v.push_back(upper);
  }
 
  v.push_back(fCarry);
  v.push_back(fPosition);
  return v;
}

Referenced by put(), and saveStatus().

put() [2/2]

std::ostream & CLHEP::RanluxppEngine::put ( std::ostream & os ) const

overridevirtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 226 of file RanluxppEngine.cc.

                                                    {
  os << beginTag() << "\n";
  const std::vector<unsigned long> state = put();
  for (unsigned long v : state) {
    os << v << "\n";
  }
  return os;
}

restoreStatus()

void CLHEP::RanluxppEngine::restoreStatus ( const char filename[] = "Ranluxpp.conf" )

overridevirtual

Implements CLHEP::HepRandomEngine.

Definition at line 191 of file RanluxppEngine.cc.

                                                        {
  std::ifstream is(filename);
  get(is);
  is.close();
}

saveStatus()

void CLHEP::RanluxppEngine::saveStatus ( const char filename[] = "Ranluxpp.conf" ) const

overridevirtual

Implements CLHEP::HepRandomEngine.

Definition at line 185 of file RanluxppEngine.cc.

                                                           {
  std::ofstream os(filename);
  put(os);
  os.close();
}

setSeed()

void CLHEP::RanluxppEngine::setSeed ( long seed, int dummy = 0 )

overridevirtual

Implements CLHEP::HepRandomEngine.

Definition at line 130 of file RanluxppEngine.cc.

                                           {
  theSeed = seed;
 
  uint64_t lcg[9];
  lcg[0] = 1;
  for (int i = 1; i < 9; i++) {
    lcg[i] = 0;
  }
 
  uint64_t a_seed[9];
  // Skip 2 ** 96 states.
  powermod(kA_2048, a_seed, uint64_t(1) << 48);
  powermod(a_seed, a_seed, uint64_t(1) << 48);
  // Skip more states according to seed.
  powermod(a_seed, a_seed, seed);
  mulmod(a_seed, lcg);
 
  to_ranlux(lcg, fState, fCarry);
  fPosition = 0;
}

Referenced by RanluxppEngine(), RanluxppEngine(), and setSeeds().

setSeeds()

void CLHEP::RanluxppEngine::setSeeds ( const long * seeds, int dummy = 0 )

overridevirtual

Implements CLHEP::HepRandomEngine.

Definition at line 151 of file RanluxppEngine.cc.

                                                    {
  theSeeds = seeds;
  setSeed(*seeds, 0);
}

showStatus()

void CLHEP::RanluxppEngine::showStatus ( ) const

overridevirtual

Implements CLHEP::HepRandomEngine.

Definition at line 197 of file RanluxppEngine.cc.

                                      {
  std::cout
      << "--------------------- RanluxppEngine status --------------------"
      << std::endl;
  std::cout << " fState[] = {";
  std::cout << std::hex << std::setfill('0');
  for (int i = 0; i < 9; i++) {
    if (i % 3 == 0) {
      std::cout << std::endl << "     ";
    } else {
      std::cout << " ";
    }
    std::cout << "0x" << std::setw(16) << fState[i] << ",";
  }
  std::cout << std::endl << " }" << std::endl;
  std::cout << std::dec;
  std::cout << " fCarry = " << fCarry << ", fPosition = " << fPosition
            << std::endl;
  std::cout
      << "----------------------------------------------------------------"
      << std::endl;
}

skip()

void CLHEP::RanluxppEngine::skip

(

uint64_t

n

)

Definition at line 156 of file RanluxppEngine.cc.

                                    {
  int left = (kMaxPos - fPosition) / kBits;
  assert(left >= 0 && "position was out of range!");
  if (n < (uint64_t)left) {
    // Just skip the next few entries in the currently available bits.
    fPosition += n * kBits;
    return;
  }
 
  n -= left;
  // Need to advance and possibly skip over blocks.
  int nPerState = kMaxPos / kBits;
  int skip = int(n / nPerState);
 
  uint64_t a_skip[9];
  powermod(kA_2048, a_skip, skip + 1);
 
  uint64_t lcg[9];
  to_lcg(fState, fCarry, lcg);
  mulmod(a_skip, lcg);
  to_ranlux(lcg, fState, fCarry);
 
  // Potentially skip numbers in the freshly generated block.
  int remaining = int(n - skip * nPerState);
  assert(remaining >= 0 && "should not end up at a negative position!");
  fPosition = remaining * kBits;
  assert(fPosition <= kMaxPos && "position out of range!");
}

Referenced by skip().

Member Data Documentation

VECTOR_STATE_SIZE

const unsigned int CLHEP::RanluxppEngine::VECTOR_STATE_SIZE = 21

static

Definition at line 92 of file RanluxppEngine.h.

Referenced by getState(), getState(), and put().

---

The documentation for this class was generated from the following files:

• RanluxppEngine.h
• RanluxppEngine.cc