CLHEP::NonRandomEngine Class Reference

#include <NonRandomEngine.h>

Inheritance diagram for CLHEP::NonRandomEngine:

Public Member Functions
	NonRandomEngine ()
virtual	~NonRandomEngine ()
void	setNextRandom (double r)
void	setRandomSequence (double *s, int n)
void	setRandomInterval (double x)
double	flat ()
void	flatArray (const int size, double *vect)
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 void	saveStatus (const char filename[]="Config.conf") const =0
virtual void	restoreStatus (const char filename[]="Config.conf")=0
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

Author

Definition at line 38 of file NonRandomEngine.h.

Constructor & Destructor Documentation

NonRandomEngine()

CLHEP::NonRandomEngine::NonRandomEngine

(

)

Definition at line 33 of file NonRandomEngine.cc.

                                 : nextHasBeenSet(false), 
                     sequenceHasBeenSet(false),
                     intervalHasBeenSet(false) ,
                                     nextRandom(0.05),
                     nInSeq(0),
                     randomInterval(0.1) { }

~NonRandomEngine()

CLHEP::NonRandomEngine::~NonRandomEngine ( )

virtual

Definition at line 40 of file NonRandomEngine.cc.

{ }

Member Function Documentation

beginTag()

std::string CLHEP::NonRandomEngine::beginTag ( )

static

Definition at line 141 of file NonRandomEngine.cc.

                                       { 
  return "NonRandomEngine-begin"; 
}  

engineName()

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

inlinestatic

Definition at line 70 of file NonRandomEngine.h.

{return "NonRandomEngine";}

flat()

double CLHEP::NonRandomEngine::flat ( )

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 65 of file NonRandomEngine.cc.

                             {
 
  if (sequenceHasBeenSet) {
    double v = sequence[nInSeq++];
    if (nInSeq >= sequence.size() ) sequenceHasBeenSet = false;
    return v;
  }
 
  if ( !nextHasBeenSet ) {
    std::cout 
    << "Attempt to use NonRandomEngine without setting next random!\n";
    exit(1);
  }
 
  double a = nextRandom;
  nextHasBeenSet = false;
 
  if (intervalHasBeenSet) {
    nextRandom += randomInterval;
    if ( nextRandom >= 1 ) nextRandom -= 1.0;
    nextHasBeenSet = true;
  }
 
  return a;
}

Referenced by flatArray().

flatArray()

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

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 92 of file NonRandomEngine.cc.

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

get() [1/2]

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 202 of file NonRandomEngine.cc.

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

get() [2/2]

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 128 of file NonRandomEngine.cc.

                                                  {
  std::string beginMarker = "NonRandomEngine-begin";
  is >> beginMarker;
  if (beginMarker != "NonRandomEngine-begin") {
    is.clear(std::ios::badbit | is.rdstate());
    std::cerr << "\nInput mispositioned or"
          << "\nNonRandomEngine state description missing or"
          << "\nwrong engine type found.\n";
    return is;
  }
  return getState(is);
}

getState() [1/2]

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 211 of file NonRandomEngine.cc.

                                                                  {
  unsigned long seqSize = v[9];
  if (v.size() != 2*seqSize + 10 ) {
    std::cerr << 
   "\nNonRandomEngine get:state vector has wrong length - state unchanged\n";
    std::cerr << "  (length = " << v.size() 
              << "; expected " << 2*seqSize + 10 << ")\n"; 
    return false;
  }
  std::vector<unsigned long> t(2);
  nextHasBeenSet     = (v[1]!=0);
  sequenceHasBeenSet = (v[2]!=0);
  intervalHasBeenSet = (v[3]!=0);
  t[0] = v[4]; t[1] = v[5]; nextRandom = DoubConv::longs2double(t);
  nInSeq = (unsigned int)v[6];
  t[0] = v[7]; t[1] = v[8]; randomInterval = DoubConv::longs2double(t);
  sequence.clear();
  for (unsigned long i=0; i<seqSize; ++i) {
    t[0] = v[2*i+10]; t[1] = v[2*i+11];
    sequence.push_back(DoubConv::longs2double(t));
  }
  return true;
}

getState() [2/2]

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 145 of file NonRandomEngine.cc.

                                                       {
  if ( possibleKeywordInput ( is, "Uvec", nextHasBeenSet ) ) {
    std::vector<unsigned long> v;
    unsigned long uu = 99999;
    unsigned long ssiz = 0;  
    for (unsigned int istart=0; istart < 10; ++istart) {
      is >> uu;
      if (!is) {
    is.clear(std::ios::badbit | is.rdstate());
        std::cout << "istart = " << istart << "\n";
    std::cerr 
    << "\nNonRandomEngine state (vector) description has no sequence size."
        << "\ngetState() has failed."
           << "\nInput stream is probably mispositioned now." << std::endl;
        return is;
      } 
      v.push_back(uu);
      if (istart==9) ssiz = uu;
    }   
    for (unsigned int ivec=0; ivec < 2*ssiz; ++ivec) {
      is >> uu;
      if (!is) {
        is.clear(std::ios::badbit | is.rdstate());
        std::cerr << "\nNonRandomEngine 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 >> nextHasBeenSet;  Removed, encompassed by possibleKeywordInput()
 
  std::string  endMarker  = "NonRandomEngine-end";
  is >> sequenceHasBeenSet >> intervalHasBeenSet;
  is >> nextRandom >> nInSeq >> randomInterval;
  unsigned int seqSize;
  is >> seqSize;
  sequence.clear();
  double x;
  for (unsigned int i = 0; i < seqSize; ++i) {
    is >> x;
    sequence.push_back(x);
  }
  is >> endMarker;
  if (endMarker != "NonRandomEngine-end") {
    is.clear(std::ios::badbit | is.rdstate());
    std::cerr << "\n NonRandomEngine state description incomplete."
          << "\nInput stream is probably mispositioned now." << std::endl;
    return is;
  }
  return is;
}

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

name()

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

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 31 of file NonRandomEngine.cc.

{return "NonRandomEngine";}

put() [1/2]

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 108 of file NonRandomEngine.cc.

                                                     {
  std::vector<unsigned long> v;
  v.push_back (engineIDulong<NonRandomEngine>());
  std::vector<unsigned long> t;
  v.push_back(static_cast<unsigned long>(nextHasBeenSet));
  v.push_back(static_cast<unsigned long>(sequenceHasBeenSet));
  v.push_back(static_cast<unsigned long>(intervalHasBeenSet));
  t = DoubConv::dto2longs(nextRandom);
  v.push_back(t[0]); v.push_back(t[1]);
  v.push_back(static_cast<unsigned long>(nInSeq));
  t = DoubConv::dto2longs(randomInterval);
  v.push_back(t[0]); v.push_back(t[1]);
  v.push_back(static_cast<unsigned long>(sequence.size()));
  for (unsigned int i=0; i<sequence.size(); ++i) {
    t = DoubConv::dto2longs(sequence[i]);
    v.push_back(t[0]); v.push_back(t[1]);
  }
  return v;
}

Referenced by put().

put() [2/2]

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

virtual

Reimplemented from CLHEP::HepRandomEngine.

Definition at line 98 of file NonRandomEngine.cc.

                                                        {
  std::string beginMarker = "NonRandomEngine-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;  
}

setNextRandom()

void CLHEP::NonRandomEngine::setNextRandom

(

double

r

)

Definition at line 43 of file NonRandomEngine.cc.

                                            {
  nextRandom = r;
  nextHasBeenSet=true;
  return;
}

setRandomInterval()

void CLHEP::NonRandomEngine::setRandomInterval

(

double

x

)

Definition at line 59 of file NonRandomEngine.cc.

                                                {
  randomInterval = x;
  intervalHasBeenSet=true;
  return;
}

setRandomSequence()

void CLHEP::NonRandomEngine::setRandomSequence	(	double *	s,
		int	n )

Definition at line 49 of file NonRandomEngine.cc.

                                                        {
  sequence.clear();
  for (int i=0; i<n; i++) sequence.push_back(*s++);
  assert (sequence.size() == (unsigned int)n);
  nInSeq = 0;
  sequenceHasBeenSet=true;
  nextHasBeenSet=false;
  return;
}

---

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

• NonRandomEngine.h
• NonRandomEngine.cc