#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

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

◆ ~G4PhantomParameterisation()

G4PhantomParameterisation::~G4PhantomParameterisation ( )

overridedefault

Member Function Documentation

◆ BuildContainerSolid() [1/2]

void G4PhantomParameterisation::BuildContainerSolid ( G4VPhysicalVolume * pPhysicalVol )

Definition at line 53 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 66 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

Definition at line 176 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

Reimplemented from G4VPVParameterisation.

Definition at line 84 of file G4PhantomParameterisation.hh.

85 {}

◆ ComputeDimensions() [2/13]

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

inlineoverridevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 92 of file G4PhantomParameterisation.hh.

93 {}

◆ ComputeDimensions() [3/13]

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

inlineoverridevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 98 of file G4PhantomParameterisation.hh.

99 {}

◆ ComputeDimensions() [4/13]

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

inlineoverridevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 104 of file G4PhantomParameterisation.hh.

105 {}

◆ ComputeDimensions() [5/13]

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

inlineoverridevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 94 of file G4PhantomParameterisation.hh.

95 {}

◆ ComputeDimensions() [6/13]

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

inlineoverridevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 102 of file G4PhantomParameterisation.hh.

103 {}

◆ ComputeDimensions() [7/13]

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

inlineoverridevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 106 of file G4PhantomParameterisation.hh.

107 {}

◆ ComputeDimensions() [8/13]

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

inlineoverridevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 108 of file G4PhantomParameterisation.hh.

109 {}

◆ ComputeDimensions() [9/13]

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

inlineoverridevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 96 of file G4PhantomParameterisation.hh.

97 {}

◆ ComputeDimensions() [10/13]

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

inlineoverridevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 100 of file G4PhantomParameterisation.hh.

101 {}

◆ ComputeDimensions() [11/13]

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

inlineoverridevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 90 of file G4PhantomParameterisation.hh.

91 {}

◆ ComputeDimensions() [12/13]

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

inlineoverridevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 88 of file G4PhantomParameterisation.hh.

89 {}

◆ ComputeDimensions() [13/13]

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

inlineoverridevirtual

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 )

overridevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 118 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	,
		G4VPhysicalVolume *	pPhysicalVol )

overridevirtual

Reimplemented from G4VPVParameterisation.

Definition at line 110 of file G4PhantomParameterisation.cc.

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

◆ ComputeTransformation()

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

overridevirtual

Implements G4VPVParameterisation.

Definition at line 79 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 157 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 150 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 129 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 140 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

Reimplemented in G4PartialPhantomParameterisation.

Definition at line 223 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 91 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;
}