#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

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)

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::G4IntersectionSolid	(	const G4String &	pName,
		G4VSolid *	pSolidA,
		G4VSolid *	pSolidB
	)

Definition at line 61 of file G4IntersectionSolid.cc.

Referenced by Clone().

   : G4BooleanSolid(pName,pSolidA,pSolidB)
 {
 } 

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

Definition at line 71 of file G4IntersectionSolid.cc.

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

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

Definition at line 84 of file G4IntersectionSolid.cc.

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

G4IntersectionSolid::~G4IntersectionSolid ( )

virtual

Definition at line 106 of file G4IntersectionSolid.cc.

107 {

108 }

G4IntersectionSolid::G4IntersectionSolid ( __void__ & a )

Definition at line 97 of file G4IntersectionSolid.cc.

   : G4BooleanSolid(a)
 {
 }

G4IntersectionSolid::G4IntersectionSolid ( const G4IntersectionSolid & rhs )

Definition at line 114 of file G4IntersectionSolid.cc.

   : G4BooleanSolid (rhs)
 {
 }

Member Function Documentation

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

virtual

Implements G4VSolid.

Definition at line 142 of file G4IntersectionSolid.cc.

References G4VSolid::CalculateExtent(), G4BooleanSolid::fPtrSolidA, G4BooleanSolid::fPtrSolidB, G4INCL::Math::max(), and G4INCL::Math::min().

 {
   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.
 }

G4VSolid * G4IntersectionSolid::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 518 of file G4IntersectionSolid.cc.

References G4IntersectionSolid().

 {
   return new G4IntersectionSolid(*this);
 }

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

virtual

Reimplemented from G4VSolid.

Definition at line 499 of file G4IntersectionSolid.cc.

502 {

503 }

G4Polyhedron * G4IntersectionSolid::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 538 of file G4IntersectionSolid.cc.

References HepPolyhedronProcessor::execute(), processor, and G4BooleanSolid::StackPolyhedron().

 {
   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; }
 }

void G4IntersectionSolid::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtual

Implements G4VSolid.

Definition at line 528 of file G4IntersectionSolid.cc.

References G4VGraphicsScene::AddSolid().

 {
   scene.AddSolid (*this);
 }

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

virtual

Implements G4VSolid.

Definition at line 270 of file G4IntersectionSolid.cc.

References G4VSolid::DistanceToIn(), G4VSolid::DistanceToOut(), G4BooleanSolid::fPtrSolidA, G4BooleanSolid::fPtrSolidB, G4cerr, G4cout, G4endl, Inside(), G4VSolid::Inside(), kInside, kSurface, and test::v.

 {
   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 ;  
 }

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

virtual

Implements G4VSolid.

Definition at line 371 of file G4IntersectionSolid.cc.

References G4VSolid::DistanceToIn(), G4BooleanSolid::fPtrSolidA, G4BooleanSolid::fPtrSolidB, G4cerr, G4cout, G4endl, Inside(), G4VSolid::Inside(), kInside, kOutside, and G4INCL::Math::min().

 {
 #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 ;
 }

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 414 of file G4IntersectionSolid.cc.

References G4VSolid::DistanceToOut(), G4BooleanSolid::fPtrSolidA, G4BooleanSolid::fPtrSolidB, G4cerr, G4cout, G4endl, Inside(), kOutside, G4INCL::Math::min(), python.hepunit::mm, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

 {
   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 ; 
 }

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

virtual

Implements G4VSolid.

Definition at line 473 of file G4IntersectionSolid.cc.

References G4VSolid::DistanceToOut(), G4BooleanSolid::fPtrSolidA, G4BooleanSolid::fPtrSolidB, G4cerr, G4cout, G4endl, Inside(), kOutside, and G4INCL::Math::min().

 {
 #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) ) ; 
 
 }

G4GeometryType G4IntersectionSolid::GetEntityType ( ) const

virtual

Reimplemented from G4BooleanSolid.

Definition at line 509 of file G4IntersectionSolid.cc.

 {
   return G4String("G4IntersectionSolid");
 }

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

virtual

Implements G4VSolid.

Definition at line 175 of file G4IntersectionSolid.cc.

References G4BooleanSolid::fPtrSolidA, G4BooleanSolid::fPtrSolidB, G4VSolid::Inside(), kInside, kOutside, and kSurface.

Referenced by DistanceToIn(), and DistanceToOut().

 {
   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 ;
     }
   }
 }

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

Definition at line 124 of file G4IntersectionSolid.cc.

References G4BooleanSolid::operator=().

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

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

virtual

Implements G4VSolid.

Definition at line 206 of file G4IntersectionSolid.cc.

References G4VSolid::DistanceToOut(), G4BooleanSolid::fPtrSolidA, G4BooleanSolid::fPtrSolidB, G4cerr, G4cout, G4endl, G4VSolid::Inside(), kOutside, kSurface, and G4VSolid::SurfaceNormal().

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

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation