G4BREPSolidPolyhedra Class Reference

#include <G4BREPSolidPolyhedra.hh>

Inheritance diagram for G4BREPSolidPolyhedra:

Public Member Functions
	G4BREPSolidPolyhedra (const G4String &name, G4double phi1, G4double dphi, G4int sides, G4int num_z_planes, G4double z_start, G4double z_values[], G4double RMIN[], G4double RMAX[])
	~G4BREPSolidPolyhedra ()
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
G4VSolid *	Clone () const
std::ostream &	StreamInfo (std::ostream &os) const
G4Polyhedron *	CreatePolyhedron () const
void	Reset () const
	G4BREPSolidPolyhedra (__void__ &)
	G4BREPSolidPolyhedra (const G4BREPSolidPolyhedra &rhs)
G4BREPSolidPolyhedra &	operator= (const G4BREPSolidPolyhedra &rhs)
Data Structures
struct	G4BREPPolyhedraParams

---

Detailed Description

Definition at line 59 of file G4BREPSolidPolyhedra.hh.

---

Constructor & Destructor Documentation

G4BREPSolidPolyhedra::G4BREPSolidPolyhedra	(	const G4String &	name,
		G4double	phi1,
		G4double	dphi,
		G4int	sides,
		G4int	num_z_planes,
		G4double	z_start,
		G4double	z_values[],
		G4double	RMIN[],
		G4double	RMAX[]
	)

Definition at line 71 of file G4BREPSolidPolyhedra.cc.

References G4BREPSolid::active, G4endl, G4Exception(), and JustWarning.

Referenced by Clone().

  : G4BREPSolid(name)
{    
  // Store the original parameters, to be used in visualisation
  // Note radii are not scaled because this BREP uses the radius of the
  // circumscribed circle and also graphics_reps/G4Polyhedron uses the
  // radius of the circumscribed circle.
  
  // Save contructor parameters
  //
  constructorParams.start_angle    = start_angle;
  constructorParams.opening_angle  = opening_angle;
  constructorParams.sides          = sides;
  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];      
    }
  }

  // z_values[0]  should be equal to z_start, for consistency 
  //   with what the constructor does.
  // Otherwise the z_values that are shifted by (z_values[0] - z_start) , 
  //   because z_values are only used in the form 
  //   length = z_values[d+1] - z_values[d];         // JA Apr 2, 97
  
  if( z_values[0] != z_start )
  {
    std::ostringstream message;
    message << "Construction Error. z_values[0] must be equal to z_start!"
            << G4endl
            << "        Wrong solid parameters: "
            << " z_values[0]= " << z_values[0] << " is not equal to "
            << " z_start= " << z_start << ".";
    G4Exception( "G4BREPSolidPolyhedra::G4BREPSolidPolyhedra()",
                 "GeomSolids1002", JustWarning, message );
    if( num_z_planes <= 0 )  { constructorParams.z_values = new G4double[1]; }
    constructorParams.z_values[0]= z_start; 
  }

  active=1;
  InitializePolyhedra(); 
}

G4BREPSolidPolyhedra::~G4BREPSolidPolyhedra

(

)

Definition at line 148 of file G4BREPSolidPolyhedra.cc.

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

G4BREPSolidPolyhedra::G4BREPSolidPolyhedra

(

__void__ &

)

Definition at line 135 of file G4BREPSolidPolyhedra.cc.

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

G4BREPSolidPolyhedra::G4BREPSolidPolyhedra

(

const G4BREPSolidPolyhedra &

rhs

)

Definition at line 158 of file G4BREPSolidPolyhedra.cc.

References constructorParams.

  : G4BREPSolid(rhs)
{
  constructorParams.start_angle    = rhs.constructorParams.start_angle;
  constructorParams.opening_angle  = rhs.constructorParams.opening_angle;
  constructorParams.sides          = rhs.constructorParams.sides;
  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 num_z_planes = constructorParams.num_z_planes;
  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] = rhs.constructorParams.z_values[idx];
      constructorParams.RMIN[idx]     = rhs.constructorParams.RMIN[idx];
      constructorParams.RMAX[idx]     = rhs.constructorParams.RMAX[idx];      
    }
  }

  InitializePolyhedra();
}

---

Member Function Documentation

G4VSolid * G4BREPSolidPolyhedra::Clone

(

)

const [virtual]

Reimplemented from G4BREPSolid.

Definition at line 1340 of file G4BREPSolidPolyhedra.cc.

References G4BREPSolidPolyhedra().

{
  return new G4BREPSolidPolyhedra(*this);
}

G4Polyhedron * G4BREPSolidPolyhedra::CreatePolyhedron

(

)

const [virtual]

Reimplemented from G4BREPSolid.

Definition at line 1517 of file G4BREPSolidPolyhedra.cc.

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

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

Reimplemented from G4BREPSolid.

Definition at line 1106 of file G4BREPSolidPolyhedra.cc.

References G4BREPSolid::Intersect(), G4VSolid::kCarTolerance, G4BREPSolid::nb_of_surfaces, Reset(), G4BREPSolid::ShortestDistance, G4Surface::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();
  
  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 intersect 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
            // ignore it if the direction is away from the boundary
            //    
            G4Vector3D Norm = SurfaceVec[a]->SurfaceNormal(Pttmp);

            if( (Norm * Vtmp) < 0 )
            {
              ShortestDistance = surfDistance;
//              ShortestDistance = surfDistance==0
//                                 ? sqrHalfTolerance
//                                 : surfDistance;
            }
          }
        }
      }
    }
  }

  // Be careful !
  // SurfaceVec->Distance is in fact the squared distance
  //
  if(ShortestDistance != kInfinity)
  {
    return std::sqrt(ShortestDistance);
  }
  else  // no intersection
  {
    return kInfinity;
  }
}

G4double G4BREPSolidPolyhedra::DistanceToIn

(

const G4ThreeVector &

)

const [virtual]

Reimplemented from G4BREPSolid.

Definition at line 1057 of file G4BREPSolidPolyhedra.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 G4BREPSolidPolyhedra::DistanceToOut

(

const G4ThreeVector &

)

const [virtual]

Reimplemented from G4BREPSolid.

Definition at line 1285 of file G4BREPSolidPolyhedra.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();
  
  // calculate 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 Dist;
    return std::fabs(Dist);
  }
}

G4double G4BREPSolidPolyhedra::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 1187 of file G4BREPSolidPolyhedra.cc.

References G4BREPSolid::Intersect(), G4VSolid::kCarTolerance, G4BREPSolid::nb_of_surfaces, Reset(), G4BREPSolid::ShortestDistance, 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 (even number of
  // intersections greater than the tolerance).
  //
  // 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

  G4int parity = 0;

  // Set the surfaces to active again
  //
  Reset();

  const G4double sqrHalfTolerance = kCarTolerance*kCarTolerance*0.25;    
  G4Vector3D Ptv = 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; // this is actually the square of the distance
 
  for(a=0; a< nb_of_surfaces; a++)
  {
    G4double surfDistance = SurfaceVec[a]->GetDistance();
    
    if(SurfaceVec[a]->IsActive())
    {
      G4int intersects = SurfaceVec[a]->Intersect(r);

      // test if the ray intersects the surface
      //
      if( intersects != 0 )
      {
        parity += 1;

        // 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: ignore it
            //
            parity -= 1;
          }
        }
      }      
    }
  }

   G4double distance = 0.;
   
  // Be careful !
  // SurfaceVec->Distance is in fact the squared distance
  //
   // This condition was changed in order to give not zero answer
   // when particle is passing the border of two Touching Surfaces
   // and the distance to this surfaces is not zero.
   // parity is for the points on the boundary,
   // parity is counting only surfDistance<kCarTolerance/2. 
   //
   //  if((ShortestDistance != kInfinity) && (parity&1))
   //  
   //
   if((ShortestDistance != kInfinity) || (parity&1))
  {
    distance = std::sqrt(ShortestDistance);
  }

  return distance;
}

void G4BREPSolidPolyhedra::Initialize

(

)

[virtual]

Reimplemented from G4BREPSolid.

Definition at line 906 of file G4BREPSolidPolyhedra.cc.

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

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

EInside G4BREPSolidPolyhedra::Inside

(

register const G4ThreeVector &

Pt

)

const [virtual]

Reimplemented from G4BREPSolid.

Definition at line 929 of file G4BREPSolidPolyhedra.cc.

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

{
  // This function find 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 Polyhedra 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);
  
  G4int hits=0, samehit=0;

  for(G4int a=0; a < nb_of_surfaces; a++)
  {
    G4Surface* surface = SurfaceVec[a];

    if(surface->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( (surface->Intersect(r)) & 1 )
      {
        // test if the point is on the surface
        //
        if(surface->GetDistance() < sqrHalfTolerance)
        {
          return kSurface;
        }
        // test if this intersection was found before
        //
        for(G4int i=0; i<a; i++)
        {
          if(surface->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
  //
  return ( (hits&1) ? kInside : kOutside );
}

G4BREPSolidPolyhedra & G4BREPSolidPolyhedra::operator=

(

const G4BREPSolidPolyhedra &

rhs

)

Definition at line 187 of file G4BREPSolidPolyhedra.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.sides          = rhs.constructorParams.sides;
  constructorParams.num_z_planes   = rhs.constructorParams.num_z_planes;
  constructorParams.z_start        = rhs.constructorParams.z_start;
  G4int num_z_planes = constructorParams.num_z_planes;
  if( num_z_planes > 0 )
  {               
    delete [] constructorParams.z_values;
    delete [] constructorParams.RMIN;
    delete [] constructorParams.RMAX;
    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] = rhs.constructorParams.z_values[idx];
      constructorParams.RMIN[idx]     = rhs.constructorParams.RMIN[idx];
      constructorParams.RMAX[idx]     = rhs.constructorParams.RMAX[idx];      
    }
  }
  
  InitializePolyhedra();

  return *this;
}  

void G4BREPSolidPolyhedra::Reset

(

)

const [virtual]

Reimplemented from G4BREPSolid.

Definition at line 919 of file G4BREPSolidPolyhedra.cc.

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

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

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

std::ostream & G4BREPSolidPolyhedra::StreamInfo

(

std::ostream &

os

)

const [virtual]

Reimplemented from G4BREPSolid.

Definition at line 1345 of file G4BREPSolidPolyhedra.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 sides:         " << constructorParams.sides
  << "\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 G4BREPSolidPolyhedra::SurfaceNormal

(

const G4ThreeVector &

)

const [virtual]

Reimplemented from G4BREPSolid.

Definition at line 1008 of file G4BREPSolidPolyhedra.cc.

References G4FPlane::GetSrfPoint(), G4VSolid::kCarTolerance, G4BREPSolid::nb_of_surfaces, G4FPlane::SurfaceNormal(), and G4BREPSolid::SurfaceVec.

{
  // This function calculates the normal of the closest surface
  // to the given point
  // Note : the sense of the normal depends on the sense of the surface 

  G4int        iplane;
  G4bool       normflag = false;
  const G4double sqrHalfTolerance = kCarTolerance*kCarTolerance*0.25;    

  // Determine if the point is on the surface
  //
  G4double minDist = kInfinity;
  G4int normPlane = 0;
  for(iplane = 0; iplane < nb_of_surfaces; iplane++)
  {
    G4double dist = std::fabs(SurfaceVec[iplane]->HowNear(Pt));
    if( minDist > dist )
    {
      minDist = dist;
      normPlane = iplane;
    }
    if( dist < sqrHalfTolerance)
    {
      // the point is on this surface, so take this as the
      // the surface to consider for computing the normal
      //
      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[iplane]->SurfaceNormal(Pt);
    return norm.unit();
  }
  else             // point not on surface
  {
    G4FPlane* nPlane = (G4FPlane*)(SurfaceVec[normPlane]);
    G4ThreeVector hitPt = nPlane->GetSrfPoint();
    G4ThreeVector hitNorm = nPlane->SurfaceNormal(hitPt);
    return hitNorm.unit();
  }
}

---

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

• G4BREPSolidPolyhedra.hh
• G4BREPSolidPolyhedra.cc

---