#include <G4Para.hh>

Inheritance diagram for G4Para:

Collaboration diagram for G4Para:

Public Member Functions
	G4Para (const G4String &pName, G4double pDx, G4double pDy, G4double pDz, G4double pAlpha, G4double pTheta, G4double pPhi)

	G4Para (const G4String &pName, const G4ThreeVector pt[8])

virtual	~G4Para ()

G4double	GetZHalfLength () const

G4ThreeVector	GetSymAxis () const

G4double	GetYHalfLength () const

G4double	GetXHalfLength () const

G4double	GetTanAlpha () const

void	SetXHalfLength (G4double val)

void	SetYHalfLength (G4double val)

void	SetZHalfLength (G4double val)

void	SetAlpha (G4double alpha)

void	SetTanAlpha (G4double val)

void	SetThetaAndPhi (double pTheta, double pPhi)

void	SetAllParameters (G4double pDx, G4double pDy, G4double pDz, G4double pAlpha, G4double pTheta, G4double pPhi)

G4double	GetCubicVolume ()

G4double	GetSurfaceArea ()

void	ComputeDimensions (G4VPVParameterisation p, const G4int n, const G4VPhysicalVolume pRep)

G4bool	CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pMin, G4double &pMax) const

EInside	Inside (const G4ThreeVector &p) const

G4ThreeVector	SurfaceNormal (const G4ThreeVector &p) const

G4double	DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const

G4double	DistanceToIn (const G4ThreeVector &p) const

G4double	DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=G4bool(false), G4bool validNorm=0, G4ThreeVector n=0) const

G4double	DistanceToOut (const G4ThreeVector &p) const

G4GeometryType	GetEntityType () const

G4ThreeVector	GetPointOnSurface () const

G4VSolid *	Clone () const

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

void	DescribeYourselfTo (G4VGraphicsScene &scene) const

G4Polyhedron *	CreatePolyhedron () const

	G4Para (__void__ &)

	G4Para (const G4Para &rhs)

G4Para &	operator= (const G4Para &rhs)

Public Member Functions inherited from G4CSGSolid
	G4CSGSolid (const G4String &pName)

virtual	~G4CSGSolid ()

virtual G4Polyhedron *	GetPolyhedron () const

	G4CSGSolid (__void__ &)

	G4CSGSolid (const G4CSGSolid &rhs)

G4CSGSolid &	operator= (const G4CSGSolid &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

void	DumpInfo () const

virtual G4VisExtent	GetExtent () 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)

G4double	EstimateCubicVolume (G4int nStat, G4double epsilon) const

G4double	EstimateSurfaceArea (G4int nStat, G4double ell) const

Protected Member Functions
G4ThreeVectorList *	CreateRotatedVertices (const G4AffineTransform &pTransform) const

Protected Member Functions inherited from G4CSGSolid
G4double	GetRadiusInRing (G4double rmin, G4double rmax) 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

Private Member Functions
G4ThreeVector	ApproxSurfaceNormal (const G4ThreeVector &p) const

G4ThreeVector	GetPointOnPlane (G4ThreeVector p0, G4ThreeVector p1, G4ThreeVector p2, G4ThreeVector p3, G4double &area) const

Private Attributes
G4double	fDx

G4double	fDy

G4double	fDz

G4double	fTalpha

G4double	fTthetaCphi

G4double	fTthetaSphi

Additional Inherited Members
Protected Attributes inherited from G4CSGSolid
G4double	fCubicVolume

G4double	fSurfaceArea

G4bool	fRebuildPolyhedron

G4Polyhedron *	fpPolyhedron

Protected Attributes inherited from G4VSolid
G4double	kCarTolerance

Detailed Description

Definition at line 77 of file G4Para.hh.

Constructor & Destructor Documentation

◆ G4Para() [1/4]

G4Para::G4Para	(	const G4String &	pName,
		G4double	pDx,
		G4double	pDy,
		G4double	pDz,
		G4double	pAlpha,
		G4double	pTheta,
		G4double	pPhi
	)

Definition at line 98 of file G4Para.cc.

   : G4CSGSolid(pName)
 {
   if ((pDx<=0) || (pDy<=0) || (pDz<=0))
   {
     std::ostringstream message;
     message << "Invalid Length Parameters for Solid: " << GetName() << G4endl
             << "        pDx, pDy, pDz = "
             << pDx << ", " << pDy << ", " << pDz;
     G4Exception("G4Para::G4Para()", "GeomSolids0002",
                 FatalException, message);
   }
   SetAllParameters( pDx, pDy, pDz, pAlpha, pTheta, pPhi);
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ G4Para() [2/4]

G4Para::G4Para	(	const G4String &	pName,
		const G4ThreeVector	pt[8]
	)

Definition at line 121 of file G4Para.cc.

   : G4CSGSolid(pName)
 {
   if (!( pt[0].z()<0 && pt[0].z()==pt[1].z() && pt[0].z()==pt[2].z() &&
          pt[0].z()==pt[3].z() && pt[4].z()>0 && pt[4].z()==pt[5].z() &&
          pt[4].z()==pt[6].z() && pt[4].z()==pt[7].z()           &&
         (pt[0].z()+pt[4].z())==0                                &&
          pt[0].y()==pt[1].y() && pt[2].y()==pt[3].y()           &&
          pt[4].y()==pt[5].y() && pt[6].y()==pt[7].y()           &&
        ( pt[0].y() + pt[2].y() + pt[4].y() + pt[6].y() ) == 0   && 
        ( pt[0].x() + pt[1].x() + pt[4].x() + pt[5].x() ) == 0) )
   {
     std::ostringstream message;
     message << "Invalid vertice coordinates for Solid: " << GetName();
     G4Exception("G4Para::G4Para()", "GeomSolids0002",
                 FatalException, message);
   }    
   fDx = ((pt[3]).x()-(pt[2]).x())*0.5;
   fDy = ((pt[2]).y()-(pt[1]).y())*0.5;
   fDz = (pt[7]).z();
   fTalpha = ((pt[2]).x()+(pt[3]).x()-(pt[1]).x()-(pt[0]).x())*0.25/fDy ;
   fTthetaCphi = ((pt[4]).x()+fDy*fTalpha+fDx)/fDz ;
   fTthetaSphi = ((pt[4]).y()+fDy)/fDz ;
   fCubicVolume = 0.;
   fSurfaceArea = 0.;
 }

Here is the call graph for this function:

◆ ~G4Para()

G4Para::~G4Para ( )

virtual

Definition at line 163 of file G4Para.cc.

164 {

165 }

◆ G4Para() [3/4]

G4Para::G4Para ( __void__ & a )

Definition at line 154 of file G4Para.cc.

   : G4CSGSolid(a), fDx(0.), fDy(0.), fDz(0.),
     fTalpha(0.), fTthetaCphi(0.), fTthetaSphi(0.)
 {
 }

◆ G4Para() [4/4]

G4Para::G4Para ( const G4Para & rhs )

Definition at line 171 of file G4Para.cc.

   : G4CSGSolid(rhs), fDx(rhs.fDx), fDy(rhs.fDy), fDz(rhs.fDz),
     fTalpha(rhs.fTalpha), fTthetaCphi(rhs.fTthetaCphi),
     fTthetaSphi(rhs.fTthetaSphi)
 {
 }

Member Function Documentation

◆ ApproxSurfaceNormal()

G4ThreeVector G4Para::ApproxSurfaceNormal ( const G4ThreeVector & p ) const

private

Definition at line 550 of file G4Para.cc.

 {
   ENSide  side;
   G4ThreeVector norm;
   G4double distx,disty,distz;
   G4double newpx,newpy,xshift;
   G4double calpha,salpha;  // Sin/Cos(alpha) - needed to recalc G4Parameter 
   G4double tntheta,cosntheta;  // tan and cos of normal's theta component
   G4double ycomp;
 
   newpx=p.x()-fTthetaCphi*p.z();
   newpy=p.y()-fTthetaSphi*p.z();
 
   calpha=1/std::sqrt(1+fTalpha*fTalpha);
   salpha=-calpha*fTalpha;  // NOTE: actually use MINUS std::sin(alpha)
   
   xshift=newpx*calpha+newpy*salpha;
 
   distx=std::fabs(std::fabs(xshift)-fDx*calpha);
   disty=std::fabs(std::fabs(newpy)-fDy);
   distz=std::fabs(std::fabs(p.z())-fDz);
     
   if (distx<disty)
   {
     if (distx<distz) {side=kNX;}
     else {side=kNZ;}
   }
   else
   {
     if (disty<distz) {side=kNY;}
     else {side=kNZ;}
   }
 
   switch (side)
   {
     case kNX:
       tntheta=fTthetaCphi*calpha+fTthetaSphi*salpha;
       if (xshift<0)
       {
         cosntheta=-1/std::sqrt(1+tntheta*tntheta);
       }
       else
       {
         cosntheta=1/std::sqrt(1+tntheta*tntheta);
       }
       norm=G4ThreeVector(calpha*cosntheta,salpha*cosntheta,-tntheta*cosntheta);
       break;
     case kNY:
       if (newpy<0)
       {
         ycomp=-1/std::sqrt(1+fTthetaSphi*fTthetaSphi);
       }
       else
       {
         ycomp=1/std::sqrt(1+fTthetaSphi*fTthetaSphi);
       }
       norm=G4ThreeVector(0,ycomp,-fTthetaSphi*ycomp);
       break;
     case kNZ:           // Closest to Z
       if (p.z()>=0)
       {
         norm=G4ThreeVector(0,0,1);
       }
       else
       {
         norm=G4ThreeVector(0,0,-1);
       }
       break;
   }
   return norm;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CalculateExtent()

G4bool G4Para::CalculateExtent	(	const EAxis	pAxis,
		const G4VoxelLimits &	pVoxelLimit,
		const G4AffineTransform &	pTransform,
		G4double &	pMin,
		G4double &	pMax
	)		const

virtual

Implements G4VSolid.

Definition at line 218 of file G4Para.cc.

 {
   G4bool flag;
 
   if (!pTransform.IsRotated())
   {  
     // Special case handling for unrotated trapezoids
     // Compute z/x/y/ mins and maxs respecting limits, with early returns
     // if outside limits. Then switch() on pAxis
 
     G4int i ; 
     G4double xoffset,xMin,xMax;
     G4double yoffset,yMin,yMax;
     G4double zoffset,zMin,zMax;
     G4double temp[8] ;       // some points for intersection with zMin/zMax
     
     xoffset=pTransform.NetTranslation().x();      
     yoffset=pTransform.NetTranslation().y();
     zoffset=pTransform.NetTranslation().z();
  
     G4ThreeVector pt[8];   // vertices after translation
     pt[0]=G4ThreeVector(xoffset-fDz*fTthetaCphi-fDy*fTalpha-fDx,
                         yoffset-fDz*fTthetaSphi-fDy,zoffset-fDz);
     pt[1]=G4ThreeVector(xoffset-fDz*fTthetaCphi-fDy*fTalpha+fDx,
                         yoffset-fDz*fTthetaSphi-fDy,zoffset-fDz);
     pt[2]=G4ThreeVector(xoffset-fDz*fTthetaCphi+fDy*fTalpha-fDx,
                         yoffset-fDz*fTthetaSphi+fDy,zoffset-fDz);
     pt[3]=G4ThreeVector(xoffset-fDz*fTthetaCphi+fDy*fTalpha+fDx,
                         yoffset-fDz*fTthetaSphi+fDy,zoffset-fDz);
     pt[4]=G4ThreeVector(xoffset+fDz*fTthetaCphi-fDy*fTalpha-fDx,
                         yoffset+fDz*fTthetaSphi-fDy,zoffset+fDz);
     pt[5]=G4ThreeVector(xoffset+fDz*fTthetaCphi-fDy*fTalpha+fDx,
                         yoffset+fDz*fTthetaSphi-fDy,zoffset+fDz);
     pt[6]=G4ThreeVector(xoffset+fDz*fTthetaCphi+fDy*fTalpha-fDx,
                         yoffset+fDz*fTthetaSphi+fDy,zoffset+fDz);
     pt[7]=G4ThreeVector(xoffset+fDz*fTthetaCphi+fDy*fTalpha+fDx,
                         yoffset+fDz*fTthetaSphi+fDy,zoffset+fDz);
     zMin=zoffset-fDz;
     zMax=zoffset+fDz;
     if ( pVoxelLimit.IsZLimited() )
     {
       if   ( (zMin>pVoxelLimit.GetMaxZExtent()+kCarTolerance)
           || (zMax<pVoxelLimit.GetMinZExtent()-kCarTolerance) )
       {
         return false;
       }
       else
       {
         if (zMin<pVoxelLimit.GetMinZExtent())
         {
           zMin=pVoxelLimit.GetMinZExtent();
         }
         if (zMax>pVoxelLimit.GetMaxZExtent())
         {
           zMax=pVoxelLimit.GetMaxZExtent();
         }
       }
     }
 
     temp[0] = pt[0].y()+(pt[4].y()-pt[0].y())
                        *(zMin-pt[0].z())/(pt[4].z()-pt[0].z()) ;
     temp[1] = pt[0].y()+(pt[4].y()-pt[0].y())
                        *(zMax-pt[0].z())/(pt[4].z()-pt[0].z()) ;
     temp[2] = pt[2].y()+(pt[6].y()-pt[2].y())
                        *(zMin-pt[2].z())/(pt[6].z()-pt[2].z()) ;
     temp[3] = pt[2].y()+(pt[6].y()-pt[2].y())
                        *(zMax-pt[2].z())/(pt[6].z()-pt[2].z()) ;        
     yMax = yoffset - std::fabs(fDz*fTthetaSphi) - fDy - fDy ;
     yMin = -yMax ;
     for(i=0;i<4;i++)
     {
       if(temp[i] > yMax) yMax = temp[i] ;
       if(temp[i] < yMin) yMin = temp[i] ;
     }
       
     if (pVoxelLimit.IsYLimited())
     {
       if ( (yMin>pVoxelLimit.GetMaxYExtent()+kCarTolerance)
         || (yMax<pVoxelLimit.GetMinYExtent()-kCarTolerance) )
       {
         return false;
       }
       else
       {
         if (yMin<pVoxelLimit.GetMinYExtent())
         {
           yMin=pVoxelLimit.GetMinYExtent();
         }
         if (yMax>pVoxelLimit.GetMaxYExtent())
         {
           yMax=pVoxelLimit.GetMaxYExtent();
         }
       }
     }
 
     temp[0] = pt[0].x()+(pt[4].x()-pt[0].x())
                        *(zMin-pt[0].z())/(pt[4].z()-pt[0].z()) ;
     temp[1] = pt[0].x()+(pt[4].x()-pt[0].x())
                        *(zMax-pt[0].z())/(pt[4].z()-pt[0].z()) ;
     temp[2] = pt[2].x()+(pt[6].x()-pt[2].x())
                        *(zMin-pt[2].z())/(pt[6].z()-pt[2].z()) ;
     temp[3] = pt[2].x()+(pt[6].x()-pt[2].x())
                        *(zMax-pt[2].z())/(pt[6].z()-pt[2].z()) ;
     temp[4] = pt[3].x()+(pt[7].x()-pt[3].x())
                        *(zMin-pt[3].z())/(pt[7].z()-pt[3].z()) ;
     temp[5] = pt[3].x()+(pt[7].x()-pt[3].x())
                        *(zMax-pt[3].z())/(pt[7].z()-pt[3].z()) ;
     temp[6] = pt[1].x()+(pt[5].x()-pt[1].x())
                        *(zMin-pt[1].z())/(pt[5].z()-pt[1].z()) ;
     temp[7] = pt[1].x()+(pt[5].x()-pt[1].x())
                        *(zMax-pt[1].z())/(pt[5].z()-pt[1].z()) ;
 
     xMax = xoffset - std::fabs(fDz*fTthetaCphi) - fDx - fDx -fDx - fDx;
     xMin = -xMax ;
     for(i=0;i<8;i++)
     {
       if(temp[i] > xMax) xMax = temp[i] ;
       if(temp[i] < xMin) xMin = temp[i] ;
     }
       // xMax/Min = f(yMax/Min) ?
     if (pVoxelLimit.IsXLimited())
     {
       if ( (xMin>pVoxelLimit.GetMaxXExtent()+kCarTolerance)
         || (xMax<pVoxelLimit.GetMinXExtent()-kCarTolerance) )
       {
         return false;
       }
       else
       {
         if (xMin<pVoxelLimit.GetMinXExtent())
         {
           xMin=pVoxelLimit.GetMinXExtent();
         }
         if (xMax>pVoxelLimit.GetMaxXExtent())
         {
           xMax=pVoxelLimit.GetMaxXExtent();
         }
       }
     }
 
     switch (pAxis)
     {
       case kXAxis:
         pMin=xMin;
         pMax=xMax;
         break;
       case kYAxis:
         pMin=yMin;
         pMax=yMax;
         break;
       case kZAxis:
         pMin=zMin;
         pMax=zMax;
         break;
       default:
         break;
     }
 
     pMin-=kCarTolerance;
     pMax+=kCarTolerance;
     flag = true;
   }
   else
   {
     // General rotated case - create and clip mesh to boundaries
 
     G4bool existsAfterClip=false;
     G4ThreeVectorList *vertices;
 
     pMin=+kInfinity;
     pMax=-kInfinity;
 
     // Calculate rotated vertex coordinates
 
     vertices=CreateRotatedVertices(pTransform);
     ClipCrossSection(vertices,0,pVoxelLimit,pAxis,pMin,pMax);
     ClipCrossSection(vertices,4,pVoxelLimit,pAxis,pMin,pMax);
     ClipBetweenSections(vertices,0,pVoxelLimit,pAxis,pMin,pMax);
       
     if (pMin!=kInfinity||pMax!=-kInfinity)
     {
       existsAfterClip=true;
         
       // Add 2*tolerance to avoid precision troubles
       //
       pMin-=kCarTolerance;
       pMax+=kCarTolerance;
     }
     else
     {
       // Check for case where completely enveloping clipping volume
       // If point inside then we are confident that the solid completely
       // envelopes the clipping volume. Hence set min/max extents according
       // to clipping volume extents along the specified axis.
        
       G4ThreeVector clipCentre(
         (pVoxelLimit.GetMinXExtent()+pVoxelLimit.GetMaxXExtent())*0.5,
         (pVoxelLimit.GetMinYExtent()+pVoxelLimit.GetMaxYExtent())*0.5,
         (pVoxelLimit.GetMinZExtent()+pVoxelLimit.GetMaxZExtent())*0.5);
         
       if (Inside(pTransform.Inverse().TransformPoint(clipCentre))!=kOutside)
       {
         existsAfterClip=true;
         pMin=pVoxelLimit.GetMinExtent(pAxis);
         pMax=pVoxelLimit.GetMaxExtent(pAxis);
       }
     }
     delete vertices ;          //  'new' in the function called
     flag = existsAfterClip ;
   }
   return flag;
 }

Here is the call graph for this function:

◆ Clone()

G4VSolid * G4Para::Clone ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1203 of file G4Para.cc.

 {
   return new G4Para(*this);
 }

Here is the call graph for this function:

◆ ComputeDimensions()

void G4Para::ComputeDimensions	(	G4VPVParameterisation *	p,
		const G4int	n,
		const G4VPhysicalVolume *	pRep
	)

virtual

Reimplemented from G4VSolid.

Definition at line 206 of file G4Para.cc.

 {
   p->ComputeDimensions(*this,n,pRep);
 }

Here is the call graph for this function:

◆ CreatePolyhedron()

G4Polyhedron * G4Para::CreatePolyhedron ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1345 of file G4Para.cc.

 {
   G4double phi = std::atan2(fTthetaSphi, fTthetaCphi);
   G4double alpha = std::atan(fTalpha);
   G4double theta = std::atan(std::sqrt(fTthetaCphi*fTthetaCphi
                             +fTthetaSphi*fTthetaSphi));
     
   return new G4PolyhedronPara(fDx, fDy, fDz, alpha, theta, phi);
 }

◆ CreateRotatedVertices()

G4ThreeVectorList * G4Para::CreateRotatedVertices ( const G4AffineTransform & pTransform ) const

protected

Definition at line 1147 of file G4Para.cc.

 {
   G4ThreeVectorList *vertices;
   vertices=new G4ThreeVectorList();
   if (vertices)
   {
     vertices->reserve(8);
     G4ThreeVector vertex0(-fDz*fTthetaCphi-fDy*fTalpha-fDx,
                           -fDz*fTthetaSphi-fDy, -fDz);
     G4ThreeVector vertex1(-fDz*fTthetaCphi-fDy*fTalpha+fDx,
                           -fDz*fTthetaSphi-fDy, -fDz);
     G4ThreeVector vertex2(-fDz*fTthetaCphi+fDy*fTalpha-fDx,
                           -fDz*fTthetaSphi+fDy, -fDz);
     G4ThreeVector vertex3(-fDz*fTthetaCphi+fDy*fTalpha+fDx,
                           -fDz*fTthetaSphi+fDy, -fDz);
     G4ThreeVector vertex4(+fDz*fTthetaCphi-fDy*fTalpha-fDx,
                           +fDz*fTthetaSphi-fDy, +fDz);
     G4ThreeVector vertex5(+fDz*fTthetaCphi-fDy*fTalpha+fDx,
                           +fDz*fTthetaSphi-fDy, +fDz);
     G4ThreeVector vertex6(+fDz*fTthetaCphi+fDy*fTalpha-fDx,
                           +fDz*fTthetaSphi+fDy, +fDz);
     G4ThreeVector vertex7(+fDz*fTthetaCphi+fDy*fTalpha+fDx,
                           +fDz*fTthetaSphi+fDy, +fDz);
 
     vertices->push_back(pTransform.TransformPoint(vertex0));
     vertices->push_back(pTransform.TransformPoint(vertex1));
     vertices->push_back(pTransform.TransformPoint(vertex2));
     vertices->push_back(pTransform.TransformPoint(vertex3));
     vertices->push_back(pTransform.TransformPoint(vertex4));
     vertices->push_back(pTransform.TransformPoint(vertex5));
     vertices->push_back(pTransform.TransformPoint(vertex6));
     vertices->push_back(pTransform.TransformPoint(vertex7));
   }
   else
   {
     DumpInfo();
     G4Exception("G4Para::CreateRotatedVertices()",
                 "GeomSolids0003", FatalException,
                 "Error in allocation of vertices. Out of memory !");
   }
   return vertices;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ DescribeYourselfTo()

void G4Para::DescribeYourselfTo ( G4VGraphicsScene & scene ) const

virtual

Implements G4VSolid.

Definition at line 1340 of file G4Para.cc.

 {
   scene.AddSolid (*this);
 }

Here is the call graph for this function:

◆ DistanceToIn() [1/2]

G4double G4Para::DistanceToIn	(	const G4ThreeVector &	p,
		const G4ThreeVector &	v
	)		const

virtual

Implements G4VSolid.

Definition at line 638 of file G4Para.cc.

 {
   G4double snxt;    // snxt = default return value
   G4double smin,smax;
   G4double tmin,tmax;
   G4double yt,vy,xt,vx;
   G4double max;
   //
   // Z Intersection range
   //
   if (v.z()>0)
   {
     max=fDz-p.z();
     if (max>kCarTolerance*0.5)
     {
       smax=max/v.z();
       smin=(-fDz-p.z())/v.z();
     }
     else
     {
       return snxt=kInfinity;
     }
   }
   else if (v.z()<0)
   {
     max=-fDz-p.z();
     if (max<-kCarTolerance*0.5)
     {
       smax=max/v.z();
       smin=(fDz-p.z())/v.z();
     }
     else
     {
       return snxt=kInfinity;
     }
   }
   else
   {
     if (std::fabs(p.z())<=fDz) // Inside
     {
       smin=0;
       smax=kInfinity;
     }
     else
     {
       return snxt=kInfinity;
     }
   }
     
   //
   // Y G4Parallel planes intersection
   //
 
   yt=p.y()-fTthetaSphi*p.z();
   vy=v.y()-fTthetaSphi*v.z();
 
   if (vy>0)
   {
     max=fDy-yt;
     if (max>kCarTolerance*0.5)
     {
       tmax=max/vy;
       tmin=(-fDy-yt)/vy;
     }
     else
     {
       return snxt=kInfinity;
     }
   }
   else if (vy<0)
   {
     max=-fDy-yt;
     if (max<-kCarTolerance*0.5)
     {
       tmax=max/vy;
       tmin=(fDy-yt)/vy;
     }
     else
     {
       return snxt=kInfinity;
     }
   }
   else
   {
     if (std::fabs(yt)<=fDy)
     {
       tmin=0;
       tmax=kInfinity;
     }
     else
     {
       return snxt=kInfinity;
     }
   }
 
   // Re-Calc valid intersection range
   //
   if (tmin>smin) smin=tmin;
   if (tmax<smax) smax=tmax;
   if (smax<=smin)
   {
     return snxt=kInfinity;
   }
   else
   {
     //
     // X G4Parallel planes intersection
     //
     xt=p.x()-fTthetaCphi*p.z()-fTalpha*yt;
     vx=v.x()-fTthetaCphi*v.z()-fTalpha*vy;
     if (vx>0)
     {
       max=fDx-xt;
       if (max>kCarTolerance*0.5)
       {
         tmax=max/vx;
         tmin=(-fDx-xt)/vx;
       }
       else
       {
         return snxt=kInfinity;
       }
     }
     else if (vx<0)
     {
       max=-fDx-xt;
       if (max<-kCarTolerance*0.5)
       {
         tmax=max/vx;
         tmin=(fDx-xt)/vx;
       }
       else
       {
         return snxt=kInfinity;
       }
     }
     else
     {
       if (std::fabs(xt)<=fDx)
       {
         tmin=0;
         tmax=kInfinity;
       }
       else
       {
         return snxt=kInfinity;
       }
     }
     if (tmin>smin) smin=tmin;
     if (tmax<smax) smax=tmax;
   }
 
   if (smax>0&&smin<smax)
   {
     if (smin>0)
     {
       snxt=smin;
     }
     else
     {
       snxt=0;
     }
   }
   else
   {
     snxt=kInfinity;
   }
   return snxt;
 }

Here is the call graph for this function:

◆ DistanceToIn() [2/2]

G4double G4Para::DistanceToIn ( const G4ThreeVector & p ) const

virtual

Implements G4VSolid.

Definition at line 814 of file G4Para.cc.

 {
   G4double safe=0.0;
   G4double distz1,distz2,disty1,disty2,distx1,distx2;
   G4double trany,cosy,tranx,cosx;
 
   // Z planes
   //
   distz1=p.z()-fDz;
   distz2=-fDz-p.z();
   if (distz1>distz2)
   {
     safe=distz1;
   }
   else
   {
     safe=distz2;
   }
 
   trany=p.y()-fTthetaSphi*p.z(); // Transformed y into `box' system
 
   // Transformed x into `box' system
   //
   cosy=1.0/std::sqrt(1.0+fTthetaSphi*fTthetaSphi);
   disty1=(trany-fDy)*cosy;
   disty2=(-fDy-trany)*cosy;
     
   if (disty1>safe) safe=disty1;
   if (disty2>safe) safe=disty2;
 
   tranx=p.x()-fTthetaCphi*p.z()-fTalpha*trany;
   cosx=1.0/std::sqrt(1.0+fTalpha*fTalpha+fTthetaCphi*fTthetaCphi);
   distx1=(tranx-fDx)*cosx;
   distx2=(-fDx-tranx)*cosx;
     
   if (distx1>safe) safe=distx1;
   if (distx2>safe) safe=distx2;
     
   if (safe<0) safe=0;
   return safe;  
 }

Here is the call graph for this function:

◆ DistanceToOut() [1/2]

G4double G4Para::DistanceToOut	(	const G4ThreeVector &	p,
		const G4ThreeVector &	v,
		const G4bool	calcNorm = `G4bool(false)`,
		G4bool *	validNorm = `0`,
		G4ThreeVector *	n = `0`
	)		const

virtual

Implements G4VSolid.

Definition at line 861 of file G4Para.cc.

 {
   ESide side = kUndef;
   G4double snxt;    // snxt = return value
   G4double max,tmax;
   G4double yt,vy,xt,vx;
 
   G4double ycomp,calpha,salpha,tntheta,cosntheta;
 
   //
   // Z Intersections
   //
 
   if (v.z()>0)
   {
     max=fDz-p.z();
     if (max>kCarTolerance*0.5)
     {
       snxt=max/v.z();
       side=kPZ;
     }
     else
     {
       if (calcNorm)
       {
         *validNorm=true;
         *n=G4ThreeVector(0,0,1);
       }
       return snxt=0;
     }
   }
   else if (v.z()<0)
   {
     max=-fDz-p.z();
     if (max<-kCarTolerance*0.5)
     {
       snxt=max/v.z();
       side=kMZ;
     }
     else
     {
       if (calcNorm)
       {
         *validNorm=true;
         *n=G4ThreeVector(0,0,-1);
       }
       return snxt=0;
     }
   }
   else
   {
     snxt=kInfinity;
   }
     
   //
   // Y plane intersection
   //
 
   yt=p.y()-fTthetaSphi*p.z();
   vy=v.y()-fTthetaSphi*v.z();
 
   if (vy>0)
   {
     max=fDy-yt;
     if (max>kCarTolerance*0.5)
     {
       tmax=max/vy;
       if (tmax<snxt)
       {
         snxt=tmax;
         side=kPY;
       }
     }
     else
     {
       if (calcNorm)
       {      
         *validNorm=true; // Leaving via plus Y
         ycomp=1/std::sqrt(1+fTthetaSphi*fTthetaSphi);
         *n=G4ThreeVector(0,ycomp,-fTthetaSphi*ycomp);
       }
       return snxt=0;
     }
   }
   else if (vy<0)
   {
     max=-fDy-yt;
     if (max<-kCarTolerance*0.5)
     {
       tmax=max/vy;
       if (tmax<snxt)
       {
         snxt=tmax;
         side=kMY;
       }
     }
     else
     {
       if (calcNorm)
       {
         *validNorm=true; // Leaving via minus Y
         ycomp=-1/std::sqrt(1+fTthetaSphi*fTthetaSphi);
         *n=G4ThreeVector(0,ycomp,-fTthetaSphi*ycomp);
       }
       return snxt=0;
     }
   }
 
   //
   // X plane intersection
   //
 
   xt=p.x()-fTthetaCphi*p.z()-fTalpha*yt;
   vx=v.x()-fTthetaCphi*v.z()-fTalpha*vy;
   if (vx>0)
   {
     max=fDx-xt;
     if (max>kCarTolerance*0.5)
     {
       tmax=max/vx;
       if (tmax<snxt)
       {
         snxt=tmax;
         side=kPX;
       }
     }
     else
     {
       if (calcNorm)
       {
         *validNorm=true; // Leaving via plus X
         calpha=1/std::sqrt(1+fTalpha*fTalpha);
         salpha=-calpha*fTalpha;  // NOTE: actually use MINUS std::sin(alpha)
         tntheta=fTthetaCphi*calpha+fTthetaSphi*salpha;
         cosntheta=1/std::sqrt(1+tntheta*tntheta);
         *n=G4ThreeVector(calpha*cosntheta,salpha*cosntheta,-tntheta*cosntheta);
       }
       return snxt=0;
     }
   }
   else if (vx<0)
   {
     max=-fDx-xt;
     if (max<-kCarTolerance*0.5)
     {
       tmax=max/vx;
       if (tmax<snxt)
       {
         snxt=tmax;
         side=kMX;
       }
     }
     else
     {
       if (calcNorm)
       {
         *validNorm=true; // Leaving via minus X
         calpha=1/std::sqrt(1+fTalpha*fTalpha);
         salpha=-calpha*fTalpha;  // NOTE: actually use MINUS std::sin(alpha)
         tntheta=fTthetaCphi*calpha+fTthetaSphi*salpha;
         cosntheta=-1/std::sqrt(1+tntheta*tntheta);
         *n=G4ThreeVector(calpha*cosntheta,salpha*cosntheta,-tntheta*cosntheta);
       }
       return snxt=0;
     }
   }
 
   if (calcNorm)
   {
     *validNorm=true;
     switch (side)
     {
       case kMZ:
         *n=G4ThreeVector(0,0,-1);
         break;
       case kPZ:
         *n=G4ThreeVector(0,0,1);
         break;
       case kMY:
         ycomp=-1/std::sqrt(1+fTthetaSphi*fTthetaSphi);
         *n=G4ThreeVector(0,ycomp,-fTthetaSphi*ycomp);
         break;        
       case kPY:
         ycomp=1/std::sqrt(1+fTthetaSphi*fTthetaSphi);
         *n=G4ThreeVector(0,ycomp,-fTthetaSphi*ycomp);
         break;        
       case kMX:
         calpha=1/std::sqrt(1+fTalpha*fTalpha);
         salpha=-calpha*fTalpha;  // NOTE: actually use MINUS std::sin(alpha)
         tntheta=fTthetaCphi*calpha+fTthetaSphi*salpha;
         cosntheta=-1/std::sqrt(1+tntheta*tntheta);
         *n=G4ThreeVector(calpha*cosntheta,salpha*cosntheta,-tntheta*cosntheta);
         break;
       case kPX:
         calpha=1/std::sqrt(1+fTalpha*fTalpha);
         salpha=-calpha*fTalpha;  // NOTE: actually use MINUS std::sin(alpha)
         tntheta=fTthetaCphi*calpha+fTthetaSphi*salpha;
         cosntheta=1/std::sqrt(1+tntheta*tntheta);
         *n=G4ThreeVector(calpha*cosntheta,salpha*cosntheta,-tntheta*cosntheta);
         break;
       default:
         DumpInfo();
         G4Exception("G4Para::DistanceToOut(p,v,..)",
                     "GeomSolids1002",JustWarning,
                     "Undefined side for valid surface normal to solid.");
         break;
     }
   }
   return snxt;
 }

Here is the call graph for this function:

◆ DistanceToOut() [2/2]

G4double G4Para::DistanceToOut ( const G4ThreeVector & p ) const

virtual

Implements G4VSolid.

Definition at line 1079 of file G4Para.cc.

 {
   G4double safe=0.0;
   G4double distz1,distz2,disty1,disty2,distx1,distx2;
   G4double trany,cosy,tranx,cosx;
 
 #ifdef G4CSGDEBUG
   if( Inside(p) == kOutside )
   {
      G4int oldprc = G4cout.precision(16) ;
      G4cout << G4endl ;
      DumpInfo();
      G4cout << "Position:"  << G4endl << G4endl ;
      G4cout << "p.x() = "   << p.x()/mm << " mm" << G4endl ;
      G4cout << "p.y() = "   << p.y()/mm << " mm" << G4endl ;
      G4cout << "p.z() = "   << p.z()/mm << " mm" << G4endl << G4endl ;
      G4cout.precision(oldprc) ;
      G4Exception("G4Para::DistanceToOut(p)", "GeomSolids1002",
                  JustWarning, "Point p is outside !?" );
   }
 #endif
 
   // Z planes
   //
   distz1=fDz-p.z();
   distz2=fDz+p.z();
   if (distz1<distz2)
   {
     safe=distz1;
   }
   else
   {
     safe=distz2;
   }
 
   trany=p.y()-fTthetaSphi*p.z(); // Transformed y into `box' system
 
   // Transformed x into `box' system
   //
   cosy=1.0/std::sqrt(1.0+fTthetaSphi*fTthetaSphi);
   disty1=(fDy-trany)*cosy;
   disty2=(fDy+trany)*cosy;
     
   if (disty1<safe) safe=disty1;
   if (disty2<safe) safe=disty2;
 
   tranx=p.x()-fTthetaCphi*p.z()-fTalpha*trany;
   cosx=1.0/std::sqrt(1.0+fTalpha*fTalpha+fTthetaCphi*fTthetaCphi);
   distx1=(fDx-tranx)*cosx;
   distx2=(fDx+tranx)*cosx;
     
   if (distx1<safe) safe=distx1;
   if (distx2<safe) safe=distx2;
     
   if (safe<0) safe=0;
   return safe;  
 }

Here is the call graph for this function:

◆ GetCubicVolume()

G4double G4Para::GetCubicVolume ( )

inlinevirtual

Reimplemented from G4VSolid.

◆ GetEntityType()

G4GeometryType G4Para::GetEntityType ( ) const

virtual

Implements G4VSolid.

Definition at line 1194 of file G4Para.cc.

 {
   return G4String("G4Para");
 }

◆ GetPointOnPlane()

G4ThreeVector G4Para::GetPointOnPlane	(	G4ThreeVector	p0,
		G4ThreeVector	p1,
		G4ThreeVector	p2,
		G4ThreeVector	p3,
		G4double &	area
	)		const

private

Definition at line 1240 of file G4Para.cc.

 {
   G4double lambda1, lambda2, chose, aOne, aTwo;
   G4ThreeVector t, u, v, w, Area, normal;
   
   t = p1 - p0;
   u = p2 - p1;
   v = p3 - p2;
   w = p0 - p3;
 
   Area = G4ThreeVector(w.y()*v.z() - w.z()*v.y(),
                        w.z()*v.x() - w.x()*v.z(),
                        w.x()*v.y() - w.y()*v.x());
   
   aOne = 0.5*Area.mag();
   
   Area = G4ThreeVector(t.y()*u.z() - t.z()*u.y(),
                        t.z()*u.x() - t.x()*u.z(),
                        t.x()*u.y() - t.y()*u.x());
   
   aTwo = 0.5*Area.mag();
   
   area = aOne + aTwo;
   
   chose = G4RandFlat::shoot(0.,aOne+aTwo);
 
   if( (chose>=0.) && (chose < aOne) )
   {
     lambda1 = G4RandFlat::shoot(0.,1.);
     lambda2 = G4RandFlat::shoot(0.,lambda1);
     return (p2+lambda1*v+lambda2*w);    
   }
 
   // else
 
   lambda1 = G4RandFlat::shoot(0.,1.);
   lambda2 = G4RandFlat::shoot(0.,lambda1);
   return (p0+lambda1*t+lambda2*u);    
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ GetPointOnSurface()

G4ThreeVector G4Para::GetPointOnSurface ( ) const

virtual

Reimplemented from G4VSolid.

Definition at line 1289 of file G4Para.cc.

 {
   G4ThreeVector One, Two, Three, Four, Five, Six;
   G4ThreeVector pt[8] ;
   G4double chose, aOne, aTwo, aThree, aFour, aFive, aSix;
 
   pt[0] = G4ThreeVector(-fDz*fTthetaCphi-fDy*fTalpha-fDx,
                         -fDz*fTthetaSphi-fDy, -fDz);
   pt[1] = G4ThreeVector(-fDz*fTthetaCphi-fDy*fTalpha+fDx,
                         -fDz*fTthetaSphi-fDy, -fDz);
   pt[2] = G4ThreeVector(-fDz*fTthetaCphi+fDy*fTalpha-fDx,
                         -fDz*fTthetaSphi+fDy, -fDz);
   pt[3] = G4ThreeVector(-fDz*fTthetaCphi+fDy*fTalpha+fDx,
                         -fDz*fTthetaSphi+fDy, -fDz);
   pt[4] = G4ThreeVector(+fDz*fTthetaCphi-fDy*fTalpha-fDx,
                         +fDz*fTthetaSphi-fDy, +fDz);
   pt[5] = G4ThreeVector(+fDz*fTthetaCphi-fDy*fTalpha+fDx,
                         +fDz*fTthetaSphi-fDy, +fDz);
   pt[6] = G4ThreeVector(+fDz*fTthetaCphi+fDy*fTalpha-fDx,
                         +fDz*fTthetaSphi+fDy, +fDz);
   pt[7] = G4ThreeVector(+fDz*fTthetaCphi+fDy*fTalpha+fDx,
                         +fDz*fTthetaSphi+fDy, +fDz);
 
   // make sure we provide the points in a clockwise fashion
 
   One   = GetPointOnPlane(pt[0],pt[1],pt[3],pt[2], aOne);
   Two   = GetPointOnPlane(pt[4],pt[5],pt[7],pt[6], aTwo);
   Three = GetPointOnPlane(pt[6],pt[7],pt[3],pt[2], aThree);
   Four  = GetPointOnPlane(pt[4],pt[5],pt[1],pt[0], aFour); 
   Five  = GetPointOnPlane(pt[0],pt[2],pt[6],pt[4], aFive);
   Six   = GetPointOnPlane(pt[1],pt[3],pt[7],pt[5], aSix);
 
   chose = G4RandFlat::shoot(0.,aOne+aTwo+aThree+aFour+aFive+aSix);
   
   if( (chose>=0.) && (chose<aOne) )                    
     { return One; }
   else if(chose>=aOne && chose<aOne+aTwo)  
     { return Two; }
   else if(chose>=aOne+aTwo && chose<aOne+aTwo+aThree)
     { return Three; }
   else if(chose>=aOne+aTwo+aThree && chose<aOne+aTwo+aThree+aFour)
     { return Four; }
   else if(chose>=aOne+aTwo+aThree+aFour && chose<aOne+aTwo+aThree+aFour+aFive)
     { return Five; }
   return Six;
 }

Here is the call graph for this function:

◆ GetSurfaceArea()

G4double G4Para::GetSurfaceArea ( )

inlinevirtual

Reimplemented from G4VSolid.

◆ GetSymAxis()

G4ThreeVector G4Para::GetSymAxis ( ) const

inline

Here is the caller graph for this function:

◆ GetTanAlpha()

G4double G4Para::GetTanAlpha ( ) const

inline

Here is the caller graph for this function:

◆ GetXHalfLength()

G4double G4Para::GetXHalfLength ( ) const

inline

Here is the caller graph for this function:

◆ GetYHalfLength()

G4double G4Para::GetYHalfLength ( ) const

inline

Here is the caller graph for this function:

◆ GetZHalfLength()

G4double G4Para::GetZHalfLength ( ) const

inline

Here is the caller graph for this function:

◆ Inside()

EInside G4Para::Inside ( const G4ThreeVector & p ) const

virtual

Implements G4VSolid.

Definition at line 438 of file G4Para.cc.

 {
   G4double xt, yt, yt1;
   EInside  in = kOutside;
 
   yt1 = p.y() - fTthetaSphi*p.z();
   yt  = std::fabs(yt1) ;
 
   // xt = std::fabs( p.x() - fTthetaCphi*p.z() - fTalpha*yt );
 
   xt = std::fabs( p.x() - fTthetaCphi*p.z() - fTalpha*yt1 );
 
   if ( std::fabs( p.z() ) <= fDz - kCarTolerance*0.5)
   {
     if (yt <= fDy - kCarTolerance*0.5)
     {
       if      ( xt <= fDx - kCarTolerance*0.5 ) in = kInside;
       else if ( xt <= fDx + kCarTolerance*0.5 ) in = kSurface;
     }
     else if ( yt <= fDy + kCarTolerance*0.5)
     {
       if ( xt <= fDx + kCarTolerance*0.5 ) in = kSurface;  
     }
   }
   else  if ( std::fabs(p.z()) <= fDz + kCarTolerance*0.5 )
   {
     if ( yt <= fDy + kCarTolerance*0.5)
     {
       if ( xt <= fDx + kCarTolerance*0.5 ) in = kSurface;  
     }
   }
   return in;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ operator=()

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

Definition at line 182 of file G4Para.cc.

 {
    // Check assignment to self
    //
    if (this == &rhs)  { return *this; }
 
    // Copy base class data
    //
    G4CSGSolid::operator=(rhs);
 
    // Copy data
    //
    fDx = rhs.fDx; fDy = rhs.fDy; fDz = rhs.fDz;
    fTalpha = rhs.fTalpha; fTthetaCphi = rhs.fTthetaCphi;
    fTthetaSphi = rhs.fTthetaSphi;
 
    return *this;
 }

Here is the call graph for this function:

◆ SetAllParameters()

void G4Para::SetAllParameters	(	G4double	pDx,
		G4double	pDy,
		G4double	pDz,
		G4double	pAlpha,
		G4double	pTheta,
		G4double	pPhi
	)

Definition at line 70 of file G4Para.cc.

 {
   if ( pDx > 0 && pDy > 0 && pDz > 0 )
   {
     fDx         = pDx;
     fDy         = pDy;
     fDz         = pDz;
     fTalpha     = std::tan(pAlpha);
     fTthetaCphi = std::tan(pTheta)*std::cos(pPhi);
     fTthetaSphi = std::tan(pTheta)*std::sin(pPhi);
   }
   else
   {
     std::ostringstream message;
     message << "Invalid Length Parameters for Solid: " << GetName() << G4endl
             << "        pDx, pDy, pDz = "
             << pDx << ", " << pDy << ", " << pDz;
     G4Exception("G4Para::SetAllParameters()", "GeomSolids0002",
                 FatalException, message);
   }
   fCubicVolume = 0.;
   fSurfaceArea = 0.;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ SetAlpha()

void G4Para::SetAlpha ( G4double alpha )

inline

Here is the caller graph for this function:

◆ SetTanAlpha()

void G4Para::SetTanAlpha ( G4double val )

inline

Here is the caller graph for this function:

◆ SetThetaAndPhi()

void G4Para::SetThetaAndPhi	(	double	pTheta,
		double	pPhi
	)

inline

Here is the caller graph for this function:

◆ SetXHalfLength()

void G4Para::SetXHalfLength ( G4double val )

inline

Here is the caller graph for this function:

◆ SetYHalfLength()

void G4Para::SetYHalfLength ( G4double val )

inline

Here is the caller graph for this function:

◆ SetZHalfLength()

void G4Para::SetZHalfLength ( G4double val )

inline

Here is the caller graph for this function:

◆ StreamInfo()

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

virtual

Reimplemented from G4CSGSolid.

Definition at line 1212 of file G4Para.cc.

 {
   G4int oldprc = os.precision(16);
   os << "-----------------------------------------------------------\n"
      << "    *** Dump for solid - " << GetName() << " ***\n"
      << "    ===================================================\n"
      << " Solid type: G4Para\n"
      << " Parameters: \n"
      << "    half length X: " << fDx/mm << " mm \n"
      << "    half length Y: " << fDy/mm << " mm \n"
      << "    half length Z: " << fDz/mm << " mm \n"
      << "    std::tan(alpha)         : " << fTalpha/degree << " degrees \n"
      << "    std::tan(theta)*std::cos(phi): " << fTthetaCphi/degree
      << " degrees \n"
      << "    std::tan(theta)*std::sin(phi): " << fTthetaSphi/degree
      << " degrees \n"
      << "-----------------------------------------------------------\n";
   os.precision(oldprc);
 
   return os;
 }

Here is the call graph for this function:

◆ SurfaceNormal()

G4ThreeVector G4Para::SurfaceNormal ( const G4ThreeVector & p ) const

virtual

Implements G4VSolid.

Definition at line 477 of file G4Para.cc.

 {
   G4ThreeVector norm, sumnorm(0.,0.,0.);
   G4int noSurfaces = 0; 
   G4double distx,disty,distz;
   G4double newpx,newpy,xshift;
   G4double calpha,salpha;      // Sin/Cos(alpha) - needed to recalc G4Parameter
   G4double tntheta,cosntheta;  // tan and cos of normal's theta component
   G4double ycomp;
   G4double delta = 0.5*kCarTolerance;
 
   newpx  = p.x()-fTthetaCphi*p.z();
   newpy  = p.y()-fTthetaSphi*p.z();
 
   calpha = 1/std::sqrt(1+fTalpha*fTalpha);
   salpha = -calpha*fTalpha; // NOTE: using MINUS std::sin(alpha)
   
   //  xshift = newpx*calpha+newpy*salpha;
   xshift = newpx - newpy*fTalpha;
 
   //  distx  = std::fabs(std::fabs(xshift)-fDx*calpha);
   distx  = std::fabs(std::fabs(xshift)-fDx);
   disty  = std::fabs(std::fabs(newpy)-fDy);
   distz  = std::fabs(std::fabs(p.z())-fDz);
 
   tntheta   = fTthetaCphi*calpha + fTthetaSphi*salpha;
   cosntheta = 1/std::sqrt(1+tntheta*tntheta);
   ycomp     = 1/std::sqrt(1+fTthetaSphi*fTthetaSphi);
 
   G4ThreeVector nX  = G4ThreeVector( calpha*cosntheta,
                                      salpha*cosntheta,
                                     -tntheta*cosntheta);
   G4ThreeVector nY  = G4ThreeVector( 0, ycomp,-fTthetaSphi*ycomp);
   G4ThreeVector nZ  = G4ThreeVector( 0, 0,  1.0);
 
   if (distx <= delta)      
   {
     noSurfaces ++;
     if ( xshift >= 0.) {sumnorm += nX;}
     else               {sumnorm -= nX;}
   }
   if (disty <= delta)
   {
     noSurfaces ++;
     if ( newpy >= 0.)  {sumnorm += nY;}
     else               {sumnorm -= nY;}
   }
   if (distz <= delta)  
   {
     noSurfaces ++;
     if ( p.z() >= 0.)  {sumnorm += nZ;}
     else               {sumnorm -= nZ;}
   }
   if ( noSurfaces == 0 )
   {
 #ifdef G4CSGDEBUG
     G4Exception("G4Para::SurfaceNormal(p)", "GeomSolids1002",
                 JustWarning, "Point p is not on surface !?" );
 #endif 
      norm = ApproxSurfaceNormal(p);
   }
   else if ( noSurfaces == 1 ) {norm = sumnorm;}
   else                        {norm = sumnorm.unit();}
 
   return norm;
 }

Here is the call graph for this function:

Member Data Documentation

◆ fDx

G4double G4Para::fDx

private

Definition at line 179 of file G4Para.hh.

◆ fDy

G4double G4Para::fDy

private

Definition at line 179 of file G4Para.hh.

◆ fDz

G4double G4Para::fDz

private

Definition at line 179 of file G4Para.hh.

◆ fTalpha

G4double G4Para::fTalpha

private

Definition at line 180 of file G4Para.hh.

◆ fTthetaCphi

G4double G4Para::fTthetaCphi

private

Definition at line 180 of file G4Para.hh.

◆ fTthetaSphi

G4double G4Para::fTthetaSphi

private

Definition at line 180 of file G4Para.hh.

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

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ G4Para() [1/4]

◆ G4Para() [2/4]

◆ ~G4Para()

◆ G4Para() [3/4]

◆ G4Para() [4/4]

Member Function Documentation

◆ ApproxSurfaceNormal()

◆ CalculateExtent()

◆ Clone()

◆ ComputeDimensions()

◆ CreatePolyhedron()

◆ CreateRotatedVertices()

◆ DescribeYourselfTo()

◆ DistanceToIn() [1/2]

◆ DistanceToIn() [2/2]

◆ DistanceToOut() [1/2]

◆ DistanceToOut() [2/2]

◆ GetCubicVolume()

◆ GetEntityType()

◆ GetPointOnPlane()

◆ GetPointOnSurface()

◆ GetSurfaceArea()

◆ GetSymAxis()

◆ GetTanAlpha()

◆ GetXHalfLength()

◆ GetYHalfLength()

◆ GetZHalfLength()

◆ Inside()

◆ operator=()

◆ SetAllParameters()

◆ SetAlpha()

◆ SetTanAlpha()

◆ SetThetaAndPhi()

◆ SetXHalfLength()

◆ SetYHalfLength()

◆ SetZHalfLength()

◆ StreamInfo()

◆ SurfaceNormal()

Member Data Documentation

◆ fDx

◆ fDy

◆ fDz

◆ fTalpha

◆ fTthetaCphi

◆ fTthetaSphi