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

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 50 of file MixMaxRng.h.

Constructor & Destructor Documentation

MixMaxRng() [1/4]

CLHEP::MixMaxRng::MixMaxRng

(

std::istream &

is

)

Definition at line 69 of file MixMaxRng.cc.

: HepRandomEngine()
{
   get(is);
}

MixMaxRng() [2/4]

CLHEP::MixMaxRng::MixMaxRng

(

)

Definition at line 55 of file MixMaxRng.cc.

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

MixMaxRng() [3/4]

CLHEP::MixMaxRng::MixMaxRng

(

long

seed

)

Definition at line 62 of file MixMaxRng.cc.

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

~MixMaxRng()

CLHEP::MixMaxRng::~MixMaxRng

(

)

Definition at line 75 of file MixMaxRng.cc.

{
}

MixMaxRng() [4/4]

CLHEP::MixMaxRng::MixMaxRng

(

const MixMaxRng &

rng

)

Definition at line 79 of file MixMaxRng.cc.

  : HepRandomEngine(rng)
{
   S.V = rng.S.V;
   S.sumtot= rng.S.sumtot;
   S.counter= rng.S.counter;
}

Member Function Documentation

beginTag()

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

static

Definition at line 402 of file MixMaxRng.cc.

{ 
   return "MixMaxRng-begin"; 
}

engineName()

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

static

Definition at line 252 of file MixMaxRng.cc.

{
   return "MixMaxRng";
}

flat()

double CLHEP::MixMaxRng::flat ( )

inlinevirtual

Implements CLHEP::HepRandomEngine.

Definition at line 66 of file MixMaxRng.h.

{ return (S.counter<=(N-1)) ? generate(S.counter):iterate(); }

Referenced by flatArray().

flatArray()

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

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 326 of file MixMaxRng.cc.

{
   // fill_array( S, size, arrayDbl );
   for (int i=0; i<size; ++i) { vect[i] = flat(); }
}

get() [1/2]

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 440 of file MixMaxRng.cc.

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

get() [2/2]

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 384 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 > &  v )

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 450 of file MixMaxRng.cc.

{
   if (v.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) {
     S.V[i/2]= ( (v[i] & MASK32) | ( (myuint_t)(v[i+1]) << 32 ) );
     // unpack from a data structure which is 32-bit on some platforms
   }
   S.counter = v[2*rng_get_N()+1];
   precalc();
   if ( ( (v[2*rng_get_N()+2] & MASK32)
        | ( (myuint_t)(v[2*rng_get_N()+3]) << 32 ) ) != S.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 407 of file MixMaxRng.cc.

{
   char endMarker[MarkerLen];
   is >> theSeed;
   for (int i=0; i<rng_get_N(); ++i)  is >> S.V[i];
   is >> S.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 ( S.counter < 0 || S.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 != S.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().

name()

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

inlinevirtual

Implements CLHEP::HepRandomEngine.

Definition at line 105 of file MixMaxRng.h.

{ return "MixMaxRng"; }

operator double()

CLHEP::MixMaxRng::operator double ( )

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 332 of file MixMaxRng.cc.

{
  return flat();
}

operator float()

CLHEP::MixMaxRng::operator float ( )

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 337 of file MixMaxRng.cc.

{
  return float( flat() );
}

operator unsigned int()

CLHEP::MixMaxRng::operator unsigned int ( )

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 342 of file MixMaxRng.cc.

{
   return static_cast<unsigned int>(get_next());
   // clhep_get_next returns a 64-bit integer, of which the lower 61 bits
   // are random and upper 3 bits are zero
}

operator=()

MixMaxRng & CLHEP::MixMaxRng::operator=

(

const MixMaxRng &

rng

)

Definition at line 87 of file MixMaxRng.cc.

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

put() [1/2]

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 367 of file MixMaxRng.cc.

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

put() [2/2]

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 349 of file MixMaxRng.cc.

{
   char beginMarker[] = "MixMaxRng-begin";
   char endMarker[]   = "MixMaxRng-end";
 
   int pr = os.precision(24);
   os << beginMarker << " ";
   os << theSeed << "\n";
   for (int i=0; i<rng_get_N(); ++i) {
      os <<  S.V[i] << "\n";
   }
   os << S.counter << "\n";
   os << S.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 124 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", &S.V[0]) )
   {
     fprintf(stderr, "mixmax -> read_state: error reading file %s\n", filename);
     throw std::runtime_error("Error in reading state file");
   }
 
   int i;
   for( i = 1; i < rng_get_N(); i++)
   {
     if (!fscanf(fin, ", %llu", &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 )
     {
       S.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"
               , vecVal, MixMaxRng::M61, filename);
     }
   }
    
   int counter;
   if (!fscanf( fin, "}; counter=%i; ", &counter))
   {
     fprintf(stderr, "mixmax -> read_state: error reading counter from file %s\n", filename);
     throw std::runtime_error("Error in reading state file");
   }
   if( counter <= rng_get_N() )
   {
     S.counter= counter;
   }
   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 sumtot;
   if (!fscanf( fin, "sumtot=%llu\n", &sumtot))
   {
     fprintf(stderr, "mixmax -> read_state: error reading checksum from file %s\n", filename);
     throw std::runtime_error("Error in reading state file");
   }
 
   if (S.sumtot != sumtot)
   {
     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 104 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, ", S.V[j] );
     }
     fprintf(fh, "%llu", S.V[rng_get_N()-1] );
     fprintf(fh, "}; " );
     fprintf(fh, "counter=%u; ", S.counter );
     fprintf(fh, "sumtot=%llu;\n", S.sumtot );
     fclose(fh);
   }
}

setSeed()

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

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 214 of file MixMaxRng.cc.

{
   //seed_uniquestream(0,0,0,longSeed);
   theSeed = longSeed;
   seed_spbox(longSeed);
}

Referenced by MixMaxRng().

setSeeds()

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

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 225 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 204 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