#include <G4PhantomParameterisation.hh>

Inheritance diagram for G4PhantomParameterisation:

Public Member Functions
void	BuildContainerSolid (G4VPhysicalVolume *pPhysicalVol)

void	BuildContainerSolid (G4VSolid *pMotherSolid)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

virtual G4VSolid *	ComputeSolid (const G4int, G4VPhysicalVolume *)

virtual void	ComputeTransformation (const G4int, G4VPhysicalVolume *) const

	G4PhantomParameterisation ()

G4VSolid *	GetContainerSolid () const

G4Material *	GetMaterial (size_t copyNo) const

G4Material *	GetMaterial (size_t nx, size_t ny, size_t nz) const

size_t	GetMaterialIndex (size_t copyNo) const

size_t	GetMaterialIndex (size_t nx, size_t ny, size_t nz) const

size_t *	GetMaterialIndices () const

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

virtual G4VVolumeMaterialScanner *	GetMaterialScanner ()

size_t	GetNoVoxels () const

size_t	GetNoVoxelsX () const

size_t	GetNoVoxelsY () const

size_t	GetNoVoxelsZ () const

virtual G4int	GetReplicaNo (const G4ThreeVector &localPoint, const G4ThreeVector &localDir)

G4ThreeVector	GetTranslation (const G4int copyNo) const

G4double	GetVoxelHalfX () const

G4double	GetVoxelHalfY () const

G4double	GetVoxelHalfZ () const

virtual G4bool	IsNested () const

void	SetMaterialIndices (size_t *matInd)

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

void	SetNoVoxels (size_t nx, size_t ny, size_t nz)

void	SetSkipEqualMaterials (G4bool skip)

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

G4bool	SkipEqualMaterials () const

	~G4PhantomParameterisation ()

Protected Attributes
G4bool	bSkipEqualMaterials = true

G4VSolid *	fContainerSolid = nullptr

G4double	fContainerWallX =0.0

G4double	fContainerWallY =0.0

G4double	fContainerWallZ =0.0

size_t *	fMaterialIndices = nullptr

std::vector< G4Material * >	fMaterials

size_t	fNoVoxels = 0

size_t	fNoVoxelsX = 0

size_t	fNoVoxelsXY = 0

size_t	fNoVoxelsY = 0

size_t	fNoVoxelsZ = 0

G4double	fVoxelHalfX = 0.0

G4double	fVoxelHalfY = 0.0

G4double	fVoxelHalfZ = 0.0

G4double	kCarTolerance

Private Member Functions
void	CheckCopyNo (const G4int copyNo) const

void	ComputeVoxelIndices (const G4int copyNo, size_t &nx, size_t &ny, size_t &nz) const

Detailed Description

Definition at line 68 of file G4PhantomParameterisation.hh.

Constructor & Destructor Documentation

◆ G4PhantomParameterisation()

G4PhantomParameterisation::G4PhantomParameterisation ( )

Definition at line 42 of file G4PhantomParameterisation.cc.

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

References G4GeometryTolerance::GetInstance(), G4GeometryTolerance::GetSurfaceTolerance(), and kCarTolerance.

◆ ~G4PhantomParameterisation()

G4PhantomParameterisation::~G4PhantomParameterisation ( )

Definition at line 49 of file G4PhantomParameterisation.cc.

50{

51}

Member Function Documentation

◆ BuildContainerSolid() [1/2]

void G4PhantomParameterisation::BuildContainerSolid ( G4VPhysicalVolume * pPhysicalVol )

Definition at line 55 of file G4PhantomParameterisation.cc.

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

References fContainerSolid, fContainerWallX, fContainerWallY, fContainerWallZ, fNoVoxelsX, fNoVoxelsY, fNoVoxelsZ, fVoxelHalfX, fVoxelHalfY, fVoxelHalfZ, G4VPhysicalVolume::GetLogicalVolume(), and G4LogicalVolume::GetSolid().

◆ BuildContainerSolid() [2/2]

void G4PhantomParameterisation::BuildContainerSolid ( G4VSolid * pMotherSolid )

Definition at line 67 of file G4PhantomParameterisation.cc.

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

References fContainerSolid, fContainerWallX, fContainerWallY, fContainerWallZ, fNoVoxelsX, fNoVoxelsY, fNoVoxelsZ, fVoxelHalfX, fVoxelHalfY, and fVoxelHalfZ.

◆ CheckCopyNo()

void G4PhantomParameterisation::CheckCopyNo ( const G4int copyNo ) const

private

Definition at line 390 of file G4PhantomParameterisation.cc.

{ 
  if( copyNo < 0 || copyNo >= G4int(fNoVoxels) )
  {
    std::ostringstream message;
    message << "Copy number is negative or too big!" << G4endl
            << "        Copy number: " << copyNo << G4endl
            << "        Total number of voxels: " << fNoVoxels;
    G4Exception("G4PhantomParameterisation::CheckCopyNo()",
                "GeomNav0002", FatalErrorInArgument, message);
  }
}

References FatalErrorInArgument, fNoVoxels, G4endl, and G4Exception().

Referenced by ComputeMaterial(), ComputeVoxelIndices(), GetMaterialIndex(), and GetTranslation().

◆ CheckVoxelsFillContainer()

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

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);
  }
}

References FatalException, fContainerSolid, fNoVoxelsX, fNoVoxelsY, fNoVoxelsZ, fVoxelHalfX, fVoxelHalfY, fVoxelHalfZ, G4endl, G4Exception(), G4VSolid::GetName(), JustWarning, and kCarTolerance.

◆ ComputeDimensions() [1/13]

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

inlinevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 84 of file G4PhantomParameterisation.hh.

85 {}

◆ ComputeDimensions() [2/13]

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

inlinevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 92 of file G4PhantomParameterisation.hh.

93 {}

◆ ComputeDimensions() [3/13]

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

inlinevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 98 of file G4PhantomParameterisation.hh.

99 {}

◆ ComputeDimensions() [4/13]

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

inlinevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 104 of file G4PhantomParameterisation.hh.

105 {}

◆ ComputeDimensions() [5/13]

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

inlinevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 94 of file G4PhantomParameterisation.hh.

95 {}

◆ ComputeDimensions() [6/13]

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

inlinevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 102 of file G4PhantomParameterisation.hh.

103 {}

◆ ComputeDimensions() [7/13]

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

inlinevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 106 of file G4PhantomParameterisation.hh.

107 {}

◆ ComputeDimensions() [8/13]

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

inlinevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 108 of file G4PhantomParameterisation.hh.

109 {}

◆ ComputeDimensions() [9/13]

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

inlinevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 96 of file G4PhantomParameterisation.hh.

97 {}

◆ ComputeDimensions() [10/13]

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

inlinevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 100 of file G4PhantomParameterisation.hh.

101 {}

◆ ComputeDimensions() [11/13]

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

inlinevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 90 of file G4PhantomParameterisation.hh.

91 {}

◆ ComputeDimensions() [12/13]

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

inlinevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 88 of file G4PhantomParameterisation.hh.

89 {}

◆ ComputeDimensions() [13/13]

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

inlinevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 86 of file G4PhantomParameterisation.hh.

87 {}

◆ ComputeMaterial()

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

virtual

Reimplemented from G4VPVParameterisation.

Reimplemented in G4PartialPhantomParameterisation.

Definition at line 119 of file G4PhantomParameterisation.cc.

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

References CheckCopyNo(), fMaterials, and GetMaterialIndex().

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

◆ ComputeSolid()

G4VSolid * G4PhantomParameterisation::ComputeSolid	(	const	G4int,
		G4VPhysicalVolume *	pPhysicalVol
	)

virtual

Reimplemented from G4VPVParameterisation.

Definition at line 111 of file G4PhantomParameterisation.cc.

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

References G4VPhysicalVolume::GetLogicalVolume(), and G4LogicalVolume::GetSolid().

◆ ComputeTransformation()

void G4PhantomParameterisation::ComputeTransformation	(	const G4int	copyNo,
		G4VPhysicalVolume *	physVol
	)		const

virtual

Implements G4VPVParameterisation.

Reimplemented in G4PartialPhantomParameterisation.

Definition at line 80 of file G4PhantomParameterisation.cc.

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

References GetTranslation(), and G4VPhysicalVolume::SetTranslation().

Referenced by G4RegularNavigation::LevelLocate().

◆ ComputeVoxelIndices()

void G4PhantomParameterisation::ComputeVoxelIndices	(	const G4int	copyNo,
		size_t &	nx,
		size_t &	ny,
		size_t &	nz
	)		const

private

Definition at line 163 of file G4PhantomParameterisation.cc.

{
  CheckCopyNo( copyNo );
  nx = size_t(copyNo%fNoVoxelsX);
  ny = size_t( (copyNo/fNoVoxelsX)%fNoVoxelsY );
  nz = size_t(copyNo/fNoVoxelsXY);
}

References CheckCopyNo(), fNoVoxelsX, fNoVoxelsXY, and fNoVoxelsY.

Referenced by GetTranslation().

◆ GetContainerSolid()

G4VSolid * G4PhantomParameterisation::GetContainerSolid ( ) const

inline

Referenced by G4RegularNavigation::ComputeStepSkippingEqualMaterials().

◆ GetMaterial() [1/2]

G4Material * G4PhantomParameterisation::GetMaterial ( size_t copyNo ) const

Definition at line 157 of file G4PhantomParameterisation.cc.

{
  return fMaterials[GetMaterialIndex(copyNo)];
}

References fMaterials, and GetMaterialIndex().

◆ GetMaterial() [2/2]

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

Definition at line 151 of file G4PhantomParameterisation.cc.

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

References fMaterials, and GetMaterialIndex().

Referenced by G4EnergySplitter::SplitEnergyInVolumes().

◆ GetMaterialIndex() [1/2]

size_t G4PhantomParameterisation::GetMaterialIndex ( size_t copyNo ) const

Definition at line 130 of file G4PhantomParameterisation.cc.

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

References CheckCopyNo(), and fMaterialIndices.

◆ GetMaterialIndex() [2/2]

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

Definition at line 141 of file G4PhantomParameterisation.cc.

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

References fNoVoxelsX, fNoVoxelsXY, and GetMaterialIndex().

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

◆ GetMaterialIndices()

size_t * G4PhantomParameterisation::GetMaterialIndices ( ) const

inline

◆ GetMaterials()

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

inline

◆ GetMaterialScanner()

G4VVolumeMaterialScanner * G4VPVParameterisation::GetMaterialScanner ( )

virtualinherited

Reimplemented in G4VNestedParameterisation.

Definition at line 62 of file G4VPVParameterisation.cc.

{
  return nullptr;
}

Referenced by G4Region::ScanVolumeTree().

◆ GetNoVoxels()

size_t G4PhantomParameterisation::GetNoVoxels ( ) const

inline

Referenced by G4RegularNavigation::LevelLocate().

◆ GetNoVoxelsX()

size_t G4PhantomParameterisation::GetNoVoxelsX ( ) const

inline

Referenced by G4GMocrenFileSceneHandler::AddSolid().

◆ GetNoVoxelsY()

size_t G4PhantomParameterisation::GetNoVoxelsY ( ) const

inline

Referenced by G4GMocrenFileSceneHandler::AddSolid().

◆ GetNoVoxelsZ()

size_t G4PhantomParameterisation::GetNoVoxelsZ ( ) const

inline

Referenced by G4GMocrenFileSceneHandler::AddSolid().

◆ GetReplicaNo()

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

virtual

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.);
  G4int nx = G4int(fx);
 
  G4double fy = (localPoint.y()+fContainerWallY+kCarTolerance)/(fVoxelHalfY*2.); 
  G4int ny = G4int(fy);
 
  G4double fz = (localPoint.z()+fContainerWallZ+kCarTolerance)/(fVoxelHalfZ*2.);
  G4int 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;       
      }
    }
  }
  
  G4int copyNo = 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 = fNoVoxelsX-1;
    isOK = false;
  }
  if( ny < 0 )
  {
    ny = 0;
    isOK = false;
  }
  else if( ny >= G4int(fNoVoxelsY) )
  {
    ny = fNoVoxelsY-1;
    isOK = false;
  }
  if( nz < 0 )
  {
    nz = 0;
    isOK = false;
  }
  else if( nz >= G4int(fNoVoxelsZ) )
  {
    nz = 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 = nx + fNoVoxelsX*ny + fNoVoxelsXY*nz;
  }
 
  return copyNo;
}

References FatalErrorInArgument, fContainerSolid, fContainerWallX, fContainerWallY, fContainerWallZ, fNoVoxelsX, fNoVoxelsXY, fNoVoxelsY, fNoVoxelsZ, fVoxelHalfX, fVoxelHalfY, fVoxelHalfZ, G4endl, G4Exception(), G4VSolid::GetName(), G4VSolid::Inside(), JustWarning, kCarTolerance, kOutside, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by G4RegularNavigation::ComputeStep(), G4RegularNavigation::ComputeStepSkippingEqualMaterials(), and G4RegularNavigation::LevelLocate().

◆ GetTranslation()

G4ThreeVector G4PhantomParameterisation::GetTranslation ( const G4int copyNo ) const

Definition at line 92 of file G4PhantomParameterisation.cc.

{
  CheckCopyNo( copyNo );
 
  size_t nx;
  size_t ny;
  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;
}