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 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 ()

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 37 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 33 of file RandBreitWigner.cc.

                                  {
}

Member Function Documentation

distributionName()

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

inlinestatic

Definition at line 131 of file RandBreitWigner.h.

{return "RandBreitWigner";}  

engine()

HepRandomEngine & CLHEP::RandBreitWigner::engine ( )

virtual

Reimplemented from CLHEP::HepRandom.

Definition at line 31 of file RandBreitWigner.cc.

{return *localEngine;}

fire() [1/3]

double CLHEP::RandBreitWigner::fire

(

)

Definition at line 198 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 203 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 213 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 257 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 263 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 270 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 225 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 230 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 242 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 291 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 30 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 36 of file RandBreitWigner.cc.

                                   {
   return fire( defaultA, defaultB );
}

operator()() [2/3]

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

Definition at line 40 of file RandBreitWigner.cc.

                                                       {
   return fire( a, b );
}

operator()() [3/3]

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

Definition at line 44 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 278 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 58 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 48 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 131 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 120 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 97 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 103 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 110 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 173 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 180 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 188 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 82 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 70 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 157 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 144 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