#include <G4TwistTrapAlphaSide.hh>

Inheritance diagram for G4TwistTrapAlphaSide:

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[])

	G4TwistTrapAlphaSide (__void__ &)

	G4TwistTrapAlphaSide (const G4String &name, G4double PhiTwist, G4double pDz, G4double pTheta, G4double pPhi, G4double pDy1, G4double pDx1, G4double pDx2, G4double pDy2, G4double pDx3, G4double pDx4, G4double pAlph, G4double AngleSide)

G4int	GetAxisType (G4int areacode, G4int whichaxis) const

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

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 G4String	GetName () const

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

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

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

void	SetAxis (G4int i, const EAxis axis)

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

virtual	~G4TwistTrapAlphaSide ()

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 G4int	GetAreaCode (const G4ThreeVector &xx, G4bool withTol=true)

virtual G4double	GetBoundaryMax (G4double phi)

virtual G4double	GetBoundaryMin (G4double phi)

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

void	GetPhiUAtX (G4ThreeVector p, G4double &phi, G4double &u)

virtual G4double	GetSurfaceArea ()

G4double	GetValueA (G4double phi)

G4double	GetValueB (G4double phi)

G4double	GetValueD (G4double phi)

G4ThreeVector	NormAng (G4double phi, G4double u)

G4ThreeVector	ProjectPoint (const G4ThreeVector &p, G4bool isglobal=false)

virtual void	SetBoundaries ()

virtual void	SetCorners ()

virtual G4ThreeVector	SurfacePoint (G4double phi, G4double u, G4bool isGlobal=false)

G4double	Xcoef (G4double u, G4double phi)

Private Attributes
G4double	fa1md1

G4double	fa2md2

G4double	fAlph

G4SurfSideQuery	fAmIOnLeftSide

G4double	fAngleSide

Boundary	fBoundaries [4]

G4ThreeVector	fCorners [4]

G4double	fdeltaX

G4double	fdeltaY

G4double	fDx1

G4double	fDx2

G4double	fDx3

G4double	fDx3minus1

G4double	fDx3plus1

G4double	fDx4

G4double	fDx4minus2

G4double	fDx4plus2

G4double	fDy1

G4double	fDy2

G4double	fDy2minus1

G4double	fDy2plus1

G4double	fDz

G4String	fName

G4VTwistSurface *	fNeighbours [4]

G4double	fPhi

G4double	fPhiTwist

G4double	fTAlph

G4double	fTheta

Detailed Description

Definition at line 41 of file G4TwistTrapAlphaSide.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

◆ G4TwistTrapAlphaSide() [1/2]

G4TwistTrapAlphaSide::G4TwistTrapAlphaSide	(	const G4String &	name,
		G4double	PhiTwist,
		G4double	pDz,
		G4double	pTheta,
		G4double	pPhi,
		G4double	pDy1,
		G4double	pDx1,
		G4double	pDx2,
		G4double	pDy2,
		G4double	pDx3,
		G4double	pDx4,
		G4double	pAlph,
		G4double	AngleSide
	)

Definition at line 40 of file G4TwistTrapAlphaSide.cc.

  : G4VTwistSurface(name)
{
  fAxis[0]    = kYAxis; // in local coordinate system
  fAxis[1]    = kZAxis;
  fAxisMin[0] = -kInfinity ;  // Y Axis boundary
  fAxisMax[0] = kInfinity ;   //   depends on z !!
  fAxisMin[1] = -pDz ;      // Z Axis boundary
  fAxisMax[1] = pDz ;
  
  fDx1  = pDx1 ;
  fDx2  = pDx2 ;
  fDx3  = pDx3 ;
  fDx4  = pDx4 ;
 
  fDy1   = pDy1 ;
  fDy2   = pDy2 ;
 
  fDz   = pDz ;
 
  fAlph = pAlph  ;
  fTAlph = std::tan(fAlph) ;
 
  fTheta = pTheta ;
  fPhi   = pPhi ;
 
  // precalculate frequently used parameters
  fDx4plus2  = fDx4 + fDx2 ;
  fDx4minus2 = fDx4 - fDx2 ;
  fDx3plus1  = fDx3 + fDx1 ; 
  fDx3minus1 = fDx3 - fDx1 ;
  fDy2plus1  = fDy2 + fDy1 ;
  fDy2minus1 = fDy2 - fDy1 ;
 
  fa1md1 = 2*fDx2 - 2*fDx1  ; 
  fa2md2 = 2*fDx4 - 2*fDx3 ;
 
  fPhiTwist = PhiTwist ;     // dphi
  fAngleSide = AngleSide ;  // 0,90,180,270 deg
 
  fdeltaX = 2 * fDz * std::tan(fTheta) * std::cos(fPhi);
    // dx in surface equation
  fdeltaY = 2 * fDz * std::tan(fTheta) * std::sin(fPhi);
    // dy in surface equation
  
  fRot.rotateZ( AngleSide ) ; 
  
  fTrans.set(0, 0, 0);  // No Translation
  fIsValidNorm = false;
  
  SetCorners() ;
  SetBoundaries() ;
}

References fa1md1, fa2md2, fAlph, fAngleSide, G4VTwistSurface::fAxis, G4VTwistSurface::fAxisMax, G4VTwistSurface::fAxisMin, fdeltaX, fdeltaY, fDx1, fDx2, fDx3, fDx3minus1, fDx3plus1, fDx4, fDx4minus2, fDx4plus2, fDy1, fDy2, fDy2minus1, fDy2plus1, fDz, G4VTwistSurface::fIsValidNorm, fPhi, fPhiTwist, G4VTwistSurface::fRot, fTAlph, fTheta, G4VTwistSurface::fTrans, kInfinity, kYAxis, kZAxis, CLHEP::HepRotation::rotateZ(), CLHEP::Hep3Vector::set(), SetBoundaries(), and SetCorners().

◆ ~G4TwistTrapAlphaSide()

G4TwistTrapAlphaSide::~G4TwistTrapAlphaSide ( )

virtual

Definition at line 125 of file G4TwistTrapAlphaSide.cc.

126{

127}

◆ G4TwistTrapAlphaSide() [2/2]

G4TwistTrapAlphaSide::G4TwistTrapAlphaSide ( __void__ & a )

Definition at line 112 of file G4TwistTrapAlphaSide.cc.

  : G4VTwistSurface(a), fTheta(0.), fPhi(0.), fDy1(0.), fDx1(0.), fDx2(0.), 
    fDy2(0.), fDx3(0.), fDx4(0.), fDz(0.), fAlph(0.), fTAlph(0.), fPhiTwist(0.), 
    fAngleSide(0.), fDx4plus2(0.), fDx4minus2(0.), fDx3plus1(0.), fDx3minus1(0.), 
    fDy2plus1(0.), fDy2minus1(0.), fa1md1(0.), fa2md2(0.), fdeltaX(0.),
    fdeltaY(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 G4TwistTubsSide::DistanceToSurface(), G4TwistTubsFlatSide::GetAreaCode(), and G4TwistTubsHypeSide::GetAreaCodeInPhi().

◆ ComputeGlobalDirection()

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

inlineinherited

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

◆ ComputeGlobalPoint()

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

inlineinherited

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

◆ ComputeLocalDirection()

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

inlineinherited

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

◆ ComputeLocalPoint()

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

inlineinherited

Referenced by G4TwistBoxSide::DistanceToSurface(), DistanceToSurface(), G4TwistTrapFlatSide::DistanceToSurface(), G4TwistTrapParallelSide::DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), G4TwistTubsHypeSide::DistanceToSurface(), G4TwistTubsSide::DistanceToSurface(), G4TwistBoxSide::GetNormal(), GetNormal(), G4TwistTrapParallelSide::GetNormal(), G4TwistTubsHypeSide::GetNormal(), G4TwistTubsSide::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 G4TwistTubsSide::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 G4TwistTubsSide::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/2]

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

inlineinherited

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

◆ DistanceToPlane() [2/2]

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

inlineinherited

◆ DistanceToPlaneWithV()

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

inlineinherited

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

◆ DistanceToSurface() [1/2]

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

virtual

Implements G4VTwistSurface.

Definition at line 188 of file G4TwistTrapAlphaSide.cc.

{
  static const G4double pihalf = pi/2 ;
  const G4double ctol = 0.5 * kCarTolerance;
 
  G4bool IsParallel = false ;
  G4bool IsConverged =  false ;
 
  G4int nxx = 0 ;  // number of physical solutions
 
  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  // initialise
  {
    for (G4int j=0; j<G4VSURFACENXX ; ++j)
    {
      distance[j] = kInfinity;
      areacode[j] = sOutside;
      isvalid[j]  = false;
      gxx[j].set(kInfinity, kInfinity, kInfinity);
    }
  }
 
  G4ThreeVector p = ComputeLocalPoint(gp);
  G4ThreeVector v = ComputeLocalDirection(gv);
  
#ifdef G4TWISTDEBUG
  G4cout << "Local point p = " << p << G4endl ;
  G4cout << "Local direction v = " << v << G4endl ; 
#endif
 
  G4double phi,u ;  // parameters
 
  // temporary variables
 
  G4double      tmpdist = kInfinity ;
  G4ThreeVector tmpxx;
  G4int         tmpareacode = sOutside ;
  G4bool        tmpisvalid  = false ;
 
  std::vector<Intersection> xbuf ;
  Intersection xbuftmp ;
  
  // prepare some variables for the intersection finder
 
  G4double L = 2*fDz ;
 
  G4double phixz = fPhiTwist * ( p.x() * v.z() - p.z() * v.x() ) ;
  G4double phiyz = fPhiTwist * ( p.y() * v.z() - p.z() * v.y() ) ;
 
 
  // special case vz = 0
 
  if ( v.z() == 0. )
 {
    if ( std::fabs(p.z()) <= L )   // intersection possible in z
    {
      phi = p.z() * fPhiTwist / L ;  // phi is determined by the z-position 
      u = (fDy1*(4*(-(fdeltaY*phi*v.x()) + fPhiTwist*p.y()*v.x()
                    + fdeltaX*phi*v.y() - fPhiTwist*p.x()*v.y())
                 + ((fDx3plus1 + fDx4plus2)*fPhiTwist
                 +  2*(fDx3minus1 + fDx4minus2)*phi)
                     *(v.y()*std::cos(phi) - v.x()*std::sin(phi))))
         /(fPhiTwist*(4*fDy1* v.x() - (fa1md1 + 4*fDy1*fTAlph)*v.y())
                    *std::cos(phi) + fPhiTwist*(fa1md1*v.x()
                       + 4*fDy1*(fTAlph*v.x() + v.y()))*std::sin(phi));
      xbuftmp.phi = phi ;
      xbuftmp.u = u ;
      xbuftmp.areacode = sOutside ;
      xbuftmp.distance = kInfinity ;
      xbuftmp.isvalid = false ;
 
      xbuf.push_back(xbuftmp) ;  // store it to xbuf
    }
    else   // no intersection possible
    {
      distance[0] = kInfinity;
      gxx[0].set(kInfinity,kInfinity,kInfinity);
      isvalid[0] = false ;
      areacode[0] = sOutside ;
      fCurStatWithV.SetCurrentStatus(0, gxx[0], distance[0],
                                     areacode[0], isvalid[0],
                                     0, validate, &gp, &gv);
      return 0;
    }  // end std::fabs(p.z() <= L 
  } // end v.z() == 0
  else  // general solution for non-zero vz
  {
 
    G4double c[8],srd[7],si[7] ;  
 
    c[7] = 57600*
      fDy1*(fa1md1*phiyz + 
            fDy1*(-4*phixz + 4*fTAlph*phiyz
                 + (fDx3plus1 + fDx4plus2)*fPhiTwist*v.z())) ;
    c[6] = -57600*
      fDy1*(4*fDy1*(phiyz + 2*fDz*v.x() + fTAlph*(phixz - 2*fDz*v.y()))
          - 2*fDy1*(2*fdeltaX + fDx3minus1 + fDx4minus2
                  - 2*fdeltaY*fTAlph)*v.z()
          + fa1md1*(phixz - 2*fDz*v.y() + fdeltaY*v.z()));
    c[5] = 4800*
      fDy1*(fa1md1*(-5*phiyz - 24*fDz*v.x() + 12*fdeltaX*v.z()) + 
            fDy1*(20*phixz - 4*(5*fTAlph*phiyz + 24*fDz*fTAlph*v.x()
                   + 24*fDz*v.y()) + (48*fdeltaY + (fDx3plus1 + fDx4plus2)
                                    *fPhiTwist + 48*fdeltaX*fTAlph)*v.z()));
    c[4] = 4800*
      fDy1*(fa1md1*(phixz - 10*fDz*v.y() + 5*fdeltaY*v.z())
          + 2*fDy1*(2*phiyz + 20*fDz*v.x()
                   + (-10*fdeltaX + fDx3minus1 + fDx4minus2)*v.z()
                   + 2*fTAlph*(phixz - 10*fDz*v.y() + 5*fdeltaY*v.z())));
    c[3] = -96*
      fDy1*(-(fa1md1*(phiyz + 100*fDz*v.x() - 50*fdeltaX*v.z()))
          + fDy1*(4*phixz - 400*fDz*v.y()
                  + (200*fdeltaY - (fDx3plus1 + fDx4plus2)*fPhiTwist)*v.z()
                  - 4*fTAlph*(phiyz + 100*fDz*v.x() - 50*fdeltaX*v.z())));
    c[2] = 32*
      fDy1*(4*fDy1*(7*fTAlph*phixz + 7*phiyz - 6*fDz*v.x() + 6*fDz*fTAlph*v.y())
          + 6*fDy1*(2*fdeltaX+fDx3minus1+fDx4minus2-2*fdeltaY*fTAlph)*v.z()
          + fa1md1*(7*phixz + 6*fDz*v.y() - 3*fdeltaY*v.z()));
    c[1] = -8*
      fDy1*(fa1md1*(-9*phiyz - 56*fDz*v.x() + 28*fdeltaX*v.z())
          + 4*fDy1*(9*phixz - 9*fTAlph*phiyz - 56*fDz*fTAlph*v.x()
                  - 56*fDz*v.y() + 28*(fdeltaY + fdeltaX*fTAlph)*v.z()));
    c[0] = 72*
      fDy1*(fa1md1*(2*fDz*v.y() - fdeltaY*v.z())
          + fDy1*(-8*fDz*v.x() + 8*fDz*fTAlph*v.y()
                + 4*fdeltaX*v.z() - 4*fdeltaY*fTAlph*v.z()));
 
#ifdef G4TWISTDEBUG
    G4cout << "coef = " << c[0] << " " 
           <<  c[1] << " "  
           <<  c[2] << " "  
           <<  c[3] << " "  
           <<  c[4] << " "  
           <<  c[5] << " "  
           <<  c[6] << " "  
           <<  c[7] << G4endl ; 
#endif    
 
    G4JTPolynomialSolver trapEq ;
    G4int num = trapEq.FindRoots(c,7,srd,si);
 
    for (G4int i = 0 ; i<num ; i++ )   // loop over all math solutions
    {  
      if ( si[i]==0.0 )  // only real solutions
      { 
#ifdef G4TWISTDEBUG
        G4cout << "Solution " << i << " : " << srd[i] << G4endl ;
#endif
        phi = std::fmod(srd[i] , pihalf)  ;
        u   = (fDy1*(4*(phiyz + 2*fDz*phi*v.y() - fdeltaY*phi*v.z())
                     - ((fDx3plus1 + fDx4plus2)*fPhiTwist
                       + 2*(fDx3minus1 + fDx4minus2)*phi)*v.z()*std::sin(phi)))
             /(fPhiTwist*v.z()*(4*fDy1*std::cos(phi)
                             + (fa1md1 + 4*fDy1*fTAlph)*std::sin(phi)));        
        xbuftmp.phi = phi ;
        xbuftmp.u = u ;
        xbuftmp.areacode = sOutside ;
        xbuftmp.distance = kInfinity ;
        xbuftmp.isvalid = false ;
        
        xbuf.push_back(xbuftmp) ;  // store it to xbuf
      
#ifdef G4TWISTDEBUG
        G4cout << "solution " << i << " = " << phi << " , " << u  << G4endl ;
#endif
      }  // end if real solution
    }  // end loop i    
  }    // end general case
 
  nxx = xbuf.size() ;  // save the number of  solutions
 
  G4ThreeVector xxonsurface  ;    // point on surface
  G4ThreeVector surfacenormal  ;  // normal vector  
  G4double deltaX;  // distance between intersection point and point on surface
  G4double theta;   // angle between track and surfacenormal
  G4double factor;  // a scaling factor
  G4int maxint=30;  // number of iterations
 
  for ( size_t k = 0 ; k<xbuf.size() ; ++k )
  {
#ifdef G4TWISTDEBUG
    G4cout << "Solution " << k << " : " 
           << "reconstructed phiR = " << xbuf[k].phi
           << ", uR = " << xbuf[k].u << G4endl ; 
#endif
    
    phi = xbuf[k].phi ;  // get the stored values for phi and u
    u = xbuf[k].u ;
 
    IsConverged = false ;   // no convergence at the beginning
    
    for ( G4int i = 1 ; i<maxint ; ++i )
    {
      xxonsurface = SurfacePoint(phi,u) ;
      surfacenormal = NormAng(phi,u) ;
 
      tmpdist = DistanceToPlaneWithV(p, v, xxonsurface, surfacenormal, tmpxx); 
      deltaX = ( tmpxx - xxonsurface ).mag() ; 
      theta = std::fabs(std::acos(v*surfacenormal) - pihalf) ;
      if ( theta < 0.001 )
      { 
        factor = 50 ;
        IsParallel = true ;
      }
      else
      {
        factor = 1 ;
      }
 
#ifdef G4TWISTDEBUG
      G4cout << "Step i = " << i << ", distance = " << tmpdist
             << ", " << deltaX << G4endl ;
      G4cout << "X = " << tmpxx << G4endl ;
#endif
      
      GetPhiUAtX(tmpxx, phi, u) ;
        // the new point xx is accepted and phi/u replaced
      
#ifdef G4TWISTDEBUG
      G4cout << "approximated phi = " << phi << ", u = " << u << G4endl ; 
#endif
      
      if ( deltaX <= factor*ctol ) { IsConverged = true ; break ; }
      
    }  // end iterative loop (i)
    
    if ( std::fabs(tmpdist)<ctol ) { tmpdist = 0 ; }
 
#ifdef G4TWISTDEBUG
    G4cout << "refined solution "  << phi << " , " << u  <<  G4endl ;
    G4cout << "distance = " << tmpdist << G4endl ;
    G4cout << "local X = " << tmpxx << G4endl ;
#endif
    
    tmpisvalid = false ;  // init 
 
    if ( IsConverged )
    {
      if (validate == kValidateWithTol)
      {
        tmpareacode = GetAreaCode(tmpxx);
        if (!IsOutside(tmpareacode))
        {
          if (tmpdist >= 0) tmpisvalid = true;
        }
      }
      else if (validate == kValidateWithoutTol)
      {
        tmpareacode = GetAreaCode(tmpxx, false);
        if (IsInside(tmpareacode))
        {
          if (tmpdist >= 0) { tmpisvalid = true; }
        }
      }
      else  // kDontValidate
      {
        G4Exception("G4TwistTrapAlphaSide::DistanceToSurface()",
                    "GeomSolids0001", FatalException,
                    "Feature NOT implemented !");
      }
    } 
    else
    {
      tmpdist = kInfinity;     // no convergence after 10 steps 
      tmpisvalid = false ;     // solution is not vaild
    }  
 
    // store the found values
    // 
    xbuf[k].xx = tmpxx ;
    xbuf[k].distance = tmpdist ;
    xbuf[k].areacode = tmpareacode ;
    xbuf[k].isvalid = tmpisvalid ;
 
  }  // end loop over physical solutions (variable k)
 
  std::sort(xbuf.begin() , xbuf.end(), DistanceSort ) ;  // sorting
 
#ifdef G4TWISTDEBUG
  G4cout << G4endl << "list xbuf after sorting : " << G4endl ;
  G4cout << G4endl << G4endl ;
#endif
 
  // erase identical intersection (within kCarTolerance) 
  //
  xbuf.erase( std::unique(xbuf.begin(), xbuf.end() , EqualIntersection ),
              xbuf.end() );
 
 
  // add guesses
  //
  G4int nxxtmp = xbuf.size() ;
 
  if ( nxxtmp<2 || IsParallel  )  // positive end
  {
 
#ifdef G4TWISTDEBUG
    G4cout << "add guess at +z/2 .. " << G4endl ;
#endif
 
    phi = fPhiTwist/2 ;
    u   = 0 ;
    
    xbuftmp.phi = phi ;
    xbuftmp.u = u ;
    xbuftmp.areacode = sOutside ;
    xbuftmp.distance = kInfinity ;
    xbuftmp.isvalid = false ;
    
    xbuf.push_back(xbuftmp) ;  // store it to xbuf
 
#ifdef G4TWISTDEBUG
    G4cout << "add guess at -z/2 .. " << G4endl ;
#endif
 
    phi = -fPhiTwist/2 ;
    u   = 0 ;
    
    xbuftmp.phi = phi ;
    xbuftmp.u = u ;
    xbuftmp.areacode = sOutside ;
    xbuftmp.distance = kInfinity ;
    xbuftmp.isvalid = false ;
    
    xbuf.push_back(xbuftmp) ;  // store it to xbuf
 
    for ( size_t k = nxxtmp ; k<xbuf.size() ; ++k )
    {
 
#ifdef G4TWISTDEBUG
      G4cout << "Solution " << k << " : " 
             << "reconstructed phiR = " << xbuf[k].phi
             << ", uR = " << xbuf[k].u << G4endl ; 
#endif
      
      phi = xbuf[k].phi ;  // get the stored values for phi and u
      u   = xbuf[k].u ;
 
      IsConverged = false ;   // no convergence at the beginning
      
      for ( G4int i = 1 ; i<maxint ; ++i )
      {
        xxonsurface = SurfacePoint(phi,u) ;
        surfacenormal = NormAng(phi,u) ;
        tmpdist = DistanceToPlaneWithV(p, v, xxonsurface, surfacenormal, tmpxx);
        deltaX = ( tmpxx - xxonsurface ).mag();
        theta = std::fabs(std::acos(v*surfacenormal) - pihalf);
        if ( theta < 0.001 )
        { 
          factor = 50 ;    
        }
        else
        {
          factor = 1 ;
        }
        
#ifdef G4TWISTDEBUG
        G4cout << "Step i = " << i << ", distance = " << tmpdist
               << ", " << deltaX << G4endl
               << "X = " << tmpxx << G4endl ;
#endif
 
        GetPhiUAtX(tmpxx, phi, u) ;
          // the new point xx is accepted and phi/u replaced
      
#ifdef G4TWISTDEBUG
        G4cout << "approximated phi = " << phi << ", u = " << u << G4endl ; 
#endif
      
        if ( deltaX <= factor*ctol ) { IsConverged = true ; break ; }
      
      }  // end iterative loop (i)
    
      if ( std::fabs(tmpdist)<ctol )  { tmpdist = 0; }
 
#ifdef G4TWISTDEBUG
      G4cout << "refined solution "  << phi << " , " << u  <<  G4endl ;
      G4cout << "distance = " << tmpdist << G4endl ;
      G4cout << "local X = " << tmpxx << G4endl ;
#endif
 
      tmpisvalid = false ;  // init 
 
      if ( IsConverged )
      {
        if (validate == kValidateWithTol)
        {
          tmpareacode = GetAreaCode(tmpxx);
          if (!IsOutside(tmpareacode))
          {
            if (tmpdist >= 0)  { tmpisvalid = true; }
          }
        }
        else if (validate == kValidateWithoutTol)
        {
          tmpareacode = GetAreaCode(tmpxx, false);
          if (IsInside(tmpareacode))
          {
            if (tmpdist >= 0)  { tmpisvalid = true; }
          }
        }
        else  // kDontValidate
        {
          G4Exception("G4TwistedBoxSide::DistanceToSurface()",
                      "GeomSolids0001", FatalException,
                      "Feature NOT implemented !");
        }
      } 
      else
      {
        tmpdist = kInfinity;     // no convergence after 10 steps 
        tmpisvalid = false ;     // solution is not vaild
      }  
 
      // store the found values
      //
      xbuf[k].xx = tmpxx ;
      xbuf[k].distance = tmpdist ;
      xbuf[k].areacode = tmpareacode ;
      xbuf[k].isvalid = tmpisvalid ;
 
    }  // end loop over physical solutions 
  }  // end less than 2 solutions
 
  // sort again
  std::sort(xbuf.begin() , xbuf.end(), DistanceSort ) ;  // sorting
 
  // erase identical intersection (within kCarTolerance) 
  xbuf.erase( std::unique(xbuf.begin(), xbuf.end() , EqualIntersection ) ,
              xbuf.end() );
 
#ifdef G4TWISTDEBUG
  G4cout << G4endl << "list xbuf after sorting : " << G4endl ;
  G4cout << G4endl << G4endl ;
#endif
 
  nxx = xbuf.size() ;   // determine number of solutions again.
 
  for ( size_t i = 0 ; i<xbuf.size() ; ++i )
  {
    distance[i] = xbuf[i].distance;
    gxx[i]      = ComputeGlobalPoint(xbuf[i].xx);
    areacode[i] = xbuf[i].areacode ;
    isvalid[i]  = xbuf[i].isvalid ;
    
    fCurStatWithV.SetCurrentStatus(i, gxx[i], distance[i], areacode[i],
                                     isvalid[i], nxx, validate, &gp, &gv);
#ifdef G4TWISTDEBUG
    G4cout << "element Nr. " << i 
           << ", local Intersection = " << xbuf[i].xx 
           << ", distance = " << xbuf[i].distance 
           << ", u = " << xbuf[i].u 
           << ", phi = " << xbuf[i].phi 
           << ", isvalid = " << xbuf[i].isvalid 
           << G4endl ;
#endif
 
  }  // end for( i ) loop
 
#ifdef G4TWISTDEBUG
  G4cout << "G4TwistTrapAlphaSide finished " << G4endl ;
  G4cout << nxx << " possible physical solutions found" << G4endl ;
  for ( G4int k= 0 ; k< nxx ; k++ )
  {
    G4cout << "global intersection Point found: " << gxx[k] << G4endl ;
    G4cout << "distance = " << distance[k] << G4endl ;
    G4cout << "isvalid = " << isvalid[k] << G4endl ;
  }
#endif
 
  return nxx ;
}

◆ DistanceToSurface() [2/2]

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

virtual

Implements G4VTwistSurface.

Definition at line 684 of file G4TwistTrapAlphaSide.cc.

{  
   const G4double ctol = 0.5 * kCarTolerance;
 
   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 (G4int i=0; i<G4VSURFACENXX; ++i)
      {
         distance[i] = kInfinity;
         areacode[i] = sOutside;
         gxx[i].set(kInfinity, kInfinity, kInfinity);
      }
   }
 
   G4ThreeVector p = ComputeLocalPoint(gp);
   G4ThreeVector xx;  // intersection point
   G4ThreeVector xxonsurface ; // interpolated intersection point 
 
   // the surfacenormal at that surface point
   //
   G4double phiR = 0  ;
   G4double uR = 0 ;
 
   G4ThreeVector surfacenormal ; 
   G4double deltaX, uMax ;
   G4double halfphi = 0.5*fPhiTwist ;
   
   for ( G4int i = 1 ; i<20 ; ++i )
   {
     xxonsurface = SurfacePoint(phiR,uR) ;
     surfacenormal = NormAng(phiR,uR) ;
     distance[0] = DistanceToPlane(p,xxonsurface,surfacenormal,xx); // new XX
     deltaX = ( xx - xxonsurface ).mag() ; 
 
#ifdef G4TWISTDEBUG
     G4cout << "i = " << i << ", distance = " << distance[0]
            << ", " << deltaX << G4endl
            << "X = " << xx << G4endl ;
#endif
 
     // the new point xx is accepted and phi/psi replaced
     //
     GetPhiUAtX(xx, phiR, uR) ;
     
     if ( deltaX <= ctol ) { break ; }
   }
 
   // check validity of solution ( valid phi,psi ) 
 
   uMax = GetBoundaryMax(phiR) ;
 
   if (  phiR > halfphi ) { phiR =  halfphi ; }
   if ( phiR < -halfphi ) { phiR = -halfphi ; }
   if ( uR > uMax )  { uR = uMax ;  }
   if ( uR < -uMax ) { uR = -uMax ; }
 
   xxonsurface = SurfacePoint(phiR,uR) ;
   distance[0] = (  p - xx ).mag() ;
   if ( distance[0] <= ctol ) { distance[0] = 0 ; } 
 
   // end of validity 
 
#ifdef G4TWISTDEBUG
   G4cout << "refined solution "  << phiR << " , " << uR << " , " << G4endl ;
   G4cout << "distance = " << distance[0] << G4endl ;
   G4cout << "X = " << xx << G4endl ;
#endif
 
   G4bool isvalid = true;
   gxx[0]      = ComputeGlobalPoint(xx);
   
#ifdef G4TWISTDEBUG
   G4cout << "intersection Point found: " << gxx[0] << G4endl ;
   G4cout << "distance = " << distance[0] << G4endl ;
#endif
 
   fCurStat.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
                            isvalid, 1, kDontValidate, &gp);
   return 1;
}

◆ GetAreaCode()

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

privatevirtual

Implements G4VTwistSurface.

Definition at line 785 of file G4TwistTrapAlphaSide.cc.

{
   // We must use the function in local coordinate system.
   // See the description of DistanceToSurface(p,v).
   
   const G4double ctol = 0.5 * kCarTolerance;
 
   G4double phi ;
   G4double yprime ;
   GetPhiUAtX(xx, phi,yprime ) ;
 
   G4double fYAxisMax =  GetBoundaryMax(phi) ;
   G4double fYAxisMin =  GetBoundaryMin(phi) ;
 
#ifdef G4TWISTDEBUG
   G4cout << "GetAreaCode: phi = " << phi << G4endl ;
   G4cout << "GetAreaCode: yprime = " << yprime << G4endl ;
   G4cout << "Intervall is " << fYAxisMin << " to " << fYAxisMax << G4endl ;
#endif
 
   G4int areacode = sInside;
   
   if (fAxis[0] == kYAxis && fAxis[1] == kZAxis)
   {
      G4int zaxis = 1;
 
      if (withTol)
      {
        G4bool isoutside   = false;
        
        // test boundary of yaxis
 
         if (yprime < fYAxisMin + ctol)
         {
            areacode |= (sAxis0 & (sAxisY | sAxisMin)) | sBoundary; 
            if (yprime <= fYAxisMin - ctol)  { isoutside = true; }
 
         }
         else if (yprime > fYAxisMax - ctol)
         {
            areacode |= (sAxis0 & (sAxisY | sAxisMax)) | sBoundary;
            if (yprime >= fYAxisMax + ctol)  { isoutside = true; }
         }
 
         // test boundary of z-axis
 
         if (xx.z() < fAxisMin[zaxis] + ctol)
         {
            areacode |= (sAxis1 & (sAxisZ | sAxisMin)); 
 
            if   (areacode & sBoundary)   // xx is on the corner
              { areacode |= sCorner; }
 
            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)   // xx is on the corner
               { areacode |= sCorner; }
            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 & sAxisY) | (sAxis1 & sAxisZ);
         }           
         
      }
      else
      {
         // boundary of y-axis
 
         if (yprime < fYAxisMin )
         {
            areacode |= (sAxis0 & (sAxisY | sAxisMin)) | sBoundary;
         }
         else if (yprime > fYAxisMax)
         {
            areacode |= (sAxis0 & (sAxisY | sAxisMax)) | sBoundary;
         }
         
         // boundary of z-axis
 
         if (xx.z() < fAxisMin[zaxis])
         {
            areacode |= (sAxis1 & (sAxisZ | sAxisMin));
            if   (areacode & sBoundary)   // xx is on the corner
              { areacode |= sCorner; }
            else
              { areacode |= sBoundary; }
         }
         else if (xx.z() > fAxisMax[zaxis])
         {
            areacode |= (sAxis1 & (sAxisZ | sAxisMax)) ;
            if   (areacode & sBoundary)   // xx is on the corner
              { areacode |= sCorner; }
            else
              { areacode |= sBoundary; }
         }
 
         if ((areacode & sBoundary) != sBoundary)
         {
            areacode |= (sAxis0 & sAxisY) | (sAxis1 & sAxisZ);
         }           
      }
      return areacode;
   }
   else
   {
      G4Exception("G4TwistTrapAlphaSide::GetAreaCode()",
                  "GeomSolids0001", FatalException,
                  "Feature NOT implemented !");
   }
   return areacode;
}

References FatalException, G4VTwistSurface::fAxis, G4VTwistSurface::fAxisMax, G4VTwistSurface::fAxisMin, G4cout, G4endl, G4Exception(), GetBoundaryMax(), GetBoundaryMin(), GetPhiUAtX(), G4VTwistSurface::kCarTolerance, kYAxis, kZAxis, G4VTwistSurface::sAxis0, G4VTwistSurface::sAxis1, G4VTwistSurface::sAxisMax, G4VTwistSurface::sAxisMin, G4VTwistSurface::sAxisY, G4VTwistSurface::sAxisZ, G4VTwistSurface::sBoundary, G4VTwistSurface::sCorner, G4VTwistSurface::sInside, 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 G4TwistTubsSide::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 G4TwistTrapAlphaSide::GetBoundaryMax ( G4double phi )

inlineprivatevirtual

Implements G4VTwistSurface.

Definition at line 200 of file G4TwistTrapAlphaSide.hh.

{
  return 0.5*GetValueB(phi) ;
}

References GetValueB().

Referenced by DistanceToSurface(), and GetAreaCode().

◆ GetBoundaryMin()

G4double G4TwistTrapAlphaSide::GetBoundaryMin ( G4double phi )

inlineprivatevirtual

Implements G4VTwistSurface.

Definition at line 194 of file G4TwistTrapAlphaSide.hh.

{
  return -0.5*GetValueB(phi) ;
}

References GetValueB().

Referenced by GetAreaCode().

◆ 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(), G4TwistTubsSide::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(), SetBoundaries(), G4TwistTrapFlatSide::SetBoundaries(), G4TwistTrapParallelSide::SetBoundaries(), G4TwistTubsFlatSide::SetBoundaries(), G4TwistTubsHypeSide::SetBoundaries(), and G4TwistTubsSide::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(), GetFacets(), G4TwistTrapFlatSide::GetFacets(), G4TwistTrapParallelSide::GetFacets(), G4TwistTubsFlatSide::GetFacets(), G4TwistTubsHypeSide::GetFacets(), and G4TwistTubsSide::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(), GetFacets(), G4TwistTrapFlatSide::GetFacets(), G4TwistTrapParallelSide::GetFacets(), G4TwistTubsFlatSide::GetFacets(), G4TwistTubsHypeSide::GetFacets(), and G4TwistTubsSide::GetFacets().

◆ GetFacets()

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

privatevirtual

Implements G4VTwistSurface.

Definition at line 1103 of file G4TwistTrapAlphaSide.cc.

{
 
  G4double phi ;
  G4double b ;   
 
  G4double z, u ;     // the two parameters for the surface equation
  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 = -fDz+i*(2.*fDz)/(n-1) ;
    phi = z*fPhiTwist/(2*fDz) ;
    b = GetValueB(phi) ;
 
    for ( G4int j = 0 ; j<k ; ++j )
    {
      nnode = GetNode(i,j,k,n,iside) ;
      u = -b/2 +j*b/(k-1) ;
      p = SurfacePoint(phi,u,true) ;  // surface point in global coordinates
 
      xyz[nnode][0] = p.x() ;
      xyz[nnode][1] = p.y() ;
      xyz[nnode][2] = p.z() ;
 
      if ( i<n-1 && j<k-1 )  // conterclock 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) ;  // f77 numbering
        faces[nface][1] = GetEdgeVisibility(i,j,k,n,1,-1)
                        * (GetNode(i  ,j+1,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+1,j  ,k,n,iside)+1) ;
      }
    }
  }
}

References fDz, fPhiTwist, G4VTwistSurface::GetEdgeVisibility(), G4VTwistSurface::GetFace(), G4VTwistSurface::GetNode(), GetValueB(), 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(), GetFacets(), G4TwistTrapFlatSide::GetFacets(), G4TwistTrapParallelSide::GetFacets(), G4TwistTubsFlatSide::GetFacets(), G4TwistTubsHypeSide::GetFacets(), and G4TwistTubsSide::GetFacets().

◆ GetNormal()

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

virtual

Implements G4VTwistSurface.

Definition at line 134 of file G4TwistTrapAlphaSide.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;
      }
   }
 
   G4double phi ;
   G4double u ;
 
   GetPhiUAtX(xx,phi,u) ;   // phi,u for point xx close to surface 
 
   G4ThreeVector normal =  NormAng(phi,u) ;  // the normal vector at phi,u
 
#ifdef G4TWISTDEBUG
   G4cout  << "normal vector = " << normal << G4endl ;
   G4cout << "phi = " << phi << " , u = " << u << G4endl ;
#endif
 
   if (isGlobal)
   {
      fCurrentNormal.normal = ComputeGlobalDirection(normal.unit());
   }
   else
   {
      fCurrentNormal.normal = normal.unit();
   }
 
   return fCurrentNormal.normal;
}

References G4VTwistSurface::ComputeGlobalDirection(), G4VTwistSurface::ComputeLocalPoint(), G4VTwistSurface::fCurrentNormal, G4cout, G4endl, GetPhiUAtX(), G4VTwistSurface::kCarTolerance, CLHEP::normal(), G4VTwistSurface::G4SurfCurNormal::normal, NormAng(), and G4VTwistSurface::G4SurfCurNormal::p.

◆ GetPhiUAtX()

void G4TwistTrapAlphaSide::GetPhiUAtX	(	G4ThreeVector	p,
		G4double &	phi,
		G4double &	u
	)

private

Definition at line 1033 of file G4TwistTrapAlphaSide.cc.

{
  // find closest point XX on surface for a given point p
  // X0 is a point on the surface,  d is the direction
  // ( both for a fixed z = pz)
  
  // phi is given by the z coordinate of p
 
  phi =  p.z()/(2*fDz)*fPhiTwist ;
  u = (fPhiTwist*(2*fDx1*fDx1 - 2*fDx2*fDx2 - fa1md1*(fDx3 + fDx4)
             - 4*(fDx3plus1 + fDx4plus2)*fDy1*fTAlph)
             - 2*(2*fDx1*fDx1 - 2*fDx2*fDx2 + fa1md1*(fDx3 + fDx4)
                + 4*(fDx3minus1 + fDx4minus2)*fDy1*fTAlph)*phi
             - 4*(fa1md1*(fdeltaX*phi - fPhiTwist*p.x())
             + 4*fDy1*(fdeltaY*phi + fdeltaX*fTAlph*phi
                     - fPhiTwist*(fTAlph*p.x() + p.y())))*std::cos(phi)
             - 4*(fa1md1*fdeltaY*phi - 4*fdeltaX*fDy1*phi
                + 4*fdeltaY*fDy1*fTAlph*phi + 4*fDy1*fPhiTwist*p.x()
                - fPhiTwist*(fa1md1 + 4*fDy1*fTAlph)*p.y())*std::sin(phi))
       /(fDy1* fPhiTwist*((std::fabs(((fa1md1 + 4*fDy1*fTAlph)*std::cos(phi))
                          /fDy1 - 4*std::sin(phi)))
                        *(std::fabs(((fa1md1 + 4*fDy1*fTAlph)*std::cos(phi))
                          /fDy1 - 4*std::sin(phi)))
             + (std::fabs(4*std::cos(phi)
                + ((fa1md1 + 4*fDy1*fTAlph)*std::sin(phi))/fDy1))
             * (std::fabs(4*std::cos(phi)
                + ((fa1md1 + 4*fDy1*fTAlph)*std::sin(phi))/fDy1)))) ;
}

References fa1md1, fdeltaX, fdeltaY, fDx1, fDx2, fDx3, fDx3minus1, fDx3plus1, fDx4, fDx4minus2, fDx4plus2, fDy1, fDz, fPhiTwist, fTAlph, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

Referenced by DistanceToSurface(), GetAreaCode(), GetNormal(), and ProjectPoint().

◆ GetSurfaceArea()

G4double G4TwistTrapAlphaSide::GetSurfaceArea ( )

inlineprivatevirtual

Implements G4VTwistSurface.

Definition at line 206 of file G4TwistTrapAlphaSide.hh.

{
  return (fDz*(std::sqrt(16*fDy1*fDy1
             + (fa1md1 + 4*fDy1*fTAlph)*(fa1md1 + 4*fDy1*fTAlph))
             + std::sqrt(16*fDy2*fDy2 + (fa2md2 + 4*fDy2*fTAlph)
                                      * (fa2md2 + 4*fDy2*fTAlph))))/2. ;
}

References fa1md1, fa2md2, fDy1, fDy2, fDz, and fTAlph.

◆ GetValueA()

G4double G4TwistTrapAlphaSide::GetValueA ( G4double phi )

inlineprivate

Definition at line 152 of file G4TwistTrapAlphaSide.hh.

{
  return ( fDx4plus2 + fDx4minus2 * ( 2 * phi ) / fPhiTwist  ) ;
}

References fDx4minus2, fDx4plus2, and fPhiTwist.

Referenced by Xcoef().

◆ GetValueB()

G4double G4TwistTrapAlphaSide::GetValueB ( G4double phi )

inlineprivate

Definition at line 164 of file G4TwistTrapAlphaSide.hh.

{
  return ( fDy2plus1 + fDy2minus1 * ( 2 * phi ) / fPhiTwist ) ;
}

References fDy2minus1, fDy2plus1, and fPhiTwist.

Referenced by GetBoundaryMax(), GetBoundaryMin(), GetFacets(), and Xcoef().

◆ GetValueD()

G4double G4TwistTrapAlphaSide::GetValueD ( G4double phi )

inlineprivate

Definition at line 158 of file G4TwistTrapAlphaSide.hh.

{
  return ( fDx3plus1 + fDx3minus1 * ( 2 * phi) / fPhiTwist  ) ;
} 

References fDx3minus1, fDx3plus1, and fPhiTwist.

Referenced by Xcoef().

◆ 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(), DistanceToSurface(), G4TwistTrapFlatSide::DistanceToSurface(), G4TwistTrapParallelSide::DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), G4TwistTubsHypeSide::DistanceToSurface(), G4TwistTubsSide::DistanceToSurface(), and G4TwistTubsHypeSide::Inside().

◆ IsOutside()

G4bool G4VTwistSurface::IsOutside ( G4int areacode ) const

inlineinherited

Referenced by G4TwistBoxSide::DistanceToSurface(), DistanceToSurface(), G4TwistTrapFlatSide::DistanceToSurface(), G4TwistTrapParallelSide::DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), G4TwistTubsHypeSide::DistanceToSurface(), G4TwistTubsSide::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().

◆ NormAng()

G4ThreeVector G4TwistTrapAlphaSide::NormAng	(	G4double	phi,
		G4double	u
	)

inlineprivate

Definition at line 215 of file G4TwistTrapAlphaSide.hh.

{
  // function to calculate the norm at a given point on the surface
  // replace a1-d1
 
  G4ThreeVector nvec ( fDy1* fDz*(4*fDy1*std::cos(phi)
                     + (fa1md1 + 4*fDy1*fTAlph)*std::sin(phi)),
                       -(fDy1* fDz*((fa1md1 + 4*fDy1*fTAlph)*std::cos(phi)
                     - 4*fDy1*std::sin(phi))),
                       (fDy1*(-8*(fDx3minus1 + fDx4minus2)*fDy1
                                + fa1md1*(fDx2 + fDx3plus1 + fDx4)*fPhiTwist
                                + 4*(fDx2 + fDx3plus1 + fDx4)*fDy1*fPhiTwist
                                *fTAlph + 2*(fDx3minus1 + fDx4minus2)
                                *(fa1md1 + 4*fDy1*fTAlph)*phi)
                                + fPhiTwist*(16*fDy1*fDy1
                                + (fa1md1 + 4*fDy1*fTAlph)
                                *(fa1md1 + 4*fDy1*fTAlph))*u
                                + 4*fDy1*(fa1md1*fdeltaY - 4*fdeltaX*fDy1
                                + 4*fdeltaY*fDy1*fTAlph)* std::cos(phi)
                                - 4*fDy1*(fa1md1*fdeltaX + 4*fDy1*(fdeltaY
                                + fdeltaX*fTAlph))*std::sin(phi))/ 8. ) ;
  return nvec.unit();
}

References fa1md1, fdeltaX, fdeltaY, fDx2, fDx3minus1, fDx3plus1, fDx4, fDx4minus2, fDy1, fDz, fPhiTwist, fTAlph, and CLHEP::Hep3Vector::unit().

Referenced by DistanceToSurface(), and GetNormal().

◆ ProjectPoint()

G4ThreeVector G4TwistTrapAlphaSide::ProjectPoint	(	const G4ThreeVector &	p,
		G4bool	isglobal = `false`
	)

private

Definition at line 1066 of file G4TwistTrapAlphaSide.cc.

{
  // Get Rho at p.z() on Hyperbolic Surface.
 
  G4ThreeVector tmpp;
  if (isglobal)
  {
     tmpp = fRot.inverse()*p - fTrans;
  }
  else
  {
     tmpp = p;
  }
 
  G4double phi ;
  G4double u ;
 
  GetPhiUAtX( tmpp, phi, u ) ;
    // calculate (phi, u) for a point p close the surface
  
  G4ThreeVector xx = SurfacePoint(phi,u) ;
    // transform back to cartesian coordinates
 
  if (isglobal)
  {
     return (fRot * xx + fTrans);
  }
  else
  {
     return xx;
  }
}

References G4VTwistSurface::fRot, G4VTwistSurface::fTrans, GetPhiUAtX(), CLHEP::HepRotation::inverse(), and SurfacePoint().

◆ 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 G4TwistTrapAlphaSide::SetBoundaries ( )

privatevirtual

Implements G4VTwistSurface.

Definition at line 987 of file G4TwistTrapAlphaSide.cc.

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

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

Referenced by G4TwistTrapAlphaSide().

◆ 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(), SetBoundaries(), G4TwistTrapFlatSide::SetBoundaries(), G4TwistTrapParallelSide::SetBoundaries(), G4TwistTubsFlatSide::SetBoundaries(), G4TwistTubsHypeSide::SetBoundaries(), and G4TwistTubsSide::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(), SetCorners(), G4TwistTrapFlatSide::SetCorners(), G4TwistTrapParallelSide::SetCorners(), G4TwistTubsFlatSide::SetCorners(), G4TwistTubsSide::SetCorners(), and G4TwistTubsHypeSide::SetCorners().

◆ SetCorners()

void G4TwistTrapAlphaSide::SetCorners ( )

privatevirtual

Implements G4VTwistSurface.

Definition at line 918 of file G4TwistTrapAlphaSide.cc.

{
 
  // Set Corner points in local coodinate.   
 
  if (fAxis[0] == kYAxis && fAxis[1] == kZAxis)
  {
    
    G4double x, y, z;
 
    // corner of Axis0min and Axis1min
    //
    x = -fdeltaX/2. + (fDx1 - fDy1*fTAlph)*std::cos(fPhiTwist/2.)
      - fDy1*std::sin(fPhiTwist/2.);
    y = -fdeltaY/2. - fDy1*std::cos(fPhiTwist/2.)
      + (-fDx1 + fDy1*fTAlph)*std::sin(fPhiTwist/2.);
    z = -fDz ;
 
    //    G4cout << "SetCorners: " << x << ", " << y << ", " << z << G4endl ;
 
    SetCorner(sC0Min1Min, x, y, z);
      
    // corner of Axis0max and Axis1min
    //
    x = -fdeltaX/2. + (fDx2 + fDy1*fTAlph)*std::cos(fPhiTwist/2.)
      + fDy1*std::sin(fPhiTwist/2.);
    y = -fdeltaY/2. + fDy1*std::cos(fPhiTwist/2.)
      - (fDx2 + fDy1*fTAlph)*std::sin(fPhiTwist/2.);
    z = -fDz ;
 
    //    G4cout << "SetCorners: " << x << ", " << y << ", " << z << G4endl ;
 
    SetCorner(sC0Max1Min, x, y, z);
      
    // corner of Axis0max and Axis1max
    //
    x = fdeltaX/2. + (fDx4 + fDy2*fTAlph)*std::cos(fPhiTwist/2.)
      - fDy2*std::sin(fPhiTwist/2.);
    y = fdeltaY/2. + fDy2*std::cos(fPhiTwist/2.)
      + (fDx4 + fDy2*fTAlph)*std::sin(fPhiTwist/2.);
    z = fDz ;
    
    //    G4cout << "SetCorners: " << x << ", " << y << ", " << z << G4endl ;
    
    SetCorner(sC0Max1Max, x, y, z);
 
    // corner of Axis0min and Axis1max
    x = fdeltaX/2. + (fDx3 - fDy2*fTAlph)*std::cos(fPhiTwist/2.)
      + fDy2*std::sin(fPhiTwist/2.) ;
    y = fdeltaY/2. - fDy2*std::cos(fPhiTwist/2.)
      + (fDx3 - fDy2*fTAlph)*std::sin(fPhiTwist/2.) ;
    z = fDz ;
 
    //    G4cout << "SetCorners: " << x << ", " << y << ", " << z << G4endl ;
 
    SetCorner(sC0Min1Max, x, y, z);
 
  }
  else
  {
    G4Exception("G4TwistTrapAlphaSide::SetCorners()",
                "GeomSolids0001", FatalException,
                "Method NOT implemented !");
  }
}

References FatalException, G4VTwistSurface::fAxis, fdeltaX, fdeltaY, fDx1, fDx2, fDx3, fDx4, fDy1, fDy2, fDz, fPhiTwist, fTAlph, G4Exception(), kYAxis, kZAxis, G4VTwistSurface::sC0Max1Max, G4VTwistSurface::sC0Max1Min, G4VTwistSurface::sC0Min1Max, G4VTwistSurface::sC0Min1Min, and G4VTwistSurface::SetCorner().

Referenced by G4TwistTrapAlphaSide().

◆ SetNeighbours()

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

inlineinherited

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

◆ SurfacePoint()

G4ThreeVector G4TwistTrapAlphaSide::SurfacePoint	(	G4double	phi,
		G4double	u,
		G4bool	isGlobal = `false`
	)

inlineprivatevirtual

Implements G4VTwistSurface.

Definition at line 180 of file G4TwistTrapAlphaSide.hh.

{
  // function to calculate a point on the surface, given by parameters phi,u
 
  G4ThreeVector SurfPoint ( Xcoef(u,phi) * std::cos(phi)
                          - u * std::sin(phi) + fdeltaX*phi/fPhiTwist,
                            Xcoef(u,phi) * std::sin(phi)
                          + u * std::cos(phi) + fdeltaY*phi/fPhiTwist,
                            2*fDz*phi/fPhiTwist  );
  if (isGlobal) { return (fRot * SurfPoint + fTrans); }
  return SurfPoint;
}

References fdeltaX, fdeltaY, fDz, fPhiTwist, G4VTwistSurface::fRot, G4VTwistSurface::fTrans, and Xcoef().

Referenced by DistanceToSurface(), GetFacets(), and ProjectPoint().

◆ Xcoef()

G4double G4TwistTrapAlphaSide::Xcoef	(	G4double	u,
		G4double	phi
	)

inlineprivate

Definition at line 171 of file G4TwistTrapAlphaSide.hh.

{
  
  return GetValueA(phi)/2. + (GetValueD(phi)-GetValueA(phi))/4. 
    - u*( ( GetValueD(phi)-GetValueA(phi) )/( 2 * GetValueB(phi) ) - fTAlph );
 
}

References fTAlph, GetValueA(), GetValueB(), and GetValueD().

Referenced by SurfacePoint().

Field Documentation

◆ fa1md1

G4double G4TwistTrapAlphaSide::fa1md1

private

Definition at line 140 of file G4TwistTrapAlphaSide.hh.

Referenced by DistanceToSurface(), G4TwistTrapAlphaSide(), GetPhiUAtX(), GetSurfaceArea(), and NormAng().

◆ fa2md2

G4double G4TwistTrapAlphaSide::fa2md2

private

Definition at line 141 of file G4TwistTrapAlphaSide.hh.

Referenced by G4TwistTrapAlphaSide(), and GetSurfaceArea().

◆ fAlph

G4double G4TwistTrapAlphaSide::fAlph

private

Definition at line 127 of file G4TwistTrapAlphaSide.hh.

Referenced by G4TwistTrapAlphaSide().

◆ fAmIOnLeftSide

G4SurfSideQuery G4VTwistSurface::fAmIOnLeftSide

privateinherited

Definition at line 342 of file G4VTwistSurface.hh.

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

◆ fAngleSide

G4double G4TwistTrapAlphaSide::fAngleSide

private

Definition at line 132 of file G4TwistTrapAlphaSide.hh.

Referenced by G4TwistTrapAlphaSide().

◆ fAxis

EAxis G4VTwistSurface::fAxis[2]

protectedinherited

Definition at line 308 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::DebugPrint(), G4TwistTubsSide::DistanceToSurface(), G4TwistBoxSide::G4TwistBoxSide(), G4TwistTrapAlphaSide(), G4TwistTrapFlatSide::G4TwistTrapFlatSide(), G4TwistTrapParallelSide::G4TwistTrapParallelSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4TwistTubsHypeSide::G4TwistTubsHypeSide(), G4TwistTubsSide::G4TwistTubsSide(), G4VTwistSurface::G4VTwistSurface(), G4TwistBoxSide::GetAreaCode(), GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), G4TwistTrapParallelSide::GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCode(), G4TwistTubsSide::GetAreaCode(), G4VTwistSurface::SetAxis(), G4TwistBoxSide::SetBoundaries(), SetBoundaries(), G4TwistTrapFlatSide::SetBoundaries(), G4TwistTrapParallelSide::SetBoundaries(), G4TwistTubsFlatSide::SetBoundaries(), G4TwistTubsHypeSide::SetBoundaries(), G4TwistTubsSide::SetBoundaries(), G4TwistBoxSide::SetCorners(), SetCorners(), G4TwistTrapFlatSide::SetCorners(), G4TwistTrapParallelSide::SetCorners(), G4TwistTubsFlatSide::SetCorners(), G4TwistTubsSide::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(), G4TwistTrapFlatSide::G4TwistTrapFlatSide(), G4TwistTrapParallelSide::G4TwistTrapParallelSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4TwistTubsHypeSide::G4TwistTubsHypeSide(), G4TwistTubsSide::G4TwistTubsSide(), G4VTwistSurface::G4VTwistSurface(), G4TwistBoxSide::GetAreaCode(), GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), G4TwistTrapParallelSide::GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCode(), G4TwistTubsSide::GetAreaCode(), G4VTwistSurface::GetBoundaryLimit(), G4TwistTubsSide::GetBoundaryMax(), G4TwistTubsFlatSide::GetFacets(), G4TwistTubsHypeSide::GetFacets(), G4TwistTubsSide::GetFacets(), G4TwistTubsHypeSide::GetSurfaceArea(), G4TwistTubsSide::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(), G4TwistTrapFlatSide::G4TwistTrapFlatSide(), G4TwistTrapParallelSide::G4TwistTrapParallelSide(), G4TwistTubsFlatSide::G4TwistTubsFlatSide(), G4TwistTubsHypeSide::G4TwistTubsHypeSide(), G4TwistTubsSide::G4TwistTubsSide(), G4VTwistSurface::G4VTwistSurface(), G4TwistBoxSide::GetAreaCode(), GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), G4TwistTrapParallelSide::GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCode(), G4TwistTubsSide::GetAreaCode(), G4VTwistSurface::GetBoundaryLimit(), G4TwistTubsSide::GetBoundaryMin(), G4TwistTubsFlatSide::GetFacets(), G4TwistTubsHypeSide::GetFacets(), G4TwistTubsSide::GetFacets(), G4TwistTubsHypeSide::GetSurfaceArea(), G4TwistTubsSide::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(), GetNormal(), G4TwistTrapParallelSide::GetNormal(), G4TwistTubsHypeSide::GetNormal(), and G4TwistTubsSide::GetNormal().

◆ fCurStat

CurrentStatus G4VTwistSurface::fCurStat

protectedinherited

Definition at line 312 of file G4VTwistSurface.hh.

Referenced by G4TwistTubsSide::DistanceToSurface(), G4TwistBoxSide::DistanceToSurface(), 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(), DistanceToSurface(), G4TwistTrapFlatSide::DistanceToSurface(), G4TwistTrapParallelSide::DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), G4TwistTubsHypeSide::DistanceToSurface(), and G4TwistTubsSide::DistanceToSurface().

◆ fdeltaX

G4double G4TwistTrapAlphaSide::fdeltaX

private

Definition at line 143 of file G4TwistTrapAlphaSide.hh.

Referenced by DistanceToSurface(), G4TwistTrapAlphaSide(), GetPhiUAtX(), NormAng(), SetCorners(), and SurfacePoint().

◆ fdeltaY

G4double G4TwistTrapAlphaSide::fdeltaY

private

Definition at line 144 of file G4TwistTrapAlphaSide.hh.

Referenced by DistanceToSurface(), G4TwistTrapAlphaSide(), GetPhiUAtX(), NormAng(), SetCorners(), and SurfacePoint().

◆ fDx1

G4double G4TwistTrapAlphaSide::fDx1

private

Definition at line 118 of file G4TwistTrapAlphaSide.hh.

Referenced by G4TwistTrapAlphaSide(), GetPhiUAtX(), and SetCorners().

◆ fDx2

G4double G4TwistTrapAlphaSide::fDx2

private

Definition at line 119 of file G4TwistTrapAlphaSide.hh.

Referenced by G4TwistTrapAlphaSide(), GetPhiUAtX(), NormAng(), and SetCorners().

◆ fDx3

G4double G4TwistTrapAlphaSide::fDx3

private

Definition at line 122 of file G4TwistTrapAlphaSide.hh.

Referenced by G4TwistTrapAlphaSide(), GetPhiUAtX(), and SetCorners().

◆ fDx3minus1

G4double G4TwistTrapAlphaSide::fDx3minus1

private

Definition at line 137 of file G4TwistTrapAlphaSide.hh.

Referenced by DistanceToSurface(), G4TwistTrapAlphaSide(), GetPhiUAtX(), GetValueD(), and NormAng().

◆ fDx3plus1

G4double G4TwistTrapAlphaSide::fDx3plus1

private

Definition at line 136 of file G4TwistTrapAlphaSide.hh.

Referenced by DistanceToSurface(), G4TwistTrapAlphaSide(), GetPhiUAtX(), GetValueD(), and NormAng().

◆ fDx4

G4double G4TwistTrapAlphaSide::fDx4

private

Definition at line 123 of file G4TwistTrapAlphaSide.hh.

Referenced by G4TwistTrapAlphaSide(), GetPhiUAtX(), NormAng(), and SetCorners().

◆ fDx4minus2

G4double G4TwistTrapAlphaSide::fDx4minus2

private

Definition at line 135 of file G4TwistTrapAlphaSide.hh.

Referenced by DistanceToSurface(), G4TwistTrapAlphaSide(), GetPhiUAtX(), GetValueA(), and NormAng().

◆ fDx4plus2

G4double G4TwistTrapAlphaSide::fDx4plus2

private

Definition at line 134 of file G4TwistTrapAlphaSide.hh.

Referenced by DistanceToSurface(), G4TwistTrapAlphaSide(), GetPhiUAtX(), and GetValueA().

◆ fDy1

G4double G4TwistTrapAlphaSide::fDy1

private

Definition at line 117 of file G4TwistTrapAlphaSide.hh.

Referenced by DistanceToSurface(), G4TwistTrapAlphaSide(), GetPhiUAtX(), GetSurfaceArea(), NormAng(), and SetCorners().

◆ fDy2

G4double G4TwistTrapAlphaSide::fDy2

private

Definition at line 121 of file G4TwistTrapAlphaSide.hh.

Referenced by G4TwistTrapAlphaSide(), GetSurfaceArea(), and SetCorners().

◆ fDy2minus1

G4double G4TwistTrapAlphaSide::fDy2minus1

private

Definition at line 139 of file G4TwistTrapAlphaSide.hh.

Referenced by G4TwistTrapAlphaSide(), and GetValueB().

◆ fDy2plus1

G4double G4TwistTrapAlphaSide::fDy2plus1

private

Definition at line 138 of file G4TwistTrapAlphaSide.hh.

Referenced by G4TwistTrapAlphaSide(), and GetValueB().

◆ fDz

G4double G4TwistTrapAlphaSide::fDz

private

Definition at line 125 of file G4TwistTrapAlphaSide.hh.

Referenced by DistanceToSurface(), G4TwistTrapAlphaSide(), GetFacets(), GetPhiUAtX(), GetSurfaceArea(), NormAng(), SetCorners(), and SurfacePoint().

◆ fHandedness

G4int G4VTwistSurface::fHandedness

protectedinherited

Definition at line 315 of file G4VTwistSurface.hh.

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

◆ fIsValidNorm

G4bool G4VTwistSurface::fIsValidNorm

protectedinherited

Definition at line 323 of file G4VTwistSurface.hh.

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

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

◆ fPhi

G4double G4TwistTrapAlphaSide::fPhi

private

Definition at line 115 of file G4TwistTrapAlphaSide.hh.

Referenced by G4TwistTrapAlphaSide().

◆ fPhiTwist

G4double G4TwistTrapAlphaSide::fPhiTwist

private

Definition at line 130 of file G4TwistTrapAlphaSide.hh.

Referenced by DistanceToSurface(), G4TwistTrapAlphaSide(), GetFacets(), GetPhiUAtX(), GetValueA(), GetValueB(), GetValueD(), NormAng(), SetCorners(), and SurfacePoint().

◆ fRot

G4RotationMatrix G4VTwistSurface::fRot

protectedinherited

◆ fTAlph

G4double G4TwistTrapAlphaSide::fTAlph

private

Definition at line 128 of file G4TwistTrapAlphaSide.hh.

Referenced by DistanceToSurface(), G4TwistTrapAlphaSide(), GetPhiUAtX(), GetSurfaceArea(), NormAng(), SetCorners(), and Xcoef().

◆ fTheta

G4double G4TwistTrapAlphaSide::fTheta

private

Definition at line 114 of file G4TwistTrapAlphaSide.hh.

Referenced by G4TwistTrapAlphaSide().

◆ 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 G4TwistTubsSide::DistanceToSurface(), G4TwistBoxSide::GetAreaCode(), GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), G4TwistTrapParallelSide::GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCode(), G4TwistTubsSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCodeInPhi(), G4VTwistSurface::GetBoundaryAtPZ(), G4VTwistSurface::GetBoundaryAxis(), G4VTwistSurface::GetBoundaryLimit(), G4TwistTubsHypeSide::GetBoundaryMax(), G4TwistTubsHypeSide::GetBoundaryMin(), G4VTwistSurface::Boundary::GetBoundaryParameters(), G4TwistBoxSide::SetBoundaries(), SetBoundaries(), G4TwistTrapFlatSide::SetBoundaries(), G4TwistTrapParallelSide::SetBoundaries(), G4TwistTubsFlatSide::SetBoundaries(), G4TwistTubsHypeSide::SetBoundaries(), G4TwistTubsSide::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(), G4TwistTubsSide::GetAreaCode(), G4VTwistSurface::GetBoundaryAxis(), G4TwistTrapFlatSide::SetBoundaries(), G4TwistTrapParallelSide::SetBoundaries(), and G4TwistTubsSide::SetBoundaries().

◆ sAxisY

const G4int G4VTwistSurface::sAxisY = 0x00000808

staticinherited

Definition at line 227 of file G4VTwistSurface.hh.

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

◆ sAxisZ

const G4int G4VTwistSurface::sAxisZ = 0x00000C0C

staticinherited

Definition at line 228 of file G4VTwistSurface.hh.

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

◆ sBoundary

const G4int G4VTwistSurface::sBoundary = 0x20000000

staticinherited

Definition at line 218 of file G4VTwistSurface.hh.

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

◆ sC0Max1Max

◆ sC0Max1Min

◆ sC0Min1Max

const G4int G4VTwistSurface::sC0Min1Max = 0x40000102

staticinherited

Definition at line 223 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::DebugPrint(), G4VTwistSurface::GetBoundaryLimit(), G4TwistBoxSide::SetBoundaries(), SetBoundaries(), G4TwistTrapFlatSide::SetBoundaries(), G4TwistTrapParallelSide::SetBoundaries(), G4TwistTubsFlatSide::SetBoundaries(), G4TwistTubsHypeSide::SetBoundaries(), G4TwistTubsSide::SetBoundaries(), G4VTwistSurface::SetCorner(), G4TwistBoxSide::SetCorners(), SetCorners(), G4TwistTrapFlatSide::SetCorners(), G4TwistTrapParallelSide::SetCorners(), G4TwistTubsFlatSide::SetCorners(), G4TwistTubsSide::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(), SetBoundaries(), G4TwistTrapFlatSide::SetBoundaries(), G4TwistTrapParallelSide::SetBoundaries(), G4TwistTubsFlatSide::SetBoundaries(), G4TwistTubsHypeSide::SetBoundaries(), G4TwistTubsSide::SetBoundaries(), G4VTwistSurface::SetCorner(), G4TwistBoxSide::SetCorners(), SetCorners(), G4TwistTrapFlatSide::SetCorners(), G4TwistTrapParallelSide::SetCorners(), G4TwistTubsFlatSide::SetCorners(), G4TwistTubsSide::SetCorners(), and G4TwistTubsHypeSide::SetCorners().

◆ sCorner

const G4int G4VTwistSurface::sCorner = 0x40000000

staticinherited

Definition at line 219 of file G4VTwistSurface.hh.

Referenced by G4TwistBoxSide::GetAreaCode(), GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), G4TwistTrapParallelSide::GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCode(), G4TwistTubsSide::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(), G4TwistTubsSide::DistanceToSurface(), G4TwistBoxSide::GetAreaCode(), GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), G4TwistTrapParallelSide::GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), G4TwistTubsHypeSide::GetAreaCode(), G4TwistTubsSide::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(), DistanceToSurface(), G4TwistTrapFlatSide::DistanceToSurface(), G4TwistTrapParallelSide::DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), G4TwistTubsHypeSide::DistanceToSurface(), G4TwistTubsSide::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/G4TwistTrapAlphaSide.hh
source/geometry/solids/specific/src/G4TwistTrapAlphaSide.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

◆ G4TwistTrapAlphaSide() [1/2]

◆ ~G4TwistTrapAlphaSide()

◆ G4TwistTrapAlphaSide() [2/2]

Member Function Documentation

◆ AmIOnLeftSide()

◆ ComputeGlobalDirection()

◆ ComputeGlobalPoint()

◆ ComputeLocalDirection()

◆ ComputeLocalPoint()

◆ DebugPrint()

◆ DistanceTo()

◆ DistanceToBoundary()

◆ DistanceToIn()

◆ DistanceToLine()

◆ DistanceToOut()

◆ DistanceToPlane() [1/2]

◆ DistanceToPlane() [2/2]

◆ DistanceToPlaneWithV()

◆ DistanceToSurface() [1/2]

◆ DistanceToSurface() [2/2]

◆ GetAreaCode()

◆ GetAxisType()

◆ GetBoundaryAtPZ()

◆ GetBoundaryAxis()

◆ GetBoundaryLimit()

◆ GetBoundaryMax()

◆ GetBoundaryMin()

◆ GetBoundaryParameters()

◆ GetCorner()

◆ GetEdgeVisibility()

◆ GetFace()

◆ GetFacets()

◆ GetName()

◆ GetNeighbours() [1/2]

◆ GetNeighbours() [2/2]

◆ GetNode()

◆ GetNormal()

◆ GetPhiUAtX()

◆ GetSurfaceArea()

◆ GetValueA()

◆ GetValueB()

◆ GetValueD()

◆ IsAxis0()

◆ IsAxis1()

◆ IsBoundary()

◆ IsCorner()

◆ IsInside()

◆ IsOutside()

◆ IsSameBoundary()

◆ IsValidNorm()

◆ NormAng()

◆ ProjectPoint()

◆ SetAxis()

◆ SetBoundaries()

◆ SetBoundary()

◆ SetCorner()

◆ SetCorners()

◆ SetNeighbours()

◆ SurfacePoint()

◆ Xcoef()

Field Documentation

◆ fa1md1

◆ fa2md2

◆ fAlph

◆ fAmIOnLeftSide

◆ fAngleSide

◆ fAxis

◆ fAxisMax

◆ fAxisMin