#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 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

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.

40{ }

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.

70{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 int 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 = v[6];
  t[0] = v[7]; t[1] = v[8]; randomInterval = DoubConv::longs2double(t);
  sequence.clear();
  for (unsigned int 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(), and getState().

◆ name()

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

virtual

Implements CLHEP::HepRandomEngine.

Definition at line 31 of file NonRandomEngine.cc.

31{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:

Public Member Functions

Static Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ NonRandomEngine()

◆ ~NonRandomEngine()

Member Function Documentation

◆ beginTag()

◆ engineName()

◆ flat()

◆ flatArray()

◆ get() [1/2]

◆ get() [2/2]

◆ getState() [1/2]

◆ getState() [2/2]

◆ name()

◆ put() [1/2]

◆ put() [2/2]

◆ setNextRandom()

◆ setRandomInterval()

◆ setRandomSequence()