Changeset 1340 for trunk/source/global


Ignore:
Timestamp:
Nov 5, 2010, 3:45:55 PM (14 years ago)
Author:
garnier
Message:

update ti head

Location:
trunk/source/global
Files:
25 edited

Legend:

Unmodified
Added
Removed

  • trunk/source/global/HEPGeometry/GNUmakefile

    r833 r1340  
    1 # $Id: GNUmakefile,v 1.2 2004/06/11 14:18:56 gcosmo Exp $
     1# $Id: GNUmakefile,v 1.4 2010/10/27 07:40:06 gcosmo Exp $
    22# --------------------------------------------------------------
    33# GNUmakefile for global HEPGeometry.  Gabriele Cosmo, 26/9/96.
    … …  
    1212include $(G4INSTALL)/config/architecture.gmk
    1313
    14 CPPFLAGS += -DG4IOS_EXPORT
     14CPPFLAGS += -DG4IOS_ALLOC_EXPORT
    1515CPPFLAGS += -I$(G4BASE)/global/management/include
    1616

  • trunk/source/global/HEPNumerics/GNUmakefile

    r833 r1340  
    1 # $Id: GNUmakefile,v 1.2 2004/06/11 14:18:57 gcosmo Exp $
     1# $Id: GNUmakefile,v 1.4 2010/10/27 07:40:06 gcosmo Exp $
    22# --------------------------------------------------------------
    33# GNUmakefile for global HEPNumerics.  Gabriele Cosmo, 26/9/96.
    … …  
    1212include $(G4INSTALL)/config/architecture.gmk
    1313
    14 CPPFLAGS += -DG4IOS_EXPORT
     14CPPFLAGS += -DG4IOS_ALLOC_EXPORT
    1515CPPFLAGS += -I$(G4BASE)/global/management/include
    1616

  • trunk/source/global/HEPNumerics/include/G4SimplexDownhill.hh

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4SimplexDownhill.hh,v 1.3 2007/06/21 15:04:12 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4SimplexDownhill.hh,v 1.4 2010/11/01 13:55:17 gcosmo Exp $
     28// GEANT4 tag $Name: global-V09-03-22 $
    2929//
    3030// Class description:
    … …  
    5454
    5555      G4SimplexDownhill( T* tp , G4int n )
    56       { target = tp; init(); numberOfVariable = n; }
     56        : currentValue(0.), target(tp), numberOfVariable(n)
     57      { init(); }
    5758
    5859      ~G4SimplexDownhill();

  • trunk/source/global/HEPNumerics/src/G4JTPolynomialSolver.cc

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 // $Id: G4JTPolynomialSolver.cc,v 1.7 2008/03/13 09:35:57 gcosmo Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4JTPolynomialSolver.cc,v 1.8 2010/07/14 10:45:46 gcosmo Exp $
     27// GEANT4 tag $Name: global-V09-03-22 $
    2828//
    2929// --------------------------------------------------------------------
    … …  
    4646
    4747G4JTPolynomialSolver::G4JTPolynomialSolver()
     48  : sr(0.), si(0.), u(0.),v(0.),
     49    a(0.), b(0.), c(0.), d(0.),
     50    a1(0.), a2(0.), a3(0.), a6(0.), a7(0.),
     51    e(0.), f(0.), g(0.), h(0.),
     52    szr(0.), szi(0.), lzr(0.), lzi(0.),
     53    n(0), nmi(0)
    4854{
    4955}

  • trunk/source/global/HEPRandom/GNUmakefile

    r833 r1340  
    1 # $Id: GNUmakefile,v 1.3 2004/10/29 08:40:23 gcosmo Exp $
     1# $Id: GNUmakefile,v 1.5 2010/10/27 07:40:06 gcosmo Exp $
    22# --------------------------------------------------------------
    33# GNUmakefile for global HEPRandom.  Gunter Folger 12-Dec-2000.
    … …  
    1111include $(G4INSTALL)/config/architecture.gmk
    1212
    13 CPPFLAGS += -DG4IOS_EXPORT
     13CPPFLAGS += -DG4IOS_ALLOC_EXPORT
    1414CPPFLAGS += -I$(G4BASE)/global/HepGeometry/include
    1515

  • trunk/source/global/History

    r1315 r1340  
    1 $Id: History,v 1.245 2010/06/09 13:54:13 gcosmo Exp $
     1$Id: History,v 1.264 2010/11/01 13:56:48 gcosmo Exp $
    22-------------------------------------------------------------------
    33
    … …  
    1717     * Reverse chronological order (last date on top), please *
    1818     ----------------------------------------------------------
     19
     20Nov 01, 2010  G.Cosmo (global-V09-03-22)
     21- Fixed dummy initialisation in constructor for G4SimplexDownhill and
     22  G4ConvergenceTester classes.
     23- Fixed cases of tainted scalar in G4DataVector, G4OrderedTable,
     24  G4PhysicsTable and G4PhysicsVector.
     25
     26Oct 30, 2010  T.Koi (global-V09-03-21)
     27- Fixed error in calculation of CPU time for each event in G4ConvergenceTester.
     28
     29Oct 27, 2010  G.Cosmo (global-V09-03-20, global-V09-03-19)
     30- Replaced G4IOS_EXPORT flag with G4IOS_ALLOC_EXPORT for DLL exported symbols.
     31
     32Oct 15, 2010  G.Cosmo (global-V09-03-18)
     33- Fixed compilation error on WIN32-VC for G4ConvergenceTester. Also, added
     34  explicit initialization of static data to constructor.
     35
     36Oct 14, 2010  M.Kelsey (global-V09-03-17)
     37- Modified FPE handler to get correct SIGINFO data for error messages.
     38
     39Oct 12, 2010  G.Cosmo (global-V09-03-16)
     40- Added class G4ConvergenceTester, moved from extended example N03Con,
     41  implementing a facility for estimating the quality of the simulation,
     42  by providing statistical information to assist in establishing valid
     43  confidence intervals for Monte Carlo results.
     44
     45Oct 1, 2010  G.Cosmo (global-V09-03-15)
     46- Fixed typo in destructor of G4StateManager.
     47- Fixed type clash with input stream in G4PhysicsVector::Retrieve(),
     48  G4PhysicsTable::RetrievePhysicsTable(), G4OrderedTable::Store()
     49  and G4DataVector::Retrieve().
     50- Fixed potential case of memory leak in G4OrderedTable::Retrieve().
     51- Added dummy initialization of members in constructors for classes
     52  G4SliceTimer, G4ErrorPropagatorData,
     53
     54Sep 18, 2010  V.Ivantchenko (global-V09-03-14)
     55- Withdrawn latest change made to G4PhysicsVector::PutValue(), due to
     56  misunderstanding...
     57
     58Sep 18, 2010  H.Kurashige (global-V09-03-13)
     59- Fixed bug in G4PhysicsVector::PutValue() to correctly handle last bin
     60  when Energy=theEmax in getValue().
     61
     62Aug 23, 2010  V.Ivantchenko (global-V09-03-12)
     63- Added methods logfactorial() and powN() to G4Pow class.
     64
     65Aug 19, 2010  G.Cosmo (global-V09-03-11)
     66- Correction to G4FPEDetection.hh to avoid compilation error on Linux.
     67
     68Aug 09, 2010  M.Maire
     69- G4UnitsTable: added new category "Solid angle".
     70
     71Jul 16, 2010  G.Cosmo (global-V09-03-10)
     72- Added INT_MAX and INT_MIN portability macros in templates.hh.
     73
     74Jul 14, 2010  G.Cosmo (global-V09-03-09)
     75- G4Allocator: implemented customizable pool size.
     76- G4AllocatorPool: moved dummy copy constructor to private section.
     77- Fixed cases of invalidated iterator in G4StateManager.
     78- Fixed restoring of cout/cerr formatting in G4DataVector, G4PhysicsVector.
     79- Added dummy initialization of members in constructors for classes
     80  G4JTPolynomialSolver, G4AllocatorPool, G4ErrorPropagatorData.
     81- Added experimental code for MacOSX in G4FPEDetection.hh.
    1982
    2083Jun 09, 2010  G.Cosmo (global-V09-03-08)

  • trunk/source/global/management/GNUmakefile

    r1058 r1340  
    1 # $Id: GNUmakefile,v 1.6 2009/01/27 08:45:28 gcosmo Exp $
     1# $Id: GNUmakefile,v 1.8 2010/10/27 07:40:06 gcosmo Exp $
    22# --------------------------------------------------------------
    33# GNUmakefile for global management.  Gabriele Cosmo, 26/9/96.
    … …  
    1212include $(G4INSTALL)/config/architecture.gmk
    1313
    14 CPPFLAGS += -DG4IOS_EXPORT
     14CPPFLAGS += -DG4IOS_ALLOC_EXPORT
    1515ifdef G4RF_DEBUG
    1616  CPPFLAGS += -DG4RF_DEBUG

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

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4Allocator.hh,v 1.20 2010/03/30 08:17:24 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4Allocator.hh,v 1.21 2010/04/01 12:43:12 gcosmo Exp $
     28// GEANT4 tag $Name: global-V09-03-22 $
    2929//
    3030//
    … …  
    6666
    6767    inline void ResetStorage();
    68       // Returns allocated storage to the free store, resets
    69       // allocator and page sizes.
     68      // Returns allocated storage to the free store, resets allocator.
    7069      // Note: contents in memory are lost using this call !
    7170
    7271    inline size_t GetAllocatedSize() const;
    7372      // Returns the size of the total memory allocated
     73    inline int GetNoPages() const;
     74      // Returns the total number of allocated pages
     75    inline size_t GetPageSize() const;
     76      // Returns the current size of a page
     77    inline void IncreasePageSize( unsigned int sz );
     78      // Resets allocator and increases default page size of a given factor
    7479
    7580  public:  // without description
    … …  
    213218
    214219// ************************************************************
     220// GetNoPages
     221// ************************************************************
     222//
     223template <class Type>
     224int G4Allocator<Type>::GetNoPages() const
     225{
     226  return mem.GetNoPages();
     227}
     228
     229// ************************************************************
     230// GetPageSize
     231// ************************************************************
     232//
     233template <class Type>
     234size_t G4Allocator<Type>::GetPageSize() const
     235{
     236  return mem.GetPageSize();
     237}
     238
     239// ************************************************************
     240// IncreasePageSize
     241// ************************************************************
     242//
     243template <class Type>
     244void G4Allocator<Type>::IncreasePageSize( unsigned int sz )
     245{
     246  ResetStorage();
     247  mem.GrowPageSize(sz);
     248}
     249
     250// ************************************************************
    215251// operator==
    216252// ************************************************************

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

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4AllocatorPool.hh,v 1.5 2006/06/29 19:01:18 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4AllocatorPool.hh,v 1.7 2010/07/14 10:45:46 gcosmo Exp $
     28// GEANT4 tag $Name: global-V09-03-22 $
    2929//
    3030//
    … …  
    5858      // Destructor. Return storage to the free store
    5959
    60     G4AllocatorPool(const G4AllocatorPool& right);
    61       // Copy constructor
    62 
    6360    inline void* Alloc();
    6461      // Allocate one element
    … …  
    7168      // Return storage to the free store
    7269
     70    inline int  GetNoPages() const;
     71      // Return the total number of allocated pages
     72    inline unsigned int  GetPageSize() const;
     73      // Accessor for default page size
     74    inline void GrowPageSize( unsigned int factor );
     75      // Increase default page size by a given factor
     76
    7377  private:
    7478
     79    G4AllocatorPool(const G4AllocatorPool& right);
     80      // Provate copy constructor
    7581    G4AllocatorPool& operator= (const G4AllocatorPool& right);
    7682      // Private equality operator
    … …  
    97103
    98104    const unsigned int esize;
    99     const unsigned int csize;
     105    unsigned int csize;
    100106    G4PoolChunk* chunks;
    101107    G4PoolLink* head;
    … …  
    142148}
    143149
     150// ************************************************************
     151// GetNoPages
     152// ************************************************************
     153//
     154inline int
     155G4AllocatorPool::GetNoPages() const
     156{
     157  return nchunks;
     158}
     159
     160// ************************************************************
     161// GetPageSize
     162// ************************************************************
     163//
     164inline unsigned int
     165G4AllocatorPool::GetPageSize() const
     166{
     167  return csize;
     168}
     169
     170// ************************************************************
     171// GrowPageSize
     172// ************************************************************
     173//
     174inline void
     175G4AllocatorPool::GrowPageSize( unsigned int sz )
     176{
     177  csize = (sz) ? sz*csize : csize;
     178}
     179
    144180#endif

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

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4FPEDetection.hh,v 1.2 2006/11/15 16:00:18 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4FPEDetection.hh,v 1.5 2010/10/14 17:02:52 mkelsey Exp $
     28// GEANT4 tag $Name: global-V09-03-22 $
    2929//
    3030//
    … …  
    3232//
    3333// -----------------------------------------------------------------------
    34 // This global method should be used on LINUX platforms with gcc compiler
    35 // for activating NaN detection and FPE signals, and forcing abortion of
    36 // the application at the time these are detected.
     34// This global method should be used on LINUX or MacOSX platforms with gcc
     35// compiler for activating NaN detection and FPE signals, and forcing
     36// abortion of the application at the time these are detected.
    3737// Meant to be used for debug purposes, can be activated by compiling the
    3838// "run" module with the flag G4FPE_DEBUG set in the environment.
    … …  
    4141#ifndef G4FPEDetection_h
    4242#define G4FPEDetection_h 1
     43
     44#include <iostream>
     45#include <stdlib.h>  /* abort(), exit() */
    4346
    4447#ifdef __linux__
    … …  
    4851  #include <csignal>
    4952
    50   #include <iostream>
    51 
    5253  struct sigaction termaction, oldaction;
    5354
    54   void TerminationSignalHandler(int sig)
     55  static void TerminationSignalHandler(int sig, siginfo_t* sinfo, void* /* context */)
    5556  {
    5657    std::cerr << "ERROR: " << sig;
    57     std::string message;
    58     switch (SIGFPE)
    59     {
     58    std::string message = "Floating-point exception (FPE).";
     59
     60    if (sinfo) {
     61      switch (sinfo->si_code) {
     62#ifdef FPE_NOOP         /* BUG: MacOSX uses this instead of INTDIV */
     63      case FPE_NOOP:
     64#endif
    6065      case FPE_INTDIV:
    6166        message = "Integer divide by zero.";
    … …  
    8590        message = "Unknown error.";
    8691        break;
    87     }
     92      }
     93    }
     94
    8895    std::cerr << " - " << message << std::endl;
    89 
     96   
    9097    ::abort();
    9198  }
    9299
    93   void InvalidOperationDetection()
     100  static void InvalidOperationDetection()
    94101  {
    95102    std::cout << std::endl
    … …  
    106113    //(void) feenableexcept( FE_UNDERFLOW );
    107114
    108     sigset_t *def_set;
    109     def_set=&termaction.sa_mask;
    110     sigfillset(def_set);
    111     sigdelset(def_set,SIGFPE);
    112     termaction.sa_handler=TerminationSignalHandler;
    113     termaction.sa_flags=0;
    114     sigaction(SIGFPE, &termaction,&oldaction);
    115   }
    116 #endif
    117 #else
    118   void InvalidOperationDetection() {;}
    119 #endif
    120 
    121 #endif
     115    sigdelset(&termaction.sa_mask,SIGFPE);
     116    termaction.sa_sigaction=TerminationSignalHandler;
     117    termaction.sa_flags=SA_SIGINFO;
     118    sigaction(SIGFPE, &termaction, &oldaction);
     119  }
     120#endif
     121#elif __MACH__      /* MacOSX */
     122
     123  #include <fenv.h>
     124  #include <signal.h>
     125
     126  #define DEFINED_PPC      (defined(__ppc__) || defined(__ppc64__))
     127  #define DEFINED_INTEL    (defined(__i386__) || defined(__x86_64__))
     128
     129  #if DEFINED_PPC
     130
     131    #define FE_EXCEPT_SHIFT 22  // shift flags right to get masks
     132    #define FM_ALL_EXCEPT    FE_ALL_EXCEPT >> FE_EXCEPT_SHIFT
     133
     134    static inline int feenableexcept (unsigned int excepts)
     135    {
     136      static fenv_t fenv;
     137      unsigned int new_excepts = (excepts & FE_ALL_EXCEPT) >> FE_EXCEPT_SHIFT,
     138                   old_excepts;  // all previous masks
     139
     140      if ( fegetenv (&fenv) )  { return -1; }
     141      old_excepts = (fenv & FM_ALL_EXCEPT) << FE_EXCEPT_SHIFT;
     142      fenv = (fenv & ~new_excepts) | new_excepts;
     143
     144      return ( fesetenv (&fenv) ? -1 : old_excepts );
     145    }
     146
     147    static inline int fedisableexcept (unsigned int excepts)
     148    {
     149      static fenv_t fenv;
     150      unsigned int still_on = ~((excepts & FE_ALL_EXCEPT) >> FE_EXCEPT_SHIFT),
     151                   old_excepts;  // previous masks
     152
     153      if ( fegetenv (&fenv) )  { return -1; }
     154      old_excepts = (fenv & FM_ALL_EXCEPT) << FE_EXCEPT_SHIFT;
     155      fenv &= still_on;
     156
     157      return ( fesetenv (&fenv) ? -1 : old_excepts );
     158    }
     159
     160  #elif DEFINED_INTEL
     161
     162    static inline int feenableexcept (unsigned int excepts)
     163    {
     164      static fenv_t fenv;
     165      unsigned int new_excepts = excepts & FE_ALL_EXCEPT,
     166                   old_excepts;  // previous masks
     167
     168      if ( fegetenv (&fenv) )  { return -1; }
     169      old_excepts = fenv.__control & FE_ALL_EXCEPT;
     170
     171      // unmask
     172      //
     173      fenv.__control &= ~new_excepts;
     174      fenv.__mxcsr   &= ~(new_excepts << 7);
     175
     176      return ( fesetenv (&fenv) ? -1 : old_excepts );
     177    }
     178
     179    static inline int fedisableexcept (unsigned int excepts)
     180    {
     181      static fenv_t fenv;
     182      unsigned int new_excepts = excepts & FE_ALL_EXCEPT,
     183                   old_excepts;  // all previous masks
     184
     185      if ( fegetenv (&fenv) )  { return -1; }
     186      old_excepts = fenv.__control & FE_ALL_EXCEPT;
     187
     188      // mask
     189      //
     190      fenv.__control |= new_excepts;
     191      fenv.__mxcsr   |= new_excepts << 7;
     192
     193      return ( fesetenv (&fenv) ? -1 : old_excepts );
     194    }
     195
     196  #endif  /* PPC or INTEL enabling */
     197
     198  static void TerminationSignalHandler(int sig, siginfo_t* sinfo, void* /* context */)
     199  {
     200    std::cerr << "ERROR: " << sig;
     201    std::string message = "Floating-point exception (FPE).";
     202
     203    if (sinfo) {
     204      switch (sinfo->si_code) {
     205#ifdef FPE_NOOP         /* BUG: MacOSX uses this instead of INTDIV */
     206      case FPE_NOOP:
     207#endif
     208      case FPE_INTDIV:
     209        message = "Integer divide by zero.";
     210        break;
     211      case FPE_INTOVF:
     212        message = "Integer overflow.";
     213        break;
     214      case FPE_FLTDIV:
     215        message = "Floating point divide by zero.";
     216        break;
     217      case FPE_FLTOVF:
     218        message = "Floating point overflow.";
     219        break;
     220      case FPE_FLTUND:
     221        message = "Floating point underflow.";
     222        break;
     223      case FPE_FLTRES:
     224        message = "Floating point inexact result.";
     225        break;
     226      case FPE_FLTINV:
     227        message = "Floating point invalid operation.";
     228        break;
     229      case FPE_FLTSUB:
     230        message = "Subscript out of range.";
     231        break;
     232      default:
     233        message = "Unknown error.";
     234        break;
     235      }
     236    }
     237
     238    std::cerr << " - " << message << std::endl;
     239   
     240    ::abort();
     241  }
     242
     243  static void InvalidOperationDetection()
     244  {
     245    struct sigaction termaction, oldaction;
     246
     247    std::cout << std::endl
     248              << "        "
     249              << "############################################" << std::endl
     250              << "        "
     251              << "!!! WARNING - FPE detection is activated !!!" << std::endl
     252              << "        "
     253              << "############################################" << std::endl;
     254
     255    feenableexcept ( FE_DIVBYZERO );
     256    feenableexcept ( FE_INVALID   );
     257    // fedisableexcept( FE_OVERFLOW  );
     258    // fedisableexcept( FE_UNDERFLOW );
     259
     260    sigdelset(&termaction.sa_mask,SIGFPE);
     261    termaction.sa_sigaction=TerminationSignalHandler;
     262    termaction.sa_flags=SA_SIGINFO;
     263    sigaction(SIGFPE, &termaction, &oldaction);
     264  }
     265#else  /* Not Linux, nor MacOSX ... */
     266
     267  static void InvalidOperationDetection() {;}
     268
     269#endif
     270
     271#endif

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

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4PhysicsVector.icc,v 1.28 2010/05/28 05:13:43 kurasige Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4PhysicsVector.icc,v 1.30 2010/09/20 16:22:56 gcosmo Exp $
     28// GEANT4 tag $Name: global-V09-03-22 $
    2929//
    3030//

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

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 // $Id: G4Pow.hh,v 1.5 2010/05/28 08:18:03 vnivanch Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4Pow.hh,v 1.7 2010/08/24 08:12:08 gcosmo Exp $
     27// GEANT4 tag $Name: global-V09-03-22 $
    2828//
    2929//
    … …  
    8282    inline G4double powZ(G4int Z, G4double y);
    8383    inline G4double powA(G4double A, G4double y);
     84           G4double powN(G4double x, G4int n);
    8485
    8586    // Fast factorial
    8687    //
    8788    inline G4double factorial(G4int Z);
     89    inline G4double logfactorial(G4int Z);
    8890
    8991  private:
    … …  
    101103    G4DataVector lz;
    102104    G4DataVector fact;
     105    G4DataVector logfact;
    103106};
    104107
    … …  
    190193}
    191194
     195inline G4double G4Pow::logfactorial(G4int Z)
     196{
     197  return logfact[Z];
     198}
     199
    192200// -------------------------------------------------------------------
    193201

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

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4ios.hh,v 1.10 2006/06/29 19:03:43 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4ios.hh,v 1.12 2010/10/27 07:40:06 gcosmo Exp $
     28// GEANT4 tag $Name: global-V09-03-22 $
    2929//
    3030//
    … …  
    4242#include <iostream>
    4343
    44 #if defined G4IOS_EXPORT
     44#if defined G4IOS_ALLOC_EXPORT
    4545  extern G4DLLEXPORT std::ostream G4cout;
    4646  extern G4DLLEXPORT std::ostream G4cerr;

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

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4strstreambuf.hh,v 1.16 2007/11/13 17:35:06 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4strstreambuf.hh,v 1.18 2010/10/27 07:40:06 gcosmo Exp $
     28// GEANT4 tag $Name: global-V09-03-22 $
    2929// ====================================================================
    3030//
    … …  
    4141class G4strstreambuf;
    4242
    43 #if defined G4IOS_EXPORT
     43#if defined G4IOS_ALLOC_EXPORT
    4444extern G4DLLEXPORT G4strstreambuf G4coutbuf;
    4545extern G4DLLEXPORT G4strstreambuf G4cerrbuf;

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

    r1337 r1340  
    2525//
    2626//
    27 // $Id: templates.hh,v 1.13 2008/08/15 12:15:53 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: templates.hh,v 1.14 2010/07/16 15:48:51 gcosmo Exp $
     28// GEANT4 tag $Name: global-V09-03-22 $
    2929//
    3030//
    … …  
    109109#endif
    110110
     111#ifndef INT_MAX   /* Max decimal value of a int */
     112#define INT_MAX   std::numeric_limits<int>::max()   // 2147483647
     113#endif
     114
     115#ifndef INT_MIN   /* Min decimal value of a int */
     116#define INT_MIN   std::numeric_limits<int>::min()   // -2147483648
     117#endif
     118
    111119//---------------------------------
    112120

  • trunk/source/global/management/src/G4AllocatorPool.cc

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4AllocatorPool.cc,v 1.4 2006/06/29 19:03:57 gunter Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4AllocatorPool.cc,v 1.6 2010/07/14 10:45:46 gcosmo Exp $
     28// GEANT4 tag $Name: global-V09-03-22 $
    2929//
    3030//
    … …  
    5555//
    5656G4AllocatorPool::G4AllocatorPool(const G4AllocatorPool& right)
    57   : esize(right.esize), csize(right.csize)
     57  : esize(right.esize), csize(right.csize),
     58    chunks(right.chunks), head(right.head), nchunks(right.nchunks)
    5859{
    59   *this = right;
    6060}
    6161

  • trunk/source/global/management/src/G4DataVector.cc

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4DataVector.cc,v 1.9 2007/11/13 17:35:06 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4DataVector.cc,v 1.12 2010/11/01 13:55:53 gcosmo Exp $
     28// GEANT4 tag $Name: global-V09-03-22 $
    2929//
    3030//
    … …  
    8888{
    8989  clear();
    90   size_t sizeV=0;
     90  G4int sizeV=0;
    9191 
    9292  // retrieve in ascii mode
    … …  
    9696    fIn >> sizeV;
    9797    if (fIn.fail())  { return false; }
    98    
     98    if (sizeV<=0)
     99    {
     100#ifdef G4VERBOSE 
     101      G4cerr << "G4DataVector::Retrieve():";
     102      G4cerr << " Invalid vector size: " << sizeV << G4endl;
     103#endif
     104      return false;
     105    }
     106
    99107    reserve(sizeV);
    100     for(size_t i = 0; i < sizeV ; i++)
     108    for(G4int i = 0; i < sizeV ; i++)
    101109    {
    102110      G4double vData=0.0;
    … …  
    120128
    121129  reserve(sizeV);
    122   for(size_t i = 0; i < sizeV; i++)
     130  for(G4int i = 0; i < sizeV; i++)
    123131  {
    124132    push_back(value[i]);
    … …  
    130138std::ostream& operator<<(std::ostream& out, const G4DataVector& pv)
    131139{
    132   out << pv.size() << G4endl;
     140  out << pv.size() << std::setprecision(12) << G4endl;
    133141  for(size_t i = 0; i < pv.size(); i++)
    134142  {
    135     out << std::setprecision(12) << pv[i] << G4endl;
     143    out << pv[i] << G4endl;
    136144  }
     145  out << std::setprecision(6);
    137146
    138147  return out;

  • trunk/source/global/management/src/G4ErrorPropagatorData.cc

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4ErrorPropagatorData.cc,v 1.5 2009/05/19 13:31:47 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4ErrorPropagatorData.cc,v 1.7 2010/10/01 16:36:31 gcosmo Exp $
     28// GEANT4 tag $Name: global-V09-03-22 $
    2929//
    3030//
    … …  
    3838
    3939G4ErrorPropagatorData* G4ErrorPropagatorData::theErrorPropagatorData = 0;
    40 
    4140G4int G4ErrorPropagatorData::theVerbosity = 0;
    4241
    4342//-------------------------------------------------------------------
    4443
    45 G4ErrorPropagatorData::~G4ErrorPropagatorData()
     44G4ErrorPropagatorData::G4ErrorPropagatorData()
     45  : theMode(G4ErrorMode_PropTest), theState(G4ErrorState_PreInit),
     46    theStage(G4ErrorStage_Inflation), theTarget(0)
    4647{
    4748}
    4849
    49 G4ErrorPropagatorData::G4ErrorPropagatorData()
     50G4ErrorPropagatorData::~G4ErrorPropagatorData()
    5051{
    51   theStage = G4ErrorStage_Inflation;
    5252}
    5353

  • trunk/source/global/management/src/G4OrderedTable.cc

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4OrderedTable.cc,v 1.6 2007/11/13 17:35:06 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4OrderedTable.cc,v 1.8 2010/11/01 13:55:53 gcosmo Exp $
     28// GEANT4 tag $Name: global-V09-03-22 $
    2929//
    3030//
    … …  
    7171  {
    7272#ifdef G4VERBOSE 
    73     G4cerr << "G4OrderedTable::::Store  ";
    74     G4cerr << " Can not open file " << fileName << G4endl;
     73    G4cerr << "G4OrderedTable::::Store():";
     74    G4cerr << " Cannot open file: " << fileName << G4endl;
    7575#endif
    7676    fOut.close();
    … …  
    123123  {
    124124#ifdef G4VERBOSE 
    125     G4cerr << "G4OrderedTable::Retrieve  ";
    126     G4cerr << " Can not open file " << fileName << G4endl;
     125    G4cerr << "G4OrderedTable::Retrieve():";
     126    G4cerr << " Cannot open file: " << fileName << G4endl;
    127127#endif
    128128    fIn.close();
    … …  
    134134 
    135135  // Number of elements
    136   size_t tableSize=0;
     136  G4int tableSize=0;
    137137  if (!ascii)
    138138  {
    … …  
    143143    fIn >> tableSize;
    144144  }
     145  if (tableSize<=0)
     146  {
     147#ifdef G4VERBOSE 
     148    G4cerr << "G4OrderedTable::Retrieve():";
     149    G4cerr << " Invalid table size: " << tableSize << G4endl;
     150#endif
     151    return false;
     152  }
    145153  reserve(tableSize);
    146154
    147155  // Physics Vector
    148   for (size_t idx=0; idx<tableSize; ++idx)
     156  for (G4int idx=0; idx<tableSize; ++idx)
    149157  {
    150158    G4int vType=0;
    … …  
    160168    {
    161169#ifdef G4VERBOSE 
    162       G4cerr << "G4OrderedTable::Retrieve  ";
    163       G4cerr << " illegal Data Vector type " << vType << " in  ";
     170      G4cerr << "G4OrderedTable::Retrieve():";
     171      G4cerr << " Illegal Data Vector type: " << vType << " in  ";
    164172      G4cerr << fileName << G4endl;
    165173#endif         
    … …  
    173181    {
    174182#ifdef G4VERBOSE 
    175       G4cerr << "G4OrderedTable::Retrieve  ";
    176       G4cerr << " error in retreiving " << idx
    177              << "-th Physics Vector from file ";
     183      G4cerr << "G4OrderedTable::Retrieve(): ";
     184      G4cerr << " Rrror in retreiving " << idx
     185             << "-th Physics Vector from file: ";
    178186      G4cerr << fileName << G4endl;
    179187#endif         
    180188      fIn.close();
     189      delete pVec;
    181190      return false;
    182191    }

  • trunk/source/global/management/src/G4PhysicsTable.cc

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4PhysicsTable.cc,v 1.15 2007/11/13 17:35:06 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4PhysicsTable.cc,v 1.17 2010/11/01 13:55:53 gcosmo Exp $
     28// GEANT4 tag $Name: global-V09-03-22 $
    2929//
    3030//
    … …  
    3636// ------------------------------------------------------------
    3737
    38 #include "G4PhysicsVector.hh"
    39 #include "G4PhysicsTable.hh"
    4038#include <iostream>
    4139#include <fstream>
    4240#include <iomanip>
    4341
    44 G4PhysicsTable::G4PhysicsTable()
    45   : G4PhysCollection()
    46 {
    47 }
    48 
    49 G4PhysicsTable::G4PhysicsTable(size_t cap)
    50   : G4PhysCollection()
    51 {
    52   reserve(cap);
    53   vecFlag.reserve(cap);
    54 }
    55 
    56 G4PhysicsTable::G4PhysicsTable(const G4PhysicsTable& right)
    57   : G4PhysCollection()
    58 {
    59   *this = right;
    60 }
    61 
    62 G4PhysicsTable& G4PhysicsTable::operator=(const G4PhysicsTable& right)
    63 {
    64   if (this != &right)
    65   {
    66     size_t idx = 0;
    67     for (G4PhysCollection::const_iterator itr=right.begin();
    68          itr!=right.end(); ++itr )
    69     {
    70       G4PhysCollection::push_back(*itr);
    71       vecFlag.push_back(right.GetFlag(idx));
    72       idx +=1;
    73     }
    74   }
    75   return *this;
    76 }
    77 
    78 G4PhysicsTable::~G4PhysicsTable()
    79 {
    80   G4PhysCollection::clear();
    81   vecFlag.clear();
    82 }
    83  
    84 void   G4PhysicsTable::resize(size_t siz, G4PhysicsVector* vec)
    85 {
    86   G4PhysCollection::resize(siz, vec);
    87   vecFlag.resize(siz, true);
    88 }
    89 
    90 G4bool G4PhysicsTable::StorePhysicsTable(const G4String& fileName,
    91                                          G4bool          ascii)
    92 {
    93   std::ofstream fOut; 
    94  
    95   // open output file //
    96   if (!ascii)
    97     { fOut.open(fileName, std::ios::out|std::ios::binary); }
    98   else
    99     { fOut.open(fileName, std::ios::out); }
    100 
    101   // check if the file has been opened successfully
    102   if (!fOut)
    103   {
    104 #ifdef G4VERBOSE 
    105     G4cerr << "G4PhysicsTable::StorePhysicsTable  ";
    106     G4cerr << " Can not open file " << fileName << G4endl;
    107 #endif
    108     fOut.close();
    109     return false;
    110   }
    111 
    112   // Number of elements
    113   size_t tableSize = size();
    114   if (!ascii)
    115   {
    116     fOut.write( (char*)(&tableSize), sizeof tableSize);
    117   }
    118   else
    119   {
    120     fOut << tableSize << G4endl;
    121   }
    122 
    123   // Physics Vector
    124   for (G4PhysicsTableIterator itr=begin(); itr!=end(); ++itr)
    125   {
    126     G4int vType = (*itr)->GetType();
    127     if (!ascii)
    128     {
    129       fOut.write( (char*)(&vType), sizeof vType);
    130     }
    131     else
    132     {
    133       fOut << vType << G4endl;
    134     }
    135     (*itr)->Store(fOut,ascii);
    136   }
    137   fOut.close();
    138   return true;
    139 }
    140 
    141 
    142 G4bool G4PhysicsTable::ExistPhysicsTable(const G4String& fileName) const
    143 {
    144   std::ifstream fIn; 
    145   G4bool value=true;
    146   // open input file
    147   fIn.open(fileName,std::ios::in);
    148 
    149   // check if the file has been opened successfully
    150   if (!fIn)
    151   {
    152     value = false;
    153   }
    154   fIn.close();
    155   return value;
    156 }
    157    
    158 G4bool G4PhysicsTable::RetrievePhysicsTable(const G4String& fileName,
    159                                             G4bool          ascii)
    160 {
    161   std::ifstream fIn; 
    162   // open input file
    163   if (ascii)
    164     { fIn.open(fileName,std::ios::in|std::ios::binary); }
    165   else
    166     { fIn.open(fileName,std::ios::in);}
    167 
    168   // check if the file has been opened successfully
    169   if (!fIn)
    170   {
    171 #ifdef G4VERBOSE 
    172     G4cerr << "G4PhysicsTable::RetrievePhysicsTable  ";
    173     G4cerr << " Can not open file " << fileName << G4endl;
    174 #endif
    175     fIn.close();
    176     return false;
    177   }
    178 
    179   // clear
    180   clearAndDestroy();
    181  
    182   // Number of elements
    183   size_t tableSize=0;
    184   if (!ascii)
    185   {
    186     fIn.read((char*)(&tableSize), sizeof tableSize);
    187   }
    188   else
    189   {
    190     fIn >> tableSize;
    191   }
    192   reserve(tableSize);
    193   vecFlag.clear();
    194 
    195   // Physics Vector
    196   for (size_t idx=0; idx<tableSize; ++idx)
    197   {
    198     G4int vType=0;
    199     if (!ascii)
    200     {
    201       fIn.read( (char*)(&vType), sizeof vType);
    202     }
    203     else
    204     {
    205       fIn >>  vType;
    206     }
    207     G4PhysicsVector* pVec = CreatePhysicsVector(vType);
    208     if (pVec==0)
    209     {
    210 #ifdef G4VERBOSE 
    211       G4cerr << "G4PhysicsTable::RetrievePhysicsTable  ";
    212       G4cerr << " illegal Physics Vector type " << vType << " in  ";
    213       G4cerr << fileName << G4endl;
    214 #endif         
    215       fIn.close();
    216       return false;
    217     }
    218 
    219     if (! (pVec->Retrieve(fIn,ascii)) )
    220     {
    221 #ifdef G4VERBOSE 
    222       G4cerr << "G4PhysicsTable::RetrievePhysicsTable  ";
    223       G4cerr << " error in retreiving " << idx << "-th Physics Vector from file ";
    224       G4cerr << fileName << G4endl;
    225 #endif         
    226       fIn.close();
    227       return false;
    228     }
    229 
    230     // add a PhysicsVector to this PhysicsTable
    231     G4PhysCollection::push_back(pVec);
    232     vecFlag.push_back(true);
    233    
    234   }
    235   fIn.close();
    236   return true;
    237 }
    238 
    239 std::ostream& operator<<(std::ostream& out,
    240                          G4PhysicsTable& right)
    241 {
    242   // Printout Physics Vector
    243   size_t i=0;
    244   for (G4PhysicsTableIterator itr=right.begin(); itr!=right.end(); ++itr)
    245   {
    246     out << std::setw(8) << i << "-th Vector   ";
    247     out << ": Type    " << G4int((*itr)->GetType()) ;
    248     out << ": Flag    ";
    249     if (right.GetFlag(i))
    250     {
    251       out << " T";
    252     }
    253     else
    254     {
    255       out << " F";
    256     }
    257     out << G4endl;
    258     out << *(*itr);
    259     i +=1;
    260   }
    261   out << G4endl;
    262   return out;
    263 }
    264 
    265 void G4PhysicsTable::ResetFlagArray()
    266 {
    267   size_t tableSize = G4PhysCollection::size();
    268   vecFlag.clear();
    269   for (size_t idx=0; idx<tableSize; idx++)
    270   {
    271     vecFlag.push_back(true);
    272   }
    273 }
    274 
     42#include "G4PhysicsVector.hh"
     43#include "G4PhysicsTable.hh"
    27544#include "G4PhysicsVectorType.hh"
    27645#include "G4LPhysicsFreeVector.hh"
    … …  
    28150#include "G4PhysicsLnVector.hh"
    28251 
     52G4PhysicsTable::G4PhysicsTable()
     53  : G4PhysCollection()
     54{
     55}
     56
     57G4PhysicsTable::G4PhysicsTable(size_t cap)
     58  : G4PhysCollection()
     59{
     60  reserve(cap);
     61  vecFlag.reserve(cap);
     62}
     63
     64G4PhysicsTable::G4PhysicsTable(const G4PhysicsTable& right)
     65  : G4PhysCollection()
     66{
     67  *this = right;
     68}
     69
     70G4PhysicsTable& G4PhysicsTable::operator=(const G4PhysicsTable& right)
     71{
     72  if (this != &right)
     73  {
     74    size_t idx = 0;
     75    for (G4PhysCollection::const_iterator itr=right.begin();
     76         itr!=right.end(); ++itr )
     77    {
     78      G4PhysCollection::push_back(*itr);
     79      vecFlag.push_back(right.GetFlag(idx));
     80      idx +=1;
     81    }
     82  }
     83  return *this;
     84}
     85
     86G4PhysicsTable::~G4PhysicsTable()
     87{
     88  G4PhysCollection::clear();
     89  vecFlag.clear();
     90}
     91 
     92void   G4PhysicsTable::resize(size_t siz, G4PhysicsVector* vec)
     93{
     94  G4PhysCollection::resize(siz, vec);
     95  vecFlag.resize(siz, true);
     96}
     97
     98G4bool G4PhysicsTable::StorePhysicsTable(const G4String& fileName,
     99                                         G4bool          ascii)
     100{
     101  std::ofstream fOut; 
     102 
     103  // open output file //
     104  if (!ascii)
     105    { fOut.open(fileName, std::ios::out|std::ios::binary); }
     106  else
     107    { fOut.open(fileName, std::ios::out); }
     108
     109  // check if the file has been opened successfully
     110  if (!fOut)
     111  {
     112#ifdef G4VERBOSE 
     113    G4cerr << "G4PhysicsTable::StorePhysicsTable():";
     114    G4cerr << " Cannot open file: " << fileName << G4endl;
     115#endif
     116    fOut.close();
     117    return false;
     118  }
     119
     120  // Number of elements
     121  size_t tableSize = size();
     122  if (!ascii)
     123  {
     124    fOut.write( (char*)(&tableSize), sizeof tableSize);
     125  }
     126  else
     127  {
     128    fOut << tableSize << G4endl;
     129  }
     130
     131  // Physics Vector
     132  for (G4PhysicsTableIterator itr=begin(); itr!=end(); ++itr)
     133  {
     134    G4int vType = (*itr)->GetType();
     135    if (!ascii)
     136    {
     137      fOut.write( (char*)(&vType), sizeof vType);
     138    }
     139    else
     140    {
     141      fOut << vType << G4endl;
     142    }
     143    (*itr)->Store(fOut,ascii);
     144  }
     145  fOut.close();
     146  return true;
     147}
     148
     149
     150G4bool G4PhysicsTable::ExistPhysicsTable(const G4String& fileName) const
     151{
     152  std::ifstream fIn; 
     153  G4bool value=true;
     154  // open input file
     155  fIn.open(fileName,std::ios::in);
     156
     157  // check if the file has been opened successfully
     158  if (!fIn)
     159  {
     160    value = false;
     161  }
     162  fIn.close();
     163  return value;
     164}
     165   
     166G4bool G4PhysicsTable::RetrievePhysicsTable(const G4String& fileName,
     167                                            G4bool          ascii)
     168{
     169  std::ifstream fIn; 
     170  // open input file
     171  if (ascii)
     172    { fIn.open(fileName,std::ios::in|std::ios::binary); }
     173  else
     174    { fIn.open(fileName,std::ios::in);}
     175
     176  // check if the file has been opened successfully
     177  if (!fIn)
     178  {
     179#ifdef G4VERBOSE 
     180    G4cerr << "G4PhysicsTable::RetrievePhysicsTable():";
     181    G4cerr << " Cannot open file: " << fileName << G4endl;
     182#endif
     183    fIn.close();
     184    return false;
     185  }
     186
     187  // clear
     188  clearAndDestroy();
     189 
     190  // Number of elements
     191  G4int tableSize=0;
     192  if (!ascii)
     193  {
     194    fIn.read((char*)(&tableSize), sizeof tableSize);
     195  }
     196  else
     197  {
     198    fIn >> tableSize;
     199  }
     200  if (tableSize<=0)
     201  {
     202#ifdef G4VERBOSE 
     203    G4cerr << "G4PhysicsTable::RetrievePhysicsTable():";
     204    G4cerr << " Invalid table size: " << tableSize << G4endl;
     205#endif
     206    return false;
     207  }
     208  reserve(tableSize);
     209  vecFlag.clear();
     210
     211  // Physics Vector
     212  for (G4int idx=0; idx<tableSize; ++idx)
     213  {
     214    G4int vType=0;
     215    if (!ascii)
     216    {
     217      fIn.read( (char*)(&vType), sizeof vType);
     218    }
     219    else
     220    {
     221      fIn >>  vType;
     222    }
     223    G4PhysicsVector* pVec = CreatePhysicsVector(vType);
     224    if (pVec==0)
     225    {
     226#ifdef G4VERBOSE 
     227      G4cerr << "G4PhysicsTable::RetrievePhysicsTable():";
     228      G4cerr << " Illegal Physics Vector type: " << vType << " in: ";
     229      G4cerr << fileName << G4endl;
     230#endif         
     231      fIn.close();
     232      return false;
     233    }
     234
     235    if (! (pVec->Retrieve(fIn,ascii)) )
     236    {
     237#ifdef G4VERBOSE 
     238      G4cerr << "G4PhysicsTable::RetrievePhysicsTable():";
     239      G4cerr << " Rrror in retreiving " << idx
     240             << "-th Physics Vector from file: ";
     241      G4cerr << fileName << G4endl;
     242#endif         
     243      fIn.close();
     244      return false;
     245    }
     246
     247    // add a PhysicsVector to this PhysicsTable
     248    G4PhysCollection::push_back(pVec);
     249    vecFlag.push_back(true);
     250   
     251  }
     252  fIn.close();
     253  return true;
     254}
     255
     256std::ostream& operator<<(std::ostream& out,
     257                         G4PhysicsTable& right)
     258{
     259  // Printout Physics Vector
     260  size_t i=0;
     261  for (G4PhysicsTableIterator itr=right.begin(); itr!=right.end(); ++itr)
     262  {
     263    out << std::setw(8) << i << "-th Vector   ";
     264    out << ": Type    " << G4int((*itr)->GetType()) ;
     265    out << ": Flag    ";
     266    if (right.GetFlag(i))
     267    {
     268      out << " T";
     269    }
     270    else
     271    {
     272      out << " F";
     273    }
     274    out << G4endl;
     275    out << *(*itr);
     276    i +=1;
     277  }
     278  out << G4endl;
     279  return out;
     280}
     281
     282void G4PhysicsTable::ResetFlagArray()
     283{
     284  size_t tableSize = G4PhysCollection::size();
     285  vecFlag.clear();
     286  for (size_t idx=0; idx<tableSize; idx++)
     287  {
     288    vecFlag.push_back(true);
     289  }
     290}
     291
    283292G4PhysicsVector* G4PhysicsTable::CreatePhysicsVector(G4int type)
    284293{

  • trunk/source/global/management/src/G4PhysicsVector.cc

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4PhysicsVector.cc,v 1.46 2010/05/28 05:13:43 kurasige Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4PhysicsVector.cc,v 1.49 2010/11/01 13:55:53 gcosmo Exp $
     28// GEANT4 tag $Name: global-V09-03-22 $
    2929//
    3030//
    … …  
    205205    if (fIn.fail())  { return false; }
    206206    // contents
    207     size_t size=0;
    208     fIn >> size;
     207    G4int siz=0;
     208    fIn >> siz;
    209209    if (fIn.fail())  { return false; }
    210 
    211     binVector.reserve(size);
    212     dataVector.reserve(size);
     210    if (siz<=0)
     211    {
     212#ifdef G4VERBOSE 
     213      G4cerr << "G4PhysicsVector::Retrieve():";
     214      G4cerr << " Invalid vector size: " << siz << G4endl;
     215#endif
     216      return false;
     217    }
     218
     219    binVector.reserve(siz);
     220    dataVector.reserve(siz);
    213221    G4double vBin, vData;
    214222
    215     for(size_t i = 0; i < size ; i++)
     223    for(G4int i = 0; i < siz ; i++)
    216224    {
    217225      vBin = 0.;
    … …  
    445453  // or not ordered than spline cannot be applied
    446454{
    447   if(!useSpline) return useSpline;
     455  if(!useSpline)  { return useSpline; }
    448456  secDerivative.clear();
    449457  secDerivative.reserve(numberOfNodes);
    … …  
    464472{
    465473  // binning
    466   out << std::setprecision(12) << pv.edgeMin;
    467   out <<" " << pv.edgeMax <<" " << pv.numberOfNodes << G4endl;
     474  out << std::setprecision(12) << pv.edgeMin << " "
     475      << pv.edgeMax << " " << pv.numberOfNodes << G4endl;
    468476
    469477  // contents
    … …  
    471479  for(size_t i = 0; i < pv.dataVector.size(); i++)
    472480  {
    473     out << std::setprecision(12) << pv.binVector[i] << "  "
    474         << pv.dataVector[i] << G4endl;
    475   }
     481    out << pv.binVector[i] << "  " << pv.dataVector[i] << G4endl;
     482  }
     483  out << std::setprecision(6);
     484
    476485  return out;
    477486}

  • trunk/source/global/management/src/G4Pow.cc

    r1337 r1340  
    2424// ********************************************************************
    2525//
    26 // $Id: G4Pow.cc,v 1.2 2009/07/03 11:35:06 vnivanch Exp $
    27 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     26// $Id: G4Pow.cc,v 1.4 2010/08/24 08:12:08 gcosmo Exp $
     27// GEANT4 tag $Name: global-V09-03-22 $
    2828//
    2929// -------------------------------------------------------------------
    … …  
    6565  lz.resize(maxZ,0.0);
    6666  fact.resize(maxZ,0.0);
     67  logfact.resize(maxZ,0.0);
    6768
    6869  onethird = 1.0/3.0;
    6970  G4double f = 1.0;
    7071
    71   for(G4int i=1; i<maxZ; i++)
     72  for(G4int i=1; i<maxZ; ++i)
    7273  {
    7374    G4double x  = G4double(i);
    … …  
    7677    f      *= x;
    7778    fact[i] = f;
     79    logfact[i] = std::log(f);
    7880  }
    7981  fact[0] = 1.0;
     82  logfact[0] = 0.0;
    8083}
    8184
    … …  
    8689
    8790// -------------------------------------------------------------------
     91
     92G4double G4Pow::powN(G4double x, G4int n)
     93{
     94  G4double res = 1.0;
     95  if(n >= 0) { for(G4int i=0; i<n; ++i) { res *= x; } }
     96  else if((n < 0) && (x != 0.0))
     97  {
     98    G4double y = 1.0/x;
     99    G4int nn = -n;
     100    for(G4int i=0; i<nn; ++i) { res *= y; }
     101  }
     102  return res;
     103}

  • trunk/source/global/management/src/G4SliceTimer.cc

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4SliceTimer.cc,v 1.2 2006/11/02 15:39:39 gcosmo Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4SliceTimer.cc,v 1.3 2010/10/01 16:36:31 gcosmo Exp $
     28// GEANT4 tag $Name: global-V09-03-22 $
    2929//
    3030//
    … …  
    6666
    6767G4SliceTimer::G4SliceTimer()
    68   : fValidTimes(true)
     68  : fValidTimes(true), fRealElapsed(0.), fSystemElapsed(0.), fUserElapsed(0.)
    6969{
    7070  Clear();

  • trunk/source/global/management/src/G4StateManager.cc

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4StateManager.cc,v 1.13 2006/11/23 00:41:56 asaim Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4StateManager.cc,v 1.15 2010/10/01 16:36:31 gcosmo Exp $
     28// GEANT4 tag $Name: global-V09-03-22 $
    2929//
    3030//
    … …  
    6161    theDependentsList.pop_back();
    6262    for (std::vector<G4VStateDependent*>::iterator
    63          i=theDependentsList.begin(); i!=theDependentsList.end(); i++)
     63         i=theDependentsList.begin(); i!=theDependentsList.end();)
    6464    {
    6565      if (*i==state)
    6666      {
    67         theDependentsList.erase(i);
    68         i--;
     67        i = theDependentsList.erase(i);
     68      }
     69      else
     70      {
     71        ++i;
    6972      }
    7073    }
    … …  
    153156  G4VStateDependent* tmp = 0;
    154157  for (std::vector<G4VStateDependent*>::iterator i=theDependentsList.begin();
    155        i!=theDependentsList.end(); i++)
    156     {
    157       if (**i==*aDependent)
    158         {
    159           tmp = *i;
    160           theDependentsList.erase(i);
    161         }
    162     }
     158       i!=theDependentsList.end();)
     159  {
     160    if (**i==*aDependent)
     161    {
     162      tmp = *i;
     163      i = theDependentsList.erase(i);
     164    }
     165    else
     166    {
     167      ++i;
     168    }
     169  }
    163170  return (tmp != 0);
    164171}
    … …  
    216223  G4VStateDependent* tmp = 0;
    217224  for (std::vector<G4VStateDependent*>::iterator i=theDependentsList.begin();
    218        i!=theDependentsList.end(); i++)
    219     {
    220       if (**i==*aDependent)
    221         {
    222           tmp = *i;
    223           theDependentsList.erase(i);
    224         }
    225     }
     225       i!=theDependentsList.end();)
     226  {
     227    if (**i==*aDependent)
     228    {
     229      tmp = *i;
     230      i = theDependentsList.erase(i);
     231    }
     232    else
     233    {
     234      ++i;
     235    }
     236  }
    226237  return tmp;
    227238}

  • trunk/source/global/management/src/G4UnitsTable.cc

    r1337 r1340  
    2525//
    2626//
    27 // $Id: G4UnitsTable.cc,v 1.37 2008/05/06 17:17:08 maire Exp $
    28 // GEANT4 tag $Name: geant4-09-04-beta-01 $
     27// $Id: G4UnitsTable.cc,v 1.38 2010/08/09 15:21:14 maire Exp $
     28// GEANT4 tag $Name: global-V09-03-22 $
    2929//
    3030//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
    … …  
    4343// 18-08-06: remove symbol mum (mma)
    4444// 06-05-08: V/m ("Electric field")  (mma)
     45// 09-08-10: new category "Solid angle"  (mma)
    4546//
    4647//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
    … …  
    217218 new G4UnitDefinition(     "radian","rad"    ,"Angle",radian);
    218219 new G4UnitDefinition("milliradian","mrad"   ,"Angle",milliradian);
    219  new G4UnitDefinition(  "steradian","sr"     ,"Angle",steradian);
    220220 new G4UnitDefinition(     "degree","deg"    ,"Angle",degree);
    221221 
     222 //Solid angle
     223 new G4UnitDefinition(  "steradian","sr"     ,"Solid angle",steradian);
     224 new G4UnitDefinition("millisteradian","msr" ,"Solid angle",steradian*0.001);
     225   
    222226 //Time
    223227 new G4UnitDefinition(     "second","s"      ,"Time",second);
Note: See TracChangeset for help on using the changeset viewer.