Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Member Functions | Protected Member Functions | List of all members
G4TwistTrapFlatSide Class Reference

#include <G4TwistTrapFlatSide.hh>

+ Inheritance diagram for G4TwistTrapFlatSide:

Public Member Functions

 G4TwistTrapFlatSide (const G4String &name, G4double PhiTwist, G4double pDx1, G4double pDx2, G4double pDy, G4double pDz, G4double pAlpha, G4double pPhi, G4double pTheta, G4int handedness)
 
virtual ~G4TwistTrapFlatSide ()
 
virtual G4ThreeVector GetNormal (const G4ThreeVector &, G4bool isGlobal=false)
 
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[])
 
virtual G4ThreeVector SurfacePoint (G4double x, G4double y, G4bool isGlobal=false)
 
virtual G4double GetBoundaryMin (G4double u)
 
virtual G4double GetBoundaryMax (G4double u)
 
virtual G4double GetSurfaceArea ()
 
virtual void GetFacets (G4int m, G4int n, G4double xyz[][3], G4int faces[][4], G4int iside)
 
 G4TwistTrapFlatSide (__void__ &)
 
- Public Member Functions inherited from G4VTwistSurface
 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 *axis0min, G4VTwistSurface *axis1min, G4VTwistSurface *axis0max, G4VTwistSurface *axis1max)
 
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__ &)
 

Protected Member Functions

virtual G4int GetAreaCode (const G4ThreeVector &xx, G4bool withTol=true)
 
- Protected Member Functions inherited from G4VTwistSurface
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)
 

Additional Inherited Members

- Public Types inherited from G4VTwistSurface
enum  EValidate { kDontValidate = 0 , kValidateWithTol = 1 , kValidateWithoutTol = 2 , kUninitialized = 3 }
 
- Static Public Attributes inherited from G4VTwistSurface
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 Attributes inherited from G4VTwistSurface
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 50 of file G4TwistTrapFlatSide.hh.

Constructor & Destructor Documentation

◆ G4TwistTrapFlatSide() [1/2]

G4TwistTrapFlatSide::G4TwistTrapFlatSide ( const G4String &  name,
G4double  PhiTwist,
G4double  pDx1,
G4double  pDx2,
G4double  pDy,
G4double  pDz,
G4double  pAlpha,
G4double  pPhi,
G4double  pTheta,
G4int  handedness 
)

Definition at line 46 of file G4TwistTrapFlatSide.cc.

57 : G4VTwistSurface(name)
58{
59 fHandedness = handedness; // +z = +ve, -z = -ve
60
61 fDx1 = pDx1 ;
62 fDx2 = pDx2 ;
63 fDy = pDy ;
64 fDz = pDz ;
65 fAlpha = pAlpha ;
66 fTAlph = std::tan(fAlpha) ;
67 fPhi = pPhi ;
68 fTheta = pTheta ;
69
70 fdeltaX = 2 * fDz * std::tan(fTheta) * std::cos(fPhi) ;
71 // dx in surface equation
72 fdeltaY = 2 * fDz * std::tan(fTheta) * std::sin(fPhi) ;
73 // dy in surface equation
74
75 fPhiTwist = PhiTwist ;
76
77 fCurrentNormal.normal.set( 0, 0, (fHandedness < 0 ? -1 : 1));
78 // Unit vector, in local coordinate system
79 fRot.rotateZ( fHandedness > 0
80 ? 0.5 * fPhiTwist
81 : -0.5 * fPhiTwist );
82
83 fTrans.set(
84 fHandedness > 0 ? 0.5*fdeltaX : -0.5*fdeltaX ,
85 fHandedness > 0 ? 0.5*fdeltaY : -0.5*fdeltaY ,
86 fHandedness > 0 ? fDz : -fDz ) ;
87
88 fIsValidNorm = true;
89
90
91 fAxis[0] = kXAxis ;
92 fAxis[1] = kYAxis ;
93 fAxisMin[0] = kInfinity ; // x-Axis cannot be fixed, because it
94 fAxisMax[0] = kInfinity ; // depends on y
95 fAxisMin[1] = -fDy ; // y - axis
96 fAxisMax[1] = fDy ;
97
98 SetCorners();
99 SetBoundaries();
100}
CLHEP::Hep3Vector::set
void set(double x, double y, double z)
CLHEP::HepRotation::rotateZ
HepRotation & rotateZ(double delta)
Definition: Rotation.cc:92
G4VTwistSurface::fAxisMax
G4double fAxisMax[2]
Definition: G4VTwistSurface.hh:322
G4VTwistSurface::fRot
G4RotationMatrix fRot
Definition: G4VTwistSurface.hh:325
G4VTwistSurface::fTrans
G4ThreeVector fTrans
Definition: G4VTwistSurface.hh:326
G4VTwistSurface::fAxisMin
G4double fAxisMin[2]
Definition: G4VTwistSurface.hh:321
G4VTwistSurface::fCurrentNormal
G4SurfCurNormal fCurrentNormal
Definition: G4VTwistSurface.hh:334
kYAxis
@ kYAxis
Definition: geomdefs.hh:54
kXAxis
@ kXAxis
Definition: geomdefs.hh:54

◆ ~G4TwistTrapFlatSide()

G4TwistTrapFlatSide::~G4TwistTrapFlatSide ( )
virtual

Definition at line 116 of file G4TwistTrapFlatSide.cc.

117{
118}

◆ G4TwistTrapFlatSide() [2/2]

G4TwistTrapFlatSide::G4TwistTrapFlatSide ( __void__ &  a)

Definition at line 106 of file G4TwistTrapFlatSide.cc.

107 : G4VTwistSurface(a), fDx1(0.), fDx2(0.), fDy(0.), fDz(0.), fPhiTwist(0.),
108 fAlpha(0.), fTAlph(0.), fPhi(0.), fTheta(0.), fdeltaX(0.), fdeltaY(0.)
109{
110}

Member Function Documentation

◆ DistanceToSurface() [1/2]

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

Implements G4VTwistSurface.

Definition at line 136 of file G4TwistTrapFlatSide.cc.

143{
144 fCurStatWithV.ResetfDone(validate, &gp, &gv);
145
146 if (fCurStatWithV.IsDone()) {
147 G4int i;
148 for (i=0; i<fCurStatWithV.GetNXX(); i++) {
149 gxx[i] = fCurStatWithV.GetXX(i);
150 distance[i] = fCurStatWithV.GetDistance(i);
151 areacode[i] = fCurStatWithV.GetAreacode(i);
152 isvalid[i] = fCurStatWithV.IsValid(i);
153 }
154 return fCurStatWithV.GetNXX();
155 } else {
156 // initialize
157 G4int i;
158 for (i=0; i<2; i++) {
159 distance[i] = kInfinity;
160 areacode[i] = sOutside;
161 isvalid[i] = false;
162 gxx[i].set(kInfinity, kInfinity, kInfinity);
163 }
164 }
165
166 G4ThreeVector p = ComputeLocalPoint(gp);
167 G4ThreeVector v = ComputeLocalDirection(gv);
168
169 //
170 // special case!
171 // if p is on surface, distance = 0.
172 //
173
174 if (std::fabs(p.z()) == 0.) { // if p is on the plane
175 distance[0] = 0;
176 G4ThreeVector xx = p;
177 gxx[0] = ComputeGlobalPoint(xx);
178
179 if (validate == kValidateWithTol) {
180 areacode[0] = GetAreaCode(xx);
181 if (!IsOutside(areacode[0])) {
182 isvalid[0] = true;
183 }
184 } else if (validate == kValidateWithoutTol) {
185 areacode[0] = GetAreaCode(xx, false);
186 if (IsInside(areacode[0])) {
187 isvalid[0] = true;
188 }
189 } else { // kDontValidate
190 areacode[0] = sInside;
191 isvalid[0] = true;
192 }
193
194 return 1;
195 }
196 //
197 // special case end
198 //
199
200 if (v.z() == 0) {
201
202 fCurStatWithV.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
203 isvalid[0], 0, validate, &gp, &gv);
204 return 0;
205 }
206
207 distance[0] = - (p.z() / v.z());
208
209 G4ThreeVector xx = p + distance[0]*v;
210 gxx[0] = ComputeGlobalPoint(xx);
211
212 if (validate == kValidateWithTol) {
213 areacode[0] = GetAreaCode(xx);
214 if (!IsOutside(areacode[0])) {
215 if (distance[0] >= 0) isvalid[0] = true;
216 }
217 } else if (validate == kValidateWithoutTol) {
218 areacode[0] = GetAreaCode(xx, false);
219 if (IsInside(areacode[0])) {
220 if (distance[0] >= 0) isvalid[0] = true;
221 }
222 } else { // kDontValidate
223 areacode[0] = sInside;
224 if (distance[0] >= 0) isvalid[0] = true;
225 }
226
227
228 fCurStatWithV.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
229 isvalid[0], 1, validate, &gp, &gv);
230
231#ifdef G4TWISTDEBUG
232 G4cerr << "ERROR - G4TwistTrapFlatSide::DistanceToSurface(p,v)" << G4endl;
233 G4cerr << " Name : " << GetName() << G4endl;
234 G4cerr << " xx : " << xx << G4endl;
235 G4cerr << " gxx[0] : " << gxx[0] << G4endl;
236 G4cerr << " dist[0] : " << distance[0] << G4endl;
237 G4cerr << " areacode[0] : " << areacode[0] << G4endl;
238 G4cerr << " isvalid[0] : " << isvalid[0] << G4endl;
239#endif
240 return 1;
241}
G4int
int G4int
Definition: G4Types.hh:66
G4endl
#define G4endl
Definition: G4ios.hh:52
G4cerr
G4DLLIMPORT std::ostream G4cerr
CLHEP::Hep3Vector::z
double z() const
G4TwistTrapFlatSide::GetAreaCode
virtual G4int GetAreaCode(const G4ThreeVector &xx, G4bool withTol=true)
Definition: G4TwistTrapFlatSide.cc:298
G4VTwistSurface::CurrentStatus::GetAreacode
G4int GetAreacode(G4int i) const
Definition: G4VTwistSurface.hh:260
G4VTwistSurface::CurrentStatus::GetDistance
G4double GetDistance(G4int i) const
Definition: G4VTwistSurface.hh:259
G4VTwistSurface::CurrentStatus::SetCurrentStatus
void SetCurrentStatus(G4int i, G4ThreeVector &xx, G4double &dist, G4int &areacode, G4bool &isvalid, G4int nxx, EValidate validate, const G4ThreeVector *p, const G4ThreeVector *v=0)
Definition: G4VTwistSurface.cc:1151
G4VTwistSurface::CurrentStatus::IsValid
G4bool IsValid(G4int i) const
Definition: G4VTwistSurface.hh:263
G4VTwistSurface::CurrentStatus::GetXX
G4ThreeVector GetXX(G4int i) const
Definition: G4VTwistSurface.hh:258
G4VTwistSurface::CurrentStatus::ResetfDone
void ResetfDone(EValidate validate, const G4ThreeVector *p, const G4ThreeVector *v=0)
Definition: G4VTwistSurface.cc:1191
G4VTwistSurface::sOutside
static const G4int sOutside
Definition: G4VTwistSurface.hh:228
G4VTwistSurface::ComputeLocalDirection
G4ThreeVector ComputeLocalDirection(const G4ThreeVector &gp) const
G4VTwistSurface::IsInside
G4bool IsInside(G4int areacode, G4bool testbitmode=false) const
G4VTwistSurface::ComputeLocalPoint
G4ThreeVector ComputeLocalPoint(const G4ThreeVector &gp) const
G4VTwistSurface::IsOutside
G4bool IsOutside(G4int areacode) const
G4VTwistSurface::sInside
static const G4int sInside
Definition: G4VTwistSurface.hh:229
G4VTwistSurface::GetName
virtual G4String GetName() const
Definition: G4VTwistSurface.hh:119
G4VTwistSurface::fCurStatWithV
CurrentStatus fCurStatWithV
Definition: G4VTwistSurface.hh:323
G4VTwistSurface::ComputeGlobalPoint
G4ThreeVector ComputeGlobalPoint(const G4ThreeVector &lp) const

◆ DistanceToSurface() [2/2]

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

Implements G4VTwistSurface.

Definition at line 246 of file G4TwistTrapFlatSide.cc.

250{
251 // Calculate distance to plane in local coordinate,
252 // then return distance and global intersection points.
253 //
254
255 fCurStat.ResetfDone(kDontValidate, &gp);
256
257 if (fCurStat.IsDone()) {
258 G4int i;
259 for (i=0; i<fCurStat.GetNXX(); i++) {
260 gxx[i] = fCurStat.GetXX(i);
261 distance[i] = fCurStat.GetDistance(i);
262 areacode[i] = fCurStat.GetAreacode(i);
263 }
264 return fCurStat.GetNXX();
265 } else {
266 // initialize
267 G4int i;
268 for (i=0; i<2; i++) {
269 distance[i] = kInfinity;
270 areacode[i] = sOutside;
271 gxx[i].set(kInfinity, kInfinity, kInfinity);
272 }
273 }
274
275 G4ThreeVector p = ComputeLocalPoint(gp);
276 G4ThreeVector xx;
277
278 // The plane is placed on origin with making its normal
279 // parallel to z-axis.
280 if (std::fabs(p.z()) <= 0.5 * kCarTolerance)
281 { // if p is on the plane, return 1
282 distance[0] = 0;
283 xx = p;
284 } else {
285 distance[0] = std::fabs(p.z());
286 xx.set(p.x(), p.y(), 0);
287 }
288
289 gxx[0] = ComputeGlobalPoint(xx);
290 areacode[0] = sInside;
291 G4bool isvalid = true;
292 fCurStat.SetCurrentStatus(0, gxx[0], distance[0], areacode[0],
293 isvalid, 1, kDontValidate, &gp);
294 return 1;
295
296}
G4bool
bool G4bool
Definition: G4Types.hh:67
CLHEP::Hep3Vector::x
double x() const
CLHEP::Hep3Vector::y
double y() const
G4VTwistSurface::fCurStat
CurrentStatus fCurStat
Definition: G4VTwistSurface.hh:324

◆ GetAreaCode()

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

Implements G4VTwistSurface.

Definition at line 298 of file G4TwistTrapFlatSide.cc.

300{
301
302 static const G4double ctol = 0.5 * kCarTolerance;
303 G4int areacode = sInside;
304
305 if (fAxis[0] == kXAxis && fAxis[1] == kYAxis) {
306
307 G4int yaxis = 1;
308
309 G4double wmax = xAxisMax(xx.y(), fTAlph ) ;
310 G4double wmin = -xAxisMax(xx.y(), -fTAlph ) ;
311
312 if (withTol) {
313
314 G4bool isoutside = false;
315
316 // test boundary of x-axis
317
318 if (xx.x() < wmin + ctol) {
319 areacode |= (sAxis0 & (sAxisX | sAxisMin)) | sBoundary;
320 if (xx.x() <= wmin - ctol) isoutside = true;
321
322 } else if (xx.x() > wmax - ctol) {
323 areacode |= (sAxis0 & (sAxisX | sAxisMax)) | sBoundary;
324 if (xx.x() >= wmax + ctol) isoutside = true;
325 }
326
327 // test boundary of y-axis
328
329 if (xx.y() < fAxisMin[yaxis] + ctol) {
330 areacode |= (sAxis1 & (sAxisY | sAxisMin));
331
332 if (areacode & sBoundary) areacode |= sCorner; // xx is on the corner.
333 else areacode |= sBoundary;
334 if (xx.y() <= fAxisMin[yaxis] - ctol) isoutside = true;
335
336 } else if (xx.y() > fAxisMax[yaxis] - ctol) {
337 areacode |= (sAxis1 & (sAxisY | sAxisMax));
338
339 if (areacode & sBoundary) areacode |= sCorner; // xx is on the corner.
340 else areacode |= sBoundary;
341 if (xx.y() >= fAxisMax[yaxis] + ctol) isoutside = true;
342 }
343
344 // if isoutside = true, clear inside bit.
345 // if not on boundary, add axis information.
346
347 if (isoutside) {
348 G4int tmpareacode = areacode & (~sInside);
349 areacode = tmpareacode;
350 } else if ((areacode & sBoundary) != sBoundary) {
351 areacode |= (sAxis0 & sAxisX) | (sAxis1 & sAxisY);
352 }
353
354 } else {
355
356 // boundary of x-axis
357
358 if (xx.x() < wmin ) {
359 areacode |= (sAxis0 & (sAxisX | sAxisMin)) | sBoundary;
360 } else if (xx.x() > wmax) {
361 areacode |= (sAxis0 & (sAxisX | sAxisMax)) | sBoundary;
362 }
363
364 // boundary of y-axis
365
366 if (xx.y() < fAxisMin[yaxis]) {
367 areacode |= (sAxis1 & (sAxisY | sAxisMin));
368 if (areacode & sBoundary) areacode |= sCorner; // xx is on the corner.
369 else areacode |= sBoundary;
370
371 } else if (xx.y() > fAxisMax[yaxis]) {
372 areacode |= (sAxis1 & (sAxisY | sAxisMax)) ;
373 if (areacode & sBoundary) areacode |= sCorner; // xx is on the corner.
374 else areacode |= sBoundary;
375 }
376
377 if ((areacode & sBoundary) != sBoundary) {
378 areacode |= (sAxis0 & sAxisX) | (sAxis1 & sAxisY);
379 }
380 }
381 return areacode;
382 } else {
383 G4Exception("G4TwistTrapFlatSide::GetAreaCode()",
384 "GeomSolids0001", FatalException,
385 "Feature NOT implemented !");
386 }
387
388 return areacode;
389}
FatalException
@ FatalException
Definition: G4ExceptionSeverity.hh:60
G4double
double G4double
Definition: G4Types.hh:64
G4VTwistSurface::sAxisMax
static const G4int sAxisMax
Definition: G4VTwistSurface.hh:237
G4VTwistSurface::sAxis0
static const G4int sAxis0
Definition: G4VTwistSurface.hh:243
G4VTwistSurface::sAxisMin
static const G4int sAxisMin
Definition: G4VTwistSurface.hh:236
G4VTwistSurface::sAxis1
static const G4int sAxis1
Definition: G4VTwistSurface.hh:244
G4VTwistSurface::sBoundary
static const G4int sBoundary
Definition: G4VTwistSurface.hh:230
G4VTwistSurface::sCorner
static const G4int sCorner
Definition: G4VTwistSurface.hh:231
G4VTwistSurface::sAxisY
static const G4int sAxisY
Definition: G4VTwistSurface.hh:239
G4VTwistSurface::sAxisX
static const G4int sAxisX
Definition: G4VTwistSurface.hh:238
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41

Referenced by DistanceToSurface().

◆ GetBoundaryMax()

G4double G4TwistTrapFlatSide::GetBoundaryMax ( G4double  u)
inlinevirtual

Implements G4VTwistSurface.

Definition at line 150 of file G4TwistTrapFlatSide.hh.

151{
152 return xAxisMax(y, fTAlph ) ;
153}

Referenced by GetFacets().

◆ GetBoundaryMin()

G4double G4TwistTrapFlatSide::GetBoundaryMin ( G4double  u)
inlinevirtual

Implements G4VTwistSurface.

Definition at line 144 of file G4TwistTrapFlatSide.hh.

145{
146 return -xAxisMax(y, -fTAlph ) ;
147}

Referenced by GetFacets().

◆ GetFacets()

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

Implements G4VTwistSurface.

Definition at line 486 of file G4TwistTrapFlatSide.cc.

488{
489
490 G4double x,y ; // the two parameters for the surface equation
491 G4ThreeVector p ; // a point on the surface, given by (z,u)
492
493 G4int nnode ;
494 G4int nface ;
495
496 G4double xmin,xmax ;
497
498 // calculate the (n-1)*(k-1) vertices
499
500 G4int i,j ;
501
502 for ( i = 0 ; i<n ; i++ ) {
503
504 y = -fDy + i*(2*fDy)/(n-1) ;
505
506 for ( j = 0 ; j<k ; j++ ) {
507
508 xmin = GetBoundaryMin(y) ;
509 xmax = GetBoundaryMax(y) ;
510 x = xmin + j*(xmax-xmin)/(k-1) ;
511
512 nnode = GetNode(i,j,k,n,iside) ;
513 p = SurfacePoint(x,y,true) ; // surface point in global coordinate system
514
515 xyz[nnode][0] = p.x() ;
516 xyz[nnode][1] = p.y() ;
517 xyz[nnode][2] = p.z() ;
518
519 if ( i<n-1 && j<k-1 ) {
520
521 nface = GetFace(i,j,k,n,iside) ;
522
523 if (fHandedness < 0) { // lower side
524 faces[nface][0] = GetEdgeVisibility(i,j,k,n,0,1) * ( GetNode(i ,j ,k,n,iside)+1) ;
525 faces[nface][1] = GetEdgeVisibility(i,j,k,n,1,1) * ( GetNode(i+1,j ,k,n,iside)+1) ;
526 faces[nface][2] = GetEdgeVisibility(i,j,k,n,2,1) * ( GetNode(i+1,j+1,k,n,iside)+1) ;
527 faces[nface][3] = GetEdgeVisibility(i,j,k,n,3,1) * ( GetNode(i ,j+1,k,n,iside)+1) ;
528 } else { // upper side
529 faces[nface][0] = GetEdgeVisibility(i,j,k,n,0,-1) * ( GetNode(i ,j ,k,n,iside)+1) ;
530 faces[nface][1] = GetEdgeVisibility(i,j,k,n,1,-1) * ( GetNode(i ,j+1,k,n,iside)+1) ;
531 faces[nface][2] = GetEdgeVisibility(i,j,k,n,2,-1) * ( GetNode(i+1,j+1,k,n,iside)+1) ;
532 faces[nface][3] = GetEdgeVisibility(i,j,k,n,3,-1) * ( GetNode(i+1,j ,k,n,iside)+1) ;
533 }
534
535 }
536 }
537 }
538}
G4TwistTrapFlatSide::GetBoundaryMin
virtual G4double GetBoundaryMin(G4double u)
Definition: G4TwistTrapFlatSide.hh:144
G4TwistTrapFlatSide::GetBoundaryMax
virtual G4double GetBoundaryMax(G4double u)
Definition: G4TwistTrapFlatSide.hh:150
G4TwistTrapFlatSide::SurfacePoint
virtual G4ThreeVector SurfacePoint(G4double x, G4double y, G4bool isGlobal=false)
Definition: G4TwistTrapFlatSide.hh:135
G4VTwistSurface::GetNode
G4int GetNode(G4int i, G4int j, G4int m, G4int n, G4int iside)
Definition: G4VTwistSurface.cc:922
G4VTwistSurface::GetFace
G4int GetFace(G4int i, G4int j, G4int m, G4int n, G4int iside)
Definition: G4VTwistSurface.cc:873
G4VTwistSurface::GetEdgeVisibility
G4int GetEdgeVisibility(G4int i, G4int j, G4int m, G4int n, G4int number, G4int orientation)
Definition: G4VTwistSurface.cc:987

◆ GetNormal()

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

Implements G4VTwistSurface.

Definition at line 123 of file G4TwistTrapFlatSide.cc.

125{
126 if (isGlobal) {
127 return ComputeGlobalDirection(fCurrentNormal.normal);
128 } else {
129 return fCurrentNormal.normal;
130 }
131}
G4VTwistSurface::ComputeGlobalDirection
G4ThreeVector ComputeGlobalDirection(const G4ThreeVector &lp) const

◆ GetSurfaceArea()

G4double G4TwistTrapFlatSide::GetSurfaceArea ( )
inlinevirtual

Implements G4VTwistSurface.

Definition at line 156 of file G4TwistTrapFlatSide.hh.

157{
158 return 2*(fDx1 + fDx2)*fDy ;
159}

◆ SurfacePoint()

G4ThreeVector G4TwistTrapFlatSide::SurfacePoint ( G4double  x,
G4double  y,
G4bool  isGlobal = false 
)
inlinevirtual

Implements G4VTwistSurface.

Definition at line 135 of file G4TwistTrapFlatSide.hh.

136{
137 G4ThreeVector SurfPoint ( x,y,0);
138
139 if (isGlobal) { return (fRot*SurfPoint + fTrans); }
140 return SurfPoint;
141}

Referenced by GetFacets().

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