G4IntersectionSolid Class Reference

G4IntersectionSolid is a solid describing the Boolean intersection of two solids. More...

#include <G4IntersectionSolid.hh>

Inheritance diagram for G4IntersectionSolid:

Public Member Functions
	G4IntersectionSolid (const G4String &pName, G4VSolid *pSolidA, G4VSolid *pSolidB)
	G4IntersectionSolid (const G4String &pName, G4VSolid *pSolidA, G4VSolid *pSolidB, G4RotationMatrix *rotMatrix, const G4ThreeVector &transVector)
	G4IntersectionSolid (const G4String &pName, G4VSolid *pSolidA, G4VSolid *pSolidB, const G4Transform3D &transform)
	~G4IntersectionSolid () override=default
	G4IntersectionSolid (__void__ &)
	G4IntersectionSolid (const G4IntersectionSolid &rhs)
G4IntersectionSolid &	operator= (const G4IntersectionSolid &rhs)
G4GeometryType	GetEntityType () const override
G4VSolid *	Clone () const override
void	BoundingLimits (G4ThreeVector &pMin, G4ThreeVector &pMax) const override
G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pMin, G4double &pMax) const override
EInside	Inside (const G4ThreeVector &p) const override
G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const override
G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const override
G4double	DistanceToIn (const G4ThreeVector &p) const override
G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool *validNorm=nullptr, G4ThreeVector *n=nullptr) const override
G4double	DistanceToOut (const G4ThreeVector &p) const override
void	ComputeDimensions (G4VPVParameterisation *p, const G4int n, const G4VPhysicalVolume *pRep) override
void	DescribeYourselfTo (G4VGraphicsScene &scene) const override
G4Polyhedron *	CreatePolyhedron () const override
Public Member Functions inherited from G4BooleanSolid
	G4BooleanSolid (const G4String &pName, G4VSolid *pSolidA, G4VSolid *pSolidB)
	G4BooleanSolid (const G4String &pName, G4VSolid *pSolidA, G4VSolid *pSolidB, G4RotationMatrix *rotMatrix, const G4ThreeVector &transVector)
	G4BooleanSolid (const G4String &pName, G4VSolid *pSolidA, G4VSolid *pSolidB, const G4Transform3D &transform)
	~G4BooleanSolid () override
	G4BooleanSolid (__void__ &)
	G4BooleanSolid (const G4BooleanSolid &rhs)
G4BooleanSolid &	operator= (const G4BooleanSolid &rhs)
const G4VSolid *	GetConstituentSolid (G4int no) const override
G4VSolid *	GetConstituentSolid (G4int no) override
G4double	GetCubicVolume () override
G4double	GetSurfaceArea () override
G4Polyhedron *	GetPolyhedron () const override
std::ostream &	StreamInfo (std::ostream &os) const override
G4int	GetCubVolStatistics () const
void	SetCubVolStatistics (G4int st)
G4double	GetCubVolEpsilon () const
void	SetCubVolEpsilon (G4double ep)
G4int	GetAreaStatistics () const
void	SetAreaStatistics (G4int st)
G4double	GetAreaAccuracy () const
void	SetAreaAccuracy (G4double ep)
G4ThreeVector	GetPointOnSurface () const override
G4int	GetNumOfConstituents () const override
G4bool	IsFaceted () const override
Public Member Functions inherited from G4VSolid
	G4VSolid (const G4String &name)
virtual	~G4VSolid ()
	G4VSolid (const G4VSolid &rhs)
G4VSolid &	operator= (const G4VSolid &rhs)
G4bool	operator== (const G4VSolid &s) const
G4String	GetName () const
void	SetName (const G4String &name)
G4double	GetTolerance () const
void	DumpInfo () const
virtual G4VisExtent	GetExtent () const
virtual const G4DisplacedSolid *	GetDisplacedSolidPtr () const
virtual G4DisplacedSolid *	GetDisplacedSolidPtr ()
	G4VSolid (__void__ &)
G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const
G4double	EstimateSurfaceArea (G4int nStat, G4double epsilon) const

Additional Inherited Members
Static Public Member Functions inherited from G4BooleanSolid
static G4VBooleanProcessor *	GetExternalBooleanProcessor ()
static void	SetExternalBooleanProcessor (G4VBooleanProcessor *extProcessor)
Protected Member Functions inherited from G4BooleanSolid
void	GetListOfPrimitives (std::vector< std::pair< G4VSolid *, G4Transform3D > > &, const G4Transform3D &) const
G4Polyhedron *	StackPolyhedron (HepPolyhedronProcessor &, const G4VSolid *) const
Protected Member Functions inherited from G4VSolid
void	CalculateClippedPolygonExtent (G4ThreeVectorList &pPolygon, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const
void	ClipCrossSection (G4ThreeVectorList *pVertices, const G4int pSectionIndex, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const
void	ClipBetweenSections (G4ThreeVectorList *pVertices, const G4int pSectionIndex, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const
void	ClipPolygon (G4ThreeVectorList &pPolygon, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis) const
Protected Attributes inherited from G4BooleanSolid
G4VSolid *	fPtrSolidA = nullptr
G4VSolid *	fPtrSolidB = nullptr
G4double	fCubicVolume = -1.0
G4double	fSurfaceArea = -1.0
Protected Attributes inherited from G4VSolid
G4double	kCarTolerance
Static Protected Attributes inherited from G4BooleanSolid
static G4VBooleanProcessor *	fExternalBoolProcessor = nullptr

Detailed Description

G4IntersectionSolid is a solid describing the Boolean intersection of two solids.

Definition at line 50 of file G4IntersectionSolid.hh.

Constructor & Destructor Documentation

G4IntersectionSolid() [1/5]

G4IntersectionSolid::G4IntersectionSolid	(	const G4String &	pName,
		G4VSolid *	pSolidA,
		G4VSolid *	pSolidB )

Constructor of a Boolean intersection between two solids with no displacement.

Parameters

[in]	pName	The name of the Boolean composition.
[in]	pSolidA	Pointer to the first reference solid.
[in]	pSolidB	Pointer to the second solid to form the composition.

Definition at line 50 of file G4IntersectionSolid.cc.

  : G4BooleanSolid(pName,pSolidA,pSolidB)
{
} 

Referenced by Clone(), G4IntersectionSolid(), and operator=().

G4IntersectionSolid() [2/5]

G4IntersectionSolid::G4IntersectionSolid	(	const G4String &	pName,
		G4VSolid *	pSolidA,
		G4VSolid *	pSolidB,
		G4RotationMatrix *	rotMatrix,
		const G4ThreeVector &	transVector )

Constructor of a Boolean intersection between two solids with rotation and translation, used to transform the coordinate system of the second solid to the coordinate system of the first solid.

Parameters

[in]	pName	The name of the Boolean composition.
[in]	pSolidA	Pointer to the first reference solid.
[in]	pSolidB	Pointer to the second solid to form the composition.
[in]	rotMatrix	Pointer to the rotation vector.
[in]	transVector	The translation vector.

Definition at line 60 of file G4IntersectionSolid.cc.

  : G4BooleanSolid(pName,pSolidA,pSolidB,rotMatrix,transVector)
{
}

G4IntersectionSolid() [3/5]

G4IntersectionSolid::G4IntersectionSolid	(	const G4String &	pName,
		G4VSolid *	pSolidA,
		G4VSolid *	pSolidB,
		const G4Transform3D &	transform )

Constructor of a Boolean intersection between two solids with a transformation that moves the second solid from its desired position to its standard position.

Parameters

[in]	pName	The name of the Boolean composition.
[in]	pSolidA	Pointer to the first reference solid.
[in]	pSolidB	Pointer to the second solid to form the composition.
[in]	transform	The composed 3D transformation.

Definition at line 73 of file G4IntersectionSolid.cc.

  : G4BooleanSolid(pName,pSolidA,pSolidB,transform)
{
} 

~G4IntersectionSolid()

G4IntersectionSolid::~G4IntersectionSolid ( )

overridedefault

Default destructor.

G4IntersectionSolid() [4/5]

G4IntersectionSolid::G4IntersectionSolid

(

__void__ &

a

)

Fake default constructor for usage restricted to direct object persistency for clients requiring preallocation of memory for persistifiable objects.

Definition at line 86 of file G4IntersectionSolid.cc.

  : G4BooleanSolid(a)
{
}

G4IntersectionSolid() [5/5]

G4IntersectionSolid::G4IntersectionSolid ( const G4IntersectionSolid & rhs )

default

Copy constructor and assignment operator.

Member Function Documentation

BoundingLimits()

void G4IntersectionSolid::BoundingLimits ( G4ThreeVector & pMin, G4ThreeVector & pMax ) const

overridevirtual

Computes the bounding limits of the solid.

Parameters

[out]	pMin	The minimum bounding limit point.
[out]	pMax	The maximum bounding limit point.

Reimplemented from G4VSolid.

Definition at line 120 of file G4IntersectionSolid.cc.

{
  G4ThreeVector minA,maxA, minB,maxB;
  fPtrSolidA->BoundingLimits(minA,maxA);
  fPtrSolidB->BoundingLimits(minB,maxB);
 
  pMin.set(std::max(minA.x(),minB.x()),
           std::max(minA.y(),minB.y()),
           std::max(minA.z(),minB.z()));
 
  pMax.set(std::min(maxA.x(),maxB.x()),
           std::min(maxA.y(),maxB.y()),
           std::min(maxA.z(),maxB.z()));
 
  // Check correctness of the bounding box
  //
  if (pMin.x() >= pMax.x() || pMin.y() >= pMax.y() || pMin.z() >= pMax.z())
  {
    std::ostringstream message;
    message << "Bad bounding box (min >= max) for solid: "
            << GetName() << " !"
            << "\npMin = " << pMin
            << "\npMax = " << pMax;
    G4Exception("G4IntersectionSolid::BoundingLimits()", "GeomMgt0001",
                JustWarning, message);
    DumpInfo();
  }
}

CalculateExtent()

G4bool G4IntersectionSolid::CalculateExtent ( const EAxis pAxis, const G4VoxelLimits & pVoxelLimit, const G4AffineTransform & pTransform, G4double & pMin, G4double & pMax ) const

overridevirtual

Calculates the minimum and maximum extent of the solid, when under the specified transform, and within the specified limits.

Parameters

[in]	pAxis	The axis along which compute the extent.
[in]	pVoxelLimit	The limiting space dictated by voxels.
[in]	pTransform	The internal transformation applied to the solid.
[out]	pMin	The minimum extent value.
[out]	pMax	The maximum extent value.

Returns

True if the solid is intersected by the extent region.

Implements G4VSolid.

Definition at line 155 of file G4IntersectionSolid.cc.

{
  G4bool   retA, retB, out;
  G4double minA, minB, maxA, maxB; 
 
  retA = fPtrSolidA
          ->CalculateExtent( pAxis, pVoxelLimit, pTransform, minA, maxA);
  retB = fPtrSolidB
          ->CalculateExtent( pAxis, pVoxelLimit, pTransform, minB, maxB);
 
  if( retA && retB )
  {
    pMin = std::max( minA, minB ); 
    pMax = std::min( maxA, maxB );
    out  = (pMax > pMin); // true;
  }
  else
  {
    out = false;
  }
 
  return out; // It exists in this slice only if both exist in it.
}

Clone()

G4VSolid * G4IntersectionSolid::Clone ( ) const

overridevirtual

Makes a clone of the object for use in multi-treading.

Returns

A pointer to the new cloned allocated solid.

Reimplemented from G4VSolid.

Definition at line 524 of file G4IntersectionSolid.cc.

{
  return new G4IntersectionSolid(*this);
}

ComputeDimensions()

void G4IntersectionSolid::ComputeDimensions ( G4VPVParameterisation * p, const G4int n, const G4VPhysicalVolume * pRep )

overridevirtual

Throws an exception as paramterisations are not allowed for these solids.

Reimplemented from G4VSolid.

Definition at line 501 of file G4IntersectionSolid.cc.

{
  DumpInfo();
  G4Exception("G4IntersectionSolid::ComputeDimensions()",
              "GeomSolids0001", FatalException,
              "Method not applicable in this context!");
}

CreatePolyhedron()

G4Polyhedron * G4IntersectionSolid::CreatePolyhedron ( ) const

overridevirtual

Creates a Polyhedron used for Visualisation. It is the caller's responsibility to delete it. A null pointer means "not created".

Reimplemented from G4VSolid.

Definition at line 544 of file G4IntersectionSolid.cc.

{
  if (fExternalBoolProcessor == nullptr)
  {
    HepPolyhedronProcessor processor;
    // Stack components and components of components recursively
    // See G4BooleanSolid::StackPolyhedron
    G4Polyhedron* top = StackPolyhedron(processor, this);
    auto result = new G4Polyhedron(*top);
    if (processor.execute(*result))
    {
      return result;
    }
    return nullptr;
  }
  else
  {
    return fExternalBoolProcessor->Process(this);
  }
}

DescribeYourselfTo()

void G4IntersectionSolid::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

overridevirtual

Methods for creating graphical representations (i.e. for visualisation).

Implements G4VSolid.

Definition at line 534 of file G4IntersectionSolid.cc.

{
  scene.AddSolid (*this);
}

DistanceToIn() [1/2]

G4double G4IntersectionSolid::DistanceToIn ( const G4ThreeVector & p ) const

overridevirtual

Calculates the safety distance to the nearest surface of a shape from an outside point. The distance can be an underestimate.

Implements G4VSolid.

Definition at line 373 of file G4IntersectionSolid.cc.

{
#ifdef G4BOOLDEBUG
  if( Inside(p) == kInside )
  {
    G4cout << "WARNING - Invalid call in "
           << "G4IntersectionSolid::DistanceToIn(p)" << G4endl
           << "  Point p is inside !" << G4endl;
    G4cout << "          p = " << p << G4endl;
    G4cerr << "WARNING - Invalid call in "
           << "G4IntersectionSolid::DistanceToIn(p)" << G4endl
           << "  Point p is inside !" << G4endl;
    G4cerr << "          p = " << p << G4endl;
  }
#endif
  EInside sideA = fPtrSolidA->Inside(p) ;
  EInside sideB = fPtrSolidB->Inside(p) ;
  G4double dist=0.0 ;
 
  if( sideA != kInside && sideB != kOutside )
  {
    dist = fPtrSolidA->DistanceToIn(p) ;
  }
  else
  {
    if( sideB != kInside && sideA != kOutside )
    {
      dist = fPtrSolidB->DistanceToIn(p) ;
    }
    else
    {
      dist =  std::min(fPtrSolidA->DistanceToIn(p),
                       fPtrSolidB->DistanceToIn(p) ) ; 
    }
  }
  return dist ;
}

DistanceToIn() [2/2]

G4double G4IntersectionSolid::DistanceToIn ( const G4ThreeVector & p, const G4ThreeVector & v ) const

overridevirtual

Returns the distance along the normalised vector "v" to the shape, from the point at offset "p". If there is no intersection, return kInfinity. The first intersection resulting from leaving a surface/volume is discarded. Hence, it is tolerant of points on the surface of the shape.

Implements G4VSolid.

Definition at line 266 of file G4IntersectionSolid.cc.

{
  G4double dist = 0.0;
  if( Inside(p) == kInside )
  {
#ifdef G4BOOLDEBUG
    G4cout << "WARNING - Invalid call in "
           << "G4IntersectionSolid::DistanceToIn(p,v)" << G4endl
           << "  Point p is inside !" << G4endl;
    G4cout << "          p = " << p << G4endl;
    G4cout << "          v = " << v << G4endl;
    G4cerr << "WARNING - Invalid call in "
           << "G4IntersectionSolid::DistanceToIn(p,v)" << G4endl
           << "  Point p is inside !" << G4endl;
    G4cerr << "          p = " << p << G4endl;
    G4cerr << "          v = " << v << G4endl;
#endif
  }
  else // if( Inside(p) == kSurface ) 
  {
    EInside wA = fPtrSolidA->Inside(p);
    EInside wB = fPtrSolidB->Inside(p);
 
    G4ThreeVector pA = p,  pB = p;
    G4double      dA = 0., dA1=0., dA2=0.;
    G4double      dB = 0., dB1=0., dB2=0.;
    G4bool        doA = true, doB = true;
 
    static const std::size_t max_trials=10000;
    for (std::size_t trial=0; trial<max_trials; ++trial) 
    {
      if(doA) 
      {
        // find next valid range for A
 
        dA1 = 0.;
 
        if( wA != kInside ) 
        {
          dA1 = fPtrSolidA->DistanceToIn(pA, v);
 
          if( dA1 == kInfinity ) { return kInfinity; }
        
          pA += dA1*v;
        }
        dA2 = dA1 + fPtrSolidA->DistanceToOut(pA, v);
      }
      dA1 += dA;
      dA2 += dA;
 
      if(doB) 
      {
        // find next valid range for B
 
        dB1 = 0.;
        if(wB != kInside) 
        {
          dB1 = fPtrSolidB->DistanceToIn(pB, v);
 
          if(dB1 == kInfinity) { return kInfinity; }
        
          pB += dB1*v;
        }
        dB2 = dB1 + fPtrSolidB->DistanceToOut(pB, v);
      }
      dB1 += dB;
      dB2 += dB;
 
       // check if they overlap
 
      if( dA1 < dB1 ) 
      {
        if( dB1 < dA2 ) { return dB1; }
 
        dA   = dA2;
        pA   = p + dA*v;  // continue from here
        wA   = kSurface;
        doA  = true;
        doB  = false;
      }
      else 
      {
        if( dA1 < dB2 ) { return dA1; }
 
        dB   = dB2;
        pB   = p + dB*v;  // continue from here
        wB   = kSurface;
        doB  = true;
        doA  = false;
      }
    }
  }
#ifdef G4BOOLDEBUG
  G4Exception("G4IntersectionSolid::DistanceToIn(p,v)",
              "GeomSolids0001", JustWarning,
              "Reached maximum number of iterations! Returning zero.");
#endif
  return dist ;  
}

DistanceToOut() [1/2]

G4double G4IntersectionSolid::DistanceToOut ( const G4ThreeVector & p ) const

overridevirtual

Calculates the safety distance to the nearest surface of a shape from an inside point "p". The distance can be an underestimate.

Implements G4VSolid.

Definition at line 475 of file G4IntersectionSolid.cc.

{
#ifdef G4BOOLDEBUG
  if( Inside(p) == kOutside )
  {
    G4cout << "WARNING - Invalid call in "
           << "G4IntersectionSolid::DistanceToOut(p)" << G4endl
           << "  Point p is outside !" << G4endl;
    G4cout << "          p = " << p << G4endl;
    G4cerr << "WARNING - Invalid call in "
           << "G4IntersectionSolid::DistanceToOut(p)" << G4endl
           << "  Point p is outside !" << G4endl;
    G4cerr << "          p = " << p << G4endl;
  }
#endif
 
  return std::min(fPtrSolidA->DistanceToOut(p),
                  fPtrSolidB->DistanceToOut(p) ) ; 
 
}

DistanceToOut() [2/2]

G4double G4IntersectionSolid::DistanceToOut ( const G4ThreeVector & p, const G4ThreeVector & v, const G4bool calcNorm = false, G4bool * validNorm = nullptr, G4ThreeVector * n = nullptr ) const

overridevirtual

Returns the distance along the normalised vector "v" to the shape, from a point at an offset "p" inside or on the surface of the shape. Intersections with surfaces, when the point is < Tolerance/2 from a surface must be ignored. Must be called as solid.DistanceToOut(p,v) or by specifying all the parameters.

Parameters

[in]	p	The reference point in space.
[in]	v	The normalised direction.
[in]	calcNorm	Flag to enable the normal computation or not.
[out]	validNorm	Set to true if the solid lies entirely behind or on the exiting surface (calcNorm must be true, otherwise it is unused).
[out]	n	The exiting outwards normal vector (undefined Magnitude). (calcNorm must be true, otherwise it is unused).

Returns

The distance value to exit the volume.

Implements G4VSolid.

Definition at line 416 of file G4IntersectionSolid.cc.

{
  G4bool         validNormA, validNormB;
  G4ThreeVector  nA, nB;
 
#ifdef G4BOOLDEBUG
  if( Inside(p) == kOutside )
  {
    G4cout << "Position:"  << G4endl << G4endl;
    G4cout << "p.x() = "   << p.x()/mm << " mm" << G4endl;
    G4cout << "p.y() = "   << p.y()/mm << " mm" << G4endl;
    G4cout << "p.z() = "   << p.z()/mm << " mm" << G4endl << G4endl;
    G4cout << "Direction:" << G4endl << G4endl;
    G4cout << "v.x() = "   << v.x() << G4endl;
    G4cout << "v.y() = "   << v.y() << G4endl;
    G4cout << "v.z() = "   << v.z() << G4endl << G4endl;
    G4cout << "WARNING - Invalid call in "
           << "G4IntersectionSolid::DistanceToOut(p,v)" << G4endl
           << "  Point p is outside !" << G4endl;
    G4cout << "          p = " << p << G4endl;
    G4cout << "          v = " << v << G4endl;
    G4cerr << "WARNING - Invalid call in "
           << "G4IntersectionSolid::DistanceToOut(p,v)" << G4endl
           << "  Point p is outside !" << G4endl;
    G4cerr << "          p = " << p << G4endl;
    G4cerr << "          v = " << v << G4endl;
  }
#endif
  G4double distA = fPtrSolidA->DistanceToOut(p,v,calcNorm,&validNormA,&nA) ;
  G4double distB = fPtrSolidB->DistanceToOut(p,v,calcNorm,&validNormB,&nB) ;
 
  G4double dist = std::min(distA,distB) ; 
 
  if( calcNorm )
  {
    if ( distA < distB )
    {
       *validNorm = validNormA;
       *n =         nA;
    }
    else
    {   
       *validNorm = validNormB;
       *n =         nB;
    }
  }
 
  return dist ; 
}

GetEntityType()

G4GeometryType G4IntersectionSolid::GetEntityType ( ) const

overridevirtual

Returns the type ID, "G4IntersectionSolid" of the solid.

Reimplemented from G4BooleanSolid.

Definition at line 515 of file G4IntersectionSolid.cc.

{
  return {"G4IntersectionSolid"};
}

Inside()

EInside G4IntersectionSolid::Inside ( const G4ThreeVector & p ) const

overridevirtual

Returns if the given point "p" is inside or not the solid.

Implements G4VSolid.

Definition at line 187 of file G4IntersectionSolid.cc.

{
  EInside positionA = fPtrSolidA->Inside(p);
  if(positionA == kOutside) { return positionA; } // outside A
 
  EInside positionB = fPtrSolidB->Inside(p);
  if(positionA == kInside) { return positionB; }
 
  if(positionB == kOutside) { return positionB; } // outside B
 
  return kSurface;                            // surface A & B
}

Referenced by DistanceToIn(), DistanceToIn(), DistanceToOut(), and DistanceToOut().

operator=()

G4IntersectionSolid & G4IntersectionSolid::operator=

(

const G4IntersectionSolid &

rhs

)

Definition at line 102 of file G4IntersectionSolid.cc.

{
  // Check assignment to self
  //
  if (this == &rhs)  { return *this; }
 
  // Copy base class data
  //
  G4BooleanSolid::operator=(rhs);
 
  return *this;
}  

SurfaceNormal()

G4ThreeVector G4IntersectionSolid::SurfaceNormal ( const G4ThreeVector & p ) const

overridevirtual

Returns the outwards pointing unit normal of the shape for the surface closest to the point at offset "p".

Implements G4VSolid.

Definition at line 204 of file G4IntersectionSolid.cc.

{
  G4ThreeVector normal;
  EInside insideA, insideB;
  
  insideA = fPtrSolidA->Inside(p);
  insideB = fPtrSolidB->Inside(p);
 
#ifdef G4BOOLDEBUG
  if( (insideA == kOutside) || (insideB == kOutside) )
  {
    G4cout << "WARNING - Invalid call in "
           << "G4IntersectionSolid::SurfaceNormal(p)" << G4endl
           << "  Point p is outside !" << G4endl;
    G4cout << "          p = " << p << G4endl;
    G4cerr << "WARNING - Invalid call in "
           << "G4IntersectionSolid::SurfaceNormal(p)" << G4endl
           << "  Point p is outside !" << G4endl;
    G4cerr << "          p = " << p << G4endl;
  }
#endif
 
  // On the surface of both is difficult ... treat it like on A now!
  //
  if( insideA == kSurface )
  {
    normal = fPtrSolidA->SurfaceNormal(p) ;
  }
  else if( insideB == kSurface )
  {
    normal = fPtrSolidB->SurfaceNormal(p) ;
  } 
  else  // We are on neither surface, so we should generate an exception
  {
    if(fPtrSolidA->DistanceToOut(p) <= fPtrSolidB->DistanceToOut(p) )
    { 
      normal= fPtrSolidA->SurfaceNormal(p) ;   
    }
    else
    {
      normal= fPtrSolidB->SurfaceNormal(p) ;   
    }
#ifdef G4BOOLDEBUG
    G4cout << "WARNING - Invalid call in "
           << "G4IntersectionSolid::SurfaceNormal(p)" << G4endl
           << "  Point p is out of surface !" << G4endl;
    G4cout << "          p = " << p << G4endl;
    G4cerr << "WARNING - Invalid call in "
           << "G4IntersectionSolid::SurfaceNormal(p)" << G4endl
           << "  Point p is out of surface !" << G4endl;
    G4cerr << "          p = " << p << G4endl;
#endif
    }
 
  return normal;
}

---

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

• G4IntersectionSolid.hh
• G4IntersectionSolid.cc