CLHEP Namespace Reference

Namespaces
namespace	detail

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

Typedefs
using	myID_t = std::uint32_t
using	myuint_t = std::uint64_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 ()
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 &os, const Hep2Vector &q)
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)
void	ZMinputAxisAngle (std::istream &is, double &x, double &y, double &z, double &delta)
void	ZMinput3doubles (std::istream &is, const char *type, double &x, double &y, double &z)
double	transformSmall (double r)
double	gammln (double xx)
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
DLL_API const Hep3Vector	HepXHat
DLL_API const Hep3Vector	HepYHat
DLL_API const Hep3Vector	HepZHat

Typedef Documentation

HepLorentzVectorD

typedef HepLorentzVector CLHEP::HepLorentzVectorD

Definition at line 547 of file LorentzVector.h.

HepLorentzVectorF

typedef HepLorentzVector CLHEP::HepLorentzVectorF

Definition at line 548 of file LorentzVector.h.

HepThreeVectorD

typedef Hep3Vector CLHEP::HepThreeVectorD

Definition at line 421 of file ThreeVector.h.

HepThreeVectorF

typedef Hep3Vector CLHEP::HepThreeVectorF

Definition at line 422 of file ThreeVector.h.

myID_t

using CLHEP::myID_t = std::uint32_t

Author

K.Savvidy

Definition at line 49 of file MixMaxRng.h.

myuint_t

using CLHEP::myuint_t = std::uint64_t

Definition at line 50 of file MixMaxRng.h.

shared_ptr

template<typename T>

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

Definition at line 15 of file memory.h.

weak_ptr

template<typename T>

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

Definition at line 17 of file memory.h.

Enumeration Type Documentation

ZMpvMetric_t

enum CLHEP::ZMpvMetric_t

Enumerator
TimePositive
TimeNegative

Definition at line 59 of file LorentzVector.h.

{ TimePositive, TimeNegative };

Function Documentation

boostOf() [1/2]

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

inline

boostOf() [2/2]

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

inline

Referenced by G4LightIonQMDReaction::ApplyYourself(), and G4QMDReaction::ApplyYourself().

boostXOf()

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

inline

boostYOf()

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

inline

boostZOf()

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

inline

crc32ul()

unsigned long CLHEP::crc32ul

(

const std::string &

s

)

Definition at line 36 of file engineIDulong.cc.

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

Referenced by engineIDulong().

engineIDulong()

template<class E>

unsigned long CLHEP::engineIDulong

(

)

Definition at line 25 of file engineIDulong.h.

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

Referenced by CLHEP::DualRand::get(), CLHEP::HepJamesRandom::get(), CLHEP::MixMaxRng::get(), CLHEP::MTwistEngine::get(), CLHEP::NonRandomEngine::get(), CLHEP::RanecuEngine::get(), CLHEP::Ranlux64Engine::get(), CLHEP::RanluxEngine::get(), CLHEP::RanluxppEngine::get(), CLHEP::RanshiEngine::get(), CLHEP::DualRand::put(), CLHEP::HepJamesRandom::put(), CLHEP::MixMaxRng::put(), CLHEP::MTwistEngine::put(), CLHEP::NonRandomEngine::put(), CLHEP::RanecuEngine::put(), CLHEP::Ranlux64Engine::put(), CLHEP::RanluxEngine::put(), CLHEP::RanluxppEngine::put(), and CLHEP::RanshiEngine::put().

gammln()

double CLHEP::gammln

(

double

xx

)

Definition at line 56 of file RandPoisson.cc.

                         {
 
// Returns the value ln(Gamma(xx) for xx > 0.  Full accuracy is obtained for 
// xx > 1. For 0 < xx < 1. the reflection formula (6.1.4) can be used first.
// (Adapted from Numerical Recipes in C)
 
  static const double cof[6] = {76.18009172947146,-86.50532032941677,
                             24.01409824083091, -1.231739572450155,
                             0.1208650973866179e-2, -0.5395239384953e-5};
  int j;
  double x = xx - 1.0;
  double tmp = x + 5.5;
  tmp -= (x + 0.5) * std::log(tmp);
  double ser = 1.000000000190015;
 
  for ( j = 0; j <= 5; j++ ) {
    x += 1.0;
    ser += cof[j]/x;
  }
  return -tmp + std::log(2.5066282746310005*ser);
}

Referenced by CLHEP::RandPoisson::fire(), CLHEP::RandPoisson::shoot(), and CLHEP::RandPoisson::shoot().

HepXHat()

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

HepYHat()

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

HepZHat()

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

inverseOf() [1/9]

HepBoost CLHEP::inverseOf ( const HepBoost & lt )

inline

inverseOf() [2/9]

HepBoostX CLHEP::inverseOf ( const HepBoostX & b )

inline

inverseOf() [3/9]

HepBoostY CLHEP::inverseOf ( const HepBoostY & b )

inline

inverseOf() [4/9]

HepBoostZ CLHEP::inverseOf ( const HepBoostZ & b )

inline

inverseOf() [5/9]

HepLorentzRotation CLHEP::inverseOf ( const HepLorentzRotation & lt )

inline

inverseOf() [6/9]

HepRotation CLHEP::inverseOf ( const HepRotation & r )

inline

inverseOf() [7/9]

HepRotationX CLHEP::inverseOf ( const HepRotationX & r )

inline

inverseOf() [8/9]

HepRotationY CLHEP::inverseOf ( const HepRotationY & r )

inline

inverseOf() [9/9]

HepRotationZ CLHEP::inverseOf ( const HepRotationZ & r )

inline

operator!=() [1/2]

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

inline

Definition at line 363 of file LorentzRotation.h.

  { return lt!=HepLorentzRotation(b); }

operator!=() [2/2]

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

inline

Definition at line 350 of file LorentzRotation.h.

  { return lt!=HepLorentzRotation(r); }

operator*() [1/15]

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

inline

operator*() [2/15]

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

inline

operator*() [3/15]

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

inline

operator*() [4/15]

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

inline

operator*() [5/15]

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

inline

operator*() [6/15]

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

Definition at line 260 of file LorentzRotation.cc.

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

operator*() [7/15]

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

operator*() [8/15]

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

inline

operator*() [9/15]

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

operator*() [10/15]

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

inline

operator*() [11/15]

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

operator*() [12/15]

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

inline

operator*() [13/15]

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

inline

operator*() [14/15]

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

inline

operator*() [15/15]

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

inline

operator+() [1/2]

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

inline

operator+() [2/2]

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

inline

operator-() [1/2]

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

inline

operator-() [2/2]

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

inline

operator/() [1/3]

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

Definition at line 61 of file TwoVector.cc.

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

operator/() [2/3]

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

Definition at line 298 of file ThreeVector.cc.

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

operator/() [3/3]

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

Definition at line 161 of file LorentzVector.cc.

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

operator<() [1/2]

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

inline

Definition at line 369 of file LorentzRotation.h.

  { return lt<b; }

operator<() [2/2]

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

inline

Definition at line 356 of file LorentzRotation.h.

  { return lt<r; }

operator<<() [1/16]

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

Definition at line 63 of file ThreeVector.cc.

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

operator<<() [2/16]

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

Definition at line 86 of file LorentzVector.cc.

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

operator<<() [3/16]

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

Definition at line 69 of file TwoVector.cc.

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

operator<<() [4/16]

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

Definition at line 89 of file AxisAngle.cc.

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

operator<<() [5/16]

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

inline

Definition at line 238 of file Boost.h.

{return b.print(os);}

operator<<() [6/16]

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

inline

Definition at line 212 of file BoostX.h.

{return b.print(os);}

operator<<() [7/16]

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

inline

Definition at line 213 of file BoostY.h.

{return b.print(os);}

operator<<() [8/16]

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

inline

Definition at line 212 of file BoostZ.h.

{return b.print(os);}

operator<<() [9/16]

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

Definition at line 101 of file EulerAngles.cc.

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

operator<<() [10/16]

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

inline

Definition at line 344 of file LorentzRotation.h.

  {return lt.print(os);}

operator<<() [11/16]

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

Definition at line 219 of file Random.cc.

                                                                  {
  return dist.put(os);
}

operator<<() [12/16]

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

Definition at line 100 of file RandomEngine.cc.

                                                                     {
  return e.put(os);
}

operator<<() [13/16]

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

inline

Definition at line 406 of file Rotation.h.

{return r.print(os);}

operator<<() [14/16]

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

inline

Definition at line 275 of file RotationX.h.

{return r.print(os);}

operator<<() [15/16]

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

inline

Definition at line 275 of file RotationY.h.

{return r.print(os);}

operator<<() [16/16]

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

inline

Definition at line 275 of file RotationZ.h.

{return r.print(os);}

operator<=() [1/2]

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

inline

Definition at line 365 of file LorentzRotation.h.

  { return lt<=b; }

operator<=() [2/2]

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

inline

Definition at line 352 of file LorentzRotation.h.

  { return lt<=r; }

operator==() [1/2]

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

inline

Definition at line 361 of file LorentzRotation.h.

  { return lt==HepLorentzRotation(b); }

operator==() [2/2]

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

inline

Definition at line 348 of file LorentzRotation.h.

  { return lt==HepLorentzRotation(r); }

operator>() [1/2]

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

inline

Definition at line 371 of file LorentzRotation.h.

  { return lt>b; }

operator>() [2/2]

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

inline

Definition at line 358 of file LorentzRotation.h.

  { return lt>r; }

operator>=() [1/2]

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

inline

Definition at line 367 of file LorentzRotation.h.

  { return lt>=b; }

operator>=() [2/2]

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

inline

Definition at line 354 of file LorentzRotation.h.

  { return lt>=r; }

operator>>() [1/7]

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

Definition at line 77 of file TwoVector.cc.

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

operator>>() [2/7]

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

Definition at line 70 of file ThreeVector.cc.

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

operator>>() [3/7]

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

Definition at line 92 of file LorentzVector.cc.

                                                                 {
 
// Required format is ( a, b, c; d ) that is, four numbers, preceded by
// (, followed by ), components of the spatial vector separated by commas,
// time component separated by semicolon. The four numbers are taken
// as x, y, z, t.
 
  double x, y, z, t;
  char c;
 
  is >> std::ws >> c;
    // ws is defined to invoke eatwhite(istream & )
    // see (Stroustrup gray book) page 333 and 345.
  if (is.fail() || c != '(' ) {
    std::cerr << "Could not find required opening parenthesis "
          << "in input of a HepLorentzVector" << std::endl;
    return is;
  }
 
  is >> x >> std::ws >> c;
  if (is.fail() || c != ',' ) {
    std::cerr << "Could not find x value and required trailing comma "
          << "in input of a HepLorentzVector" << std::endl; 
    return is;
  }
 
  is >> y >> std::ws >> c;
  if (is.fail() || c != ',' ) {
    std::cerr << "Could not find y value and required trailing comma "
              <<  "in input of a HepLorentzVector" << std::endl;
    return is;
  }
 
  is >> z >> std::ws >> c;
  if (is.fail() || c != ';' ) {
    std::cerr << "Could not find z value and required trailing semicolon "
         <<  "in input of a HepLorentzVector" << std::endl;
    return is;
  }
 
  is >> t >> std::ws >> c;
  if (is.fail() || c != ')' ) {
    std::cerr << "Could not find t value and required close parenthesis "
         << "in input of a HepLorentzVector" << std::endl;
    return is;
  }
 
  v1.setX(x);
  v1.setY(y);
  v1.setZ(z);
  v1.setT(t);
  return is;
}

operator>>() [4/7]

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

Definition at line 99 of file AxisAngle.cc.

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

operator>>() [5/7]

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

Definition at line 110 of file EulerAngles.cc.

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

operator>>() [6/7]

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

Definition at line 223 of file Random.cc.

                                                            {
  return dist.get(is);
}

operator>>() [7/7]

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

Definition at line 104 of file RandomEngine.cc.

                                                               {
  return e.get(is);
}

possibleKeywordInput()

template<class IS, class T>

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

Definition at line 166 of file RandomEngine.h.

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

Referenced by CLHEP::RandBinomial::get(), CLHEP::RandBreitWigner::get(), CLHEP::RandChiSquare::get(), CLHEP::RandExponential::get(), CLHEP::RandExpZiggurat::get(), CLHEP::RandFlat::get(), CLHEP::RandGamma::get(), CLHEP::RandGauss::get(), CLHEP::RandGeneral::get(), CLHEP::RandPoisson::get(), CLHEP::RandPoissonQ::get(), CLHEP::RandStudentT::get(), CLHEP::DualRand::getState(), CLHEP::HepJamesRandom::getState(), CLHEP::NonRandomEngine::getState(), CLHEP::RanecuEngine::getState(), CLHEP::Ranlux64Engine::getState(), CLHEP::RanluxEngine::getState(), CLHEP::RanshiEngine::getState(), CLHEP::RandGauss::restoreDistState(), CLHEP::RandGauss::restoreEngineStatus(), CLHEP::DualRand::restoreStatus(), CLHEP::HepJamesRandom::restoreStatus(), CLHEP::RanecuEngine::restoreStatus(), CLHEP::Ranlux64Engine::restoreStatus(), CLHEP::RanluxEngine::restoreStatus(), and CLHEP::RanshiEngine::restoreStatus().

rotationOf() [1/8]

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

Definition at line 126 of file SpaceVectorR.cc.

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

rotationOf() [2/8]

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

Definition at line 121 of file SpaceVectorR.cc.

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

rotationOf() [3/8]

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

Definition at line 132 of file SpaceVectorR.cc.

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

rotationOf() [4/8]

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

Definition at line 137 of file SpaceVectorR.cc.

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

rotationOf() [5/8]

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

Definition at line 43 of file LorentzVectorR.cc.

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

rotationOf() [6/8]

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

Definition at line 50 of file LorentzVectorR.cc.

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

rotationOf() [7/8]

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

Definition at line 56 of file LorentzVectorR.cc.

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

rotationOf() [8/8]

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

Definition at line 62 of file LorentzVectorR.cc.

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

rotationXOf() [1/2]

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

Definition at line 143 of file SpaceVectorR.cc.

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

rotationXOf() [2/2]

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

Definition at line 25 of file LorentzVectorB.cc.

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

rotationYOf() [1/2]

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

Definition at line 148 of file SpaceVectorR.cc.

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

rotationYOf() [2/2]

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

Definition at line 31 of file LorentzVectorB.cc.

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

rotationZOf() [1/2]

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

Definition at line 153 of file SpaceVectorR.cc.

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

rotationZOf() [2/2]

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

Definition at line 37 of file LorentzVectorB.cc.

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

transformSmall()

double CLHEP::transformSmall

(

double

r

)

Definition at line 218 of file flatToGaussian.cc.

                                 {
 
  // Solve for -v in the asymtotic formula 
  //
  // errInt (-v) =  exp(-v*v/2)         1     1*3    1*3*5
  //           ------------ * (1 - ---- + ---- - ----- + ... )
  //           v*sqrt(2*pi)        v**2   v**4   v**6
 
  // The value of r (=errInt(-v)) supplied is going to less than 2.0E-13,
  // which is such that v < -7.25.  Since the value of r is meaningful only
  // to an absolute error of 1E-16 (double precision accuracy for a number 
  // which on the high side could be of the form 1-epsilon), computing
  // v to more than 3-4 digits of accuracy is suspect; however, to ensure 
  // smoothness with the table generator (which uses quite a few terms) we
  // also use terms up to 1*3*5* ... *13/v**14, and insist on accuracy of
  // solution at the level of 1.0e-7.
 
  // This routine is called less than one time in a trillion firings, so
  // speed is of no concern.  As a matter of technique, we terminate the
  // iterations in case they would be infinite, but this should not happen.
 
  double eps = 1.0e-7;
  double guess = 7.5;
  double v;
  
  for ( int i = 1; i < 50; i++ ) {
    double vn2 = 1.0/(guess*guess);
    double s1 = -13*11*9*7*5*3 * vn2*vn2*vn2*vn2*vn2*vn2*vn2;
            s1 +=    11*9*7*5*3 * vn2*vn2*vn2*vn2*vn2*vn2;
            s1 +=      -9*7*5*3 * vn2*vn2*vn2*vn2*vn2;
            s1 +=         7*5*3 * vn2*vn2*vn2*vn2;
            s1 +=          -5*3 * vn2*vn2*vn2;
            s1 +=            3 * vn2*vn2    - vn2  +    1.0;
    v = std::sqrt ( 2.0 * std::log ( s1 / (r*guess*std::sqrt(CLHEP::twopi)) ) );
    if ( std::abs(v-guess) < eps ) break;
    guess = v;
  }
 
  return -v;
 
} // transformSmall()

Referenced by CLHEP::HepStat::flatToGaussian().

ZMinput2doubles()

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

Definition at line 243 of file ZMinput.cc.

                                     {
 
// Accepted formats are 
// x y 
// x, y (comma is optional, and whitespace ignored if comma present)
// ( x, y ) (comma optional)
 
  char c;
  bool parenthesis = false;
 
  if ( !eatwhitespace(is) ) {
    std::cerr << "istream ended before trying to input " << type << "\n";
    return;
  }
 
  if ( !is.get(c) ) { fouledup(); return; }
  if ( c == '(' ) {
    parenthesis = true;
    if ( !eatwhitespace(is) ) {
      std::cerr << "istream ended after ( trying to input " << type << "\n";
      return;
    }
  } else {
    is.putback(c);
  }  
 
  // At this point, parenthesis or not, the next item read is supposed to
  // be the number x.
 
  if (!(is >> x)) {
    std::cerr << "Could not read first value in input of " << type << "\n";
    return;
  }
 
  if ( !eatwhitespace(is) ) {
    std::cerr << "istream ended before second value of " << type << "\n";
    return;
  } 
 
  if ( !is.get(c) ) { fouledup(); return; }
  if ( c == ',' ) {
    if ( !eatwhitespace(is) ) {
      std::cerr << "istream ended ater one value and comma in " 
                            << type << "\n";
      return;
    }
  } else {
    is.putback(c);
  }
 
  // At this point, comma or not, the next item read is supposed to
  // be the number y.
 
  if (!(is >> y)) {
    std::cerr << "Could not read second value in input of " << type << "\n";
    return;
  }
 
  // Finally, check for the closing parenthesis if there was an open paren.
 
  if (parenthesis) {
    if ( !eatwhitespace(is) ) {
      std::cerr << "No closing parenthesis in input of " << type << "\n";
      return;
    } 
    if ( !is.get(c) ) { fouledup(); return; }
    if ( c != ')' ) {
      std::cerr << "Missing closing parenthesis in input of " 
                            << type << "\n";
      // Now a trick to do (as nearly as we can) what 
      // is.putback(c); is.setstate(std::ios_base::failbit); 
      // would do (because using ios_base will confuse old CLHEP compilers):
      if ( isdigit(c) || (c=='-') || (c=='+') ) {
        is.putback('@');
      } else {
        is.putback('c');
      }
      int m;
      is >> m;  // This fails, leaving the state bad, and the istream
        // otherwise unchanged, except if the next char might
        // have started a valid int, it turns to @
      return;
    }
  }
 
  return;
 
}

Referenced by operator>>().

ZMinput3doubles()

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

Definition at line 42 of file ZMinput.cc.

                                                 {
 
// Accepted formats are 
// x y z
// x, y, z (each comma is optional, and whitespace ignored if comma present)
// ( x, y, z ) (commas optional)
 
  char c;
  bool parenthesis = false;
 
  if ( !eatwhitespace(is) ) {
    std::cerr << "istream ended before trying to input " << type << "\n";
    return;
  }
 
  if ( !is.get(c) ) { fouledup(); return; }
  if ( c == '(' ) {
    parenthesis = true;
    if ( !eatwhitespace(is) ) {
      std::cerr << "istream ended after ( trying to input " << type << "\n";
      return;
    }
  } else {
    is.putback(c);
  }  
 
  // At this point, parenthesis or not, the next item read is supposed to
  // be the number x.
 
  if (!(is >> x)) {
    std::cerr << "Could not read first value in input of " << type << "\n";
    return;
  }
 
  if ( !eatwhitespace(is) ) {
    std::cerr << "istream ended before second value of " << type << "\n";
    return;
  } 
 
  if ( !is.get(c) ) { fouledup(); return; }
  if ( c == ',' ) {
    if ( !eatwhitespace(is) ) {
      std::cerr << "istream ended ater one value and comma in " 
                            << type << "\n";
      return;
    }
  } else {
    is.putback(c);
  }
 
  // At this point, comma or not, the next item read is supposed to
  // be the number y.
 
  if (!(is >> y)) {
    std::cerr << "Could not read second value in input of " << type << "\n";
    return;
  }
 
  if ( !eatwhitespace(is) ) {
    std::cerr << "istream ended before third value of " << type << "\n";
    return;
  } 
 
  if ( !is.get(c) ) { fouledup(); return; }
  if ( c == ',' ) {
    if ( !eatwhitespace(is) ) {
      std::cerr << "istream ended ater two values and comma in " 
                            << type << "\n";
      return;
    }
  } else {
    is.putback(c);
  }
 
  // At this point, comma or not, the next item read is supposed to
  // be the number z.
 
  if (!(is >> z)) {
    std::cerr << "Could not read third value in input of " << type << "\n";
    return;
  }
 
  // Finally, check for the closing parenthesis if there was an open paren.
 
  if (parenthesis) {
    if ( !eatwhitespace(is) ) {
      std::cerr << "No closing parenthesis in input of " << type << "\n";
      return;
    } 
    if ( !is.get(c) ) { fouledup(); return; }
    if ( c != ')' ) {
      std::cerr << "Missing closing parenthesis in input of " 
                            << type << "\n";
      // Now a trick to do (as nearly as we can) what 
      // is.putback(c); is.setstate(std::ios_base::failbit); 
      // would do (because using ios_base will confuse old CLHEP compilers):
      if ( isdigit(c) || (c=='-') || (c=='+') ) {
        is.putback('@');
      } else {
        is.putback('c');
      }
      int m;
      is >> m;  // This fails, leaving the state bad, and the istream
        // otherwise unchanged, except if the next char might
        // have started a valid int, it turns to @
      return;
    }
  }
 
  return;
 
}

Referenced by CLHEP::HepEulerAngles::operator>>, operator>>(), and ZMinputAxisAngle().

ZMinputAxisAngle()

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

Definition at line 156 of file ZMinput.cc.

                             {
// Accepted formats are 
// parenthesis optional, then
// any acceptable format for a Hep3Vector, then
// optional comma, then
// delta, then
// close parenthesis if opened at start.
//
// But if there is an open parenthesis, it must be for the overall
// object.  That is, if the axis has parentheses, the form must be 
// ( (x,y,z) , delta ) 
 
  char c;
  bool parenthesis = false;
 
  if ( !eatwhitespace(is) ) {
    std::cerr << "istream ended before trying to input AxisAngle \n";
    return;
  }
 
  if ( !is.get(c) ) { fouledup(); return; }
  if ( c == '(' ) {
    parenthesis = true;
    if ( !eatwhitespace(is) ) {
      std::cerr << "istream ended after ( trying to input AxisAngle \n";
      return;
    }
  } else {
    is.putback(c);
  }  
 
  // At this point, parenthesis or not, the next item read is supposed to
  // be a valid Hep3Vector axis.
 
  ZMinput3doubles ( is, "axis of AxisAngle", x, y, z );
  if (!is) return;
 
  if ( !eatwhitespace(is) ) {
    std::cerr << "istream ended before delta of AxisAngle \n";
    return;
  } 
 
  if ( !is.get(c) ) { fouledup(); return; }
  if ( c == ',' ) {
    if ( !eatwhitespace(is) ) {
      std::cerr << "istream ended ater axis and comma in AxisAngle \n"; 
      return;
    }
  } else {
    is.putback(c);
  }
 
  // At this point, comma or not, the next item read is supposed to
  // be the number delta.
 
  if (!(is >> delta)) {
    std::cerr << "Could not delta value in input of AxisAngle \n";
    return;
  }
 
  // Finally, check for the closing parenthesis if there was an open paren.
 
  if (parenthesis) {
    if ( !eatwhitespace(is) ) {
      std::cerr << "No closing parenthesis in input of AxisAngle \n";
      return;
    } 
    if ( !is.get(c) ) { fouledup(); return; }
    if ( c != ')' ) {
      std::cerr << "Missing closing parenthesis in input of AxisAngle \n";
      if ( isdigit(c) || (c=='-') || (c=='+') ) {
        is.putback('@');
      } else {
        is.putback('c');
      }
      int m;
      is >> m;  // This fails, leaving the state bad.
      return;
    }
  }
 
  return;
 
}

Referenced by CLHEP::HepAxisAngle::operator>>.

Variable Documentation

HepXHat

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

Referenced by G4GPSModel::DescribeYourselfTo(), G4CrystalUnitCell::G4CrystalUnitCell(), G4SPSAngDistribution::G4SPSAngDistribution(), and G4SPSPosDistribution::G4SPSPosDistribution().

HepYHat

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

Definition at line 419 of file ThreeVector.h.

Referenced by G4GPSModel::DescribeYourselfTo(), G4CrystalUnitCell::G4CrystalUnitCell(), G4SPSAngDistribution::G4SPSAngDistribution(), and G4SPSPosDistribution::G4SPSPosDistribution().

HepZHat

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

Definition at line 419 of file ThreeVector.h.

Referenced by G4GPSModel::DescribeYourselfTo(), G4CrystalUnitCell::G4CrystalUnitCell(), G4SPSAngDistribution::G4SPSAngDistribution(), and G4SPSPosDistribution::G4SPSPosDistribution().