CLHEP::MixMaxRng Class Reference

#include <MixMaxRng.h>

Inheritance diagram for CLHEP::MixMaxRng:

Public Member Functions
	MixMaxRng (std::istream &is)
	MixMaxRng ()
	MixMaxRng (long seed)
	~MixMaxRng ()
	MixMaxRng (const MixMaxRng &rng)
MixMaxRng &	operator= (const MixMaxRng &rng)
double	flat ()
void	flatArray (const int size, double *vect)
void	setSeed (long longSeed, int=0)
void	setSeeds (const long *seeds, int seedNum=0)
void	saveStatus (const char filename[]="MixMaxRngState.conf") const
void	restoreStatus (const char filename[]="MixMaxRngState.conf")
void	showStatus () const
	operator double ()
	operator float ()
	operator unsigned int ()
virtual std::ostream &	put (std::ostream &os) const
virtual std::istream &	get (std::istream &is)
virtual std::istream &	getState (std::istream &is)
std::string	name () const
std::vector< unsigned long >	put () const
bool	get (const std::vector< unsigned long > &vec)
bool	getState (const std::vector< unsigned long > &vec)
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	beginTag ()
static std::string	engineName ()
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)

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

Definition at line 52 of file MixMaxRng.h.

Constructor & Destructor Documentation

MixMaxRng() [1/4]

CLHEP::MixMaxRng::MixMaxRng

(

std::istream &

is

)

Definition at line 72 of file MixMaxRng.cc.

: HepRandomEngine()
{
   get(is);
}

Referenced by MixMaxRng(), and operator=().

MixMaxRng() [2/4]

CLHEP::MixMaxRng::MixMaxRng

(

)

Definition at line 58 of file MixMaxRng.cc.

: HepRandomEngine()
{
   int numEngines = ++numberOfEngines;
   setSeed(static_cast<long>(numEngines));
}

MixMaxRng() [3/4]

CLHEP::MixMaxRng::MixMaxRng

(

long

seed

)

Definition at line 65 of file MixMaxRng.cc.

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

~MixMaxRng()

CLHEP::MixMaxRng::~MixMaxRng

(

)

Definition at line 78 of file MixMaxRng.cc.

{
}

MixMaxRng() [4/4]

CLHEP::MixMaxRng::MixMaxRng

(

const MixMaxRng &

rng

)

Definition at line 82 of file MixMaxRng.cc.

  : HepRandomEngine(rng)
{
   std::copy(rng.V, rng.V+N, V);
   sumtot= rng.sumtot;
   counter= rng.counter;
}

Member Function Documentation

beginTag()

std::string CLHEP::MixMaxRng::beginTag ( )

static

Definition at line 315 of file MixMaxRng.cc.

{ 
   return "MixMaxRng-begin"; 
}

engineName()

std::string CLHEP::MixMaxRng::engineName ( )

static

Definition at line 247 of file MixMaxRng.cc.

{
   return "MixMaxRng";
}

flat()

double CLHEP::MixMaxRng::flat ( )

inlinevirtual

Implements CLHEP::HepRandomEngine.

Definition at line 69 of file MixMaxRng.h.

  {
    if (counter >= N) iterate();
    return INV_M61*static_cast<double>(V[counter++]);
  }

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

flatArray()

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

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 257 of file MixMaxRng.cc.

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

get() [1/2]

bool CLHEP::MixMaxRng::get ( const std::vector< unsigned long > & vec )

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 353 of file MixMaxRng.cc.

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

get() [2/2]

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 297 of file MixMaxRng.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,"MixMaxRng-begin")) {
      is.clear(std::ios::badbit | is.rdstate());
      std::cerr << "\nInput stream mispositioned or"
                << "\nMixMaxRng state description missing or"
                << "\nwrong engine type found." << std::endl;
      return is;
   }
   return getState(is);
}

Referenced by MixMaxRng().

getState() [1/2]

bool CLHEP::MixMaxRng::getState ( const std::vector< unsigned long > & vec )

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 364 of file MixMaxRng.cc.

{
   if (vec.size() != VECTOR_STATE_SIZE ) {
     std::cerr <<
        "\nMixMaxRng::getState(): vector has wrong length - state unchanged\n";
     return false;
   }
   for (int i=1; i<2*rng_get_N() ; i=i+2) {
     V[i/2]= ( (vec[i] & MASK32) | ( (myuint_t)(vec[i+1]) << 32 ) );
     // unpack from a data structure which is 32-bit on some platforms
   }
   counter = (int)vec[2*rng_get_N()+1];
   precalc();
   if ( ( (vec[2*rng_get_N()+2] & MASK32)
        | ( (myuint_t)(vec[2*rng_get_N()+3]) << 32 ) ) != sumtot) {
     std::cerr << "\nMixMaxRng::getState(): vector has wrong checksum!"
               << "\nInput vector is probably mispositioned now.\n";
     return false;
   }
   return true;
}

getState() [2/2]

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 320 of file MixMaxRng.cc.

{
   char endMarker[MarkerLen];
   is >> theSeed;
   for (int i=0; i<rng_get_N(); ++i)  is >> V[i];
   is >> counter;
   myuint_t checksum;
   is >> checksum;
   is >> std::ws;
   is.width(MarkerLen);
   is >> endMarker;
   if (strcmp(endMarker,"MixMaxRng-end")) {
       is.clear(std::ios::badbit | is.rdstate());
       std::cerr << "\nMixMaxRng state description incomplete."
                 << "\nInput stream is probably mispositioned now.\n";
       return is;
   }
   if ( counter < 0 || counter > rng_get_N() ) {
       std::cerr << "\nMixMaxRng::getState(): "
                 << "vector read wrong value of counter from file!"
                 << "\nInput stream is probably mispositioned now.\n";
       return is;
   }
   precalc();
   if ( checksum != sumtot) {
       std::cerr << "\nMixMaxRng::getState(): "
                 << "checksum disagrees with value stored in file!"
                 << "\nInput stream is probably mispositioned now.\n";
       return is;
   }
   return is;
}

Referenced by get(), and get().

name()

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

inlinevirtual

Implements CLHEP::HepRandomEngine.

Definition at line 118 of file MixMaxRng.h.

{ return "MixMaxRng"; }

operator double()

CLHEP::MixMaxRng::operator double ( )

inlinevirtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 103 of file MixMaxRng.h.

{ return flat(); }

operator float()

CLHEP::MixMaxRng::operator float ( )

inlinevirtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 106 of file MixMaxRng.h.

{ return float( flat() ); }

operator unsigned int()

CLHEP::MixMaxRng::operator unsigned int ( )

inlinevirtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 109 of file MixMaxRng.h.

{ return static_cast<unsigned int>(get_next()); }

operator=()

MixMaxRng & CLHEP::MixMaxRng::operator=

(

const MixMaxRng &

rng

)

Definition at line 90 of file MixMaxRng.cc.

{
   // Check assignment to self
   //
   if (this == &rng)  { return *this; }
 
   // Copy base class data
   //
   HepRandomEngine::operator=(rng);
 
   std::copy(rng.V, rng.V+N, V);
   sumtot= rng.sumtot;
   counter= rng.counter;
 
   return *this;
}

put() [1/2]

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 280 of file MixMaxRng.cc.

{
   std::vector<unsigned long> vec;
   vec.push_back (engineIDulong<MixMaxRng>());
   for (int i=0; i<rng_get_N(); ++i)
   {
     vec.push_back(static_cast<unsigned long>(V[i] & MASK32));
       // little-ended order on all platforms
     vec.push_back(static_cast<unsigned long>(V[i] >> 32  ));
       // pack uint64 into a data structure which is 32-bit on some platforms
   }
   vec.push_back(static_cast<unsigned long>(counter));
   vec.push_back(static_cast<unsigned long>(sumtot & MASK32));
   vec.push_back(static_cast<unsigned long>(sumtot >> 32));
   return vec;
}

put() [2/2]

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 262 of file MixMaxRng.cc.

{
   char beginMarker[] = "MixMaxRng-begin";
   char endMarker[]   = "MixMaxRng-end";
 
   long pr = os.precision(24);
   os << beginMarker << " ";
   os << theSeed << "\n";
   for (int i=0; i<rng_get_N(); ++i) {
      os <<  V[i] << "\n";
   }
   os << counter << "\n";
   os << sumtot << "\n";
   os << endMarker << "\n";
   os.precision(pr);
   return os;  
}

restoreStatus()

void CLHEP::MixMaxRng::restoreStatus ( const char filename[] = "MixMaxRngState.conf" )

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 127 of file MixMaxRng.cc.

{
   // a function for reading the state from a file
   FILE* fin;
   if(  ( fin = fopen(filename, "r") ) )
   {
      char l=0;
      while ( l != '{' ) { // 0x7B = "{"
        l=fgetc(fin); // proceed until hitting opening bracket
      }
      ungetc(' ', fin);
   }
   else
   {
      fprintf(stderr, "mixmax -> read_state: error reading file %s\n", filename);
      throw std::runtime_error("Error in reading state file");
   }
    
   myuint_t vecVal;
   //printf("mixmax -> read_state: starting to read state from file\n");
   if (!fscanf(fin, "%llu", (unsigned long long*) &V[0]) )
   {
     fprintf(stderr, "mixmax -> read_state: error reading file %s\n", filename);
     throw std::runtime_error("Error in reading state file");
   }
 
   for (int i = 1; i < rng_get_N(); ++i)
   {
     if (!fscanf(fin, ", %llu", (unsigned long long*) &vecVal) )
     {
       fprintf(stderr, "mixmax -> read_state: error reading vector component i=%d from file %s\n", i, filename);
       throw std::runtime_error("Error in reading state file");
     }
     if( vecVal <= MixMaxRng::M61 )
     {
       V[i] = vecVal;
     }
     else
     {
       fprintf(stderr, "mixmax -> read_state: Invalid state vector value= %llu"
               " ( must be less than %llu ) "
               " obtained from reading file %s\n"
               , (unsigned long long)vecVal, (unsigned long long)MixMaxRng::M61, filename);
     }
   }
    
   int incounter;
   if (!fscanf( fin, "}; counter=%i; ", &incounter))
   {
     fprintf(stderr, "mixmax -> read_state: error reading counter from file %s\n", filename);
     throw std::runtime_error("Error in reading state file");
   }
   if( incounter <= rng_get_N() )
   {
     counter = incounter;
   }
   else
   {
     fprintf(stderr, "mixmax -> read_state: Invalid counter = %d"
             "  Must be 0 <= counter < %u\n" , counter, rng_get_N());
     print_state();
     throw std::runtime_error("Error in reading state counter");
   }
   precalc();
   myuint_t insumtot;
   if (!fscanf( fin, "sumtot=%llu\n", (unsigned long long*) &insumtot))
   {
     fprintf(stderr, "mixmax -> read_state: error reading checksum from file %s\n", filename);
     throw std::runtime_error("Error in reading state file");
   }
 
   if (sumtot != insumtot)
   {
     fprintf(stderr, "mixmax -> checksum error while reading state from file %s - corrupted?\n", filename);
     throw std::runtime_error("Error in reading state checksum");
   }
   fclose(fin);
}

saveStatus()

void CLHEP::MixMaxRng::saveStatus ( const char filename[] = "MixMaxRngState.conf" ) const

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 107 of file MixMaxRng.cc.

{
   // Create a C file-handle or an object that can accept the same output
   FILE *fh= fopen(filename, "w");
   if( fh )
   {
     int j;
     fprintf(fh, "mixmax state, file version 1.0\n" );
     fprintf(fh, "N=%u; V[N]={", rng_get_N() );
     for (j=0; (j< (rng_get_N()-1) ); ++j) {
         fprintf(fh, "%llu, ", (unsigned long long)V[j] );
     }
     fprintf(fh, "%llu", (unsigned long long)V[rng_get_N()-1] );
     fprintf(fh, "}; " );
     fprintf(fh, "counter=%u; ", counter );
     fprintf(fh, "sumtot=%llu;\n", (unsigned long long)sumtot );
     fclose(fh);
   }
}

setSeed()

void CLHEP::MixMaxRng::setSeed ( long longSeed, int = 0 )

inlinevirtual

Implements CLHEP::HepRandomEngine.

Definition at line 81 of file MixMaxRng.h.

  {
    seed_spbox(theSeed = longSeed);
  }

Referenced by MixMaxRng(), and MixMaxRng().

setSeeds()

void CLHEP::MixMaxRng::setSeeds ( const long * seeds, int seedNum = 0 )

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 220 of file MixMaxRng.cc.

{
   myID_t seed0, seed1= 0, seed2= 0, seed3= 0;
 
   if( seedNum < 1 ) {  // Assuming at least 2 seeds in vector...
       seed0= static_cast<myID_t>(Seeds[0]) & MASK32;
       seed1= static_cast<myID_t>(Seeds[1]) & MASK32;
   } 
   else
   {
     if( seedNum < 4 ) {
       seed0= static_cast<myID_t>(Seeds[0]) & MASK32;
       if( seedNum > 1){ seed1= static_cast<myID_t>(Seeds[1]) & MASK32; }
       if( seedNum > 2){ seed2= static_cast<myID_t>(Seeds[2]) & MASK32; }
     }
     if( seedNum >= 4 ) {
       seed0= static_cast<myID_t>(Seeds[0]) & MASK32;
       seed1= static_cast<myID_t>(Seeds[1]) & MASK32;
       seed2= static_cast<myID_t>(Seeds[2]) & MASK32;
       seed3= static_cast<myID_t>(Seeds[3]) & MASK32;
     }
   }
   theSeed = Seeds[0];
   theSeeds = Seeds;
   seed_uniquestream(seed3, seed2, seed1, seed0);
}

showStatus()

void CLHEP::MixMaxRng::showStatus ( ) const

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 206 of file MixMaxRng.cc.

{
   std::cout << std::endl;
   std::cout << "------- MixMaxRng engine status -------" << std::endl;
 
   std::cout << " Current state vector is:" << std::endl;
   print_state();
   std::cout << "---------------------------------------" << std::endl;
}

---

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

• MixMaxRng.h
• MixMaxRng.cc