Loading...
Searching...
No Matches
G4Paraboloid Class Reference
#include <G4Paraboloid.hh>
Inheritance diagram for G4Paraboloid:
Protected Attributes | |
| G4bool | fRebuildPolyhedron = false |
| G4Polyhedron * | fpPolyhedron = nullptr |
| Protected Attributes inherited from G4VSolid | |
| G4double | kCarTolerance |
Additional Inherited Members | |
| Protected Member Functions inherited from G4VSolid | |
| void | CalculateClippedPolygonExtent (G4ThreeVectorList &pPolygon, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const |
| void | ClipCrossSection (G4ThreeVectorList *pVertices, const G4int pSectionIndex, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const |
| void | ClipBetweenSections (G4ThreeVectorList *pVertices, const G4int pSectionIndex, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const |
| void | ClipPolygon (G4ThreeVectorList &pPolygon, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis) const |
Detailed Description
Definition at line 67 of file G4Paraboloid.hh.
Constructor & Destructor Documentation
◆ G4Paraboloid() [1/3]
Definition at line 62 of file G4Paraboloid.cc.
66 : G4VSolid(pName)
67{
68 if( (pDz <= 0.) || (pR2 <= pR1) || (pR1 < 0.) )
69 {
70 std::ostringstream message;
71 message << "Invalid dimensions. Negative Input Values or R1>=R2 - "
72 << GetName();
74 FatalErrorInArgument, message,
75 "Z half-length must be larger than zero or R1>=R2.");
76 }
77
78 r1 = pR1;
79 r2 = pR2;
80 dz = pDz;
81
82 // r1^2 = k1 * (-dz) + k2
83 // r2^2 = k1 * ( dz) + k2
84 // => r1^2 + r2^2 = k2 + k2 => k2 = (r2^2 + r1^2) / 2
85 // and r2^2 - r1^2 = k1 * dz - k1 * (-dz) => k1 = (r2^2 - r1^2) / 2 / dz
86
87 k1 = (r2 * r2 - r1 * r1) / 2 / dz;
88 k2 = (r2 * r2 + r1 * r1) / 2;
89}
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition: G4Exception.cc:59
Definition: G4VSolid.hh:83
G4String GetName() const
◆ ~G4Paraboloid()
|
virtual |
Definition at line 105 of file G4Paraboloid.cc.
106{
108}
◆ G4Paraboloid() [2/3]
| G4Paraboloid::G4Paraboloid | ( | __void__ & | a | ) |
Definition at line 96 of file G4Paraboloid.cc.
◆ G4Paraboloid() [3/3]
| G4Paraboloid::G4Paraboloid | ( | const G4Paraboloid & | rhs | ) |
Definition at line 114 of file G4Paraboloid.cc.
115 : G4VSolid(rhs),
116 fSurfaceArea(rhs.fSurfaceArea), fCubicVolume(rhs.fCubicVolume),
117 dz(rhs.dz), r1(rhs.r1), r2(rhs.r2), k1(rhs.k1), k2(rhs.k2)
118{
119}
Member Function Documentation
◆ BoundingLimits()
|
virtual |
Reimplemented from G4VSolid.
Definition at line 149 of file G4Paraboloid.cc.
151{
152 pMin.set(-r2,-r2,-dz);
153 pMax.set( r2, r2, dz);
154
155 // Check correctness of the bounding box
156 //
158 {
159 std::ostringstream message;
160 message << "Bad bounding box (min >= max) for solid: "
162 << "\npMin = " << pMin
163 << "\npMax = " << pMax;
165 JustWarning, message);
166 DumpInfo();
167 }
168}
double z() const
double x() const
double y() const
void set(double x, double y, double z)
void DumpInfo() const
Referenced by CalculateExtent().
◆ CalculateExtent()
|
virtual |
Implements G4VSolid.
Definition at line 175 of file G4Paraboloid.cc.
179{
180 G4ThreeVector bmin, bmax;
181
182 // Get bounding box
183 BoundingLimits(bmin,bmax);
184
185 // Find extent
186 G4BoundingEnvelope bbox(bmin,bmax);
187 return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
188}
Definition: ThreeVector.h:36
Definition: G4BoundingEnvelope.hh:59
void BoundingLimits(G4ThreeVector &pMin, G4ThreeVector &pMax) const
Definition: G4Paraboloid.cc:149
◆ CalculateSurfaceArea()
|
inline |
Referenced by GetPointOnSurface().
◆ Clone()
|
virtual |
Reimplemented from G4VSolid.
Definition at line 861 of file G4Paraboloid.cc.
◆ CreatePolyhedron()
|
virtual |
Reimplemented from G4VSolid.
Definition at line 927 of file G4Paraboloid.cc.
Referenced by GetPolyhedron().
◆ DescribeYourselfTo()
|
virtual |
Implements G4VSolid.
Definition at line 922 of file G4Paraboloid.cc.
923{
925}
virtual void AddSolid(const G4Box &)=0
◆ DistanceToIn() [1/2]
|
virtual |
Implements G4VSolid.
Definition at line 464 of file G4Paraboloid.cc.
465{
467 if(safz<0.) { safz=0.; }
468 G4double safr = kInfinity;
469
472 G4double sqrho = std::sqrt(rho);
473
474 if(paraRho<0.)
475 {
476 safr=sqrho-r2;
477 if(safr>safz) { safz=safr; }
478 return safz;
479 }
480
481 G4double sqprho = std::sqrt(paraRho);
482 G4double dRho = sqrho-sqprho;
483 if(dRho<0.) { return safz; }
484
485 G4double talf = -2.*k1*sqprho;
486 G4double tmp = 1+talf*talf;
487 if(tmp<0.) { return safz; }
488
489 G4double salf = talf/std::sqrt(tmp);
490 safr = std::fabs(dRho*salf);
491 if(safr>safz) { safz=safr; }
492
493 return safz;
494}
◆ DistanceToIn() [2/2]
|
virtual |
Implements G4VSolid.
Definition at line 331 of file G4Paraboloid.cc.
333{
337
339 {
340 // If the points is above check for intersection with upper edge.
341
343 {
347 {
349 { return 0; }
350 else
351 { return intersection; }
352 }
353 }
354 else // Direction away, no possibility of intersection
355 {
356 return kInfinity;
357 }
358 }
360 {
361 // If the points is belove check for intersection with lower edge.
362
364 {
368 {
370 {
371 return 0;
372 }
373 else
374 {
375 return intersection;
376 }
377 }
378 }
379 else // Direction away, no possibility of intersection
380 {
381 return kInfinity;
382 }
383 }
384
386 vRho2 = v.perp2(), intersection,
388
392 {
393 // Is there a problem with squaring rho twice?
394
395 if(vRho2<tol2) // Needs to be treated seperately.
396 {
398 if(intersection < 0) { return kInfinity; }
400 {
401 return intersection;
402 }
403 else
404 {
405 return kInfinity;
406 }
407 }
409 {
410 return kInfinity;
411 }
412 else
413 {
415 if(intersection < 0)
416 {
417 return kInfinity;
418 }
420 {
421 return intersection;
422 }
423 else
424 {
425 return kInfinity;
426 }
427 }
428 }
430 {
431 // If this is true we're somewhere in the border.
432
434 if(normal.dot(v) <= 0)
435 { return 0; }
436 else
437 { return kInfinity; }
438 }
439 else
440 {
441 std::ostringstream message;
443 {
445 }
446 else
447 {
449 << G4endl;
450 }
452 << " v = " << v * (1/mm) << " mm";
454 JustWarning, message);
455 return 0;
456 }
457}
double perp2() const
◆ DistanceToOut() [1/2]
|
virtual |
Implements G4VSolid.
Definition at line 811 of file G4Paraboloid.cc.
812{
813 G4double safe=0.0,rho,safeR,safeZ ;
814 G4double tanRMax,secRMax,pRMax ;
815
816#ifdef G4SPECSDEBUG
818 {
820 DumpInfo();
821 std::ostringstream message;
822 G4long oldprc = message.precision(16);
828 message.precision(oldprc) ;
830 JustWarning, message);
831 }
832#endif
833
834 rho = p.perp();
835 safeZ = dz - std::fabs(p.z()) ;
836
837 tanRMax = (r2 - r1)*0.5/dz ;
838 secRMax = std::sqrt(1.0 + tanRMax*tanRMax) ;
839 pRMax = tanRMax*p.z() + (r1+r2)*0.5 ;
840 safeR = (pRMax - rho)/secRMax ;
841
842 if (safeZ < safeR) { safe = safeZ; }
843 else { safe = safeR; }
845 return safe ;
846}
G4GLOB_DLL std::ostream G4cout
double perp() const
◆ DistanceToOut() [2/2]
|
virtual |
Implements G4VSolid.
Definition at line 500 of file G4Paraboloid.cc.
505{
510
511 if(calcNorm) { *validNorm = false; }
512
513 // We have that the particle p follows the line x = p + s * v
514 // meaning x = p.x() + s * v.x(), y = p.y() + s * v.y() and
515 // z = p.z() + s * v.z()
516 // The equation for all points on the surface (surface expanded for
517 // to include all z) x^2 + y^2 = k1 * z + k2 => .. =>
518 // => s = (A +- std::sqrt(A^2 + B)) / vRho2
519 // where:
520 //
522 //
523 // and:
524 //
526
529 {
530 // Make sure it's safely inside.
531
533 {
534 // It's heading upwards, check where it colides with the plane z = dz.
535 // When it does, is that in the surface of the paraboloid.
536 // z = p.z() + variable * v.z() for all points the particle can go.
537 // => variable = (z - p.z()) / v.z() so intersection must be:
538
541
543 {
544 if(calcNorm)
545 {
548 {
551 }
552 *validNorm = true;
553 }
554 return intersection;
555 }
556 }
557 else if(v.z() < 0)
558 {
559 // It's heading downwards, check were it colides with the plane z = -dz.
560 // When it does, is that in the surface of the paraboloid.
561 // z = p.z() + variable * v.z() for all points the particle can go.
562 // => variable = (z - p.z()) / v.z() so intersection must be:
563
564 intersection = (-dz - p.z()) / v.z();
566
568 {
569 if(calcNorm)
570 {
573 {
576 }
577 *validNorm = true;
578 }
579 return intersection;
580 }
581 }
582
583 // Now check for collisions with paraboloid surface.
584
585 if(vRho2 == 0) // Needs to be treated seperately.
586 {
587 intersection = ((rho2 - k2)/k1 - p.z())/v.z();
588 if(calcNorm)
589 {
590 G4ThreeVector intersectionP = p + v * intersection;
593
594 *validNorm = true;
595 }
596 return intersection;
597 }
599 {
600 // intersection = (A + std::sqrt(B + sqr(A))) / vRho2;
601 // The above calculation has a precision problem:
602 // known problem of solving quadratic equation with small A
603
607 if(calcNorm)
608 {
609 G4ThreeVector intersectionP = p + v * intersection;
612 *validNorm = true;
613 }
614 return intersection;
615 }
616 std::ostringstream message;
617 message << "There is no intersection between given line and solid!"
618 << G4endl
620 << " v = " << v;
622 JustWarning, message);
623
624 return kInfinity;
625 }
627 || sqr(rho2 - paraRho2 - 0.25 * tol2) < tol2 * paraRho2 )
628 && std::fabs(p.z()) < dz + tolh)
629 {
630 // If this is true we're somewhere in the border.
631
633
635 {
636 // We're in the lower or upper edge
637 //
639 { // If we're heading out of the object that is treated here
640 if(calcNorm)
641 {
642 *validNorm = true;
645 else
647 }
648 return 0;
649 }
650
651 if(v.z() == 0)
652 {
653 // Case where we're moving inside the surface needs to be
654 // treated separately.
655 // Distance until it goes out through a side is returned.
656
661
662 if(calcNorm)
663 {
664 *validNorm = true;
665
668 * intersection, -k1/2).unit()).unit();
669 }
670 return intersection;
671 }
672 }
673 //
674 // Problem in the Logic :: Following condition for point on upper surface
675 // and Vz<0 will return 0 (Problem #1015), but
676 // it has to return intersection with parabolic
677 // surface or with lower plane surface (z = -dz)
678 // The logic has to be :: If not found intersection until now,
679 // do not exit but continue to search for possible intersection.
680 // Only for point situated on both borders (Z and parabolic)
681 // this condition has to be taken into account and done later
682 //
683 //
684 // else if(normal.dot(v) >= 0)
685 // {
686 // if(calcNorm)
687 // {
688 // *validNorm = true;
689 // *n = normal.unit();
690 // }
691 // return 0;
692 // }
693
694 if(v.z() > 0)
695 {
696 // Check for collision with upper edge.
697
698 intersection = (dz - p.z()) / v.z();
699 G4ThreeVector ip = p + intersection * v;
700
702 {
703 if(calcNorm)
704 {
705 *validNorm = true;
707 }
708 return intersection;
709 }
711 {
712 if(calcNorm)
713 {
714 *validNorm = true;
718 }
719 return intersection;
720 }
721 }
722 if( v.z() < 0)
723 {
724 // Check for collision with lower edge.
725
726 intersection = (-dz - p.z()) / v.z();
727 G4ThreeVector ip = p + intersection * v;
728
730 {
731 if(calcNorm)
732 {
733 *validNorm = true;
735 }
736 return intersection;
737 }
739 {
740 if(calcNorm)
741 {
742 *validNorm = true;
746 }
747 return intersection;
748 }
749 }
750
751 // Note: comparison with zero below would not be correct !
752 //
753 if(std::fabs(vRho2) > tol2) // precision error in the calculation of
754 { // intersection = (A+std::sqrt(B+sqr(A)))/vRho2
758 {
761 }
762 else // Point is On both borders: Z and parabolic
763 { // solution depends on normal.dot(v) sign
765 {
766 if(calcNorm)
767 {
768 *validNorm = true;
770 }
771 return 0;
772 }
773 intersection = 2.*A;
774 }
775 }
776 else
777 {
778 intersection = ((rho2 - k2) / k1 - p.z()) / v.z();
779 }
780
781 if(calcNorm)
782 {
783 *validNorm = true;
785 + intersection * v.y(), - k1 / 2);
787 }
788 return intersection;
789 }
790 else
791 {
792#ifdef G4SPECSDEBUG
794 {
797 }
798 else
801#endif
802 return kInfinity;
803 }
804 return 0;
805}
Hep3Vector unit() const
double dot(const Hep3Vector &) const
◆ GetCubicVolume()
◆ GetEntityType()
|
virtual |
Implements G4VSolid.
Definition at line 852 of file G4Paraboloid.cc.
◆ GetPointOnSurface()
|
virtual |
Reimplemented from G4VSolid.
Definition at line 891 of file G4Paraboloid.cc.
892{
894 G4double z = G4RandFlat::shoot(0.,1.);
895 G4double phi = G4RandFlat::shoot(0., twopi);
897 {
898 G4double rho;
900 {
901 rho = r1 * std::sqrt(G4RandFlat::shoot(0., 1.));
903 }
904 else
905 {
906 rho = r2 * std::sqrt(G4RandFlat::shoot(0., 1));
908 }
909 }
910 else
911 {
912 z = G4RandFlat::shoot(0., 1.)*2*dz - dz;
914 std::sqrt(z*k1 + k2)*std::sin(phi), z);
915 }
916}
G4double CalculateSurfaceArea() const
◆ GetPolyhedron()
|
virtual |
Reimplemented from G4VSolid.
Definition at line 932 of file G4Paraboloid.cc.
933{
935 fRebuildPolyhedron ||
938 {
939 G4AutoLock l(&polyhedronMutex);
943 l.unlock();
944 }
946}
G4Polyhedron * CreatePolyhedron() const
Definition: G4Paraboloid.cc:927
G4int GetNumberOfRotationStepsAtTimeOfCreation() const
Definition: G4Polyhedron.hh:152
Definition: G4AutoLock.hh:274
static G4int GetNumberOfRotationSteps()
Definition: HepPolyhedron.cc:269
◆ GetRadiusMinusZ()
|
inline |
Referenced by G4GDMLWriteSolids::ParaboloidWrite().
◆ GetRadiusPlusZ()
|
inline |
Referenced by G4GDMLWriteSolids::ParaboloidWrite().
◆ GetSurfaceArea()
◆ GetZHalfLength()
|
inline |
Referenced by G4GDMLWriteSolids::ParaboloidWrite().
◆ Inside()
|
virtual |
Implements G4VSolid.
Definition at line 194 of file G4Paraboloid.cc.
195{
196 // First check is the point is above or below the solid.
197 //
199
203
205 {
206 // Actually checking rho < radius of paraboloid at z = p.z().
207 // We're either inside or in lower/upper cutoff area.
208
210 {
211 // We're in the upper/lower cutoff area, sides have a paraboloid shape
212 // maybe further checks should be made to make these nicer
213
215 }
216 else
217 {
219 }
220 }
222 {
223 // We're in the parabolic surface.
224
226 }
227 else
228 {
230 }
231}
Referenced by DistanceToIn(), and DistanceToOut().
◆ operator=()
| G4Paraboloid & G4Paraboloid::operator= | ( | const G4Paraboloid & | rhs | ) |
Definition at line 125 of file G4Paraboloid.cc.
126{
127 // Check assignment to self
128 //
129 if (this == &rhs) { return *this; }
130
131 // Copy base class data
132 //
133 G4VSolid::operator=(rhs);
134
135 // Copy data
136 //
137 fSurfaceArea = rhs.fSurfaceArea; fCubicVolume = rhs.fCubicVolume;
138 dz = rhs.dz; r1 = rhs.r1; r2 = rhs.r2; k1 = rhs.k1; k2 = rhs.k2;
141
142 return *this;
143}
◆ SetRadiusMinusZ()
|
inline |
◆ SetRadiusPlusZ()
|
inline |
◆ SetZHalfLength()
|
inline |
◆ StreamInfo()
|
virtual |
Implements G4VSolid.
Definition at line 870 of file G4Paraboloid.cc.
871{
872 G4long oldprc = os.precision(16);
873 os << "-----------------------------------------------------------\n"
875 << " ===================================================\n"
876 << " Solid type: G4Paraboloid\n"
877 << " Parameters: \n"
878 << " z half-axis: " << dz/mm << " mm \n"
879 << " radius at -dz: " << r1/mm << " mm \n"
880 << " radius at dz: " << r2/mm << " mm \n"
881 << "-----------------------------------------------------------\n";
882 os.precision(oldprc);
883
884 return os;
885}
◆ SurfaceNormal()
|
virtual |
Implements G4VSolid.
Definition at line 237 of file G4Paraboloid.cc.
238{
241 {
242 // If above or below just return normal vector for the cutoff plane.
243
245 }
247 {
248 // This means we're somewhere in the plane z = dz or z = -dz.
249 // (As far as the program is concerned anyway.
250
252 {
254 {
256 }
259 {
263 }
264 else
265 {
267 }
268 }
269 else
270 {
272 {
274 }
277 {
281 }
282 else
283 {
285 }
286 }
287 }
288 else
289 {
294
296 {
297 // Actually checking rho < radius of paraboloid at z = p.z().
298 // We're inside.
299
301 }
303 {
304 // We're in the parabolic surface.
305
307 }
308 else
309 {
311 }
312 }
313
315 {
316 std::ostringstream message;
318 << " p = " << 1 / mm * p << " mm";
320 JustWarning, message);
321 }
323}
double mag2() const
Member Data Documentation
◆ fpPolyhedron
|
mutableprotected |
Definition at line 141 of file G4Paraboloid.hh.
Referenced by GetPolyhedron(), operator=(), and ~G4Paraboloid().
◆ fRebuildPolyhedron
|
mutableprotected |
Definition at line 140 of file G4Paraboloid.hh.
Referenced by GetPolyhedron(), and operator=().
The documentation for this class was generated from the following files:
