G4SubtractionSolid Class Reference

#include <G4SubtractionSolid.hh>

Inheritance diagram for G4SubtractionSolid:

Public Member Functions
	G4SubtractionSolid (const G4String &pName, G4VSolid *pSolidA, G4VSolid *pSolidB)
	G4SubtractionSolid (const G4String &pName, G4VSolid *pSolidA, G4VSolid *pSolidB, G4RotationMatrix *rotMatrix, const G4ThreeVector &transVector)
	G4SubtractionSolid (const G4String &pName, G4VSolid *pSolidA, G4VSolid *pSolidB, const G4Transform3D &transform)
	~G4SubtractionSolid () override
G4GeometryType	GetEntityType () const override
G4VSolid *	Clone () const override
	G4SubtractionSolid (__void__ &)
	G4SubtractionSolid (const G4SubtractionSolid &rhs)
G4SubtractionSolid &	operator= (const G4SubtractionSolid &rhs)
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
G4double	GetCubicVolume () final
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
const G4VSolid *	GetConstituentSolid (G4int no) const override
G4VSolid *	GetConstituentSolid (G4int no) override
G4double	GetSurfaceArea () override
G4Polyhedron *	GetPolyhedron () const override
std::ostream &	StreamInfo (std::ostream &os) const override
G4int	GetCubVolStatistics () const
G4double	GetCubVolEpsilon () const
void	SetCubVolStatistics (G4int st)
void	SetCubVolEpsilon (G4double ep)
G4int	GetAreaStatistics () const
G4double	GetAreaAccuracy () const
void	SetAreaStatistics (G4int st)
void	SetAreaAccuracy (G4double ep)
G4ThreeVector	GetPointOnSurface () const override
	G4BooleanSolid (__void__ &)
	G4BooleanSolid (const G4BooleanSolid &rhs)
G4BooleanSolid &	operator= (const G4BooleanSolid &rhs)
Public Member Functions inherited from G4VSolid
	G4VSolid (const G4String &name)
virtual	~G4VSolid ()
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__ &)
	G4VSolid (const G4VSolid &rhs)
G4VSolid &	operator= (const G4VSolid &rhs)
G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const
G4double	EstimateSurfaceArea (G4int nStat, G4double ell) const

Additional Inherited Members
Static Public Member Functions inherited from G4BooleanSolid
static void	SetExternalBooleanProcessor (G4VBooleanProcessor *extProcessor)
static G4VBooleanProcessor *	GetExternalBooleanProcessor ()
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

Definition at line 46 of file G4SubtractionSolid.hh.

Constructor & Destructor Documentation

G4SubtractionSolid() [1/5]

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

Definition at line 54 of file G4SubtractionSolid.cc.

  : G4BooleanSolid(pName,pSolidA,pSolidB)
{
}

Referenced by Clone().

G4SubtractionSolid() [2/5]

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

Definition at line 65 of file G4SubtractionSolid.cc.

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

G4SubtractionSolid() [3/5]

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

Definition at line 78 of file G4SubtractionSolid.cc.

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

~G4SubtractionSolid()

G4SubtractionSolid::~G4SubtractionSolid ( )

overridedefault

G4SubtractionSolid() [4/5]

G4SubtractionSolid::G4SubtractionSolid

(

__void__ &

a

)

Definition at line 91 of file G4SubtractionSolid.cc.

  : G4BooleanSolid(a)
{
}

G4SubtractionSolid() [5/5]

G4SubtractionSolid::G4SubtractionSolid ( const G4SubtractionSolid & rhs )

default

Member Function Documentation

BoundingLimits()

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

overridevirtual

Reimplemented from G4VSolid.

Definition at line 131 of file G4SubtractionSolid.cc.

{
  // Since it is unclear how the shape of the first solid will be changed
  // after subtraction, just return its original bounding box.
  //
  fPtrSolidA->BoundingLimits(pMin,pMax);
 
  // 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("G4SubtractionSolid::BoundingLimits()", "GeomMgt0001",
                JustWarning, message);
    DumpInfo();
  }
}

CalculateExtent()

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

overridevirtual

Implements G4VSolid.

Definition at line 159 of file G4SubtractionSolid.cc.

{
  // Since we cannot be sure how much the second solid subtracts 
  // from the first, we must use the first solid's extent!
 
  return fPtrSolidA->CalculateExtent( pAxis, pVoxelLimit, 
                                      pTransform, pMin, pMax );
}

Clone()

G4VSolid * G4SubtractionSolid::Clone ( ) const

overridevirtual

Reimplemented from G4VSolid.

Definition at line 531 of file G4SubtractionSolid.cc.

{
  return new G4SubtractionSolid(*this);
}

ComputeDimensions()

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

overridevirtual

Reimplemented from G4VSolid.

Definition at line 541 of file G4SubtractionSolid.cc.

{
}

CreatePolyhedron()

G4Polyhedron * G4SubtractionSolid::CreatePolyhedron ( ) const

overridevirtual

Reimplemented from G4VSolid.

Definition at line 561 of file G4SubtractionSolid.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;
    }
    else
    {
      return nullptr;
    }
  }
  else
  {
    return fExternalBoolProcessor
           ->Subtraction(GetConstituentSolid(0)->GetPolyhedron(),
                         GetConstituentSolid(1)->GetPolyhedron());
  }
}

DescribeYourselfTo()

void G4SubtractionSolid::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

overridevirtual

Implements G4VSolid.

Definition at line 552 of file G4SubtractionSolid.cc.

{
  scene.AddSolid (*this);
}

DistanceToIn() [1/2]

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

overridevirtual

Implements G4VSolid.

Definition at line 403 of file G4SubtractionSolid.cc.

{
  G4double dist = 0.0;
 
#ifdef G4BOOLDEBUG
  if( Inside(p) == kInside )
  {
    G4cout << "WARNING - Invalid call in "
           << "G4SubtractionSolid::DistanceToIn(p)" << G4endl
           << "  Point p is inside !" << G4endl;
    G4cout << "          p = " << p << G4endl;
    G4cerr << "WARNING - Invalid call in "
           << "G4SubtractionSolid::DistanceToIn(p)" << G4endl
           << "  Point p is inside !" << G4endl;
    G4cerr << "          p = " << p << G4endl;
  }
#endif
 
  if( ( fPtrSolidA->Inside(p) != kOutside) &&   // case 1
      ( fPtrSolidB->Inside(p) != kOutside)    )
  {
    dist = fPtrSolidB->DistanceToOut(p);
  }
  else
  {
    dist = fPtrSolidA->DistanceToIn(p); 
  }
  
  return dist; 
}

DistanceToIn() [2/2]

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

overridevirtual

Implements G4VSolid.

Definition at line 263 of file G4SubtractionSolid.cc.

{
  G4double dist = 0.0, dist2 = 0.0, disTmp = 0.0;
    
#ifdef G4BOOLDEBUG
  if( Inside(p) == kInside )
  {
    G4cout << "WARNING - Invalid call in "
           << "G4SubtractionSolid::DistanceToIn(p,v)" << G4endl
           << "  Point p is inside !" << G4endl;
    G4cout << "          p = " << p << G4endl;
    G4cout << "          v = " << v << G4endl;
    G4cerr << "WARNING - Invalid call in "
           << "G4SubtractionSolid::DistanceToIn(p,v)" << G4endl
           << "  Point p is inside !" << G4endl;
    G4cerr << "          p = " << p << G4endl;
    G4cerr << "          v = " << v << G4endl;
  }
#endif
 
    // if( // ( fPtrSolidA->Inside(p) != kOutside) &&  // case1:p in both A&B 
    if ( fPtrSolidB->Inside(p) != kOutside )   // start: out of B
    {
      dist = fPtrSolidB->DistanceToOut(p,v) ; // ,calcNorm,validNorm,n) ;
      
      if( fPtrSolidA->Inside(p+dist*v) != kInside )
      {
        G4int count1=0;
        do   // Loop checking, 13.08.2015, G.Cosmo
        {
          disTmp = fPtrSolidA->DistanceToIn(p+dist*v,v) ;
 
          if(disTmp == kInfinity)
          {  
            return kInfinity ;
          }
          dist += disTmp ;
 
          if( Inside(p+dist*v) == kOutside )
          {
            disTmp = fPtrSolidB->DistanceToOut(p+dist*v,v) ;
            dist2 = dist+disTmp;
            if (dist == dist2)  { return dist; }   // no progress
            dist = dist2 ;
            ++count1;
            if( count1 > 1000 )  // Infinite loop detected
            {
              G4String nameB = fPtrSolidB->GetName();
              if(fPtrSolidB->GetEntityType()=="G4DisplacedSolid")
              {
                nameB = (dynamic_cast<G4DisplacedSolid*>(fPtrSolidB))
                        ->GetConstituentMovedSolid()->GetName();
              }
              std::ostringstream message;
              message << "Illegal condition caused by solids: "
                      << fPtrSolidA->GetName() << " and " << nameB << G4endl;
              message.precision(16);
              message << "Looping detected in point " << p+dist*v
                      << ", from original point " << p
                      << " and direction " << v << G4endl
                      << "Computed candidate distance: " << dist << "*mm. ";
              message.precision(6);
              DumpInfo();
              G4Exception("G4SubtractionSolid::DistanceToIn(p,v)",
                          "GeomSolids1001", JustWarning, message,
                          "Returning candidate distance.");
              return dist;
            }
          }    
        }
        while( Inside(p+dist*v) == kOutside ) ;
      }
    }
    else // p outside A, start in A
    {
      dist = fPtrSolidA->DistanceToIn(p,v) ;
 
      if( dist == kInfinity ) // past A, hence past A\B
      {
        return kInfinity ;
      }
      else
      {
        G4int count2=0;
        while( Inside(p+dist*v) == kOutside )  // pushing loop
        {
          disTmp = fPtrSolidB->DistanceToOut(p+dist*v,v) ;
          dist += disTmp ;
 
          if( Inside(p+dist*v) == kOutside )
          { 
            disTmp = fPtrSolidA->DistanceToIn(p+dist*v,v) ;
 
            if(disTmp == kInfinity) // past A, hence past A\B
            {  
              return kInfinity ;
            }                 
            dist2 = dist+disTmp;
            if (dist == dist2)  { return dist; }   // no progress
            dist = dist2 ;
            ++count2;
            if( count2 > 1000 )  // Infinite loop detected
            {
              G4String nameB = fPtrSolidB->GetName();
              if(fPtrSolidB->GetEntityType()=="G4DisplacedSolid")
              {
                nameB = (dynamic_cast<G4DisplacedSolid*>(fPtrSolidB))
                        ->GetConstituentMovedSolid()->GetName();
              }
              std::ostringstream message;
              message << "Illegal condition caused by solids: "
                      << fPtrSolidA->GetName() << " and " << nameB << G4endl;
              message.precision(16);
              message << "Looping detected in point " << p+dist*v
                      << ", from original point " << p
                      << " and direction " << v << G4endl
                      << "Computed candidate distance: " << dist << "*mm. ";
              message.precision(6);
              DumpInfo();
              G4Exception("G4SubtractionSolid::DistanceToIn(p,v)",
                          "GeomSolids1001", JustWarning, message,
                          "Returning candidate distance.");
              return dist;
            }
          }
        }    // Loop checking, 13.08.2015, G.Cosmo
      }
    }
  
  return dist ;
}

DistanceToOut() [1/2]

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

overridevirtual

Implements G4VSolid.

Definition at line 493 of file G4SubtractionSolid.cc.

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

DistanceToOut() [2/2]

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

overridevirtual

Implements G4VSolid.

Definition at line 439 of file G4SubtractionSolid.cc.

{
#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 "
             << "G4SubtractionSolid::DistanceToOut(p,v)" << G4endl
             << "  Point p is outside !" << G4endl;
      G4cout << "          p = " << p << G4endl;
      G4cout << "          v = " << v << G4endl;
      G4cerr << "WARNING - Invalid call in "
             << "G4SubtractionSolid::DistanceToOut(p,v)" << G4endl
             << "  Point p is outside !" << G4endl;
      G4cerr << "          p = " << p << G4endl;
      G4cerr << "          v = " << v << G4endl;
    }
#endif
 
    G4double distout;
    G4double distA = fPtrSolidA->DistanceToOut(p,v,calcNorm,validNorm,n) ;
    G4double distB = fPtrSolidB->DistanceToIn(p,v) ;
    if(distB < distA)
    {
      if(calcNorm)
      {
        *n = -(fPtrSolidB->SurfaceNormal(p+distB*v)) ;
        *validNorm = false ;
      }
      distout= distB ;
    }
    else
    {
      distout= distA ; 
    } 
    return distout;
}

GetCubicVolume()

G4double G4SubtractionSolid::GetCubicVolume ( )

finalvirtual

Reimplemented from G4BooleanSolid.

Definition at line 592 of file G4SubtractionSolid.cc.

{
  if( fCubicVolume != -1.0 )
  {
    return fCubicVolume;
  }
 
  G4double cubVolumeA = fPtrSolidA->GetCubicVolume();
 
  G4ThreeVector bminA, bmaxA, bminB, bmaxB;
  fPtrSolidA->BoundingLimits(bminA, bmaxA);
  fPtrSolidB->BoundingLimits(bminB, bmaxB);
  G4double intersection = 0.;
  G4bool canIntersect =
     bminA.x() < bmaxB.x() && bminA.y() < bmaxB.y() && bminA.z() < bmaxB.z() &&
     bminB.x() < bmaxA.x() && bminB.y() < bmaxA.y() && bminB.z() < bmaxA.z();
  if ( canIntersect )
  {
    G4IntersectionSolid intersectVol( "Temporary-Intersection-for-Subtraction",
                                      fPtrSolidA, fPtrSolidB );
    intersectVol.SetCubVolStatistics(100000);
    intersection = intersectVol.GetCubicVolume();
  }
 
  fCubicVolume = cubVolumeA - intersection;
  if (fCubicVolume < 0.01*cubVolumeA) fCubicVolume = G4VSolid::GetCubicVolume();
 
  return fCubicVolume;
}

GetEntityType()

G4GeometryType G4SubtractionSolid::GetEntityType ( ) const

overridevirtual

Reimplemented from G4BooleanSolid.

Definition at line 522 of file G4SubtractionSolid.cc.

{
  return {"G4SubtractionSolid"};
}

Inside()

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

overridevirtual

Implements G4VSolid.

Definition at line 176 of file G4SubtractionSolid.cc.

{
  EInside positionA = fPtrSolidA->Inside(p);
  if (positionA == kOutside) return positionA; // outside A
 
  EInside positionB = fPtrSolidB->Inside(p);
  if (positionB == kOutside) return positionA;
 
  if (positionB == kInside) return kOutside;
  if (positionA == kInside) return kSurface; // surface B
 
  // Point is on both surfaces
  //
  static const G4double rtol = 1000*kCarTolerance;
 
  return ((fPtrSolidA->SurfaceNormal(p) -
           fPtrSolidB->SurfaceNormal(p)).mag2() > rtol) ? kSurface : kOutside;
}

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

operator=()

G4SubtractionSolid & G4SubtractionSolid::operator=

(

const G4SubtractionSolid &

rhs

)

Definition at line 113 of file G4SubtractionSolid.cc.

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

SurfaceNormal()

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

overridevirtual

Implements G4VSolid.

Definition at line 200 of file G4SubtractionSolid.cc.

{
  G4ThreeVector normal;
 
  EInside InsideA = fPtrSolidA->Inside(p);
  EInside InsideB = fPtrSolidB->Inside(p); 
 
  if( InsideA == kOutside )
  {
#ifdef G4BOOLDEBUG
    G4cout << "WARNING - Invalid call [1] in "
           << "G4SubtractionSolid::SurfaceNormal(p)" << G4endl
           << "  Point p is outside !" << G4endl;
    G4cout << "          p = " << p << G4endl;
    G4cerr << "WARNING - Invalid call [1] in "
           << "G4SubtractionSolid::SurfaceNormal(p)" << G4endl
           << "  Point p is outside !" << G4endl;
    G4cerr << "          p = " << p << G4endl;
#endif
    normal = fPtrSolidA->SurfaceNormal(p) ;
  }
  else if( InsideA == kSurface && 
           InsideB != kInside      ) 
  {
    normal = fPtrSolidA->SurfaceNormal(p) ;
  }
  else if( InsideA == kInside && 
           InsideB != kOutside    )
  {
    normal = -fPtrSolidB->SurfaceNormal(p) ;
  }
  else 
  {
    if ( fPtrSolidA->DistanceToOut(p) <= fPtrSolidB->DistanceToIn(p) )
    {
      normal = fPtrSolidA->SurfaceNormal(p) ;
    }
    else
    {
      normal = -fPtrSolidB->SurfaceNormal(p) ;
    }
#ifdef G4BOOLDEBUG
    if(Inside(p) == kInside)
    {
      G4cout << "WARNING - Invalid call [2] in "
             << "G4SubtractionSolid::SurfaceNormal(p)" << G4endl
             << "  Point p is inside !" << G4endl;
      G4cout << "          p = " << p << G4endl;
      G4cerr << "WARNING - Invalid call [2] in "
             << "G4SubtractionSolid::SurfaceNormal(p)" << G4endl
             << "  Point p is inside !" << G4endl;
      G4cerr << "          p = " << p << G4endl;
    }
#endif
  }
  return normal;
}

---

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

• G4SubtractionSolid.hh
• G4SubtractionSolid.cc