G4SurfaceVoxelizer Class Reference

#include <G4SurfaceVoxelizer.hh>

Collaboration diagram for G4SurfaceVoxelizer:

Classes
class	G4VoxelComparator

Public Member Functions
void	Voxelize (std::vector< G4VFacet *> &facets)
void	DisplayVoxelLimits ()
void	DisplayBoundaries ()
void	DisplayListNodes () const
	G4SurfaceVoxelizer ()
	~G4SurfaceVoxelizer ()
void	GetCandidatesVoxel (std::vector< G4int > &voxels)
G4int	GetCandidatesVoxelArray (const G4ThreeVector &point, std::vector< G4int > &list, G4SurfBits *crossed=0) const
G4int	GetCandidatesVoxelArray (const std::vector< G4int > &voxels, const G4SurfBits bitmasks[], std::vector< G4int > &list, G4SurfBits *crossed=0) const
G4int	GetCandidatesVoxelArray (const std::vector< G4int > &voxels, std::vector< G4int > &list, G4SurfBits *crossed=0) 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, const std::vector< G4int > &curVoxel) const
G4double	DistanceToFirst (const G4ThreeVector &point, const G4ThreeVector &direction) const
G4double	DistanceToBoundingBox (const G4ThreeVector &point) const
G4int	GetVoxelsIndex (G4int x, G4int y, G4int z) const
G4int	GetVoxelsIndex (const 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
template<typename T >
static G4int	BinarySearch (const std::vector< T > &vec, T value)
static G4double	MinDistanceToBox (const G4ThreeVector &aPoint, const G4ThreeVector &f)
static G4int	SetDefaultVoxelsCount (G4int count)
static G4int	GetDefaultVoxelsCount ()

Private Member Functions
void	BuildEmpty ()
G4String	GetCandidatesAsString (const G4SurfBits &bits) const
void	CreateSortedBoundary (std::vector< G4double > &boundaryRaw, G4int axis)
void	BuildBoundaries ()
void	BuildReduceVoxels (std::vector< G4double > fBoundaries[], G4ThreeVector reductionRatio)
void	BuildReduceVoxels2 (std::vector< G4double > fBoundaries[], G4ThreeVector reductionRatio)
void	BuildVoxelLimits (std::vector< G4VFacet *> &facets)
void	DisplayBoundaries (std::vector< G4double > &fBoundaries)
void	BuildBitmasks (std::vector< G4double > fBoundaries[], G4SurfBits bitmasks[], G4bool countsOnly=false)
void	BuildBoundingBox ()
void	SetReductionRatio (G4int maxVoxels, G4ThreeVector &reductionRatio)
void	CreateMiniVoxels (std::vector< G4double > fBoundaries[], G4SurfBits bitmasks[])

Static Private Member Functions
static void	FindComponentsFastest (unsigned int mask, std::vector< G4int > &list, G4int i)

Private Attributes
std::vector< G4VoxelBox >	fVoxelBoxes
std::vector< std::vector< G4int > >	fVoxelBoxesCandidates
std::map< G4int, std::vector< G4int > >	fCandidates
const std::vector< G4int >	fNoCandidates
long long	fCountOfVoxels
G4int	fNPerSlice
std::vector< G4VoxelBox >	fBoxes
std::vector< G4double >	fBoundaries [3]
std::vector< G4int >	fCandidatesCounts [3]
G4int	fTotalCandidates
G4SurfBits	fBitmasks [3]
G4ThreeVector	fBoundingBoxCenter
G4Box	fBoundingBox
G4ThreeVector	fBoundingBoxSize
G4ThreeVector	fReductionRatio
G4int	fMaxVoxels
G4double	fTolerance
G4SurfBits	fEmpty

Static Private Attributes
static G4ThreadLocal G4int	fDefaultVoxelsCount = -1

Detailed Description

Definition at line 66 of file G4SurfaceVoxelizer.hh.

Constructor & Destructor Documentation

G4SurfaceVoxelizer()

G4SurfaceVoxelizer::G4SurfaceVoxelizer

(

)

Definition at line 60 of file G4SurfaceVoxelizer.cc.

  : fBoundingBox("TessBBox", 1, 1, 1)
{
  fCountOfVoxels = fNPerSlice = fTotalCandidates = 0;
  
  fTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();

  SetMaxVoxels(fDefaultVoxelsCount); 

  G4SolidStore::GetInstance()->DeRegister(&fBoundingBox);
}

Here is the call graph for this function:

~G4SurfaceVoxelizer()

G4SurfaceVoxelizer::~G4SurfaceVoxelizer

(

)

Definition at line 73 of file G4SurfaceVoxelizer.cc.

{
}

Member Function Documentation

AllocatedMemory()

G4int G4SurfaceVoxelizer::AllocatedMemory

(

)

Definition at line 1083 of file G4SurfaceVoxelizer.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();

  G4int csize = fCandidates.size();
  for (G4int i = 0; i < csize; i++)
  {
    size += sizeof(vector<G4int>) + fCandidates[i].capacity() * sizeof(G4int);
  }

  return size;
}

Here is the call graph for this function:

Here is the caller graph for this function:

BinarySearch()

template<typename T >

static G4int G4SurfaceVoxelizer::BinarySearch ( const std::vector< T > &  vec, T  value  )

inlinestatic

Here is the caller graph for this function:

BuildBitmasks()

void G4SurfaceVoxelizer::BuildBitmasks ( std::vector< G4double >  fBoundaries[], G4SurfBits  bitmasks[], G4bool  countsOnly = false  )

private

Definition at line 308 of file G4SurfaceVoxelizer.cc.

{
  // "BuildListNodes" stores in the bitmasks solids present in each slice
  // along an axis.

  G4int numNodes = fBoxes.size();
  G4int bitsPerSlice = GetBitsPerSlice();

  for (G4int k = 0; k < 3; k++)
  {
    G4int total = 0;
    vector<G4double> &boundary = boundaries[k];
    G4int voxelsCount = boundary.size() - 1;
    G4SurfBits &bitmask = bitmasks[k];

    if (!countsOnly)
    {
      bitmask.Clear();
#ifdef G4SPECSDEBUG
      G4cout << "Allocating bitmask..." << G4endl;
#endif
      bitmask.SetBitNumber(voxelsCount*bitsPerSlice-1, false);
        // it is here so we can set the maximum number of bits. this line
        // will rellocate the memory and set all to zero
    }
    vector<G4int> &candidatesCount = fCandidatesCounts[k];
    candidatesCount.resize(voxelsCount);

    for(G4int i = 0 ; i < voxelsCount; ++i) { candidatesCount[i] = 0; }

    // Loop on the nodes, number of slices per axis
    //
    for(G4int j = 0 ; j < numNodes; j++)
    {
      // Determination of the minimum and maximum position along x
      // of the bounding boxe of each node
      //
      G4double p = fBoxes[j].pos[k], d = fBoxes[j].hlen[k];

      G4double min = p - d; // - localTolerance;
      G4double max = p + d; // + localTolerance;

      G4int i = BinarySearch(boundary, min);
      if (i < 0)  { i = 0; }

      do    // Loop checking, 13.08.2015, G.Cosmo
      {
        if (!countsOnly)
        {
          G4int index = i*bitsPerSlice+j;
          bitmask.SetBitNumber(index);
        }
        candidatesCount[i]++;
        total++;
        i++;
      }
      while (max > boundary[i] && i < voxelsCount);
    }
  }
#ifdef G4SPECSDEBUG
  G4cout << "Build list nodes completed." << G4endl;
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

BuildBoundaries()

void G4SurfaceVoxelizer::BuildBoundaries ( )

private

Definition at line 201 of file G4SurfaceVoxelizer.cc.

{
  // "SortBoundaries" orders the boundaries along each axis (increasing order)
  // and also does not take into account redundant boundaries, i.e. if two
  // boundaries are separated by a distance strictly inferior to "tolerance".
  // The sorted boundaries are respectively stored in:
  //              * boundaries[0..2]

  // In addition, the number of elements contained in the three latter arrays
  // are precise thanks to variables: boundariesCountX, boundariesCountY and
  // boundariesCountZ.

  if (G4int numNodes = fBoxes.size())
  {
    const G4double tolerance = fTolerance / 100.0;
      // Minimal distance to discriminate two boundaries.

    vector<G4double> sortedBoundary(2*numNodes);

    G4int considered;

    for (G4int j = 0; j <= 2; ++j)
    {
      CreateSortedBoundary(sortedBoundary, j);
      vector<G4double> &boundary = fBoundaries[j];
      boundary.clear();

      considered = 0;

      for(G4int i = 0 ; i < 2*numNodes; ++i)
      {
        G4double newBoundary = sortedBoundary[i];
#ifdef G4SPECSDEBUG 
        if (j == 0) G4cout << "Examining " << newBoundary << "..." << G4endl;
#endif
        G4int size = boundary.size();
        if(!size || abs(boundary[size-1] - newBoundary) > tolerance)
        {
          considered++;
          {
#ifdef G4SPECSDEBUG     
            if (j == 0) G4cout << "Adding boundary " << newBoundary << "..."
                               << G4endl;
#endif    
            boundary.push_back(newBoundary);
            continue;
          }
        }
        // If two successive boundaries are too close from each other,
        // only the first one is considered   
      }

      G4int n = boundary.size();
      G4int max = 100000;
      if (n > max/2)
      {
        G4int skip = n / (max /2); // n has to be 2x bigger then 50.000.
                                   // therefore only from 100.000 reduced
        vector<G4double> reduced;
        for (G4int i = 0; i < n; i++)
        {
          // 50 ok for 2k, 1000, 2000
          G4int size = boundary.size();
          if (i % skip == 0 || i == 0 || i == size - 1)
          {
            // this condition of merging boundaries was wrong,
            // it did not count with right part, which can be
            // completely ommited and not included in final consideration.
            // Now should be OK
            //
            reduced.push_back(boundary[i]);
          }
        }
        boundary = reduced;
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

BuildBoundingBox()

void G4SurfaceVoxelizer::BuildBoundingBox ( )

private

Definition at line 414 of file G4SurfaceVoxelizer.cc.

{
  G4ThreeVector toleranceVector;
  toleranceVector.set(fTolerance/100,fTolerance/100,fTolerance/100);
  for (G4int i = 0; i <= 2; ++i)
  {
    G4double min = fBoundaries[i].front();
    G4double max = fBoundaries[i].back();
    fBoundingBoxSize[i] = (max-min)/2;
    fBoundingBoxCenter[i] = min + fBoundingBoxSize[i];
  }
  //  sizes -= toleranceVector;
  fBoundingBox = G4Box("TessBBox", fBoundingBoxSize.x(),
                       fBoundingBoxSize.y(), fBoundingBoxSize.z());
}

Here is the call graph for this function:

Here is the caller graph for this function:

BuildEmpty()

void G4SurfaceVoxelizer::BuildEmpty ( )

private

Definition at line 78 of file G4SurfaceVoxelizer.cc.

{
  // by reserving the size of candidates, we would avoid reallocation of 
  // the vector which could cause fragmentation
  //
  vector<G4int> xyz(3), max(3), candidates(fTotalCandidates);
  const vector<G4int> empty(0);

  for (G4int i = 0; i <= 2; i++) max[i] = fBoundaries[i].size();
  unsigned int size = max[0] * max[1] * max[2];

  fEmpty.Clear();
  fEmpty.ResetBitNumber(size-1);
  fEmpty.ResetAllBits(true);

  for (xyz[2] = 0; xyz[2] < max[2]; ++xyz[2])
  {
    for (xyz[1] = 0; xyz[1] < max[1]; ++xyz[1])
    {
      for (xyz[0] = 0; xyz[0] < max[0]; ++xyz[0])
      {
        G4int index = GetVoxelsIndex(xyz);
        if (GetCandidatesVoxelArray(xyz, candidates)) 
        {
          fEmpty.SetBitNumber(index, false);

          // rather than assigning directly with:
          // "fCandidates[index] = candidates;", in an effort to ensure that 
          // capacity would be just exact, we rather use following 3 lines
          //
          vector<G4int> &c = (fCandidates[index] = empty);
          c.reserve(candidates.size());
          c.assign(candidates.begin(), candidates.end());
        }
      }
    }
  }
#ifdef G4SPECSDEBUG
  G4cout << "Non-empty voxels count: " << fCandidates.size() << G4endl;
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

BuildReduceVoxels()

void G4SurfaceVoxelizer::BuildReduceVoxels ( std::vector< G4double >  fBoundaries[], G4ThreeVector  reductionRatio  )

private

Definition at line 461 of file G4SurfaceVoxelizer.cc.

{
  for (G4int k = 0; k <= 2; ++k)
  {
    vector<G4int> &candidatesCount = fCandidatesCounts[k];
    G4int max = candidatesCount.size();
    vector<G4VoxelInfo> voxels(max);
    G4VoxelComparator comp(voxels);
    set<G4int, G4VoxelComparator> voxelSet(comp);
    vector<G4int> mergings;

    for (G4int j = 0; j < max; ++j)
    {
      G4VoxelInfo &voxel = voxels[j];
      voxel.count = candidatesCount[j];
      voxel.previous = j - 1;
      voxel.next = j + 1;
      voxels[j] = voxel;
    }

    for (G4int j = 0; j < max - 1; ++j)  { voxelSet.insert(j); }
      // we go to size-1 to make sure we will not merge the last element

    G4int count = 0;
    while (true)    // Loop checking, 13.08.2015, G.Cosmo
    {
      G4double reduction = reductionRatio[k];
      if (reduction == 0)
        break;
      G4int currentCount = voxelSet.size();
      if (currentCount <= 2)
        break;
      G4double currentRatio = 1 - (G4double) count / max;
      if (currentRatio <= reduction && currentCount <= 1000)
        break;
      const G4int pos = *voxelSet.begin();
      mergings.push_back(pos);

      G4VoxelInfo &voxel = voxels[pos];
      G4VoxelInfo &nextVoxel = voxels[voxel.next];

      voxelSet.erase(pos);
      if (voxel.next != max - 1) { voxelSet.erase(voxel.next); }
      if (voxel.previous != -1)  { voxelSet.erase(voxel.previous); }

      nextVoxel.count += voxel.count;
      voxel.count = 0;
      nextVoxel.previous = voxel.previous;

      if (voxel.next != max - 1)
        voxelSet.insert(voxel.next);

      if (voxel.previous != -1)
      {
        voxels[voxel.previous].next = voxel.next;
        voxelSet.insert(voxel.previous);
      }
      count++;
    }

    if (mergings.size())
    {
      sort(mergings.begin(), mergings.end());

      vector<G4double> &boundary = boundaries[k];
      vector<G4double> reducedBoundary(boundary.size() - mergings.size());
      G4int skip = mergings[0] + 1, cur = 0, i = 0;
      max = boundary.size();
      for (G4int j = 0; j < max; ++j)
      {
        if (j != skip)
        {
          reducedBoundary[cur++] = boundary[j];
        }
        else
        {
          if (++i < (G4int)mergings.size())  { skip = mergings[i] + 1; }
        }
      }
      boundaries[k] = reducedBoundary;
    }
  }
}

Here is the caller graph for this function:

BuildReduceVoxels2()

void G4SurfaceVoxelizer::BuildReduceVoxels2 ( std::vector< G4double >  fBoundaries[], G4ThreeVector  reductionRatio  )

private

Definition at line 547 of file G4SurfaceVoxelizer.cc.

{
  for (G4int k = 0; k <= 2; ++k)
  {
    vector<G4int> &candidatesCount = fCandidatesCounts[k];
    G4int max = candidatesCount.size();
    G4int total = 0;
    for (G4int i = 0; i < max; i++) total += candidatesCount[i];

    G4double reduction = reductionRatio[k];
    if (reduction == 0)
      break;

    G4int destination = (G4int) (reduction * max) + 1;
    if (destination > 1000) destination = 1000;
    if (destination < 2) destination = 2;
    G4double average = ((G4double)total / max) / reduction;

    vector<G4int> mergings;

    vector<G4double> &boundary = boundaries[k];
    vector<G4double> reducedBoundary(destination);

    G4int sum = 0, cur = 0;
    for (G4int i = 0; i < max; i++)
    {
      sum += candidatesCount[i];
      if (sum > average * (cur + 1) || i == 0)
      {
        G4double val = boundary[i];
        reducedBoundary[cur] = val;
        cur++;
        if (cur == destination)
          break;
      }
    }
    reducedBoundary[destination-1] = boundary[max];
    boundaries[k] = reducedBoundary;
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

BuildVoxelLimits()

void G4SurfaceVoxelizer::BuildVoxelLimits ( std::vector< G4VFacet *> &  facets )

private

Definition at line 121 of file G4SurfaceVoxelizer.cc.

{
  // "BuildVoxelLimits"'s aim is to store the coordinates of the origin as well
  // as the half lengths related to the bounding box of each node.
  // These quantities are stored in the array "fBoxes" (6 different values per
  // node.

  if (G4int numNodes = facets.size()) // Number of nodes
  {
    fBoxes.resize(numNodes); // Array which will store the half lengths
    fNPerSlice = 1+(fBoxes.size()-1)/(8*sizeof(unsigned int));

    G4ThreeVector toleranceVector;
    toleranceVector.set(10 * fTolerance,10 * fTolerance,10 * fTolerance);

    for (G4int i = 0; i < numNodes; ++i)
    {
      G4VFacet &facet = *facets[i];
      G4ThreeVector min, max;
      G4ThreeVector x(1,0,0), y(0,1,0), z(0,0,1);
      G4ThreeVector extent;
      max.set (facet.Extent(x), facet.Extent(y), facet.Extent(z));
      min.set (-facet.Extent(-x), -facet.Extent(-y), -facet.Extent(-z));
      min -= toleranceVector; max += toleranceVector;
      G4ThreeVector hlen = (max - min) / 2;
      fBoxes[i].hlen = hlen;
      fBoxes[i].pos = min + hlen;
    }
    fTotalCandidates = fBoxes.size();
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Contains()

G4bool G4SurfaceVoxelizer::Contains

(

const G4ThreeVector &

point

)

const

Definition at line 926 of file G4SurfaceVoxelizer.cc.

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

Here is the caller graph for this function:

CountVoxels()

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

inline

Here is the caller graph for this function:

CreateMiniVoxels()

void G4SurfaceVoxelizer::CreateMiniVoxels ( std::vector< G4double >  fBoundaries[], G4SurfBits  bitmasks[]  )

private

Definition at line 590 of file G4SurfaceVoxelizer.cc.

{
  vector<G4int> voxel(3), maxVoxels(3);
  for (G4int i = 0; i <= 2; ++i) maxVoxels[i] = boundaries[i].size();

  G4ThreeVector point;
  for (voxel[2] = 0; voxel[2] < maxVoxels[2] - 1; ++voxel[2])
  {
    for (voxel[1] = 0; voxel[1] < maxVoxels[1] - 1; ++voxel[1])
    {
      for (voxel[0] = 0; voxel[0] < maxVoxels[0] - 1; ++voxel[0])
      {
        vector<G4int> candidates;
        if (GetCandidatesVoxelArray(voxel, bitmasks, candidates, 0))
        {
          // find a box for corresponding non-empty voxel
          G4VoxelBox box;
          for (G4int i = 0; i <= 2; ++i)
          {
            G4int index = voxel[i];
            const vector<G4double> &boundary = boundaries[i];
            G4double hlen = 0.5 * (boundary[index+1] - boundary[index]);
            box.hlen[i] = hlen;
            box.pos[i] = boundary[index] + hlen;
          }
          fVoxelBoxes.push_back(box);
          vector<G4int>(candidates).swap(candidates);
          fVoxelBoxesCandidates.push_back(candidates);
        }
      }
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

CreateSortedBoundary()

void G4SurfaceVoxelizer::CreateSortedBoundary ( std::vector< G4double > &  boundaryRaw, G4int  axis  )

private

Definition at line 171 of file G4SurfaceVoxelizer.cc.

{
  // "CreateBoundaries"'s aim is to determine the slices induced by the
  // bounding fBoxes, along each axis. The created boundaries are stored
  // in the array "boundariesRaw"

  G4int numNodes = fBoxes.size(); // Number of nodes in structure

  // Determination of the boundaries along x, y and z axis
  //
  for(G4int i = 0 ; i < numNodes; ++i)   
  {
    // For each node, the boundaries are created by using the array "fBoxes"
    // built in method "BuildVoxelLimits"
    //
    G4double p = fBoxes[i].pos[axis], d = fBoxes[i].hlen[axis];

    // x boundaries
    //
#ifdef G4SPECSDEBUG
    G4cout << "Boundary " << p - d << " - " << p + d << G4endl;
#endif
    boundary[2*i] = p - d;
    boundary[2*i+1] = p + d;
  }
  sort(boundary.begin(), boundary.end());
}

Here is the caller graph for this function:

DisplayBoundaries() [1/2]

void G4SurfaceVoxelizer::DisplayBoundaries

(

)

Definition at line 281 of file G4SurfaceVoxelizer.cc.

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

DisplayBoundaries() [2/2]

void G4SurfaceVoxelizer::DisplayBoundaries ( std::vector< G4double > &  fBoundaries )

private

Definition at line 292 of file G4SurfaceVoxelizer.cc.

{
  // Prints the positions of the boundaries of the slices on the three axes

  G4int count = boundaries.size();
  G4int oldprec = G4cout.precision(16);
  for(G4int i = 0; i < count; ++i)
  {
    G4cout << setw(10) << setiosflags(ios::fixed) << boundaries[i];
    if(i != count-1) G4cout << "-> ";
  }
  G4cout << "|" << G4endl << "Number of boundaries: " << count << G4endl;
  G4cout.precision(oldprec);
}

DisplayListNodes()

void G4SurfaceVoxelizer::DisplayListNodes

(

)

const

Definition at line 389 of file G4SurfaceVoxelizer.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 (G4int j = 0; j <= 2; ++j)
  {
    G4cout << " * " << axis[j] << " axis:" << G4endl;
    G4int count = 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;
    }
  }
}

Here is the call graph for this function:

DisplayVoxelLimits()

void G4SurfaceVoxelizer::DisplayVoxelLimits

(

)

Definition at line 154 of file G4SurfaceVoxelizer.cc.

{
  // "DisplayVoxelLimits" displays the dX, dY, dZ, pX, pY and pZ for each node

  G4int numNodes = fBoxes.size();
  G4int oldprec = G4cout.precision(16);
  for(G4int 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 G4SurfaceVoxelizer::DistanceToBoundingBox

(

const G4ThreeVector &

point

)

const

Definition at line 948 of file G4SurfaceVoxelizer.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

DistanceToFirst()

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

Definition at line 938 of file G4SurfaceVoxelizer.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

DistanceToNext()

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

Definition at line 983 of file G4SurfaceVoxelizer.cc.

{
  G4double shift = kInfinity;

  for (G4int i = 0; i <= 2; ++i)
  {
    // Looking for the next voxels on the considered direction X,Y,Z axis
    //
    const vector<G4double> &boundary = fBoundaries[i];
    G4int cur = curVoxel[i];
    if(direction[i] >= 1e-10)
    {
        if (boundary[++cur] - point[i] < fTolerance) // make sure shift would
        if (++cur >= (G4int) boundary.size())      // be non-zero
          continue;
    }
    else 
    {
      if(direction[i] <= -1e-10) 
      {
        if (point[i] - boundary[cur] < fTolerance) // make sure shift would
          if (--cur < 0)                           // be non-zero
            continue;
      }
      else 
        continue;
    }
    G4double dif = boundary[cur] - point[i];
    G4double distance = dif / direction[i];

    if (shift > distance) 
      shift = distance;
  }

  return shift;
}

Here is the caller graph for this function:

Empty()

const G4SurfBits& G4SurfaceVoxelizer::Empty ( ) const

inline

Here is the caller graph for this function:

FindComponentsFastest()

void G4SurfaceVoxelizer::FindComponentsFastest ( unsigned int  mask, std::vector< G4int > &  list, G4int  i  )

staticprivate

Definition at line 773 of file G4SurfaceVoxelizer.cc.

{
  for (G4int byte = 0; byte < (G4int) (sizeof(unsigned int)); byte++)
  {
    if (G4int maskByte = mask & 0xFF)
    {
      for (G4int bit = 0; bit < 8; bit++)
      {
        if (maskByte & 1) 
          { list.push_back(8*(sizeof(unsigned int)*i+ byte) + bit); }
        if (!(maskByte >>= 1)) break;
      }
    }
    mask >>= 8;
  }
}

Here is the caller graph for this function:

GetBitsPerSlice()

G4int G4SurfaceVoxelizer::GetBitsPerSlice ( ) const

inline

Here is the caller graph for this function:

GetBoundary()

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

inline

Here is the caller graph for this function:

GetBoxes()

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

inline

GetCandidates()

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

inline

Here is the caller graph for this function:

GetCandidatesAsString()

G4String G4SurfaceVoxelizer::GetCandidatesAsString ( const G4SurfBits &  bits ) const

private

Definition at line 374 of file G4SurfaceVoxelizer.cc.

{
  // Decodes the candidates in mask as G4String.

  stringstream ss;
  G4int numNodes = fBoxes.size();

  for(G4int i=0; i<numNodes; ++i)
  {
    if (bits.TestBitNumber(i))  { ss << i+1 << " "; }
  }
  return ss.str();
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetCandidatesVoxel()

void G4SurfaceVoxelizer::GetCandidatesVoxel

(

std::vector< G4int > &

voxels

)

Definition at line 758 of file G4SurfaceVoxelizer.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] << "]: ";
  vector<G4int> candidates;
  G4int count = GetCandidatesVoxelArray(voxels, candidates);
  G4cout << "[ ";
  for (G4int i = 0; i < count; ++i) G4cout << candidates[i];
  G4cout << "]  " << G4endl;
}

Here is the call graph for this function:

GetCandidatesVoxelArray() [1/3]

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

Definition at line 792 of file G4SurfaceVoxelizer.cc.

{
  // Method returning the candidates corresponding to the passed point

  list.clear();

  for (G4int 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;
  } 
  else
  {
    if (fNPerSlice == 1)
    {
      unsigned int mask;
      G4int slice = BinarySearch(fBoundaries[0], point.x()); 
      if (!(mask = ((unsigned int *) fBitmasks[0].fAllBits)[slice]
      )) return 0;
      slice = BinarySearch(fBoundaries[1], point.y());
      if (!(mask &= ((unsigned int *) fBitmasks[1].fAllBits)[slice]
      )) return 0;
      slice = BinarySearch(fBoundaries[2], point.z());
      if (!(mask &= ((unsigned int *) fBitmasks[2].fAllBits)[slice]
      )) return 0;
      if (crossed && (!(mask &= ~((unsigned int *)crossed->fAllBits)[0])))
        return 0;

      FindComponentsFastest(mask, list, 0);
    }
    else
    {
      unsigned int *masks[3], mask; // masks for X,Y,Z axis
      for (G4int 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 ? (unsigned int *)crossed->fAllBits : 0;

      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])) continue;
        if (!(mask &= masks[1][i])) continue;
        if (!(mask &= masks[2][i])) continue;
        if (maskCrossed && !(mask &= ~maskCrossed[i])) continue;

        FindComponentsFastest(mask, list, i);
      }
    }
  }
  return list.size();
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetCandidatesVoxelArray() [2/3]

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

Definition at line 859 of file G4SurfaceVoxelizer.cc.

{
  list.clear();

  if (fTotalCandidates == 1)
  {
    list.push_back(0);
    return 1;
  }
  else
  {
    if (fNPerSlice == 1)
    {
      unsigned int mask;
      if (!(mask = ((unsigned int *) bitmasks[0].fAllBits)[voxels[0]]
      )) return 0;
      if (!(mask &= ((unsigned int *) bitmasks[1].fAllBits)[voxels[1]]
      )) return 0;
      if (!(mask &= ((unsigned int *) bitmasks[2].fAllBits)[voxels[2]]
      )) return 0;
      if (crossed && (!(mask &= ~((unsigned int *)crossed->fAllBits)[0])))
        return 0;

      FindComponentsFastest(mask, list, 0);
    }
    else
    {
      unsigned int *masks[3], mask; // masks for X,Y,Z axis
      for (G4int i = 0; i <= 2; ++i)
      {
        masks[i] = ((unsigned int *) bitmasks[i].fAllBits)
                 + voxels[i]*fNPerSlice;
      }
      unsigned int *maskCrossed =
        crossed ? (unsigned int *)crossed->fAllBits : 0;

      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])) continue;
        if (!(mask &= masks[1][i])) continue;
        if (!(mask &= masks[2][i])) continue;
        if (maskCrossed && !(mask &= ~maskCrossed[i])) continue;

        FindComponentsFastest(mask, list, i);
      }
    }
  }
  return list.size();
}

Here is the call graph for this function:

GetCandidatesVoxelArray() [3/3]

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

Definition at line 917 of file G4SurfaceVoxelizer.cc.

{
  // Method returning the candidates corresponding to the passed point

  return GetCandidatesVoxelArray(voxels, fBitmasks, list, crossed);
}

Here is the call graph for this function:

GetCountOfVoxels()

long long G4SurfaceVoxelizer::GetCountOfVoxels ( ) const

inline

Here is the caller graph for this function:

GetDefaultVoxelsCount()

G4int G4SurfaceVoxelizer::GetDefaultVoxelsCount ( )

static

Definition at line 1077 of file G4SurfaceVoxelizer.cc.

{
  return fDefaultVoxelsCount;
}

GetMaxVoxels()

G4int G4SurfaceVoxelizer::GetMaxVoxels ( G4ThreeVector &  ratioOfReduction )

inline

Here is the caller graph for this function:

GetPointIndex()

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

inline

Here is the caller graph for this function:

GetTotalCandidates()

G4int G4SurfaceVoxelizer::GetTotalCandidates ( ) const

inline

GetVoxel()

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

inline

Here is the caller graph for this function:

GetVoxelBox()

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

inline

Here is the caller graph for this function:

GetVoxelBoxCandidates()

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

inline

Here is the caller graph for this function:

GetVoxelBoxesSize()

G4int G4SurfaceVoxelizer::GetVoxelBoxesSize ( ) const

inline

Here is the caller graph for this function:

GetVoxelsIndex() [1/2]

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

inline

Here is the caller graph for this function:

GetVoxelsIndex() [2/2]

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

inline

IsEmpty()

G4bool G4SurfaceVoxelizer::IsEmpty ( G4int  index ) const

inline

Here is the caller graph for this function:

MinDistanceToBox()

G4double G4SurfaceVoxelizer::MinDistanceToBox ( const G4ThreeVector &  aPoint, const G4ThreeVector &  f  )

static

Definition at line 957 of file G4SurfaceVoxelizer.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
  // if (!aAccurate) return safe;
  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);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetDefaultVoxelsCount()

G4int G4SurfaceVoxelizer::SetDefaultVoxelsCount ( G4int  count )

static

Definition at line 1069 of file G4SurfaceVoxelizer.cc.

{
  G4int res = fDefaultVoxelsCount;
  fDefaultVoxelsCount = count;
  return res;
}

SetMaxVoxels() [1/2]

void G4SurfaceVoxelizer::SetMaxVoxels

(

G4int

max

)

Definition at line 1055 of file G4SurfaceVoxelizer.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

SetMaxVoxels() [2/2]

void G4SurfaceVoxelizer::SetMaxVoxels

(

const G4ThreeVector &

reductionRatio

)

Definition at line 1062 of file G4SurfaceVoxelizer.cc.

{
  fMaxVoxels = -1;
  fReductionRatio = ratioOfReduction;
}

SetReductionRatio()

void G4SurfaceVoxelizer::SetReductionRatio ( G4int  maxVoxels, G4ThreeVector &  reductionRatio  )

private

Definition at line 445 of file G4SurfaceVoxelizer.cc.

{
  G4double maxTotal = (G4double) fCandidatesCounts[0].size()
                    * fCandidatesCounts[1].size() * fCandidatesCounts[2].size();

  if (maxVoxels > 0 && maxVoxels < maxTotal)
  {
    G4double ratio = (G4double) maxVoxels / maxTotal;
    ratio = pow(ratio, 1./3.);
    if (ratio > 1)  { ratio = 1; }
    reductionRatio.set(ratio,ratio,ratio);
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

UpdateCurrentVoxel()

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

Definition at line 1024 of file G4SurfaceVoxelizer.cc.

{
  for (G4int i = 0; i <= 2; ++i)
  {
    G4int index = curVoxel[i];
    const 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;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Voxelize()

void G4SurfaceVoxelizer::Voxelize

(

std::vector< G4VFacet *> &

facets

)

Definition at line 626 of file G4SurfaceVoxelizer.cc.

{
  G4int maxVoxels = fMaxVoxels;
  G4ThreeVector reductionRatio = fReductionRatio;

  G4int size = facets.size();
  if (size < 10)
  {
    for (G4int i = 0; i < (G4int) facets.size(); i++)
    { 
      if (facets[i]->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, 0, 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

    vector<G4double> miniBoundaries[3];

    for (G4int i = 0; i <= 2; ++i)  { miniBoundaries[i] = fBoundaries[i]; }

    G4int voxelsCountMini = (fCountOfVoxels >= 1000)
                          ? 100 : fCountOfVoxels / 10;

    // if (voxelCountMini < 8) voxelCountMini = 8;
    // voxelsCountMini = 1;

    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 (G4int i = 0; i < 3; i++)
    {
      fCandidatesCounts[i].resize(0);
      fBitmasks[i].Clear();
    }
  }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

fBitmasks

G4SurfBits G4SurfaceVoxelizer::fBitmasks[3]

private

Definition at line 236 of file G4SurfaceVoxelizer.hh.

fBoundaries

std::vector<G4double> G4SurfaceVoxelizer::fBoundaries[3]

private

Definition at line 229 of file G4SurfaceVoxelizer.hh.

fBoundingBox

G4Box G4SurfaceVoxelizer::fBoundingBox

private

Definition at line 240 of file G4SurfaceVoxelizer.hh.

fBoundingBoxCenter

G4ThreeVector G4SurfaceVoxelizer::fBoundingBoxCenter

private

Definition at line 238 of file G4SurfaceVoxelizer.hh.

fBoundingBoxSize

G4ThreeVector G4SurfaceVoxelizer::fBoundingBoxSize

private

Definition at line 242 of file G4SurfaceVoxelizer.hh.

fBoxes

std::vector<G4VoxelBox> G4SurfaceVoxelizer::fBoxes

private

Definition at line 226 of file G4SurfaceVoxelizer.hh.

fCandidates

std::map<G4int, std::vector<G4int> > G4SurfaceVoxelizer::fCandidates

mutableprivate

Definition at line 218 of file G4SurfaceVoxelizer.hh.

fCandidatesCounts

std::vector<G4int> G4SurfaceVoxelizer::fCandidatesCounts[3]

private

Definition at line 232 of file G4SurfaceVoxelizer.hh.

fCountOfVoxels

long long G4SurfaceVoxelizer::fCountOfVoxels

private

Definition at line 222 of file G4SurfaceVoxelizer.hh.

fDefaultVoxelsCount

G4ThreadLocal G4int G4SurfaceVoxelizer::fDefaultVoxelsCount = -1

staticprivate

Definition at line 183 of file G4SurfaceVoxelizer.hh.

fEmpty

G4SurfBits G4SurfaceVoxelizer::fEmpty

private

Definition at line 250 of file G4SurfaceVoxelizer.hh.

fMaxVoxels

G4int G4SurfaceVoxelizer::fMaxVoxels

private

Definition at line 246 of file G4SurfaceVoxelizer.hh.

fNoCandidates

const std::vector<G4int> G4SurfaceVoxelizer::fNoCandidates

private

Definition at line 220 of file G4SurfaceVoxelizer.hh.

fNPerSlice

G4int G4SurfaceVoxelizer::fNPerSlice

private

Definition at line 224 of file G4SurfaceVoxelizer.hh.

fReductionRatio

G4ThreeVector G4SurfaceVoxelizer::fReductionRatio

private

Definition at line 244 of file G4SurfaceVoxelizer.hh.

fTolerance

G4double G4SurfaceVoxelizer::fTolerance

private

Definition at line 248 of file G4SurfaceVoxelizer.hh.

fTotalCandidates

G4int G4SurfaceVoxelizer::fTotalCandidates

private

Definition at line 234 of file G4SurfaceVoxelizer.hh.

fVoxelBoxes

std::vector<G4VoxelBox> G4SurfaceVoxelizer::fVoxelBoxes

private

Definition at line 216 of file G4SurfaceVoxelizer.hh.

fVoxelBoxesCandidates

std::vector<std::vector<G4int> > G4SurfaceVoxelizer::fVoxelBoxesCandidates

private

Definition at line 217 of file G4SurfaceVoxelizer.hh.

---

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

• G4SurfaceVoxelizer.hh
• G4SurfaceVoxelizer.cc