G4TwistTubsHypeSide Class Reference

#include <G4TwistTubsHypeSide.hh>

Inheritance diagram for G4TwistTubsHypeSide:

Data Structures
class	Insidetype

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[])
	G4TwistTubsHypeSide (__void__ &)
	G4TwistTubsHypeSide (const G4String &name, const G4RotationMatrix &rot, const G4ThreeVector &tlate, const G4int handedness, const G4double kappa, const G4double tanstereo, const G4double r0, const EAxis axis0=kPhi, const EAxis axis1=kZAxis, G4double axis0min=-kInfinity, G4double axis1min=-kInfinity, G4double axis0max=kInfinity, G4double axis1max=kInfinity)
	G4TwistTubsHypeSide (const G4String &name, G4double EndInnerRadius[2], G4double EndOuterRadius[2], G4double DPhi, G4double EndPhi[2], G4double EndZ[2], G4double InnerRadius, G4double OuterRadius, G4double Kappa, G4double TanInnerStereo, G4double TanOuterStereo, G4int handedness)
G4int	GetAxisType (G4int areacode, G4int whichaxis) const
virtual G4ThreeVector	GetBoundaryAtPZ (G4int areacode, const G4ThreeVector &p) const
virtual G4double	GetBoundaryMax (G4double phi)
virtual G4double	GetBoundaryMin (G4double phi)
virtual void	GetBoundaryParameters (const G4int &areacode, G4ThreeVector &d, G4ThreeVector &x0, G4int &boundarytype) const
G4int	GetEdgeVisibility (G4int i, G4int j, G4int m, G4int n, G4int number, G4int orientation)
G4int	GetFace (G4int i, G4int j, G4int m, G4int n, G4int iside)
virtual void	GetFacets (G4int m, G4int n, G4double xyz[][3], G4int faces[][4], G4int iside)
virtual G4String	GetName () const
G4int	GetNode (G4int i, G4int j, G4int m, G4int n, G4int iside)
virtual G4ThreeVector	GetNormal (const G4ThreeVector &xx, G4bool isGlobal=false)
virtual G4double	GetRhoAtPZ (const G4ThreeVector &p, G4bool isglobal=false) const
virtual G4double	GetSurfaceArea ()
virtual EInside	Inside (const G4ThreeVector &gp)
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 G4ThreeVector	SurfacePoint (G4double, G4double, G4bool isGlobal=false)
virtual	~G4TwistTubsHypeSide ()

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 G4int	GetAreaCodeInPhi (const G4ThreeVector &xx, G4bool withTol=true)
virtual void	SetBoundaries ()
virtual void	SetCorners ()
virtual void	SetCorners (G4double EndInnerRadius[2], G4double EndOuterRadius[2], G4double DPhi, G4double EndPhi[2], G4double EndZ[2])

Private Attributes
G4SurfSideQuery	fAmIOnLeftSide
Boundary	fBoundaries [4]
G4ThreeVector	fCorners [4]
G4double	fDPhi
Insidetype	fInside
G4double	fKappa
G4String	fName
G4VTwistSurface *	fNeighbours [4]
G4double	fR0
G4double	fR02
G4double	fTan2Stereo
G4double	fTanStereo

Detailed Description

Definition at line 43 of file G4TwistTubsHypeSide.hh.

Member Enumeration Documentation

EValidate

enum G4VTwistSurface::EValidate

inherited

Enumerator
kDontValidate
kValidateWithTol
kValidateWithoutTol
kUninitialized

Definition at line 52 of file G4VTwistSurface.hh.

                  { kDontValidate = 0, kValidateWithTol = 1, 
                    kValidateWithoutTol = 2, kUninitialized = 3 };

Constructor & Destructor Documentation

G4TwistTubsHypeSide() [1/3]

G4TwistTubsHypeSide::G4TwistTubsHypeSide	(	const G4String &	name,
		const G4RotationMatrix &	rot,
		const G4ThreeVector &	tlate,
		const G4int	handedness,
		const G4double	kappa,
		const G4double	tanstereo,
		const G4double	r0,
		const EAxis	axis0 = kPhi,
		const EAxis	axis1 = kZAxis,
		G4double	axis0min = -kInfinity,
		G4double	axis1min = -kInfinity,
		G4double	axis0max = kInfinity,
		G4double	axis1max = kInfinity
	)

Definition at line 40 of file G4TwistTubsHypeSide.cc.

  : G4VTwistSurface(name, rot, tlate, handedness, axis0, axis1,
                    axis0min, axis1min, axis0max, axis1max),
    fKappa(kappa), fTanStereo(tanstereo),
    fTan2Stereo(tanstereo*tanstereo), fR0(r0), fR02(r0*r0), fDPhi(twopi)
{
   if ( (axis0 == kZAxis) && (axis1 == kPhi) )
   {
      G4Exception("G4TwistTubsHypeSide::G4TwistTubsHypeSide()",
                  "GeomSolids0002", FatalErrorInArgument,
                  "Should swap axis0 and axis1!");
   }
   fInside.gp.set(kInfinity, kInfinity, kInfinity);
   fInside.inside = kOutside;
   fIsValidNorm = false;
   SetCorners();
   SetBoundaries();
}

References FatalErrorInArgument, fInside, G4VTwistSurface::fIsValidNorm, G4Exception(), G4TwistTubsHypeSide::Insidetype::gp, G4TwistTubsHypeSide::Insidetype::inside, kInfinity, kOutside, kPhi, kZAxis, CLHEP::Hep3Vector::set(), SetBoundaries(), and SetCorners().

G4TwistTubsHypeSide() [2/3]

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

Definition at line 71 of file G4TwistTubsHypeSide.cc.

   : G4VTwistSurface(name)
{
 
   fHandedness = handedness;   // +z = +ve, -z = -ve
   fAxis[0]    = kPhi;
   fAxis[1]    = kZAxis;
   fAxisMin[0] = kInfinity;         // we cannot fix boundary min of Phi, 
   fAxisMax[0] = kInfinity;         // because it depends on z.
   fAxisMin[1] = EndZ[0];
   fAxisMax[1] = EndZ[1];
   fKappa      = Kappa;
   fDPhi       = DPhi ;
 
   if (handedness < 0)  // inner hyperbolic surface
   {
      fTanStereo  = TanInnerStereo;
      fR0         = InnerRadius;
   }
   else                 // outer hyperbolic surface
   {
      fTanStereo  = TanOuterStereo;
      fR0         = OuterRadius;
   }
   fTan2Stereo = fTanStereo * fTanStereo;
   fR02        = fR0 * fR0;
   
   fTrans.set(0, 0, 0);
   fIsValidNorm = false;
 
   fInside.gp.set(kInfinity, kInfinity, kInfinity);
   fInside.inside = kOutside;
   
   SetCorners(EndInnerRadius, EndOuterRadius, DPhi, EndPhi, EndZ) ; 
 
   SetBoundaries();
}

References G4VTwistSurface::fAxis, G4VTwistSurface::fAxisMax, G4VTwistSurface::fAxisMin, fDPhi, G4VTwistSurface::fHandedness, fInside, G4VTwistSurface::fIsValidNorm, fKappa, fR0, fR02, fTan2Stereo, fTanStereo, G4VTwistSurface::fTrans, G4TwistTubsHypeSide::Insidetype::gp, G4TwistTubsHypeSide::Insidetype::inside, kInfinity, kOutside, kPhi, kZAxis, CLHEP::Hep3Vector::set(), SetBoundaries(), and SetCorners().

~G4TwistTubsHypeSide()

G4TwistTubsHypeSide::~G4TwistTubsHypeSide ( )

virtual

Definition at line 132 of file G4TwistTubsHypeSide.cc.

{
}

G4TwistTubsHypeSide() [3/3]

G4TwistTubsHypeSide::G4TwistTubsHypeSide

(

__void__ &

a

)

Definition at line 123 of file G4TwistTubsHypeSide.cc.

  : G4VTwistSurface(a), fKappa(0.), fTanStereo(0.), fTan2Stereo(0.),
    fR0(0.), fR02(0.), fDPhi(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 GetAreaCodeInPhi().

ComputeGlobalDirection()

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

inlineinherited

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

ComputeGlobalPoint()

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

inlineinherited

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

ComputeLocalDirection()

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

inlineinherited

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

ComputeLocalPoint()

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

inlineinherited

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

DistanceToPlane() [2/2]

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

inlineinherited

DistanceToPlaneWithV()

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

inlineinherited

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

DistanceToSurface() [1/2]

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

virtual

Implements G4VTwistSurface.

Definition at line 251 of file G4TwistTubsHypeSide.cc.

{
   // Decide if and where a line intersects with a hyperbolic
   // surface (of infinite extent)
   //
   // Arguments:
   //     p       - (in) Point on trajectory
   //     v       - (in) Vector along trajectory
   //     r2      - (in) Square of radius at z = 0
   //     tan2phi - (in) std::tan(stereo)**2
   //     s       - (out) Up to two points of intersection, where the
   //                     intersection point is p + s*v, and if there are
   //                     two intersections, s[0] < s[1]. May be negative.
   // Returns:
   //     The number of intersections. If 0, the trajectory misses.
   //
   //
   // Equation of a line:
   //
   //       x = x0 + s*tx      y = y0 + s*ty      z = z0 + s*tz
   //
   // Equation of a hyperbolic surface:
   //
   //       x**2 + y**2 = r**2 + (z*tanPhi)**2
   //
   // Solution is quadratic:
   //
   //  a*s**2 + b*s + c = 0
   //
   // where:
   //
   //  a = tx**2 + ty**2 - (tz*tanPhi)**2
   //
   //  b = 2*( x0*tx + y0*ty - z0*tz*tanPhi**2 )
   //
   //  c = x0**2 + y0**2 - r**2 - (z0*tanPhi)**2
   //
      
   fCurStatWithV.ResetfDone(validate, &gp, &gv);
 
   if (fCurStatWithV.IsDone())
   {
      for (G4int i=0; i<fCurStatWithV.GetNXX(); ++i)
      {
         gxx[i] = fCurStatWithV.GetXX(i);
         distance[i] = fCurStatWithV.GetDistance(i);
         areacode[i] = fCurStatWithV.GetAreacode(i);
         isvalid[i]  = fCurStatWithV.IsValid(i);
      }
      return fCurStatWithV.GetNXX();
   }
   else   // initialize
   {
      for (auto i=0; i<2; ++i)
      {
         distance[i] = kInfinity;
         areacode[i] = sOutside;
         isvalid[i]  = false;
         gxx[i].set(kInfinity, kInfinity, kInfinity);
      }
   }
   
   G4ThreeVector p = ComputeLocalPoint(gp);
   G4ThreeVector v = ComputeLocalDirection(gv);
   G4ThreeVector xx[2]; 
   
   //
   // special case!  p is on origin.
   // 
 
   if (p.mag() == 0)
   {
      // p is origin. 
      // unique solution of 2-dimension question in r-z plane 
      // Equations:
      //    r^2 = fR02 + z^2*fTan2Stere0
      //    r = beta*z
      //        where 
      //        beta = vrho / vz
      // Solution (z value of intersection point):
      //    xxz = +- std::sqrt (fR02 / (beta^2 - fTan2Stereo))
      //
 
      G4double vz    = v.z();
      G4double absvz = std::fabs(vz);
      G4double vrho  = v.getRho();       
      G4double vslope = vrho/vz;
      G4double vslope2 = vslope * vslope;
      if (vrho == 0 || (vrho/absvz) <= (absvz*std::fabs(fTanStereo)/absvz))
      {
         // vz/vrho is bigger than slope of asymptonic line
         distance[0] = kInfinity;
         fCurStatWithV.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
                                        isvalid[0], 0, validate, &gp, &gv);
         return 0;
      }
       
      if (vz)
      { 
         G4double xxz  = std::sqrt(fR02 / (vslope2 - fTan2Stereo)) 
                        * (vz / std::fabs(vz)) ;
         G4double t = xxz / vz;
         xx[0].set(t*v.x(), t*v.y(), xxz);
      }
      else
      {
         // p.z = 0 && v.z =0
         xx[0].set(v.x()*fR0, v.y()*fR0, 0);  // v is a unit vector.
      }
      distance[0] = xx[0].mag();
      gxx[0]      = ComputeGlobalPoint(xx[0]);
 
      if (validate == kValidateWithTol)
      {
         areacode[0] = GetAreaCode(xx[0]);
         if (!IsOutside(areacode[0]))
         {
            if (distance[0] >= 0) isvalid[0] = true;
         }
      }
      else if (validate == kValidateWithoutTol)
      {
         areacode[0] = GetAreaCode(xx[0], false);
         if (IsInside(areacode[0]))
         {
            if (distance[0] >= 0) isvalid[0] = true;
         }
      }
      else  // kDontValidate                       
      {
         areacode[0] = sInside;
            if (distance[0] >= 0) isvalid[0] = true;
      }
                 
      fCurStatWithV.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
                                     isvalid[0], 1, validate, &gp, &gv);
      return 1;
   }
 
   //
   // special case end.
   // 
 
   G4double a = v.x()*v.x() + v.y()*v.y() - v.z()*v.z()*fTan2Stereo;
   G4double b = 2.0
              * ( p.x() * v.x() + p.y() * v.y() - p.z() * v.z() * fTan2Stereo );
   G4double c = p.x()*p.x() + p.y()*p.y() - fR02 - p.z()*p.z()*fTan2Stereo;
   G4double D = b*b - 4*a*c;          //discriminant
   G4int vout = 0;
   
   if (std::fabs(a) < DBL_MIN)
   {
      if (std::fabs(b) > DBL_MIN)            // single solution
      {
         distance[0] = -c/b;
         xx[0] = p + distance[0]*v;
         gxx[0] = ComputeGlobalPoint(xx[0]);
 
         if (validate == kValidateWithTol)
         {
            areacode[0] = GetAreaCode(xx[0]);
            if (!IsOutside(areacode[0]))
            {
               if (distance[0] >= 0) isvalid[0] = true;
            }
         }
         else if (validate == kValidateWithoutTol)
         {
            areacode[0] = GetAreaCode(xx[0], false);
            if (IsInside(areacode[0]))
            {
               if (distance[0] >= 0) isvalid[0] = true;
            }
         }
         else  // kDontValidate                       
         {
            areacode[0] = sInside;
               if (distance[0] >= 0) isvalid[0] = true;
         }
                 
         fCurStatWithV.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
                                        isvalid[0], 1, validate, &gp, &gv);
         vout = 1;
      }
      else
      {
        // if a=b=0 and c != 0, p is origin and v is parallel to asymptotic line
        // if a=b=c=0, p is on surface and v is paralell to stereo wire.
        // return distance = infinity
 
         fCurStatWithV.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
                                        isvalid[0], 0, validate, &gp, &gv);
         vout = 0;
      }
   }
   else if (D > DBL_MIN)          // double solutions
   {
      D = std::sqrt(D);
      G4double      factor = 0.5/a;
      G4double      tmpdist[2] = {kInfinity, kInfinity};
      G4ThreeVector tmpxx[2] ;
      G4int         tmpareacode[2] = {sOutside, sOutside};
      G4bool        tmpisvalid[2]  = {false, false};
 
      for (auto i=0; i<2; ++i)
      {
         tmpdist[i] = factor*(-b - D);
         D = -D;
         tmpxx[i] = p + tmpdist[i]*v;
        
         if (validate == kValidateWithTol)
         {
            tmpareacode[i] = GetAreaCode(tmpxx[i]);
            if (!IsOutside(tmpareacode[i]))
            {
               if (tmpdist[i] >= 0) tmpisvalid[i] = true;
               continue;
            }
         }
         else if (validate == kValidateWithoutTol)
         {
            tmpareacode[i] = GetAreaCode(tmpxx[i], false);
            if (IsInside(tmpareacode[i]))
            {
               if (tmpdist[i] >= 0) tmpisvalid[i] = true;
               continue;
            }
         }
         else  // kDontValidate
         {
            tmpareacode[i] = sInside;
               if (tmpdist[i] >= 0) tmpisvalid[i] = true;
            continue;
         }
      }      
 
      if (tmpdist[0] <= tmpdist[1])
      {
          distance[0] = tmpdist[0];
          distance[1] = tmpdist[1];
          xx[0]       = tmpxx[0];
          xx[1]       = tmpxx[1];
          gxx[0]      = ComputeGlobalPoint(tmpxx[0]);
          gxx[1]      = ComputeGlobalPoint(tmpxx[1]);
          areacode[0] = tmpareacode[0];
          areacode[1] = tmpareacode[1];
          isvalid[0]  = tmpisvalid[0];
          isvalid[1]  = tmpisvalid[1];
      }
      else
      {
          distance[0] = tmpdist[1];
          distance[1] = tmpdist[0];
          xx[0]       = tmpxx[1];
          xx[1]       = tmpxx[0];
          gxx[0]      = ComputeGlobalPoint(tmpxx[1]);
          gxx[1]      = ComputeGlobalPoint(tmpxx[0]);
          areacode[0] = tmpareacode[1];
          areacode[1] = tmpareacode[0];
          isvalid[0]  = tmpisvalid[1];
          isvalid[1]  = tmpisvalid[0];
      }
         
      fCurStatWithV.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
                                     isvalid[0], 2, validate, &gp, &gv);
      fCurStatWithV.SetCurrentStatus(1, gxx[1], distance[1], areacode[1],
                                     isvalid[1], 2, validate, &gp, &gv);
      vout = 2;
   }
   else
   {
      // if D<0, no solution
      // if D=0, just grazing the surfaces, return kInfinity
 
      fCurStatWithV.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
                                     isvalid[0], 0, validate, &gp, &gv);
      vout = 0;
   }
   return vout;
}

References G4VTwistSurface::ComputeGlobalPoint(), G4VTwistSurface::ComputeLocalDirection(), G4VTwistSurface::ComputeLocalPoint(), D(), DBL_MIN, G4VTwistSurface::fCurStatWithV, fR0, fR02, fTan2Stereo, fTanStereo, GetAreaCode(), G4VTwistSurface::CurrentStatus::GetAreacode(), G4VTwistSurface::CurrentStatus::GetDistance(), G4VTwistSurface::CurrentStatus::GetNXX(), CLHEP::Hep3Vector::getRho(), G4VTwistSurface::CurrentStatus::GetXX(), G4VTwistSurface::CurrentStatus::IsDone(), G4VTwistSurface::IsInside(), G4VTwistSurface::IsOutside(), G4VTwistSurface::CurrentStatus::IsValid(), kInfinity, G4VTwistSurface::kValidateWithoutTol, G4VTwistSurface::kValidateWithTol, CLHEP::Hep3Vector::mag(), G4VTwistSurface::CurrentStatus::ResetfDone(), CLHEP::Hep3Vector::set(), G4VTwistSurface::CurrentStatus::SetCurrentStatus(), G4VTwistSurface::sInside, G4VTwistSurface::sOutside, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

DistanceToSurface() [2/2]

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

virtual

Implements G4VTwistSurface.

Definition at line 541 of file G4TwistTubsHypeSide.cc.

{
    // Find the approximate distance of a point of a hyperbolic surface.
    // The distance must be an underestimate. 
    // It will also be nice (although not necessary) that the estimate is
    // always finite no matter how close the point is.
    //
    // We arranged G4Hype::ApproxDistOutside and G4Hype::ApproxDistInside
    // for this function. See these discriptions.
    
   const G4double halftol
     = 0.5 * G4GeometryTolerance::GetInstance()->GetRadialTolerance();
 
   fCurStat.ResetfDone(kDontValidate, &gp);
 
   if (fCurStat.IsDone())
   {
      for (G4int i=0; i<fCurStat.GetNXX(); ++i)
      {
         gxx[i] = fCurStat.GetXX(i);
         distance[i] = fCurStat.GetDistance(i);
         areacode[i] = fCurStat.GetAreacode(i);
      }
      return fCurStat.GetNXX();
   }
   else  // initialize
   {
      for (auto i=0; i<2; ++i)
      {
         distance[i] = kInfinity;
         areacode[i] = sOutside;
         gxx[i].set(kInfinity, kInfinity, kInfinity);
      }
   }
   
 
   G4ThreeVector p = ComputeLocalPoint(gp);
   G4ThreeVector xx;
 
   //
   // special case!
   // If p is on surface, return distance = 0 immediatery .
   //
   G4ThreeVector  lastgxx[2];
   for (auto i=0; i<2; ++i)
   {
      lastgxx[i] = fCurStatWithV.GetXX(i);
   }
 
   if ((gp - lastgxx[0]).mag() < halftol || (gp - lastgxx[1]).mag() < halftol)
   {
      // last winner, or last poststep point is on the surface.
      xx = p;             
      gxx[0] = gp;
      distance[0] = 0;      
 
      G4bool isvalid = true;
      fCurStat.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
                                isvalid, 1, kDontValidate, &gp);
 
      return 1;
   }
   //
   // special case end
   //
       
   G4double prho       = p.getRho();
   G4double pz         = std::fabs(p.z());           // use symmetry
   G4double r1         = std::sqrt(fR02 + pz * pz * fTan2Stereo);
   
   G4ThreeVector pabsz(p.x(), p.y(), pz);
    
   if (prho > r1 + halftol)   // p is outside of Hyperbolic surface
   {
      // First point xx1
      G4double t = r1 / prho;
      G4ThreeVector xx1(t * pabsz.x(), t * pabsz.y() , pz);
      
      // Second point xx2
      G4double z2 = (prho * fTanStereo + pz) / (1 + fTan2Stereo);
      G4double r2 = std::sqrt(fR02 + z2 * z2 * fTan2Stereo);
      t = r2 / prho;
      G4ThreeVector xx2(t * pabsz.x(), t * pabsz.y() , z2);
            
      G4double len = (xx2 - xx1).mag();
      if (len < DBL_MIN)
      {
         // xx2 = xx1?? I guess we
         // must have really bracketed the normal
         distance[0] = (pabsz - xx1).mag();
         xx = xx1;
      }
      else
      {
         distance[0] = DistanceToLine(pabsz, xx1, (xx2 - xx1) , xx);
      }
      
   }
   else if (prho < r1 - halftol)  // p is inside of Hyperbolic surface.
   {
      // First point xx1
      G4double t;
      G4ThreeVector xx1;
      if (prho < DBL_MIN)
      {
         xx1.set(r1, 0. , pz);
      }
      else
      {
         t = r1 / prho;
         xx1.set(t * pabsz.x(), t * pabsz.y() , pz);
      }
      
      // dr, dz is tangential vector of Hyparbolic surface at xx1
      // dr = r, dz = z*tan2stereo
      G4double dr  = pz * fTan2Stereo;
      G4double dz  = r1;
      G4double tanbeta   = dr / dz;
      G4double pztanbeta = pz * tanbeta;
      
      // Second point xx2 
      // xx2 is intersection between x-axis and tangential vector
      G4double r2 = r1 - pztanbeta;
      G4ThreeVector xx2;
      if (prho < DBL_MIN)
      {
         xx2.set(r2, 0. , 0.);
      }
      else
      {
         t  = r2 / prho;
         xx2.set(t * pabsz.x(), t * pabsz.y() , 0.);
      }
      
      G4ThreeVector d = xx2 - xx1;
      distance[0] = DistanceToLine(pabsz, xx1, d, xx);
          
   }
   else   // p is on Hyperbolic surface.
   {
      distance[0] = 0;
      xx.set(p.x(), p.y(), pz);
   }
 
   if (p.z() < 0)
   {
      G4ThreeVector tmpxx(xx.x(), xx.y(), -xx.z());
      xx = tmpxx;
   }
       
   gxx[0] = ComputeGlobalPoint(xx);
   areacode[0]    = sInside;
   G4bool isvalid = true;
   fCurStat.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
                             isvalid, 1, kDontValidate, &gp);
   return 1;
}

References G4VTwistSurface::ComputeGlobalPoint(), G4VTwistSurface::ComputeLocalPoint(), DBL_MIN, G4VTwistSurface::DistanceToLine(), G4VTwistSurface::fCurStat, G4VTwistSurface::fCurStatWithV, fR02, fTan2Stereo, fTanStereo, G4VTwistSurface::CurrentStatus::GetAreacode(), G4VTwistSurface::CurrentStatus::GetDistance(), G4GeometryTolerance::GetInstance(), G4VTwistSurface::CurrentStatus::GetNXX(), G4GeometryTolerance::GetRadialTolerance(), CLHEP::Hep3Vector::getRho(), G4VTwistSurface::CurrentStatus::GetXX(), G4VTwistSurface::CurrentStatus::IsDone(), G4VTwistSurface::kDontValidate, kInfinity, G4VTwistSurface::CurrentStatus::ResetfDone(), CLHEP::Hep3Vector::set(), G4VTwistSurface::CurrentStatus::SetCurrentStatus(), G4VTwistSurface::sInside, G4VTwistSurface::sOutside, CLHEP::Hep3Vector::x(), CLHEP::Hep3Vector::y(), and CLHEP::Hep3Vector::z().

GetAreaCode()

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

privatevirtual

Implements G4VTwistSurface.

Definition at line 705 of file G4TwistTubsHypeSide.cc.

{
   const G4double ctol = 0.5 * kCarTolerance;
   G4int areacode = sInside;
 
   if ((fAxis[0] == kPhi && fAxis[1] == kZAxis))
   {
      G4int zaxis   = 1;
      
      if (withTol)
      {
         G4bool isoutside      = false;
         G4int  phiareacode    = GetAreaCodeInPhi(xx);
         G4bool isoutsideinphi = IsOutside(phiareacode);
 
         // test boundary of phiaxis
 
         if ((phiareacode & sAxisMin) == sAxisMin)
         {
            areacode |= (sAxis0 & (sAxisPhi | sAxisMin)) | sBoundary;
            if (isoutsideinphi) isoutside = true;
         }
         else if ((phiareacode & sAxisMax)  == sAxisMax)
         {
            areacode |= (sAxis0 & (sAxisPhi | sAxisMax)) | sBoundary;
            if (isoutsideinphi) isoutside = true;
         }
 
         // test boundary of zaxis
 
         if (xx.z() < fAxisMin[zaxis] + ctol)
         {
            areacode |= (sAxis1 & (sAxisZ | sAxisMin));
            if   (areacode & sBoundary) areacode |= sCorner;  // xx is on corner.
            else                        areacode |= sBoundary;
 
            if (xx.z() <= fAxisMin[zaxis] - ctol) isoutside = true;
 
         }
         else if (xx.z() > fAxisMax[zaxis] - ctol)
         {
            areacode |= (sAxis1 & (sAxisZ | sAxisMax));
            if   (areacode & sBoundary) areacode |= sCorner;  // xx is on corner.
            else                        areacode |= sBoundary;
 
            if (xx.z() >= fAxisMax[zaxis] + ctol) isoutside = true;
         }
 
         // if isoutside = true, clear sInside bit.
         // if not on boundary, add boundary information. 
 
         if (isoutside)
         {
            G4int tmpareacode = areacode & (~sInside);
            areacode = tmpareacode;
         }
         else if ((areacode & sBoundary) != sBoundary)
         {
            areacode |= (sAxis0 & sAxisPhi) | (sAxis1 & sAxisZ);
         }
 
         return areacode;
      }
      else
      {
         G4int phiareacode = GetAreaCodeInPhi(xx, false);
         
         // test boundary of z-axis
 
         if (xx.z() < fAxisMin[zaxis])
         {
            areacode |= (sAxis1 & (sAxisZ | sAxisMin)) | sBoundary;
 
         }
         else if (xx.z() > fAxisMax[zaxis])
         {
            areacode |= (sAxis1 & (sAxisZ | sAxisMax)) | sBoundary;
         }
 
         // boundary of phi-axis
 
         if (phiareacode == sAxisMin)
         {
            areacode |= (sAxis0 & (sAxisPhi | sAxisMin));
            if   (areacode & sBoundary) areacode |= sCorner;  // xx is on corner.
            else                        areacode |= sBoundary; 
             
         }
         else if (phiareacode == sAxisMax)
         {
            areacode |= (sAxis0 & (sAxisPhi | sAxisMax));
            if   (areacode & sBoundary) areacode |= sCorner;  // xx is on corner.
            else                        areacode |= sBoundary;
         }
 
         // if not on boundary, add boundary information. 
 
         if ((areacode & sBoundary) != sBoundary)
         {
            areacode |= (sAxis0 & sAxisPhi) | (sAxis1 & sAxisZ);
         }
         return areacode;
      }
   }
   else
   {
      std::ostringstream message;
      message << "Feature NOT implemented !" << G4endl
              << "        fAxis[0] = " << fAxis[0] << G4endl
              << "        fAxis[1] = " << fAxis[1];
      G4Exception("G4TwistTubsHypeSide::GetAreaCode()",
                  "GeomSolids0001", FatalException, message);
   }
   return areacode;
}

References FatalException, G4VTwistSurface::fAxis, G4VTwistSurface::fAxisMax, G4VTwistSurface::fAxisMin, G4endl, G4Exception(), GetAreaCodeInPhi(), G4VTwistSurface::IsOutside(), G4VTwistSurface::kCarTolerance, kPhi, kZAxis, G4VTwistSurface::sAxis0, G4VTwistSurface::sAxis1, G4VTwistSurface::sAxisMax, G4VTwistSurface::sAxisMin, G4VTwistSurface::sAxisPhi, G4VTwistSurface::sAxisZ, G4VTwistSurface::sBoundary, G4VTwistSurface::sCorner, G4VTwistSurface::sInside, and CLHEP::Hep3Vector::z().

Referenced by DistanceToSurface(), and Inside().

GetAreaCodeInPhi()

G4int G4TwistTubsHypeSide::GetAreaCodeInPhi ( const G4ThreeVector &  xx, G4bool  withTol = true  )

privatevirtual

Definition at line 825 of file G4TwistTubsHypeSide.cc.

{
   
   G4ThreeVector lowerlimit; // lower phi-boundary limit at z = xx.z()
   G4ThreeVector upperlimit; // upper phi-boundary limit at z = xx.z()
   lowerlimit = GetBoundaryAtPZ(sAxis0 & sAxisMin, xx);
   upperlimit = GetBoundaryAtPZ(sAxis0 & sAxisMax, xx);
 
   G4int  areacode  = sInside;
   G4bool isoutside = false; 
   
   if (withTol)
   {
      if (AmIOnLeftSide(xx, lowerlimit) >= 0)       // xx is on lowerlimit
      {
         areacode |= (sAxisMin | sBoundary);
         if (AmIOnLeftSide(xx, lowerlimit) > 0) isoutside = true; 
 
      }
      else if (AmIOnLeftSide(xx, upperlimit) <= 0)  // xx is on upperlimit
      {
         areacode |= (sAxisMax | sBoundary);
         if (AmIOnLeftSide(xx, upperlimit) < 0) isoutside = true; 
      }
 
      // if isoutside = true, clear inside bit.
 
      if (isoutside)
      {
         G4int tmpareacode = areacode & (~sInside);
         areacode = tmpareacode;
      }
   }
   else
   {
      if (AmIOnLeftSide(xx, lowerlimit, false) >= 0)
      {
         areacode |= (sAxisMin | sBoundary);
      }
      else if (AmIOnLeftSide(xx, upperlimit, false) <= 0)
      {
         areacode |= (sAxisMax | sBoundary);
      }
   }
 
   return areacode;
}

References G4VTwistSurface::AmIOnLeftSide(), G4VTwistSurface::GetBoundaryAtPZ(), G4VTwistSurface::sAxis0, G4VTwistSurface::sAxisMax, G4VTwistSurface::sAxisMin, G4VTwistSurface::sBoundary, and G4VTwistSurface::sInside.

Referenced by GetAreaCode().

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(), GetAreaCodeInPhi(), GetBoundaryMax(), and 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 G4TwistTubsHypeSide::GetBoundaryMax ( G4double  phi )

inlinevirtual

Implements G4VTwistSurface.

Definition at line 182 of file G4TwistTubsHypeSide.hh.

{
  G4ThreeVector ptmp(0,0,z) ;  // temporary point with z Komponent only
  G4ThreeVector upperlimit;    // upper phi-boundary limit at z = ptmp.z()
  upperlimit = GetBoundaryAtPZ(sAxis0 & sAxisMax, ptmp);
  return   std::atan2( upperlimit.y(), upperlimit.x() ) ;
}

References G4VTwistSurface::GetBoundaryAtPZ(), G4VTwistSurface::sAxis0, G4VTwistSurface::sAxisMax, CLHEP::Hep3Vector::x(), and CLHEP::Hep3Vector::y().

Referenced by GetFacets().

GetBoundaryMin()

G4double G4TwistTubsHypeSide::GetBoundaryMin ( G4double  phi )

inlinevirtual

Implements G4VTwistSurface.

Definition at line 173 of file G4TwistTubsHypeSide.hh.

{
  G4ThreeVector ptmp(0,0,z) ;  // temporary point with z Komponent only
  G4ThreeVector lowerlimit;    // lower phi-boundary limit at z = ptmp.z()
  lowerlimit = GetBoundaryAtPZ(sAxis0 & sAxisMin, ptmp);
  return  std::atan2( lowerlimit.y(), lowerlimit.x() ) ;  
}

References G4VTwistSurface::GetBoundaryAtPZ(), G4VTwistSurface::sAxis0, G4VTwistSurface::sAxisMin, CLHEP::Hep3Vector::x(), and CLHEP::Hep3Vector::y().

Referenced by GetFacets().

GetBoundaryParameters()

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

virtualinherited

Definition at line 668 of file G4VTwistSurface.cc.

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

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

Referenced by G4VTwistSurface::DistanceToBoundary(), 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(), G4TwistTrapAlphaSide::SetBoundaries(), G4TwistTrapFlatSide::SetBoundaries(), G4TwistTrapParallelSide::SetBoundaries(), G4TwistTubsFlatSide::SetBoundaries(), 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(), G4TwistTrapAlphaSide::GetFacets(), G4TwistTrapFlatSide::GetFacets(), G4TwistTrapParallelSide::GetFacets(), G4TwistTubsFlatSide::GetFacets(), 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(), G4TwistTrapAlphaSide::GetFacets(), G4TwistTrapFlatSide::GetFacets(), G4TwistTrapParallelSide::GetFacets(), G4TwistTubsFlatSide::GetFacets(), GetFacets(), and G4TwistTubsSide::GetFacets().

GetFacets()

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

virtual

Implements G4VTwistSurface.

Definition at line 996 of file G4TwistTubsHypeSide.cc.

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

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

GetName()

virtual G4String G4VTwistSurface::GetName ( ) const

inlinevirtualinherited

Definition at line 107 of file G4VTwistSurface.hh.

{ return fName; }

References G4VTwistSurface::fName.

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

GetNeighbours() [1/2]

G4VTwistSurface ** G4VTwistSurface::GetNeighbours ( )

inlineprotectedinherited

Definition at line 183 of file G4VTwistSurface.hh.

{ return fNeighbours; } 

References G4VTwistSurface::fNeighbours.

Referenced by G4VTwistSurface::DistanceToIn().

GetNeighbours() [2/2]

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

inlineprotectedinherited

GetNode()

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

inherited

Definition at line 952 of file G4VTwistSurface.cc.

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

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

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

GetNormal()

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

virtual

Implements G4VTwistSurface.

Definition at line 139 of file G4TwistTubsHypeSide.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;
      }
   }
   
   fCurrentNormal.p = xx;
 
   G4ThreeVector normal( xx.x(), xx.y(), -xx.z() * fTan2Stereo);
   normal *= fHandedness;
   normal = normal.unit();
 
   if (isGlobal)
   {
      fCurrentNormal.normal = ComputeLocalDirection(normal);
   }
   else
   {
      fCurrentNormal.normal = normal;
   }
   return fCurrentNormal.normal;
}

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

GetRhoAtPZ()

G4double G4TwistTubsHypeSide::GetRhoAtPZ ( const G4ThreeVector &  p, G4bool  isglobal = false  ) const

inlinevirtual

Definition at line 149 of file G4TwistTubsHypeSide.hh.

{
  // Get Rho at p.z() on Hyperbolic Surface.
  G4ThreeVector tmpp;
  if (isglobal) { tmpp = fRot.inverse()*p - fTrans; }
  else          { tmpp = p; }
 
  return std::sqrt(fR02 + tmpp.z() * tmpp.z() * fTan2Stereo); 
}

References fR02, G4VTwistSurface::fRot, fTan2Stereo, G4VTwistSurface::fTrans, CLHEP::HepRotation::inverse(), and CLHEP::Hep3Vector::z().

Referenced by Inside().

GetSurfaceArea()

G4double G4TwistTubsHypeSide::GetSurfaceArea ( )

inlinevirtual

Implements G4VTwistSurface.

Definition at line 191 of file G4TwistTubsHypeSide.hh.

{
  // approximation with tube surface
 
  return ( fAxisMax[1] - fAxisMin[1] ) * fR0 * fDPhi ;
}

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

Inside()

EInside G4TwistTubsHypeSide::Inside ( const G4ThreeVector &  gp )

virtual

Definition at line 184 of file G4TwistTubsHypeSide.cc.

{
   // Inside returns 
   const G4double halftol
     = 0.5 * G4GeometryTolerance::GetInstance()->GetRadialTolerance();
 
   if (fInside.gp == gp)
   {
      return fInside.inside;
   }
   fInside.gp = gp;
   
   G4ThreeVector p = ComputeLocalPoint(gp);
  
 
   if (p.mag() < DBL_MIN)
   {
      fInside.inside = kOutside;
      return fInside.inside;
   }
   
   G4double rhohype = GetRhoAtPZ(p);
   G4double distanceToOut = fHandedness * (rhohype - p.getRho());
                            // +ve : inside
 
   if (distanceToOut < -halftol)
   {
     fInside.inside = kOutside;
   }
   else
   {
      G4int areacode = GetAreaCode(p);
      if (IsOutside(areacode))
      {
         fInside.inside = kOutside;
      }
      else if (IsBoundary(areacode))
      {
         fInside.inside = kSurface;
      }
      else if (IsInside(areacode))
      {
         if (distanceToOut <= halftol)
         {
            fInside.inside = kSurface;
         }
         else
         {
            fInside.inside = kInside;
         }
      }
      else
      {
         G4cout << "WARNING - G4TwistTubsHypeSide::Inside()" << G4endl
                << "          Invalid option !" << G4endl
                << "          name, areacode, distanceToOut = "
                << GetName() << ", " << std::hex << areacode
                << std::dec << ", " << distanceToOut << G4endl;
      }
   }
 
   return fInside.inside; 
}

References G4VTwistSurface::ComputeLocalPoint(), DBL_MIN, G4VTwistSurface::fHandedness, fInside, G4cout, G4endl, GetAreaCode(), G4GeometryTolerance::GetInstance(), G4VTwistSurface::GetName(), G4GeometryTolerance::GetRadialTolerance(), CLHEP::Hep3Vector::getRho(), GetRhoAtPZ(), G4TwistTubsHypeSide::Insidetype::gp, G4TwistTubsHypeSide::Insidetype::inside, G4VTwistSurface::IsBoundary(), G4VTwistSurface::IsInside(), G4VTwistSurface::IsOutside(), kInside, kOutside, kSurface, and CLHEP::Hep3Vector::mag().

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 Inside(), and G4VTwistSurface::IsSameBoundary().

IsCorner()

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

inlineinherited

Referenced by G4VTwistSurface::IsSameBoundary().

IsInside()

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

inlineinherited

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

IsOutside()

G4bool G4VTwistSurface::IsOutside ( G4int  areacode ) const

inlineinherited

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

{ return fIsValidNorm; }

References G4VTwistSurface::fIsValidNorm.

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

SetAxis()

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

inlineinherited

Definition at line 156 of file G4VTwistSurface.hh.

{ fAxis[i] = axis; }

References G4VTwistSurface::fAxis.

SetBoundaries()

void G4TwistTubsHypeSide::SetBoundaries ( )

privatevirtual

Implements G4VTwistSurface.

Definition at line 949 of file G4TwistTubsHypeSide.cc.

{
   // Set direction-unit vector of phi-boundary-lines in local coodinate.
   // sAxis0 must be kPhi.
   // This fanction set lower phi-boundary and upper phi-boundary.
 
   if (fAxis[0] == kPhi && fAxis[1] == kZAxis)
   {
      G4ThreeVector direction;
      // sAxis0 & sAxisMin
      direction = GetCorner(sC0Min1Max) - GetCorner(sC0Min1Min);
      direction = direction.unit();
      SetBoundary(sAxis0 & (sAxisPhi | sAxisMin), direction, 
                   GetCorner(sC0Min1Min), sAxisZ);
 
      // sAxis0 & sAxisMax
      direction = GetCorner(sC0Max1Max) - GetCorner(sC0Max1Min);
      direction = direction.unit();
      SetBoundary(sAxis0 & (sAxisPhi | sAxisMax), direction, 
                  GetCorner(sC0Max1Min), sAxisZ);
 
      // sAxis1 & sAxisMin
      direction = GetCorner(sC0Max1Min) - GetCorner(sC0Min1Min);
      direction = direction.unit();
      SetBoundary(sAxis1 & (sAxisZ | sAxisMin), direction, 
                   GetCorner(sC0Min1Min), sAxisPhi);
 
      // sAxis1 & sAxisMax
      direction = GetCorner(sC0Max1Max) - GetCorner(sC0Min1Max);
      direction = direction.unit();
      SetBoundary(sAxis1 & (sAxisZ | sAxisMax), direction, 
                  GetCorner(sC0Min1Max), sAxisPhi);
   }
   else
   {
      std::ostringstream message;
      message << "Feature NOT implemented !" << G4endl
              << "        fAxis[0] = " << fAxis[0] << G4endl
              << "        fAxis[1] = " << fAxis[1];
      G4Exception("G4TwistTubsHypeSide::SetBoundaries()",
                  "GeomSolids0001", FatalException, message);
   }
}

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

Referenced by G4TwistTubsHypeSide().

SetBoundary()

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

protectedvirtualinherited

Definition at line 863 of file G4VTwistSurface.cc.

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

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

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

SetCorners() [1/2]

void G4TwistTubsHypeSide::SetCorners ( )

privatevirtual

Implements G4VTwistSurface.

Definition at line 939 of file G4TwistTubsHypeSide.cc.

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

References FatalException, and G4Exception().

Referenced by G4TwistTubsHypeSide().

SetCorners() [2/2]

void G4TwistTubsHypeSide::SetCorners ( G4double  EndInnerRadius[2], G4double  EndOuterRadius[2], G4double  DPhi, G4double  EndPhi[2], G4double  EndZ[2]  )

privatevirtual

Definition at line 877 of file G4TwistTubsHypeSide.cc.

{
   // Set Corner points in local coodinate.
 
   if (fAxis[0] == kPhi && fAxis[1] == kZAxis) {
 
      G4double endRad[2];
      G4double halfdphi = 0.5*DPhi;
      
      for (auto i=0; i<2; ++i) // i=0,1 : -ve z, +ve z
      {
        endRad[i] = (fHandedness == 1 ? EndOuterRadius[i] : EndInnerRadius[i]);
      }
 
      G4int zmin = 0 ;  // at -ve z
      G4int zmax = 1 ;  // at +ve z
 
      G4double x, y, z;
      
      // corner of Axis0min and Axis1min
      x = endRad[zmin]*std::cos(endPhi[zmin] - halfdphi);
      y = endRad[zmin]*std::sin(endPhi[zmin] - halfdphi);
      z = endZ[zmin];
      SetCorner(sC0Min1Min, x, y, z);
      
      // corner of Axis0max and Axis1min
      x = endRad[zmin]*std::cos(endPhi[zmin] + halfdphi);
      y = endRad[zmin]*std::sin(endPhi[zmin] + halfdphi);
      z = endZ[zmin];
      SetCorner(sC0Max1Min, x, y, z);
      
      // corner of Axis0max and Axis1max
      x = endRad[zmax]*std::cos(endPhi[zmax] + halfdphi);
      y = endRad[zmax]*std::sin(endPhi[zmax] + halfdphi);
      z = endZ[zmax];
      SetCorner(sC0Max1Max, x, y, z);
      
      // corner of Axis0min and Axis1max
      x = endRad[zmax]*std::cos(endPhi[zmax] - halfdphi);
      y = endRad[zmax]*std::sin(endPhi[zmax] - halfdphi);
      z = endZ[zmax];
      SetCorner(sC0Min1Max, x, y, z);
 
   }
   else
   {
      std::ostringstream message;
      message << "Feature NOT implemented !" << G4endl
              << "        fAxis[0] = " << fAxis[0] << G4endl
              << "        fAxis[1] = " << fAxis[1];
      G4Exception("G4TwistTubsHypeSide::SetCorners()",
                  "GeomSolids0001", FatalException, message);
   }
}

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

SetNeighbours()

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

inlineinherited

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

SurfacePoint()

G4ThreeVector G4TwistTubsHypeSide::SurfacePoint ( G4double  phi, G4double  z, G4bool  isGlobal = false  )

inlinevirtual

Implements G4VTwistSurface.

Definition at line 161 of file G4TwistTubsHypeSide.hh.

{
  G4double rho = std::sqrt(fR02 + z * z * fTan2Stereo) ;
 
  G4ThreeVector SurfPoint (rho*std::cos(phi), rho*std::sin(phi), z) ;
 
  if (isGlobal) { return (fRot * SurfPoint + fTrans); }
  return SurfPoint;
}

References fR02, G4VTwistSurface::fRot, fTan2Stereo, and G4VTwistSurface::fTrans.

Referenced by GetFacets().

Field Documentation

fAmIOnLeftSide

G4SurfSideQuery G4VTwistSurface::fAmIOnLeftSide

privateinherited

Definition at line 342 of file G4VTwistSurface.hh.

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

fAxis

EAxis G4VTwistSurface::fAxis[2]

protectedinherited

Definition at line 308 of file G4VTwistSurface.hh.

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

fAxisMax

G4double G4VTwistSurface::fAxisMax[2]

protectedinherited

Definition at line 310 of file G4VTwistSurface.hh.

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

fCurStat

CurrentStatus G4VTwistSurface::fCurStat

protectedinherited

Definition at line 312 of file G4VTwistSurface.hh.

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

fCurStatWithV

CurrentStatus G4VTwistSurface::fCurStatWithV

protectedinherited

Definition at line 311 of file G4VTwistSurface.hh.

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

fDPhi

G4double G4TwistTubsHypeSide::fDPhi

private

Definition at line 133 of file G4TwistTubsHypeSide.hh.

Referenced by G4TwistTubsHypeSide(), and GetSurfaceArea().

fHandedness

G4int G4VTwistSurface::fHandedness

protectedinherited

Definition at line 315 of file G4VTwistSurface.hh.

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

fInside

Insidetype G4TwistTubsHypeSide::fInside

private

Definition at line 141 of file G4TwistTubsHypeSide.hh.

Referenced by G4TwistTubsHypeSide(), and Inside().

fIsValidNorm

G4bool G4VTwistSurface::fIsValidNorm

protectedinherited

Definition at line 323 of file G4VTwistSurface.hh.

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

fKappa

G4double G4TwistTubsHypeSide::fKappa

private

Definition at line 128 of file G4TwistTubsHypeSide.hh.

Referenced by G4TwistTubsHypeSide().

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

fR0

G4double G4TwistTubsHypeSide::fR0

private

Definition at line 131 of file G4TwistTubsHypeSide.hh.

Referenced by DistanceToSurface(), G4TwistTubsHypeSide(), and GetSurfaceArea().

fR02

G4double G4TwistTubsHypeSide::fR02

private

Definition at line 132 of file G4TwistTubsHypeSide.hh.

Referenced by DistanceToSurface(), G4TwistTubsHypeSide(), GetRhoAtPZ(), and SurfacePoint().

fRot

G4RotationMatrix G4VTwistSurface::fRot

protectedinherited

Definition at line 313 of file G4VTwistSurface.hh.

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

fTan2Stereo

G4double G4TwistTubsHypeSide::fTan2Stereo

private

Definition at line 130 of file G4TwistTubsHypeSide.hh.

Referenced by DistanceToSurface(), G4TwistTubsHypeSide(), GetNormal(), GetRhoAtPZ(), and SurfacePoint().

fTanStereo

G4double G4TwistTubsHypeSide::fTanStereo

private

Definition at line 129 of file G4TwistTubsHypeSide.hh.

Referenced by DistanceToSurface(), and G4TwistTubsHypeSide().

fTrans

G4ThreeVector G4VTwistSurface::fTrans

protectedinherited

Definition at line 314 of file G4VTwistSurface.hh.

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

kCarTolerance

G4double G4VTwistSurface::kCarTolerance

protectedinherited

Definition at line 324 of file G4VTwistSurface.hh.

Referenced by G4TwistTubsSide::DistanceToPlane(), G4TwistBoxSide::DistanceToSurface(), G4TwistTrapAlphaSide::DistanceToSurface(), G4TwistTrapParallelSide::DistanceToSurface(), G4TwistTubsSide::DistanceToSurface(), G4TwistTrapFlatSide::DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), G4VTwistSurface::G4VTwistSurface(), G4TwistBoxSide::GetAreaCode(), G4TwistTrapAlphaSide::GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), G4TwistTrapParallelSide::GetAreaCode(), GetAreaCode(), G4TwistTubsSide::GetAreaCode(), G4TwistBoxSide::GetNormal(), G4TwistTrapAlphaSide::GetNormal(), G4TwistTrapParallelSide::GetNormal(), GetNormal(), G4TwistTubsSide::GetNormal(), and G4VTwistSurface::IsSameBoundary().

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

sAxis1

const G4int G4VTwistSurface::sAxis1 = 0x000000FF

staticinherited

Definition at line 232 of file G4VTwistSurface.hh.

Referenced by G4TwistBoxSide::GetAreaCode(), G4TwistTrapAlphaSide::GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), G4TwistTrapParallelSide::GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), GetAreaCode(), G4TwistTubsSide::GetAreaCode(), G4VTwistSurface::GetBoundaryAtPZ(), G4VTwistSurface::GetBoundaryAxis(), G4VTwistSurface::GetBoundaryLimit(), G4VTwistSurface::Boundary::GetBoundaryParameters(), G4TwistBoxSide::SetBoundaries(), G4TwistTrapAlphaSide::SetBoundaries(), G4TwistTrapFlatSide::SetBoundaries(), G4TwistTrapParallelSide::SetBoundaries(), G4TwistTubsFlatSide::SetBoundaries(), SetBoundaries(), G4TwistTubsSide::SetBoundaries(), and G4VTwistSurface::SetBoundary().

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

Definition at line 225 of file G4VTwistSurface.hh.

Referenced by G4TwistTubsSide::DistanceToSurface(), G4TwistBoxSide::GetAreaCode(), G4TwistTrapAlphaSide::GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), G4TwistTrapParallelSide::GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), GetAreaCode(), G4TwistTubsSide::GetAreaCode(), GetAreaCodeInPhi(), G4VTwistSurface::GetBoundaryLimit(), GetBoundaryMax(), G4TwistBoxSide::SetBoundaries(), G4TwistTrapAlphaSide::SetBoundaries(), G4TwistTrapFlatSide::SetBoundaries(), G4TwistTrapParallelSide::SetBoundaries(), G4TwistTubsFlatSide::SetBoundaries(), SetBoundaries(), G4TwistTubsSide::SetBoundaries(), and G4VTwistSurface::SetBoundary().

sAxisMin

const G4int G4VTwistSurface::sAxisMin = 0x00000101

staticinherited

Definition at line 224 of file G4VTwistSurface.hh.

Referenced by G4TwistTubsSide::DistanceToSurface(), G4TwistBoxSide::GetAreaCode(), G4TwistTrapAlphaSide::GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), G4TwistTrapParallelSide::GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), GetAreaCode(), G4TwistTubsSide::GetAreaCode(), GetAreaCodeInPhi(), G4VTwistSurface::GetBoundaryLimit(), GetBoundaryMin(), G4TwistBoxSide::SetBoundaries(), G4TwistTrapAlphaSide::SetBoundaries(), G4TwistTrapFlatSide::SetBoundaries(), G4TwistTrapParallelSide::SetBoundaries(), G4TwistTubsFlatSide::SetBoundaries(), SetBoundaries(), G4TwistTubsSide::SetBoundaries(), and G4VTwistSurface::SetBoundary().

sAxisPhi

const G4int G4VTwistSurface::sAxisPhi = 0x00001414

staticinherited

Definition at line 230 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::DistanceToBoundary(), G4TwistTubsFlatSide::GetAreaCode(), GetAreaCode(), G4VTwistSurface::GetBoundaryAtPZ(), G4VTwistSurface::GetBoundaryAxis(), G4TwistTubsFlatSide::SetBoundaries(), and 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(), G4TwistTrapAlphaSide::GetAreaCode(), G4TwistTrapFlatSide::GetAreaCode(), G4VTwistSurface::GetBoundaryAxis(), G4TwistBoxSide::SetBoundaries(), G4TwistTrapAlphaSide::SetBoundaries(), and G4TwistTrapFlatSide::SetBoundaries().

sAxisZ

const G4int G4VTwistSurface::sAxisZ = 0x00000C0C

staticinherited

Definition at line 228 of file G4VTwistSurface.hh.

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

sBoundary

const G4int G4VTwistSurface::sBoundary = 0x20000000

staticinherited

Definition at line 218 of file G4VTwistSurface.hh.

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

sC0Max1Max

const G4int G4VTwistSurface::sC0Max1Max = 0x40000202

staticinherited

Definition at line 222 of file G4VTwistSurface.hh.

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

sC0Max1Min

const G4int G4VTwistSurface::sC0Max1Min = 0x40000201

staticinherited

Definition at line 221 of file G4VTwistSurface.hh.

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

sC0Min1Max

const G4int G4VTwistSurface::sC0Min1Max = 0x40000102

staticinherited

Definition at line 223 of file G4VTwistSurface.hh.

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

sC0Min1Min

const G4int G4VTwistSurface::sC0Min1Min = 0x40000101

staticinherited

Definition at line 220 of file G4VTwistSurface.hh.

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

sCorner

const G4int G4VTwistSurface::sCorner = 0x40000000

staticinherited

Definition at line 219 of file G4VTwistSurface.hh.

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

sOutside

const G4int G4VTwistSurface::sOutside = 0x00000000

staticinherited

Definition at line 216 of file G4VTwistSurface.hh.

Referenced by G4VTwistSurface::CurrentStatus::CurrentStatus(), G4VTwistSurface::DistanceTo(), G4VTwistSurface::DistanceToIn(), G4VTwistSurface::DistanceToOut(), G4TwistBoxSide::DistanceToSurface(), G4TwistTrapAlphaSide::DistanceToSurface(), G4TwistTrapFlatSide::DistanceToSurface(), G4TwistTrapParallelSide::DistanceToSurface(), G4TwistTubsFlatSide::DistanceToSurface(), 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/G4TwistTubsHypeSide.hh
• source/geometry/solids/specific/src/G4TwistTubsHypeSide.cc