Import Geant4 10.0.0 source tree

source/externals/clhep/include/CLHEP/Random/RandExpZiggurat.h

@@ -0,0 +1,168 @@
+/*
+Code adapted from:
+http://www.jstatsoft.org/v05/i08/
+
+
+Original disclaimer:
+
+The ziggurat method for RNOR and REXP
+Combine the code below with the main program in which you want
+normal or exponential variates.   Then use of RNOR in any expression
+will provide a standard normal variate with mean zero, variance 1,
+while use of REXP in any expression will provide an exponential variate
+with density exp(-x),x>0.
+Before using RNOR or REXP in your main, insert a command such as
+zigset(86947731 );
+with your own choice of seed value>0, rather than 86947731.
+(If you do not invoke zigset(...) you will get all zeros for RNOR and REXP.)
+For details of the method, see Marsaglia and Tsang, "The ziggurat method
+for generating random variables", Journ. Statistical Software.
+
+*/
+
+#ifndef RandExpZiggurat_h
+#define RandExpZiggurat_h 1
+
+#include "CLHEP/Random/Random.h"
+
+namespace CLHEP {
+
+/**
+ * @author ATLAS
+ * @ingroup random
+ */
+class RandExpZiggurat : public HepRandom {
+
+public:
+
+  inline RandExpZiggurat ( HepRandomEngine& anEngine, double mean=1.0 );
+  inline RandExpZiggurat ( HepRandomEngine* anEngine, double mean=1.0 );
+  // These constructors should be used to instantiate a RandExpZiggurat
+  // distribution object defining a local engine for it.
+  // The static generator will be skipped using the non-static methods
+  // defined below.
+  // If the engine is passed by pointer the corresponding engine object
+  // will be deleted by the RandExpZiggurat destructor.
+  // If the engine is passed by reference the corresponding engine object
+  // will not be deleted by the RandExpZiggurat destructor.
+
+  virtual ~RandExpZiggurat();
+  // Destructor
+
+  // Static methods to shoot random values using the static generator
+
+  static float shoot() {return shoot(HepRandom::getTheEngine());};
+  static float shoot( float mean ) {return shoot(HepRandom::getTheEngine(),mean);};
+
+  /* ENGINE IS INTRINSIC FLOAT
+  static double shoot() {return shoot(HepRandom::getTheEngine());};
+  static double shoot( double mean ) {return shoot(HepRandom::getTheEngine(),mean);};
+  */
+
+  static void shootArray ( const int size, float* vect, float mean=1.0 );
+  static void shootArray ( const int size, double* vect, double mean=1.0 );
+
+  //  Static methods to shoot random values using a given engine
+  //  by-passing the static generator.
+
+  static inline float shoot( HepRandomEngine* anEngine ) {return ziggurat_REXP(anEngine);};
+  static inline float shoot( HepRandomEngine* anEngine, float mean ) {return shoot(anEngine)*mean;};
+  
+  /* ENGINE IS INTRINSIC FLOAT
+  static inline double shoot( HepRandomEngine* anEngine ) {return ziggurat_REXP(anEngine);};
+
+  static inline double shoot( HepRandomEngine* anEngine, double mean ) {return shoot(anEngine)*mean;};
+  */
+  
+  static void shootArray ( HepRandomEngine* anEngine, const int size, float* vect, float mean=1.0 );
+  static void shootArray ( HepRandomEngine* anEngine, const int size, double* vect, double mean=1.0 );
+
+  //  Methods using the localEngine to shoot random values, by-passing
+  //  the static generator.
+
+  inline float fire() {return fire(defaultMean);};
+  inline float fire( float mean ) {return ziggurat_REXP(localEngine)*mean;};
+  
+  /* ENGINE IS INTRINSIC FLOAT
+  inline double fire() {return fire(defaultMean);};
+  inline double fire( double mean ) {return ziggurat_REXP(localEngine)*mean;};
+  */
+  
+  void fireArray ( const int size, float* vect );
+  void fireArray ( const int size, double* vect );
+  void fireArray ( const int size, float* vect, float mean );
+  void fireArray ( const int size, double* vect, double mean );
+  
+  virtual double operator()();
+  inline float operator()( float mean ) {return fire( mean );};
+
+  // Save and restore to/from streams
+  
+  std::ostream & put ( std::ostream & os ) const;
+  std::istream & get ( std::istream & is );
+
+  std::string name() const;
+  HepRandomEngine & engine();
+
+  static std::string distributionName() {return "RandExpZiggurat";}  
+  // Provides the name of this distribution class
+  
+  static bool ziggurat_init();
+protected:
+  //////////////////////////
+  // Ziggurat Original code:
+  //////////////////////////
+  //static unsigned long jz,jsr=123456789;
+  //
+  //#define SHR3 (jz=jsr, jsr^=(jsr<<13), jsr^=(jsr>>17), jsr^=(jsr<<5),jz+jsr)
+  //#define UNI (.5 + (signed) SHR3*.2328306e-9)
+  //#define IUNI SHR3
+  //
+  //static long hz;
+  //static unsigned long iz, kn[128], ke[256];
+  //static float wn[128],fn[128], we[256],fe[256];
+  //
+  //#define RNOR (hz=SHR3, iz=hz&127, (fabs(hz)<kn[iz])? hz*wn[iz] : nfix())
+  //#define REXP (jz=SHR3, iz=jz&255, (    jz <ke[iz])? jz*we[iz] : efix())
+
+  static unsigned long kn[128], ke[256];
+  static float wn[128],fn[128], we[256],fe[256];
+
+  static bool ziggurat_is_init;
+
+  static inline unsigned long ziggurat_SHR3(HepRandomEngine* anEngine) {return (unsigned int)(*anEngine);};
+  static inline float ziggurat_UNI(HepRandomEngine* anEngine) {return anEngine->flat();};
+  static inline float ziggurat_REXP(HepRandomEngine* anEngine) {
+    unsigned long jz=ziggurat_SHR3(anEngine);
+    unsigned long iz=jz&255;
+    return (jz<ke[iz]) ? jz*we[iz] : ziggurat_efix(jz,anEngine);
+  };
+  static float ziggurat_efix(unsigned long jz,HepRandomEngine* anEngine);
+
+private:
+
+  // Private copy constructor. Defining it here disallows use.
+  RandExpZiggurat(const RandExpZiggurat& d);
+
+  HepRandomEngine* localEngine;
+  bool deleteEngine;
+  double defaultMean;
+};
+
+}  // namespace CLHEP
+
+namespace CLHEP {
+
+inline RandExpZiggurat::RandExpZiggurat(HepRandomEngine & anEngine, double mean ) : localEngine(&anEngine), deleteEngine(false), defaultMean(mean) 
+{
+  if(!ziggurat_is_init) ziggurat_init();
+}
+
+inline RandExpZiggurat::RandExpZiggurat(HepRandomEngine * anEngine, double mean ) : localEngine(anEngine), deleteEngine(true), defaultMean(mean) 
+{
+  if(!ziggurat_is_init) ziggurat_init();
+}
+
+}  // namespace CLHEP
+
+#endif

source/externals/clhep/include/CLHEP/Random/RandGaussZiggurat.h

@@ -0,0 +1,147 @@
+/*
+Code adapted from:
+http://www.jstatsoft.org/v05/i08/
+
+
+Original disclaimer:
+
+The ziggurat method for RNOR and REXP
+Combine the code below with the main program in which you want
+normal or exponential variates.   Then use of RNOR in any expression
+will provide a standard normal variate with mean zero, variance 1,
+while use of REXP in any expression will provide an exponential variate
+with density exp(-x),x>0.
+Before using RNOR or REXP in your main, insert a command such as
+zigset(86947731 );
+with your own choice of seed value>0, rather than 86947731.
+(If you do not invoke zigset(...) you will get all zeros for RNOR and REXP.)
+For details of the method, see Marsaglia and Tsang, "The ziggurat method
+for generating random variables", Journ. Statistical Software.
+
+*/
+
+
+#ifndef RandGaussZiggurat_h
+#define RandGaussZiggurat_h 1
+
+#include "cmath"
+#include "CLHEP/Random/RandGauss.h"
+
+namespace CLHEP {
+
+/**
+ * @author ATLAS
+ * @ingroup random
+ */
+class RandGaussZiggurat : public RandGauss {
+
+public:
+
+  inline RandGaussZiggurat ( HepRandomEngine& anEngine, double mean=0.0, double stdDev=1.0 );
+  inline RandGaussZiggurat ( HepRandomEngine* anEngine, double mean=0.0, double stdDev=1.0 );
+
+  // Destructor
+  virtual ~RandGaussZiggurat();
+
+  // Static methods to shoot random values using the static generator
+  
+  static inline float shoot() {return ziggurat_RNOR(HepRandom::getTheEngine());};
+  static inline float shoot( float mean, float stdDev ) {return shoot()*stdDev + mean;};
+
+  static void shootArray ( const int size, float* vect, float mean=0.0, float stdDev=1.0 );
+  static void shootArray ( const int size, double* vect, double mean=0.0, double stdDev=1.0 );
+
+  //  Static methods to shoot random values using a given engine
+  //  by-passing the static generator.
+
+  static inline float shoot( HepRandomEngine* anotherEngine ) {return ziggurat_RNOR(anotherEngine);};
+  static inline float shoot( HepRandomEngine* anotherEngine, float mean, float stdDev ) {return shoot(anotherEngine)*stdDev + mean;};
+
+  static void shootArray ( HepRandomEngine* anotherEngine, const int size, float* vect, float mean=0.0, float stdDev=1.0 );
+  static void shootArray ( HepRandomEngine* anotherEngine, const int size, double* vect, double mean=0.0, double stdDev=1.0 );
+
+  //  Instance methods using the localEngine to instead of the static 
+  //  generator, and the default mean and stdDev established at construction
+
+  inline float fire() {return ziggurat_RNOR(localEngine.get()) * defaultStdDev + defaultMean;};
+
+  inline float fire ( float mean, float stdDev ) {return ziggurat_RNOR(localEngine.get()) * stdDev + mean;};
+  
+  void fireArray  ( const int size, float* vect);
+  void fireArray  ( const int size, double* vect);
+  void fireArray  ( const int size, float* vect, float mean, float stdDev );
+  void fireArray  ( const int size, double* vect, double mean, double stdDev );
+
+  virtual double operator()();
+  virtual double operator()( double mean, double stdDev );
+
+  // Save and restore to/from streams
+  
+  std::ostream & put ( std::ostream & os ) const;
+  std::istream & get ( std::istream & is );
+
+  std::string name() const;
+  HepRandomEngine & engine();
+
+  static std::string distributionName() {return "RandGaussZiggurat";}  
+  // Provides the name of this distribution class
+  
+  static bool ziggurat_init();
+protected:  
+  //////////////////////////
+  // Ziggurat Original code:
+  //////////////////////////
+  //static unsigned long jz,jsr=123456789;
+  //
+  //#define SHR3 (jz=jsr, jsr^=(jsr<<13), jsr^=(jsr>>17), jsr^=(jsr<<5),jz+jsr)
+  //#define UNI (.5 + (signed) SHR3*.2328306e-9)
+  //#define IUNI SHR3
+  //
+  //static long hz;
+  //static unsigned long iz, kn[128], ke[256];
+  //static float wn[128],fn[128], we[256],fe[256];
+  //
+  //#define RNOR (hz=SHR3, iz=hz&127, (fabs(hz)<kn[iz])? hz*wn[iz] : nfix())
+  //#define REXP (jz=SHR3, iz=jz&255, (    jz <ke[iz])? jz*we[iz] : efix())
+
+  static unsigned long kn[128], ke[256];
+  static float wn[128],fn[128], we[256],fe[256];
+
+  static bool ziggurat_is_init;
+  
+  static inline unsigned long ziggurat_SHR3(HepRandomEngine* anEngine) {return (unsigned int)(*anEngine);};
+  static inline float ziggurat_UNI(HepRandomEngine* anEngine) {return anEngine->flat();};
+  static inline float ziggurat_RNOR(HepRandomEngine* anEngine) {
+    long hz=(signed)ziggurat_SHR3(anEngine);
+    unsigned long iz=hz&127;
+    return ((unsigned long)abs(hz)<kn[iz]) ? hz*wn[iz] : ziggurat_nfix(hz,anEngine);
+  };
+  static float ziggurat_nfix(long hz,HepRandomEngine* anEngine);
+  
+private:
+
+  // Private copy constructor. Defining it here disallows use.
+  RandGaussZiggurat(const RandGaussZiggurat& d);
+
+  // All the engine info, and the default mean and sigma, are in the RandGauss
+  // base class.
+
+};
+
+}  // namespace CLHEP
+
+namespace CLHEP {
+
+RandGaussZiggurat::RandGaussZiggurat(HepRandomEngine & anEngine, double mean,double stdDev ): RandGauss(anEngine, mean, stdDev) 
+{
+  if(!ziggurat_is_init) ziggurat_init();
+}
+
+RandGaussZiggurat::RandGaussZiggurat(HepRandomEngine * anEngine, double mean,double stdDev ): RandGauss(anEngine, mean, stdDev) 
+{
+  if(!ziggurat_is_init) ziggurat_init();
+}
+
+}  // namespace CLHEP
+
+#endif

source/externals/clhep/include/CLHEP/Random/Randomize.h

@@ -39,11 +39,13 @@
 #include "CLHEP/Random/RandBreitWigner.h"
 #include "CLHEP/Random/RandChiSquare.h"
 #include "CLHEP/Random/RandExponential.h"
+#include "CLHEP/Random/RandExpZiggurat.h"
 #include "CLHEP/Random/RandFlat.h"
 #include "CLHEP/Random/RandBit.h"
 #include "CLHEP/Random/RandGamma.h"
 #include "CLHEP/Random/RandGauss.h"
 #include "CLHEP/Random/RandGaussQ.h"
+#include "CLHEP/Random/RandGaussZiggurat.h"
 #include "CLHEP/Random/RandGeneral.h"
 #include "CLHEP/Random/RandLandau.h"
 #include "CLHEP/Random/RandPoissonQ.h"

source/externals/clhep/include/CLHEP/Units/SystemOfUnits.h

@@ -252,6 +252,18 @@ namespace CLHEP {
   //
   static const double becquerel = 1./second ;
   static const double curie = 3.7e+10 * becquerel;
+  static const double kilobecquerel = 1.e+3*becquerel;
+  static const double megabecquerel = 1.e+6*becquerel;
+  static const double gigabecquerel = 1.e+9*becquerel;
+  static const double millicurie = 1.e-3*curie;
+  static const double microcurie = 1.e-6*curie;
+  static const double Bq = becquerel;
+  static const double kBq = kilobecquerel;
+  static const double MBq = megabecquerel;
+  static const double GBq = gigabecquerel;
+  static const double Ci = curie;
+  static const double mCi = millicurie;
+  static const double uCi = microcurie;
 
   //
   // Absorbed dose [L^2][T^-2]

source/externals/clhep/include/CLHEP/Utility/memory.h

@@ -1486,6 +1486,15 @@ do_nothing_deleter::operator () ( void const * ) const
 }  // namespace CLHEP
 
 
+#if defined __GNUC__ 
+  #if __GNUC__ > 3 && __GNUC_MINOR__ > 6
+    #pragma GCC diagnostic pop
+  #endif
+#endif 
+#ifdef __clang__
+  #pragma clang diagnostic pop
+#endif
+
 
 
 #endif  // CLHEP_MEMORY_H