lars/geant4
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Import Geant4 10.3.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-12-09 12:35:28 +01:00
parent 4ec577e5c4
commit a3452e42ac
3514 changed files with 210500 additions and 89628 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/global/management/include/G4LPhysicsFreeVector.hh
+16 -13
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4LPhysicsFreeVector.hh 74256 2013-10-02 14:24:02Z gcosmo $
// $Id: G4LPhysicsFreeVector.hh 98864 2016-08-15 11:53:26Z gcosmo $
//
//
// ------------------------------------------------------------------
@@ -49,27 +49,30 @@
#ifndef G4LPhysicsFreeVector_h
#define G4LPhysicsFreeVector_h 1
#include "G4PhysicsVector.hh"
#include "G4PhysicsFreeVector.hh"
class G4LPhysicsFreeVector : public G4PhysicsVector
class G4LPhysicsFreeVector : public G4PhysicsFreeVector
{
public: // with description
G4LPhysicsFreeVector();
G4LPhysicsFreeVector();
// the vector will be filled from external file using Retrieve method
G4LPhysicsFreeVector(size_t nbin, G4double binmin, G4double binmax);
G4LPhysicsFreeVector(size_t length, G4double emin=0.0, G4double emax=0.0);
// the vector with 'length' elements will be filled using PutValues method
// by default the vector is initialized with zeros
virtual ~G4LPhysicsFreeVector();
void PutValues(size_t binNumber, G4double binValue, G4double dataValue);
// G4PhysicsVector has PutValue() but it is inconvenient.
// Want to simultaneously fill the bin and data vectors.
void DumpValues();
virtual ~G4LPhysicsFreeVector();
inline void PutValues(size_t index, G4double e, G4double dataValue);
// user code is responsible for correct filling of all elements
};
#include "G4LPhysicsFreeVector.icc"
inline
void G4LPhysicsFreeVector::PutValues(size_t index, G4double e, G4double value)
{
G4PhysicsFreeVector::PutValue(index, e, value);
}
#endif
source/global/management/include/G4Physics2DVector.hh
+6 -10
View File
@@ -64,8 +64,10 @@ class G4Physics2DVector
public: // with description
G4Physics2DVector();
// Vector will be filled via Retrieve method
explicit G4Physics2DVector(size_t nx, size_t ny);
// constructors
// Vector will be filled via Put methods
G4Physics2DVector(const G4Physics2DVector&);
G4Physics2DVector& operator=(const G4Physics2DVector&);
@@ -123,13 +125,11 @@ public: // with description
inline void SetBicubicInterpolation(G4bool);
// Activate/deactivate bicubic interpolation.
void Store(std::ofstream& fOut);
void Store(std::ofstream& fOut) const;
G4bool Retrieve(std::ifstream& fIn);
// To store/retrieve persistent data to/from file streams.
inline void SetVerboseLevel(G4int value);
inline G4int GetVerboseLevel() const;
// Set/Get Verbose level
protected:
@@ -139,10 +139,6 @@ protected:
void CopyData(const G4Physics2DVector& vec);
// void ComputeValue(G4double x, G4double y) const;
// Main method to interpolate 2D vector
// by default by linear interpolation
G4double BicubicInterpolation(G4double x, G4double y,
size_t idx, size_t idy) const;
// Bicubic interpolation of 2D vector
@@ -162,8 +158,8 @@ private:
inline G4double DerivativeXY(size_t idx, size_t idy, G4double fac) const;
// computation of derivatives
G4int operator==(const G4Physics2DVector &right) const ;
G4int operator!=(const G4Physics2DVector &right) const ;
G4int operator==(const G4Physics2DVector &right) const = delete;
G4int operator!=(const G4Physics2DVector &right) const = delete;
G4PhysicsVectorType type; // The type of PhysicsVector (enumerator)
source/global/management/include/G4Physics2DVector.icc
-5
View File
@@ -134,11 +134,6 @@ inline void G4Physics2DVector::SetVerboseLevel(G4int val)
verboseLevel = val;
}
inline G4int G4Physics2DVector::GetVerboseLevel() const
{
return verboseLevel;
}
inline G4double
G4Physics2DVector::DerivativeX(size_t idx, size_t idy, G4double fac) const
{
source/global/management/include/G4PhysicsFreeVector.hh
+26 -22
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4PhysicsFreeVector.hh 74256 2013-10-02 14:24:02Z gcosmo $
// $Id: G4PhysicsFreeVector.hh 98864 2016-08-15 11:53:26Z gcosmo $
//
//
//--------------------------------------------------------------------
@@ -62,31 +62,35 @@
class G4PhysicsFreeVector : public G4PhysicsVector
{
public: // with description
public: // with description
G4PhysicsFreeVector();
explicit G4PhysicsFreeVector(size_t theNbin);
G4PhysicsFreeVector(const G4DataVector& binVector,
const G4DataVector& dataVector);
// Constructors:
// 'binVector' has the low edge value of each scale bin.
// 'dataVector' has the cross-section/energy-loss/etc at
// the energy/momenturm of the corresponding a bin of
// 'binVector'. 'binVector' and 'dataVector' need to have
// the same vector length.
G4PhysicsFreeVector();
// the vector will be filled from external file using Retrieve method
explicit G4PhysicsFreeVector(size_t length);
// the vector with 'length' elements will be filled using PutValue method
// by default the vector is initialized with zeros
G4PhysicsFreeVector(const G4DataVector& eVector,
const G4DataVector& dataVector);
// the vector is filled in this constructor
// 'eVector' and 'dataVector' need to have the same vector length
// 'eVector' assumed to be ordered
virtual ~G4PhysicsFreeVector();
// Destructor
void PutValue( size_t binNumber, G4double binValue,
G4double dataValue );
// To use this method to fill a PhysicsFreeVector, you have
// to Construct a PhysicsFreeVector of the size you need
// using G4PhysicsFreeVector(size_t theNbin). Also take
// note that you have to fill all bin values and data
// values before you the PhysicsFreeVector.
virtual ~G4PhysicsFreeVector();
inline void PutValue(size_t index, G4double energy, G4double dataValue);
// user code is responsible for correct filling of all elements
};
inline
void G4PhysicsFreeVector::PutValue(size_t index, G4double e, G4double value)
{
if(index >= numberOfNodes) { PrintPutValueError(index); }
binVector[index] = e;
dataVector[index] = value;
if(index == 0) { edgeMin = e; }
else if( numberOfNodes - 1 == index) { edgeMax = e; }
}
#endif
source/global/management/include/G4PhysicsLinearVector.hh
+13 -15
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4PhysicsLinearVector.hh 74256 2013-10-02 14:24:02Z gcosmo $
// $Id: G4PhysicsLinearVector.hh 98864 2016-08-15 11:53:26Z gcosmo $
//
//
//--------------------------------------------------------------------
@@ -59,25 +59,23 @@
class G4PhysicsLinearVector : public G4PhysicsVector
{
public:
public:// with description
G4PhysicsLinearVector();
explicit G4PhysicsLinearVector(size_t theNbin);
// Constructors
G4PhysicsLinearVector();
// the vector will be filled from external file using Retrieve method
public: // with description
G4PhysicsLinearVector(G4double theEmin, G4double theEmax, size_t theNbin);
// Energy vector will be computed and filled at construction,
// number of elements 'theNbin+1'. Use PutValue() to fill the data vector
G4PhysicsLinearVector(G4double theEmin, G4double theEmax, size_t theNbin);
// Constructor
virtual ~G4PhysicsLinearVector();
virtual ~G4PhysicsLinearVector();
// Destructor
virtual G4bool Retrieve(std::ifstream& fIn, G4bool ascii) final;
// To retrieve persistent data from a file stream.
virtual G4bool Retrieve(std::ifstream& fIn, G4bool ascii);
virtual void ScaleVector(G4double factorE, G4double factorV);
// Scale all values of the vector and second derivatives
// by factorV, energies by vectorE.
virtual void ScaleVector(G4double factorE, G4double factorV) final;
// Scale all values of the vector and second derivatives
// by factorV, energies - by vectorE.
};
source/global/management/include/G4PhysicsLnVector.hh
+3 -28
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4PhysicsLnVector.hh 74256 2013-10-02 14:24:02Z gcosmo $
// $Id: G4PhysicsLnVector.hh 98864 2016-08-15 11:53:26Z gcosmo $
//
//
//--------------------------------------------------------------------
@@ -50,33 +50,8 @@
#ifndef G4PhysicsLnVector_h
#define G4PhysicsLnVector_h 1
#include "globals.hh"
#include "G4PhysicsVector.hh"
#include "G4PhysicsLogVector.hh"
class G4PhysicsLnVector : public G4PhysicsVector
{
public:
G4PhysicsLnVector();
explicit G4PhysicsLnVector(size_t theNbin);
// Constructors
public: // with description
G4PhysicsLnVector(G4double theEmin, G4double theEmax, size_t theNbin);
// Because of logarithmic scale, note that 'theEmin' has to be
// greater than zero. No protection exists against this error.
virtual ~G4PhysicsLnVector();
// Destructor.
virtual G4bool Retrieve(std::ifstream& fIn, G4bool ascii);
// To retrieve persistent data from file stream.
virtual void ScaleVector(G4double factorE, G4double factorV);
// Scale all values of the vector and second derivatives
// by factorV, energies by vectorE.
};
typedef G4PhysicsLogVector G4PhysicsLnVector;
#endif
source/global/management/include/G4PhysicsLogVector.hh
+16 -18
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4PhysicsLogVector.hh 74256 2013-10-02 14:24:02Z gcosmo $
// $Id: G4PhysicsLogVector.hh 98864 2016-08-15 11:53:26Z gcosmo $
//
//
//--------------------------------------------------------------------
@@ -59,28 +59,26 @@
class G4PhysicsLogVector : public G4PhysicsVector
{
public:
public:// with description
G4PhysicsLogVector();
explicit G4PhysicsLogVector(size_t theNbin);
// Constructors
G4PhysicsLogVector();
// the vector will be filled from external file using Retrieve method
public: // with description
G4PhysicsLogVector(G4double theEmin, G4double theEmax, size_t theNbin);
// Because of logarithmic scale, note that 'theEmin' has to be
G4PhysicsLogVector(G4double theEmin, G4double theEmax, size_t theNbin);
// Energy vector will be computed and filled at construction,
// number of nodes 'theNbin+1'. Use PutValue() to fill the data vector
//
// Because of logarithmic scale, 'theEmin' has to be
// greater than zero. No protection exists against this error.
virtual ~G4PhysicsLogVector();
// Destructor
virtual G4bool Retrieve(std::ifstream& fIn, G4bool ascii);
// To retrieve persistent data from file stream.
virtual ~G4PhysicsLogVector();
virtual void ScaleVector(G4double factorE, G4double factorV);
// Scale all values of the vector and second derivatives
// by factorV, energies by vectorE.
virtual G4bool Retrieve(std::ifstream& fIn, G4bool ascii) final;
// To retrieve persistent data from a file stream.
virtual void ScaleVector(G4double factorE, G4double factorV) final;
// Scale all values of the vector and second derivatives
// by factorV, energies - by vectorE.
};
source/global/management/include/G4PhysicsOrderedFreeVector.hh
+32 -6
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4PhysicsOrderedFreeVector.hh 93409 2015-10-21 13:26:27Z gcosmo $
// $Id: G4PhysicsOrderedFreeVector.hh 98864 2016-08-15 11:53:26Z gcosmo $
//
////////////////////////////////////////////////////////////////////////
// PhysicsOrderedFreeVector Class Definition
@@ -74,12 +74,18 @@ class G4PhysicsOrderedFreeVector : public G4PhysicsVector
////////////////////////////////
G4PhysicsOrderedFreeVector();
// the vector will be filled from exteran file using Retrieve
// or InsertValues methods
G4PhysicsOrderedFreeVector(G4double* Energies,
G4double* Values,
size_t VectorLength);
// the vector is filled in this constructor
// 'Energies' and 'Values' need to have the same vector length
// 'Energies' assumed to be ordered
virtual ~G4PhysicsOrderedFreeVector();
////////////
// Methods
////////////
@@ -96,8 +102,6 @@ class G4PhysicsOrderedFreeVector : public G4PhysicsVector
inline G4double GetMinLowEdgeEnergy();
void DumpValues();
private:
size_t FindValueBinLocation(G4double aValue);
@@ -105,7 +109,29 @@ class G4PhysicsOrderedFreeVector : public G4PhysicsVector
G4double LinearInterpolationOfEnergy(G4double aValue, size_t theLocBin);
};
#include "G4PhysicsOrderedFreeVector.icc"
inline
G4double G4PhysicsOrderedFreeVector::GetMaxValue()
{
return dataVector.back();
}
inline
G4double G4PhysicsOrderedFreeVector::GetMinValue()
{
return dataVector.front();
}
inline
G4double G4PhysicsOrderedFreeVector::GetMaxLowEdgeEnergy()
{
return binVector.back();
}
inline
G4double G4PhysicsOrderedFreeVector::GetMinLowEdgeEnergy()
{
return binVector.front();
}
#endif /* G4PhysicsOrderedFreeVector_h */
source/global/management/include/G4PhysicsTable.hh
+3 -3
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4PhysicsTable.hh 67970 2013-03-13 10:10:06Z gcosmo $
// $Id: G4PhysicsTable.hh 98864 2016-08-15 11:53:26Z gcosmo $
//
//
// ------------------------------------------------------------
@@ -133,8 +133,8 @@ class G4PhysicsTable : public std::vector<G4PhysicsVector*>
private:
G4PhysicsTable(const G4PhysicsTable&);
G4PhysicsTable& operator=(const G4PhysicsTable&);
G4PhysicsTable(const G4PhysicsTable&) = delete;
G4PhysicsTable& operator=(const G4PhysicsTable&) = delete;
// Private copy constructor and assignment operator.
};
source/global/management/include/G4PhysicsTable.icc
+2 -2
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4PhysicsTable.icc 70961 2013-06-07 15:17:02Z gcosmo $
// $Id: G4PhysicsTable.icc 98864 2016-08-15 11:53:26Z gcosmo $
//
//
// ------------------------------------------------------------
@@ -38,7 +38,7 @@
inline
void G4PhysicsTable::clearAndDestroy()
{
G4PhysicsVector* a=0;
G4PhysicsVector* a=nullptr;
while (size()>0)
{
a = G4PhysCollection::back();
source/global/management/include/G4PhysicsVector.hh
+28 -27
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4PhysicsVector.hh 93409 2015-10-21 13:26:27Z gcosmo $
// $Id: G4PhysicsVector.hh 98864 2016-08-15 11:53:26Z gcosmo $
//
//
//---------------------------------------------------------------
@@ -75,20 +75,16 @@ typedef std::vector<G4double> G4PVDataVector;
class G4PhysicsVector
{
public: // with description
public:// with description
G4PhysicsVector(G4bool spline = false);
// constructor
// This class is an abstract class with pure virtual method of
// virtual size_t FindBinLocation(G4double theEnergy) const
// So, default constructor is not supposed to be invoked explicitly
explicit G4PhysicsVector(G4bool spline = false);
// default constructor - vector will be filled via Retrieve() method
G4PhysicsVector(const G4PhysicsVector&);
G4PhysicsVector& operator=(const G4PhysicsVector&);
// Copy constructor and assignment operator.
virtual ~G4PhysicsVector();
// destructor
G4double Value(G4double theEnergy, size_t& lastidx) const;
// Get the cross-section/energy-loss value corresponding to the
@@ -100,7 +96,8 @@ class G4PhysicsVector
// Get the cross-section/energy-loss value corresponding to the
// given energy. An appropriate interpolation is used to calculate
// the value. This method is kept for backward compatibility reason,
// it should be used is bin location cannot be kept thread safe
// it should be used instead of the previous method if bin location
// cannot be kept thread safe
inline G4double GetValue(G4double theEnergy, G4bool& isOutRange) const;
// Obsolete method to get value, isOutRange is not used anymore.
@@ -109,22 +106,21 @@ class G4PhysicsVector
G4int operator==(const G4PhysicsVector &right) const ;
G4int operator!=(const G4PhysicsVector &right) const ;
inline G4double operator[](const size_t binNumber) const ;
// Returns simply the value in the bin specified by 'binNumber'
// of the dataVector. The boundary check will not be done.
inline G4double operator[](const size_t index) const ;
// Returns the value for the specified index of the dataVector
// The boundary check will not be done.
inline G4double operator()(const size_t binNumber) const ;
// Returns simply the value in the bin specified by 'binNumber'
// of the dataVector. The boundary check will not be Done.
inline G4double operator()(const size_t index) const ;
// Returns the value for the specified index of the dataVector
// The boundary check will not be done.
inline void PutValue(size_t index, G4double theValue);
// Put 'theValue' into the bin specified by 'binNumber'.
// Put 'theValue' into the dataVector specified by 'index'.
// Take note that the 'index' starts from '0'.
// To fill the vector, you have beforehand to construct a vector
// by the constructor with Emin, Emax, Nbin. 'theValue' should
// be the crosssection/energyloss value corresponding to the
// energy of the index. You can get this energy by the next method
// or by the old method GetLowEdgeEnergy().
// energy of the index.
virtual void ScaleVector(G4double factorE, G4double factorV);
// Scale all values of the vector and second derivatives
@@ -133,9 +129,10 @@ class G4PhysicsVector
// convert values into Geant4 units
inline G4double Energy(size_t index) const;
// Returns simply the value in the energy specified by 'index'
// Returns the value in the energy specified by 'index'
// of the energy vector. The boundary check will not be done.
// Use this function when you fill physis vector by PutValue().
// Use this function when compute cross section or dEdx
// before filling the vector by PutValue(..).
inline G4double GetMaxEnergy() const;
// Returns the energy of the last point of the vector
@@ -144,7 +141,6 @@ class G4PhysicsVector
// Obsolete method
// Get the energy value at the low edge of the specified bin.
// Take note that the 'binNumber' starts from '0'.
// This value should be defined before the call.
// The boundary check will not be done.
inline size_t GetVectorLength() const;
@@ -156,8 +152,10 @@ class G4PhysicsVector
// idx is suggested bin number from user code
void FillSecondDerivatives();
// Initialise second derivatives for spline keeping
// 3d derivative continues - default algorithm
// Initialise second derivatives for spline keeping
// 3d derivative continues - default algorithm
// Warning: this method should be called when the vector
// is already filled
void ComputeSecDerivatives();
// Initialise second derivatives for spline using algorithm
@@ -186,15 +184,15 @@ class G4PhysicsVector
inline void SetSpline(G4bool);
// Activate/deactivate Spline interpolation.
virtual G4bool Store(std::ofstream& fOut, G4bool ascii=false);
G4bool Store(std::ofstream& fOut, G4bool ascii=false) const;
virtual G4bool Retrieve(std::ifstream& fIn, G4bool ascii=false);
// To store/retrieve persistent data to/from file streams.
friend std::ostream& operator<<(std::ostream&, const G4PhysicsVector&);
void DumpValues(G4double unitE=1.0, G4double unitV=1.0) const;
// print vector
inline void SetVerboseLevel(G4int value);
inline G4int GetVerboseLevel(G4int);
// Set/Get Verbose level
protected:
@@ -202,6 +200,8 @@ class G4PhysicsVector
void CopyData(const G4PhysicsVector& vec);
// Internal methods for allowing copy of objects
void PrintPutValueError(size_t index);
protected:
G4PhysicsVectorType type; // The type of PhysicsVector (enumerator)
@@ -227,7 +227,8 @@ class G4PhysicsVector
inline G4double Interpolation(size_t idx, G4double energy) const;
inline size_t FindBinLocation(G4double theEnergy) const;
// Find the bin# in which theEnergy belongs
// find low edge index of a bin for given energy
// min value 0, max value VectorLength-1
G4bool useSpline;
source/global/management/include/G4PhysicsVector.icc
+24 -29
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4PhysicsVector.icc 93409 2015-10-21 13:26:27Z gcosmo $
// $Id: G4PhysicsVector.icc 98864 2016-08-15 11:53:26Z gcosmo $
//
//
//---------------------------------------------------------------
@@ -42,25 +42,25 @@
//---------------------------------------------------------------
inline
G4double G4PhysicsVector::operator[](const size_t binNumber) const
G4double G4PhysicsVector::operator[](const size_t index) const
{
return dataVector[binNumber];
return dataVector[index];
}
//---------------------------------------------------------------
inline
G4double G4PhysicsVector::operator()(const size_t binNumber) const
G4double G4PhysicsVector::operator()(const size_t index) const
{
return dataVector[binNumber];
return dataVector[index];
}
//---------------------------------------------------------------
inline
G4double G4PhysicsVector::Energy(const size_t binNumber) const
G4double G4PhysicsVector::Energy(const size_t index) const
{
return binVector[binNumber];
return binVector[index];
}
//---------------------------------------------------------------
@@ -79,15 +79,6 @@ inline
return numberOfNodes;
}
//---------------------------------------------------------------
inline
G4double G4PhysicsVector::GetValue(G4double theEnergy, G4bool&) const
{
size_t idx=0;
return Value(theEnergy, idx);
}
//------------------------------------------------
inline
@@ -137,18 +128,16 @@ inline
inline
G4double G4PhysicsVector::Interpolation(size_t idx, G4double e) const
{
G4double res;
if(useSpline) { res = SplineInterpolation(idx, e); }
else { res = LinearInterpolation(idx, e); }
return res;
return useSpline ? SplineInterpolation(idx, e) : LinearInterpolation(idx, e);
}
//---------------------------------------------------------------
inline
void G4PhysicsVector::PutValue(size_t binNumber, G4double theValue)
void G4PhysicsVector::PutValue(size_t index, G4double theValue)
{
dataVector[binNumber] = theValue;
if(index >= numberOfNodes) { PrintPutValueError(index); }
dataVector[index] = theValue;
}
//---------------------------------------------------------------
@@ -156,10 +145,7 @@ inline
inline
G4bool G4PhysicsVector::IsFilledVectorExist() const
{
G4bool status=false;
if(numberOfNodes > 0) { status=true; }
return status;
return (numberOfNodes > 0) ? true : false;
}
//---------------------------------------------------------------
@@ -195,13 +181,13 @@ void G4PhysicsVector::SetVerboseLevel(G4int value)
}
//---------------------------------------------------------------
/*
inline
G4int G4PhysicsVector::GetVerboseLevel(G4int)
G4int G4PhysicsVector::GetVerboseLevel() const
{
return verboseLevel;
}
*/
//---------------------------------------------------------------
inline
@@ -250,3 +236,12 @@ inline
}
//---------------------------------------------------------------
inline
G4double G4PhysicsVector::GetValue(G4double theEnergy, G4bool&) const
{
size_t idx=0;
return Value(theEnergy, idx);
}
//---------------------------------------------------------------
source/global/management/include/G4TWorkspacePool.hh
+2 -1
View File
@@ -42,6 +42,7 @@
#define G4TWORKSPACEPOOL_HH
#include "tls.hh"
#include "globals.hh"
template<class T>
class G4TWorkspacePool
@@ -80,7 +81,7 @@ private:
};
#include "globals.hh"
template<typename T> G4ThreadLocal T* G4TWorkspacePool<T>::fMyWorkspace=0;
template<class T>
T* G4TWorkspacePool<T>::CreateWorkspace()
source/global/management/include/G4Threading.hh
+3
View File
@@ -210,6 +210,9 @@ namespace G4Threading
G4bool G4SetPinAffinity( G4int idx , G4Thread& at);
void SetMultithreadedApplication(G4bool value);
G4bool IsMultithreadedApplication();
int WorkerThreadLeavesPool();
int WorkerThreadJoinsPool();
G4int GetNumberOfRunningWorkerThreads();
}
#endif //G4Threading_hh
source/global/management/include/G4UnitsTable.hh
+27 -2
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4UnitsTable.hh 67970 2013-03-13 10:10:06Z gcosmo $
// $Id: G4UnitsTable.hh 98932 2016-08-18 13:26:49Z gcosmo $
//
//
// -----------------------------------------------------------------
@@ -57,13 +57,29 @@
#include "G4ThreeVector.hh"
class G4UnitsCategory;
class G4UnitDefinition;
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
#ifdef G4MULTITHREADED
class G4UnitsTable : public std::vector<G4UnitsCategory*>
{
public:
G4UnitsTable();
~G4UnitsTable();
public:
void Synchronize();
G4bool Contains(const G4UnitDefinition*,const G4String&);
};
#else
typedef std::vector<G4UnitsCategory*> G4UnitsTable;
#endif
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
class G4UnitDefinition
{
public: // with description
public: // with description
G4UnitDefinition(const G4String& name, const G4String& symbol,
const G4String& category, G4double value);
@@ -88,6 +104,7 @@ public: // with description
static G4UnitsTable& GetUnitsTable();
static G4bool IsUnitDefined(const G4String&);
static G4double GetValueOf (const G4String&);
static G4String GetCategory(const G4String&);
@@ -103,8 +120,16 @@ public: // with description
G4double Value; // value in the internal system of units
static G4ThreadLocal G4UnitsTable *pUnitsTable; // table of Units
static G4ThreadLocal G4bool unitsTableDestroyed;
size_t CategoryIndex; // category index of this unit
#ifdef G4MULTITHREADED
static G4UnitsTable *pUnitsTableShadow; // shadow of table of Units
public:
inline static G4UnitsTable& GetUnitsTableShadow()
{return *pUnitsTableShadow;}
#endif
};
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
source/global/management/include/G4Version.hh
+5 -5
View File
@@ -24,7 +24,7 @@
// ********************************************************************
//
//
// $Id: G4Version.hh 97990 2016-06-30 10:04:56Z gcosmo $
// $Id: G4Version.hh 101827 2016-12-01 10:16:01Z gcosmo $
// GEANT4 tag $Name:$
//
// Version information
@@ -50,7 +50,7 @@
#endif
#ifndef G4VERSION_TAG
#define G4VERSION_TAG "$Name: geant4-10-03-beta-01 $"
#define G4VERSION_TAG "$Name: geant4-10-03 $"
#endif
// as variables
@@ -58,10 +58,10 @@
#include "G4String.hh"
#ifdef G4MULTITHREADED
static const G4String G4Version = "$Name: geant4-10-03-beta-01 [MT]$";
static const G4String G4Version = "$Name: geant4-10-03 [MT]$";
#else
static const G4String G4Version = "$Name: geant4-10-03-beta-01 $";
static const G4String G4Version = "$Name: geant4-10-03 $";
#endif
static const G4String G4Date = "(30-June-2016)";
static const G4String G4Date = "(9-December-2016)";
#endif