G4BREPSolidPCone Class Reference

#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)
Data Structures
struct	G4BREPPConeParams

---

Detailed Description

Definition at line 57 of file G4BREPSolidPCone.hh.

---

Constructor & Destructor Documentation

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.

References G4BREPSolid::active.

Referenced by Clone().

  : 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

(

)

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

(

__void__ &

)

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

(

const G4BREPSolidPCone &

rhs

)

Definition at line 117 of file G4BREPSolidPCone.cc.

References constructorParams.

  : 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

G4VSolid * G4BREPSolidPCone::Clone

(

)

const [virtual]

Reimplemented from G4BREPSolid.

Definition at line 1048 of file G4BREPSolidPCone.cc.

References G4BREPSolidPCone().

{
  return new G4BREPSolidPCone(*this);
}

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

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

Reimplemented from G4BREPSolid.

Definition at line 856 of file G4BREPSolidPCone.cc.

References G4Surface::GetDistance(), G4Surface::HowNear(), G4BREPSolid::Intersect(), G4VSolid::kCarTolerance, G4BREPSolid::nb_of_surfaces, Reset(), G4BREPSolid::ShortestDistance, SurfaceNormal(), G4BREPSolid::SurfaceVec, and G4BREPSolid::TestSurfaceBBoxes().

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

G4double G4BREPSolidPCone::DistanceToIn

(

const G4ThreeVector &

)

const [virtual]

Reimplemented from G4BREPSolid.

Definition at line 812 of file G4BREPSolidPCone.cc.

References G4BREPSolid::nb_of_surfaces, Reset(), and G4BREPSolid::SurfaceVec.

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

G4double G4BREPSolidPCone::DistanceToOut

(

const G4ThreeVector &

)

const [virtual]

Reimplemented from G4BREPSolid.

Definition at line 1005 of file G4BREPSolidPCone.cc.

References G4BREPSolid::nb_of_surfaces, Reset(), and G4BREPSolid::SurfaceVec.

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

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.

References G4Surface::GetDistance(), G4Surface::HowNear(), G4BREPSolid::Intersect(), G4VSolid::kCarTolerance, G4BREPSolid::nb_of_surfaces, Reset(), G4BREPSolid::ShortestDistance, SurfaceNormal(), G4BREPSolid::SurfaceVec, and G4BREPSolid::TestSurfaceBBoxes().

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

void G4BREPSolidPCone::Initialize

(

)

[virtual]

Reimplemented from G4BREPSolid.

Definition at line 665 of file G4BREPSolidPCone.cc.

References G4BREPSolid::AxisBox, G4BREPSolid::Box, G4BREPSolid::CalcBBoxes(), G4BREPSolid::CheckSurfaceNormals(), G4BREPSolid::IsConvex(), and G4BREPSolid::ShortestDistance.

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

EInside G4BREPSolidPCone::Inside

(

register const G4ThreeVector &

Pt

)

const [virtual]

Reimplemented from G4BREPSolid.

Definition at line 679 of file G4BREPSolidPCone.cc.

References G4BREPSolid::GetBBox(), G4VSolid::kCarTolerance, kInside, kOutside, kSurface, G4BREPSolid::nb_of_surfaces, Reset(), G4Surface::SurfaceNormal(), G4BREPSolid::SurfaceVec, and G4BREPSolid::TestSurfaceBBoxes().

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

G4BREPSolidPCone & G4BREPSolidPCone::operator=

(

const G4BREPSolidPCone &

rhs

)

Definition at line 145 of file G4BREPSolidPCone.cc.

References constructorParams, and G4BREPSolid::operator=().

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

void G4BREPSolidPCone::Reset

(

)

const [virtual]

Reimplemented from G4BREPSolid.

Definition at line 1083 of file G4BREPSolidPCone.cc.

References G4BREPSolid::Active(), G4BREPSolid::nb_of_surfaces, G4BREPSolid::ShortestDistance, G4BREPSolid::StartInside(), and G4BREPSolid::SurfaceVec.

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

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

std::ostream & G4BREPSolidPCone::StreamInfo

(

std::ostream &

os

)

const [virtual]

Reimplemented from G4BREPSolid.

Definition at line 1053 of file G4BREPSolidPCone.cc.

References G4BREPSolid::StreamInfo().

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

G4ThreeVector G4BREPSolidPCone::SurfaceNormal

(

const G4ThreeVector &

)

const [virtual]

Reimplemented from G4BREPSolid.

Definition at line 763 of file G4BREPSolidPCone.cc.

References G4Surface::GetClosestHit(), G4VSolid::kCarTolerance, G4BREPSolid::nb_of_surfaces, G4Surface::SurfaceNormal(), and G4BREPSolid::SurfaceVec.

Referenced by DistanceToIn(), and DistanceToOut().

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

• G4BREPSolidPCone.hh
• G4BREPSolidPCone.cc

---