Ignore:
Timestamp:
Nov 19, 2009, 3:40:00 PM (15 years ago)
Author:
garnier
Message:

CVS update

Location:
trunk/source/global/management/include
Files:
12 edited

Legend:

Unmodified
Added
Removed

  • trunk/source/global/management/include/G4Allocator.hh

    r1058 r1193  
    2525//
    2626//
    27 // $Id: G4Allocator.hh,v 1.18 2006/06/29 19:01:16 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4Allocator.hh,v 1.19 2009/10/29 16:01:28 gcosmo Exp $
     28// GEANT4 tag $Name: global-V09-02-10 $
    2929//
    3030//
    … …  
    9999      // Returns the address of values
    100100
    101     pointer allocate(size_type n, void* hint = 0)
     101    pointer allocate(size_type n, void* = 0)
    102102    {
    103103      // Allocates space for n elements of type Type, but does not initialise

  • trunk/source/global/management/include/G4ErrorPropagatorData.hh

    r1058 r1193  
    2525//
    2626//
    27 // $Id: G4ErrorPropagatorData.hh,v 1.3 2007/06/08 10:33:47 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4ErrorPropagatorData.hh,v 1.5 2009/05/19 13:31:47 gcosmo Exp $
     28// GEANT4 tag $Name: global-V09-02-10 $
    2929//
    3030//
    … …  
    3838//   and manager verbosity for the error propagation classes.
    3939
    40 // History:
    4140// - Created. P.Arce, 2004.
    4241// --------------------------------------------------------------------
    … …  
    5655                    G4ErrorState_TargetCloserThanBoundary,
    5756                    G4ErrorState_StoppedAtTarget };
     57
     58enum G4ErrorStage  { G4ErrorStage_Inflation = 1,
     59                     G4ErrorStage_Deflation };
     60
    5861class G4ErrorTarget;
    5962
    … …  
    7275  G4ErrorState GetState() const;
    7376  void SetState( G4ErrorState sta );
     77
     78  G4ErrorStage GetStage() const;
     79  void SetStage( G4ErrorStage sta );
    7480
    7581  const G4ErrorTarget* GetTarget( G4bool mustExist = 0) const;
    … …  
    94100  G4ErrorState theState;
    95101
     102  G4ErrorStage theStage;
     103
    96104  G4ErrorTarget* theTarget;
    97105

  • trunk/source/global/management/include/G4ErrorPropagatorData.icc

    r1058 r1193  
    2525//
    2626//
    27 // $Id: G4ErrorPropagatorData.icc,v 1.4 2007/06/08 10:33:47 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4ErrorPropagatorData.icc,v 1.5 2009/05/14 13:46:40 arce Exp $
     28// GEANT4 tag $Name: global-V09-02-10 $
    2929//
    3030//
    … …  
    5959
    6060inline
     61void G4ErrorPropagatorData::SetStage( G4ErrorStage sta )
     62{
     63  theStage = sta;
     64}
     65
     66inline
     67G4ErrorStage G4ErrorPropagatorData::GetStage() const
     68{
     69  return theStage;
     70}
     71
     72inline
    6173const G4ErrorTarget* G4ErrorPropagatorData::GetTarget( G4bool mustExist ) const
    6274{

  • trunk/source/global/management/include/G4LPhysicsFreeVector.icc

    r1058 r1193  
    2525//
    2626//
    27 // $Id: G4LPhysicsFreeVector.icc,v 1.13 2008/09/22 08:26:33 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4LPhysicsFreeVector.icc,v 1.14 2009/06/25 10:05:26 vnivanch Exp $
     28// GEANT4 tag $Name: global-V09-02-10 $
    2929//
    3030//
    … …  
    5252   if(binNumber == 0)
    5353     { edgeMin = binValue; }
    54    else if( numberOfBin - 1 == binNumber)
     54   else if( numberOfNodes - 1 == binNumber)
    5555     { edgeMax = binValue; }
    5656}
    … …  
    8484{
    8585   G4int n1 = 0;
    86    G4int n2 = numberOfBin/2;
    87    G4int n3 = numberOfBin - 1;
     86   G4int n2 = numberOfNodes/2;
     87   G4int n3 = numberOfNodes - 1;
    8888   while (n1 != n3 - 1)
    8989   {

  • trunk/source/global/management/include/G4PhysicsFreeVector.hh

    r1058 r1193  
    2525//
    2626//
    27 // $Id: G4PhysicsFreeVector.hh,v 1.12 2008/09/22 14:49:57 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4PhysicsFreeVector.hh,v 1.13 2009/06/25 10:05:26 vnivanch Exp $
     28// GEANT4 tag $Name: global-V09-02-10 $
    2929//
    3030//
    … …  
    108108
    109109  size_t lowerBound = 0;
    110   size_t upperBound = numberOfBin-1;
     110  size_t upperBound = numberOfNodes-2;
    111111
    112112  while (lowerBound <= upperBound)

  • trunk/source/global/management/include/G4PhysicsOrderedFreeVector.hh

    r1058 r1193  
    2525//
    2626//
    27 // $Id: G4PhysicsOrderedFreeVector.hh,v 1.11 2008/09/22 14:49:57 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4PhysicsOrderedFreeVector.hh,v 1.12 2009/06/25 10:05:26 vnivanch Exp $
     28// GEANT4 tag $Name: global-V09-02-10 $
    2929//
    3030////////////////////////////////////////////////////////////////////////
    … …  
    8686        ////////////
    8787
    88         void InsertValues(G4double energy, G4double value);
     88        void InsertValues(G4double energy, G4double value);
    8989
    9090        G4double GetLowEdgeEnergy(size_t binNumber) const;

  • trunk/source/global/management/include/G4PhysicsOrderedFreeVector.icc

    r1058 r1193  
    2525//
    2626//
    27 // $Id: G4PhysicsOrderedFreeVector.icc,v 1.8 2006/06/29 19:02:31 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4PhysicsOrderedFreeVector.icc,v 1.9 2009/06/25 10:05:26 vnivanch Exp $
     28// GEANT4 tag $Name: global-V09-02-10 $
    2929//
    3030////////////////////////////////////////////////////////////////////////
    … …  
    7373void G4PhysicsOrderedFreeVector::DumpValues()
    7474{
    75    for (size_t i = 0; i < numberOfBin; i++)
     75   for (size_t i = 0; i < numberOfNodes; i++)
    7676   {
    7777      G4cout << binVector[i] << "\t" << dataVector[i] << G4endl;
    … …  
    8383{
    8484   G4int n1 = 0;
    85    G4int n2 = numberOfBin/2;
    86    G4int n3 = numberOfBin - 1;
     85   G4int n2 = numberOfNodes/2;
     86   G4int n3 = numberOfNodes - 1;
    8787   while (n1 != n3 - 1)
    8888   {

  • trunk/source/global/management/include/G4PhysicsVector.hh

    r1058 r1193  
    2525//
    2626//
    27 // $Id: G4PhysicsVector.hh,v 1.18 2008/09/22 08:26:33 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4PhysicsVector.hh,v 1.25 2009/11/04 11:32:43 vnivanch Exp $
     28// GEANT4 tag $Name: global-V09-02-10 $
    2929//
    3030//
    … …  
    5151//    09 Mar. 2001, H.Kurashige : Added G4PhysicsVectorType & Store/Retrieve()
    5252//    02 Apr. 2008, A.Bagulya : Added SplineInterpolation() and SetSpline()
     53//    11 May  2009, V.Ivanchenko : Added ComputeSecondDerivatives
     54//    19 Jun. 2009, V.Ivanchenko : Removed hidden bin
    5355//
    5456//---------------------------------------------------------------
    … …  
    8486         // destructor
    8587
    86     inline G4double GetValue(G4double theEnergy, G4bool& isOutRange);
     88    inline G4double Value(G4double theEnergy);
    8789         // Get the cross-section/energy-loss value corresponding to the
    8890         // given energy. An appropriate interpolation is used to calculate
    8991         // the value.
    90          // [Note] isOutRange is not used anymore. This argument is kept
    91          //        for the compatibility reason.
     92
     93    inline G4double GetValue(G4double theEnergy, G4bool& isOutRange);
     94         // Obolete method to get value, isOutRange is not used anymore.
     95         // This method is kept for the compatibility reason.
    9296
    9397    G4int operator==(const G4PhysicsVector &right) const ;
    9498    G4int operator!=(const G4PhysicsVector &right) const ;
     99
    95100    inline G4double operator[](const size_t binNumber) const ;
    96101         // Returns simply the value in the bin specified by 'binNumber'
    97          // of the dataVector. The boundary check will be Done. If you
    98          // don't want this check, use the operator ().
     102         // of the dataVector. The boundary check will not be done.
     103
    99104    inline G4double operator()(const size_t binNumber) const ;
    100105         // Returns simply the value in the bin specified by 'binNumber'
    101          // of the dataVector. The boundary check will not be Done. If
    102          // you want this check, use the operator [].
    103 
    104     inline void PutValue(size_t binNumber, G4double theValue);
     106         // of the dataVector. The boundary check will not be Done.
     107
     108    inline void PutValue(size_t index, G4double theValue);
    105109         // Put 'theValue' into the bin specified by 'binNumber'.
    106          // Take note that the 'binNumber' starts from '0'.
    107          // To fill the vector, you have beforehand to Construct a vector
     110         // Take note that the 'index' starts from '0'.
     111         // To fill the vector, you have beforehand to construct a vector
    108112         // by the constructor with Emin, Emax, Nbin. 'theValue' should
    109          // be the crosssection/energyloss value corresponding to the low
    110          // edge energy of the bin specified by 'binNumber'. You can get
    111          // the low edge energy value of a bin by GetLowEdgeEnergy().
     113         // be the crosssection/energyloss value corresponding to the 
     114         // energy of the index. You can get this energy by the next method
     115         // or by the old method GetLowEdgeEnergy().
     116
     117    void ScaleVector(G4double factorE, G4double factorV);
     118         // Scale all values of the vector and second derivatives
     119         // by factorV, energies by vectorE. This method may be applied
     120         // for example after Retrieve a vector from an external file to
     121         // convert values into Geant4 units
     122
     123    inline G4double Energy(size_t index) const;
     124         // Returns simply the value in the energy specified by 'index'
     125         // of the energy vector. The boundary check will not be done.
     126         // Use this function when you fill physis vector by PutValue().
     127
    112128    virtual G4double GetLowEdgeEnergy(size_t binNumber) const;
     129         // Obsolete method
    113130         // Get the energy value at the low edge of the specified bin.
    114131         // Take note that the 'binNumber' starts from '0'.
    115          // This value is defined when a physics vector is constructed
    116          // by a constructor of a derived class. Use this function
    117          // when you fill physis vector by PutValue().
     132         // This value should be defined before the call.
     133         // The boundary check will not be done.
     134
    118135    inline size_t GetVectorLength() const;
    119136         // Get the toal length (bin number) of the vector.
     137
     138    void FillSecondDerivatives();
     139        // Initialise second derivatives for spline keeping
     140        // 3d derivative continues - default algorithm
     141
     142    void ComputeSecDerivatives();
     143         // Initialise second derivatives for spline using algorithm
     144         // which garantee only 1st derivative continues
     145         // Warning: this method should be called when the vector
     146         // is already filled
     147
     148    void ComputeSecondDerivatives(G4double firstPointDerivative,
     149                                  G4double endPointDerivative);
     150         // Initialise second derivatives for spline using
     151         // user defined 1st derivatives at edge points
     152         // Warning: this method should be called when the vector
     153         // is already filled
     154
    120155    inline G4bool IsFilledVectorExist() const;
    121156         // Is non-empty physics vector already exist?
    … …  
    124159         // Put a comment to the G4PhysicsVector. This may help to check
    125160         // whether your are accessing to the one you want.
     161
    126162    inline const G4String& GetComment() const;
    127163         // Retrieve the comment of the G4PhysicsVector.
    … …  
    154190    G4PhysicsVectorType type;   // The type of PhysicsVector (enumerator)
    155191
    156     G4double edgeMin;           // Lower edge value of the lowest bin
    157     G4double edgeMax;           // Lower edge value of the highest bin
    158     size_t numberOfBin;
     192    G4double edgeMin;           // Energy of first point
     193    G4double edgeMax;           // Energy of the last point
     194
     195    size_t numberOfNodes;
    159196
    160197    G4double lastEnergy;        // Cache the last input value
    … …  
    163200
    164201    G4PVDataVector dataVector;    // Vector to keep the crossection/energyloss
    165     G4PVDataVector binVector;     // Vector to keep the low edge value of bin
     202    G4PVDataVector binVector;     // Vector to keep energy
     203    G4PVDataVector secDerivative; // Vector to keep second derivatives
    166204
    167205  private:
     206
     207    G4bool SplinePossible();
    168208
    169209    inline G4double LinearInterpolation();
    … …  
    174214    inline void Interpolation();
    175215
    176     void FillSecondDerivatives();
    177       // Initialise second derivatives for spline
    178 
    179     G4double*  secDerivative;
    180 
    181216    G4String   comment;
    182217    G4bool     useSpline;

  • trunk/source/global/management/include/G4PhysicsVector.icc

    r1058 r1193  
    2525//
    2626//
    27 // $Id: G4PhysicsVector.icc,v 1.17 2008/09/22 08:26:33 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4PhysicsVector.icc,v 1.23 2009/11/18 11:42:03 vnivanch Exp $
     28// GEANT4 tag $Name: global-V09-02-10 $
    2929//
    3030//
    … …  
    5959//---------------------------------------------------------------
    6060
     61inline
     62 G4double G4PhysicsVector::Energy(const size_t binNumber) const
     63{
     64  return binVector[binNumber];
     65}
     66
     67//---------------------------------------------------------------
     68
    6169inline
    6270 size_t G4PhysicsVector::GetVectorLength() const
    6371{
    64   return numberOfBin;
     72  return numberOfNodes;
    6573}
    6674
    … …  
    94102  // numberOfBin-1.
    95103
    96   if( !secDerivative ) { FillSecondDerivatives(); }
     104  if(0 == secDerivative.size() ) { FillSecondDerivatives(); }
    97105
    98106  // check bin value
    99   G4double delta = binVector[lastBin+1] - binVector[lastBin];
    100 
    101   G4double a = (binVector[lastBin+1] - lastEnergy)/delta;
    102   G4double b = (lastEnergy - binVector[lastBin])/delta;
     107  G4double x1 = binVector[lastBin];
     108  G4double x2 = binVector[lastBin+1];
     109  G4double delta = x2 - x1;
     110
     111  G4double a = (x2 - lastEnergy)/delta;
     112  G4double b = (lastEnergy - x1)/delta;
    103113   
    104114  // Final evaluation of cubic spline polynomial for return   
    … …  
    107117
    108118  G4double res = a*y1 + b*y2 +
    109         ((a*a*a - a)*secDerivative[lastBin] +
    110          (b*b*b - b)*secDerivative[lastBin+1])*delta*delta/6.0  ;
     119        ( (a*a*a - a)*secDerivative[lastBin] +
     120          (b*b*b - b)*secDerivative[lastBin+1] )*delta*delta/6.0;
    111121
    112122  return res;
    … …  
    117127inline
    118128 G4double G4PhysicsVector::GetValue(G4double theEnergy, G4bool&)
     129{
     130  return Value(theEnergy);
     131}
     132
     133//---------------------------------------------------------------
     134
     135inline
     136 G4double G4PhysicsVector::Value(G4double theEnergy)
    119137{
    120138  // Use cache for speed up - check if the value 'theEnergy' is same as the
    … …  
    134152     lastValue  = dataVector[0];
    135153
    136   } else if(theEnergy < lastEnergy && theEnergy >= binVector[lastBin-1]) {
    137      lastBin--;
    138      lastEnergy = theEnergy;
    139      Interpolation();
    140 
    141154  } else if( theEnergy >= edgeMax ){
    142      lastBin = numberOfBin-1;
     155     lastBin = numberOfNodes-2;
    143156     lastEnergy = edgeMax;
    144      lastValue  = dataVector[lastBin];
     157     lastValue  = dataVector[numberOfNodes-1];
    145158
    146159  } else {
    147160     lastBin = FindBinLocation(theEnergy);
     161     if(lastBin >= numberOfNodes-1) {lastBin = numberOfNodes-2;}
    148162     lastEnergy = theEnergy;
    149163     Interpolation();
    … …  
    167181{
    168182  dataVector[binNumber] = theValue;
    169 
    170   // Fill the bin which is hidden to user with theValue. This is to
    171   // handle correctly when Energy=theEmax in getValue.
    172 
    173   if(binNumber==numberOfBin-1) { dataVector[binNumber+1] = theValue; }
    174183}
    175184
    … …  
    181190  G4bool status=false;
    182191
    183   if(numberOfBin > 0) { status=true; }
     192  if(numberOfNodes > 0) { status=true; }
    184193  return status;
    185194}

  • trunk/source/global/management/include/G4String.hh

    r1058 r1193  
    2525//
    2626//
    27 // $Id: G4String.hh,v 1.10 2008/12/08 14:16:05 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4String.hh,v 1.15 2009/08/10 10:18:09 gcosmo Exp $
     28// GEANT4 tag $Name: global-V09-02-10 $
    2929//
    3030//
    … …  
    7878  inline G4int operator!() const;
    7979
    80   inline G4bool operator==(G4String) const;
     80  inline G4bool operator==(const G4String&) const;
    8181  inline G4bool operator==(const char*) const;
    82   inline G4bool operator!=(G4String) const;
     82  inline G4bool operator!=(const G4String&) const;
    8383  inline G4bool operator!=(const char*) const;
    8484
    … …  
    138138  inline G4bool operator!=(const char*) const;
    139139
    140   //inline G4String operator () (unsigned int, unsigned int);
    141140  inline operator const char*() const;
    142141  inline G4SubString operator()(str_size, str_size);
    … …  
    160159  inline G4int last(char) const;
    161160
    162   inline G4bool contains(std::string) const;
     161  inline G4bool contains(const std::string&) const;
    163162  inline G4bool contains(char) const;
    164163
    … …  
    184183  inline unsigned int hash( caseCompare cmp = exact ) const;
    185184  inline unsigned int stlhash() const;
    186 
    187   // useful for supplying hash functions to template hash collection ctors
    188   //
    189   static inline unsigned int hash(const G4String&);
    190 
    191185};
    192186

  • trunk/source/global/management/include/G4String.icc

    r1058 r1193  
    2525//
    2626//
    27 // $Id: G4String.icc,v 1.11 2008/12/08 14:16:05 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4String.icc,v 1.19 2009/08/10 10:30:03 gcosmo Exp $
     28// GEANT4 tag $Name: global-V09-02-10 $
    2929//
    3030//
    … …  
    9191G4int G4SubString::operator!() const
    9292{
    93   return extent==0 ? 1 : 0;
    94 }
    95 
    96 G4bool G4SubString::operator==(G4String s) const
    97 {
    98   return mystring->substr(mystart,extent) == s ? true:false;
     93  return (extent==0) ? 1 : 0;
     94}
     95
     96G4bool G4SubString::operator==(const G4String& s) const
     97{
     98  return (mystring->find(s,mystart,extent) != std::string::npos);
    9999}
    100100
    101101G4bool G4SubString::operator==(const char* s) const
    102102{
    103   return mystring->substr(mystart,extent) == std::string(s) ? true:false;
    104 }
    105 
    106 G4bool G4SubString::operator!=(G4String s) const
    107 {
    108   return mystring->substr(mystart,extent) != std::string(s) ? true:false;
     103  return (mystring->find(s,mystart,extent) != std::string::npos);
     104}
     105
     106G4bool G4SubString::operator!=(const G4String& s) const
     107{
     108  return (mystring->find(s,mystart,extent) == std::string::npos);
    109109}
    110110
    111111G4bool G4SubString::operator!=(const char* s) const
    112112{
    113   return mystring->substr(mystart,extent) != std::string(s) ? true:false;
     113  return (mystring->find(s,mystart,extent) == std::string::npos);
    114114}
    115115
    … …  
    126126G4bool G4SubString::isNull() const
    127127{
    128   return extent==0 ? true : false;
     128  return (extent==0);
    129129}
    130130
    … …  
    219219G4bool G4String::operator==(const G4String &s) const
    220220{
    221   const std_string *a=this;
    222   const std_string *b=&s;
    223   return *a==*b;
     221  return (std_string::compare(s) == 0);
    224222}
    225223
    226224G4bool G4String::operator==(const char* s) const
    227225{
    228   const std_string *a=this;
    229   const std_string b=s;
    230   return *a==b;
     226  return (std_string::compare(s) == 0);
    231227}
    232228
    233229G4bool G4String::operator!=(const G4String &s) const
    234230{
    235   const std_string *a=this;
    236   const std_string *b=&s;
    237   return *a!=*b;
     231  return !(*this == s);
    238232}
    239233
    240234G4bool G4String::operator!=(const char* s) const
    241235{
    242   const std_string *a=this;
    243   const std_string b=s;
    244   return *a!=b;
     236  return !(*this == s);
    245237}
    246238
    … …  
    268260G4int G4String::compareTo(const char* s, caseCompare mode)
    269261{
    270   if(mode==exact)
    271     { return strcmp(c_str(),s); }
    272   else
    273     { return strcasecompare(c_str(),s); }
     262  return (mode==exact) ? strcmp(c_str(),s)
     263                       : strcasecompare(c_str(),s);
    274264}
    275265
    276266G4int G4String::compareTo(const G4String& s, caseCompare mode)
    277267{
    278   if(mode==exact)
    279     { return strcmp(c_str(),s.c_str()); }
    280   else
    281     { return strcasecompare(c_str(),s.c_str()); }
     268  return (mode==exact) ? strcmp(c_str(),s.c_str())
     269                       : strcasecompare(c_str(),s.c_str());
    282270}
    283271
    … …  
    298286{
    299287  char tmp[1024];
    300   if ( skipWhite ) {
     288  if ( skipWhite )
     289  {
    301290    s >> std::ws;
    302291    s.getline(tmp,1024);
    303292    *this=tmp;
    304293  }
    305   else {
     294  else
     295  {
    306296    s.getline(tmp,1024);   
    307297    *this=tmp;
    … …  
    325315G4String& G4String::remove(str_size n)
    326316{
    327   if(n<size())
    328     { erase(n,size()-n); }
     317  if(n<size()) { erase(n,size()-n); }
    329318  return *this;
    330319}
    … …  
    346335}
    347336
    348 G4bool G4String::contains(std::string s) const
    349 {
    350   G4int i=std_string::find(s);
    351   if(i != G4int(std_string::npos))
    352     { return true; }
    353   else
    354     { return false; }
     337G4bool G4String::contains(const std::string& s) const
     338{
     339  return (std_string::find(s) != std_string::npos);
    355340}
    356341
    357342G4bool G4String::contains(char c) const
    358343{
    359   G4int i=std_string::find(c);
    360   if(i != G4int(std_string::npos))
    361     { return true; }
    362   else
    363     { return false; }
     344  return (std_string::find(c) != std_string::npos);
    364345}
    365346
    … …  
    474455  return str_size(h);
    475456}
    476 
    477 unsigned int G4String::hash(const G4String& s)
    478 {
    479   return s.hash();
    480 }

  • trunk/source/global/management/include/G4Version.hh

    r1058 r1193  
    2525//
    2626//
    27 // $Id: G4Version.hh,v 1.17 2008/12/02 09:15:58 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-02-ref-02 $
     27// $Id: G4Version.hh,v 1.24 2009/06/19 14:29:09 vnivanch Exp $
     28// GEANT4 tag $Name: global-V09-02-10 $
    2929//
    3030// Version information
    … …  
    4747
    4848#ifndef G4VERSION_NUMBER
    49 #define G4VERSION_NUMBER  920
     49#define G4VERSION_NUMBER  930
    5050#endif
    5151
    5252#ifndef G4VERSION_TAG
    53 #define G4VERSION_TAG "$Name: geant4-09-02-ref-02 $"
     53#define G4VERSION_TAG "$Name: global-V09-02-10 $"
    5454#endif
    5555
    … …  
    5858#include "G4String.hh"
    5959
    60 static const G4String G4Version = "$Name: geant4-09-02-ref-02 $";
    61 static const G4String G4Date    = "(19-December-2008)";
     60static const G4String G4Version = "$Name: global-V09-02-10 $";
     61static const G4String G4Date    = "(5-June-2009)";
    6262
    6363#endif
Note: See TracChangeset for help on using the changeset viewer.