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 36 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 35 of file RandBreitWigner.cc.

                                  {
}

Member Function Documentation

distributionName()

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

inlinestatic

Definition at line 130 of file RandBreitWigner.h.

{return "RandBreitWigner";}  

engine()

HepRandomEngine & CLHEP::RandBreitWigner::engine ( )

virtual

Reimplemented from CLHEP::HepRandom.

Definition at line 33 of file RandBreitWigner.cc.

{return *localEngine;}

fire() [1/3]

double CLHEP::RandBreitWigner::fire

(

)

Definition at line 200 of file RandBreitWigner.cc.

{
  return fire( defaultA, defaultB );
}

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

fire() [2/3]

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

Definition at line 205 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 215 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 259 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 265 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 272 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 227 of file RandBreitWigner.cc.

{
  return fireM2( defaultA, defaultB );
}

Referenced by fireM2().

fireM2() [2/3]

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

Definition at line 232 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 244 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 293 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 32 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 38 of file RandBreitWigner.cc.

                                   {
   return fire( defaultA, defaultB );
}

operator()() [2/3]

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

Definition at line 42 of file RandBreitWigner.cc.

                                                       {
   return fire( a, b );
}

operator()() [3/3]

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

Definition at line 46 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 280 of file RandBreitWigner.cc.

                                                          {
  int 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;
}

shoot() [1/4]

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

static

Definition at line 60 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 50 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 shootArray().

shoot() [3/4]

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

static

Definition at line 133 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 122 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 99 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 105 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 112 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 175 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 182 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 190 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 84 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 72 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);
}

shootM2() [3/4]

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

static

Definition at line 159 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 146 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