#include <G4SubtractionSolid.hh>

Inheritance diagram for G4SubtractionSolid:

Collaboration 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)

virtual	~G4SubtractionSolid ()

G4GeometryType	GetEntityType () const

G4VSolid *	Clone () const

	G4SubtractionSolid (__void__ &)

	G4SubtractionSolid (const G4SubtractionSolid &rhs)

G4SubtractionSolid &	operator= (const G4SubtractionSolid &rhs)

void	Extent (G4ThreeVector &pMin, G4ThreeVector &pMax) const

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

EInside	Inside (const G4ThreeVector &p) const

G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const

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

G4double	DistanceToIn (const G4ThreeVector &p) const

G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool validNorm=0, G4ThreeVector n=0) const

G4double	DistanceToOut (const G4ThreeVector &p) const

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

void	DescribeYourselfTo (G4VGraphicsScene &scene) const

G4Polyhedron *	CreatePolyhedron () const

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)

virtual	~G4BooleanSolid ()

virtual const G4VSolid *	GetConstituentSolid (G4int no) const

virtual G4VSolid *	GetConstituentSolid (G4int no)

G4double	GetCubicVolume ()

G4double	GetSurfaceArea ()

virtual G4Polyhedron *	GetPolyhedron () const

std::ostream &	StreamInfo (std::ostream &os) const

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

	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
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

G4VSolid *	fPtrSolidB

Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Detailed Description

Definition at line 53 of file G4SubtractionSolid.hh.

Constructor & Destructor Documentation

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

Definition at line 60 of file G4SubtractionSolid.cc.

   : G4BooleanSolid(pName,pSolidA,pSolidB)
 {
 }

Here is the caller graph for this function:

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

Definition at line 71 of file G4SubtractionSolid.cc.

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

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

Definition at line 84 of file G4SubtractionSolid.cc.

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

G4SubtractionSolid::~G4SubtractionSolid ( )

virtual

Definition at line 106 of file G4SubtractionSolid.cc.

107 {

108 }

G4SubtractionSolid::G4SubtractionSolid ( __void__ & a )

Definition at line 97 of file G4SubtractionSolid.cc.

   : G4BooleanSolid(a)
 {
 }

G4SubtractionSolid::G4SubtractionSolid ( const G4SubtractionSolid & rhs )

Definition at line 114 of file G4SubtractionSolid.cc.

   : G4BooleanSolid (rhs)
 {
 }

Member Function Documentation

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

virtual

Implements G4VSolid.

Definition at line 169 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 );
 }

Here is the call graph for this function:

G4VSolid * G4SubtractionSolid::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 552 of file G4SubtractionSolid.cc.

 {
   return new G4SubtractionSolid(*this);
 }

Here is the call graph for this function:

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

virtual

Reimplemented from G4VSolid.

Definition at line 562 of file G4SubtractionSolid.cc.

565 {

566 }

G4Polyhedron * G4SubtractionSolid::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 583 of file G4SubtractionSolid.cc.

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

Here is the call graph for this function:

void G4SubtractionSolid::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtual

Implements G4VSolid.

Definition at line 573 of file G4SubtractionSolid.cc.

 {
   scene.AddSolid (*this);
 }

Here is the call graph for this function:

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

virtual

Implements G4VSolid.

Definition at line 284 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 ;
 }

Here is the call graph for this function:

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

virtual

Implements G4VSolid.

Definition at line 424 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; 
 }

Here is the call graph for this function:

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

virtual

Implements G4VSolid.

Definition at line 460 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;
 }

Here is the call graph for this function:

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

virtual

Implements G4VSolid.

Definition at line 514 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; 
 }

Here is the call graph for this function:

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

virtual

Reimplemented from G4VSolid.

Definition at line 142 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->Extent(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::Extent()", "GeomMgt0001",
                 JustWarning, message);
     DumpInfo();
   }
 }

Here is the call graph for this function:

G4GeometryType G4SubtractionSolid::GetEntityType ( ) const

virtual

Reimplemented from G4BooleanSolid.

Definition at line 543 of file G4SubtractionSolid.cc.

 {
   return G4String("G4SubtractionSolid");
 }

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

virtual

Implements G4VSolid.

Definition at line 186 of file G4SubtractionSolid.cc.

 {
   EInside positionA = fPtrSolidA->Inside(p);
   if (positionA == kOutside) return kOutside;
 
   EInside positionB = fPtrSolidB->Inside(p);
   
   if(positionA == kInside && positionB == kOutside)
   {
     return kInside ;
   }
   else
   {
     static const G4double rtol
       = 1000.0*G4GeometryTolerance::GetInstance()->GetRadialTolerance();
     if(( positionA == kInside && positionB == kSurface) ||
        ( positionB == kOutside && positionA == kSurface) ||
        ( positionA == kSurface && positionB == kSurface &&
          ( fPtrSolidA->SurfaceNormal(p) - 
            fPtrSolidB->SurfaceNormal(p) ).mag2() > rtol ) )
     {
       return kSurface;
     }
     else
     {
       return kOutside;
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4SubtractionSolid & G4SubtractionSolid::operator= ( const G4SubtractionSolid & rhs )

Definition at line 124 of file G4SubtractionSolid.cc.

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

Here is the call graph for this function:

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

virtual

Implements G4VSolid.

Definition at line 221 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;
 }

Here is the call graph for this function:

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

source/geant4.10.03.p02/source/geometry/solids/Boolean/include/G4SubtractionSolid.hh
source/geant4.10.03.p02/source/geometry/solids/Boolean/src/G4SubtractionSolid.cc

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation