source: trunk/documents/UserDoc/DocBookUsersGuides/ForApplicationDeveloper/xml/Fundamentals/global.xml @ 1358

<!-- ******************************************************** -->
<!--                                                          -->
<!--  [History]                                               -->
<!--    Changed by: Katsuya Amako, 21-Sep-1998                -->
<!--    Changed by: Katsuya Amako,  9-Jul-1998                -->
<!--    Proof read by: Joe Chuma,   2-Jul-1999                -->
<!--    Changed by: Katsuya Amako, 15-Jul-2000                -->
<!--    Changed by: Dennis Wright, 29-Nov-2001                -->
<!--    Converted to DocBook: Katsuya Amako, Aug-2006         -->
<!--                                                          -->
<!-- ******************************************************** -->


<!-- ******************* Section (Level#1) ****************** -->
<sect1 id="sect.GlobClass">
<title>
Global Usage Classes
</title>

<para>
The "global" category in Geant4 collects all classes, types,
structures and constants which are considered of general use within
the Geant4 toolkit. This category also defines the interface with
third-party software libraries (CLHEP, STL, etc.) and
system-related types, by defining, where appropriate,
<literal>typedef</literal>s according to the Geant4 code conventions.
</para>

<!-- ******************* Section (Level#2) ****************** -->
<sect2 id="sect.GlobClass.SignClass">
<title>
Signature of Geant4 classes
</title>

<para>
In order to keep an homogeneous naming style, and according to
the Geant4 coding style conventions, each class part of the Geant4
kernel has its name beginning with the prefix <emphasis>G4</emphasis>, e.g.,
<emphasis>G4VHit, G4GeometryManager, G4ProcessVector</emphasis>, etc. Instead of
the raw C types, <emphasis>G4</emphasis> types are used within the Geant4 code.
For the basic numeric types (<literal>int, float, double</literal>, etc.),
different compilers and different platforms provide different value
ranges. In order to assure portability, the use of <emphasis>G4int,
G4float, G4double, G4bool</emphasis>, globally defined, is preferable.
<emphasis>G4</emphasis> types implement the right generic type
for a given architecture.
</para>

<!-- ******************* Section (Level#3) ****************** -->
<sect3 id="sect.GlobClass.SignClass.BasicType">
<title>
Basic types
</title>

<para>
The basic types in Geant4 are considered to be the
following:

<itemizedlist spacing="compact">
   <listitem><para>
     <emphasis>G4int</emphasis>,
   </para></listitem>
   <listitem><para>
     <emphasis>G4long</emphasis>,
   </para></listitem>
   <listitem><para>
     <emphasis>G4float</emphasis>,
   </para></listitem>
   <listitem><para>
     <emphasis>G4double</emphasis>,
   </para></listitem>
   <listitem><para>
     <emphasis>G4bool</emphasis>,
   </para></listitem>
   <listitem><para>
     <emphasis>G4complex</emphasis>,
   </para></listitem>
   <listitem><para>
     <emphasis>G4String</emphasis>.
   </para></listitem>
</itemizedlist>

which currently consist of simple <literal>typedef</literal>s to
respective types defined in the <emphasis role="bold">CLHEP</emphasis>, 
<emphasis role="bold">STL</emphasis> or system
libraries. Most definitions of these basic types come with the
inclusion of a single header file, <literal>globals.hh</literal>. This file
also provides inclusion of required system headers, as well as some
global utility functions needed and used within the Geant4
kernel.
</para>

</sect3>

<!-- ******************* Section (Level#3) ****************** -->
<sect3 id="sect.GlobClass.SignClass.Typedefs">
<title>
Typedefs to CLHEP classes and their usage
</title>

<para>
The following classes are <literal>typedef</literal>s to the corresponding
classes of the <emphasis role="bold">CLHEP</emphasis> 
(<emphasis role="bold">Computing Library for High Energy Physics</emphasis>) 
distribution. For more detailed documentation please refer to the 
<ulink url="http://cern.ch/clhep/manual/RefGuide/">
<emphasis role="bold">CLHEP reference guide</emphasis>
</ulink>
and the 
<ulink url="http://cern.ch/clhep/manual/UserGuide/">
<emphasis role="bold">CLHEP user manual</emphasis>
</ulink>
.

<itemizedlist spacing="compact">
  <listitem><para>
    <emphasis>G4ThreeVector, G4RotationMatrix, G4LorentzVector</emphasis> and
    <emphasis>G4LorentzRotation</emphasis>
    <para>
    Vector classes: defining 3-component (x,y,z) vector entities,
    rotation of such objects as 3x3 matrices,
    4-component (x,y,z,t) vector entities and their rotation as 4x4 matrices.
    </para>
  </para></listitem>
  <listitem><para>
    <emphasis>G4Plane3D, G4Transform3D, G4Normal3D, G4Point3D</emphasis>, and
    <emphasis>G4Vector3D</emphasis>
    <para>
    Geometrical classes: defining geometrical entities and
    transformations in 3D space.
    </para>
  </para></listitem>
</itemizedlist>
</para>

</sect3>
</sect2>


<!-- ******************* Section (Level#2) ****************** -->
<sect2 id="sect.GlobClass.HEPRandom">
<title>
The <emphasis>HEPRandom</emphasis> module in CLHEP
</title>

<para>
The <emphasis>HEPRandom</emphasis> module, originally part of the Geant4
kernel, and now distributed as a module of <emphasis
role="bold">CLHEP</emphasis>, 
has been designed and developed starting from the <emphasis>Random</emphasis> 
class of MC++, the original <emphasis role="bold">CLHEP</emphasis>'s 
<emphasis>HepRandom</emphasis> module and the 
<emphasis role="bold">Rogue Wave</emphasis> approach in the 
<emphasis role="bold">Math.h++</emphasis> package. For
detailed documentation on the <emphasis>HEPRandom</emphasis> classes see the

<ulink url="http://cern.ch/clhep/manual/RefGuide/">
<emphasis role="bold">CLHEP reference guide</emphasis>
</ulink>
and the 
<ulink url="http://cern.ch/clhep/manual/UserGuide/">
<emphasis role="bold">CLHEP user manual</emphasis>
</ulink>
.
</para>

<para>
Information written in this manual is extracted from the
original 
<ulink url="http://cern.ch/clhep/manual/UserGuide/Random/Random.html">
manifesto
</ulink>
 distributed with the <emphasis>HEPRandom</emphasis>
package.</para>

<para>
The <emphasis>HEPRandom</emphasis> module consists of classes implementing
different random ``engines'' and different random
``distributions''. A distribution associated to an engine
constitutes a random ``generator''. A distribution class can
collect different algorithms and different calling sequences for
each method to define distribution parameters or range-intervals.
An engine implements the basic algorithm for pseudo-random numbers
generation.
</para>

<para>
There are 3 different ways of shooting random values:

<orderedlist spacing="compact">
  <listitem><para>
    Using the static generator defined in the <emphasis>HepRandom</emphasis>
    class: random values are shot using static methods <literal>shoot()</literal>
    defined for each distribution class. The static generator will use,
    as default engine, a <emphasis>HepJamesRandom</emphasis> object, and the user can
    set its properties or change it with a new instantiated engine
    object by using the static methods defined in the <emphasis>HepRandom</emphasis>
    class.
  </para></listitem>
  <listitem><para>
    Skipping the static generator and specifying an engine object:
    random values are shot using static methods
    <literal>shoot(*HepRandomEngine)</literal> defined for each distribution
    class. The user must instantiate an engine object and give it as
    argument to the shoot method. The generator mechanism will then be
    by-passed by using the basic <literal>flat()</literal> method of the
    specified engine. The user must take care of the engine objects
    he/she instantiates.
  </para></listitem>
  <listitem><para>
    Skipping the static generator and instantiating a distribution
    object: random values are shot using <literal>fire()</literal> methods (NOT
    static) defined for each distribution class. The user must
    instantiate a distribution object giving as argument to the
    constructor an engine by pointer or by reference. By doing so, the
    engine will be associated to the distribution object and the
    generator mechanism will be by-passed by using the basic
    <literal>flat()</literal> method of that engine.
  </para></listitem>
</orderedlist>
</para>

<para>
In this guide, we'll only focus on the static generator (point
1.), since the static interface of <emphasis>HEPRandom</emphasis> is the only one
used within the Geant4 toolkit.
</para>

<!-- ******************* Section (Level#3) ****************** -->
<sect3 id="sect.GlobClass.HEPRandom.Engines">
<title>
<emphasis>HEPRandom</emphasis> engines
</title>

<para>
The class <emphasis>HepRandomEngine</emphasis> is the abstract class defining
the interface for each random engine. It implements the
<literal>getSeed()</literal> and <literal>getSeeds()</literal> methods which return the
`initial seed' value and the initial array of seeds (if any)
respectively. Many concrete random engines can be defined and added
to the structure, simply making them inheriting from
<emphasis>HepRandomEngine</emphasis>. Several different engines are currently
implemented in <emphasis>HepRandom</emphasis>, we describe here five of them:

<itemizedlist spacing="compact">
  <listitem><para>
    <emphasis>HepJamesRandom</emphasis>
    <para>
    It implements the algorithm described in ``F.James, Comp. Phys.
    Comm. 60 (1990) 329'' for pseudo-random number generation. This is
    the default random engine for the static generator; it will be
    invoked by each distribution class unless the user sets a different one.
    </para>
  </para></listitem>
  <listitem><para>
    <emphasis>DRand48Engine</emphasis>
    <para>
    Random engine using the <literal>drand48()</literal> and
    <literal>srand48()</literal> system functions from C standard library to
    implement the <literal>flat()</literal> basic distribution and for setting
    seeds respectively. <emphasis>DRand48Engine</emphasis> uses the 
    <literal>seed48()</literal>
    function from C standard library to retrieve the current internal
    status of the generator, which is represented by 3 short values.
    <emphasis>DRand48Engine</emphasis> is the only engine defined in 
    <emphasis>HEPRandom</emphasis>
    which intrinsically works in 32 bits precision. Copies of an object
    of this kind are not allowed.
    </para>
  </para></listitem>
  <listitem><para>
    <emphasis>RandEngine</emphasis>
    <para>
    Simple random engine using the <literal>rand()</literal> and
    <literal>srand()</literal> system functions from the C standard library to
    implement the <literal>flat()</literal> basic distribution and for setting
    seeds respectively. Please note that it's well known that the
    spectral properties of <literal>rand()</literal> leave a great deal to be
    desired, therefore the usage of this engine is not recommended if a
    good randomness quality or a long period is required in your code.
    Copies of an object of this kind are not allowed.
    </para>
  </para></listitem>
  <listitem><para>
    <emphasis>RanluxEngine</emphasis>
    <para>
    The algorithm for <emphasis>RanluxEngine</emphasis> has been taken from the
    original implementation in FORTRAN77 by Fred James, part of the
    <emphasis role="bold">MATHLIB HEP</emphasis> library. The initialisation is 
    carried out using
    a Multiplicative Congruential generator using formula constants of
    L'Ecuyer as described in ``F.James, Comp. Phys. Comm. 60 (1990)
    329-344''. The engine provides five different luxury levels for
    quality of random generation. When instantiating a
    <emphasis>RanluxEngine</emphasis>, the user can specify the luxury level to the
    constructor (if not, the default value 3 is taken). For example:

    <informalexample>
    <programlisting>
      RanluxEngine theRanluxEngine(seed,4);
      // instantiates an engine with `seed' and the best luxury-level
      ... or
      RanluxEngine theRanluxEngine;
      // instantiates an engine with default seed value and luxury-level
      ...
    </programlisting>
    </informalexample>

    The class provides a <literal>getLuxury()</literal> method to get the
    engine luxury level.
    </para>
    <para>
    The <literal>SetSeed()</literal> and <literal>SetSeeds()</literal> 
    methods to set the initial seeds for the engine, can be invoked specifying 
    the luxury level. For example:

    <informalexample>
    <programlisting>
      // static interface
      HepRandom::setTheSeed(seed,4);  // sets the seed to `seed' and luxury to 4
      HepRandom::setTheSeed(seed);    // sets the seed to `seed' keeping
                                      // the current luxury level
    </programlisting>
    </informalexample>
    </para>
  </para></listitem>
  <listitem><para>
    <emphasis>RanecuEngine</emphasis>
    <para>
    The algorithm for <emphasis>RanecuEngine</emphasis> is taken from the one
    originally written in FORTRAN77 as part of the 
    <emphasis role="bold">MATHLIB HEP</emphasis>
    library. The initialisation is carried out using a Multiplicative
    Congruential generator using formula constants of L'Ecuyer as
    described in ``F.James, Comp. Phys. Comm. 60 (1990) 329-344''.
    Handling of seeds for this engine is slightly different than the
    other engines in <emphasis>HEPRandom</emphasis>. Seeds are taken from a seed
    table given an index, the <literal>getSeed()</literal> method returns the
    current index of seed table. The <literal>setSeeds()</literal> method will
    set seeds in the local <literal>SeedTable</literal> at a given position index
    (if the index number specified exceeds the table's size,
    <literal>[index%size]</literal> is taken). For example:

    <informalexample>
    <programlisting>                                     
      // static interface
      const G4long* table_entry;
      table_entry = HepRandom::getTheSeeds();
      // it returns a pointer `table_entry' to the local SeedTable
      // at the current `index' position. The couple of seeds
      // accessed represents the current `status' of the engine itself !
      ...
      G4int index=n;
      G4long seeds[2];
      HepRandom::setTheSeeds(seeds,index);
      // sets the new `index' for seeds and modify the values inside
      // the local SeedTable at the `index' position. If the index
      // is not specified, the current index in the table is considered.
      ...
    </programlisting>
    </informalexample>                                     
    </para>

    <para>
    The <literal>setSeed()</literal> method resets the current `status' of the
    engine to the original seeds stored in the static table of seeds in
    <emphasis>HepRandom</emphasis>, at the specified index.
    </para>
  </para></listitem>
</itemizedlist>
</para>

<para>
Except for the <emphasis>RanecuEngine</emphasis>, for which the internal
status is represented by just a couple of longs, all the other
engines have a much more complex representation of their internal
status, which currently can be obtained only through the methods
<literal>saveStatus()</literal>, <literal>restoreStatus()</literal> and
<literal>showStatus()</literal>, which can also be statically called from
<emphasis>HepRandom</emphasis>. The status of the generator is needed for example
to be able to reproduce a run or an event in a run at a given stage
of the simulation.
</para>

<para>
<emphasis>RanecuEngine</emphasis> is probably the most suitable engine for
this kind of operation, since its internal status can be
fetched/reset by simply using
<literal>getSeeds()</literal>/<literal>setSeeds()</literal>
(<literal>getTheSeeds()</literal>/<literal>setTheSeeds()</literal> for the static
interface in <emphasis>HepRandom</emphasis>).
</para>

</sect3>


<!-- ******************* Section (Level#3) ****************** -->
<sect3 id="sect.GlobClass.HEPRandom.StaticInt">
<title>
The static interface in the <emphasis>HepRandom</emphasis> class
</title>

<para>
<emphasis>HepRandom</emphasis> a singleton class and using a
<emphasis>HepJamesRandom</emphasis> engine as default algorithm for pseudo-random
number generation. <emphasis>HepRandom</emphasis> defines a static private data
member, <literal>theGenerator</literal>, and a set of static methods to
manipulate it. By means of <literal>theGenerator</literal>, the user can
change the underlying engine algorithm, get and set the seeds, and
use any kind of defined random distribution. The static methods
<literal>setTheSeed()</literal> and <literal>getTheSeed()</literal> will set and get
respectively the `initial' seed to the main engine used by the
static generator. For example:

<informalexample>
<programlisting>                                     
      HepRandom::setTheSeed(seed);  // to change the current seed to 'seed'
      int startSeed = HepRandom::getTheSeed();  // to get the current initial seed
      HepRandom::saveEngineStatus();    // to save the current engine status on file
      HepRandom::restoreEngineStatus(); // to restore the current engine to a previous
                                        // saved configuration
      HepRandom::showEngineStatus();    // to display the current engine status to stdout
      ...
      int index=n;
      long seeds[2];
      HepRandom::getTheTableSeeds(seeds,index);
        // fills `seeds' with the values stored in the global
        // seedTable at position `index'
</programlisting>
</informalexample>                                      
</para>

<para>
Only one random engine can be active at a time, the user can
decide at any time to change it, define a new one (if not done
already) and set it. For example:

<informalexample>
<programlisting>                                      
      RanecuEngine theNewEngine;
      HepRandom::setTheEngine(&amp;theNewEngine);
       ...
</programlisting>
</informalexample>                                      

or simply setting it to an old instantiated engine (the old
engine status is kept and the new random sequence will start
exactly from the last one previously interrupted). For example:

<informalexample>
<programlisting>                                      
      HepRandom::setTheEngine(&amp;myOldEngine);
</programlisting>
</informalexample>                                       
</para>

<para>
Other static methods defined in this class are:

<itemizedlist spacing="compact">
  <listitem><para>
    <literal>void setTheSeeds(const G4long* seeds, G4int)</literal>
  </para></listitem>
  <listitem><para>
    <literal>const G4long* getTheSeeds()</literal>
    <para>
    To set/get an array of seeds for the generator, in the case of a
    <emphasis>RanecuEngine</emphasis> this corresponds also to set/get the current
    status of the engine.
    </para>
  </para></listitem>
  <listitem><para>
    <literal>HepRandomEngine* getTheEngine()</literal>
    <para>
    To get a pointer to the current engine used by the static
    generator.
    </para>
  </para></listitem>
</itemizedlist>
</para>

</sect3>

<!-- ******************* Section (Level#3) ****************** -->
<sect3 id="sect.GlobClass.HEPRandom.Distri">
<title>
<emphasis>HEPRandom</emphasis> distributions
</title>

<para>
A distribution-class can collect different algorithms and
different calling sequences for each method to define distribution
parameters or range-intervals; it also collects methods to fill
arrays, of specified size, of random values, according to the
distribution. This class collects either static and not static
methods. A set of distribution classes are defined in
<emphasis>HEPRandom</emphasis>. Here is the description of some of them:

<itemizedlist spacing="compact">
  <listitem><para>
    <emphasis>RandFlat</emphasis>
    <para>
    Class to shoot flat random values (integers or double) within a
    specified interval. The class provides also methods to shoot just
    random bits.
    </para>
  </para></listitem>
  <listitem><para>
    <emphasis>RandExponential</emphasis>
    <para>
    Class to shoot exponential distributed random values, given a
    mean (default mean = 1)
    </para>
  </para></listitem>
  <listitem><para>
    <emphasis>RandGauss</emphasis>
    <para>
    Class to shoot Gaussian distributed random values, given a mean
    (default = 0) or specifying also a deviation (default = 1).
    Gaussian random numbers are generated two at the time, so every
    other time a number is shot, the number returned is the one
    generated the time before.
    </para>
  </para></listitem>
  <listitem><para>
    <emphasis>RandBreitWigner</emphasis>
    <para>
    Class to shoot numbers according to the Breit-Wigner
    distribution algorithms (plain or mean^2).
    </para>
  </para></listitem>
  <listitem><para>
    <emphasis>RandPoisson</emphasis>
    <para>
    Class to shoot numbers according to the Poisson distribution,
    given a mean (default = 1) (Algorithm taken from ``W.H.Press et
    al., Numerical Recipes in C, Second Edition'').
    </para>
  </para></listitem>
</itemizedlist>
</para>

</sect3>
</sect2>


<!-- ******************* Section (Level#2) ****************** -->
<sect2 id="sect.HEPNumerics">
<title>
The <emphasis>HEPNumerics</emphasis> module
</title>

<para>
A set of classes implementing numerical algorithms has been
developed in Geant4. Most of the algorithms and methods have been
implemented mainly based on recommendations given in the books:

<itemizedlist spacing="compact">
  <listitem><para>
    B.H. Flowers, ``An introduction to Numerical Methods In C++'',
    Claredon Press, Oxford 1995.
  </para></listitem>
  <listitem><para>
    M. Abramowitz, I. Stegun, ``Handbook of mathematical
    functions'', DOVER Publications INC, New York 1965 ; chapters 9,
    10, and 22.
  </para></listitem>
</itemizedlist>
</para>

<para>
This set of classes includes:

<itemizedlist spacing="compact">
  <listitem><para>
    <emphasis>G4ChebyshevApproximation</emphasis>
    <para>
    Class creating the Chebyshev approximation for a function
    pointed by fFunction data member. The Chebyshev polynomial
    approximation provides an efficient evaluation of the minimax
    polynomial, which (among all polynomials of the same degree) has
    the smallest maximum deviation from the true function.
    </para>
  </para></listitem>
  <listitem><para>
    <emphasis>G4DataInterpolation</emphasis>
    <para>
    Class providing methods for data interpolations and
    extrapolations: Polynomial, Cubic Spline, ...
    </para>
  </para></listitem>
  <listitem><para>
    <emphasis>G4GaussChebyshevQ</emphasis>
  </para></listitem>
  <listitem><para>
    <emphasis>G4GaussHermiteQ</emphasis>
  </para></listitem>
  <listitem><para>
    <emphasis>G4GaussJacobiQ</emphasis>
  </para></listitem>
  <listitem><para>
    <emphasis>G4GaussLaguerreQ</emphasis>
    <para>
    Classes implementing the Gauss-Chebyshev, Gauss-Hermite,
    Gauss-Jacobi, Gauss-Laguerre and Gauss-Legendre quadrature methods.
    Roots of orthogonal polynomials and corresponding weights are
    calculated based on iteration method (by bisection Newton
    algorithm).
    </para>
  </para></listitem>
  <listitem><para>
    <emphasis>G4Integrator</emphasis>
    <para>
    Template class collecting integrator methods for generic
    functions (Legendre, Simpson, Adaptive Gauss, Laguerre, Hermite,
    Jacobi).
    </para>
  </para></listitem>
  <listitem><para>
    <emphasis>G4SimpleIntegration</emphasis>
    <para>
    Class implementing simple numerical methods (Trapezoidal,
    MidPoint, Gauss, Simpson, Adaptive Gauss, for integration of
    functions with signature: double f(double).
    </para>
  </para></listitem>
</itemizedlist>
</para>

</sect2>

<!-- ******************* Section (Level#2) ****************** -->
<sect2 id="sect.GeneManage">
<title>
General management classes
</title>

<para>
The `global' category defines also a set of `utility' classes
generally used within the kernel of Geant4. These classes
include:

<itemizedlist spacing="compact">
  <listitem><para>
    <emphasis>G4Allocator</emphasis>
    <para>
    A class for fast allocation of objects to the heap through
    paging mechanism. It's meant to be used by associating it to the
    object to be allocated and defining for it <literal>new</literal> and
    <literal>delete</literal> operators via <literal>MallocSingle()</literal> and
    <literal>FreeSingle()</literal> methods of <emphasis>G4Allocator</emphasis>.
    </para>
    <para>
    <emphasis role="bold">Note</emphasis>:
    <literal>G4Allocator</literal> assumes that objects being allocated
    have all the same size for the type they represent. For this reason,
    classes which are handled by <literal>G4Allocator</literal> should
    <emphasis>avoid</emphasis> to be used as base-classes for others.
    Similarly, base-classes of sub-classes handled through
    <literal>G4Allocator</literal> should not define their (eventually
    empty) virtual destructors inlined; such measure is necessary in order
    also to prevent bad aliasing optimisations by compilers which may
    potentially lead to crashes in the attempt to free allocated chunks
    of memory when using the base-class pointer or not.
    </para>
    <para>
    The list of allocators implicitely defined and used in Geant4 is reported here:
    <informalexample>
    <programlisting>
      - events (G4Event): anEventAllocator
      - tracks (G4Track): aTrackAllocator
      - stacked tracks (G4StackedTrack): aStackedTrackAllocator
      - primary particles (G4PrimaryParticle): aPrimaryParticleAllocator
      - primary vertices (G4PrimaryVertex): aPrimaryVertexAllocator
      - decay products (G4DecayProducts): aDecayProductsAllocator
      - digits collections of an event (G4DCofThisEvent): anDCoTHAllocator
      - digits collections (G4DigiCollection): aDCAllocator
      - hits collections of an event (G4HCofThisEvent): anHCoTHAllocator
      - hits collections (G4HitsCollection): anHCAllocator
      - touchable histories (G4TouchableHistory): aTouchableHistoryAllocator
      - trajectories (G4Trajectory): aTrajectoryAllocator
      - trajectory points (G4TrajectoryPoint): aTrajectoryPointAllocator
      - trajectory containers (G4TrajectoryContainer): aTrajectoryContainerAllocator
      - navigation levels (G4NavigationLevel): aNavigationLevelAllocator
      - navigation level nodes (G4NavigationLevelRep): aNavigLevelRepAllocator
      - reference-counted handles (G4ReferenceCountedHandle&lt;X&gt;): aRCHAllocator
      - counted objects (G4CountedObject&lt;X&gt;): aCountedObjectAllocator
      - HEPEvt primary particles (G4HEPEvtParticle): aHEPEvtParticleAllocator
      - electron occupancy objects(G4ElectronOccupancy): aElectronOccupancyAllocator
      - "rich" trajectories (G4RichTrajectory): aRichTrajectoryAllocator
      - "rich" trajectory points (G4RichTrajectoryPoint): aRichTrajectoryPointAllocator
      - "smooth" trajectories (G4SmoothTrajectory): aSmoothTrajectoryAllocator
      - "smooth" trajectory points (G4SmoothTrajectoryPoint): aSmoothTrajectoryPointAllocator
      - "ray" trajectories (G4RayTrajectory): G4RayTrajectoryAllocator
      - "ray" trajectory points (G4RayTrajectoryPoint): G4RayTrajectoryPointAllocator
    </programlisting>
    </informalexample>
    For each of these allocators, accessible from the global namespace, it is
    possible to monitor the allocation in their memory pools or force them to
    release the allocated memory (for example at the end of a run):
    <informalexample>
    <programlisting>
      // Return the size of the total memory allocated for tracks
      //
      aTrackAllocator.GetAllocatedSize();

      // Return allocated storage for tracks to the free store
      //
      aTrackAllocator.ResetStorage();
    </programlisting>
    </informalexample>
    </para>
  </para></listitem>
  <listitem><para>
    <emphasis>G4ReferenceCountedHandle</emphasis>
    <para>
    Template class acting as a smart pointer and wrapping the type
    to be counted. It performs the reference counting during the
    life-time of the counted object.
    </para>
  </para></listitem>
  <listitem><para>
    <emphasis>G4FastVector</emphasis>
    <para>
    Template class defining a vector of pointers, not performing
    boundary checking.
    </para>
  </para></listitem>
  <listitem><para>
    <emphasis>G4PhysicsVector</emphasis>
    <para>
    Defines a physics vector which has values of energy-loss,
    cross-section, and other physics values of a particle in matter in
    a given range of the energy, momentum, etc. This class serves as
    the base class for a vector having various energy scale, for
    example like 'log' (<emphasis>G4PhysicsLogVector</emphasis>) 'linear'
    (<emphasis>G4PhysicsLinearVector</emphasis>), 'free'
    (<emphasis>G4PhysicsFreeVector</emphasis>), etc.
    </para>
  </para></listitem>
  <listitem><para>
    <emphasis>G4LPhysicsFreeVector</emphasis>
    <para>
    Implements a free vector for low energy physics cross-section
    data. A subdivision method is used to find the energy|momentum
    bin.
    </para>
  </para></listitem>
  <listitem><para>
    <emphasis>G4PhysicsOrderedFreeVector</emphasis>
    <para>
    A physics ordered free vector inherits from
    <emphasis>G4PhysicsVector</emphasis>. It provides, in addition, a method
    for the user to insert energy/value pairs in sequence. Methods to retrieve
    the max and min energies and values from the vector are also
    provided.
    </para>
  </para></listitem>
  <listitem><para>
    <emphasis>G4Timer</emphasis>
    <para>
    Utility class providing methods to measure elapsed user/system
    process time.
    Uses <literal>&lt;sys/times.h&gt;</literal> and <literal>&lt;unistd.h&gt;</literal> -
    POSIX.1.
    </para>
  </para></listitem>
  <listitem><para>
    <emphasis>G4UserLimits</emphasis>
    <para>
    Class collecting methods for get and set any kind of step
    limitation allowed in Geant4.
    </para>
  </para></listitem>
  <listitem><para>
    <emphasis>G4UnitsTable</emphasis>
    <para>
    Placeholder for the system of units in Geant4.
    </para>
  </para></listitem>
</itemizedlist>
</para>


</sect2>
</sect1>