#include <RandPoissonQ.h>

Inheritance diagram for CLHEP::RandPoissonQ:

Public Member Functions
	RandPoissonQ (HepRandomEngine &anEngine, double m=1.0)

	RandPoissonQ (HepRandomEngine *anEngine, double m=1.0)

virtual	~RandPoissonQ ()

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

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

long	fire ()

long	fire (double m)

void	fireArray (const int size, long *vect)

void	fireArray (const int size, long *vect, double m)

double	operator() ()

double	operator() (double m)

std::string	name () const

HepRandomEngine &	engine ()

Public Member Functions inherited from CLHEP::RandPoisson
	RandPoisson (HepRandomEngine &anEngine, double m=1.0)

	RandPoisson (HepRandomEngine *anEngine, double m=1.0)

virtual	~RandPoisson ()

long	fire ()

long	fire (double m)

void	fireArray (const int size, long *vect)

void	fireArray (const int size, long *vect, double m)

double	operator() (double m)

Public Member Functions inherited from CLHEP::HepRandom
	HepRandom ()

	HepRandom (long seed)

	HepRandom (HepRandomEngine &algorithm)

	HepRandom (HepRandomEngine *algorithm)

virtual	~HepRandom ()

double	flat ()

void	flatArray (const int size, double *vect)

double	flat (HepRandomEngine *theNewEngine)

void	flatArray (HepRandomEngine theNewEngine, const int size, double vect)

Static Public Member Functions
static long	shoot (double m=1.0)

static void	shootArray (const int size, long *vect, double m=1.0)

static long	shoot (HepRandomEngine *anEngine, double m=1.0)

static void	shootArray (HepRandomEngine anEngine, const int size, long vect, double m=1.0)

static std::string	distributionName ()

static int	tableBoundary ()

Static Public Member Functions inherited from CLHEP::RandPoisson
static long	shoot (double m=1.0)

static void	shootArray (const int size, long *vect, double m=1.0)

static long	shoot (HepRandomEngine *anEngine, double m=1.0)

static void	shootArray (HepRandomEngine anEngine, const int size, long vect, double m=1.0)

static std::string	distributionName ()

Static Public Member Functions inherited from CLHEP::HepRandom
static void	setTheSeed (long seed, int lux=3)

static long	getTheSeed ()

static void	setTheSeeds (const long *seeds, int aux=-1)

static const long *	getTheSeeds ()

static void	getTheTableSeeds (long *seeds, int index)

static HepRandom *	getTheGenerator ()

static void	setTheEngine (HepRandomEngine *theNewEngine)

static HepRandomEngine *	getTheEngine ()

static void	saveEngineStatus (const char filename[]="Config.conf")

static void	restoreEngineStatus (const char filename[]="Config.conf")

static std::ostream &	saveFullState (std::ostream &os)

static std::istream &	restoreFullState (std::istream &is)

static std::ostream &	saveDistState (std::ostream &os)

static std::istream &	restoreDistState (std::istream &is)

static std::ostream &	saveStaticRandomStates (std::ostream &os)

static std::istream &	restoreStaticRandomStates (std::istream &is)

static void	showEngineStatus ()

static int	createInstance ()

static std::string	distributionName ()

Static Public Attributes
static const double	MAXIMUM_POISSON_DEVIATE = 2.0E9

Additional Inherited Members
Protected Member Functions inherited from CLHEP::RandPoisson
HepRandomEngine *	getLocalEngine ()

Static Protected Member Functions inherited from CLHEP::RandPoisson
static double	getOldMean ()

static double	getMaxMean ()

static void	setOldMean (double val)

static double *	getPStatus ()

static void	setPStatus (double sq, double alxm, double g1)

Protected Attributes inherited from CLHEP::RandPoisson
double	meanMax

double	defaultMean

Static Protected Attributes inherited from CLHEP::HepRandom
static const long	seedTable [215][2]

Detailed Description

Author

Definition at line 32 of file RandPoissonQ.h.

Constructor & Destructor Documentation

CLHEP::RandPoissonQ::RandPoissonQ	(	HepRandomEngine &	anEngine,
		double	m = `1.0`
	)

inline

CLHEP::RandPoissonQ::RandPoissonQ	(	HepRandomEngine *	anEngine,
		double	m = `1.0`
	)

inline

CLHEP::RandPoissonQ::~RandPoissonQ ( )

virtual

Definition at line 79 of file RandPoissonQ.cc.

79 {

80 }

Member Function Documentation

static std::string CLHEP::RandPoissonQ::distributionName ( )

inlinestatic

Definition at line 102 of file RandPoissonQ.h.

102 {return "RandPoissonQ";}

HepRandomEngine & CLHEP::RandPoissonQ::engine ( )

virtual

Reimplemented from CLHEP::RandPoisson.

Definition at line 49 of file RandPoissonQ.cc.

References CLHEP::RandPoisson::engine().

49 {return RandPoisson::engine();}

CLHEP::RandPoisson::engine

HepRandomEngine & engine()

Definition: RandPoisson.cc:36

long CLHEP::RandPoissonQ::fire ( )

Definition at line 132 of file RandPoissonQ.cc.

References CLHEP::RandPoisson::defaultMean, and CLHEP::RandPoisson::getLocalEngine().

Referenced by fireArray(), and operator()().

                         {
   if ( defaultMean < LAST_MU + S ) {
     return poissonDeviateSmall ( getLocalEngine(), defaultMean );
   } else {
     return poissonDeviateQuick ( getLocalEngine(), a0, a1, a2, sigma );
   }
 } // fire()

long CLHEP::RandPoissonQ::fire ( double m )

Definition at line 128 of file RandPoissonQ.cc.

References CLHEP::RandPoisson::getLocalEngine(), and shoot().

                                    {
   return shoot(getLocalEngine(), mean);
 }

void CLHEP::RandPoissonQ::fireArray	(	const int	size,
		long *	vect
	)

Definition at line 184 of file RandPoissonQ.cc.

References CLHEP::RandPoisson::defaultMean, fire(), and test::v.

                                                        {
   for( long* v = vect; v != vect + size; ++v )
     *v = fire( defaultMean );
 }

void CLHEP::RandPoissonQ::fireArray	(	const int	size,
		long *	vect,
		double	m
	)

Definition at line 179 of file RandPoissonQ.cc.

References fire(), and test::v.

                                                                  {
   for( long* v = vect; v != vect + size; ++v )
     *v = fire( m );
 }

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

virtual

Reimplemented from CLHEP::RandPoisson.

Definition at line 571 of file RandPoissonQ.cc.

References CLHEP::RandPoisson::get(), CLHEP::DoubConv::longs2double(), name(), and CLHEP::possibleKeywordInput().

                                                  {
   std::string inName;
   is >> inName;
   if (inName != name()) {
     is.clear(std::ios::badbit | is.rdstate());
     std::cerr << "Mismatch when expecting to read state of a "
               << name() << " distribution\n"
           << "Name found was " << inName
           << "\nistream is left in the badbit state\n";
     return is;
   }
   if (possibleKeywordInput(is, "Uvec", a0)) {
     std::vector<unsigned long> t(2);
     is >> a0 >> t[0] >> t[1]; a0 = DoubConv::longs2double(t); 
     is >> a1 >> t[0] >> t[1]; a1 = DoubConv::longs2double(t); 
     is >> a2 >> t[0] >> t[1]; a2 = DoubConv::longs2double(t); 
     is >> sigma >> t[0] >> t[1]; sigma = DoubConv::longs2double(t); 
     RandPoisson::get(is);
     return is;
   }
   // is >> a0 encompassed by possibleKeywordInput
   is >> a1 >> a2 >> sigma;
   RandPoisson::get(is);
   return is;
 }

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

virtual

Reimplemented from CLHEP::RandPoisson.

Definition at line 48 of file RandPoissonQ.cc.

Referenced by get(), and put().

48 {return "RandPoissonQ";}

double CLHEP::RandPoissonQ::operator() ( )

virtual

Reimplemented from CLHEP::RandPoisson.

Definition at line 120 of file RandPoissonQ.cc.

References fire().

                                 {
   return (double) fire();
 }

double CLHEP::RandPoissonQ::operator() ( double m )

Definition at line 124 of file RandPoissonQ.cc.

References fire().

                                              {
   return (double) fire(mean);
 }

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

virtual

Reimplemented from CLHEP::RandPoisson.

Definition at line 544 of file RandPoissonQ.cc.

References CLHEP::DoubConv::dto2longs(), name(), gammaraytel::pr, and CLHEP::RandPoisson::put().

                                                        {
   int pr=os.precision(20);
   std::vector<unsigned long> t(2);
   os << " " << name() << "\n";
   os << "Uvec" << "\n";
   t = DoubConv::dto2longs(a0);
   os << a0 << " " << t[0] << " " << t[1] << "\n";
   t = DoubConv::dto2longs(a1);
   os << a1 << " " << t[0] << " " << t[1] << "\n";
   t = DoubConv::dto2longs(a2);
   os << a2 << " " << t[0] << " " << t[1] << "\n";
   t = DoubConv::dto2longs(sigma);
   os << sigma << " " << t[0] << " " << t[1] << "\n";
   RandPoisson::put(os);
   os.precision(pr);
   return os;
 #ifdef REMOVED
   int pr=os.precision(20);
   os << " " << name() << "\n";
   os << a0 << " " << a1 << " " << a2 << "\n";
   os << sigma << "\n";
   RandPoisson::put(os);
   os.precision(pr);
   return os;
 #endif
 }

long CLHEP::RandPoissonQ::shoot ( double m = 1.0 )

static

Definition at line 116 of file RandPoissonQ.cc.

References CLHEP::HepRandom::getTheEngine().

Referenced by fire(), and shootArray().

                                   {
   return shoot(getTheEngine(), xm);
 }

long CLHEP::RandPoissonQ::shoot	(	HepRandomEngine *	anEngine,
		double	m = `1.0`
	)

static

Definition at line 140 of file RandPoissonQ.cc.

                                                                {
 
   // The following variables, static to this method, apply to the 
   // last time a large mean was supplied; they obviate certain calculations
   // if consecutive calls use the same mean.
 
   static double lastLargeMean = -1.;    // Mean from previous shoot 
                     // requiring poissonDeviateQuick()
   static double lastA0;     
   static double lastA1;     
   static double lastA2;     
   static double lastSigma;      
 
   if ( mean < LAST_MU + S ) {
     return poissonDeviateSmall ( anEngine, mean );
   } else {
     if ( mean != lastLargeMean ) {
       // Compute the coefficients defining the quadratic transformation from a 
       // Gaussian to a Poisson for this mean.  Also save these for next time.
       double sig2 = mean * (.9998654 - .08346/mean);
       lastSigma = std::sqrt(sig2);
       double t = 1./sig2;
       lastA2 = t*(1./6.) + t*t*(1./324.);
       lastA1 = std::sqrt (1-2*lastA2*lastA2*sig2);
       lastA0 = mean + .5 - sig2 * lastA2;
     }
     return poissonDeviateQuick ( anEngine, lastA0, lastA1, lastA2, lastSigma );
   }
 
 } // shoot (anEngine, mean)

void CLHEP::RandPoissonQ::shootArray	(	const int	size,
		long *	vect,
		double	m = `1.0`
	)

static

Definition at line 171 of file RandPoissonQ.cc.

References shoot(), and test::v.

                                                                   {
   for( long* v = vect; v != vect + size; ++v )
     *v = shoot(m);
      // Note: We could test for m > 100, and if it is, precompute a0, a1, a2, 
      // and sigma and call the appropriate form of poissonDeviateQuick.  
      // But since those are cached anyway, not much time would be saved.
 }

static void CLHEP::RandPoissonQ::shootArray	(	HepRandomEngine *	anEngine,
		const int	size,
		long *	vect,
		double	m = `1.0`
	)

static

static int CLHEP::RandPoissonQ::tableBoundary ( )

inlinestatic

Field Documentation

const double CLHEP::RandPoissonQ::MAXIMUM_POISSON_DEVIATE = 2.0E9

static

Definition at line 109 of file RandPoissonQ.h.

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

Public Member Functions

Static Public Member Functions

Static Public Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Field Documentation