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

Import Geant4 4.1.0 source tree

Browse Source
This commit is contained in:
Gabriele Cosmo
2016-06-08 16:39:52 +02:00
parent 921d3b1cda
commit 330b82b769
4524 changed files with 178689 additions and 43575 deletions
Download Patch File Download Diff File Expand all files Collapse all files
source/geometry/management/include/G4AffineTransform.hh
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: G4AffineTransform.hh,v 1.4 2001/07/11 09:59:15 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
//
// class G4AffineTransform
source/geometry/management/include/G4AffineTransform.icc
+4 -5
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4AffineTransform.icc,v 1.4 2001/07/11 09:59:16 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4AffineTransform.icc,v 1.6 2002/01/08 12:38:05 gcosmo Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
//
// G4AffineTransformation Inline implementation
@@ -294,7 +294,7 @@ G4bool G4AffineTransform::operator != (const G4AffineTransform& tf) const
inline
G4double G4AffineTransform::operator [] (const G4int n) const
{
G4double v;
G4double v = 0.0;
switch(n)
{
case 0:
@@ -336,10 +336,9 @@ G4double G4AffineTransform::operator [] (const G4int n) const
case 3:
case 7:
case 11:
v=0;
break;
case 15:
v=1;
v=1.0;
break;
}
return v;
source/geometry/management/include/G4AssemblyTriplet.hh
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: G4AssemblyTriplet.hh,v 1.5 2001/07/11 09:59:16 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
//
// Class G4AssemblyTriplet
source/geometry/management/include/G4AssemblyTriplet.icc
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: G4AssemblyTriplet.icc,v 1.5 2001/07/11 09:59:16 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
//
// Class G4AssemblyTriplet - inline implementation
source/geometry/management/include/G4AssemblyVolume.hh
+36 -8
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4AssemblyVolume.hh,v 1.5 2001/07/11 09:59:16 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4AssemblyVolume.hh,v 1.7 2002/06/22 00:39:23 radoone Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
//
// Class G4AssemblyVolume
@@ -66,6 +66,16 @@ class G4AssemblyVolume
// Constructors & destructor.
// At destruction all the generated physical volumes and associated
// rotation matrices of the imprints will be destroyed.
//
// The rotation matrix passed in can be 0 = identity or an address even of an object
// on the upper stack frame. During assembly imprint, it creates anyway a new matrix
// and keeps track of it so it can delete it later at destruction time.
// This new policy has been adopted since user has no control on the way the rotations
// are combined it's safer doing it this way.
//
// WARNING! This interface will likely change in the next major release of Geant4 from
// a pointer to a reference due to the reason above
//
void AddPlacedVolume( G4LogicalVolume* pPlacedVolume,
G4ThreeVector& translation,
@@ -91,6 +101,16 @@ class G4AssemblyVolume
// the coordinate system of the first one.
// Every next volume being added into the assembly will be placed
// w.r.t to the previous one.
//
// The rotation matrix passed in can be 0 = identity or an address even of an object
// on the upper stack frame. During assembly imprint, it creates anyway a new matrix
// and keeps track of it so it can delete it later at destruction time.
// This new policy has been adopted since user has no control on the way the rotations
// are combined it's safer doing it this way.
//
// WARNING! This interface will likely change in the next major release of Geant4 from
// a pointer to a reference due to the reason above
//
void AddPlacedVolume( G4LogicalVolume* pPlacedVolume,
G4Transform3D& transformation);
@@ -100,17 +120,19 @@ class G4AssemblyVolume
void MakeImprint( G4LogicalVolume* pMotherLV,
G4ThreeVector& translationInMother,
G4RotationMatrix* pRotationInMother);
G4RotationMatrix* pRotationInMother,
G4int copyNumBase = 0 );
//
// Creates instance of an assembly volume inside the given mother volume.
void MakeImprint( G4LogicalVolume* pMotherLV,
G4Transform3D& transformation);
G4Transform3D& transformation,
G4int copyNumBase = 0 );
//
// The same as previous but takes complete 3D transformation in space
// as its argument.
private:
private:
G4std::vector<G4AssemblyTriplet> fTriplets;
//
@@ -129,9 +151,12 @@ private:
// generated physical volumes and rotation matrices as well !
// This may affect validity of detector contruction !
protected:
public:
unsigned int GetImprintsCount() const;
protected:
void SetImprintsCount( unsigned int value );
void ImprintsCountPlus();
void ImprintsCountMinus();
@@ -145,9 +170,12 @@ private:
//
// Number of imprints of the given assembly volume.
protected:
public:
unsigned int GetInstanceCount() const;
protected:
void SetInstanceCount( unsigned int value );
void InstanceCountPlus();
void InstanceCountMinus();
source/geometry/management/include/G4AssemblyVolume.icc
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: G4AssemblyVolume.icc,v 1.3 2001/07/11 09:59:16 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
//
// Class G4AssemblyVolume - inline implementation
source/geometry/management/include/G4DrawVoxels.hh
+3 -3
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4DrawVoxels.hh,v 1.10 2001/07/11 09:59:16 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4DrawVoxels.hh,v 1.11 2002/04/19 08:20:16 gcosmo Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
//
// class G4DrawVoxels
@@ -68,7 +68,7 @@ class G4DrawVoxels
// Copy constructor and assignment operator not supported (array
// fvoxelcolours ...).
~G4DrawVoxels(){};
~G4DrawVoxels();
// Destructor NOT virtual. Not a base class.
void DrawVoxels(const G4LogicalVolume* lv) const;
source/geometry/management/include/G4GeometryManager.hh
+5 -2
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4GeometryManager.hh,v 1.5 2001/10/22 16:08:04 gcosmo Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4GeometryManager.hh,v 1.6 2002/04/26 16:23:34 gcosmo Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// class G4GeometryManager
//
@@ -69,6 +69,9 @@ class G4GeometryManager
// Open (`unlock') the geometry and remove optimisation information if
// present.
G4bool IsGeometryClosed();
// Return true/false according to state of optimised geoemtry.
static G4GeometryManager* GetInstance();
// Return ptr to singleton instance of the class.
source/geometry/management/include/G4LogicalSurface.hh
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: G4LogicalSurface.hh,v 1.6 2001/07/11 09:59:16 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
////////////////////////////////////////////////////////////////////////
// Class G4LogicalSurface
source/geometry/management/include/G4LogicalSurface.icc
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: G4LogicalSurface.icc,v 1.5 2001/07/11 09:59:16 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
////////////////////////////////////////////////////////////////////////
// Surface Class Inline Methods
source/geometry/management/include/G4LogicalVolume.hh
+69 -50
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4LogicalVolume.hh,v 1.8 2001/07/11 09:59:17 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4LogicalVolume.hh,v 1.9 2002/05/17 17:59:47 gcosmo Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
//
// class G4LogicalVolume
@@ -45,7 +45,7 @@
// Daughters are ascribed and managed by means of a simple
// GetNoDaughters,Get&SetDaughter(n),AddDaughter interface.
//
// Smart voxels as used for tracking optimisation are also an attribute.
// Smart voxels as used for tracking optimisation. They're also an attribute.
//
// Logical volumes self register to the logical volume Store on construction,
// and deregister on destruction.
@@ -57,52 +57,56 @@
//
// G4std::vector<G4VPhysicalVolume*> fDaughters
// - Vector of daughters. Given initial size of 0.
// G4FieldManager *fFieldManager
// - Pointer (possibly NULL) to (magnetic or other) field manager object.
// G4Material *fMaterial
// G4FieldManager* fFieldManager
// - Pointer (possibly 0) to (magnetic or other) field manager object.
// G4Material* fMaterial
// - Pointer to material at this node.
// G4String fName
// - Name of logical volume.
// G4VSensitiveDetector *fSensitiveDetector
// - Pointer (possibly NULL) to `Hit' object.
// G4VSolid *fSolid
// - Pointer (possibly 0) to `Hit' object.
// G4VSolid* fSolid
// - Pointer to solid.
// G4UserLimits *fUserLimits
// - Pointer (possibly NULL) to user Step limit object for this node.
// G4SmartVoxelHeader *fVoxel
// - Pointer (possibly NULL) to optimisation info objects.
// G4UserLimits* fUserLimits
// - Pointer (possibly 0) to user Step limit object for this node.
// G4SmartVoxelHeader* fVoxel
// - Pointer (possibly 0) to optimisation info objects.
// G4bool fOptimise;
// - Flag to identify if optimisation should be applied or not.
// G4double fSmartless
// - Quality for optimisation, average number of voxels to be spent
// per content.
// const G4VisAttributes* fVisAttributes
// - Pointer (possibly NULL) to visualization attributes.
// G4FastSimulationManager *fFastSimulationManager
// - Pointer (possibly NULL) to G4FastSimulationManager object.
// - Pointer (possibly 0) to visualization attributes.
// G4FastSimulationManager* fFastSimulationManager
// - Pointer (possibly 0) to G4FastSimulationManager object.
// G4bool fIsEnvelope
// - Flags if the Logical Volume is an envelope for a FastSimulationManager.
// G4double fBiasWeight
// - Weight used in the event biasing technique.
// History:
// 17.05.02 G.Cosmo: Added IsToOptimise() method and related flag
// 18.04.01 G.Cosmo: Migrated to STL vector
// 12.02.99 S.Giani: Added user defined optimisation quality
// 09.11.98 J. Apostolakis: Changed G4MagneticField to G4FieldManager
// 09.11.98 M. Verderi & JA. : added BiasWeight member and Get/Set methods
// 10.20.97 P. MoraDeFreitas : added pointer to a FastSimulation
// (J.Apostolakis) & flag to indicate if it is an Envelope for it
// 19.11.96 J.Allison Replaced G4Visible with explicit const G4VisAttributes*.
// 19.08.96 P.Kent Split -> hh/icc/cc files; G4VSensitiveDetector change
// 11.07.95 P.Kent Initial version.
// 09.11.98 J.Apostolakis: Changed G4MagneticField to G4FieldManager
// 09.11.98 M.Verderi, J.Apostolakis: Added BiasWeight member and accessors
// 10.20.97 P.M.DeFreitas: Added pointer to a FastSimulation
// J.Apostolakis: & flag to indicate if it is an Envelope for it
// 19.11.96 J.Allison: Replaced G4Visible with explicit const G4VisAttributes*
// 19.08.96 P.Kent: Split -> hh/icc/cc files; G4VSensitiveDetector change
// 11.07.95 P.Kent: Initial version.
#ifndef G4LOGICALVOLUME_HH
#define G4LOGICALVOLUME_HH
#include "globals.hh"
#include "G4VPhysicalVolume.hh" // Need operator == for vector fdaughters
#include "G4VPhysicalVolume.hh" // Need operator == for vector fdaughters
#include "g4std/vector"
#include <assert.h>
// Forward declarations
//
class G4FieldManager;
class G4Material;
class G4VSensitiveDetector;
@@ -118,14 +122,19 @@ class G4LogicalVolume
public: // with description
G4LogicalVolume(G4VSolid *pSolid, G4Material *pMaterial,
const G4String& name,
G4FieldManager *pFieldMgr=0,
G4VSensitiveDetector *pSDetector=0,
G4UserLimits *pULimits=0);
// Constructor. The solid and material pointer must be non null. The
// parameters for field, detector and user limits are optional.
G4LogicalVolume(G4VSolid* pSolid,
G4Material* pMaterial,
const G4String& name,
G4FieldManager* pFieldMgr=0,
G4VSensitiveDetector* pSDetector=0,
G4UserLimits* pULimits=0,
G4bool optimise=true);
// Constructor. The solid and material pointer must be non null.
// The parameters for field, detector and user limits are optional.
// The volume also enters itself into the logical volume Store.
// Optimisation of the geometry (voxelisation) for the volume
// hierarchy is applied by default. For parameterised volumes in
// the hierarchy, optimisation is -always- applied.
~G4LogicalVolume();
// Destructor. Removes the logical volume from the logical volume Store.
@@ -169,7 +178,7 @@ class G4LogicalVolume
inline G4VSensitiveDetector* GetSensitiveDetector() const;
// Gets current SensitiveDetector.
inline void SetSensitiveDetector(G4VSensitiveDetector *pSDetector);
// Sets SensitiveDetector (can be NULL).
// Sets SensitiveDetector (can be 0).
inline G4UserLimits* GetUserLimits() const;
inline void SetUserLimits(G4UserLimits *pULimits);
@@ -179,13 +188,21 @@ class G4LogicalVolume
inline void SetVoxelHeader(G4SmartVoxelHeader *pVoxel);
// Gets and sets current VoxelHeader.
inline G4double GetSmartless();
inline G4double GetSmartless() const;
inline void SetSmartless(G4double s);
// Gets and sets user defined optimisation quality.
inline G4bool IsToOptimise() const;
// Replies if geometry optimisation (voxelisation) is to be
// applied for this volume hierarchy.
inline void SetOptimisation(G4bool optim);
// Specifies if to apply or not geometry optimisation to this
// volume hierarchy. Note that for parameterised volumes in the
// hierarchy, optimisation is always applied.
G4bool operator == ( const G4LogicalVolume& lv) const;
// Equality defined by address only- return true if objects are at
// same address, else false.
// Equality defined by address only.
// Returns true if objects are at same address, else false.
inline const G4VisAttributes* GetVisAttributes () const;
inline void SetVisAttributes (const G4VisAttributes* pVA);
@@ -209,11 +226,11 @@ class G4LogicalVolume
private:
void SetFastSimulationManager (G4FastSimulationManager* pPA,
G4bool IsEnvelope);
G4bool IsEnvelope);
// Sets the fast simulation manager. Private method called by the
// public SetIsEnvelope method with IsEnvelope = TRUE. It is
// public SetIsEnvelope method with IsEnvelope = true. It is
// then called recursivaly to the daughters to propagate the
// FastSimulationManager pointer with IsEnvelope = FALSE.
// FastSimulationManager pointer with IsEnvelope = false.
G4LogicalVolume* FindMotherLogicalVolumeForEnvelope();
@@ -227,27 +244,29 @@ class G4LogicalVolume
G4PhysicalVolumeList fDaughters;
// Vector of daughters. Given initial size of 0.
G4FieldManager *fFieldManager;
// Pointer (possibly NULL) to (magnetic or other) field manager object.
G4Material *fMaterial;
G4FieldManager* fFieldManager;
// Pointer (possibly 0) to (magnetic or other) field manager object.
G4Material* fMaterial;
// Pointer to material at this node.
G4String fName;
// Name of logical volume.
G4VSensitiveDetector *fSensitiveDetector;
// Pointer (possibly NULL) to `Hit' object.
G4VSolid *fSolid;
G4VSensitiveDetector* fSensitiveDetector;
// Pointer (possibly 0) to `Hit' object.
G4VSolid* fSolid;
// Pointer to solid.
G4UserLimits *fUserLimits;
// Pointer (possibly NULL) to user Step limit object for this node.
G4SmartVoxelHeader *fVoxel;
// Pointer (possibly NULL) to optimisation info objects.
G4UserLimits* fUserLimits;
// Pointer (possibly 0) to user Step limit object for this node.
G4SmartVoxelHeader* fVoxel;
// Pointer (possibly 0) to optimisation info objects.
G4bool fOptimise;
// Flag to identify if optimisation should be applied or not.
G4double fSmartless;
// Quality for optimisation, average number of voxels to be spent
// per content.
const G4VisAttributes* fVisAttributes;
// Pointer (possibly NULL) to visualization attributes.
G4FastSimulationManager *fFastSimulationManager;
// Pointer (possibly NULL) to G4FastSimulationManager object.
// Pointer (possibly 0) to visualization attributes.
G4FastSimulationManager* fFastSimulationManager;
// Pointer (possibly 0) to G4FastSimulationManager object.
G4bool fIsEnvelope;
// Flags if the Logical Volume is an envelope for a
// FastSimulationManager.
source/geometry/management/include/G4LogicalVolume.icc
+305 -179
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4LogicalVolume.icc,v 1.6 2001/07/11 09:59:17 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4LogicalVolume.icc,v 1.8 2002/05/17 17:59:47 gcosmo Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
//
// class G4LogicalVolume Inline Implementation file
@@ -32,224 +32,350 @@
// 09.11.98 - J. Apostolakis: Changed MagneticField to FieldManager
// 12.02.99 - S.Giani: Added set/get methods for voxelization quality
// 18.04.01 - G.Cosmo: Migrated to STL vector
// 17.05.02 - G.Cosmo: Added IsToOptimise() method
// ********************************************************************
// ********************************************************************
// GetName
// ********************************************************************
//
inline
G4String G4LogicalVolume::GetName() const
{
return fName;
}
{
return fName;
}
// ********************************************************************
// SetName
// ********************************************************************
//
inline
void G4LogicalVolume::SetName(const G4String& pName)
{
fName=pName;
}
{
fName = pName;
}
// ********************************************************************
// GetFieldManager
// ********************************************************************
//
inline
G4FieldManager* G4LogicalVolume::GetFieldManager() const
{
return fFieldManager;
}
{
return fFieldManager;
}
// ********************************************************************
// GetNoDaughters
// ********************************************************************
//
inline
G4int G4LogicalVolume::GetNoDaughters() const
{
return fDaughters.size();
}
{
return fDaughters.size();
}
// ********************************************************************
// GetDaughter
// ********************************************************************
//
inline
G4VPhysicalVolume* G4LogicalVolume::GetDaughter(const G4int i) const
{
return fDaughters[i];
}
{
return fDaughters[i];
}
// ********************************************************************
// GetFastSimulationManager
// ********************************************************************
//
inline
G4FastSimulationManager* G4LogicalVolume::GetFastSimulationManager () const
{
return fFastSimulationManager;
}
{
return fFastSimulationManager;
}
// ********************************************************************
// AddDaughter
// ********************************************************************
//
inline
void G4LogicalVolume::AddDaughter(G4VPhysicalVolume* pNewDaughter)
{
fDaughters.push_back(pNewDaughter);
fDaughters.push_back(pNewDaughter);
// Propagates the mother's FastSimulationManager pointer. If we are in
// the World logical volume, propagates only if pointer != 0.
// (perhaps someone would like to parametrize all the World volume
// for a particle type, why not ?).
// (one could also parameterise all the World volume for a particle type!)
G4VPhysicalVolume *myPhysical= pNewDaughter->GetMother();
G4VPhysicalVolume *pMotherPhys;
G4LogicalVolume *pDaughterLogical;
G4VPhysicalVolume* myPhysical = pNewDaughter->GetMother();
G4VPhysicalVolume* pMotherPhys;
G4LogicalVolume* pDaughterLogical;
if( myPhysical !=0 ){
pMotherPhys= myPhysical->GetMother();
pDaughterLogical = pNewDaughter->GetLogicalVolume();
if( myPhysical !=0 )
{
pMotherPhys = myPhysical->GetMother();
pDaughterLogical = pNewDaughter->GetLogicalVolume();
if( (pMotherPhys!=0) ||
( pMotherPhys==0) && (fFastSimulationManager!=0))
{
if(pDaughterLogical->GetFastSimulationManager() != fFastSimulationManager)
pDaughterLogical->SetFastSimulationManager(fFastSimulationManager,
FALSE);
}
else
{
pDaughterLogical->SetFastSimulationManager(NULL,FALSE);
}
}
if( (pMotherPhys!=0) || ( pMotherPhys==0) && (fFastSimulationManager!=0) )
{
if( pDaughterLogical->GetFastSimulationManager()!=fFastSimulationManager )
pDaughterLogical->SetFastSimulationManager(fFastSimulationManager,false);
}
else
{
pDaughterLogical->SetFastSimulationManager(0, false);
}
}
// Propagate the Field Manager, if the daughter has no field Manager.
//
pDaughterLogical = pNewDaughter->GetLogicalVolume();
G4FieldManager* pDaughterFieldManager = pDaughterLogical->GetFieldManager();
pDaughterLogical = pNewDaughter->GetLogicalVolume();
G4FieldManager* pDaughterFieldManager =
pDaughterLogical->GetFieldManager();
if( pDaughterFieldManager == 0 )
{
pDaughterLogical->SetFieldManager(fFieldManager, true);
}
}
if( pDaughterFieldManager == 0 )
{
pDaughterLogical->SetFieldManager(fFieldManager, true);
}
// ********************************************************************
// IsDaughter
// ********************************************************************
//
inline
G4bool G4LogicalVolume::IsDaughter(const G4VPhysicalVolume* p) const
{
G4PhysicalVolumeList::const_iterator i;
for ( i=fDaughters.begin(); i!=fDaughters.end(); ++i )
{
if (**i==*p) return true;
}
return false;
}
// ********************************************************************
// RemoveDaughter
// ********************************************************************
//
inline
void G4LogicalVolume::RemoveDaughter(const G4VPhysicalVolume* p)
{
G4PhysicalVolumeList::iterator i;
for ( i=fDaughters.begin(); i!=fDaughters.end(); ++i )
{
if (**i==*p)
{
fDaughters.erase(i);
break;
}
}
}
// ********************************************************************
// GetSolid
// ********************************************************************
//
inline
G4VSolid* G4LogicalVolume::GetSolid() const
{
return fSolid;
}
// ********************************************************************
// SetSolid
// ********************************************************************
//
inline
void G4LogicalVolume::SetSolid(G4VSolid *pSolid)
{
assert(pSolid != 0);
fSolid=pSolid;
}
// ********************************************************************
// GetMaterial
// ********************************************************************
//
inline
G4Material* G4LogicalVolume::GetMaterial() const
{
return fMaterial;
}
// ********************************************************************
// SetMaterial
// ********************************************************************
//
inline
void G4LogicalVolume::SetMaterial(G4Material *pMaterial)
{
fMaterial=pMaterial;
}
// ********************************************************************
// GetSensitiveDetector
// ********************************************************************
//
inline
G4VSensitiveDetector* G4LogicalVolume::GetSensitiveDetector() const
{
return fSensitiveDetector;
}
// ********************************************************************
// SetSensitiveDetector
// ********************************************************************
//
inline
void G4LogicalVolume::SetSensitiveDetector(G4VSensitiveDetector* pSDetector)
{
fSensitiveDetector = pSDetector;
}
// ********************************************************************
// GetUserLimits
// ********************************************************************
//
inline
G4UserLimits* G4LogicalVolume::GetUserLimits() const
{
return fUserLimits;
}
// ********************************************************************
// SetUserLimits
// ********************************************************************
//
inline
void G4LogicalVolume::SetUserLimits(G4UserLimits* pULimits)
{
fUserLimits = pULimits;
}
// ********************************************************************
// GetVoxelHeader
// ********************************************************************
//
inline
G4SmartVoxelHeader* G4LogicalVolume::GetVoxelHeader() const
{
return fVoxel;
}
// ********************************************************************
// SetVoxelHeader
// ********************************************************************
//
inline
void G4LogicalVolume::SetVoxelHeader(G4SmartVoxelHeader* pVoxel)
{
fVoxel = pVoxel;
}
// ********************************************************************
// GetSmartless
// ********************************************************************
//
inline
G4double G4LogicalVolume::GetSmartless() const
{
return fSmartless;
}
// ********************************************************************
// SetSmartless
// ********************************************************************
//
inline
void G4LogicalVolume::SetSmartless(G4double s)
{
fSmartless = s;
}
// ********************************************************************
// IsToOptimise
// ********************************************************************
//
inline
G4bool G4LogicalVolume::IsToOptimise() const
{
return fOptimise;
}
// ********************************************************************
// SetOptimisation
// ********************************************************************
//
inline
void G4LogicalVolume::SetOptimisation(G4bool optim)
{
fOptimise = optim;
}
// ********************************************************************
// Operator ==
// ********************************************************************
//
inline
G4bool G4LogicalVolume::operator == ( const G4LogicalVolume& lv) const
{
return (this==&lv) ? true : false;
}
// ********************************************************************
// GetVisAttributes
// ********************************************************************
//
inline
const G4VisAttributes* G4LogicalVolume::GetVisAttributes () const
{
return fVisAttributes;
}
// ********************************************************************
// SetVisAttributes
// ********************************************************************
//
inline
void G4LogicalVolume::SetVisAttributes (const G4VisAttributes* pVA)
{
fVisAttributes = pVA;
}
inline
G4bool G4LogicalVolume::IsDaughter(const G4VPhysicalVolume* p) const
{
G4PhysicalVolumeList::const_iterator i;
for (i=fDaughters.begin(); i!=fDaughters.end(); ++i)
{
if (**i==*p) return true;
}
return false;
}
inline
void G4LogicalVolume::RemoveDaughter(const G4VPhysicalVolume* p)
{
G4PhysicalVolumeList::iterator i;
for (i=fDaughters.begin(); i!=fDaughters.end(); ++i)
{
if (**i==*p)
{
fDaughters.erase(i);
break;
}
}
}
inline
G4VSolid* G4LogicalVolume::GetSolid() const
{
return fSolid;
}
inline
void G4LogicalVolume::SetSolid(G4VSolid *pSolid)
{
assert(pSolid != 0);
fSolid=pSolid;
}
inline
G4Material* G4LogicalVolume::GetMaterial() const
{
return fMaterial;
}
inline
void G4LogicalVolume::SetMaterial(G4Material *pMaterial)
{
// assert(pMaterial != 0);
fMaterial=pMaterial;
}
inline
G4VSensitiveDetector* G4LogicalVolume::GetSensitiveDetector() const
{
return fSensitiveDetector;
}
inline
void G4LogicalVolume::SetSensitiveDetector(G4VSensitiveDetector *pSDetector)
{
fSensitiveDetector=pSDetector;
}
inline
G4UserLimits* G4LogicalVolume::GetUserLimits() const
{
return fUserLimits;
}
inline
void G4LogicalVolume::SetUserLimits(G4UserLimits *pULimits)
{
fUserLimits=pULimits;
}
inline
G4SmartVoxelHeader* G4LogicalVolume::GetVoxelHeader() const
{
return fVoxel;
}
inline
void G4LogicalVolume::SetVoxelHeader(G4SmartVoxelHeader *pVoxel)
{
fVoxel=pVoxel;
}
inline
G4double G4LogicalVolume::GetSmartless()
{
return fSmartless;
}
inline
void G4LogicalVolume::SetSmartless(G4double s)
{
fSmartless=s;
}
inline
G4bool G4LogicalVolume::operator == ( const G4LogicalVolume& lv) const
{
return (this==&lv) ? true : false;
}
inline
const G4VisAttributes* G4LogicalVolume::GetVisAttributes () const
{
return fVisAttributes;
}
inline
void G4LogicalVolume::SetVisAttributes (const G4VisAttributes* pVA)
{
fVisAttributes = pVA;
}
inline
void G4LogicalVolume::SetVisAttributes (const G4VisAttributes& VA)
{
fVisAttributes = &VA;
}
{
fVisAttributes = &VA;
}
inline void
// ********************************************************************
// BecomeEnvelopeForFastSimulation
// ********************************************************************
//
inline
void
G4LogicalVolume::BecomeEnvelopeForFastSimulation(G4FastSimulationManager* pPA)
{
SetFastSimulationManager(pPA,TRUE);
}
{
SetFastSimulationManager(pPA, true);
}
// ********************************************************************
// SetBiasWeight
// ********************************************************************
//
inline
void G4LogicalVolume::SetBiasWeight(G4double w)
{
fBiasWeight = w;
}
{
fBiasWeight = w;
}
// ********************************************************************
// GetBiasWeight
// ********************************************************************
//
inline
G4double G4LogicalVolume::GetBiasWeight() const
{
return fBiasWeight;
}
{
return fBiasWeight;
}
source/geometry/management/include/G4LogicalVolumeStore.hh
+7 -5
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4LogicalVolumeStore.hh,v 1.6 2001/07/11 09:59:17 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4LogicalVolumeStore.hh,v 1.7 2002/04/19 08:20:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// class G4LogicalVolumeStore
//
@@ -65,11 +65,12 @@ class G4LogicalVolumeStore : public G4std::vector<G4LogicalVolume*>
static void DeRegister(G4LogicalVolume* pVolume);
// Remove the logical volume from the collection.
static G4LogicalVolumeStore* GetInstance();
// Get a ptr to the unique G4LogicalVolumeStore,
// creating it if necessary.
// Get a ptr to the unique G4LogicalVolumeStore, creating it if necessary.
static void Clean();
// Delete all volumes from the store.
virtual ~G4LogicalVolumeStore();
// Destructor.
// Destructor: takes care to delete allocated logical volumes.
protected:
@@ -78,6 +79,7 @@ class G4LogicalVolumeStore : public G4std::vector<G4LogicalVolume*>
private:
static G4LogicalVolumeStore* fgInstance;
static G4bool locked;
};
#endif
source/geometry/management/include/G4PVParameterised.hh
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: G4PVParameterised.hh,v 1.5 2001/07/11 09:59:17 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
//
// class G4PVParameterised
source/geometry/management/include/G4PVPlacement.hh
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: G4PVPlacement.hh,v 1.6 2001/07/11 09:59:17 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
//
// class G4PVPlacement
source/geometry/management/include/G4PVReplica.hh
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: G4PVReplica.hh,v 1.5 2001/07/11 09:59:17 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
//
// class G4PVReplica
source/geometry/management/include/G4PhysicalVolumeStore.hh
+7 -5
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4PhysicalVolumeStore.hh,v 1.7 2001/07/11 09:59:17 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4PhysicalVolumeStore.hh,v 1.8 2002/04/19 08:20:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// class G4PhysicalVolume
//
@@ -65,11 +65,12 @@ class G4PhysicalVolumeStore : public G4std::vector<G4VPhysicalVolume*>
static void DeRegister(G4VPhysicalVolume* pSolid);
// Remove the volume from the collection.
static G4PhysicalVolumeStore* GetInstance();
// Get a ptr to the unique G4PhysicalVolumeStore,
// creating it if necessary.
// Get a ptr to the unique G4PhysicalVolumeStore, creating it if necessary.
static void Clean();
// Delete all volumes from the store.
virtual ~G4PhysicalVolumeStore();
// Default destructor.
// Destructor: takes care to delete allocated physical volumes.
protected:
@@ -78,6 +79,7 @@ class G4PhysicalVolumeStore : public G4std::vector<G4VPhysicalVolume*>
private:
static G4PhysicalVolumeStore* fgInstance;
static G4bool locked;
};
#endif
source/geometry/management/include/G4SmartVoxelHeader.hh
+6 -4
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4SmartVoxelHeader.hh,v 1.6 2001/07/11 09:59:18 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4SmartVoxelHeader.hh,v 1.7 2002/05/15 10:06:36 gcosmo Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// class G4SmartVoxelHeader
//
@@ -97,7 +97,9 @@ class G4SmartVoxelHeader
EAxis GetAxis() const;
// Return the current division axis.
EAxis GetParamAxis() const;
// Return suggested division axis for parameterised volume.
G4double GetMaxExtent() const;
// Return the maximum coordinate limit along the current axis.
G4double GetMinExtent() const;
@@ -187,7 +189,7 @@ class G4SmartVoxelHeader
G4int fmaxEquivalent;
// Min and max equivalent slice nos for previous level.
EAxis faxis;
EAxis faxis, fparamAxis;
// Axis for slices.
G4double fmaxExtent;
source/geometry/management/include/G4SmartVoxelHeader.icc
+8 -2
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4SmartVoxelHeader.icc,v 1.3 2001/07/11 09:59:18 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4SmartVoxelHeader.icc,v 1.4 2002/05/15 10:06:36 gcosmo Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
//
// G4SmartVoxelHeader Inline implementation
@@ -58,6 +58,12 @@ EAxis G4SmartVoxelHeader::GetAxis() const
return faxis;
}
inline
EAxis G4SmartVoxelHeader::GetParamAxis() const
{
return fparamAxis;
}
inline
G4double G4SmartVoxelHeader::GetMaxExtent() const
{
source/geometry/management/include/G4SmartVoxelNode.hh
+4 -4
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4SmartVoxelNode.hh,v 1.6 2001/07/11 09:59:18 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4SmartVoxelNode.hh,v 1.7 2002/04/19 08:20:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// class G4SmartVoxelNode
//
@@ -64,10 +64,10 @@ class G4SmartVoxelNode
G4SmartVoxelNode(G4int pSlice=0) : fminEquivalent(pSlice),
fmaxEquivalent(pSlice) {}
// Constructor. Create an empty node with slice number pSlice.
// THis number is not stored, but used to provide defaults for the
// This number is not stored, but used to provide defaults for the
// minimum and maximum equivalent node numbers.
~G4SmartVoxelNode() {}
~G4SmartVoxelNode();
// Destructor. No actions.
G4int GetVolume(G4int pVolumeNo) const;
source/geometry/management/include/G4SmartVoxelNode.icc
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: G4SmartVoxelNode.icc,v 1.3 2001/07/11 09:59:18 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
//
// G4SmartVoxelNode Inline implementation
source/geometry/management/include/G4SmartVoxelProxy.hh
+3 -3
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4SmartVoxelProxy.hh,v 1.5 2001/07/11 09:59:18 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4SmartVoxelProxy.hh,v 1.6 2002/04/19 08:20:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// class G4SmartVoxelProxy
//
@@ -62,7 +62,7 @@ class G4SmartVoxelProxy
: fHeader(0), fNode(pNode) {}
// Proxy for the specified node.
~G4SmartVoxelProxy() {}
~G4SmartVoxelProxy();
// Destructor - do nothing. Not responsible for proxied objects.
G4bool IsHeader() const;
source/geometry/management/include/G4SmartVoxelProxy.icc
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: G4SmartVoxelProxy.icc,v 1.2 2001/07/11 09:59:18 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
//
// G4SmartVoxelProxy Inline implementation
source/geometry/management/include/G4SmartVoxelStat.hh
+1 -1
View File
@@ -21,7 +21,7 @@
// ********************************************************************
//
// $Id: G4SmartVoxelStat.hh,v 1.1 2001/10/22 16:08:05 gcosmo Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
// --------------------------------------------------------------------
// GEANT 4 class header file
source/geometry/management/include/G4SolidStore.hh
+6 -3
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4SolidStore.hh,v 1.6 2001/07/11 09:59:18 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4SolidStore.hh,v 1.7 2002/04/19 08:20:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// class G4SolidStore
//
@@ -66,9 +66,11 @@ class G4SolidStore : public G4std::vector<G4VSolid*>
// Remove the solid from the collection.
static G4SolidStore* GetInstance();
// Get a ptr to the unique G4SolidStore, creating it if necessary.
static void Clean();
// Delete all solids from the store.
virtual ~G4SolidStore();
// Default destructor.
// Destructor: takes care to delete allocated solids.
protected:
@@ -77,6 +79,7 @@ class G4SolidStore : public G4std::vector<G4VSolid*>
private:
static G4SolidStore* fgInstance;
static G4bool locked;
};
#endif
source/geometry/management/include/G4TouchableHandle.hh
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: G4TouchableHandle.hh,v 1.5 2001/11/06 17:06:47 gcosmo Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
// Class G4TouchableHandle
//
source/geometry/management/include/G4VPVParameterisation.hh
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: G4VPVParameterisation.hh,v 1.4 2001/07/11 09:59:18 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
// class G4VPVParamterisation
//
source/geometry/management/include/G4VPhysicalVolume.hh
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: G4VPhysicalVolume.hh,v 1.6 2001/07/11 09:59:18 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
//
// class G4VPhysicalVolume
source/geometry/management/include/G4VPhysicalVolume.icc
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: G4VPhysicalVolume.icc,v 1.5 2001/07/11 09:59:18 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
//
// class G4VPhysicalVolume Inline Implementation
source/geometry/management/include/G4VSolid.hh
+9 -5
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4VSolid.hh,v 1.9 2001/07/11 09:59:19 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4VSolid.hh,v 1.10 2002/04/16 08:21:07 grichine Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
//
// class G4VSolid
@@ -188,6 +188,9 @@ class G4VSolid
// If the solid is a "G4DisplacedSolid", return a self pointer
// else return 0.
// virtual G4ThreeVectorList*
// CreateRotatedVertices(const G4AffineTransform& pTransform) const = 0 ;
protected: // with description
void CalculateClippedPolygonExtent(G4ThreeVectorList& pPolygon,
@@ -233,8 +236,9 @@ class G4VSolid
//
// No modifications are made to pVertices.
void ClipPolygon(G4ThreeVectorList& pPolygon,
const G4VoxelLimits& pVoxelLimit) const;
void ClipPolygon( G4ThreeVectorList& pPolygon,
const G4VoxelLimits& pVoxelLimit,
const EAxis pAxis ) const;
// Clip the specified convex polygon to the given limits, where
// the polygon is described by the vertices at (0),(1),...,(n),(0) in
// pPolygon.
@@ -244,7 +248,7 @@ private:
void ClipPolygonToSimpleLimits(G4ThreeVectorList& pPolygon,
G4ThreeVectorList& outputPolygon,
const G4VoxelLimits& pVoxelLimit) const;
const G4VoxelLimits& pVoxelLimit ) const;
// Clip the specified convex polygon to the given limits, storing the
// result in outputPolygon. The voxel limits must be limited in one
// *plane* only: This is achieved by having only x or y or z limits,
source/geometry/management/include/G4VSolid.icc
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: G4VSolid.icc,v 1.5 2001/07/11 09:59:19 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
//
// G4VSolid Inline implementation
source/geometry/management/include/G4VTouchable.hh
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: G4VTouchable.hh,v 1.5 2001/07/11 09:59:19 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
//
// class G4VTouchable
source/geometry/management/include/G4VTouchable.icc
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: G4VTouchable.icc,v 1.5 2001/07/11 09:59:19 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
//
// class G4VTouchable Inline implementation
source/geometry/management/include/G4VoxelLimits.hh
+4 -6
View File
@@ -21,8 +21,8 @@
// ********************************************************************
//
//
// $Id: G4VoxelLimits.hh,v 1.5 2001/07/11 09:59:19 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// $Id: G4VoxelLimits.hh,v 1.6 2002/04/19 08:20:18 gcosmo Exp $
// GEANT4 tag $Name: geant4-04-01 $
//
// class G4VoxelLimits
//
@@ -62,12 +62,10 @@ class G4VoxelLimits
{
public: // with description
G4VoxelLimits() : fxAxisMin(-kInfinity),fxAxisMax(kInfinity),
fyAxisMin(-kInfinity),fyAxisMax(kInfinity),
fzAxisMin(-kInfinity),fzAxisMax(kInfinity) {;}
G4VoxelLimits();
// Constructor - initialise to be unlimited. Volume unrestricted.
~G4VoxelLimits() {;}
~G4VoxelLimits();
// Destructor. No actions.
void AddLimit(const EAxis pAxis, const G4double pMin,const G4double pMax);
source/geometry/management/include/G4VoxelLimits.icc
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: G4VoxelLimits.icc,v 1.2 2001/07/11 09:59:19 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
//
// G4VoxelLimits Inline implementation
source/geometry/management/include/meshdefs.hh
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: meshdefs.hh,v 1.4 2001/07/11 09:59:19 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
//
// Tube/Cone Meshing constants for extent calculations
source/geometry/management/include/voxeldefs.hh
+1 -1
View File
@@ -22,7 +22,7 @@
//
//
// $Id: voxeldefs.hh,v 1.5 2001/07/11 09:59:19 gunter Exp $
// GEANT4 tag $Name: geant4-04-00 $
// GEANT4 tag $Name: geant4-04-01 $
//
//
//