#include <G4BREPSolid.hh>

Inheritance diagram for G4BREPSolid:

Public Member Functions
	G4BREPSolid (const G4String &name)

	G4BREPSolid (const G4String &, G4Surface **, G4int)

virtual	~G4BREPSolid ()

virtual void	Initialize ()

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

virtual EInside	Inside (register const G4ThreeVector &Pt) const

virtual G4ThreeVector	SurfaceNormal (const G4ThreeVector &) const

virtual G4double	DistanceToIn (const G4ThreeVector &) const

virtual G4double	DistanceToIn (register const G4ThreeVector &Pt, register const G4ThreeVector &V) const

virtual G4double	DistanceToOut (const G4ThreeVector &) const

virtual G4double	DistanceToOut (register const G4ThreeVector &Pt, register const G4ThreeVector &V, const G4bool calcNorm=false, G4bool validNorm=0, G4ThreeVector n=0) const

G4Point3D	Scope () const

virtual G4String	GetEntityType () const

virtual G4VSolid *	Clone () const

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

void	DescribeYourselfTo (G4VGraphicsScene &scene) const

G4Polyhedron *	CreatePolyhedron () const

G4NURBS *	CreateNURBS () const

virtual G4Polyhedron *	GetPolyhedron () const

G4int	Intersect (register const G4Ray &) const

G4Surface *	GetSurface (G4int) const

void	Active (G4int) const

G4int	Active () const

G4double	GetShortestDistance () const

G4int	GetId () const

void	SetId (G4int)

const G4String &	GetName () const

void	SetName (const G4String &name)

G4int	GetNumberOfFaces () const

G4int	GetNumberOfSolids () const

const G4Axis2Placement3D *	GetPlace () const

const G4BoundingBox3D *	GetBBox () 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)

G4double	GetCubicVolume ()

G4double	GetSurfaceArea ()

G4double	IntersectionDistance () const

void	IntersectionDistance (G4double) const

virtual void	Reset () const

	G4BREPSolid (__void__ &)

	G4BREPSolid (const G4BREPSolid &rhs)

G4BREPSolid &	operator= (const G4BREPSolid &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)

Protected Member Functions
G4ThreeVectorList *	CreateRotatedVertices (const G4AffineTransform &) const

G4bool	IsConvex ()

virtual void	CalcBBoxes ()

void	CheckSurfaceNormals ()

void	RemoveHiddenFaces (register const G4Ray &G4Rayref, G4int) const

void	TestSurfaceBBoxes (register const G4Ray &) const

G4int	StartInside () const

void	StartInside (G4int si) const

void	QuickSort (register G4Surface **SrfVec, register G4int left, register G4int right) 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
G4int	Box

G4int	Convex

G4int	AxisBox

G4int	PlaneSolid

G4Axis2Placement3D *	place

G4BoundingBox3D *	bbox

G4double	intersectionDistance

G4int	active

G4int	startInside

G4int	nb_of_surfaces

G4Point3D	intersection_point

G4Surface **	SurfaceVec

G4double	RealDist

G4String	solidname

G4int	Id

Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Static Protected Attributes
static G4int	NumberOfSolids =0

static G4Ray	Track

static G4double	ShortestDistance = kInfinity

Detailed Description

Definition at line 50 of file G4BREPSolid.hh.

Constructor & Destructor Documentation

◆ G4BREPSolid() [1/4]

G4BREPSolid::G4BREPSolid ( const G4String & name )

Definition at line 52 of file G4BREPSolid.cc.

 : G4VSolid(name),
   Box(0), Convex(0), AxisBox(0), PlaneSolid(0), place(0), bbox(0),
   intersectionDistance(kInfinity), active(1), startInside(0),
   nb_of_surfaces(0), SurfaceVec(0), RealDist(0.), solidname(name), Id(0),
   fStatistics(1000000), fCubVolEpsilon(0.001), fAreaAccuracy(-1.),
   fCubicVolume(0.), fSurfaceArea(0.), fpPolyhedron(0)
{
  static G4bool warn=true;
  if (warn)
  {
    G4cout
         << "--------------------------------------------------------" << G4endl
         << "WARNING: BREPS classes are being dismissed.  They will |" << G4endl
         << "         be removed starting  from next  Geant4  major |" << G4endl
         << "         release.  Please, consider switching to adopt |" << G4endl
         << "         correspondent CSG or specific primitives.     |" << G4endl
         << "--------------------------------------------------------"
         << G4endl;
    warn = false;
  }
}

◆ G4BREPSolid() [2/4]

G4BREPSolid::G4BREPSolid	(	const G4String &	name,
		G4Surface **	srfVec,
		G4int	numberOfSrfs
	)

Definition at line 75 of file G4BREPSolid.cc.

 : G4VSolid(name),
   Box(0), Convex(0), AxisBox(0), PlaneSolid(0), place(0), bbox(0),
   intersectionDistance(kInfinity), active(1), startInside(0),
   nb_of_surfaces(numberOfSrfs), SurfaceVec(srfVec), RealDist(0.),
   solidname(name), Id(0),
   fStatistics(1000000), fCubVolEpsilon(0.001), fAreaAccuracy(-1.),
   fCubicVolume(0.), fSurfaceArea(0.), fpPolyhedron(0)
{
  static G4bool warn=true;
  if (warn)
  {
    G4cout
         << "--------------------------------------------------------" << G4endl
         << "WARNING: BREPS classes are being dismissed.  They will |" << G4endl
         << "         be removed starting  from next  Geant4  major |" << G4endl
         << "         release.  Please, consider switching to adopt |" << G4endl
         << "         correspondent CSG or specific primitives.     |" << G4endl
         << "--------------------------------------------------------"
         << G4endl;
    warn = false;
  }
  Initialize();
}

◆ ~G4BREPSolid()

G4BREPSolid::~G4BREPSolid ( )

virtual

Definition at line 112 of file G4BREPSolid.cc.

{
  delete place;
  delete bbox;
  
  for(G4int a=0;a<nb_of_surfaces;++a)
    { delete SurfaceVec[a]; }
  
  delete [] SurfaceVec;
  delete fpPolyhedron;
}

◆ G4BREPSolid() [3/4]

G4BREPSolid::G4BREPSolid ( __void__ & a )

Definition at line 102 of file G4BREPSolid.cc.

  : G4VSolid(a),
   Box(0), Convex(0), AxisBox(0), PlaneSolid(0), place(0), bbox(0),
   intersectionDistance(kInfinity), active(1), startInside(0),
   nb_of_surfaces(0), SurfaceVec(0), RealDist(0.), solidname(""), Id(0),
   fStatistics(1000000), fCubVolEpsilon(0.001), fAreaAccuracy(-1.),
   fCubicVolume(0.), fSurfaceArea(0.), fpPolyhedron(0)
{
}

◆ G4BREPSolid() [4/4]

G4BREPSolid::G4BREPSolid ( const G4BREPSolid & rhs )

Definition at line 124 of file G4BREPSolid.cc.

  : G4VSolid(rhs), Box(rhs.Box), Convex(rhs.Convex), AxisBox(rhs.AxisBox),
    PlaneSolid(rhs.PlaneSolid), place(0), bbox(0),
    intersectionDistance(rhs.intersectionDistance), active(rhs.active),
    startInside(rhs.startInside), nb_of_surfaces(rhs.nb_of_surfaces),
    intersection_point(rhs.intersection_point), SurfaceVec(0),
    RealDist(rhs.RealDist), solidname(rhs.solidname), Id(rhs.Id),
    fStatistics(rhs.fStatistics), fCubVolEpsilon(rhs.fCubVolEpsilon),
    fAreaAccuracy(rhs.fAreaAccuracy), fCubicVolume(rhs.fCubicVolume),
    fSurfaceArea(rhs.fSurfaceArea), fpPolyhedron(0)
{
  Initialize();
}

Member Function Documentation

◆ Active() [1/2]

G4int G4BREPSolid::Active ( ) const

inline

Referenced by G4BREPSolidPCone::Reset(), G4BREPSolidPolyhedra::Reset(), and TestSurfaceBBoxes().

◆ Active() [2/2]

void G4BREPSolid::Active ( G4int ) const

inline

◆ CalcBBoxes()

void G4BREPSolid::CalcBBoxes ( )

protectedvirtual

Definition at line 1140 of file G4BREPSolid.cc.

{
  // First initialization. Calculates the bounding boxes
  // for the surfaces and for the solid.
 
  G4Surface* srf;
  G4Point3D min, max;
  
  if(active)
  {
    min =  PINFINITY;
    max = -PINFINITY;
    
    for(G4int a = 0;a < nb_of_surfaces;a++)
    {
      // Get first in List
      //
      srf = SurfaceVec[a];
/*
      G4int convex=1; 
      G4int concavepoint=-1;
 
      if (srf->MyType() == 1) 
      {
        concavepoint = srf->IsConvex();
        convex = srf->GetConvex();
      }
 
      // Make bbox for face
      //
      if(convex && Concavepoint==-1)
*/
      {
        srf->CalcBBox();
        G4Point3D box_min = srf->GetBBox()->GetBoxMin();
        G4Point3D box_max = srf->GetBBox()->GetBoxMax();
 
        // Find max and min of face bboxes to make solids bbox.
 
        // replace by Extend
        // max < box_max
        //
        if(max.x() < box_max.x()) max.setX(box_max.x()); 
        if(max.y() < box_max.y()) max.setY(box_max.y()); 
        if(max.z() < box_max.z()) max.setZ(box_max.z()); 
 
        // min > box_min
        //
        if(min.x() > box_min.x()) min.setX(box_min.x()); 
        if(min.y() > box_min.y()) min.setY(box_min.y()); 
        if(min.z() > box_min.z()) min.setZ(box_min.z());
      }
    }
    bbox =  new G4BoundingBox3D(min, max);
    return;
  }
  G4Exception("G4BREPSolid::CalcBBoxes()", "GeomSolids1002",
              JustWarning, "No bbox calculated for solid.");
}

Referenced by Initialize(), G4BREPSolidCone::Initialize(), G4BREPSolidPCone::Initialize(), and G4BREPSolidPolyhedra::Initialize().

◆ CalculateExtent()

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

virtual

Implements G4VSolid.

Definition at line 596 of file G4BREPSolid.cc.

{
  G4Point3D Min = bbox->GetBoxMin();
  G4Point3D Max = bbox->GetBoxMax();
 
  if (!pTransform.IsRotated())
    {
      // Special case handling for unrotated boxes
      // Compute x/y/z mins and maxs respecting limits, with early returns
      // if outside limits. Then switch() on pAxis
      //
      G4double xoffset,xMin,xMax;
      G4double yoffset,yMin,yMax;
      G4double zoffset,zMin,zMax;
 
      xoffset=pTransform.NetTranslation().x();
      xMin=xoffset+Min.x();
      xMax=xoffset+Max.x();
      if (pVoxelLimit.IsXLimited())
      {
        if (xMin>pVoxelLimit.GetMaxXExtent()
            ||xMax<pVoxelLimit.GetMinXExtent())
        {
          return false;
        }
        else
        {
          if (xMin<pVoxelLimit.GetMinXExtent())
          {
            xMin=pVoxelLimit.GetMinXExtent();
          }
          if (xMax>pVoxelLimit.GetMaxXExtent())
          {
            xMax=pVoxelLimit.GetMaxXExtent();
          }
        }
      }
 
      yoffset=pTransform.NetTranslation().y();
      yMin=yoffset+Min.y();
      yMax=yoffset+Max.y();
      if (pVoxelLimit.IsYLimited())
      {
        if (yMin>pVoxelLimit.GetMaxYExtent()
            ||yMax<pVoxelLimit.GetMinYExtent())
        {
          return false;
        }
        else
        {
          if (yMin<pVoxelLimit.GetMinYExtent())
          {
            yMin=pVoxelLimit.GetMinYExtent();
          }
          if (yMax>pVoxelLimit.GetMaxYExtent())
          {
            yMax=pVoxelLimit.GetMaxYExtent();
          }
        }
      }
 
      zoffset=pTransform.NetTranslation().z();
      zMin=zoffset+Min.z();
      zMax=zoffset+Max.z();
      if (pVoxelLimit.IsZLimited())
      {
        if (zMin>pVoxelLimit.GetMaxZExtent()
            ||zMax<pVoxelLimit.GetMinZExtent())
        {
          return false;
        }
        else
        {
          if (zMin<pVoxelLimit.GetMinZExtent())
          {
            zMin=pVoxelLimit.GetMinZExtent();
          }
          if (zMax>pVoxelLimit.GetMaxZExtent())
          {
            zMax=pVoxelLimit.GetMaxZExtent();
          }
        }
      }
 
      switch (pAxis)
      {
        case kXAxis:
          pMin=xMin;
          pMax=xMax;
          break;
        case kYAxis:
          pMin=yMin;
          pMax=yMax;
          break;
        case kZAxis:
          pMin=zMin;
          pMax=zMax;
          break;
        default:
          break;
      }
      pMin-=kCarTolerance;
      pMax+=kCarTolerance;
 
      return true;
    }
  else
    {
      // General rotated case - create and clip mesh to boundaries
 
      G4bool existsAfterClip=false;
      G4ThreeVectorList *vertices;
 
      pMin=+kInfinity;
      pMax=-kInfinity;
 
      // Calculate rotated vertex coordinates
      //
      vertices=CreateRotatedVertices(pTransform);
      ClipCrossSection(vertices,0,pVoxelLimit,pAxis,pMin,pMax);
      ClipCrossSection(vertices,4,pVoxelLimit,pAxis,pMin,pMax);
      ClipBetweenSections(vertices,0,pVoxelLimit,pAxis,pMin,pMax);
 
      if ( (pMin!=kInfinity) || (pMax!=-kInfinity) )
      {
        existsAfterClip=true;
    
        // Add 2*tolerance to avoid precision troubles
        //
        pMin-=kCarTolerance;
        pMax+=kCarTolerance;
      }
      else
      {
        // Check for case where completely enveloping clipping volume.
        // If point inside then we are confident that the solid completely
        // envelopes the clipping volume. Hence set min/max extents according
        // to clipping volume extents along the specified axis.
        //
        G4ThreeVector clipCentre(
                (pVoxelLimit.GetMinXExtent()+pVoxelLimit.GetMaxXExtent())*0.5,
                (pVoxelLimit.GetMinYExtent()+pVoxelLimit.GetMaxYExtent())*0.5,
                (pVoxelLimit.GetMinZExtent()+pVoxelLimit.GetMaxZExtent())*0.5);
 
        if (Inside(pTransform.Inverse().TransformPoint(clipCentre))!=kOutside)
        {
          existsAfterClip=true;
          pMin=pVoxelLimit.GetMinExtent(pAxis);
          pMax=pVoxelLimit.GetMaxExtent(pAxis);
        }
      }
      delete vertices;
      return existsAfterClip;
    }
}

◆ CheckSurfaceNormals()

void G4BREPSolid::CheckSurfaceNormals ( )

protected

Definition at line 213 of file G4BREPSolid.cc.

{
  if(!PlaneSolid)
    return; // All faces must be planar
 
  Convex=1;
 
  // Checks that the normals of the surfaces point outwards.
  // If not, turns the Normal to point out.
  
  // Loop through each face and check the G4Vector3D of the Normal
  //
  G4Surface* srf;
  G4Point3D V;
  
  G4int SrfNum = 0;
  G4double YValue=0;
  G4Point3D Pt;
  
  G4int a, b;
  for(a=0; a<nb_of_surfaces; a++)
  {
    // Find vertex point containing extreme y value
    //
    srf = SurfaceVec[a];
    G4int Points = srf->GetNumberOfPoints();
    
    for(b =0; b<Points; b++)
    {
      Pt = (G4Point3D)srf->GetPoint(b);    
      if(YValue < Pt.y())
      {
        YValue = Pt.y();
        SrfNum = a;   // Save srf number
      }
    }
  }
 
  // Move the selected face to the first in the List
  //
  srf = SurfaceVec[SrfNum];            
  
  // Start handling the surfaces in order and compare
  // the neighbouring ones and turn their normals if they
  // point inwards
  //
  G4Point3D Pt1;
  G4Point3D Pt2;
  G4Point3D Pt3;
  G4Point3D Pt4;
  
  G4Vector3D N1;
  G4Vector3D N2;    
  G4Vector3D N3;    
  G4Vector3D N4;    
 
  G4int* ConnectedList = new G4int[nb_of_surfaces];    
 
  for(a=0; a<nb_of_surfaces; a++)
    ConnectedList[a]=0;
  
  G4Surface* ConnectedSrf;
 
  for(a=0; a<nb_of_surfaces-1; a++)
  {
    if(ConnectedList[a] == 0) 
      break;
    else
      ConnectedList[a]=1;
    
    srf = SurfaceVec[a];
    G4int SrfPoints = srf->GetNumberOfPoints();
    N1 = (srf->Norm())->GetDir();
 
    for(b=a+1; b<nb_of_surfaces; b++)
    {
      if(ConnectedList[b] == 1) 
        break;
      else
        ConnectedList[b]=1;
     
      // Get next in List
      // 
      ConnectedSrf = SurfaceVec[b];    
 
      // Check if it is connected to srf by looping through the points.
      //
      G4int ConnSrfPoints = ConnectedSrf->GetNumberOfPoints();
 
      for(G4int c=0;c<SrfPoints;c++)
      {
        Pt1 = srf->GetPoint(c);
 
        for(G4int d=0;d<ConnSrfPoints;d++)
        {
          // Find common points
          //
          Pt2 = (ConnectedSrf)->GetPoint(d);
 
          if( Pt1 == Pt2 ) 
          {
            // Common point found. Compare normals.
            //
            N2 = ((ConnectedSrf)->Norm())->GetDir();
 
            // Check cross product.
            //
            G4Vector3D CP1 = G4Vector3D( N1.cross(N2) );
            G4double CrossProd1 = CP1.x()+CP1.y()+CP1.z();
 
            // Create the other normals
            //
            if(c==0) 
              Pt3 = srf->GetPoint(c+1);
            else
              Pt3 = srf->GetPoint(0);
 
            N3 = (Pt1-Pt3);
 
            if(d==0) 
              Pt4 = (ConnectedSrf)->GetPoint(d+1);
            else
              Pt4 = (ConnectedSrf)->GetPoint(0);
 
            N4 = (Pt1-Pt4);
 
            G4Vector3D CP2 = G4Vector3D( N3.cross(N4) );
            G4double CrossProd2 = CP2.x()+CP2.y()+CP2.z();
 
            G4cout << "\nCroosProd2: " << CrossProd2;
 
            if( (CrossProd1 < 0 && CrossProd2 < 0) ||
                (CrossProd1 > 0 && CrossProd2 > 0)    )
            {
              // Turn Normal
              //
              (ConnectedSrf)->Norm()
                ->SetDir(-1 * (ConnectedSrf)->Norm()->GetDir());
 
              // Take the CrossProd1 again as the other Normal was turned.
              //
              CP1 = N1.cross(N2);
              CrossProd1 = CP1.x()+CP1.y()+CP1.z();
            }
            if(CrossProd1 > 0) 
              Convex=0;
          }
        }
      }
    }
  }
  
  delete []ConnectedList;
}

Referenced by Initialize(), G4BREPSolidCone::Initialize(), G4BREPSolidPCone::Initialize(), and G4BREPSolidPolyhedra::Initialize().

◆ Clone()

G4VSolid * G4BREPSolid::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Reimplemented in G4BREPSolidBox, G4BREPSolidCone, G4BREPSolidCylinder, G4BREPSolidPCone, G4BREPSolidPolyhedra, G4BREPSolidSphere, and G4BREPSolidTorus.

Definition at line 196 of file G4BREPSolid.cc.

{
  return new G4BREPSolid(*this);
}

◆ CreateNURBS()

G4NURBS * G4BREPSolid::CreateNURBS ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1130 of file G4BREPSolid.cc.

{
  // Approximate implementation, just a box ...
 
  G4Point3D Min = bbox->GetBoxMin();
  G4Point3D Max = bbox->GetBoxMax();  
 
  return new G4NURBSbox (Max.x(), Max.y(), Max.z());
}

◆ CreatePolyhedron()

G4Polyhedron * G4BREPSolid::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Reimplemented in G4BREPSolidPCone, and G4BREPSolidPolyhedra.

Definition at line 1120 of file G4BREPSolid.cc.

{
  // Approximate implementation, just a box ...
 
  G4Point3D Min = bbox->GetBoxMin();
  G4Point3D Max = bbox->GetBoxMax();  
 
  return new G4PolyhedronBox (Max.x(), Max.y(), Max.z());
}

Referenced by GetPolyhedron().

◆ CreateRotatedVertices()

G4ThreeVectorList * G4BREPSolid::CreateRotatedVertices ( const G4AffineTransform & pTransform ) const

protected

Definition at line 756 of file G4BREPSolid.cc.

{
  G4Point3D Min = bbox->GetBoxMin();
  G4Point3D Max = bbox->GetBoxMax();
 
  G4ThreeVectorList *vertices;
  vertices=new G4ThreeVectorList();
    
  if (vertices)
  {
    vertices->reserve(8);
    G4ThreeVector vertex0(Min.x(),Min.y(),Min.z());
    G4ThreeVector vertex1(Max.x(),Min.y(),Min.z());
    G4ThreeVector vertex2(Max.x(),Max.y(),Min.z());
    G4ThreeVector vertex3(Min.x(),Max.y(),Min.z());
    G4ThreeVector vertex4(Min.x(),Min.y(),Max.z());
    G4ThreeVector vertex5(Max.x(),Min.y(),Max.z());
    G4ThreeVector vertex6(Max.x(),Max.y(),Max.z());
    G4ThreeVector vertex7(Min.x(),Max.y(),Max.z());
 
    vertices->push_back(pTransform.TransformPoint(vertex0));
    vertices->push_back(pTransform.TransformPoint(vertex1));
    vertices->push_back(pTransform.TransformPoint(vertex2));
    vertices->push_back(pTransform.TransformPoint(vertex3));
    vertices->push_back(pTransform.TransformPoint(vertex4));
    vertices->push_back(pTransform.TransformPoint(vertex5));
    vertices->push_back(pTransform.TransformPoint(vertex6));
    vertices->push_back(pTransform.TransformPoint(vertex7));
  }
  else
  {
    G4Exception("G4BREPSolid::CreateRotatedVertices()", "GeomSolids0003",
                FatalException, "Out of memory - Cannot allocate vertices!");
  }
  return vertices;
}

Referenced by CalculateExtent().

◆ DescribeYourselfTo()

void G4BREPSolid::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtual

Implements G4VSolid.

Definition at line 1115 of file G4BREPSolid.cc.

{
  scene.AddSolid (*this);
}

◆ DistanceToIn() [1/2]

G4double G4BREPSolid::DistanceToIn ( const G4ThreeVector & Pt ) const

virtual

Implements G4VSolid.

Reimplemented in G4BREPSolidPCone, G4BREPSolidPolyhedra, G4BREPSolidSphere, and G4BREPSolidCone.

Definition at line 888 of file G4BREPSolid.cc.

{
  // Calculates the shortest distance ("safety") from a point
  // outside the solid to any boundary of this solid.
  // Return 0 if the point is already inside.
 
  G4double *dists = new G4double[nb_of_surfaces];
  G4int a;
 
  // Set the surfaces to active again
  //
  Reset();
  
  // Compute the shortest distance of the point to each surface.
  // Be careful : it's a signed value
  //
  for(a=0; a< nb_of_surfaces; a++)  
    dists[a] = SurfaceVec[a]->HowNear(Pt);
     
  G4double Dist = kInfinity;
  
  // If dists[] is positive, the point is outside, so take the shortest of
  // the shortest positive distances dists[] can be equal to 0 : point on
  // a surface.
  // ( Problem with the G4FPlane : there is no inside and no outside...
  //   So, to test if the point is inside to return 0, utilize the Inside()
  //   function. But I don't know if it is really needed because dToIn is 
  //   called only if the point is outside )
  //
  for(a = 0; a < nb_of_surfaces; a++)
    if( std::fabs(Dist) > std::fabs(dists[a]) ) 
      //if( dists[a] >= 0)
        Dist = dists[a];
  
  delete[] dists;
 
  if(Dist == kInfinity)
    return 0;  // the point is inside the solid or on a surface
  else
    return std::fabs(Dist);
}

◆ DistanceToIn() [2/2]

G4double G4BREPSolid::DistanceToIn	(	register const G4ThreeVector &	Pt,
		register const G4ThreeVector &	V
	)		const

virtual

Reimplemented in G4BREPSolidCone, G4BREPSolidPCone, G4BREPSolidPolyhedra, and G4BREPSolidSphere.

Definition at line 930 of file G4BREPSolid.cc.

{
  // Calculates the distance from a point outside the solid
  // to the solid's boundary along a specified direction vector.
  //
  // Note : Intersections with boundaries less than the tolerance must be
  //        ignored if the direction is away from the boundary.
  
  G4int a;
  
  // Set the surfaces to active again
  //
  Reset();
  
  const G4double sqrHalfTolerance = kCarTolerance*kCarTolerance*0.25;
  G4Vector3D Pttmp(Pt);
  G4Vector3D Vtmp(V);   
  G4Ray r(Pttmp, Vtmp);
 
  // Test if the bounding box of each surface is intersected
  // by the ray. If not, the surface become deactive.
  //
  TestSurfaceBBoxes(r);
  
  ShortestDistance = kInfinity;
  
  for(a=0; a< nb_of_surfaces; a++)
  {
    if( SurfaceVec[a]->IsActive() )
    {
      // Test if the ray intersects the surface
      //
      if( SurfaceVec[a]->Intersect(r) )
      {
        G4double surfDistance = SurfaceVec[a]->GetDistance();
 
        // If more than 1 surface is intersected, take the nearest one
        //
        if( surfDistance < ShortestDistance )
        {
          if( surfDistance > sqrHalfTolerance )
          {
            ShortestDistance = surfDistance;
          }
          else
          {
            // The point is within the boundary. It is ignored it if
            // the direction is away from the boundary
            //
            G4Vector3D Norm = SurfaceVec[a]->SurfaceNormal(Pttmp);
 
            if( (Norm * Vtmp) < 0 )
            {
              ShortestDistance = surfDistance;
            }
          }
        }
      }
    }
  }
  
  // Be careful !
  // SurfaceVec->Distance is in fact the squared distance
  //
  if(ShortestDistance != kInfinity)
    return std::sqrt(ShortestDistance);
  else
    return kInfinity;  // No intersection
}

◆ DistanceToOut() [1/2]

G4double G4BREPSolid::DistanceToOut ( const G4ThreeVector & Pt ) const

virtual

Implements G4VSolid.

Reimplemented in G4BREPSolidPCone, G4BREPSolidPolyhedra, G4BREPSolidSphere, and G4BREPSolidCone.

Definition at line 1073 of file G4BREPSolid.cc.

{
  // Calculates the shortest distance ("safety") from a point
  // inside the solid to any boundary of this solid.
  // Returns 0 if the point is already outside.
 
  G4double *dists = new G4double[nb_of_surfaces];
  G4int a;
 
  // Set the surfaces to active again
  //
  Reset();
  
  // Compute the shortest distance of the point to each surfaces
  // Be careful : it's a signed value
  //
  for(a=0; a< nb_of_surfaces; a++)
    dists[a] = SurfaceVec[a]->HowNear(Pt);  
 
  G4double Dist = kInfinity;
  
  // If dists[] is negative, the point is inside so take the shortest of the
  // shortest negative distances dists[] can be equal to 0 : point on a
  // surface
  // ( Problem with the G4FPlane : there is no inside and no outside...
  //   So, to test if the point is outside to return 0, utilize the Inside()
  //   function. But I don`t know if it is really needed because dToOut is 
  //   called only if the point is inside )
  //
  for(a = 0; a < nb_of_surfaces; a++)
    if( std::fabs(Dist) > std::fabs(dists[a]) ) 
      //if( dists[a] <= 0)
        Dist = dists[a];
  
  delete[] dists;
 
  if(Dist == kInfinity)
    return 0;  // The point is ouside the solid or on a surface
  else
    return std::fabs(Dist);
}

◆ DistanceToOut() [2/2]

G4double G4BREPSolid::DistanceToOut	(	register const G4ThreeVector &	Pt,
		register const G4ThreeVector &	V,
		const G4bool	calcNorm = `false`,
		G4bool *	validNorm = `0`,
		G4ThreeVector *	n = `0`
	)		const

virtual

Reimplemented in G4BREPSolidCone, G4BREPSolidPCone, G4BREPSolidPolyhedra, and G4BREPSolidSphere.

Definition at line 1001 of file G4BREPSolid.cc.

{
  // Calculates the distance from a point inside the solid to the solid's
  // boundary along a specified direction vector.
  // Returns 0 if the point is already outside.
  //
  // Note : If the shortest distance to a boundary is less than the tolerance,
  //        it is ignored. This allows for a point within a tolerant boundary
  //        to leave immediately.
 
  // Set the surfaces to active again
  //
  Reset();
 
  const G4double sqrHalfTolerance = kCarTolerance*kCarTolerance*0.25;
  G4Vector3D Ptv = P;
  G4int a;
 
  if(validNorm)
    *validNorm=false;
 
  G4Vector3D Pttmp(Ptv);
  G4Vector3D Vtmp(D);   
  
  G4Ray r(Pttmp, Vtmp);
 
  // Test if the bounding box of each surface is intersected
  // by the ray. If not, the surface become deactive.
  //
  TestSurfaceBBoxes(r);
  
  ShortestDistance = kInfinity;
 
  for(a=0; a< nb_of_surfaces; a++)
  {
    if(SurfaceVec[a]->IsActive())
    {
      // Test if the ray intersect the surface
      //
      if( (SurfaceVec[a]->Intersect(r)) )
      {
        // If more than 1 surface is intersected, take the nearest one
        //
        G4double surfDistance = SurfaceVec[a]->GetDistance();
        if( surfDistance < ShortestDistance )
        {
          if( surfDistance > sqrHalfTolerance )
          {
            ShortestDistance = surfDistance;
          }
          else
          {
            // The point is within the boundary: ignore it
          }
        }
      }
    }
  }
 
  // Be careful !
  // SurfaceVec->Distance is in fact the squared distance
  //
  if(ShortestDistance != kInfinity)
    return std::sqrt(ShortestDistance);
  else
    return 0.0;  // No intersection is found, the point is outside
}

◆ GetAreaAccuracy()

G4double G4BREPSolid::GetAreaAccuracy ( ) const

inline

◆ GetAreaStatistics()

G4int G4BREPSolid::GetAreaStatistics ( ) const

inline

◆ GetBBox()

const G4BoundingBox3D * G4BREPSolid::GetBBox ( ) const

inline

Referenced by Inside(), G4BREPSolidPCone::Inside(), and G4BREPSolidPolyhedra::Inside().

◆ GetCubicVolume()

G4double G4BREPSolid::GetCubicVolume ( )

inlinevirtual

Reimplemented from G4VSolid.

◆ GetCubVolEpsilon()

G4double G4BREPSolid::GetCubVolEpsilon ( ) const

inline

◆ GetCubVolStatistics()

G4int G4BREPSolid::GetCubVolStatistics ( ) const

inline

◆ GetEntityType()

G4String G4BREPSolid::GetEntityType ( ) const

virtual

Implements G4VSolid.

Definition at line 191 of file G4BREPSolid.cc.

{
  return "Closed_Shell";
}

Referenced by StreamInfo().

◆ GetId()

G4int G4BREPSolid::GetId ( ) const

inline

◆ GetName()

const G4String & G4BREPSolid::GetName ( ) const

inline

Referenced by StreamInfo().

◆ GetNumberOfFaces()

G4int G4BREPSolid::GetNumberOfFaces ( ) const

inline

◆ GetNumberOfSolids()

G4int G4BREPSolid::GetNumberOfSolids ( ) const

inline

◆ GetPlace()

const G4Axis2Placement3D * G4BREPSolid::GetPlace ( ) const

inline

◆ GetPolyhedron()

G4Polyhedron * G4BREPSolid::GetPolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1524 of file G4BREPSolid.cc.

{
  if (!fpPolyhedron ||
      fpPolyhedron->GetNumberOfRotationStepsAtTimeOfCreation() !=
      fpPolyhedron->GetNumberOfRotationSteps())
    {
      delete fpPolyhedron;
      fpPolyhedron = CreatePolyhedron();
    }
  return fpPolyhedron;
}

◆ GetShortestDistance()

G4double G4BREPSolid::GetShortestDistance ( ) const

inline

◆ GetSurface()

G4Surface * G4BREPSolid::GetSurface ( G4int ) const

inline

◆ GetSurfaceArea()

G4double G4BREPSolid::GetSurfaceArea ( )

inlinevirtual

Reimplemented from G4VSolid.

◆ Initialize()

void G4BREPSolid::Initialize ( )

virtual

Reimplemented in G4BREPSolidCone, G4BREPSolidPCone, and G4BREPSolidPolyhedra.

Definition at line 171 of file G4BREPSolid.cc.

{
  if(active)
  {
    // Compute bounding box for solids and surfaces
    // Convert concave planes to convex
    //
    ShortestDistance= kInfinity;
    if (!SurfaceVec) { return; }
 
    IsBox();
    CheckSurfaceNormals();
    
    if(!Box || !AxisBox)
      IsConvex();
    
    CalcBBoxes();
  }
}

Referenced by G4BREPSolid(), and operator=().

◆ Inside()

EInside G4BREPSolid::Inside ( register const G4ThreeVector & Pt ) const

virtual

Reimplemented in G4BREPSolidBox, G4BREPSolidCone, G4BREPSolidPCone, G4BREPSolidPolyhedra, and G4BREPSolidSphere.

Definition at line 793 of file G4BREPSolid.cc.

{
  // This function finds if the point Pt is inside, 
  // outside or on the surface of the solid
 
  const G4double sqrHalfTolerance = kCarTolerance*kCarTolerance*0.25;
 
  G4Vector3D v(1, 0, 0.01);
  G4Vector3D Pttmp(Pt);
  G4Vector3D Vtmp(v);
  G4Ray r(Pttmp, Vtmp);
  
  // Check if point is inside the PCone bounding box
  //
  if( !GetBBox()->Inside(Pttmp) )
    return kOutside;
 
  // Set the surfaces to active again
  //
  Reset();
  
  // Test if the bounding box of each surface is intersected
  // by the ray. If not, the surface become deactive.
  //
  TestSurfaceBBoxes(r);
  
  G4int hits=0, samehit=0;
 
  for(G4int a=0; a < nb_of_surfaces; a++)
  {
    if(SurfaceVec[a]->IsActive())
    {
      // Count the number of intersections. If this number is odd,
      // the start of the ray is inside the volume bounded by the surfaces,
      // so increment the number of intersection by 1 if the point is not
      // on the surface and if this intersection was not found before.
      //
      if( (SurfaceVec[a]->Intersect(r)) & 1 )
      {
        // Test if the point is on the surface
        //
        if(SurfaceVec[a]->GetDistance() < sqrHalfTolerance)
          return kSurface;
 
        // Test if this intersection was found before
        //
        for(G4int i=0; i<a; i++)
          if(SurfaceVec[a]->GetDistance() == SurfaceVec[i]->GetDistance())
          {
            samehit++;
            break;
          }
 
        // Count the number of surfaces intersected by the ray
        //
        if(!samehit)
          hits++;
      }
    }
  }
   
  // If the number of surfaces intersected is odd,
  // the point is inside the solid
  //
  if(hits&1)
    return kInside;
  else
    return kOutside;
}

Referenced by CalculateExtent(), and Inside().

◆ Intersect()

G4int G4BREPSolid::Intersect ( register const G4Ray & rayref ) const

Definition at line 1300 of file G4BREPSolid.cc.

{
  // Gets the roughly calculated closest intersection point for
  // a b_spline & accurate point for others.
 
  const G4double sqrHalfTolerance = kCarTolerance*kCarTolerance*0.25;
 
  register G4Surface* srf;
  G4double HitDistance = -1;
  const G4Point3D& RayStart = rayref.GetStart();
  const G4Point3D& RayDir   = rayref.GetDir();
 
  G4int result=1;
   
  // Sort List of active surfaces according to
  // bbox distances to ray starting point
  //
  QuickSort(SurfaceVec, 0, nb_of_surfaces-1);
  G4int Number=0;
   
  // Start handling active surfaces in order
  //
  for(register G4int a=0;a<nb_of_surfaces;a++)
  {
    srf = SurfaceVec[a];
    
    if(srf->IsActive())
    {
      result = srf->Intersect(rayref);
      if(result)
      {
        // Get the evaluated point on the surface
        //
        const G4Point3D& closest_point = srf->GetClosestHit();
 
        // Test for DistanceToIn(pt, vec)
        // if d = 0 and vec.norm > 0, do not see the surface
        //
        if( !( (srf->GetDistance() < sqrHalfTolerance)  || 
             (RayDir.dot(srf->SurfaceNormal(closest_point)) > 0) ) )
        {
  
          if(srf->MyType()==1)
            HitDistance = srf->GetDistance();
          else
          {
            // Check if the evaluated point is in front of the 
            // bbox of the next surface.
            // 
            HitDistance = RayStart.distance2(closest_point);
          }
        }
      }   
      else  // No hit
      {
        srf->Deactivate();
      }
    }
    Number++;
  }
  
  if(HitDistance < 0)
    return 0;
  
  QuickSort(SurfaceVec, 0, nb_of_surfaces-1);
  
  if(!(SurfaceVec[0]->IsActive()))
    return 0;     
  
  ((G4BREPSolid*)this)->intersection_point = SurfaceVec[0]->GetClosestHit();
  bbox->SetDistance(HitDistance);
 
  return 1;
}

Referenced by G4BREPSolidCone::DistanceToIn(), DistanceToIn(), G4BREPSolidPCone::DistanceToIn(), G4BREPSolidPolyhedra::DistanceToIn(), G4BREPSolidCone::DistanceToOut(), DistanceToOut(), G4BREPSolidPCone::DistanceToOut(), G4BREPSolidSphere::DistanceToOut(), and Inside().

◆ IntersectionDistance() [1/2]

G4double G4BREPSolid::IntersectionDistance ( ) const

inline

◆ IntersectionDistance() [2/2]

void G4BREPSolid::IntersectionDistance ( G4double ) const

inline

◆ IsConvex()

G4bool G4BREPSolid::IsConvex ( )

protected

Definition at line 460 of file G4BREPSolid.cc.

{
  if (!PlaneSolid) { return 0; }    // All faces must be planar
 
  // This is not robust. There can be concave solids
  // where the concavity comes for example from three triangles.
 
  // Additional checking 20.8. For each face the connecting faces are
  // found and the cross product computed between the face and each
  // connecting face. If the result changes value at any point the
  // solid is concave.
  
  G4Surface* Srf=0;
  G4Surface* ConnectedSrf=0;
  G4int Result;
  Convex = 1;
  
  G4int a, b, c, d;
  for(a=0;a<nb_of_surfaces;a++)
  {
    Srf = SurfaceVec[a];
 
    // Primary test. Test wether any one of the faces
    // is concave -> solid is concave. This is not enough to
    // distinguish all the cases of concavity.
    //
    Result = Srf->IsConvex();
    
    if (Result != -1)
    {
      Convex = 0;
      return 0;
    }
  }
 
  Srf = SurfaceVec[0];        
 
  G4int ConnectingPoints=0;  
  G4Point3D  Pt1, Pt2;
  G4Vector3D N1, N2;    
 
  // L. Broglia
  // The number of connecting points can be 
  // (nb_of_surfaces-1) * nb_of_surfaces  (loop a & loop b)
  
  // G4int* ConnectedList = new G4int[nb_of_surfaces];
  const G4int maxCNum =  (nb_of_surfaces-1)*nb_of_surfaces; 
  G4int* ConnectedList = new G4int[maxCNum];  
 
  for(a=0; a<maxCNum; a++)
  {
    ConnectedList[a]=0;
  }
  
  G4int Connections=0;
 
  for(a=0; a<nb_of_surfaces-1; a++)
  {
    Srf = SurfaceVec[a];
    G4int SrfPoints = Srf->GetNumberOfPoints();
    Result=0;
    
    for(b=0; b<nb_of_surfaces; b++)
    {
      if (b==a) { continue; }
 
      // Get next in List
      //
      ConnectedSrf = SurfaceVec[b];
      
      // Check if it is connected to Srf by looping through the points.
      //
      G4int ConnSrfPoints = ConnectedSrf->GetNumberOfPoints();
      
      for(c=0; c<SrfPoints; c++)
      {
        const G4Point3D& Pts1 =Srf->GetPoint(c);
 
        for(d=0; d<ConnSrfPoints; d++)
        {
          // Find common points
          //
          const G4Point3D& Pts2 = ConnectedSrf->GetPoint(d);
          if (Pts1 == Pts2)  { ConnectingPoints++; }
        }
        if (ConnectingPoints > 0)  { break; }
      }
      
      if (ConnectingPoints > 0)
      {
        Connections++;
        ConnectedList[Connections]=b;
      }
      ConnectingPoints=0;
    }
  }
  
  // If connected, check for concavity.
  // Get surfaces from ConnectedList and compare their normals
  //
  for(c=0; c<Connections; c++)
  {
    G4int Left=0; 
    G4int Right =0;
    G4int tmp = ConnectedList[c];
    
    Srf = SurfaceVec[tmp];
    ConnectedSrf = SurfaceVec[tmp+1];
    
    // Get normals
    //
    N1 = Srf->Norm()->GetDir();
    N2 = ConnectedSrf->Norm()->GetDir();
 
    // Check cross product
    //
    G4Vector3D CP = G4Vector3D( N1.cross(N2) ); 
    G4double CrossProd = CP.x()+CP.y()+CP.z();
    if (CrossProd > 0)  { Left++;  }
    if (CrossProd < 0)  { Right++; }
    if (Left&&Right)
    {
      Convex = 0;
      delete [] ConnectedList;
      return 0;
    }
    Connections=0;
  } 
  
  Convex=1;
 
  delete [] ConnectedList;
 
  return 1;
}

Referenced by Initialize(), G4BREPSolidCone::Initialize(), G4BREPSolidPCone::Initialize(), and G4BREPSolidPolyhedra::Initialize().

◆ operator=()

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

Definition at line 138 of file G4BREPSolid.cc.

{
   // Check assignment to self
   //
   if (this == &rhs)  { return *this; }
 
   // Copy base class data
   //
   G4VSolid::operator=(rhs);
 
   // Copy data
   //
   Box= rhs.Box; Convex= rhs.Convex; AxisBox= rhs.AxisBox;
   PlaneSolid= rhs.PlaneSolid;
   intersectionDistance= rhs.intersectionDistance; active= rhs.active;
   startInside= rhs.startInside; nb_of_surfaces= rhs.nb_of_surfaces;
   intersection_point= rhs.intersection_point;
   RealDist= rhs.RealDist; solidname= rhs.solidname; Id= rhs.Id;
   fStatistics= rhs.fStatistics; fCubVolEpsilon= rhs.fCubVolEpsilon;
   fAreaAccuracy= rhs.fAreaAccuracy; fCubicVolume= rhs.fCubicVolume;
   fSurfaceArea= rhs.fSurfaceArea;
 
   delete place; delete bbox; place= 0; bbox= 0;
   for(G4int a=0;a<nb_of_surfaces;++a)
     { delete SurfaceVec[a]; }
   delete [] SurfaceVec; SurfaceVec= 0;
   delete fpPolyhedron; fpPolyhedron= 0;
 
   Initialize();
 
   return *this;
}  

Referenced by G4BREPSolidBox::operator=(), G4BREPSolidCone::operator=(), G4BREPSolidCylinder::operator=(), G4BREPSolidPCone::operator=(), G4BREPSolidPolyhedra::operator=(), G4BREPSolidSphere::operator=(), and G4BREPSolidTorus::operator=().

◆ QuickSort()

void G4BREPSolid::QuickSort	(	register G4Surface **	SrfVec,
		register G4int	left,
		register G4int	right
	)		const

inlineprotected

Referenced by Intersect().

◆ RemoveHiddenFaces()

void G4BREPSolid::RemoveHiddenFaces	(	register const G4Ray &	G4Rayref,
		G4int	In
	)		const

protected

Definition at line 1200 of file G4BREPSolid.cc.

{
  // Deactivates the planar faces that are on the "back" side of a solid.
  // B-splines are not handled by this function. Also cases where the ray
  // starting point is Inside the bbox of the solid are ignored as we don't
  // know if the starting point is Inside the actual solid except for
  // axis-oriented box-like solids.
  
  register G4Surface* srf;
  register const G4Vector3D& RayDir = rayref.GetDir();
  register G4double Result;
  G4int a;
 
  // In all other cases the ray starting point is outside the solid
  //
  if(!In)
    for(a=0; a<nb_of_surfaces; a++)
    {
      // Deactivates the solids faces that are hidden
      //
      srf = SurfaceVec[a];
      if(srf->MyType()==1)
      {
        const G4Vector3D& Normal = (srf->Norm())->GetDir();
        Result = (RayDir * Normal);
 
        if( Result >= 0 )
          srf->Deactivate();
      }
    }
  else
    for(a=0; a<nb_of_surfaces; a++)
    {
      // Deactivates the AxisBox type solids faces whose normals 
      // point in the G4Vector3D opposite to the rays G4Vector3D
      // i.e. are behind the ray starting point as in this case the
      // ray starts from Inside the solid.
      //
      srf = SurfaceVec[a];
      if(srf->MyType()==1)
      {
        const G4Vector3D& Normal = (srf->Norm())->GetDir();
        Result = (RayDir * Normal);
 
        if( Result < 0 )
          srf->Deactivate();
      }
    }
}

◆ Reset()

void G4BREPSolid::Reset ( ) const

virtual

Reimplemented in G4BREPSolidPCone, and G4BREPSolidPolyhedra.

Definition at line 201 of file G4BREPSolid.cc.

{
  ((G4BREPSolid*)this)->active=1;
  ((G4BREPSolid*)this)->intersectionDistance=kInfinity;
  ((G4BREPSolid*)this)->startInside=0; 
     
  for(register G4int a=0;a<nb_of_surfaces;a++)
    SurfaceVec[a]->Reset();
 
  ShortestDistance = kInfinity;
}

Referenced by DistanceToIn(), G4BREPSolidCone::DistanceToIn(), G4BREPSolidCone::DistanceToOut(), DistanceToOut(), Inside(), and Reset().

◆ Scope()

G4Point3D G4BREPSolid::Scope ( ) const

Definition at line 1498 of file G4BREPSolid.cc.

{
  G4Point3D scope;
  G4Point3D Max = bbox->GetBoxMax();
  G4Point3D Min = bbox->GetBoxMin();  
  
  scope.setX(std::fabs(Max.x()) - std::fabs(Min.x()));
  scope.setY(std::fabs(Max.y()) - std::fabs(Min.y()));
  scope.setZ(std::fabs(Max.z()) - std::fabs(Min.z()));
  
  return scope;
}

◆ SetAreaAccuracy()

void G4BREPSolid::SetAreaAccuracy ( G4double ep )

inline

◆ SetAreaStatistics()

void G4BREPSolid::SetAreaStatistics ( G4int st )

inline

◆ SetCubVolEpsilon()

void G4BREPSolid::SetCubVolEpsilon ( G4double ep )

inline

◆ SetCubVolStatistics()

void G4BREPSolid::SetCubVolStatistics ( G4int st )

inline

◆ SetId()

void G4BREPSolid::SetId ( G4int )

inline

◆ SetName()

void G4BREPSolid::SetName ( const G4String & name )

inline

◆ StartInside() [1/2]

G4int G4BREPSolid::StartInside ( ) const

inlineprotected

Referenced by G4BREPSolidPCone::Reset(), and G4BREPSolidPolyhedra::Reset().

◆ StartInside() [2/2]

void G4BREPSolid::StartInside ( G4int si ) const

inlineprotected

◆ StreamInfo()

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

virtual

Implements G4VSolid.

Reimplemented in G4BREPSolidBox, G4BREPSolidCone, G4BREPSolidCylinder, G4BREPSolidPCone, G4BREPSolidPolyhedra, G4BREPSolidSphere, and G4BREPSolidTorus.

Definition at line 1511 of file G4BREPSolid.cc.

{
  os << "-----------------------------------------------------------\n"
     << "    *** Dump for solid - " << GetName() << " ***\n"
     << "    ===================================================\n"
     << " Solid type: " << GetEntityType() << "\n"
     << " Parameters: \n"
     << "   Number of solids: " << NumberOfSolids << "\n"
     << "-----------------------------------------------------------\n";
 
  return os;
}

Referenced by G4BREPSolidBox::StreamInfo(), G4BREPSolidCone::StreamInfo(), G4BREPSolidCylinder::StreamInfo(), G4BREPSolidPCone::StreamInfo(), G4BREPSolidPolyhedra::StreamInfo(), G4BREPSolidSphere::StreamInfo(), and G4BREPSolidTorus::StreamInfo().

◆ SurfaceNormal()

G4ThreeVector G4BREPSolid::SurfaceNormal ( const G4ThreeVector & Pt ) const

virtual

Implements G4VSolid.

Reimplemented in G4BREPSolidPCone, G4BREPSolidPolyhedra, G4BREPSolidSphere, and G4BREPSolidCone.

Definition at line 863 of file G4BREPSolid.cc.

{  
  // This function calculates the normal of the surface at a point on the
  // surface. If the point is not on the surface the result is undefined.
  // Note : the sense of the normal depends on the sense of the surface.
 
  const G4double sqrHalfTolerance = kCarTolerance*kCarTolerance*0.25;
  G4int          iplane;
    
  // Find on which surface the point is
  //
  for(iplane = 0; iplane < nb_of_surfaces; iplane++)
  {
    if(SurfaceVec[iplane]->HowNear(Pt) < sqrHalfTolerance)
      // the point is on this surface
      break;
  }
  
  // Calculate the normal at this point
  //
  G4ThreeVector norm = SurfaceVec[iplane]->SurfaceNormal(Pt);
 
  return norm.unit();
}

◆ TestSurfaceBBoxes()

void G4BREPSolid::TestSurfaceBBoxes ( register const G4Ray & rayref ) const

protected

Definition at line 1251 of file G4BREPSolid.cc.

{
  register G4Surface* srf;
  G4int active_srfs = nb_of_surfaces;
  
  // Do the bbox tests to all surfaces in List
  // for planar faces the intersection is instead evaluated.
  //
  G4int intersection=0;
  
  for(G4int a=0;a<nb_of_surfaces;a++)
  {
    // Get first in List
    //
    srf = SurfaceVec[a];
    
    if(srf->IsActive())
    {
      // Get type
      //
      if(srf->MyType() != 1) // 1 == planar face
      {
        if(srf->GetBBox()->Test(rayref))
          srf->SetDistance(bbox->GetDistance());
        else
        {
          // Test failed. Flag as inactive.
          //
          srf->Deactivate();
          active_srfs--;
        }
      }
      else
      {
        // Type was convex planar face
        intersection = srf->Intersect(rayref);
 
        if(!intersection) 
          active_srfs--;
      }
    }
    else
      active_srfs--;
  }
  
  if(!active_srfs) Active(0);
}

Referenced by DistanceToIn(), G4BREPSolidPCone::DistanceToIn(), G4BREPSolidPolyhedra::DistanceToIn(), DistanceToOut(), G4BREPSolidPCone::DistanceToOut(), G4BREPSolidPolyhedra::DistanceToOut(), Inside(), G4BREPSolidPCone::Inside(), and G4BREPSolidPolyhedra::Inside().

Member Data Documentation

◆ active

G4int G4BREPSolid::active

protected

Definition at line 227 of file G4BREPSolid.hh.

Referenced by CalcBBoxes(), G4BREPSolidBox::G4BREPSolidBox(), G4BREPSolidCone::G4BREPSolidCone(), G4BREPSolidCylinder::G4BREPSolidCylinder(), G4BREPSolidPCone::G4BREPSolidPCone(), G4BREPSolidPolyhedra::G4BREPSolidPolyhedra(), G4BREPSolidSphere::G4BREPSolidSphere(), G4BREPSolidTorus::G4BREPSolidTorus(), Initialize(), operator=(), and G4BREPSolidSphere::SphReset().

◆ AxisBox

G4int G4BREPSolid::AxisBox

protected

Definition at line 223 of file G4BREPSolid.hh.

Referenced by Initialize(), G4BREPSolidCone::Initialize(), G4BREPSolidPCone::Initialize(), G4BREPSolidPolyhedra::Initialize(), and operator=().

◆ bbox

G4BoundingBox3D* G4BREPSolid::bbox

protected

Definition at line 225 of file G4BREPSolid.hh.

Referenced by CalcBBoxes(), CalculateExtent(), CreateNURBS(), CreatePolyhedron(), CreateRotatedVertices(), G4BREPSolidBox::Inside(), Intersect(), operator=(), Scope(), TestSurfaceBBoxes(), and ~G4BREPSolid().

◆ Box

G4int G4BREPSolid::Box

protected

Definition at line 223 of file G4BREPSolid.hh.

Referenced by Initialize(), G4BREPSolidCone::Initialize(), G4BREPSolidPCone::Initialize(), G4BREPSolidPolyhedra::Initialize(), and operator=().

◆ Convex

G4int G4BREPSolid::Convex

protected

Definition at line 223 of file G4BREPSolid.hh.

Referenced by CheckSurfaceNormals(), IsConvex(), and operator=().

◆ Id

G4int G4BREPSolid::Id

protected

Definition at line 234 of file G4BREPSolid.hh.

Referenced by operator=().

◆ intersection_point

G4Point3D G4BREPSolid::intersection_point

protected

Definition at line 230 of file G4BREPSolid.hh.

Referenced by operator=().

◆ intersectionDistance

G4double G4BREPSolid::intersectionDistance

protected

Definition at line 226 of file G4BREPSolid.hh.

Referenced by operator=().

◆ nb_of_surfaces

◆ NumberOfSolids

G4int G4BREPSolid::NumberOfSolids =0

staticprotected

Definition at line 219 of file G4BREPSolid.hh.

Referenced by StreamInfo().

◆ place

G4Axis2Placement3D* G4BREPSolid::place

protected

Definition at line 224 of file G4BREPSolid.hh.

Referenced by operator=(), and ~G4BREPSolid().

◆ PlaneSolid

G4int G4BREPSolid::PlaneSolid

protected

Definition at line 223 of file G4BREPSolid.hh.

Referenced by CheckSurfaceNormals(), G4BREPSolidBox::G4BREPSolidBox(), IsConvex(), and operator=().

◆ RealDist

G4double G4BREPSolid::RealDist

protected

Definition at line 232 of file G4BREPSolid.hh.

Referenced by operator=().

◆ ShortestDistance

G4double G4BREPSolid::ShortestDistance = kInfinity

staticprotected

Definition at line 221 of file G4BREPSolid.hh.

Referenced by G4BREPSolidCone::DistanceToIn(), DistanceToIn(), G4BREPSolidPCone::DistanceToIn(), G4BREPSolidPolyhedra::DistanceToIn(), G4BREPSolidSphere::DistanceToIn(), G4BREPSolidCone::DistanceToOut(), DistanceToOut(), G4BREPSolidPCone::DistanceToOut(), G4BREPSolidPolyhedra::DistanceToOut(), G4BREPSolidSphere::DistanceToOut(), Initialize(), G4BREPSolidCone::Initialize(), G4BREPSolidPCone::Initialize(), G4BREPSolidPolyhedra::Initialize(), Reset(), G4BREPSolidPCone::Reset(), and G4BREPSolidPolyhedra::Reset().

◆ solidname

G4String G4BREPSolid::solidname

protected

Definition at line 233 of file G4BREPSolid.hh.

Referenced by operator=().

◆ startInside

G4int G4BREPSolid::startInside

protected

Definition at line 228 of file G4BREPSolid.hh.

Referenced by operator=().

◆ SurfaceVec

G4Surface** G4BREPSolid::SurfaceVec

protected

Definition at line 231 of file G4BREPSolid.hh.

Referenced by CalcBBoxes(), CheckSurfaceNormals(), DistanceToIn(), G4BREPSolidPCone::DistanceToIn(), G4BREPSolidPolyhedra::DistanceToIn(), G4BREPSolidSphere::DistanceToIn(), G4BREPSolidCone::DistanceToIn(), G4BREPSolidCone::DistanceToOut(), DistanceToOut(), G4BREPSolidPCone::DistanceToOut(), G4BREPSolidPolyhedra::DistanceToOut(), G4BREPSolidSphere::DistanceToOut(), Initialize(), Inside(), G4BREPSolidCone::Inside(), G4BREPSolidPCone::Inside(), G4BREPSolidPolyhedra::Inside(), G4BREPSolidSphere::Inside(), Intersect(), IsConvex(), operator=(), RemoveHiddenFaces(), Reset(), G4BREPSolidPCone::Reset(), G4BREPSolidPolyhedra::Reset(), SurfaceNormal(), G4BREPSolidPCone::SurfaceNormal(), G4BREPSolidPolyhedra::SurfaceNormal(), G4BREPSolidSphere::SurfaceNormal(), G4BREPSolidCone::SurfaceNormal(), TestSurfaceBBoxes(), and ~G4BREPSolid().

◆ Track

G4Ray G4BREPSolid::Track

staticprotected

Definition at line 220 of file G4BREPSolid.hh.

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

Public Member Functions

Protected Member Functions

Protected Attributes

Static Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ G4BREPSolid() [1/4]

◆ G4BREPSolid() [2/4]

◆ ~G4BREPSolid()

◆ G4BREPSolid() [3/4]

◆ G4BREPSolid() [4/4]

Member Function Documentation

◆ Active() [1/2]

◆ Active() [2/2]

◆ CalcBBoxes()

◆ CalculateExtent()

◆ CheckSurfaceNormals()

◆ Clone()

◆ CreateNURBS()

◆ CreatePolyhedron()

◆ CreateRotatedVertices()

◆ DescribeYourselfTo()

◆ DistanceToIn() [1/2]

◆ DistanceToIn() [2/2]

◆ DistanceToOut() [1/2]

◆ DistanceToOut() [2/2]

◆ GetAreaAccuracy()

◆ GetAreaStatistics()

◆ GetBBox()

◆ GetCubicVolume()

◆ GetCubVolEpsilon()

◆ GetCubVolStatistics()

◆ GetEntityType()

◆ GetId()

◆ GetName()

◆ GetNumberOfFaces()

◆ GetNumberOfSolids()

◆ GetPlace()

◆ GetPolyhedron()

◆ GetShortestDistance()

◆ GetSurface()

◆ GetSurfaceArea()

◆ Initialize()

◆ Inside()

◆ Intersect()

◆ IntersectionDistance() [1/2]

◆ IntersectionDistance() [2/2]

◆ IsConvex()

◆ operator=()

◆ QuickSort()

◆ RemoveHiddenFaces()

◆ Reset()

◆ Scope()

◆ SetAreaAccuracy()

◆ SetAreaStatistics()

◆ SetCubVolEpsilon()

◆ SetCubVolStatistics()

◆ SetId()

◆ SetName()

◆ StartInside() [1/2]

◆ StartInside() [2/2]

◆ StreamInfo()

◆ SurfaceNormal()

◆ TestSurfaceBBoxes()

Member Data Documentation

◆ active

◆ AxisBox

◆ bbox

◆ Box

◆ Convex

◆ Id

◆ intersection_point

◆ intersectionDistance

◆ nb_of_surfaces

◆ NumberOfSolids

◆ place

◆ PlaneSolid

◆ RealDist

◆ ShortestDistance

◆ solidname