Loading...
Searching...
No Matches
G4Trap Class Reference
G4Trap is a general trapezoid: the faces perpendicular to the Z planes are trapezia, and their centres are not necessarily on a line parallel to the Z axis. A check for planarity is made in the calculation of the equation for each plane. If the planes are not parallel, a call to G4Exception is made. More...
#include <G4Trap.hh>
Inheritance diagram for G4Trap:
Protected Member Functions | |
| void | MakePlanes () |
| void | MakePlanes (const G4ThreeVector pt[8]) |
| G4bool | MakePlane (const G4ThreeVector &p1, const G4ThreeVector &p2, const G4ThreeVector &p3, const G4ThreeVector &p4, TrapSidePlane &plane) |
| void | SetCachedValues () |
| Protected Member Functions inherited from G4CSGSolid | |
| G4double | GetRadiusInRing (G4double rmin, G4double rmax) const |
| 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 |
Additional Inherited Members | |
| Protected Attributes inherited from G4CSGSolid | |
| G4double | fCubicVolume = 0.0 |
| G4double | fSurfaceArea = 0.0 |
| G4bool | fRebuildPolyhedron = false |
| G4Polyhedron * | fpPolyhedron = nullptr |
| Protected Attributes inherited from G4VSolid | |
| G4double | kCarTolerance |
Detailed Description
G4Trap is a general trapezoid: the faces perpendicular to the Z planes are trapezia, and their centres are not necessarily on a line parallel to the Z axis. A check for planarity is made in the calculation of the equation for each plane. If the planes are not parallel, a call to G4Exception is made.
Constructor & Destructor Documentation
◆ G4Trap() [1/8]
| G4Trap::G4Trap | ( | const G4String & | pName, |
| G4double | pDz, | ||
| G4double | pTheta, | ||
| G4double | pPhi, | ||
| G4double | pDy1, | ||
| G4double | pDx1, | ||
| G4double | pDx2, | ||
| G4double | pAlp1, | ||
| G4double | pDy2, | ||
| G4double | pDx3, | ||
| G4double | pDx4, | ||
| G4double | pAlp2 ) |
The most general constructor for G4Trap which prepares plane equations and corner coordinates from parameters.
- Parameters
-
[in] pName The name of the solid. [in] pDz Half-length along the Z-axis. [in] pTheta Polar angle of the line joining the centres of the faces at -/+pDz. [in] pPhi Azimuthal angle of the line joining the centre of the face at -pDz to the centre of the face at +pDz. [in] pDy1 Half-length along Y of the face at -pDz. [in] pDx1 Half-length along X of the side at y=-pDy1 of the face at -pDz. [in] pDx2 Half-length along X of the side at y=+pDy1 of the face at -pDz. [in] pAlp1 Angle with respect to the Y axis from the centre of the side at y=-pDy1 to the centre at y=+pDy1 of the face at -pDz. [in] pDy2 Half-length along Y of the face at +pDz. [in] pDx3 Half-length along X of the side at y=-pDy2 of the face at +pDz. [in] pDx4 Half-length along X of the side at y=+pDy2 of the face at +pDz. [in] pAlp2 Angle with respect to the Y axis from the centre of the side at y=-pDy2 to the centre at y=+pDy2 of the face at +pDz.
Definition at line 66 of file G4Trap.cc.
74{
75 fDz = pDz;
76 fTthetaCphi = std::tan(pTheta)*std::cos(pPhi);
77 fTthetaSphi = std::tan(pTheta)*std::sin(pPhi);
78
79 fDy1 = pDy1; fDx1 = pDx1; fDx2 = pDx2; fTalpha1 = std::tan(pAlp1);
80 fDy2 = pDy2; fDx3 = pDx3; fDx4 = pDx4; fTalpha2 = std::tan(pAlp2);
81
82 CheckParameters();
83 MakePlanes();
84}
Referenced by Clone(), G4Trap(), GetAlpha2(), and operator=().
◆ G4Trap() [2/8]
| G4Trap::G4Trap | ( | const G4String & | pName, |
| const G4ThreeVector | pt[8] ) |
Prepares plane equations and parameters from corner coordinates.
- Parameters
-
[in] pName The name of the solid. [in] pt Points of the 8 vertices.
Definition at line 92 of file G4Trap.cc.
95{
96 // Start with check of centering - the center of gravity trap line
97 // should cross the origin of frame
98 //
99 if ( pt[0].z() >= 0
100 || pt[0].z() != pt[1].z()
101 || pt[0].z() != pt[2].z()
102 || pt[0].z() != pt[3].z()
103
104 || pt[4].z() <= 0
105 || pt[4].z() != pt[5].z()
106 || pt[4].z() != pt[6].z()
107 || pt[4].z() != pt[7].z()
108
109 || std::fabs( pt[0].z() + pt[4].z() ) >= kCarTolerance
110
111 || pt[0].y() != pt[1].y()
112 || pt[2].y() != pt[3].y()
113 || pt[4].y() != pt[5].y()
114 || pt[6].y() != pt[7].y()
115
116 || std::fabs(pt[0].y()+pt[2].y()+pt[4].y()+pt[6].y()) >= kCarTolerance
117 || std::fabs(pt[0].x()+pt[1].x()+pt[4].x()+pt[5].x() +
118 pt[2].x()+pt[3].x()+pt[6].x()+pt[7].x()) >= kCarTolerance )
119 {
120 std::ostringstream message;
123 FatalException, message);
124 }
125
126 // Set parameters
127 //
128 fDz = (pt[7]).z();
129
130 fDy1 = ((pt[2]).y()-(pt[1]).y())*0.5;
131 fDx1 = ((pt[1]).x()-(pt[0]).x())*0.5;
132 fDx2 = ((pt[3]).x()-(pt[2]).x())*0.5;
133 fTalpha1 = ((pt[2]).x()+(pt[3]).x()-(pt[1]).x()-(pt[0]).x())*0.25/fDy1;
134
135 fDy2 = ((pt[6]).y()-(pt[5]).y())*0.5;
136 fDx3 = ((pt[5]).x()-(pt[4]).x())*0.5;
137 fDx4 = ((pt[7]).x()-(pt[6]).x())*0.5;
138 fTalpha2 = ((pt[6]).x()+(pt[7]).x()-(pt[5]).x()-(pt[4]).x())*0.25/fDy2;
139
140 fTthetaCphi = ((pt[4]).x()+fDy2*fTalpha2+fDx3)/fDz;
141 fTthetaSphi = ((pt[4]).y()+fDy2)/fDz;
142
143 CheckParameters();
144 MakePlanes(pt);
145}
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition G4Exception.cc:59
G4String GetName() const
◆ G4Trap() [3/8]
Constructor for Right Angular Wedge from STEP (assumes pLTX<=pX).
- Parameters
-
[in] pName The name of the solid. [in] pZ Length along Z. [in] pY Length along Y. [in] pX Length along X at the wider side. [in] pLTX Length along X at the narrower side (plTX<=pX).
Definition at line 151 of file G4Trap.cc.
156{
157 fDz = 0.5*pZ; fTthetaCphi = 0; fTthetaSphi = 0;
158 fDy1 = 0.5*pY; fDx1 = 0.5*pX; fDx2 = 0.5*pLTX; fTalpha1 = 0.5*(pLTX - pX)/pY;
159 fDy2 = fDy1; fDx3 = fDx1; fDx4 = fDx2; fTalpha2 = fTalpha1;
160
161 CheckParameters();
162 MakePlanes();
163}
◆ G4Trap() [4/8]
| G4Trap::G4Trap | ( | const G4String & | pName, |
| G4double | pDx1, | ||
| G4double | pDx2, | ||
| G4double | pDy1, | ||
| G4double | pDy2, | ||
| G4double | pDz ) |
Constructor for G4Trd.
- Parameters
-
[in] pName The name of the solid. [in] pDx1 Half-length along X at the surface positioned at -dz. [in] pDx2 Half-length along X at the surface positioned at +dz. [in] pDy1 Half-length along Y at the surface positioned at -dz. [in] pDy2 Half-length along Y at the surface positioned at +dz. [in] pDz Half-length along Z axis.
Definition at line 169 of file G4Trap.cc.
174{
175 fDz = pDz; fTthetaCphi = 0; fTthetaSphi = 0;
176 fDy1 = pDy1; fDx1 = pDx1; fDx2 = pDx1; fTalpha1 = 0;
177 fDy2 = pDy2; fDx3 = pDx2; fDx4 = pDx2; fTalpha2 = 0;
178
179 CheckParameters();
180 MakePlanes();
181}
◆ G4Trap() [5/8]
| G4Trap::G4Trap | ( | const G4String & | pName, |
| G4double | pDx, | ||
| G4double | pDy, | ||
| G4double | pDz, | ||
| G4double | pAlpha, | ||
| G4double | pTheta, | ||
| G4double | pPhi ) |
Constructor for G4Para.
- Parameters
-
[in] pName The name of the solid. [in] pDx Half-length in X. [in] pDy Half-length in Y. [in] pDz Half-length in Z. [in] pAlpha Angle formed by the Y axis and the plane joining the centre of the faces parallel to the Z-X plane at -dy and +dy. [in] pTheta Polar angle of the line joining the centres of the faces at -dz and +dz in Z. [in] pPhi Azimuthal angle of the line joining the centres of the faces at -dz and +dz in Z.
Definition at line 187 of file G4Trap.cc.
193{
194 fDz = pDz;
195 fTthetaCphi = std::tan(pTheta)*std::cos(pPhi);
196 fTthetaSphi = std::tan(pTheta)*std::sin(pPhi);
197
198 fDy1 = pDy; fDx1 = pDx; fDx2 = pDx; fTalpha1 = std::tan(pAlpha);
199 fDy2 = pDy; fDx3 = pDx; fDx4 = pDx; fTalpha2 = fTalpha1;
200
201 CheckParameters();
202 MakePlanes();
203}
◆ G4Trap() [6/8]
| G4Trap::G4Trap | ( | const G4String & | pName | ) |
Constructor for "nominal" G4Trap whose parameters are to be set by a G4VPVParamaterisation later on.
- Parameters
-
[in] pName The name of the solid.
Definition at line 211 of file G4Trap.cc.
213 fDz(1.), fTthetaCphi(0.), fTthetaSphi(0.),
214 fDy1(1.), fDx1(1.), fDx2(1.), fTalpha1(0.),
215 fDy2(1.), fDx3(1.), fDx4(1.), fTalpha2(0.)
216{
217 MakePlanes();
218}
◆ ~G4Trap()
|
overridedefault |
Default destructor.
◆ G4Trap() [7/8]
| G4Trap::G4Trap | ( | __void__ & | a | ) |
Fake default constructor for usage restricted to direct object persistency for clients requiring preallocation of memory for persistifiable objects.
Definition at line 225 of file G4Trap.cc.
227 fDz(1.), fTthetaCphi(0.), fTthetaSphi(0.),
228 fDy1(1.), fDx1(1.), fDx2(1.), fTalpha1(0.),
229 fDy2(1.), fDx3(1.), fDx4(1.), fTalpha2(0.)
230{
231 MakePlanes();
232}
◆ G4Trap() [8/8]
| G4Trap::G4Trap | ( | const G4Trap & | rhs | ) |
Copy constructor and assignment operator.
Definition at line 238 of file G4Trap.cc.
239 : G4CSGSolid(rhs), halfCarTolerance(rhs.halfCarTolerance),
240 fDz(rhs.fDz), fTthetaCphi(rhs.fTthetaCphi), fTthetaSphi(rhs.fTthetaSphi),
241 fDy1(rhs.fDy1), fDx1(rhs.fDx1), fDx2(rhs.fDx2), fTalpha1(rhs.fTalpha1),
242 fDy2(rhs.fDy2), fDx3(rhs.fDx3), fDx4(rhs.fDx4), fTalpha2(rhs.fTalpha2)
243{
246 fTrapType = rhs.fTrapType;
247}
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 498 of file G4Trap.cc.
499{
500 G4ThreeVector pt[8];
501 GetVertices(pt);
502
503 G4double xmin = kInfinity, xmax = -kInfinity;
504 G4double ymin = kInfinity, ymax = -kInfinity;
505 for (const auto & i : pt)
506 {
507 G4double x = i.x();
508 if (x < xmin) { xmin = x; }
509 if (x > xmax) { xmax = x; }
510 G4double y = i.y();
511 if (y < ymin) { ymin = y; }
512 if (y > ymax) { ymax = y; }
513 }
514
516 pMin.set(xmin,ymin,-dz);
517 pMax.set(xmax,ymax, dz);
518
519 // Check correctness of the bounding box
520 //
522 {
523 std::ostringstream message;
524 message << "Bad bounding box (min >= max) for solid: "
526 << "\npMin = " << pMin
527 << "\npMax = " << pMax;
529 JustWarning, message);
530 DumpInfo();
531 }
532}
double z() const
double x() const
double y() const
void set(double x, double y, double z)
G4double GetZHalfLength() const
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 538 of file G4Trap.cc.
542{
543 G4ThreeVector bmin, bmax;
544 G4bool exist;
545
546 // Check bounding box (bbox)
547 //
548 BoundingLimits(bmin,bmax);
549 G4BoundingEnvelope bbox(bmin,bmax);
550#ifdef G4BBOX_EXTENT
551 return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
552#endif
553 if (bbox.BoundingBoxVsVoxelLimits(pAxis,pVoxelLimit,pTransform,pMin,pMax))
554 {
555 return exist = pMin < pMax;
556 }
557
558 // Set bounding envelope (benv) and calculate extent
559 //
560 G4ThreeVector pt[8];
561 GetVertices(pt);
562
563 G4ThreeVectorList baseA(4), baseB(4);
564 baseA[0] = pt[0];
565 baseA[1] = pt[1];
566 baseA[2] = pt[3];
567 baseA[3] = pt[2];
568
569 baseB[0] = pt[4];
570 baseB[1] = pt[5];
571 baseB[2] = pt[7];
572 baseB[3] = pt[6];
573
574 std::vector<const G4ThreeVectorList *> polygons(2);
575 polygons[0] = &baseA;
576 polygons[1] = &baseB;
577
578 G4BoundingEnvelope benv(bmin,bmax,polygons);
579 exist = benv.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
580 return exist;
581}
void BoundingLimits(G4ThreeVector &pMin, G4ThreeVector &pMax) const override
Definition G4Trap.cc:498
◆ 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 1088 of file G4Trap.cc.
1089{
1091}
G4Trap(const G4String &pName, G4double pDz, G4double pTheta, G4double pPhi, G4double pDy1, G4double pDx1, G4double pDx2, G4double pAlp1, G4double pDy2, G4double pDx3, G4double pDx4, G4double pAlp2)
Definition G4Trap.cc:66
◆ ComputeDimensions()
|
overridevirtual |
Dispatch method for parameterisation replication mechanism and dimension computation.
Reimplemented from G4VSolid.
Definition at line 487 of file G4Trap.cc.
490{
492}
virtual void ComputeDimensions(G4Box &, const G4int, const G4VPhysicalVolume *) const
Definition G4VPVParameterisation.hh:123
◆ 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 1248 of file G4Trap.cc.
1249{
1250 G4double phi = std::atan2(fTthetaSphi, fTthetaCphi);
1251 G4double alpha1 = std::atan(fTalpha1);
1253 G4double theta = std::atan(std::sqrt(fTthetaCphi*fTthetaCphi
1254 +fTthetaSphi*fTthetaSphi));
1255
1256 return new G4PolyhedronTrap(fDz, theta, phi,
1257 fDy1, fDx1, fDx2, alpha1,
1258 fDy2, fDx3, fDx4, alpha2);
1259}
◆ DescribeYourselfTo()
|
overridevirtual |
◆ 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 855 of file G4Trap.cc.
856{
857 switch (fTrapType)
858 {
859 case 0: // General case
860 {
864 G4double dy = std::max(dz,std::max(dy1,dy2));
865
867 + fPlanes[2].c*p.z()+fPlanes[2].d;
869 + fPlanes[3].c*p.z()+fPlanes[3].d;
870 G4double dist = std::max(dy,std::max(dx1,dx2));
871 return (dist > 0) ? dist : 0.;
872 }
873 case 1: // YZ section is a rectangle
874 {
878 + fPlanes[2].c*p.z()+fPlanes[2].d;
880 + fPlanes[3].c*p.z()+fPlanes[3].d;
881 G4double dist = std::max(dy,std::max(dx1,dx2));
882 return (dist > 0) ? dist : 0.;
883 }
884 case 2: // YZ section is a rectangle and
885 { // XZ section is an isosceles trapezoid
889 + fPlanes[3].c*p.z()+fPlanes[3].d;
890 G4double dist = std::max(dy,dx);
891 return (dist > 0) ? dist : 0.;
892 }
893 case 3: // YZ section is a rectangle and
894 { // XY section is an isosceles trapezoid
898 + fPlanes[3].b*p.y()+fPlanes[3].d;
899 G4double dist = std::max(dy,dx);
900 return (dist > 0) ? dist : 0.;
901 }
902 }
903 return 0.;
904}
◆ 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 783 of file G4Trap.cc.
785{
786 // Z intersections
787 //
789 {
790 return kInfinity;
791 }
793 G4double dz = (invz < 0) ? fDz : -fDz;
796
797 // Y intersections
798 //
800 G4int i = 0;
801 for ( ; i<2; ++i)
802 {
805 if (dist >= -halfCarTolerance)
806 {
807 if (cosa >= 0) { return kInfinity; }
808 G4double tmp = -dist/cosa;
809 if (tymin < tmp) { tymin = tmp; }
810 }
811 else if (cosa > 0)
812 {
813 G4double tmp = -dist/cosa;
814 if (tymax > tmp) { tymax = tmp; }
815 }
816 }
817
818 // Z intersections
819 //
821 for ( ; i<4; ++i)
822 {
825 fPlanes[i].d;
826 if (dist >= -halfCarTolerance)
827 {
828 if (cosa >= 0) { return kInfinity; }
829 G4double tmp = -dist/cosa;
830 if (txmin < tmp) { txmin = tmp; }
831 }
832 else if (cosa > 0)
833 {
834 G4double tmp = -dist/cosa;
835 if (txmax > tmp) { txmax = tmp; }
836 }
837 }
838
839 // Find distance
840 //
841 G4double tmin = std::max(std::max(txmin,tymin),tzmin);
842 G4double tmax = std::min(std::min(txmax,tymax),tzmax);
843
844 if (tmax <= tmin + halfCarTolerance) { return kInfinity; } // touch or no hit
845
846 return (tmin < halfCarTolerance ) ? 0. : tmin;
847}
◆ 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 999 of file G4Trap.cc.
1000{
1001#ifdef G4CSGDEBUG
1003 {
1004 std::ostringstream message;
1005 G4long oldprc = message.precision(16);
1007 message << "Position:\n";
1011 G4cout.precision(oldprc);
1013 JustWarning, message );
1014 DumpInfo();
1015 }
1016#endif
1017 switch (fTrapType)
1018 {
1019 case 0: // General case
1020 {
1024 G4double dy = std::max(dz,std::max(dy1,dy2));
1025
1027 + fPlanes[2].c*p.z()+fPlanes[2].d;
1029 + fPlanes[3].c*p.z()+fPlanes[3].d;
1030 G4double dist = std::max(dy,std::max(dx1,dx2));
1031 return (dist < 0) ? -dist : 0.;
1032 }
1033 case 1: // YZ section is a rectangle
1034 {
1038 + fPlanes[2].c*p.z()+fPlanes[2].d;
1040 + fPlanes[3].c*p.z()+fPlanes[3].d;
1041 G4double dist = std::max(dy,std::max(dx1,dx2));
1042 return (dist < 0) ? -dist : 0.;
1043 }
1044 case 2: // YZ section is a rectangle and
1045 { // XZ section is an isosceles trapezoid
1049 + fPlanes[3].c*p.z()+fPlanes[3].d;
1050 G4double dist = std::max(dy,dx);
1051 return (dist < 0) ? -dist : 0.;
1052 }
1053 case 3: // YZ section is a rectangle and
1054 { // XY section is an isosceles trapezoid
1058 + fPlanes[3].b*p.y()+fPlanes[3].d;
1059 G4double dist = std::max(dy,dx);
1060 return (dist < 0) ? -dist : 0.;
1061 }
1062 }
1063 return 0.;
1064}
G4GLOB_DLL std::ostream G4cout
◆ 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 912 of file G4Trap.cc.
915{
916 // Z intersections
917 //
919 {
920 if (calcNorm)
921 {
922 *validNorm = true;
924 }
925 return 0;
926 }
930
931 // Y intersections
932 //
933 G4int i = 0;
934 for ( ; i<2; ++i)
935 {
937 if (cosa > 0)
938 {
940 if (dist >= -halfCarTolerance)
941 {
942 if (calcNorm)
943 {
944 *validNorm = true;
945 n->set(0, fPlanes[i].b, fPlanes[i].c);
946 }
947 return 0;
948 }
949 G4double tmp = -dist/cosa;
950 if (tmax > tmp) { tmax = tmp; iside = i; }
951 }
952 }
953
954 // X intersections
955 //
956 for ( ; i<4; ++i)
957 {
959 if (cosa > 0)
960 {
963 if (dist >= -halfCarTolerance)
964 {
965 if (calcNorm)
966 {
967 *validNorm = true;
968 n->set(fPlanes[i].a, fPlanes[i].b, fPlanes[i].c);
969 }
970 return 0;
971 }
972 G4double tmp = -dist/cosa;
973 if (tmax > tmp) { tmax = tmp; iside = i; }
974 }
975 }
976
977 // Set normal, if required, and return distance
978 //
979 if (calcNorm)
980 {
981 *validNorm = true;
982 if (iside < 0)
983 {
985 }
986 else
987 {
988 n->set(fPlanes[iside].a, fPlanes[iside].b, fPlanes[iside].c);
989 }
990 }
991 return tmax;
992}
◆ GetAlpha1()
|
inline |
Referenced by StreamInfo().
◆ GetAlpha2()
|
inline |
Referenced by StreamInfo().
◆ GetCubicVolume()
|
overridevirtual |
Returning an estimation of the solid volume (capacity) and surface area, in internal units.
Reimplemented from G4VSolid.
Definition at line 1190 of file G4Trap.cc.
1191{
1193 {
1194 G4AutoLock l(&trapMutex);
1195 G4ThreeVector pt[8];
1196 GetVertices(pt);
1197
1205
1206 fCubicVolume = ((dx1 + dx2 + dx3 + dx4)*(dy1 + dy2) +
1207 (dx4 + dx3 - dx2 - dx1)*(dy2 - dy1)/3)*dz*0.125;
1208 l.unlock();
1209 }
1211}
◆ GetEntityType()
|
overridevirtual |
◆ GetPhi()
|
inline |
Accessors obtaining (re)computed values of the original parameters.
Referenced by StreamInfo().
◆ GetPointOnSurface()
|
overridevirtual |
Returns a random point located and uniformly distributed on the surface of the solid.
Reimplemented from G4VSolid.
Definition at line 1149 of file G4Trap.cc.
1150{
1151 // Set indeces
1153 { {0,1,3,2}, {0,4,5,1}, {2,3,7,6}, {0,2,6,4}, {1,5,7,3}, {4,6,7,5} };
1154
1155 // Set vertices
1156 G4ThreeVector pt[8];
1157 GetVertices(pt);
1158
1159 // Select face
1160 //
1162 G4int k = 5;
1163 k -= (G4int)(select <= fAreas[4]);
1164 k -= (G4int)(select <= fAreas[3]);
1165 k -= (G4int)(select <= fAreas[2]);
1166 k -= (G4int)(select <= fAreas[1]);
1167 k -= (G4int)(select <= fAreas[0]);
1168
1169 // Select sub-triangle
1170 //
1171 G4int i0 = iface[k][0];
1172 G4int i1 = iface[k][1];
1173 G4int i2 = iface[k][2];
1174 G4int i3 = iface[k][3];
1176 if (select > fAreas[k] - s2) { i0 = i2; }
1177
1178 // Generate point
1179 //
1182 if (u + v > 1.) { u = 1. - u; v = 1. - v; }
1183 return (1.-u-v)*pt[i0] + u*pt[i1] + v*pt[i3];
1184}
double mag() const
static G4ThreeVector TriangleAreaNormal(const G4ThreeVector &A, const G4ThreeVector &B, const G4ThreeVector &C)
Definition G4GeomTools.cc:607
◆ GetSidePlane()
|
inline |
More accessors.
◆ 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 1217 of file G4Trap.cc.
1218{
1220 {
1221 G4AutoLock l(&trapMutex);
1222 G4ThreeVector pt[8];
1223 G4int iface [6][4] =
1224 { {0,1,3,2}, {0,4,5,1}, {2,3,7,6}, {0,2,6,4}, {1,5,7,3}, {4,6,7,5} };
1225
1226 GetVertices(pt);
1227 for (const auto & i : iface)
1228 {
1230 pt[i[1]],
1231 pt[i[2]],
1232 pt[i[3]]).mag();
1233 }
1234 l.unlock();
1235 }
1237}
static G4ThreeVector QuadAreaNormal(const G4ThreeVector &A, const G4ThreeVector &B, const G4ThreeVector &C, const G4ThreeVector &D)
Definition G4GeomTools.cc:618
◆ GetSymAxis()
|
inline |
◆ GetTanAlpha1()
|
inline |
◆ GetTanAlpha2()
|
inline |
◆ GetTheta()
|
inline |
Referenced by StreamInfo().
◆ GetXHalfLength1()
|
inline |
◆ GetXHalfLength2()
|
inline |
◆ GetXHalfLength3()
|
inline |
◆ GetXHalfLength4()
|
inline |
◆ GetYHalfLength1()
|
inline |
◆ GetYHalfLength2()
|
inline |
◆ GetZHalfLength()
|
inline |
Accessors. Returning the coordinates of a unit vector along a straight line joining centers of -/+fDz planes.
Referenced by BoundingLimits(), G4tgbGeometryDumper::GetSolidParams(), G4GDMLWriteParamvol::Trap_dimensionsWrite(), and G4GDMLWriteSolids::TrapWrite().
◆ Inside()
|
overridevirtual |
Concrete implementations of the expected query interfaces for solids, as defined in the base class G4VSolid.
Implements G4VSolid.
Definition at line 587 of file G4Trap.cc.
588{
589 switch (fTrapType)
590 {
591 case 0: // General case
592 {
596 G4double dy = std::max(dz,std::max(dy1,dy2));
597
599 + fPlanes[2].c*p.z()+fPlanes[2].d;
601 + fPlanes[3].c*p.z()+fPlanes[3].d;
602 G4double dist = std::max(dy,std::max(dx1,dx2));
603
606 }
607 case 1: // YZ section is a rectangle
608 {
612 + fPlanes[2].c*p.z()+fPlanes[2].d;
614 + fPlanes[3].c*p.z()+fPlanes[3].d;
615 G4double dist = std::max(dy,std::max(dx1,dx2));
616
619 }
620 case 2: // YZ section is a rectangle and
621 { // XZ section is an isosceles trapezoid
625 + fPlanes[3].c*p.z()+fPlanes[3].d;
626 G4double dist = std::max(dy,dx);
627
630 }
631 case 3: // YZ section is a rectangle and
632 { // XY section is an isosceles trapezoid
636 + fPlanes[3].b*p.y()+fPlanes[3].d;
637 G4double dist = std::max(dy,dx);
638
641 }
642 }
644}
Referenced by DistanceToOut().
◆ IsFaceted()
|
overridevirtual |
◆ MakePlane()
|
protected |
Calculates the coefficents of the plane p1->p2->p3->p4->p1 where the ThreeVectors 1-4 are in anti-clockwise order when viewed from infront of the plane (i.e. from normal direction).
- Returns
- true if the points are co-planar, false otherwise.
Definition at line 400 of file G4Trap.cc.
405{
410 normal = normal.unit();
411
412 G4ThreeVector centre = (p1 + p2 + p3 + p4)*0.25;
417
418 // compute distances and check planarity
423 G4double dmax = std::max(std::max(std::max(d1,d2),d3),d4);
424
426}
Hep3Vector unit() const
void setY(double)
double dot(const Hep3Vector &) const
void setZ(double)
void setX(double)
Referenced by MakePlanes().
◆ MakePlanes() [1/2]
|
protected |
Internal methods for checking and building planes. Computing the vertices and setting side planes, checking for planarity.
Definition at line 333 of file G4Trap.cc.
334{
335 G4double DzTthetaCphi = fDz*fTthetaCphi;
336 G4double DzTthetaSphi = fDz*fTthetaSphi;
337 G4double Dy1Talpha1 = fDy1*fTalpha1;
338 G4double Dy2Talpha2 = fDy2*fTalpha2;
339
340 G4ThreeVector pt[8] =
341 {
342 G4ThreeVector(-DzTthetaCphi-Dy1Talpha1-fDx1,-DzTthetaSphi-fDy1,-fDz),
343 G4ThreeVector(-DzTthetaCphi-Dy1Talpha1+fDx1,-DzTthetaSphi-fDy1,-fDz),
344 G4ThreeVector(-DzTthetaCphi+Dy1Talpha1-fDx2,-DzTthetaSphi+fDy1,-fDz),
345 G4ThreeVector(-DzTthetaCphi+Dy1Talpha1+fDx2,-DzTthetaSphi+fDy1,-fDz),
346 G4ThreeVector( DzTthetaCphi-Dy2Talpha2-fDx3, DzTthetaSphi-fDy2, fDz),
347 G4ThreeVector( DzTthetaCphi-Dy2Talpha2+fDx3, DzTthetaSphi-fDy2, fDz),
348 G4ThreeVector( DzTthetaCphi+Dy2Talpha2-fDx4, DzTthetaSphi+fDy2, fDz),
349 G4ThreeVector( DzTthetaCphi+Dy2Talpha2+fDx4, DzTthetaSphi+fDy2, fDz)
350 };
351
352 MakePlanes(pt);
353}
Referenced by G4Trap(), G4Trap(), G4Trap(), G4Trap(), G4Trap(), G4Trap(), G4Trap(), MakePlanes(), and SetAllParameters().
◆ MakePlanes() [2/2]
|
protected |
Definition at line 359 of file G4Trap.cc.
360{
362 const static G4String side[4] = { "~-Y", "~+Y", "~-X", "~+X" };
363
365 {
367 pt[iface[i][1]],
368 pt[iface[i][2]],
369 pt[iface[i][3]],
370 fPlanes[i])) { continue; }
371
372 // Non planar side face
373 G4ThreeVector normal(fPlanes[i].a,fPlanes[i].b,fPlanes[i].c);
374 G4double dmax = 0;
376 {
377 G4double dist = normal.dot(pt[iface[i][k]]) + fPlanes[i].d;
378 if (std::abs(dist) > std::abs(dmax)) { dmax = dist; }
379 }
380 std::ostringstream message;
381 message << "Side face " << side[i] << " is not planar for solid: "
383 StreamInfo(message);
385 FatalException, message);
386 }
387
388 // Re-compute parameters
389 SetCachedValues();
390}
std::ostream & StreamInfo(std::ostream &os) const override
Definition G4Trap.cc:1097
G4bool MakePlane(const G4ThreeVector &p1, const G4ThreeVector &p2, const G4ThreeVector &p3, const G4ThreeVector &p4, TrapSidePlane &plane)
Definition G4Trap.cc:400
◆ operator=()
Definition at line 253 of file G4Trap.cc.
254{
255 // Check assignment to self
256 //
257 if (this == &rhs) { return *this; }
258
259 // Copy base class data
260 //
261 G4CSGSolid::operator=(rhs);
262
263 // Copy data
264 //
265 halfCarTolerance = rhs.halfCarTolerance;
266 fDz = rhs.fDz; fTthetaCphi = rhs.fTthetaCphi; fTthetaSphi = rhs.fTthetaSphi;
267 fDy1 = rhs.fDy1; fDx1 = rhs.fDx1; fDx2 = rhs.fDx2; fTalpha1 = rhs.fTalpha1;
268 fDy2 = rhs.fDy2; fDx3 = rhs.fDx3; fDx4 = rhs.fDx4; fTalpha2 = rhs.fTalpha2;
271 fTrapType = rhs.fTrapType;
272 return *this;
273}
◆ SetAllParameters()
| void G4Trap::SetAllParameters | ( | G4double | pDz, |
| G4double | pTheta, | ||
| G4double | pPhi, | ||
| G4double | pDy1, | ||
| G4double | pDx1, | ||
| G4double | pDx2, | ||
| G4double | pAlp1, | ||
| G4double | pDy2, | ||
| G4double | pDx3, | ||
| G4double | pDx4, | ||
| G4double | pAlp2 ) |
Sets all parameters, as for constructor. Checks and sets half-widths as well as angles. Makes a final check of co-planarity.
Definition at line 280 of file G4Trap.cc.
291{
292 // Reset data of the base class
293 fCubicVolume = 0;
294 fSurfaceArea = 0;
296
297 // Set parameters
298 fDz = pDz;
299 fTthetaCphi = std::tan(pTheta)*std::cos(pPhi);
300 fTthetaSphi = std::tan(pTheta)*std::sin(pPhi);
301
302 fDy1 = pDy1; fDx1 = pDx1; fDx2 = pDx2; fTalpha1 = std::tan(pAlp1);
303 fDy2 = pDy2; fDx3 = pDx3; fDx4 = pDx4; fTalpha2 = std::tan(pAlp2);
304
305 CheckParameters();
306 MakePlanes();
307}
Referenced by G4ParameterisationTrdX::ComputeDimensions(), and G4ParameterisationTrdY::ComputeDimensions().
◆ SetCachedValues()
|
protected |
Recomputes parameters using planes.
Definition at line 432 of file G4Trap.cc.
433{
434 // Set indeces
436 { {0,1,3,2}, {0,4,5,1}, {2,3,7,6}, {0,2,6,4}, {1,5,7,3}, {4,6,7,5} };
437
438 // Get vertices
439 G4ThreeVector pt[8];
440 GetVertices(pt);
441
442 // Set face areas
444 {
445 fAreas[i] = G4GeomTools::QuadAreaNormal(pt[iface[i][0]],
446 pt[iface[i][1]],
447 pt[iface[i][2]],
448 pt[iface[i][3]]).mag();
449 }
451
452 // Define type of trapezoid
453 fTrapType = 0;
454 if (fPlanes[0].b == -1 && fPlanes[1].b == 1 &&
455 std::abs(fPlanes[0].a) < DBL_EPSILON &&
456 std::abs(fPlanes[0].c) < DBL_EPSILON &&
457 std::abs(fPlanes[1].a) < DBL_EPSILON &&
458 std::abs(fPlanes[1].c) < DBL_EPSILON)
459 {
460 fTrapType = 1; // YZ section is a rectangle ...
462 std::abs(fPlanes[2].c - fPlanes[3].c) < DBL_EPSILON &&
463 fPlanes[2].b == 0 &&
464 fPlanes[3].b == 0)
465 {
466 fTrapType = 2; // ... and XZ section is a isosceles trapezoid
467 fPlanes[2].a = -fPlanes[3].a;
468 fPlanes[2].c = fPlanes[3].c;
469 }
471 std::abs(fPlanes[2].b - fPlanes[3].b) < DBL_EPSILON &&
472 fPlanes[2].c == 0 &&
473 fPlanes[3].c == 0)
474 {
475 fTrapType = 3; // ... and XY section is a isosceles trapezoid
476 fPlanes[2].a = -fPlanes[3].a;
477 fPlanes[2].b = fPlanes[3].b;
478 }
479 }
480}
Referenced by MakePlanes().
◆ StreamInfo()
|
overridevirtual |
Streams the object contents to an output stream.
Reimplemented from G4CSGSolid.
Definition at line 1097 of file G4Trap.cc.
1098{
1103
1104 G4long oldprc = os.precision(16);
1105 os << "-----------------------------------------------------------\n"
1107 << " ===================================================\n"
1108 << " Solid type: G4Trap\n"
1109 << " Parameters:\n"
1110 << " half length Z: " << fDz/mm << " mm\n"
1111 << " half length Y, face -Dz: " << fDy1/mm << " mm\n"
1112 << " half length X, face -Dz, side -Dy1: " << fDx1/mm << " mm\n"
1113 << " half length X, face -Dz, side +Dy1: " << fDx2/mm << " mm\n"
1114 << " half length Y, face +Dz: " << fDy2/mm << " mm\n"
1115 << " half length X, face +Dz, side -Dy2: " << fDx3/mm << " mm\n"
1116 << " half length X, face +Dz, side +Dy2: " << fDx4/mm << " mm\n"
1117 << " theta: " << theta/degree << " degrees\n"
1118 << " phi: " << phi/degree << " degrees\n"
1119 << " alpha, face -Dz: " << alpha1/degree << " degrees\n"
1121 << "-----------------------------------------------------------\n";
1122 os.precision(oldprc);
1123
1124 return os;
1125}
G4double GetAlpha2() const
G4double GetAlpha1() const
G4double GetTheta() const
G4double GetPhi() const
Referenced by MakePlanes().
◆ 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 650 of file G4Trap.cc.
651{
652 G4double nx = 0, ny = 0, nz = 0;
655
656 switch (fTrapType)
657 {
658 case 0: // General case
659 {
661 {
663 if (std::abs(dy) > halfCarTolerance) { continue; }
664 ny = fPlanes[i].b;
665 nz += fPlanes[i].c;
666 break;
667 }
669 {
672 if (std::abs(dx) > halfCarTolerance) { continue; }
673 nx = fPlanes[i].a;
674 ny += fPlanes[i].b;
675 nz += fPlanes[i].c;
676 break;
677 }
678 break;
679 }
680 case 1: // YZ section - rectangle
681 {
685 {
688 if (std::abs(dx) > halfCarTolerance) { continue; }
689 nx = fPlanes[i].a;
690 ny += fPlanes[i].b;
691 nz += fPlanes[i].c;
692 break;
693 }
694 break;
695 }
696 case 2: // YZ section - rectangle, XZ section - isosceles trapezoid
697 {
701 fPlanes[3].c*p.z() + fPlanes[3].d;
703 nx = std::copysign(k, p.x())*fPlanes[3].a;
704 nz += k*fPlanes[3].c;
705 break;
706 }
707 case 3: // YZ section - rectangle, XY section - isosceles trapezoid
708 {
712 fPlanes[3].b*p.y() + fPlanes[3].d;
714 nx = std::copysign(k, p.x())*fPlanes[3].a;
715 ny += k*fPlanes[3].b;
716 break;
717 }
718 }
719
720 // Return normal
721 //
722 G4double mag2 = nx*nx + ny*ny + nz*nz;
723 if (mag2 == 1)
724 {
725 return { nx,ny,nz };
726 }
727 if (mag2 != 0)
728 {
730 }
731
732 // Point is not on the surface
733 //
734#ifdef G4CSGDEBUG
735 std::ostringstream message;
736 G4long oldprc = message.precision(16);
737 message << "Point p is not on surface (!?) of solid: "
739 message << "Position:\n";
743 G4cout.precision(oldprc) ;
745 JustWarning, message );
746 DumpInfo();
747#endif
748
749 return ApproxSurfaceNormal(p);
750}
The documentation for this class was generated from the following files:
