G4IntersectionSolid Class Reference

#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)
virtual	~G4IntersectionSolid ()
G4GeometryType	GetEntityType () const
G4VSolid *	Clone () const
	G4IntersectionSolid (__void__ &)
	G4IntersectionSolid (const G4IntersectionSolid &rhs)
G4IntersectionSolid &	operator= (const G4IntersectionSolid &rhs)
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
G4NURBS *	CreateNURBS () 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 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 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 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 G4NURBS *	CreateNURBS () 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)

Additional Inherited Members
Protected Member Functions inherited from G4BooleanSolid
G4Polyhedron *	StackPolyhedron (HepPolyhedronProcessor &, const G4VSolid *) const
G4double	GetAreaRatio () 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
G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const
G4double	EstimateSurfaceArea (G4int nStat, G4double ell) const
Protected Attributes inherited from G4BooleanSolid
G4VSolid *	fPtrSolidA
G4VSolid *	fPtrSolidB
G4double	fAreaRatio
Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Detailed Description

Definition at line 53 of file G4IntersectionSolid.hh.

Constructor & Destructor Documentation

G4IntersectionSolid() [1/5]

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

Definition at line 63 of file G4IntersectionSolid.cc.

  : G4BooleanSolid(pName,pSolidA,pSolidB)
{
} 

G4IntersectionSolid() [2/5]

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

Definition at line 73 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
	)

Definition at line 86 of file G4IntersectionSolid.cc.

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

~G4IntersectionSolid()

G4IntersectionSolid::~G4IntersectionSolid ( )

virtual

Definition at line 108 of file G4IntersectionSolid.cc.

{
}

G4IntersectionSolid() [4/5]

G4IntersectionSolid::G4IntersectionSolid

(

__void__ &

a

)

Definition at line 99 of file G4IntersectionSolid.cc.

  : G4BooleanSolid(a)
{
}

G4IntersectionSolid() [5/5]

G4IntersectionSolid::G4IntersectionSolid

(

const G4IntersectionSolid &

rhs

)

Definition at line 116 of file G4IntersectionSolid.cc.

  : G4BooleanSolid (rhs)
{
}

Member Function Documentation

CalculateExtent()

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

virtual

Implements G4VSolid.

Definition at line 144 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;
#ifdef G4BOOLDEBUG
    // G4cout.precision(16);
    // G4cout<<"pMin = "<<pMin<<"; pMax = "<<pMax<<G4endl;
#endif
  }
  else out = false;
 
  return out; // It exists in this slice only if both exist in it.
}

Clone()

G4VSolid * G4IntersectionSolid::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Reimplemented in G4BREPSolidOpenPCone.

Definition at line 520 of file G4IntersectionSolid.cc.

{
  return new G4IntersectionSolid(*this);
}

ComputeDimensions()

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

virtual

Reimplemented from G4VSolid.

Definition at line 501 of file G4IntersectionSolid.cc.

{
}

CreateNURBS()

G4NURBS * G4IntersectionSolid::CreateNURBS ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 556 of file G4IntersectionSolid.cc.

{
  // Take into account boolean operation - see CreatePolyhedron.
  // return new G4NURBSbox (1.0, 1.0, 1.0);
  return 0;
}

CreatePolyhedron()

G4Polyhedron * G4IntersectionSolid::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 540 of file G4IntersectionSolid.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; }
}

DescribeYourselfTo()

void G4IntersectionSolid::DescribeYourselfTo ( G4VGraphicsScene &  scene ) const

virtual

Implements G4VSolid.

Reimplemented in G4BREPSolidOpenPCone.

Definition at line 530 of file G4IntersectionSolid.cc.

{
  scene.AddSolid (*this);
}

DistanceToIn() [1/2]

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

virtual

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

virtual

Implements G4VSolid.

Definition at line 272 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;
 
    while(true) 
    {
      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;
      }
    }
  }
  return dist ;  
}

DistanceToOut() [1/2]

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

virtual

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 = 0, G4ThreeVector *  n = 0  ) const

virtual

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

virtual

Reimplemented from G4BooleanSolid.

Definition at line 511 of file G4IntersectionSolid.cc.

{
  return G4String("G4IntersectionSolid");
}

Inside()

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

virtual

Implements G4VSolid.

Definition at line 177 of file G4IntersectionSolid.cc.

{
  EInside positionA = fPtrSolidA->Inside(p) ;
 
  if( positionA == kOutside ) return kOutside ;
 
  EInside positionB = fPtrSolidB->Inside(p) ;
  
  if(positionA == kInside && positionB == kInside)
  {
    return kInside ;
  }
  else
  {
    if((positionA == kInside && positionB == kSurface) ||
       (positionB == kInside && positionA == kSurface) ||
       (positionA == kSurface && positionB == kSurface)   )
    {
      return kSurface ;
    }
    else
    {
      return kOutside ;
    }
  }
}

Referenced by DistanceToIn(), and DistanceToOut().

operator=()

G4IntersectionSolid & G4IntersectionSolid::operator=

(

const G4IntersectionSolid &

rhs

)

Definition at line 126 of file G4IntersectionSolid.cc.

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

Referenced by G4BREPSolidOpenPCone::operator=().

SurfaceNormal()

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

virtual

Implements G4VSolid.

Definition at line 208 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
 
  // OLD: if(fPtrSolidA->DistanceToOut(p) <= fPtrSolidB->DistanceToOut(p) ) 
 
  // On the surface of both is difficult ... treat it like on A now!
  //
  // if( (insideA == kSurface) && (insideB == kSurface) )
  //    normal= fPtrSolidA->SurfaceNormal(p) ;
  // else 
  if( insideA == kSurface )
    {
      normal= fPtrSolidA->SurfaceNormal(p) ;
    }
  else if( insideB == kSurface )
    {
      normal= fPtrSolidB->SurfaceNormal(p) ;
    } 
    // We are on neither surface, so we should generate an exception
  else
    {
      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