G4ToroidalSurface Class Reference

#include <G4ToroidalSurface.hh>

Inheritance diagram for G4ToroidalSurface:

Public Member Functions
	G4ToroidalSurface ()
	G4ToroidalSurface (const G4Vector3D &, const G4Vector3D &, const G4Vector3D &, G4double, G4double)
virtual	~G4ToroidalSurface ()
G4String	GetEntityType () const
G4int	Intersect (const G4Ray &)
void	CalcBBox ()
G4Vector3D	GetDirection () const
G4Vector3D	GetAxis () const
G4Point3D	GetLocation () const
G4double	GetMinRadius () const
G4double	GetMaxRadius () const
G4double	ClosestDistanceToPoint (const G4Point3D &x)
virtual G4Vector3D	SurfaceNormal (const G4Point3D &Pt) const
void	MultiplyPointByMatrix (G4Point3D &Base)
void	MultiplyVectorByMatrix (G4Vector3D &DCos)
Public Member Functions inherited from G4Surface
	G4Surface ()
virtual	~G4Surface ()
G4int	operator== (const G4Surface &s)
virtual G4String	GetEntityType () const
virtual const char *	Name () const
virtual G4int	MyType () const
void	SetBoundaries (G4CurveVector *)
virtual G4double	HowNear (const G4Vector3D &x) const
virtual G4double	ClosestDistanceToPoint (const G4Point3D &Pt)
G4Vector3D	GetOrigin () const
G4double	GetDistance () const
void	SetDistance (G4double Dist)
G4int	IsActive () const
void	SetActive (G4int act)
void	Deactivate ()
void	SetSameSense (G4int sameSense0)
G4int	GetSameSense () const
G4BoundingBox3D *	GetBBox ()
const G4Point3D &	GetClosestHit () const
void	SetNextNode (G4Surface *)
G4Surface *	GetNextNode ()
virtual void	Reset ()
virtual G4int	Intersect (const G4Ray &)
virtual G4Vector3D	Normal (const G4Vector3D &p) const
virtual void	CalcBBox ()
virtual G4double	GetUHit () const
virtual G4double	GetVHit () const
virtual G4Point3D	Evaluation (const G4Ray &G4Rayref)
virtual G4int	Evaluate (register const G4Ray &Rayref)
virtual void	Project ()
virtual void	CalcNormal ()
virtual G4int	IsConvex () const
virtual G4int	GetConvex () const
virtual G4int	GetNumberOfPoints () const
virtual const G4Point3D &	GetPoint (G4int Count) const
virtual G4Ray *	Norm ()
virtual G4Vector3D	SurfaceNormal (const G4Point3D &Pt) const =0
Public Member Functions inherited from G4STEPEntity
	G4STEPEntity ()
virtual	~G4STEPEntity ()
virtual G4String	GetEntityType () const =0

Additional Inherited Members
Static Public Member Functions inherited from G4Surface
static void	Project (G4double &Coord, const G4Point3D &Pt, const G4Plane &Pl)
Protected Member Functions inherited from G4Surface
virtual void	InitBounded ()
Protected Attributes inherited from G4Surface
G4BoundingBox3D *	bbox
G4Point3D	closest_hit
G4Surface *	next
G4SurfaceBoundary	surfaceBoundary
G4double	kCarTolerance
G4double	kAngTolerance
G4int	Intersected
G4Vector3D	origin
G4int	Type
G4int	AdvancedFace
G4int	active
G4double	distance
G4double	uhit
G4double	vhit
G4int	sameSense

Detailed Description

Definition at line 46 of file G4ToroidalSurface.hh.

Constructor & Destructor Documentation

G4ToroidalSurface() [1/2]

G4ToroidalSurface::G4ToroidalSurface

(

)

Definition at line 39 of file G4ToroidalSurface.cc.

 : MinRadius(0.), MaxRadius(0.), TransMatrix(0), EQN_EPS(1e-9)
{
}

G4ToroidalSurface() [2/2]

G4ToroidalSurface::G4ToroidalSurface	(	const G4Vector3D &	Location,
		const G4Vector3D &	Ax,
		const G4Vector3D &	Dir,
		G4double	MinRad,
		G4double	MaxRad
	)

Definition at line 44 of file G4ToroidalSurface.cc.

  : EQN_EPS(1e-9)
{   
  Placement.Init(Dir, Ax, Location);
 
  MinRadius = MinRad;
  MaxRadius = MaxRad;
  TransMatrix= new G4PointMatrix(4,4);
}

~G4ToroidalSurface()

G4ToroidalSurface::~G4ToroidalSurface ( )

virtual

Definition at line 59 of file G4ToroidalSurface.cc.

{
  delete TransMatrix;
}

Member Function Documentation

CalcBBox()

void G4ToroidalSurface::CalcBBox ( )

virtual

Reimplemented from G4Surface.

Definition at line 65 of file G4ToroidalSurface.cc.

{
  // L. Broglia
  // G4Point3D Origin = Placement.GetSrfPoint();
  G4Point3D Origin = Placement.GetLocation();
 
  G4Point3D Min(Origin.x()-MaxRadius,
        Origin.y()-MaxRadius,
        Origin.z()-MaxRadius);
  G4Point3D Max(Origin.x()+MaxRadius,
        Origin.y()+MaxRadius,
        Origin.z()+MaxRadius);
 
  bbox = new G4BoundingBox3D(Min,Max);
}

ClosestDistanceToPoint()

G4double G4ToroidalSurface::ClosestDistanceToPoint ( const G4Point3D &  x )

virtual

Reimplemented from G4Surface.

Definition at line 88 of file G4ToroidalSurface.cc.

{
  // L. Broglia
  // G4Point3D Origin = Placement.GetSrfPoint();
  G4Point3D Origin = Placement.GetLocation();
 
  G4double  Dist   = Pt.distance(Origin);
 
  return ((Dist - MaxRadius)*(Dist - MaxRadius));
}

GetAxis()

G4Vector3D G4ToroidalSurface::GetAxis ( ) const

inline

GetDirection()

G4Vector3D G4ToroidalSurface::GetDirection ( ) const

inline

GetEntityType()

G4String G4ToroidalSurface::GetEntityType ( ) const

inlinevirtual

Reimplemented from G4Surface.

GetLocation()

G4Point3D G4ToroidalSurface::GetLocation ( ) const

inline

GetMaxRadius()

G4double G4ToroidalSurface::GetMaxRadius ( ) const

inline

GetMinRadius()

G4double G4ToroidalSurface::GetMinRadius ( ) const

inline

Intersect()

G4int G4ToroidalSurface::Intersect ( const G4Ray &  Ray )

virtual

Reimplemented from G4Surface.

Definition at line 100 of file G4ToroidalSurface.cc.

{
  // ----   inttor - Intersect a ray with a torus. ------------------------
  //    from GraphicsGems II by 
  
  //    Description:                             
  //        Inttor determines the intersection of a ray with a torus.    
  //                                     
  //    On entry:                            
  //        raybase = The coordinate defining the base of the        
  //              intersecting ray.                  
  //        raycos  = The G4Vector3D cosines of the above ray.       
  //        center  = The center location of the torus.          
  //        radius  = The major radius of the torus.             
  //        rplane  = The minor radius in the G4Plane of the torus.  
  //        rnorm   = The minor radius Normal to the G4Plane of the torus. 
  //        tran    = A 4x4 transformation matrix that will position     
  //              the torus at the origin and orient it such that    
  //              the G4Plane of the torus lyes in the x-z G4Plane.  
  //                                     
  //    On return:                           
  //        nhits   = The number of intersections the ray makes with     
  //              the torus.                     
  //        rhits   = The entering/leaving distances of the      
  //              intersections.                     
  //                                     
  //    Returns:  True if the ray intersects the torus.          
  //                                     
  // --------------------------------------------------------------------
       
  // Variables. Should be optimized later...
  G4Point3D  Base = Ray.GetStart();   // Base of the intersection ray
  G4Vector3D DCos = Ray.GetDir();     // Direction cosines of the ray
  G4int      nhits=0;             // Number of intersections
  G4double   rhits[4];            // Intersection distances
  G4double   hits[4] = {0.,0.,0.,0.}; // Ordered intersection distances
  G4double   rho, a0, b0;         // Related constants      
  G4double   f, l, t, g1, q, m1, u;   // Ray dependent terms        
  G4double   C[5];            // Quartic coefficients         
    
  //    Transform the intersection ray                  
  
  
  //    MultiplyPointByMatrix  (Base);  // Matriisi puuttuu viela!
  //    MultiplyVectorByMatrix (DCos);
  
  //    Compute constants related to the torus. 
  G4double rnorm = MaxRadius - MinRadius; // ei tietoa onko oikein...
  rho = MinRadius*MinRadius / (rnorm*rnorm);
  a0  = 4. * MaxRadius*MaxRadius;
  b0  = MaxRadius*MaxRadius - MinRadius*MinRadius;
  
  //    Compute ray dependent terms.                       
  f = 1. - DCos.y()*DCos.y();
  l = 2. * (Base.x()*DCos.x() + Base.z()*DCos.z());
  t = Base.x()*Base.x() + Base.z()*Base.z();
  g1 = f + rho * DCos.y()*DCos.y();
  q = a0 / (g1*g1);
  m1 = (l + 2.*rho*DCos.y()*Base.y()) / g1;
  u = (t +    rho*Base.y()*Base.y() + b0) / g1;
    
  //    Compute the coefficients of the quartic.            
  
  C[4] = 1.0;
  C[3] = 2. * m1;
  C[2] = m1*m1 + 2.*u - q*f;
  C[1] = 2.*m1*u - q*l;
  C[0] = u*u - q*t;
    
  //    Use quartic root solver found in "Graphics Gems" by Jochen Schwarze.
  nhits = SolveQuartic (C,rhits);
  
  //    SolveQuartic returns root pairs in reversed order.      
  m1 = rhits[0]; u = rhits[1]; rhits[0] = u; rhits[1] = m1;
  m1 = rhits[2]; u = rhits[3]; rhits[2] = u; rhits[3] = m1;
 
  //    return (*nhits != 0);
  
  if(nhits != 0)
  {
    // Convert Hit distances to intersection points
    /*
      G4Point3D** IntersectionPoints = new G4Point3D*[nhits];
      for(G4int a=0;a<nhits;a++)
      {
      G4double Dist = rhits[a];
      IntersectionPoints[a] = new G4Point3D((Base - Dist * DCos)); 
      }
      // Check wether any of the hits are on the actual surface
      // Start with checking for the intersections that are Inside the bbox
      
      G4Point3D* Hit;
      G4int InsideBox[2]; // Max 2 intersections on the surface
      G4int Counter=0;
    */
 
    G4Point3D BoxMin = bbox->GetBoxMin();
    G4Point3D BoxMax = bbox->GetBoxMax();
    G4Point3D Hit;
    G4int       c1     = 0;
    G4int       c2;
    G4double  tempVec[4];
    
    for(G4int a=0;a<nhits;a++) 
    {
      while ( (c1 < 4) && (hits[c1] <= rhits[a]) )
      {
    tempVec[c1]=hits[c1]; 
    c1++;
      }
    
      for(c2=c1+1;c2<4;c2++) 
    tempVec[c2]=hits[c2-1];
    
      if(c1<4) 
      {
    tempVec[c1]=rhits[a];
    
    for(c2=0;c2<4;c2++)
      hits[c2]=tempVec[c2];
      }
    }
    
    for(G4int b=0;b<nhits;b++)
    {
      //        Hit = IntersectionPoints[b]; 
      if(hits[b] >=kCarTolerance*0.5)
      {
    Hit = Base + (hits[b]*DCos);
    //        InsideBox[Counter]=b;
    if( (Hit.x() > BoxMin.x()) &&
        (Hit.x() < BoxMax.x()) &&
        (Hit.y() > BoxMin.y()) &&
        (Hit.y() < BoxMax.y()) &&       
        (Hit.z() > BoxMin.z()) &&
        (Hit.z() < BoxMax.z())    )
    {
      closest_hit = Hit;
      distance =  hits[b]*hits[b];
      return 1;
    }
    
    //          Counter++;
      }
    }
    
    // If two Inside bbox, find closest 
    // G4int Closest=0;
    
    //      if(Counter>1)
    //      if(rhits[InsideBox[0]] > rhits[InsideBox[1]])
    //          Closest=1;
    
    // Project polygon and do point in polygon
    // Projection also for curves etc.
    // Should probably be implemented in the curve class. 
    // G4Plane Plane1 = Ray.GetPlane(1);
    // G4Plane Plane2 = Ray.GetPlane(2);
    
    // Point in polygon
    return 1;
  }
  return 0;
}

MultiplyPointByMatrix()

void G4ToroidalSurface::MultiplyPointByMatrix ( G4Point3D &  Base )

inline

MultiplyVectorByMatrix()

void G4ToroidalSurface::MultiplyVectorByMatrix ( G4Vector3D &  DCos )

inline

SurfaceNormal()

G4Vector3D G4ToroidalSurface::SurfaceNormal ( const G4Point3D &  Pt ) const

virtual

Implements G4Surface.

Definition at line 82 of file G4ToroidalSurface.cc.

{
  return G4Vector3D(0,0,0);
}

---

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

• G4ToroidalSurface.hh
• G4ToroidalSurface.cc