#include <G4BREPSolidPCone.hh>

Inheritance diagram for G4BREPSolidPCone:

Public Member Functions
	G4BREPSolidPCone (const G4String &name, G4double start_angle, G4double opening_angle, G4int num_z_planes, G4double z_start, G4double z_values[], G4double RMIN[], G4double RMAX[])

	~G4BREPSolidPCone ()

void	Initialize ()

EInside	Inside (register const G4ThreeVector &Pt) const

G4ThreeVector	SurfaceNormal (const G4ThreeVector &) const

G4double	DistanceToIn (const G4ThreeVector &) const

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

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

G4double	DistanceToOut (const G4ThreeVector &) const

void	Reset () const

G4Polyhedron *	CreatePolyhedron () const

G4VSolid *	Clone () const

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

	G4BREPSolidPCone (__void__ &)

	G4BREPSolidPCone (const G4BREPSolidPCone &rhs)

G4BREPSolidPCone &	operator= (const G4BREPSolidPCone &rhs)

Public Member Functions inherited from G4BREPSolid
	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)

Additional Inherited Members
Protected Member Functions inherited from G4BREPSolid
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 inherited from G4BREPSolid
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 inherited from G4BREPSolid
static G4int	NumberOfSolids =0

static G4Ray	Track

static G4double	ShortestDistance = kInfinity

Detailed Description

Definition at line 57 of file G4BREPSolidPCone.hh.

Constructor & Destructor Documentation

◆ G4BREPSolidPCone() [1/3]

G4BREPSolidPCone::G4BREPSolidPCone	(	const G4String &	name,
		G4double	start_angle,
		G4double	opening_angle,
		G4int	num_z_planes,
		G4double	z_start,
		G4double	z_values[],
		G4double	RMIN[],
		G4double	RMAX[]
	)

Definition at line 58 of file G4BREPSolidPCone.cc.

  : G4BREPSolid(name)
{
  // Save contructor parameters
  //
  constructorParams.start_angle    = start_angle;
  constructorParams.opening_angle  = opening_angle;
  constructorParams.num_z_planes   = num_z_planes;
  constructorParams.z_start        = z_start;
  constructorParams.z_values       = 0;
  constructorParams.RMIN           = 0;
  constructorParams.RMAX           = 0;
  
  if( num_z_planes > 0 )
  {               
    constructorParams.z_values       = new G4double[num_z_planes];
    constructorParams.RMIN           = new G4double[num_z_planes];
    constructorParams.RMAX           = new G4double[num_z_planes];
    for( G4int idx = 0; idx < num_z_planes; ++idx )
    {
      constructorParams.z_values[idx] = z_values[idx];
      constructorParams.RMIN[idx]     = RMIN[idx];
      constructorParams.RMAX[idx]     = RMAX[idx];      
    }
  }
 
  active=1;
  InitializePCone();
}

◆ ~G4BREPSolidPCone()

G4BREPSolidPCone::~G4BREPSolidPCone ( )

Definition at line 107 of file G4BREPSolidPCone.cc.

{
  if( constructorParams.num_z_planes > 0 )
  {
    delete [] constructorParams.z_values;
    delete [] constructorParams.RMIN;
    delete [] constructorParams.RMAX;
  }
}

◆ G4BREPSolidPCone() [2/3]

G4BREPSolidPCone::G4BREPSolidPCone ( __void__ & a )

Definition at line 95 of file G4BREPSolidPCone.cc.

  : G4BREPSolid(a)
{
  constructorParams.start_angle    = 0.;
  constructorParams.opening_angle  = 0.;
  constructorParams.num_z_planes   = 0;
  constructorParams.z_start        = 0.;
  constructorParams.z_values = 0;
  constructorParams.RMIN = 0;
  constructorParams.RMAX = 0;
}

◆ G4BREPSolidPCone() [3/3]

G4BREPSolidPCone::G4BREPSolidPCone ( const G4BREPSolidPCone & rhs )

Definition at line 117 of file G4BREPSolidPCone.cc.

  : G4BREPSolid(rhs)
{
  constructorParams.start_angle   = rhs.constructorParams.start_angle;
  constructorParams.opening_angle = rhs.constructorParams.opening_angle;
  constructorParams.num_z_planes  = rhs.constructorParams.num_z_planes;
  constructorParams.z_start       = rhs.constructorParams.z_start;
  constructorParams.z_values = 0;
  constructorParams.RMIN     = 0;
  constructorParams.RMAX     = 0;
  G4int nplanes = constructorParams.num_z_planes;
  if( nplanes > 0 )
  {
    constructorParams.z_values = new G4double[nplanes];
    constructorParams.RMIN     = new G4double[nplanes];
    constructorParams.RMAX     = new G4double[nplanes];
    for( G4int idx = 0; idx < nplanes; ++idx )
    {
      constructorParams.z_values[idx] = rhs.constructorParams.z_values[idx];
      constructorParams.RMIN[idx]     = rhs.constructorParams.RMIN[idx];
      constructorParams.RMAX[idx]     = rhs.constructorParams.RMAX[idx];      
    }
  }
  
  InitializePCone();
}

Member Function Documentation

◆ Clone()

G4VSolid * G4BREPSolidPCone::Clone ( ) const

virtual

Reimplemented from G4BREPSolid.

Definition at line 1048 of file G4BREPSolidPCone.cc.

{
  return new G4BREPSolidPCone(*this);
}

◆ CreatePolyhedron()

G4Polyhedron * G4BREPSolidPCone::CreatePolyhedron ( ) const

virtual

Reimplemented from G4BREPSolid.

Definition at line 1150 of file G4BREPSolidPCone.cc.

{
  return new G4PolyhedronPcon( constructorParams.start_angle, 
                               constructorParams.opening_angle, 
                               constructorParams.num_z_planes, 
                               constructorParams.z_values,
                               constructorParams.RMIN,
                               constructorParams.RMAX );
}

◆ DistanceToIn() [1/2]

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

virtual

Reimplemented from G4BREPSolid.

Definition at line 812 of file G4BREPSolidPCone.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 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 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)
    // the point is inside the solid or on a surface
    //
    return 0;
  else 
    return std::fabs(Dist);
}

◆ DistanceToIn() [2/2]

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

virtual

Reimplemented from G4BREPSolid.

Definition at line 856 of file G4BREPSolidPCone.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();
  
  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 intersect the surface
      //
      G4Vector3D Norm = SurfaceVec[a]->SurfaceNormal(Pttmp);
      G4double hownear = SurfaceVec[a]->HowNear(Pt);
      
      if( (Norm * Vtmp) < 0 && std::fabs(hownear) < sqrHalfTolerance )
        return 0;
      
      if( (SurfaceVec[a]->Intersect(r)) )
      {
        // if more than 1 surface is intersected,
        // take the nearest one
        G4double distance = SurfaceVec[a]->GetDistance();
        
        if( distance < ShortestDistance )
        {
          if( distance > sqrHalfTolerance )
          {
            ShortestDistance = distance;
          }
        }
      }
    }
  }
  
  // Be careful !
  // SurfaceVec->Distance is in fact the squared distance
  //
  if(ShortestDistance != kInfinity)
    return( std::sqrt(ShortestDistance) );
  else
    // no intersection
    //
    return kInfinity; 
}

◆ DistanceToOut() [1/2]

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

virtual

Reimplemented from G4BREPSolid.

Definition at line 1005 of file G4BREPSolidPCone.cc.

{
  // Calculates the shortest distance ("safety") from a point
  // inside the solid to any boundary of this solid.
  // Return 0 if the point is already outside.
 
  G4double *dists = new G4double[nb_of_surfaces];
  G4int a;
 
  // Set the surfaces to active again
  Reset();
  
  // calcul of 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)
    // the point is ouside the solid or on a surface
    //
    return 0;
  else
    return std::fabs(Dist);
}

◆ DistanceToOut() [2/2]

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

virtual

Reimplemented from G4BREPSolid.

Definition at line 924 of file G4BREPSolidPCone.cc.

{
  // Calculates the distance from a point inside the solid
  // to the solid`s boundary along a specified direction vector.
  // Return 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 = G4Vector3D( Pt );
  G4int a;
 
  // I don`t understand this line
  //
  if(validNorm)
    *validNorm=false;
 
  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() )
    {
      G4Vector3D Norm = SurfaceVec[a]->SurfaceNormal(Pttmp);
      G4double hownear = SurfaceVec[a]->HowNear(Pt);
      
      if( (Norm * Vtmp) > 0 && std::fabs( hownear ) < sqrHalfTolerance )
        return 0;
      
      // test if the ray intersect the surface
      //
      if( SurfaceVec[a]->Intersect(r) )
      {
        // if more than 1 surface is intersected,
        // take the nearest one
        //
        G4double distance = SurfaceVec[a]->GetDistance();
 
        if( distance < ShortestDistance )
        {
          if( distance > sqrHalfTolerance )
          {
            ShortestDistance = distance;
          }
        }
      }
    }
  }
 
  // Be careful !
  // SurfaceVec->Distance is in fact the squared distance
  //
  if(ShortestDistance != kInfinity)
    return std::sqrt(ShortestDistance);
  else
    // if no intersection is founded, the point is outside
    //
    return 0; 
}

◆ Initialize()

void G4BREPSolidPCone::Initialize ( )

virtual

Reimplemented from G4BREPSolid.

Definition at line 665 of file G4BREPSolidPCone.cc.

{ 
  // Computes the bounding box for solids and surfaces
  // Converts concave planes to convex
  //    
  ShortestDistance=1000000;
  CheckSurfaceNormals();
  
  if(!Box || !AxisBox)
    IsConvex();
  
  CalcBBoxes();
}

◆ Inside()

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

virtual

Reimplemented from G4BREPSolid.

Definition at line 679 of file G4BREPSolidPCone.cc.

{
  // This function find if the point Pt is inside, 
  // outside or on the surface of the solid
 
  G4Vector3D v(1, 0, 0.01);
  //G4Vector3D v(1, 0, 0); // This will miss the planar surface perp. to Z axis
  //G4Vector3D v(0, 0, 1); // This works, however considered as hack not a fix
  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 is deactivated.
  //
  TestSurfaceBBoxes(r);
  
  G4double dist = kInfinity;
  G4bool isIntersected = false;
  G4int WhichSurface = 0;
 
  const G4double sqrHalfTolerance = kCarTolerance*kCarTolerance*0.25;
 
  // Chech if the point is on the surface, otherwise
  // find the nearest intersected suface. If there are not intersections the
  // point is outside
 
  for(G4int a=0; a < nb_of_surfaces; a++)
  {
    G4Surface* surface = SurfaceVec[a];
    
    if( surface->IsActive() )
    {
      G4double hownear = surface->HowNear(Pt);
      
      if( std::fabs( hownear ) < sqrHalfTolerance )
      {
        return kSurface;
      }
 
      if( surface->Intersect(r) )
      {
        isIntersected = true;
        hownear = surface->GetDistance();
        
        if ( std::fabs( hownear ) < dist )
        {
          dist         = hownear;
          WhichSurface = a;
        }
      }
    }
  }
  
  if ( !isIntersected )
  {
    return kOutside;
  }
 
  // Find the point of intersection on the surface and the normal
  // !!!! be carefull the distance is std::sqrt(dist) !!!!
 
  dist = std::sqrt( dist );
  G4Vector3D IntersectionPoint = Pttmp + dist*Vtmp;
  G4Vector3D Normal =
             SurfaceVec[WhichSurface]->SurfaceNormal( IntersectionPoint );
  
  G4double dot = Normal*Vtmp;
  
  return ( (dot > 0) ? kInside : kOutside );
}

Referenced by Inside().

◆ operator=()

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

Definition at line 145 of file G4BREPSolidPCone.cc.

{
  // Check assignment to self
  //
  if (this == &rhs)  { return *this; }
 
  // Copy base class data
  //
  G4BREPSolid::operator=(rhs);
 
  // Copy data
  //
  constructorParams.start_angle   = rhs.constructorParams.start_angle;
  constructorParams.opening_angle = rhs.constructorParams.opening_angle;
  constructorParams.num_z_planes  = rhs.constructorParams.num_z_planes;
  constructorParams.z_start       = rhs.constructorParams.z_start;
  G4int nplanes = constructorParams.num_z_planes;
  if( nplanes > 0 )
  {
    delete [] constructorParams.z_values;
    delete [] constructorParams.RMIN;
    delete [] constructorParams.RMAX;
    constructorParams.z_values = new G4double[nplanes];
    constructorParams.RMIN     = new G4double[nplanes];
    constructorParams.RMAX     = new G4double[nplanes];
    for( G4int idx = 0; idx < nplanes; ++idx )
    {
      constructorParams.z_values[idx] = rhs.constructorParams.z_values[idx];
      constructorParams.RMIN[idx]     = rhs.constructorParams.RMIN[idx];
      constructorParams.RMAX[idx]     = rhs.constructorParams.RMAX[idx];      
    }
  }
  
  InitializePCone();
 
  return *this;
}  

◆ Reset()

void G4BREPSolidPCone::Reset ( ) const

virtual

Reimplemented from G4BREPSolid.

Definition at line 1083 of file G4BREPSolidPCone.cc.

{
  Active(1);
  ((G4BREPSolidPCone*)this)->intersectionDistance=kInfinity;
  StartInside(0);
  for(register int a=0;a<nb_of_surfaces;a++)
    SurfaceVec[a]->Reset();
  ShortestDistance = kInfinity;
}

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

◆ StreamInfo()

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

virtual

Reimplemented from G4BREPSolid.

Definition at line 1053 of file G4BREPSolidPCone.cc.

{  
  // Streams solid contents to output stream.
 
  G4BREPSolid::StreamInfo( os )
  << "\n start_angle:   " << constructorParams.start_angle
  << "\n opening_angle: " << constructorParams.opening_angle
  << "\n num_z_planes:  " << constructorParams.num_z_planes
  << "\n z_start:       " << constructorParams.z_start
  << "\n z_values:      ";
  G4int idx;
  for( idx = 0; idx < constructorParams.num_z_planes; idx++ )
  {
    os << constructorParams.z_values[idx] << " ";
  }
  os << "\n RMIN:          "; 
  for( idx = 0; idx < constructorParams.num_z_planes; idx++ )
  {
    os << constructorParams.RMIN[idx] << " ";
  }
  os << "\n RMAX:          ";
  for( idx = 0; idx < constructorParams.num_z_planes; idx++ )
  {
    os << constructorParams.RMAX[idx] << " ";
  }
  os << "\n-----------------------------------------------------------\n";
 
  return os;
}

◆ SurfaceNormal()

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

virtual

Reimplemented from G4BREPSolid.

Definition at line 763 of file G4BREPSolidPCone.cc.

{  
  // This function calculates the normal of the closest surface
  // at a point on the surface
  // Note : the sense of the normal depends on the sense of the surface 
 
  G4int        isurf;
  G4bool       normflag = false;
 
  const G4double sqrHalfTolerance = kCarTolerance*kCarTolerance*0.25;
 
  // Determine if the point is on the surface
  //
  G4double minDist = kInfinity;
  G4int normSurface = 0;
  for(isurf = 0; isurf < nb_of_surfaces; isurf++)
  {
    G4double dist = std::fabs(SurfaceVec[isurf]->HowNear(Pt));
    if( minDist > dist )
    {
      minDist = dist;
      normSurface = isurf;
    }
    if( dist < sqrHalfTolerance)
    {
      // the point is on this surface
      //
      normflag = true;
      break;
    }
  }
  
  // Calculate the normal at this point, if the point is on the
  // surface, otherwise compute the normal to the closest surface
  //
  if ( normflag )  // point on surface
  {
    G4ThreeVector norm = SurfaceVec[isurf]->SurfaceNormal(Pt);
    return norm.unit();
  }
  else             // point not on surface
  {
    G4Surface* nSurface = SurfaceVec[normSurface];
    G4ThreeVector hitPt = nSurface->GetClosestHit();
    G4ThreeVector hitNorm = nSurface->SurfaceNormal(hitPt);
    return hitNorm.unit();
  }
}

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

Public Member Functions

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4BREPSolidPCone() [1/3]

◆ ~G4BREPSolidPCone()

◆ G4BREPSolidPCone() [2/3]

◆ G4BREPSolidPCone() [3/3]

Member Function Documentation

◆ Clone()

◆ CreatePolyhedron()

◆ DistanceToIn() [1/2]

◆ DistanceToIn() [2/2]

◆ DistanceToOut() [1/2]

◆ DistanceToOut() [2/2]

◆ Initialize()

◆ Inside()

◆ operator=()

◆ Reset()

◆ StreamInfo()

◆ SurfaceNormal()