Geant4  10.03.p02
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Namespaces | Classes | Typedefs | Enumerations | Functions | Variables
CLHEP Namespace Reference

Namespaces

 detail
 

Classes

class  DoubConvException
 
class  DoubConv
 
class  DualRand
 
class  EngineFactory
 
class  HepJamesRandom
 
struct  rng_state_st
 
class  MixMaxRng
 
class  MTwistEngine
 
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  HepRandom
 
class  HepRandomEngine
 
class  RandPoisson
 
class  RandPoissonQ
 
class  RandStudentT
 
class  RanecuEngine
 
class  Ranlux64Engine
 
class  RanluxEngine
 
class  RanshiEngine
 
class  HepStat
 
class  StaticRandomStates
 
struct  do_nothing_deleter
 
class  noncopyable
 
class  HepAxisAngle
 
class  HepBoost
 
class  HepBoostX
 
class  HepBoostY
 
class  HepBoostZ
 
class  HepEulerAngles
 
class  HepLorentzRotation
 
class  HepLorentzVector
 
class  Tcomponent
 
class  HepRotation
 
class  Hep4RotationInterface
 
class  Hep3RotationInterface
 
struct  HepRep3x3
 
struct  HepRep4x4
 
struct  HepRep4x4Symmetric
 
class  HepRotationX
 
class  HepRotationY
 
class  HepRotationZ
 
class  Hep3Vector
 
class  Hep2Vector
 

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

typedef HepLorentzVector CLHEP::HepLorentzVectorD

Definition at line 550 of file LorentzVector.h.

typedef HepLorentzVector CLHEP::HepLorentzVectorF

Definition at line 551 of file LorentzVector.h.

typedef Hep3Vector CLHEP::HepThreeVectorD

Definition at line 426 of file ThreeVector.h.

typedef Hep3Vector CLHEP::HepThreeVectorF

Definition at line 427 of file ThreeVector.h.

typedef uint32_t CLHEP::myID_t

Definition at line 81 of file mixmax.h.

typedef uint64_t CLHEP::myuint

Definition at line 50 of file mixmax.h.

typedef struct rng_state_st CLHEP::rng_state_t

Definition at line 65 of file mixmax.h.

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

Definition at line 15 of file memory.h.

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

Definition at line 17 of file memory.h.

Enumeration Type Documentation

enum CLHEP::ZMpvMetric_t
Enumerator
TimePositive 
TimeNegative 

Definition at line 64 of file LorentzVector.h.

64 { TimePositive, TimeNegative };

Function Documentation

myuint CLHEP::apply_bigskip ( myuint *  Vout,
myuint *  Vin,
myID_t  clusterID,
myID_t  machineID,
myID_t  runID,
myID_t  streamID 
)
HepLorentzVector CLHEP::boostOf ( const HepLorentzVector &  vec,
const Hep3Vector &  betaVector 
)
inline

Here is the caller graph for this function:

HepLorentzVector CLHEP::boostOf ( const HepLorentzVector &  vec,
const Hep3Vector &  axis,
double  beta 
)
inline
HepLorentzVector CLHEP::boostXOf ( const HepLorentzVector &  vec,
double  beta 
)
inline
HepLorentzVector CLHEP::boostYOf ( const HepLorentzVector &  vec,
double  beta 
)
inline
HepLorentzVector CLHEP::boostZOf ( const HepLorentzVector &  vec,
double  beta 
)
inline
void CLHEP::branch_inplace ( rng_state_t *  Xin,
myID_t *  ID 
)
static void CLHEP::correctByPi ( double &  psi1,
double &  phi1 
)
static

Definition at line 148 of file RotationE.cc.

148  {
149  if (psi1 > 0) {
150  psi1 -= CLHEP::pi;
151  } else {
152  psi1 += CLHEP::pi;
153  }
154  if (phi1 > 0) {
155  phi1 -= CLHEP::pi;
156  } else {
157  phi1 += CLHEP::pi;
158  }
159 }
CLHEP::pi
static constexpr double pi
Definition: SystemOfUnits.h:54

Here is the caller graph for this function:

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.

163  {
164 
165  // set up quatities which would be positive if sin and cosine of
166  // psi1 and phi1 were positive:
167  double w[4];
168  w[0] = rxz; w[1] = rzx; w[2] = ryz; w[3] = -rzy;
169 
170  // find biggest relevant term, which is the best one to use in correcting.
171  double maxw = std::abs(w[0]);
172  int imax = 0;
173  for (int i = 1; i < 4; ++i) {
174  if (std::abs(w[i]) > maxw) {
175  maxw = std::abs(w[i]);
176  imax = i;
177  }
178  }
179  // Determine if the correction needs to be applied: The criteria are
180  // different depending on whether a sine or cosine was the determinor:
181  switch (imax) {
182  case 0:
183  if (w[0] > 0 && psi1 < 0) correctByPi ( psi1, phi1 );
184  if (w[0] < 0 && psi1 > 0) correctByPi ( psi1, phi1 );
185  break;
186  case 1:
187  if (w[1] > 0 && phi1 < 0) correctByPi ( psi1, phi1 );
188  if (w[1] < 0 && phi1 > 0) correctByPi ( psi1, phi1 );
189  break;
190  case 2:
191  if (w[2] > 0 && std::abs(psi1) > CLHEP::halfpi) correctByPi ( psi1, phi1 );
192  if (w[2] < 0 && std::abs(psi1) < CLHEP::halfpi) correctByPi ( psi1, phi1 );
193  break;
194  case 3:
195  if (w[3] > 0 && std::abs(phi1) > CLHEP::halfpi) correctByPi ( psi1, phi1 );
196  if (w[3] < 0 && std::abs(phi1) < CLHEP::halfpi) correctByPi ( psi1, phi1 );
197  break;
198  }
199 }
CLHEP::correctByPi
static void correctByPi(double &psi1, double &phi1)
Definition: RotationE.cc:148
CLHEP::halfpi
static constexpr double halfpi
Definition: SystemOfUnits.h:56
imax
static const G4int imax
Definition: G4ElectroNuclearCrossSection.cc:98

Here is the call graph for this function:

Here is the caller graph for this function:

unsigned long CLHEP::crc32ul ( const std::string &  s)

Definition at line 37 of file engineIDulong.cc.

37  {
38  static const std::vector<unsigned long> crc_table = gen_crc_table();
39  unsigned long crc = 0;
40  int end = s.length();
41  for (int j = 0; j != end; ++j) {
42  int i = ( (int) ( crc >> 24) ^ s[j] ) & 0xff;
43  crc = ( ( crc << 8 ) ^ crc_table[i] ) & 0xffffffffUL;
44  }
45  return crc;
46 }
crc_table
local const z_crc_t FAR crc_table[TBLS][256]
Definition: crc32.h:5
CLHEP::gen_crc_table
static std::vector< unsigned long > gen_crc_table()
Definition: engineIDulong.cc:19
s
const XML_Char * s
Definition: expat.h:262
int
typedef int(XMLCALL *XML_NotStandaloneHandler)(void *userData)

Here is the call graph for this function:

Here is the caller graph for this function:

template<class E >
unsigned long CLHEP::engineIDulong ( )

Definition at line 24 of file engineIDulong.h.

24  {
25  static const unsigned long id = crc32ul(E::engineName());
26  return id;
27 }
CLHEP::crc32ul
unsigned long crc32ul(const std::string &s)
Definition: engineIDulong.cc:37

Here is the call graph for this function:

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

Definition at line 90 of file mixmax.cc.

91 {
92  // Return an array of n random numbers uniformly distributed in (0,1]
93  unsigned int i,j;
94  const int M=N-1;
95  for (i=0; i<(n/M); i++){
96  iterate_and_fill_array(X, array+i*M);
97  }
98  unsigned int rem=(n % M);
99  if (rem) {
100  iterate(X);
101  for (j=0; j< (rem); j++){
102  array[M*i+j] = (int64_t)X->V[j] * (double)(INV_MERSBASE);
103  }
104  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
105  }else{
106  X->counter = N;
107  }
108 }
CLHEP::iterate
int iterate(rng_state_t *X)
Definition: mixmax.cc:39
n
const G4int n
Definition: G4UrQMD1_3Interface.hh:144
CLHEP::iterate_and_fill_array
void iterate_and_fill_array(rng_state_t *X, double *array)
Definition: mixmax.cc:110
INV_MERSBASE
#define INV_MERSBASE
Definition: mixmax.h:130
N
**D E S C R I P T I O N
Definition: HEPEvtcom.cc:77

Here is the call graph for this function:

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

Definition at line 255 of file mixmax.cc.

256 {
257  myuint o,ph,pl,ah,al;
258  o=(s)*a;
259  ph = ((s)>>32);
260  pl = (s) & MASK32;
261  ah = a>>32;
262  al = a & MASK32;
263  o = (o & M61) + ((ph*ah)<<3) + ((ah*pl+al*ph + ((al*pl)>>32))>>29) ;
264  o += cum;
265  o = (o & M61) + ((o>>61));
266  return o;
267 }
a
std::vector< ExP01TrackerHit * > a
Definition: ExP01Classes.hh:33
CLHEP::myuint
uint64_t myuint
Definition: mixmax.h:50
s
const XML_Char * s
Definition: expat.h:262
readPY.pl
tuple pl
Definition: readPY.py:5
M61
#define M61
Definition: mixmax.h:119
MASK32
#define MASK32
Definition: mixmax.cc:253
double CLHEP::gammln ( double  xx)

Definition at line 54 of file RandPoisson.cc.

54  {
55 
56 // Returns the value ln(Gamma(xx) for xx > 0. Full accuracy is obtained for
57 // xx > 1. For 0 < xx < 1. the reflection formula (6.1.4) can be used first.
58 // (Adapted from Numerical Recipes in C)
59 
60  static const double cof[6] = {76.18009172947146,-86.50532032941677,
61  24.01409824083091, -1.231739572450155,
62  0.1208650973866179e-2, -0.5395239384953e-5};
63  int j;
64  double x = xx - 1.0;
65  double tmp = x + 5.5;
66  tmp -= (x + 0.5) * std::log(tmp);
67  double ser = 1.000000000190015;
68 
69  for ( j = 0; j <= 5; j++ ) {
70  x += 1.0;
71  ser += cof[j]/x;
72  }
73  return -tmp + std::log(2.5066282746310005*ser);
74 }
test.x
tuple x
Definition: test.py:50

Here is the caller graph for this function:

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

Definition at line 19 of file engineIDulong.cc.

19  {
20  /* generate the table of CRC remainders for all possible bytes */
21  static const unsigned long POLYNOMIAL = 0x04c11db7UL;
22  std::vector<unsigned long> crc_table;
23  for ( unsigned long i = 0; i < 256; ++i ) {
24  unsigned long crc = i << 24;
25  for ( int j = 0; j < 8; j++ ) {
26  if ( crc & 0x80000000UL ) {
27  crc = ( ( crc << 1 ) ^ POLYNOMIAL ) & 0xffffffffUL;
28  } else {
29  crc = ( crc << 1 ) & 0xffffffffUL;
30  }
31  }
32  crc_table.push_back(crc);
33  }
34  return crc_table;
35 }
crc_table
local const z_crc_t FAR crc_table[TBLS][256]
Definition: crc32.h:5

Here is the caller graph for this function:

myuint CLHEP::GET_BY_MACRO ( rng_state_t *  X)
inline

Definition at line 174 of file mixmax.h.

174  {
175  int i;
176  i=X->counter;
177 
178  if (i<=(N-1) ){
179  X->counter++;
180  return X->V[i];
181  }else{
182  X->sumtot = iterate_raw_vec(X->V, X->sumtot);
183  X->counter=2;
184  return X->V[1];
185  }
186 }
CLHEP::iterate_raw_vec
myuint iterate_raw_vec(myuint *Y, myuint sumtotOld)
Definition: mixmax.cc:52
N
**D E S C R I P T I O N
Definition: HEPEvtcom.cc:77

Here is the call graph for this function:

Here is the caller graph for this function:

myuint CLHEP::get_next ( rng_state_t *  X)

Definition at line 82 of file mixmax.cc.

82  {
83  return GET_BY_MACRO(X);
84 }
CLHEP::GET_BY_MACRO
myuint GET_BY_MACRO(rng_state_t *X)
Definition: mixmax.h:174

Here is the call graph for this function:

Here is the caller graph for this function:

double CLHEP::get_next_float ( rng_state_t *  X)

Definition at line 86 of file mixmax.cc.

86  {
87  return get_next_float_BY_MACRO(X);
88 }
CLHEP::get_next_float_BY_MACRO
double get_next_float_BY_MACRO(rng_state_t *X)
Definition: mixmax.h:189

Here is the call graph for this function:

Here is the caller graph for this function:

double CLHEP::get_next_float_BY_MACRO ( rng_state_t *  X)
inline

Definition at line 189 of file mixmax.h.

189  {
190  int64_t Z=(int64_t)get_next(X);
191 #if defined(__x86_64__) && defined(__SSE__) && defined(__AVX__) && defined(USE_INLINE_ASM)
192  double F;
193  __asm__ __volatile__( "pxor %0, %0;"
194  //"cvtsi2sdq %1, %0;"
195  :"=x"(F)
196  //:"r"(Z)
197  );
198  F=Z;
199  return F*INV_MERSBASE;
200 #else
201  return Z*INV_MERSBASE;
202 #endif
203  }
INV_MERSBASE
#define INV_MERSBASE
Definition: mixmax.h:130
get_next
#define get_next(X)
Definition: mixmax.h:169
Z
G4int Z
Definition: G4ParticleHPJENDLHEData.cc:262

Here is the call graph for this function:

Here is the caller graph for this function:

const Hep3Vector CLHEP::HepXHat ( 1.  0,
0.  0,
0.  0 
)
const Hep3Vector CLHEP::HepYHat ( 0.  0,
1.  0,
0.  0 
)
const Hep3Vector CLHEP::HepZHat ( 0.  0,
0.  0,
1.  0 
)
HepBoostX CLHEP::inverseOf ( const HepBoostX &  b)
inline
HepBoostY CLHEP::inverseOf ( const HepBoostY &  b)
inline
HepBoostZ CLHEP::inverseOf ( const HepBoostZ &  b)
inline
HepRotationY CLHEP::inverseOf ( const HepRotationY &  r)
inline
HepRotationZ CLHEP::inverseOf ( const HepRotationZ &  r)
inline
HepRotationX CLHEP::inverseOf ( const HepRotationX &  r)
inline
HepBoost CLHEP::inverseOf ( const HepBoost &  lt)
inline

Here is the caller graph for this function:

HepRotation CLHEP::inverseOf ( const HepRotation &  r)
inline
HepLorentzRotation CLHEP::inverseOf ( const HepLorentzRotation &  lt)
inline
int CLHEP::iterate ( rng_state_t *  X)

Definition at line 39 of file mixmax.cc.

39  {
40  X->sumtot = iterate_raw_vec(X->V, X->sumtot);
41  return 0;
42 }
CLHEP::iterate_raw_vec
myuint iterate_raw_vec(myuint *Y, myuint sumtotOld)
Definition: mixmax.cc:52

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 110 of file mixmax.cc.

110  {
111  myuint* Y=X->V;
112  int i;
113  myuint tempP, tempV;
114 #if (SPECIAL != 0)
115  myuint temp2 = Y[1];
116 #endif
117  Y[0] = (tempV = modadd(Y[0] , X->sumtot));
118  //array[0] = (double)tempV * (double)(INV_MERSBASE);
119  myuint sumtot = 0, ovflow = 0; // will keep a running sum of all new elements (except Y[0])
120  tempP = 0; // will keep a partial sum of all old elements (except Y[0])
121  for (i=1; i<N; i++){
122  tempP = modadd(tempP,Y[i]);
123  Y[i] = ( tempV = modadd(tempV,tempP) );
124  sumtot += tempV; if (sumtot < tempV) {ovflow++;}
125  array[i-1] = (int64_t)tempV * (double)(INV_MERSBASE);
126  }
127 #if (SPECIAL != 0)
128  temp2 = MOD_MULSPEC(temp2);
129  Y[2] = modadd( Y[2] , temp2 );
130  sumtot += temp2; if (sumtot < temp2) {ovflow++;}
131 #endif
132  X->sumtot = MOD_MERSENNE(MOD_MERSENNE(sumtot) + (ovflow <<3 ));
133 }
Y
double Y(double density)
Definition: G4DNAElectronHoleRecombination.cc:55
CLHEP::myuint
uint64_t myuint
Definition: mixmax.h:50
MOD_MERSENNE
#define MOD_MERSENNE(k)
Definition: mixmax.h:128
CLHEP::modadd
myuint modadd(myuint foo, myuint bar)
Definition: mixmax.cc:135
INV_MERSBASE
#define INV_MERSBASE
Definition: mixmax.h:130
N
**D E S C R I P T I O N
Definition: HEPEvtcom.cc:77

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 52 of file mixmax.cc.

52  {
53  // operates with a raw vector, uses known sum of elements of Y
54  int i;
55 #ifdef SPECIAL
56  myuint temp2 = Y[1];
57 #endif
58  myuint tempP, tempV;
59  Y[0] = ( tempV = sumtotOld);
60  myuint sumtot = Y[0], ovflow = 0; // will keep a running sum of all new elements (except Y[0])
61  tempP = 0; // will keep a partial sum of all old elements (except Y[0])
62  for (i=1; i<N; i++){
63 #if (SPECIALMUL!=0)
64  myuint tempPO = MULWU(tempP);
65  tempP = modadd(tempP,Y[i]);
66  tempV = MOD_MERSENNE(tempV + tempP + tempPO); // edge cases ?
67 #else
68  tempP = modadd(tempP , Y[i]);
69  tempV = modadd(tempV , tempP);
70 #endif
71  Y[i] = tempV;
72  sumtot += tempV; if (sumtot < tempV) {ovflow++;}
73  }
74 #ifdef SPECIAL
75  temp2 = MOD_MULSPEC(temp2);
76  Y[2] = modadd( Y[2] , temp2 );
77  sumtot += temp2; if (sumtot < temp2) {ovflow++;}
78 #endif
79  return MOD_MERSENNE(MOD_MERSENNE(sumtot) + (ovflow <<3 ));
80 }
Y
double Y(double density)
Definition: G4DNAElectronHoleRecombination.cc:55
CLHEP::myuint
uint64_t myuint
Definition: mixmax.h:50
MOD_MERSENNE
#define MOD_MERSENNE(k)
Definition: mixmax.h:128
CLHEP::MULWU
uint64_t MULWU(uint64_t)
Definition: mixmax.cc:47
CLHEP::modadd
myuint modadd(myuint foo, myuint bar)
Definition: mixmax.cc:135
N
**D E S C R I P T I O N
Definition: HEPEvtcom.cc:77

Here is the call graph for this function:

Here is the caller graph for this function:

template<class E >
static HepRandomEngine* CLHEP::makeAnEngine ( const std::string &  tag,
std::istream &  is 
)
static

Definition at line 32 of file EngineFactory.cc.

33  {
34  if ( tag != E::beginTag() ) return 0;
35  HepRandomEngine* eptr = new E;
36  eptr->getState(is);
37  if (!is) return 0;
38  return eptr;
39 }
tag
Definition: xmlparse.cc:187

Here is the call graph for this function:

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

Definition at line 43 of file EngineFactory.cc.

43  {
44  if ( (v[0] & 0xffffffffUL) != engineIDulong<E>() ) return 0;
45  HepRandomEngine* eptr = new E;
46  bool success = eptr->getState(v);
47  if (!success) return 0;
48  // std::cerr << "makeAnEngine made " << E::engineName() << "\n";
49  return eptr;
50 }
test.v
tuple v
Definition: test.py:18

Here is the call graph for this function:

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

Definition at line 135 of file mixmax.cc.

135  {
136 #if defined(__x86_64__) && defined(USE_INLINE_ASM)
137  myuint out;
138  /* Assembler trick suggested by Andrzej Görlich */
139  __asm__ ("addq %2, %0; "
140  "btrq $61, %0; "
141  "adcq $0, %0; "
142  :"=r"(out)
143  :"0"(foo), "r"(bar)
144  );
145  return out;
146 #else
147  return MOD_MERSENNE(foo+bar);
148 #endif
149 }
CLHEP::myuint
uint64_t myuint
Definition: mixmax.h:50
MOD_MERSENNE
#define MOD_MERSENNE(k)
Definition: mixmax.h:128
bar
static constexpr double bar
Definition: G4SIunits.hh:236

Here is the caller graph for this function:

myuint CLHEP::modmulM61 ( myuint  s,
myuint  a 
)
uint64_t CLHEP::MULWU ( uint64_t  )
inline

Definition at line 47 of file mixmax.cc.

47 { return 0;}

Here is the caller graph for this function:

static double CLHEP::normal ( HepRandomEngine *  eptr)
static

Definition at line 77 of file RandPoisson.cc.

78 {
79  double r;
80  double v1,v2,fac;
81  do {
82  v1 = 2.0 * eptr->flat() - 1.0;
83  v2 = 2.0 * eptr->flat() - 1.0;
84  r = v1*v1 + v2*v2;
85  } while ( r > 1.0 );
86 
87  fac = std::sqrt(-2.0*std::log(r)/r);
88  return v2*fac;
89 }
fac
static const G4double fac
Definition: G4NISTStoppingData.hh:87

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 353 of file LorentzRotation.h.

354  { return lt!=r; }
bool CLHEP::operator!= ( const HepBoost &  b,
const HepLorentzRotation &  lt 
)
inline

Definition at line 366 of file LorentzRotation.h.

367  { return lt!=b; }
test.b
tuple b
Definition: test.py:12
double CLHEP::operator* ( const Hep2Vector &  a,
const Hep2Vector &  b 
)
inline
Hep2Vector CLHEP::operator* ( const Hep2Vector &  p,
double  a 
)
inline
HepRotation CLHEP::operator* ( const HepRotationX &  rx,
const HepRotation &  r 
)
inline
Hep2Vector CLHEP::operator* ( double  a,
const Hep2Vector &  p 
)
inline
HepRotation CLHEP::operator* ( const HepRotationY &  ry,
const HepRotation &  r 
)
inline
HepLorentzRotation CLHEP::operator* ( const HepRotation &  r,
const HepLorentzRotation &  lt 
)

Definition at line 264 of file LorentzRotation.cc.

265  {
266  r.rep4x4();
267  lt.rep4x4();
268  return HepLorentzRotation( HepRep4x4(
269  r.xx()*lt.xx() + r.xy()*lt.yx() + r.xz()*lt.zx() + r.xt()*lt.tx(),
270  r.xx()*lt.xy() + r.xy()*lt.yy() + r.xz()*lt.zy() + r.xt()*lt.ty(),
271  r.xx()*lt.xz() + r.xy()*lt.yz() + r.xz()*lt.zz() + r.xt()*lt.tz(),
272  r.xx()*lt.xt() + r.xy()*lt.yt() + r.xz()*lt.zt() + r.xt()*lt.tt(),
273 
274  r.yx()*lt.xx() + r.yy()*lt.yx() + r.yz()*lt.zx() + r.yt()*lt.tx(),
275  r.yx()*lt.xy() + r.yy()*lt.yy() + r.yz()*lt.zy() + r.yt()*lt.ty(),
276  r.yx()*lt.xz() + r.yy()*lt.yz() + r.yz()*lt.zz() + r.yt()*lt.tz(),
277  r.yx()*lt.xt() + r.yy()*lt.yt() + r.yz()*lt.zt() + r.yt()*lt.tt(),
278 
279  r.zx()*lt.xx() + r.zy()*lt.yx() + r.zz()*lt.zx() + r.zt()*lt.tx(),
280  r.zx()*lt.xy() + r.zy()*lt.yy() + r.zz()*lt.zy() + r.zt()*lt.ty(),
281  r.zx()*lt.xz() + r.zy()*lt.yz() + r.zz()*lt.zz() + r.zt()*lt.tz(),
282  r.zx()*lt.xt() + r.zy()*lt.yt() + r.zz()*lt.zt() + r.zt()*lt.tt(),
283 
284  r.tx()*lt.xx() + r.ty()*lt.yx() + r.tz()*lt.zx() + r.tt()*lt.tx(),
285  r.tx()*lt.xy() + r.ty()*lt.yy() + r.tz()*lt.zy() + r.tt()*lt.ty(),
286  r.tx()*lt.xz() + r.ty()*lt.yz() + r.tz()*lt.zz() + r.tt()*lt.tz(),
287  r.tx()*lt.xt() + r.ty()*lt.yt() + r.tz()*lt.zt() + r.tt()*lt.tt() ) );
288 }

Here is the call graph for this function:

HepRotation CLHEP::operator* ( const HepRotationZ &  rz,
const HepRotation &  r 
)
inline
HepLorentzRotation CLHEP::operator* ( const HepRotationX &  r,
const HepLorentzRotation &  lt 
)
HepLorentzRotation CLHEP::operator* ( const HepRotationY &  r,
const HepLorentzRotation &  lt 
)
HepLorentzRotation CLHEP::operator* ( const HepRotationZ &  r,
const HepLorentzRotation &  lt 
)
double CLHEP::operator* ( const Hep3Vector &  ,
const Hep3Vector &   
)
inline
Hep3Vector CLHEP::operator* ( const Hep3Vector &  ,
double  a 
)
inline
Hep3Vector CLHEP::operator* ( double  a,
const Hep3Vector &   
)
inline
HepLorentzVector CLHEP::operator* ( const HepLorentzVector &  ,
double  a 
)
inline
HepLorentzVector CLHEP::operator* ( double  a,
const HepLorentzVector &   
)
inline
Hep2Vector CLHEP::operator+ ( const Hep2Vector &  a,
const Hep2Vector &  b 
)
inline
Hep3Vector CLHEP::operator+ ( const Hep3Vector &  ,
const Hep3Vector &   
)
inline
Hep2Vector CLHEP::operator- ( const Hep2Vector &  a,
const Hep2Vector &  b 
)
inline
Hep3Vector CLHEP::operator- ( const Hep3Vector &  ,
const Hep3Vector &   
)
inline
Hep2Vector CLHEP::operator/ ( const Hep2Vector &  p,
double  a 
)

Definition at line 61 of file TwoVector.cc.

61  {
62 // if (a==0) {
63 // std::cerr << "Hep2Vector operator/ () - "
64 // << "Division of Hep2Vector by zero" << std::endl;
65 // }
66  return Hep2Vector(p.x()/a, p.y()/a);
67 }
a
std::vector< ExP01TrackerHit * > a
Definition: ExP01Classes.hh:33
p
const char * p
Definition: xmltok.h:285

Here is the call graph for this function:

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

Definition at line 301 of file ThreeVector.cc.

301  {
302 // if (c == 0) {
303 // std::cerr << "Hep3Vector::operator/ () - "
304 // << "Attempt to divide vector by 0 -- "
305 // << "will produce infinities and/or NANs" << std::endl;
306 // }
307  double oneOverC = 1.0/c;
308  return Hep3Vector ( v1.x() * oneOverC,
309  v1.y() * oneOverC,
310  v1.z() * oneOverC );
311 } /* v / c */
test.c
tuple c
Definition: test.py:13

Here is the call graph for this function:

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

Definition at line 165 of file LorentzVector.cc.

165  {
166 // if (c == 0) {
167 // std::cerr << "HepLorentzVector::operator /() - "
168 // << "Attempt to do LorentzVector / 0 -- \n"
169 // << "division by zero would produce infinite or NAN components"
170 // << std::endl;
171 // }
172  double oneOverC = 1.0/c;
173  return HepLorentzVector (w.getV() * oneOverC,
174  w.getT() * oneOverC);
175 } /* LV = w / c */
test.c
tuple c
Definition: test.py:13

Here is the call graph for this function:

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

Definition at line 359 of file LorentzRotation.h.

360  { return lt<r; }
bool CLHEP::operator< ( const HepBoost &  b,
const HepLorentzRotation &  lt 
)
inline

Definition at line 372 of file LorentzRotation.h.

373  { return lt<b; }
test.b
tuple b
Definition: test.py:12
std::ostream & CLHEP::operator<< ( std::ostream &  os,
const HepAxisAngle &  aa 
)

Definition at line 85 of file AxisAngle.cc.

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

Here is the call graph for this function:

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

Definition at line 100 of file EulerAngles.cc.

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

Here is the call graph for this function:

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

Definition at line 69 of file TwoVector.cc.

69  {
70  os << "(" << q.x() << ", " << q.y() << ")";
71  return os;
72 }

Here is the call graph for this function:

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

Definition at line 216 of file Random.cc.

216  {
217  return dist.put(os);
218 }

Here is the call graph for this function:

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

Definition at line 98 of file RandomEngine.cc.

98  {
99  return e.put(os);
100 }

Here is the call graph for this function:

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

Definition at line 215 of file BoostX.h.

215 {return b.print(os);}
test.b
tuple b
Definition: test.py:12
std::ostream& CLHEP::operator<< ( std::ostream &  os,
const HepBoostZ &  b 
)
inline

Definition at line 215 of file BoostZ.h.

215 {return b.print(os);}
test.b
tuple b
Definition: test.py:12
std::ostream& CLHEP::operator<< ( std::ostream &  os,
const HepBoostY &  b 
)
inline

Definition at line 216 of file BoostY.h.

216 {return b.print(os);}
test.b
tuple b
Definition: test.py:12
std::ostream& CLHEP::operator<< ( std::ostream &  os,
const HepBoost &  b 
)
inline

Definition at line 241 of file Boost.h.

241 {return b.print(os);}
test.b
tuple b
Definition: test.py:12
std::ostream& CLHEP::operator<< ( std::ostream &  os,
const HepRotationX &  r 
)
inline

Definition at line 278 of file RotationX.h.

278 {return r.print(os);}
std::ostream& CLHEP::operator<< ( std::ostream &  os,
const HepRotationY &  r 
)
inline

Definition at line 278 of file RotationY.h.

278 {return r.print(os);}
std::ostream& CLHEP::operator<< ( std::ostream &  os,
const HepRotationZ &  r 
)
inline

Definition at line 278 of file RotationZ.h.

278 {return r.print(os);}
std::ostream& CLHEP::operator<< ( std::ostream &  os,
const HepLorentzRotation &  lt 
)
inline

Definition at line 348 of file LorentzRotation.h.

349  {return lt.print(os);}
std::ostream& CLHEP::operator<< ( std::ostream &  os,
const HepRotation &  r 
)
inline

Definition at line 410 of file Rotation.h.

410 {return r.print(os);}
std::ostream & CLHEP::operator<< ( std::ostream &  os,
const Hep3Vector &  v 
)

Definition at line 66 of file ThreeVector.cc.

66  {
67  return os << "(" << v.x() << "," << v.y() << "," << v.z() << ")";
68 }
test.v
tuple v
Definition: test.py:18

Here is the call graph for this function:

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

Definition at line 90 of file LorentzVector.cc.

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

Here is the call graph for this function:

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

Definition at line 355 of file LorentzRotation.h.

356  { return lt<=r; }
bool CLHEP::operator<= ( const HepBoost &  b,
const HepLorentzRotation &  lt 
)
inline

Definition at line 368 of file LorentzRotation.h.

369  { return lt<=b; }
test.b
tuple b
Definition: test.py:12
bool CLHEP::operator== ( const HepRotation &  r,
const HepLorentzRotation &  lt 
)
inline

Definition at line 351 of file LorentzRotation.h.

352  { return lt==r; }
bool CLHEP::operator== ( const HepBoost &  b,
const HepLorentzRotation &  lt 
)
inline

Definition at line 364 of file LorentzRotation.h.

365  { return lt==b; }
test.b
tuple b
Definition: test.py:12
bool CLHEP::operator> ( const HepRotation &  r,
const HepLorentzRotation &  lt 
)
inline

Definition at line 361 of file LorentzRotation.h.

362  { return lt>r; }
bool CLHEP::operator> ( const HepBoost &  b,
const HepLorentzRotation &  lt 
)
inline

Definition at line 374 of file LorentzRotation.h.

375  { return lt>b; }
test.b
tuple b
Definition: test.py:12
bool CLHEP::operator>= ( const HepRotation &  r,
const HepLorentzRotation &  lt 
)
inline

Definition at line 357 of file LorentzRotation.h.

358  { return lt>=r; }
bool CLHEP::operator>= ( const HepBoost &  b,
const HepLorentzRotation &  lt 
)
inline

Definition at line 370 of file LorentzRotation.h.

371  { return lt>=b; }
test.b
tuple b
Definition: test.py:12
std::istream & CLHEP::operator>> ( std::istream &  is,
HepAxisAngle &  aa 
)

Definition at line 95 of file AxisAngle.cc.

95  {
96  Hep3Vector axis;
97  double delta;
98  double x,y,z;
99  ZMinputAxisAngle ( is, x, y, z, delta );
100  axis.set(x,y,z);
101  aa.set ( axis, delta );
102  return is;
103 } // operator>>()
CLHEP::ZMinputAxisAngle
void ZMinputAxisAngle(std::istream &is, double &x, double &y, double &z, double &delta)
Definition: ZMinput.cc:156
test.x
tuple x
Definition: test.py:50
test.z
tuple z
Definition: test.py:28

Here is the call graph for this function:

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

Definition at line 109 of file EulerAngles.cc.

109  {
110  double thePhi;
111  double theTheta;
112  double thePsi;
113  ZMinput3doubles ( is, "HepEulerAngle", thePhi , theTheta , thePsi );
114  ea.set ( thePhi , theTheta , thePsi );
115  return is;
116 } // operator>>()
CLHEP::ZMinput3doubles
void ZMinput3doubles(std::istream &is, const char *type, double &x, double &y, double &z)
Definition: ZMinput.cc:42

Here is the call graph for this function:

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

Definition at line 77 of file TwoVector.cc.

77  {
78  double x, y;
79  ZMinput2doubles ( is, "Hep2Vector", x, y );
80  p.set(x, y);
81  return is;
82 } // operator>>()
p
const char * p
Definition: xmltok.h:285
test.x
tuple x
Definition: test.py:50
CLHEP::ZMinput2doubles
void ZMinput2doubles(std::istream &is, const char *type, double &x, double &y)
Definition: ZMinput.cc:243

Here is the call graph for this function:

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

Definition at line 220 of file Random.cc.

220  {
221  return dist.get(is);
222 }

Here is the call graph for this function:

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

Definition at line 102 of file RandomEngine.cc.

102  {
103  return e.get(is);
104 }

Here is the call graph for this function:

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

Definition at line 73 of file ThreeVector.cc.

73  {
74  double x, y, z;
75  ZMinput3doubles ( is, "Hep3Vector", x, y, z );
76  v.set(x, y, z);
77  return is;
78 } // operator>>()
test.x
tuple x
Definition: test.py:50
test.v
tuple v
Definition: test.py:18
test.z
tuple z
Definition: test.py:28
CLHEP::ZMinput3doubles
void ZMinput3doubles(std::istream &is, const char *type, double &x, double &y, double &z)
Definition: ZMinput.cc:42

Here is the call graph for this function:

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

Definition at line 96 of file LorentzVector.cc.

96  {
97 
98 // Required format is ( a, b, c; d ) that is, four numbers, preceded by
99 // (, followed by ), components of the spatial vector separated by commas,
100 // time component separated by semicolon. The four numbers are taken
101 // as x, y, z, t.
102 
103  double x, y, z, t;
104  char c;
105 
106  is >> std::ws >> c;
107  // ws is defined to invoke eatwhite(istream & )
108  // see (Stroustrup gray book) page 333 and 345.
109  if (is.fail() || c != '(' ) {
110  std::cerr << "Could not find required opening parenthesis "
111  << "in input of a HepLorentzVector" << std::endl;
112  return is;
113  }
114 
115  is >> x >> std::ws >> c;
116  if (is.fail() || c != ',' ) {
117  std::cerr << "Could not find x value and required trailing comma "
118  << "in input of a HepLorentzVector" << std::endl;
119  return is;
120  }
121 
122  is >> y >> std::ws >> c;
123  if (is.fail() || c != ',' ) {
124  std::cerr << "Could not find y value and required trailing comma "
125  << "in input of a HepLorentzVector" << std::endl;
126  return is;
127  }
128 
129  is >> z >> std::ws >> c;
130  if (is.fail() || c != ';' ) {
131  std::cerr << "Could not find z value and required trailing semicolon "
132  << "in input of a HepLorentzVector" << std::endl;
133  return is;
134  }
135 
136  is >> t >> std::ws >> c;
137  if (is.fail() || c != ')' ) {
138  std::cerr << "Could not find t value and required close parenthesis "
139  << "in input of a HepLorentzVector" << std::endl;
140  return is;
141  }
142 
143  v1.setX(x);
144  v1.setY(y);
145  v1.setZ(z);
146  v1.setT(t);
147  return is;
148 }
test.x
tuple x
Definition: test.py:50
test.z
tuple z
Definition: test.py:28
test.c
tuple c
Definition: test.py:13

Here is the call graph for this function:

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

Definition at line 167 of file RandomEngine.h.

167  {
168  std::string firstWord;
169  is >> firstWord;
170  if (firstWord == key) return true;
171  std::istringstream reread(firstWord);
172  reread >> t;
173  return false;
174 }

Here is the caller graph for this function:

myuint CLHEP::precalc ( rng_state_t *  X)

Definition at line 225 of file mixmax.cc.

225  {
226  int i;
227  myuint temp;
228  temp = 0;
229  for (i=0; i < N; i++){
230  temp = MOD_MERSENNE(temp + X->V[i]);
231  }
232  X->sumtot = temp;
233  return temp;
234 }
CLHEP::myuint
uint64_t myuint
Definition: mixmax.h:50
MOD_MERSENNE
#define MOD_MERSENNE(k)
Definition: mixmax.h:128
N
**D E S C R I P T I O N
Definition: HEPEvtcom.cc:77

Here is the caller graph for this function:

void CLHEP::print_state ( rng_state_t *  X)

Definition at line 270 of file mixmax.cc.

270  {
271  int j;
272  fprintf(X->fh, "mixmax state, file version 1.0\n" );
273  fprintf(X->fh, "N=%u; V[N]={", rng_get_N() );
274  for (j=0; (j< (rng_get_N()-1) ); j++) {
275  fprintf(X->fh, "%llu, ", X->V[j] );
276  }
277  fprintf(X->fh, "%llu", X->V[rng_get_N()-1] );
278  fprintf(X->fh, "}; " );
279  fprintf(X->fh, "counter=%u; ", X->counter );
280  fprintf(X->fh, "sumtot=%llu;\n", X->sumtot );
281 }
CLHEP::rng_get_N
int rng_get_N(void)
Definition: mixmax.cc:237

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 283 of file mixmax.cc.

283  {
284  // a function for reading the state from a file, after J. Apostolakis
285  FILE* fin;
286  if( ( fin = fopen(filename, "r") ) ){
287  char l=0;
288  while ( l != '{' ) { // 0x7B = "{"
289  l=fgetc(fin); // proceed until hitting opening bracket
290  }
291  ungetc(' ', fin);
292  }else{
293  fprintf(stderr, "mixmax -> read_state: error reading file %s\n", filename);
294  exit(ERROR_READING_STATE_FILE);
295  }
296 
297  myuint vecVal;
298  //printf("mixmax -> read_state: starting to read state from file\n");
299  if (!fscanf(fin, "%llu", &X->V[0]) ) {fprintf(stderr, "mixmax -> read_state: error reading file %s\n", filename); exit(ERROR_READING_STATE_FILE);}
300  //printf("V[%d] = %llu\n",0, X->V[0]);
301  int i;
302  for( i = 1; i < rng_get_N(); i++){
303  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);}
304  //printf("V[%d] = %llu\n",i, vecVal);
305  if( vecVal <= MERSBASE ){
306  X->V[i] = vecVal;
307  }else{
308  fprintf(stderr, "mixmax -> read_state: Invalid state vector value= %llu"
309  " ( must be less than %llu ) "
310  " obtained from reading file %s\n"
311  , vecVal, MERSBASE, filename);
312 
313  }
314  }
315 
316  unsigned int counter;
317  if (!fscanf( fin, "}; counter=%u; ", &counter)){fprintf(stderr, "mixmax -> read_state: error reading counter from file %s\n", filename); exit(ERROR_READING_STATE_FILE);}
318  if( counter <= N ) {
319  X->counter= counter;
320  }else{
321  fprintf(stderr, "mixmax -> read_state: Invalid counter = %d"
322  " Must be 0 <= counter < %u\n" , counter, N);
323  print_state(X);
324  exit(ERROR_READING_STATE_COUNTER);
325  }
326  precalc(X);
327  myuint sumtot;
328  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);}
329 
330  if (X->sumtot != sumtot) {
331  fprintf(stderr, "mixmax -> checksum error while reading state from file %s - corrupted?\n", filename);
332  exit(ERROR_READING_STATE_CHECKSUM);
333  }
334 // else{fprintf(stderr, "mixmax -> read_state: checksum ok: %llu == %llu\n",X->sumtot, sumtot);}
335  fclose(fin);
336 }
CLHEP::print_state
void print_state(rng_state_t *X)
Definition: mixmax.cc:270
CLHEP::rng_get_N
int rng_get_N(void)
Definition: mixmax.cc:237
ERROR_READING_STATE_FILE
#define ERROR_READING_STATE_FILE
Definition: mixmax.h:210
CLHEP::myuint
uint64_t myuint
Definition: mixmax.h:50
MERSBASE
#define MERSBASE
Definition: mixmax.h:125
ERROR_READING_STATE_CHECKSUM
#define ERROR_READING_STATE_CHECKSUM
Definition: mixmax.h:212
CLHEP::precalc
myuint precalc(rng_state_t *X)
Definition: mixmax.cc:225
N
**D E S C R I P T I O N
Definition: HEPEvtcom.cc:77
ERROR_READING_STATE_COUNTER
#define ERROR_READING_STATE_COUNTER
Definition: mixmax.h:211

Here is the call graph for this function:

Here is the caller graph for this function:

rng_state_t * CLHEP::rng_alloc ( )

Definition at line 151 of file mixmax.cc.

152 {
153 /* allocate the state */
154  rng_state_t *p = (rng_state_t*)malloc(sizeof(rng_state_t));
155  p->fh=NULL; // by default, set the output file handle to stdout
156  return p;
157 }
p
const char * p
Definition: xmltok.h:285
CLHEP::rng_state_st::fh
FILE * fh
Definition: mixmax.h:62
CLHEP::rng_state_t
struct rng_state_st rng_state_t
Definition: mixmax.h:65

Here is the caller graph for this function:

rng_state_t * CLHEP::rng_copy ( myuint *  Y)

Definition at line 165 of file mixmax.cc.

166 {
167  /* copy the vector stored at Y, and return pointer to the newly allocated and initialized state.
168  It is the user's responsibility to make sure that Y is properly allocated with rng_alloc,
169  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]
170  Partial sums on this new state are recalculated, and counter set to zero, so that when get_next is called,
171  it will output the initial vector before any new numbers are produced, call iterate(X) if you want to advance right away */
172  rng_state_t* X = rng_alloc();
173  myuint sumtot=0,ovflow=0;
174  X->counter = 2;
175  int i;
176  for ( i=0; i < N; i++){
177  X->V[i] = Y[i];
178  sumtot += X->V[(i)]; if (sumtot < X->V[(i)]) {ovflow++;}
179 
180  }
181  X->sumtot = MOD_MERSENNE(MOD_MERSENNE(sumtot) + (ovflow <<3 ));
182  return X;
183 }
Y
double Y(double density)
Definition: G4DNAElectronHoleRecombination.cc:55
CLHEP::myuint
uint64_t myuint
Definition: mixmax.h:50
MOD_MERSENNE
#define MOD_MERSENNE(k)
Definition: mixmax.h:128
CLHEP::rng_alloc
rng_state_t * rng_alloc()
Definition: mixmax.cc:151
N
**D E S C R I P T I O N
Definition: HEPEvtcom.cc:77
CLHEP::rng_state_t
struct rng_state_st rng_state_t
Definition: mixmax.h:65

Here is the call graph for this function:

Here is the caller graph for this function:

int CLHEP::rng_free ( rng_state_t *  X)

Definition at line 159 of file mixmax.cc.

160 {
161  free(X);
162  return 0;
163 }
ForceCollisionState::free

Here is the caller graph for this function:

int CLHEP::rng_get_N ( void  )

Definition at line 237 of file mixmax.cc.

237 {return N;}
N
**D E S C R I P T I O N
Definition: HEPEvtcom.cc:77

Here is the caller graph for this function:

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

Definition at line 47 of file LorentzVectorR.cc.

49  {
50  HepLorentzVector vv (vec);
51  return vv.rotate (aaxis, ddelta);
52 }

Here is the call graph for this function:

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

Definition at line 55 of file LorentzVectorR.cc.

55  {
56  HepLorentzVector vv (vec);
57  return vv.rotate (ax);
58 }

Here is the call graph for this function:

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

Definition at line 61 of file LorentzVectorR.cc.

61  {
62  HepLorentzVector vv (vec);
63  return vv.rotate (e1);
64 }

Here is the call graph for this function:

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

Definition at line 66 of file LorentzVectorR.cc.

69  {
70  HepLorentzVector vv (vec);
71  return vv.rotate (phi1, theta1, psi1);
72 }

Here is the call graph for this function:

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

Definition at line 132 of file SpaceVectorR.cc.

133  {
134  Hep3Vector vv(vec);
135  return vv.rotate(axis, ddelta);
136 }

Here is the call graph for this function:

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

Definition at line 127 of file SpaceVectorR.cc.

127  {
128  Hep3Vector vv(vec);
129  return vv.rotate (ax);
130 }

Here is the call graph for this function:

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

Definition at line 143 of file SpaceVectorR.cc.

144  {
145  Hep3Vector vv(vec);
146  return vv.rotate(phi, theta, psi);
147 }

Here is the call graph for this function:

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

Definition at line 138 of file SpaceVectorR.cc.

138  {
139  Hep3Vector vv(vec);
140  return vv.rotate (ex);
141 }

Here is the call graph for this function:

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

Definition at line 28 of file LorentzVectorB.cc.

28  {
29  HepLorentzVector vv (vec);
30  return vv.rotateX (phi);
31 }

Here is the call graph for this function:

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

Definition at line 149 of file SpaceVectorR.cc.

149  {
150  Hep3Vector vv(vec);
151  return vv.rotateX (ddelta);
152 }

Here is the call graph for this function:

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

Definition at line 34 of file LorentzVectorB.cc.

34  {
35  HepLorentzVector vv (vec);
36  return vv.rotateY (phi);
37 }

Here is the call graph for this function:

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

Definition at line 154 of file SpaceVectorR.cc.

154  {
155  Hep3Vector vv(vec);
156  return vv.rotateY (ddelta);
157 }

Here is the call graph for this function:

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

Definition at line 40 of file LorentzVectorB.cc.

40  {
41  HepLorentzVector vv (vec);
42  return vv.rotateZ (phi);
43 }

Here is the call graph for this function:

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

Definition at line 159 of file SpaceVectorR.cc.

159  {
160  Hep3Vector vv(vec);
161  return vv.rotateZ (ddelta);
162 }

Here is the call graph for this function:

static double CLHEP::safe_acos ( double  x)
inlinestatic

Definition at line 23 of file Rotation.cc.

23  {
24  if (std::abs(x) <= 1.0) return std::acos(x);
25  return ( (x>0) ? 0 : CLHEP::pi );
26 }
test.x
tuple x
Definition: test.py:50
CLHEP::pi
static constexpr double pi
Definition: SystemOfUnits.h:54

Here is the caller graph for this function:

static double CLHEP::safe_acos ( double  x)
inlinestatic

Definition at line 26 of file RotationE.cc.

26  {
27  if (std::abs(x) <= 1.0) return std::acos(x);
28  return ( (x>0) ? 0 : CLHEP::pi );
29 }
test.x
tuple x
Definition: test.py:50
CLHEP::pi
static constexpr double pi
Definition: SystemOfUnits.h:54
static double CLHEP::safe_acos ( double  x)
inlinestatic

Definition at line 26 of file RotationZ.cc.

26  {
27  if (std::abs(x) <= 1.0) return std::acos(x);
28  return ( (x>0) ? 0 : CLHEP::pi );
29 }
test.x
tuple x
Definition: test.py:50
CLHEP::pi
static constexpr double pi
Definition: SystemOfUnits.h:54
static double CLHEP::safe_acos ( double  x)
inlinestatic

Definition at line 26 of file RotationX.cc.

26  {
27  if (std::abs(x) <= 1.0) return std::acos(x);
28  return ( (x>0) ? 0 : CLHEP::pi );
29 }
test.x
tuple x
Definition: test.py:50
CLHEP::pi
static constexpr double pi
Definition: SystemOfUnits.h:54
static double CLHEP::safe_acos ( double  x)
inlinestatic

Definition at line 26 of file RotationY.cc.

26  {
27  if (std::abs(x) <= 1.0) return std::acos(x);
28  return ( (x>0) ? 0 : CLHEP::pi );
29 }
test.x
tuple x
Definition: test.py:50
CLHEP::pi
static constexpr double pi
Definition: SystemOfUnits.h:54
void CLHEP::seed_spbox ( rng_state_t *  X,
myuint  seed 
)

Definition at line 202 of file mixmax.cc.

203 { // a 64-bit LCG from Knuth line 26, in combination with a bit swap is used to seed
204  const myuint MULT64=6364136223846793005ULL;
205  int i;
206  myuint sumtot=0,ovflow=0;
207  if (seed == 0){
208  fprintf(stderr, " try seeding with nonzero seed next time!\n");
209  exit(SEED_WAS_ZERO);
210  }
211 
212  myuint l = seed;
213 
214  //X->V[0] = l & MERSBASE;
215  if (X->fh==NULL){X->fh=stdout;} // if the filehandle is not yet set, make it stdout
216  for (i=0; i < N; i++){
217  l*=MULT64; l = (l << 32) ^ (l>>32);
218  X->V[i] = l & MERSBASE;
219  sumtot += X->V[(i)]; if (sumtot < X->V[(i)]) {ovflow++;}
220  }
221  X->counter = N; // set the counter to N if iteration should happen right away
222  X->sumtot = MOD_MERSENNE(MOD_MERSENNE(sumtot) + (ovflow <<3 ));
223 }
CLHEP::myuint
uint64_t myuint
Definition: mixmax.h:50
SEED_WAS_ZERO
#define SEED_WAS_ZERO
Definition: mixmax.h:209
MOD_MERSENNE
#define MOD_MERSENNE(k)
Definition: mixmax.h:128
seed
long seed
Definition: chem4.cc:68
MERSBASE
#define MERSBASE
Definition: mixmax.h:125
N
**D E S C R I P T I O N
Definition: HEPEvtcom.cc:77

Here is the caller graph for this function:

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

Definition at line 435 of file mixmax.cc.

435  {
436  Xin->V[0] = (myuint)clusterID;
437  Xin->V[1] = (myuint)machineID;
438  Xin->V[2] = (myuint)runID;
439  Xin->V[3] = (myuint)streamID;
440  Xin->V[4] = (myuint)clusterID << 5;
441  Xin->V[5] = (myuint)machineID << 7;
442  Xin->V[6] = (myuint)runID << 11;
443  Xin->V[7] = (myuint)streamID << 13;
444  precalc(Xin);
445  Xin->sumtot = iterate_raw_vec(Xin->V, Xin->sumtot);
446  Xin->sumtot = iterate_raw_vec(Xin->V, Xin->sumtot);
447 }
CLHEP::myuint
uint64_t myuint
Definition: mixmax.h:50
CLHEP::iterate_raw_vec
myuint iterate_raw_vec(myuint *Y, myuint sumtotOld)
Definition: mixmax.cc:52
CLHEP::precalc
myuint precalc(rng_state_t *X)
Definition: mixmax.cc:225

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 185 of file mixmax.cc.

186 {
187 int i;
188  if (index<N){
189  for (i=0; i < N; i++){
190  X->V[i] = 0;
191  }
192  X->V[index] = 1;
193  }else{
194  fprintf(stderr, "Out of bounds index, is not ( 0 <= index < N )\n"); exit(ARRAY_INDEX_OUT_OF_BOUNDS);
195  }
196  X->counter = N; // set the counter to N if iteration should happen right away
197  //precalc(X);
198  X->sumtot = 1; //(index ? 1:0);
199  if (X->fh==NULL){X->fh=stdout;}
200 }
ARRAY_INDEX_OUT_OF_BOUNDS
#define ARRAY_INDEX_OUT_OF_BOUNDS
Definition: mixmax.h:208
N
**D E S C R I P T I O N
Definition: HEPEvtcom.cc:77
static double CLHEP::StirlingCorrection ( long int  k)
static

Definition at line 93 of file RandBinomial.cc.

94 {
95  #define C1 8.33333333333333333e-02 // +1/12
96  #define C3 -2.77777777777777778e-03 // -1/360
97  #define C5 7.93650793650793651e-04 // +1/1260
98  #define C7 -5.95238095238095238e-04 // -1/1680
99 
100  static const double c[31] = { 0.0,
101  8.106146679532726e-02, 4.134069595540929e-02,
102  2.767792568499834e-02, 2.079067210376509e-02,
103  1.664469118982119e-02, 1.387612882307075e-02,
104  1.189670994589177e-02, 1.041126526197209e-02,
105  9.255462182712733e-03, 8.330563433362871e-03,
106  7.573675487951841e-03, 6.942840107209530e-03,
107  6.408994188004207e-03, 5.951370112758848e-03,
108  5.554733551962801e-03, 5.207655919609640e-03,
109  4.901395948434738e-03, 4.629153749334029e-03,
110  4.385560249232324e-03, 4.166319691996922e-03,
111  3.967954218640860e-03, 3.787618068444430e-03,
112  3.622960224683090e-03, 3.472021382978770e-03,
113  3.333155636728090e-03, 3.204970228055040e-03,
114  3.086278682608780e-03, 2.976063983550410e-03,
115  2.873449362352470e-03, 2.777674929752690e-03,
116  };
117  double r, rr;
118 
119  if (k > 30L) {
120  r = 1.0 / (double) k; rr = r * r;
121  return(r*(C1 + rr*(C3 + rr*(C5 + rr*C7))));
122  }
123  else return(c[k]);
124 }
C3
#define C3
C7
#define C7
C1
#define C1
test.c
tuple c
Definition: test.py:13
L
static constexpr double L
Definition: G4SIunits.hh:124
C5
#define C5
double CLHEP::transformSmall ( double  r)

Definition at line 219 of file flatToGaussian.cc.

219  {
220 
221  // Solve for -v in the asymtotic formula
222  //
223  // errInt (-v) = exp(-v*v/2) 1 1*3 1*3*5
224  // ------------ * (1 - ---- + ---- - ----- + ... )
225  // v*sqrt(2*pi) v**2 v**4 v**6
226 
227  // The value of r (=errInt(-v)) supplied is going to less than 2.0E-13,
228  // which is such that v < -7.25. Since the value of r is meaningful only
229  // to an absolute error of 1E-16 (double precision accuracy for a number
230  // which on the high side could be of the form 1-epsilon), computing
231  // v to more than 3-4 digits of accuracy is suspect; however, to ensure
232  // smoothness with the table generator (which uses quite a few terms) we
233  // also use terms up to 1*3*5* ... *13/v**14, and insist on accuracy of
234  // solution at the level of 1.0e-7.
235 
236  // This routine is called less than one time in a trillion firings, so
237  // speed is of no concern. As a matter of technique, we terminate the
238  // iterations in case they would be infinite, but this should not happen.
239 
240  double eps = 1.0e-7;
241  double guess = 7.5;
242  double v;
243 
244  for ( int i = 1; i < 50; i++ ) {
245  double vn2 = 1.0/(guess*guess);
246  double s1 = -13*11*9*7*5*3 * vn2*vn2*vn2*vn2*vn2*vn2*vn2;
247  s1 += 11*9*7*5*3 * vn2*vn2*vn2*vn2*vn2*vn2;
248  s1 += -9*7*5*3 * vn2*vn2*vn2*vn2*vn2;
249  s1 += 7*5*3 * vn2*vn2*vn2*vn2;
250  s1 += -5*3 * vn2*vn2*vn2;
251  s1 += 3 * vn2*vn2 - vn2 + 1.0;
252  v = std::sqrt ( 2.0 * std::log ( s1 / (r*guess*std::sqrt(CLHEP::twopi)) ) );
253  if ( std::abs(v-guess) < eps ) break;
254  guess = v;
255  }
256 
257  return -v;
258 
259 } // transformSmall()
eps
static const G4double eps
Definition: G4ElectroNuclearCrossSection.cc:99
test.v
tuple v
Definition: test.py:18
CLHEP::twopi
static constexpr double twopi
Definition: SystemOfUnits.h:55

Here is the caller graph for this function:

static const Hep2Vector CLHEP::X_HAT2 ( 1.  0,
0.  0 
)
static
static const Hep2Vector CLHEP::Y_HAT2 ( 0.  0,
1.  0 
)
static
void CLHEP::ZMinput2doubles ( std::istream &  is,
const char *  type,
double &  x,
double &  y 
)

Definition at line 243 of file ZMinput.cc.

244  {
245 
246 // Accepted formats are
247 // x y
248 // x, y (comma is optional, and whitespace ignored if comma present)
249 // ( x, y ) (comma optional)
250 
251  char c;
252  bool parenthesis = false;
253 
254  if ( !eatwhitespace(is) ) {
255  std::cerr << "istream ended before trying to input " << type << "\n";
256  return;
257  }
258 
259  if ( !is.get(c) ) { fouledup(); return; }
260  if ( c == '(' ) {
261  parenthesis = true;
262  if ( !eatwhitespace(is) ) {
263  std::cerr << "istream ended after ( trying to input " << type << "\n";
264  return;
265  }
266  } else {
267  is.putback(c);
268  }
269 
270  // At this point, parenthesis or not, the next item read is supposed to
271  // be the number x.
272 
273  if (!(is >> x)) {
274  std::cerr << "Could not read first value in input of " << type << "\n";
275  return;
276  }
277 
278  if ( !eatwhitespace(is) ) {
279  std::cerr << "istream ended before second value of " << type << "\n";
280  return;
281  }
282 
283  if ( !is.get(c) ) { fouledup(); return; }
284  if ( c == ',' ) {
285  if ( !eatwhitespace(is) ) {
286  std::cerr << "istream ended ater one value and comma in "
287  << type << "\n";
288  return;
289  }
290  } else {
291  is.putback(c);
292  }
293 
294  // At this point, comma or not, the next item read is supposed to
295  // be the number y.
296 
297  if (!(is >> y)) {
298  std::cerr << "Could not read second value in input of " << type << "\n";
299  return;
300  }
301 
302  // Finally, check for the closing parenthesis if there was an open paren.
303 
304  if (parenthesis) {
305  if ( !eatwhitespace(is) ) {
306  std::cerr << "No closing parenthesis in input of " << type << "\n";
307  return;
308  }
309  if ( !is.get(c) ) { fouledup(); return; }
310  if ( c != ')' ) {
311  std::cerr << "Missing closing parenthesis in input of "
312  << type << "\n";
313  // Now a trick to do (as nearly as we can) what
314  // is.putback(c); is.setstate(std::ios_base::failbit);
315  // would do (because using ios_base will confuse old CLHEP compilers):
316  if ( isdigit(c) || (c=='-') || (c=='+') ) {
317  is.putback('@');
318  } else {
319  is.putback('c');
320  }
321  int m;
322  is >> m; // This fails, leaving the state bad, and the istream
323  // otherwise unchanged, except if the next char might
324  // have started a valid int, it turns to @
325  return;
326  }
327  }
328 
329  return;
330 
331 }
test.x
tuple x
Definition: test.py:50
m
static constexpr double m
Definition: G4SIunits.hh:129
test.c
tuple c
Definition: test.py:13

Here is the caller graph for this function:

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

Definition at line 42 of file ZMinput.cc.

43  {
44 
45 // Accepted formats are
46 // x y z
47 // x, y, z (each comma is optional, and whitespace ignored if comma present)
48 // ( x, y, z ) (commas optional)
49 
50  char c;
51  bool parenthesis = false;
52 
53  if ( !eatwhitespace(is) ) {
54  std::cerr << "istream ended before trying to input " << type << "\n";
55  return;
56  }
57 
58  if ( !is.get(c) ) { fouledup(); return; }
59  if ( c == '(' ) {
60  parenthesis = true;
61  if ( !eatwhitespace(is) ) {
62  std::cerr << "istream ended after ( trying to input " << type << "\n";
63  return;
64  }
65  } else {
66  is.putback(c);
67  }
68 
69  // At this point, parenthesis or not, the next item read is supposed to
70  // be the number x.
71 
72  if (!(is >> x)) {
73  std::cerr << "Could not read first value in input of " << type << "\n";
74  return;
75  }
76 
77  if ( !eatwhitespace(is) ) {
78  std::cerr << "istream ended before second value of " << type << "\n";
79  return;
80  }
81 
82  if ( !is.get(c) ) { fouledup(); return; }
83  if ( c == ',' ) {
84  if ( !eatwhitespace(is) ) {
85  std::cerr << "istream ended ater one value and comma in "
86  << type << "\n";
87  return;
88  }
89  } else {
90  is.putback(c);
91  }
92 
93  // At this point, comma or not, the next item read is supposed to
94  // be the number y.
95 
96  if (!(is >> y)) {
97  std::cerr << "Could not read second value in input of " << type << "\n";
98  return;
99  }
100 
101  if ( !eatwhitespace(is) ) {
102  std::cerr << "istream ended before third value of " << type << "\n";
103  return;
104  }
105 
106  if ( !is.get(c) ) { fouledup(); return; }
107  if ( c == ',' ) {
108  if ( !eatwhitespace(is) ) {
109  std::cerr << "istream ended ater two values and comma in "
110  << type << "\n";
111  return;
112  }
113  } else {
114  is.putback(c);
115  }
116 
117  // At this point, comma or not, the next item read is supposed to
118  // be the number z.
119 
120  if (!(is >> z)) {
121  std::cerr << "Could not read third value in input of " << type << "\n";
122  return;
123  }
124 
125  // Finally, check for the closing parenthesis if there was an open paren.
126 
127  if (parenthesis) {
128  if ( !eatwhitespace(is) ) {
129  std::cerr << "No closing parenthesis in input of " << type << "\n";
130  return;
131  }
132  if ( !is.get(c) ) { fouledup(); return; }
133  if ( c != ')' ) {
134  std::cerr << "Missing closing parenthesis in input of "
135  << type << "\n";
136  // Now a trick to do (as nearly as we can) what
137  // is.putback(c); is.setstate(std::ios_base::failbit);
138  // would do (because using ios_base will confuse old CLHEP compilers):
139  if ( isdigit(c) || (c=='-') || (c=='+') ) {
140  is.putback('@');
141  } else {
142  is.putback('c');
143  }
144  int m;
145  is >> m; // This fails, leaving the state bad, and the istream
146  // otherwise unchanged, except if the next char might
147  // have started a valid int, it turns to @
148  return;
149  }
150  }
151 
152  return;
153 
154 }
test.x
tuple x
Definition: test.py:50
m
static constexpr double m
Definition: G4SIunits.hh:129
test.z
tuple z
Definition: test.py:28
test.c
tuple c
Definition: test.py:13

Here is the caller graph for this function:

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

Definition at line 156 of file ZMinput.cc.

158  {
159 // Accepted formats are
160 // parenthesis optional, then
161 // any acceptable format for a Hep3Vector, then
162 // optional comma, then
163 // delta, then
164 // close parenthesis if opened at start.
165 //
166 // But if there is an open parenthesis, it must be for the overall
167 // object. That is, if the axis has parentheses, the form must be
168 // ( (x,y,z) , delta )
169 
170  char c;
171  bool parenthesis = false;
172 
173  if ( !eatwhitespace(is) ) {
174  std::cerr << "istream ended before trying to input AxisAngle \n";
175  return;
176  }
177 
178  if ( !is.get(c) ) { fouledup(); return; }
179  if ( c == '(' ) {
180  parenthesis = true;
181  if ( !eatwhitespace(is) ) {
182  std::cerr << "istream ended after ( trying to input AxisAngle \n";
183  return;
184  }
185  } else {
186  is.putback(c);
187  }
188 
189  // At this point, parenthesis or not, the next item read is supposed to
190  // be a valid Hep3Vector axis.
191 
192  ZMinput3doubles ( is, "axis of AxisAngle", x, y, z );
193  if (!is) return;
194 
195  if ( !eatwhitespace(is) ) {
196  std::cerr << "istream ended before delta of AxisAngle \n";
197  return;
198  }
199 
200  if ( !is.get(c) ) { fouledup(); return; }
201  if ( c == ',' ) {
202  if ( !eatwhitespace(is) ) {
203  std::cerr << "istream ended ater axis and comma in AxisAngle \n";
204  return;
205  }
206  } else {
207  is.putback(c);
208  }
209 
210  // At this point, comma or not, the next item read is supposed to
211  // be the number delta.
212 
213  if (!(is >> delta)) {
214  std::cerr << "Could not delta value in input of AxisAngle \n";
215  return;
216  }
217 
218  // Finally, check for the closing parenthesis if there was an open paren.
219 
220  if (parenthesis) {
221  if ( !eatwhitespace(is) ) {
222  std::cerr << "No closing parenthesis in input of AxisAngle \n";
223  return;
224  }
225  if ( !is.get(c) ) { fouledup(); return; }
226  if ( c != ')' ) {
227  std::cerr << "Missing closing parenthesis in input of AxisAngle \n";
228  if ( isdigit(c) || (c=='-') || (c=='+') ) {
229  is.putback('@');
230  } else {
231  is.putback('c');
232  }
233  int m;
234  is >> m; // This fails, leaving the state bad.
235  return;
236  }
237  }
238 
239  return;
240 
241 }
test.x
tuple x
Definition: test.py:50
m
static constexpr double m
Definition: G4SIunits.hh:129
test.z
tuple z
Definition: test.py:28
test.c
tuple c
Definition: test.py:13
CLHEP::ZMinput3doubles
void ZMinput3doubles(std::istream &is, const char *type, double &x, double &y, double &z)
Definition: ZMinput.cc:42

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 20 of file AxisAngle.cc.

20  {
21 
22  double sinDelta = std::sin( aa.delta() );
23  double cosDelta = std::cos( aa.delta() );
24  double oneMinusCosDelta = 1.0 - cosDelta;
25 
26  double uX = aa.getAxis().getX();
27  double uY = aa.getAxis().getY();
28  double uZ = aa.getAxis().getZ();
29 
30  array[0] = oneMinusCosDelta * uX * uX + cosDelta;
31  array[1] = oneMinusCosDelta * uX * uY - sinDelta * uZ;
32  array[2] = oneMinusCosDelta * uX * uZ + sinDelta * uY;
33 
34  array[3] = oneMinusCosDelta * uY * uX + sinDelta * uZ;
35  array[4] = oneMinusCosDelta * uY * uY + cosDelta;
36  array[5] = oneMinusCosDelta * uY * uZ - sinDelta * uX;
37 
38  array[6] = oneMinusCosDelta * uZ * uX - sinDelta * uY;
39  array[7] = oneMinusCosDelta * uZ * uY + sinDelta * uX;
40  array[8] = oneMinusCosDelta * uZ * uZ + cosDelta;
41 
42 } // ZMpvAxisAngleRep

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 43 of file EulerAngles.cc.

43  {
44 
45  double sinPhi = std::sin( ex.phi() ) , cosPhi = std::cos( ex.phi() );
46  double sinTheta = std::sin( ex.theta() ), cosTheta = std::cos( ex.theta() );
47  double sinPsi = std::sin( ex.psi() ) , cosPsi = std::cos( ex.psi() );
48 
49  array[0] = cosPsi * cosPhi - sinPsi * cosTheta * sinPhi;
50  array[1] = cosPsi * sinPhi + sinPsi * cosTheta * cosPhi;
51  array[2] = sinPsi * sinTheta;
52 
53  array[3] = - sinPsi * cosPhi - cosPsi * cosTheta * sinPhi;
54  array[4] = - sinPsi * sinPhi + cosPsi * cosTheta * cosPhi;
55  array[5] = cosPsi * sinTheta;
56 
57  array[6] = sinTheta * sinPhi;
58  array[7] = - sinTheta * cosPhi;
59  array[8] = cosTheta;
60 
61 } // ZMpvEulerAnglesRep

Here is the call graph for this function:

Here is the caller graph for this function:

Variable Documentation

constexpr double CLHEP::alpha_rcl2
static
Initial value:
= fine_structure_const
*classic_electr_radius
*classic_electr_radius

Definition at line 101 of file PhysicalConstants.h.

constexpr double CLHEP::ampere = coulomb/second
static

Definition at line 214 of file SystemOfUnits.h.

constexpr double CLHEP::amu = amu_c2/c_squared
static

Definition at line 83 of file PhysicalConstants.h.

constexpr double CLHEP::amu_c2 = 931.494028 * MeV
static

Definition at line 82 of file PhysicalConstants.h.

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

Definition at line 82 of file SystemOfUnits.h.

constexpr double CLHEP::atmosphere = 101325*pascal
static

Definition at line 209 of file SystemOfUnits.h.

constexpr double CLHEP::Avogadro = 6.02214179e+23/mole
static

Definition at line 49 of file PhysicalConstants.h.

constexpr double CLHEP::bar = 100000*pascal
static

Definition at line 208 of file SystemOfUnits.h.

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

Definition at line 85 of file SystemOfUnits.h.

constexpr double CLHEP::becquerel = 1./second
static

Definition at line 271 of file SystemOfUnits.h.

constexpr double CLHEP::Bohr_radius = electron_Compton_length/fine_structure_const
static

Definition at line 99 of file PhysicalConstants.h.

constexpr double CLHEP::Bq = becquerel
static

Definition at line 278 of file SystemOfUnits.h.

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

Definition at line 55 of file PhysicalConstants.h.

constexpr double CLHEP::c_squared = c_light * c_light
static

Definition at line 56 of file PhysicalConstants.h.

constexpr double CLHEP::candela = 1.
static

Definition at line 297 of file SystemOfUnits.h.

constexpr double CLHEP::centimeter = 10.*millimeter
static

Definition at line 66 of file SystemOfUnits.h.

constexpr double CLHEP::centimeter2 = centimeter*centimeter
static

Definition at line 67 of file SystemOfUnits.h.

constexpr double CLHEP::centimeter3 = centimeter*centimeter*centimeter
static

Definition at line 68 of file SystemOfUnits.h.

constexpr double CLHEP::Ci = curie
static

Definition at line 282 of file SystemOfUnits.h.

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

Definition at line 106 of file SystemOfUnits.h.

constexpr double CLHEP::classic_electr_radius = elm_coupling/electron_mass_c2
static

Definition at line 97 of file PhysicalConstants.h.

constexpr double CLHEP::cm = centimeter
static

Definition at line 99 of file SystemOfUnits.h.

constexpr double CLHEP::cm2 = centimeter2
static

Definition at line 100 of file SystemOfUnits.h.

constexpr double CLHEP::cm3 = centimeter3
static

Definition at line 101 of file SystemOfUnits.h.

constexpr double CLHEP::coulomb = eplus/e_SI
static

Definition at line 159 of file SystemOfUnits.h.

constexpr double CLHEP::curie = 3.7e+10 * becquerel
static

Definition at line 272 of file SystemOfUnits.h.

constexpr double CLHEP::deg = degree
static

Definition at line 132 of file SystemOfUnits.h.

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

Definition at line 124 of file SystemOfUnits.h.

constexpr double CLHEP::dL = 1.e-1*liter
static

Definition at line 105 of file SystemOfUnits.h.

constexpr double CLHEP::e_SI = 1.602176487e-19
static

Definition at line 158 of file SystemOfUnits.h.

constexpr double CLHEP::e_squared = eplus * eplus
static

Definition at line 72 of file PhysicalConstants.h.

constexpr double CLHEP::electron_charge = - eplus
static

Definition at line 71 of file PhysicalConstants.h.

constexpr double CLHEP::electron_Compton_length = hbarc/electron_mass_c2
static

Definition at line 98 of file PhysicalConstants.h.

constexpr double CLHEP::electron_mass_c2 = 0.510998910 * MeV
static

Definition at line 79 of file PhysicalConstants.h.

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

Definition at line 165 of file SystemOfUnits.h.

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

Definition at line 95 of file PhysicalConstants.h.

constexpr double CLHEP::eplus = 1.
static

Definition at line 157 of file SystemOfUnits.h.

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

Definition at line 90 of file PhysicalConstants.h.

constexpr double CLHEP::eV = electronvolt
static

Definition at line 175 of file SystemOfUnits.h.

constexpr double CLHEP::farad = coulomb/volt
static

Definition at line 234 of file SystemOfUnits.h.

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

Definition at line 83 of file SystemOfUnits.h.

constexpr double CLHEP::fine_structure_const = elm_coupling/hbarc
static

Definition at line 96 of file PhysicalConstants.h.

constexpr double CLHEP::g = gram
static

Definition at line 190 of file SystemOfUnits.h.

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

Definition at line 250 of file SystemOfUnits.h.

const double CLHEP::gaussTables[2 *TableSize]
static
Initial value:
= {
}

Definition at line 85 of file flatToGaussian.cc.

const float CLHEP::gaussTables[TableSize]
static
Initial value:
= {
}

Definition at line 88 of file RandGaussQ.cc.

constexpr double CLHEP::GBq = gigabecquerel
static

Definition at line 281 of file SystemOfUnits.h.

constexpr double CLHEP::GeV = gigaelectronvolt
static

Definition at line 177 of file SystemOfUnits.h.

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

Definition at line 275 of file SystemOfUnits.h.

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

Definition at line 167 of file SystemOfUnits.h.

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

Definition at line 185 of file SystemOfUnits.h.

constexpr double CLHEP::gray = joule/kilogram
static

Definition at line 289 of file SystemOfUnits.h.

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

Definition at line 63 of file PhysicalConstants.h.

constexpr double CLHEP::halfpi = pi/2
static

Definition at line 56 of file SystemOfUnits.h.

constexpr double CLHEP::hbar_Planck = h_Planck/twopi
static

Definition at line 64 of file PhysicalConstants.h.

constexpr double CLHEP::hbarc = hbar_Planck * c_light
static

Definition at line 65 of file PhysicalConstants.h.

constexpr double CLHEP::hbarc_squared = hbarc * hbarc
static

Definition at line 66 of file PhysicalConstants.h.

constexpr double CLHEP::henry = weber/ampere
static

Definition at line 256 of file SystemOfUnits.h.

constexpr double CLHEP::hep_pascal = newton/m2
static

Definition at line 207 of file SystemOfUnits.h.

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

Definition at line 65 of file Randomize.h.

const Hep3Vector CLHEP::HepXHat(1.0, 0.0, 0.0)
const Hep3Vector CLHEP::HepYHat(0.0, 1.0, 0.0)
const Hep3Vector CLHEP::HepZHat(0.0, 0.0, 1.0)
constexpr double CLHEP::hertz = 1./second
static

Definition at line 143 of file SystemOfUnits.h.

const float CLHEP::inverseLandau[TABLE_END+1]
static

Definition at line 74 of file RandLandau.cc.

constexpr double CLHEP::joule = electronvolt/e_SI
static

Definition at line 171 of file SystemOfUnits.h.

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

Definition at line 111 of file PhysicalConstants.h.

constexpr double CLHEP::kBq = kilobecquerel
static

Definition at line 279 of file SystemOfUnits.h.

constexpr double CLHEP::kelvin = 1.
static

Definition at line 261 of file SystemOfUnits.h.

constexpr double CLHEP::keV = kiloelectronvolt
static

Definition at line 176 of file SystemOfUnits.h.

constexpr double CLHEP::kg = kilogram
static

Definition at line 189 of file SystemOfUnits.h.

constexpr double CLHEP::kGasThreshold = 10.*mg/cm3
static

Definition at line 118 of file PhysicalConstants.h.

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

Definition at line 273 of file SystemOfUnits.h.

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

Definition at line 166 of file SystemOfUnits.h.

constexpr double CLHEP::kilogauss = 1.e-1*tesla
static

Definition at line 251 of file SystemOfUnits.h.

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

Definition at line 184 of file SystemOfUnits.h.

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

Definition at line 290 of file SystemOfUnits.h.

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

Definition at line 144 of file SystemOfUnits.h.

constexpr double CLHEP::kilometer = 1000.*meter
static

Definition at line 74 of file SystemOfUnits.h.

constexpr double CLHEP::kilometer2 = kilometer*kilometer
static

Definition at line 75 of file SystemOfUnits.h.

constexpr double CLHEP::kilometer3 = kilometer*kilometer*kilometer
static

Definition at line 76 of file SystemOfUnits.h.

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

Definition at line 223 of file SystemOfUnits.h.

constexpr double CLHEP::km = kilometer
static

Definition at line 113 of file SystemOfUnits.h.

constexpr double CLHEP::km2 = kilometer2
static

Definition at line 114 of file SystemOfUnits.h.

constexpr double CLHEP::km3 = kilometer3
static

Definition at line 115 of file SystemOfUnits.h.

constexpr double CLHEP::L = liter
static

Definition at line 104 of file SystemOfUnits.h.

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

Definition at line 103 of file SystemOfUnits.h.

constexpr double CLHEP::lumen = candela*steradian
static

Definition at line 302 of file SystemOfUnits.h.

constexpr double CLHEP::lux = lumen/meter2
static

Definition at line 307 of file SystemOfUnits.h.

constexpr double CLHEP::m = meter
static

Definition at line 109 of file SystemOfUnits.h.

constexpr double CLHEP::m2 = meter2
static

Definition at line 110 of file SystemOfUnits.h.

constexpr double CLHEP::m3 = meter3
static

Definition at line 111 of file SystemOfUnits.h.

const int CLHEP::MarkerLen = 64
static

Definition at line 49 of file MixMaxRng.cc.

const int CLHEP::MarkerLen = 64
static

Definition at line 56 of file RanecuEngine.cc.

const int CLHEP::MarkerLen = 64
static

Definition at line 58 of file RanluxEngine.cc.

const int CLHEP::MarkerLen = 64
static

Definition at line 59 of file JamesRandom.cc.

const int CLHEP::MarkerLen = 64
static

Definition at line 59 of file RanshiEngine.cc.

const int CLHEP::MarkerLen = 64
static

Definition at line 60 of file MTwistEngine.cc.

const int CLHEP::MarkerLen = 64
static

Definition at line 67 of file DualRand.cc.

const int CLHEP::MarkerLen = 64
static

Definition at line 76 of file Ranlux64Engine.cc.

constexpr double CLHEP::MBq = megabecquerel
static

Definition at line 280 of file SystemOfUnits.h.

constexpr double CLHEP::mCi = millicurie
static

Definition at line 283 of file SystemOfUnits.h.

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

Definition at line 274 of file SystemOfUnits.h.

constexpr double CLHEP::megaelectronvolt = 1.
static

Definition at line 164 of file SystemOfUnits.h.

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

Definition at line 145 of file SystemOfUnits.h.

constexpr double CLHEP::megavolt = megaelectronvolt/eplus
static

Definition at line 222 of file SystemOfUnits.h.

constexpr double CLHEP::meter = 1000.*millimeter
static

Definition at line 70 of file SystemOfUnits.h.

constexpr double CLHEP::meter2 = meter*meter
static

Definition at line 71 of file SystemOfUnits.h.

constexpr double CLHEP::meter3 = meter*meter*meter
static

Definition at line 72 of file SystemOfUnits.h.

constexpr double CLHEP::MeV = megaelectronvolt
static

Definition at line 174 of file SystemOfUnits.h.

constexpr double CLHEP::mg = milligram
static

Definition at line 191 of file SystemOfUnits.h.

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

Definition at line 216 of file SystemOfUnits.h.

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

Definition at line 87 of file SystemOfUnits.h.

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

Definition at line 277 of file SystemOfUnits.h.

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

Definition at line 236 of file SystemOfUnits.h.

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

Definition at line 292 of file SystemOfUnits.h.

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

Definition at line 80 of file SystemOfUnits.h.

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

Definition at line 140 of file SystemOfUnits.h.

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

Definition at line 215 of file SystemOfUnits.h.

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

Definition at line 86 of file SystemOfUnits.h.

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

Definition at line 276 of file SystemOfUnits.h.

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

Definition at line 235 of file SystemOfUnits.h.

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

Definition at line 186 of file SystemOfUnits.h.

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

Definition at line 291 of file SystemOfUnits.h.

constexpr double CLHEP::millimeter = 1.
static

Definition at line 62 of file SystemOfUnits.h.

constexpr double CLHEP::millimeter2 = millimeter*millimeter
static

Definition at line 63 of file SystemOfUnits.h.

constexpr double CLHEP::millimeter3 = millimeter*millimeter*millimeter
static

Definition at line 64 of file SystemOfUnits.h.

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

Definition at line 123 of file SystemOfUnits.h.

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

Definition at line 139 of file SystemOfUnits.h.

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

Definition at line 107 of file SystemOfUnits.h.

constexpr double CLHEP::mm = millimeter
static

Definition at line 95 of file SystemOfUnits.h.

constexpr double CLHEP::mm2 = millimeter2
static

Definition at line 96 of file SystemOfUnits.h.

constexpr double CLHEP::mm3 = millimeter3
static

Definition at line 97 of file SystemOfUnits.h.

constexpr double CLHEP::mole = 1.
static

Definition at line 266 of file SystemOfUnits.h.

constexpr double CLHEP::mrad = milliradian
static

Definition at line 130 of file SystemOfUnits.h.

constexpr double CLHEP::ms = millisecond
static

Definition at line 150 of file SystemOfUnits.h.

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

Definition at line 89 of file PhysicalConstants.h.

const int CLHEP::N = 17

Definition at line 43 of file mixmax.h.

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

Definition at line 217 of file SystemOfUnits.h.

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

Definition at line 88 of file SystemOfUnits.h.

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

Definition at line 237 of file SystemOfUnits.h.

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

Definition at line 81 of file SystemOfUnits.h.

constexpr double CLHEP::nanosecond = 1.
static

Definition at line 137 of file SystemOfUnits.h.

constexpr double CLHEP::neutron_mass_c2 = 939.56536 * MeV
static

Definition at line 81 of file PhysicalConstants.h.

constexpr double CLHEP::newton = joule/meter
static

Definition at line 201 of file SystemOfUnits.h.

constexpr double CLHEP::nm = nanometer
static

Definition at line 92 of file SystemOfUnits.h.

constexpr double CLHEP::ns = nanosecond
static

Definition at line 148 of file SystemOfUnits.h.

constexpr double CLHEP::ohm = volt/ampere
static

Definition at line 229 of file SystemOfUnits.h.

constexpr double CLHEP::parsec = 3.0856775807e+16*meter
static

Definition at line 78 of file SystemOfUnits.h.

constexpr double CLHEP::pc = parsec
static

Definition at line 117 of file SystemOfUnits.h.

constexpr double CLHEP::perCent = 0.01
static

Definition at line 312 of file SystemOfUnits.h.

constexpr double CLHEP::perMillion = 0.000001
static

Definition at line 314 of file SystemOfUnits.h.

constexpr double CLHEP::perThousand = 0.001
static

Definition at line 313 of file SystemOfUnits.h.

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

Definition at line 169 of file SystemOfUnits.h.

constexpr double CLHEP::PeV = petaelectronvolt
static

Definition at line 179 of file SystemOfUnits.h.

constexpr double CLHEP::pi = 3.14159265358979323846
static

Definition at line 54 of file SystemOfUnits.h.

constexpr double CLHEP::pi2 = pi*pi
static

Definition at line 57 of file SystemOfUnits.h.

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

Definition at line 89 of file SystemOfUnits.h.

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

Definition at line 238 of file SystemOfUnits.h.

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

Definition at line 141 of file SystemOfUnits.h.

const double CLHEP::poissonTables[51 *((95-10)/5+1)]
static
Initial value:
= {
}

Definition at line 72 of file RandPoissonQ.cc.

const double CLHEP::prec = 4.6566128E-10
static

Definition at line 58 of file RanecuEngine.cc.

constexpr double CLHEP::proton_mass_c2 = 938.272013 * MeV
static

Definition at line 80 of file PhysicalConstants.h.

constexpr double CLHEP::ps = picosecond
static

Definition at line 152 of file SystemOfUnits.h.

constexpr double CLHEP::rad = radian
static

Definition at line 129 of file SystemOfUnits.h.

constexpr double CLHEP::radian = 1.
static

Definition at line 122 of file SystemOfUnits.h.

constexpr double CLHEP::s = second
static

Definition at line 149 of file SystemOfUnits.h.

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

Definition at line 138 of file SystemOfUnits.h.

constexpr double CLHEP::sr = steradian
static

Definition at line 131 of file SystemOfUnits.h.

constexpr double CLHEP::steradian = 1.
static

Definition at line 126 of file SystemOfUnits.h.

constexpr double CLHEP::STP_Pressure = 1.*atmosphere
static

Definition at line 117 of file PhysicalConstants.h.

constexpr double CLHEP::STP_Temperature = 273.15*kelvin
static

Definition at line 116 of file PhysicalConstants.h.

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

Definition at line 540 of file LorentzVector.h.

const int CLHEP::TABLE_END = 982
static

Definition at line 61 of file RandLandau.cc.

const float CLHEP::TABLE_INTERVAL = .001f
static

Definition at line 60 of file RandLandau.cc.

const float CLHEP::TABLE_MULTIPLIER = 1.0f/TABLE_INTERVAL
static

Definition at line 62 of file RandLandau.cc.

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

Definition at line 168 of file SystemOfUnits.h.

constexpr double CLHEP::tesla = volt*second/meter2
static

Definition at line 248 of file SystemOfUnits.h.

constexpr double CLHEP::TeV = teraelectronvolt
static

Definition at line 178 of file SystemOfUnits.h.

const int CLHEP::Toffsets[5]
static
Initial value:
= { Table0offset,
Table1offset,
Table2offset,
Table3offset,
Table4offset }
Table2offset
#define Table2offset
Definition: flatToGaussian.cc:73
Table0offset
#define Table0offset
Definition: flatToGaussian.cc:71
Table1offset
#define Table1offset
Definition: flatToGaussian.cc:72
Table3offset
#define Table3offset
Definition: flatToGaussian.cc:74
Table4offset
#define Table4offset
Definition: flatToGaussian.cc:75

Definition at line 77 of file flatToGaussian.cc.

const int CLHEP::Tsizes[5]
static
Initial value:
= { Table0size,
Table1size,
Table2size,
Table3size,
Table4size }
Table2size
#define Table2size
Definition: flatToGaussian.cc:48
Table1size
#define Table1size
Definition: flatToGaussian.cc:47
Table3size
#define Table3size
Definition: flatToGaussian.cc:49
Table0size
#define Table0size
Definition: flatToGaussian.cc:46
Table4size
#define Table4size
Definition: flatToGaussian.cc:50

Definition at line 53 of file flatToGaussian.cc.

const double CLHEP::Tsteps[5]
static
Initial value:
= { Table0step,
Table1step,
Table2step,
Table3step,
Table4step }
Table2step
#define Table2step
Definition: flatToGaussian.cc:61
Table0step
#define Table0step
Definition: flatToGaussian.cc:59
Table1step
#define Table1step
Definition: flatToGaussian.cc:60
Table3step
#define Table3step
Definition: flatToGaussian.cc:62
Table4step
#define Table4step
Definition: flatToGaussian.cc:63

Definition at line 65 of file flatToGaussian.cc.

constexpr double CLHEP::twopi = 2*pi
static

Definition at line 55 of file SystemOfUnits.h.

constexpr double CLHEP::twopi_mc2_rcl2
static
Initial value:
= twopi*electron_mass_c2
*classic_electr_radius
*classic_electr_radius
twopi
static constexpr double twopi
Definition: G4SIunits.hh:76
python.hepunit.electron_mass_c2
float electron_mass_c2
Definition: hepunit.py:274

Definition at line 105 of file PhysicalConstants.h.

constexpr double CLHEP::uCi = microcurie
static

Definition at line 284 of file SystemOfUnits.h.

constexpr double CLHEP::um = micrometer
static

Definition at line 93 of file SystemOfUnits.h.

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

Definition at line 123 of file PhysicalConstants.h.

constexpr double CLHEP::us = microsecond
static

Definition at line 151 of file SystemOfUnits.h.

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

Definition at line 224 of file SystemOfUnits.h.

constexpr double CLHEP::watt = joule/second
static

Definition at line 196 of file SystemOfUnits.h.

constexpr double CLHEP::weber = volt*second
static

Definition at line 243 of file SystemOfUnits.h.

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

Definition at line 537 of file LorentzVector.h.

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

Definition at line 538 of file LorentzVector.h.

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

Definition at line 539 of file LorentzVector.h.