CLHEP::Ranlux64Engine Class Reference

#include <Ranlux64Engine.h>

Inheritance diagram for CLHEP::Ranlux64Engine:

Public Member Functions
double	flat ()
void	flatArray (const int size, double *vect)
bool	get (const std::vector< unsigned long > &v)
virtual std::istream &	get (std::istream &is)
int	getLuxury () const
long	getSeed () const
const long *	getSeeds () const
bool	getState (const std::vector< unsigned long > &v)
virtual std::istream &	getState (std::istream &is)
std::string	name () const
virtual	operator double ()
virtual	operator float ()
virtual	operator unsigned int ()
bool	operator!= (const HepRandomEngine &engine)
bool	operator== (const HepRandomEngine &engine)
std::vector< unsigned long >	put () const
virtual std::ostream &	put (std::ostream &os) const
	Ranlux64Engine ()
	Ranlux64Engine (int rowIndex, int colIndex, int lxr)
	Ranlux64Engine (long seed, int lxr=1)
	Ranlux64Engine (std::istream &is)
void	restoreStatus (const char filename[]="Ranlux64.conf")
void	saveStatus (const char filename[]="Ranlux64.conf") const
void	setSeed (long seed, int lxr=1)
void	setSeeds (const long *seeds, int lxr=1)
void	showStatus () const
virtual	~Ranlux64Engine ()

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

Static Public Attributes
static const unsigned int	VECTOR_STATE_SIZE = 30

Static Protected Member Functions
static bool	checkFile (std::istream &file, const std::string &filename, const std::string &classname, const std::string &methodname)
static double	exponent_bit_32 ()
static double	mantissa_bit_12 ()
static double	mantissa_bit_24 ()
static double	mantissa_bit_32 ()
static double	nearlyTwoToMinus_54 ()
static double	twoToMinus_32 ()
static double	twoToMinus_48 ()
static double	twoToMinus_49 ()
static double	twoToMinus_53 ()

Protected Attributes
long	theSeed
const long *	theSeeds

Private Member Functions
void	advance (int dozens)
void	update ()

Private Attributes
double	carry
int	endIters
int	index
int	luxury
int	pDiscard
int	pDozens
double	randoms [12]

Detailed Description

Author

Definition at line 48 of file Ranlux64Engine.h.

Constructor & Destructor Documentation

Ranlux64Engine() [1/4]

CLHEP::Ranlux64Engine::Ranlux64Engine

(

std::istream &

is

)

Definition at line 151 of file Ranlux64Engine.cc.

: HepRandomEngine()
{
  is >> *this;
}

Ranlux64Engine() [2/4]

CLHEP::Ranlux64Engine::Ranlux64Engine

(

)

Definition at line 107 of file Ranlux64Engine.cc.

: HepRandomEngine()
{
   luxury = 1;
   int numEngines = numberOfEngines++;
   int cycle    = std::abs(int(numEngines/maxIndex));
   int curIndex = std::abs(int(numEngines%maxIndex));
 
   long mask = ((cycle & 0x007fffff) << 8);
   long seedlist[2];
   HepRandom::getTheTableSeeds( seedlist, curIndex );
   seedlist[0] ^= mask;
   seedlist[1] = 0;
 
   setSeeds(seedlist, luxury);
   advance ( 8 );       // Discard some iterations and ensure that
                // this sequence won't match one where seeds 
                // were provided.
}

References advance(), geant4_check_module_cycles::cycle, CLHEP::HepRandom::getTheTableSeeds(), luxury, CLHEP::anonymous_namespace{Ranlux64Engine.cc}::maxIndex, CLHEP::anonymous_namespace{Ranlux64Engine.cc}::numberOfEngines(), and setSeeds().

Ranlux64Engine() [3/4]

CLHEP::Ranlux64Engine::Ranlux64Engine	(	long	seed,
		int	lxr = 1
	)

Definition at line 127 of file Ranlux64Engine.cc.

: HepRandomEngine()
{
   luxury = lux;
   long seedlist[2]={seed,0};
   setSeeds(seedlist, lux);
   advance ( 2*lux + 1 );   // Discard some iterations to use a different 
                // point in the sequence.  
}

References advance(), CLHEP::lux, luxury, and setSeeds().

Ranlux64Engine() [4/4]

CLHEP::Ranlux64Engine::Ranlux64Engine	(	int	rowIndex,
		int	colIndex,
		int	lxr
	)

Definition at line 137 of file Ranlux64Engine.cc.

: HepRandomEngine()
{
   luxury = lux;
   int cycle = std::abs(int(rowIndex/maxIndex));
   int   row = std::abs(int(rowIndex%maxIndex));
   long mask = (( cycle & 0x000007ff ) << 20 );
   long seedlist[2]; 
   HepRandom::getTheTableSeeds( seedlist, row );
   seedlist[0] ^= mask;
   seedlist[1]= 0;
   setSeeds(seedlist, lux);
}

References geant4_check_module_cycles::cycle, CLHEP::HepRandom::getTheTableSeeds(), CLHEP::lux, luxury, CLHEP::anonymous_namespace{Ranlux64Engine.cc}::maxIndex, and setSeeds().

~Ranlux64Engine()

CLHEP::Ranlux64Engine::~Ranlux64Engine ( )

virtual

Definition at line 157 of file Ranlux64Engine.cc.

{}

Member Function Documentation

advance()

void CLHEP::Ranlux64Engine::advance ( int  dozens )

private

Definition at line 259 of file Ranlux64Engine.cc.

                                       {
 
  double  y1, y2, y3;
  double  cValue = twoToMinus_48();
  double  zero = 0.0;
  double  one  = 1.0;
 
        // Technical note:  We use Luscher's trick to only do the
        // carry subtraction when we really have to.  Like him, we use 
        // three registers instead of two so that we avoid sequences
        // like storing y1 then immediately replacing its value:
        // some architectures lose time when this is done.
 
        // Luscher's ranlxd.c fills the stash going
        // upward.  We fill it downward to save a bit of time in the
        // flat() routine at no cost later.  This means that while
        // Luscher's ir is jr+5, our n-r is (n-s)-5.  (Note that
        // though ranlxd.c initializes ir and jr to 11 and 7, ir as
        // used is 5 more than jr because update is entered after 
        // incrementing ir.)  
        //
 
        // I have CAREFULLY checked that the algorithms do match
        // in all details.
 
  int k;
  for ( k = dozens; k > 0; --k ) {
 
    y1 = randoms[ 4] - randoms[11] - carry;
 
    y2 = randoms[ 3] - randoms[10];
    if ( y1 < zero ) {
      y1 += one;            
      y2 -= cValue;
    }
    randoms[11] = y1;
 
    y3 = randoms[ 2] - randoms[ 9];
    if ( y2 < zero ) {
      y2 += one;            
      y3 -= cValue;
    }
    randoms[10] = y2;
 
    y1 = randoms[ 1] - randoms[ 8];
    if ( y3 < zero ) {
      y3 += one;            
      y1 -= cValue;
    }
    randoms[ 9] = y3;
 
    y2 = randoms[ 0] - randoms[ 7];
    if ( y1 < zero ) {
      y1 += one;            
      y2 -= cValue;
    }
    randoms[ 8] = y1;
 
    y3 = randoms[11] - randoms[ 6];
    if ( y2 < zero ) {
      y2 += one;            
      y3 -= cValue;
    }
    randoms[ 7] = y2;
 
    y1 = randoms[10] - randoms[ 5];
    if ( y3 < zero ) {
      y3 += one;            
      y1 -= cValue;
    }
    randoms[ 6] = y3;
 
    y2 = randoms[ 9] - randoms[ 4];
    if ( y1 < zero ) {
      y1 += one;            
      y2 -= cValue;
    }
    randoms[ 5] = y1;
 
    y3 = randoms[ 8] - randoms[ 3];
    if ( y2 < zero ) {
      y2 += one;            
      y3 -= cValue;
    }
    randoms[ 4] = y2;
 
    y1 = randoms[ 7] - randoms[ 2];
    if ( y3 < zero ) {
      y3 += one;            
      y1 -= cValue;
    }
    randoms[ 3] = y3;
 
    y2 = randoms[ 6] - randoms[ 1];
    if ( y1 < zero ) {
      y1 += one;            
      y2 -= cValue;
    }
    randoms[ 2] = y1;
 
    y3 = randoms[ 5] - randoms[ 0];
    if ( y2 < zero ) {
      y2 += one;            
      y3 -= cValue;
    }
    randoms[ 1] = y2;
 
    if ( y3 < zero ) {
      y3 += one;            
      carry = cValue;
    }
    randoms[ 0] = y3; 
 
  } // End of major k loop doing 12 numbers at each cycle
 
} // advance(dozens)

References carry, randoms, CLHEP::HepRandomEngine::twoToMinus_48(), and anonymous_namespace{G4CascadeDeexciteBase.cc}::zero.

Referenced by Ranlux64Engine(), and update().

beginTag()

std::string CLHEP::Ranlux64Engine::beginTag ( )

static

Definition at line 642 of file Ranlux64Engine.cc.

                                      { 
  return "Ranlux64Engine-begin"; 
}

checkFile()

bool CLHEP::HepRandomEngine::checkFile ( std::istream &  file, const std::string &  filename, const std::string &  classname, const std::string &  methodname  )

staticprotectedinherited

Definition at line 47 of file RandomEngine.cc.

                                           {
  if (!file) {
    std::cerr << "Failure to find or open file " << filename <<
    " in " << classname << "::" << methodname << "()\n";
    return false;
  }  
  return true;
}                

References geant4_check_module_cycles::file.

Referenced by CLHEP::DualRand::restoreStatus(), CLHEP::HepJamesRandom::restoreStatus(), CLHEP::MTwistEngine::restoreStatus(), CLHEP::RanecuEngine::restoreStatus(), CLHEP::RanluxEngine::restoreStatus(), restoreStatus(), and CLHEP::RanshiEngine::restoreStatus().

engineName()

static std::string CLHEP::Ranlux64Engine::engineName ( )

inlinestatic

Definition at line 91 of file Ranlux64Engine.h.

{return "Ranlux64Engine";}

Referenced by restoreStatus().

exponent_bit_32()

static double CLHEP::HepRandomEngine::exponent_bit_32 ( )

inlinestaticprotectedinherited

flat()

double CLHEP::Ranlux64Engine::flat ( )

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 159 of file Ranlux64Engine.cc.

                            {
  // Luscher improves the speed by computing several numbers in a shot,
  // in a manner similar to that of the Tausworth in DualRand or the Hurd
  // engines.  Thus, the real work is done in update().  Here we merely ensure
  // that zero, which the algorithm can produce, is never returned by flat().
 
  if (index <= 0) update();
  return randoms[--index] + twoToMinus_49();
}

References index, randoms, CLHEP::HepRandomEngine::twoToMinus_49(), and update().

Referenced by flatArray().

flatArray()

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

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 376 of file Ranlux64Engine.cc.

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

References flat().

get() [1/2]

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 688 of file Ranlux64Engine.cc.

                                                            {
  if ((v[0] & 0xffffffffUL) != engineIDulong<Ranlux64Engine>()) {
    std::cerr << 
        "\nRanlux64Engine get:state vector has wrong ID word - state unchanged\n";
    return false;
  }
  return getState(v);
}

References getState().

get() [2/2]

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 624 of file Ranlux64Engine.cc.

{
  char beginMarker [MarkerLen];
  is >> std::ws;
  is.width(MarkerLen);  // causes the next read to the char* to be <=
            // that many bytes, INCLUDING A TERMINATION \0 
            // (Stroustrup, section 21.3.2)
  is >> beginMarker;
  if (strcmp(beginMarker,"Ranlux64Engine-begin")) {
     is.clear(std::ios::badbit | is.rdstate());
     std::cerr << "\nInput stream mispositioned or"
           << "\nRanlux64Engine state description missing or"
           << "\nwrong engine type found." << std::endl;
     return is;
  }
  return getState(is);
}

References getState(), and CLHEP::MarkerLen.

getLuxury()

int CLHEP::Ranlux64Engine::getLuxury ( ) const

inline

Definition at line 82 of file Ranlux64Engine.h.

{ return luxury; }

References luxury.

Referenced by G4WorkerRunManager::G4WorkerRunManager(), and G4UserWorkerThreadInitialization::SetupRNGEngine().

getSeed()

long CLHEP::HepRandomEngine::getSeed ( ) const

inlineinherited

Definition at line 112 of file RandomEngine.h.

{ return theSeed; }

References CLHEP::HepRandomEngine::theSeed.

getSeeds()

const long * CLHEP::HepRandomEngine::getSeeds ( ) const

inlineinherited

Definition at line 115 of file RandomEngine.h.

{ return theSeeds; }

References CLHEP::HepRandomEngine::theSeeds.

getState() [1/2]

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 697 of file Ranlux64Engine.cc.

                                                                 {
  if (v.size() != VECTOR_STATE_SIZE ) {
    std::cerr << 
        "\nRanlux64Engine get:state vector has wrong length - state unchanged\n";
    return false;
  }
  std::vector<unsigned long> t(2);
  for (int i=0; i<12; ++i) {
    t[0] = v[2*i+1]; t[1] = v[2*i+2];
    randoms[i] = DoubConv::longs2double(t);
  }
  t[0] = v[25]; t[1] = v[26];
  carry    = DoubConv::longs2double(t);
  index    = v[27];
  luxury   = v[28];
  pDiscard = v[29]; 
  return true;
}

References carry, index, CLHEP::DoubConv::longs2double(), luxury, pDiscard, randoms, and VECTOR_STATE_SIZE.

getState() [2/2]

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 646 of file Ranlux64Engine.cc.

{
  if ( possibleKeywordInput ( is, "Uvec", theSeed ) ) {
    std::vector<unsigned long> v;
    unsigned long uu;
    for (unsigned int ivec=0; ivec < VECTOR_STATE_SIZE; ++ivec) {
      is >> uu;
      if (!is) {
        is.clear(std::ios::badbit | is.rdstate());
        std::cerr << "\nRanlux64Engine state (vector) description improper."
        << "\ngetState() has failed."
           << "\nInput stream is probably mispositioned now." << std::endl;
        return is;
      }
      v.push_back(uu);
    }
    getState(v);
    return (is);
  }
 
//  is >> theSeed;  Removed, encompassed by possibleKeywordInput()
 
  char endMarker   [MarkerLen];
  for (int i=0; i<12; ++i) {
     is >> randoms[i];
  }
  is >> carry; is >> index;
  is >> luxury; is >> pDiscard;
  pDozens  = pDiscard / 12;
  endIters = pDiscard % 12;
  is >> std::ws;
  is.width(MarkerLen);  
  is >> endMarker;
  if (strcmp(endMarker,"Ranlux64Engine-end")) {
     is.clear(std::ios::badbit | is.rdstate());
     std::cerr << "\nRanlux64Engine state description incomplete."
           << "\nInput stream is probably mispositioned now." << std::endl;
     return is;
  }
  return is;
}

References carry, endIters, getState(), index, luxury, CLHEP::MarkerLen, pDiscard, pDozens, CLHEP::possibleKeywordInput(), randoms, CLHEP::HepRandomEngine::theSeed, and VECTOR_STATE_SIZE.

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

mantissa_bit_12()

static double CLHEP::HepRandomEngine::mantissa_bit_12 ( )

inlinestaticprotectedinherited

Referenced by CLHEP::RanluxEngine::flat(), and CLHEP::RanluxEngine::flatArray().

mantissa_bit_24()

static double CLHEP::HepRandomEngine::mantissa_bit_24 ( )

inlinestaticprotectedinherited

Referenced by CLHEP::RanluxEngine::flat(), CLHEP::RanluxEngine::flatArray(), CLHEP::RanluxEngine::getState(), CLHEP::RanluxEngine::put(), CLHEP::RanluxEngine::setSeed(), and CLHEP::RanluxEngine::setSeeds().

mantissa_bit_32()

static double CLHEP::HepRandomEngine::mantissa_bit_32 ( )

inlinestaticprotectedinherited

name()

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

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 105 of file Ranlux64Engine.cc.

{return "Ranlux64Engine";}

Referenced by source.g4viscp.G4Scene::create_scene(), mcscore.MCParticle::printout(), and source.g4viscp.G4Scene::update_scene().

nearlyTwoToMinus_54()

static double CLHEP::HepRandomEngine::nearlyTwoToMinus_54 ( )

inlinestaticprotectedinherited

Referenced by CLHEP::DualRand::flat(), CLHEP::MTwistEngine::flat(), and CLHEP::RanshiEngine::flat().

newEngine() [1/2]

HepRandomEngine * CLHEP::HepRandomEngine::newEngine ( const std::vector< unsigned long > &  v )

staticinherited

Definition at line 96 of file RandomEngine.cc.

                                                             {
  return EngineFactory::newEngine(v);
}

References CLHEP::EngineFactory::newEngine().

newEngine() [2/2]

HepRandomEngine * CLHEP::HepRandomEngine::newEngine ( std::istream &  is )

staticinherited

Definition at line 91 of file RandomEngine.cc.

                                                          {
  return EngineFactory::newEngine(is);
}

References CLHEP::EngineFactory::newEngine().

Referenced by CLHEP::StaticRandomStates::restore().

operator double()

CLHEP::HepRandomEngine::operator double ( )

virtualinherited

Reimplemented in CLHEP::DualRand, CLHEP::HepJamesRandom, CLHEP::MixMaxRng, CLHEP::MTwistEngine, CLHEP::RanecuEngine, CLHEP::RanluxEngine, CLHEP::RanshiEngine, and CLHEP::RanluxppEngine.

Definition at line 34 of file RandomEngine.cc.

                                 {
  return flat();
}

References G4AblaRandom::flat().

operator float()

CLHEP::HepRandomEngine::operator float ( )

virtualinherited

Reimplemented in CLHEP::DualRand, CLHEP::HepJamesRandom, CLHEP::MixMaxRng, CLHEP::MTwistEngine, CLHEP::RanecuEngine, CLHEP::RanluxEngine, CLHEP::RanshiEngine, and CLHEP::RanluxppEngine.

Definition at line 38 of file RandomEngine.cc.

                                {
  return float( flat() );
}

References G4AblaRandom::flat().

operator unsigned int()

CLHEP::HepRandomEngine::operator unsigned int ( )

virtualinherited

Reimplemented in CLHEP::DualRand, CLHEP::HepJamesRandom, CLHEP::MixMaxRng, CLHEP::MTwistEngine, CLHEP::RanecuEngine, CLHEP::RanluxEngine, CLHEP::RanshiEngine, and CLHEP::RanluxppEngine.

Definition at line 42 of file RandomEngine.cc.

                                       {
  return (unsigned int)( flat() * exponent_bit_32() );
}

References G4AblaRandom::flat().

operator!=()

bool CLHEP::HepRandomEngine::operator!= ( const HepRandomEngine &  engine )

inlineinherited

operator==()

bool CLHEP::HepRandomEngine::operator== ( const HepRandomEngine &  engine )

inlineinherited

put() [1/2]

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 608 of file Ranlux64Engine.cc.

                                                    {
  std::vector<unsigned long> v;
  v.push_back (engineIDulong<Ranlux64Engine>());
  std::vector<unsigned long> t;
  for (int i=0; i<12; ++i) {
    t = DoubConv::dto2longs(randoms[i]);
    v.push_back(t[0]); v.push_back(t[1]);
  }
  t = DoubConv::dto2longs(carry);
  v.push_back(t[0]); v.push_back(t[1]);
  v.push_back(static_cast<unsigned long>(index));
  v.push_back(static_cast<unsigned long>(luxury));
  v.push_back(static_cast<unsigned long>(pDiscard));
  return v;
}

References carry, CLHEP::DoubConv::dto2longs(), index, luxury, pDiscard, and randoms.

Referenced by put(), and saveStatus().

put() [2/2]

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 597 of file Ranlux64Engine.cc.

{
   char beginMarker[] = "Ranlux64Engine-begin";
  os << beginMarker << "\nUvec\n";
  std::vector<unsigned long> v = put();
  for (unsigned int i=0; i<v.size(); ++i) {
     os <<  v[i] <<  "\n";
  }
  return os;  
}

References put().

restoreStatus()

void CLHEP::Ranlux64Engine::restoreStatus ( const char  filename[] = "Ranlux64.conf" )

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 544 of file Ranlux64Engine.cc.

{
   std::ifstream inFile( filename, std::ios::in);
   if (!checkFile ( inFile, filename, engineName(), "restoreStatus" )) {
     std::cerr << "  -- Engine state remains unchanged\n";
     return;
   }
  if ( possibleKeywordInput ( inFile, "Uvec", theSeed ) ) {
    std::vector<unsigned long> v;
    unsigned long xin;
    for (unsigned int ivec=0; ivec < VECTOR_STATE_SIZE; ++ivec) {
      inFile >> xin;
      if (!inFile) {
        inFile.clear(std::ios::badbit | inFile.rdstate());
        std::cerr << "\nJamesRandom state (vector) description improper."
           << "\nrestoreStatus has failed."
           << "\nInput stream is probably mispositioned now." << std::endl;
        return;
      }
      v.push_back(xin);
    }
    getState(v);
    return;
  }
 
   if (!inFile.bad() && !inFile.eof()) {
//     inFile >> theSeed;  removed -- encompased by possibleKeywordInput
     for (int i=0; i<12; ++i) {
       inFile >> randoms[i];
     }
     inFile >> carry; inFile >> index;
     inFile >> luxury; inFile >> pDiscard;
     pDozens  = pDiscard / 12;
     endIters = pDiscard % 12;
   }
}

References carry, CLHEP::HepRandomEngine::checkFile(), endIters, engineName(), getState(), index, luxury, pDiscard, pDozens, CLHEP::possibleKeywordInput(), randoms, CLHEP::HepRandomEngine::theSeed, and VECTOR_STATE_SIZE.

saveStatus()

void CLHEP::Ranlux64Engine::saveStatus ( const char  filename[] = "Ranlux64.conf" ) const

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 532 of file Ranlux64Engine.cc.

{
   std::ofstream outFile( filename, std::ios::out ) ;
  if (!outFile.bad()) {
    outFile << "Uvec\n";
    std::vector<unsigned long> v = put();
    for (unsigned int i=0; i<v.size(); ++i) {
      outFile << v[i] << "\n";
    }
  }
}

References put().

setSeed()

void CLHEP::Ranlux64Engine::setSeed ( long  seed, int  lxr = 1  )

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 382 of file Ranlux64Engine.cc.

                                               {
 
// The initialization is carried out using a Multiplicative
// Congruential generator using formula constants of L'Ecuyer
// as described in "A review of pseudorandom number generators"
// (Fred James) published in Computer Physics Communications 60 (1990)
// pages 329-344
 
  const int ecuyer_a(53668);
  const int ecuyer_b(40014);
  const int ecuyer_c(12211);
  const int ecuyer_d(2147483563);
 
  const int lux_levels[3] = {109, 202, 397};
  theSeed = seed;
 
  if( (lux > 2)||(lux < 0) ){
     pDiscard = (lux >= 12) ? (lux-12) : lux_levels[1];
  }else{
     pDiscard = lux_levels[luxury];
  }
  pDozens  = pDiscard / 12;
  endIters = pDiscard % 12;
 
  long init_table[24];
  long next_seed = seed;
  long k_multiple;
  int i;
  next_seed &= 0xffffffff;
  while( next_seed >= ecuyer_d ) {
     next_seed -= ecuyer_d;
  }
  
  for(i = 0;i != 24;i++){
     k_multiple = next_seed / ecuyer_a;
     next_seed = ecuyer_b * (next_seed - k_multiple * ecuyer_a)
                                       - k_multiple * ecuyer_c;
     if(next_seed < 0) {
    next_seed += ecuyer_d;
     }
     next_seed &= 0xffffffff;
     init_table[i] = next_seed;
  } 
  // are we on a 64bit machine?
  if( sizeof(long) >= 8 ) {
     int64_t topbits1, topbits2;
#ifdef WIN32
     topbits1 = ( (int64_t) seed >> 32) & 0xffff ;
     topbits2 = ( (int64_t) seed >> 48) & 0xffff ;
#else
     topbits1 = detail::rshift<32>(seed) & 0xffff ;
     topbits2 = detail::rshift<48>(seed) & 0xffff ;
#endif
     init_table[0] ^= topbits1;
     init_table[2] ^= topbits2;
     //std::cout << " init_table[0] " << init_table[0] << " from " << topbits1 << std::endl;
     //std::cout << " init_table[2] " << init_table[2] << " from " << topbits2 << std::endl;
  }   
 
  for(i = 0;i < 12; i++){
     randoms[i] = (init_table[2*i  ]      ) * 2.0 * twoToMinus_32() +
                  (init_table[2*i+1] >> 15) * twoToMinus_48();
     //if( randoms[i] < 0. || randoms[i]  > 1. ) {
     //std::cout << "setSeed:  init_table " << init_table[2*i  ] << std::endl;
     //std::cout << "setSeed:  init_table " << init_table[2*i+1] << std::endl;
     //std::cout << "setSeed:  random " << i << " is " << randoms[i] << std::endl;
     //}
  }
 
  carry = 0.0;
  if ( randoms[11] == 0. ) carry = twoToMinus_48();
  // Perform an update before returning the first random number.
  index = -1;
 
} // setSeed()

References carry, endIters, index, CLHEP::lux, luxury, pDiscard, pDozens, randoms, CLHEP::HepRandomEngine::theSeed, CLHEP::HepRandomEngine::twoToMinus_32(), and CLHEP::HepRandomEngine::twoToMinus_48().

Referenced by setSeeds().

setSeeds()

void CLHEP::Ranlux64Engine::setSeeds ( const long *  seeds, int  lxr = 1  )

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 458 of file Ranlux64Engine.cc.

                                                         {
// old code only uses the first long in seeds
//  setSeed( *seeds ? *seeds : 32767, lux );
//  theSeeds = seeds;
 
// using code from Ranlux - even those are 32bit seeds, 
// that is good enough to completely differentiate the sequences
 
   const int ecuyer_a = 53668;
   const int ecuyer_b = 40014;
   const int ecuyer_c = 12211;
   const int ecuyer_d = 2147483563;
 
   const int lux_levels[3] = {109, 202, 397};
   const long *seedptr; 
 
   theSeeds = seeds;
   seedptr  = seeds;
 
   if(seeds == 0){
      setSeed(theSeed,lux);
      theSeeds = &theSeed;
      return;
   }
 
   theSeed = *seeds;
 
// number of additional random numbers that need to be 'thrown away'
// every 24 numbers is set using luxury level variable.
 
  if( (lux > 2)||(lux < 0) ){
     pDiscard = (lux >= 12) ? (lux-12) : lux_levels[1];
  }else{
     pDiscard = lux_levels[luxury];
  }
  pDozens  = pDiscard / 12;
  endIters = pDiscard % 12;
 
  long init_table[24];
  long next_seed = *seeds;
  long k_multiple;
  int i;
      
  for( i = 0;(i != 24)&&(*seedptr != 0);i++){
      init_table[i] =  *seedptr & 0xffffffff;
      seedptr++;
  }            
 
  if(i != 24){
     next_seed = init_table[i-1];
     for(;i != 24;i++){
    k_multiple = next_seed / ecuyer_a;
    next_seed = ecuyer_b * (next_seed - k_multiple * ecuyer_a)
                                      - k_multiple * ecuyer_c;
    if(next_seed < 0) {
       next_seed += ecuyer_d;
    }
    next_seed &= 0xffffffff;
    init_table[i] = next_seed;
     }    
  }
 
  for(i = 0;i < 12; i++){
     randoms[i] = (init_table[2*i  ]      ) * 2.0 * twoToMinus_32() +
                  (init_table[2*i+1] >> 15) * twoToMinus_48();
  }
 
  carry = 0.0;
  if ( randoms[11] == 0. ) carry = twoToMinus_48();
  // Perform an update before returning the first random number.
  index = -1;
 
}

References carry, endIters, index, CLHEP::lux, luxury, pDiscard, pDozens, randoms, setSeed(), CLHEP::HepRandomEngine::theSeed, CLHEP::HepRandomEngine::theSeeds, CLHEP::HepRandomEngine::twoToMinus_32(), and CLHEP::HepRandomEngine::twoToMinus_48().

Referenced by Ranlux64Engine().

showStatus()

void CLHEP::Ranlux64Engine::showStatus ( ) const

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 581 of file Ranlux64Engine.cc.

{
   std::cout << std::endl;
   std::cout << "--------- Ranlux engine status ---------" << std::endl;
   std::cout << " Initial seed = " << theSeed << std::endl;
   std::cout << " randoms[] = ";
   for (int i=0; i<12; ++i) {
     std::cout << randoms[i] << std::endl;
   }
   std::cout << std::endl;
   std::cout << " carry = " << carry << ", index = " << index << std::endl;
   std::cout << " luxury = " << luxury << " pDiscard = " 
                        << pDiscard << std::endl;
   std::cout << "----------------------------------------" << std::endl;
}

References carry, index, luxury, pDiscard, randoms, and CLHEP::HepRandomEngine::theSeed.

twoToMinus_32()

static double CLHEP::HepRandomEngine::twoToMinus_32 ( )

inlinestaticprotectedinherited

Referenced by CLHEP::DualRand::flat(), CLHEP::MTwistEngine::flat(), CLHEP::RanshiEngine::flat(), setSeed(), and setSeeds().

twoToMinus_48()

static double CLHEP::HepRandomEngine::twoToMinus_48 ( )

inlinestaticprotectedinherited

Referenced by advance(), setSeed(), setSeeds(), and update().

twoToMinus_49()

static double CLHEP::HepRandomEngine::twoToMinus_49 ( )

inlinestaticprotectedinherited

Referenced by flat().

twoToMinus_53()

static double CLHEP::HepRandomEngine::twoToMinus_53 ( )

inlinestaticprotectedinherited

Referenced by CLHEP::DualRand::flat(), CLHEP::MTwistEngine::flat(), and CLHEP::RanshiEngine::flat().

update()

void CLHEP::Ranlux64Engine::update ( )

private

Definition at line 169 of file Ranlux64Engine.cc.

                            {
  // Update the stash of twelve random numbers.  
  // When this routione is entered, index is always 0.  The randoms 
  // contains the last 12 numbers in the sequents:  s[0] is x[a+11], 
  // s[1] is x[a+10] ... and s[11] is x[a] for some a.  Carry contains
  // the last carry value (c[a+11]).
  //
  // The recursion relation (3) in Luscher's note says 
  //   delta[n] = x[n-s] = x[n-r] -c[n-1] or for n=a+12,
  //   delta[a+12] = x[a+7] - x[a] -c[a+11] where we use r=12, s=5 per eqn. (7)
  // This reduces to 
  // s[11] = s[4] - s[11] - carry.
  // The next number similarly will be given by s[10] = s[3] - s[10] - carry,
  // and so forth until s[0] is filled.
  // 
  // However, we need to skip 397, 202 or 109 numbers - these are not divisible 
  // by 12 - to "fare well in the spectral test".  
 
  advance(pDozens);
 
  // Since we wish at the end to have the 12 last numbers in the order of 
  // s[11] first, till s[0] last, we will have to do 1, 10, or 1 iterations 
  // and then re-arrange to place to get the oldest one in s[11].
  // Generically, this will imply re-arranging the s array at the end,
  // but we can treat the special case of endIters = 1 separately for superior
  // efficiency in the cases of levels 0 and 2.
 
  double  y1;
 
  if ( endIters == 1 ) {    // Luxury levels 0 and 2 will go here
    y1 = randoms[ 4] - randoms[11] - carry;
    if ( y1 < 0.0 ) {
      y1 += 1.0;            
      carry = twoToMinus_48();
    } else {
      carry = 0.0;
    }
    randoms[11] = randoms[10];  
    randoms[10] = randoms[ 9];  
    randoms[ 9] = randoms[ 8];  
    randoms[ 8] = randoms[ 7];  
    randoms[ 7] = randoms[ 6];  
    randoms[ 6] = randoms[ 5];  
    randoms[ 5] = randoms[ 4];  
    randoms[ 4] = randoms[ 3];  
    randoms[ 3] = randoms[ 2];  
    randoms[ 2] = randoms[ 1];  
    randoms[ 1] = randoms[ 0];  
    randoms[ 0] = y1;
 
  } else {
 
    int m, nr, ns;
    for ( m = 0, nr = 11, ns = 4; m < endIters; ++m, --nr ) {
      y1 = randoms [ns] - randoms[nr] - carry;
      if ( y1 < 0.0 ) {
        y1 += 1.0;
        carry = twoToMinus_48();
      } else {
        carry = 0.0;
      }
      randoms[nr] = y1;
      --ns;
      if ( ns < 0 ) {
        ns = 11;
      }
    } // loop on m
 
    double temp[12];
    for (m=0; m<12; m++) {
      temp[m]=randoms[m];
    }
 
    ns = 11 - endIters;
    for (m=11; m>=0; --m) {
      randoms[m] = temp[ns];
      --ns;
      if ( ns < 0 ) {
        ns = 11;
      }
    } 
 
  }
 
  // Now when we return, there are 12 fresh usable numbers in s[11] ... s[0]
 
  index = 12;
 
} // update()

References advance(), carry, endIters, index, CLHEP::m, CLHEP::ns, pDozens, randoms, and CLHEP::HepRandomEngine::twoToMinus_48().

Referenced by flat().

Field Documentation

carry

double CLHEP::Ranlux64Engine::carry

private

Definition at line 111 of file Ranlux64Engine.h.

Referenced by advance(), getState(), put(), restoreStatus(), setSeed(), setSeeds(), showStatus(), and update().

endIters

int CLHEP::Ranlux64Engine::endIters

private

Definition at line 106 of file Ranlux64Engine.h.

Referenced by getState(), restoreStatus(), setSeed(), setSeeds(), and update().

index

int CLHEP::Ranlux64Engine::index

private

Definition at line 109 of file Ranlux64Engine.h.

Referenced by flat(), getState(), put(), restoreStatus(), setSeed(), setSeeds(), showStatus(), and update().

luxury

int CLHEP::Ranlux64Engine::luxury

private

Definition at line 107 of file Ranlux64Engine.h.

Referenced by getLuxury(), getState(), put(), Ranlux64Engine(), restoreStatus(), setSeed(), setSeeds(), and showStatus().

pDiscard

int CLHEP::Ranlux64Engine::pDiscard

private

Definition at line 104 of file Ranlux64Engine.h.

Referenced by getState(), put(), restoreStatus(), setSeed(), setSeeds(), and showStatus().

pDozens

int CLHEP::Ranlux64Engine::pDozens

private

Definition at line 105 of file Ranlux64Engine.h.

Referenced by getState(), restoreStatus(), setSeed(), setSeeds(), and update().

randoms

double CLHEP::Ranlux64Engine::randoms[12]

private

Definition at line 110 of file Ranlux64Engine.h.

Referenced by advance(), flat(), getState(), put(), restoreStatus(), setSeed(), setSeeds(), showStatus(), and update().

theSeed

long CLHEP::HepRandomEngine::theSeed

protectedinherited

Definition at line 142 of file RandomEngine.h.

Referenced by CLHEP::DualRand::DualRand(), CLHEP::HepRandomEngine::getSeed(), CLHEP::DualRand::getState(), CLHEP::HepJamesRandom::getState(), CLHEP::MixMaxRng::getState(), CLHEP::MTwistEngine::getState(), CLHEP::RanecuEngine::getState(), getState(), CLHEP::RanluxEngine::getState(), CLHEP::RanshiEngine::getState(), CLHEP::HepJamesRandom::HepJamesRandom(), CLHEP::MixMaxRng::MixMaxRng(), CLHEP::RanecuEngine::put(), CLHEP::MixMaxRng::put(), CLHEP::MTwistEngine::put(), CLHEP::RanecuEngine::RanecuEngine(), CLHEP::RanluxEngine::RanluxEngine(), CLHEP::RanluxppEngine::RanluxppEngine(), CLHEP::RanshiEngine::RanshiEngine(), CLHEP::DualRand::restoreStatus(), CLHEP::HepJamesRandom::restoreStatus(), CLHEP::MTwistEngine::restoreStatus(), CLHEP::RanecuEngine::restoreStatus(), CLHEP::RanluxEngine::restoreStatus(), restoreStatus(), CLHEP::RanshiEngine::restoreStatus(), CLHEP::MTwistEngine::saveStatus(), CLHEP::RanecuEngine::setIndex(), CLHEP::RanecuEngine::setSeed(), CLHEP::HepJamesRandom::setSeed(), CLHEP::MixMaxRng::setSeed(), CLHEP::RanluxppEngine::setSeed(), setSeed(), CLHEP::RanluxEngine::setSeed(), CLHEP::DualRand::setSeed(), CLHEP::MTwistEngine::setSeed(), CLHEP::RanecuEngine::setSeeds(), setSeeds(), CLHEP::RanluxEngine::setSeeds(), CLHEP::MixMaxRng::setSeeds(), CLHEP::RanshiEngine::setSeeds(), CLHEP::DualRand::showStatus(), CLHEP::HepJamesRandom::showStatus(), CLHEP::MTwistEngine::showStatus(), CLHEP::RanecuEngine::showStatus(), showStatus(), CLHEP::RanluxEngine::showStatus(), and CLHEP::RanshiEngine::showStatus().

theSeeds

const long* CLHEP::HepRandomEngine::theSeeds

protectedinherited

Definition at line 143 of file RandomEngine.h.

Referenced by CLHEP::HepRandomEngine::getSeeds(), CLHEP::RanecuEngine::RanecuEngine(), CLHEP::RanecuEngine::setIndex(), CLHEP::RanecuEngine::setSeed(), CLHEP::HepJamesRandom::setSeeds(), CLHEP::RanluxppEngine::setSeeds(), CLHEP::RanecuEngine::setSeeds(), setSeeds(), CLHEP::RanluxEngine::setSeeds(), CLHEP::MixMaxRng::setSeeds(), CLHEP::DualRand::setSeeds(), CLHEP::MTwistEngine::setSeeds(), and CLHEP::RanshiEngine::setSeeds().

VECTOR_STATE_SIZE

const unsigned int CLHEP::Ranlux64Engine::VECTOR_STATE_SIZE = 30

static

Definition at line 97 of file Ranlux64Engine.h.

Referenced by getState(), and restoreStatus().

---

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

• source/externals/clhep/include/CLHEP/Random/Ranlux64Engine.h
• source/externals/clhep/src/Ranlux64Engine.cc