G4GeomTestVolume Class Reference

G4GeomTestVolume allows to check for inconsistencies in the geometric boundaries of a physical volume and the boundaries of all its immediate daughters. More...

#include <G4GeomTestVolume.hh>

Public Member Functions
	G4GeomTestVolume (G4VPhysicalVolume *theTarget, G4double theTolerance=0.0, G4int numberOfPoints=10000, G4bool theVerbosity=true)
	~G4GeomTestVolume ()
G4double	GetTolerance () const
void	SetTolerance (G4double tolerance)
G4int	GetResolution () const
void	SetResolution (G4int points)
G4bool	GetVerbosity () const
void	SetVerbosity (G4bool verbosity)
G4int	GetErrorsThreshold () const
void	SetErrorsThreshold (G4int max)
void	TestOverlapInTree () const
void	TestRecursiveOverlap (G4int sLevel=0, G4int depth=-1)

Detailed Description

G4GeomTestVolume allows to check for inconsistencies in the geometric boundaries of a physical volume and the boundaries of all its immediate daughters.

Definition at line 49 of file G4GeomTestVolume.hh.

Constructor & Destructor Documentation

G4GeomTestVolume()

G4GeomTestVolume::G4GeomTestVolume	(	G4VPhysicalVolume *	theTarget,
		G4double	theTolerance = 0.0,
		G4int	numberOfPoints = 10000,
		G4bool	theVerbosity = true )

Constructor and Destructor.

Definition at line 43 of file G4GeomTestVolume.cc.

  : target(theTarget), tolerance(theTolerance),
    resolution(numberOfPoints), verbosity(theVerbosity)
{;}

Referenced by TestRecursiveOverlap().

~G4GeomTestVolume()

G4GeomTestVolume::~G4GeomTestVolume

(

)

Definition at line 54 of file G4GeomTestVolume.cc.

{;}

Member Function Documentation

GetErrorsThreshold()

G4int G4GeomTestVolume::GetErrorsThreshold

(

)

const

Get/Set maximum number of errors to report (default set to 1).

Definition at line 107 of file G4GeomTestVolume.cc.

{
  return maxErr;
}

GetResolution()

G4int G4GeomTestVolume::GetResolution

(

)

const

Gets/Sets number of points to check (default set to 10000).

Definition at line 75 of file G4GeomTestVolume.cc.

{
  return resolution;
}

GetTolerance()

G4double G4GeomTestVolume::GetTolerance

(

)

const

Gets/Sets error tolerance (default set to 0*mm).

Definition at line 59 of file G4GeomTestVolume.cc.

{
  return tolerance;
}

GetVerbosity()

G4bool G4GeomTestVolume::GetVerbosity

(

)

const

Gets/Sets verbosity mode (default set to true).

Definition at line 91 of file G4GeomTestVolume.cc.

{
  return verbosity;
}

SetErrorsThreshold()

void G4GeomTestVolume::SetErrorsThreshold

(

G4int

max

)

Definition at line 115 of file G4GeomTestVolume.cc.

{
  maxErr = max;
}

Referenced by TestRecursiveOverlap().

SetResolution()

void G4GeomTestVolume::SetResolution

(

G4int

points

)

Definition at line 83 of file G4GeomTestVolume.cc.

{
  resolution = np;
}

SetTolerance()

void G4GeomTestVolume::SetTolerance

(

G4double

tolerance

)

Definition at line 67 of file G4GeomTestVolume.cc.

{
  tolerance = tol;
}

SetVerbosity()

void G4GeomTestVolume::SetVerbosity

(

G4bool

verbosity

)

Definition at line 99 of file G4GeomTestVolume.cc.

{
  verbosity = verb;
}

TestOverlapInTree()

void G4GeomTestVolume::TestOverlapInTree

(

)

const

Checks for overlaps in the volume tree without duplication in identical logical volumes.

Definition at line 123 of file G4GeomTestVolume.cc.

{
  std::queue<G4VPhysicalVolume*> volumes;
  std::set<G4LogicalVolume*> checked;
 
  volumes.push(target);
  while (!volumes.empty())
  {
    G4VPhysicalVolume* current = volumes.front();
    volumes.pop();
 
    // check overlaps for daughters
    G4LogicalVolume* logical = current->GetLogicalVolume();
    std::size_t ndaughters = logical->GetNoDaughters();
    for (std::size_t i=0; i<ndaughters; ++i)
    {
      G4VPhysicalVolume* daughter = logical->GetDaughter(i);
      daughter->CheckOverlaps(resolution, tolerance, verbosity, maxErr);
    }
 
    // append the queue of volumes
    G4LogicalVolume* previousLogical = nullptr;
    for (std::size_t i=0; i<ndaughters; ++i)
    {
      G4VPhysicalVolume* daughter = logical->GetDaughter(i);
      G4LogicalVolume* daughterLogical = daughter->GetLogicalVolume();
      if (daughterLogical->GetNoDaughters() == 0) { continue; }
      G4bool found = (daughterLogical == previousLogical);
      if (!found) { found = (checked.find(daughterLogical) != checked.cend()); }
      if (!found)
      {
        checked.emplace(daughterLogical);
        previousLogical = daughterLogical;
        volumes.push(daughter);
      }
      else
      {
        if (verbosity)
        {
          G4cout << "Checking overlaps in tree of volume " << daughter->GetName()
                 << " (" << daughterLogical->GetSolid()->GetEntityType() << ")"
                 << " is omitted, to avoid duplication" << G4endl;
        }
      }
    }
  }
}

TestRecursiveOverlap()

void G4GeomTestVolume::TestRecursiveOverlap	(	G4int	sLevel = 0,
		G4int	depth = -1 )

Activates overlaps check, propagating recursively to the daughters, with possibility of specifying the initial level in the volume tree and the depth (default is the whole tree).

Note

Depending on the complexity of the geometry, this may require long computational time.

Definition at line 174 of file G4GeomTestVolume.cc.

{
  // If reached requested level of depth (i.e. set to 0), exit.
  // If not depth specified (i.e. set to -1), visit the whole tree.
  // If requested initial level of depth is not zero, visit from beginning
  //
  if (depth == 0) { return; }
  if (depth != -1) { depth--; }
  if (slevel != 0) { slevel--; }
 
  //
  // As long as we reached the requested
  // initial level of depth, test ourselves
  //
  if ( slevel==0 )
  {
    target->CheckOverlaps(resolution, tolerance, verbosity, maxErr);
  }
 
  //
  // Loop over unique daughters
  //
  std::set<const G4LogicalVolume *> tested;
 
  const G4LogicalVolume *logical = target->GetLogicalVolume();
  auto nDaughter = (G4int)logical->GetNoDaughters();
  for( auto iDaughter=0; iDaughter<nDaughter; ++iDaughter )
  {
    G4VPhysicalVolume *daughter = logical->GetDaughter(iDaughter);
    
    // Tested already?
    //
    // const G4LogicalVolume *daughterLogical =
    //      daughter->GetLogicalVolume();
    // std::pair<std::set<const G4LogicalVolume *>::iterator, G4bool>
    //       there = tested.insert(daughterLogical);
    // if (!there.second) continue;
 
    //
    // Recurse
    //
    G4GeomTestVolume vTest( daughter, tolerance, resolution, verbosity );
    vTest.SetErrorsThreshold(maxErr);
    vTest.TestRecursiveOverlap( slevel,depth );
  }
}

Referenced by TestRecursiveOverlap().

---

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

• G4GeomTestVolume.hh
• G4GeomTestVolume.cc