Class Specifications for Geometry


       Class name:
          G4GeometryManager

       Category:		Geometry
       Documentation:
          A class responsible for managing high level objects in
          the geometrical
          subsystem, notably including opening and closing
          (`locking') the geometry, and  creating/deleting
          optimisation information for G4Navigator.

       Export Control:	Public
       Cardinality:		1
       Hierarchy:
          Superclasses:	none
       Public Uses:
	                G4LogicalVolume	

       Public Interface:
          Operations:
                        CloseGeometry (G4bool)
                        GetInstance ( )
                        OpenGeometry ( )

       Private Interface:
          Has-A Relationships:
	                G4GeometryManager	fgInstance

          Operations:
                        BuildOptimisations ( )
                        DeleteOptimisations ( )

       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Operation name:
          BuildOptimisations

       Private member of:	G4GeometryManager
       Return Class:	void
       Documentation:
          Build all necessary optimisation info. Currently
          consists of looping over all  defined logical volumes
          and creating smart voxels.

       Concurrency:	Sequential



       Operation name:
          CloseGeometry

       Public member of:	G4GeometryManager
       Return Class:	G4bool
       Arguments:
	          G4bool	pOptimize=true
       Documentation:
          Close (`lock') the geometry: perform sanity and
          `completion' checks, and optionally build optimisation
          information.

       Concurrency:	Sequential



       Operation name:
          DeleteOptimisations

       Private member of:	G4GeometryManager
       Return Class:	void
       Documentation:
          Destroy any optimisation info created by
          BuildOptimisations. Currently consists of looping over
          all created logical volumes and deleting any smart
          voxels.

       Concurrency:	Sequential



       Operation name:
          GetInstance

       Public member of:	G4GeometryManager
       Return Class:	G4GeometryManager*
       Documentation:
          Return ptr to the singleton geometry manager

       Concurrency:	Sequential



       Operation name:
          OpenGeometry

       Public member of:	G4GeometryManager
       Return Class:	void
       Documentation:
          Open (`unlock') the geometry and remove optimisation
          information if present.

       Concurrency:	Sequential



       Class name:
          G4RotationMatrixStore

       Category:		Geometry
       Documentation:
          Responsible for storing and providing access to all
          rotation matrices

       Export Control:	Public
       Cardinality:		1
       Hierarchy:
          Superclasses:	none
       Private Interface:
          Has-A Relationships:
	                G4RotationMatrixStore	fgInstance
	                G4RotationMatrix	frotationMatrices

       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Class name:
          G4LogicalVolume

       Category:		Geometry
       Documentation:
          Represents a leaf node or unpositioned subtree in the
          geometry hierarchy. It may have daughters ascribed to
          it, and is responsible for retrieval of the physical
          and tracking attributes of the physical volume that it
          represents. [material, visualisation attribute,
          solid..]

       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	none
       Public Uses:
	                G4LogicalVolumeStore	

       Public Interface:
          Operations:
                        AddDaughter (G4VPhysicalVolume*)
                        GetDaughter (G4int)
                        GetMagneticField ( )
                        GetMaterial ( )
                        GetName ( )
                        GetNoDaughters ( )
                        GetSensitiveDetector ( )
                        GetSolid ( )
                        GetUserLimits ( )
                        GetVoxelHeader ( )
                        IsDaughter (G4VPhysicalVolume*)
                        RemoveDaughter (G4VPhysicalVolume*)
                        SetMagneticField (G4MagneticField*)
                        SetMaterial (G4Material*)
                        SetName (G4String&)
                        SetSensitiveDetector (G4SensitiveDetector*)
                        SetSolid (G4VSolid)
                        SetUserLimits (G4UserLimits*)
                        SetVoxelHeader (G4VoxelHeader*)
                        operator== (const G4LogicalVolume)

       Private Interface:
          Has-A Relationships:
	                G4VPhysicalVolume	fdaughters
                        The volumes positioned inside the logical
                        volume

	                G4MagneticField	fmagneticField
	                G4Material	fmaterial
	                G4String	fname
	                G4SensitiveDetector	fsensitive
                        Hit calculation

	                G4VSolid	fsolid
	                G4UserLimits	fuserLimits
	                G4SmartVoxelHeader	fvoxel
                        Pure tracking optimisation information


       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Operation name:
          AddDaughter

       Public member of:	G4LogicalVolume
       Arguments:
	          G4VPhysicalVolume*	p
       Concurrency:	Sequential



       Operation name:
          GetDaughter

       Public member of:	G4LogicalVolume
       Return Class:	G4PhysicalVolume*
       Arguments:
	          G4int	n
       Concurrency:	Sequential



       Operation name:
          GetMagneticField

       Public member of:	G4LogicalVolume
       Return Class:	G4MagneticField*
       Documentation:
          Gets current magentic field

       Concurrency:	Sequential



       Operation name:
          GetMaterial

       Public member of:	G4LogicalVolume
       Return Class:	G4Material*
       Documentation:
          Gets current material

       Concurrency:	Sequential



       Operation name:
          GetName

       Public member of:	G4LogicalVolume
       Return Class:	G4String
       Documentation:
          Returns the name of the logical volume

       Concurrency:	Sequential



       Operation name:
          GetNoDaughters

       Public member of:	G4LogicalVolume
       Return Class:	G4int
       Concurrency:	Sequential



       Operation name:
          GetSensitiveDetector

       Public member of:	G4LogicalVolume
       Return Class:	G4SensitiveDetector*
       Documentation:
          Gets current sensitive detector

       Concurrency:	Sequential



       Operation name:
          GetSolid

       Public member of:	G4LogicalVolume
       Return Class:	G4VSolid*
       Concurrency:	Sequential



       Operation name:
          GetUserLimits

       Public member of:	G4LogicalVolume
       Return Class:	G4UserLimits*
       Documentation:
          Gets current user limits

       Concurrency:	Sequential



       Operation name:
          GetVoxelHeader

       Public member of:	G4LogicalVolume
       Return Class:	G4VoxelHeader*
       Documentation:
          Get current voxel header

       Concurrency:	Sequential



       Operation name:
          IsDaughter

       Public member of:	G4LogicalVolume
       Return Class:	G4bool
       Arguments:
	          G4VPhysicalVolume*	p
       Concurrency:	Sequential



       Operation name:
          RemoveDaughter

       Public member of:	G4LogicalVolume
       Return Class:	void
       Arguments:
	          G4VPhysicalVolume*	p
       Concurrency:	Sequential



       Operation name:
          SetMagneticField

       Public member of:	G4LogicalVolume
       Return Class:	void
       Arguments:
	          G4MagneticField*	pField
       Documentation:
          Stes magnetic field

       Concurrency:	Sequential



       Operation name:
          SetMaterial

       Public member of:	G4LogicalVolume
       Return Class:	void
       Arguments:
	          G4Material*	pMaterial
       Documentation:
          Sets material

       Concurrency:	Sequential



       Operation name:
          SetName

       Public member of:	G4LogicalVolume
       Return Class:	void
       Arguments:
	          G4String&	pName
       Concurrency:	Sequential



       Operation name:
          SetSensitiveDetector

       Public member of:	G4LogicalVolume
       Return Class:	void
       Arguments:
	          G4SensitiveDetector*	pSDetector
       Documentation:
          Sets sensitive detector

       Concurrency:	Sequential



       Operation name:
          SetSolid

       Public member of:	G4LogicalVolume
       Arguments:
	          G4VSolid	solid
       Concurrency:	Sequential



       Operation name:
          SetUserLimits

       Public member of:	G4LogicalVolume
       Return Class:	void
       Arguments:
	          G4UserLimits*	pULimits
       Concurrency:	Sequential



       Operation name:
          SetVoxelHeader

       Public member of:	G4LogicalVolume
       Return Class:	void
       Arguments:
	          G4VoxelHeader*	pVoxel
       Documentation:
          Sets current voxel header

       Concurrency:	Sequential



       Operation name:
          operator==

       Public member of:	G4LogicalVolume
       Return Class:	G4bool
       Arguments:
	          const G4LogicalVolume	&lv
       Documentation:
          Returns true if lv has the same address as the current
          object.

       Concurrency:	Sequential



       Class name:
          G4MagneticField

       Category:		Geometry
       Documentation:
          Responsible for the magnetic field in each volume,
          including the calculation of particle trajectories in
          the field. In cases where a geometric
          step limits the particle's step, the distance
          calculated is guaranteed to be to a boundary.

       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	none
       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Class name:
          G4UserLimits

       Category:		Geometry
       Documentation:
          Responsible for user limits on step size

       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	none
       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Class name:
          G4LogicalVolumeStore

       Category:		Geometry
       Documentation:
          Responsible for storing and providing access to all
          logical volumes

       Export Control:	Public
       Cardinality:		1
       Hierarchy:
          Superclasses:	none
       Private Interface:
          Has-A Relationships:
	                G4LogicalVolumeStore	fgInstance
	                G4LogicalVolume	fvolumes
                        The managed volumes



       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient




       Class name:
          G4Navigator

       Category:		Geometry
       Documentation:
          A class for use by the tracking management, able to
          obtain/calculate dynamic tracking time information such
          as the distance to the next volume, or to find the
          physical volume containing agiven point in the world
          reference system. The navigator maintains a
          transformation history and other information to
          optimise the tracking time performance.

       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	none
       Public Interface:
          Operations:
                        ComputeLocalAxis (const G4ThreeVector&)
                        ComputeStep (G4ThreeVector, G4ThreeVector,
                                     G4double, G4double)
                        CreateGRSSolid ( )
                        CreateGRSVolume ( )
                        CreateTouchableHistory ( )
                        GetCurrentLocalCoordinate ( )
                        GetCurrentLocalDirection ( )
                        GetWorldVolume ( )
                        LocateGlobalPointAndSetup (const G4ThreeVector&, G4bool)
                        LocateGlobalPointAndSetup (const G4ThreeVector&,
                                                   const G4TouchableHistory&)
                        NetRotation ( )
                        NetTranslation ( )
                        SetGeometricallyLimitedStep ( )
                        SetWorldVolume (G4VPhysicalVolume*)

       Private Interface:
          Has-A Relationships:
	                G4NavigationHistory	fHistory
	                G4NormalNavigation	fnormalNav
	                G4ParameterisedNavigation	fparamNav
	                G4ReplicaNavigation	freplicaNav
	                G4VPhysicalVolume	ftopPhysical
                        A link to the topmost physical volume in
                        the detector. It must be positioned at
                        the origin and unrotated.


	                G4VoxelNavigation	fvoxelNav

       State machine:	Yes
       Concurrency:		Sequential
       Persistence:		Transient



       Operation name:
          ComputeLocalAxis

       Public member of:	G4Navigator
       Return Class:	G4ThreeVector
       Arguments:
	          const G4ThreeVector&	pVec
       Documentation:
          Returns vector rotated into current local reference
          system

       Concurrency:	Sequential



       Operation name:
          ComputeStep

       Public member of:	G4Navigator
       Return Class:	G4double
       Arguments:
	          G4ThreeVector	globalpoint
	          G4ThreeVector	direction
	          G4double	pCurrentProposedStepLength
	          G4double	&newSafety
       Documentation:
          Calculate the distance to the next boundary intersected
          along the specified NORMALISED vector direction and
          from the specified point in the global coordiante
          system.  LocateGlobalPointAndSetup must have been
          called with the same global point prior to this call.
          The isotropic distance to the nearest boundary is also
          calculated (usually an underesitmate). The current
          proposed step length is used to avoid intersection
          calculations: if it can be determined that the nearest
          boundary is >pCurrentProposedStepLength away, kInfinity
          is returned together with the computed isotropic safety
          distance. Geometry must be closed.

       Semantics:
          Object diagram: Distance Computation

       Concurrency:	Sequential



       Operation name:
          CreateGRSSolid

       Public member of:	G4Navigator
       Return Class:	G4GRSSolid*
       Documentation:
          Returns touchable solid of current volume

       Concurrency:	Sequential



       Operation name:
          CreateGRSVolume

       Public member of:	G4Navigator
       Return Class:	G4GRSVolume*
       Documentation:
          Returns touchable version of current volume

       Concurrency:	Sequential



       Operation name:
          CreateTouchableHistory

       Public member of:	G4Navigator
       Return Class:	G4TouchableHistory*
       Documentation:
          Returns touchable of current volume, including
          hierarchy all history information

       Concurrency:	Sequential



       Operation name:
          GetCurrentLocalCoordinate

       Public member of:	G4Navigator
       Return Class:	G4ThreeVector
       Documentation:
          Return the local coordinate of the current track,
          realtive to its containing volume.

       Concurrency:	Sequential



       Operation name:
          GetCurrentLocalDirection

       Public member of:	G4Navigator
       Return Class:	G4ThreeVector
       Documentation:
          Return the `current' track's direction relative to its
          containing physical volume

       Concurrency:	Sequential



       Operation name:
          GetWorldVolume

       Public member of:	G4Navigator
       Return Class:	G4VPhysicalVolume*
       Documentation:
          Return the current  world (`topmost') volume

       Concurrency:	Sequential



       Operation name:
          LocateGlobalPointAndSetup

       Public member of:	G4Navigator
       Return Class:	G4PhysicalVolume*
       Arguments:
	          const G4ThreeVector&	p
	          G4bool	pRelativeSearch=true
       Documentation:
          Search the geometrical hierarchy for the volumes
          deepest in the hierarchy containing the point in the
          global coordinate space. Makes use of no previous/state
          information. Returns the physical volume containing the
          point, with all previous mothers correctly setup.  If
          pRelativeSearch is set to true, the search begin is the
          geometrical hierarchy at the location of the last
          located point, or the endpoint of the previous step if
          SetGeometricallyLimitedStep() has been called
          immediately before. Geometry must be closed.

       Semantics:
          Object diagram: Point Location

       Concurrency:	Sequential



       Operation name:
          LocateGlobalPointAndSetup

       Public member of:	G4Navigator
       Return Class:	G4VPhysicalVolume*
       Arguments:
	          const G4ThreeVector&	globalPoint
	          const G4TouchableHistory&	history
       Documentation:
          Locate a point in the hierarchy starting from the
          `state'/position stored in the history

       Concurrency:	Sequential



       Operation name:
          NetRotation

       Public member of:	G4Navigator
       Return Class:	G4RotationMatrix
       Documentation:
          Returns current net rotation

       Concurrency:	Sequential



       Operation name:
          NetTranslation

       Public member of:	G4Navigator
       Return Class:	G4ThreeVector
       Documentation:
          Returns current net translation

       Concurrency:	Sequential



       Operation name:
          SetGeometricallyLimitedStep

       Public member of:	G4Navigator
       Return Class:	void
       Documentation:
          Inform the navigator that the previous step calculated
          by the geometry was taken in its entirety

       Concurrency:	Sequential



       Operation name:
          SetWorldVolume

       Public member of:	G4Navigator
       Return Class:	G4bool
       Arguments:
	          G4VPhysicalVolume*	pWorld
       Documentation:
          Set the world (`topmost') volume. This must be
          positioned at (0,0,0) and unrotated

       Concurrency:	Sequential



       Class name:
          G4NavigationHistory

       Category:		Geometry
       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	none
       Public Interface:
          Operations:
                        BackLevel ( )
                        Clear ( )
                        GetDepth ( )
                        GetTopReplicaNo ( )
                        GetTopTransform ( )
                        GetTopVolume ( )
                        GetTopVolumeType ( )
                        NewLevel ( )
                        Reset ( )

       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Operation name:
          BackLevel

       Public member of:	G4NavigationHistory
       Concurrency:	Sequential



       Operation name:
          Clear

       Public member of:	G4NavigationHistory
       Concurrency:	Sequential



       Operation name:
          GetDepth

       Public member of:	G4NavigationHistory
       Concurrency:	Sequential



       Operation name:
          GetTopReplicaNo

       Public member of:	G4NavigationHistory
       Concurrency:	Sequential



       Operation name:
          GetTopTransform

       Public member of:	G4NavigationHistory
       Concurrency:	Sequential



       Operation name:
          GetTopVolume

       Public member of:	G4NavigationHistory
       Concurrency:	Sequential



       Operation name:
          GetTopVolumeType

       Public member of:	G4NavigationHistory
       Concurrency:	Sequential



       Operation name:
          NewLevel

       Public member of:	G4NavigationHistory
       Concurrency:	Sequential



       Operation name:
          Reset

       Public member of:	G4NavigationHistory
       Concurrency:	Sequential



       Class name:
          G4NormalNavigation

       Category:		Geometry
       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	none
       Public Interface:
          Operations:
                        ComputeStep ( )
                        LevelLocate ( )

       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Operation name:
          ComputeStep

       Public member of:	G4NormalNavigation
       Concurrency:	Sequential



       Operation name:
          LevelLocate

       Public member of:	G4NormalNavigation
       Concurrency:	Sequential



       Class name:
          G4VoxelNavigation

       Category:		Geometry
       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	none
       Public Interface:
          Operations:
                        ComputeStep ( )
                        LevelLocate ( )
                        VoxelLocate ( )

       Private Interface:
          Operations:
                        ComputeVoxelSafety ( )
                        LocateNextVoxel ( )
                        VoxelSubLevelSetup ( )

       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Operation name:
          ComputeStep

       Public member of:	G4VoxelNavigation
       Concurrency:	Sequential



       Operation name:
          ComputeVoxelSafety

       Private member of:	G4VoxelNavigation
       Concurrency:	Sequential



       Operation name:
          LevelLocate

       Public member of:	G4VoxelNavigation
       Concurrency:	Sequential



       Operation name:
          LocateNextVoxel

       Private member of:	G4VoxelNavigation
       Concurrency:	Sequential



       Operation name:
          VoxelLocate

       Public member of:	G4VoxelNavigation
       Concurrency:	Sequential



       Operation name:
          VoxelSubLevelSetup

       Private member of:	G4VoxelNavigation
       Concurrency:	Sequential



       Class name:
          G4ReplicaNavigation

       Category:		Geometry
       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	none
       Public Interface:
          Operations:
                        BackLocate ( )
                        ComputeStep ( )
                        ComputeTransform ( )
                        DistanceToOut ( )
                        Inside ( )
                        LevelLocate ( )

       Private Interface:
          Operations:
                        DistanceToOutPhi ( )
                        DistanceToOutRad ( )
                        VoxelLocate ( )

       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Operation name:
          BackLocate

       Public member of:	G4ReplicaNavigation
       Concurrency:	Sequential



       Operation name:
          ComputeStep

       Public member of:	G4ReplicaNavigation
       Concurrency:	Sequential



       Operation name:
          ComputeTransform

       Public member of:	G4ReplicaNavigation
       Concurrency:	Sequential



       Operation name:
          DistanceToOut

       Public member of:	G4ReplicaNavigation
       Concurrency:	Sequential



       Operation name:
          DistanceToOutPhi

       Private member of:	G4ReplicaNavigation
       Concurrency:	Sequential



       Operation name:
          DistanceToOutRad

       Private member of:	G4ReplicaNavigation
       Concurrency:	Sequential



       Operation name:
          Inside

       Public member of:	G4ReplicaNavigation
       Concurrency:	Sequential



       Operation name:
          LevelLocate

       Public member of:	G4ReplicaNavigation
       Concurrency:	Sequential



       Operation name:
          VoxelLocate

       Private member of:	G4ReplicaNavigation
       Concurrency:	Sequential



       Class name:
          G4ParameterisedNavigation

       Category:		Geometry
       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	none
       Public Interface:
          Operations:
                        ComputeStep ( )
                        LevelLocate ( )
                        VoxelLocate ( )

       Private Interface:
          Operations:
                        ComputeVoxelSafety ( )
                        LocateNextVoxel ( )

       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Operation name:
          ComputeStep

       Public member of:	G4ParameterisedNavigation
       Concurrency:	Sequential



       Operation name:
          ComputeVoxelSafety

       Private member of:	G4ParameterisedNavigation
       Concurrency:	Sequential



       Operation name:
          LevelLocate

       Public member of:	G4ParameterisedNavigation
       Concurrency:	Sequential



       Operation name:
          LocateNextVoxel

       Private member of:	G4ParameterisedNavigation
       Concurrency:	Sequential



       Operation name:
          VoxelLocate

       Public member of:	G4ParameterisedNavigation
       Concurrency:	Sequential



       Class name:
          G4VPhysicalVolume

       Category:		Geometry
       Documentation:
          Represents one or many volumes positioned within and
          relative to a mother volume.

       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	none
       Public Interface:
          Operations:
                        GetCopyNo ( )
                        GetLogicalVolume ( )
                        GetMother ( )
                        GetName ( )
                        GetParameterisation ( )
                        GetReplicationData (EAxis&, G4int&, G4double&,
                                            G4double&, G4bool&)
                        GetRotation ( )
                        GetRotation ( )
                        GetTranslation ( )
                        IsMany ( )
                        IsReplicated ( )
                        SetLogicalVolume (G4LogicalVolume*)
                        SetMother (G4VPhysicalVolume*)
                        SetName (G4String&)
                        SetRotation (G4RotationMatrix*)
                        SetTranslation (const G4ThreeVector&)
                        Setup (G4VPhysicalVolume*)
                        operator== (const G4VPhysicalVolume)

       Private Interface:
          Has-A Relationships:
	                G4LogicalVolume	flogical
                        The logical volume representing the
                        physical and tracking attributes of the
                        volume

	                G4VPhysicalVolume	fmother
                        The current mother volume

	                G4String	fname
	                G4RotationMatrix	frot
	                G4ThreeVector	ftrans

       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Operation name:
          GetCopyNo

       Public member of:	G4VPhysicalVolume
       Return Class:	G4int
       Documentation:
          Return the copy number of the volume

       Concurrency:	Sequential



       Operation name:
          GetLogicalVolume

       Public member of:	G4VPhysicalVolume
       Return Class:	G4LogicalVolume*
       Documentation:
          Return the logical volume (subtree) that is positioned.

       Concurrency:	Sequential



       Operation name:
          GetMother

       Public member of:	G4VPhysicalVolume
       Return Class:	G4VPhysicalVolume*
       Documentation:
          Return the volumes *currently active* mother

       Concurrency:	Sequential



       Operation name:
          GetName

       Public member of:	G4VPhysicalVolume
       Return Class:	G4String
       Documentation:
          Returns the volume's name

       Concurrency:	Sequential



       Operation name:
          GetParameterisation

       Public member of:	G4VPhysicalVolume
       Return Class:	G4VPVParameterisation*
       Documentation:
          Returns parameterisation object

       Concurrency:	Sequential



       Operation name:
          GetReplicationData

       Public member of:	G4VPhysicalVolume
       Arguments:
	          EAxis&	axis
	          G4int&	nReplicas
	          G4double&	width
	          G4double&	offset
	          G4bool&	consuming
       Documentation:
          Returns information about replication: axis, no of
          replications, width, offset, and whether consuming
          (completely filling the mother volume)

       Concurrency:	Sequential



       Operation name:
          GetRotation

       Public member of:	G4VPhysicalVolume
       Return Class:	const G4RotationMatrix*
       Documentation:
          Returns current rotation matrix (possbily null =>
          no/identity rotation)

       Concurrency:	Sequential



       Operation name:
          GetRotation

       Public member of:	G4VPhysicalVolume
       Return Class:	G4RotationMatrix*
       Documentation:
          Returns (non const) ptr to current rotation

       Concurrency:	Sequential



       Operation name:
          GetTranslation

       Public member of:	G4VPhysicalVolume
       Return Class:	const G4ThreeVector&
       Documentation:
          Returns current translation

       Concurrency:	Sequential



       Operation name:
          IsMany

       Public member of:	G4VPhysicalVolume
       Return Class:	G4bool
       Documentation:
          Returns true if the volume is MANY

       Concurrency:	Sequential



       Operation name:
          IsReplicated

       Public member of:	G4VPhysicalVolume
       Return Class:	G4bool
       Documentation:
          Returns true if volume represents many touchables

       Concurrency:	Sequential



       Operation name:
          SetLogicalVolume

       Public member of:	G4VPhysicalVolume
       Arguments:
	          G4LogicalVolume*	pLogical
       Concurrency:	Sequential



       Operation name:
          SetMother

       Public member of:	G4VPhysicalVolume
       Arguments:
	          G4VPhysicalVolume*	pMother
       Concurrency:	Sequential



       Operation name:
          SetName

       Public member of:	G4VPhysicalVolume
       Arguments:
	          G4String&	pName
       Concurrency:	Sequential



       Operation name:
          SetRotation

       Public member of:	G4VPhysicalVolume
       Return Class:	void
       Arguments:
	          G4RotationMatrix*	pRot
       Documentation:
          Set current rotation matrix ptr

       Concurrency:	Sequential



       Operation name:
          SetTranslation

       Public member of:	G4VPhysicalVolume
       Return Class:	void
       Arguments:
	          const G4ThreeVector&	v
       Concurrency:	Sequential



       Operation name:
          Setup

       Public member of:	G4VPhysicalVolume
       Return Class:	void
       Arguments:
	          G4VPhysicalVolume*	pMother
       Documentation:
          Calculate the mother-> local (self) transformation for
          the volume, and perform any necessary setup.

       Concurrency:	Sequential



       Operation name:
          operator==

       Public member of:	G4VPhysicalVolume
       Return Class:	G4bool
       Arguments:
	          const G4VPhysicalVolume	&p
       Documentation:
          Returns true if objects have same address

       Concurrency:	Sequential



       Class name:
          G4PVPlacement

       Category:		Geometry
       Documentation:
          A physical volume corresponding to a single touchable
          detector element.

       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	G4VPhysicalVolume
       Private Interface:
          Has-A Relationships:
	                G4int	fcopyNo
                        For (users) unique identification

	                G4bool	fmany
                        Flag for booleans


       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Class name:
          G4PVReplica

       Category:		Geometry
       Documentation:
          Represents many touchable detector elements differing
          only in their
          positioning. The elements' positions are calculated by
          means of a simple
          linear formula, and the elements completely fill the
          containing mother volume.

       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	G4VPhysicalVolume
       Private Interface:
          Has-A Relationships:
	                EAxis	faxis
                        The axis along which replication occurs

	                G4int	fnReplicas
                        The number of replications

	                G4double	foffset
                        The offset of the first replication along
                        the axis (only required for phi
                        replication)

	                G4double	fwidth
                        The width of each replication along the
                        axis 


       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Class name:
          G4PVIndexed

       Category:		Geometry
       Documentation:
          A volume able to perform simple changes to its shape
          and representing
          a single touchable detector element. [Corresponds to
          GSPOSP]

       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	G4PVPlacement
       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Class name:
          G4PVParameterised

       Category:		Geometry
       Documentation:
          Represnts many touchable detector elements. Each
          element's position is
          calculated as per G4PVDivision, and each element's
          shape can be modified by means of a user supplied
          formula.

       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	G4PVReplica
       Private Interface:
          Has-A Relationships:
	                G4VPVParameterisation	fparam
                        The parameterisation object


       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Class name:
          G4VPVParameterisation

       Category:		Geometry
       Documentation:
          Parameterisation class able to tcompute the
          transformation and (indirectly) the dimensions of
          parameterised volumes, given a replication number.

       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	none
       Public Interface:
          Operations:
                        ComputeDimensions (G4Box&, G4int,
                                           G4VPhysicalVolume*)
                        ComputeDimensions (G4Tubs&, G4int,
                                           G4VPhysicalVolume*)
                        ComputeTransformation (G4Transform&, G4int)

       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Operation name:
          ComputeDimensions

       Public member of:	G4VPVParameterisation
       Arguments:
	          G4Box&	pBox
	          G4int	n
	          G4VPhysicalVolume*	pRep
       Documentation:
          Compute the dimensions of the G4Box of given
          replication number and (parameterised) physical volume.

       Concurrency:	Sequential



       Operation name:
          ComputeDimensions

       Public member of:	G4VPVParameterisation
       Arguments:
	          G4Tubs&	pTubs
	          G4int	n
	          G4VPhysicalVolume*	pRep
       Documentation:
          Compute the dimensions of the G4Tubs of given
          replication number and (parameterised) physical volume.

       Concurrency:	Sequential



       Operation name:
          ComputeTransformation

       Public member of:	G4VPVParameterisation
       Arguments:
	          G4Transform&	pTrans
	          G4int	n
       Documentation:
          Compute the transformation  of the specified
          replication

       Concurrency:	Sequential
       The parameterisation object




       Class name:
          MyCustomG4PVParameterisation

       Category:		Geometry
       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	G4VPVParameterisation
       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient
       The volumes positioned inside the logical volume

       The logical volume representing the physical and tracking
       attributes of the volume



       Class name:
          G4Box

       Category:		Geometry
       Documentation:
          A cuboid of given half lengths dx dy dz. The box is
          centred on the origin with sides parallel to the x/y/z
          axes appropriately.

       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	G4VSolid
       Public Interface:
          Operations:
                        G4Box (const G4String, G4double, G4double, G4double)

       Protected Interface:
          Operations:
                        CalculateRotatedVertices (const G4Transform)

       Private Interface:
          Has-A Relationships:
	                G4double	fDx
                        The x half-length

	                G4double	fDy
                        The y half-length

	                G4double	fDz
                        The z half-length


       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Operation name:
          CalculateRotatedVertices

       Protected member of:	G4Box
       Return Class:	G4ThreeVectorList*
       Arguments:
	          const G4Transform	&pTransform
       Documentation:
          Create the list of transformed vertices in the format
          required for G4VSolid::ClipCrossSection and
          ClipBetweenSections

       Concurrency:	Sequential



       Operation name:
          G4Box

       Public member of:	G4Box
       Arguments:
	          const G4String	&pName
	          G4double	pX
	          G4double	pY
	          G4double	pZ
       Documentation:
          Construct a box with the given name and half lengths.

       Concurrency:	Sequential



       Class name:
          G4Tubs

       Category:		Geometry
       Documentation:
          A tube or tube segment with curved sides parallel to
          the z-axis. The tube has a specified half-length along
          the z axis, about which it is centred, and a given
          minimum and maximum radius. A minimum radius of 0
          signifies a filled tube /cylinder. The tube segment is
          specified by starting and delta
          angles for phi, with 0 being the +x axis, 90 or PI/2
          the +z axis. A delta angle of 360 or 2PI signifies a
          complete, unsegmented tube/cylinder.

       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	G4VSolid
       Public Interface:
          Operations:
                        G4Tubs (const G4String, G4double, G4double,
                                G4double, G4double, G4bool)

       Protected Interface:
          Operations:
                        CalculateRotatedVertices (const G4Transform)

       Private Interface:
          Has-A Relationships:
	                G4double	fDPhi
                        The delta angle in radians. 2PI if the
                        tube is unsegmented.

	                G4double	fDz
                        The z half-length

	                G4double	fRMax
                        The maximum radius

	                G4double	fRMin
                        The minimum radius

	                G4double	fSPhi
                        The starting phi angle in radians,
                        adjusted such the fSPhi+fDPhi<=2PI,
                        fSPhi>-2PI


       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Operation name:
          CalculateRotatedVertices

       Protected member of:	G4Tubs
       Return Class:	G4ThreeVectorList*
       Arguments:
	          const G4Transform	&pTransform
       Documentation:
          Create the list of transformed vertices in the format
          required for G4VSolid::ClipCrossSection and
          ClipBetweenSections. Perform this by fitting a mesh
          around the tube.

       Concurrency:	Sequential



       Operation name:
          G4Tubs

       Public member of:	G4Tubs
       Arguments:
	          const G4String	&pName
	          G4double	pRMin
	          G4double	pRMax
	          G4double	pDz
	          G4double	pDPhi
	          G4bool	pRadians=false
       Documentation:
          Constrcut a tubs with the given name and dimensions. If
          pRadians=true, the angles are provided is radians, else
          degrees are assumed. The angles are converted to
          radians internally.

       Concurrency:	Sequential



       Class name:
          G4HalfSpaceSolid

       Category:		Geometry
       Documentation:
          A solid created by the boolean AND of 1 or more half
          space surfaces

       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	G4VSolid
       Public Interface:
          Has-A Relationships:
	                G4VHalfSpaceSurface	

       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Class name:
          G4BREPSolid

       Category:		Geometry
       Documentation:
          A solid creted by an abitrary set of finite surfaces

       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	G4VSolid
       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Class name:
          G4Torus

       Category:		Geometry
       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	G4VSolid
       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Class name:
          G4Trd

       Category:		Geometry
       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	G4VSolid
       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Class name:
          G4Cons

       Category:		Geometry
       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	G4VSolid
       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Class name:
          G4Sphere

       Category:		Geometry
       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	G4VSolid
       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Class name:
          G4Trap

       Category:		Geometry
       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	G4VSolid
       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Class name:
          G4GTra

       Category:		Geometry
       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	G4VSolid
       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Class name:
          G4VHalfSpaceSurface

       Category:		Geometry
       Documentation:
          A mathemetical surface, possibly infinite, with the
          space on given side defined as being `inside'

       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	none
       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Class name:
          G4HalfSpacePlane

       Category:		Geometry
       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	G4VHalfSpaceSurface
       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Class name:
          G4VSweptSolid

       Category:		Geometry
       Documentation:
          A solid created by performing a 3D transformation on a
          finite planar face

       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	G4VSolid
       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Class name:
          G4ExtrudedSolid

       Category:		Geometry
       Documentation:
          A solid generated by extruding a planar face along a
          specified axis

       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	G4VSweptSolid
       Private Interface:
          Has-A Relationships:
	                G4PlanarFace	

       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Class name:
          G4RotatedSolid

       Category:		Geometry
       Documentation:
          A solid generated by rotating a planar face about a
          specified axis

       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	G4VSweptSolid
       Private Interface:
          Has-A Relationships:
	                G4PlanarFace	

       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Class name:
          G4HalfSpaceSpherical

       Category:		Geometry
       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	G4VHalfSpaceSurface
       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Class name:
          G4HalfSpaceConical

       Category:		Geometry
       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	G4VHalfSpaceSurface
       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Class name:
          G4HalfSpaceCylindrical

       Category:		Geometry
       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	G4VHalfSpaceSurface
       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Class name:
          G4PlanarFace

       Category:		Geometry
       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	none
       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Class name:
          G4SolidStore

       Category:		Geometry
       Documentation:
          Responsible for storing and providing access to all
          solids

       Export Control:	Public
       Cardinality:		1
       Hierarchy:
          Superclasses:	none
       Private Interface:
          Has-A Relationships:
	                G4SolidStore	fgInstance
	                G4VSolid	fsolids

       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Class name:
          G4VSolid

       Category:		Geometry
       Documentation:
          Represents position independent geomeetrical entities,
          having
          only a `shape'

       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	none
       Public Uses:
	                G4SolidStore	
	                G4VoxelLimits	

       Public Interface:
          Operations:
                        CalculateExtent (const EAxis, const G4VoxelLimits&,
                                         const G4Transform&, G4double&, G4double&)
                        ComputeDimensions ( )
                        DistanceToIn (const G4ThreeVector&)
                        DistanceToIn (const G4ThreeVector&,
                                      const G4ThreeVector&)
                        DistanceToOut (const G4ThreeVector&)
                        DistanceToOut (const G4ThreeVector&,
                                       const G4ThreeVector&, const G4bool,
                                       G4bool*, G4ThreeVector*)
                        G4VSolid (const G4String)
                        Inside (const G4ThreeVector&)
                        SurfaceNormal (const G4ThreeVector&)
                        operator== (const G4VSolid)
                        ~G4VSolid ( )

       Protected Interface:
          Operations:
                        CalculateClippedPolygonExtent (G4ThreeVectorList&,
                                      const G4VoxelLimits, const EAxis,
                                      G4double, G4double)
                        ClipBetweenSections (G4ThreeVectorList, 
                                      const G4int, const G4VoxelLimits&,
                                      const EAxis, G4double, G4double)
                        ClipCrossSection (G4ThreeVectorList, const G4int,
                                      const G4VoxelLimits, const EAxis,
                                      G4double, G4double)
                        ClipPolygon (G4ThreeVectorList, const G4VoxelLimits)

       Private Interface:
          Has-A Relationships:
	                G4String	fname

          Operations:
                        ClipPolygonToSimpleLimits (G4ThreeVectorList,
                                      G4ThreeVectorList, const G4VoxelLimits)

       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Operation name:
          CalculateClippedPolygonExtent

       Protected member of:	G4VSolid
       Return Class:	void
       Arguments:
	          G4ThreeVectorList&	&pPolygon
	          const G4VoxelLimits	&pVoxelLimit
	          const EAxis	pAxis
	          G4double	&pMin
	          G4double	&pMax
       Documentation:
          Calculate the maximum and minimum extents of the convex
          polygon pPolygon along the axis pAxis, within the
          limits pVoxelLimit.

          If the minimum is pMax, pMax is set to the new
          maximum.

          Modifications to pPolygon ARE made - it is left in an
          undefined state.

       Concurrency:	Sequential



       Operation name:
          CalculateExtent

       Public member of:	G4VSolid
       Return Class:	G4bool
       Arguments:
	          const EAxis	pAxis
	          const G4VoxelLimits&	pVoxelLimit
	          const G4Transform&	pTransform
	          G4double&	pMin
	          G4double&	pMax
       Documentation:
          Calculate the minimum and maximum extent of the solid,
          when under the specified transform, and within the
          specified limits. If the solid does is not intersected
          by the region, return false, else return true.

       Concurrency:	Sequential



       Operation name:
          ClipBetweenSections

       Protected member of:	G4VSolid
       Return Class:	void
       Arguments:
	          G4ThreeVectorList	*pVertices
	          const G4int	pSectionIndex
	          const G4VoxelLimits&	&pVoxelLimit
	          const EAxis	pAxis
	          G4double	&pMin
	          G4double	&pMax
       Documentation:
          Calculate the maximum and minimum extents of the
          polygon joining the CrossSections at
          pSectionIndex->pSectionIndex+3 and
          pSectionIndex+4->pSectionIndex+7 in the list pVertices,
          within the boundaries of the voxxel limits pVoxelLimit.

          If the minimum is pMax, pMax is set to the new
          maximum.

          No modifications are made to pVertices.

       Concurrency:	Sequential



       Operation name:
          ClipCrossSection

       Protected member of:	G4VSolid
       Return Class:	void
       Arguments:
	          G4ThreeVectorList	*pVertices
	          const G4int	pSectionIndex
	          const G4VoxelLimits	&pVoxelLimit
	          const EAxis	pAxis
	          G4double	&pMin
	          G4double	&pMax
       Documentation:
          Calculate the maximum and minimum extents of the
          polygon described by the vertices: pSectionIndex->
          pSectionIndex+1 ->pSectionIndex+3 -> pSectionIndex in
          the list pVertices.

          If the minimum is pMax, pMax is set to the
          new maximum.

          No modifications are made to pVertices. 

       Concurrency:	Sequential



       Operation name:
          ClipPolygon

       Protected member of:	G4VSolid
       Return Class:	void
       Arguments:
	          G4ThreeVectorList	&pPolygon
	          const G4VoxelLimits	&pVoxelLimit
       Documentation:
          Clip the specified convex polygon to the given limits,
          where the polygon is described by the vertices at
          (0),(1),...,(n),(0) in pPolygon.

          If the polygon is completely clipped away, the polygon
          is cleared.

       Concurrency:	Sequential



       Operation name:
          ClipPolygonToSimpleLimits

       Private member of:	G4VSolid
       Return Class:	void
       Arguments:
	          G4ThreeVectorList	&pPolygon
	          G4ThreeVectorList	&outputPolygon
	          const G4VoxelLimits	&pVoxelLimit
       Documentation:
          Clip the specified convex polygon to the given limits,
          storing the result in outputPolygon. The voxel limits
          must be limits in one plane only - this is achieve by
          having only x or y or z limits, and either the minimum
          or maximum limit set yo 0+kInfinity respectively.

       Concurrency:	Sequential



       Operation name:
          ComputeDimensions

       Public member of:	G4VSolid
       Documentation:
          By using the paramterisation object, compute the
          dimensions of the solid for the given replication
          number. Dispatches to the relevant ComputeDimensions
          function of the replication object, so that the
          replication object obtains type of solid

       Concurrency:	Sequential



       Operation name:
          DistanceToIn

       Public member of:	G4VSolid
       Return Class:	G4double
       Arguments:
	          const G4ThreeVector&	p
	          const G4ThreeVector&	v
       Documentation:
          Return distance along the normalised vector v to the
          shape, from the point at offset p. If there is no
          intersection, return kInfinity. The first intersection
          resulting from `leaving' a surface/volume is discarded.
          Henacs, tolerant ofpoints on surface of shape.

       Concurrency:	Sequential



       Operation name:
          DistanceToIn

       Public member of:	G4VSolid
       Return Class:	G4double
       Arguments:
	          const G4ThreeVector&	p
       Documentation:
          Calculate distance to nearest surface of shape from an
          outside point. The distance can be an underestimate.

       Concurrency:	Sequential



       Operation name:
          DistanceToOut

       Public member of:	G4VSolid
       Return Class:	G4double
       Arguments:
	          const G4ThreeVector&	p
	          const G4ThreeVector&	v
	          const G4bool	calcNorm=false
	          G4bool*	validNorm=0
	          G4ThreeVector*	n=0
       Documentation:
          Return distance along the nomalised vector v to the
          shape, from a point at an offset p inside or on the
          surface of the shape. Intersections with surfaces, with
          the point is *
       Arguments:
	          G4LogicalVolume*	pVolume
	          G4VoxelLimits	pLimits
	          const G4VolumeNosVector	*pCandidates
	          EAxis	pAxis
       Documentation:
          Compute the best axis for slicing at the current depth,
          within the current limits, and build the corresponding
          nodes.

       Concurrency:	Sequential



       Operation name:
          BuildVoxels

       Protected member of:	G4SmartVoxelHeader
       Return Class:	void
       Arguments:
	          G4LogicalVolume*	pVolume
	          G4VoxelLimits	pLimits
	          const G4VolumeNosVector	*pCandidates
       Documentation:
          Build and redine voxels between specified limits,
          considering only the physical volumes `pCandidates'

       Semantics:
          Object diagram: Voxel Construction (G4VoxelHeader::BuildVoxels)

       Concurrency:	Sequential



       Operation name:
          CalculateQuality

       Protected member of:	G4SmartVoxelHeader
       Return Class:	G4double
       Arguments:
	          G4ProxyVector	*pSlice
       Documentation:
          Calculate the "quality value"  for the specified vector
          of voxels. The value returned should be >0 and such
          that the smaller the number the higher the quality of
          the slice. pSlice must consist of SmartVoxelNodeProxies
          only

       Concurrency:	Sequential



       Operation name:
          CollectEquivalentHeaders

       Protected member of:	G4SmartVoxelHeader
       Return Class:	void
       Documentation:
          Collect common headers, deleting all but one to save
          memory, and adjust stored slice ptrs appropriately

       Concurrency:	Sequential



       Operation name:
          CollectEquivalentNodes

       Protected member of:	G4SmartVoxelHeader
       Return Class:	void
       Documentation:
          Coolect common nodes, deleting all butone to save
          memory, and adjusting stored slice ptrs.

       Concurrency:	Sequential



       Operation name:
          G4SmartVoxelHeader

       Public member of:	G4SmartVoxelHeader
       Arguments:
	          G4LogicalVolume	*pVolume
	          const G4int	pSlice=0
       Documentation:
          Constructor for topmost header, to begin voxel
          construction at a given logical volume.

       Semantics:
          Object diagram: Voxel Construction

       Concurrency:	Sequential



       Operation name:
          G4SmartVoxelHeader

       Protected member of:	G4SmartVoxelHeader
       Arguments:
	          G4LogicalVolume	*pVolume
	          const G4VoxelLimits	&pLimits
	          G4VolumeNosVector	*pCandidates
	          G4int	pSlice=0
       Concurrency:	Sequential



       Operation name:
          GetAxis

       Public member of:	G4SmartVoxelHeader
       Return Class:	EAxis
       Documentation:
          Return the current division axis

       Concurrency:	Sequential



       Operation name:
          GetMaxEquivalentSliceNo

       Public member of:	G4SmartVoxelHeader
       Return Class:	G4int
       Documentation:
          Return the max equivalents slice no

       Concurrency:	Sequential



       Operation name:
          GetMaxExtent

       Public member of:	G4SmartVoxelHeader
       Return Class:	G4double
       Documentation:
          Return the maximum coordinate limit along the current
          axis

       Concurrency:	Sequential



       Operation name:
          GetMinEquivalentSliceNo

       Public member of:	G4SmartVoxelHeader
       Return Class:	G4int
       Documentation:
          Returns the minimum equivalent slice no

       Concurrency:	Sequential



       Operation name:
          GetMinExtent

       Public member of:	G4SmartVoxelHeader
       Return Class:	G4double
       Documentation:
          Return the minimum coordinate limit along the current
          axis

       Concurrency:	Sequential



       Operation name:
          GetNoSlices

       Public member of:	G4SmartVoxelHeader
       Return Class:	G4int
       Documentation:
          Return the no of slices along the current axis

       Concurrency:	Sequential



       Operation name:
          GetSlice

       Public member of:	G4SmartVoxelHeader
       Return Class:	G4VSmartVoxelProxy*
       Arguments:
	          G4int	n
       Documentation:
          Return ptr to the proxy for the nth slice (numbering
          from 0, no bounds checking)

       Concurrency:	Sequential



       Operation name:
          RefineNodes

       Protected member of:	G4SmartVoxelHeader
       Return Class:	void
       Arguments:
	          G4LogicalVolume	*pVolume
	          G4VoxelLimits	pLimits
       Documentation:
          Examine each contained node, refine (create a
          replacement additional dimension of voxels) when there
          is more than one voxel in the slice.

       Concurrency:	Sequential



       Operation name:
          SetMaxEquivalentSliceNo

       Public member of:	G4SmartVoxelHeader
       Arguments:
	          G4int	pSlice
       Documentation:
          Sets the maximum equivalent sliceno

       Concurrency:	Sequential



       Operation name:
          SetMinEquivalentSliceNo

       Public member of:	G4SmartVoxelHeader
       Arguments:
	          G4int	pSlice
       Documentation:
          Stes the minimum equivalent slice no

       Concurrency:	Sequential



       Operation name:
          operator==

       Public member of:	G4SmartVoxelHeader
       Return Class:	G4bool
       Arguments:
	          const G4SmartVoxelHeader	&pHead
       Documentation:
          Equality operator. Return true if the contents of the
          headers (and their related nodes/headers) are equal.

       Concurrency:	Sequential



       Operation name:
          ~G4SmartVoxelHeader

       Public member of:	G4SmartVoxelHeader
       Documentation:
          Destroy header and underlying nodes/headers

       Concurrency:	Sequential



       Class name:
          G4SmartVoxelProxy

       Category:		Geometry
       Documentation:
          A class for proxying for either smart voxel headers or
          nodes. Get functionality is provided proxy type
          checking: GetHeader fails when proxying for a node.

       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	none
       Public Interface:
          Operations:
                        G4SmartVoxelProxy (G4SmartVoxelHeader)
                        G4SmartVoxelProxy (G4SmartVoxelNode)
                        GetHeader ( )
                        GetNode ( )
                        IsHeader ( )
                        IsNode ( )

       Private Interface:
          Has-A Relationships:
	                G4SmartVoxelHeader	fheader
	                G4SmartVoxelNode	fnode

       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Operation name:
          G4SmartVoxelProxy

       Public member of:	G4SmartVoxelProxy
       Arguments:
	          G4SmartVoxelHeader	*pHeader
       Documentation:
          Proxy for the specifed header

       Concurrency:	Sequential



       Operation name:
          G4SmartVoxelProxy

       Public member of:	G4SmartVoxelProxy
       Arguments:
	          G4SmartVoxelNode	*pNode
       Documentation:
          Proxy for the psicifed node

       Concurrency:	Sequential



       Operation name:
          GetHeader

       Public member of:	G4SmartVoxelProxy
       Documentation:
          Return ptr to Header if proxying for a header, else
          call G4Exception

       Concurrency:	Sequential



       Operation name:
          GetNode

       Public member of:	G4SmartVoxelProxy
       Documentation:
          Return ptr to node if proxying for a node, else call
          G4Exception

       Concurrency:	Sequential



       Operation name:
          IsHeader

       Public member of:	G4SmartVoxelProxy
       Return Class:	G4bool
       Documentation:
          Returns true if proxying for a header

       Concurrency:	Sequential



       Operation name:
          IsNode

       Public member of:	G4SmartVoxelProxy
       Return Class:	G4bool
       Documentation:
          Returns ture if proxying for a node

       Concurrency:	Sequential



       Class name:
          G4SmartVoxelNode

       Category:		Geometry
       Documentation:
          A single virtual division, containing the physical
          volumes inside
          its boundaries and those of its parents


       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	none
       Public Interface:
          Operations:
                        GetContents ( )
                        GetMaxEquivalentSliceNo ( )
                        GetMinEquivalentSliceNo ( )
                        GetNoContained ( )
                        Insert ( )
                        IsRefined ( )
                        SetMaxEquivalentSliceNo (G4int)
                        SetMinEquivalentSliceNo (G4int)

       Private Interface:
          Has-A Relationships:
	                G4int	fcontents
	                G4int	fmaxEquivalent
                        The maximum equivalent slice no

	                G4int	fminEquivalent
                        The minimum equivalent slice no


       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Operation name:
          GetContents

       Public member of:	G4SmartVoxelNode
       Documentation:
          Return the contents of the virtual slice

       Concurrency:	Sequential



       Operation name:
          GetMaxEquivalentSliceNo

       Public member of:	G4SmartVoxelNode
       Documentation:
          Returns greatest slice no of neighbouring slices with
          same contents

       Concurrency:	Sequential



       Operation name:
          GetMinEquivalentSliceNo

       Public member of:	G4SmartVoxelNode
       Documentation:
          Returns smallest slice no of neighbouring slices with
          same contents

       Concurrency:	Sequential



       Operation name:
          GetNoContained

       Public member of:	G4SmartVoxelNode
       Return Class:	G4int
       Documentation:
          Return no of volumes contained by the node

       Concurrency:	Sequential



       Operation name:
          Insert

       Public member of:	G4SmartVoxelNode
       Documentation:
          Add a physical volume to the nodes contents

       Concurrency:	Sequential



       Operation name:
          IsRefined

       Public member of:	G4SmartVoxelNode
       Return Class:	G4bool
       Documentation:
          Return true if the specified node is sufficiently
          refined (<=1 volume inside node)

       Concurrency:	Sequential



       Operation name:
          SetMaxEquivalentSliceNo

       Public member of:	G4SmartVoxelNode
       Arguments:
	          G4int	pSlice
       Documentation:
          Sets the maximum equivalent slice no

       Concurrency:	Sequential



       Operation name:
          SetMinEquivalentSliceNo

       Public member of:	G4SmartVoxelNode
       Arguments:
	          G4int	pSlice
       Documentation:
          Sets the minimum equivalent slice no

       Concurrency:	Sequential



       Class name:
          G4VoxelLimits

       Category:		Geometry
       Documentation:
          Represents limitation/restirctions of space , where
          restriction are only made perpendicular to the
          cartesian axes.

       Export Control:	Public
       Cardinality:		n
       Hierarchy:
          Superclasses:	none
       Public Interface:
          Operations:
                        AddLimit (EAxis, G4double, G4double)
                        ClipToLimits (G4ThreeVector&, G4ThreeVector&)
                        G4VoxelLimits ( )
                        GetMaxExtent (EAxis)
                        GetMaxXExtent ( )
                        GetMaxYExtent ( )
                        GetMaxZExtent ( )
                        GetMinExtent (EAxis)
                        GetMinXExtent ( )
                        GetMinYExtent ( )
                        GetMinZExtent ( )
                        Inside (G4ThreeVector&)
                        IsLimited (EAxis)
                        IsLimited ( )
                        IsXLimited ( )
                        IsYLimited ( )
                        IsZLimited ( )
                        OutCode (const G4ThreeVector&)

       Private Interface:
          Has-A Relationships:
	                G4double	fxAxisMax
	                G4double	fxAxisMin
	                G4double	fyAxisMax
	                G4double	fyAxisMin
	                G4double	fzAxisMax
	                G4double	fzAxisMin

       State machine:	No
       Concurrency:		Sequential
       Persistence:		Transient



       Operation name:
          AddLimit

       Public member of:	G4VoxelLimits
       Return Class:	void
       Arguments:
	          EAxis	pAxis
	          G4double	pMin
	          G4double	pMax
       Documentation:
          Further limit the overall limits to between the minimum
          and maximum values specified along the given axis

       Concurrency:	Sequential



       Operation name:
          ClipToLimits

       Public member of:	G4VoxelLimits
       Return Class:	G4bool
       Arguments:
	          G4ThreeVector&	pStart
	          G4ThreeVector&	pEnd
       Documentation:
          Clip the line segment pStart->pEnd to the volume
          described by the current limits. Return true if theline
          remains after clipping, else false, and leave the
          vectors in an undefined state.

       Concurrency:	Sequential



       Operation name:
          G4VoxelLimits

       Public member of:	G4VoxelLimits
       Documentation:
          Constructor. Initialise to be unlimited

       Concurrency:	Sequential



       Operation name:
          GetMaxExtent

       Public member of:	G4VoxelLimits
       Return Class:	G4double
       Arguments:
	          EAxis	pAxis
       Documentation:
          Return maximum limit along specified axis, kInfinity if
          not limited

       Concurrency:	Sequential



       Operation name:
          GetMaxXExtent

       Public member of:	G4VoxelLimits
       Concurrency:	Sequential



       Operation name:
          GetMaxYExtent

       Public member of:	G4VoxelLimits
       Concurrency:	Sequential



       Operation name:
          GetMaxZExtent

       Public member of:	G4VoxelLimits
       Concurrency:	Sequential



       Operation name:
          GetMinExtent

       Public member of:	G4VoxelLimits
       Return Class:	G4double
       Arguments:
	          EAxis	pAxis
       Documentation:
          Return minimum limit along specified axis, kInifinty if
          not limited

       Concurrency:	Sequential



       Operation name:
          GetMinXExtent

       Public member of:	G4VoxelLimits
       Concurrency:	Sequential



       Operation name:
          GetMinYExtent

       Public member of:	G4VoxelLimits
       Concurrency:	Sequential



       Operation name:
          GetMinZExtent

       Public member of:	G4VoxelLimits
       Concurrency:	Sequential



       Operation name:
          Inside

       Public member of:	G4VoxelLimits
       Return Class:	G4bool
       Arguments:
	          G4ThreeVector&	pVec
       Documentation:
          Return true if the specified vector is inside/on
          boundaries of limits

       Concurrency:	Sequential



       Operation name:
          IsLimited

       Public member of:	G4VoxelLimits
       Return Class:	G4bool
       Arguments:
	          EAxis	PAxis
       Documentation:
          Returns true if specified axis is limited

       Concurrency:	Sequential



       Operation name:
          IsLimited

       Public member of:	G4VoxelLimits
       Return Class:	G4bool
       Documentation:
          Returns true if any axis is limited

       Concurrency:	Sequential



       Operation name:
          IsXLimited

       Public member of:	G4VoxelLimits
       Return Class:	G4bool
       Concurrency:	Sequential



       Operation name:
          IsYLimited

       Public member of:	G4VoxelLimits
       Return Class:	G4bool
       Concurrency:	Sequential



       Operation name:
          IsZLimited

       Public member of:	G4VoxelLimits
       Return Class:	G4bool
       Concurrency:	Sequential



       Operation name:
          OutCode

       Public member of:	G4VoxelLimits
       Return Class:	G4int
       Arguments:
	          const G4ThreeVector&	pVec
       Documentation:
          Calculate the `outcode' for the specified vector.
          Intended for use during clipping against the limits.
          The bits are set given the following conditions:

          0 pVec.x()fxAxisMax && IsXlimited()

          and similarly 2-3 for y and 4-5 for z limits

       Concurrency:	Sequential