#include <G4PartialPhantomParameterisation.hh>

Inheritance diagram for G4PartialPhantomParameterisation:

Public Member Functions
	G4PartialPhantomParameterisation ()

	~G4PartialPhantomParameterisation () override

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

Definition at line 53 of file G4PartialPhantomParameterisation.hh.

Constructor & Destructor Documentation

◆ G4PartialPhantomParameterisation()

G4PartialPhantomParameterisation::G4PartialPhantomParameterisation ( )

Definition at line 44 of file G4PartialPhantomParameterisation.cc.

45{

46}

◆ ~G4PartialPhantomParameterisation()

G4PartialPhantomParameterisation::~G4PartialPhantomParameterisation ( )

overridedefault

Member Function Documentation

◆ BuildContainerWalls()

void G4PartialPhantomParameterisation::BuildContainerWalls ( )

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

Reimplemented from G4VPVParameterisation.

Definition at line 80 of file G4PartialPhantomParameterisation.cc.

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

◆ ComputeTransformation()

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

overridevirtual

Implements G4VPVParameterisation.

Definition at line 53 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 120 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 112 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 91 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 103 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

Reimplemented from G4PhantomParameterisation.

Definition at line 156 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 64 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 79 of file G4PartialPhantomParameterisation.hh.

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

◆ SetFilledMins()

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

inline

Definition at line 84 of file G4PartialPhantomParameterisation.hh.

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

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

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4PartialPhantomParameterisation()

◆ ~G4PartialPhantomParameterisation()

Member Function Documentation

◆ BuildContainerWalls()

◆ ComputeMaterial()

◆ ComputeTransformation()

◆ GetMaterial() [1/2]

◆ GetMaterial() [2/2]

◆ GetMaterialIndex() [1/2]

◆ GetMaterialIndex() [2/2]

◆ GetReplicaNo()

◆ GetTranslation()

◆ SetFilledIDs()

◆ SetFilledMins()