G4UnionSolid Class Reference

#include <G4UnionSolid.hh>

Inheritance diagram for G4UnionSolid:

Public Member Functions
	G4UnionSolid (const G4String &pName, G4VSolid *pSolidA, G4VSolid *pSolidB)
	G4UnionSolid (const G4String &pName, G4VSolid *pSolidA, G4VSolid *pSolidB, G4RotationMatrix *rotMatrix, const G4ThreeVector &transVector)
	G4UnionSolid (const G4String &pName, G4VSolid *pSolidA, G4VSolid *pSolidB, const G4Transform3D &transform)
virtual	~G4UnionSolid ()
G4GeometryType	GetEntityType () const
G4VSolid *	Clone () const
	G4UnionSolid (__void__ &)
	G4UnionSolid (const G4UnionSolid &rhs)
G4UnionSolid &	operator= (const G4UnionSolid &rhs)
void	BoundingLimits (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=nullptr, G4ThreeVector *n=nullptr) 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
virtual 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)
virtual	~G4BooleanSolid ()
virtual const G4VSolid *	GetConstituentSolid (G4int no) const
virtual G4VSolid *	GetConstituentSolid (G4int no)
virtual 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	BoundingLimits (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=nullptr, G4ThreeVector *n=nullptr) const =0
virtual G4double	DistanceToOut (const G4ThreeVector &p) const =0
virtual void	ComputeDimensions (G4VPVParameterisation *p, const G4int n, const G4VPhysicalVolume *pRep)
virtual G4double	GetCubicVolume ()
virtual G4double	GetSurfaceArea ()
virtual G4GeometryType	GetEntityType () const =0
virtual G4ThreeVector	GetPointOnSurface () const
virtual G4VSolid *	Clone () const
virtual std::ostream &	StreamInfo (std::ostream &os) const =0
void	DumpInfo () const
virtual void	DescribeYourselfTo (G4VGraphicsScene &scene) const =0
virtual G4VisExtent	GetExtent () const
virtual G4Polyhedron *	CreatePolyhedron () const
virtual G4Polyhedron *	GetPolyhedron () const
virtual const G4VSolid *	GetConstituentSolid (G4int no) const
virtual G4VSolid *	GetConstituentSolid (G4int no)
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 = nullptr
G4VSolid *	fPtrSolidB = nullptr
G4double	fCubicVolume = -1.0
Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Detailed Description

Definition at line 45 of file G4UnionSolid.hh.

Constructor & Destructor Documentation

G4UnionSolid() [1/5]

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

Definition at line 53 of file G4UnionSolid.cc.

  : G4BooleanSolid(pName,pSolidA,pSolidB)
{
  Init();
}

G4UnionSolid() [2/5]

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

Definition at line 65 of file G4UnionSolid.cc.

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

G4UnionSolid() [3/5]

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

Definition at line 80 of file G4UnionSolid.cc.

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

~G4UnionSolid()

G4UnionSolid::~G4UnionSolid ( )

virtual

Definition at line 103 of file G4UnionSolid.cc.

{
}

G4UnionSolid() [4/5]

G4UnionSolid::G4UnionSolid

(

__void__ &

a

)

Definition at line 94 of file G4UnionSolid.cc.

  : G4BooleanSolid(a)
{
}

G4UnionSolid() [5/5]

G4UnionSolid::G4UnionSolid

(

const G4UnionSolid &

rhs

)

Definition at line 111 of file G4UnionSolid.cc.

  : G4BooleanSolid (rhs)
{
  fPMin = rhs.fPMin;
  fPMax = rhs.fPMax;
  halfCarTolerance=0.5*kCarTolerance;
}

Member Function Documentation

BoundingLimits()

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

virtual

Reimplemented from G4VSolid.

Definition at line 158 of file G4UnionSolid.cc.

{
  G4ThreeVector minA,maxA, minB,maxB;
  fPtrSolidA->BoundingLimits(minA,maxA);
  fPtrSolidB->BoundingLimits(minB,maxB);
 
  pMin.set(std::min(minA.x(),minB.x()),
           std::min(minA.y(),minB.y()),
           std::min(minA.z(),minB.z()));
 
  pMax.set(std::max(maxA.x(),maxB.x()),
           std::max(maxA.y(),maxB.y()),
           std::max(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("G4UnionSolid::BoundingLimits()", "GeomMgt0001",
                JustWarning, message);
    DumpInfo();
  }
}

CalculateExtent()

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

virtual

Implements G4VSolid.

Definition at line 193 of file G4UnionSolid.cc.

{
  G4bool   touchesA, touchesB, out ;
  G4double minA =  kInfinity, minB =  kInfinity, 
           maxA = -kInfinity, maxB = -kInfinity; 
 
  touchesA = fPtrSolidA->CalculateExtent( pAxis, pVoxelLimit, 
                                          pTransform, minA, maxA);
  touchesB = fPtrSolidB->CalculateExtent( pAxis, pVoxelLimit, 
                                          pTransform, minB, maxB);
  if( touchesA || touchesB )
  {
    pMin = std::min( minA, minB ); 
    pMax = std::max( maxA, maxB );
    out  = true ; 
  }
  else
  {
    out = false ;
  }
 
  return out ;  // It exists in this slice if either one does.
}

Clone()

G4VSolid * G4UnionSolid::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 495 of file G4UnionSolid.cc.

{
  return new G4UnionSolid(*this);
}

ComputeDimensions()

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

virtual

Reimplemented from G4VSolid.

Definition at line 505 of file G4UnionSolid.cc.

{
}

CreatePolyhedron()

G4Polyhedron * G4UnionSolid::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 526 of file G4UnionSolid.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 nullptr; }
}

DescribeYourselfTo()

void G4UnionSolid::DescribeYourselfTo ( G4VGraphicsScene &  scene ) const

virtual

Implements G4VSolid.

Definition at line 516 of file G4UnionSolid.cc.

{
  scene.AddSolid (*this);
}

DistanceToIn() [1/2]

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

virtual

Implements G4VSolid.

Definition at line 322 of file G4UnionSolid.cc.

{
#ifdef G4BOOLDEBUG
  if( Inside(p) == kInside )
  {
    G4cout << "WARNING - Invalid call in "
           << "G4UnionSolid::DistanceToIn(p)" << G4endl
           << "  Point p is inside !" << G4endl;
    G4cout << "          p = " << p << G4endl;
    G4cerr << "WARNING - Invalid call in "
           << "G4UnionSolid::DistanceToIn(p)" << G4endl
           << "  Point p is inside !" << G4endl;
    G4cerr << "          p = " << p << G4endl;
  }
#endif
  G4double distA = fPtrSolidA->DistanceToIn(p) ;
  G4double distB = fPtrSolidB->DistanceToIn(p) ;
  G4double safety = std::min(distA,distB) ;
  if(safety < 0.0) safety = 0.0 ;
  return safety ;
}

DistanceToIn() [2/2]

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

virtual

Implements G4VSolid.

Definition at line 293 of file G4UnionSolid.cc.

{
#ifdef G4BOOLDEBUG
  if( Inside(p) == kInside )
  {
    G4cout << "WARNING - Invalid call in "
           << "G4UnionSolid::DistanceToIn(p,v)" << G4endl
           << "  Point p is inside !" << G4endl;
    G4cout << "          p = " << p << G4endl;
    G4cout << "          v = " << v << G4endl;
    G4cerr << "WARNING - Invalid call in "
           << "G4UnionSolid::DistanceToIn(p,v)" << G4endl
           << "  Point p is inside !" << G4endl;
    G4cerr << "          p = " << p << G4endl;
    G4cerr << "          v = " << v << G4endl;
  }
#endif
 
  return std::min(fPtrSolidA->DistanceToIn(p,v),
                  fPtrSolidB->DistanceToIn(p,v) ) ;
}

DistanceToOut() [1/2]

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

virtual

Implements G4VSolid.

Definition at line 436 of file G4UnionSolid.cc.

{
  G4double distout = 0.0;
  if( Inside(p) == kOutside )
  {
#ifdef G4BOOLDEBUG
    G4cout << "WARNING - Invalid call in "
           << "G4UnionSolid::DistanceToOut(p)" << G4endl
           << "  Point p is outside !" << G4endl;
    G4cout << "          p = " << p << G4endl;
    G4cerr << "WARNING - Invalid call in "
           << "G4UnionSolid::DistanceToOut(p)" << G4endl
           << "  Point p is outside !" << G4endl;
    G4cerr << "          p = " << p << G4endl;
#endif
  }
  else
  {
    EInside positionA = fPtrSolidA->Inside(p) ;
    EInside positionB = fPtrSolidB->Inside(p) ;
  
    //  Is this equivalent ??
    //    if( ! (  (positionA == kOutside)) && 
    //             (positionB == kOutside))  ) 
    if((positionA == kInside  && positionB == kInside  ) ||
       (positionA == kInside  && positionB == kSurface ) ||
       (positionA == kSurface && positionB == kInside  )     )
    {     
      distout= std::max(fPtrSolidA->DistanceToOut(p),
                        fPtrSolidB->DistanceToOut(p) ) ;
    }
    else
    {
      if(positionA == kOutside)
      {
        distout= fPtrSolidB->DistanceToOut(p) ;
      }
      else
      {
        distout= fPtrSolidA->DistanceToOut(p) ;
      }
    }
  }
  return distout;
}

DistanceToOut() [2/2]

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

virtual

Implements G4VSolid.

Definition at line 349 of file G4UnionSolid.cc.

{
  G4double  dist = 0.0, disTmp = 0.0 ;
  G4ThreeVector normTmp;
  G4ThreeVector* nTmp = &normTmp;
 
  if( Inside(p) == kOutside )
  {
#ifdef G4BOOLDEBUG
      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 "
             << "G4UnionSolid::DistanceToOut(p,v)" << G4endl
             << "  Point p is outside !" << G4endl;
      G4cout << "          p = " << p << G4endl;
      G4cout << "          v = " << v << G4endl;
      G4cerr << "WARNING - Invalid call in "
             << "G4UnionSolid::DistanceToOut(p,v)" << G4endl
             << "  Point p is outside !" << G4endl;
      G4cerr << "          p = " << p << G4endl;
      G4cerr << "          v = " << v << G4endl;
#endif
  }
  else
  {
    EInside positionA = fPtrSolidA->Inside(p) ;
 
    if( positionA != kOutside )
    { 
      do  // Loop checking, 13.08.2015, G.Cosmo
      {
        disTmp = fPtrSolidA->DistanceToOut(p+dist*v,v,calcNorm,
                                           validNorm,nTmp);
        dist += disTmp ;
 
        if(fPtrSolidB->Inside(p+dist*v) != kOutside)
        { 
          disTmp = fPtrSolidB->DistanceToOut(p+dist*v,v,calcNorm,
                                             validNorm,nTmp);
          dist += disTmp ;
        }
      }
      while( (fPtrSolidA->Inside(p+dist*v) != kOutside)
          && (disTmp > halfCarTolerance) );
    }
    else // if( positionB != kOutside )
    {
      do  // Loop checking, 13.08.2015, G.Cosmo
      {
        disTmp = fPtrSolidB->DistanceToOut(p+dist*v,v,calcNorm,
                                           validNorm,nTmp); 
        dist += disTmp ;
 
        if(fPtrSolidA->Inside(p+dist*v) != kOutside)
        { 
          disTmp = fPtrSolidA->DistanceToOut(p+dist*v,v,calcNorm,
                                             validNorm,nTmp);
          dist += disTmp ;
        }
      }
      while( (fPtrSolidB->Inside(p+dist*v) != kOutside)
          && (disTmp > halfCarTolerance) );
    }
  }
  if( calcNorm )
  { 
     *validNorm = false ;
     *n         = *nTmp ;   
  }
  return dist ;
}

GetCubicVolume()

G4double G4UnionSolid::GetCubicVolume ( )

finalvirtual

Reimplemented from G4BooleanSolid.

Definition at line 542 of file G4UnionSolid.cc.

{
   if( fCubicVolume != -1.0 ) {
      return fCubicVolume;
   }
   G4double cubVolumeA = fPtrSolidA->GetCubicVolume();
   G4double cubVolumeB = fPtrSolidB->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-Union",
                                        fPtrSolidA, fPtrSolidB );
      intersection = intersectVol.GetCubicVolume();
   }
 
   fCubicVolume = cubVolumeA + cubVolumeB - intersection;
 
   return fCubicVolume;
}

GetEntityType()

G4GeometryType G4UnionSolid::GetEntityType ( ) const

virtual

Reimplemented from G4BooleanSolid.

Definition at line 486 of file G4UnionSolid.cc.

{
  return G4String("G4UnionSolid");
}

Inside()

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

virtual

Implements G4VSolid.

Definition at line 227 of file G4UnionSolid.cc.

{
  if (std::max(p.z()-fPMax.z(), fPMin.z()-p.z()) > 0) { return kOutside; }
 
  EInside positionA = fPtrSolidA->Inside(p);
  if (positionA == kInside)  { return positionA; } // inside A
  EInside positionB = fPtrSolidB->Inside(p);
  if (positionA == kOutside) { return positionB; }
 
  if (positionB == kInside)  { return positionB; } // inside  B
  if (positionB == kOutside) { return positionA; } // surface A
 
  // Both points are on surface
  //
  static const G4double rtol
    = 1000*G4GeometryTolerance::GetInstance()->GetRadialTolerance();
 
  return ((fPtrSolidA->SurfaceNormal(p) + 
           fPtrSolidB->SurfaceNormal(p)).mag2() < rtol) ? kInside : kSurface;
}

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

operator=()

G4UnionSolid & G4UnionSolid::operator=

(

const G4UnionSolid &

rhs

)

Definition at line 123 of file G4UnionSolid.cc.

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

SurfaceNormal()

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

virtual

Implements G4VSolid.

Definition at line 253 of file G4UnionSolid.cc.

{
  EInside positionA = fPtrSolidA->Inside(p);
  EInside positionB = fPtrSolidB->Inside(p);
 
  if (positionA == kSurface &&
      positionB == kOutside) return fPtrSolidA->SurfaceNormal(p);
 
  if (positionA == kOutside &&
      positionB == kSurface) return fPtrSolidB->SurfaceNormal(p);
 
  if (positionA == kSurface &&
      positionB == kSurface)
  {
    if (Inside(p) == kSurface)
    {
      G4ThreeVector normalA = fPtrSolidA->SurfaceNormal(p);
      G4ThreeVector normalB = fPtrSolidB->SurfaceNormal(p);
      return (normalA + normalB).unit(); 
    }
  }
#ifdef G4BOOLDEBUG
  G4String surf[3] = { "OUTSIDE", "SURFACE", "INSIDE" };
  std::ostringstream message;
  G4int oldprc = message.precision(16);
  message << "Invalid call of SurfaceNormal(p) for union solid: "
          << GetName() << " !"
          << "\nPoint p" << p << " is " << surf[Inside(p)] << " !!!"; 
  message.precision(oldprc);
  G4Exception("G4UnionSolid::SurfaceNormal()", "GeomMgt0001",
              JustWarning, message);
#endif
  return fPtrSolidA->SurfaceNormal(p);
}

---

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

• G4UnionSolid.hh
• G4UnionSolid.cc