#include <G4GeomTestVolume.hh>

Public Member Functions
	G4GeomTestVolume (const G4VPhysicalVolume theTarget, G4GeomTestLogger theLogger, G4double theTolerance=1E-4)

	~G4GeomTestVolume ()

G4double	GetTolerance () const

void	SetTolerance (G4double tolerance)

void	TestCartGridXYZ (G4int nx=100, G4int ny=100, G4int nz=100)

void	TestCartGridX (G4int ny=100, G4int nz=100)

void	TestCartGridY (G4int nz=100, G4int nx=100)

void	TestCartGridZ (G4int nx=100, G4int ny=100)

void	TestCartGrid (const G4ThreeVector &g1, const G4ThreeVector &g2, const G4ThreeVector &v, G4int n1, G4int n2)

void	TestRecursiveCartGrid (G4int nx=100, G4int ny=100, G4int nz=100, G4int sLevel=0, G4int depth=-1)

void	TestCylinder (G4int nPhi=90, G4int nZ=50, G4int nRho=50, G4double fracZ=0.8, G4double fracRho=0.8, G4bool usePhi=false)

void	TestRecursiveCylinder (G4int nPhi=90, G4int nZ=50, G4int nRho=50, G4double fracZ=0.8, G4double fracRho=0.8, G4bool usePhi=false, G4int sLevel=0, G4int depth=-1)

void	TestOneLine (const G4ThreeVector &p, const G4ThreeVector &v)

void	TestRecursiveLine (const G4ThreeVector &p, const G4ThreeVector &v, G4int sLevel=0, G4int depth=-1)

void	ReportErrors ()

void	ClearErrors ()

Protected Attributes
const G4VPhysicalVolume *	target

G4GeomTestLogger *	logger

G4double	tolerance

G4VisExtent	extent

std::map< G4long, G4GeomTestOverlapList >	overlaps

std::map< G4long, G4GeomTestOvershootList >	overshoots

Detailed Description

Definition at line 54 of file G4GeomTestVolume.hh.

Constructor & Destructor Documentation

◆ G4GeomTestVolume()

G4GeomTestVolume::G4GeomTestVolume	(	const G4VPhysicalVolume *	theTarget,
		G4GeomTestLogger *	theLogger,
		G4double	theTolerance = `1E-4`
	)

Definition at line 56 of file G4GeomTestVolume.cc.

  : target(theTarget),
    logger(theLogger),
    tolerance(theTolerance),
    extent(theTarget->GetLogicalVolume()->GetSolid()->GetExtent())
{;}

◆ ~G4GeomTestVolume()

G4GeomTestVolume::~G4GeomTestVolume ( )

Definition at line 68 of file G4GeomTestVolume.cc.

68{;}

Member Function Documentation

◆ ClearErrors()

void G4GeomTestVolume::ClearErrors ( )

Definition at line 687 of file G4GeomTestVolume.cc.

{
  overshoots.clear();
  overlaps.clear();
}

◆ GetTolerance()

G4double G4GeomTestVolume::GetTolerance ( ) const

Definition at line 73 of file G4GeomTestVolume.cc.

{
  return tolerance;
}

◆ ReportErrors()

void G4GeomTestVolume::ReportErrors ( )

Definition at line 649 of file G4GeomTestVolume.cc.

{
  //
  // Report overshoots
  //
  if (overshoots.empty())
    logger->NoProblem("GeomTest: no daughter volume extending outside mother detected.");
  else
  {
    std::map<G4long,G4GeomTestOvershootList>::iterator overshoot =
      overshoots.begin();
    while( overshoot != overshoots.end() )
    {
      logger->OvershootingDaughter( &(*overshoot).second );
      ++overshoot;
    }
  }
 
  //
  // Report overlaps
  //
  if (overlaps.empty())
    logger->NoProblem("GeomTest: no overlapping daughters detected.");
  else
  {
    std::map<G4long,G4GeomTestOverlapList>::iterator overlap =
      overlaps.begin();
    while( overlap != overlaps.end() )
    {
      logger->OverlappingDaughters( &(*overlap).second );
      ++overlap;
    }
  }
}

Referenced by TestRecursiveCartGrid(), TestRecursiveCylinder(), and TestRecursiveLine().

◆ SetTolerance()

void G4GeomTestVolume::SetTolerance ( G4double tolerance )

Definition at line 81 of file G4GeomTestVolume.cc.

{
  tolerance = val;
}

◆ TestCartGrid()

void G4GeomTestVolume::TestCartGrid	(	const G4ThreeVector &	g1,
		const G4ThreeVector &	g2,
		const G4ThreeVector &	v,
		G4int	n1,
		G4int	n2
	)

Definition at line 333 of file G4GeomTestVolume.cc.

{
  if (n1 <= 0 || n2 <= 0) 
    G4Exception( "G4GeomTestVolume::TestCartGrid()", "GeomNav0002",
                 FatalException, "Arguments n1 and n2 must be >= 1" );
    
  G4ThreeVector xMin( extent.GetXmin(), extent.GetYmin(),
                      extent.GetZmin() );
  G4ThreeVector xMax( extent.GetXmax(), extent.GetYmax(),
                      extent.GetZmax() );
  
  G4ThreeVector g1(theG1.unit());
  G4ThreeVector g2(theG2.unit());
  G4ThreeVector v(theV.unit());
  
  G4double gMin1 = g1.dot(xMin);
  G4double gMax1 = g1.dot(xMax);
  
  G4double gMin2 = g2.dot(xMin);
  G4double gMax2 = g2.dot(xMax);
  
  G4double delta1 = (gMax1-gMin1)/G4double(n1);
  G4double delta2 = (gMax2-gMin2)/G4double(n2);
    
  G4int i1, i2;
  
  for(i1=0;i1<=n1;++i1)
  {
    G4ThreeVector p1 = (gMin1 + G4double(i1)*delta1)*g1;
    
    for(i2=0;i2<=n2;++i2)
    {
      G4ThreeVector p2 = (gMin2 + G4double(i2)*delta2)*g2;
      
      TestOneLine( p1+p2, v );
    }
  }
}  

Referenced by TestCartGridX(), TestCartGridY(), and TestCartGridZ().

◆ TestCartGridX()

void G4GeomTestVolume::TestCartGridX	(	G4int	ny = `100`,
		G4int	nz = `100`
	)

Definition at line 99 of file G4GeomTestVolume.cc.

{
  TestCartGrid( G4ThreeVector(0,1,0), G4ThreeVector(0,0,1),
                G4ThreeVector(1,0,0), ny, nz );
}

Referenced by TestCartGridXYZ().

◆ TestCartGridXYZ()

void G4GeomTestVolume::TestCartGridXYZ	(	G4int	nx = `100`,
		G4int	ny = `100`,
		G4int	nz = `100`
	)

Definition at line 89 of file G4GeomTestVolume.cc.

{
  TestCartGridX( ny, nz );
  TestCartGridY( nz, nx );
  TestCartGridZ( nx, ny );
}

Referenced by TestRecursiveCartGrid().

◆ TestCartGridY()

void G4GeomTestVolume::TestCartGridY	(	G4int	nz = `100`,
		G4int	nx = `100`
	)

Definition at line 108 of file G4GeomTestVolume.cc.

{
  TestCartGrid( G4ThreeVector(0,0,1), G4ThreeVector(1,0,0),
                G4ThreeVector(0,1,0), nz, nx );
}

Referenced by TestCartGridXYZ().

◆ TestCartGridZ()

void G4GeomTestVolume::TestCartGridZ	(	G4int	nx = `100`,
		G4int	ny = `100`
	)

Definition at line 117 of file G4GeomTestVolume.cc.

{
  TestCartGrid( G4ThreeVector(1,0,0), G4ThreeVector(0,1,0),
                G4ThreeVector(0,0,1), nx, ny );
}

Referenced by TestCartGridXYZ().

◆ TestCylinder()

void G4GeomTestVolume::TestCylinder	(	G4int	nPhi = `90`,
		G4int	nZ = `50`,
		G4int	nRho = `50`,
		G4double	fracZ = `0.8`,
		G4double	fracRho = `0.8`,
		G4bool	usePhi = `false`
	)

Definition at line 249 of file G4GeomTestVolume.cc.

{
  //
  // Get size of our volume
  //
  G4double xMax = std::max(extent.GetXmax(),-extent.GetXmin());
  G4double yMax = std::max(extent.GetYmax(),-extent.GetYmin());
  G4double rhoMax = std::sqrt(xMax*xMax + yMax*yMax);
  
  G4double zMax = extent.GetZmax();
  G4double zMin = extent.GetZmin();
  G4double zHalfLength = 0.5*(zMax-zMin);
  G4double z0 = 0.5*(zMax+zMin);
  
  //
  // Loop over phi
  //
  G4double deltaPhi = 2*pi/G4double(nPhi);
  
  G4double phi = 0;
  G4int iPhi = nPhi;
  if ((iPhi&1) == 0) iPhi++;  // Also use odd number phi slices
  do
  {
    G4double cosPhi = std::cos(phi);
    G4double sinPhi = std::sin(phi);
    G4ThreeVector vPhi1(sinPhi,-cosPhi,0);
 
    //
    // Loop over rho
    //
    G4double rho = rhoMax;
    G4int iRho = nRho;
    do
    {
      G4ThreeVector p(rho*cosPhi,rho*sinPhi,0);
      static G4ThreeVector v(0,0,1);
      
      TestOneLine( p, v );
      
      if (usePhi)
      {
        //
        // Loop over z
        //
        G4double zScale = 1.0;
        G4int iZ=nZ;
        do
        {
          p.setZ( z0 + zScale*zHalfLength );
          TestOneLine(p,vPhi1);
          p.setZ( z0 - zScale*zHalfLength );
          TestOneLine(p,vPhi1);
        } while( zScale *= fracZ, --iZ );
      }
    } while( rho *= fracRho, --iRho );
 
    //
    // Loop over z
    //
    G4ThreeVector p(0,0,0);
    G4ThreeVector vPhi2(cosPhi,sinPhi,0);
    
    G4double zScale = 1.0;
    G4int iZ=nZ;
    do
    {
      p.setZ( z0 + zScale*zHalfLength );
      
      TestOneLine(p,vPhi2);
      
      p.setZ( z0 - zScale*zHalfLength );
      
      TestOneLine(p,vPhi2);
    } while( zScale *= fracZ, --iZ );
    
  } while( phi += deltaPhi, --iPhi );
}

Referenced by TestRecursiveCylinder().

◆ TestOneLine()

void G4GeomTestVolume::TestOneLine	(	const G4ThreeVector &	p,
		const G4ThreeVector &	v
	)

Definition at line 441 of file G4GeomTestVolume.cc.

{
  //
  // Keep track of intersection points
  //
  std::vector<G4GeomTestVolPoint> points;
  
  //
  // Calculate intersections with the mother volume
  //
  G4GeomTestSegment targetSegment( target->GetLogicalVolume()->GetSolid(),
                                   p, v, logger );
  
  //
  // Add them to our list
  // 
  G4int n = targetSegment.GetNumberPoints();
  G4int i;
  for(i=0;i<n;++i)
  {
    points.push_back( G4GeomTestVolPoint( targetSegment.GetPoint(i), -1 ) );
  } 
 
  //
  // Loop over daughter volumes
  //
  const G4LogicalVolume *logical = target->GetLogicalVolume();
  G4int nDaughter = logical->GetNoDaughters();
  G4int iDaughter;
  for( iDaughter=0; iDaughter<nDaughter; ++iDaughter)
  {
    const G4VPhysicalVolume *daughter = 
          logical->GetDaughter(iDaughter);
    
    //
    // Convert coordinates to daughter local coordinates
    //
    const G4RotationMatrix *rotation = daughter->GetFrameRotation();
    const G4ThreeVector &translation = daughter->GetFrameTranslation();
    
    G4ThreeVector pLocal = translation + p;
    G4ThreeVector vLocal = v;
    
    if (rotation)
    {
      pLocal = (*rotation)*pLocal;
      vLocal = (*rotation)*vLocal;
    }
    
    //
    // Find intersections
    //
    G4GeomTestSegment
       daughterSegment( daughter->GetLogicalVolume()->GetSolid(), 
                        pLocal, vLocal, logger );
    
    //
    // Add them to the list
    //
    n = daughterSegment.GetNumberPoints();
    for(i=0;i<n;++i)
    {
      points.push_back( G4GeomTestVolPoint( daughterSegment.GetPoint(i),
            iDaughter, translation, rotation ) );
    } 
  }
  
  //
  // Now sort the list of intersection points
  //
  std::sort( points.begin(), points.end() );
  
  //
  // Search for problems:
  //    1. Overlap daughters will be indicated by intersecting
  //       points that lie within another daughter
  //    2. Daughter extending outside the mother will be
  //       indicated by intersecting points outside the mother
  //
  // The search method is always looking forward when
  // resolving discrepencies due to roundoff error. Once
  // one instance of a daughter intersection is analyzed,
  // it is removed from further consideration
  //
  n = points.size();
  
  //
  // Set true if this point has been analyzed
  //
  std::vector<G4bool> checked( n, false );
  
  for(i=0;i<n;++i)
  {
    if (checked[i]) continue;
  
    G4int iDaug = points[i].GetDaughterIndex();
    if (iDaug < 0) continue;
  
    //
    // Intersection found. Find matching pair.
    //
    G4double iS = points[i].GetDistance();
    G4int j = i;
    while(++j<n)
    {
      if (iDaug == points[j].GetDaughterIndex()) break;
    }
    if (j>=n)
    {
      //
      // Unmatched? This shouldn't happen
      //
      logger->SolidProblem( logical->GetDaughter(iDaug)->
                            GetLogicalVolume()->GetSolid(),
                            "Unmatched intersection point",
          points[i].GetPosition() );
      continue;
    }
    
    checked[j] = true;
    
    G4double jS = points[j].GetDistance();
 
    //
    // Otherwise, we could have a problem
    //
    G4int k = i;
    while(++k<j)
    {
      if (checked[k]) continue;
      
      G4bool kEntering = points[k].Entering();
      G4double kS = points[k].GetDistance();
      
      
      //
      // Problem found: catagorize
      //
      G4int kDaug = points[k].GetDaughterIndex();
      if (kDaug < 0)
      {
        //
        // Ignore small overshoots if they are within tolerance
        //
        if (kS-iS < tolerance &&   kEntering ) continue;
        if (jS-kS < tolerance && (!kEntering)) continue;
 
        //
        // We appear to extend outside the mother volume
        //
        std::map<G4long,G4GeomTestOvershootList>::iterator overshoot =
          overshoots.find(iDaug);
        if (overshoot == overshoots.end())
        {
          std::pair<std::map<G4long,G4GeomTestOvershootList>::iterator,G4bool>
            result =
              overshoots.insert( std::pair<const G4long,G4GeomTestOvershootList>
                               (iDaug,G4GeomTestOvershootList(target,iDaug)) );
          overshoot = result.first;
        }
 
        if (kEntering)
          (*overshoot).second.AddError( points[i].GetPosition(),
                                        points[k].GetPosition() );
        else
          (*overshoot).second.AddError( points[k].GetPosition(),
                                        points[j].GetPosition() );
      }
      else
      {
        //
        // Ignore small overlaps if they are within tolerance
        //
        if (kS-iS < tolerance && (!kEntering)) continue;
        if (jS-kS < tolerance &&   kEntering ) continue;
        
        //
        // We appear to overlap with another daughter
        //
        G4long key = iDaug < kDaug ?
               (iDaug*nDaughter + kDaug) : (kDaug*nDaughter + iDaug);
        
        std::map<G4long,G4GeomTestOverlapList>::iterator overlap =
          overlaps.find(key);
        if (overlap == overlaps.end())
        {
          std::pair<std::map<G4long,G4GeomTestOverlapList>::iterator,G4bool>
            result =
            overlaps.insert( std::pair<const G4long,G4GeomTestOverlapList>
                           (key,G4GeomTestOverlapList(target,iDaug,kDaug)) );
          overlap = result.first;
        }
 
        if (points[k].Entering())
          (*overlap).second.AddError( points[k].GetPosition(),
                                      points[j].GetPosition() );
        else
          (*overlap).second.AddError( points[i].GetPosition(),
                                      points[k].GetPosition() );
      }
    }
  }
}

Referenced by TestCartGrid(), TestCylinder(), and TestRecursiveLine().

◆ TestRecursiveCartGrid()

void G4GeomTestVolume::TestRecursiveCartGrid	(	G4int	nx = `100`,
		G4int	ny = `100`,
		G4int	nz = `100`,
		G4int	sLevel = `0`,
		G4int	depth = `-1`
	)

Definition at line 126 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 aren't a replica and we reached the requested
  // initial level of depth, test ourselves
  //
  if ( (!target->IsReplicated()) && (slevel==0) )
  {
    TestCartGridXYZ( nx, ny, nz );
    ReportErrors();
  }
 
  //
  // Loop over unique daughters
  //
  std::set<const G4LogicalVolume *> tested;
 
  const G4LogicalVolume *logical = target->GetLogicalVolume();
  G4int nDaughter = logical->GetNoDaughters();
  G4int iDaughter;
  for( iDaughter=0; iDaughter<nDaughter; ++iDaughter )
  {
    const G4VPhysicalVolume *daughter =
          logical->GetDaughter(iDaughter);
    const G4LogicalVolume *daughterLogical =
          daughter->GetLogicalVolume();
    
    //
    // Skip empty daughters
    //
    if (daughterLogical->GetNoDaughters() == 0) continue;
    
    //
    // Tested already?
    //
    std::pair<std::set<const G4LogicalVolume *>::iterator,G4bool>
           there = tested.insert(daughterLogical);
    if (!there.second) continue;
 
    //
    // Recurse
    //
    G4GeomTestVolume vTest( daughter, logger, tolerance );
    vTest.TestRecursiveCartGrid( nx,ny,nz,slevel,depth );
  }
}

Referenced by TestRecursiveCartGrid().

◆ TestRecursiveCylinder()

void G4GeomTestVolume::TestRecursiveCylinder	(	G4int	nPhi = `90`,
		G4int	nZ = `50`,
		G4int	nRho = `50`,
		G4double	fracZ = `0.8`,
		G4double	fracRho = `0.8`,
		G4bool	usePhi = `false`,
		G4int	sLevel = `0`,
		G4int	depth = `-1`
	)

Definition at line 186 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 aren't a replica and we reached the requested
  // initial level of depth, test ourselves
  //
  if ( (!target->IsReplicated()) && (slevel==0) )
  {
    TestCylinder( nPhi, nZ, nRho, fracZ, fracRho, usePhi );
    ReportErrors();
  }
 
  //
  // Loop over unique daughters
  //
  std::set<const G4LogicalVolume *> tested;
 
  const G4LogicalVolume *logical = target->GetLogicalVolume();
  G4int nDaughter = logical->GetNoDaughters();
  G4int iDaughter;
  for( iDaughter=0; iDaughter<nDaughter; ++iDaughter )
  {
    const G4VPhysicalVolume *daughter =
          logical->GetDaughter(iDaughter);
    const G4LogicalVolume *daughterLogical =
          daughter->GetLogicalVolume();
    
    //
    // Skip empty daughters
    //
    if (daughterLogical->GetNoDaughters() == 0) continue;
    
    //
    // Tested already?
    //
    std::pair<std::set<const G4LogicalVolume *>::iterator,G4bool>
           there = tested.insert(daughterLogical);
    if (!there.second) continue;
 
    //
    // Recurse
    //
    G4GeomTestVolume vTest( daughter, logger, tolerance );
    vTest.TestRecursiveCylinder( nPhi, nZ, nRho,
                                 fracZ, fracRho, usePhi,
                                 slevel, depth );
  }
}

Referenced by TestRecursiveCylinder().

◆ TestRecursiveLine()

void G4GeomTestVolume::TestRecursiveLine	(	const G4ThreeVector &	p,
		const G4ThreeVector &	v,
		G4int	sLevel = `0`,
		G4int	depth = `-1`
	)

Definition at line 379 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 aren't a replica and we reached the requested
  // initial level of depth, test ourselves
  //
  if ( (!target->IsReplicated()) && (slevel==0) )
  {
    TestOneLine( p, v );
    ReportErrors();
  }
 
  //
  // Loop over unique daughters
  //
  std::set<const G4LogicalVolume *> tested;
 
  const G4LogicalVolume *logical = target->GetLogicalVolume();
  G4int nDaughter = logical->GetNoDaughters();
  G4int iDaughter;
  for( iDaughter=0; iDaughter<nDaughter; ++iDaughter )
  {
    const G4VPhysicalVolume *daughter =
          logical->GetDaughter(iDaughter);
    const G4LogicalVolume *daughterLogical =
          daughter->GetLogicalVolume();
    
    //
    // Skip empty daughters
    //
    if (daughterLogical->GetNoDaughters() == 0) continue;
    
    //
    // Tested already?
    //
    std::pair<std::set<const G4LogicalVolume *>::iterator,G4bool>
           there = tested.insert(daughterLogical);
    if (!there.second) continue;
 
    //
    // Recurse
    //
    G4GeomTestVolume vTest( daughter, logger, tolerance );
    vTest.TestRecursiveLine( p, v, slevel, depth );
  }
}

Referenced by TestRecursiveLine().

Member Data Documentation

◆ extent

G4VisExtent G4GeomTestVolume::extent

protected

Definition at line 165 of file G4GeomTestVolume.hh.

Referenced by TestCartGrid(), and TestCylinder().

◆ logger

G4GeomTestLogger* G4GeomTestVolume::logger

protected

Definition at line 163 of file G4GeomTestVolume.hh.

Referenced by ReportErrors(), TestOneLine(), TestRecursiveCartGrid(), TestRecursiveCylinder(), and TestRecursiveLine().

◆ overlaps

std::map<G4long,G4GeomTestOverlapList> G4GeomTestVolume::overlaps

protected

Definition at line 167 of file G4GeomTestVolume.hh.

Referenced by ClearErrors(), ReportErrors(), and TestOneLine().

◆ overshoots

std::map<G4long,G4GeomTestOvershootList> G4GeomTestVolume::overshoots

protected

Definition at line 172 of file G4GeomTestVolume.hh.

Referenced by ClearErrors(), ReportErrors(), and TestOneLine().

◆ target

const G4VPhysicalVolume* G4GeomTestVolume::target

protected

Definition at line 162 of file G4GeomTestVolume.hh.

Referenced by TestOneLine(), TestRecursiveCartGrid(), TestRecursiveCylinder(), and TestRecursiveLine().

◆ tolerance

G4double G4GeomTestVolume::tolerance

protected

Definition at line 164 of file G4GeomTestVolume.hh.

Referenced by GetTolerance(), SetTolerance(), TestOneLine(), TestRecursiveCartGrid(), TestRecursiveCylinder(), and TestRecursiveLine().

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

Public Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4GeomTestVolume()

◆ ~G4GeomTestVolume()

Member Function Documentation

◆ ClearErrors()

◆ GetTolerance()

◆ ReportErrors()

◆ SetTolerance()

◆ TestCartGrid()

◆ TestCartGridX()

◆ TestCartGridXYZ()

◆ TestCartGridY()

◆ TestCartGridZ()

◆ TestCylinder()

◆ TestOneLine()

◆ TestRecursiveCartGrid()

◆ TestRecursiveCylinder()

◆ TestRecursiveLine()

Member Data Documentation

◆ extent

◆ logger

◆ overlaps

◆ overshoots

◆ target

◆ tolerance