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)

---

Detailed Description

Definition at line 46 of file G4ToroidalSurface.hh.

---

Constructor & Destructor Documentation

G4ToroidalSurface::G4ToroidalSurface

(

)

Definition at line 39 of file G4ToroidalSurface.cc.

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

G4ToroidalSurface::G4ToroidalSurface	(	const G4Vector3D &	,
		const G4Vector3D &	,
		const G4Vector3D &	,
		G4double	,
		G4double
	)

Definition at line 44 of file G4ToroidalSurface.cc.

References G4Axis2Placement3D::Init().

  : EQN_EPS(1e-9)
{   
  Placement.Init(Dir, Ax, Location);

  MinRadius = MinRad;
  MaxRadius = MaxRad;
  TransMatrix= new G4PointMatrix(4,4);
}

G4ToroidalSurface::~G4ToroidalSurface

(

)

[virtual]

Definition at line 59 of file G4ToroidalSurface.cc.

{
  delete TransMatrix;
}

---

Member Function Documentation

void G4ToroidalSurface::CalcBBox

(

)

[virtual]

Reimplemented from G4Surface.

Definition at line 65 of file G4ToroidalSurface.cc.

References G4Surface::bbox, and G4Axis2Placement3D::GetLocation().

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

G4double G4ToroidalSurface::ClosestDistanceToPoint

(

const G4Point3D &

x

)

[virtual]

Reimplemented from G4Surface.

Definition at line 88 of file G4ToroidalSurface.cc.

References G4Axis2Placement3D::GetLocation().

{
  // L. Broglia
  // G4Point3D Origin = Placement.GetSrfPoint();
  G4Point3D Origin = Placement.GetLocation();

  G4double  Dist   = Pt.distance(Origin);

  return ((Dist - MaxRadius)*(Dist - MaxRadius));
}

G4Vector3D G4ToroidalSurface::GetAxis

(

)

const [inline]

Definition at line 50 of file G4ToroidalSurface.icc.

References G4Axis2Placement3D::GetAxis().

{
  return Placement.GetAxis();
}

G4Vector3D G4ToroidalSurface::GetDirection

(

)

const [inline]

Definition at line 44 of file G4ToroidalSurface.icc.

References G4Axis2Placement3D::GetRefDirection().

{
  return Placement.GetRefDirection();
}

G4String G4ToroidalSurface::GetEntityType

(

)

const [inline, virtual]

Reimplemented from G4Surface.

Definition at line 38 of file G4ToroidalSurface.icc.

{
  return G4String("Toroidal_Surface");
}

G4Point3D G4ToroidalSurface::GetLocation

(

)

const [inline]

Definition at line 56 of file G4ToroidalSurface.icc.

References G4Axis2Placement3D::GetLocation().

{
  return Placement.GetLocation();
}

G4double G4ToroidalSurface::GetMaxRadius

(

)

const [inline]

Definition at line 67 of file G4ToroidalSurface.icc.

{
  return MaxRadius;
}

G4double G4ToroidalSurface::GetMinRadius

(

)

const [inline]

Definition at line 62 of file G4ToroidalSurface.icc.

{
  return MinRadius;
}

G4int G4ToroidalSurface::Intersect

(

const G4Ray &

)

[virtual]

Reimplemented from G4Surface.

Definition at line 100 of file G4ToroidalSurface.cc.

References G4Surface::bbox, G4Surface::closest_hit, G4Surface::distance, G4BoundingBox3D::GetBoxMax(), G4BoundingBox3D::GetBoxMin(), G4Ray::GetDir(), G4Ray::GetStart(), and G4Surface::kCarTolerance.

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

void G4ToroidalSurface::MultiplyPointByMatrix

(

G4Point3D &

Base

)

[inline]

Definition at line 73 of file G4ToroidalSurface.icc.

References G4PointMatrix::get().

{
  Base.setX((Base.x() * TransMatrix->get(0,0)) + 
            (Base.y() * TransMatrix->get(1,0)) + 
            (Base.z() * TransMatrix->get(2,0)));
  Base.setY((Base.x() * TransMatrix->get(0,1)) + 
            (Base.y() * TransMatrix->get(1,1)) + 
            (Base.z() * TransMatrix->get(2,1)));
  Base.setZ((Base.x() * TransMatrix->get(0,2)) + 
            (Base.y() * TransMatrix->get(1,2)) + 
            (Base.z() * TransMatrix->get(2,2)));
}

void G4ToroidalSurface::MultiplyVectorByMatrix

(

G4Vector3D &

DCos

)

[inline]

Definition at line 87 of file G4ToroidalSurface.icc.

References G4PointMatrix::get().

{
  G4double w;
  DCos.setX((DCos.x() * TransMatrix->get(0,0)) + 
            (DCos.y() * TransMatrix->get(1,0)) + 
            (DCos.z() * TransMatrix->get(2,0)) + TransMatrix->get(3,0));

  DCos.setY((DCos.x() * TransMatrix->get(0,1)) + 
            (DCos.y() * TransMatrix->get(1,1)) + 
            (DCos.z() * TransMatrix->get(2,1)) + TransMatrix->get(3,1));

  DCos.setY((DCos.x() * TransMatrix->get(0,2)) + 
            (DCos.y() * TransMatrix->get(1,2)) + 
            (DCos.z() * TransMatrix->get(2,2)) + TransMatrix->get(3,2));
  
  w      = ((DCos.x() * TransMatrix->get(0,3)) + 
            (DCos.y() * TransMatrix->get(1,3)) + 
            (DCos.z() * TransMatrix->get(2,3)) + TransMatrix->get(3,3));
    
  if (w != 0.0) 
  {
    DCos.setX(DCos.x() / w);  
    DCos.setY(DCos.y() / w); 
    DCos.setZ(DCos.z() / w);
  }
}

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.icc
• G4ToroidalSurface.cc

---