#include <G4BooleanSolid.hh>

Inheritance diagram for G4BooleanSolid:

Collaboration diagram for G4BooleanSolid:

Public Member Functions
	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 G4GeometryType	GetEntityType () const

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

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

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

virtual EInside	Inside (const G4ThreeVector &p) const =0

virtual G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const =0

virtual G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const =0

virtual G4double	DistanceToIn (const G4ThreeVector &p) const =0

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

virtual G4double	DistanceToOut (const G4ThreeVector &p) const =0

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

virtual G4VSolid *	Clone () const

void	DumpInfo () const

virtual void	DescribeYourselfTo (G4VGraphicsScene &scene) const =0

virtual G4VisExtent	GetExtent () const

virtual G4Polyhedron *	CreatePolyhedron () 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

Protected Member Functions
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
G4VSolid *	fPtrSolidA

G4VSolid *	fPtrSolidB

Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Detailed Description

Definition at line 51 of file G4BooleanSolid.hh.

Constructor & Destructor Documentation

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

Definition at line 61 of file G4BooleanSolid.cc.

                                                       :
   G4VSolid(pName), fStatistics(1000000), fCubVolEpsilon(0.001),
   fAreaAccuracy(-1.), fCubicVolume(0.), fSurfaceArea(0.),
   fRebuildPolyhedron(false), fpPolyhedron(0), fPrimitivesSurfaceArea(0.),
   createdDisplacedSolid(false)
 {
   fPtrSolidA = pSolidA ;
   fPtrSolidB = pSolidB ;
 }

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

Definition at line 77 of file G4BooleanSolid.cc.

                                                                       :
   G4VSolid(pName), fStatistics(1000000), fCubVolEpsilon(0.001),
   fAreaAccuracy(-1.), fCubicVolume(0.), fSurfaceArea(0.),
   fRebuildPolyhedron(false), fpPolyhedron(0), fPrimitivesSurfaceArea(0.),
   createdDisplacedSolid(true)
 {
   fPtrSolidA = pSolidA ;
   fPtrSolidB = new G4DisplacedSolid("placedB",pSolidB,rotMatrix,transVector) ;
 }

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

Definition at line 95 of file G4BooleanSolid.cc.

                                                                     :
   G4VSolid(pName), fStatistics(1000000), fCubVolEpsilon(0.001),
   fAreaAccuracy(-1.), fCubicVolume(0.), fSurfaceArea(0.),
   fRebuildPolyhedron(false), fpPolyhedron(0), fPrimitivesSurfaceArea(0.),
   createdDisplacedSolid(true)
 {
   fPtrSolidA = pSolidA ;
   fPtrSolidB = new G4DisplacedSolid("placedB",pSolidB,transform) ;
 }

G4BooleanSolid::~G4BooleanSolid ( )

virtual

Definition at line 126 of file G4BooleanSolid.cc.

 {
   if(createdDisplacedSolid)
   {
     ((G4DisplacedSolid*)fPtrSolidB)->CleanTransformations();
   }
   delete fpPolyhedron; fpPolyhedron = 0;
 }

G4BooleanSolid::G4BooleanSolid ( __void__ & a )

Definition at line 113 of file G4BooleanSolid.cc.

   : G4VSolid(a), fPtrSolidA(0), fPtrSolidB(0),
     fStatistics(1000000), fCubVolEpsilon(0.001), 
     fAreaAccuracy(-1.), fCubicVolume(0.), fSurfaceArea(0.),
     fRebuildPolyhedron(false), fpPolyhedron(0), fPrimitivesSurfaceArea(0.),
     createdDisplacedSolid(false)
 {
 }

G4BooleanSolid::G4BooleanSolid ( const G4BooleanSolid & rhs )

Definition at line 139 of file G4BooleanSolid.cc.

   : G4VSolid (rhs), fPtrSolidA(rhs.fPtrSolidA), fPtrSolidB(rhs.fPtrSolidB),
     fStatistics(rhs.fStatistics), fCubVolEpsilon(rhs.fCubVolEpsilon),
     fAreaAccuracy(rhs.fAreaAccuracy), fCubicVolume(rhs.fCubicVolume),
     fSurfaceArea(rhs.fSurfaceArea), fRebuildPolyhedron(false), fpPolyhedron(0),
     createdDisplacedSolid(rhs.createdDisplacedSolid)
 {
   fPrimitives.resize(0); fPrimitivesSurfaceArea = 0.;
 }

Member Function Documentation

G4double G4BooleanSolid::GetAreaAccuracy ( ) const

inline

G4int G4BooleanSolid::GetAreaStatistics ( ) const

inline

const G4VSolid * G4BooleanSolid::GetConstituentSolid ( G4int no ) const

virtual

Reimplemented from G4VSolid.

Definition at line 183 of file G4BooleanSolid.cc.

 {
   const G4VSolid*  subSolid=0;
   if( no == 0 )  
     subSolid = fPtrSolidA;
   else if( no == 1 ) 
     subSolid = fPtrSolidB;
   else
   {
     DumpInfo();
     G4Exception("G4BooleanSolid::GetConstituentSolid()",
                 "GeomSolids0002", FatalException, "Invalid solid index.");
   }
 
   return subSolid;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4VSolid * G4BooleanSolid::GetConstituentSolid ( G4int no )

virtual

Reimplemented from G4VSolid.

Definition at line 206 of file G4BooleanSolid.cc.

 {
   G4VSolid*  subSolid=0;
   if( no == 0 )  
     subSolid = fPtrSolidA;
   else if( no == 1 ) 
     subSolid = fPtrSolidB;
   else
   {
     DumpInfo();
     G4Exception("G4BooleanSolid::GetConstituentSolid()",
                 "GeomSolids0002", FatalException, "Invalid solid index.");
   }
 
   return subSolid;
 }

Here is the call graph for this function:

G4double G4BooleanSolid::GetCubicVolume ( )

inlinevirtual

Reimplemented from G4VSolid.

G4double G4BooleanSolid::GetCubVolEpsilon ( ) const

inline

G4int G4BooleanSolid::GetCubVolStatistics ( ) const

inline

G4GeometryType G4BooleanSolid::GetEntityType ( ) const

virtual

Implements G4VSolid.

Reimplemented in G4IntersectionSolid, G4SubtractionSolid, and G4UnionSolid.

Definition at line 227 of file G4BooleanSolid.cc.

 {
   return G4String("G4BooleanSolid");
 }

Here is the caller graph for this function:

void G4BooleanSolid::GetListOfPrimitives	(	std::vector< std::pair< G4VSolid *, G4Transform3D >> &	primitives,
		const G4Transform3D &	curPlacement
	)		const

protected

Definition at line 255 of file G4BooleanSolid.cc.

 {
   G4Transform3D transform;
   G4VSolid* solid;
   G4String type;
 
   // Repeat two times, first time for fPtrSolidA and then for fPtrSolidB
   //
   for (G4int i=0; i<2; i++)
   {
     transform = curPlacement;
     solid     = (i == 0) ? fPtrSolidA : fPtrSolidB;
     type      = solid->GetEntityType();
 
     // While current solid is a trasformed solid just modify transform
     //
     while (type == "G4DisplacedSolid" ||
            type == "G4ReflectedSolid" ||
            type == "G4ScaledSolid")
     {
       if (type == "G4DisplacedSolid")
       {
         transform = transform * G4Transform3D(
                     ((G4DisplacedSolid*)solid)->GetObjectRotation(),
                     ((G4DisplacedSolid*)solid)->GetObjectTranslation());
         solid     = ((G4DisplacedSolid*)solid)->GetConstituentMovedSolid();
       }
       else if (type == "G4ReflectedSolid")
       {
         transform= transform*((G4ReflectedSolid*)solid)->GetDirectTransform3D();
         solid    = ((G4ReflectedSolid*)solid)->GetConstituentMovedSolid();
       }
       else if (type == "G4ScaledSolid")
       {
         transform = transform * ((G4ScaledSolid*)solid)->GetScaleTransform();
         solid     = ((G4ScaledSolid*)solid)->GetUnscaledSolid();
       }
       type  = solid->GetEntityType();
     }
 
     // If current solid is a Boolean solid then continue recursion,
     // otherwise add it to the list of primitives
     //
     if (type == "G4UnionSolid"        ||
         type == "G4SubtractionSolid"  ||
         type == "G4IntersectionSolid" ||
         type == "G4BooleanSolid")
     {
       ((G4BooleanSolid *)solid)->GetListOfPrimitives(primitives,transform);
     }
     else
     {
       primitives.push_back(std::pair<G4VSolid*,G4Transform3D>(solid,transform));
     }
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4ThreeVector G4BooleanSolid::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 319 of file G4BooleanSolid.cc.

 {
   G4int nprims = fPrimitives.size();
   std::pair<G4VSolid *, G4Transform3D> prim;
 
   // Get list of primitives and find the total area of their surfaces
   //
   if (nprims == 0)
   {
     GetListOfPrimitives(fPrimitives, G4Transform3D());
     nprims = fPrimitives.size();
     fPrimitivesSurfaceArea = 0.;
     for (G4int i=0; i<nprims; i++)
     {
       fPrimitivesSurfaceArea += fPrimitives[i].first->GetSurfaceArea();
     }
   }
 
   // Select random primitive, get random point on its surface and
   // check that the point belongs to the surface of the solid
   //
   G4ThreeVector p;
   for (G4int k=0; k<1000000; k++) // try 1000000 times
   {
      G4double rand = fPrimitivesSurfaceArea * G4UniformRand();
      G4double area = 0.;
      for (G4int i=0; i<nprims; i++)
      {
        prim  = fPrimitives[i];
        area += prim.first->GetSurfaceArea();
        if (rand < area) break;
      }
      p = prim.first->GetPointOnSurface();
      p = prim.second * G4Point3D(p);
      if (Inside(p) == kSurface) return p;
   }
   std::ostringstream message;
   message << "Solid - " << GetName() << "\n"
       << "All attempts to generate a point on the surface have failed.\n"
       << "Returning point from the last unsuccessful attempt!";
   G4Exception("G4BooleanSolid::GetPointOnSurface()",
               "GeomSolids1001", JustWarning, message);
   return p;
 }

Here is the call graph for this function:

G4Polyhedron * G4BooleanSolid::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 368 of file G4BooleanSolid.cc.

 {
   if (!fpPolyhedron ||
       fRebuildPolyhedron ||
       fpPolyhedron->GetNumberOfRotationStepsAtTimeOfCreation() !=
       fpPolyhedron->GetNumberOfRotationSteps())
     {
       G4AutoLock l(&polyhedronMutex);
       delete fpPolyhedron;
       fpPolyhedron = CreatePolyhedron();
       fRebuildPolyhedron = false;
       l.unlock();
     }
   return fpPolyhedron;
 }

Here is the call graph for this function:

G4double G4BooleanSolid::GetSurfaceArea ( )

inlinevirtual

Reimplemented from G4VSolid.

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

Definition at line 153 of file G4BooleanSolid.cc.

 {
   // Check assignment to self
   //
   if (this == &rhs)  { return *this; }
 
   // Copy base class data
   //
   G4VSolid::operator=(rhs);
 
   // Copy data
   //
   fPtrSolidA= rhs.fPtrSolidA; fPtrSolidB= rhs.fPtrSolidB;
   fStatistics= rhs.fStatistics; fCubVolEpsilon= rhs.fCubVolEpsilon;
   fAreaAccuracy= rhs.fAreaAccuracy; fCubicVolume= rhs.fCubicVolume;
   fSurfaceArea= rhs.fSurfaceArea;
   createdDisplacedSolid= rhs.createdDisplacedSolid;
   fRebuildPolyhedron = false;
   delete fpPolyhedron; fpPolyhedron = 0;
   fPrimitives.resize(0); fPrimitivesSurfaceArea = 0.;
 
   return *this;
 }  

Here is the call graph for this function:

Here is the caller graph for this function:

void G4BooleanSolid::SetAreaAccuracy ( G4double ep )

inline

void G4BooleanSolid::SetAreaStatistics ( G4int st )

inline

void G4BooleanSolid::SetCubVolEpsilon ( G4double ep )

inline

void G4BooleanSolid::SetCubVolStatistics ( G4int st )

inline

G4Polyhedron * G4BooleanSolid::StackPolyhedron	(	HepPolyhedronProcessor &	processor,
		const G4VSolid *	solid
	)		const

protected

Definition at line 389 of file G4BooleanSolid.cc.

 {
   HepPolyhedronProcessor::Operation operation;
   const G4String& type = solid->GetEntityType();
   if (type == "G4UnionSolid")
     { operation = HepPolyhedronProcessor::UNION; }
   else if (type == "G4IntersectionSolid")
     { operation = HepPolyhedronProcessor::INTERSECTION; }
   else if (type == "G4SubtractionSolid")
     { operation = HepPolyhedronProcessor::SUBTRACTION; }
   else
   {
     std::ostringstream message;
     message << "Solid - " << solid->GetName()
             << " - Unrecognised composite solid" << G4endl
             << " Returning NULL !";
     G4Exception("StackPolyhedron()", "GeomSolids1001", JustWarning, message);
     return 0;
   }
 
   G4Polyhedron* top = 0;
   const G4VSolid* solidA = solid->GetConstituentSolid(0);
   const G4VSolid* solidB = solid->GetConstituentSolid(1);
 
   if (solidA->GetConstituentSolid(0))
   {
     top = StackPolyhedron(processor, solidA);
   }
   else
   {
     top = solidA->GetPolyhedron();
   }
   G4Polyhedron* operand = solidB->GetPolyhedron();
   processor.push_back (operation, *operand);
 
   return top;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

virtual

Implements G4VSolid.

Definition at line 236 of file G4BooleanSolid.cc.

 {
   os << "-----------------------------------------------------------\n"
      << "    *** Dump for Boolean solid - " << GetName() << " ***\n"
      << "    ===================================================\n"
      << " Solid type: " << GetEntityType() << "\n"
      << " Parameters of constituent solids: \n"
      << "===========================================================\n";
   fPtrSolidA->StreamInfo(os);
   fPtrSolidB->StreamInfo(os);
   os << "===========================================================\n";
 
   return os;
 }

Here is the call graph for this function:

Member Data Documentation

G4VSolid* G4BooleanSolid::fPtrSolidA

protected

Definition at line 121 of file G4BooleanSolid.hh.

G4VSolid* G4BooleanSolid::fPtrSolidB

protected

Definition at line 122 of file G4BooleanSolid.hh.

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

geant4.10.03.p01/source/geometry/solids/Boolean/include/G4BooleanSolid.hh
geant4.10.03.p01/source/geometry/solids/Boolean/src/G4BooleanSolid.cc

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation