#include <G4TwistTubsSide.hh>

Inheritance diagram for G4TwistTubsSide:

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

Public Member Functions
virtual G4int	AmIOnLeftSide (const G4ThreeVector &me, const G4ThreeVector &vec, G4bool withTol=true)

G4ThreeVector	ComputeGlobalDirection (const G4ThreeVector &lp) const

G4ThreeVector	ComputeGlobalPoint (const G4ThreeVector &lp) const

G4ThreeVector	ComputeLocalDirection (const G4ThreeVector &gp) const

G4ThreeVector	ComputeLocalPoint (const G4ThreeVector &gp) const

void	DebugPrint () const

virtual G4double	DistanceTo (const G4ThreeVector &gp, G4ThreeVector &gxx)

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

virtual G4double	DistanceToIn (const G4ThreeVector &gp, const G4ThreeVector &gv, G4ThreeVector &gxxbest)

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

virtual G4double	DistanceToOut (const G4ThreeVector &gp, const G4ThreeVector &gv, G4ThreeVector &gxxbest)

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	DistanceToPlaneWithV (const G4ThreeVector &p, const G4ThreeVector &v, const G4ThreeVector &x0, const G4ThreeVector &n0, G4ThreeVector &xx)

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

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

	G4TwistTubsSide (__void__ &)

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

	G4TwistTubsSide (const G4String &name, G4double EndInnerRadius[2], G4double EndOuterRadius[2], G4double DPhi, G4double EndPhi[2], G4double EndZ[2], G4double InnerRadius, G4double OuterRadius, G4double Kappa, G4int handedness)

G4int	GetAxisType (G4int areacode, G4int whichaxis) const

virtual G4ThreeVector	GetBoundaryAtPZ (G4int areacode, const G4ThreeVector &p) const

virtual G4double	GetBoundaryMax (G4double phi)

virtual G4double	GetBoundaryMin (G4double phi)

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

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

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

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

virtual G4String	GetName () const

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

virtual G4ThreeVector	GetNormal (const G4ThreeVector &xx, G4bool isGlobal=false)

virtual G4double	GetSurfaceArea ()

G4bool	IsAxis0 (G4int areacode) const

G4bool	IsAxis1 (G4int areacode) const

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

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

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

G4bool	IsOutside (G4int areacode) const

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

G4bool	IsValidNorm () const

G4ThreeVector	ProjectAtPXPZ (const G4ThreeVector &p, G4bool isglobal=false) 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)

virtual	~G4TwistTubsSide ()

Static Public Attributes
static const G4int	sAreaMask = 0XF0000000

static const G4int	sAxis0 = 0x0000FF00

static const G4int	sAxis1 = 0x000000FF

static const G4int	sAxisMask = 0x0000FCFC

static const G4int	sAxisMax = 0x00000202

static const G4int	sAxisMin = 0x00000101

static const G4int	sAxisPhi = 0x00001414

static const G4int	sAxisRho = 0x00001010

static const G4int	sAxisX = 0x00000404

static const G4int	sAxisY = 0x00000808

static const G4int	sAxisZ = 0x00000C0C

static const G4int	sBoundary = 0x20000000

static const G4int	sC0Max1Max = 0x40000202

static const G4int	sC0Max1Min = 0x40000201

static const G4int	sC0Min1Max = 0x40000102

static const G4int	sC0Min1Min = 0x40000101

static const G4int	sCorner = 0x40000000

static const G4int	sInside = 0x10000000

static const G4int	sOutside = 0x00000000

static const G4int	sSizeMask = 0x00000303

Protected Member Functions
void	GetBoundaryAxis (G4int areacode, EAxis axis[]) const

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

G4ThreeVector	GetCorner (G4int areacode) const

G4VTwistSurface **	GetNeighbours ()

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

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	fAxisMax [2]

G4double	fAxisMin [2]

G4SurfCurNormal	fCurrentNormal

CurrentStatus	fCurStat

CurrentStatus	fCurStatWithV

G4int	fHandedness

G4bool	fIsValidNorm

G4RotationMatrix	fRot

G4ThreeVector	fTrans

G4double	kCarTolerance

Private Member Functions
virtual G4double	DistanceToPlane (const G4ThreeVector &p, const G4ThreeVector &A, const G4ThreeVector &B, const G4ThreeVector &C, const G4ThreeVector &D, const G4int parity, G4ThreeVector &xx, G4ThreeVector &n)

virtual G4int	GetAreaCode (const G4ThreeVector &xx, G4bool withTol=true)

virtual void	SetBoundaries ()

virtual void	SetCorners ()

virtual void	SetCorners (G4double endInnerRad[2], G4double endOuterRad[2], G4double endPhi[2], G4double endZ[2])

Private Attributes
G4SurfSideQuery	fAmIOnLeftSide

Boundary	fBoundaries [4]

G4ThreeVector	fCorners [4]

G4double	fKappa

G4String	fName

G4VTwistSurface *	fNeighbours [4]

Detailed Description

Definition at line 41 of file G4TwistTubsSide.hh.

Member Enumeration Documentation

◆ EValidate

enum G4VTwistSurface::EValidate

inherited

Enumerator
kDontValidate
kValidateWithTol
kValidateWithoutTol
kUninitialized

Definition at line 52 of file G4VTwistSurface.hh.

52 { kDontValidate = 0, kValidateWithTol = 1,

53 kValidateWithoutTol = 2, kUninitialized = 3 };

G4VTwistSurface::kUninitialized

@ kUninitialized

Definition: G4VTwistSurface.hh:53

G4VTwistSurface::kValidateWithTol

@ kValidateWithTol

Definition: G4VTwistSurface.hh:52

G4VTwistSurface::kDontValidate

@ kDontValidate

Definition: G4VTwistSurface.hh:52

G4VTwistSurface::kValidateWithoutTol

@ kValidateWithoutTol

Definition: G4VTwistSurface.hh:53

Constructor & Destructor Documentation

◆ G4TwistTubsSide() [1/3]

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

Definition at line 38 of file G4TwistTubsSide.cc.

   : G4VTwistSurface(name, rot, tlate, handedness, axis0, axis1,
                     axis0min, axis1min, axis0max, axis1max),
     fKappa(kappa)
{
   if (axis0 == kZAxis && axis1 == kXAxis)
   {
      G4Exception("G4TwistTubsSide::G4TwistTubsSide()", "GeomSolids0002",
                  FatalErrorInArgument, "Should swap axis0 and axis1!");
   }
   fIsValidNorm = false;
   SetCorners();
   SetBoundaries();
}

References FatalErrorInArgument, G4VTwistSurface::fIsValidNorm, G4Exception(), kXAxis, kZAxis, SetBoundaries(), and SetCorners().

◆ G4TwistTubsSide() [2/3]

G4TwistTubsSide::G4TwistTubsSide	(	const G4String &	name,
		G4double	EndInnerRadius[2],
		G4double	EndOuterRadius[2],
		G4double	DPhi,
		G4double	EndPhi[2],
		G4double	EndZ[2],
		G4double	InnerRadius,
		G4double	OuterRadius,
		G4double	Kappa,
		G4int	handedness
	)

Definition at line 63 of file G4TwistTubsSide.cc.

  : G4VTwistSurface(name)
{  
   fHandedness = handedness;   // +z = +ve, -z = -ve
   fAxis[0]    = kXAxis; // in local coordinate system
   fAxis[1]    = kZAxis;
   fAxisMin[0] = InnerRadius;  // Inner-hype radius at z=0
   fAxisMax[0] = OuterRadius;  // Outer-hype radius at z=0
   fAxisMin[1] = EndZ[0];
   fAxisMax[1] = EndZ[1];
 
   fKappa = Kappa;
   fRot.rotateZ( fHandedness > 0
                 ? -0.5*DPhi
                 :  0.5*DPhi );
   fTrans.set(0, 0, 0);
   fIsValidNorm = false;
   
   SetCorners( EndInnerRadius, EndOuterRadius, EndPhi, EndZ) ;
   SetBoundaries();
}

References G4VTwistSurface::fAxis, G4VTwistSurface::fAxisMax, G4VTwistSurface::fAxisMin, G4VTwistSurface::fHandedness, G4VTwistSurface::fIsValidNorm, fKappa, G4VTwistSurface::fRot, G4VTwistSurface::fTrans, kXAxis, kZAxis, CLHEP::HepRotation::rotateZ(), CLHEP::Hep3Vector::set(), SetBoundaries(), and SetCorners().

◆ ~G4TwistTubsSide()

G4TwistTubsSide::~G4TwistTubsSide ( )

virtual

Definition at line 106 of file G4TwistTubsSide.cc.

107{

108}

◆ G4TwistTubsSide() [3/3]

G4TwistTubsSide::G4TwistTubsSide ( __void__ & a )

Definition at line 97 of file G4TwistTubsSide.cc.

  : G4VTwistSurface(a), fKappa(0.)
{
}

Member Function Documentation

◆ AmIOnLeftSide()

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

virtualinherited

Definition at line 147 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;
}

References G4VTwistSurface::G4SurfSideQuery::amIOnLeftSide, CLHEP::Hep3Vector::cross(), G4VTwistSurface::fAmIOnLeftSide, G4VTwistSurface::fName, G4cout, G4endl, G4GeometryTolerance::GetAngularTolerance(), G4GeometryTolerance::GetInstance(), G4VTwistSurface::G4SurfSideQuery::me, CLHEP::HepRotation::rotateZ(), G4VTwistSurface::G4SurfSideQuery::vec, G4VTwistSurface::G4SurfSideQuery::withTol, CLHEP::Hep3Vector::x(), and CLHEP::Hep3Vector::y().

Referenced by DistanceToSurface(), G4TwistTubsFlatSide::GetAreaCode(), and G4TwistTubsHypeSide::GetAreaCodeInPhi().

◆ ComputeGlobalDirection()

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

inlineinherited

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

◆ ComputeGlobalPoint()

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

inlineinherited

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

◆ ComputeLocalDirection()

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

inlineinherited

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

◆ ComputeLocalPoint()

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

inlineinherited

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

◆ DebugPrint()

void G4VTwistSurface::DebugPrint ( ) const

inherited

Definition at line 1139 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;
}

References A, B(), C(), D(), G4VTwistSurface::fAxis, G4VTwistSurface::fAxisMax, G4VTwistSurface::fAxisMin, G4VTwistSurface::fName, G4VTwistSurface::fRot, G4VTwistSurface::fTrans, G4cout, G4endl, G4VTwistSurface::GetCorner(), G4VTwistSurface::sC0Max1Max, G4VTwistSurface::sC0Max1Min, G4VTwistSurface::sC0Min1Max, and G4VTwistSurface::sC0Min1Min.

◆ DistanceTo()

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

virtualinherited

Definition at line 577 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];
}

References G4VTwistSurface::DistanceToSurface(), G4VTwistSurface::fName, G4cout, G4endl, G4VSURFACENXX, kInfinity, and G4VTwistSurface::sOutside.

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

◆ DistanceToBoundary()

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

virtualinherited

Definition at line 231 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;
}

References G4VTwistSurface::DistanceToLine(), FatalException, G4endl, G4Exception(), G4VTwistSurface::GetBoundaryParameters(), CLHEP::Hep3Vector::getRho(), G4VTwistSurface::IsAxis0(), G4VTwistSurface::IsAxis1(), kInfinity, G4VTwistSurface::sAxisPhi, CLHEP::Hep3Vector::set(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by DistanceToSurface().

◆ DistanceToIn()

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

virtualinherited

Definition at line 290 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 .  
               //
 
               }
               else 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] == true && isaccepted[1] == true)
         {
            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;
}

References G4VTwistSurface::DistanceToSurface(), G4VTwistSurface::fName, G4cout, G4endl, G4VSURFACENXX, G4VTwistSurface::GetNeighbours(), G4VTwistSurface::GetNormal(), G4VTwistSurface::IsInside(), G4VTwistSurface::IsSameBoundary(), kInfinity, G4VTwistSurface::kValidateWithTol, CLHEP::normal(), and G4VTwistSurface::sOutside.

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

◆ DistanceToLine()

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

inlineinherited

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

◆ DistanceToOut()

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

virtualinherited

Definition at line 494 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;
}

References G4VTwistSurface::DistanceToSurface(), G4VTwistSurface::fName, G4cout, G4endl, G4VSURFACENXX, G4VTwistSurface::GetNormal(), kInfinity, G4VTwistSurface::kValidateWithTol, CLHEP::normal(), and G4VTwistSurface::sOutside.

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

◆ DistanceToPlane() [1/3]

G4double G4TwistTubsSide::DistanceToPlane	(	const G4ThreeVector &	p,
		const G4ThreeVector &	A,
		const G4ThreeVector &	B,
		const G4ThreeVector &	C,
		const G4ThreeVector &	D,
		const G4int	parity,
		G4ThreeVector &	xx,
		G4ThreeVector &	n
	)

privatevirtual

Definition at line 747 of file G4TwistTubsSide.cc.

{
   const G4double halftol = 0.5 * kCarTolerance;
   
   G4ThreeVector M = 0.5*(A + B);
   G4ThreeVector N = 0.5*(C + D);
   G4ThreeVector xxanm;  // foot of normal from p to plane ANM
   G4ThreeVector nanm;   // normal of plane ANM
   G4ThreeVector xxcmn;  // foot of normal from p to plane CMN
   G4ThreeVector ncmn;   // normal of plane CMN
 
   G4double distToanm = G4VTwistSurface::DistanceToPlane(p, A, (N - A), (M - A),
                                                         xxanm, nanm) * parity;
   G4double distTocmn = G4VTwistSurface::DistanceToPlane(p, C, (M - C), (N - C),
                                                         xxcmn, ncmn) * parity;
#ifdef G4SPECSDEBUG
   // if p is behind of both surfaces, abort.
   if (distToanm * distTocmn > 0 && distToanm < 0)
   {
     G4Exception("G4TwistTubsSide::DistanceToPlane()",
                 "GeomSolids0003", FatalException,
                 "Point p is behind the surfaces.");
   }
#endif
   // if p is on surface, return 0.
   if (std::fabs(distToanm) <= halftol)
   {
      xx = xxanm;
      n  = nanm * parity;
      return 0;
   }
   else if (std::fabs(distTocmn) <= halftol)
   {
      xx = xxcmn;
      n  = ncmn * parity;
      return 0;
   }
   
   if (distToanm <= distTocmn)
   {
      if (distToanm > 0)
      {
         // both distanses are positive. take smaller one.
         xx = xxanm;
         n  = nanm * parity;
         return distToanm;
      }
      else
      {
         // take -ve distance and call the function recursively.
         return DistanceToPlane(p, A, M, N, D, parity, xx, n);
      }
   }
   else
   {
      if (distTocmn > 0)
      {
         // both distanses are positive. take smaller one.
         xx = xxcmn;
         n  = ncmn * parity;
         return distTocmn;
      }
      else
      {
         // take -ve distance and call the function recursively.
         return DistanceToPlane(p, C, N, M, B, parity, xx, n);
      }
   }
}

References A, B(), C(), D(), DistanceToPlane(), G4VTwistSurface::DistanceToPlane(), FatalException, G4Exception(), G4VTwistSurface::kCarTolerance, M, CLHEP::detail::n, and parity().

Referenced by DistanceToPlane(), and DistanceToSurface().

◆ DistanceToPlane() [2/3]

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

inlineinherited

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

◆ DistanceToPlane() [3/3]

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

inlineinherited

◆ DistanceToPlaneWithV()

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

inlineinherited

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

◆ DistanceToSurface() [1/2]

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

virtual

Implements G4VTwistSurface.

Definition at line 156 of file G4TwistTubsSide.cc.

{
   // Coordinate system:
   //
   //    The coordinate system is so chosen that the intersection of
   //    the twisted surface with the z=0 plane coincides with the
   //    x-axis. 
   //    Rotation matrix from this coordinate system (local system)
   //    to global system is saved in fRot field.
   //    So the (global) particle position and (global) velocity vectors, 
   //    p and v, should be rotated fRot.inverse() in order to convert
   //    to local vectors.
   //
   // Equation of a twisted surface:
   //
   //    x(rho(z=0), z) = rho(z=0)
   //    y(rho(z=0), z) = rho(z=0)*K*z
   //    z(rho(z=0), z) = z
   //    with
   //       K = std::tan(fPhiTwist/2)/fZHalfLen
   //
   // Equation of a line:
   //
   //    gxx = p + t*v
   //    with
   //       p = fRot.inverse()*gp  
   //       v = fRot.inverse()*gv
   //
   // Solution for intersection:
   //
   //    Required time for crossing is given by solving the
   //    following quadratic equation:
   //
   //       a*t^2 + b*t + c = 0
   //
   //    where
   //
   //       a = K*v_x*v_z
   //       b = K*(v_x*p_z + v_z*p_x) - v_y
   //       c = K*p_x*p_z - p_y
   //
   //    Out of the possible two solutions you must choose
   //    the one that gives a positive rho(z=0).
   //
   //
      
   fCurStatWithV.ResetfDone(validate, &gp, &gv);
 
   if (fCurStatWithV.IsDone())
   {
      for (G4int i=0; i<fCurStatWithV.GetNXX(); ++i)
      {
         gxx[i] = fCurStatWithV.GetXX(i);
         distance[i] = fCurStatWithV.GetDistance(i);
         areacode[i] = fCurStatWithV.GetAreacode(i);
         isvalid[i]  = fCurStatWithV.IsValid(i);
      }
      return fCurStatWithV.GetNXX();
   }
   else  // initialize
   {
      for (auto i=0; i<2; ++i)
      {
         distance[i] = kInfinity;
         areacode[i] = sOutside;
         isvalid[i]  = false;
         gxx[i].set(kInfinity, kInfinity, kInfinity);
      }
   }
 
   G4ThreeVector p = ComputeLocalPoint(gp);
   G4ThreeVector v = ComputeLocalDirection(gv);
   G4ThreeVector xx[2]; 
 
   // 
   // special case! 
   // p is origin or
   //
 
   G4double absvz = std::fabs(v.z());
 
   if ((absvz<DBL_MIN) && (std::fabs(p.x() * v.y() - p.y() * v.x())<DBL_MIN))
   {
      // no intersection
 
      isvalid[0] = false;
      fCurStat.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
                                isvalid[0], 0, validate, &gp, &gv);
      return 0;
   } 
   
   // 
   // special case end
   //
 
   G4double a = fKappa * v.x() * v.z();
   G4double b = fKappa * (v.x() * p.z() + v.z() * p.x()) - v.y();
   G4double c = fKappa * p.x() * p.z() - p.y();
   G4double D = b * b - 4 * a * c;             // discriminant
   G4int vout = 0;
 
   if (std::fabs(a) < DBL_MIN)
   {
      if (std::fabs(b) > DBL_MIN)
      {
         // single solution
 
         distance[0] = - c / b;
         xx[0]       = p + distance[0]*v;
         gxx[0]      = ComputeGlobalPoint(xx[0]);
 
         if (validate == kValidateWithTol)
         {
            areacode[0] = GetAreaCode(xx[0]);
            if (!IsOutside(areacode[0]))
            {
               if (distance[0] >= 0) isvalid[0] = true;
            }
         }
         else if (validate == kValidateWithoutTol)
         {
            areacode[0] = GetAreaCode(xx[0], false);
            if (IsInside(areacode[0]))
            {
               if (distance[0] >= 0) isvalid[0] = true;
            }
         }
         else  // kDontValidate
         { 
            // we must omit x(rho,z) = rho(z=0) < 0
            if (xx[0].x() > 0)
            {
               areacode[0] = sInside;
               if (distance[0] >= 0) isvalid[0] = true;
            }
            else
            {
               distance[0] = kInfinity;
               fCurStatWithV.SetCurrentStatus(0, gxx[0], distance[0],
                                              areacode[0], isvalid[0],
                                              0, validate, &gp, &gv);
               return vout;
            } 
         }
                 
         fCurStatWithV.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
                                        isvalid[0], 1, validate, &gp, &gv);
         vout = 1;
      }
      else
      {
         // if a=b=0 , v.y=0 and (v.x=0 && p.x=0) or (v.z=0 && p.z=0) .
         //    if v.x=0 && p.x=0, no intersection unless p is on z-axis
         //    (in that case, v is paralell to surface). 
         //    if v.z=0 && p.z=0, no intersection unless p is on x-axis
         //    (in that case, v is paralell to surface). 
         // return distance = infinity.
 
         fCurStatWithV.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
                                        isvalid[0], 0, validate, &gp, &gv);
      }
   }
   else if (D > DBL_MIN)
   {
      // double solutions
 
      D = std::sqrt(D);
      G4double      factor = 0.5/a;
      G4double      tmpdist[2] = {kInfinity, kInfinity};
      G4ThreeVector tmpxx[2];
      G4int         tmpareacode[2] = {sOutside, sOutside};
      G4bool        tmpisvalid[2]  = {false, false};
 
      for (auto i=0; i<2; ++i)
      {
         G4double bminusD = - b - D;
 
         // protection against round off error  
         //G4double protection = 1.0e-6;
         G4double protection = 0;
         if ( b * D < 0 && std::fabs(bminusD / D) < protection )
         {
            G4double acovbb = (a*c)/(b*b);
            tmpdist[i] = - c/b * ( 1 - acovbb * (1 + 2*acovbb));
         }
         else
         { 
            tmpdist[i] = factor * bminusD;
         }
 
         D = -D;
         tmpxx[i] = p + tmpdist[i]*v;
         
         if (validate == kValidateWithTol)
         {
            tmpareacode[i] = GetAreaCode(tmpxx[i]);
            if (!IsOutside(tmpareacode[i]))
            {
               if (tmpdist[i] >= 0) tmpisvalid[i] = true;
               continue;
            }
         }
         else if (validate == kValidateWithoutTol)
         {
            tmpareacode[i] = GetAreaCode(tmpxx[i], false);
            if (IsInside(tmpareacode[i]))
            {
               if (tmpdist[i] >= 0) tmpisvalid[i] = true;
               continue;
            }
         }
         else  // kDontValidate
         {
            // we must choose x(rho,z) = rho(z=0) > 0
            if (tmpxx[i].x() > 0)
            {
               tmpareacode[i] = sInside;
               if (tmpdist[i] >= 0) tmpisvalid[i] = true;
               continue;
            } else {
               tmpdist[i] = kInfinity;
               continue;
            }                     
         }
      }
      
      if (tmpdist[0] <= tmpdist[1])
      {
         distance[0] = tmpdist[0];
         distance[1] = tmpdist[1];
         xx[0]       = tmpxx[0];
         xx[1]       = tmpxx[1];
         gxx[0]      = ComputeGlobalPoint(tmpxx[0]);
         gxx[1]      = ComputeGlobalPoint(tmpxx[1]);
         areacode[0] = tmpareacode[0];
         areacode[1] = tmpareacode[1];
         isvalid[0]  = tmpisvalid[0];
         isvalid[1]  = tmpisvalid[1];
      }
      else
      {
         distance[0] = tmpdist[1];
         distance[1] = tmpdist[0];
         xx[0]       = tmpxx[1];
         xx[1]       = tmpxx[0];
         gxx[0]      = ComputeGlobalPoint(tmpxx[1]);
         gxx[1]      = ComputeGlobalPoint(tmpxx[0]);
         areacode[0] = tmpareacode[1];
         areacode[1] = tmpareacode[0];
         isvalid[0]  = tmpisvalid[1];
         isvalid[1]  = tmpisvalid[0];
      }
         
      fCurStatWithV.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
                                     isvalid[0], 2, validate, &gp, &gv);
      fCurStatWithV.SetCurrentStatus(1, gxx[1], distance[1], areacode[1],
                                     isvalid[1], 2, validate, &gp, &gv);
 
      // protection against roundoff error
 
      for (G4int k=0; k<2; ++k)
      {
         if (!isvalid[k]) continue;
 
         G4ThreeVector xxonsurface(xx[k].x(), fKappa * std::fabs(xx[k].x())
                                              * xx[k].z() , xx[k].z());
         G4double      deltaY  =  (xx[k] - xxonsurface).mag();
 
         if ( deltaY > 0.5*kCarTolerance )
         {
           G4int maxcount = 10;
           G4int l;
           G4double lastdeltaY = deltaY; 
           for (l=0; l<maxcount; ++l)
           {
             G4ThreeVector surfacenormal = GetNormal(xxonsurface); 
             distance[k] = DistanceToPlaneWithV(p, v, xxonsurface,
                                                surfacenormal, xx[k]);
             deltaY      = (xx[k] - xxonsurface).mag();
             if (deltaY > lastdeltaY) { }   // ???
             gxx[k]      = ComputeGlobalPoint(xx[k]);
 
             if (deltaY <= 0.5*kCarTolerance) break;
             xxonsurface.set(xx[k].x(),
                             fKappa * std::fabs(xx[k].x()) * xx[k].z(),
                             xx[k].z());
           }
           if (l == maxcount)
           {
             std::ostringstream message;
             message << "Exceeded maxloop count!" << G4endl
                     << "        maxloop count " << maxcount;
             G4Exception("G4TwistTubsFlatSide::DistanceToSurface(p,v)",
                         "GeomSolids0003",  FatalException, message);
           }
         }
      }
      vout = 2;
   }
   else
   {
      // if D<0, no solution
      // if D=0, just grazing the surfaces, return kInfinity
 
      fCurStatWithV.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
                                     isvalid[0], 0, validate, &gp, &gv);
   }
 
   return vout;
}

◆ DistanceToSurface() [2/2]

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

virtual

Implements G4VTwistSurface.

Definition at line 476 of file G4TwistTubsSide.cc.

{  
   fCurStat.ResetfDone(kDontValidate, &gp);
   if (fCurStat.IsDone())
   {
      for (G4int i=0; i<fCurStat.GetNXX(); ++i)
      {
         gxx[i] = fCurStat.GetXX(i);
         distance[i] = fCurStat.GetDistance(i);
         areacode[i] = fCurStat.GetAreacode(i);
      }
      return fCurStat.GetNXX();
   }
   else  // initialize
   {
      for (auto i=0; i<2; ++i)
      {
         distance[i] = kInfinity;
         areacode[i] = sOutside;
         gxx[i].set(kInfinity, kInfinity, kInfinity);
      }
   }
   
   const G4double halftol = 0.5 * kCarTolerance; 
 
   G4ThreeVector  p       = ComputeLocalPoint(gp);
   G4ThreeVector  xx;
   G4int          parity  = (fKappa >= 0 ? 1 : -1);
 
   // 
   // special case! 
   // If p is on surface, or
   // p is on z-axis, 
   // return here immediatery.
   //
   
   G4ThreeVector  lastgxx[2];
   for (auto i=0; i<2; ++i)
   {
      lastgxx[i] = fCurStatWithV.GetXX(i);
   } 
 
   if  ((gp - lastgxx[0]).mag() < halftol
     || (gp - lastgxx[1]).mag() < halftol)
   { 
      // last winner, or last poststep point is on the surface.
      xx = p;
      distance[0] = 0;
      gxx[0] = gp;
 
      G4bool isvalid = true;
      fCurStat.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
                             isvalid, 1, kDontValidate, &gp);
      return 1;
   }
          
   if (p.getRho() == 0)
   { 
      // p is on z-axis. Namely, p is on twisted surface (invalid area).
      // We must return here, however, returning distance to x-minimum
      // boundary is better than return 0-distance.
      //
      G4bool isvalid = true;
      if (fAxis[0] == kXAxis && fAxis[1] == kZAxis)
      {
         distance[0] = DistanceToBoundary(sAxis0 & sAxisMin, xx, p);
         areacode[0] = sInside;
      }
      else
      {
         distance[0] = 0;
         xx.set(0., 0., 0.);
      }
      gxx[0] = ComputeGlobalPoint(xx);
      fCurStat.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
                                isvalid, 0, kDontValidate, &gp);
      return 1;
   } 
 
   // 
   // special case end
   //
 
   // set corner points of quadrangle try area ...
 
   G4ThreeVector A;  // foot of normal from p to boundary of sAxis0 & sAxisMin
   G4ThreeVector C;  // foot of normal from p to boundary of sAxis0 & sAxisMax
   G4ThreeVector B;       // point on boundary sAxis0 & sAxisMax at z = A.z()
   G4ThreeVector D;       // point on boundary sAxis0 & sAxisMin at z = C.z()
 
   // G4double      distToA; // distance from p to A
   DistanceToBoundary(sAxis0 & sAxisMin, A, p);
   // G4double      distToC; // distance from p to C 
   DistanceToBoundary(sAxis0 & sAxisMax, C, p);
   
   // is p.z between a.z and c.z?
   // p.z must be bracketed a.z and c.z.
   if (A.z() > C.z())
   {
      if (p.z() > A.z())
      {
         A = GetBoundaryAtPZ(sAxis0 & sAxisMin, p);
      }
      else if (p.z() < C.z())
      {
         C = GetBoundaryAtPZ(sAxis0 & sAxisMax, p);
      }
   }
   else
   {
      if (p.z() > C.z())
      {
         C = GetBoundaryAtPZ(sAxis0 & sAxisMax, p);
      }
      else if (p.z() < A.z())
      {
         A = GetBoundaryAtPZ(sAxis0 & sAxisMin, p);
      }
   }
 
   G4ThreeVector  d[2];     // direction vectors of boundary
   G4ThreeVector  x0[2];    // foot of normal from line to p 
   G4int          btype[2]; // boundary type
 
   for (auto i=0; i<2; ++i)
   {
      if (i == 0)
      {
         GetBoundaryParameters((sAxis0 & sAxisMax), d[i], x0[i], btype[i]);
         B = x0[i] + ((A.z() - x0[i].z()) / d[i].z()) * d[i]; 
         // x0 + t*d , d is direction unit vector.
      }
      else
      {
         GetBoundaryParameters((sAxis0 & sAxisMin), d[i], x0[i], btype[i]);
         D = x0[i] + ((C.z() - x0[i].z()) / d[i].z()) * d[i]; 
      }
   }
 
   // In order to set correct diagonal, swap A and D, C and B if needed.  
   G4ThreeVector pt(p.x(), p.y(), 0.);
   G4double      rc = std::fabs(p.x());
   G4ThreeVector surfacevector(rc, rc * fKappa * p.z(), 0.); 
   G4int         pside = AmIOnLeftSide(pt, surfacevector); 
   G4double      test  = (A.z() - C.z()) * parity * pside;  
 
   if (test == 0)
   {
      if (pside == 0)
      {
         // p is on surface.
         xx = p;
         distance[0] = 0;
         gxx[0] = gp;
 
         G4bool isvalid = true;
         fCurStat.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
                                   isvalid, 1, kDontValidate, &gp);
         return 1;
      }
      else
      {
         // A.z = C.z(). return distance to line.
         d[0] = C - A;
         distance[0] = DistanceToLine(p, A, d[0], xx);
         areacode[0] = sInside;
         gxx[0] = ComputeGlobalPoint(xx);
         G4bool isvalid = true;
         fCurStat.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
                                   isvalid, 1, kDontValidate, &gp);
         return 1;
      } 
   }
   else if (test < 0)  // wrong diagonal. vector AC is crossing the surface! 
   {                   // swap A and D, C and B
      G4ThreeVector tmp;
      tmp = A;
      A = D;
      D = tmp;
      tmp = C;
      C = B;
      B = tmp; 
 
   }
   else  // correct diagonal. nothing to do.  
   {
   }
 
   // Now, we chose correct diagonal.
   // First try. divide quadrangle into double triangle by diagonal and 
   // calculate distance to both surfaces.
 
   G4ThreeVector xxacb;   // foot of normal from plane ACB to p
   G4ThreeVector nacb;    // normal of plane ACD
   G4ThreeVector xxcad;   // foot of normal from plane CAD to p
   G4ThreeVector ncad;    // normal of plane CAD
   G4ThreeVector AB(A.x(), A.y(), 0);
   G4ThreeVector DC(C.x(), C.y(), 0);
 
   G4double distToACB = G4VTwistSurface::DistanceToPlane(p, A, C-A, AB,
                                                         xxacb, nacb) * parity;
   G4double distToCAD = G4VTwistSurface::DistanceToPlane(p, C, C-A, DC,
                                                         xxcad, ncad) * parity;
   // if calculated distance = 0, return  
 
   if (std::fabs(distToACB) <= halftol || std::fabs(distToCAD) <= halftol)
   {
      xx = (std::fabs(distToACB) < std::fabs(distToCAD) ? xxacb : xxcad); 
      areacode[0] = sInside;
      gxx[0] = ComputeGlobalPoint(xx);
      distance[0] = 0;
      G4bool isvalid = true;
      fCurStat.SetCurrentStatus(0, gxx[0], distance[0] , areacode[0],
                                isvalid, 1, kDontValidate, &gp);
      return 1;
   }
   
   if (distToACB * distToCAD > 0 && distToACB < 0)
   {
      // both distToACB and distToCAD are negative.
      // divide quadrangle into double triangle by diagonal
      G4ThreeVector normal;
      distance[0] = DistanceToPlane(p, A, B, C, D, parity, xx, normal);
   }
   else
   {
      if (distToACB * distToCAD > 0)
      {
         // both distToACB and distToCAD are positive.
         // Take smaller one.
         if (distToACB <= distToCAD)
         {
            distance[0] = distToACB;
            xx   = xxacb;
         }
         else
         {
            distance[0] = distToCAD;
            xx   = xxcad;
         }
      }
      else
      {
         // distToACB * distToCAD is negative.
         // take positive one
         if (distToACB > 0)
         {
            distance[0] = distToACB;
            xx   = xxacb;
         }
         else
         {
            distance[0] = distToCAD;
            xx   = xxcad;
         }
      }
   }
   areacode[0] = sInside;
   gxx[0]      = ComputeGlobalPoint(xx);
   G4bool isvalid = true;
   fCurStat.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
                             isvalid, 1, kDontValidate, &gp);
   return 1;
}

◆ GetAreaCode()

G4int G4TwistTubsSide::GetAreaCode	(	const G4ThreeVector &	xx,
		G4bool	withTol = `true`
	)

privatevirtual

Implements G4VTwistSurface.

Definition at line 827 of file G4TwistTubsSide.cc.

{
   // We must use the function in local coordinate system.
   // See the description of DistanceToSurface(p,v).
   
   const G4double ctol = 0.5 * kCarTolerance;
   G4int areacode = sInside;
   
   if (fAxis[0] == kXAxis && fAxis[1] == kZAxis)
   {
      G4int xaxis = 0;
      G4int zaxis = 1;
      
      if (withTol)
      {
         G4bool isoutside   = false;
 
         // test boundary of xaxis
 
         if (xx.x() < fAxisMin[xaxis] + ctol)
         {
            areacode |= (sAxis0 & (sAxisX | sAxisMin)) | sBoundary; 
            if (xx.x() <= fAxisMin[xaxis] - ctol) isoutside = true;
 
         }
         else if (xx.x() > fAxisMax[xaxis] - ctol)
         {
            areacode |= (sAxis0 & (sAxisX | sAxisMax)) | sBoundary;
            if (xx.x() >= fAxisMax[xaxis] + ctol)  isoutside = true;
         }
 
         // test boundary of z-axis
 
         if (xx.z() < fAxisMin[zaxis] + ctol)
         {
            areacode |= (sAxis1 & (sAxisZ | sAxisMin)); 
 
            if   (areacode & sBoundary) areacode |= sCorner;  // xx is on corner
            else                        areacode |= sBoundary;
            if (xx.z() <= fAxisMin[zaxis] - ctol) isoutside = true;
 
         }
         else if (xx.z() > fAxisMax[zaxis] - ctol)
         {
            areacode |= (sAxis1 & (sAxisZ | sAxisMax));
 
            if   (areacode & sBoundary) areacode |= sCorner;  // xx is on corner
            else                        areacode |= sBoundary; 
            if (xx.z() >= fAxisMax[zaxis] + ctol) isoutside = true;
         }
 
         // if isoutside = true, clear inside bit.             
         // if not on boundary, add axis information.             
         
         if (isoutside)
         {
            G4int tmpareacode = areacode & (~sInside);
            areacode = tmpareacode;
         }
         else if ((areacode & sBoundary) != sBoundary)
         {
            areacode |= (sAxis0 & sAxisX) | (sAxis1 & sAxisZ);
         }
      }
      else
      {
         // boundary of x-axis
 
         if (xx.x() < fAxisMin[xaxis] )
         {
            areacode |= (sAxis0 & (sAxisX | sAxisMin)) | sBoundary;
         }
         else if (xx.x() > fAxisMax[xaxis])
         {
            areacode |= (sAxis0 & (sAxisX | sAxisMax)) | sBoundary;
         }
         
         // boundary of z-axis
 
         if (xx.z() < fAxisMin[zaxis])
         {
            areacode |= (sAxis1 & (sAxisZ | sAxisMin));
            if   (areacode & sBoundary) areacode |= sCorner;  // xx is oncorner
            else                        areacode |= sBoundary; 
           
         }
         else if (xx.z() > fAxisMax[zaxis])
         {
            areacode |= (sAxis1 & (sAxisZ | sAxisMax)) ;
            if   (areacode & sBoundary) areacode |= sCorner;  // xx is on corner
            else                        areacode |= sBoundary; 
         }
 
         if ((areacode & sBoundary) != sBoundary)
         {
            areacode |= (sAxis0 & sAxisX) | (sAxis1 & sAxisZ);
         }           
      }
      return areacode;
   }
   else
   {
      G4Exception("G4TwistTubsSide::GetAreaCode()",
                  "GeomSolids0001", FatalException,
                  "Feature NOT implemented !");
   }
   return areacode;
}

References FatalException, G4VTwistSurface::fAxis, G4VTwistSurface::fAxisMax, G4VTwistSurface::fAxisMin, G4Exception(), G4VTwistSurface::kCarTolerance, kXAxis, kZAxis, G4VTwistSurface::sAxis0, G4VTwistSurface::sAxis1, G4VTwistSurface::sAxisMax, G4VTwistSurface::sAxisMin, G4VTwistSurface::sAxisX, G4VTwistSurface::sAxisZ, G4VTwistSurface::sBoundary, G4VTwistSurface::sCorner, G4VTwistSurface::sInside, CLHEP::Hep3Vector::x(), and CLHEP::Hep3Vector::z().

Referenced by DistanceToSurface().

◆ GetAxisType()

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

inlineinherited

◆ GetBoundaryAtPZ()

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

virtualinherited

Definition at line 698 of file G4VTwistSurface.cc.

{
   // areacode must be one of them:
   // sAxis0 & sAxisMin, sAxis0 & sAxisMax,
   // sAxis1 & sAxisMin, sAxis1 & sAxisMax.
 
   if (areacode & sAxis0 && areacode & sAxis1)
   {
     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;
   G4bool        found = false;
   
   for (G4int i=0; i<4; ++i)
   {
      if (fBoundaries[i].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;
}

References FatalException, G4VTwistSurface::fBoundaries, G4endl, G4Exception(), G4VTwistSurface::GetBoundaryParameters(), G4VTwistSurface::sAxis0, G4VTwistSurface::sAxis1, G4VTwistSurface::sAxisPhi, G4VTwistSurface::sAxisRho, and CLHEP::Hep3Vector::z().

Referenced by DistanceToSurface(), G4TwistTubsHypeSide::GetAreaCodeInPhi(), G4TwistTubsHypeSide::GetBoundaryMax(), and G4TwistTubsHypeSide::GetBoundaryMin().

◆ GetBoundaryAxis()

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

protectedinherited

Definition at line 783 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) {
         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);
         }
      }
   }
}

References FatalException, G4endl, G4Exception(), kPhi, kRho, kXAxis, kYAxis, kZAxis, G4VTwistSurface::sAxis0, G4VTwistSurface::sAxis1, G4VTwistSurface::sAxisMask, G4VTwistSurface::sAxisPhi, G4VTwistSurface::sAxisRho, G4VTwistSurface::sAxisX, G4VTwistSurface::sAxisY, G4VTwistSurface::sAxisZ, and G4VTwistSurface::sBoundary.

◆ GetBoundaryLimit()

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

protectedinherited

Definition at line 825 of file G4VTwistSurface.cc.

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

References G4VTwistSurface::fAxisMax, G4VTwistSurface::fAxisMin, G4endl, G4Exception(), JustWarning, G4VTwistSurface::sAxis0, G4VTwistSurface::sAxis1, G4VTwistSurface::sAxisMax, G4VTwistSurface::sAxisMin, G4VTwistSurface::sBoundary, G4VTwistSurface::sC0Max1Max, G4VTwistSurface::sC0Max1Min, G4VTwistSurface::sC0Min1Max, G4VTwistSurface::sC0Min1Min, and G4VTwistSurface::sCorner.

◆ GetBoundaryMax()

G4double G4TwistTubsSide::GetBoundaryMax ( G4double phi )

inlinevirtual

Implements G4VTwistSurface.

Definition at line 167 of file G4TwistTubsSide.hh.

{
  return  fAxisMax[0] ;  // outer radius at z = 0
}

References G4VTwistSurface::fAxisMax.

Referenced by GetFacets().

◆ GetBoundaryMin()

G4double G4TwistTubsSide::GetBoundaryMin ( G4double phi )

inlinevirtual

Implements G4VTwistSurface.

Definition at line 161 of file G4TwistTubsSide.hh.

{
  return  fAxisMin[0] ;  // inner radius at z = 0
}

References G4VTwistSurface::fAxisMin.

Referenced by GetFacets().

◆ GetBoundaryParameters()

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

virtualinherited

Definition at line 668 of file G4VTwistSurface.cc.

{
   // areacode must be one of them:
   // sAxis0 & sAxisMin, sAxis0 & sAxisMax,
   // sAxis1 & sAxisMin, sAxis1 & sAxisMax.
   
   for (G4int i=0; i<4; ++i)
   {
      if (fBoundaries[i].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);
}

References FatalException, G4VTwistSurface::fBoundaries, G4endl, G4Exception(), and G4VTwistSurface::GetBoundaryParameters().

Referenced by G4VTwistSurface::DistanceToBoundary(), DistanceToSurface(), G4VTwistSurface::GetBoundaryAtPZ(), G4VTwistSurface::GetBoundaryParameters(), and G4VTwistSurface::IsSameBoundary().

◆ GetCorner()

G4ThreeVector G4VTwistSurface::GetCorner ( G4int areacode ) const

inlineprotectedinherited

Referenced by G4VTwistSurface::DebugPrint(), G4TwistTubsFlatSide::GetAreaCode(), G4TwistTubsFlatSide::GetBoundaryMax(), G4TwistTubsFlatSide::GetBoundaryMin(), G4VTwistSurface::IsSameBoundary(), G4TwistBoxSide::SetBoundaries(), G4TwistTrapAlphaSide::SetBoundaries(), G4TwistTrapFlatSide::SetBoundaries(), G4TwistTrapParallelSide::SetBoundaries(), G4TwistTubsFlatSide::SetBoundaries(), G4TwistTubsHypeSide::SetBoundaries(), and SetBoundaries().

◆ GetEdgeVisibility()

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

inherited

Definition at line 1031 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 ;
    }
    
    else if ( i == n-2 ) {  // signs (C):  -+--
      return  ( number == 1 ) ? 1 : -1 ; 
    }
    
    else
    {
      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 ;
    }
 
    else if ( j == k-2 ) {  // signs (B):  --+-
      return  ( number == 2 ) ? 1 : -1 ; 
    }
 
    else
    {
      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 ;
  }
  else if ( i == 0 && j == k-2 ) {   // signs (b) : --++
    return ( number == 2 || number == 3 ) ? 1 : -1 ;
  }
  else if ( i == n-2 && j == k-2 ) { // signs (c) : -++-
    return ( number == 1 || number == 2 ) ? 1 : -1 ;
  }
  else if ( i == n-2 && j == 0 ) {   // signs (d) : ++--
    return ( number == 0 || number == 1 ) ? 1 : -1 ;
  }
  else
  {
    std::ostringstream message;
    message << "Not correct face number: " << GetName() << " !";
    G4Exception("G4TwistSurface::G4GetEdgeVisibility()",
                "GeomSolids0003", FatalException, message);
  }
 
  std::ostringstream message;
  message << "Not correct face number: " << GetName() << " !";
  G4Exception("G4TwistSurface::G4GetEdgeVisibility()", "GeomSolids0003",
              FatalException, message);
 
  return 0 ;
}

References FatalException, G4Exception(), G4VTwistSurface::GetName(), and CLHEP::detail::n.

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

◆ GetFace()

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

inherited

Definition at line 906 of file G4VTwistSurface.cc.

{
  // this is the face mapping function
  // (i,j) -> face number
 
  if ( iside == 0 ) {
    return i * ( k - 1 ) + j ;
  }
 
  else if ( iside == 1 ) {
    return (k-1)*(k-1) + i*(k-1) + j ;
  }
 
  else if ( iside == 2 ) {
    return 2*(k-1)*(k-1) + i*(k-1) + j ;
  }
 
  else if ( iside == 3 ) {
    return 2*(k-1)*(k-1) + (n-1)*(k-1) + i*(k-1) + j ;
  }
  
  else if ( iside == 4 ) {
    return 2*(k-1)*(k-1) + 2*(n-1)*(k-1) + i*(k-1) + j ;
  }
  
  else if ( iside == 5 ) {
    return 2*(k-1)*(k-1) + 3*(n-1)*(k-1) + i*(k-1) + j ;
  }
 
  else {
    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
}

References FatalException, G4endl, G4Exception(), G4VTwistSurface::GetName(), and CLHEP::detail::n.

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

◆ GetFacets()

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

virtual

Implements G4VTwistSurface.

Definition at line 1050 of file G4TwistTubsSide.cc.

{
  G4double z ;     // the two parameters for the surface equation
  G4double x,xmin,xmax ;
 
  G4ThreeVector p ;  // a point on the surface, given by (z,u)
 
  G4int nnode ;
  G4int nface ;
 
  // calculate the (n-1)*(k-1) vertices
 
  for ( G4int i = 0 ; i<n ; ++i )
  {
    z = fAxisMin[1] + i*(fAxisMax[1]-fAxisMin[1])/(n-1) ;
 
    for ( G4int j = 0 ; j<k ; ++j )
    {
      nnode = GetNode(i,j,k,n,iside) ;
 
      xmin = GetBoundaryMin(z) ; 
      xmax = GetBoundaryMax(z) ;
 
      if (fHandedness < 0)
      { 
        x = xmin + j*(xmax-xmin)/(k-1) ;
      }
      else
      {               
        x = xmax - j*(xmax-xmin)/(k-1) ;
      }
 
      p = SurfacePoint(x,z,true) ;  // surface point in global coord.system
 
      xyz[nnode][0] = p.x() ;
      xyz[nnode][1] = p.y() ;
      xyz[nnode][2] = p.z() ;
 
      if ( i<n-1 && j<k-1 )   // clock wise filling
      {
        nface = GetFace(i,j,k,n,iside) ;
 
    faces[nface][0] = GetEdgeVisibility(i,j,k,n,0,1)
                        * ( GetNode(i  ,j  ,k,n,iside)+1) ;  
    faces[nface][1] = GetEdgeVisibility(i,j,k,n,1,1)
                        * ( GetNode(i+1,j  ,k,n,iside)+1) ;
    faces[nface][2] = GetEdgeVisibility(i,j,k,n,2,1)
                        * ( GetNode(i+1,j+1,k,n,iside)+1) ;
    faces[nface][3] = GetEdgeVisibility(i,j,k,n,3,1)
                        * ( GetNode(i  ,j+1,k,n,iside)+1) ;
      }
    }
  }
}

References G4VTwistSurface::fAxisMax, G4VTwistSurface::fAxisMin, G4VTwistSurface::fHandedness, GetBoundaryMax(), GetBoundaryMin(), G4VTwistSurface::GetEdgeVisibility(), G4VTwistSurface::GetFace(), G4VTwistSurface::GetNode(), CLHEP::detail::n, SurfacePoint(), CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

◆ GetName()

virtual G4String G4VTwistSurface::GetName ( ) const

inlinevirtualinherited

Definition at line 107 of file G4VTwistSurface.hh.

107{ return fName; }

References G4VTwistSurface::fName.

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

◆ GetNeighbours() [1/2]

G4VTwistSurface ** G4VTwistSurface::GetNeighbours ( )

inlineprotectedinherited

Definition at line 183 of file G4VTwistSurface.hh.

183{ return fNeighbours; }

G4VTwistSurface::fNeighbours

G4VTwistSurface * fNeighbours[4]

Definition: G4VTwistSurface.hh:328

References G4VTwistSurface::fNeighbours.

Referenced by G4VTwistSurface::DistanceToIn().

◆ GetNeighbours() [2/2]

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

inlineprotectedinherited

◆ GetNode()

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

inherited

Definition at line 952 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 ;
  }
 
  else if ( iside == 2 )
  {
    // front side.
    if      ( i == 0 )   { return       j ;  }
    else if ( i == n-1 ) { return k*k + j ;  } 
    else                 { return 2*k*k + 4*(i-1)*(k-1) + j ; }
  }
 
  else if ( iside == 3 )
  {
    // right side
    if      ( i == 0 )   { return       (j+1)*k - 1 ; } 
    else if ( i == n-1 ) { return k*k + (j+1)*k - 1 ; }
    else
    {
      return 2*k*k + 4*(i-1)*(k-1) + (k-1) + j ;
    }
  }
  else if ( iside == 4 )
  {
    // back side
    if      ( i == 0 )   { return   k*k - 1 - j ; }    // reversed order
    else if ( i == n-1 ) { return 2*k*k - 1 - j ; }    // reversed order 
    else
    {
      return 2*k*k + 4*(i-1)*(k-1) + 2*(k-1) + j ; // normal order
    }
  }
  else if ( iside == 5 )
  {
    // left side 
    if      ( i == 0 )   { return k*k   - (j+1)*k ; }  // reversed order
    else if ( i == n-1)  { return 2*k*k - (j+1)*k ; }  // reverded order
    else
    {
      if ( j == k-1 ) { return 2*k*k + 4*(i-1)*(k-1) ; } // special case
      else
      {
        return 2*k*k + 4*(i-1)*(k-1) + 3*(k-1) + j ; // normal order
      }
    }
  }
  else
  {
    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 
} 

References FatalException, G4endl, G4Exception(), G4VTwistSurface::GetName(), and CLHEP::detail::n.

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

◆ GetNormal()

G4ThreeVector G4TwistTubsSide::GetNormal	(	const G4ThreeVector &	xx,
		G4bool	isGlobal = `false`
	)

virtual

Implements G4VTwistSurface.

Definition at line 113 of file G4TwistTubsSide.cc.

{
   // GetNormal returns a normal vector at a surface (or very close
   // to surface) point at tmpxx.
   // If isGlobal=true, it returns the normal in global coordinate.
   //
   G4ThreeVector xx;
   if (isGlobal)
   {
      xx = ComputeLocalPoint(tmpxx);
      if ((xx - fCurrentNormal.p).mag() < 0.5 * kCarTolerance)
      {
         return ComputeGlobalDirection(fCurrentNormal.normal);
      }
   }
   else
   {
      xx = tmpxx;
      if (xx == fCurrentNormal.p)
      {
         return fCurrentNormal.normal;
      }
   }
   
   G4ThreeVector er(1, fKappa * xx.z(), 0);
   G4ThreeVector ez(0, fKappa * xx.x(), 1);
   G4ThreeVector normal = fHandedness*(er.cross(ez));
 
   if (isGlobal)
   {
      fCurrentNormal.normal = ComputeGlobalDirection(normal.unit());
   }
   else
   {
      fCurrentNormal.normal = normal.unit();
   }
   return fCurrentNormal.normal;
}

References G4VTwistSurface::ComputeGlobalDirection(), G4VTwistSurface::ComputeLocalPoint(), CLHEP::Hep3Vector::cross(), G4VTwistSurface::fCurrentNormal, G4VTwistSurface::fHandedness, fKappa, G4VTwistSurface::kCarTolerance, CLHEP::normal(), G4VTwistSurface::G4SurfCurNormal::normal, G4VTwistSurface::G4SurfCurNormal::p, CLHEP::Hep3Vector::x(), and CLHEP::Hep3Vector::z().

Referenced by DistanceToSurface().

◆ GetSurfaceArea()

G4double G4TwistTubsSide::GetSurfaceArea ( )

inlinevirtual

Implements G4VTwistSurface.

Definition at line 173 of file G4TwistTubsSide.hh.

{
  // approximation only
  return ( fAxisMax[0] - fAxisMin[0] ) * ( fAxisMax[1] - fAxisMin[1] ) ;
}

References G4VTwistSurface::fAxisMax, and G4VTwistSurface::fAxisMin.

◆ IsAxis0()

G4bool G4VTwistSurface::IsAxis0 ( G4int areacode ) const

inlineinherited

Referenced by G4VTwistSurface::DistanceToBoundary().

◆ IsAxis1()

G4bool G4VTwistSurface::IsAxis1 ( G4int areacode ) const

inlineinherited

Referenced by G4VTwistSurface::DistanceToBoundary().

◆ IsBoundary()

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

inlineinherited

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

◆ IsCorner()

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

inlineinherited

Referenced by G4VTwistSurface::IsSameBoundary().

◆ IsInside()

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

inlineinherited

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

◆ IsOutside()

G4bool G4VTwistSurface::IsOutside ( G4int areacode ) const

inlineinherited

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

◆ IsSameBoundary()

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

inherited

Definition at line 616 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));
 
      if ((corner1 - corner2).mag() < kCarTolerance) { return true; }
      else                                           { return false; }
   }
   else 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);
 
      if ((x01 - x02).mag() < kCarTolerance &&
          (d1 - d2).mag() < kCarTolerance) { return true; }
      else                                 { return false; }
   }
   else
   {
      return false;
   }
}

References G4VTwistSurface::ComputeGlobalDirection(), G4VTwistSurface::ComputeGlobalPoint(), d1, d2, G4VTwistSurface::GetBoundaryParameters(), G4VTwistSurface::GetCorner(), G4VTwistSurface::IsBoundary(), G4VTwistSurface::IsCorner(), and G4VTwistSurface::kCarTolerance.

Referenced by G4VTwistSurface::DistanceToIn().

◆ IsValidNorm()

G4bool G4VTwistSurface::IsValidNorm ( ) const

inlineinherited

Definition at line 144 of file G4VTwistSurface.hh.

144{ return fIsValidNorm; }

References G4VTwistSurface::fIsValidNorm.

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

◆ ProjectAtPXPZ()

G4ThreeVector G4TwistTubsSide::ProjectAtPXPZ	(	const G4ThreeVector &	p,
		G4bool	isglobal = `false`
	)		const

inline

Definition at line 138 of file G4TwistTubsSide.hh.

{
  // Get Rho at p.z() on Hyperbolic Surface.
  G4ThreeVector tmpp;
  if (isglobal) { tmpp = fRot.inverse()*p - fTrans; }
  else          { tmpp = p; }
  G4ThreeVector xx(p.x(), p.x() * fKappa * p.z(), p.z());
  if (isglobal) { return (fRot * xx + fTrans); }
  return xx;
}

References fKappa, G4VTwistSurface::fRot, G4VTwistSurface::fTrans, CLHEP::HepRotation::inverse(), CLHEP::Hep3Vector::x(), and CLHEP::Hep3Vector::z().

◆ SetAxis()

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

inlineinherited

Definition at line 156 of file G4VTwistSurface.hh.

156{ fAxis[i] = axis; }

References G4VTwistSurface::fAxis.

◆ SetBoundaries()

void G4TwistTubsSide::SetBoundaries ( )

privatevirtual

Implements G4VTwistSurface.

Definition at line 1003 of file G4TwistTubsSide.cc.

{
   // Set direction-unit vector of boundary-lines in local coodinate. 
   //   
   G4ThreeVector direction;
   
   if (fAxis[0] == kXAxis && fAxis[1] == kZAxis)
   {
      // sAxis0 & sAxisMin
      direction = GetCorner(sC0Min1Max) - GetCorner(sC0Min1Min);
      direction = direction.unit();
      SetBoundary(sAxis0 & (sAxisX | sAxisMin), direction, 
                  GetCorner(sC0Min1Min), sAxisZ) ;
      
      // sAxis0 & sAxisMax
      direction = GetCorner(sC0Max1Max) - GetCorner(sC0Max1Min);
      direction = direction.unit();
      SetBoundary(sAxis0 & (sAxisX | sAxisMax), direction, 
                  GetCorner(sC0Max1Min), sAxisZ);
                  
      // sAxis1 & sAxisMin
      direction = GetCorner(sC0Max1Min) - GetCorner(sC0Min1Min);
      direction = direction.unit();
      SetBoundary(sAxis1 & (sAxisZ | sAxisMin), direction, 
                  GetCorner(sC0Min1Min), sAxisX);
                  
      // sAxis1 & sAxisMax
      direction = GetCorner(sC0Max1Max) - GetCorner(sC0Min1Max);
      direction = direction.unit();
      SetBoundary(sAxis1 & (sAxisZ | sAxisMax), direction, 
                  GetCorner(sC0Min1Max), sAxisX);
                  
   }
   else
   {
      std::ostringstream message;
      message << "Feature NOT implemented !" << G4endl
              << "        fAxis[0] = " << fAxis[0] << G4endl
              << "        fAxis[1] = " << fAxis[1];
      G4Exception("G4TwistTubsSide::SetCorners()",
                  "GeomSolids0001", FatalException, message);
   }
}

References FatalException, G4VTwistSurface::fAxis, G4endl, G4Exception(), G4VTwistSurface::GetCorner(), kXAxis, kZAxis, G4VTwistSurface::sAxis0, G4VTwistSurface::sAxis1, G4VTwistSurface::sAxisMax, G4VTwistSurface::sAxisMin, G4VTwistSurface::sAxisX, G4VTwistSurface::sAxisZ, G4VTwistSurface::sC0Max1Max, G4VTwistSurface::sC0Max1Min, G4VTwistSurface::sC0Min1Max, G4VTwistSurface::sC0Min1Min, G4VTwistSurface::SetBoundary(), and CLHEP::Hep3Vector::unit().

Referenced by G4TwistTubsSide().

◆ SetBoundary()

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

protectedvirtualinherited

Definition at line 863 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 i=0; i<4; ++i)
      {
         if (fBoundaries[i].IsEmpty())
         {
            fBoundaries[i].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);
   }
}

References FatalException, G4VTwistSurface::fBoundaries, G4endl, G4Exception(), G4VTwistSurface::sAxis0, G4VTwistSurface::sAxis1, G4VTwistSurface::sAxisMax, G4VTwistSurface::sAxisMin, and G4VTwistSurface::Boundary::SetFields().

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

◆ SetCorner()

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

protectedinherited

Definition at line 757 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);
   }
}

References FatalException, G4VTwistSurface::fCorners, G4endl, G4Exception(), G4VTwistSurface::sC0Max1Max, G4VTwistSurface::sC0Max1Min, G4VTwistSurface::sC0Min1Max, G4VTwistSurface::sC0Min1Min, G4VTwistSurface::sCorner, and CLHEP::Hep3Vector::set().

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

◆ SetCorners() [1/2]

void G4TwistTubsSide::SetCorners ( )

privatevirtual

Implements G4VTwistSurface.

Definition at line 993 of file G4TwistTubsSide.cc.

{
   G4Exception("G4TwistTubsSide::SetCorners()",
               "GeomSolids0001", FatalException,
               "Method NOT implemented !");
}

References FatalException, and G4Exception().

Referenced by G4TwistTubsSide().

◆ SetCorners() [2/2]

void G4TwistTubsSide::SetCorners	(	G4double	endInnerRad[2],
		G4double	endOuterRad[2],
		G4double	endPhi[2],
		G4double	endZ[2]
	)

privatevirtual

Definition at line 940 of file G4TwistTubsSide.cc.

{
   // Set Corner points in local coodinate.   
 
   if (fAxis[0] == kXAxis && fAxis[1] == kZAxis)
   {
      G4int zmin = 0 ;  // at -ve z
      G4int zmax = 1 ;  // at +ve z
 
      G4double x, y, z;
      
      // corner of Axis0min and Axis1min
      x = endInnerRad[zmin]*std::cos(endPhi[zmin]);
      y = endInnerRad[zmin]*std::sin(endPhi[zmin]);
      z = endZ[zmin];
      SetCorner(sC0Min1Min, x, y, z);
      
      // corner of Axis0max and Axis1min
      x = endOuterRad[zmin]*std::cos(endPhi[zmin]);
      y = endOuterRad[zmin]*std::sin(endPhi[zmin]);
      z = endZ[zmin];
      SetCorner(sC0Max1Min, x, y, z);
      
      // corner of Axis0max and Axis1max
      x = endOuterRad[zmax]*std::cos(endPhi[zmax]);
      y = endOuterRad[zmax]*std::sin(endPhi[zmax]);
      z = endZ[zmax];
      SetCorner(sC0Max1Max, x, y, z);
      
      // corner of Axis0min and Axis1max
      x = endInnerRad[zmax]*std::cos(endPhi[zmax]);
      y = endInnerRad[zmax]*std::sin(endPhi[zmax]);
      z = endZ[zmax];
      SetCorner(sC0Min1Max, x, y, z);
 
   }
   else
   {
      std::ostringstream message;
      message << "Feature NOT implemented !" << G4endl
              << "        fAxis[0] = " << fAxis[0] << G4endl
              << "        fAxis[1] = " << fAxis[1];
      G4Exception("G4TwistTubsSide::SetCorners()",
                  "GeomSolids0001", FatalException, message);
   }
}

References FatalException, G4VTwistSurface::fAxis, G4endl, G4Exception(), kXAxis, kZAxis, G4VTwistSurface::sC0Max1Max, G4VTwistSurface::sC0Max1Min, G4VTwistSurface::sC0Min1Max, G4VTwistSurface::sC0Min1Min, and G4VTwistSurface::SetCorner().

◆ SetNeighbours()

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

inlineinherited

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

◆ SurfacePoint()

G4ThreeVector G4TwistTubsSide::SurfacePoint	(	G4double	x,
		G4double	z,
		G4bool	isGlobal = `false`
	)

inlinevirtual

Implements G4VTwistSurface.

Definition at line 152 of file G4TwistTubsSide.hh.

{
  G4ThreeVector SurfPoint( x , x * fKappa * z , z ) ;
 
  if (isGlobal) { return (fRot * SurfPoint + fTrans); }
  return SurfPoint;
}

References fKappa, G4VTwistSurface::fRot, and G4VTwistSurface::fTrans.

Referenced by GetFacets().

Field Documentation

◆ fAmIOnLeftSide

G4SurfSideQuery G4VTwistSurface::fAmIOnLeftSide

privateinherited

Definition at line 342 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::AmIOnLeftSide(), and G4VTwistSurface::G4VTwistSurface().

◆ fAxis

EAxis G4VTwistSurface::fAxis[2]

protectedinherited

Definition at line 308 of file G4VTwistSurface.hh.

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

◆ fAxisMax

G4double G4VTwistSurface::fAxisMax[2]

protectedinherited

Definition at line 310 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::DebugPrint(), G4TwistBoxSide::G4TwistBoxSide(), G4TwistTrapAlphaSide::G4TwistTrapAlphaSide(), G4TwistTrapFlatSide::G4TwistTrapFlatSide(), G4TwistTrapParallelSide::G4TwistTrapParallelSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4TwistTubsHypeSide::G4TwistTubsHypeSide(), G4TwistTubsSide(), G4VTwistSurface::G4VTwistSurface(), G4TwistBoxSide::GetAreaCode(), G4TwistTrapAlphaSide::GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), G4TwistTrapParallelSide::GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCode(), GetAreaCode(), G4VTwistSurface::GetBoundaryLimit(), GetBoundaryMax(), G4TwistTubsFlatSide::GetFacets(), G4TwistTubsHypeSide::GetFacets(), GetFacets(), G4TwistTubsHypeSide::GetSurfaceArea(), GetSurfaceArea(), and G4TwistTubsFlatSide::SetCorners().

◆ fAxisMin

G4double G4VTwistSurface::fAxisMin[2]

protectedinherited

Definition at line 309 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::DebugPrint(), G4TwistBoxSide::G4TwistBoxSide(), G4TwistTrapAlphaSide::G4TwistTrapAlphaSide(), G4TwistTrapFlatSide::G4TwistTrapFlatSide(), G4TwistTrapParallelSide::G4TwistTrapParallelSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4TwistTubsHypeSide::G4TwistTubsHypeSide(), G4TwistTubsSide(), G4VTwistSurface::G4VTwistSurface(), G4TwistBoxSide::GetAreaCode(), G4TwistTrapAlphaSide::GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), G4TwistTrapParallelSide::GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCode(), GetAreaCode(), G4VTwistSurface::GetBoundaryLimit(), GetBoundaryMin(), G4TwistTubsFlatSide::GetFacets(), G4TwistTubsHypeSide::GetFacets(), GetFacets(), G4TwistTubsHypeSide::GetSurfaceArea(), GetSurfaceArea(), and G4TwistTubsFlatSide::SetCorners().

◆ fBoundaries

Boundary G4VTwistSurface::fBoundaries[4]

privateinherited

Definition at line 331 of file G4VTwistSurface.hh.

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

◆ fCorners

G4ThreeVector G4VTwistSurface::fCorners[4]

privateinherited

Definition at line 330 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::G4VTwistSurface(), and G4VTwistSurface::SetCorner().

◆ fCurrentNormal

G4SurfCurNormal G4VTwistSurface::fCurrentNormal

protectedinherited

Definition at line 322 of file G4VTwistSurface.hh.

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

◆ fCurStat

CurrentStatus G4VTwistSurface::fCurStat

protectedinherited

Definition at line 312 of file G4VTwistSurface.hh.

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

◆ fCurStatWithV

CurrentStatus G4VTwistSurface::fCurStatWithV

protectedinherited

Definition at line 311 of file G4VTwistSurface.hh.

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

◆ fHandedness

G4int G4VTwistSurface::fHandedness

protectedinherited

Definition at line 315 of file G4VTwistSurface.hh.

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

◆ fIsValidNorm

G4bool G4VTwistSurface::fIsValidNorm

protectedinherited

Definition at line 323 of file G4VTwistSurface.hh.

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

◆ fKappa

G4double G4TwistTubsSide::fKappa

private

Definition at line 129 of file G4TwistTubsSide.hh.

Referenced by DistanceToSurface(), G4TwistTubsSide(), GetNormal(), ProjectAtPXPZ(), and SurfacePoint().

◆ fName

G4String G4VTwistSurface::fName

privateinherited

Definition at line 332 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::AmIOnLeftSide(), G4VTwistSurface::DebugPrint(), G4VTwistSurface::DistanceTo(), G4VTwistSurface::DistanceToIn(), G4VTwistSurface::DistanceToOut(), and G4VTwistSurface::GetName().

◆ fNeighbours

G4VTwistSurface* G4VTwistSurface::fNeighbours[4]

privateinherited

Definition at line 328 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::G4VTwistSurface(), and G4VTwistSurface::GetNeighbours().

◆ fRot

G4RotationMatrix G4VTwistSurface::fRot

protectedinherited

◆ fTrans

G4ThreeVector G4VTwistSurface::fTrans

protectedinherited

◆ kCarTolerance

G4double G4VTwistSurface::kCarTolerance

protectedinherited

◆ sAreaMask

const G4int G4VTwistSurface::sAreaMask = 0XF0000000

staticinherited

Definition at line 235 of file G4VTwistSurface.hh.

◆ sAxis0

const G4int G4VTwistSurface::sAxis0 = 0x0000FF00

staticinherited

Definition at line 231 of file G4VTwistSurface.hh.

Referenced by DistanceToSurface(), G4TwistBoxSide::GetAreaCode(), G4TwistTrapAlphaSide::GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), G4TwistTrapParallelSide::GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCode(), GetAreaCode(), G4TwistTubsHypeSide::GetAreaCodeInPhi(), G4VTwistSurface::GetBoundaryAtPZ(), G4VTwistSurface::GetBoundaryAxis(), G4VTwistSurface::GetBoundaryLimit(), G4TwistTubsHypeSide::GetBoundaryMax(), G4TwistTubsHypeSide::GetBoundaryMin(), G4VTwistSurface::Boundary::GetBoundaryParameters(), G4TwistBoxSide::SetBoundaries(), G4TwistTrapAlphaSide::SetBoundaries(), G4TwistTrapFlatSide::SetBoundaries(), G4TwistTrapParallelSide::SetBoundaries(), G4TwistTubsFlatSide::SetBoundaries(), G4TwistTubsHypeSide::SetBoundaries(), SetBoundaries(), and G4VTwistSurface::SetBoundary().

◆ sAxis1

const G4int G4VTwistSurface::sAxis1 = 0x000000FF

staticinherited

◆ sAxisMask

const G4int G4VTwistSurface::sAxisMask = 0x0000FCFC

staticinherited

Definition at line 234 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::GetBoundaryAxis().

◆ sAxisMax

const G4int G4VTwistSurface::sAxisMax = 0x00000202

staticinherited

◆ sAxisMin

const G4int G4VTwistSurface::sAxisMin = 0x00000101

staticinherited

◆ sAxisPhi

const G4int G4VTwistSurface::sAxisPhi = 0x00001414

staticinherited

Definition at line 230 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::DistanceToBoundary(), G4TwistTubsFlatSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCode(), G4VTwistSurface::GetBoundaryAtPZ(), G4VTwistSurface::GetBoundaryAxis(), G4TwistTubsFlatSide::SetBoundaries(), and G4TwistTubsHypeSide::SetBoundaries().

◆ sAxisRho

const G4int G4VTwistSurface::sAxisRho = 0x00001010

staticinherited

Definition at line 229 of file G4VTwistSurface.hh.

Referenced by G4TwistTubsFlatSide::GetAreaCode(), G4VTwistSurface::GetBoundaryAtPZ(), G4VTwistSurface::GetBoundaryAxis(), and G4TwistTubsFlatSide::SetBoundaries().

◆ sAxisX

const G4int G4VTwistSurface::sAxisX = 0x00000404

staticinherited

Definition at line 226 of file G4VTwistSurface.hh.

Referenced by G4TwistTrapFlatSide::GetAreaCode(), G4TwistTrapParallelSide::GetAreaCode(), GetAreaCode(), G4VTwistSurface::GetBoundaryAxis(), G4TwistTrapFlatSide::SetBoundaries(), G4TwistTrapParallelSide::SetBoundaries(), and SetBoundaries().

◆ sAxisY

const G4int G4VTwistSurface::sAxisY = 0x00000808

staticinherited

Definition at line 227 of file G4VTwistSurface.hh.

Referenced by G4TwistBoxSide::GetAreaCode(), G4TwistTrapAlphaSide::GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), G4VTwistSurface::GetBoundaryAxis(), G4TwistBoxSide::SetBoundaries(), G4TwistTrapAlphaSide::SetBoundaries(), and G4TwistTrapFlatSide::SetBoundaries().

◆ sAxisZ

const G4int G4VTwistSurface::sAxisZ = 0x00000C0C

staticinherited

Definition at line 228 of file G4VTwistSurface.hh.

Referenced by G4TwistBoxSide::GetAreaCode(), G4TwistTrapAlphaSide::GetAreaCode(), G4TwistTrapParallelSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCode(), GetAreaCode(), G4VTwistSurface::GetBoundaryAxis(), G4TwistBoxSide::SetBoundaries(), G4TwistTrapAlphaSide::SetBoundaries(), G4TwistTrapParallelSide::SetBoundaries(), G4TwistTubsHypeSide::SetBoundaries(), and SetBoundaries().

◆ sBoundary

const G4int G4VTwistSurface::sBoundary = 0x20000000

staticinherited

Definition at line 218 of file G4VTwistSurface.hh.

Referenced by G4TwistBoxSide::GetAreaCode(), G4TwistTrapAlphaSide::GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), G4TwistTrapParallelSide::GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCode(), GetAreaCode(), G4TwistTubsHypeSide::GetAreaCodeInPhi(), G4VTwistSurface::GetBoundaryAxis(), and G4VTwistSurface::GetBoundaryLimit().

◆ sC0Max1Max

const G4int G4VTwistSurface::sC0Max1Max = 0x40000202

staticinherited

◆ sC0Max1Min

const G4int G4VTwistSurface::sC0Max1Min = 0x40000201

staticinherited

◆ sC0Min1Max

const G4int G4VTwistSurface::sC0Min1Max = 0x40000102

staticinherited

Definition at line 223 of file G4VTwistSurface.hh.

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

◆ sC0Min1Min

const G4int G4VTwistSurface::sC0Min1Min = 0x40000101

staticinherited

Definition at line 220 of file G4VTwistSurface.hh.

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

◆ sCorner

const G4int G4VTwistSurface::sCorner = 0x40000000

staticinherited

Definition at line 219 of file G4VTwistSurface.hh.

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

◆ sInside

const G4int G4VTwistSurface::sInside = 0x10000000

staticinherited

Definition at line 217 of file G4VTwistSurface.hh.

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

◆ sOutside

const G4int G4VTwistSurface::sOutside = 0x00000000

staticinherited

Definition at line 216 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::CurrentStatus::CurrentStatus(), G4VTwistSurface::DistanceTo(), G4VTwistSurface::DistanceToIn(), G4VTwistSurface::DistanceToOut(), G4TwistBoxSide::DistanceToSurface(), G4TwistTrapAlphaSide::DistanceToSurface(), G4TwistTrapFlatSide::DistanceToSurface(), G4TwistTrapParallelSide::DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), G4TwistTubsHypeSide::DistanceToSurface(), DistanceToSurface(), and G4VTwistSurface::CurrentStatus::ResetfDone().

◆ sSizeMask

const G4int G4VTwistSurface::sSizeMask = 0x00000303

staticinherited

Definition at line 233 of file G4VTwistSurface.hh.

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

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

source/geometry/solids/specific/include/G4TwistTubsSide.hh
source/geometry/solids/specific/src/G4TwistTubsSide.cc

Public Types

Public Member Functions

Static Public Attributes

Protected Member Functions

Protected Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Enumeration Documentation

◆ EValidate

Constructor & Destructor Documentation

◆ G4TwistTubsSide() [1/3]

◆ G4TwistTubsSide() [2/3]

◆ ~G4TwistTubsSide()

◆ G4TwistTubsSide() [3/3]

Member Function Documentation

◆ AmIOnLeftSide()

◆ ComputeGlobalDirection()

◆ ComputeGlobalPoint()

◆ ComputeLocalDirection()

◆ ComputeLocalPoint()

◆ DebugPrint()

◆ DistanceTo()

◆ DistanceToBoundary()

◆ DistanceToIn()

◆ DistanceToLine()

◆ DistanceToOut()

◆ DistanceToPlane() [1/3]

◆ DistanceToPlane() [2/3]

◆ DistanceToPlane() [3/3]

◆ 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()

◆ ProjectAtPXPZ()

◆ SetAxis()

◆ SetBoundaries()

◆ SetBoundary()

◆ SetCorner()

◆ SetCorners() [1/2]

◆ SetCorners() [2/2]

◆ SetNeighbours()

◆ SurfacePoint()

Field Documentation

◆ fAmIOnLeftSide

◆ fAxis

◆ fAxisMax

◆ fAxisMin

◆ fBoundaries

◆ fCorners

◆ fCurrentNormal

◆ fCurStat

◆ fCurStatWithV

◆ fHandedness

◆ fIsValidNorm