G4VTwistSurface is a base class for boundary surface of a G4VSolid. More...

#include <G4VTwistSurface.hh>

Inheritance diagram for G4VTwistSurface:

Classes
class	CurrentStatus
class	Boundary
class	G4SurfCurNormal

Public Types
enum	EValidate { kDontValidate = 0 , kValidateWithTol = 1 , kValidateWithoutTol = 2 , kUninitialized = 3 }

Public Member Functions
	G4VTwistSurface (const G4String &name)
	G4VTwistSurface (const G4String &name, const G4RotationMatrix &rot, const G4ThreeVector &tlate, G4int handedness, const EAxis axis0, const EAxis axis1, G4double axis0min=-kInfinity, G4double axis1min=-kInfinity, G4double axis0max=kInfinity, G4double axis1max=kInfinity)
virtual	~G4VTwistSurface ()=default
virtual G4int	AmIOnLeftSide (const G4ThreeVector &me, const G4ThreeVector &vec, G4bool withTol=true)
virtual G4double	DistanceToBoundary (G4int areacode, G4ThreeVector &xx, const G4ThreeVector &p)
virtual G4double	DistanceToIn (const G4ThreeVector &gp, const G4ThreeVector &gv, G4ThreeVector &gxxbest)
virtual G4double	DistanceToOut (const G4ThreeVector &gp, const G4ThreeVector &gv, G4ThreeVector &gxxbest)
virtual G4double	DistanceTo (const G4ThreeVector &gp, G4ThreeVector &gxx)
virtual G4int	DistanceToSurface (const G4ThreeVector &gp, const G4ThreeVector &gv, G4ThreeVector gxx[], G4double distance[], G4int areacode[], G4bool isvalid[], EValidate validate=kValidateWithTol)=0
virtual G4int	DistanceToSurface (const G4ThreeVector &gp, G4ThreeVector gxx[], G4double distance[], G4int areacode[])=0
virtual G4ThreeVector	GetNormal (const G4ThreeVector &p, G4bool isGlobal)=0
virtual void	GetBoundaryParameters (const G4int &areacode, G4ThreeVector &d, G4ThreeVector &x0, G4int &boundarytype) const
virtual G4ThreeVector	GetBoundaryAtPZ (G4int areacode, const G4ThreeVector &p) const
G4double	DistanceToPlaneWithV (const G4ThreeVector &p, const G4ThreeVector &v, const G4ThreeVector &x0, const G4ThreeVector &n0, G4ThreeVector &xx)
G4double	DistanceToPlane (const G4ThreeVector &p, const G4ThreeVector &x0, const G4ThreeVector &n0, G4ThreeVector &xx)
G4double	DistanceToPlane (const G4ThreeVector &p, const G4ThreeVector &x0, const G4ThreeVector &t1, const G4ThreeVector &t2, G4ThreeVector &xx, G4ThreeVector &n)
G4double	DistanceToLine (const G4ThreeVector &p, const G4ThreeVector &x0, const G4ThreeVector &d, G4ThreeVector &xx)
G4bool	IsAxis0 (G4int areacode) const
G4bool	IsAxis1 (G4int areacode) const
G4bool	IsOutside (G4int areacode) const
G4bool	IsInside (G4int areacode, G4bool testbitmode=false) const
G4bool	IsBoundary (G4int areacode, G4bool testbitmode=false) const
G4bool	IsCorner (G4int areacode, G4bool testbitmode=false) const
G4bool	IsValidNorm () const
G4bool	IsSameBoundary (G4VTwistSurface surface1, G4int areacode1, G4VTwistSurface surface2, G4int areacode2) const
G4int	GetAxisType (G4int areacode, G4int whichaxis) const
G4ThreeVector	ComputeGlobalPoint (const G4ThreeVector &lp) const
G4ThreeVector	ComputeLocalPoint (const G4ThreeVector &gp) const
G4ThreeVector	ComputeGlobalDirection (const G4ThreeVector &lp) const
G4ThreeVector	ComputeLocalDirection (const G4ThreeVector &gp) const
void	SetAxis (G4int i, const EAxis axis)
void	SetNeighbours (G4VTwistSurface ax0min, G4VTwistSurface ax1min, G4VTwistSurface ax0max, G4VTwistSurface ax1max)
virtual G4ThreeVector	SurfacePoint (G4double, G4double, G4bool isGlobal=false)=0
virtual G4double	GetBoundaryMin (G4double)=0
virtual G4double	GetBoundaryMax (G4double)=0
virtual G4double	GetSurfaceArea ()=0
virtual void	GetFacets (G4int m, G4int n, G4double xyz[][3], G4int faces[][4], G4int iside)=0
G4int	GetNode (G4int i, G4int j, G4int m, G4int n, G4int iside)
G4int	GetFace (G4int i, G4int j, G4int m, G4int n, G4int iside)
G4int	GetEdgeVisibility (G4int i, G4int j, G4int m, G4int n, G4int number, G4int orientation)
const G4String &	GetName () const
void	DebugPrint () const
	G4VTwistSurface (__void__ &)

Static Public Attributes
static const G4int	sOutside = 0x00000000
static const G4int	sInside = 0x10000000
static const G4int	sBoundary = 0x20000000
static const G4int	sCorner = 0x40000000
static const G4int	sC0Min1Min = 0x40000101
static const G4int	sC0Max1Min = 0x40000201
static const G4int	sC0Max1Max = 0x40000202
static const G4int	sC0Min1Max = 0x40000102
static const G4int	sAxisMin = 0x00000101
static const G4int	sAxisMax = 0x00000202
static const G4int	sAxisX = 0x00000404
static const G4int	sAxisY = 0x00000808
static const G4int	sAxisZ = 0x00000C0C
static const G4int	sAxisRho = 0x00001010
static const G4int	sAxisPhi = 0x00001414
static const G4int	sAxis0 = 0x0000FF00
static const G4int	sAxis1 = 0x000000FF
static const G4int	sSizeMask = 0x00000303
static const G4int	sAxisMask = 0x0000FCFC
static const G4int	sAreaMask = 0XF0000000

Protected Member Functions
G4VTwistSurface **	GetNeighbours ()
G4int	GetNeighbours (G4int areacode, G4VTwistSurface *surfaces[])
G4ThreeVector	GetCorner (G4int areacode) const
void	GetBoundaryAxis (G4int areacode, EAxis axis[]) const
void	GetBoundaryLimit (G4int areacode, G4double limit[]) const
virtual G4int	GetAreaCode (const G4ThreeVector &xx, G4bool withtol=true)=0
virtual void	SetBoundary (const G4int &axiscode, const G4ThreeVector &direction, const G4ThreeVector &x0, const G4int &boundarytype)
void	SetCorner (G4int areacode, G4double x, G4double y, G4double z)

Protected Attributes
EAxis	fAxis [2]
G4double	fAxisMin [2]
G4double	fAxisMax [2]
CurrentStatus	fCurStatWithV
CurrentStatus	fCurStat
G4RotationMatrix	fRot
G4ThreeVector	fTrans
G4int	fHandedness
G4SurfCurNormal	fCurrentNormal
G4bool	fIsValidNorm
G4double	kCarTolerance

Detailed Description

G4VTwistSurface is a base class for boundary surface of a G4VSolid.

Definition at line 52 of file G4VTwistSurface.hh.

Member Enumeration Documentation

◆ EValidate

enum G4VTwistSurface::EValidate

Enumerator
kDontValidate
kValidateWithTol
kValidateWithoutTol
kUninitialized

Definition at line 56 of file G4VTwistSurface.hh.

56 { kDontValidate = 0, kValidateWithTol = 1,

57 kValidateWithoutTol = 2, kUninitialized = 3 };

G4VTwistSurface::kUninitialized

@ kUninitialized

Definition G4VTwistSurface.hh:57

G4VTwistSurface::kValidateWithTol

@ kValidateWithTol

Definition G4VTwistSurface.hh:56

G4VTwistSurface::kDontValidate

@ kDontValidate

Definition G4VTwistSurface.hh:56

G4VTwistSurface::kValidateWithoutTol

@ kValidateWithoutTol

Definition G4VTwistSurface.hh:57

Constructor & Destructor Documentation

◆ G4VTwistSurface() [1/3]

G4VTwistSurface::G4VTwistSurface ( const G4String & name )

Base constructor, given a name.

Parameters

[in] name The surface name.

Definition at line 64 of file G4VTwistSurface.cc.

  : fIsValidNorm(false), fName(name)
{
 
   fAxis[0]    = kUndefined;
   fAxis[1]    = kUndefined;
   fAxisMin[0] = kInfinity;
   fAxisMin[1] = kInfinity;
   fAxisMax[0] = kInfinity;
   fAxisMax[1] = kInfinity;
   fHandedness = 1;
 
   for (auto i=0; i<4; ++i)
   {
      fCorners[i].set(kInfinity, kInfinity, kInfinity);
      fNeighbours[i] = nullptr;
   }
 
   fCurrentNormal.p.set(kInfinity, kInfinity, kInfinity);
   
   fAmIOnLeftSide.me.set(kInfinity, kInfinity, kInfinity);
   fAmIOnLeftSide.vec.set(kInfinity, kInfinity, kInfinity);
   kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
}

Referenced by DistanceToIn(), G4TwistBoxSide::G4TwistBoxSide(), G4TwistBoxSide::G4TwistBoxSide(), G4TwistTrapAlphaSide::G4TwistTrapAlphaSide(), G4TwistTrapAlphaSide::G4TwistTrapAlphaSide(), G4TwistTrapFlatSide::G4TwistTrapFlatSide(), G4TwistTrapFlatSide::G4TwistTrapFlatSide(), G4TwistTrapParallelSide::G4TwistTrapParallelSide(), G4TwistTrapParallelSide::G4TwistTrapParallelSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4TwistTubsHypeSide::G4TwistTubsHypeSide(), G4TwistTubsHypeSide::G4TwistTubsHypeSide(), G4TwistTubsHypeSide::G4TwistTubsHypeSide(), G4TwistTubsSide::G4TwistTubsSide(), G4TwistTubsSide::G4TwistTubsSide(), G4TwistTubsSide::G4TwistTubsSide(), GetNeighbours(), GetNeighbours(), IsSameBoundary(), and SetNeighbours().

◆ G4VTwistSurface() [2/3]

G4VTwistSurface::G4VTwistSurface	(	const G4String &	name,
		const G4RotationMatrix &	rot,
		const G4ThreeVector &	tlate,
		G4int	handedness,
		const EAxis	axis0,
		const EAxis	axis1,
		G4double	axis0min = -kInfinity,
		G4double	axis1min = -kInfinity,
		G4double	axis0max = kInfinity,
		G4double	axis1max = kInfinity )

Constructs a surface, given its parameters.

Parameters

[in]	name	The surface name.
[in]	rot	Rotation: 0.5*(phi-width segment).
[in]	tlate	Translation.
[in]	handedness	Orientation: R-hand = 1, L-hand = -1.
[in]	axis0	First axis.
[in]	axis1	Second axis.
[in]	axis0min	Minimum in first axis.
[in]	axis1min	Minimum in second axis.
[in]	axis0max	Maximum in first axis.
[in]	axis1max	Maximum in second axis.

Definition at line 89 of file G4VTwistSurface.cc.

   : fIsValidNorm(false), fName(name)
{
   fAxis[0]    = axis0;
   fAxis[1]    = axis1;
   fAxisMin[0] = axis0min;
   fAxisMin[1] = axis1min;
   fAxisMax[0] = axis0max;
   fAxisMax[1] = axis1max;
   fHandedness = handedness;
   fRot        = rot;
   fTrans      = tlate;
 
   for (auto i=0; i<4; ++i)
   {
      fCorners[i].set(kInfinity, kInfinity, kInfinity);
      fNeighbours[i] = nullptr;
   }
 
   fCurrentNormal.p.set(kInfinity, kInfinity, kInfinity);
   
   fAmIOnLeftSide.me.set(kInfinity, kInfinity, kInfinity);
   fAmIOnLeftSide.vec.set(kInfinity, kInfinity, kInfinity);
   kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
}

◆ ~G4VTwistSurface()

virtual G4VTwistSurface::~G4VTwistSurface ( )

virtualdefault

Default destructor.

◆ G4VTwistSurface() [3/3]

G4VTwistSurface::G4VTwistSurface ( __void__ & )

Fake default constructor for usage restricted to direct object persistency for clients requiring preallocation of memory for persistifiable objects.

Definition at line 127 of file G4VTwistSurface.cc.

  : fHandedness(0), fIsValidNorm(false), kCarTolerance(0.),
    fName("")
{
   fAxis[0] = fAxis[1] = kXAxis;
   fAxisMin[0] = fAxisMin[1] = 0.;
   fAxisMax[0] = fAxisMax[1] = 0.;
   fNeighbours[0] = fNeighbours[1] = fNeighbours[2] = fNeighbours[3] = nullptr;
}

Member Function Documentation

◆ AmIOnLeftSide()

G4int G4VTwistSurface::AmIOnLeftSide	(	const G4ThreeVector &	me,
		const G4ThreeVector &	vec,
		G4bool	withTol = true )

virtual

Returns the phi-location of point 'me' (phi relation between 'me' and 'vec' projected on z=0 plane). If 'me' is on -ve-phi-side of 'vec', it returns 1; on the other hand, if 'me' is on +ve-phi-side of 'vec', it returns -1. If 'me' is on boundary of 'vec', it returns 0.

Returns: The z-coordinate of normal vector of me.cross(vec).

Definition at line 140 of file G4VTwistSurface.cc.

{
   // AmIOnLeftSide returns phi-location of "me"
   // (phi relation between me and vec projected on z=0 plane).
   // If "me" is on -ve-phi-side of "vec", it returns 1.
   // On the other hand, if "me" is on +ve-phi-side of "vec",
   // it returns -1.
   // (The return value represents z-coordinate of normal vector
   //  of me.cross(vec).)
   // If me is on boundary of vec, return 0.
 
   const G4double kAngTolerance
     = G4GeometryTolerance::GetInstance()->GetAngularTolerance();
 
   G4RotationMatrix unitrot;
   const G4RotationMatrix rottol    = unitrot.rotateZ(0.5*kAngTolerance);
   const G4RotationMatrix invrottol = unitrot.rotateZ(-1.*kAngTolerance);
 
   if (fAmIOnLeftSide.me == me 
       && fAmIOnLeftSide.vec == vec
       && fAmIOnLeftSide.withTol == withtol)
   {
      return fAmIOnLeftSide.amIOnLeftSide;
   }
   
   fAmIOnLeftSide.me      = me;
   fAmIOnLeftSide.vec     = vec;
   fAmIOnLeftSide.withTol = withtol;
   
   G4ThreeVector met   = (G4ThreeVector(me.x(), me.y(), 0.)).unit();
   G4ThreeVector vect  = (G4ThreeVector(vec.x(), vec.y(), 0.)).unit();
   
   G4ThreeVector ivect = invrottol * vect;
   G4ThreeVector rvect = rottol * vect;
 
   G4double metcrossvect = met.x() * vect.y() - met.y() * vect.x();
   
   if (withtol)
   {
      if (met.x() * ivect.y() - met.y() * ivect.x() > 0 && 
          metcrossvect >= 0)  {
         fAmIOnLeftSide.amIOnLeftSide = 1;
      } else if (met.x() * rvect.y() - met.y() * rvect.x() < 0 &&
                 metcrossvect <= 0)  {
         fAmIOnLeftSide.amIOnLeftSide = -1;
      } else {
         fAmIOnLeftSide.amIOnLeftSide = 0;
      }
   }
   else
   {
      if (metcrossvect > 0) {    
         fAmIOnLeftSide.amIOnLeftSide = 1;
      } else if (metcrossvect < 0 ) {
         fAmIOnLeftSide.amIOnLeftSide = -1;
      } else {       
         fAmIOnLeftSide.amIOnLeftSide = 0;
      }
   }
 
#ifdef G4TWISTDEBUG
   G4cout << "         === G4VTwistSurface::AmIOnLeftSide() =============="
          << G4endl;
   G4cout << "             Name , returncode  : " << fName << " " 
                       << fAmIOnLeftSide.amIOnLeftSide <<  G4endl;
   G4cout << "             me, vec    : " << std::setprecision(14) << me 
                                          << " " << vec  << G4endl;
   G4cout << "             met, vect  : " << met << " " << vect  << G4endl;
   G4cout << "             ivec, rvec : " << ivect << " " << rvect << G4endl;
   G4cout << "             met x vect : " << metcrossvect << G4endl;
   G4cout << "             met x ivec : " << met.cross(ivect) << G4endl;
   G4cout << "             met x rvec : " << met.cross(rvect) << G4endl;
   G4cout << "         =============================================="
          << G4endl;
#endif
 
   return fAmIOnLeftSide.amIOnLeftSide;
}

Referenced by G4TwistTubsSide::DistanceToSurface().

◆ ComputeGlobalDirection()

G4ThreeVector G4VTwistSurface::ComputeGlobalDirection ( const G4ThreeVector & lp ) const

inline

Referenced by G4TwistBoxSide::GetNormal(), G4TwistTrapAlphaSide::GetNormal(), G4TwistTrapFlatSide::GetNormal(), G4TwistTrapParallelSide::GetNormal(), G4TwistTubsFlatSide::GetNormal(), G4TwistTubsHypeSide::GetNormal(), G4TwistTubsSide::GetNormal(), and IsSameBoundary().

◆ ComputeGlobalPoint()

G4ThreeVector G4VTwistSurface::ComputeGlobalPoint ( const G4ThreeVector & lp ) const

inline

Utility functions computing global/local point/direction.

◆ ComputeLocalDirection()

G4ThreeVector G4VTwistSurface::ComputeLocalDirection ( const G4ThreeVector & gp ) const

inline

Referenced by G4TwistBoxSide::DistanceToSurface(), G4TwistTrapAlphaSide::DistanceToSurface(), G4TwistTrapFlatSide::DistanceToSurface(), G4TwistTrapParallelSide::DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), G4TwistTubsHypeSide::DistanceToSurface(), G4TwistTubsSide::DistanceToSurface(), and G4TwistTubsHypeSide::GetNormal().

◆ ComputeLocalPoint()

G4ThreeVector G4VTwistSurface::ComputeLocalPoint ( const G4ThreeVector & gp ) const

inline

◆ DebugPrint()

void G4VTwistSurface::DebugPrint ( ) const

Prints on standard output surface data.

Definition at line 1084 of file G4VTwistSurface.cc.

{
   G4ThreeVector A = fRot * GetCorner(sC0Min1Min) + fTrans;
   G4ThreeVector B = fRot * GetCorner(sC0Max1Min) + fTrans;
   G4ThreeVector C = fRot * GetCorner(sC0Max1Max) + fTrans;
   G4ThreeVector D = fRot * GetCorner(sC0Min1Max) + fTrans;
  
   G4cout << "/* G4VTwistSurface::DebugPrint():--------------------------"
          << G4endl;
   G4cout << "/* Name = " << fName << G4endl;
   G4cout << "/* Axis = " << std::hex << fAxis[0] << " "
          << std::hex << fAxis[1] 
          << " (0,1,2,3,5 = kXAxis,kYAxis,kZAxis,kRho,kPhi)"
          << std::dec << G4endl;
   G4cout << "/* BoundaryLimit(in local) fAxis0(min, max) = ("<<fAxisMin[0] 
          << ", " << fAxisMax[0] << ")" << G4endl;
   G4cout << "/* BoundaryLimit(in local) fAxis1(min, max) = ("<<fAxisMin[1] 
          << ", " << fAxisMax[1] << ")" << G4endl;
   G4cout << "/* Cornar point sC0Min1Min = " << A << G4endl;
   G4cout << "/* Cornar point sC0Max1Min = " << B << G4endl;
   G4cout << "/* Cornar point sC0Max1Max = " << C << G4endl;
   G4cout << "/* Cornar point sC0Min1Max = " << D << G4endl;
   G4cout << "/*---------------------------------------------------------"
          << G4endl;
}

◆ DistanceTo()

G4double G4VTwistSurface::DistanceTo	(	const G4ThreeVector &	gp,
		G4ThreeVector &	gxx )

virtual

Returns the safety distance to a boundary from an arbitrary point 'gp'.

Parameters

[in]	gp	The arbitrary point.
[out]	gxxbest	The returned reference point on boundary.

Definition at line 570 of file G4VTwistSurface.cc.

{
#ifdef G4TWISTDEBUG
   G4cout << "~~~~~ G4VTwistSurface::DistanceTo(p) - Start ~~~~~~~~~" << G4endl;
   G4cout << "      Name : " << fName << G4endl;
   G4cout << "      gp   : " << gp << G4endl;
   G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
#endif
 
 
   G4ThreeVector gxx[G4VSURFACENXX];
   G4double      distance[G4VSURFACENXX]  ; 
   G4int         areacode[G4VSURFACENXX]  ;
   
   for (G4int i = 0 ; i<G4VSURFACENXX ; ++i )
   {
     distance[i] = kInfinity ;
     areacode[i] = sOutside ;
   }
 
   DistanceToSurface(gp, gxx, distance, areacode);
   gxxbest = gxx[0];
 
#ifdef G4TWISTDEBUG
   G4cout << "~~~~~ G4VTwistSurface::DistanceTo(p) - return ~~~~~~~~" << G4endl;
   G4cout << "      Name     : " << fName << G4endl; 
   G4cout << "      gxx      : " << gxxbest << G4endl; 
   G4cout << "      bestdist : " << distance[0] << G4endl;
   G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
#endif
 
   return distance[0];
}

Referenced by G4TwistedTubs::SurfaceNormal(), and G4VTwistedFaceted::SurfaceNormal().

◆ DistanceToBoundary()

G4double G4VTwistSurface::DistanceToBoundary	(	G4int	areacode,
		G4ThreeVector &	xx,
		const G4ThreeVector &	p )

virtual

Returns the distance to the nearest boundary from an arbitrary point 'p' in local coodinate.

Parameters

[in]	areacode	Point location code according to axes.
[out]	xx	The returned reference point on boundary.
[in]	p	The arbitrary point in input.

Definition at line 224 of file G4VTwistSurface.cc.

{
   // DistanceToBoundary 
   //
   // return distance to nearest boundary from arbitrary point p 
   // in local coodinate.
   // Argument areacode must be one of them:
   // sAxis0 & sAxisMin, sAxis0 & sAxisMax,
   // sAxis1 & sAxisMin, sAxis1 & sAxisMax.
   //
 
   G4ThreeVector d;    // direction vector of the boundary
   G4ThreeVector x0;   // reference point of the boundary
   G4double      dist = kInfinity;
   G4int         boundarytype;
 
   if (IsAxis0(areacode) && IsAxis1(areacode))
   {
      std::ostringstream message;
      message << "Point is in the corner area." << G4endl
              << "        Point is in the corner area. This function returns"
              << G4endl
              << "        a direction vector of a boundary line." << G4endl
              << "        areacode = " << areacode;
      G4Exception("G4VTwistSurface::DistanceToBoundary()", "GeomSolids0003",
                  FatalException, message);
   }
   else if (IsAxis0(areacode) || IsAxis1(areacode))
   {
      GetBoundaryParameters(areacode, d, x0, boundarytype);
      if (boundarytype == sAxisPhi)
      {
         G4double t = x0.getRho() / p.getRho();
         xx.set(t*p.x(), t*p.y(), x0.z());
         dist = (xx - p).mag();
      }
      else
      { 
         // linear boundary
         // sAxisX, sAxisY, sAxisZ, sAxisRho
         dist = DistanceToLine(p, x0, d, xx);
      }
   }
   else
   {
      std::ostringstream message;
      message << "Bad areacode of boundary." << G4endl
              << "        areacode = " << areacode;
      G4Exception("G4VTwistSurface::DistanceToBoundary()", "GeomSolids0003",
                  FatalException, message);
   }
   return dist;
}

Referenced by G4TwistTubsSide::DistanceToSurface().

◆ DistanceToIn()

G4double G4VTwistSurface::DistanceToIn	(	const G4ThreeVector &	gp,
		const G4ThreeVector &	gv,
		G4ThreeVector &	gxxbest )

virtual

Returns the distance from outside to a boundary from an arbitrary point 'gp' and direction 'gv'.

Parameters

[in]	gp	The arbitrary point.
[in]	gv	The direction vector.
[out]	gxxbest	The returned reference point on boundary.

Definition at line 283 of file G4VTwistSurface.cc.

{
#ifdef G4TWISTDEBUG
   G4cout << " ~~~~ G4VTwistSurface::DistanceToIn(p,v) - Start ~~~~" << G4endl;
   G4cout << "      Name : " << fName << G4endl;
   G4cout << "      gp   : " << gp << G4endl;
   G4cout << "      gv   : " <<  gv << G4endl;
   G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
#endif
   
   G4ThreeVector gxx[G4VSURFACENXX];
   G4double      distance[G4VSURFACENXX]  ; 
   G4int         areacode[G4VSURFACENXX]  ;
   G4bool        isvalid[G4VSURFACENXX]   ; 
   
   for (G4int i = 0 ; i<G4VSURFACENXX ; ++i )
   {
     distance[i] = kInfinity ;
     areacode[i] = sOutside ;
     isvalid[i] = false ;
   }
 
   G4double      bestdistance   = kInfinity;
#ifdef G4TWISTDEBUG
   G4int         besti          = -1;  
#endif
   G4ThreeVector bestgxx(kInfinity, kInfinity, kInfinity);
 
   G4int         nxx = DistanceToSurface(gp, gv, gxx, distance, areacode, 
                                         isvalid, kValidateWithTol);
 
   for (G4int i=0; i<nxx; ++i)
   {
 
      // skip this intersection if:
      //   - invalid intersection
      //   - particle goes outword the surface
 
      if (!isvalid[i])
      {
         // xx[i] is sOutside or distance[i] < 0
         continue;      
      }
 
      G4ThreeVector normal = GetNormal(gxx[i], true);
 
      if ((normal * gv) >= 0)
      {
 
#ifdef G4TWISTDEBUG
         G4cout << "   G4VTwistSurface::DistanceToIn(p,v): "
                << "particle goes outword the surface." << G4endl;
#endif 
         continue; 
      }
      
      //
      // accept this intersection if the intersection is inside.
      //
 
      if (IsInside(areacode[i]))
      {
         if (distance[i] < bestdistance)
         {
            bestdistance = distance[i];
            bestgxx = gxx[i];
#ifdef G4TWISTDEBUG
            besti   = i;
            G4cout << "   G4VTwistSurface::DistanceToIn(p,v): "
                   << " areacode sInside name, distance = "
                   << fName <<  " "<< bestdistance << G4endl;
#endif 
         }
 
      //
      // else, the intersection is on boundary or corner.
      //
 
      }
      else
      {
         G4VTwistSurface* neighbours[2];
         G4bool      isaccepted[2] = {false, false};
         G4int       nneighbours   = GetNeighbours(areacode[i], neighbours);
            
         for (G4int j=0; j<nneighbours; ++j)
         {
            // if on corner, nneighbours = 2.
            // if on boundary, nneighbours = 1.
 
            G4ThreeVector tmpgxx[G4VSURFACENXX];
            G4double      tmpdist[G4VSURFACENXX] ;
            G4int         tmpareacode[G4VSURFACENXX] ;
            G4bool        tmpisvalid[G4VSURFACENXX] ;
 
            for (G4int l = 0 ; l<G4VSURFACENXX ; ++l )
            {
              tmpdist[l] = kInfinity ;
              tmpareacode[l] = sOutside ;
              tmpisvalid[l] = false ;
            }
 
            G4int tmpnxx = neighbours[j]->DistanceToSurface(
                                          gp, gv, tmpgxx, tmpdist,
                                          tmpareacode, tmpisvalid,
                                          kValidateWithTol);
            G4ThreeVector neighbournormal;
 
            for (G4int k=0; k< tmpnxx; ++k)
            {
               //  
               // if tmpxx[k] is valid && sInside, the final winner must
               // be neighbour surface. return kInfinity. 
               // else , choose tmpxx on same boundary of xx, then check normal 
               //  
 
               if (IsInside(tmpareacode[k]))
               {
#ifdef G4TWISTDEBUG
                  G4cout << "   G4VTwistSurface:DistanceToIn(p,v): "
                         << " intersection "<< tmpgxx[k] << G4endl
                         << "   is inside of neighbour surface of " << fName 
                         << " . returning kInfinity." << G4endl;
                  G4cout << "~~ G4VTwistSurface::DistanceToIn(p,v) - return ~~"
                         << G4endl;
                  G4cout << "      No intersections " << G4endl; 
                  G4cout << "      Name : " << fName << G4endl; 
                  G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
                         << G4endl;
#endif 
                  if (tmpisvalid[k]) { return kInfinity; }
                  continue;
 
               //  
               // if tmpxx[k] is valid && sInside, the final winner must
               // be neighbour surface. return .  
               //
 
               }
               if (IsSameBoundary(this,areacode[i],
                                       neighbours[j], tmpareacode[k]))
               { 
                  // tmpxx[k] is same boundary (or corner) of xx.
                 
                  neighbournormal = neighbours[j]->GetNormal(tmpgxx[k], true);
                  if (neighbournormal * gv < 0) { isaccepted[j] = true; }
               }
            } 
 
            // if nneighbours = 1, chabge isaccepted[1] before
            // exiting neighboursurface loop.  
 
            if (nneighbours == 1) { isaccepted[1] = true; }
 
         } // neighboursurface loop end
 
         // now, we can accept xx intersection
 
         if (isaccepted[0] && isaccepted[1])
         {
            if (distance[i] < bestdistance)
            {
               bestdistance = distance[i];
               gxxbest = gxx[i];
#ifdef G4TWISTDEBUG
               besti = i;
               G4cout << "   G4VTwistSurface::DistanceToIn(p,v): "
                      << " areacode sBoundary & sBoundary distance = "
                      << fName  << " " << distance[i] << G4endl;
#endif 
            }
         }
      } // else end
   } // intersection loop end
 
   gxxbest = bestgxx;
 
#ifdef G4TWISTDEBUG
   if (besti < 0)
   {
      G4cout << "~~~ G4VTwistSurface::DistanceToIn(p,v) - return ~~~" << G4endl;
      G4cout << "      No intersections " << G4endl; 
      G4cout << "      Name : " << fName << G4endl; 
      G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
   }
   else
   {
      G4cout << "~~~ G4VTwistSurface::DistanceToIn(p,v) : return ~~~" << G4endl;
      G4cout << "      Name, i  : " << fName << " , " << besti << G4endl; 
      G4cout << "      gxx[i]   : " << gxxbest << G4endl; 
      G4cout << "      bestdist : " << bestdistance << G4endl;
      G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
   } 
 
#endif
 
   return bestdistance;
}

◆ DistanceToLine()

G4double G4VTwistSurface::DistanceToLine	(	const G4ThreeVector &	p,
		const G4ThreeVector &	x0,
		const G4ThreeVector &	d,
		G4ThreeVector &	xx )

inline

Referenced by DistanceToBoundary(), G4TwistTubsHypeSide::DistanceToSurface(), and G4TwistTubsSide::DistanceToSurface().

◆ DistanceToOut()

G4double G4VTwistSurface::DistanceToOut	(	const G4ThreeVector &	gp,
		const G4ThreeVector &	gv,
		G4ThreeVector &	gxxbest )

virtual

Returns the distance from inside to a boundary from an arbitrary point 'gp' and direction 'gv'.

Parameters

[in]	gp	The arbitrary point.
[in]	gv	The direction vector.
[out]	gxxbest	The returned reference point on boundary.

Definition at line 487 of file G4VTwistSurface.cc.

{
#ifdef G4TWISTDEBUG
   G4cout << "~~~~~ G4VTwistSurface::DistanceToOut(p,v) - Start ~~~~" << G4endl;
   G4cout << "      Name : " << fName << G4endl;
   G4cout << "      gp   : " << gp << G4endl;
   G4cout << "      gv   : " <<  gv << G4endl;
   G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
#endif
 
   G4ThreeVector gxx[G4VSURFACENXX];
   G4double      distance[G4VSURFACENXX]; 
   G4int         areacode[G4VSURFACENXX];
   G4bool        isvalid[G4VSURFACENXX]; 
   
   for ( G4int i = 0 ; i<G4VSURFACENXX ; ++i )
   {
     distance[i] = kInfinity ;
     areacode[i] = sOutside ;
     isvalid[i] = false ;
   }
 
   G4int         nxx;
   G4double      bestdistance   = kInfinity;
 
   nxx = DistanceToSurface(gp, gv, gxx, distance, areacode,
                           isvalid, kValidateWithTol);
 
   for (G4int i=0; i<nxx; ++i)
   {
      if (!(isvalid[i]))
      {
         continue;
      }
 
      G4ThreeVector normal = GetNormal(gxx[i], true);
      if (normal * gv <= 0)
      {
         // particle goes toword inside of solid, return kInfinity
#ifdef G4TWISTDEBUG
          G4cout << "   G4VTwistSurface::DistanceToOut(p,v): normal*gv < 0 " 
                 << fName << " " << normal 
                 << G4endl;
#endif 
      }
      else
      {
         // gxx[i] is accepted.
         if (distance[i] < bestdistance)
         {
            bestdistance = distance[i];
            gxxbest = gxx[i];
         }
      } 
   }
 
#ifdef G4TWISTDEBUG
   if (besti < 0)
   {
      G4cout << "~~ G4VTwistSurface::DistanceToOut(p,v) - return ~~" << G4endl;
      G4cout << "      No intersections   " << G4endl; 
      G4cout << "      Name     : " << fName << G4endl; 
      G4cout << "      bestdist : " << bestdistance << G4endl;
      G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
   }
   else
   {
      G4cout << "~~ G4VTwistSurface::DistanceToOut(p,v) : return ~~" << G4endl;
      G4cout << "      Name, i  : " << fName << " , " << i << G4endl; 
      G4cout << "      gxx[i]   : " << gxxbest << G4endl; 
      G4cout << "      bestdist : " << bestdistance << G4endl;
      G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
   } 
#endif
 
   return bestdistance;
}

Referenced by G4TwistedTubs::DistanceToOut(), and G4VTwistedFaceted::DistanceToOut().

◆ DistanceToPlane() [1/2]

G4double G4VTwistSurface::DistanceToPlane	(	const G4ThreeVector &	p,
		const G4ThreeVector &	x0,
		const G4ThreeVector &	n0,
		G4ThreeVector &	xx )

inline

Referenced by G4TwistBoxSide::DistanceToSurface(), G4TwistTrapAlphaSide::DistanceToSurface(), G4TwistTrapParallelSide::DistanceToSurface(), and G4TwistTubsSide::DistanceToSurface().

◆ DistanceToPlane() [2/2]

G4double G4VTwistSurface::DistanceToPlane	(	const G4ThreeVector &	p,
		const G4ThreeVector &	x0,
		const G4ThreeVector &	t1,
		const G4ThreeVector &	t2,
		G4ThreeVector &	xx,
		G4ThreeVector &	n )

inline

◆ DistanceToPlaneWithV()

G4double G4VTwistSurface::DistanceToPlaneWithV	(	const G4ThreeVector &	p,
		const G4ThreeVector &	v,
		const G4ThreeVector &	x0,
		const G4ThreeVector &	n0,
		G4ThreeVector &	xx )

inline

Utility methods to compute the distance from a plane/line.

Referenced by G4TwistBoxSide::DistanceToSurface(), G4TwistTrapAlphaSide::DistanceToSurface(), G4TwistTrapParallelSide::DistanceToSurface(), and G4TwistTubsSide::DistanceToSurface().

◆ DistanceToSurface() [1/2]

virtual G4int G4VTwistSurface::DistanceToSurface	(	const G4ThreeVector &	gp,
		const G4ThreeVector &	gv,
		G4ThreeVector	gxx[],
		G4double	distance[],
		G4int	areacode[],
		G4bool	isvalid[],
		EValidate	validate = kValidateWithTol )

pure virtual

Returns the distance to surface, given point 'gp' and direction 'gv'.

Parameters

[in]	gp	The point from where computing the distance.
[in]	gv	The direction along which computing the distance.
[out]	gxx	Vector of global points based on number of solutions.
[out]	distance	The distance vector based on number of solutions.
[out]	areacode	The location vector based on number of solutions.
[out]	isvalid	Validity vector based on number of solutions.
[in]	validate	Adopted validation criteria.

Returns: The number of solutions.

Implemented in G4TwistBoxSide, G4TwistTrapAlphaSide, G4TwistTrapFlatSide, G4TwistTrapParallelSide, G4TwistTubsFlatSide, G4TwistTubsHypeSide, and G4TwistTubsSide.

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

◆ DistanceToSurface() [2/2]

virtual G4int G4VTwistSurface::DistanceToSurface	(	const G4ThreeVector &	gp,
		G4ThreeVector	gxx[],
		G4double	distance[],
		G4int	areacode[] )

pure virtual

Returns the safety distance to surface, given point 'gp'.

Parameters

[in]	gp	The point from where computing the safety distance.
[out]	gxx	Vector of global points based on number of solutions.
[out]	distance	The distance vector based on number of solutions.
[out]	areacode	The location vector based on number of solutions.

Returns: The number of solutions.

Implemented in G4TwistBoxSide, G4TwistTrapAlphaSide, G4TwistTrapFlatSide, G4TwistTrapParallelSide, G4TwistTubsFlatSide, G4TwistTubsHypeSide, and G4TwistTubsSide.

◆ GetAreaCode()

virtual G4int G4VTwistSurface::GetAreaCode	(	const G4ThreeVector &	xx,
		G4bool	withtol = true )

protectedpure virtual

◆ GetAxisType()

G4int G4VTwistSurface::GetAxisType	(	G4int	areacode,
		G4int	whichaxis ) const

inline

◆ GetBoundaryAtPZ()

G4ThreeVector G4VTwistSurface::GetBoundaryAtPZ	(	G4int	areacode,
		const G4ThreeVector &	p ) const

virtual

Returns Z projection of point 'p' on boundary.

Parameters

[in]	areacode	The location code.
[out]	p	The arbitrary point.

Returns: The Z projection on boundary.

Definition at line 685 of file G4VTwistSurface.cc.

{
   // areacode must be one of them:
   // sAxis0 & sAxisMin, sAxis0 & sAxisMax,
   // sAxis1 & sAxisMin, sAxis1 & sAxisMax.
 
   if (((areacode & sAxis0) != 0) && ((areacode & sAxis1) != 0))
   {
     std::ostringstream message;
     message << "Point is in the corner area." << G4endl
             << "        This function returns "
             << "a direction vector of a boundary line." << G4endl
             << "        areacode = " << areacode;
     G4Exception("G4VTwistSurface::GetBoundaryAtPZ()", "GeomSolids0003",
                 FatalException, message);
   }
 
   G4ThreeVector d;
   G4ThreeVector x0;
   G4int         boundarytype = 0;
   G4bool        found = false;
   
   for (const auto & boundary : fBoundaries)
   {
      if (boundary.GetBoundaryParameters(areacode, d, x0, boundarytype))
      {
         found = true;
         continue;
      }
   }
 
   if (!found)
   {
     std::ostringstream message;
     message << "Not registered boundary." << G4endl
             << "        Boundary at areacode " << areacode << G4endl
             << "        is not registered.";
     G4Exception("G4VTwistSurface::GetBoundaryAtPZ()", "GeomSolids0002",
                 FatalException, message);
   }
 
   if (((boundarytype & sAxisPhi) == sAxisPhi) ||
       ((boundarytype & sAxisRho) == sAxisRho))
   {
     std::ostringstream message;
     message << "Not a z-depended line boundary." << G4endl
             << "        Boundary at areacode " << areacode << G4endl
             << "        is not a z-depended line.";
     G4Exception("G4VTwistSurface::GetBoundaryAtPZ()", "GeomSolids0002",
                 FatalException, message);
   }
   return ((p.z() - x0.z()) / d.z()) * d + x0;
}

Referenced by G4TwistTubsSide::DistanceToSurface().

◆ GetBoundaryAxis()

void G4VTwistSurface::GetBoundaryAxis	(	G4int	areacode,
		EAxis	axis[] ) const

protected

Definition at line 769 of file G4VTwistSurface.cc.

{
   if ((areacode & sBoundary) != sBoundary) {
     G4Exception("G4VTwistSurface::GetBoundaryAxis()", "GeomSolids0003",
                 FatalException, "Not located on a boundary!");
   }
   for (G4int i=0; i<2; ++i)
   {
      G4int whichaxis = 0 ;
      if (i == 0) {
         whichaxis = sAxis0;
      } else if (i == 1) {
         whichaxis = sAxis1;
      }
      
      // extracted axiscode of whichaxis
      G4int axiscode = whichaxis & sAxisMask & areacode ; 
      if (axiscode != 0) {
         if (axiscode == (whichaxis & sAxisX)) {
            axis[i] = kXAxis;
         } else if (axiscode == (whichaxis & sAxisY)) {
            axis[i] = kYAxis;
         } else if (axiscode == (whichaxis & sAxisZ)) {
            axis[i] = kZAxis;
         } else if (axiscode == (whichaxis & sAxisRho)) {
            axis[i] = kRho;
         } else if (axiscode == (whichaxis & sAxisPhi)) {
            axis[i] = kPhi;
         } else {
           std::ostringstream message;
           message << "Not supported areacode." << G4endl
                   << "        areacode " << areacode;
           G4Exception("G4VTwistSurface::GetBoundaryAxis()", "GeomSolids0001",
                       FatalException, message);
         }
      }
   }
}

◆ GetBoundaryLimit()

void G4VTwistSurface::GetBoundaryLimit	(	G4int	areacode,
		G4double	limit[] ) const

protected

Definition at line 811 of file G4VTwistSurface.cc.

{
   if ((areacode & sCorner) != 0) {
      if ((areacode & sC0Min1Min) != 0) {
         limit[0] = fAxisMin[0];
         limit[1] = fAxisMin[1];
      } else if ((areacode & sC0Max1Min) != 0) {
         limit[0] = fAxisMax[0];
         limit[1] = fAxisMin[1];
      } else if ((areacode & sC0Max1Max) != 0) {
         limit[0] = fAxisMax[0];
         limit[1] = fAxisMax[1];
      } else if ((areacode & sC0Min1Max) != 0) {
         limit[0] = fAxisMin[0];
         limit[1] = fAxisMax[1];
      }
   } else if ((areacode & sBoundary) != 0) {
      if ((areacode & (sAxis0 | sAxisMin)) != 0) {
         limit[0] = fAxisMin[0];
      } else if ((areacode & (sAxis1 | sAxisMin)) != 0) {
         limit[0] = fAxisMin[1];
      } else if ((areacode & (sAxis0 | sAxisMax)) != 0) {
         limit[0] = fAxisMax[0];
      } else if ((areacode & (sAxis1 | sAxisMax)) != 0) {
         limit[0] = fAxisMax[1];
      }
   } else {
     std::ostringstream message;
     message << "Not located on a boundary!" << G4endl
             << "          areacode " << areacode;
     G4Exception("G4VTwistSurface::GetBoundaryLimit()", "GeomSolids1002",
                 JustWarning, message);
   }
}

◆ GetBoundaryMax()

virtual G4double G4VTwistSurface::GetBoundaryMax ( G4double )

pure virtual

◆ GetBoundaryMin()

virtual G4double G4VTwistSurface::GetBoundaryMin ( G4double )

pure virtual

Internal accessors to be implemented in concrete derived classes.

◆ GetBoundaryParameters()

void G4VTwistSurface::GetBoundaryParameters	(	const G4int &	areacode,
		G4ThreeVector &	d,
		G4ThreeVector &	x0,
		G4int &	boundarytype ) const

virtual

Returns parameters of boundaries.

Parameters

[in]	areacode	The location code.
[out]	d	Boundary direction.
[out]	x0	The point on boundary.
[out]	boundarytype	The boundary code.

Definition at line 656 of file G4VTwistSurface.cc.

{
   // areacode must be one of them:
   // sAxis0 & sAxisMin, sAxis0 & sAxisMax,
   // sAxis1 & sAxisMin, sAxis1 & sAxisMax.
   
   for (const auto & boundary : fBoundaries)
   {
      if (boundary.GetBoundaryParameters(areacode, d, x0, boundarytype))
      {
         return;
      }
   }
 
   std::ostringstream message;
   message << "Not registered boundary." << G4endl
           << "        Boundary at areacode " << std::hex << areacode
           << std::dec << G4endl
           << "        is not registered.";
   G4Exception("G4VTwistSurface::GetBoundaryParameters()", "GeomSolids0002",
               FatalException, message);
}

Referenced by DistanceToBoundary(), G4TwistTubsSide::DistanceToSurface(), and IsSameBoundary().

◆ GetCorner()

G4ThreeVector G4VTwistSurface::GetCorner ( G4int areacode ) const

inlineprotected

Referenced by DebugPrint(), and IsSameBoundary().

◆ GetEdgeVisibility()

G4int G4VTwistSurface::GetEdgeVisibility	(	G4int	i,
		G4int	j,
		G4int	m,
		G4int	n,
		G4int	number,
		G4int	orientation )

Checks face visibility, based on verteces and orientation.

Returns: -1 if invisible; 1 if visible.

Definition at line 981 of file G4VTwistSurface.cc.

{
  // clockwise filling         -> positive orientation
  // counter clockwise filling -> negative orientation 
 
  //
  //   d    C    c
  //     +------+ 
  //     |      |
  //     |      |
  //     |      |
  //   D |      |B
  //     |      |
  //     |      |
  //     |      |
  //     +------+
  //    a   A    b
  //    
  //  a = +--+    A = ---+
  //  b = --++    B = --+-
  //  c = -++-    C = -+--
  //  d = ++--    D = +---
 
 
  // check first invisible faces
 
  if ( ( i>0 && i<n-2 ) && ( j>0 && j<k-2 ) )
  {
    return -1 ;   // always invisible, signs:   ----
  }
  
  // change first the vertex number (depends on the orientation)
  // 0,1,2,3  -> 3,2,1,0
  if ( orientation < 0 ) { number = ( 3 - number ) ;  }
  
  // check true edges
  if ( ( j>=1 && j<=k-3 ) )
  {
    if ( i == 0 )        // signs (A):  ---+
    {
      return ( number == 3 ) ? 1 : -1 ;
    }
    
    if ( i == n-2 )      // signs (C):  -+--
    {
      return  ( number == 1 ) ? 1 : -1 ; 
    }
    
    std::ostringstream message;
    message << "Not correct face number: " << GetName() << " !";
    G4Exception("G4TwistSurface::G4GetEdgeVisibility()",
                "GeomSolids0003", FatalException, message);
  }
  
  if ( ( i>=1 && i<=n-3 ) )
  {
    if ( j == 0 )    // signs (D):  +---
    {
      return ( number == 0 ) ? 1 : -1 ;
    }
 
    if ( j == k-2 )  // signs (B):  --+-
    {
      return  ( number == 2 ) ? 1 : -1 ; 
    }
    
    std::ostringstream message;
    message << "Not correct face number: " << GetName() << " !";
    G4Exception("G4TwistSurface::G4GetEdgeVisibility()",
                "GeomSolids0003", FatalException, message);
  }
  
  // now the corners
  if ( i == 0 && j == 0 )          // signs (a) : +--+
  {
    return ( number == 0 || number == 3 ) ? 1 : -1 ;
  }
  if ( i == 0 && j == k-2 )   // signs (b) : --++
  {
    return ( number == 2 || number == 3 ) ? 1 : -1 ;
  }
  if ( i == n-2 && j == k-2 ) // signs (c) : -++-
  {
    return ( number == 1 || number == 2 ) ? 1 : -1 ;
  }
  if ( i == n-2 && j == 0 )   // signs (d) : ++--
  {
    return ( number == 0 || number == 1 ) ? 1 : -1 ;
  }
 
  std::ostringstream message;
  message << "Not correct face number: " << GetName() << " !";
  G4Exception("G4TwistSurface::G4GetEdgeVisibility()", "GeomSolids0003",
              FatalException, message);
 
  return 0 ;
}

◆ GetFace()

G4int G4VTwistSurface::GetFace	(	G4int	i,
		G4int	j,
		G4int	m,
		G4int	n,
		G4int	iside )

Definition at line 891 of file G4VTwistSurface.cc.

{
  // this is the face mapping function
  // (i,j) -> face number
 
  if ( iside == 0 ) { return i * ( k - 1 ) + j ; }
  if ( iside == 1 ) { return (k-1)*(k-1) + i*(k-1) + j ; }
  if ( iside == 2 ) { return 2*(k-1)*(k-1) + i*(k-1) + j ; }
  if ( iside == 3 ) { return 2*(k-1)*(k-1) + (n-1)*(k-1) + i*(k-1) + j ; }
  if ( iside == 4 ) { return 2*(k-1)*(k-1) + 2*(n-1)*(k-1) + i*(k-1) + j ; }
  if ( iside == 5 ) { return 2*(k-1)*(k-1) + 3*(n-1)*(k-1) + i*(k-1) + j ; }
 
  std::ostringstream message;
  message << "Not correct side number: "
          << GetName() << G4endl
          << "iside is " << iside << " but should be "
          << "0,1,2,3,4 or 5" << ".";
  G4Exception("G4TwistSurface::G4GetFace()", "GeomSolids0002",
              FatalException, message);
 
  return -1 ;  // wrong face
}

◆ GetFacets()

virtual void G4VTwistSurface::GetFacets	(	G4int	m,
		G4int	n,
		G4double	xyz[][3],
		G4int	faces[][4],
		G4int	iside )

pure virtual

◆ GetName()

const G4String & G4VTwistSurface::GetName ( ) const

inline

Returns the surface name.

Definition at line 292 of file G4VTwistSurface.hh.

292{ return fName; }

Referenced by G4TwistTrapFlatSide::DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), G4TwistBoxSide::G4TwistBoxSide(), GetEdgeVisibility(), GetFace(), GetNode(), and G4TwistTubsHypeSide::Inside().

◆ GetNeighbours() [1/2]

G4VTwistSurface ** G4VTwistSurface::GetNeighbours ( )

inlineprotected

Internal accessors.

Definition at line 311 of file G4VTwistSurface.hh.

311{ return fNeighbours; }

Referenced by DistanceToIn().

◆ GetNeighbours() [2/2]

G4int G4VTwistSurface::GetNeighbours	(	G4int	areacode,
		G4VTwistSurface *	surfaces[] )

inlineprotected

◆ GetNode()

G4int G4VTwistSurface::GetNode	(	G4int	i,
		G4int	j,
		G4int	m,
		G4int	n,
		G4int	iside )

Node/face mapping functions.

Definition at line 918 of file G4VTwistSurface.cc.

{
  // this is the node mapping function
  // (i,j) -> node number
  // Depends on the side iside and the used meshing of the surface
 
  if ( iside == 0 )
  {
    // lower endcap is kxk squared. 
    // n = k 
    return i * k + j ;
  }
  if ( iside == 1 )
  {
    // upper endcap is kxk squared. Shift by k*k
    // n = k 
    return  k*k + i*k + j ;
  }
  if ( iside == 2 )
  {
    // front side.
    if ( i == 0 )   { return       j ;  }
    if ( i == n-1 ) { return k*k + j ;  } 
    return 2*k*k + 4*(i-1)*(k-1) + j ;
  }
  if ( iside == 3 )
  {
    // right side
    if ( i == 0 )   { return       (j+1)*k - 1 ; } 
    if ( i == n-1 ) { return k*k + (j+1)*k - 1 ; }
    return 2*k*k + 4*(i-1)*(k-1) + (k-1) + j ;
  }
  if ( iside == 4 )
  {
    // back side
    if ( i == 0 )   { return   k*k - 1 - j ; }    // reversed order
    if ( i == n-1 ) { return 2*k*k - 1 - j ; }    // reversed order 
    return 2*k*k + 4*(i-1)*(k-1) + 2*(k-1) + j ; // normal order
  }
  if ( iside == 5 )
  {
    // left side 
    if      ( i == 0 ) { return k*k   - (j+1)*k ; }  // reversed order
    if ( i == n-1) { return 2*k*k - (j+1)*k ; }  // reverded order
    if ( j == k-1 ) { return 2*k*k + 4*(i-1)*(k-1) ; } // special case
    return 2*k*k + 4*(i-1)*(k-1) + 3*(k-1) + j ; // normal order
  }
 
  std::ostringstream message;
  message << "Not correct side number: "
          << GetName() << G4endl
          << "iside is " << iside << " but should be "
          << "0,1,2,3,4 or 5" << ".";
  G4Exception("G4TwistSurface::G4GetNode()", "GeomSolids0002",
              FatalException, message);
 
  return -1 ;  // wrong node 
} 

◆ GetNormal()

virtual G4ThreeVector G4VTwistSurface::GetNormal	(	const G4ThreeVector &	p,
		G4bool	isGlobal )

pure virtual

Returns a normal vector at a surface (or very close to the surface) point at 'p'.

Parameters

[in]	p	The point where computing the normal.
[in]	isGlobal	If true, it returns the normal in global coordinates.

Returns: The normal vector.

Implemented in G4TwistBoxSide, G4TwistTrapAlphaSide, G4TwistTrapFlatSide, G4TwistTrapParallelSide, G4TwistTubsFlatSide, G4TwistTubsHypeSide, and G4TwistTubsSide.

Referenced by DistanceToIn(), G4TwistedTubs::DistanceToOut(), G4VTwistedFaceted::DistanceToOut(), DistanceToOut(), G4TwistedTubs::SurfaceNormal(), and G4VTwistedFaceted::SurfaceNormal().

◆ GetSurfaceArea()

virtual G4double G4VTwistSurface::GetSurfaceArea ( )

pure virtual

◆ IsAxis0()

G4bool G4VTwistSurface::IsAxis0 ( G4int areacode ) const

inline

Test functions/accessors, based on 'areacode' location.

Referenced by DistanceToBoundary().

◆ IsAxis1()

G4bool G4VTwistSurface::IsAxis1 ( G4int areacode ) const

inline

Referenced by DistanceToBoundary().

◆ IsBoundary()

G4bool G4VTwistSurface::IsBoundary	(	G4int	areacode,
		G4bool	testbitmode = false ) const

inline

Referenced by G4TwistTubsHypeSide::Inside(), and IsSameBoundary().

◆ IsCorner()

G4bool G4VTwistSurface::IsCorner	(	G4int	areacode,
		G4bool	testbitmode = false ) const

inline

Referenced by IsSameBoundary().

◆ IsInside()

G4bool G4VTwistSurface::IsInside	(	G4int	areacode,
		G4bool	testbitmode = false ) const

inline

Referenced by DistanceToIn(), G4TwistBoxSide::DistanceToSurface(), G4TwistTrapAlphaSide::DistanceToSurface(), G4TwistTrapFlatSide::DistanceToSurface(), G4TwistTrapParallelSide::DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), G4TwistTubsHypeSide::DistanceToSurface(), G4TwistTubsSide::DistanceToSurface(), and G4TwistTubsHypeSide::Inside().

◆ IsOutside()

G4bool G4VTwistSurface::IsOutside ( G4int areacode ) const

inline

Referenced by G4TwistBoxSide::DistanceToSurface(), G4TwistTrapAlphaSide::DistanceToSurface(), G4TwistTrapFlatSide::DistanceToSurface(), G4TwistTrapParallelSide::DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), G4TwistTubsHypeSide::DistanceToSurface(), G4TwistTubsSide::DistanceToSurface(), and G4TwistTubsHypeSide::Inside().

◆ IsSameBoundary()

G4bool G4VTwistSurface::IsSameBoundary	(	G4VTwistSurface *	surface1,
		G4int	areacode1,
		G4VTwistSurface *	surface2,
		G4int	areacode2 ) const

Definition at line 609 of file G4VTwistSurface.cc.

{
   //
   // IsSameBoundary
   //
   // checking tool whether two boundaries on different surfaces are same or not.
   //
 
   G4bool testbitmode = true;
   G4bool iscorner[2] = {IsCorner(areacode1, testbitmode), 
                         IsCorner(areacode2, testbitmode)};
 
   if (iscorner[0] && iscorner[1])
   {
      // on corner 
      G4ThreeVector corner1 = 
           surf1->ComputeGlobalPoint(surf1->GetCorner(areacode1));
      G4ThreeVector corner2 = 
           surf2->ComputeGlobalPoint(surf2->GetCorner(areacode2));
 
      return (corner1 - corner2).mag() < kCarTolerance;
   }
   if ((IsBoundary(areacode1, testbitmode) && (!iscorner[0])) &&
            (IsBoundary(areacode2, testbitmode) && (!iscorner[1])))
   {
      // on boundary  
      G4ThreeVector d1, d2, ld1, ld2;
      G4ThreeVector x01, x02, lx01, lx02;
      G4int         type1, type2;
      surf1->GetBoundaryParameters(areacode1, ld1, lx01, type1);
      surf2->GetBoundaryParameters(areacode2, ld2, lx02, type2);
 
      x01 = surf1->ComputeGlobalPoint(lx01);
      x02 = surf2->ComputeGlobalPoint(lx02);
      d1  = surf1->ComputeGlobalDirection(ld1);
      d2  = surf2->ComputeGlobalDirection(ld2);
 
      return (x01 - x02).mag() < kCarTolerance
            && (d1 - d2).mag() < kCarTolerance;
   }
   return false;
}

Referenced by DistanceToIn().

◆ IsValidNorm()

G4bool G4VTwistSurface::IsValidNorm ( ) const

inline

Definition at line 241 of file G4VTwistSurface.hh.

241{ return fIsValidNorm; }

Referenced by G4TwistedTubs::DistanceToOut(), and G4VTwistedFaceted::DistanceToOut().

◆ SetAxis()

void G4VTwistSurface::SetAxis	(	G4int	i,
		const EAxis	axis )

inline

Modifiers for axes.

Definition at line 257 of file G4VTwistSurface.hh.

257{ fAxis[i] = axis; }

◆ SetBoundary()

void G4VTwistSurface::SetBoundary	(	const G4int &	axiscode,
		const G4ThreeVector &	direction,
		const G4ThreeVector &	x0,
		const G4int &	boundarytype )

protectedvirtual

Modifier for boundaries.

Parameters

[in]	axiscode	The location code, either: sAxis0 & sAxisMin, sAxis0 & sAxisMax, sAxis1 & sAxisMin, sAxis1 & sAxisMax.
[in]	direction	Direction.
[in]	x0	Point on boundary.
[in]	boundarytype	The shape of locus from the start point to end point of boundary (ex. sAxisRho = linear line which start point is fixed at origin; sAxisPhi = part of circle which center placed at the origin.

Definition at line 849 of file G4VTwistSurface.cc.

{
   G4int code = (~sAxisMask) & axiscode;
   if ((code == (sAxis0 & sAxisMin)) ||
       (code == (sAxis0 & sAxisMax)) ||
       (code == (sAxis1 & sAxisMin)) ||
       (code == (sAxis1 & sAxisMax)))
   {
      G4bool done = false;
      for (auto & boundary : fBoundaries)
      {
         if (boundary.IsEmpty())
         {
            boundary.SetFields(axiscode, direction, x0, boundarytype);
            done = true;
            break;
         }
      }
 
      if (!done)
      {
         G4Exception("G4VTwistSurface::SetBoundary()", "GeomSolids0003",
                      FatalException, "Number of boundary exceeding 4!");
      }
   }
   else
   {
      std::ostringstream message;
      message << "Invalid axis-code." << G4endl
              << "        axiscode = "
              << std::hex << axiscode << std::dec;
      G4Exception("G4VTwistSurface::SetBoundary()", "GeomSolids0003",
                  FatalException, message);
   }
}

◆ SetCorner()

void G4VTwistSurface::SetCorner	(	G4int	areacode,
		G4double	x,
		G4double	y,
		G4double	z )

protected

Modifier for corners.

Definition at line 743 of file G4VTwistSurface.cc.

{
   if ((areacode & sCorner) != sCorner)
   {
     std::ostringstream message;
     message << "Area code must represents corner." << G4endl
             << "        areacode " << areacode;
     G4Exception("G4VTwistSurface::SetCorner()", "GeomSolids0002",
                 FatalException, message);
   }
 
   if ((areacode & sC0Min1Min) == sC0Min1Min) {
      fCorners[0].set(x, y, z);
   } else if ((areacode & sC0Max1Min) == sC0Max1Min) {
      fCorners[1].set(x, y, z);
   } else if ((areacode & sC0Max1Max) == sC0Max1Max) {
      fCorners[2].set(x, y, z);
   } else if ((areacode & sC0Min1Max) == sC0Min1Max) {
      fCorners[3].set(x, y, z);
   }
}

◆ SetNeighbours()

void G4VTwistSurface::SetNeighbours	(	G4VTwistSurface *	ax0min,
		G4VTwistSurface *	ax1min,
		G4VTwistSurface *	ax0max,
		G4VTwistSurface *	ax1max )

inline

◆ SurfacePoint()

virtual G4ThreeVector G4VTwistSurface::SurfacePoint	(	G4double	,
		G4double	,
		G4bool	isGlobal = false )

pure virtual

Returns point on surface given the axes.

Member Data Documentation

◆ fAxis

EAxis G4VTwistSurface::fAxis[2]

protected

Definition at line 452 of file G4VTwistSurface.hh.

Referenced by DebugPrint(), G4TwistTubsSide::DistanceToSurface(), G4TwistBoxSide::G4TwistBoxSide(), G4TwistTrapAlphaSide::G4TwistTrapAlphaSide(), G4TwistTrapFlatSide::G4TwistTrapFlatSide(), G4TwistTrapParallelSide::G4TwistTrapParallelSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4TwistTubsHypeSide::G4TwistTubsHypeSide(), G4TwistTubsSide::G4TwistTubsSide(), G4VTwistSurface(), G4VTwistSurface(), G4VTwistSurface(), and SetAxis().

◆ fAxisMax

G4double G4VTwistSurface::fAxisMax[2]

protected

Definition at line 454 of file G4VTwistSurface.hh.

Referenced by DebugPrint(), G4TwistBoxSide::G4TwistBoxSide(), G4TwistTrapAlphaSide::G4TwistTrapAlphaSide(), G4TwistTrapFlatSide::G4TwistTrapFlatSide(), G4TwistTrapParallelSide::G4TwistTrapParallelSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4TwistTubsHypeSide::G4TwistTubsHypeSide(), G4TwistTubsSide::G4TwistTubsSide(), G4VTwistSurface(), G4VTwistSurface(), G4VTwistSurface(), and GetBoundaryLimit().

◆ fAxisMin

G4double G4VTwistSurface::fAxisMin[2]

protected

Definition at line 453 of file G4VTwistSurface.hh.

Referenced by DebugPrint(), G4TwistBoxSide::G4TwistBoxSide(), G4TwistTrapAlphaSide::G4TwistTrapAlphaSide(), G4TwistTrapFlatSide::G4TwistTrapFlatSide(), G4TwistTrapParallelSide::G4TwistTrapParallelSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4TwistTubsHypeSide::G4TwistTubsHypeSide(), G4TwistTubsSide::G4TwistTubsSide(), G4VTwistSurface(), G4VTwistSurface(), G4VTwistSurface(), and GetBoundaryLimit().

◆ fCurrentNormal

G4SurfCurNormal G4VTwistSurface::fCurrentNormal

protected

Definition at line 469 of file G4VTwistSurface.hh.

Referenced by G4TwistTrapFlatSide::G4TwistTrapFlatSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4VTwistSurface(), G4VTwistSurface(), G4TwistBoxSide::GetNormal(), G4TwistTrapAlphaSide::GetNormal(), G4TwistTrapFlatSide::GetNormal(), G4TwistTrapParallelSide::GetNormal(), G4TwistTubsFlatSide::GetNormal(), G4TwistTubsHypeSide::GetNormal(), and G4TwistTubsSide::GetNormal().

◆ fCurStat

CurrentStatus G4VTwistSurface::fCurStat

protected

Definition at line 456 of file G4VTwistSurface.hh.

Referenced by G4TwistBoxSide::DistanceToSurface(), G4TwistTrapAlphaSide::DistanceToSurface(), G4TwistTrapFlatSide::DistanceToSurface(), G4TwistTrapParallelSide::DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), G4TwistTubsHypeSide::DistanceToSurface(), G4TwistTubsSide::DistanceToSurface(), and G4TwistTubsSide::DistanceToSurface().

◆ fCurStatWithV

CurrentStatus G4VTwistSurface::fCurStatWithV

protected

Definition at line 455 of file G4VTwistSurface.hh.

Referenced by G4TwistBoxSide::DistanceToSurface(), G4TwistTrapAlphaSide::DistanceToSurface(), G4TwistTrapFlatSide::DistanceToSurface(), G4TwistTrapParallelSide::DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), G4TwistTubsHypeSide::DistanceToSurface(), G4TwistTubsHypeSide::DistanceToSurface(), G4TwistTubsSide::DistanceToSurface(), and G4TwistTubsSide::DistanceToSurface().

◆ fHandedness

G4int G4VTwistSurface::fHandedness

protected

Definition at line 459 of file G4VTwistSurface.hh.

Referenced by G4TwistTrapFlatSide::G4TwistTrapFlatSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4TwistTubsHypeSide::G4TwistTubsHypeSide(), G4TwistTubsSide::G4TwistTubsSide(), G4VTwistSurface(), G4VTwistSurface(), G4VTwistSurface(), G4TwistTubsHypeSide::GetNormal(), G4TwistTubsSide::GetNormal(), and G4TwistTubsHypeSide::Inside().

◆ fIsValidNorm

G4bool G4VTwistSurface::fIsValidNorm

protected

Definition at line 470 of file G4VTwistSurface.hh.

Referenced by G4TwistBoxSide::G4TwistBoxSide(), G4TwistTrapAlphaSide::G4TwistTrapAlphaSide(), G4TwistTrapFlatSide::G4TwistTrapFlatSide(), G4TwistTrapParallelSide::G4TwistTrapParallelSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4TwistTubsHypeSide::G4TwistTubsHypeSide(), G4TwistTubsHypeSide::G4TwistTubsHypeSide(), G4TwistTubsSide::G4TwistTubsSide(), G4TwistTubsSide::G4TwistTubsSide(), G4VTwistSurface(), G4VTwistSurface(), G4VTwistSurface(), and IsValidNorm().

◆ fRot

G4RotationMatrix G4VTwistSurface::fRot

protected

Definition at line 457 of file G4VTwistSurface.hh.

Referenced by DebugPrint(), G4TwistBoxSide::G4TwistBoxSide(), G4TwistTrapAlphaSide::G4TwistTrapAlphaSide(), G4TwistTrapFlatSide::G4TwistTrapFlatSide(), G4TwistTrapParallelSide::G4TwistTrapParallelSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4TwistTubsSide::G4TwistTubsSide(), G4VTwistSurface(), G4TwistTubsHypeSide::GetRhoAtPZ(), and G4TwistTubsSide::ProjectAtPXPZ().

◆ fTrans

G4ThreeVector G4VTwistSurface::fTrans

protected

Definition at line 458 of file G4VTwistSurface.hh.

Referenced by DebugPrint(), G4TwistBoxSide::G4TwistBoxSide(), G4TwistTrapAlphaSide::G4TwistTrapAlphaSide(), G4TwistTrapFlatSide::G4TwistTrapFlatSide(), G4TwistTrapParallelSide::G4TwistTrapParallelSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4TwistTubsHypeSide::G4TwistTubsHypeSide(), G4TwistTubsSide::G4TwistTubsSide(), G4VTwistSurface(), G4TwistTubsHypeSide::GetRhoAtPZ(), and G4TwistTubsSide::ProjectAtPXPZ().

◆ kCarTolerance

G4double G4VTwistSurface::kCarTolerance

protected

◆ sAreaMask

const G4int G4VTwistSurface::sAreaMask = 0XF0000000

static

Definition at line 371 of file G4VTwistSurface.hh.

◆ sAxis0

const G4int G4VTwistSurface::sAxis0 = 0x0000FF00

static

Definition at line 367 of file G4VTwistSurface.hh.

Referenced by G4TwistTubsSide::DistanceToSurface(), GetBoundaryAtPZ(), GetBoundaryAxis(), GetBoundaryLimit(), G4VTwistSurface::Boundary::GetBoundaryParameters(), and SetBoundary().

◆ sAxis1

const G4int G4VTwistSurface::sAxis1 = 0x000000FF

static

Definition at line 368 of file G4VTwistSurface.hh.

Referenced by GetBoundaryAtPZ(), GetBoundaryAxis(), GetBoundaryLimit(), G4VTwistSurface::Boundary::GetBoundaryParameters(), and SetBoundary().

◆ sAxisMask

const G4int G4VTwistSurface::sAxisMask = 0x0000FCFC

static

Definition at line 370 of file G4VTwistSurface.hh.

Referenced by GetBoundaryAxis(), and SetBoundary().

◆ sAxisMax

const G4int G4VTwistSurface::sAxisMax = 0x00000202

static

Definition at line 361 of file G4VTwistSurface.hh.

Referenced by G4TwistTubsSide::DistanceToSurface(), GetBoundaryLimit(), and SetBoundary().

◆ sAxisMin

const G4int G4VTwistSurface::sAxisMin = 0x00000101

static

Definition at line 360 of file G4VTwistSurface.hh.

Referenced by G4TwistTubsSide::DistanceToSurface(), GetBoundaryLimit(), and SetBoundary().

◆ sAxisPhi

const G4int G4VTwistSurface::sAxisPhi = 0x00001414

static

Definition at line 366 of file G4VTwistSurface.hh.

Referenced by DistanceToBoundary(), GetBoundaryAtPZ(), and GetBoundaryAxis().

◆ sAxisRho

const G4int G4VTwistSurface::sAxisRho = 0x00001010

static

Definition at line 365 of file G4VTwistSurface.hh.

Referenced by GetBoundaryAtPZ(), and GetBoundaryAxis().

◆ sAxisX

const G4int G4VTwistSurface::sAxisX = 0x00000404

static

Definition at line 362 of file G4VTwistSurface.hh.

Referenced by GetBoundaryAxis().

◆ sAxisY

const G4int G4VTwistSurface::sAxisY = 0x00000808

static

Definition at line 363 of file G4VTwistSurface.hh.

Referenced by GetBoundaryAxis().

◆ sAxisZ

const G4int G4VTwistSurface::sAxisZ = 0x00000C0C

static

Definition at line 364 of file G4VTwistSurface.hh.

Referenced by GetBoundaryAxis().

◆ sBoundary

const G4int G4VTwistSurface::sBoundary = 0x20000000

static

Definition at line 354 of file G4VTwistSurface.hh.

Referenced by GetBoundaryAxis(), and GetBoundaryLimit().

◆ sC0Max1Max

const G4int G4VTwistSurface::sC0Max1Max = 0x40000202

static

Definition at line 358 of file G4VTwistSurface.hh.

Referenced by DebugPrint(), GetBoundaryLimit(), and SetCorner().

◆ sC0Max1Min

const G4int G4VTwistSurface::sC0Max1Min = 0x40000201

static

Definition at line 357 of file G4VTwistSurface.hh.

Referenced by DebugPrint(), GetBoundaryLimit(), and SetCorner().

◆ sC0Min1Max

const G4int G4VTwistSurface::sC0Min1Max = 0x40000102

static

Definition at line 359 of file G4VTwistSurface.hh.

Referenced by DebugPrint(), GetBoundaryLimit(), and SetCorner().

◆ sC0Min1Min

const G4int G4VTwistSurface::sC0Min1Min = 0x40000101

static

Definition at line 356 of file G4VTwistSurface.hh.

Referenced by DebugPrint(), GetBoundaryLimit(), and SetCorner().

◆ sCorner

const G4int G4VTwistSurface::sCorner = 0x40000000

static

Definition at line 355 of file G4VTwistSurface.hh.

Referenced by GetBoundaryLimit(), and SetCorner().

◆ sInside

const G4int G4VTwistSurface::sInside = 0x10000000

static

Definition at line 353 of file G4VTwistSurface.hh.

Referenced by G4TwistTrapFlatSide::DistanceToSurface(), G4TwistTrapFlatSide::DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), G4TwistTubsHypeSide::DistanceToSurface(), G4TwistTubsHypeSide::DistanceToSurface(), G4TwistTubsSide::DistanceToSurface(), and G4TwistTubsSide::DistanceToSurface().

◆ sOutside

const G4int G4VTwistSurface::sOutside = 0x00000000

static

◆ sSizeMask

const G4int G4VTwistSurface::sSizeMask = 0x00000303

static

Definition at line 369 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::Boundary::GetBoundaryParameters().

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

Classes

Public Types

Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Detailed Description

Member Enumeration Documentation

◆ EValidate

Constructor & Destructor Documentation

◆ G4VTwistSurface() [1/3]

◆ G4VTwistSurface() [2/3]

◆ ~G4VTwistSurface()

◆ G4VTwistSurface() [3/3]

Member Function Documentation

◆ AmIOnLeftSide()

◆ ComputeGlobalDirection()

◆ ComputeGlobalPoint()

◆ ComputeLocalDirection()

◆ ComputeLocalPoint()

◆ DebugPrint()

◆ DistanceTo()

◆ DistanceToBoundary()

◆ DistanceToIn()

◆ DistanceToLine()

◆ DistanceToOut()

◆ DistanceToPlane() [1/2]

◆ DistanceToPlane() [2/2]

◆ DistanceToPlaneWithV()

◆ DistanceToSurface() [1/2]

◆ DistanceToSurface() [2/2]

◆ GetAreaCode()

◆ GetAxisType()

◆ GetBoundaryAtPZ()

◆ GetBoundaryAxis()

◆ GetBoundaryLimit()

◆ GetBoundaryMax()

◆ GetBoundaryMin()

◆ GetBoundaryParameters()

◆ GetCorner()

◆ GetEdgeVisibility()

◆ GetFace()

◆ GetFacets()

◆ GetName()

◆ GetNeighbours() [1/2]

◆ GetNeighbours() [2/2]

◆ GetNode()

◆ GetNormal()

◆ GetSurfaceArea()

◆ IsAxis0()

◆ IsAxis1()

◆ IsBoundary()

◆ IsCorner()

◆ IsInside()

◆ IsOutside()

◆ IsSameBoundary()

◆ IsValidNorm()

◆ SetAxis()

◆ SetBoundary()

◆ SetCorner()

◆ SetNeighbours()

◆ SurfacePoint()

Member Data Documentation

◆ fAxis

◆ fAxisMax

◆ fAxisMin

◆ fCurrentNormal

◆ fCurStat

◆ fCurStatWithV

◆ fHandedness

◆ fIsValidNorm

◆ fRot

◆ fTrans

◆ kCarTolerance

◆ sAreaMask

◆ sAxis0

◆ sAxis1

◆ sAxisMask

◆ sAxisMax

◆ sAxisMin