Geant4 11.1.1
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Classes | Public Types | Public Member Functions | Static Public Attributes | Protected Member Functions | Protected Attributes | List of all members
G4VTwistSurface Class Referenceabstract

#include <G4VTwistSurface.hh>

+ Inheritance diagram for G4VTwistSurface:

Classes

class  Boundary
 
class  CurrentStatus
 
class  G4SurfCurNormal
 

Public Types

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

Public Member Functions

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

Static Public Attributes

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

Protected Member Functions

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

Protected Attributes

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

Detailed Description

Definition at line 48 of file G4VTwistSurface.hh.

Member Enumeration Documentation

◆ EValidate

enum G4VTwistSurface::EValidate
Enumerator
kDontValidate 
kValidateWithTol 
kValidateWithoutTol 
kUninitialized 

Definition at line 52 of file G4VTwistSurface.hh.

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

Constructor & Destructor Documentation

◆ G4VTwistSurface() [1/3]

G4VTwistSurface::G4VTwistSurface ( const G4String &  name)

Definition at line 64 of file G4VTwistSurface.cc.

65 : fIsValidNorm(false), fName(name)
66{
67
68 fAxis[0] = kUndefined;
69 fAxis[1] = kUndefined;
70 fAxisMin[0] = kInfinity;
71 fAxisMin[1] = kInfinity;
72 fAxisMax[0] = kInfinity;
73 fAxisMax[1] = kInfinity;
74 fHandedness = 1;
75
76 for (auto i=0; i<4; ++i)
77 {
78 fCorners[i].set(kInfinity, kInfinity, kInfinity);
79 fNeighbours[i] = nullptr;
80 }
81
82 fCurrentNormal.p.set(kInfinity, kInfinity, kInfinity);
83
84 fAmIOnLeftSide.me.set(kInfinity, kInfinity, kInfinity);
85 fAmIOnLeftSide.vec.set(kInfinity, kInfinity, kInfinity);
86 kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
87}
CLHEP::Hep3Vector::set
void set(double x, double y, double z)
G4GeometryTolerance::GetSurfaceTolerance
G4double GetSurfaceTolerance() const
Definition: G4GeometryTolerance.cc:72
G4GeometryTolerance::GetInstance
static G4GeometryTolerance * GetInstance()
Definition: G4GeometryTolerance.cc:58
G4VTwistSurface::fAxisMax
G4double fAxisMax[2]
Definition: G4VTwistSurface.hh:310
G4VTwistSurface::fAxisMin
G4double fAxisMin[2]
Definition: G4VTwistSurface.hh:309
G4VTwistSurface::fCurrentNormal
G4SurfCurNormal fCurrentNormal
Definition: G4VTwistSurface.hh:322
kUndefined
@ kUndefined
Definition: geomdefs.hh:61

◆ G4VTwistSurface() [2/3]

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

Definition at line 89 of file G4VTwistSurface.cc.

99 : fIsValidNorm(false), fName(name)
100{
101 fAxis[0] = axis0;
102 fAxis[1] = axis1;
103 fAxisMin[0] = axis0min;
104 fAxisMin[1] = axis1min;
105 fAxisMax[0] = axis0max;
106 fAxisMax[1] = axis1max;
107 fHandedness = handedness;
108 fRot = rot;
109 fTrans = tlate;
110
111 for (auto i=0; i<4; ++i)
112 {
113 fCorners[i].set(kInfinity, kInfinity, kInfinity);
114 fNeighbours[i] = nullptr;
115 }
116
117 fCurrentNormal.p.set(kInfinity, kInfinity, kInfinity);
118
119 fAmIOnLeftSide.me.set(kInfinity, kInfinity, kInfinity);
120 fAmIOnLeftSide.vec.set(kInfinity, kInfinity, kInfinity);
121 kCarTolerance = G4GeometryTolerance::GetInstance()->GetSurfaceTolerance();
122}
G4VTwistSurface::fRot
G4RotationMatrix fRot
Definition: G4VTwistSurface.hh:313
G4VTwistSurface::fTrans
G4ThreeVector fTrans
Definition: G4VTwistSurface.hh:314

◆ ~G4VTwistSurface()

G4VTwistSurface::~G4VTwistSurface ( )
virtual

Definition at line 140 of file G4VTwistSurface.cc.

141{
142}

◆ G4VTwistSurface() [3/3]

G4VTwistSurface::G4VTwistSurface ( __void__ &  )

Definition at line 127 of file G4VTwistSurface.cc.

128 : fHandedness(0), fIsValidNorm(false), kCarTolerance(0.),
129 fName("")
130{
131 fAxis[0] = fAxis[1] = kXAxis;
132 fAxisMin[0] = fAxisMin[1] = 0.;
133 fAxisMax[0] = fAxisMax[1] = 0.;
134 fNeighbours[0] = fNeighbours[1] = fNeighbours[2] = fNeighbours[3] = nullptr;
135}
kXAxis
@ kXAxis
Definition: geomdefs.hh:55

Member Function Documentation

◆ AmIOnLeftSide()

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

Definition at line 147 of file G4VTwistSurface.cc.

150{
151 // AmIOnLeftSide returns phi-location of "me"
152 // (phi relation between me and vec projected on z=0 plane).
153 // If "me" is on -ve-phi-side of "vec", it returns 1.
154 // On the other hand, if "me" is on +ve-phi-side of "vec",
155 // it returns -1.
156 // (The return value represents z-coordinate of normal vector
157 // of me.cross(vec).)
158 // If me is on boundary of vec, return 0.
159
160 const G4double kAngTolerance
161 = G4GeometryTolerance::GetInstance()->GetAngularTolerance();
162
163 G4RotationMatrix unitrot;
164 const G4RotationMatrix rottol = unitrot.rotateZ(0.5*kAngTolerance);
165 const G4RotationMatrix invrottol = unitrot.rotateZ(-1.*kAngTolerance);
166
167 if (fAmIOnLeftSide.me == me
168 && fAmIOnLeftSide.vec == vec
169 && fAmIOnLeftSide.withTol == withtol)
170 {
171 return fAmIOnLeftSide.amIOnLeftSide;
172 }
173
174 fAmIOnLeftSide.me = me;
175 fAmIOnLeftSide.vec = vec;
176 fAmIOnLeftSide.withTol = withtol;
177
178 G4ThreeVector met = (G4ThreeVector(me.x(), me.y(), 0.)).unit();
179 G4ThreeVector vect = (G4ThreeVector(vec.x(), vec.y(), 0.)).unit();
180
181 G4ThreeVector ivect = invrottol * vect;
182 G4ThreeVector rvect = rottol * vect;
183
184 G4double metcrossvect = met.x() * vect.y() - met.y() * vect.x();
185
186 if (withtol)
187 {
188 if (met.x() * ivect.y() - met.y() * ivect.x() > 0 &&
189 metcrossvect >= 0) {
190 fAmIOnLeftSide.amIOnLeftSide = 1;
191 } else if (met.x() * rvect.y() - met.y() * rvect.x() < 0 &&
192 metcrossvect <= 0) {
193 fAmIOnLeftSide.amIOnLeftSide = -1;
194 } else {
195 fAmIOnLeftSide.amIOnLeftSide = 0;
196 }
197 }
198 else
199 {
200 if (metcrossvect > 0) {
201 fAmIOnLeftSide.amIOnLeftSide = 1;
202 } else if (metcrossvect < 0 ) {
203 fAmIOnLeftSide.amIOnLeftSide = -1;
204 } else {
205 fAmIOnLeftSide.amIOnLeftSide = 0;
206 }
207 }
208
209#ifdef G4TWISTDEBUG
210 G4cout << " === G4VTwistSurface::AmIOnLeftSide() =============="
211 << G4endl;
212 G4cout << " Name , returncode : " << fName << " "
213 << fAmIOnLeftSide.amIOnLeftSide << G4endl;
214 G4cout << " me, vec : " << std::setprecision(14) << me
215 << " " << vec << G4endl;
216 G4cout << " met, vect : " << met << " " << vect << G4endl;
217 G4cout << " ivec, rvec : " << ivect << " " << rvect << G4endl;
218 G4cout << " met x vect : " << metcrossvect << G4endl;
219 G4cout << " met x ivec : " << met.cross(ivect) << G4endl;
220 G4cout << " met x rvec : " << met.cross(rvect) << G4endl;
221 G4cout << " =============================================="
222 << G4endl;
223#endif
224
225 return fAmIOnLeftSide.amIOnLeftSide;
226}
G4ThreeVector
CLHEP::Hep3Vector G4ThreeVector
Definition: G4ThreeVector.hh:36
G4double
double G4double
Definition: G4Types.hh:83
G4endl
#define G4endl
Definition: G4ios.hh:57
G4cout
G4GLOB_DLL std::ostream G4cout
CLHEP::Hep3Vector::x
double x() const
CLHEP::Hep3Vector::y
double y() const
CLHEP::Hep3Vector::cross
Hep3Vector cross(const Hep3Vector &) const
CLHEP::HepRotation::rotateZ
HepRotation & rotateZ(double delta)
Definition: Rotation.cc:87
G4GeometryTolerance::GetAngularTolerance
G4double GetAngularTolerance() const
Definition: G4GeometryTolerance.cc:77

Referenced by G4TwistTubsSide::DistanceToSurface(), and G4TwistTubsFlatSide::GetAreaCode().

◆ ComputeGlobalDirection()

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

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

◆ ComputeGlobalPoint()

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

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

◆ ComputeLocalDirection()

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

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

◆ ComputeLocalPoint()

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

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

◆ DebugPrint()

void G4VTwistSurface::DebugPrint ( ) const

Definition at line 1139 of file G4VTwistSurface.cc.

1140{
1141 G4ThreeVector A = fRot * GetCorner(sC0Min1Min) + fTrans;
1142 G4ThreeVector B = fRot * GetCorner(sC0Max1Min) + fTrans;
1143 G4ThreeVector C = fRot * GetCorner(sC0Max1Max) + fTrans;
1144 G4ThreeVector D = fRot * GetCorner(sC0Min1Max) + fTrans;
1145
1146 G4cout << "/* G4VTwistSurface::DebugPrint():--------------------------"
1147 << G4endl;
1148 G4cout << "/* Name = " << fName << G4endl;
1149 G4cout << "/* Axis = " << std::hex << fAxis[0] << " "
1150 << std::hex << fAxis[1]
1151 << " (0,1,2,3,5 = kXAxis,kYAxis,kZAxis,kRho,kPhi)"
1152 << std::dec << G4endl;
1153 G4cout << "/* BoundaryLimit(in local) fAxis0(min, max) = ("<<fAxisMin[0]
1154 << ", " << fAxisMax[0] << ")" << G4endl;
1155 G4cout << "/* BoundaryLimit(in local) fAxis1(min, max) = ("<<fAxisMin[1]
1156 << ", " << fAxisMax[1] << ")" << G4endl;
1157 G4cout << "/* Cornar point sC0Min1Min = " << A << G4endl;
1158 G4cout << "/* Cornar point sC0Max1Min = " << B << G4endl;
1159 G4cout << "/* Cornar point sC0Max1Max = " << C << G4endl;
1160 G4cout << "/* Cornar point sC0Min1Max = " << D << G4endl;
1161 G4cout << "/*---------------------------------------------------------"
1162 << G4endl;
1163}
B
G4double B(G4double temperature)
Definition: G4DNAElectronHoleRecombination.cc:68
D
G4double D(G4double temp)
Definition: G4DNAElectronHoleRecombination.cc:90
A
const G4double A[17]
Definition: G4WaterStopping.cc:53
G4VTwistSurface::sC0Min1Min
static const G4int sC0Min1Min
Definition: G4VTwistSurface.hh:220
G4VTwistSurface::sC0Min1Max
static const G4int sC0Min1Max
Definition: G4VTwistSurface.hh:223
G4VTwistSurface::sC0Max1Max
static const G4int sC0Max1Max
Definition: G4VTwistSurface.hh:222
G4VTwistSurface::GetCorner
G4ThreeVector GetCorner(G4int areacode) const
G4VTwistSurface::sC0Max1Min
static const G4int sC0Max1Min
Definition: G4VTwistSurface.hh:221

◆ DistanceTo()

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

Definition at line 577 of file G4VTwistSurface.cc.

579{
580#ifdef G4TWISTDEBUG
581 G4cout << "~~~~~ G4VTwistSurface::DistanceTo(p) - Start ~~~~~~~~~" << G4endl;
582 G4cout << " Name : " << fName << G4endl;
583 G4cout << " gp : " << gp << G4endl;
584 G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
585#endif
586
587
588 G4ThreeVector gxx[G4VSURFACENXX];
589 G4double distance[G4VSURFACENXX] ;
590 G4int areacode[G4VSURFACENXX] ;
591
592 for (G4int i = 0 ; i<G4VSURFACENXX ; ++i )
593 {
594 distance[i] = kInfinity ;
595 areacode[i] = sOutside ;
596 }
597
598 DistanceToSurface(gp, gxx, distance, areacode);
599 gxxbest = gxx[0];
600
601#ifdef G4TWISTDEBUG
602 G4cout << "~~~~~ G4VTwistSurface::DistanceTo(p) - return ~~~~~~~~" << G4endl;
603 G4cout << " Name : " << fName << G4endl;
604 G4cout << " gxx : " << gxxbest << G4endl;
605 G4cout << " bestdist : " << distance[0] << G4endl;
606 G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
607#endif
608
609 return distance[0];
610}
G4int
int G4int
Definition: G4Types.hh:85
G4VSURFACENXX
#define G4VSURFACENXX
Definition: G4VTwistSurface.hh:46
G4VTwistSurface::sOutside
static const G4int sOutside
Definition: G4VTwistSurface.hh:216
G4VTwistSurface::DistanceToSurface
virtual G4int DistanceToSurface(const G4ThreeVector &gp, const G4ThreeVector &gv, G4ThreeVector gxx[], G4double distance[], G4int areacode[], G4bool isvalid[], EValidate validate=kValidateWithTol)=0

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 
)
virtual

Definition at line 231 of file G4VTwistSurface.cc.

234{
235 // DistanceToBoundary
236 //
237 // return distance to nearest boundary from arbitrary point p
238 // in local coodinate.
239 // Argument areacode must be one of them:
240 // sAxis0 & sAxisMin, sAxis0 & sAxisMax,
241 // sAxis1 & sAxisMin, sAxis1 & sAxisMax.
242 //
243
244 G4ThreeVector d; // direction vector of the boundary
245 G4ThreeVector x0; // reference point of the boundary
246 G4double dist = kInfinity;
247 G4int boundarytype;
248
249 if (IsAxis0(areacode) && IsAxis1(areacode))
250 {
251 std::ostringstream message;
252 message << "Point is in the corner area." << G4endl
253 << " Point is in the corner area. This function returns"
254 << G4endl
255 << " a direction vector of a boundary line." << G4endl
256 << " areacode = " << areacode;
257 G4Exception("G4VTwistSurface::DistanceToBoundary()", "GeomSolids0003",
258 FatalException, message);
259 }
260 else if (IsAxis0(areacode) || IsAxis1(areacode))
261 {
262 GetBoundaryParameters(areacode, d, x0, boundarytype);
263 if (boundarytype == sAxisPhi)
264 {
265 G4double t = x0.getRho() / p.getRho();
266 xx.set(t*p.x(), t*p.y(), x0.z());
267 dist = (xx - p).mag();
268 }
269 else
270 {
271 // linear boundary
272 // sAxisX, sAxisY, sAxisZ, sAxisRho
273 dist = DistanceToLine(p, x0, d, xx);
274 }
275 }
276 else
277 {
278 std::ostringstream message;
279 message << "Bad areacode of boundary." << G4endl
280 << " areacode = " << areacode;
281 G4Exception("G4VTwistSurface::DistanceToBoundary()", "GeomSolids0003",
282 FatalException, message);
283 }
284 return dist;
285}
FatalException
@ FatalException
Definition: G4ExceptionSeverity.hh:61
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition: G4Exception.cc:59
CLHEP::Hep3Vector::z
double z() const
CLHEP::Hep3Vector::getRho
double getRho() const
G4VTwistSurface::IsAxis1
G4bool IsAxis1(G4int areacode) const
G4VTwistSurface::IsAxis0
G4bool IsAxis0(G4int areacode) const
G4VTwistSurface::DistanceToLine
G4double DistanceToLine(const G4ThreeVector &p, const G4ThreeVector &x0, const G4ThreeVector &d, G4ThreeVector &xx)
G4VTwistSurface::sAxisPhi
static const G4int sAxisPhi
Definition: G4VTwistSurface.hh:230
G4VTwistSurface::GetBoundaryParameters
virtual void GetBoundaryParameters(const G4int &areacode, G4ThreeVector &d, G4ThreeVector &x0, G4int &boundarytype) const
Definition: G4VTwistSurface.cc:668

Referenced by G4TwistTubsSide::DistanceToSurface().

◆ DistanceToIn()

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

Definition at line 290 of file G4VTwistSurface.cc.

293{
294#ifdef G4TWISTDEBUG
295 G4cout << " ~~~~ G4VTwistSurface::DistanceToIn(p,v) - Start ~~~~" << G4endl;
296 G4cout << " Name : " << fName << G4endl;
297 G4cout << " gp : " << gp << G4endl;
298 G4cout << " gv : " << gv << G4endl;
299 G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
300#endif
301
302 G4ThreeVector gxx[G4VSURFACENXX];
303 G4double distance[G4VSURFACENXX] ;
304 G4int areacode[G4VSURFACENXX] ;
305 G4bool isvalid[G4VSURFACENXX] ;
306
307 for (G4int i = 0 ; i<G4VSURFACENXX ; ++i )
308 {
309 distance[i] = kInfinity ;
310 areacode[i] = sOutside ;
311 isvalid[i] = false ;
312 }
313
314 G4double bestdistance = kInfinity;
315#ifdef G4TWISTDEBUG
316 G4int besti = -1;
317#endif
318 G4ThreeVector bestgxx(kInfinity, kInfinity, kInfinity);
319
320 G4int nxx = DistanceToSurface(gp, gv, gxx, distance, areacode,
321 isvalid, kValidateWithTol);
322
323 for (G4int i=0; i<nxx; ++i)
324 {
325
326 // skip this intersection if:
327 // - invalid intersection
328 // - particle goes outword the surface
329
330 if (!isvalid[i])
331 {
332 // xx[i] is sOutside or distance[i] < 0
333 continue;
334 }
335
336 G4ThreeVector normal = GetNormal(gxx[i], true);
337
338 if ((normal * gv) >= 0)
339 {
340
341#ifdef G4TWISTDEBUG
342 G4cout << " G4VTwistSurface::DistanceToIn(p,v): "
343 << "particle goes outword the surface." << G4endl;
344#endif
345 continue;
346 }
347
348 //
349 // accept this intersection if the intersection is inside.
350 //
351
352 if (IsInside(areacode[i]))
353 {
354 if (distance[i] < bestdistance)
355 {
356 bestdistance = distance[i];
357 bestgxx = gxx[i];
358#ifdef G4TWISTDEBUG
359 besti = i;
360 G4cout << " G4VTwistSurface::DistanceToIn(p,v): "
361 << " areacode sInside name, distance = "
362 << fName << " "<< bestdistance << G4endl;
363#endif
364 }
365
366 //
367 // else, the intersection is on boundary or corner.
368 //
369
370 }
371 else
372 {
373 G4VTwistSurface* neighbours[2];
374 G4bool isaccepted[2] = {false, false};
375 G4int nneighbours = GetNeighbours(areacode[i], neighbours);
376
377 for (G4int j=0; j<nneighbours; ++j)
378 {
379 // if on corner, nneighbours = 2.
380 // if on boundary, nneighbours = 1.
381
382 G4ThreeVector tmpgxx[G4VSURFACENXX];
383 G4double tmpdist[G4VSURFACENXX] ;
384 G4int tmpareacode[G4VSURFACENXX] ;
385 G4bool tmpisvalid[G4VSURFACENXX] ;
386
387 for (G4int l = 0 ; l<G4VSURFACENXX ; ++l )
388 {
389 tmpdist[l] = kInfinity ;
390 tmpareacode[l] = sOutside ;
391 tmpisvalid[l] = false ;
392 }
393
394 G4int tmpnxx = neighbours[j]->DistanceToSurface(
395 gp, gv, tmpgxx, tmpdist,
396 tmpareacode, tmpisvalid,
397 kValidateWithTol);
398 G4ThreeVector neighbournormal;
399
400 for (G4int k=0; k< tmpnxx; ++k)
401 {
402 //
403 // if tmpxx[k] is valid && sInside, the final winner must
404 // be neighbour surface. return kInfinity.
405 // else , choose tmpxx on same boundary of xx, then check normal
406 //
407
408 if (IsInside(tmpareacode[k]))
409 {
410#ifdef G4TWISTDEBUG
411 G4cout << " G4VTwistSurface:DistanceToIn(p,v): "
412 << " intersection "<< tmpgxx[k] << G4endl
413 << " is inside of neighbour surface of " << fName
414 << " . returning kInfinity." << G4endl;
415 G4cout << "~~ G4VTwistSurface::DistanceToIn(p,v) - return ~~"
416 << G4endl;
417 G4cout << " No intersections " << G4endl;
418 G4cout << " Name : " << fName << G4endl;
419 G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
420 << G4endl;
421#endif
422 if (tmpisvalid[k]) return kInfinity;
423 continue;
424
425 //
426 // if tmpxx[k] is valid && sInside, the final winner must
427 // be neighbour surface. return .
428 //
429
430 }
431 else if (IsSameBoundary(this,areacode[i],
432 neighbours[j], tmpareacode[k]))
433 {
434 // tmpxx[k] is same boundary (or corner) of xx.
435
436 neighbournormal = neighbours[j]->GetNormal(tmpgxx[k], true);
437 if (neighbournormal * gv < 0) isaccepted[j] = true;
438 }
439 }
440
441 // if nneighbours = 1, chabge isaccepted[1] before
442 // exiting neighboursurface loop.
443
444 if (nneighbours == 1) isaccepted[1] = true;
445
446 } // neighboursurface loop end
447
448 // now, we can accept xx intersection
449
450 if (isaccepted[0] == true && isaccepted[1] == true)
451 {
452 if (distance[i] < bestdistance)
453 {
454 bestdistance = distance[i];
455 gxxbest = gxx[i];
456#ifdef G4TWISTDEBUG
457 besti = i;
458 G4cout << " G4VTwistSurface::DistanceToIn(p,v): "
459 << " areacode sBoundary & sBoundary distance = "
460 << fName << " " << distance[i] << G4endl;
461#endif
462 }
463 }
464 } // else end
465 } // intersection loop end
466
467 gxxbest = bestgxx;
468
469#ifdef G4TWISTDEBUG
470 if (besti < 0)
471 {
472 G4cout << "~~~ G4VTwistSurface::DistanceToIn(p,v) - return ~~~" << G4endl;
473 G4cout << " No intersections " << G4endl;
474 G4cout << " Name : " << fName << G4endl;
475 G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
476 }
477 else
478 {
479 G4cout << "~~~ G4VTwistSurface::DistanceToIn(p,v) : return ~~~" << G4endl;
480 G4cout << " Name, i : " << fName << " , " << besti << G4endl;
481 G4cout << " gxx[i] : " << gxxbest << G4endl;
482 G4cout << " bestdist : " << bestdistance << G4endl;
483 G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
484 }
485
486#endif
487
488 return bestdistance;
489}
G4bool
bool G4bool
Definition: G4Types.hh:86
G4VTwistSurface::GetNeighbours
G4VTwistSurface ** GetNeighbours()
Definition: G4VTwistSurface.hh:183
G4VTwistSurface::IsInside
G4bool IsInside(G4int areacode, G4bool testbitmode=false) const
G4VTwistSurface::IsSameBoundary
G4bool IsSameBoundary(G4VTwistSurface *surface1, G4int areacode1, G4VTwistSurface *surface2, G4int areacode2) const
Definition: G4VTwistSurface.cc:616
G4VTwistSurface::GetNormal
virtual G4ThreeVector GetNormal(const G4ThreeVector &xx, G4bool isGlobal)=0

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

◆ DistanceToLine()

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

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

◆ DistanceToOut()

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

Definition at line 494 of file G4VTwistSurface.cc.

497{
498#ifdef G4TWISTDEBUG
499 G4cout << "~~~~~ G4VTwistSurface::DistanceToOut(p,v) - Start ~~~~" << G4endl;
500 G4cout << " Name : " << fName << G4endl;
501 G4cout << " gp : " << gp << G4endl;
502 G4cout << " gv : " << gv << G4endl;
503 G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
504#endif
505
506 G4ThreeVector gxx[G4VSURFACENXX];
507 G4double distance[G4VSURFACENXX];
508 G4int areacode[G4VSURFACENXX];
509 G4bool isvalid[G4VSURFACENXX];
510
511 for ( G4int i = 0 ; i<G4VSURFACENXX ; ++i )
512 {
513 distance[i] = kInfinity ;
514 areacode[i] = sOutside ;
515 isvalid[i] = false ;
516 }
517
518 G4int nxx;
519 G4double bestdistance = kInfinity;
520
521 nxx = DistanceToSurface(gp, gv, gxx, distance, areacode,
522 isvalid, kValidateWithTol);
523
524 for (G4int i=0; i<nxx; ++i)
525 {
526 if (!(isvalid[i]))
527 {
528 continue;
529 }
530
531 G4ThreeVector normal = GetNormal(gxx[i], true);
532 if (normal * gv <= 0)
533 {
534 // particle goes toword inside of solid, return kInfinity
535#ifdef G4TWISTDEBUG
536 G4cout << " G4VTwistSurface::DistanceToOut(p,v): normal*gv < 0 "
537 << fName << " " << normal
538 << G4endl;
539#endif
540 }
541 else
542 {
543 // gxx[i] is accepted.
544 if (distance[i] < bestdistance)
545 {
546 bestdistance = distance[i];
547 gxxbest = gxx[i];
548 }
549 }
550 }
551
552#ifdef G4TWISTDEBUG
553 if (besti < 0)
554 {
555 G4cout << "~~ G4VTwistSurface::DistanceToOut(p,v) - return ~~" << G4endl;
556 G4cout << " No intersections " << G4endl;
557 G4cout << " Name : " << fName << G4endl;
558 G4cout << " bestdist : " << bestdistance << G4endl;
559 G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
560 }
561 else
562 {
563 G4cout << "~~ G4VTwistSurface::DistanceToOut(p,v) : return ~~" << G4endl;
564 G4cout << " Name, i : " << fName << " , " << i << G4endl;
565 G4cout << " gxx[i] : " << gxxbest << G4endl;
566 G4cout << " bestdist : " << bestdistance << G4endl;
567 G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
568 }
569#endif
570
571 return bestdistance;
572}

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

◆ DistanceToPlane() [1/2]

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

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

◆ DistanceToPlane() [2/2]

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

◆ DistanceToPlaneWithV()

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

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

◆ DistanceToSurface() [1/2]

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

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

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

◆ DistanceToSurface() [2/2]

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

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

◆ GetAreaCode()

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

Implemented in G4TwistTrapFlatSide, and G4TwistTubsFlatSide.

◆ GetAxisType()

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

◆ GetBoundaryAtPZ()

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

Definition at line 698 of file G4VTwistSurface.cc.

700{
701 // areacode must be one of them:
702 // sAxis0 & sAxisMin, sAxis0 & sAxisMax,
703 // sAxis1 & sAxisMin, sAxis1 & sAxisMax.
704
705 if (areacode & sAxis0 && areacode & sAxis1)
706 {
707 std::ostringstream message;
708 message << "Point is in the corner area." << G4endl
709 << " This function returns "
710 << "a direction vector of a boundary line." << G4endl
711 << " areacode = " << areacode;
712 G4Exception("G4VTwistSurface::GetBoundaryAtPZ()", "GeomSolids0003",
713 FatalException, message);
714 }
715
716 G4ThreeVector d;
717 G4ThreeVector x0;
718 G4int boundarytype;
719 G4bool found = false;
720
721 for (G4int i=0; i<4; ++i)
722 {
723 if (fBoundaries[i].GetBoundaryParameters(areacode, d, x0,
724 boundarytype))
725 {
726 found = true;
727 continue;
728 }
729 }
730
731 if (!found)
732 {
733 std::ostringstream message;
734 message << "Not registered boundary." << G4endl
735 << " Boundary at areacode " << areacode << G4endl
736 << " is not registered.";
737 G4Exception("G4VTwistSurface::GetBoundaryAtPZ()", "GeomSolids0002",
738 FatalException, message);
739 }
740
741 if (((boundarytype & sAxisPhi) == sAxisPhi) ||
742 ((boundarytype & sAxisRho) == sAxisRho))
743 {
744 std::ostringstream message;
745 message << "Not a z-depended line boundary." << G4endl
746 << " Boundary at areacode " << areacode << G4endl
747 << " is not a z-depended line.";
748 G4Exception("G4VTwistSurface::GetBoundaryAtPZ()", "GeomSolids0002",
749 FatalException, message);
750 }
751 return ((p.z() - x0.z()) / d.z()) * d + x0;
752}
G4VTwistSurface::sAxis0
static const G4int sAxis0
Definition: G4VTwistSurface.hh:231
G4VTwistSurface::sAxis1
static const G4int sAxis1
Definition: G4VTwistSurface.hh:232
G4VTwistSurface::sAxisRho
static const G4int sAxisRho
Definition: G4VTwistSurface.hh:229

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

◆ GetBoundaryAxis()

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

Definition at line 783 of file G4VTwistSurface.cc.

784{
785 if ((areacode & sBoundary) != sBoundary) {
786 G4Exception("G4VTwistSurface::GetBoundaryAxis()", "GeomSolids0003",
787 FatalException, "Not located on a boundary!");
788 }
789 for (G4int i=0; i<2; ++i)
790 {
791 G4int whichaxis = 0 ;
792 if (i == 0) {
793 whichaxis = sAxis0;
794 } else if (i == 1) {
795 whichaxis = sAxis1;
796 }
797
798 // extracted axiscode of whichaxis
799 G4int axiscode = whichaxis & sAxisMask & areacode ;
800 if (axiscode) {
801 if (axiscode == (whichaxis & sAxisX)) {
802 axis[i] = kXAxis;
803 } else if (axiscode == (whichaxis & sAxisY)) {
804 axis[i] = kYAxis;
805 } else if (axiscode == (whichaxis & sAxisZ)) {
806 axis[i] = kZAxis;
807 } else if (axiscode == (whichaxis & sAxisRho)) {
808 axis[i] = kRho;
809 } else if (axiscode == (whichaxis & sAxisPhi)) {
810 axis[i] = kPhi;
811 } else {
812 std::ostringstream message;
813 message << "Not supported areacode." << G4endl
814 << " areacode " << areacode;
815 G4Exception("G4VTwistSurface::GetBoundaryAxis()", "GeomSolids0001",
816 FatalException, message);
817 }
818 }
819 }
820}
G4VTwistSurface::sAxisMask
static const G4int sAxisMask
Definition: G4VTwistSurface.hh:234
G4VTwistSurface::sBoundary
static const G4int sBoundary
Definition: G4VTwistSurface.hh:218
G4VTwistSurface::sAxisZ
static const G4int sAxisZ
Definition: G4VTwistSurface.hh:228
G4VTwistSurface::sAxisY
static const G4int sAxisY
Definition: G4VTwistSurface.hh:227
G4VTwistSurface::sAxisX
static const G4int sAxisX
Definition: G4VTwistSurface.hh:226
kPhi
@ kPhi
Definition: geomdefs.hh:60
kYAxis
@ kYAxis
Definition: geomdefs.hh:56
kZAxis
@ kZAxis
Definition: geomdefs.hh:57
kRho
@ kRho
Definition: geomdefs.hh:58

◆ GetBoundaryLimit()

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

Definition at line 825 of file G4VTwistSurface.cc.

826{
827 if (areacode & sCorner) {
828 if (areacode & sC0Min1Min) {
829 limit[0] = fAxisMin[0];
830 limit[1] = fAxisMin[1];
831 } else if (areacode & sC0Max1Min) {
832 limit[0] = fAxisMax[0];
833 limit[1] = fAxisMin[1];
834 } else if (areacode & sC0Max1Max) {
835 limit[0] = fAxisMax[0];
836 limit[1] = fAxisMax[1];
837 } else if (areacode & sC0Min1Max) {
838 limit[0] = fAxisMin[0];
839 limit[1] = fAxisMax[1];
840 }
841 } else if (areacode & sBoundary) {
842 if (areacode & (sAxis0 | sAxisMin)) {
843 limit[0] = fAxisMin[0];
844 } else if (areacode & (sAxis1 | sAxisMin)) {
845 limit[0] = fAxisMin[1];
846 } else if (areacode & (sAxis0 | sAxisMax)) {
847 limit[0] = fAxisMax[0];
848 } else if (areacode & (sAxis1 | sAxisMax)) {
849 limit[0] = fAxisMax[1];
850 }
851 } else {
852 std::ostringstream message;
853 message << "Not located on a boundary!" << G4endl
854 << " areacode " << areacode;
855 G4Exception("G4VTwistSurface::GetBoundaryLimit()", "GeomSolids1002",
856 JustWarning, message);
857 }
858}
JustWarning
@ JustWarning
Definition: G4ExceptionSeverity.hh:65
G4VTwistSurface::sAxisMax
static const G4int sAxisMax
Definition: G4VTwistSurface.hh:225
G4VTwistSurface::sAxisMin
static const G4int sAxisMin
Definition: G4VTwistSurface.hh:224
G4VTwistSurface::sCorner
static const G4int sCorner
Definition: G4VTwistSurface.hh:219

◆ GetBoundaryMax()

virtual G4double G4VTwistSurface::GetBoundaryMax ( G4double  )
pure virtual

Implemented in G4TwistTubsFlatSide, G4TwistTubsHypeSide, G4TwistTubsSide, and G4TwistTrapFlatSide.

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

◆ GetBoundaryMin()

virtual G4double G4VTwistSurface::GetBoundaryMin ( G4double  )
pure virtual

Implemented in G4TwistTubsFlatSide, G4TwistTubsHypeSide, G4TwistTubsSide, and G4TwistTrapFlatSide.

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

◆ GetBoundaryParameters()

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

Definition at line 668 of file G4VTwistSurface.cc.

672{
673 // areacode must be one of them:
674 // sAxis0 & sAxisMin, sAxis0 & sAxisMax,
675 // sAxis1 & sAxisMin, sAxis1 & sAxisMax.
676
677 for (G4int i=0; i<4; ++i)
678 {
679 if (fBoundaries[i].GetBoundaryParameters(areacode, d, x0,
680 boundarytype))
681 {
682 return;
683 }
684 }
685
686 std::ostringstream message;
687 message << "Not registered boundary." << G4endl
688 << " Boundary at areacode " << std::hex << areacode
689 << std::dec << G4endl
690 << " is not registered.";
691 G4Exception("G4VTwistSurface::GetBoundaryParameters()", "GeomSolids0002",
692 FatalException, message);
693}

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

◆ GetCorner()

G4ThreeVector G4VTwistSurface::GetCorner ( G4int  areacode) const
inlineprotected

Referenced by DebugPrint(), G4TwistTubsFlatSide::GetAreaCode(), G4TwistTubsFlatSide::GetBoundaryMax(), G4TwistTubsFlatSide::GetBoundaryMin(), and IsSameBoundary().

◆ GetEdgeVisibility()

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

Definition at line 1031 of file G4VTwistSurface.cc.

1033{
1034 // clockwise filling -> positive orientation
1035 // counter clockwise filling -> negative orientation
1036
1037 //
1038 // d C c
1039 // +------+
1040 // | |
1041 // | |
1042 // | |
1043 // D | |B
1044 // | |
1045 // | |
1046 // | |
1047 // +------+
1048 // a A b
1049 //
1050 // a = +--+ A = ---+
1051 // b = --++ B = --+-
1052 // c = -++- C = -+--
1053 // d = ++-- D = +---
1054
1055
1056 // check first invisible faces
1057
1058 if ( ( i>0 && i<n-2 ) && ( j>0 && j<k-2 ) )
1059 {
1060 return -1 ; // always invisible, signs: ----
1061 }
1062
1063 // change first the vertex number (depends on the orientation)
1064 // 0,1,2,3 -> 3,2,1,0
1065 if ( orientation < 0 ) { number = ( 3 - number ) ; }
1066
1067 // check true edges
1068 if ( ( j>=1 && j<=k-3 ) )
1069 {
1070 if ( i == 0 ) { // signs (A): ---+
1071 return ( number == 3 ) ? 1 : -1 ;
1072 }
1073
1074 else if ( i == n-2 ) { // signs (C): -+--
1075 return ( number == 1 ) ? 1 : -1 ;
1076 }
1077
1078 else
1079 {
1080 std::ostringstream message;
1081 message << "Not correct face number: " << GetName() << " !";
1082 G4Exception("G4TwistSurface::G4GetEdgeVisibility()",
1083 "GeomSolids0003", FatalException, message);
1084 }
1085 }
1086
1087 if ( ( i>=1 && i<=n-3 ) )
1088 {
1089 if ( j == 0 ) { // signs (D): +---
1090 return ( number == 0 ) ? 1 : -1 ;
1091 }
1092
1093 else if ( j == k-2 ) { // signs (B): --+-
1094 return ( number == 2 ) ? 1 : -1 ;
1095 }
1096
1097 else
1098 {
1099 std::ostringstream message;
1100 message << "Not correct face number: " << GetName() << " !";
1101 G4Exception("G4TwistSurface::G4GetEdgeVisibility()",
1102 "GeomSolids0003", FatalException, message);
1103 }
1104 }
1105
1106 // now the corners
1107 if ( i == 0 && j == 0 ) { // signs (a) : +--+
1108 return ( number == 0 || number == 3 ) ? 1 : -1 ;
1109 }
1110 else if ( i == 0 && j == k-2 ) { // signs (b) : --++
1111 return ( number == 2 || number == 3 ) ? 1 : -1 ;
1112 }
1113 else if ( i == n-2 && j == k-2 ) { // signs (c) : -++-
1114 return ( number == 1 || number == 2 ) ? 1 : -1 ;
1115 }
1116 else if ( i == n-2 && j == 0 ) { // signs (d) : ++--
1117 return ( number == 0 || number == 1 ) ? 1 : -1 ;
1118 }
1119 else
1120 {
1121 std::ostringstream message;
1122 message << "Not correct face number: " << GetName() << " !";
1123 G4Exception("G4TwistSurface::G4GetEdgeVisibility()",
1124 "GeomSolids0003", FatalException, message);
1125 }
1126
1127 std::ostringstream message;
1128 message << "Not correct face number: " << GetName() << " !";
1129 G4Exception("G4TwistSurface::G4GetEdgeVisibility()", "GeomSolids0003",
1130 FatalException, message);
1131
1132 return 0 ;
1133}
G4VTwistSurface::GetName
virtual G4String GetName() const
Definition: G4VTwistSurface.hh:107

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

◆ GetFace()

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

Definition at line 906 of file G4VTwistSurface.cc.

908{
909 // this is the face mapping function
910 // (i,j) -> face number
911
912 if ( iside == 0 ) {
913 return i * ( k - 1 ) + j ;
914 }
915
916 else if ( iside == 1 ) {
917 return (k-1)*(k-1) + i*(k-1) + j ;
918 }
919
920 else if ( iside == 2 ) {
921 return 2*(k-1)*(k-1) + i*(k-1) + j ;
922 }
923
924 else if ( iside == 3 ) {
925 return 2*(k-1)*(k-1) + (n-1)*(k-1) + i*(k-1) + j ;
926 }
927
928 else if ( iside == 4 ) {
929 return 2*(k-1)*(k-1) + 2*(n-1)*(k-1) + i*(k-1) + j ;
930 }
931
932 else if ( iside == 5 ) {
933 return 2*(k-1)*(k-1) + 3*(n-1)*(k-1) + i*(k-1) + j ;
934 }
935
936 else {
937 std::ostringstream message;
938 message << "Not correct side number: "
939 << GetName() << G4endl
940 << "iside is " << iside << " but should be "
941 << "0,1,2,3,4 or 5" << ".";
942 G4Exception("G4TwistSurface::G4GetFace()", "GeomSolids0002",
943 FatalException, message);
944 }
945
946 return -1 ; // wrong face
947}

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

◆ GetFacets()

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

Implemented in G4TwistTrapFlatSide, G4TwistTubsFlatSide, G4TwistTubsHypeSide, and G4TwistTubsSide.

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

◆ GetName()

virtual G4String G4VTwistSurface::GetName ( ) const
inlinevirtual

Definition at line 107 of file G4VTwistSurface.hh.

107{ return fName; }

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

◆ GetNeighbours() [1/2]

G4VTwistSurface ** G4VTwistSurface::GetNeighbours ( )
inlineprotected

Definition at line 183 of file G4VTwistSurface.hh.

183{ return fNeighbours; }

Referenced by DistanceToIn().

◆ GetNeighbours() [2/2]

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

◆ GetNode()

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

Definition at line 952 of file G4VTwistSurface.cc.

954{
955 // this is the node mapping function
956 // (i,j) -> node number
957 // Depends on the side iside and the used meshing of the surface
958
959 if ( iside == 0 )
960 {
961 // lower endcap is kxk squared.
962 // n = k
963 return i * k + j ;
964 }
965
966 if ( iside == 1 )
967 {
968 // upper endcap is kxk squared. Shift by k*k
969 // n = k
970 return k*k + i*k + j ;
971 }
972
973 else if ( iside == 2 )
974 {
975 // front side.
976 if ( i == 0 ) { return j ; }
977 else if ( i == n-1 ) { return k*k + j ; }
978 else { return 2*k*k + 4*(i-1)*(k-1) + j ; }
979 }
980
981 else if ( iside == 3 )
982 {
983 // right side
984 if ( i == 0 ) { return (j+1)*k - 1 ; }
985 else if ( i == n-1 ) { return k*k + (j+1)*k - 1 ; }
986 else
987 {
988 return 2*k*k + 4*(i-1)*(k-1) + (k-1) + j ;
989 }
990 }
991 else if ( iside == 4 )
992 {
993 // back side
994 if ( i == 0 ) { return k*k - 1 - j ; } // reversed order
995 else if ( i == n-1 ) { return 2*k*k - 1 - j ; } // reversed order
996 else
997 {
998 return 2*k*k + 4*(i-1)*(k-1) + 2*(k-1) + j ; // normal order
999 }
1000 }
1001 else if ( iside == 5 )
1002 {
1003 // left side
1004 if ( i == 0 ) { return k*k - (j+1)*k ; } // reversed order
1005 else if ( i == n-1) { return 2*k*k - (j+1)*k ; } // reverded order
1006 else
1007 {
1008 if ( j == k-1 ) { return 2*k*k + 4*(i-1)*(k-1) ; } // special case
1009 else
1010 {
1011 return 2*k*k + 4*(i-1)*(k-1) + 3*(k-1) + j ; // normal order
1012 }
1013 }
1014 }
1015 else
1016 {
1017 std::ostringstream message;
1018 message << "Not correct side number: "
1019 << GetName() << G4endl
1020 << "iside is " << iside << " but should be "
1021 << "0,1,2,3,4 or 5" << ".";
1022 G4Exception("G4TwistSurface::G4GetNode()", "GeomSolids0002",
1023 FatalException, message);
1024 }
1025 return -1 ; // wrong node
1026}

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

◆ GetNormal()

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

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

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

◆ GetSurfaceArea()

virtual G4double G4VTwistSurface::GetSurfaceArea ( )
pure virtual

Implemented in G4TwistTrapFlatSide, G4TwistTubsFlatSide, G4TwistTubsHypeSide, and G4TwistTubsSide.

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

◆ IsAxis0()

G4bool G4VTwistSurface::IsAxis0 ( G4int  areacode) const
inline

Referenced by DistanceToBoundary().

◆ IsAxis1()

G4bool G4VTwistSurface::IsAxis1 ( G4int  areacode) const
inline

Referenced by DistanceToBoundary().

◆ IsBoundary()

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

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

◆ IsCorner()

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

Referenced by IsSameBoundary().

◆ IsInside()

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

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

◆ IsOutside()

G4bool G4VTwistSurface::IsOutside ( G4int  areacode) const
inline

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

◆ IsSameBoundary()

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

Definition at line 616 of file G4VTwistSurface.cc.

618{
619 //
620 // IsSameBoundary
621 //
622 // checking tool whether two boundaries on different surfaces are same or not.
623 //
624
625 G4bool testbitmode = true;
626 G4bool iscorner[2] = {IsCorner(areacode1, testbitmode),
627 IsCorner(areacode2, testbitmode)};
628
629 if (iscorner[0] && iscorner[1])
630 {
631 // on corner
632 G4ThreeVector corner1 =
633 surf1->ComputeGlobalPoint(surf1->GetCorner(areacode1));
634 G4ThreeVector corner2 =
635 surf2->ComputeGlobalPoint(surf2->GetCorner(areacode2));
636
637 if ((corner1 - corner2).mag() < kCarTolerance) { return true; }
638 else { return false; }
639 }
640 else if ((IsBoundary(areacode1, testbitmode) && (!iscorner[0])) &&
641 (IsBoundary(areacode2, testbitmode) && (!iscorner[1])))
642 {
643 // on boundary
644 G4ThreeVector d1, d2, ld1, ld2;
645 G4ThreeVector x01, x02, lx01, lx02;
646 G4int type1, type2;
647 surf1->GetBoundaryParameters(areacode1, ld1, lx01, type1);
648 surf2->GetBoundaryParameters(areacode2, ld2, lx02, type2);
649
650 x01 = surf1->ComputeGlobalPoint(lx01);
651 x02 = surf2->ComputeGlobalPoint(lx02);
652 d1 = surf1->ComputeGlobalDirection(ld1);
653 d2 = surf2->ComputeGlobalDirection(ld2);
654
655 if ((x01 - x02).mag() < kCarTolerance &&
656 (d1 - d2).mag() < kCarTolerance) { return true; }
657 else { return false; }
658 }
659 else
660 {
661 return false;
662 }
663}
G4VTwistSurface::IsCorner
G4bool IsCorner(G4int areacode, G4bool testbitmode=false) const
G4VTwistSurface::IsBoundary
G4bool IsBoundary(G4int areacode, G4bool testbitmode=false) const

Referenced by DistanceToIn().

◆ IsValidNorm()

G4bool G4VTwistSurface::IsValidNorm ( ) const
inline

Definition at line 144 of file G4VTwistSurface.hh.

144{ return fIsValidNorm; }

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

◆ SetAxis()

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

Definition at line 156 of file G4VTwistSurface.hh.

156{ fAxis[i] = axis; }

◆ SetBoundary()

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

Definition at line 863 of file G4VTwistSurface.cc.

867{
868 G4int code = (~sAxisMask) & axiscode;
869 if ((code == (sAxis0 & sAxisMin)) ||
870 (code == (sAxis0 & sAxisMax)) ||
871 (code == (sAxis1 & sAxisMin)) ||
872 (code == (sAxis1 & sAxisMax)))
873 {
874 G4bool done = false;
875 for (auto i=0; i<4; ++i)
876 {
877 if (fBoundaries[i].IsEmpty())
878 {
879 fBoundaries[i].SetFields(axiscode, direction,
880 x0, boundarytype);
881 done = true;
882 break;
883 }
884 }
885
886 if (!done)
887 {
888 G4Exception("G4VTwistSurface::SetBoundary()", "GeomSolids0003",
889 FatalException, "Number of boundary exceeding 4!");
890 }
891 }
892 else
893 {
894 std::ostringstream message;
895 message << "Invalid axis-code." << G4endl
896 << " axiscode = "
897 << std::hex << axiscode << std::dec;
898 G4Exception("G4VTwistSurface::SetBoundary()", "GeomSolids0003",
899 FatalException, message);
900 }
901}
G4VTwistSurface::Boundary::SetFields
void SetFields(const G4int &areacode, const G4ThreeVector &d, const G4ThreeVector &x0, const G4int &boundarytype)
Definition: G4VTwistSurface.cc:1297
code
Definition: inftrees.h:24

◆ SetCorner()

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

Definition at line 757 of file G4VTwistSurface.cc.

759{
760 if ((areacode & sCorner) != sCorner)
761 {
762 std::ostringstream message;
763 message << "Area code must represents corner." << G4endl
764 << " areacode " << areacode;
765 G4Exception("G4VTwistSurface::SetCorner()", "GeomSolids0002",
766 FatalException, message);
767 }
768
769 if ((areacode & sC0Min1Min) == sC0Min1Min) {
770 fCorners[0].set(x, y, z);
771 } else if ((areacode & sC0Max1Min) == sC0Max1Min) {
772 fCorners[1].set(x, y, z);
773 } else if ((areacode & sC0Max1Max) == sC0Max1Max) {
774 fCorners[2].set(x, y, z);
775 } else if ((areacode & sC0Min1Max) == sC0Min1Max) {
776 fCorners[3].set(x, y, z);
777 }
778}

◆ SetNeighbours()

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

◆ SurfacePoint()

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

Implemented in G4TwistTrapFlatSide, G4TwistTubsFlatSide, G4TwistTubsHypeSide, and G4TwistTubsSide.

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

Member Data Documentation

◆ fAxis

EAxis G4VTwistSurface::fAxis[2]
protected

Definition at line 308 of file G4VTwistSurface.hh.

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

◆ fAxisMax

G4double G4VTwistSurface::fAxisMax[2]
protected

Definition at line 310 of file G4VTwistSurface.hh.

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

◆ fAxisMin

G4double G4VTwistSurface::fAxisMin[2]
protected

Definition at line 309 of file G4VTwistSurface.hh.

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

◆ fCurrentNormal

G4SurfCurNormal G4VTwistSurface::fCurrentNormal
protected

Definition at line 322 of file G4VTwistSurface.hh.

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

◆ fCurStat

CurrentStatus G4VTwistSurface::fCurStat
protected

Definition at line 312 of file G4VTwistSurface.hh.

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

◆ fCurStatWithV

CurrentStatus G4VTwistSurface::fCurStatWithV
protected

Definition at line 311 of file G4VTwistSurface.hh.

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

◆ fHandedness

G4int G4VTwistSurface::fHandedness
protected

Definition at line 315 of file G4VTwistSurface.hh.

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

◆ fIsValidNorm

G4bool G4VTwistSurface::fIsValidNorm
protected

Definition at line 323 of file G4VTwistSurface.hh.

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

◆ fRot

G4RotationMatrix G4VTwistSurface::fRot
protected

Definition at line 313 of file G4VTwistSurface.hh.

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

◆ fTrans

G4ThreeVector G4VTwistSurface::fTrans
protected

Definition at line 314 of file G4VTwistSurface.hh.

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

◆ kCarTolerance

G4double G4VTwistSurface::kCarTolerance
protected

Definition at line 324 of file G4VTwistSurface.hh.

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

◆ sAreaMask

const G4int G4VTwistSurface::sAreaMask = 0XF0000000
static

Definition at line 235 of file G4VTwistSurface.hh.

◆ sAxis0

const G4int G4VTwistSurface::sAxis0 = 0x0000FF00
static

Definition at line 231 of file G4VTwistSurface.hh.

Referenced by G4TwistTubsSide::DistanceToSurface(), G4TwistTrapFlatSide::GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), GetBoundaryAtPZ(), GetBoundaryAxis(), GetBoundaryLimit(), G4TwistTubsHypeSide::GetBoundaryMax(), G4TwistTubsHypeSide::GetBoundaryMin(), G4VTwistSurface::Boundary::GetBoundaryParameters(), and SetBoundary().

◆ sAxis1

const G4int G4VTwistSurface::sAxis1 = 0x000000FF
static

Definition at line 232 of file G4VTwistSurface.hh.

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

◆ sAxisMask

const G4int G4VTwistSurface::sAxisMask = 0x0000FCFC
static

Definition at line 234 of file G4VTwistSurface.hh.

Referenced by GetBoundaryAxis().

◆ sAxisMax

const G4int G4VTwistSurface::sAxisMax = 0x00000202
static

Definition at line 225 of file G4VTwistSurface.hh.

Referenced by G4TwistTubsSide::DistanceToSurface(), G4TwistTrapFlatSide::GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), GetBoundaryLimit(), G4TwistTubsHypeSide::GetBoundaryMax(), and SetBoundary().

◆ sAxisMin

const G4int G4VTwistSurface::sAxisMin = 0x00000101
static

Definition at line 224 of file G4VTwistSurface.hh.

Referenced by G4TwistTubsSide::DistanceToSurface(), G4TwistTrapFlatSide::GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), GetBoundaryLimit(), G4TwistTubsHypeSide::GetBoundaryMin(), and SetBoundary().

◆ sAxisPhi

const G4int G4VTwistSurface::sAxisPhi = 0x00001414
static

Definition at line 230 of file G4VTwistSurface.hh.

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

◆ sAxisRho

const G4int G4VTwistSurface::sAxisRho = 0x00001010
static

Definition at line 229 of file G4VTwistSurface.hh.

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

◆ sAxisX

const G4int G4VTwistSurface::sAxisX = 0x00000404
static

Definition at line 226 of file G4VTwistSurface.hh.

Referenced by G4TwistTrapFlatSide::GetAreaCode(), and GetBoundaryAxis().

◆ sAxisY

const G4int G4VTwistSurface::sAxisY = 0x00000808
static

Definition at line 227 of file G4VTwistSurface.hh.

Referenced by G4TwistTrapFlatSide::GetAreaCode(), and GetBoundaryAxis().

◆ sAxisZ

const G4int G4VTwistSurface::sAxisZ = 0x00000C0C
static

Definition at line 228 of file G4VTwistSurface.hh.

Referenced by GetBoundaryAxis().

◆ sBoundary

const G4int G4VTwistSurface::sBoundary = 0x20000000
static

Definition at line 218 of file G4VTwistSurface.hh.

Referenced by G4TwistTrapFlatSide::GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), GetBoundaryAxis(), and GetBoundaryLimit().

◆ sC0Max1Max

const G4int G4VTwistSurface::sC0Max1Max = 0x40000202
static

Definition at line 222 of file G4VTwistSurface.hh.

Referenced by DebugPrint(), G4TwistTubsFlatSide::GetAreaCode(), GetBoundaryLimit(), G4TwistTubsFlatSide::GetBoundaryMax(), and SetCorner().

◆ sC0Max1Min

const G4int G4VTwistSurface::sC0Max1Min = 0x40000201
static

Definition at line 221 of file G4VTwistSurface.hh.

Referenced by DebugPrint(), G4TwistTubsFlatSide::GetAreaCode(), GetBoundaryLimit(), G4TwistTubsFlatSide::GetBoundaryMin(), and SetCorner().

◆ sC0Min1Max

const G4int G4VTwistSurface::sC0Min1Max = 0x40000102
static

Definition at line 223 of file G4VTwistSurface.hh.

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

◆ sC0Min1Min

const G4int G4VTwistSurface::sC0Min1Min = 0x40000101
static

Definition at line 220 of file G4VTwistSurface.hh.

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

◆ sCorner

const G4int G4VTwistSurface::sCorner = 0x40000000
static

Definition at line 219 of file G4VTwistSurface.hh.

Referenced by G4TwistTrapFlatSide::GetAreaCode(), G4TwistTubsFlatSide::GetAreaCode(), GetBoundaryLimit(), and SetCorner().

◆ sInside

const G4int G4VTwistSurface::sInside = 0x10000000
static

Definition at line 217 of file G4VTwistSurface.hh.

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

◆ sOutside

const G4int G4VTwistSurface::sOutside = 0x00000000
static

Definition at line 216 of file G4VTwistSurface.hh.

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

◆ sSizeMask

const G4int G4VTwistSurface::sSizeMask = 0x00000303
static

Definition at line 233 of file G4VTwistSurface.hh.

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

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