G4SmartVoxelHeader Class Reference

G4SmartVoxelHeader represents a set of voxels, created by a single axis of virtual division. It contains the individual voxels, which are potentially further divided along different axes. More...

#include <G4SmartVoxelHeader.hh>

Public Member Functions
	G4SmartVoxelHeader (G4LogicalVolume *pVolume, G4int pSlice=0)
	G4SmartVoxelHeader (G4LogicalVolume *pVolume, const G4VoxelLimits &pLimits, const G4VolumeNosVector *pCandidates, G4int pSlice=0)
	~G4SmartVoxelHeader ()
G4bool	operator== (const G4SmartVoxelHeader &pHead) const
G4int	GetMaxEquivalentSliceNo () const
void	SetMaxEquivalentSliceNo (G4int pMax)
G4int	GetMinEquivalentSliceNo () const
void	SetMinEquivalentSliceNo (G4int pMin)
EAxis	GetAxis () const
EAxis	GetParamAxis () const
G4double	GetMaxExtent () const
G4double	GetMinExtent () const
std::size_t	GetNoSlices () const
G4SmartVoxelProxy *	GetSlice (std::size_t n) const
G4bool	AllSlicesEqual () const

Friends
std::ostream &	operator<< (std::ostream &s, const G4SmartVoxelHeader &h)

Detailed Description

G4SmartVoxelHeader represents a set of voxels, created by a single axis of virtual division. It contains the individual voxels, which are potentially further divided along different axes.

Definition at line 80 of file G4SmartVoxelHeader.hh.

Constructor & Destructor Documentation

G4SmartVoxelHeader() [1/2]

G4SmartVoxelHeader::G4SmartVoxelHeader	(	G4LogicalVolume *	pVolume,
		G4int	pSlice = 0 )

Constructor for the topmost header, to begin voxel construction at a given logical volume; 'pSlice' is used to set max and min equivalent slice numbers for the header - they apply to the level of the header, not its nodes.

Parameters

[in]	pVolume	Pointer to the logical volume to voxelise.
[in]	pSlice	Max & min equivalent slice numbers for the header.

Definition at line 59 of file G4SmartVoxelHeader.cc.

  : fminEquivalent(pSlice),
    fmaxEquivalent(pSlice),
    fparamAxis(kUndefined)
{
  std::size_t nDaughters = pVolume->GetNoDaughters();
 
  // Determine whether daughter is replicated
  //
  if ((nDaughters!=1) || (!pVolume->GetDaughter(0)->IsReplicated()))
  {
    // Daughter not replicated => conventional voxel Build
    // where each daughters extents are computed
    //
    BuildVoxels(pVolume);
  }
  else
  {
    // Single replicated daughter
    //
    BuildReplicaVoxels(pVolume);
  }
}

Referenced by operator<<, operator==(), and ~G4SmartVoxelHeader().

G4SmartVoxelHeader() [2/2]

G4SmartVoxelHeader::G4SmartVoxelHeader	(	G4LogicalVolume *	pVolume,
		const G4VoxelLimits &	pLimits,
		const G4VolumeNosVector *	pCandidates,
		G4int	pSlice = 0 )

Constructor for building and refine voxels between specified limits, considering only the physical volumes numbered 'pCandidates'; 'pSlice' is used to set max and min equivalent slice numbers for the header; they apply to the level of the header, not its nodes.

Parameters

[in]	pVolume	Pointer to the logical volume to voxelise.
[in]	pLimits	Refinement limits for building the voxels.
[in]	pCandidates	Candidate volumes to be considered.
[in]	pSlice	Max & min equivalent slice numbers for the header.

Definition at line 91 of file G4SmartVoxelHeader.cc.

  : fminEquivalent(pSlice),
    fmaxEquivalent(pSlice),
    fparamAxis(kUndefined)
{
#ifdef G4GEOMETRY_VOXELDEBUG
  G4cout << "**** G4SmartVoxelHeader::G4SmartVoxelHeader" << G4endl
         << "     Limits " << pLimits << G4endl
         << "     Candidate #s = " ;
  for (auto i=0; i<pCandidates->size(); ++i)
  {
    G4cout << (*pCandidates)[i] << " ";
  }
  G4cout << G4endl;
#endif   
 
  BuildVoxelsWithinLimits(pVolume,pLimits,pCandidates);
}

~G4SmartVoxelHeader()

G4SmartVoxelHeader::~G4SmartVoxelHeader

(

)

Destructor. Deletes all referenced nodes [but not the referenced physical volumes].

Definition at line 117 of file G4SmartVoxelHeader.cc.

{
  // Manually destroy underlying nodes/headers
  // Delete collected headers and nodes once only
  //
  std::size_t node, proxy, maxNode=fslices.size();
  G4SmartVoxelProxy* lastProxy = nullptr;
  G4SmartVoxelNode *dyingNode, *lastNode=nullptr;
  G4SmartVoxelHeader *dyingHeader, *lastHeader=nullptr;
 
  for (node=0; node<maxNode; ++node)
  {
    if (fslices[node]->IsHeader())
    {
      dyingHeader = fslices[node]->GetHeader();
      if (lastHeader != dyingHeader)
      {
        lastHeader = dyingHeader;
        lastNode = nullptr;
        delete dyingHeader;
      }
    }
    else
    {
      dyingNode = fslices[node]->GetNode();
      if (dyingNode != lastNode)
      {
        lastNode = dyingNode;
        lastHeader = nullptr;
        delete dyingNode;
      }
    }
  }
  // Delete proxies
  //
  for (proxy=0; proxy<maxNode; ++proxy)
  {
    if (fslices[proxy] != lastProxy)
    {
      lastProxy = fslices[proxy];
      delete lastProxy;
    }
  }
  // Don't need to clear slices
  // fslices.clear();
}

Member Function Documentation

AllSlicesEqual()

G4bool G4SmartVoxelHeader::AllSlicesEqual

(

)

const

Returns true if all slices are equal (after collection).

Definition at line 1247 of file G4SmartVoxelHeader.cc.

{
  std::size_t noSlices = fslices.size();
  G4SmartVoxelProxy* refProxy;
 
  if (noSlices>1)
  {
    refProxy=fslices[0];
    for (std::size_t i=1; i<noSlices; ++i)
    {
      if (refProxy!=fslices[i])
      {
        return false;
      }
    }
  }
  return true;
}

GetAxis()

EAxis G4SmartVoxelHeader::GetAxis

(

)

const

Returns the current division axis.

Referenced by G4VoxelNavigation::LocateNextVoxel(), operator==(), and G4VoxelSafety::SafetyForVoxelHeader().

GetMaxEquivalentSliceNo()

G4int G4SmartVoxelHeader::GetMaxEquivalentSliceNo

(

)

const

Access functions for min/max equivalent slices (nodes & headers).

Referenced by G4VoxelSafety::SafetyForVoxelHeader().

GetMaxExtent()

G4double G4SmartVoxelHeader::GetMaxExtent

(

)

const

Returns the maximum coordinate limit along the current axis.

Referenced by operator==(), and G4VoxelSafety::SafetyForVoxelHeader().

GetMinEquivalentSliceNo()

G4int G4SmartVoxelHeader::GetMinEquivalentSliceNo

(

)

const

Referenced by G4VoxelSafety::SafetyForVoxelHeader().

GetMinExtent()

G4double G4SmartVoxelHeader::GetMinExtent

(

)

const

Returns the minimum coordinate limit along the current axis.

Referenced by G4VoxelNavigation::ComputeVoxelSafety(), G4VoxelNavigation::LocateNextVoxel(), operator==(), and G4VoxelSafety::SafetyForVoxelHeader().

GetNoSlices()

std::size_t G4SmartVoxelHeader::GetNoSlices

(

)

const

Returns the number of slices along the current axis.

Referenced by operator==(), and G4VoxelSafety::SafetyForVoxelHeader().

GetParamAxis()

EAxis G4SmartVoxelHeader::GetParamAxis

(

)

const

Returns the suggested division axis for parameterised volume.

GetSlice()

G4SmartVoxelProxy * G4SmartVoxelHeader::GetSlice

(

std::size_t

n

)

const

Returns the pointer to the proxy for the n-th slice (numbering from 0, no bounds checking is performed).

Referenced by operator==(), and G4VoxelSafety::SafetyForVoxelHeader().

operator==()

G4bool G4SmartVoxelHeader::operator==

(

const G4SmartVoxelHeader &

pHead

)

const

Equality operator.

Definition at line 173 of file G4SmartVoxelHeader.cc.

{
  if ( (GetAxis()      == pHead.GetAxis())
    && (GetNoSlices()  == pHead.GetNoSlices())
    && (GetMinExtent() == pHead.GetMinExtent())
    && (GetMaxExtent() == pHead.GetMaxExtent()) )
  {
    std::size_t node, maxNode;
    G4SmartVoxelProxy *leftProxy, *rightProxy;
    G4SmartVoxelHeader *leftHeader, *rightHeader;
    G4SmartVoxelNode *leftNode, *rightNode;
 
    maxNode = GetNoSlices();
    for (node=0; node<maxNode; ++node)
    {
      leftProxy  = GetSlice(node);
      rightProxy = pHead.GetSlice(node);
      if (leftProxy->IsHeader())
      {
        if (rightProxy->IsNode())
        {
          return false;
        }
        leftHeader  = leftProxy->GetHeader();
        rightHeader = rightProxy->GetHeader();
        if (!(*leftHeader == *rightHeader))
        {
          return false;
        }
      }
      else
      {
        if (rightProxy->IsHeader())
        {
          return false;
        }
        leftNode  = leftProxy->GetNode();
        rightNode = rightProxy->GetNode();
        if (!(*leftNode == *rightNode))
        {
          return false;
        }
      }
    }
    return true;
  }
 
  return false;
}

SetMaxEquivalentSliceNo()

void G4SmartVoxelHeader::SetMaxEquivalentSliceNo

(

G4int

pMax

)

SetMinEquivalentSliceNo()

void G4SmartVoxelHeader::SetMinEquivalentSliceNo

(

G4int

pMin

)

Friends And Related Symbol Documentation

operator<<

std::ostream & operator<< ( std::ostream & s, const G4SmartVoxelHeader & h )

friend

Streaming operator.

Definition at line 1270 of file G4SmartVoxelHeader.cc.

{
  os << "Axis = " << G4int(h.faxis) << G4endl;
  G4SmartVoxelProxy *collectNode=nullptr, *collectHead=nullptr;
  std::size_t collectNodeNo = 0;
  std::size_t collectHeadNo = 0;
  std::size_t i, j;
  G4bool haveHeaders = false;
 
  for (i=0; i<h.fslices.size(); ++i)
  {
    os << "Slice #" << i << " = ";
    if (h.fslices[i]->IsNode())
    {
      if (h.fslices[i]!=collectNode)
      {
        os << "{";
        for (std::size_t k=0; k<h.fslices[i]->GetNode()->GetNoContained(); ++k)
        {
          os << " " << h.fslices[i]->GetNode()->GetVolume((G4int)k);
        }
        os << " }" << G4endl;
        collectNode = h.fslices[i];
        collectNodeNo = i;
      }
      else
      {
        os << "As slice #" << collectNodeNo << G4endl;
      }
    }
    else
    {
      haveHeaders=true;
      if (h.fslices[i] != collectHead)
      {
        os << "Header" << G4endl;
        collectHead = h.fslices[i];
        collectHeadNo = i;
      }
      else
      {
        os << "As slice #" << collectHeadNo << G4endl;
      }
    }
  }
 
  if (haveHeaders)
  {
    collectHead=nullptr;
    for (j=0; j<h.fslices.size(); ++j)
    {
      if (h.fslices[j]->IsHeader())
      {
        os << "Header at Slice #" << j << " = ";
        if (h.fslices[j] != collectHead)
        {
          os << G4endl 
             << (*(h.fslices[j]->GetHeader()));
          collectHead = h.fslices[j];
          collectHeadNo = j;
        }
        else
        {
          os << "As slice #" << collectHeadNo << G4endl;
        }
      }
    }
  }
  return os;
}

---

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

• G4SmartVoxelHeader.hh
• G4SmartVoxelHeader.cc