CLHEP Namespace Reference

Namespaces
	detail

Classes
struct	do_nothing_deleter
class	DoubConv
class	DoubConvException
class	DualRand
class	EngineFactory
class	Hep2Vector
class	Hep3RotationInterface
class	Hep3Vector
class	Hep4RotationInterface
class	HepAxisAngle
class	HepBoost
class	HepBoostX
class	HepBoostY
class	HepBoostZ
class	HepEulerAngles
class	HepJamesRandom
class	HepLorentzRotation
class	HepLorentzVector
class	HepRandom
class	HepRandomEngine
struct	HepRep3x3
struct	HepRep4x4
struct	HepRep4x4Symmetric
class	HepRotation
class	HepRotationX
class	HepRotationY
class	HepRotationZ
class	HepStat
class	MixMaxRng
class	MTwistEngine
class	noncopyable
class	NonRandomEngine
class	RandBinomial
class	RandBit
class	RandBreitWigner
class	RandChiSquare
class	RandExponential
class	RandExpZiggurat
class	RandFlat
class	RandGamma
class	RandGauss
class	RandGaussQ
class	RandGaussZiggurat
class	RandGeneral
class	RandLandau
class	RandPoisson
class	RandPoissonQ
class	RandStudentT
class	RanecuEngine
class	Ranlux64Engine
class	RanluxEngine
class	RanshiEngine
struct	rng_state_st
class	StaticRandomStates
class	Tcomponent

Typedefs
typedef uint64_t	myuint
typedef struct rng_state_st	rng_state_t
typedef uint32_t	myID_t
template<typename T >
using	shared_ptr = std::shared_ptr< T >
template<typename T >
using	weak_ptr = std::weak_ptr< T >
typedef HepLorentzVector	HepLorentzVectorD
typedef HepLorentzVector	HepLorentzVectorF
typedef Hep3Vector	HepThreeVectorD
typedef Hep3Vector	HepThreeVectorF

Enumerations
enum	ZMpvMetric_t { TimePositive, TimeNegative }

Functions
unsigned long	crc32ul (const std::string &s)
template<class E >
unsigned long	engineIDulong ()
int	rng_get_N (void)
rng_state_t *	rng_alloc ()
int	rng_free (rng_state_t *X)
rng_state_t *	rng_copy (myuint *Y)
void	read_state (rng_state_t *X, const char filename[])
void	print_state (rng_state_t *X)
int	iterate (rng_state_t *X)
myuint	iterate_raw_vec (myuint *Y, myuint sumtotOld)
void	seed_uniquestream (rng_state_t *X, myID_t clusterID, myID_t machineID, myID_t runID, myID_t streamID)
void	seed_spbox (rng_state_t *X, myuint seed)
void	seed_vielbein (rng_state_t *X, unsigned int i)
void	fill_array (rng_state_t *X, unsigned int n, double *array)
void	iterate_and_fill_array (rng_state_t *X, double *array)
myuint	precalc (rng_state_t *X)
myuint	apply_bigskip (myuint *Vout, myuint *Vin, myID_t clusterID, myID_t machineID, myID_t runID, myID_t streamID)
void	branch_inplace (rng_state_t *Xin, myID_t *ID)
myuint	modadd (myuint foo, myuint bar)
myuint	modmulM61 (myuint s, myuint a)
myuint	fmodmulM61 (myuint cum, myuint s, myuint a)
myuint	GET_BY_MACRO (rng_state_t *X)
double	get_next_float_BY_MACRO (rng_state_t *X)
std::ostream &	operator<< (std::ostream &os, const HepRandom &dist)
std::istream &	operator>> (std::istream &is, HepRandom &dist)
std::ostream &	operator<< (std::ostream &os, const HepRandomEngine &e)
std::istream &	operator>> (std::istream &is, HepRandomEngine &e)
template<class IS , class T >
bool	possibleKeywordInput (IS &is, const std::string &key, T &t)
std::ostream &	operator<< (std::ostream &os, const HepAxisAngle &aa)
std::istream &	operator>> (std::istream &is, HepAxisAngle &aa)
HepBoost	inverseOf (const HepBoost &lt)
std::ostream &	operator<< (std::ostream &os, const HepBoost &b)
HepBoostX	inverseOf (const HepBoostX &b)
std::ostream &	operator<< (std::ostream &os, const HepBoostX &b)
HepBoostY	inverseOf (const HepBoostY &b)
std::ostream &	operator<< (std::ostream &os, const HepBoostY &b)
HepBoostZ	inverseOf (const HepBoostZ &b)
std::ostream &	operator<< (std::ostream &os, const HepBoostZ &b)
std::ostream &	operator<< (std::ostream &os, const HepEulerAngles &aa)
std::istream &	operator>> (std::istream &is, HepEulerAngles &aa)
HepLorentzRotation	inverseOf (const HepLorentzRotation &lt)
HepLorentzRotation	operator* (const HepRotation &r, const HepLorentzRotation &lt)
HepLorentzRotation	operator* (const HepRotationX &r, const HepLorentzRotation &lt)
HepLorentzRotation	operator* (const HepRotationY &r, const HepLorentzRotation &lt)
HepLorentzRotation	operator* (const HepRotationZ &r, const HepLorentzRotation &lt)
std::ostream &	operator<< (std::ostream &os, const HepLorentzRotation &lt)
bool	operator== (const HepRotation &r, const HepLorentzRotation &lt)
bool	operator!= (const HepRotation &r, const HepLorentzRotation &lt)
bool	operator<= (const HepRotation &r, const HepLorentzRotation &lt)
bool	operator>= (const HepRotation &r, const HepLorentzRotation &lt)
bool	operator< (const HepRotation &r, const HepLorentzRotation &lt)
bool	operator> (const HepRotation &r, const HepLorentzRotation &lt)
bool	operator== (const HepBoost &b, const HepLorentzRotation &lt)
bool	operator!= (const HepBoost &b, const HepLorentzRotation &lt)
bool	operator<= (const HepBoost &b, const HepLorentzRotation &lt)
bool	operator>= (const HepBoost &b, const HepLorentzRotation &lt)
bool	operator< (const HepBoost &b, const HepLorentzRotation &lt)
bool	operator> (const HepBoost &b, const HepLorentzRotation &lt)
HepLorentzVector	rotationXOf (const HepLorentzVector &vec, double delta)
HepLorentzVector	rotationYOf (const HepLorentzVector &vec, double delta)
HepLorentzVector	rotationZOf (const HepLorentzVector &vec, double delta)
HepLorentzVector	rotationOf (const HepLorentzVector &vec, const Hep3Vector &axis, double delta)
HepLorentzVector	rotationOf (const HepLorentzVector &vec, const HepAxisAngle &ax)
HepLorentzVector	rotationOf (const HepLorentzVector &vec, const HepEulerAngles &e)
HepLorentzVector	rotationOf (const HepLorentzVector &vec, double phi, double theta, double psi)
HepLorentzVector	boostXOf (const HepLorentzVector &vec, double beta)
HepLorentzVector	boostYOf (const HepLorentzVector &vec, double beta)
HepLorentzVector	boostZOf (const HepLorentzVector &vec, double beta)
HepLorentzVector	boostOf (const HepLorentzVector &vec, const Hep3Vector &betaVector)
HepLorentzVector	boostOf (const HepLorentzVector &vec, const Hep3Vector &axis, double beta)
std::ostream &	operator<< (std::ostream &, const HepLorentzVector &)
std::istream &	operator>> (std::istream &, HepLorentzVector &)
HepLorentzVector	operator* (const HepLorentzVector &, double a)
HepLorentzVector	operator* (double a, const HepLorentzVector &)
HepLorentzVector	operator/ (const HepLorentzVector &, double a)
HepRotation	inverseOf (const HepRotation &r)
HepRotation	operator* (const HepRotationX &rx, const HepRotation &r)
HepRotation	operator* (const HepRotationY &ry, const HepRotation &r)
HepRotation	operator* (const HepRotationZ &rz, const HepRotation &r)
std::ostream &	operator<< (std::ostream &os, const HepRotation &r)
HepRotationX	inverseOf (const HepRotationX &r)
std::ostream &	operator<< (std::ostream &os, const HepRotationX &r)
HepRotationY	inverseOf (const HepRotationY &r)
std::ostream &	operator<< (std::ostream &os, const HepRotationY &r)
HepRotationZ	inverseOf (const HepRotationZ &r)
std::ostream &	operator<< (std::ostream &os, const HepRotationZ &r)
Hep3Vector	rotationXOf (const Hep3Vector &vec, double delta)
Hep3Vector	rotationYOf (const Hep3Vector &vec, double delta)
Hep3Vector	rotationZOf (const Hep3Vector &vec, double delta)
Hep3Vector	rotationOf (const Hep3Vector &vec, const Hep3Vector &axis, double delta)
Hep3Vector	rotationOf (const Hep3Vector &vec, const HepAxisAngle &ax)
Hep3Vector	rotationOf (const Hep3Vector &vec, double phi, double theta, double psi)
Hep3Vector	rotationOf (const Hep3Vector &vec, const HepEulerAngles &e)
std::ostream &	operator<< (std::ostream &, const Hep3Vector &)
std::istream &	operator>> (std::istream &, Hep3Vector &)
Hep3Vector	operator/ (const Hep3Vector &, double a)
Hep3Vector	operator+ (const Hep3Vector &, const Hep3Vector &)
Hep3Vector	operator- (const Hep3Vector &, const Hep3Vector &)
double	operator* (const Hep3Vector &, const Hep3Vector &)
Hep3Vector	operator* (const Hep3Vector &, double a)
Hep3Vector	operator* (double a, const Hep3Vector &)
std::ostream &	operator<< (std::ostream &, const Hep2Vector &)
std::istream &	operator>> (std::istream &, Hep2Vector &)
double	operator* (const Hep2Vector &a, const Hep2Vector &b)
Hep2Vector	operator* (const Hep2Vector &p, double a)
Hep2Vector	operator* (double a, const Hep2Vector &p)
Hep2Vector	operator/ (const Hep2Vector &p, double a)
Hep2Vector	operator+ (const Hep2Vector &a, const Hep2Vector &b)
Hep2Vector	operator- (const Hep2Vector &a, const Hep2Vector &b)
static const Hep2Vector	X_HAT2 (1.0, 0.0)
static const Hep2Vector	Y_HAT2 (0.0, 1.0)
static void	ZMpvAxisAngleRep (const HepAxisAngle &aa, double array[])
void	ZMinputAxisAngle (std::istream &is, double &x, double &y, double &z, double &delta)
template<class E >
static HepRandomEngine *	makeAnEngine (const std::string &tag, std::istream &is)
template<class E >
static HepRandomEngine *	makeAnEngine (const std::vector< unsigned long > &v)
static std::vector< unsigned long >	gen_crc_table ()
static void	ZMpvEulerAnglesRep (const HepEulerAngles &ex, double array[])
void	ZMinput3doubles (std::istream &is, const char *type, double &x, double &y, double &z)
double	transformSmall (double r)
uint64_t	MULWU (uint64_t)
myuint	get_next (rng_state_t *X)
double	get_next_float (rng_state_t *X)
static double	StirlingCorrection (long int k)
double	gammln (double xx)
static double	normal (HepRandomEngine *eptr)
static double	safe_acos (double x)
static double	safe_acos (double x)
static void	correctByPi (double &psi1, double &phi1)
static void	correctPsiPhi (double rxz, double rzx, double ryz, double rzy, double &psi1, double &phi1)
static double	safe_acos (double x)
static double	safe_acos (double x)
static double	safe_acos (double x)
const Hep3Vector	HepXHat (1.0, 0.0, 0.0)
const Hep3Vector	HepYHat (0.0, 1.0, 0.0)
const Hep3Vector	HepZHat (0.0, 0.0, 1.0)
void	ZMinput2doubles (std::istream &is, const char *type, double &x, double &y)

Variables
const int	N = 256
static const int	HepRandomGenActive = HepRandom::createInstance()
static const double	Avogadro = 6.02214179e+23/mole
static const double	c_light = 2.99792458e+8 * m/s
static const double	c_squared = c_light * c_light
static const double	h_Planck = 6.62606896e-34 * joule*s
static const double	hbar_Planck = h_Planck/twopi
static const double	hbarc = hbar_Planck * c_light
static const double	hbarc_squared = hbarc * hbarc
static const double	electron_charge = - eplus
static const double	e_squared = eplus * eplus
static const double	electron_mass_c2 = 0.510998910 * MeV
static const double	proton_mass_c2 = 938.272013 * MeV
static const double	neutron_mass_c2 = 939.56536 * MeV
static const double	amu_c2 = 931.494028 * MeV
static const double	amu = amu_c2/c_squared
static const double	mu0 = 4*pi*1.e-7 * henry/m
static const double	epsilon0 = 1./(c_squared*mu0)
static const double	elm_coupling = e_squared/(4*pi*epsilon0)
static const double	fine_structure_const = elm_coupling/hbarc
static const double	classic_electr_radius = elm_coupling/electron_mass_c2
static const double	electron_Compton_length = hbarc/electron_mass_c2
static const double	Bohr_radius = electron_Compton_length/fine_structure_const
static const double	alpha_rcl2
static const double	twopi_mc2_rcl2
static const double	k_Boltzmann = 8.617343e-11 * MeV/kelvin
static const double	STP_Temperature = 273.15*kelvin
static const double	STP_Pressure = 1.*atmosphere
static const double	kGasThreshold = 10.*mg/cm3
static const double	universe_mean_density = 1.e-25*g/cm3
static const double	pi = 3.14159265358979323846
static const double	twopi = 2*pi
static const double	halfpi = pi/2
static const double	pi2 = pi*pi
static const double	millimeter = 1.
static const double	millimeter2 = millimeter*millimeter
static const double	millimeter3 = millimeter*millimeter*millimeter
static const double	centimeter = 10.*millimeter
static const double	centimeter2 = centimeter*centimeter
static const double	centimeter3 = centimeter*centimeter*centimeter
static const double	meter = 1000.*millimeter
static const double	meter2 = meter*meter
static const double	meter3 = meter*meter*meter
static const double	kilometer = 1000.*meter
static const double	kilometer2 = kilometer*kilometer
static const double	kilometer3 = kilometer*kilometer*kilometer
static const double	parsec = 3.0856775807e+16*meter
static const double	micrometer = 1.e-6 *meter
static const double	nanometer = 1.e-9 *meter
static const double	angstrom = 1.e-10*meter
static const double	fermi = 1.e-15*meter
static const double	barn = 1.e-28*meter2
static const double	millibarn = 1.e-3 *barn
static const double	microbarn = 1.e-6 *barn
static const double	nanobarn = 1.e-9 *barn
static const double	picobarn = 1.e-12*barn
static const double	nm = nanometer
static const double	um = micrometer
static const double	mm = millimeter
static const double	mm2 = millimeter2
static const double	mm3 = millimeter3
static const double	cm = centimeter
static const double	cm2 = centimeter2
static const double	cm3 = centimeter3
static const double	liter = 1.e+3*cm3
static const double	L = liter
static const double	dL = 1.e-1*liter
static const double	cL = 1.e-2*liter
static const double	mL = 1.e-3*liter
static const double	m = meter
static const double	m2 = meter2
static const double	m3 = meter3
static const double	km = kilometer
static const double	km2 = kilometer2
static const double	km3 = kilometer3
static const double	pc = parsec
static const double	radian = 1.
static const double	milliradian = 1.e-3*radian
static const double	degree = (pi/180.0)*radian
static const double	steradian = 1.
static const double	rad = radian
static const double	mrad = milliradian
static const double	sr = steradian
static const double	deg = degree
static const double	nanosecond = 1.
static const double	second = 1.e+9 *nanosecond
static const double	millisecond = 1.e-3 *second
static const double	microsecond = 1.e-6 *second
static const double	picosecond = 1.e-12*second
static const double	hertz = 1./second
static const double	kilohertz = 1.e+3*hertz
static const double	megahertz = 1.e+6*hertz
static const double	ns = nanosecond
static const double	s = second
static const double	ms = millisecond
static const double	eplus = 1.
static const double	e_SI = 1.602176487e-19
static const double	coulomb = eplus/e_SI
static const double	megaelectronvolt = 1.
static const double	electronvolt = 1.e-6*megaelectronvolt
static const double	kiloelectronvolt = 1.e-3*megaelectronvolt
static const double	gigaelectronvolt = 1.e+3*megaelectronvolt
static const double	teraelectronvolt = 1.e+6*megaelectronvolt
static const double	petaelectronvolt = 1.e+9*megaelectronvolt
static const double	joule = electronvolt/e_SI
static const double	MeV = megaelectronvolt
static const double	eV = electronvolt
static const double	keV = kiloelectronvolt
static const double	GeV = gigaelectronvolt
static const double	TeV = teraelectronvolt
static const double	PeV = petaelectronvolt
static const double	kilogram = joule*second*second/(meter*meter)
static const double	gram = 1.e-3*kilogram
static const double	milligram = 1.e-3*gram
static const double	kg = kilogram
static const double	g = gram
static const double	mg = milligram
static const double	watt = joule/second
static const double	newton = joule/meter
static const double	hep_pascal = newton/m2
static const double	bar = 100000*pascal
static const double	atmosphere = 101325*pascal
static const double	ampere = coulomb/second
static const double	milliampere = 1.e-3*ampere
static const double	microampere = 1.e-6*ampere
static const double	nanoampere = 1.e-9*ampere
static const double	megavolt = megaelectronvolt/eplus
static const double	kilovolt = 1.e-3*megavolt
static const double	volt = 1.e-6*megavolt
static const double	ohm = volt/ampere
static const double	farad = coulomb/volt
static const double	millifarad = 1.e-3*farad
static const double	microfarad = 1.e-6*farad
static const double	nanofarad = 1.e-9*farad
static const double	picofarad = 1.e-12*farad
static const double	weber = volt*second
static const double	tesla = volt*second/meter2
static const double	gauss = 1.e-4*tesla
static const double	kilogauss = 1.e-1*tesla
static const double	henry = weber/ampere
static const double	kelvin = 1.
static const double	mole = 1.
static const double	becquerel = 1./second
static const double	curie = 3.7e+10 * becquerel
static const double	kilobecquerel = 1.e+3*becquerel
static const double	megabecquerel = 1.e+6*becquerel
static const double	gigabecquerel = 1.e+9*becquerel
static const double	millicurie = 1.e-3*curie
static const double	microcurie = 1.e-6*curie
static const double	Bq = becquerel
static const double	kBq = kilobecquerel
static const double	MBq = megabecquerel
static const double	GBq = gigabecquerel
static const double	Ci = curie
static const double	mCi = millicurie
static const double	uCi = microcurie
static const double	gray = joule/kilogram
static const double	kilogray = 1.e+3*gray
static const double	milligray = 1.e-3*gray
static const double	microgray = 1.e-6*gray
static const double	candela = 1.
static const double	lumen = candela*steradian
static const double	lux = lumen/meter2
static const double	perCent = 0.01
static const double	perThousand = 0.001
static const double	perMillion = 0.000001
static const HepLorentzVector	X_HAT4 = HepLorentzVector( 1, 0, 0, 0 )
static const HepLorentzVector	Y_HAT4 = HepLorentzVector( 0, 1, 0, 0 )
static const HepLorentzVector	Z_HAT4 = HepLorentzVector( 0, 0, 1, 0 )
static const HepLorentzVector	T_HAT4 = HepLorentzVector( 0, 0, 0, 1 )
DLL_API const Hep3Vector	HepXHat
DLL_API const Hep3Vector	HepYHat
DLL_API const Hep3Vector	HepZHat
static const int	MarkerLen = 64
static const int	Tsizes [5]
static const double	Tsteps [5]
static const int	Toffsets [5]
static const double	gaussTables [2 *TableSize]
static const int	MarkerLen = 64
static const int	MarkerLen = 64
static const int	MarkerLen = 64
static const float	gaussTables [TableSize]
static const float	TABLE_INTERVAL = .001f
static const int	TABLE_END = 982
static const float	TABLE_MULTIPLIER = 1.0f/TABLE_INTERVAL
static const float	inverseLandau [TABLE_END+1]
static const double	poissonTables [51 *((95-10)/5+1)]
static const int	MarkerLen = 64
static const double	prec = 4.6566128E-10
static const int	MarkerLen = 64
static const int	MarkerLen = 64
static const int	MarkerLen = 64

Typedef Documentation

HepLorentzVectorD

typedef HepLorentzVector CLHEP::HepLorentzVectorD

Definition at line 550 of file LorentzVector.h.

HepLorentzVectorF

typedef HepLorentzVector CLHEP::HepLorentzVectorF

Definition at line 551 of file LorentzVector.h.

HepThreeVectorD

typedef Hep3Vector CLHEP::HepThreeVectorD

Definition at line 426 of file ThreeVector.h.

HepThreeVectorF

typedef Hep3Vector CLHEP::HepThreeVectorF

Definition at line 427 of file ThreeVector.h.

myID_t

typedef uint32_t CLHEP::myID_t

Definition at line 80 of file mixmax.h.

myuint

typedef uint64_t CLHEP::myuint

Definition at line 49 of file mixmax.h.

rng_state_t

typedef struct rng_state_st CLHEP::rng_state_t

Definition at line 64 of file mixmax.h.

shared_ptr

template<typename T >

using CLHEP::shared_ptr = typedef std::shared_ptr<T>

Definition at line 15 of file memory.h.

weak_ptr

template<typename T >

using CLHEP::weak_ptr = typedef std::weak_ptr<T>

Definition at line 17 of file memory.h.

Enumeration Type Documentation

ZMpvMetric_t

enum CLHEP::ZMpvMetric_t

Enumerator
TimePositive
TimeNegative

Definition at line 64 of file LorentzVector.h.

{ TimePositive, TimeNegative };

Function Documentation

apply_bigskip()

myuint CLHEP::apply_bigskip	(	myuint *	Vout,
		myuint *	Vin,
		myID_t	clusterID,
		myID_t	machineID,
		myID_t	runID,
		myID_t	streamID
	)

boostOf() [1/2]

HepLorentzVector CLHEP::boostOf ( const HepLorentzVector &  vec, const Hep3Vector &  betaVector  )

inline

Here is the caller graph for this function:

boostOf() [2/2]

HepLorentzVector CLHEP::boostOf ( const HepLorentzVector &  vec, const Hep3Vector &  axis, double  beta  )

inline

boostXOf()

HepLorentzVector CLHEP::boostXOf ( const HepLorentzVector &  vec, double  beta  )

inline

boostYOf()

HepLorentzVector CLHEP::boostYOf ( const HepLorentzVector &  vec, double  beta  )

inline

boostZOf()

HepLorentzVector CLHEP::boostZOf ( const HepLorentzVector &  vec, double  beta  )

inline

branch_inplace()

void CLHEP::branch_inplace	(	rng_state_t *	Xin,
		myID_t *	ID
	)

correctByPi()

static void CLHEP::correctByPi ( double &  psi1, double &  phi1  )

static

Definition at line 148 of file RotationE.cc.

                                                {
  if (psi1 > 0) {
    psi1 -= CLHEP::pi;
  } else {
    psi1 += CLHEP::pi;
  }
  if (phi1 > 0) {
    phi1 -= CLHEP::pi;
  } else {
    phi1 += CLHEP::pi;
  }  
}

Here is the caller graph for this function:

correctPsiPhi()

static void CLHEP::correctPsiPhi ( double  rxz, double  rzx, double  ryz, double  rzy, double &  psi1, double &  phi1  )

static

Definition at line 162 of file RotationE.cc.

                                          {

  // set up quatities which would be positive if sin and cosine of
  // psi1 and phi1 were positive:
  double w[4];
  w[0] = rxz; w[1] = rzx; w[2] = ryz; w[3] = -rzy;

  // find biggest relevant term, which is the best one to use in correcting.
  double maxw = std::abs(w[0]); 
  int imax = 0;
  for (int i = 1; i < 4; ++i) {
    if (std::abs(w[i]) > maxw) {
      maxw = std::abs(w[i]);
      imax = i;
    }
  }
  // Determine if the correction needs to be applied:  The criteria are 
  // different depending on whether a sine or cosine was the determinor: 
  switch (imax) {
    case 0:
      if (w[0] > 0 && psi1 < 0)           correctByPi ( psi1, phi1 );
      if (w[0] < 0 && psi1 > 0)           correctByPi ( psi1, phi1 );
      break;
    case 1:
      if (w[1] > 0 && phi1 < 0)           correctByPi ( psi1, phi1 );
      if (w[1] < 0 && phi1 > 0)           correctByPi ( psi1, phi1 );
      break;
    case 2:
      if (w[2] > 0 && std::abs(psi1) > CLHEP::halfpi) correctByPi ( psi1, phi1 );    
      if (w[2] < 0 && std::abs(psi1) < CLHEP::halfpi) correctByPi ( psi1, phi1 );    
      break;
    case 3:
      if (w[3] > 0 && std::abs(phi1) > CLHEP::halfpi) correctByPi ( psi1, phi1 );    
      if (w[3] < 0 && std::abs(phi1) < CLHEP::halfpi) correctByPi ( psi1, phi1 );    
      break;
  }          
}

Here is the call graph for this function:

Here is the caller graph for this function:

crc32ul()

unsigned long CLHEP::crc32ul

(

const std::string &

s

)

Definition at line 37 of file engineIDulong.cc.

                                           {
  static const std::vector<unsigned long> crc_table =  gen_crc_table();
  unsigned long crc = 0;
  int end = s.length();
  for (int j = 0; j != end; ++j) {
    int i = ( (int) ( crc >> 24) ^ s[j] ) & 0xff;
    crc = ( ( crc << 8 ) ^ crc_table[i] ) & 0xffffffffUL;
  }
  return crc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

engineIDulong()

template<class E >

unsigned long CLHEP::engineIDulong

(

)

Definition at line 24 of file engineIDulong.h.

                              {
  static const unsigned long id = crc32ul(E::engineName());
  return id;
}

Here is the call graph for this function:

fill_array()

void CLHEP::fill_array	(	rng_state_t *	X,
		unsigned int	n,
		double *	array
	)

Definition at line 90 of file mixmax.cc.

{
    // Return an array of n random numbers uniformly distributed in (0,1]
    unsigned int i,j;
    const int M=N-1;
    for (i=0; i<(n/M); i++){
        iterate_and_fill_array(X, array+i*M);
    }
    unsigned int rem=(n % M);
    if (rem) {
        iterate(X);
        for (j=0; j< (rem); j++){
            array[M*i+j] = (int64_t)X->V[j] * (double)(INV_MERSBASE);
        }
        X->counter = j; // needed to continue with single fetches from the exact spot, but if you only use fill_array to get numbers then it is not necessary
    }else{
        X->counter = N;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

fmodmulM61()

myuint CLHEP::fmodmulM61 ( myuint  cum, myuint  s, myuint  a  )

inline

Definition at line 255 of file mixmax.cc.

{
    register myuint o,ph,pl,ah,al;
    o=(s)*a;
    ph = ((s)>>32);
    pl = (s) & MASK32;
    ah = a>>32;
    al = a & MASK32;
    o = (o & M61) + ((ph*ah)<<3) + ((ah*pl+al*ph + ((al*pl)>>32))>>29) ;
    o += cum;
    o = (o & M61) + ((o>>61));
    return o;
}

Here is the caller graph for this function:

gammln()

double CLHEP::gammln

(

double

xx

)

Definition at line 54 of file RandPoisson.cc.

                         {

// Returns the value ln(Gamma(xx) for xx > 0.  Full accuracy is obtained for 
// xx > 1. For 0 < xx < 1. the reflection formula (6.1.4) can be used first.
// (Adapted from Numerical Recipes in C)

  static const double cof[6] = {76.18009172947146,-86.50532032941677,
                             24.01409824083091, -1.231739572450155,
                             0.1208650973866179e-2, -0.5395239384953e-5};
  int j;
  double x = xx - 1.0;
  double tmp = x + 5.5;
  tmp -= (x + 0.5) * std::log(tmp);
  double ser = 1.000000000190015;

  for ( j = 0; j <= 5; j++ ) {
    x += 1.0;
    ser += cof[j]/x;
  }
  return -tmp + std::log(2.5066282746310005*ser);
}

Here is the caller graph for this function:

gen_crc_table()

static std::vector<unsigned long> CLHEP::gen_crc_table ( )

static

Definition at line 19 of file engineIDulong.cc.

                                                {
  /* generate the table of CRC remainders for all possible bytes */
  static const unsigned long POLYNOMIAL = 0x04c11db7UL;
  std::vector<unsigned long> crc_table;
  for ( unsigned long i = 0;  i < 256;  ++i ) {
    unsigned long crc = i << 24;
    for ( int j = 0;  j < 8;  j++ ) {
      if ( crc & 0x80000000UL ) {
        crc = ( ( crc << 1 ) ^ POLYNOMIAL ) & 0xffffffffUL;
      } else {
        crc = ( crc << 1 ) & 0xffffffffUL; 
      }
    }
    crc_table.push_back(crc);
  }
  return crc_table;
}

Here is the caller graph for this function:

GET_BY_MACRO()

myuint CLHEP::GET_BY_MACRO ( rng_state_t *  X )

inline

Definition at line 173 of file mixmax.h.

                                            {
    int i;
    i=X->counter;
    
    if (i<=(N-1) ){
        X->counter++;
        return X->V[i];
    }else{
        X->sumtot = iterate_raw_vec(X->V, X->sumtot);
        X->counter=2;
        return X->V[1];
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_next()

myuint CLHEP::get_next

(

rng_state_t *

X

)

Definition at line 82 of file mixmax.cc.

                                {
    return GET_BY_MACRO(X);
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_next_float()

double CLHEP::get_next_float

(

rng_state_t *

X

)

Definition at line 86 of file mixmax.cc.

                                     {
    return get_next_float_BY_MACRO(X);
}

Here is the call graph for this function:

Here is the caller graph for this function:

get_next_float_BY_MACRO()

double CLHEP::get_next_float_BY_MACRO ( rng_state_t *  X )

inline

Definition at line 188 of file mixmax.h.

                                                     {
        int64_t Z=(int64_t)get_next(X);
#if defined(__x86_64__) && defined(__SSE__) && defined(__AVX__) && defined(USE_INLINE_ASM)
    double F;
        __asm__ __volatile__(  "pxor %0, %0;"
                 //"cvtsi2sdq %1, %0;"
                 :"=x"(F)
                 //:"r"(Z)
                 );
        F=Z;
       return F*INV_MERSBASE;
#else
       return Z*INV_MERSBASE;
#endif
    }

Here is the call graph for this function:

Here is the caller graph for this function:

HepXHat()

const Hep3Vector CLHEP::HepXHat	(	1.	0,
		0.	0,
		0.	0
	)

HepYHat()

const Hep3Vector CLHEP::HepYHat	(	0.	0,
		1.	0,
		0.	0
	)

HepZHat()

const Hep3Vector CLHEP::HepZHat	(	0.	0,
		0.	0,
		1.	0
	)

inverseOf() [1/9]

HepBoostX CLHEP::inverseOf ( const HepBoostX &  b )

inline

inverseOf() [2/9]

HepBoostY CLHEP::inverseOf ( const HepBoostY &  b )

inline

inverseOf() [3/9]

HepBoostZ CLHEP::inverseOf ( const HepBoostZ &  b )

inline

inverseOf() [4/9]

HepRotationY CLHEP::inverseOf ( const HepRotationY &  r )

inline

inverseOf() [5/9]

HepRotationZ CLHEP::inverseOf ( const HepRotationZ &  r )

inline

inverseOf() [6/9]

HepRotationX CLHEP::inverseOf ( const HepRotationX &  r )

inline

inverseOf() [7/9]

HepBoost CLHEP::inverseOf ( const HepBoost &  lt )

inline

Here is the caller graph for this function:

inverseOf() [8/9]

HepRotation CLHEP::inverseOf ( const HepRotation &  r )

inline

inverseOf() [9/9]

HepLorentzRotation CLHEP::inverseOf ( const HepLorentzRotation &  lt )

inline

iterate()

int CLHEP::iterate

(

rng_state_t *

X

)

Definition at line 39 of file mixmax.cc.

                           {
    X->sumtot = iterate_raw_vec(X->V, X->sumtot);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

iterate_and_fill_array()

void CLHEP::iterate_and_fill_array	(	rng_state_t *	X,
		double *	array
	)

Definition at line 110 of file mixmax.cc.

                                                          {
    myuint* Y=X->V;
    int i;
    myuint  tempP, tempV;
#if (SPECIAL != 0)
    myuint temp2 = Y[1];
#endif
    Y[0] = (tempV = modadd(Y[0] , X->sumtot));
    //array[0] = (double)tempV * (double)(INV_MERSBASE);
    myuint sumtot = 0, ovflow = 0; // will keep a running sum of all new elements (except Y[0])
    tempP = 0;             // will keep a partial sum of all old elements (except Y[0])
    for (i=1; i<N; i++){
        tempP = modadd(tempP,Y[i]);
        Y[i] = ( tempV = modadd(tempV,tempP) );
        sumtot += tempV; if (sumtot < tempV) {ovflow++;}
        array[i-1] = (int64_t)tempV * (double)(INV_MERSBASE);
    }
#if (SPECIAL != 0)
    temp2 = MOD_MULSPEC(temp2);
    Y[2] = modadd( Y[2] , temp2 );
    sumtot += temp2; if (sumtot < temp2) {ovflow++;}
#endif
    X->sumtot = MOD_MERSENNE(MOD_MERSENNE(sumtot) + (ovflow <<3 ));
}

Here is the call graph for this function:

Here is the caller graph for this function:

iterate_raw_vec()

myuint CLHEP::iterate_raw_vec	(	myuint *	Y,
		myuint	sumtotOld
	)

Definition at line 52 of file mixmax.cc.

                                                   {
    // operates with a raw vector, uses known sum of elements of Y
    int i;
#ifdef SPECIAL
    myuint temp2 = Y[1];
#endif
    myuint  tempP, tempV;
    Y[0] = ( tempV = sumtotOld);
    myuint sumtot = Y[0], ovflow = 0; // will keep a running sum of all new elements (except Y[0])
    tempP = 0;              // will keep a partial sum of all old elements (except Y[0])
    for (i=1; i<N; i++){
#if (SPECIALMUL!=0)
        myuint tempPO = MULWU(tempP);
        tempP = modadd(tempP,Y[i]);
        tempV = MOD_MERSENNE(tempV + tempP + tempPO); // edge cases ?
#else
        tempP = modadd(tempP , Y[i]);
        tempV = modadd(tempV , tempP);
#endif
        Y[i] = tempV;
        sumtot += tempV; if (sumtot < tempV) {ovflow++;}
    }
#ifdef SPECIAL
    temp2 = MOD_MULSPEC(temp2);
    Y[2] = modadd( Y[2] , temp2 );
    sumtot += temp2; if (sumtot < temp2) {ovflow++;}
#endif
    return MOD_MERSENNE(MOD_MERSENNE(sumtot) + (ovflow <<3 ));
}

Here is the call graph for this function:

Here is the caller graph for this function:

makeAnEngine() [1/2]

template<class E >

static HepRandomEngine* CLHEP::makeAnEngine ( const std::string &  tag, std::istream &  is  )

static

Definition at line 32 of file EngineFactory.cc.

                               {
  if ( tag != E::beginTag() ) return 0;
  HepRandomEngine* eptr = new E;
  eptr->getState(is);
  if (!is) return 0;
  return eptr;        
}         

Here is the call graph for this function:

makeAnEngine() [2/2]

template<class E >

static HepRandomEngine* CLHEP::makeAnEngine ( const std::vector< unsigned long > &  v )

static

Definition at line 43 of file EngineFactory.cc.

                                                  {
  if ( (v[0] & 0xffffffffUL) != engineIDulong<E>() ) return 0;
  HepRandomEngine* eptr = new E;
  bool success = eptr->getState(v);
  if (!success) return 0;
  // std::cerr << "makeAnEngine made " << E::engineName() << "\n"; 
  return eptr;        
}         

Here is the call graph for this function:

modadd()

myuint CLHEP::modadd	(	myuint	foo,
		myuint	bar
	)

Definition at line 135 of file mixmax.cc.

                                     {
#if defined(__x86_64__) && defined(USE_INLINE_ASM)
    myuint out;
    /* Assembler trick suggested by Andrzej Görlich     */
    __asm__ ("addq %2, %0; "
             "btrq $61, %0; "
             "adcq $0, %0; "
             :"=r"(out)
             :"0"(foo), "r"(bar)
             );
    return out;
#else
    return MOD_MERSENNE(foo+bar);
#endif
}

Here is the caller graph for this function:

modmulM61()

myuint CLHEP::modmulM61	(	myuint	s,
		myuint	a
	)

MULWU()

uint64_t CLHEP::MULWU ( uint64_t  )

inline

Definition at line 47 of file mixmax.cc.

{ return 0;}

Here is the caller graph for this function:

normal()

static double CLHEP::normal ( HepRandomEngine *  eptr )

static

Definition at line 77 of file RandPoisson.cc.

{
  double r;
  double v1,v2,fac;
  do {
    v1 = 2.0 * eptr->flat() - 1.0;
    v2 = 2.0 * eptr->flat() - 1.0;
    r = v1*v1 + v2*v2;
  } while ( r > 1.0 );

  fac = std::sqrt(-2.0*std::log(r)/r);
  return v2*fac;
}

Here is the call graph for this function:

operator!=() [1/2]

bool CLHEP::operator!= ( const HepRotation &  r, const HepLorentzRotation &  lt  )

inline

Definition at line 353 of file LorentzRotation.h.

  { return lt!=r; }

Here is the caller graph for this function:

operator!=() [2/2]

bool CLHEP::operator!= ( const HepBoost &  b, const HepLorentzRotation &  lt  )

inline

Definition at line 366 of file LorentzRotation.h.

  { return lt!=b; }

operator*() [1/15]

double CLHEP::operator* ( const Hep2Vector &  a, const Hep2Vector &  b  )

inline

operator*() [2/15]

Hep2Vector CLHEP::operator* ( const Hep2Vector &  p, double  a  )

inline

operator*() [3/15]

HepRotation CLHEP::operator* ( const HepRotationX &  rx, const HepRotation &  r  )

inline

operator*() [4/15]

Hep2Vector CLHEP::operator* ( double  a, const Hep2Vector &  p  )

inline

operator*() [5/15]

HepRotation CLHEP::operator* ( const HepRotationY &  ry, const HepRotation &  r  )

inline

operator*() [6/15]

HepLorentzRotation CLHEP::operator*	(	const HepRotation &	r,
		const HepLorentzRotation &	lt
	)

Definition at line 264 of file LorentzRotation.cc.

                                                              {
  r.rep4x4();
  lt.rep4x4();
  return HepLorentzRotation( HepRep4x4(
         r.xx()*lt.xx() + r.xy()*lt.yx() + r.xz()*lt.zx() + r.xt()*lt.tx(),
     r.xx()*lt.xy() + r.xy()*lt.yy() + r.xz()*lt.zy() + r.xt()*lt.ty(),
     r.xx()*lt.xz() + r.xy()*lt.yz() + r.xz()*lt.zz() + r.xt()*lt.tz(),
     r.xx()*lt.xt() + r.xy()*lt.yt() + r.xz()*lt.zt() + r.xt()*lt.tt(),

         r.yx()*lt.xx() + r.yy()*lt.yx() + r.yz()*lt.zx() + r.yt()*lt.tx(),
         r.yx()*lt.xy() + r.yy()*lt.yy() + r.yz()*lt.zy() + r.yt()*lt.ty(),
         r.yx()*lt.xz() + r.yy()*lt.yz() + r.yz()*lt.zz() + r.yt()*lt.tz(),
         r.yx()*lt.xt() + r.yy()*lt.yt() + r.yz()*lt.zt() + r.yt()*lt.tt(),

         r.zx()*lt.xx() + r.zy()*lt.yx() + r.zz()*lt.zx() + r.zt()*lt.tx(),
         r.zx()*lt.xy() + r.zy()*lt.yy() + r.zz()*lt.zy() + r.zt()*lt.ty(),
         r.zx()*lt.xz() + r.zy()*lt.yz() + r.zz()*lt.zz() + r.zt()*lt.tz(),
         r.zx()*lt.xt() + r.zy()*lt.yt() + r.zz()*lt.zt() + r.zt()*lt.tt(),

         r.tx()*lt.xx() + r.ty()*lt.yx() + r.tz()*lt.zx() + r.tt()*lt.tx(),
         r.tx()*lt.xy() + r.ty()*lt.yy() + r.tz()*lt.zy() + r.tt()*lt.ty(),
         r.tx()*lt.xz() + r.ty()*lt.yz() + r.tz()*lt.zz() + r.tt()*lt.tz(),
         r.tx()*lt.xt() + r.ty()*lt.yt() + r.tz()*lt.zt() + r.tt()*lt.tt() ) );
}

Here is the call graph for this function:

operator*() [7/15]

HepRotation CLHEP::operator* ( const HepRotationZ &  rz, const HepRotation &  r  )

inline

operator*() [8/15]

HepLorentzRotation CLHEP::operator*	(	const HepRotationX &	r,
		const HepLorentzRotation &	lt
	)

operator*() [9/15]

HepLorentzRotation CLHEP::operator*	(	const HepRotationY &	r,
		const HepLorentzRotation &	lt
	)

operator*() [10/15]

HepLorentzRotation CLHEP::operator*	(	const HepRotationZ &	r,
		const HepLorentzRotation &	lt
	)

operator*() [11/15]

double CLHEP::operator* ( const Hep3Vector &  , const Hep3Vector &    )

inline

operator*() [12/15]

Hep3Vector CLHEP::operator* ( const Hep3Vector &  , double  a  )

inline

operator*() [13/15]

Hep3Vector CLHEP::operator* ( double  a, const Hep3Vector &    )

inline

operator*() [14/15]

HepLorentzVector CLHEP::operator* ( const HepLorentzVector &  , double  a  )

inline

operator*() [15/15]

HepLorentzVector CLHEP::operator* ( double  a, const HepLorentzVector &    )

inline

operator+() [1/2]

Hep2Vector CLHEP::operator+ ( const Hep2Vector &  a, const Hep2Vector &  b  )

inline

operator+() [2/2]

Hep3Vector CLHEP::operator+ ( const Hep3Vector &  , const Hep3Vector &    )

inline

operator-() [1/2]

Hep2Vector CLHEP::operator- ( const Hep2Vector &  a, const Hep2Vector &  b  )

inline

operator-() [2/2]

Hep3Vector CLHEP::operator- ( const Hep3Vector &  , const Hep3Vector &    )

inline

operator/() [1/3]

Hep2Vector CLHEP::operator/	(	const Hep2Vector &	p,
		double	a
	)

Definition at line 61 of file TwoVector.cc.

                                                      {
//  if (a==0) {
//    std::cerr << "Hep2Vector operator/ () - "
//              << "Division of Hep2Vector by zero" << std::endl;
//  }
  return Hep2Vector(p.x()/a, p.y()/a);
}

Here is the call graph for this function:

operator/() [2/3]

Hep3Vector CLHEP::operator/	(	const Hep3Vector &	v1,
		double	a
	)

Definition at line 301 of file ThreeVector.cc.

                                                          {
//  if (c == 0) {
//    std::cerr << "Hep3Vector::operator/ () - "
//      << "Attempt to divide vector by 0 -- "
//      << "will produce infinities and/or NANs" << std::endl;
//  } 
  double   oneOverC = 1.0/c;
  return Hep3Vector  (  v1.x() * oneOverC,
                        v1.y() * oneOverC,
                        v1.z() * oneOverC );
} /* v / c */

Here is the call graph for this function:

operator/() [3/3]

HepLorentzVector CLHEP::operator/	(	const HepLorentzVector &	w,
		double	a
	)

Definition at line 165 of file LorentzVector.cc.

                                                                   {
//  if (c == 0) {
//    std::cerr << "HepLorentzVector::operator /() - "
//      << "Attempt to do LorentzVector / 0 -- \n"
//      << "division by zero would produce infinite or NAN components"
//      << std::endl;
//  }
  double oneOverC = 1.0/c;
  return HepLorentzVector (w.getV() * oneOverC,
                        w.getT() * oneOverC);
} /* LV = w / c */

Here is the call graph for this function:

operator<() [1/2]

bool CLHEP::operator< ( const HepRotation &  r, const HepLorentzRotation &  lt  )

inline

Definition at line 359 of file LorentzRotation.h.

  { return lt<r; }

operator<() [2/2]

bool CLHEP::operator< ( const HepBoost &  b, const HepLorentzRotation &  lt  )

inline

Definition at line 372 of file LorentzRotation.h.

  { return lt<b; }

operator<<() [1/16]

std::ostream & CLHEP::operator<<	(	std::ostream &	os,
		const HepAxisAngle &	aa
	)

Definition at line 85 of file AxisAngle.cc.

                                                                  {
  os << '(' << aa.axis() << ", " << aa.delta() << ')';
  return  os;
}  // operator<<()

Here is the call graph for this function:

operator<<() [2/16]

std::ostream & CLHEP::operator<<	(	std::ostream &	os,
		const HepEulerAngles &	aa
	)

Definition at line 100 of file EulerAngles.cc.

{
  os << "(" << ea.phi() << ", " << ea.theta() << ", " << ea.psi() << ")";
  return  os;
}  // operator<<()

Here is the call graph for this function:

operator<<() [3/16]

std::ostream & CLHEP::operator<<	(	std::ostream &	os,
		const Hep2Vector &	q
	)

Definition at line 69 of file TwoVector.cc.

                                                                 {
  os << "(" << q.x() << ", " << q.y() << ")";
  return os;
}

Here is the call graph for this function:

operator<<() [4/16]

std::ostream & CLHEP::operator<<	(	std::ostream &	os,
		const HepRandom &	dist
	)

Definition at line 117 of file Random.cc.

                                                                  {
  return dist.put(os);
}

Here is the call graph for this function:

operator<<() [5/16]

std::ostream & CLHEP::operator<<	(	std::ostream &	os,
		const HepRandomEngine &	e
	)

Definition at line 98 of file RandomEngine.cc.

                                                                     {
  return e.put(os);
}

Here is the call graph for this function:

operator<<() [6/16]

std::ostream& CLHEP::operator<< ( std::ostream &  os, const HepBoostX &  b  )

inline

Definition at line 215 of file BoostX.h.

{return b.print(os);}

operator<<() [7/16]

std::ostream& CLHEP::operator<< ( std::ostream &  os, const HepBoostZ &  b  )

inline

Definition at line 215 of file BoostZ.h.

{return b.print(os);}

operator<<() [8/16]

std::ostream& CLHEP::operator<< ( std::ostream &  os, const HepBoostY &  b  )

inline

Definition at line 216 of file BoostY.h.

{return b.print(os);}

operator<<() [9/16]

std::ostream& CLHEP::operator<< ( std::ostream &  os, const HepBoost &  b  )

inline

Definition at line 241 of file Boost.h.

{return b.print(os);}

operator<<() [10/16]

std::ostream& CLHEP::operator<< ( std::ostream &  os, const HepRotationX &  r  )

inline

Definition at line 278 of file RotationX.h.

{return r.print(os);}

operator<<() [11/16]

std::ostream& CLHEP::operator<< ( std::ostream &  os, const HepRotationY &  r  )

inline

Definition at line 278 of file RotationY.h.

{return r.print(os);}

operator<<() [12/16]

std::ostream& CLHEP::operator<< ( std::ostream &  os, const HepRotationZ &  r  )

inline

Definition at line 278 of file RotationZ.h.

{return r.print(os);}

operator<<() [13/16]

std::ostream& CLHEP::operator<< ( std::ostream &  os, const HepLorentzRotation &  lt  )

inline

Definition at line 348 of file LorentzRotation.h.

  {return lt.print(os);}

operator<<() [14/16]

std::ostream& CLHEP::operator<< ( std::ostream &  os, const HepRotation &  r  )

inline

Definition at line 410 of file Rotation.h.

{return r.print(os);}

operator<<() [15/16]

std::ostream & CLHEP::operator<<	(	std::ostream &	os,
		const Hep3Vector &	v
	)

Definition at line 66 of file ThreeVector.cc.

                                                                {
  return os << "(" << v.x() << "," << v.y() << "," << v.z() << ")";
}

Here is the call graph for this function:

operator<<() [16/16]

std::ostream & CLHEP::operator<<	(	std::ostream &	os,
		const HepLorentzVector &	v1
	)

Definition at line 90 of file LorentzVector.cc.

{
  return os << "(" << v1.x() << "," << v1.y() << "," << v1.z()
        << ";" << v1.t() << ")";
}

Here is the call graph for this function:

operator<=() [1/2]

bool CLHEP::operator<= ( const HepRotation &  r, const HepLorentzRotation &  lt  )

inline

Definition at line 355 of file LorentzRotation.h.

  { return lt<=r; }

operator<=() [2/2]

bool CLHEP::operator<= ( const HepBoost &  b, const HepLorentzRotation &  lt  )

inline

Definition at line 368 of file LorentzRotation.h.

  { return lt<=b; }

operator==() [1/2]

bool CLHEP::operator== ( const HepRotation &  r, const HepLorentzRotation &  lt  )

inline

Definition at line 351 of file LorentzRotation.h.

  { return lt==r; }

Here is the caller graph for this function:

operator==() [2/2]

bool CLHEP::operator== ( const HepBoost &  b, const HepLorentzRotation &  lt  )

inline

Definition at line 364 of file LorentzRotation.h.

  { return lt==b; }

operator>() [1/2]

bool CLHEP::operator> ( const HepRotation &  r, const HepLorentzRotation &  lt  )

inline

Definition at line 361 of file LorentzRotation.h.

  { return lt>r; }

operator>() [2/2]

bool CLHEP::operator> ( const HepBoost &  b, const HepLorentzRotation &  lt  )

inline

Definition at line 374 of file LorentzRotation.h.

  { return lt>b; }

operator>=() [1/2]

bool CLHEP::operator>= ( const HepRotation &  r, const HepLorentzRotation &  lt  )

inline

Definition at line 357 of file LorentzRotation.h.

  { return lt>=r; }

operator>=() [2/2]

bool CLHEP::operator>= ( const HepBoost &  b, const HepLorentzRotation &  lt  )

inline

Definition at line 370 of file LorentzRotation.h.

  { return lt>=b; }

operator>>() [1/7]

std::istream & CLHEP::operator>>	(	std::istream &	is,
		HepAxisAngle &	aa
	)

Definition at line 95 of file AxisAngle.cc.

                                                            {
  Hep3Vector axis;
  double delta;
  double x,y,z;
  ZMinputAxisAngle ( is, x, y, z, delta );
  axis.set(x,y,z);
  aa.set ( axis, delta );
  return  is;
}  // operator>>()

Here is the call graph for this function:

operator>>() [2/7]

std::istream & CLHEP::operator>>	(	std::istream &	is,
		HepEulerAngles &	aa
	)

Definition at line 109 of file EulerAngles.cc.

                                                              {
  double thePhi;
  double theTheta;
  double thePsi;
  ZMinput3doubles ( is, "HepEulerAngle", thePhi , theTheta , thePsi );
  ea.set ( thePhi , theTheta , thePsi );
  return  is;
}  // operator>>()

Here is the call graph for this function:

operator>>() [3/7]

std::istream & CLHEP::operator>>	(	std::istream &	is,
		Hep2Vector &	p
	)

Definition at line 77 of file TwoVector.cc.

                                                         {
  double x, y;
  ZMinput2doubles ( is, "Hep2Vector", x, y );
  p.set(x, y);
  return  is;
}  // operator>>()

Here is the call graph for this function:

operator>>() [4/7]

std::istream & CLHEP::operator>>	(	std::istream &	is,
		HepRandom &	dist
	)

Definition at line 121 of file Random.cc.

                                                            {
  return dist.get(is);
}

Here is the call graph for this function:

operator>>() [5/7]

std::istream & CLHEP::operator>>	(	std::istream &	is,
		HepRandomEngine &	e
	)

Definition at line 102 of file RandomEngine.cc.

                                                               {
  return e.get(is);
}

Here is the call graph for this function:

operator>>() [6/7]

std::istream & CLHEP::operator>>	(	std::istream &	is,
		Hep3Vector &	v
	)

Definition at line 73 of file ThreeVector.cc.

                                                         {
  double x, y, z;
  ZMinput3doubles ( is, "Hep3Vector", x, y, z );
  v.set(x, y, z);
  return  is;
}  // operator>>()

Here is the call graph for this function:

operator>>() [7/7]

std::istream & CLHEP::operator>>	(	std::istream &	is,
		HepLorentzVector &	v1
	)

Definition at line 96 of file LorentzVector.cc.

                                                                 {

// Required format is ( a, b, c; d ) that is, four numbers, preceded by
// (, followed by ), components of the spatial vector separated by commas,
// time component separated by semicolon. The four numbers are taken
// as x, y, z, t.

  double x, y, z, t;
  char c;

  is >> std::ws >> c;
    // ws is defined to invoke eatwhite(istream & )
    // see (Stroustrup gray book) page 333 and 345.
  if (is.fail() || c != '(' ) {
    std::cerr << "Could not find required opening parenthesis "
          << "in input of a HepLorentzVector" << std::endl;
    return is;
  }

  is >> x >> std::ws >> c;
  if (is.fail() || c != ',' ) {
    std::cerr << "Could not find x value and required trailing comma "
          << "in input of a HepLorentzVector" << std::endl; 
    return is;
  }

  is >> y >> std::ws >> c;
  if (is.fail() || c != ',' ) {
    std::cerr << "Could not find y value and required trailing comma "
              <<  "in input of a HepLorentzVector" << std::endl;
    return is;
  }

  is >> z >> std::ws >> c;
  if (is.fail() || c != ';' ) {
    std::cerr << "Could not find z value and required trailing semicolon "
         <<  "in input of a HepLorentzVector" << std::endl;
    return is;
  }

  is >> t >> std::ws >> c;
  if (is.fail() || c != ')' ) {
    std::cerr << "Could not find t value and required close parenthesis "
         << "in input of a HepLorentzVector" << std::endl;
    return is;
  }

  v1.setX(x);
  v1.setY(y);
  v1.setZ(z);
  v1.setT(t);
  return is;
}

Here is the call graph for this function:

possibleKeywordInput()

template<class IS , class T >

bool CLHEP::possibleKeywordInput	(	IS &	is,
		const std::string &	key,
		T &	t
	)

Definition at line 167 of file RandomEngine.h.

                                                                  {
  std::string firstWord;
  is >> firstWord;
  if (firstWord == key) return true;
  std::istringstream reread(firstWord);
  reread >> t;
  return false;
}

Here is the caller graph for this function:

precalc()

myuint CLHEP::precalc

(

rng_state_t *

X

)

Definition at line 225 of file mixmax.cc.

                              {
    int i;
    myuint temp;
    temp = 0;
    for (i=0; i < N; i++){
        temp = MOD_MERSENNE(temp + X->V[i]);
    }   
    X->sumtot = temp; 
    return temp;
}

Here is the caller graph for this function:

print_state()

void CLHEP::print_state

(

rng_state_t *

X

)

Definition at line 270 of file mixmax.cc.

                                {
    int j;
    fprintf(X->fh, "mixmax state, file version 1.0\n" );
    fprintf(X->fh, "N=%u; V[N]={", rng_get_N() );
    for (j=0; (j< (rng_get_N()-1) ); j++) {
        fprintf(X->fh, "%llu, ", X->V[j] );
    }
    fprintf(X->fh, "%llu", X->V[rng_get_N()-1] );
    fprintf(X->fh, "}; " );
    fprintf(X->fh, "counter=%u; ", X->counter );
    fprintf(X->fh, "sumtot=%llu;\n", X->sumtot );
}

Here is the call graph for this function:

Here is the caller graph for this function:

read_state()

void CLHEP::read_state	(	rng_state_t *	X,
		const char	filename[]
	)

Definition at line 283 of file mixmax.cc.

                                                       {
    // a function for reading the state from a file, after J. Apostolakis
    FILE* fin;
    if(  ( fin = fopen(filename, "r") ) ){
        char l=0;
        while ( l != '{' ) { // 0x7B = "{"
            l=fgetc(fin); // proceed until hitting opening bracket
        }
        ungetc(' ', fin);
    }else{
        fprintf(stderr, "mixmax -> read_state: error reading file %s\n", filename);
        exit(ERROR_READING_STATE_FILE);
    }
    
    myuint vecVal;
    //printf("mixmax -> read_state: starting to read state from file\n");
    if (!fscanf(fin, "%llu", &X->V[0]) ) {fprintf(stderr, "mixmax -> read_state: error reading file %s\n", filename); exit(ERROR_READING_STATE_FILE);}
     //printf("V[%d] = %llu\n",0, X->V[0]);
    int i;
    for( i = 1; i < rng_get_N(); i++){
        if (!fscanf(fin, ", %llu", &vecVal) ) {fprintf(stderr, "mixmax -> read_state: error reading vector component i=%d from file %s\n", i, filename); exit(ERROR_READING_STATE_FILE);}
        //printf("V[%d] = %llu\n",i, vecVal);
        if(  vecVal <= MERSBASE ){
            X->V[i] = vecVal;
        }else{
            fprintf(stderr, "mixmax -> read_state: Invalid state vector value= %llu"
                    " ( must be less than %llu ) "
                    " obtained from reading file %s\n"
                    , vecVal, MERSBASE, filename);
            
        }
    }
    
    unsigned int counter;
    if (!fscanf( fin, "}; counter=%u; ", &counter)){fprintf(stderr, "mixmax -> read_state: error reading counter from file %s\n", filename); exit(ERROR_READING_STATE_FILE);}
    if( counter <= N ) {
        X->counter= counter;
    }else{
        fprintf(stderr, "mixmax -> read_state: Invalid counter = %d"
                "  Must be 0 <= counter < %u\n" , counter, N);
        print_state(X);
        exit(ERROR_READING_STATE_COUNTER);
    }
    precalc(X);
    myuint sumtot;
    if (!fscanf( fin, "sumtot=%llu\n", &sumtot)){fprintf(stderr, "mixmax -> read_state: error reading checksum from file %s\n", filename); exit(ERROR_READING_STATE_FILE);}
    
    if (X->sumtot != sumtot) {
        fprintf(stderr, "mixmax -> checksum error while reading state from file %s - corrupted?\n", filename);
        exit(ERROR_READING_STATE_CHECKSUM);
    }
//    else{fprintf(stderr, "mixmax -> read_state: checksum ok: %llu == %llu\n",X->sumtot,  sumtot);}
    fclose(fin);
}

Here is the call graph for this function:

Here is the caller graph for this function:

rng_alloc()

rng_state_t * CLHEP::rng_alloc

(

)

Definition at line 151 of file mixmax.cc.

{
/* allocate the state */
    rng_state_t  *p = (rng_state_t*)malloc(sizeof(rng_state_t)); 
    p->fh=NULL; // by default, set the output file handle to stdout  
    return p;
}

Here is the caller graph for this function:

rng_copy()

rng_state_t * CLHEP::rng_copy

(

myuint *

Y

)

Definition at line 165 of file mixmax.cc.

{
    /* copy the vector stored at Y, and return pointer to the newly allocated and initialized state.  
     It is the user's responsibility  to make sure that Y is properly allocated with rng_alloc, 
     then pass Y->V or it can also be an array -- such as myuint Y[N+1] and Y[1]...Y[N] have been set to legal values [0 .. MERSBASE-1]
     Partial sums on this new state are recalculated, and counter set to zero, so that when get_next is called, 
     it will output the initial vector before any new numbers are produced, call iterate(X) if you want to advance right away */
    rng_state_t* X = rng_alloc();
    myuint sumtot=0,ovflow=0;
    X->counter = 2;
    int i;
    for ( i=0; i < N; i++){
        X->V[i] = Y[i];
        sumtot += X->V[(i)]; if (sumtot < X->V[(i)]) {ovflow++;}

    }
    X->sumtot = MOD_MERSENNE(MOD_MERSENNE(sumtot) + (ovflow <<3 ));
    return X;
}

Here is the call graph for this function:

Here is the caller graph for this function:

rng_free()

int CLHEP::rng_free

(

rng_state_t *

X

)

Definition at line 159 of file mixmax.cc.

{
    free(X);
    return 0;
}

Here is the caller graph for this function:

rng_get_N()

int CLHEP::rng_get_N

(

void

)

Definition at line 237 of file mixmax.cc.

{return N;}

Here is the call graph for this function:

Here is the caller graph for this function:

rotationOf() [1/8]

HepLorentzVector CLHEP::rotationOf	(	const HepLorentzVector &	vec,
		const Hep3Vector &	axis,
		double	delta
	)

Definition at line 47 of file LorentzVectorR.cc.

                                {
  HepLorentzVector vv (vec);
  return vv.rotate (aaxis, ddelta);
}

Here is the call graph for this function:

rotationOf() [2/8]

HepLorentzVector CLHEP::rotationOf	(	const HepLorentzVector &	vec,
		const HepAxisAngle &	ax
	)

Definition at line 55 of file LorentzVectorR.cc.

                                                            {
  HepLorentzVector vv (vec);
  return vv.rotate (ax);
}

Here is the call graph for this function:

rotationOf() [3/8]

HepLorentzVector CLHEP::rotationOf	(	const HepLorentzVector &	vec,
		const HepEulerAngles &	e
	)

Definition at line 61 of file LorentzVectorR.cc.

                                                              {
  HepLorentzVector vv (vec);
  return vv.rotate (e1);
}

Here is the call graph for this function:

rotationOf() [4/8]

HepLorentzVector CLHEP::rotationOf	(	const HepLorentzVector &	vec,
		double	phi,
		double	theta,
		double	psi
	)

Definition at line 66 of file LorentzVectorR.cc.

                                {
  HepLorentzVector vv (vec);
  return vv.rotate (phi1, theta1, psi1);
}

Here is the call graph for this function:

rotationOf() [5/8]

Hep3Vector CLHEP::rotationOf	(	const Hep3Vector &	vec,
		const Hep3Vector &	axis,
		double	delta
	)

Definition at line 132 of file SpaceVectorR.cc.

                                                               {
  Hep3Vector vv(vec);
  return vv.rotate(axis, ddelta);
}

Here is the call graph for this function:

rotationOf() [6/8]

Hep3Vector CLHEP::rotationOf	(	const Hep3Vector &	vec,
		const HepAxisAngle &	ax
	)

Definition at line 127 of file SpaceVectorR.cc.

                                                                        {
  Hep3Vector vv(vec);
  return vv.rotate (ax);
}

Here is the call graph for this function:

rotationOf() [7/8]

Hep3Vector CLHEP::rotationOf	(	const Hep3Vector &	vec,
		double	phi,
		double	theta,
		double	psi
	)

Definition at line 143 of file SpaceVectorR.cc.

                                                             {
  Hep3Vector vv(vec);
  return vv.rotate(phi, theta, psi);
}

Here is the call graph for this function:

rotationOf() [8/8]

Hep3Vector CLHEP::rotationOf	(	const Hep3Vector &	vec,
		const HepEulerAngles &	e
	)

Definition at line 138 of file SpaceVectorR.cc.

                                                                          {
  Hep3Vector vv(vec);
  return vv.rotate (ex);
}

Here is the call graph for this function:

rotationXOf() [1/2]

HepLorentzVector CLHEP::rotationXOf	(	const HepLorentzVector &	vec,
		double	delta
	)

Definition at line 28 of file LorentzVectorB.cc.

                                              {
  HepLorentzVector vv (vec);
  return vv.rotateX (phi);
}

Here is the call graph for this function:

rotationXOf() [2/2]

Hep3Vector CLHEP::rotationXOf	(	const Hep3Vector &	vec,
		double	delta
	)

Definition at line 149 of file SpaceVectorR.cc.

                                                               {
  Hep3Vector vv(vec);
  return vv.rotateX (ddelta);
}

Here is the call graph for this function:

rotationYOf() [1/2]

HepLorentzVector CLHEP::rotationYOf	(	const HepLorentzVector &	vec,
		double	delta
	)

Definition at line 34 of file LorentzVectorB.cc.

                                              {
  HepLorentzVector vv (vec);
  return vv.rotateY (phi);
}

Here is the call graph for this function:

Here is the caller graph for this function:

rotationYOf() [2/2]

Hep3Vector CLHEP::rotationYOf	(	const Hep3Vector &	vec,
		double	delta
	)

Definition at line 154 of file SpaceVectorR.cc.

                                                               {
  Hep3Vector vv(vec);
  return vv.rotateY (ddelta);
}

Here is the call graph for this function:

rotationZOf() [1/2]

HepLorentzVector CLHEP::rotationZOf	(	const HepLorentzVector &	vec,
		double	delta
	)

Definition at line 40 of file LorentzVectorB.cc.

                                              {
  HepLorentzVector vv (vec);
  return vv.rotateZ (phi);
}

Here is the call graph for this function:

Here is the caller graph for this function:

rotationZOf() [2/2]

Hep3Vector CLHEP::rotationZOf	(	const Hep3Vector &	vec,
		double	delta
	)

Definition at line 159 of file SpaceVectorR.cc.

                                                               {
  Hep3Vector vv(vec);
  return vv.rotateZ (ddelta);
}

Here is the call graph for this function:

safe_acos() [1/5]

static double CLHEP::safe_acos ( double  x )

inlinestatic

Definition at line 23 of file Rotation.cc.

                                          {
  if (std::abs(x) <= 1.0) return std::acos(x);
  return ( (x>0) ? 0 : CLHEP::pi );
}

Here is the caller graph for this function:

safe_acos() [2/5]

static double CLHEP::safe_acos ( double  x )

inlinestatic

Definition at line 26 of file RotationE.cc.

                                          {
  if (std::abs(x) <= 1.0) return std::acos(x);
  return ( (x>0) ? 0 : CLHEP::pi );
}

safe_acos() [3/5]

static double CLHEP::safe_acos ( double  x )

inlinestatic

Definition at line 26 of file RotationZ.cc.

                                          {
  if (std::abs(x) <= 1.0) return std::acos(x);
  return ( (x>0) ? 0 : CLHEP::pi );
}

safe_acos() [4/5]

static double CLHEP::safe_acos ( double  x )

inlinestatic

Definition at line 26 of file RotationX.cc.

                                          {
  if (std::abs(x) <= 1.0) return std::acos(x);
  return ( (x>0) ? 0 : CLHEP::pi );
}

safe_acos() [5/5]

static double CLHEP::safe_acos ( double  x )

inlinestatic

Definition at line 26 of file RotationY.cc.

                                          {
  if (std::abs(x) <= 1.0) return std::acos(x);
  return ( (x>0) ? 0 : CLHEP::pi );
}

seed_spbox()

void CLHEP::seed_spbox	(	rng_state_t *	X,
		myuint	seed
	)

Definition at line 202 of file mixmax.cc.

{ // a 64-bit LCG from Knuth line 26, in combination with a bit swap is used to seed
    const myuint MULT64=6364136223846793005ULL; 
    int i;
    myuint sumtot=0,ovflow=0;
    if (seed == 0){
        fprintf(stderr, " try seeding with nonzero seed next time!\n");
        exit(SEED_WAS_ZERO);
    }
    
    myuint l = seed;

    //X->V[0] = l & MERSBASE;
    if (X->fh==NULL){X->fh=stdout;} // if the filehandle is not yet set, make it stdout
    for (i=0; i < N; i++){
        l*=MULT64; l = (l << 32) ^ (l>>32);
        X->V[i] = l & MERSBASE;
        sumtot += X->V[(i)]; if (sumtot < X->V[(i)]) {ovflow++;}
    }
    X->counter = N;  // set the counter to N if iteration should happen right away
    X->sumtot = MOD_MERSENNE(MOD_MERSENNE(sumtot) + (ovflow <<3 ));
}

seed_uniquestream()

void CLHEP::seed_uniquestream	(	rng_state_t *	X,
		myID_t	clusterID,
		myID_t	machineID,
		myID_t	runID,
		myID_t	streamID
	)

Definition at line 431 of file mixmax.cc.

                                                                                                              {
    Xin->V[0] = (myuint)clusterID;
    Xin->V[1] = (myuint)machineID;
    Xin->V[2] = (myuint)runID;
    Xin->V[3] = (myuint)streamID;
    Xin->V[4] = (myuint)clusterID << 5;
    Xin->V[5] = (myuint)machineID << 7;
    Xin->V[6] = (myuint)runID     << 11;
    Xin->V[7] = (myuint)streamID  << 13;
    precalc(Xin);
    Xin->sumtot = iterate_raw_vec(Xin->V, Xin->sumtot);
    Xin->sumtot = iterate_raw_vec(Xin->V, Xin->sumtot);
}

Here is the call graph for this function:

Here is the caller graph for this function:

seed_vielbein()

void CLHEP::seed_vielbein	(	rng_state_t *	X,
		unsigned int	i
	)

Definition at line 185 of file mixmax.cc.

{
int i;
    if (index<N){
        for (i=0; i < N; i++){
            X->V[i] = 0;
        }
        X->V[index] = 1;
    }else{
        fprintf(stderr, "Out of bounds index, is not ( 0 <= index < N  )\n"); exit(ARRAY_INDEX_OUT_OF_BOUNDS);
    }
    X->counter = N;  // set the counter to N if iteration should happen right away
    //precalc(X);
    X->sumtot = 1; //(index ? 1:0);
    if (X->fh==NULL){X->fh=stdout;} 
}

StirlingCorrection()

static double CLHEP::StirlingCorrection ( long int  k )

static

Definition at line 93 of file RandBinomial.cc.

{
  #define   C1               8.33333333333333333e-02     //  +1/12 
  #define   C3              -2.77777777777777778e-03     //  -1/360
  #define   C5               7.93650793650793651e-04     //  +1/1260
  #define   C7              -5.95238095238095238e-04     //  -1/1680

  static const double  c[31] = {   0.0,
                 8.106146679532726e-02, 4.134069595540929e-02,
                 2.767792568499834e-02, 2.079067210376509e-02,
                 1.664469118982119e-02, 1.387612882307075e-02,
                 1.189670994589177e-02, 1.041126526197209e-02,
                 9.255462182712733e-03, 8.330563433362871e-03,
                 7.573675487951841e-03, 6.942840107209530e-03,
                 6.408994188004207e-03, 5.951370112758848e-03,
                 5.554733551962801e-03, 5.207655919609640e-03,
                 4.901395948434738e-03, 4.629153749334029e-03,
                 4.385560249232324e-03, 4.166319691996922e-03,
                 3.967954218640860e-03, 3.787618068444430e-03,
                 3.622960224683090e-03, 3.472021382978770e-03,
                 3.333155636728090e-03, 3.204970228055040e-03,
                 3.086278682608780e-03, 2.976063983550410e-03,
                 2.873449362352470e-03, 2.777674929752690e-03,
  };
  double    r, rr;

  if (k > 30L) {
    r = 1.0 / (double) k;  rr = r * r;
    return(r*(C1 + rr*(C3 + rr*(C5 + rr*C7))));
    }
    else  return(c[k]);
}

Here is the caller graph for this function:

transformSmall()

double CLHEP::transformSmall

(

double

r

)

Definition at line 219 of file flatToGaussian.cc.

                                 {

  // Solve for -v in the asymtotic formula 
  //
  // errInt (-v) =  exp(-v*v/2)         1     1*3    1*3*5
  //           ------------ * (1 - ---- + ---- - ----- + ... )
  //           v*sqrt(2*pi)        v**2   v**4   v**6

  // The value of r (=errInt(-v)) supplied is going to less than 2.0E-13,
  // which is such that v < -7.25.  Since the value of r is meaningful only
  // to an absolute error of 1E-16 (double precision accuracy for a number 
  // which on the high side could be of the form 1-epsilon), computing
  // v to more than 3-4 digits of accuracy is suspect; however, to ensure 
  // smoothness with the table generator (which uses quite a few terms) we
  // also use terms up to 1*3*5* ... *13/v**14, and insist on accuracy of
  // solution at the level of 1.0e-7.

  // This routine is called less than one time in a trillion firings, so
  // speed is of no concern.  As a matter of technique, we terminate the
  // iterations in case they would be infinite, but this should not happen.

  double eps = 1.0e-7;
  double guess = 7.5;
  double v;
  
  for ( int i = 1; i < 50; i++ ) {
    double vn2 = 1.0/(guess*guess);
    double s1 = -13*11*9*7*5*3 * vn2*vn2*vn2*vn2*vn2*vn2*vn2;
            s1 +=    11*9*7*5*3 * vn2*vn2*vn2*vn2*vn2*vn2;
            s1 +=      -9*7*5*3 * vn2*vn2*vn2*vn2*vn2;
            s1 +=         7*5*3 * vn2*vn2*vn2*vn2;
            s1 +=          -5*3 * vn2*vn2*vn2;
            s1 +=            3 * vn2*vn2    - vn2  +    1.0;
    v = std::sqrt ( 2.0 * std::log ( s1 / (r*guess*std::sqrt(CLHEP::twopi)) ) );
    if ( std::abs(v-guess) < eps ) break;
    guess = v;
  }
 
  return -v;

} // transformSmall()

Here is the caller graph for this function:

X_HAT2()

static const Hep2Vector CLHEP::X_HAT2 ( 1.  0, 0.  0  )

static

Y_HAT2()

static const Hep2Vector CLHEP::Y_HAT2 ( 0.  0, 1.  0  )

static

ZMinput2doubles()

void CLHEP::ZMinput2doubles	(	std::istream &	is,
		const char *	type,
		double &	x,
		double &	y
	)

Definition at line 243 of file ZMinput.cc.

                                     {

// Accepted formats are 
// x y 
// x, y (comma is optional, and whitespace ignored if comma present)
// ( x, y ) (comma optional)

  char c;
  bool parenthesis = false;

  if ( !eatwhitespace(is) ) {
    std::cerr << "istream ended before trying to input " << type << "\n";
    return;
  }

  if ( !is.get(c) ) { fouledup(); return; }
  if ( c == '(' ) {
    parenthesis = true;
    if ( !eatwhitespace(is) ) {
      std::cerr << "istream ended after ( trying to input " << type << "\n";
      return;
    }
  } else {
    is.putback(c);
  }  

  // At this point, parenthesis or not, the next item read is supposed to
  // be the number x.

  if (!(is >> x)) {
    std::cerr << "Could not read first value in input of " << type << "\n";
    return;
  }

  if ( !eatwhitespace(is) ) {
    std::cerr << "istream ended before second value of " << type << "\n";
    return;
  } 

  if ( !is.get(c) ) { fouledup(); return; }
  if ( c == ',' ) {
    if ( !eatwhitespace(is) ) {
      std::cerr << "istream ended ater one value and comma in " 
                            << type << "\n";
      return;
    }
  } else {
    is.putback(c);
  }

  // At this point, comma or not, the next item read is supposed to
  // be the number y.

  if (!(is >> y)) {
    std::cerr << "Could not read second value in input of " << type << "\n";
    return;
  }

  // Finally, check for the closing parenthesis if there was an open paren.

  if (parenthesis) {
    if ( !eatwhitespace(is) ) {
      std::cerr << "No closing parenthesis in input of " << type << "\n";
      return;
    } 
    if ( !is.get(c) ) { fouledup(); return; }
    if ( c != ')' ) {
      std::cerr << "Missing closing parenthesis in input of " 
                            << type << "\n";
      // Now a trick to do (as nearly as we can) what 
      // is.putback(c); is.setstate(std::ios_base::failbit); 
      // would do (because using ios_base will confuse old CLHEP compilers):
      if ( isdigit(c) || (c=='-') || (c=='+') ) {
        is.putback('@');
      } else {
        is.putback('c');
      }
      int m;
      is >> m;  // This fails, leaving the state bad, and the istream
        // otherwise unchanged, except if the next char might
        // have started a valid int, it turns to @
      return;
    }
  }

  return;

}

Here is the caller graph for this function:

ZMinput3doubles()

void CLHEP::ZMinput3doubles	(	std::istream &	is,
		const char *	type,
		double &	x,
		double &	y,
		double &	z
	)

Definition at line 42 of file ZMinput.cc.

                                                 {

// Accepted formats are 
// x y z
// x, y, z (each comma is optional, and whitespace ignored if comma present)
// ( x, y, z ) (commas optional)

  char c;
  bool parenthesis = false;

  if ( !eatwhitespace(is) ) {
    std::cerr << "istream ended before trying to input " << type << "\n";
    return;
  }

  if ( !is.get(c) ) { fouledup(); return; }
  if ( c == '(' ) {
    parenthesis = true;
    if ( !eatwhitespace(is) ) {
      std::cerr << "istream ended after ( trying to input " << type << "\n";
      return;
    }
  } else {
    is.putback(c);
  }  

  // At this point, parenthesis or not, the next item read is supposed to
  // be the number x.

  if (!(is >> x)) {
    std::cerr << "Could not read first value in input of " << type << "\n";
    return;
  }

  if ( !eatwhitespace(is) ) {
    std::cerr << "istream ended before second value of " << type << "\n";
    return;
  } 

  if ( !is.get(c) ) { fouledup(); return; }
  if ( c == ',' ) {
    if ( !eatwhitespace(is) ) {
      std::cerr << "istream ended ater one value and comma in " 
                            << type << "\n";
      return;
    }
  } else {
    is.putback(c);
  }

  // At this point, comma or not, the next item read is supposed to
  // be the number y.

  if (!(is >> y)) {
    std::cerr << "Could not read second value in input of " << type << "\n";
    return;
  }

  if ( !eatwhitespace(is) ) {
    std::cerr << "istream ended before third value of " << type << "\n";
    return;
  } 

  if ( !is.get(c) ) { fouledup(); return; }
  if ( c == ',' ) {
    if ( !eatwhitespace(is) ) {
      std::cerr << "istream ended ater two values and comma in " 
                            << type << "\n";
      return;
    }
  } else {
    is.putback(c);
  }

  // At this point, comma or not, the next item read is supposed to
  // be the number z.

  if (!(is >> z)) {
    std::cerr << "Could not read third value in input of " << type << "\n";
    return;
  }

  // Finally, check for the closing parenthesis if there was an open paren.

  if (parenthesis) {
    if ( !eatwhitespace(is) ) {
      std::cerr << "No closing parenthesis in input of " << type << "\n";
      return;
    } 
    if ( !is.get(c) ) { fouledup(); return; }
    if ( c != ')' ) {
      std::cerr << "Missing closing parenthesis in input of " 
                            << type << "\n";
      // Now a trick to do (as nearly as we can) what 
      // is.putback(c); is.setstate(std::ios_base::failbit); 
      // would do (because using ios_base will confuse old CLHEP compilers):
      if ( isdigit(c) || (c=='-') || (c=='+') ) {
        is.putback('@');
      } else {
        is.putback('c');
      }
      int m;
      is >> m;  // This fails, leaving the state bad, and the istream
        // otherwise unchanged, except if the next char might
        // have started a valid int, it turns to @
      return;
    }
  }

  return;

}

Here is the caller graph for this function:

ZMinputAxisAngle()

void CLHEP::ZMinputAxisAngle	(	std::istream &	is,
		double &	x,
		double &	y,
		double &	z,
		double &	delta
	)

Definition at line 156 of file ZMinput.cc.

                             {
// Accepted formats are 
// parenthesis optional, then
// any acceptable format for a Hep3Vector, then
// optional comma, then
// delta, then
// close parenthesis if opened at start.
//
// But if there is an open parenthesis, it must be for the overall
// object.  That is, if the axis has parentheses, the form must be 
// ( (x,y,z) , delta ) 

  char c;
  bool parenthesis = false;

  if ( !eatwhitespace(is) ) {
    std::cerr << "istream ended before trying to input AxisAngle \n";
    return;
  }

  if ( !is.get(c) ) { fouledup(); return; }
  if ( c == '(' ) {
    parenthesis = true;
    if ( !eatwhitespace(is) ) {
      std::cerr << "istream ended after ( trying to input AxisAngle \n";
      return;
    }
  } else {
    is.putback(c);
  }  

  // At this point, parenthesis or not, the next item read is supposed to
  // be a valid Hep3Vector axis.

  ZMinput3doubles ( is, "axis of AxisAngle", x, y, z );
  if (!is) return;

  if ( !eatwhitespace(is) ) {
    std::cerr << "istream ended before delta of AxisAngle \n";
    return;
  } 

  if ( !is.get(c) ) { fouledup(); return; }
  if ( c == ',' ) {
    if ( !eatwhitespace(is) ) {
      std::cerr << "istream ended ater axis and comma in AxisAngle \n"; 
      return;
    }
  } else {
    is.putback(c);
  }

  // At this point, comma or not, the next item read is supposed to
  // be the number delta.

  if (!(is >> delta)) {
    std::cerr << "Could not delta value in input of AxisAngle \n";
    return;
  }

  // Finally, check for the closing parenthesis if there was an open paren.

  if (parenthesis) {
    if ( !eatwhitespace(is) ) {
      std::cerr << "No closing parenthesis in input of AxisAngle \n";
      return;
    } 
    if ( !is.get(c) ) { fouledup(); return; }
    if ( c != ')' ) {
      std::cerr << "Missing closing parenthesis in input of AxisAngle \n";
      if ( isdigit(c) || (c=='-') || (c=='+') ) {
        is.putback('@');
      } else {
        is.putback('c');
      }
      int m;
      is >> m;  // This fails, leaving the state bad.
      return;
    }
  }

  return;

}

Here is the call graph for this function:

Here is the caller graph for this function:

ZMpvAxisAngleRep()

static void CLHEP::ZMpvAxisAngleRep ( const HepAxisAngle &  aa, double  array[]  )

static

Definition at line 20 of file AxisAngle.cc.

                                                                        {

  double sinDelta = std::sin( aa.delta() );
  double cosDelta = std::cos( aa.delta() );
  double oneMinusCosDelta = 1.0 - cosDelta;

  double uX = aa.getAxis().getX();
  double uY = aa.getAxis().getY();
  double uZ = aa.getAxis().getZ();

  array[0] = oneMinusCosDelta * uX * uX  +  cosDelta;
  array[1] = oneMinusCosDelta * uX * uY  -  sinDelta * uZ;
  array[2] = oneMinusCosDelta * uX * uZ  +  sinDelta * uY;

  array[3] = oneMinusCosDelta * uY * uX  +  sinDelta * uZ;
  array[4] = oneMinusCosDelta * uY * uY  +  cosDelta;
  array[5] = oneMinusCosDelta * uY * uZ  -  sinDelta * uX;

  array[6] = oneMinusCosDelta * uZ * uX  -  sinDelta * uY;
  array[7] = oneMinusCosDelta * uZ * uY  +  sinDelta * uX;
  array[8] = oneMinusCosDelta * uZ * uZ  +  cosDelta;

} // ZMpvAxisAngleRep

Here is the call graph for this function:

Here is the caller graph for this function:

ZMpvEulerAnglesRep()

static void CLHEP::ZMpvEulerAnglesRep ( const HepEulerAngles &  ex, double  array[]  )

static

Definition at line 43 of file EulerAngles.cc.

                                                                             {

  double sinPhi   = std::sin( ex.phi() )  , cosPhi   = std::cos( ex.phi() );
  double sinTheta = std::sin( ex.theta() ), cosTheta = std::cos( ex.theta() );
  double sinPsi   = std::sin( ex.psi() )  , cosPsi   = std::cos( ex.psi() );

  array[0] =   cosPsi * cosPhi   - sinPsi * cosTheta * sinPhi;
  array[1] =   cosPsi * sinPhi   + sinPsi * cosTheta * cosPhi;
  array[2] =   sinPsi * sinTheta;

  array[3] = - sinPsi * cosPhi - cosPsi * cosTheta * sinPhi;
  array[4] = - sinPsi * sinPhi   + cosPsi * cosTheta * cosPhi;
  array[5] =   cosPsi * sinTheta;

  array[6] =   sinTheta * sinPhi;
  array[7] = - sinTheta * cosPhi;
  array[8] =   cosTheta;

} // ZMpvEulerAnglesRep

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

alpha_rcl2

const double CLHEP::alpha_rcl2

static

Initial value:

= fine_structure_const
                                   *classic_electr_radius
                                   *classic_electr_radius

Definition at line 101 of file PhysicalConstants.h.

ampere

const double CLHEP::ampere = coulomb/second

static

Definition at line 211 of file SystemOfUnits.h.

amu

const double CLHEP::amu = amu_c2/c_squared

static

Definition at line 83 of file PhysicalConstants.h.

amu_c2

const double CLHEP::amu_c2 = 931.494028 * MeV

static

Definition at line 82 of file PhysicalConstants.h.

angstrom

const double CLHEP::angstrom = 1.e-10*meter

static

Definition at line 81 of file SystemOfUnits.h.

atmosphere

const double CLHEP::atmosphere = 101325*pascal

static

Definition at line 206 of file SystemOfUnits.h.

Avogadro

const double CLHEP::Avogadro = 6.02214179e+23/mole

static

Definition at line 49 of file PhysicalConstants.h.

bar

const double CLHEP::bar = 100000*pascal

static

Definition at line 205 of file SystemOfUnits.h.

barn

const double CLHEP::barn = 1.e-28*meter2

static

Definition at line 84 of file SystemOfUnits.h.

becquerel

const double CLHEP::becquerel = 1./second

static

Definition at line 268 of file SystemOfUnits.h.

Bohr_radius

const double CLHEP::Bohr_radius = electron_Compton_length/fine_structure_const

static

Definition at line 99 of file PhysicalConstants.h.

Bq

const double CLHEP::Bq = becquerel

static

Definition at line 275 of file SystemOfUnits.h.

c_light

const double CLHEP::c_light = 2.99792458e+8 * m/s

static

Definition at line 55 of file PhysicalConstants.h.

c_squared

const double CLHEP::c_squared = c_light * c_light

static

Definition at line 56 of file PhysicalConstants.h.

candela

const double CLHEP::candela = 1.

static

Definition at line 294 of file SystemOfUnits.h.

centimeter

const double CLHEP::centimeter = 10.*millimeter

static

Definition at line 65 of file SystemOfUnits.h.

centimeter2

const double CLHEP::centimeter2 = centimeter*centimeter

static

Definition at line 66 of file SystemOfUnits.h.

centimeter3

const double CLHEP::centimeter3 = centimeter*centimeter*centimeter

static

Definition at line 67 of file SystemOfUnits.h.

Ci

const double CLHEP::Ci = curie

static

Definition at line 279 of file SystemOfUnits.h.

cL

const double CLHEP::cL = 1.e-2*liter

static

Definition at line 105 of file SystemOfUnits.h.

classic_electr_radius

const double CLHEP::classic_electr_radius = elm_coupling/electron_mass_c2

static

Definition at line 97 of file PhysicalConstants.h.

cm

const double CLHEP::cm = centimeter

static

Definition at line 98 of file SystemOfUnits.h.

cm2

const double CLHEP::cm2 = centimeter2

static

Definition at line 99 of file SystemOfUnits.h.

cm3

const double CLHEP::cm3 = centimeter3

static

Definition at line 100 of file SystemOfUnits.h.

coulomb

const double CLHEP::coulomb = eplus/e_SI

static

Definition at line 156 of file SystemOfUnits.h.

curie

const double CLHEP::curie = 3.7e+10 * becquerel

static

Definition at line 269 of file SystemOfUnits.h.

deg

const double CLHEP::deg = degree

static

Definition at line 131 of file SystemOfUnits.h.

degree

const double CLHEP::degree = (pi/180.0)*radian

static

Definition at line 123 of file SystemOfUnits.h.

dL

const double CLHEP::dL = 1.e-1*liter

static

Definition at line 104 of file SystemOfUnits.h.

e_SI

const double CLHEP::e_SI = 1.602176487e-19

static

Definition at line 155 of file SystemOfUnits.h.

e_squared

const double CLHEP::e_squared = eplus * eplus

static

Definition at line 72 of file PhysicalConstants.h.

electron_charge

const double CLHEP::electron_charge = - eplus

static

Definition at line 71 of file PhysicalConstants.h.

electron_Compton_length

const double CLHEP::electron_Compton_length = hbarc/electron_mass_c2

static

Definition at line 98 of file PhysicalConstants.h.

electron_mass_c2

const double CLHEP::electron_mass_c2 = 0.510998910 * MeV

static

Definition at line 79 of file PhysicalConstants.h.

electronvolt

const double CLHEP::electronvolt = 1.e-6*megaelectronvolt

static

Definition at line 162 of file SystemOfUnits.h.

elm_coupling

const double CLHEP::elm_coupling = e_squared/(4*pi*epsilon0)

static

Definition at line 95 of file PhysicalConstants.h.

eplus

const double CLHEP::eplus = 1.

static

Definition at line 154 of file SystemOfUnits.h.

epsilon0

const double CLHEP::epsilon0 = 1./(c_squared*mu0)

static

Definition at line 90 of file PhysicalConstants.h.

eV

const double CLHEP::eV = electronvolt

static

Definition at line 172 of file SystemOfUnits.h.

farad

const double CLHEP::farad = coulomb/volt

static

Definition at line 231 of file SystemOfUnits.h.

fermi

const double CLHEP::fermi = 1.e-15*meter

static

Definition at line 82 of file SystemOfUnits.h.

fine_structure_const

const double CLHEP::fine_structure_const = elm_coupling/hbarc

static

Definition at line 96 of file PhysicalConstants.h.

g

const double CLHEP::g = gram

static

Definition at line 187 of file SystemOfUnits.h.

gauss

const double CLHEP::gauss = 1.e-4*tesla

static

Definition at line 247 of file SystemOfUnits.h.

gaussTables [1/2]

const double CLHEP::gaussTables[2 *TableSize]

static

Initial value:

= {

}

Definition at line 85 of file flatToGaussian.cc.

gaussTables [2/2]

const float CLHEP::gaussTables[TableSize]

static

Initial value:

= {

}

Definition at line 88 of file RandGaussQ.cc.

GBq

const double CLHEP::GBq = gigabecquerel

static

Definition at line 278 of file SystemOfUnits.h.

GeV

const double CLHEP::GeV = gigaelectronvolt

static

Definition at line 174 of file SystemOfUnits.h.

gigabecquerel

const double CLHEP::gigabecquerel = 1.e+9*becquerel

static

Definition at line 272 of file SystemOfUnits.h.

gigaelectronvolt

const double CLHEP::gigaelectronvolt = 1.e+3*megaelectronvolt

static

Definition at line 164 of file SystemOfUnits.h.

gram

const double CLHEP::gram = 1.e-3*kilogram

static

Definition at line 182 of file SystemOfUnits.h.

gray

const double CLHEP::gray = joule/kilogram

static

Definition at line 286 of file SystemOfUnits.h.

h_Planck

const double CLHEP::h_Planck = 6.62606896e-34 * joule*s

static

Definition at line 63 of file PhysicalConstants.h.

halfpi

const double CLHEP::halfpi = pi/2

static

Definition at line 55 of file SystemOfUnits.h.

hbar_Planck

const double CLHEP::hbar_Planck = h_Planck/twopi

static

Definition at line 64 of file PhysicalConstants.h.

hbarc

const double CLHEP::hbarc = hbar_Planck * c_light

static

Definition at line 65 of file PhysicalConstants.h.

hbarc_squared

const double CLHEP::hbarc_squared = hbarc * hbarc

static

Definition at line 66 of file PhysicalConstants.h.

henry

const double CLHEP::henry = weber/ampere

static

Definition at line 253 of file SystemOfUnits.h.

hep_pascal

const double CLHEP::hep_pascal = newton/m2

static

Definition at line 204 of file SystemOfUnits.h.

HepRandomGenActive

const int CLHEP::HepRandomGenActive = HepRandom::createInstance()

static

Definition at line 65 of file Randomize.h.

HepXHat

const Hep3Vector CLHEP::HepXHat(1.0, 0.0, 0.0)

HepYHat

const Hep3Vector CLHEP::HepYHat(0.0, 1.0, 0.0)

HepZHat

const Hep3Vector CLHEP::HepZHat(0.0, 0.0, 1.0)

hertz

const double CLHEP::hertz = 1./second

static

Definition at line 142 of file SystemOfUnits.h.

inverseLandau

const float CLHEP::inverseLandau[TABLE_END+1]

static

Definition at line 74 of file RandLandau.cc.

joule

const double CLHEP::joule = electronvolt/e_SI

static

Definition at line 168 of file SystemOfUnits.h.

k_Boltzmann

const double CLHEP::k_Boltzmann = 8.617343e-11 * MeV/kelvin

static

Definition at line 111 of file PhysicalConstants.h.

kBq

const double CLHEP::kBq = kilobecquerel

static

Definition at line 276 of file SystemOfUnits.h.

kelvin

const double CLHEP::kelvin = 1.

static

Definition at line 258 of file SystemOfUnits.h.

keV

const double CLHEP::keV = kiloelectronvolt

static

Definition at line 173 of file SystemOfUnits.h.

kg

const double CLHEP::kg = kilogram

static

Definition at line 186 of file SystemOfUnits.h.

kGasThreshold

const double CLHEP::kGasThreshold = 10.*mg/cm3

static

Definition at line 118 of file PhysicalConstants.h.

kilobecquerel

const double CLHEP::kilobecquerel = 1.e+3*becquerel

static

Definition at line 270 of file SystemOfUnits.h.

kiloelectronvolt

const double CLHEP::kiloelectronvolt = 1.e-3*megaelectronvolt

static

Definition at line 163 of file SystemOfUnits.h.

kilogauss

const double CLHEP::kilogauss = 1.e-1*tesla

static

Definition at line 248 of file SystemOfUnits.h.

kilogram

const double CLHEP::kilogram = joule*second*second/(meter*meter)

static

Definition at line 181 of file SystemOfUnits.h.

kilogray

const double CLHEP::kilogray = 1.e+3*gray

static

Definition at line 287 of file SystemOfUnits.h.

kilohertz

const double CLHEP::kilohertz = 1.e+3*hertz

static

Definition at line 143 of file SystemOfUnits.h.

kilometer

const double CLHEP::kilometer = 1000.*meter

static

Definition at line 73 of file SystemOfUnits.h.

kilometer2

const double CLHEP::kilometer2 = kilometer*kilometer

static

Definition at line 74 of file SystemOfUnits.h.

kilometer3

const double CLHEP::kilometer3 = kilometer*kilometer*kilometer

static

Definition at line 75 of file SystemOfUnits.h.

kilovolt

const double CLHEP::kilovolt = 1.e-3*megavolt

static

Definition at line 220 of file SystemOfUnits.h.

km

const double CLHEP::km = kilometer

static

Definition at line 112 of file SystemOfUnits.h.

km2

const double CLHEP::km2 = kilometer2

static

Definition at line 113 of file SystemOfUnits.h.

km3

const double CLHEP::km3 = kilometer3

static

Definition at line 114 of file SystemOfUnits.h.

L

const double CLHEP::L = liter

static

Definition at line 103 of file SystemOfUnits.h.

liter

const double CLHEP::liter = 1.e+3*cm3

static

Definition at line 102 of file SystemOfUnits.h.

lumen

const double CLHEP::lumen = candela*steradian

static

Definition at line 299 of file SystemOfUnits.h.

lux

const double CLHEP::lux = lumen/meter2

static

Definition at line 304 of file SystemOfUnits.h.

m

const double CLHEP::m = meter

static

Definition at line 108 of file SystemOfUnits.h.

m2

const double CLHEP::m2 = meter2

static

Definition at line 109 of file SystemOfUnits.h.

m3

const double CLHEP::m3 = meter3

static

Definition at line 110 of file SystemOfUnits.h.

MarkerLen [1/8]

const int CLHEP::MarkerLen = 64

static

Definition at line 49 of file MixMaxRng.cc.

MarkerLen [2/8]

const int CLHEP::MarkerLen = 64

static

Definition at line 56 of file RanecuEngine.cc.

MarkerLen [3/8]

const int CLHEP::MarkerLen = 64

static

Definition at line 58 of file RanluxEngine.cc.

MarkerLen [4/8]

const int CLHEP::MarkerLen = 64

static

Definition at line 59 of file JamesRandom.cc.

MarkerLen [5/8]

const int CLHEP::MarkerLen = 64

static

Definition at line 59 of file RanshiEngine.cc.

MarkerLen [6/8]

const int CLHEP::MarkerLen = 64

static

Definition at line 60 of file MTwistEngine.cc.

MarkerLen [7/8]

const int CLHEP::MarkerLen = 64

static

Definition at line 67 of file DualRand.cc.

MarkerLen [8/8]

const int CLHEP::MarkerLen = 64

static

Definition at line 76 of file Ranlux64Engine.cc.

MBq

const double CLHEP::MBq = megabecquerel

static

Definition at line 277 of file SystemOfUnits.h.

mCi

const double CLHEP::mCi = millicurie

static

Definition at line 280 of file SystemOfUnits.h.

megabecquerel

const double CLHEP::megabecquerel = 1.e+6*becquerel

static

Definition at line 271 of file SystemOfUnits.h.

megaelectronvolt

const double CLHEP::megaelectronvolt = 1.

static

Definition at line 161 of file SystemOfUnits.h.

megahertz

const double CLHEP::megahertz = 1.e+6*hertz

static

Definition at line 144 of file SystemOfUnits.h.

megavolt

const double CLHEP::megavolt = megaelectronvolt/eplus

static

Definition at line 219 of file SystemOfUnits.h.

meter

const double CLHEP::meter = 1000.*millimeter

static

Definition at line 69 of file SystemOfUnits.h.

meter2

const double CLHEP::meter2 = meter*meter

static

Definition at line 70 of file SystemOfUnits.h.

meter3

const double CLHEP::meter3 = meter*meter*meter

static

Definition at line 71 of file SystemOfUnits.h.

MeV

const double CLHEP::MeV = megaelectronvolt

static

Definition at line 171 of file SystemOfUnits.h.

mg

const double CLHEP::mg = milligram

static

Definition at line 188 of file SystemOfUnits.h.

microampere

const double CLHEP::microampere = 1.e-6*ampere

static

Definition at line 213 of file SystemOfUnits.h.

microbarn

const double CLHEP::microbarn = 1.e-6 *barn

static

Definition at line 86 of file SystemOfUnits.h.

microcurie

const double CLHEP::microcurie = 1.e-6*curie

static

Definition at line 274 of file SystemOfUnits.h.

microfarad

const double CLHEP::microfarad = 1.e-6*farad

static

Definition at line 233 of file SystemOfUnits.h.

microgray

const double CLHEP::microgray = 1.e-6*gray

static

Definition at line 289 of file SystemOfUnits.h.

micrometer

const double CLHEP::micrometer = 1.e-6 *meter

static

Definition at line 79 of file SystemOfUnits.h.

microsecond

const double CLHEP::microsecond = 1.e-6 *second

static

Definition at line 139 of file SystemOfUnits.h.

milliampere

const double CLHEP::milliampere = 1.e-3*ampere

static

Definition at line 212 of file SystemOfUnits.h.

millibarn

const double CLHEP::millibarn = 1.e-3 *barn

static

Definition at line 85 of file SystemOfUnits.h.

millicurie

const double CLHEP::millicurie = 1.e-3*curie

static

Definition at line 273 of file SystemOfUnits.h.

millifarad

const double CLHEP::millifarad = 1.e-3*farad

static

Definition at line 232 of file SystemOfUnits.h.

milligram

const double CLHEP::milligram = 1.e-3*gram

static

Definition at line 183 of file SystemOfUnits.h.

milligray

const double CLHEP::milligray = 1.e-3*gray

static

Definition at line 288 of file SystemOfUnits.h.

millimeter

const double CLHEP::millimeter = 1.

static

Definition at line 61 of file SystemOfUnits.h.

millimeter2

const double CLHEP::millimeter2 = millimeter*millimeter

static

Definition at line 62 of file SystemOfUnits.h.

millimeter3

const double CLHEP::millimeter3 = millimeter*millimeter*millimeter

static

Definition at line 63 of file SystemOfUnits.h.

milliradian

const double CLHEP::milliradian = 1.e-3*radian

static

Definition at line 122 of file SystemOfUnits.h.

millisecond

const double CLHEP::millisecond = 1.e-3 *second

static

Definition at line 138 of file SystemOfUnits.h.

mL

const double CLHEP::mL = 1.e-3*liter

static

Definition at line 106 of file SystemOfUnits.h.

mm

const double CLHEP::mm = millimeter

static

Definition at line 94 of file SystemOfUnits.h.

mm2

const double CLHEP::mm2 = millimeter2

static

Definition at line 95 of file SystemOfUnits.h.

mm3

const double CLHEP::mm3 = millimeter3

static

Definition at line 96 of file SystemOfUnits.h.

mole

const double CLHEP::mole = 1.

static

Definition at line 263 of file SystemOfUnits.h.

mrad

const double CLHEP::mrad = milliradian

static

Definition at line 129 of file SystemOfUnits.h.

ms

const double CLHEP::ms = millisecond

static

Definition at line 149 of file SystemOfUnits.h.

mu0

const double CLHEP::mu0 = 4*pi*1.e-7 * henry/m

static

Definition at line 89 of file PhysicalConstants.h.

N

const int CLHEP::N = 256

Definition at line 43 of file mixmax.h.

nanoampere

const double CLHEP::nanoampere = 1.e-9*ampere

static

Definition at line 214 of file SystemOfUnits.h.

nanobarn

const double CLHEP::nanobarn = 1.e-9 *barn

static

Definition at line 87 of file SystemOfUnits.h.

nanofarad

const double CLHEP::nanofarad = 1.e-9*farad

static

Definition at line 234 of file SystemOfUnits.h.

nanometer

const double CLHEP::nanometer = 1.e-9 *meter

static

Definition at line 80 of file SystemOfUnits.h.

nanosecond

const double CLHEP::nanosecond = 1.

static

Definition at line 136 of file SystemOfUnits.h.

neutron_mass_c2

const double CLHEP::neutron_mass_c2 = 939.56536 * MeV

static

Definition at line 81 of file PhysicalConstants.h.

newton

const double CLHEP::newton = joule/meter

static

Definition at line 198 of file SystemOfUnits.h.

nm

const double CLHEP::nm = nanometer

static

Definition at line 91 of file SystemOfUnits.h.

ns

const double CLHEP::ns = nanosecond

static

Definition at line 147 of file SystemOfUnits.h.

ohm

const double CLHEP::ohm = volt/ampere

static

Definition at line 226 of file SystemOfUnits.h.

parsec

const double CLHEP::parsec = 3.0856775807e+16*meter

static

Definition at line 77 of file SystemOfUnits.h.

pc

const double CLHEP::pc = parsec

static

Definition at line 116 of file SystemOfUnits.h.

perCent

const double CLHEP::perCent = 0.01

static

Definition at line 309 of file SystemOfUnits.h.

perMillion

const double CLHEP::perMillion = 0.000001

static

Definition at line 311 of file SystemOfUnits.h.

perThousand

const double CLHEP::perThousand = 0.001

static

Definition at line 310 of file SystemOfUnits.h.

petaelectronvolt

const double CLHEP::petaelectronvolt = 1.e+9*megaelectronvolt

static

Definition at line 166 of file SystemOfUnits.h.

PeV

const double CLHEP::PeV = petaelectronvolt

static

Definition at line 176 of file SystemOfUnits.h.

pi

const double CLHEP::pi = 3.14159265358979323846

static

Definition at line 53 of file SystemOfUnits.h.

pi2

const double CLHEP::pi2 = pi*pi

static

Definition at line 56 of file SystemOfUnits.h.

picobarn

const double CLHEP::picobarn = 1.e-12*barn

static

Definition at line 88 of file SystemOfUnits.h.

picofarad

const double CLHEP::picofarad = 1.e-12*farad

static

Definition at line 235 of file SystemOfUnits.h.

picosecond

const double CLHEP::picosecond = 1.e-12*second

static

Definition at line 140 of file SystemOfUnits.h.

poissonTables

const double CLHEP::poissonTables[51 *((95-10)/5+1)]

static

Initial value:

= {

}

Definition at line 72 of file RandPoissonQ.cc.

prec

const double CLHEP::prec = 4.6566128E-10

static

Definition at line 58 of file RanecuEngine.cc.

proton_mass_c2

const double CLHEP::proton_mass_c2 = 938.272013 * MeV

static

Definition at line 80 of file PhysicalConstants.h.

rad

const double CLHEP::rad = radian

static

Definition at line 128 of file SystemOfUnits.h.

radian

const double CLHEP::radian = 1.

static

Definition at line 121 of file SystemOfUnits.h.

s

const double CLHEP::s = second

static

Definition at line 148 of file SystemOfUnits.h.

second

const double CLHEP::second = 1.e+9 *nanosecond

static

Definition at line 137 of file SystemOfUnits.h.

sr

const double CLHEP::sr = steradian

static

Definition at line 130 of file SystemOfUnits.h.

steradian

const double CLHEP::steradian = 1.

static

Definition at line 125 of file SystemOfUnits.h.

STP_Pressure

const double CLHEP::STP_Pressure = 1.*atmosphere

static

Definition at line 117 of file PhysicalConstants.h.

STP_Temperature

const double CLHEP::STP_Temperature = 273.15*kelvin

static

Definition at line 116 of file PhysicalConstants.h.

T_HAT4

const HepLorentzVector CLHEP::T_HAT4 = HepLorentzVector( 0, 0, 0, 1 )

static

Definition at line 540 of file LorentzVector.h.

TABLE_END

const int CLHEP::TABLE_END = 982

static

Definition at line 61 of file RandLandau.cc.

TABLE_INTERVAL

const float CLHEP::TABLE_INTERVAL = .001f

static

Definition at line 60 of file RandLandau.cc.

TABLE_MULTIPLIER

const float CLHEP::TABLE_MULTIPLIER = 1.0f/TABLE_INTERVAL

static

Definition at line 62 of file RandLandau.cc.

teraelectronvolt

const double CLHEP::teraelectronvolt = 1.e+6*megaelectronvolt

static

Definition at line 165 of file SystemOfUnits.h.

tesla

const double CLHEP::tesla = volt*second/meter2

static

Definition at line 245 of file SystemOfUnits.h.

TeV

const double CLHEP::TeV = teraelectronvolt

static

Definition at line 175 of file SystemOfUnits.h.

Toffsets

const int CLHEP::Toffsets[5]

static

Initial value:

= { Table0offset,
                 Table1offset,
                 Table2offset,
                 Table3offset,
                 Table4offset }

Definition at line 77 of file flatToGaussian.cc.

Tsizes

const int CLHEP::Tsizes[5]

static

Initial value:

=   { Table0size,
                 Table1size,
                 Table2size,
                 Table3size,
                 Table4size }

Definition at line 53 of file flatToGaussian.cc.

Tsteps

const double CLHEP::Tsteps[5]

static

Initial value:

= { Table0step,
                 Table1step,
                 Table2step,
                 Table3step,
                 Table4step }

Definition at line 65 of file flatToGaussian.cc.

twopi

const double CLHEP::twopi = 2*pi

static

Definition at line 54 of file SystemOfUnits.h.

twopi_mc2_rcl2

const double CLHEP::twopi_mc2_rcl2

static

Initial value:

= twopi*electron_mass_c2
                                             *classic_electr_radius
                                             *classic_electr_radius

Definition at line 105 of file PhysicalConstants.h.

uCi

const double CLHEP::uCi = microcurie

static

Definition at line 281 of file SystemOfUnits.h.

um

const double CLHEP::um = micrometer

static

Definition at line 92 of file SystemOfUnits.h.

universe_mean_density

const double CLHEP::universe_mean_density = 1.e-25*g/cm3

static

Definition at line 123 of file PhysicalConstants.h.

volt

const double CLHEP::volt = 1.e-6*megavolt

static

Definition at line 221 of file SystemOfUnits.h.

watt

const double CLHEP::watt = joule/second

static

Definition at line 193 of file SystemOfUnits.h.

weber

const double CLHEP::weber = volt*second

static

Definition at line 240 of file SystemOfUnits.h.

X_HAT4

const HepLorentzVector CLHEP::X_HAT4 = HepLorentzVector( 1, 0, 0, 0 )

static

Definition at line 537 of file LorentzVector.h.

Y_HAT4

const HepLorentzVector CLHEP::Y_HAT4 = HepLorentzVector( 0, 1, 0, 0 )

static

Definition at line 538 of file LorentzVector.h.

Z_HAT4

const HepLorentzVector CLHEP::Z_HAT4 = HepLorentzVector( 0, 0, 1, 0 )

static

Definition at line 539 of file LorentzVector.h.