G4Voxelizer Class Reference

G4Voxelizer is a tool for generating the optimisation structure of tessellated surfaces and solids positioned in 3D space; it is used in G4TessellatedSolid and G4MultiUnion. More...

#include <G4Voxelizer.hh>

Public Member Functions
	G4Voxelizer ()
	~G4Voxelizer ()=default
void	Voxelize (std::vector< G4VSolid * > &solids, std::vector< G4Transform3D > &transforms)
void	Voxelize (std::vector< G4VFacet * > &facets)
void	DisplayVoxelLimits () const
void	DisplayBoundaries ()
void	DisplayListNodes () const
void	GetCandidatesVoxel (std::vector< G4int > &voxels)
G4int	GetCandidatesVoxelArray (const G4ThreeVector &point, std::vector< G4int > &list, G4SurfBits *crossed=nullptr) const
G4int	GetCandidatesVoxelArray (const std::vector< G4int > &voxels, const G4SurfBits bitmasks[], std::vector< G4int > &list, G4SurfBits *crossed=nullptr) const
G4int	GetCandidatesVoxelArray (const std::vector< G4int > &voxels, std::vector< G4int > &list, G4SurfBits *crossed=nullptr) const
const std::vector< G4VoxelBox > &	GetBoxes () const
const std::vector< G4double > &	GetBoundary (G4int index) const
G4bool	UpdateCurrentVoxel (const G4ThreeVector &point, const G4ThreeVector &direction, std::vector< G4int > &curVoxel) const
void	GetVoxel (std::vector< G4int > &curVoxel, const G4ThreeVector &point) const
G4int	GetBitsPerSlice () const
G4bool	Contains (const G4ThreeVector &point) const
G4double	DistanceToNext (const G4ThreeVector &point, const G4ThreeVector &direction, std::vector< G4int > &curVoxel) const
G4double	DistanceToFirst (const G4ThreeVector &point, const G4ThreeVector &direction) const
G4double	DistanceToBoundingBox (const G4ThreeVector &point) const
G4double	MinDistanceToBox (const G4ThreeVector &p, const G4ThreeVector &f) const
G4int	GetVoxelsIndex (G4int x, G4int y, G4int z) const
G4int	GetVoxelsIndex (const std::vector< G4int > &voxels) const
G4bool	GetPointVoxel (const G4ThreeVector &p, std::vector< G4int > &voxels) const
G4int	GetPointIndex (const G4ThreeVector &p) const
const G4SurfBits &	Empty () const
G4bool	IsEmpty (G4int index) const
void	SetMaxVoxels (G4int max)
void	SetMaxVoxels (const G4ThreeVector &reductionRatio)
G4int	GetMaxVoxels (G4ThreeVector &ratioOfReduction)
G4int	AllocatedMemory ()
long long	GetCountOfVoxels () const
long long	CountVoxels (std::vector< G4double > boundaries[]) const
const std::vector< G4int > &	GetCandidates (std::vector< G4int > &curVoxel) const
G4int	GetVoxelBoxesSize () const
const G4VoxelBox &	GetVoxelBox (G4int i) const
const std::vector< G4int > &	GetVoxelBoxCandidates (G4int i) const
G4int	GetTotalCandidates () const

Static Public Member Functions
static void	SetDefaultVoxelsCount (G4int count)
static G4int	GetDefaultVoxelsCount ()

Detailed Description

G4Voxelizer is a tool for generating the optimisation structure of tessellated surfaces and solids positioned in 3D space; it is used in G4TessellatedSolid and G4MultiUnion.

Definition at line 68 of file G4Voxelizer.hh.

Constructor & Destructor Documentation

G4Voxelizer()

G4Voxelizer::G4Voxelizer

(

)

Constructor and default Destructor.

Definition at line 51 of file G4Voxelizer.cc.

  : fBoundingBox("VoxBBox", 1, 1, 1)
{
  fCountOfVoxels = fNPerSlice = fTotalCandidates = 0;
  
  fTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
 
  SetMaxVoxels(fDefaultVoxelsCount); 
 
  G4SolidStore::GetInstance()->DeRegister(&fBoundingBox);
}

~G4Voxelizer()

G4Voxelizer::~G4Voxelizer ( )

default

Member Function Documentation

AllocatedMemory()

G4int G4Voxelizer::AllocatedMemory

(

)

Logger returning the size of total allocated memory.

Definition at line 1253 of file G4Voxelizer.cc.

{
  G4int size = fEmpty.GetNbytes();
  size += fBoxes.capacity() * sizeof(G4VoxelBox);
  size += sizeof(G4double) * (fBoundaries[0].capacity()
        + fBoundaries[1].capacity() + fBoundaries[2].capacity());
  size += sizeof(G4int) * (fCandidatesCounts[0].capacity()
        + fCandidatesCounts[1].capacity() + fCandidatesCounts[2].capacity());
  size += fBitmasks[0].GetNbytes() + fBitmasks[1].GetNbytes()
        + fBitmasks[2].GetNbytes();
 
  auto csize = (G4int)fCandidates.size();
  for (G4int i = 0; i < csize; ++i)
  {
    size += sizeof(vector<G4int>) + fCandidates[i].capacity() * sizeof(G4int);
  }
 
  return size;
}

Contains()

G4bool G4Voxelizer::Contains

(

const G4ThreeVector &

point

)

const

Returns true if 'point' is contained within boundaries.

Definition at line 1079 of file G4Voxelizer.cc.

{
  for (auto i = 0; i < 3; ++i)
  {
    if (point[i] < fBoundaries[i].front() || point[i] > fBoundaries[i].back())
    {
      return false;
    }
  }
  return true;
}

CountVoxels()

long long G4Voxelizer::CountVoxels ( std::vector< G4double > boundaries[] ) const

inline

Referenced by Voxelize().

DisplayBoundaries()

void G4Voxelizer::DisplayBoundaries

(

)

Prints the positions of the boundaries of the slices on the three axes.

Definition at line 313 of file G4Voxelizer.cc.

{
  char axis[3] = {'X', 'Y', 'Z'};
  for (auto i = 0; i <= 2; ++i)
  {
    G4cout << " * " << axis[i] << " axis:" << G4endl << "    | ";
    DisplayBoundaries(fBoundaries[i]);
  }
}

Referenced by DisplayBoundaries().

DisplayListNodes()

void G4Voxelizer::DisplayListNodes

(

)

const

Prints which solids are present in the slices previously elaborated.

Definition at line 421 of file G4Voxelizer.cc.

{
  // Prints which solids are present in the slices previously elaborated.
 
  char axis[3] = {'X', 'Y', 'Z'};
  G4int size=8*sizeof(G4int)*fNPerSlice;
  G4SurfBits bits(size);
 
  for (auto j = 0; j <= 2; ++j)
  {
    G4cout << " * " << axis[j] << " axis:" << G4endl;
    auto count = (G4int)fBoundaries[j].size();
    for(G4int i=0; i < count-1; ++i)
    {
      G4cout << "    Slice #" << i+1 << ": [" << fBoundaries[j][i]
             << " ; " << fBoundaries[j][i+1] << "] -> ";
      bits.set(size,(const char *)fBitmasks[j].fAllBits+i
                                 *fNPerSlice*sizeof(G4int));
      G4String result = GetCandidatesAsString(bits);
      G4cout << "[ " << result.c_str() << "]  " << G4endl;
    }
  }
}

DisplayVoxelLimits()

void G4Voxelizer::DisplayVoxelLimits

(

)

const

Displays the dX, dY, dZ, pX, pY and pZ for each node.

Definition at line 191 of file G4Voxelizer.cc.

{
  // "DisplayVoxelLimits" displays the dX, dY, dZ, pX, pY and pZ for each node
 
  std::size_t numNodes = fBoxes.size();
  G4long oldprec = G4cout.precision(16);
  for(std::size_t i = 0; i < numNodes; ++i)
  {
    G4cout << setw(10) << setiosflags(ios::fixed) <<
      "    -> Node " << i+1 <<  ":\n" << 
      "\t * [x,y,z] = " << fBoxes[i].hlen <<
      "\t * [x,y,z] = " << fBoxes[i].pos << "\n";
  }
  G4cout.precision(oldprec);
}

DistanceToBoundingBox()

G4double G4Voxelizer::DistanceToBoundingBox

(

const G4ThreeVector &

point

)

const

Returns the minimum distance of 'point' to the bounding box.

Definition at line 1103 of file G4Voxelizer.cc.

{
  G4ThreeVector pointShifted = point - fBoundingBoxCenter;
  G4double shift = MinDistanceToBox(pointShifted, fBoundingBoxSize);
  return shift;
}

DistanceToFirst()

G4double G4Voxelizer::DistanceToFirst	(	const G4ThreeVector &	point,
		const G4ThreeVector &	direction ) const

Returns the distance to first bounding box, given 'point' and 'direction'.

Definition at line 1093 of file G4Voxelizer.cc.

{
  G4ThreeVector pointShifted = point - fBoundingBoxCenter;
  G4double shift = fBoundingBox.DistanceToIn(pointShifted, direction);
  return shift;
}

DistanceToNext()

G4double G4Voxelizer::DistanceToNext	(	const G4ThreeVector &	point,
		const G4ThreeVector &	direction,
		std::vector< G4int > &	curVoxel ) const

Returns the distance to next boundary, given 'point' and 'direction' and updates current voxel 'curVoxel', using the index corresponding to the closest voxel boundary on the ray.

Definition at line 1138 of file G4Voxelizer.cc.

{
  G4double shift = kInfinity;
 
  G4int cur = 0; // the smallest index, which would be than increased
  for (G4int i = 0; i <= 2; ++i)
  {
    // Looking for the next voxels on the considered direction X,Y,Z axis
    //
    const std::vector<G4double>& boundary = fBoundaries[i];
    G4int index = curVoxel[i];
    if (direction[i] >= 1e-10)
    {
      ++index;
    }
    else
    {
      if (direction[i] > -1e-10) { continue; }
    }
    G4double dif = boundary[index] - point[i];
    G4double distance = dif / direction[i];
 
    if (shift > distance)
    {
      shift = distance;
      cur = i;
    }
  }
 
  if (shift != kInfinity)
  {
    // updating current voxel using the index corresponding
    // to the closest voxel boundary on the ray
 
    if (direction[cur] > 0)
    {
      if (++curVoxel[cur] >= (G4int) fBoundaries[cur].size() - 1)
      {
        shift = kInfinity;
      }
    }
    else
    {
      if (--curVoxel[cur] < 0)
      {
        shift = kInfinity;
      }
    }
  }
  return shift;
}

Empty()

const G4SurfBits & G4Voxelizer::Empty ( ) const

inline

Returns the empty bits container.

GetBitsPerSlice()

G4int G4Voxelizer::GetBitsPerSlice ( ) const

inline

Returns memory size of a slice.

GetBoundary()

const std::vector< G4double > & G4Voxelizer::GetBoundary ( G4int index ) const

inline

Returns the boundary vector, given an 'index'.

GetBoxes()

const std::vector< G4VoxelBox > & G4Voxelizer::GetBoxes ( ) const

inline

Returns the pointer to the array containing the characteristics of each box.

GetCandidates()

const std::vector< G4int > & G4Voxelizer::GetCandidates ( std::vector< G4int > & curVoxel ) const

inline

GetCandidatesVoxel()

void G4Voxelizer::GetCandidatesVoxel

(

std::vector< G4int > &

voxels

)

Displays the nodes located in a voxel characterised by its three indexes.

Definition at line 838 of file G4Voxelizer.cc.

{
  // "GetCandidates" should compute which solids are possibly contained in
  // the voxel defined by the three slices characterized by the passed indexes.
 
  G4cout << "   Candidates in voxel [" << voxels[0] << " ; " << voxels[1]
         << " ; " << voxels[2] << "]: ";
  std::vector<G4int> candidates;
  G4int count = GetCandidatesVoxelArray(voxels, candidates);
  G4cout << "[ ";
  for (G4int i = 0; i < count; ++i)
  {
    G4cout << candidates[i];
  }
  G4cout << "]  " << G4endl;
}

GetCandidatesVoxelArray() [1/3]

G4int G4Voxelizer::GetCandidatesVoxelArray	(	const G4ThreeVector &	point,
		std::vector< G4int > &	list,
		G4SurfBits *	crossed = nullptr ) const

Methods returning in a vector container the nodes located in a voxel characterised by its three indexes.

Returns

The total candidates number.

Definition at line 918 of file G4Voxelizer.cc.

{
  // Method returning the candidates corresponding to the passed point
 
  list.clear();
 
  for (auto i = 0; i <= 2; ++i)
  {
    if(point[i] < fBoundaries[i].front() || point[i] >= fBoundaries[i].back())
    { 
      return 0;
    }
  }
 
  if (fTotalCandidates == 1)
  {
    list.push_back(0);
    return 1;
  } 
  
  if (fNPerSlice == 1)
  {
    unsigned int mask = 0xFFffFFff;
    G4int slice;
    if (fBoundaries[0].size() > 2)
    {
      slice = BinarySearch(fBoundaries[0], point.x());
      if ((mask = ((unsigned int*) fBitmasks[0].fAllBits)[slice]) == 0u)
      {
        return 0;
      }
    }
    if (fBoundaries[1].size() > 2)
    {
      slice = BinarySearch(fBoundaries[1], point.y());
      if ((mask &= ((unsigned int*) fBitmasks[1].fAllBits)[slice]) == 0u)
      {
        return 0;
      }
    }
    if (fBoundaries[2].size() > 2)
    {
      slice = BinarySearch(fBoundaries[2], point.z());
      if ((mask &= ((unsigned int*) fBitmasks[2].fAllBits)[slice]) == 0u)
      {
        return 0;
      }
    }
    if ((crossed != nullptr) && ((mask &= ~((unsigned int*)crossed->fAllBits)[0]) == 0u))
    {
      return 0;
    }
    FindComponentsFastest(mask, list, 0);
  }
  else
  {
    unsigned int* masks[3], mask; // masks for X,Y,Z axis
    for (auto i = 0; i <= 2; ++i)
    {
      G4int slice = BinarySearch(fBoundaries[i], point[i]);
      masks[i] = ((unsigned int*) fBitmasks[i].fAllBits)
               + slice * fNPerSlice;
    }
    unsigned int* maskCrossed = crossed != nullptr
                              ? (unsigned int*)crossed->fAllBits : nullptr;
 
    for (G4int i = 0 ; i < fNPerSlice; ++i)
    {
      // Logic "and" of the masks along the 3 axes x, y, z:
      // removing "if (!" and ") continue" => slightly slower
      //
      if ((mask = masks[0][i]) == 0u) { continue; }
      if ((mask &= masks[1][i]) == 0u) { continue; }
      if ((mask &= masks[2][i]) == 0u) { continue; }
      if ((maskCrossed != nullptr) && ((mask &= ~maskCrossed[i]) == 0u))
      {
        continue;
      }
      FindComponentsFastest(mask, list, i);
    }
  }
  return (G4int)list.size();
}

Referenced by GetCandidatesVoxel(), and GetCandidatesVoxelArray().

GetCandidatesVoxelArray() [2/3]

G4int G4Voxelizer::GetCandidatesVoxelArray	(	const std::vector< G4int > &	voxels,
		const G4SurfBits	bitmasks[],
		std::vector< G4int > &	list,
		G4SurfBits *	crossed = nullptr ) const

Definition at line 1005 of file G4Voxelizer.cc.

{
  list.clear();
 
  if (fTotalCandidates == 1)
  {
    list.push_back(0);
    return 1;
  }
  
  if (fNPerSlice == 1)
  {
    unsigned int mask;
    if ((mask = ((unsigned int *) bitmasks[0].fAllBits)[voxels[0]]) == 0u)
    {
      return 0;
    }
    if ((mask &= ((unsigned int *) bitmasks[1].fAllBits)[voxels[1]]) == 0u)
    {
      return 0;
    }
    if ((mask &= ((unsigned int *) bitmasks[2].fAllBits)[voxels[2]]) == 0u)
    {
      return 0;
    }
    if ((crossed != nullptr) && ((mask &= ~((unsigned int *)crossed->fAllBits)[0]) == 0u))
    {
      return 0;
    }
    FindComponentsFastest(mask, list, 0);
  }
  else
  {
    unsigned int *masks[3], mask; // masks for X,Y,Z axis
    for (auto i = 0; i <= 2; ++i)
    {
      masks[i] = ((unsigned int *) bitmasks[i].fAllBits)
               + voxels[i]*fNPerSlice;
    }
    unsigned int *maskCrossed = crossed != nullptr
                              ? (unsigned int *)crossed->fAllBits : nullptr;
 
    for (G4int i = 0 ; i < fNPerSlice; ++i)
    {
      // Logic "and" of the masks along the 3 axes x, y, z:
      // removing "if (!" and ") continue" => slightly slower
      //
      if ((mask = masks[0][i]) == 0u) { continue; }
      if ((mask &= masks[1][i]) == 0u) { continue; }
      if ((mask &= masks[2][i]) == 0u) { continue; }
      if ((maskCrossed != nullptr) && ((mask &= ~maskCrossed[i]) == 0u))
      {
        continue;
      }
      FindComponentsFastest(mask, list, i);
    }
  }
  return (G4int)list.size();
}

GetCandidatesVoxelArray() [3/3]

G4int G4Voxelizer::GetCandidatesVoxelArray	(	const std::vector< G4int > &	voxels,
		std::vector< G4int > &	list,
		G4SurfBits *	crossed = nullptr ) const

Definition at line 1070 of file G4Voxelizer.cc.

{
  // Method returning the candidates corresponding to the passed point
 
  return GetCandidatesVoxelArray(voxels, fBitmasks, list, crossed);
}

GetCountOfVoxels()

long long G4Voxelizer::GetCountOfVoxels ( ) const

inline

Utility accessors/functions for voxels.

GetDefaultVoxelsCount()

G4int G4Voxelizer::GetDefaultVoxelsCount ( )

static

Definition at line 1247 of file G4Voxelizer.cc.

{
  return fDefaultVoxelsCount;
}

GetMaxVoxels()

G4int G4Voxelizer::GetMaxVoxels ( G4ThreeVector & ratioOfReduction )

inline

GetPointIndex()

G4int G4Voxelizer::GetPointIndex ( const G4ThreeVector & p ) const

inline

GetPointVoxel()

G4bool G4Voxelizer::GetPointVoxel ( const G4ThreeVector & p, std::vector< G4int > & voxels ) const

inline

GetTotalCandidates()

G4int G4Voxelizer::GetTotalCandidates ( ) const

inline

GetVoxel()

void G4Voxelizer::GetVoxel ( std::vector< G4int > & curVoxel, const G4ThreeVector & point ) const

inline

Updates current voxel based on provided 'point'.

GetVoxelBox()

const G4VoxelBox & G4Voxelizer::GetVoxelBox ( G4int i ) const

inline

GetVoxelBoxCandidates()

const std::vector< G4int > & G4Voxelizer::GetVoxelBoxCandidates ( G4int i ) const

inline

GetVoxelBoxesSize()

G4int G4Voxelizer::GetVoxelBoxesSize ( ) const

inline

GetVoxelsIndex() [1/2]

G4int G4Voxelizer::GetVoxelsIndex ( const std::vector< G4int > & voxels ) const

inline

GetVoxelsIndex() [2/2]

G4int G4Voxelizer::GetVoxelsIndex ( G4int x, G4int y, G4int z ) const

inline

Accessors for voxels and points.

IsEmpty()

G4bool G4Voxelizer::IsEmpty ( G4int index ) const

inline

Returns true if empty bit in container, given an 'index'.

MinDistanceToBox()

G4double G4Voxelizer::MinDistanceToBox	(	const G4ThreeVector &	p,
		const G4ThreeVector &	f ) const

Utility for estimating the isotropic safety from a point 'p' outside the current solid to any of its surfaces. The algorithm may be accurate or should provide a fast underestimate, based on safety point 'f'.

Definition at line 1112 of file G4Voxelizer.cc.

{
  // Estimates the isotropic safety from a point outside the current solid to
  // any of its surfaces. The algorithm may be accurate or should provide a
  // fast underestimate.
 
  G4double safe, safx, safy, safz;
  safe = safx = -f.x() + std::abs(aPoint.x());
  safy = -f.y() + std::abs(aPoint.y());
  if ( safy > safe ) { safe = safy; }
  safz = -f.z() + std::abs(aPoint.z());
  if ( safz > safe ) { safe = safz; }
  if (safe < 0.0) { return 0.0; } // point is inside
 
  G4double safsq = 0.0;
  G4int count = 0;
  if ( safx > 0 ) { safsq += safx*safx; ++count; }
  if ( safy > 0 ) { safsq += safy*safy; ++count; }
  if ( safz > 0 ) { safsq += safz*safz; ++count; }
  if (count == 1) { return safe; }
  return std::sqrt(safsq);
}

Referenced by DistanceToBoundingBox().

SetDefaultVoxelsCount()

void G4Voxelizer::SetDefaultVoxelsCount ( G4int count )

static

Definition at line 1241 of file G4Voxelizer.cc.

{
  fDefaultVoxelsCount = count;
}

SetMaxVoxels() [1/2]

void G4Voxelizer::SetMaxVoxels

(

const G4ThreeVector &

reductionRatio

)

Definition at line 1234 of file G4Voxelizer.cc.

{
  fMaxVoxels = -1;
  fReductionRatio = ratioOfReduction;
}

SetMaxVoxels() [2/2]

void G4Voxelizer::SetMaxVoxels

(

G4int

max

)

Setters/getter for the maximum number of voxels.

Definition at line 1227 of file G4Voxelizer.cc.

{
  fMaxVoxels = max;
  fReductionRatio.set(0,0,0);
}

Referenced by G4Voxelizer().

UpdateCurrentVoxel()

G4bool G4Voxelizer::UpdateCurrentVoxel	(	const G4ThreeVector &	point,
		const G4ThreeVector &	direction,
		std::vector< G4int > &	curVoxel ) const

Utility method for checking/updating current voxel given in input.

Definition at line 1194 of file G4Voxelizer.cc.

{
  for (auto i = 0; i <= 2; ++i)
  {
    G4int index = curVoxel[i];
    const std::vector<G4double> &boundary = fBoundaries[i];
 
    if (direction[i] > 0) 
    {
      if (point[i] >= boundary[++index])
      { 
        if (++curVoxel[i] >= (G4int) boundary.size() - 1) { return false; }
      }
    }
    else
    {
      if (point[i] < boundary[index])
      { 
        if (--curVoxel[i] < 0) { return false; }
      }
    }
#ifdef G4SPECSDEBUG
    G4int indexOK = BinarySearch(boundary, point[i]);
    if (curVoxel[i] != indexOK)
      curVoxel[i] = indexOK; // put breakpoint here
#endif
  }
  return true;
}

Voxelize() [1/2]

void G4Voxelizer::Voxelize

(

std::vector< G4VFacet * > &

facets

)

Builds the voxelisation structure for facets forming a shape.

Parameters

[in]

facets

The list of facets.

Definition at line 706 of file G4Voxelizer.cc.

{
  G4int maxVoxels = fMaxVoxels;
  G4ThreeVector reductionRatio = fReductionRatio;
 
  std::size_t size = facets.size();
  if (size < 10)
  {
    for (const auto & facet : facets)
    { 
      if (facet->GetNumberOfVertices() > 3) { ++size; }
    }
  }
 
  if ((size >= 10 || maxVoxels > 0) && maxVoxels != 0 && maxVoxels != 1)
  {
#ifdef G4SPECSDEBUG
    G4cout << "Building voxel limits..." << G4endl;
#endif
    
    BuildVoxelLimits(facets);
 
#ifdef G4SPECSDEBUG
    G4cout << "Building boundaries..." << G4endl;
#endif
    
    BuildBoundaries();
 
#ifdef G4SPECSDEBUG
    G4cout << "Building bitmasks..." << G4endl;
#endif
    
    BuildBitmasks(fBoundaries, nullptr, true);
 
    if (maxVoxels < 0 && reductionRatio == G4ThreeVector())
    {
      maxVoxels = fTotalCandidates;
      if (fTotalCandidates > 1000000) { maxVoxels = 1000000; }
    }
 
    SetReductionRatio(maxVoxels, reductionRatio);
 
    fCountOfVoxels = CountVoxels(fBoundaries);
 
#ifdef G4SPECSDEBUG
    G4cout << "Total number of voxels: " << fCountOfVoxels << G4endl;
#endif
 
    BuildReduceVoxels2(fBoundaries, reductionRatio);
 
    fCountOfVoxels = CountVoxels(fBoundaries);
 
#ifdef G4SPECSDEBUG
    G4cout << "Total number of voxels after reduction: "
           << fCountOfVoxels << G4endl;
#endif
 
#ifdef G4SPECSDEBUG
    G4cout << "Building bitmasks..." << G4endl;
#endif
    
    BuildBitmasks(fBoundaries, fBitmasks);
 
    G4ThreeVector reductionRatioMini;
 
    G4SurfBits bitmasksMini[3];
 
    // section for building mini voxels
 
    std::vector<G4double> miniBoundaries[3];
 
    for (auto i = 0; i <= 2; ++i)
    {
      miniBoundaries[i] = fBoundaries[i];
    }
 
    G4int voxelsCountMini = (fCountOfVoxels >= 1000)
                          ? 100 : G4int(fCountOfVoxels / 10);
 
    SetReductionRatio(voxelsCountMini, reductionRatioMini);
 
#ifdef G4SPECSDEBUG
    G4cout << "Building reduced voxels..." << G4endl;
#endif
    
    BuildReduceVoxels(miniBoundaries, reductionRatioMini);
 
#ifdef G4SPECSDEBUG
    G4int total = CountVoxels(miniBoundaries);
    G4cout << "Total number of mini voxels: " << total << G4endl;
#endif
 
#ifdef G4SPECSDEBUG
    G4cout << "Building mini bitmasks..." << G4endl;
#endif
    
    BuildBitmasks(miniBoundaries, bitmasksMini);
 
#ifdef G4SPECSDEBUG
    G4cout << "Creating Mini Voxels..." << G4endl;
#endif
    
    CreateMiniVoxels(miniBoundaries, bitmasksMini);
 
#ifdef G4SPECSDEBUG
    G4cout << "Building bounding box..." << G4endl;
#endif
    
    BuildBoundingBox();
 
#ifdef G4SPECSDEBUG
    G4cout << "Building empty..." << G4endl;
#endif
    
    BuildEmpty();
 
#ifdef G4SPECSDEBUG
    G4cout << "Deallocating unnecessary fields during runtime..." << G4endl;
#endif    
    // deallocate fields unnecessary during runtime
    //
    fBoxes.resize(0);
    for (auto i = 0; i < 3; ++i)
    {
      fCandidatesCounts[i].resize(0);
      fBitmasks[i].Clear();
    }
  }
}

Voxelize() [2/2]

void G4Voxelizer::Voxelize	(	std::vector< G4VSolid * > &	solids,
		std::vector< G4Transform3D > &	transforms )

Builds the voxelisation structure for solids positioned in space.

Parameters

[in]	solids	The list of solids.
[in]	transforms	The associated transformation in space.

Definition at line 649 of file G4Voxelizer.cc.

{
  BuildVoxelLimits(solids, transforms);
  BuildBoundaries();
  BuildBitmasks(fBoundaries, fBitmasks);
  BuildBoundingBox();
  BuildEmpty(); // this does not work well for multi-union,
                // actually only makes performance slower,
                // these are only pre-calculated but not used by multi-union
 
  for (auto & fCandidatesCount : fCandidatesCounts)
  {
    fCandidatesCount.resize(0);
  }
}

---

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

• G4Voxelizer.hh
• G4Voxelizer.cc