G4PhantomParameterisation Class Reference

G4PhantomParameterisation describes regular parameterisations: a set of boxes of equal dimension in the x, y and z dimensions. The G4PVParameterised volume using this class must be placed inside a volume that is completely filled by these boxes. More...

#include <G4PhantomParameterisation.hh>

Inheritance diagram for G4PhantomParameterisation:

Public Member Functions
	G4PhantomParameterisation ()
	~G4PhantomParameterisation () override
void	ComputeTransformation (const G4int, G4VPhysicalVolume *) const override
G4VSolid *	ComputeSolid (const G4int, G4VPhysicalVolume *) override
G4Material *	ComputeMaterial (const G4int repNo, G4VPhysicalVolume *currentVol, const G4VTouchable *parentTouch=nullptr) override
void	ComputeDimensions (G4Box &, const G4int, const G4VPhysicalVolume *) const override
void	ComputeDimensions (G4Tubs &, const G4int, const G4VPhysicalVolume *) const override
void	ComputeDimensions (G4Trd &, const G4int, const G4VPhysicalVolume *) const override
void	ComputeDimensions (G4Trap &, const G4int, const G4VPhysicalVolume *) const override
void	ComputeDimensions (G4Cons &, const G4int, const G4VPhysicalVolume *) const override
void	ComputeDimensions (G4Orb &, const G4int, const G4VPhysicalVolume *) const override
void	ComputeDimensions (G4Sphere &, const G4int, const G4VPhysicalVolume *) const override
void	ComputeDimensions (G4Ellipsoid &, const G4int, const G4VPhysicalVolume *) const override
void	ComputeDimensions (G4Torus &, const G4int, const G4VPhysicalVolume *) const override
void	ComputeDimensions (G4Para &, const G4int, const G4VPhysicalVolume *) const override
void	ComputeDimensions (G4Hype &, const G4int, const G4VPhysicalVolume *) const override
void	ComputeDimensions (G4Polycone &, const G4int, const G4VPhysicalVolume *) const override
void	ComputeDimensions (G4Polyhedra &, const G4int, const G4VPhysicalVolume *) const override
void	BuildContainerSolid (G4VPhysicalVolume *pPhysicalVol)
void	BuildContainerSolid (G4VSolid *pMotherSolid)
virtual G4int	GetReplicaNo (const G4ThreeVector &localPoint, const G4ThreeVector &localDir)
void	SetMaterials (std::vector< G4Material * > &mates)
void	SetMaterialIndices (std::size_t *matInd)
void	SetVoxelDimensions (G4double halfx, G4double halfy, G4double halfz)
void	SetNoVoxels (std::size_t nx, std::size_t ny, std::size_t nz)
G4double	GetVoxelHalfX () const
G4double	GetVoxelHalfY () const
G4double	GetVoxelHalfZ () const
std::size_t	GetNoVoxelsX () const
std::size_t	GetNoVoxelsY () const
std::size_t	GetNoVoxelsZ () const
std::size_t	GetNoVoxels () const
std::vector< G4Material * >	GetMaterials () const
std::size_t *	GetMaterialIndices () const
G4VSolid *	GetContainerSolid () const
G4ThreeVector	GetTranslation (const G4int copyNo) const
G4bool	SkipEqualMaterials () const
void	SetSkipEqualMaterials (G4bool skip)
std::size_t	GetMaterialIndex (std::size_t nx, std::size_t ny, std::size_t nz) const
std::size_t	GetMaterialIndex (std::size_t copyNo) const
G4Material *	GetMaterial (std::size_t nx, std::size_t ny, std::size_t nz) const
G4Material *	GetMaterial (std::size_t copyNo) const
void	CheckVoxelsFillContainer (G4double contX, G4double contY, G4double contZ) const
Public Member Functions inherited from G4VPVParameterisation
	G4VPVParameterisation ()=default
virtual	~G4VPVParameterisation ()=default
virtual G4bool	IsNested () const
virtual G4VVolumeMaterialScanner *	GetMaterialScanner ()

Protected Attributes
G4double	fVoxelHalfX = 0.0
G4double	fVoxelHalfY = 0.0
G4double	fVoxelHalfZ = 0.0
std::size_t	fNoVoxelsX = 0
std::size_t	fNoVoxelsY = 0
std::size_t	fNoVoxelsZ = 0
std::size_t	fNoVoxelsXY = 0
std::size_t	fNoVoxels = 0
std::vector< G4Material * >	fMaterials
std::size_t *	fMaterialIndices = nullptr
G4VSolid *	fContainerSolid = nullptr
G4double	fContainerWallX =0.0
G4double	fContainerWallY =0.0
G4double	fContainerWallZ =0.0
G4double	kCarTolerance
G4bool	bSkipEqualMaterials = true

Detailed Description

G4PhantomParameterisation describes regular parameterisations: a set of boxes of equal dimension in the x, y and z dimensions. The G4PVParameterised volume using this class must be placed inside a volume that is completely filled by these boxes.

Definition at line 74 of file G4PhantomParameterisation.hh.

Constructor & Destructor Documentation

G4PhantomParameterisation()

G4PhantomParameterisation::G4PhantomParameterisation

(

)

Constructor and Destructor.

Definition at line 41 of file G4PhantomParameterisation.cc.

{
  kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
}

~G4PhantomParameterisation()

G4PhantomParameterisation::~G4PhantomParameterisation ( )

overridedefault

Member Function Documentation

BuildContainerSolid() [1/2]

void G4PhantomParameterisation::BuildContainerSolid

(

G4VPhysicalVolume *

pPhysicalVol

)

Saves as container solid the parent of the voxels. Checks that the voxels fill it completely.

Definition at line 52 of file G4PhantomParameterisation.cc.

{
  fContainerSolid = pMotherPhysical->GetLogicalVolume()->GetSolid();
  fContainerWallX = fNoVoxelsX * fVoxelHalfX;
  fContainerWallY = fNoVoxelsY * fVoxelHalfY;
  fContainerWallZ = fNoVoxelsZ * fVoxelHalfZ;
 
  // CheckVoxelsFillContainer();
}

BuildContainerSolid() [2/2]

void G4PhantomParameterisation::BuildContainerSolid

(

G4VSolid *

pMotherSolid

)

Definition at line 65 of file G4PhantomParameterisation.cc.

{
  fContainerSolid = pMotherSolid;
  fContainerWallX = fNoVoxelsX * fVoxelHalfX;
  fContainerWallY = fNoVoxelsY * fVoxelHalfY;
  fContainerWallZ = fNoVoxelsZ * fVoxelHalfZ;
 
  // CheckVoxelsFillContainer();
}

CheckVoxelsFillContainer()

void G4PhantomParameterisation::CheckVoxelsFillContainer	(	G4double	contX,
		G4double	contY,
		G4double	contZ ) const

Checks that the voxels fill it completely.

Definition at line 175 of file G4PhantomParameterisation.cc.

{
  G4double toleranceForWarning = 0.25*kCarTolerance;
 
  // Any bigger value than 0.25*kCarTolerance will give a warning in
  // G4NormalNavigation::ComputeStep(), because the Inverse of a container
  // translation that is Z+epsilon gives -Z+epsilon (and the maximum tolerance
  // in G4Box::Inside is 0.5*kCarTolerance
  //
  G4double toleranceForError = 1.*kCarTolerance;  
 
  // Any bigger value than kCarTolerance will give an error in GetReplicaNo()
  //
  if( std::fabs(contX-fNoVoxelsX*fVoxelHalfX) >= toleranceForError
   || std::fabs(contY-fNoVoxelsY*fVoxelHalfY) >= toleranceForError  
   || std::fabs(contZ-fNoVoxelsZ*fVoxelHalfZ) >= toleranceForError )
  {
    std::ostringstream message;
    message << "Voxels do not fully fill the container: "
            << fContainerSolid->GetName() << G4endl
            << "        DiffX= " << contX-fNoVoxelsX*fVoxelHalfX << G4endl
            << "        DiffY= " << contY-fNoVoxelsY*fVoxelHalfY << G4endl
            << "        DiffZ= " << contZ-fNoVoxelsZ*fVoxelHalfZ << G4endl
            << "        Maximum difference is: " << toleranceForError;
    G4Exception("G4PhantomParameterisation::CheckVoxelsFillContainer()",
                "GeomNav0002", FatalException, message);
 
  }
  else if( std::fabs(contX-fNoVoxelsX*fVoxelHalfX) >= toleranceForWarning
        || std::fabs(contY-fNoVoxelsY*fVoxelHalfY) >= toleranceForWarning  
        || std::fabs(contZ-fNoVoxelsZ*fVoxelHalfZ) >= toleranceForWarning )
  {
    std::ostringstream message;
    message << "Voxels do not fully fill the container: "
            << fContainerSolid->GetName() << G4endl
            << "          DiffX= " << contX-fNoVoxelsX*fVoxelHalfX << G4endl
            << "          DiffY= " << contY-fNoVoxelsY*fVoxelHalfY << G4endl
            << "          DiffZ= " << contZ-fNoVoxelsZ*fVoxelHalfZ << G4endl
            << "          Maximum difference is: " << toleranceForWarning;
    G4Exception("G4PhantomParameterisation::CheckVoxelsFillContainer()",
                "GeomNav1002", JustWarning, message);
  }
}

ComputeDimensions() [1/13]

void G4PhantomParameterisation::ComputeDimensions ( G4Box & , const G4int , const G4VPhysicalVolume *  ) const

inlineoverridevirtual

Dummy declarations ...

Reimplemented from G4VPVParameterisation.

Definition at line 94 of file G4PhantomParameterisation.hh.

                                                                     {}

ComputeDimensions() [2/13]

void G4PhantomParameterisation::ComputeDimensions ( G4Cons & , const G4int , const G4VPhysicalVolume *  ) const

inlineoverridevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 102 of file G4PhantomParameterisation.hh.

                                                                     {}

ComputeDimensions() [3/13]

void G4PhantomParameterisation::ComputeDimensions ( G4Ellipsoid & , const G4int , const G4VPhysicalVolume *  ) const

inlineoverridevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 108 of file G4PhantomParameterisation.hh.

                                                                     {}

ComputeDimensions() [4/13]

void G4PhantomParameterisation::ComputeDimensions ( G4Hype & , const G4int , const G4VPhysicalVolume *  ) const

inlineoverridevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 114 of file G4PhantomParameterisation.hh.

                                                                     {}

ComputeDimensions() [5/13]

void G4PhantomParameterisation::ComputeDimensions ( G4Orb & , const G4int , const G4VPhysicalVolume *  ) const

inlineoverridevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 104 of file G4PhantomParameterisation.hh.

                                                                     {}

ComputeDimensions() [6/13]

void G4PhantomParameterisation::ComputeDimensions ( G4Para & , const G4int , const G4VPhysicalVolume *  ) const

inlineoverridevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 112 of file G4PhantomParameterisation.hh.

                                                                     {}

ComputeDimensions() [7/13]

void G4PhantomParameterisation::ComputeDimensions ( G4Polycone & , const G4int , const G4VPhysicalVolume *  ) const

inlineoverridevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 116 of file G4PhantomParameterisation.hh.

                                                                     {}

ComputeDimensions() [8/13]

void G4PhantomParameterisation::ComputeDimensions ( G4Polyhedra & , const G4int , const G4VPhysicalVolume *  ) const

inlineoverridevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 118 of file G4PhantomParameterisation.hh.

                                                                     {}

ComputeDimensions() [9/13]

void G4PhantomParameterisation::ComputeDimensions ( G4Sphere & , const G4int , const G4VPhysicalVolume *  ) const

inlineoverridevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 106 of file G4PhantomParameterisation.hh.

                                                                     {}

ComputeDimensions() [10/13]

void G4PhantomParameterisation::ComputeDimensions ( G4Torus & , const G4int , const G4VPhysicalVolume *  ) const

inlineoverridevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 110 of file G4PhantomParameterisation.hh.

                                                                     {}

ComputeDimensions() [11/13]

void G4PhantomParameterisation::ComputeDimensions ( G4Trap & , const G4int , const G4VPhysicalVolume *  ) const

inlineoverridevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 100 of file G4PhantomParameterisation.hh.

                                                                     {}

ComputeDimensions() [12/13]

void G4PhantomParameterisation::ComputeDimensions ( G4Trd & , const G4int , const G4VPhysicalVolume *  ) const

inlineoverridevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 98 of file G4PhantomParameterisation.hh.

                                                                     {}

ComputeDimensions() [13/13]

void G4PhantomParameterisation::ComputeDimensions ( G4Tubs & , const G4int , const G4VPhysicalVolume *  ) const

inlineoverridevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 96 of file G4PhantomParameterisation.hh.

                                                                     {}

ComputeMaterial()

G4Material * G4PhantomParameterisation::ComputeMaterial ( const G4int repNo, G4VPhysicalVolume * currentVol, const G4VTouchable * parentTouch = nullptr )

overridevirtual

Computes the material for the 'currentVol' and replica number 'repNo'. Must cope with 'parentTouch' for navigator's SetupHierarchy() when used for nested parameterisations.

Parameters

[in]	currentVol	Pointer to the current physical volume.
[in]	repNo	The copy number index.
[in]	parentTouch	Pointer to the touchable of the parent volume.

Returns

A pointer to the associated material.

Reimplemented from G4VPVParameterisation.

Definition at line 117 of file G4PhantomParameterisation.cc.

{ 
  CheckCopyNo( copyNo );
  std::size_t matIndex = GetMaterialIndex(copyNo);
 
  return fMaterials[ matIndex ];
}

Referenced by G4GMocrenFileSceneHandler::AddSolid(), and G4RegularNavigation::LevelLocate().

ComputeSolid()

G4VSolid * G4PhantomParameterisation::ComputeSolid ( const G4int no, G4VPhysicalVolume * pv )

overridevirtual

Computes the solid for the 'pv' volume and replica number 'no'. To be optionally defined in derived classes, for parameterisation of the solid type.

Parameters

[in]	no	The copy number index.
[in]	pv	Pointer to the current physical volume.

Reimplemented from G4VPVParameterisation.

Definition at line 109 of file G4PhantomParameterisation.cc.

{
  return pPhysicalVol->GetLogicalVolume()->GetSolid();
}

ComputeTransformation()

void G4PhantomParameterisation::ComputeTransformation ( const G4int no, G4VPhysicalVolume * pv ) const

overridevirtual

Computes the transformation for the 'pv' volume and replica number 'no'. It is a required method, as it is the reason for this class.

Parameters

[in]	pv	Pointer to the current physical volume.
[in]	no	The copy number index.

Implements G4VPVParameterisation.

Definition at line 78 of file G4PhantomParameterisation.cc.

{
  // Voxels cannot be rotated, return translation
  //
  G4ThreeVector trans = GetTranslation( copyNo );
 
  physVol->SetTranslation( trans );
}

Referenced by G4RegularNavigation::LevelLocate().

GetContainerSolid()

G4VSolid * G4PhantomParameterisation::GetContainerSolid ( ) const

inline

GetMaterial() [1/2]

G4Material * G4PhantomParameterisation::GetMaterial

(

std::size_t

copyNo

)

const

Definition at line 156 of file G4PhantomParameterisation.cc.

{
  return fMaterials[GetMaterialIndex(copyNo)];
}

GetMaterial() [2/2]

G4Material * G4PhantomParameterisation::GetMaterial	(	std::size_t	nx,
		std::size_t	ny,
		std::size_t	nz ) const

Definition at line 149 of file G4PhantomParameterisation.cc.

{
  return fMaterials[GetMaterialIndex(nx,ny,nz)];
}

GetMaterialIndex() [1/2]

std::size_t G4PhantomParameterisation::GetMaterialIndex

(

std::size_t

copyNo

)

const

Definition at line 128 of file G4PhantomParameterisation.cc.

{
  CheckCopyNo( copyNo );
 
  if( fMaterialIndices == nullptr ) { return 0; }
  return *(fMaterialIndices+copyNo);
}

GetMaterialIndex() [2/2]

std::size_t G4PhantomParameterisation::GetMaterialIndex	(	std::size_t	nx,
		std::size_t	ny,
		std::size_t	nz ) const

Definition at line 139 of file G4PhantomParameterisation.cc.

{
  std::size_t copyNo = nx + fNoVoxelsX*ny + fNoVoxelsXY*nz;
  return GetMaterialIndex( copyNo );
}

Referenced by ComputeMaterial(), GetMaterial(), GetMaterial(), and GetMaterialIndex().

GetMaterialIndices()

std::size_t * G4PhantomParameterisation::GetMaterialIndices ( ) const

inline

GetMaterials()

std::vector< G4Material * > G4PhantomParameterisation::GetMaterials ( ) const

inline

GetNoVoxels()

std::size_t G4PhantomParameterisation::GetNoVoxels ( ) const

inline

Referenced by G4RegularNavigation::LevelLocate().

GetNoVoxelsX()

std::size_t G4PhantomParameterisation::GetNoVoxelsX ( ) const

inline

Referenced by G4GMocrenFileSceneHandler::AddSolid().

GetNoVoxelsY()

std::size_t G4PhantomParameterisation::GetNoVoxelsY ( ) const

inline

Referenced by G4GMocrenFileSceneHandler::AddSolid().

GetNoVoxelsZ()

std::size_t G4PhantomParameterisation::GetNoVoxelsZ ( ) const

inline

Referenced by G4GMocrenFileSceneHandler::AddSolid().

GetReplicaNo()

G4int G4PhantomParameterisation::GetReplicaNo ( const G4ThreeVector & localPoint, const G4ThreeVector & localDir )

virtual

Gets the voxel number corresponding to the point in the container frame. Uses 'localDir' to avoid precision problems at the surfaces.

Reimplemented in G4PartialPhantomParameterisation.

Definition at line 222 of file G4PhantomParameterisation.cc.

{
 
  // Check first that point is really inside voxels
  //
  if( fContainerSolid->Inside( localPoint ) == kOutside )
  {
    if( std::fabs(localPoint.x()) - fContainerWallX > kCarTolerance
    && std::fabs(localPoint.y()) - fContainerWallY > kCarTolerance
    && std::fabs(localPoint.z()) - fContainerWallZ > kCarTolerance )
    {
      std::ostringstream message;
      message << "Point outside voxels!" << G4endl
          << "        localPoint - " << localPoint
          << " - is outside container solid: "
          << fContainerSolid->GetName() << G4endl
          << "DIFFERENCE WITH PHANTOM WALLS X: "
          << std::fabs(localPoint.x()) - fContainerWallX
          << " Y: " << std::fabs(localPoint.y()) - fContainerWallY
          << " Z: " << std::fabs(localPoint.z()) - fContainerWallZ;
      G4Exception("G4PhantomParameterisation::GetReplicaNo()", "GeomNav0003",
          FatalErrorInArgument, message);
    }
  }
  
  // Check the voxel numbers corresponding to localPoint
  // When a particle is on a surface, it may be between -kCarTolerance and
  // +kCartolerance. By a simple distance as:
  //   G4int nx = G4int( (localPoint.x()+)/fVoxelHalfX/2.);
  // those between -kCartolerance and 0 will be placed on voxel N-1 and those
  // between 0 and kCarTolerance on voxel N.
  // To avoid precision problems place the tracks that are on the surface on
  // voxel N-1 if they have negative direction and on voxel N if they have
  // positive direction.
  // Add +kCarTolerance so that they are first placed on voxel N, and then
  // if the direction is negative substract 1
 
  G4double fx = (localPoint.x()+fContainerWallX+kCarTolerance)/(fVoxelHalfX*2.);
  auto  nx = G4int(fx);
 
  G4double fy = (localPoint.y()+fContainerWallY+kCarTolerance)/(fVoxelHalfY*2.); 
  auto  ny = G4int(fy);
 
  G4double fz = (localPoint.z()+fContainerWallZ+kCarTolerance)/(fVoxelHalfZ*2.);
  auto  nz = G4int(fz);
 
  // If it is on the surface side, check the direction: if direction is
  // negative place it in the previous voxel (if direction is positive it is
  // already in the next voxel).
  // Correct also cases where n = -1 or n = fNoVoxels. It is always traced to be
  // due to multiple scattering: track is entering a voxel but multiple
  // scattering changes the angle towards outside
  //
  if( fx - nx < kCarTolerance*fVoxelHalfX )
  {
    if( localDir.x() < 0 )
    {
      if( nx != 0 )
      {
        nx -= 1;
      }
    }
    else
    {
      if( nx == G4int(fNoVoxelsX) )  
      {
        nx -= 1;       
      }
    }
  }
  if( fy - ny < kCarTolerance*fVoxelHalfY )
  {
    if( localDir.y() < 0 )
    {
      if( ny != 0 )
      {
        ny -= 1;
      }
    }
    else
    {
      if( ny == G4int(fNoVoxelsY) )  
      {
        ny -= 1;       
      }
    }
  }
  if( fz - nz < kCarTolerance*fVoxelHalfZ )
  {
    if( localDir.z() < 0 )
    {
      if( nz != 0 )
      {
        nz -= 1;
      }
    }
    else
    {
      if( nz == G4int(fNoVoxelsZ) )  
      {
        nz -= 1;       
      }
    }
  }
  
  auto  copyNo = G4int(nx + fNoVoxelsX*ny + fNoVoxelsXY*nz);
 
  // Check if there are still errors 
  //
  G4bool isOK = true;
  if( nx < 0 )
  {
    nx = 0;
    isOK = false;
  }
  else if( nx >= G4int(fNoVoxelsX) )
  {
    nx = G4int(fNoVoxelsX)-1;
    isOK = false;
  }
  if( ny < 0 )
  {
    ny = 0;
    isOK = false;
  }
  else if( ny >= G4int(fNoVoxelsY) )
  {
    ny = G4int(fNoVoxelsY)-1;
    isOK = false;
  }
  if( nz < 0 )
  {
    nz = 0;
    isOK = false;
  }
  else if( nz >= G4int(fNoVoxelsZ) )
  {
    nz = G4int(fNoVoxelsZ)-1;
    isOK = false;
  }
  if( !isOK )
  {
    if( std::fabs(localPoint.x()-fContainerWallX) > kCarTolerance &&
    std::fabs(localPoint.y()-fContainerWallY) > kCarTolerance &&
    std::fabs(localPoint.z()-fContainerWallZ) > kCarTolerance ){    // only if difference is big 
      std::ostringstream message;
      message << "Corrected the copy number! It was negative or too big" << G4endl
          << "          LocalPoint: " << localPoint << G4endl
          << "          LocalDir: " << localDir << G4endl
          << "          Voxel container size: " << fContainerWallX
          << " " << fContainerWallY << " " << fContainerWallZ << G4endl
          << "          LocalPoint - wall: "
          << localPoint.x()-fContainerWallX << " "
          << localPoint.y()-fContainerWallY << " "
          << localPoint.z()-fContainerWallZ;
      G4Exception("G4PhantomParameterisation::GetReplicaNo()",
          "GeomNav1002", JustWarning, message);
    }
    
    copyNo = G4int(nx + fNoVoxelsX*ny + fNoVoxelsXY*nz);
  }
 
  return copyNo;
}

Referenced by G4RegularNavigation::LevelLocate().

GetTranslation()

G4ThreeVector G4PhantomParameterisation::GetTranslation

(

const G4int

copyNo

)

const

Definition at line 90 of file G4PhantomParameterisation.cc.

{
  CheckCopyNo( copyNo );
 
  std::size_t nx;
  std::size_t ny;
  std::size_t nz;
 
  ComputeVoxelIndices( copyNo, nx, ny, nz );
 
  G4ThreeVector trans( (2*nx+1)*fVoxelHalfX - fContainerWallX,
                       (2*ny+1)*fVoxelHalfY - fContainerWallY,
                       (2*nz+1)*fVoxelHalfZ - fContainerWallZ);
  return trans;
}

Referenced by ComputeTransformation().

GetVoxelHalfX()

G4double G4PhantomParameterisation::GetVoxelHalfX ( ) const

inline

Referenced by G4GMocrenFileSceneHandler::AddSolid().

GetVoxelHalfY()

G4double G4PhantomParameterisation::GetVoxelHalfY ( ) const

inline

Referenced by G4GMocrenFileSceneHandler::AddSolid().

GetVoxelHalfZ()

G4double G4PhantomParameterisation::GetVoxelHalfZ ( ) const

inline

Referenced by G4GMocrenFileSceneHandler::AddSolid().

SetMaterialIndices()

void G4PhantomParameterisation::SetMaterialIndices ( std::size_t * matInd )

inline

SetMaterials()

void G4PhantomParameterisation::SetMaterials ( std::vector< G4Material * > & mates )

inline

Set and Get methods

SetNoVoxels()

void G4PhantomParameterisation::SetNoVoxels	(	std::size_t	nx,
		std::size_t	ny,
		std::size_t	nz )

SetSkipEqualMaterials()

void G4PhantomParameterisation::SetSkipEqualMaterials

(

G4bool

skip

)

SetVoxelDimensions()

void G4PhantomParameterisation::SetVoxelDimensions	(	G4double	halfx,
		G4double	halfy,
		G4double	halfz )

SkipEqualMaterials()

G4bool G4PhantomParameterisation::SkipEqualMaterials

(

)

const

Member Data Documentation

bSkipEqualMaterials

G4bool G4PhantomParameterisation::bSkipEqualMaterials = true

protected

Flag to skip surface when two voxel have same material or not.

Definition at line 217 of file G4PhantomParameterisation.hh.

fContainerSolid

G4VSolid* G4PhantomParameterisation::fContainerSolid = nullptr

protected

Saves as container solid the parent of the voxels.

Definition at line 208 of file G4PhantomParameterisation.hh.

Referenced by BuildContainerSolid(), BuildContainerSolid(), CheckVoxelsFillContainer(), and GetReplicaNo().

fContainerWallX

G4double G4PhantomParameterisation::fContainerWallX =0.0

protected

Save position of container wall for speed-up.

Definition at line 211 of file G4PhantomParameterisation.hh.

Referenced by BuildContainerSolid(), BuildContainerSolid(), G4PartialPhantomParameterisation::BuildContainerWalls(), G4PartialPhantomParameterisation::GetReplicaNo(), GetReplicaNo(), G4PartialPhantomParameterisation::GetTranslation(), and GetTranslation().

fContainerWallY

G4double G4PhantomParameterisation::fContainerWallY =0.0

protected

Definition at line 211 of file G4PhantomParameterisation.hh.

Referenced by BuildContainerSolid(), BuildContainerSolid(), G4PartialPhantomParameterisation::BuildContainerWalls(), G4PartialPhantomParameterisation::GetReplicaNo(), GetReplicaNo(), G4PartialPhantomParameterisation::GetTranslation(), and GetTranslation().

fContainerWallZ

G4double G4PhantomParameterisation::fContainerWallZ =0.0

protected

Definition at line 211 of file G4PhantomParameterisation.hh.

Referenced by BuildContainerSolid(), BuildContainerSolid(), G4PartialPhantomParameterisation::BuildContainerWalls(), G4PartialPhantomParameterisation::GetReplicaNo(), GetReplicaNo(), G4PartialPhantomParameterisation::GetTranslation(), and GetTranslation().

fMaterialIndices

std::size_t* G4PhantomParameterisation::fMaterialIndices = nullptr

protected

Index in fMaterials that correspond to each voxel.

Definition at line 205 of file G4PhantomParameterisation.hh.

Referenced by G4PartialPhantomParameterisation::GetMaterialIndex(), and GetMaterialIndex().

fMaterials

std::vector<G4Material*> G4PhantomParameterisation::fMaterials

protected

List of materials of the voxels.

Definition at line 202 of file G4PhantomParameterisation.hh.

Referenced by G4PartialPhantomParameterisation::ComputeMaterial(), ComputeMaterial(), G4PartialPhantomParameterisation::GetMaterial(), G4PartialPhantomParameterisation::GetMaterial(), GetMaterial(), and GetMaterial().

fNoVoxels

std::size_t G4PhantomParameterisation::fNoVoxels = 0

protected

Total number of voxels (for speed-up).

Definition at line 199 of file G4PhantomParameterisation.hh.

fNoVoxelsX

std::size_t G4PhantomParameterisation::fNoVoxelsX = 0

protected

Number of voxel in x, y and z dimensions.

Definition at line 193 of file G4PhantomParameterisation.hh.

Referenced by BuildContainerSolid(), BuildContainerSolid(), G4PartialPhantomParameterisation::BuildContainerWalls(), CheckVoxelsFillContainer(), G4PartialPhantomParameterisation::GetMaterialIndex(), GetMaterialIndex(), G4PartialPhantomParameterisation::GetReplicaNo(), and GetReplicaNo().

fNoVoxelsXY

std::size_t G4PhantomParameterisation::fNoVoxelsXY = 0

protected

Number of voxels in x times number of voxels in y (for speed-up).

Definition at line 196 of file G4PhantomParameterisation.hh.

Referenced by G4PartialPhantomParameterisation::GetMaterialIndex(), GetMaterialIndex(), and GetReplicaNo().

fNoVoxelsY

std::size_t G4PhantomParameterisation::fNoVoxelsY = 0

protected

Definition at line 193 of file G4PhantomParameterisation.hh.

Referenced by BuildContainerSolid(), BuildContainerSolid(), G4PartialPhantomParameterisation::BuildContainerWalls(), CheckVoxelsFillContainer(), G4PartialPhantomParameterisation::GetReplicaNo(), and GetReplicaNo().

fNoVoxelsZ

std::size_t G4PhantomParameterisation::fNoVoxelsZ = 0

protected

Definition at line 193 of file G4PhantomParameterisation.hh.

Referenced by BuildContainerSolid(), BuildContainerSolid(), G4PartialPhantomParameterisation::BuildContainerWalls(), CheckVoxelsFillContainer(), G4PartialPhantomParameterisation::GetReplicaNo(), and GetReplicaNo().

fVoxelHalfX

G4double G4PhantomParameterisation::fVoxelHalfX = 0.0

protected

Half dimension of voxels (assume they are boxes).

Definition at line 190 of file G4PhantomParameterisation.hh.

Referenced by BuildContainerSolid(), BuildContainerSolid(), G4PartialPhantomParameterisation::BuildContainerWalls(), CheckVoxelsFillContainer(), G4PartialPhantomParameterisation::GetReplicaNo(), GetReplicaNo(), G4PartialPhantomParameterisation::GetTranslation(), and GetTranslation().

fVoxelHalfY

G4double G4PhantomParameterisation::fVoxelHalfY = 0.0

protected

Definition at line 190 of file G4PhantomParameterisation.hh.

Referenced by BuildContainerSolid(), BuildContainerSolid(), G4PartialPhantomParameterisation::BuildContainerWalls(), CheckVoxelsFillContainer(), G4PartialPhantomParameterisation::GetReplicaNo(), GetReplicaNo(), G4PartialPhantomParameterisation::GetTranslation(), and GetTranslation().

fVoxelHalfZ

G4double G4PhantomParameterisation::fVoxelHalfZ = 0.0

protected

Definition at line 190 of file G4PhantomParameterisation.hh.

Referenced by BuildContainerSolid(), BuildContainerSolid(), G4PartialPhantomParameterisation::BuildContainerWalls(), CheckVoxelsFillContainer(), G4PartialPhantomParameterisation::GetReplicaNo(), GetReplicaNo(), G4PartialPhantomParameterisation::GetTranslation(), and GetTranslation().

kCarTolerance

G4double G4PhantomParameterisation::kCarTolerance

protected

Relative surface tolerance.

Definition at line 214 of file G4PhantomParameterisation.hh.

Referenced by CheckVoxelsFillContainer(), G4PhantomParameterisation(), G4PartialPhantomParameterisation::GetReplicaNo(), and GetReplicaNo().

---

The documentation for this class was generated from the following files:

• G4PhantomParameterisation.hh
• G4PhantomParameterisation.cc