Geant4 11.4.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4VTwistSurface.cc
Go to the documentation of this file.
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26// G4VTwistSurface implementation
27//
28// Author: Kotoyo Hoshina (Chiba University), 01.08.2002 - Created.
29// Oliver Link (CERN), 13.11.2003 - Integration in Geant4
30// from original version in Jupiter-2.5.02 application.
31// --------------------------------------------------------------------
32
33#include <iomanip>
34
35#include "G4VTwistSurface.hh"
36#include "G4GeometryTolerance.hh"
37
38const G4int G4VTwistSurface::sOutside = 0x00000000;
39const G4int G4VTwistSurface::sInside = 0x10000000;
40const G4int G4VTwistSurface::sBoundary = 0x20000000;
41const G4int G4VTwistSurface::sCorner = 0x40000000;
42const G4int G4VTwistSurface::sC0Min1Min = 0x40000101;
43const G4int G4VTwistSurface::sC0Max1Min = 0x40000201;
44const G4int G4VTwistSurface::sC0Max1Max = 0x40000202;
45const G4int G4VTwistSurface::sC0Min1Max = 0x40000102;
46const G4int G4VTwistSurface::sAxisMin = 0x00000101;
47const G4int G4VTwistSurface::sAxisMax = 0x00000202;
48const G4int G4VTwistSurface::sAxisX = 0x00000404;
49const G4int G4VTwistSurface::sAxisY = 0x00000808;
50const G4int G4VTwistSurface::sAxisZ = 0x00000C0C;
51const G4int G4VTwistSurface::sAxisRho = 0x00001010;
52const G4int G4VTwistSurface::sAxisPhi = 0x00001414;
53
54// mask
55const G4int G4VTwistSurface::sAxis0 = 0x0000FF00;
56const G4int G4VTwistSurface::sAxis1 = 0x000000FF;
57const G4int G4VTwistSurface::sSizeMask = 0x00000303;
58const G4int G4VTwistSurface::sAxisMask = 0x0000FCFC;
59const G4int G4VTwistSurface::sAreaMask = 0XF0000000;
60
61//=====================================================================
62//* constructors ------------------------------------------------------
63
64G4VTwistSurface::G4VTwistSurface(const G4String &name)
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}
88
89G4VTwistSurface::G4VTwistSurface(const G4String& name,
90 const G4RotationMatrix& rot,
91 const G4ThreeVector& tlate,
92 G4int handedness,
93 const EAxis axis0 ,
94 const EAxis axis1 ,
95 G4double axis0min,
96 G4double axis1min,
97 G4double axis0max,
98 G4double axis1max )
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}
123
124//=====================================================================
125//* Fake default constructor ------------------------------------------
126
127G4VTwistSurface::G4VTwistSurface( __void__& )
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}
136
137//=====================================================================
138//* AmIOnLeftSide -----------------------------------------------------
139
140G4int G4VTwistSurface::AmIOnLeftSide(const G4ThreeVector& me,
141 const G4ThreeVector& vec,
142 G4bool withtol)
143{
144 // AmIOnLeftSide returns phi-location of "me"
145 // (phi relation between me and vec projected on z=0 plane).
146 // If "me" is on -ve-phi-side of "vec", it returns 1.
147 // On the other hand, if "me" is on +ve-phi-side of "vec",
148 // it returns -1.
149 // (The return value represents z-coordinate of normal vector
150 // of me.cross(vec).)
151 // If me is on boundary of vec, return 0.
152
153 const G4double kAngTolerance
154 = G4GeometryTolerance::GetInstance()->GetAngularTolerance();
155
156 G4RotationMatrix unitrot;
157 const G4RotationMatrix rottol = unitrot.rotateZ(0.5*kAngTolerance);
158 const G4RotationMatrix invrottol = unitrot.rotateZ(-1.*kAngTolerance);
159
160 if (fAmIOnLeftSide.me == me
161 && fAmIOnLeftSide.vec == vec
162 && fAmIOnLeftSide.withTol == withtol)
163 {
164 return fAmIOnLeftSide.amIOnLeftSide;
165 }
166
167 fAmIOnLeftSide.me = me;
168 fAmIOnLeftSide.vec = vec;
169 fAmIOnLeftSide.withTol = withtol;
170
171 G4ThreeVector met = (G4ThreeVector(me.x(), me.y(), 0.)).unit();
172 G4ThreeVector vect = (G4ThreeVector(vec.x(), vec.y(), 0.)).unit();
173
174 G4ThreeVector ivect = invrottol * vect;
175 G4ThreeVector rvect = rottol * vect;
176
177 G4double metcrossvect = met.x() * vect.y() - met.y() * vect.x();
178
179 if (withtol)
180 {
181 if (met.x() * ivect.y() - met.y() * ivect.x() > 0 &&
182 metcrossvect >= 0) {
183 fAmIOnLeftSide.amIOnLeftSide = 1;
184 } else if (met.x() * rvect.y() - met.y() * rvect.x() < 0 &&
185 metcrossvect <= 0) {
186 fAmIOnLeftSide.amIOnLeftSide = -1;
187 } else {
188 fAmIOnLeftSide.amIOnLeftSide = 0;
189 }
190 }
191 else
192 {
193 if (metcrossvect > 0) {
194 fAmIOnLeftSide.amIOnLeftSide = 1;
195 } else if (metcrossvect < 0 ) {
196 fAmIOnLeftSide.amIOnLeftSide = -1;
197 } else {
198 fAmIOnLeftSide.amIOnLeftSide = 0;
199 }
200 }
201
202#ifdef G4TWISTDEBUG
203 G4cout << " === G4VTwistSurface::AmIOnLeftSide() =============="
204 << G4endl;
205 G4cout << " Name , returncode : " << fName << " "
206 << fAmIOnLeftSide.amIOnLeftSide << G4endl;
207 G4cout << " me, vec : " << std::setprecision(14) << me
208 << " " << vec << G4endl;
209 G4cout << " met, vect : " << met << " " << vect << G4endl;
210 G4cout << " ivec, rvec : " << ivect << " " << rvect << G4endl;
211 G4cout << " met x vect : " << metcrossvect << G4endl;
212 G4cout << " met x ivec : " << met.cross(ivect) << G4endl;
213 G4cout << " met x rvec : " << met.cross(rvect) << G4endl;
214 G4cout << " =============================================="
215 << G4endl;
216#endif
217
218 return fAmIOnLeftSide.amIOnLeftSide;
219}
220
221//=====================================================================
222//* DistanceToBoundary ------------------------------------------------
223
224G4double G4VTwistSurface::DistanceToBoundary(G4int areacode,
225 G4ThreeVector& xx,
226 const G4ThreeVector& p)
227{
228 // DistanceToBoundary
229 //
230 // return distance to nearest boundary from arbitrary point p
231 // in local coodinate.
232 // Argument areacode must be one of them:
233 // sAxis0 & sAxisMin, sAxis0 & sAxisMax,
234 // sAxis1 & sAxisMin, sAxis1 & sAxisMax.
235 //
236
237 G4ThreeVector d; // direction vector of the boundary
238 G4ThreeVector x0; // reference point of the boundary
239 G4double dist = kInfinity;
240 G4int boundarytype;
241
242 if (IsAxis0(areacode) && IsAxis1(areacode))
243 {
244 std::ostringstream message;
245 message << "Point is in the corner area." << G4endl
246 << " Point is in the corner area. This function returns"
247 << G4endl
248 << " a direction vector of a boundary line." << G4endl
249 << " areacode = " << areacode;
250 G4Exception("G4VTwistSurface::DistanceToBoundary()", "GeomSolids0003",
251 FatalException, message);
252 }
253 else if (IsAxis0(areacode) || IsAxis1(areacode))
254 {
255 GetBoundaryParameters(areacode, d, x0, boundarytype);
256 if (boundarytype == sAxisPhi)
257 {
258 G4double t = x0.getRho() / p.getRho();
259 xx.set(t*p.x(), t*p.y(), x0.z());
260 dist = (xx - p).mag();
261 }
262 else
263 {
264 // linear boundary
265 // sAxisX, sAxisY, sAxisZ, sAxisRho
266 dist = DistanceToLine(p, x0, d, xx);
267 }
268 }
269 else
270 {
271 std::ostringstream message;
272 message << "Bad areacode of boundary." << G4endl
273 << " areacode = " << areacode;
274 G4Exception("G4VTwistSurface::DistanceToBoundary()", "GeomSolids0003",
275 FatalException, message);
276 }
277 return dist;
278}
279
280//=====================================================================
281//* DistanceToIn ------------------------------------------------------
282
283G4double G4VTwistSurface::DistanceToIn(const G4ThreeVector& gp,
284 const G4ThreeVector& gv,
285 G4ThreeVector& gxxbest)
286{
287#ifdef G4TWISTDEBUG
288 G4cout << " ~~~~ G4VTwistSurface::DistanceToIn(p,v) - Start ~~~~" << G4endl;
289 G4cout << " Name : " << fName << G4endl;
290 G4cout << " gp : " << gp << G4endl;
291 G4cout << " gv : " << gv << G4endl;
292 G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
293#endif
294
295 G4ThreeVector gxx[G4VSURFACENXX];
296 G4double distance[G4VSURFACENXX] ;
297 G4int areacode[G4VSURFACENXX] ;
298 G4bool isvalid[G4VSURFACENXX] ;
299
300 for (G4int i = 0 ; i<G4VSURFACENXX ; ++i )
301 {
302 distance[i] = kInfinity ;
303 areacode[i] = sOutside ;
304 isvalid[i] = false ;
305 }
306
307 G4double bestdistance = kInfinity;
308#ifdef G4TWISTDEBUG
309 G4int besti = -1;
310#endif
311 G4ThreeVector bestgxx(kInfinity, kInfinity, kInfinity);
312
313 G4int nxx = DistanceToSurface(gp, gv, gxx, distance, areacode,
314 isvalid, kValidateWithTol);
315
316 for (G4int i=0; i<nxx; ++i)
317 {
318
319 // skip this intersection if:
320 // - invalid intersection
321 // - particle goes outword the surface
322
323 if (!isvalid[i])
324 {
325 // xx[i] is sOutside or distance[i] < 0
326 continue;
327 }
328
329 G4ThreeVector normal = GetNormal(gxx[i], true);
330
331 if ((normal * gv) >= 0)
332 {
333
334#ifdef G4TWISTDEBUG
335 G4cout << " G4VTwistSurface::DistanceToIn(p,v): "
336 << "particle goes outword the surface." << G4endl;
337#endif
338 continue;
339 }
340
341 //
342 // accept this intersection if the intersection is inside.
343 //
344
345 if (IsInside(areacode[i]))
346 {
347 if (distance[i] < bestdistance)
348 {
349 bestdistance = distance[i];
350 bestgxx = gxx[i];
351#ifdef G4TWISTDEBUG
352 besti = i;
353 G4cout << " G4VTwistSurface::DistanceToIn(p,v): "
354 << " areacode sInside name, distance = "
355 << fName << " "<< bestdistance << G4endl;
356#endif
357 }
358
359 //
360 // else, the intersection is on boundary or corner.
361 //
362
363 }
364 else
365 {
366 G4VTwistSurface* neighbours[2];
367 G4bool isaccepted[2] = {false, false};
368 G4int nneighbours = GetNeighbours(areacode[i], neighbours);
369
370 for (G4int j=0; j<nneighbours; ++j)
371 {
372 // if on corner, nneighbours = 2.
373 // if on boundary, nneighbours = 1.
374
375 G4ThreeVector tmpgxx[G4VSURFACENXX];
376 G4double tmpdist[G4VSURFACENXX] ;
377 G4int tmpareacode[G4VSURFACENXX] ;
378 G4bool tmpisvalid[G4VSURFACENXX] ;
379
380 for (G4int l = 0 ; l<G4VSURFACENXX ; ++l )
381 {
382 tmpdist[l] = kInfinity ;
383 tmpareacode[l] = sOutside ;
384 tmpisvalid[l] = false ;
385 }
386
387 G4int tmpnxx = neighbours[j]->DistanceToSurface(
388 gp, gv, tmpgxx, tmpdist,
389 tmpareacode, tmpisvalid,
390 kValidateWithTol);
391 G4ThreeVector neighbournormal;
392
393 for (G4int k=0; k< tmpnxx; ++k)
394 {
395 //
396 // if tmpxx[k] is valid && sInside, the final winner must
397 // be neighbour surface. return kInfinity.
398 // else , choose tmpxx on same boundary of xx, then check normal
399 //
400
401 if (IsInside(tmpareacode[k]))
402 {
403#ifdef G4TWISTDEBUG
404 G4cout << " G4VTwistSurface:DistanceToIn(p,v): "
405 << " intersection "<< tmpgxx[k] << G4endl
406 << " is inside of neighbour surface of " << fName
407 << " . returning kInfinity." << G4endl;
408 G4cout << "~~ G4VTwistSurface::DistanceToIn(p,v) - return ~~"
409 << G4endl;
410 G4cout << " No intersections " << G4endl;
411 G4cout << " Name : " << fName << G4endl;
412 G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
413 << G4endl;
414#endif
415 if (tmpisvalid[k]) { return kInfinity; }
416 continue;
417
418 //
419 // if tmpxx[k] is valid && sInside, the final winner must
420 // be neighbour surface. return .
421 //
422
423 }
424 if (IsSameBoundary(this,areacode[i],
425 neighbours[j], tmpareacode[k]))
426 {
427 // tmpxx[k] is same boundary (or corner) of xx.
428
429 neighbournormal = neighbours[j]->GetNormal(tmpgxx[k], true);
430 if (neighbournormal * gv < 0) { isaccepted[j] = true; }
431 }
432 }
433
434 // if nneighbours = 1, chabge isaccepted[1] before
435 // exiting neighboursurface loop.
436
437 if (nneighbours == 1) { isaccepted[1] = true; }
438
439 } // neighboursurface loop end
440
441 // now, we can accept xx intersection
442
443 if (isaccepted[0] && isaccepted[1])
444 {
445 if (distance[i] < bestdistance)
446 {
447 bestdistance = distance[i];
448 gxxbest = gxx[i];
449#ifdef G4TWISTDEBUG
450 besti = i;
451 G4cout << " G4VTwistSurface::DistanceToIn(p,v): "
452 << " areacode sBoundary & sBoundary distance = "
453 << fName << " " << distance[i] << G4endl;
454#endif
455 }
456 }
457 } // else end
458 } // intersection loop end
459
460 gxxbest = bestgxx;
461
462#ifdef G4TWISTDEBUG
463 if (besti < 0)
464 {
465 G4cout << "~~~ G4VTwistSurface::DistanceToIn(p,v) - return ~~~" << G4endl;
466 G4cout << " No intersections " << G4endl;
467 G4cout << " Name : " << fName << G4endl;
468 G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
469 }
470 else
471 {
472 G4cout << "~~~ G4VTwistSurface::DistanceToIn(p,v) : return ~~~" << G4endl;
473 G4cout << " Name, i : " << fName << " , " << besti << G4endl;
474 G4cout << " gxx[i] : " << gxxbest << G4endl;
475 G4cout << " bestdist : " << bestdistance << G4endl;
476 G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
477 }
478
479#endif
480
481 return bestdistance;
482}
483
484//=====================================================================
485//* DistanceToOut(p, v) -----------------------------------------------
486
487G4double G4VTwistSurface::DistanceToOut(const G4ThreeVector& gp,
488 const G4ThreeVector& gv,
489 G4ThreeVector& gxxbest)
490{
491#ifdef G4TWISTDEBUG
492 G4cout << "~~~~~ G4VTwistSurface::DistanceToOut(p,v) - Start ~~~~" << G4endl;
493 G4cout << " Name : " << fName << G4endl;
494 G4cout << " gp : " << gp << G4endl;
495 G4cout << " gv : " << gv << G4endl;
496 G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
497#endif
498
499 G4ThreeVector gxx[G4VSURFACENXX];
500 G4double distance[G4VSURFACENXX];
501 G4int areacode[G4VSURFACENXX];
502 G4bool isvalid[G4VSURFACENXX];
503
504 for ( G4int i = 0 ; i<G4VSURFACENXX ; ++i )
505 {
506 distance[i] = kInfinity ;
507 areacode[i] = sOutside ;
508 isvalid[i] = false ;
509 }
510
511 G4int nxx;
512 G4double bestdistance = kInfinity;
513
514 nxx = DistanceToSurface(gp, gv, gxx, distance, areacode,
515 isvalid, kValidateWithTol);
516
517 for (G4int i=0; i<nxx; ++i)
518 {
519 if (!(isvalid[i]))
520 {
521 continue;
522 }
523
524 G4ThreeVector normal = GetNormal(gxx[i], true);
525 if (normal * gv <= 0)
526 {
527 // particle goes toword inside of solid, return kInfinity
528#ifdef G4TWISTDEBUG
529 G4cout << " G4VTwistSurface::DistanceToOut(p,v): normal*gv < 0 "
530 << fName << " " << normal
531 << G4endl;
532#endif
533 }
534 else
535 {
536 // gxx[i] is accepted.
537 if (distance[i] < bestdistance)
538 {
539 bestdistance = distance[i];
540 gxxbest = gxx[i];
541 }
542 }
543 }
544
545#ifdef G4TWISTDEBUG
546 if (besti < 0)
547 {
548 G4cout << "~~ G4VTwistSurface::DistanceToOut(p,v) - return ~~" << G4endl;
549 G4cout << " No intersections " << G4endl;
550 G4cout << " Name : " << fName << G4endl;
551 G4cout << " bestdist : " << bestdistance << G4endl;
552 G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
553 }
554 else
555 {
556 G4cout << "~~ G4VTwistSurface::DistanceToOut(p,v) : return ~~" << G4endl;
557 G4cout << " Name, i : " << fName << " , " << i << G4endl;
558 G4cout << " gxx[i] : " << gxxbest << G4endl;
559 G4cout << " bestdist : " << bestdistance << G4endl;
560 G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
561 }
562#endif
563
564 return bestdistance;
565}
566
567//=====================================================================
568//* DistanceTo(p) -----------------------------------------------------
569
570G4double G4VTwistSurface::DistanceTo(const G4ThreeVector& gp,
571 G4ThreeVector& gxxbest)
572{
573#ifdef G4TWISTDEBUG
574 G4cout << "~~~~~ G4VTwistSurface::DistanceTo(p) - Start ~~~~~~~~~" << G4endl;
575 G4cout << " Name : " << fName << G4endl;
576 G4cout << " gp : " << gp << G4endl;
577 G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
578#endif
579
580
581 G4ThreeVector gxx[G4VSURFACENXX];
582 G4double distance[G4VSURFACENXX] ;
583 G4int areacode[G4VSURFACENXX] ;
584
585 for (G4int i = 0 ; i<G4VSURFACENXX ; ++i )
586 {
587 distance[i] = kInfinity ;
588 areacode[i] = sOutside ;
589 }
590
591 DistanceToSurface(gp, gxx, distance, areacode);
592 gxxbest = gxx[0];
593
594#ifdef G4TWISTDEBUG
595 G4cout << "~~~~~ G4VTwistSurface::DistanceTo(p) - return ~~~~~~~~" << G4endl;
596 G4cout << " Name : " << fName << G4endl;
597 G4cout << " gxx : " << gxxbest << G4endl;
598 G4cout << " bestdist : " << distance[0] << G4endl;
599 G4cout << "~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~" << G4endl;
600#endif
601
602 return distance[0];
603}
604
605//=====================================================================
606//* IsSameBoundary ----------------------------------------------------
607
608G4bool
609G4VTwistSurface::IsSameBoundary(G4VTwistSurface* surf1, G4int areacode1,
610 G4VTwistSurface* surf2, G4int areacode2 ) const
611{
612 //
613 // IsSameBoundary
614 //
615 // checking tool whether two boundaries on different surfaces are same or not.
616 //
617
618 G4bool testbitmode = true;
619 G4bool iscorner[2] = {IsCorner(areacode1, testbitmode),
620 IsCorner(areacode2, testbitmode)};
621
622 if (iscorner[0] && iscorner[1])
623 {
624 // on corner
625 G4ThreeVector corner1 =
626 surf1->ComputeGlobalPoint(surf1->GetCorner(areacode1));
627 G4ThreeVector corner2 =
628 surf2->ComputeGlobalPoint(surf2->GetCorner(areacode2));
629
630 return (corner1 - corner2).mag() < kCarTolerance;
631 }
632 if ((IsBoundary(areacode1, testbitmode) && (!iscorner[0])) &&
633 (IsBoundary(areacode2, testbitmode) && (!iscorner[1])))
634 {
635 // on boundary
636 G4ThreeVector d1, d2, ld1, ld2;
637 G4ThreeVector x01, x02, lx01, lx02;
638 G4int type1, type2;
639 surf1->GetBoundaryParameters(areacode1, ld1, lx01, type1);
640 surf2->GetBoundaryParameters(areacode2, ld2, lx02, type2);
641
642 x01 = surf1->ComputeGlobalPoint(lx01);
643 x02 = surf2->ComputeGlobalPoint(lx02);
644 d1 = surf1->ComputeGlobalDirection(ld1);
645 d2 = surf2->ComputeGlobalDirection(ld2);
646
647 return (x01 - x02).mag() < kCarTolerance
648 && (d1 - d2).mag() < kCarTolerance;
649 }
650 return false;
651}
652
653//=====================================================================
654//* GetBoundaryParameters ---------------------------------------------
655
656void G4VTwistSurface::GetBoundaryParameters(const G4int& areacode,
657 G4ThreeVector& d,
658 G4ThreeVector& x0,
659 G4int& boundarytype) const
660{
661 // areacode must be one of them:
662 // sAxis0 & sAxisMin, sAxis0 & sAxisMax,
663 // sAxis1 & sAxisMin, sAxis1 & sAxisMax.
664
665 for (const auto & boundary : fBoundaries)
666 {
667 if (boundary.GetBoundaryParameters(areacode, d, x0, boundarytype))
668 {
669 return;
670 }
671 }
672
673 std::ostringstream message;
674 message << "Not registered boundary." << G4endl
675 << " Boundary at areacode " << std::hex << areacode
676 << std::dec << G4endl
677 << " is not registered.";
678 G4Exception("G4VTwistSurface::GetBoundaryParameters()", "GeomSolids0002",
679 FatalException, message);
680}
681
682//=====================================================================
683//* GetBoundaryAtPZ ---------------------------------------------------
684
685G4ThreeVector G4VTwistSurface::GetBoundaryAtPZ(G4int areacode,
686 const G4ThreeVector& p) const
687{
688 // areacode must be one of them:
689 // sAxis0 & sAxisMin, sAxis0 & sAxisMax,
690 // sAxis1 & sAxisMin, sAxis1 & sAxisMax.
691
692 if (((areacode & sAxis0) != 0) && ((areacode & sAxis1) != 0))
693 {
694 std::ostringstream message;
695 message << "Point is in the corner area." << G4endl
696 << " This function returns "
697 << "a direction vector of a boundary line." << G4endl
698 << " areacode = " << areacode;
699 G4Exception("G4VTwistSurface::GetBoundaryAtPZ()", "GeomSolids0003",
700 FatalException, message);
701 }
702
703 G4ThreeVector d;
704 G4ThreeVector x0;
705 G4int boundarytype = 0;
706 G4bool found = false;
707
708 for (const auto & boundary : fBoundaries)
709 {
710 if (boundary.GetBoundaryParameters(areacode, d, x0, boundarytype))
711 {
712 found = true;
713 continue;
714 }
715 }
716
717 if (!found)
718 {
719 std::ostringstream message;
720 message << "Not registered boundary." << G4endl
721 << " Boundary at areacode " << areacode << G4endl
722 << " is not registered.";
723 G4Exception("G4VTwistSurface::GetBoundaryAtPZ()", "GeomSolids0002",
724 FatalException, message);
725 }
726
727 if (((boundarytype & sAxisPhi) == sAxisPhi) ||
728 ((boundarytype & sAxisRho) == sAxisRho))
729 {
730 std::ostringstream message;
731 message << "Not a z-depended line boundary." << G4endl
732 << " Boundary at areacode " << areacode << G4endl
733 << " is not a z-depended line.";
734 G4Exception("G4VTwistSurface::GetBoundaryAtPZ()", "GeomSolids0002",
735 FatalException, message);
736 }
737 return ((p.z() - x0.z()) / d.z()) * d + x0;
738}
739
740//=====================================================================
741//* SetCorner ---------------------------------------------------------
742
743void G4VTwistSurface::SetCorner(G4int areacode,
744 G4double x, G4double y, G4double z)
745{
746 if ((areacode & sCorner) != sCorner)
747 {
748 std::ostringstream message;
749 message << "Area code must represents corner." << G4endl
750 << " areacode " << areacode;
751 G4Exception("G4VTwistSurface::SetCorner()", "GeomSolids0002",
752 FatalException, message);
753 }
754
755 if ((areacode & sC0Min1Min) == sC0Min1Min) {
756 fCorners[0].set(x, y, z);
757 } else if ((areacode & sC0Max1Min) == sC0Max1Min) {
758 fCorners[1].set(x, y, z);
759 } else if ((areacode & sC0Max1Max) == sC0Max1Max) {
760 fCorners[2].set(x, y, z);
761 } else if ((areacode & sC0Min1Max) == sC0Min1Max) {
762 fCorners[3].set(x, y, z);
763 }
764}
765
766//=====================================================================
767//* GetBoundaryAxis ---------------------------------------------------
768
769void G4VTwistSurface::GetBoundaryAxis(G4int areacode, EAxis axis[]) const
770{
771 if ((areacode & sBoundary) != sBoundary) {
772 G4Exception("G4VTwistSurface::GetBoundaryAxis()", "GeomSolids0003",
773 FatalException, "Not located on a boundary!");
774 }
775 for (G4int i=0; i<2; ++i)
776 {
777 G4int whichaxis = 0 ;
778 if (i == 0) {
779 whichaxis = sAxis0;
780 } else if (i == 1) {
781 whichaxis = sAxis1;
782 }
783
784 // extracted axiscode of whichaxis
785 G4int axiscode = whichaxis & sAxisMask & areacode ;
786 if (axiscode != 0) {
787 if (axiscode == (whichaxis & sAxisX)) {
788 axis[i] = kXAxis;
789 } else if (axiscode == (whichaxis & sAxisY)) {
790 axis[i] = kYAxis;
791 } else if (axiscode == (whichaxis & sAxisZ)) {
792 axis[i] = kZAxis;
793 } else if (axiscode == (whichaxis & sAxisRho)) {
794 axis[i] = kRho;
795 } else if (axiscode == (whichaxis & sAxisPhi)) {
796 axis[i] = kPhi;
797 } else {
798 std::ostringstream message;
799 message << "Not supported areacode." << G4endl
800 << " areacode " << areacode;
801 G4Exception("G4VTwistSurface::GetBoundaryAxis()", "GeomSolids0001",
802 FatalException, message);
803 }
804 }
805 }
806}
807
808//=====================================================================
809//* SetBoundaryLimit --------------------------------------------------
810
811void G4VTwistSurface::GetBoundaryLimit(G4int areacode, G4double limit[]) const
812{
813 if ((areacode & sCorner) != 0) {
814 if ((areacode & sC0Min1Min) != 0) {
815 limit[0] = fAxisMin[0];
816 limit[1] = fAxisMin[1];
817 } else if ((areacode & sC0Max1Min) != 0) {
818 limit[0] = fAxisMax[0];
819 limit[1] = fAxisMin[1];
820 } else if ((areacode & sC0Max1Max) != 0) {
821 limit[0] = fAxisMax[0];
822 limit[1] = fAxisMax[1];
823 } else if ((areacode & sC0Min1Max) != 0) {
824 limit[0] = fAxisMin[0];
825 limit[1] = fAxisMax[1];
826 }
827 } else if ((areacode & sBoundary) != 0) {
828 if ((areacode & (sAxis0 | sAxisMin)) != 0) {
829 limit[0] = fAxisMin[0];
830 } else if ((areacode & (sAxis1 | sAxisMin)) != 0) {
831 limit[0] = fAxisMin[1];
832 } else if ((areacode & (sAxis0 | sAxisMax)) != 0) {
833 limit[0] = fAxisMax[0];
834 } else if ((areacode & (sAxis1 | sAxisMax)) != 0) {
835 limit[0] = fAxisMax[1];
836 }
837 } else {
838 std::ostringstream message;
839 message << "Not located on a boundary!" << G4endl
840 << " areacode " << areacode;
841 G4Exception("G4VTwistSurface::GetBoundaryLimit()", "GeomSolids1002",
842 JustWarning, message);
843 }
844}
845
846//=====================================================================
847//* SetBoundary -------------------------------------------------------
848
849void G4VTwistSurface::SetBoundary(const G4int& axiscode,
850 const G4ThreeVector& direction,
851 const G4ThreeVector& x0,
852 const G4int& boundarytype)
853{
854 G4int code = (~sAxisMask) & axiscode;
855 if ((code == (sAxis0 & sAxisMin)) ||
856 (code == (sAxis0 & sAxisMax)) ||
857 (code == (sAxis1 & sAxisMin)) ||
858 (code == (sAxis1 & sAxisMax)))
859 {
860 G4bool done = false;
861 for (auto & boundary : fBoundaries)
862 {
863 if (boundary.IsEmpty())
864 {
865 boundary.SetFields(axiscode, direction, x0, boundarytype);
866 done = true;
867 break;
868 }
869 }
870
871 if (!done)
872 {
873 G4Exception("G4VTwistSurface::SetBoundary()", "GeomSolids0003",
874 FatalException, "Number of boundary exceeding 4!");
875 }
876 }
877 else
878 {
879 std::ostringstream message;
880 message << "Invalid axis-code." << G4endl
881 << " axiscode = "
882 << std::hex << axiscode << std::dec;
883 G4Exception("G4VTwistSurface::SetBoundary()", "GeomSolids0003",
884 FatalException, message);
885 }
886}
887
888//=====================================================================
889//* GetFace -----------------------------------------------------------
890
891G4int G4VTwistSurface::GetFace( G4int i, G4int j, G4int k,
892 G4int n, G4int iside )
893{
894 // this is the face mapping function
895 // (i,j) -> face number
896
897 if ( iside == 0 ) { return i * ( k - 1 ) + j ; }
898 if ( iside == 1 ) { return (k-1)*(k-1) + i*(k-1) + j ; }
899 if ( iside == 2 ) { return 2*(k-1)*(k-1) + i*(k-1) + j ; }
900 if ( iside == 3 ) { return 2*(k-1)*(k-1) + (n-1)*(k-1) + i*(k-1) + j ; }
901 if ( iside == 4 ) { return 2*(k-1)*(k-1) + 2*(n-1)*(k-1) + i*(k-1) + j ; }
902 if ( iside == 5 ) { return 2*(k-1)*(k-1) + 3*(n-1)*(k-1) + i*(k-1) + j ; }
903
904 std::ostringstream message;
905 message << "Not correct side number: "
906 << GetName() << G4endl
907 << "iside is " << iside << " but should be "
908 << "0,1,2,3,4 or 5" << ".";
909 G4Exception("G4TwistSurface::G4GetFace()", "GeomSolids0002",
910 FatalException, message);
911
912 return -1 ; // wrong face
913}
914
915//=====================================================================
916//* GetNode -----------------------------------------------------------
917
918G4int G4VTwistSurface::GetNode( G4int i, G4int j, G4int k,
919 G4int n, G4int iside )
920{
921 // this is the node mapping function
922 // (i,j) -> node number
923 // Depends on the side iside and the used meshing of the surface
924
925 if ( iside == 0 )
926 {
927 // lower endcap is kxk squared.
928 // n = k
929 return i * k + j ;
930 }
931 if ( iside == 1 )
932 {
933 // upper endcap is kxk squared. Shift by k*k
934 // n = k
935 return k*k + i*k + j ;
936 }
937 if ( iside == 2 )
938 {
939 // front side.
940 if ( i == 0 ) { return j ; }
941 if ( i == n-1 ) { return k*k + j ; }
942 return 2*k*k + 4*(i-1)*(k-1) + j ;
943 }
944 if ( iside == 3 )
945 {
946 // right side
947 if ( i == 0 ) { return (j+1)*k - 1 ; }
948 if ( i == n-1 ) { return k*k + (j+1)*k - 1 ; }
949 return 2*k*k + 4*(i-1)*(k-1) + (k-1) + j ;
950 }
951 if ( iside == 4 )
952 {
953 // back side
954 if ( i == 0 ) { return k*k - 1 - j ; } // reversed order
955 if ( i == n-1 ) { return 2*k*k - 1 - j ; } // reversed order
956 return 2*k*k + 4*(i-1)*(k-1) + 2*(k-1) + j ; // normal order
957 }
958 if ( iside == 5 )
959 {
960 // left side
961 if ( i == 0 ) { return k*k - (j+1)*k ; } // reversed order
962 if ( i == n-1) { return 2*k*k - (j+1)*k ; } // reverded order
963 if ( j == k-1 ) { return 2*k*k + 4*(i-1)*(k-1) ; } // special case
964 return 2*k*k + 4*(i-1)*(k-1) + 3*(k-1) + j ; // normal order
965 }
966
967 std::ostringstream message;
968 message << "Not correct side number: "
969 << GetName() << G4endl
970 << "iside is " << iside << " but should be "
971 << "0,1,2,3,4 or 5" << ".";
972 G4Exception("G4TwistSurface::G4GetNode()", "GeomSolids0002",
973 FatalException, message);
974
975 return -1 ; // wrong node
976}
977
978//=====================================================================
979//* GetEdgeVisiblility ------------------------------------------------
980
981G4int G4VTwistSurface::GetEdgeVisibility( G4int i, G4int j, G4int k, G4int n,
982 G4int number, G4int orientation )
983{
984 // clockwise filling -> positive orientation
985 // counter clockwise filling -> negative orientation
986
987 //
988 // d C c
989 // +------+
990 // | |
991 // | |
992 // | |
993 // D | |B
994 // | |
995 // | |
996 // | |
997 // +------+
998 // a A b
999 //
1000 // a = +--+ A = ---+
1001 // b = --++ B = --+-
1002 // c = -++- C = -+--
1003 // d = ++-- D = +---
1004
1005
1006 // check first invisible faces
1007
1008 if ( ( i>0 && i<n-2 ) && ( j>0 && j<k-2 ) )
1009 {
1010 return -1 ; // always invisible, signs: ----
1011 }
1012
1013 // change first the vertex number (depends on the orientation)
1014 // 0,1,2,3 -> 3,2,1,0
1015 if ( orientation < 0 ) { number = ( 3 - number ) ; }
1016
1017 // check true edges
1018 if ( ( j>=1 && j<=k-3 ) )
1019 {
1020 if ( i == 0 ) // signs (A): ---+
1021 {
1022 return ( number == 3 ) ? 1 : -1 ;
1023 }
1024
1025 if ( i == n-2 ) // signs (C): -+--
1026 {
1027 return ( number == 1 ) ? 1 : -1 ;
1028 }
1029
1030 std::ostringstream message;
1031 message << "Not correct face number: " << GetName() << " !";
1032 G4Exception("G4TwistSurface::G4GetEdgeVisibility()",
1033 "GeomSolids0003", FatalException, message);
1034 }
1035
1036 if ( ( i>=1 && i<=n-3 ) )
1037 {
1038 if ( j == 0 ) // signs (D): +---
1039 {
1040 return ( number == 0 ) ? 1 : -1 ;
1041 }
1042
1043 if ( j == k-2 ) // signs (B): --+-
1044 {
1045 return ( number == 2 ) ? 1 : -1 ;
1046 }
1047
1048 std::ostringstream message;
1049 message << "Not correct face number: " << GetName() << " !";
1050 G4Exception("G4TwistSurface::G4GetEdgeVisibility()",
1051 "GeomSolids0003", FatalException, message);
1052 }
1053
1054 // now the corners
1055 if ( i == 0 && j == 0 ) // signs (a) : +--+
1056 {
1057 return ( number == 0 || number == 3 ) ? 1 : -1 ;
1058 }
1059 if ( i == 0 && j == k-2 ) // signs (b) : --++
1060 {
1061 return ( number == 2 || number == 3 ) ? 1 : -1 ;
1062 }
1063 if ( i == n-2 && j == k-2 ) // signs (c) : -++-
1064 {
1065 return ( number == 1 || number == 2 ) ? 1 : -1 ;
1066 }
1067 if ( i == n-2 && j == 0 ) // signs (d) : ++--
1068 {
1069 return ( number == 0 || number == 1 ) ? 1 : -1 ;
1070 }
1071
1072 std::ostringstream message;
1073 message << "Not correct face number: " << GetName() << " !";
1074 G4Exception("G4TwistSurface::G4GetEdgeVisibility()", "GeomSolids0003",
1075 FatalException, message);
1076
1077 return 0 ;
1078}
1079
1080
1081//=====================================================================
1082//* DebugPrint --------------------------------------------------------
1083
1084void G4VTwistSurface::DebugPrint() const
1085{
1086 G4ThreeVector A = fRot * GetCorner(sC0Min1Min) + fTrans;
1087 G4ThreeVector B = fRot * GetCorner(sC0Max1Min) + fTrans;
1088 G4ThreeVector C = fRot * GetCorner(sC0Max1Max) + fTrans;
1089 G4ThreeVector D = fRot * GetCorner(sC0Min1Max) + fTrans;
1090
1091 G4cout << "/* G4VTwistSurface::DebugPrint():--------------------------"
1092 << G4endl;
1093 G4cout << "/* Name = " << fName << G4endl;
1094 G4cout << "/* Axis = " << std::hex << fAxis[0] << " "
1095 << std::hex << fAxis[1]
1096 << " (0,1,2,3,5 = kXAxis,kYAxis,kZAxis,kRho,kPhi)"
1097 << std::dec << G4endl;
1098 G4cout << "/* BoundaryLimit(in local) fAxis0(min, max) = ("<<fAxisMin[0]
1099 << ", " << fAxisMax[0] << ")" << G4endl;
1100 G4cout << "/* BoundaryLimit(in local) fAxis1(min, max) = ("<<fAxisMin[1]
1101 << ", " << fAxisMax[1] << ")" << G4endl;
1102 G4cout << "/* Cornar point sC0Min1Min = " << A << G4endl;
1103 G4cout << "/* Cornar point sC0Max1Min = " << B << G4endl;
1104 G4cout << "/* Cornar point sC0Max1Max = " << C << G4endl;
1105 G4cout << "/* Cornar point sC0Min1Max = " << D << G4endl;
1106 G4cout << "/*---------------------------------------------------------"
1107 << G4endl;
1108}
1109
1110//=====================================================================
1111// G4VTwistSurface::CurrentStatus class
1112//=====================================================================
1113
1114//=====================================================================
1115//* CurrentStatus::CurrentStatus --------------------------------------
1116
1117G4VTwistSurface::CurrentStatus::CurrentStatus()
1118{
1119 for (size_t i=0; i<G4VSURFACENXX; ++i)
1120 {
1121 fDistance[i] = kInfinity;
1122 fAreacode[i] = sOutside;
1123 fIsValid[i] = false;
1124 fXX[i].set(kInfinity, kInfinity, kInfinity);
1125 }
1126 fNXX = 0;
1127 fLastp.set(kInfinity, kInfinity, kInfinity);
1128 fLastv.set(kInfinity, kInfinity, kInfinity);
1129 fLastValidate = kUninitialized;
1130 fDone = false;
1131}
1132
1133//=====================================================================
1134//* CurrentStatus::~CurrentStatus -------------------------------------
1135
1136G4VTwistSurface::CurrentStatus::~CurrentStatus()
1137= default;
1138
1139//=====================================================================
1140//* CurrentStatus::SetCurrentStatus -----------------------------------
1141
1142void
1143G4VTwistSurface::CurrentStatus::SetCurrentStatus(G4int i,
1144 G4ThreeVector& xx,
1145 G4double& dist,
1146 G4int& areacode,
1147 G4bool& isvalid,
1148 G4int nxx,
1149 EValidate validate,
1150 const G4ThreeVector* p,
1151 const G4ThreeVector* v)
1152{
1153 fDistance[i] = dist;
1154 fAreacode[i] = areacode;
1155 fIsValid[i] = isvalid;
1156 fXX[i] = xx;
1157 fNXX = nxx;
1158 fLastValidate = validate;
1159 if (p != nullptr)
1160 {
1161 fLastp = *p;
1162 }
1163 else
1164 {
1165 G4Exception("G4VTwistSurface::CurrentStatus::SetCurrentStatus()",
1166 "GeomSolids0003", FatalException, "SetCurrentStatus: p = 0!");
1167 }
1168 if (v != nullptr)
1169 {
1170 fLastv = *v;
1171 }
1172 else
1173 {
1174 fLastv.set(kInfinity, kInfinity, kInfinity);
1175 }
1176 fDone = true;
1177}
1178
1179//=====================================================================
1180//* CurrentStatus::ResetfDone -----------------------------------------
1181
1182void
1183G4VTwistSurface::CurrentStatus::ResetfDone(EValidate validate,
1184 const G4ThreeVector* p,
1185 const G4ThreeVector* v)
1186
1187{
1188 if (validate == fLastValidate && p != nullptr && *p == fLastp)
1189 {
1190 if (v == nullptr || (*v == fLastv)) { return; }
1191 }
1192 G4ThreeVector xx(kInfinity, kInfinity, kInfinity);
1193 for (size_t i=0; i<G4VSURFACENXX; ++i)
1194 {
1195 fDistance[i] = kInfinity;
1196 fAreacode[i] = sOutside;
1197 fIsValid[i] = false;
1198 fXX[i] = xx; // bug in old code ( was fXX[i] = xx[i] )
1199 }
1200 fNXX = 0;
1201 fLastp.set(kInfinity, kInfinity, kInfinity);
1202 fLastv.set(kInfinity, kInfinity, kInfinity);
1203 fLastValidate = kUninitialized;
1204 fDone = false;
1205}
1206
1207//=====================================================================
1208//* CurrentStatus::DebugPrint -----------------------------------------
1209
1210void
1211G4VTwistSurface::CurrentStatus::DebugPrint() const
1212{
1213 G4cout << "CurrentStatus::Dist0,1= " << fDistance[0]
1214 << " " << fDistance[1] << " areacode = " << fAreacode[0]
1215 << " " << fAreacode[1] << G4endl;
1216}
1217
1218//=====================================================================
1219// G4VTwistSurface::Boundary class
1220//=====================================================================
1221
1222//=====================================================================
1223//* Boundary::SetFields -----------------------------------------------
1224
1225void
1226G4VTwistSurface::Boundary::SetFields(const G4int& areacode,
1227 const G4ThreeVector& d,
1228 const G4ThreeVector& x0,
1229 const G4int& boundarytype)
1230{
1231 fBoundaryAcode = areacode;
1232 fBoundaryDirection = d;
1233 fBoundaryX0 = x0;
1234 fBoundaryType = boundarytype;
1235}
1236
1237//=====================================================================
1238//* Boundary::IsEmpty -------------------------------------------------
1239
1240G4bool G4VTwistSurface::Boundary::IsEmpty() const
1241{
1242 return fBoundaryAcode == -1;
1243}
1244
1245//=====================================================================
1246//* Boundary::GetBoundaryParameters -----------------------------------
1247
1248G4bool
1249G4VTwistSurface::Boundary::GetBoundaryParameters(const G4int& areacode,
1250 G4ThreeVector& d,
1251 G4ThreeVector& x0,
1252 G4int& boundarytype) const
1253{
1254 // areacode must be one of them:
1255 // sAxis0 & sAxisMin, sAxis0 & sAxisMax,
1256 // sAxis1 & sAxisMin, sAxis1 & sAxisMax
1257 //
1258 if (((areacode & sAxis0) != 0) && ((areacode & sAxis1) != 0))
1259 {
1260 std::ostringstream message;
1261 message << "Located in the corner area." << G4endl
1262 << " This function returns a direction vector of "
1263 << "a boundary line." << G4endl
1264 << " areacode = " << areacode;
1265 G4Exception("G4VTwistSurface::Boundary::GetBoundaryParameters()",
1266 "GeomSolids0003", FatalException, message);
1267 }
1268 if ((areacode & sSizeMask) != (fBoundaryAcode & sSizeMask))
1269 {
1270 return false;
1271 }
1272 d = fBoundaryDirection;
1273 x0 = fBoundaryX0;
1274 boundarytype = fBoundaryType;
1275 return true;
1276}
C
G4double C(G4double temp)
Definition G4DNAElectronHoleRecombination.cc:88
B
G4double B(G4double temperature)
Definition G4DNAElectronHoleRecombination.cc:71
D
G4double D(G4double temp)
Definition G4DNAElectronHoleRecombination.cc:93
JustWarning
@ JustWarning
Definition G4ExceptionSeverity.hh:71
FatalException
@ FatalException
Definition G4ExceptionSeverity.hh:67
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition G4Exception.cc:59
G4RotationMatrix
CLHEP::HepRotation G4RotationMatrix
Definition G4RotationMatrix.hh:37
G4ThreeVector
CLHEP::Hep3Vector G4ThreeVector
Definition G4ThreeVector.hh:36
G4double
double G4double
Definition G4Types.hh:83
G4bool
bool G4bool
Definition G4Types.hh:86
G4int
int G4int
Definition G4Types.hh:85
G4VSURFACENXX
#define G4VSURFACENXX
Definition G4VTwistSurface.hh:46
A
const G4double A[17]
Definition G4WaterStopping.cc:53
G4endl
#define G4endl
Definition G4ios.hh:67
G4cout
G4GLOB_DLL std::ostream G4cout
CLHEP::Hep3Vector::z
double z() const
CLHEP::Hep3Vector::x
double x() const
CLHEP::Hep3Vector::y
double y() const
CLHEP::Hep3Vector::cross
Hep3Vector cross(const Hep3Vector &) const
CLHEP::Hep3Vector::mag
double mag() const
CLHEP::Hep3Vector::getRho
double getRho() const
CLHEP::Hep3Vector::set
void set(double x, double y, double z)
CLHEP::HepRotation::rotateZ
HepRotation & rotateZ(double delta)
Definition Rotation.cc:87
G4GeometryTolerance::GetSurfaceTolerance
G4double GetSurfaceTolerance() const
Definition G4GeometryTolerance.cc:72
G4GeometryTolerance::GetInstance
static G4GeometryTolerance * GetInstance()
Definition G4GeometryTolerance.cc:58
G4GeometryTolerance::GetAngularTolerance
G4double GetAngularTolerance() const
Definition G4GeometryTolerance.cc:77
G4VTwistSurface::Boundary::SetFields
void SetFields(const G4int &areacode, const G4ThreeVector &d, const G4ThreeVector &x0, const G4int &boundarytype)
Definition G4VTwistSurface.cc:1226
G4VTwistSurface::Boundary::GetBoundaryParameters
G4bool GetBoundaryParameters(const G4int &areacode, G4ThreeVector &d, G4ThreeVector &x0, G4int &boundarytype) const
Definition G4VTwistSurface.cc:1249
G4VTwistSurface::CurrentStatus::CurrentStatus
CurrentStatus()
Internal class defining the surface status.
Definition G4VTwistSurface.cc:1117
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=nullptr)
Definition G4VTwistSurface.cc:1143
G4VTwistSurface::CurrentStatus::ResetfDone
void ResetfDone(EValidate validate, const G4ThreeVector *p, const G4ThreeVector *v=nullptr)
Definition G4VTwistSurface.cc:1183
G4VTwistSurface::GetNormal
virtual G4ThreeVector GetNormal(const G4ThreeVector &p, G4bool isGlobal)=0
G4VTwistSurface::AmIOnLeftSide
virtual G4int AmIOnLeftSide(const G4ThreeVector &me, const G4ThreeVector &vec, G4bool withTol=true)
Definition G4VTwistSurface.cc:140
G4VTwistSurface::sAxisMask
static const G4int sAxisMask
Definition G4VTwistSurface.hh:370
G4VTwistSurface::sC0Min1Min
static const G4int sC0Min1Min
Definition G4VTwistSurface.hh:356
G4VTwistSurface::sC0Min1Max
static const G4int sC0Min1Max
Definition G4VTwistSurface.hh:359
G4VTwistSurface::G4VTwistSurface
G4VTwistSurface(const G4String &name)
Definition G4VTwistSurface.cc:64
G4VTwistSurface::IsAxis1
G4bool IsAxis1(G4int areacode) const
G4VTwistSurface::GetNode
G4int GetNode(G4int i, G4int j, G4int m, G4int n, G4int iside)
Definition G4VTwistSurface.cc:918
G4VTwistSurface::sOutside
static const G4int sOutside
Definition G4VTwistSurface.hh:352
G4VTwistSurface::ComputeGlobalDirection
G4ThreeVector ComputeGlobalDirection(const G4ThreeVector &lp) const
G4VTwistSurface::IsCorner
G4bool IsCorner(G4int areacode, G4bool testbitmode=false) const
G4VTwistSurface::sAxisMax
static const G4int sAxisMax
Definition G4VTwistSurface.hh:361
G4VTwistSurface::sAxis0
static const G4int sAxis0
Definition G4VTwistSurface.hh:367
G4VTwistSurface::GetFace
G4int GetFace(G4int i, G4int j, G4int m, G4int n, G4int iside)
Definition G4VTwistSurface.cc:891
G4VTwistSurface::GetBoundaryAxis
void GetBoundaryAxis(G4int areacode, EAxis axis[]) const
Definition G4VTwistSurface.cc:769
G4VTwistSurface::GetName
const G4String & GetName() const
Definition G4VTwistSurface.hh:292
G4VTwistSurface::DistanceTo
virtual G4double DistanceTo(const G4ThreeVector &gp, G4ThreeVector &gxx)
Definition G4VTwistSurface.cc:570
G4VTwistSurface::IsAxis0
G4bool IsAxis0(G4int areacode) const
G4VTwistSurface::fRot
G4RotationMatrix fRot
Definition G4VTwistSurface.hh:457
G4VTwistSurface::GetEdgeVisibility
G4int GetEdgeVisibility(G4int i, G4int j, G4int m, G4int n, G4int number, G4int orientation)
Definition G4VTwistSurface.cc:981
G4VTwistSurface::DistanceToSurface
virtual G4int DistanceToSurface(const G4ThreeVector &gp, const G4ThreeVector &gv, G4ThreeVector gxx[], G4double distance[], G4int areacode[], G4bool isvalid[], EValidate validate=kValidateWithTol)=0
G4VTwistSurface::GetNeighbours
G4VTwistSurface ** GetNeighbours()
Definition G4VTwistSurface.hh:311
G4VTwistSurface::DistanceToLine
G4double DistanceToLine(const G4ThreeVector &p, const G4ThreeVector &x0, const G4ThreeVector &d, G4ThreeVector &xx)
G4VTwistSurface::GetBoundaryLimit
void GetBoundaryLimit(G4int areacode, G4double limit[]) const
Definition G4VTwistSurface.cc:811
G4VTwistSurface::DebugPrint
void DebugPrint() const
Definition G4VTwistSurface.cc:1084
G4VTwistSurface::sAxisPhi
static const G4int sAxisPhi
Definition G4VTwistSurface.hh:366
G4VTwistSurface::sAxisMin
static const G4int sAxisMin
Definition G4VTwistSurface.hh:360
G4VTwistSurface::sC0Max1Max
static const G4int sC0Max1Max
Definition G4VTwistSurface.hh:358
G4VTwistSurface::DistanceToOut
virtual G4double DistanceToOut(const G4ThreeVector &gp, const G4ThreeVector &gv, G4ThreeVector &gxxbest)
Definition G4VTwistSurface.cc:487
G4VTwistSurface::DistanceToIn
virtual G4double DistanceToIn(const G4ThreeVector &gp, const G4ThreeVector &gv, G4ThreeVector &gxxbest)
Definition G4VTwistSurface.cc:283
G4VTwistSurface::sAxis1
static const G4int sAxis1
Definition G4VTwistSurface.hh:368
G4VTwistSurface::GetBoundaryAtPZ
virtual G4ThreeVector GetBoundaryAtPZ(G4int areacode, const G4ThreeVector &p) const
Definition G4VTwistSurface.cc:685
G4VTwistSurface::IsInside
G4bool IsInside(G4int areacode, G4bool testbitmode=false) const
G4VTwistSurface::fTrans
G4ThreeVector fTrans
Definition G4VTwistSurface.hh:458
G4VTwistSurface::SetBoundary
virtual void SetBoundary(const G4int &axiscode, const G4ThreeVector &direction, const G4ThreeVector &x0, const G4int &boundarytype)
Definition G4VTwistSurface.cc:849
G4VTwistSurface::sAxisRho
static const G4int sAxisRho
Definition G4VTwistSurface.hh:365
G4VTwistSurface::SetCorner
void SetCorner(G4int areacode, G4double x, G4double y, G4double z)
Definition G4VTwistSurface.cc:743
G4VTwistSurface::GetCorner
G4ThreeVector GetCorner(G4int areacode) const
G4VTwistSurface::sBoundary
static const G4int sBoundary
Definition G4VTwistSurface.hh:354
G4VTwistSurface::sAxisZ
static const G4int sAxisZ
Definition G4VTwistSurface.hh:364
G4VTwistSurface::DistanceToBoundary
virtual G4double DistanceToBoundary(G4int areacode, G4ThreeVector &xx, const G4ThreeVector &p)
Definition G4VTwistSurface.cc:224
G4VTwistSurface::sCorner
static const G4int sCorner
Definition G4VTwistSurface.hh:355
G4VTwistSurface::sC0Max1Min
static const G4int sC0Max1Min
Definition G4VTwistSurface.hh:357
G4VTwistSurface::sInside
static const G4int sInside
Definition G4VTwistSurface.hh:353
G4VTwistSurface::IsSameBoundary
G4bool IsSameBoundary(G4VTwistSurface *surface1, G4int areacode1, G4VTwistSurface *surface2, G4int areacode2) const
Definition G4VTwistSurface.cc:609
G4VTwistSurface::sAxisY
static const G4int sAxisY
Definition G4VTwistSurface.hh:363
G4VTwistSurface::sSizeMask
static const G4int sSizeMask
Definition G4VTwistSurface.hh:369
G4VTwistSurface::sAxisX
static const G4int sAxisX
Definition G4VTwistSurface.hh:362
G4VTwistSurface::sAreaMask
static const G4int sAreaMask
Definition G4VTwistSurface.hh:371
G4VTwistSurface::IsBoundary
G4bool IsBoundary(G4int areacode, G4bool testbitmode=false) const
G4VTwistSurface::ComputeGlobalPoint
G4ThreeVector ComputeGlobalPoint(const G4ThreeVector &lp) const
G4VTwistSurface::fCurrentNormal
G4SurfCurNormal fCurrentNormal
Definition G4VTwistSurface.hh:469
G4VTwistSurface::GetBoundaryParameters
virtual void GetBoundaryParameters(const G4int &areacode, G4ThreeVector &d, G4ThreeVector &x0, G4int &boundarytype) const
Definition G4VTwistSurface.cc:656
EAxis
EAxis
Definition geomdefs.hh:54
kPhi
@ kPhi
Definition geomdefs.hh:60
kYAxis
@ kYAxis
Definition geomdefs.hh:56
kXAxis
@ kXAxis
Definition geomdefs.hh:55
kZAxis
@ kZAxis
Definition geomdefs.hh:57
kUndefined
@ kUndefined
Definition geomdefs.hh:61
kRho
@ kRho
Definition geomdefs.hh:58
axis
const axis_t axis_to_type< N >::axis
Definition pugixml.cc:9668