Loading...
Searching...
No Matches
G4Paraboloid Class Reference
G4Paraboloid represents a solid with parabolic profile with possible cuts along the Z axis. More...
#include <G4Paraboloid.hh>
Inheritance diagram for G4Paraboloid:
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 |
| Protected Attributes inherited from G4VSolid | |
| G4double | kCarTolerance |
Detailed Description
G4Paraboloid represents a solid with parabolic profile with possible cuts along the Z axis.
Definition at line 71 of file G4Paraboloid.hh.
Constructor & Destructor Documentation
◆ G4Paraboloid() [1/3]
Constructs a paraboloid, given its parameters.
- Parameters
-
[in] pName The solid name. [in] pDz Half length in Z. [in] pR1 Radius at -Dz. [in] pR2 Radius at +Dz greater than pR1.
Definition at line 60 of file G4Paraboloid.cc.
64 : G4VSolid(pName)
65{
66 if( (pDz <= 0.) || (pR2 <= pR1) || (pR1 < 0.) )
67 {
68 std::ostringstream message;
69 message << "Invalid dimensions. Negative Input Values or R1>=R2 - "
70 << GetName();
72 FatalErrorInArgument, message,
73 "Z half-length must be larger than zero or R1>=R2.");
74 }
75
76 r1 = pR1;
77 r2 = pR2;
78 dz = pDz;
79
80 // r1^2 = k1 * (-dz) + k2
81 // r2^2 = k1 * ( dz) + k2
82 // => r1^2 + r2^2 = k2 + k2 => k2 = (r2^2 + r1^2) / 2
83 // and r2^2 - r1^2 = k1 * dz - k1 * (-dz) => k1 = (r2^2 - r1^2) / 2 / dz
84
85 k1 = (r2 * r2 - r1 * r1) / 2 / dz;
86 k2 = (r2 * r2 + r1 * r1) / 2;
87
88 fSurfaceArea = CalculateSurfaceArea();
89}
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition G4Exception.cc:59
G4String GetName() const
Referenced by Clone(), G4Paraboloid(), GetRadiusPlusZ(), and operator=().
◆ ~G4Paraboloid()
|
override |
Destructor.
Definition at line 105 of file G4Paraboloid.cc.
106{
107 delete fpPolyhedron; fpPolyhedron = nullptr;
108}
◆ G4Paraboloid() [2/3]
| G4Paraboloid::G4Paraboloid | ( | __void__ & | a | ) |
Fake default constructor for usage restricted to direct object persistency for clients requiring preallocation of memory for persistifiable objects.
Definition at line 96 of file G4Paraboloid.cc.
◆ G4Paraboloid() [3/3]
| G4Paraboloid::G4Paraboloid | ( | const G4Paraboloid & | rhs | ) |
Copy constructor and assignment operator.
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()
|
overridevirtual |
Computes the bounding limits of the solid.
- Parameters
-
[out] pMin The minimum bounding limit point. [out] pMax The maximum bounding limit point.
Reimplemented from G4VSolid.
Definition at line 270 of file G4Paraboloid.cc.
272{
273 pMin.set(-r2,-r2,-dz);
274 pMax.set( r2, r2, dz);
275
276 // Check correctness of the bounding box
277 //
279 {
280 std::ostringstream message;
281 message << "Bad bounding box (min >= max) for solid: "
283 << "\npMin = " << pMin
284 << "\npMax = " << pMax;
286 JustWarning, message);
287 DumpInfo();
288 }
289}
double z() const
double x() const
double y() const
void set(double x, double y, double z)
void DumpInfo() const
Referenced by CalculateExtent().
◆ CalculateExtent()
|
overridevirtual |
Calculates the minimum and maximum extent of the solid, when under the specified transform, and within the specified limits.
- Parameters
-
[in] pAxis The axis along which compute the extent. [in] pVoxelLimit The limiting space dictated by voxels. [in] pTransform The internal transformation applied to the solid. [out] pMin The minimum extent value. [out] pMax The maximum extent value.
- Returns
- True if the solid is intersected by the extent region.
Implements G4VSolid.
Definition at line 296 of file G4Paraboloid.cc.
300{
301 G4ThreeVector bmin, bmax;
302
303 // Get bounding box
304 BoundingLimits(bmin,bmax);
305
306 // Find extent
307 G4BoundingEnvelope bbox(bmin,bmax);
308 return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
309}
void BoundingLimits(G4ThreeVector &pMin, G4ThreeVector &pMax) const override
Definition G4Paraboloid.cc:270
◆ Clone()
|
overridevirtual |
Makes a clone of the object for use in multi-treading.
- Returns
- A pointer to the new cloned allocated solid.
Reimplemented from G4VSolid.
Definition at line 954 of file G4Paraboloid.cc.
955{
957}
G4Paraboloid(const G4String &pName, G4double pDz, G4double pR1, G4double pR2)
Definition G4Paraboloid.cc:60
◆ CreatePolyhedron()
|
overridevirtual |
Creates a Polyhedron used for Visualisation. It is the caller's responsibility to delete it. A null pointer means "not created".
Reimplemented from G4VSolid.
Definition at line 1026 of file G4Paraboloid.cc.
1027{
1028 return new G4PolyhedronParaboloid(r1, r2, dz, 0., twopi);
1029}
Referenced by GetPolyhedron().
◆ DescribeYourselfTo()
|
overridevirtual |
Methods for creating graphical representations (i.e. for visualisation).
Implements G4VSolid.
Definition at line 1021 of file G4Paraboloid.cc.
1022{
1024}
virtual void AddSolid(const G4Box &)=0
◆ DistanceToIn() [1/2]
|
overridevirtual |
Calculates the distance to the nearest surface of a shape from an outside point. The distance can be an underestimate.
- Parameters
-
[in] p The point at offset p.
- Returns
- The safety distance to enter the shape.
Implements G4VSolid.
Definition at line 561 of file G4Paraboloid.cc.
562{
564 if(safz<0.) { safz=0.; }
565 G4double safr = kInfinity;
566
569 G4double sqrho = std::sqrt(rho);
570
571 if(paraRho<0.)
572 {
573 safr=sqrho-r2;
574 if(safr>safz) { safz=safr; }
575 return safz;
576 }
577
578 G4double sqprho = std::sqrt(paraRho);
579 G4double dRho = sqrho-sqprho;
580 if(dRho<0.) { return safz; }
581
582 G4double talf = -2.*k1*sqprho;
583 G4double tmp = 1+talf*talf;
584 if(tmp<0.) { return safz; }
585
586 G4double salf = talf/std::sqrt(tmp);
587 safr = std::fabs(dRho*salf);
588 if(safr>safz) { safz=safr; }
589
590 return safz;
591}
◆ DistanceToIn() [2/2]
|
overridevirtual |
Returns the distance along the normalised vector 'v' to the shape, from the point at offset 'p'. If there is no intersection, returns kInfinity. The first intersection resulting from 'leaving' a surface/volume is discarded. Hence, it is tolerant of points on the surface of the shape.
- Parameters
-
[in] p The point at offset p. [in] v The normalised direction vector.
- Returns
- The distance to enter the shape.
Implements G4VSolid.
Definition at line 447 of file G4Paraboloid.cc.
449{
453
455 {
456 // If the points is above check for intersection with upper edge.
457
459 {
463 {
465 return intersection;
466 }
467 }
468 else // Direction away, no possibility of intersection
469 {
470 return kInfinity;
471 }
472 }
474 {
475 // If the points is belove check for intersection with lower edge.
476
478 {
482 {
484 return intersection;
485 }
486 }
487 else // Direction away, no possibility of intersection
488 {
489 return kInfinity;
490 }
491 }
492
494 vRho2 = v.perp2(), intersection,
496
500 {
501 // Is there a problem with squaring rho twice?
502
503 if(vRho2<tol2) // Needs to be treated separately.
504 {
506 if(intersection < 0) { return kInfinity; }
508 return kInfinity;
509 }
510
512 {
513 return kInfinity;
514 }
515
517 if(intersection < 0)
518 {
519 return kInfinity;
520 }
521
523 {
524 return intersection;
525 }
526
527 return kInfinity;
528 }
530 {
531 // If this is true we're somewhere in the border.
532
534 if(normal.dot(v) <= 0) { return 0; }
535
536 return kInfinity;
537 }
538
539 std::ostringstream message;
541 {
543 }
544 else
545 {
547 << G4endl;
548 }
550 << " v = " << v * (1/mm) << " mm";
552 JustWarning, message);
553 return 0;
554}
double perp2() const
EInside Inside(const G4ThreeVector &p) const override
Definition G4Paraboloid.cc:315
◆ DistanceToOut() [1/2]
|
overridevirtual |
Calculates the distance to the nearest surface of a shape from an inside point 'p'. The distance can be an underestimate.
- Parameters
-
[in] p The point at offset p.
- Returns
- The safety distance to exit the shape.
Implements G4VSolid.
Definition at line 904 of file G4Paraboloid.cc.
905{
906 G4double safe=0.0,rho,safeR,safeZ ;
907 G4double tanRMax,secRMax,pRMax ;
908
909#ifdef G4SPECSDEBUG
911 {
913 DumpInfo();
914 std::ostringstream message;
915 G4long oldprc = message.precision(16);
921 message.precision(oldprc) ;
923 JustWarning, message);
924 }
925#endif
926
927 rho = p.perp();
928 safeZ = dz - std::fabs(p.z()) ;
929
930 tanRMax = (r2 - r1)*0.5/dz ;
931 secRMax = std::sqrt(1.0 + tanRMax*tanRMax) ;
932 pRMax = tanRMax*p.z() + (r1+r2)*0.5 ;
933 safeR = (pRMax - rho)/secRMax ;
934
935 if (safeZ < safeR) { safe = safeZ; }
936 else { safe = safeR; }
938 return safe ;
939}
G4GLOB_DLL std::ostream G4cout
double perp() const
◆ DistanceToOut() [2/2]
|
overridevirtual |
Returns the distance along the normalised vector 'v' to the shape, from a point at an offset 'p' inside or on the surface of the shape. Intersections with surfaces, when the point is less than Tolerance/2 from a surface must be ignored.
- Parameters
-
[in] p The point at offset p. [in] v The normalised direction vector. [in] calcNorm Flag to indicate if to calculate the normal or not. [out] validNorm Flag set to true if the solid lies entirely behind or on the exiting surface. It is set false if the solid does not lie entirely behind or on the exiting surface. 'calcNorm' must be true, otherwise it is unused. [out] n The exiting outwards normal vector (undefined Magnitude). 'calcNorm' must be true, otherwise it is unused.
- Returns
- The distance to exit the shape.
Implements G4VSolid.
Definition at line 597 of file G4Paraboloid.cc.
602{
607
608 if(calcNorm) { *validNorm = false; }
609
610 // We have that the particle p follows the line x = p + s * v
611 // meaning x = p.x() + s * v.x(), y = p.y() + s * v.y() and
612 // z = p.z() + s * v.z()
613 // The equation for all points on the surface (surface expanded for
614 // to include all z) x^2 + y^2 = k1 * z + k2 => .. =>
615 // => s = (A +- std::sqrt(A^2 + B)) / vRho2
616 // where:
617 //
619 //
620 // and:
621 //
623
626 {
627 // Make sure it's safely inside.
628
630 {
631 // It's heading upwards, check where it colides with the plane z = dz.
632 // When it does, is that in the surface of the paraboloid.
633 // z = p.z() + variable * v.z() for all points the particle can go.
634 // => variable = (z - p.z()) / v.z() so intersection must be:
635
638
640 {
641 if(calcNorm)
642 {
645 {
648 }
649 *validNorm = true;
650 }
651 return intersection;
652 }
653 }
654 else if(v.z() < 0)
655 {
656 // It's heading downwards, check were it colides with the plane z = -dz.
657 // When it does, is that in the surface of the paraboloid.
658 // z = p.z() + variable * v.z() for all points the particle can go.
659 // => variable = (z - p.z()) / v.z() so intersection must be:
660
661 intersection = (-dz - p.z()) / v.z();
663
665 {
666 if(calcNorm)
667 {
670 {
673 }
674 *validNorm = true;
675 }
676 return intersection;
677 }
678 }
679
680 // Now check for collisions with paraboloid surface.
681
682 if(vRho2 == 0) // Needs to be treated seperately.
683 {
684 intersection = ((rho2 - k2)/k1 - p.z())/v.z();
685 if(calcNorm)
686 {
687 G4ThreeVector intersectionP = p + v * intersection;
690
691 *validNorm = true;
692 }
693 return intersection;
694 }
696 {
697 // intersection = (A + std::sqrt(B + sqr(A))) / vRho2;
698 // The above calculation has a precision problem:
699 // known problem of solving quadratic equation with small A
700
704 if(calcNorm)
705 {
706 G4ThreeVector intersectionP = p + v * intersection;
709 *validNorm = true;
710 }
711 return intersection;
712 }
713 std::ostringstream message;
714 message << "There is no intersection between given line and solid!"
715 << G4endl
717 << " v = " << v;
719 JustWarning, message);
720
721 return kInfinity;
722 }
724 || sqr(rho2 - paraRho2 - 0.25 * tol2) < tol2 * paraRho2 )
725 && std::fabs(p.z()) < dz + tolh)
726 {
727 // If this is true we're somewhere in the border.
728
730
732 {
733 // We're in the lower or upper edge
734 //
736 { // If we're heading out of the object that is treated here
737 if(calcNorm)
738 {
739 *validNorm = true;
742 else
744 }
745 return 0;
746 }
747
748 if(v.z() == 0)
749 {
750 // Case where we're moving inside the surface needs to be
751 // treated separately.
752 // Distance until it goes out through a side is returned.
753
758
759 if(calcNorm)
760 {
761 *validNorm = true;
762
765 * intersection, -k1/2).unit()).unit();
766 }
767 return intersection;
768 }
769 }
770 //
771 // Problem in the Logic :: Following condition for point on upper surface
772 // and Vz<0 will return 0 (Problem #1015), but
773 // it has to return intersection with parabolic
774 // surface or with lower plane surface (z = -dz)
775 // The logic has to be :: If not found intersection until now,
776 // do not exit but continue to search for possible intersection.
777 // Only for point situated on both borders (Z and parabolic)
778 // this condition has to be taken into account and done later
779 //
780 //
781 // else if(normal.dot(v) >= 0)
782 // {
783 // if(calcNorm)
784 // {
785 // *validNorm = true;
786 // *n = normal.unit();
787 // }
788 // return 0;
789 // }
790
791 if(v.z() > 0)
792 {
793 // Check for collision with upper edge.
794
795 intersection = (dz - p.z()) / v.z();
796 G4ThreeVector ip = p + intersection * v;
797
799 {
800 if(calcNorm)
801 {
802 *validNorm = true;
804 }
805 return intersection;
806 }
808 {
809 if(calcNorm)
810 {
811 *validNorm = true;
815 }
816 return intersection;
817 }
818 }
819 if( v.z() < 0)
820 {
821 // Check for collision with lower edge.
822
823 intersection = (-dz - p.z()) / v.z();
824 G4ThreeVector ip = p + intersection * v;
825
827 {
828 if(calcNorm)
829 {
830 *validNorm = true;
832 }
833 return intersection;
834 }
836 {
837 if(calcNorm)
838 {
839 *validNorm = true;
843 }
844 return intersection;
845 }
846 }
847
848 // Note: comparison with zero below would not be correct !
849 //
850 if(std::fabs(vRho2) > tol2) // precision error in the calculation of
851 { // intersection = (A+std::sqrt(B+sqr(A)))/vRho2
855 {
858 }
859 else // Point is On both borders: Z and parabolic
860 { // solution depends on normal.dot(v) sign
862 {
863 if(calcNorm)
864 {
865 *validNorm = true;
867 }
868 return 0;
869 }
870 intersection = 2.*A;
871 }
872 }
873 else
874 {
875 intersection = ((rho2 - k2) / k1 - p.z()) / v.z();
876 }
877
878 if(calcNorm)
879 {
880 *validNorm = true;
882 + intersection * v.y(), - k1 / 2);
884 }
885 return intersection;
886 }
887
888#ifdef G4SPECSDEBUG
890 {
893 }
896#endif
897 return kInfinity;
898}
Hep3Vector unit() const
double dot(const Hep3Vector &) const
◆ GetCubicVolume()
|
overridevirtual |
Returning an estimation of the solid volume (capacity) and surface area, in internal units.
Reimplemented from G4VSolid.
Definition at line 255 of file G4Paraboloid.cc.
256{
257 if(fCubicVolume == 0)
258 {
259 G4AutoLock l(¶boloidMutex);
261 l.unlock();
262 }
263 return fCubicVolume;
264}
◆ GetEntityType()
|
overridevirtual |
Returns the type ID, "G4Paraboloid" of the solid.
Implements G4VSolid.
Definition at line 945 of file G4Paraboloid.cc.
946{
947 return {"G4Paraboloid"};
948}
◆ GetPointOnSurface()
|
overridevirtual |
Returns a random point located and uniformly distributed on the surface of the solid.
Reimplemented from G4VSolid.
Definition at line 984 of file G4Paraboloid.cc.
985{
988 G4double z, rho;
990 {
992 {
993 z = -dz;
994 rho = r1*std::sqrt(G4QuickRand());
995 }
996 else
997 {
998 z = dz;
999 rho = r2*std::sqrt(G4QuickRand());
1000 }
1001 }
1002 else
1003 {
1004 // rejection sampling
1006 for (auto i = 0; i < 10000; ++i)
1007 {
1008 z = dz*(2*G4QuickRand() - 1);
1011 }
1012 rho = std::sqrt(z*k1 + k2);
1013 }
1014 return { rho*std::cos(phi), rho*std::sin(phi), z };
1015}
◆ GetPolyhedron()
|
overridevirtual |
Smart access function - creates on request and stores for future access. A null pointer means "not available".
Reimplemented from G4VSolid.
Definition at line 1031 of file G4Paraboloid.cc.
1032{
1033 if (fpPolyhedron == nullptr ||
1034 fRebuildPolyhedron ||
1035 fpPolyhedron->GetNumberOfRotationStepsAtTimeOfCreation() !=
1036 fpPolyhedron->GetNumberOfRotationSteps())
1037 {
1038 G4AutoLock l(&polyhedronMutex);
1039 delete fpPolyhedron;
1040 fpPolyhedron = CreatePolyhedron();
1041 fRebuildPolyhedron = false;
1042 l.unlock();
1043 }
1044 return fpPolyhedron;
1045}
G4Polyhedron * CreatePolyhedron() const override
Definition G4Paraboloid.cc:1026
◆ GetRadiusMinusZ()
|
inline |
Referenced by G4GDMLWriteSolids::ParaboloidWrite().
◆ GetRadiusPlusZ()
|
inline |
Referenced by G4GDMLWriteSolids::ParaboloidWrite().
◆ GetSurfaceArea()
|
overridevirtual |
Returns an estimation of the solid surface area in internal units. This method may be overloaded by derived classes to compute the exact geometrical quantity for solids where this is possible, or anyway to cache the computed value. Note: the computed value is NOT cached.
Reimplemented from G4VSolid.
Definition at line 240 of file G4Paraboloid.cc.
241{
242 if (fSurfaceArea == 0)
243 {
244 G4AutoLock l(¶boloidMutex);
245 fSurfaceArea = CalculateSurfaceArea();
246 l.unlock();
247 }
248 return fSurfaceArea;
249}
◆ GetZHalfLength()
|
inline |
Accessors.
Referenced by G4GDMLWriteSolids::ParaboloidWrite().
◆ Inside()
|
overridevirtual |
Concrete implementations of the expected query interfaces for solids, as defined in the base class G4VSolid.
Implements G4VSolid.
Definition at line 315 of file G4Paraboloid.cc.
316{
317 // First check is the point is above or below the solid.
318 //
320
324
326 {
327 // Actually checking rho < radius of paraboloid at z = p.z().
328 // We're either inside or in lower/upper cutoff area.
329
331 {
332 // We're in the upper/lower cutoff area, sides have a paraboloid shape
333 // maybe further checks should be made to make these nicer
334
336 }
338 }
340 {
341 // We're in the parabolic surface.
342
344 }
345
347}
Referenced by DistanceToIn(), DistanceToOut(), 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;
139 fRebuildPolyhedron = false;
140 delete fpPolyhedron; fpPolyhedron = nullptr;
141
142 return *this;
143}
◆ SetRadiusMinusZ()
| void G4Paraboloid::SetRadiusMinusZ | ( | G4double | R1 | ) |
Definition at line 193 of file G4Paraboloid.cc.
194{
195 if(pR1 < 0 || pR1 >= r2)
196 {
199 }
200 else
201 {
202 r1 = pR1;
205 fSurfaceArea = CalculateSurfaceArea();
206 fCubicVolume = 0.;
207 fRebuildPolyhedron = true;
208 }
209}
◆ SetRadiusPlusZ()
| void G4Paraboloid::SetRadiusPlusZ | ( | G4double | R2 | ) |
Definition at line 171 of file G4Paraboloid.cc.
172{
173 if(pR2 <= 0 || pR2 <= r1)
174 {
177 }
178 else
179 {
180 r2 = pR2;
183 fSurfaceArea = CalculateSurfaceArea();
184 fCubicVolume = 0.;
185 fRebuildPolyhedron = true;
186 }
187}
◆ SetZHalfLength()
| void G4Paraboloid::SetZHalfLength | ( | G4double | dz | ) |
Modifiers.
Definition at line 149 of file G4Paraboloid.cc.
150{
151 if(pDz <= 0)
152 {
155 }
156 else
157 {
158 dz = pDz;
161 fSurfaceArea = CalculateSurfaceArea();
162 fCubicVolume = 0.;
163 fRebuildPolyhedron = true;
164 }
165}
◆ StreamInfo()
|
overridevirtual |
Streams the object contents to an output stream.
Implements G4VSolid.
Definition at line 963 of file G4Paraboloid.cc.
964{
965 G4long oldprc = os.precision(16);
966 os << "-----------------------------------------------------------\n"
968 << " ===================================================\n"
969 << " Solid type: G4Paraboloid\n"
970 << " Parameters: \n"
971 << " z half-axis: " << dz/mm << " mm \n"
972 << " radius at -dz: " << r1/mm << " mm \n"
973 << " radius at dz: " << r2/mm << " mm \n"
974 << "-----------------------------------------------------------\n";
975 os.precision(oldprc);
976
977 return os;
978}
◆ SurfaceNormal()
|
overridevirtual |
Returns the outwards pointing unit normal of the shape for the surface closest to the point at offset 'p'.
- Parameters
-
[in] p The point at offset p.
- Returns
- The outwards pointing unit normal.
Implements G4VSolid.
Definition at line 353 of file G4Paraboloid.cc.
354{
357 {
358 // If above or below just return normal vector for the cutoff plane.
359
361 }
363 {
364 // This means we're somewhere in the plane z = dz or z = -dz.
365 // (As far as the program is concerned anyway.
366
368 {
370 {
372 }
375 {
379 }
380 else
381 {
383 }
384 }
385 else
386 {
388 {
390 }
393 {
397 }
398 else
399 {
401 }
402 }
403 }
404 else
405 {
410
412 {
413 // Actually checking rho < radius of paraboloid at z = p.z().
414 // We're inside.
415
417 }
419 {
420 // We're in the parabolic surface.
421
423 }
424 else
425 {
427 }
428 }
429
431 {
432 std::ostringstream message;
434 << " p = " << 1 / mm * p << " mm";
436 JustWarning, message);
437 }
439}
double mag2() const
The documentation for this class was generated from the following files:
