G4PartialPhantomParameterisation Class Reference

G4PartialPhantomParameterisation describes partial regular parameterisations, i.e. the voxels do not completely fill the container in the three dimensions. More...

#include <G4PartialPhantomParameterisation.hh>

Inheritance diagram for G4PartialPhantomParameterisation:

Public Member Functions
	G4PartialPhantomParameterisation ()=default
	~G4PartialPhantomParameterisation () override=default
void	ComputeTransformation (const G4int, G4VPhysicalVolume *) const override
G4Material *	ComputeMaterial (const G4int repNo, G4VPhysicalVolume *currentVol, const G4VTouchable *parentTouch=nullptr) override
G4int	GetReplicaNo (const G4ThreeVector &localPoint, const G4ThreeVector &localDir) override
G4ThreeVector	GetTranslation (const G4int copyNo) const
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	SetFilledIDs (std::multimap< G4int, G4int > fid)
void	SetFilledMins (std::map< G4int, std::map< G4int, G4int > > fmins)
void	BuildContainerWalls ()
Public Member Functions inherited from G4PhantomParameterisation
	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)
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 ()

Additional Inherited Members
Protected Attributes inherited from G4PhantomParameterisation
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

G4PartialPhantomParameterisation describes partial regular parameterisations, i.e. the voxels do not completely fill the container in the three dimensions.

Definition at line 58 of file G4PartialPhantomParameterisation.hh.

Constructor & Destructor Documentation

G4PartialPhantomParameterisation()

G4PartialPhantomParameterisation::G4PartialPhantomParameterisation ( )

default

Default Constructor and Destructor.

~G4PartialPhantomParameterisation()

G4PartialPhantomParameterisation::~G4PartialPhantomParameterisation ( )

overridedefault

Member Function Documentation

BuildContainerWalls()

void G4PartialPhantomParameterisation::BuildContainerWalls

(

)

Definition at line 322 of file G4PartialPhantomParameterisation.cc.

{
  fContainerWallX = fNoVoxelsX * fVoxelHalfX;
  fContainerWallY = fNoVoxelsY * fVoxelHalfY;
  fContainerWallZ = fNoVoxelsZ * fVoxelHalfZ;
}

ComputeMaterial()

G4Material * G4PartialPhantomParameterisation::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 71 of file G4PartialPhantomParameterisation.cc.

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

ComputeTransformation()

void G4PartialPhantomParameterisation::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 44 of file G4PartialPhantomParameterisation.cc.

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

GetMaterial() [1/2]

G4Material * G4PartialPhantomParameterisation::GetMaterial

(

std::size_t

copyNo

)

const

Definition at line 111 of file G4PartialPhantomParameterisation.cc.

{
  return fMaterials[GetMaterialIndex(copyNo)];
}

GetMaterial() [2/2]

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

Definition at line 103 of file G4PartialPhantomParameterisation.cc.

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

GetMaterialIndex() [1/2]

size_t G4PartialPhantomParameterisation::GetMaterialIndex

(

std::size_t

copyNo

)

const

Definition at line 82 of file G4PartialPhantomParameterisation.cc.

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

GetMaterialIndex() [2/2]

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

Definition at line 94 of file G4PartialPhantomParameterisation.cc.

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

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

GetReplicaNo()

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

overridevirtual

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

Parameters

[in]	localPoint	Point in local coordinates system.
[in]	localDir	Local direction to overcome precision issues.

Returns

The voxel number for the specified point.

Reimplemented from G4PhantomParameterisation.

Definition at line 147 of file G4PartialPhantomParameterisation.cc.

{
  // 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 on 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;       
      }
    }
  }
  
  // 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 )
  {
    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("G4PartialPhantomParameterisation::GetReplicaNo()",
                "GeomNav1002", JustWarning, message);
  }
 
  auto  nyz = G4int(nz*fNoVoxelsY+ny);
  auto ite = fFilledIDs.cbegin();
/*
  for( ite = fFilledIDs.cbegin(); ite != fFilledIDs.cend(); ++ite )
  {
    G4cout << " G4PartialPhantomParameterisation::GetReplicaNo filled "
           << (*ite).first << " , " << (*ite).second << std::endl;
  }
*/
 
  advance(ite,nyz);
  auto iteant = ite; iteant--;
  G4int copyNo = (*iteant).first + 1 + ( nx - (*ite).second );
/*
  G4cout << " G4PartialPhantomParameterisation::GetReplicaNo getting copyNo "
         << copyNo << "  nyz " << nyz << "  (*iteant).first "
         << (*iteant).first << "  (*ite).second " <<  (*ite).second << G4endl;
 
  G4cout << " G4PartialPhantomParameterisation::GetReplicaNo " << copyNo
         << " nx " << nx << " ny " << ny << " nz " << nz
         << " localPoint " << localPoint << " localDir " << localDir << G4endl;
*/
  return copyNo;
}

GetTranslation()

G4ThreeVector G4PartialPhantomParameterisation::GetTranslation

(

const G4int

copyNo

)

const

Definition at line 55 of file G4PartialPhantomParameterisation.cc.

{
  CheckCopyNo( copyNo );
 
  std::size_t nx, ny, 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().

SetFilledIDs()

void G4PartialPhantomParameterisation::SetFilledIDs ( std::multimap< G4int, G4int > fid )

inline

Definition at line 92 of file G4PartialPhantomParameterisation.hh.

    {
      fFilledIDs = std::move(fid); 
    }

SetFilledMins()

void G4PartialPhantomParameterisation::SetFilledMins ( std::map< G4int, std::map< G4int, G4int > > fmins )

inline

Definition at line 97 of file G4PartialPhantomParameterisation.hh.

    {
      fFilledMins = std::move(fmins);
    }

---

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

• G4PartialPhantomParameterisation.hh
• G4PartialPhantomParameterisation.cc