CLHEP::RandBreitWigner Class Reference

#include <RandBreitWigner.h>

Inheritance diagram for CLHEP::RandBreitWigner:

Public Member Functions
	RandBreitWigner (HepRandomEngine &anEngine, double a=1.0, double b=0.2)
	RandBreitWigner (HepRandomEngine *anEngine, double a=1.0, double b=0.2)
virtual	~RandBreitWigner ()
double	fire ()
double	fire (double a, double b)
double	fire (double a, double b, double c)
double	fireM2 ()
double	fireM2 (double a, double b)
double	fireM2 (double a, double b, double c)
void	fireArray (const int size, double *vect)
void	fireArray (const int size, double *vect, double a, double b)
void	fireArray (const int size, double *vect, double a, double b, double c)
double	operator() ()
double	operator() (double a, double b)
double	operator() (double a, double b, double c)
std::ostream &	put (std::ostream &os) const
std::istream &	get (std::istream &is)
std::string	name () const
HepRandomEngine &	engine ()
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)
virtual double	operator() ()
virtual std::string	name () const
virtual HepRandomEngine &	engine ()
virtual std::ostream &	put (std::ostream &os) const
virtual std::istream &	get (std::istream &is)

Static Public Member Functions
static double	shoot (double a=1.0, double b=0.2)
static double	shoot (double a, double b, double c)
static double	shootM2 (double a=1.0, double b=0.2)
static double	shootM2 (double a, double b, double c)
static void	shootArray (const int size, double *vect)
static void	shootArray (const int size, double *vect, double a, double b)
static void	shootArray (const int size, double *vect, double a, double b, double c)
static double	shoot (HepRandomEngine *anEngine, double a=1.0, double b=0.2)
static double	shoot (HepRandomEngine *anEngine, double a, double b, double c)
static double	shootM2 (HepRandomEngine *anEngine, double a=1.0, double b=0.2)
static double	shootM2 (HepRandomEngine *anEngine, double a, double b, double c)
static void	shootArray (HepRandomEngine *anEngine, const int size, double *vect)
static void	shootArray (HepRandomEngine *anEngine, const int size, double *vect, double a, double b)
static void	shootArray (HepRandomEngine *anEngine, const int size, double *vect, double a, double b, double c)
static std::string	distributionName ()
Static Public Member Functions inherited from CLHEP::HepRandom
static void	setTheSeed (long seed, int lxr=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 ()

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

Detailed Description

Author

Gabri.nosp@m.ele..nosp@m.Cosmo.nosp@m.@cer.nosp@m.n.ch

Definition at line 38 of file RandBreitWigner.h.

Constructor & Destructor Documentation

RandBreitWigner() [1/2]

CLHEP::RandBreitWigner::RandBreitWigner ( HepRandomEngine &  anEngine, double  a = 1.0, double  b = 0.2  )

inline

RandBreitWigner() [2/2]

CLHEP::RandBreitWigner::RandBreitWigner ( HepRandomEngine *  anEngine, double  a = 1.0, double  b = 0.2  )

inline

~RandBreitWigner()

CLHEP::RandBreitWigner::~RandBreitWigner ( )

virtual

Definition at line 37 of file RandBreitWigner.cc.

                                  {
}

Member Function Documentation

distributionName()

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

inlinestatic

Definition at line 132 of file RandBreitWigner.h.

{return "RandBreitWigner";}  

engine()

HepRandomEngine & CLHEP::RandBreitWigner::engine ( )

virtual

Reimplemented from CLHEP::HepRandom.

Definition at line 35 of file RandBreitWigner.cc.

{return *localEngine;}

fire() [1/3]

double CLHEP::RandBreitWigner::fire

(

)

Definition at line 202 of file RandBreitWigner.cc.

{
  return fire( defaultA, defaultB );
}

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

fire() [2/3]

double CLHEP::RandBreitWigner::fire	(	double	a,
		double	b
	)

Definition at line 207 of file RandBreitWigner.cc.

{
   double rval, displ;
 
   rval = 2.0*localEngine->flat()-1.0;
   displ = 0.5*gamma*std::tan(rval*CLHEP::halfpi);
 
   return mean + displ;
}

fire() [3/3]

double CLHEP::RandBreitWigner::fire	(	double	a,
		double	b,
		double	c
	)

Definition at line 217 of file RandBreitWigner.cc.

{
   double val, rval, displ;
 
   if ( gamma == 0.0 ) return mean;
   val = std::atan(2.0*cut/gamma);
   rval = 2.0*localEngine->flat()-1.0;
   displ = 0.5*gamma*std::tan(rval*val);
 
   return mean + displ;
}

fireArray() [1/3]

void CLHEP::RandBreitWigner::fireArray	(	const int	size,
		double *	vect
	)

Definition at line 261 of file RandBreitWigner.cc.

{
  for( double* v = vect; v != vect + size; ++v )
    *v = fire(defaultA, defaultB );
}

fireArray() [2/3]

void CLHEP::RandBreitWigner::fireArray	(	const int	size,
		double *	vect,
		double	a,
		double	b
	)

Definition at line 267 of file RandBreitWigner.cc.

{
  for( double* v = vect; v != vect + size; ++v )
    *v = fire( a, b );
}

fireArray() [3/3]

void CLHEP::RandBreitWigner::fireArray	(	const int	size,
		double *	vect,
		double	a,
		double	b,
		double	c
	)

Definition at line 274 of file RandBreitWigner.cc.

{
  for( double* v = vect; v != vect + size; ++v )
    *v = fire( a, b, c );
}

fireM2() [1/3]

double CLHEP::RandBreitWigner::fireM2

(

)

Definition at line 229 of file RandBreitWigner.cc.

{
  return fireM2( defaultA, defaultB );
}

Referenced by dist_layout(), and fireM2().

fireM2() [2/3]

double CLHEP::RandBreitWigner::fireM2	(	double	a,
		double	b
	)

Definition at line 234 of file RandBreitWigner.cc.

{
   double val, rval, displ;
 
   if ( gamma == 0.0 ) return mean;
   val = std::atan(-mean/gamma);
   rval = RandFlat::shoot(localEngine.get(),val, CLHEP::halfpi);
   displ = gamma*std::tan(rval);
 
   return std::sqrt(mean*mean + mean*displ);
}

fireM2() [3/3]

double CLHEP::RandBreitWigner::fireM2	(	double	a,
		double	b,
		double	c
	)

Definition at line 246 of file RandBreitWigner.cc.

{
   double rval, displ;
   double lower, upper, tmp;
 
   if ( gamma == 0.0 ) return mean;
   tmp = std::max(0.0,(mean-cut));
   lower = std::atan( (tmp*tmp-mean*mean)/(mean*gamma) );
   upper = std::atan( ((mean+cut)*(mean+cut)-mean*mean)/(mean*gamma) );
   rval = RandFlat::shoot(localEngine.get(),lower, upper);
   displ = gamma*std::tan(rval);
 
   return std::sqrt(std::max(0.0, mean*mean + mean*displ));
}

get()

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

virtual

Reimplemented from CLHEP::HepRandom.

Definition at line 302 of file RandBreitWigner.cc.

                                                    {
  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", defaultA)) {
    std::vector<unsigned long> t(2);
    is >> defaultA >> t[0] >> t[1]; defaultA = DoubConv::longs2double(t); 
    is >> defaultB >> t[0] >> t[1]; defaultB = DoubConv::longs2double(t); 
    return is;
  }
  // is >> defaultA encompassed by possibleKeywordInput
  is >> defaultB;
  return is;
}

name()

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

virtual

Reimplemented from CLHEP::HepRandom.

Definition at line 34 of file RandBreitWigner.cc.

{return "RandBreitWigner";}

Referenced by get(), and put().

operator()() [1/3]

double CLHEP::RandBreitWigner::operator() ( )

virtual

Reimplemented from CLHEP::HepRandom.

Definition at line 40 of file RandBreitWigner.cc.

                                   {
   return fire( defaultA, defaultB );
}

operator()() [2/3]

double CLHEP::RandBreitWigner::operator()	(	double	a,
		double	b
	)

Definition at line 44 of file RandBreitWigner.cc.

                                                       {
   return fire( a, b );
}

operator()() [3/3]

double CLHEP::RandBreitWigner::operator()	(	double	a,
		double	b,
		double	c
	)

Definition at line 48 of file RandBreitWigner.cc.

                                                                 {
   return fire( a, b, c );
}

put()

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

virtual

Reimplemented from CLHEP::HepRandom.

Definition at line 282 of file RandBreitWigner.cc.

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

shoot() [1/4]

double CLHEP::RandBreitWigner::shoot ( double  a, double  b, double  c  )

static

Definition at line 62 of file RandBreitWigner.cc.

{
   double val, rval, displ;
 
   if ( gamma == 0.0 ) return mean;
   val = std::atan(2.0*cut/gamma);
   rval = 2.0*HepRandom::getTheEngine()->flat()-1.0;
   displ = 0.5*gamma*std::tan(rval*val);
 
   return mean + displ;
}

shoot() [2/4]

double CLHEP::RandBreitWigner::shoot ( double  a = 1.0, double  b = 0.2  )

static

Definition at line 52 of file RandBreitWigner.cc.

{
   double rval, displ;
 
   rval = 2.0*HepRandom::getTheEngine()->flat()-1.0;
   displ = 0.5*gamma*std::tan(rval*CLHEP::halfpi);
 
   return mean + displ;
}

Referenced by captureStatics(), layout(), randomizeStatics(), shootArray(), and user_layout().

shoot() [3/4]

double CLHEP::RandBreitWigner::shoot ( HepRandomEngine *  anEngine, double  a, double  b, double  c  )

static

Definition at line 135 of file RandBreitWigner.cc.

{
   double val, rval, displ;
 
   if ( gamma == 0.0 ) return mean;
   val = std::atan(2.0*cut/gamma);
   rval = 2.0*anEngine->flat()-1.0;
   displ = 0.5*gamma*std::tan(rval*val);
 
   return mean + displ;
}

shoot() [4/4]

double CLHEP::RandBreitWigner::shoot ( HepRandomEngine *  anEngine, double  a = 1.0, double  b = 0.2  )

static

Definition at line 124 of file RandBreitWigner.cc.

{
   double rval, displ;
 
   rval = 2.0*anEngine->flat()-1.0;
   displ = 0.5*gamma*std::tan(rval*CLHEP::halfpi);
 
   return mean + displ;
}

shootArray() [1/6]

void CLHEP::RandBreitWigner::shootArray ( const int  size, double *  vect  )

static

Definition at line 101 of file RandBreitWigner.cc.

{
  for( double* v = vect; v != vect + size; ++v )
    *v = shoot( 1.0, 0.2 );
}

shootArray() [2/6]

void CLHEP::RandBreitWigner::shootArray ( const int  size, double *  vect, double  a, double  b  )

static

Definition at line 107 of file RandBreitWigner.cc.

{
  for( double* v = vect; v != vect + size; ++v )
    *v = shoot( a, b );
}

shootArray() [3/6]

void CLHEP::RandBreitWigner::shootArray ( const int  size, double *  vect, double  a, double  b, double  c  )

static

Definition at line 114 of file RandBreitWigner.cc.

{
  for( double* v = vect; v != vect + size; ++v )
    *v = shoot( a, b, c );
}

shootArray() [4/6]

void CLHEP::RandBreitWigner::shootArray ( HepRandomEngine *  anEngine, const int  size, double *  vect  )

static

Definition at line 177 of file RandBreitWigner.cc.

{
  for( double* v = vect; v != vect + size; ++v )
    *v = shoot( anEngine, 1.0, 0.2 );
}

shootArray() [5/6]

void CLHEP::RandBreitWigner::shootArray ( HepRandomEngine *  anEngine, const int  size, double *  vect, double  a, double  b  )

static

Definition at line 184 of file RandBreitWigner.cc.

{
  for( double* v = vect; v != vect + size; ++v )
    *v = shoot( anEngine, a, b );
}

shootArray() [6/6]

void CLHEP::RandBreitWigner::shootArray ( HepRandomEngine *  anEngine, const int  size, double *  vect, double  a, double  b, double  c  )

static

Definition at line 192 of file RandBreitWigner.cc.

{
  for( double* v = vect; v != vect + size; ++v )
    *v = shoot( anEngine, a, b, c );
}

shootM2() [1/4]

double CLHEP::RandBreitWigner::shootM2 ( double  a, double  b, double  c  )

static

Definition at line 86 of file RandBreitWigner.cc.

{
   double rval, displ;
   double lower, upper, tmp;
 
   if ( gamma == 0.0 ) return mean;
   tmp = std::max(0.0,(mean-cut));
   lower = std::atan( (tmp*tmp-mean*mean)/(mean*gamma) );
   upper = std::atan( ((mean+cut)*(mean+cut)-mean*mean)/(mean*gamma) );
   rval = RandFlat::shoot(lower, upper);
   displ = gamma*std::tan(rval);
 
   return std::sqrt(std::max(0.0, mean*mean + mean*displ));
}

shootM2() [2/4]

double CLHEP::RandBreitWigner::shootM2 ( double  a = 1.0, double  b = 0.2  )

static

Definition at line 74 of file RandBreitWigner.cc.

{
   double val, rval, displ;
 
   if ( gamma == 0.0 ) return mean;
   val = std::atan(-mean/gamma);
   rval = RandFlat::shoot(val, CLHEP::halfpi);
   displ = gamma*std::tan(rval);
 
   return std::sqrt(mean*mean + mean*displ);
}

Referenced by layout(), and user_layout().

shootM2() [3/4]

double CLHEP::RandBreitWigner::shootM2 ( HepRandomEngine *  anEngine, double  a, double  b, double  c  )

static

Definition at line 161 of file RandBreitWigner.cc.

{
   double rval, displ;
   double lower, upper, tmp;
 
   if ( gamma == 0.0 ) return mean;
   tmp = std::max(0.0,(mean-cut));
   lower = std::atan( (tmp*tmp-mean*mean)/(mean*gamma) );
   upper = std::atan( ((mean+cut)*(mean+cut)-mean*mean)/(mean*gamma) );
   rval = RandFlat::shoot(anEngine, lower, upper);
   displ = gamma*std::tan(rval);
 
   return std::sqrt( std::max(0.0, mean*mean+mean*displ) );
}

shootM2() [4/4]

double CLHEP::RandBreitWigner::shootM2 ( HepRandomEngine *  anEngine, double  a = 1.0, double  b = 0.2  )

static

Definition at line 148 of file RandBreitWigner.cc.

{
   double val, rval, displ;
 
   if ( gamma == 0.0 ) return mean;
   val = std::atan(-mean/gamma);
   rval = RandFlat::shoot(anEngine,val, CLHEP::halfpi);
   displ = gamma*std::tan(rval);
 
   return std::sqrt(mean*mean + mean*displ);
}

---

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

• RandBreitWigner.h
• RandBreitWigner.cc