Loading...
Searching...
No Matches
G4Trap Class Reference
#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
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 | ||
| ) |
Definition at line 60 of file G4Trap.cc.
68{
69 fDz = pDz;
70 fTthetaCphi = std::tan(pTheta)*std::cos(pPhi);
71 fTthetaSphi = std::tan(pTheta)*std::sin(pPhi);
72
73 fDy1 = pDy1; fDx1 = pDx1; fDx2 = pDx2; fTalpha1 = std::tan(pAlp1);
74 fDy2 = pDy2; fDx3 = pDx3; fDx4 = pDx4; fTalpha2 = std::tan(pAlp2);
75
76 CheckParameters();
77 MakePlanes();
78}
Definition: G4CSGSolid.hh:42
◆ G4Trap() [2/8]
| G4Trap::G4Trap | ( | const G4String & | pName, |
| const G4ThreeVector | pt[8] | ||
| ) |
Definition at line 86 of file G4Trap.cc.
89{
90 // Start with check of centering - the center of gravity trap line
91 // should cross the origin of frame
92 //
93 if (!( pt[0].z() < 0
94 && pt[0].z() == pt[1].z()
95 && pt[0].z() == pt[2].z()
96 && pt[0].z() == pt[3].z()
97
98 && pt[4].z() > 0
99 && pt[4].z() == pt[5].z()
100 && pt[4].z() == pt[6].z()
101 && pt[4].z() == pt[7].z()
102
103 && std::fabs( pt[0].z() + pt[4].z() ) < kCarTolerance
104
105 && pt[0].y() == pt[1].y()
106 && pt[2].y() == pt[3].y()
107 && pt[4].y() == pt[5].y()
108 && pt[6].y() == pt[7].y()
109
110 && std::fabs(pt[0].y()+pt[2].y()+pt[4].y()+pt[6].y()) < kCarTolerance
111 && std::fabs(pt[0].x()+pt[1].x()+pt[4].x()+pt[5].x() +
112 pt[2].x()+pt[3].x()+pt[6].x()+pt[7].x()) < kCarTolerance ))
113 {
114 std::ostringstream message;
117 FatalException, message);
118 }
119
120 // Set parameters
121 //
122 fDz = (pt[7]).z();
123
124 fDy1 = ((pt[2]).y()-(pt[1]).y())*0.5;
125 fDx1 = ((pt[1]).x()-(pt[0]).x())*0.5;
126 fDx2 = ((pt[3]).x()-(pt[2]).x())*0.5;
127 fTalpha1 = ((pt[2]).x()+(pt[3]).x()-(pt[1]).x()-(pt[0]).x())*0.25/fDy1;
128
129 fDy2 = ((pt[6]).y()-(pt[5]).y())*0.5;
130 fDx3 = ((pt[5]).x()-(pt[4]).x())*0.5;
131 fDx4 = ((pt[7]).x()-(pt[6]).x())*0.5;
132 fTalpha2 = ((pt[6]).x()+(pt[7]).x()-(pt[5]).x()-(pt[4]).x())*0.25/fDy2;
133
134 fTthetaCphi = ((pt[4]).x()+fDy2*fTalpha2+fDx3)/fDz;
135 fTthetaSphi = ((pt[4]).y()+fDy2)/fDz;
136
137 CheckParameters();
138 MakePlanes(pt);
139}
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition: G4Exception.cc:35
G4String GetName() const
◆ G4Trap() [3/8]
Definition at line 145 of file G4Trap.cc.
150{
151 fDz = 0.5*pZ; fTthetaCphi = 0; fTthetaSphi = 0;
152 fDy1 = 0.5*pY; fDx1 = 0.5*pX; fDx2 = 0.5*pLTX; fTalpha1 = 0.5*(pLTX - pX)/pY;
153 fDy2 = fDy1; fDx3 = fDx1; fDx4 = fDx2; fTalpha2 = fTalpha1;
154
155 CheckParameters();
156 MakePlanes();
157}
◆ G4Trap() [4/8]
| G4Trap::G4Trap | ( | const G4String & | pName, |
| G4double | pDx1, | ||
| G4double | pDx2, | ||
| G4double | pDy1, | ||
| G4double | pDy2, | ||
| G4double | pDz | ||
| ) |
Definition at line 163 of file G4Trap.cc.
168{
169 fDz = pDz; fTthetaCphi = 0; fTthetaSphi = 0;
170 fDy1 = pDy1; fDx1 = pDx1; fDx2 = pDx1; fTalpha1 = 0;
171 fDy2 = pDy2; fDx3 = pDx2; fDx4 = pDx2; fTalpha2 = 0;
172
173 CheckParameters();
174 MakePlanes();
175}
◆ G4Trap() [5/8]
| G4Trap::G4Trap | ( | const G4String & | pName, |
| G4double | pDx, | ||
| G4double | pDy, | ||
| G4double | pDz, | ||
| G4double | pAlpha, | ||
| G4double | pTheta, | ||
| G4double | pPhi | ||
| ) |
Definition at line 181 of file G4Trap.cc.
187{
188 fDz = pDz;
189 fTthetaCphi = std::tan(pTheta)*std::cos(pPhi);
190 fTthetaSphi = std::tan(pTheta)*std::sin(pPhi);
191
192 fDy1 = pDy; fDx1 = pDx; fDx2 = pDx; fTalpha1 = std::tan(pAlpha);
193 fDy2 = pDy; fDx3 = pDx; fDx4 = pDx; fTalpha2 = fTalpha1;
194
195 CheckParameters();
196 MakePlanes();
197}
◆ G4Trap() [6/8]
| G4Trap::G4Trap | ( | const G4String & | pName | ) |
Definition at line 205 of file G4Trap.cc.
207 fDz(1.), fTthetaCphi(0.), fTthetaSphi(0.),
208 fDy1(1.), fDx1(1.), fDx2(1.), fTalpha1(0.),
209 fDy2(1.), fDx3(1.), fDx4(1.), fTalpha2(0.)
210{
211 MakePlanes();
212}
◆ ~G4Trap()
◆ G4Trap() [7/8]
| G4Trap::G4Trap | ( | __void__ & | a | ) |
Definition at line 219 of file G4Trap.cc.
221 fDz(1.), fTthetaCphi(0.), fTthetaSphi(0.),
222 fDy1(1.), fDx1(1.), fDx2(1.), fTalpha1(0.),
223 fDy2(1.), fDx3(1.), fDx4(1.), fTalpha2(0.)
224{
225 MakePlanes();
226}
◆ G4Trap() [8/8]
| G4Trap::G4Trap | ( | const G4Trap & | rhs | ) |
Definition at line 240 of file G4Trap.cc.
241 : G4CSGSolid(rhs), halfCarTolerance(rhs.halfCarTolerance),
242 fDz(rhs.fDz), fTthetaCphi(rhs.fTthetaCphi), fTthetaSphi(rhs.fTthetaSphi),
243 fDy1(rhs.fDy1), fDx1(rhs.fDx1), fDx2(rhs.fDx2), fTalpha1(rhs.fTalpha1),
244 fDy2(rhs.fDy2), fDx3(rhs.fDx3), fDx4(rhs.fDx4), fTalpha2(rhs.fTalpha2)
245{
248 fTrapType = rhs.fTrapType;
249}
Member Function Documentation
◆ BoundingLimits()
|
virtual |
Reimplemented from G4VSolid.
Definition at line 549 of file G4Trap.cc.
550{
551 G4ThreeVector pt[8];
552 GetVertices(pt);
553
554 G4double xmin = kInfinity, xmax = -kInfinity;
555 G4double ymin = kInfinity, ymax = -kInfinity;
557 {
559 if (x < xmin) xmin = x;
560 if (x > xmax) xmax = x;
562 if (y < ymin) ymin = y;
563 if (y > ymax) ymax = y;
564 }
565
567 pMin.set(xmin,ymin,-dz);
568 pMax.set(xmax,ymax, dz);
569
570 // Check correctness of the bounding box
571 //
573 {
574 std::ostringstream message;
575 message << "Bad bounding box (min >= max) for solid: "
577 << "\npMin = " << pMin
578 << "\npMax = " << pMax;
580 JustWarning, message);
581 DumpInfo();
582 }
583}
Definition: ThreeVector.h:36
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()
|
virtual |
Implements G4VSolid.
Definition at line 589 of file G4Trap.cc.
593{
594 G4ThreeVector bmin, bmax;
595 G4bool exist;
596
597 // Check bounding box (bbox)
598 //
599 BoundingLimits(bmin,bmax);
600 G4BoundingEnvelope bbox(bmin,bmax);
601#ifdef G4BBOX_EXTENT
602 return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
603#endif
604 if (bbox.BoundingBoxVsVoxelLimits(pAxis,pVoxelLimit,pTransform,pMin,pMax))
605 {
606 return exist = (pMin < pMax) ? true : false;
607 }
608
609 // Set bounding envelope (benv) and calculate extent
610 //
611 G4ThreeVector pt[8];
612 GetVertices(pt);
613
614 G4ThreeVectorList baseA(4), baseB(4);
615 baseA[0] = pt[0];
616 baseA[1] = pt[1];
617 baseA[2] = pt[3];
618 baseA[3] = pt[2];
619
620 baseB[0] = pt[4];
621 baseB[1] = pt[5];
622 baseB[2] = pt[7];
623 baseB[3] = pt[6];
624
625 std::vector<const G4ThreeVectorList *> polygons(2);
626 polygons[0] = &baseA;
627 polygons[1] = &baseB;
628
629 G4BoundingEnvelope benv(bmin,bmax,polygons);
630 exist = benv.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
631 return exist;
632}
Definition: G4BoundingEnvelope.hh:59
void BoundingLimits(G4ThreeVector &pMin, G4ThreeVector &pMax) const
Definition: G4Trap.cc:549
◆ Clone()
|
virtual |
◆ ComputeDimensions()
|
virtual |
Reimplemented from G4VSolid.
Definition at line 538 of file G4Trap.cc.
541{
543}
virtual void ComputeDimensions(G4Box &, const G4int, const G4VPhysicalVolume *) const
Definition: G4VPVParameterisation.hh:91
◆ CreatePolyhedron()
|
virtual |
Reimplemented from G4VSolid.
Definition at line 1225 of file G4Trap.cc.
1226{
1227 G4double phi = std::atan2(fTthetaSphi, fTthetaCphi);
1228 G4double alpha1 = std::atan(fTalpha1);
1229 G4double alpha2 = std::atan(fTalpha2);
1230 G4double theta = std::atan(std::sqrt(fTthetaCphi*fTthetaCphi
1231 +fTthetaSphi*fTthetaSphi));
1232
1234 fDy1, fDx1, fDx2, alpha1,
1235 fDy2, fDx3, fDx4, alpha2);
1236}
Definition: G4Polyhedron.hh:208
◆ DescribeYourselfTo()
|
virtual |
◆ DistanceToIn() [1/2]
|
virtual |
Implements G4VSolid.
Definition at line 896 of file G4Trap.cc.
897{
898 switch (fTrapType)
899 {
900 case 0: // General case
901 {
905 G4double dy = std::max(dz,std::max(dy1,dy2));
906
911 G4double dist = std::max(dy,std::max(dx1,dx2));
912 return (dist > 0) ? dist : 0.;
913 }
914 case 1: // YZ section is a rectangle
915 {
922 G4double dist = std::max(dy,std::max(dx1,dx2));
923 return (dist > 0) ? dist : 0.;
924 }
925 case 2: // YZ section is a rectangle and
926 { // XZ section is an isosceles trapezoid
931 G4double dist = std::max(dy,dx);
932 return (dist > 0) ? dist : 0.;
933 }
934 case 3: // YZ section is a rectangle and
935 { // XY section is an isosceles trapezoid
940 G4double dist = std::max(dy,dx);
941 return (dist > 0) ? dist : 0.;
942 }
943 }
944 return 0.;
945}
◆ DistanceToIn() [2/2]
|
virtual |
Implements G4VSolid.
Definition at line 827 of file G4Trap.cc.
829{
830 // Z intersections
831 //
833 return kInfinity;
835 G4double dz = (invz < 0) ? fDz : -fDz;
838
839 // Y intersections
840 //
842 G4int i = 0;
843 for ( ; i<2; ++i)
844 {
847 if (dist >= -halfCarTolerance)
848 {
849 if (cosa >= 0) return kInfinity;
850 G4double tmp = -dist/cosa;
851 if (tymin < tmp) tymin = tmp;
852 }
853 else if (cosa > 0)
854 {
855 G4double tmp = -dist/cosa;
856 if (tymax > tmp) tymax = tmp;
857 }
858 }
859
860 // Z intersections
861 //
863 for ( ; i<4; ++i)
864 {
867 fPlanes[i].d;
868 if (dist >= -halfCarTolerance)
869 {
870 if (cosa >= 0) return kInfinity;
871 G4double tmp = -dist/cosa;
872 if (txmin < tmp) txmin = tmp;
873 }
874 else if (cosa > 0)
875 {
876 G4double tmp = -dist/cosa;
877 if (txmax > tmp) txmax = tmp;
878 }
879 }
880
881 // Find distance
882 //
883 G4double tmin = std::max(std::max(txmin,tymin),tzmin);
884 G4double tmax = std::min(std::min(txmax,tymax),tzmax);
885
886 if (tmax <= tmin + halfCarTolerance) return kInfinity; // touch or no hit
887 return (tmin < halfCarTolerance ) ? 0. : tmin;
888}
◆ DistanceToOut() [1/2]
|
virtual |
Implements G4VSolid.
Definition at line 1036 of file G4Trap.cc.
1037{
1038#ifdef G4CSGDEBUG
1040 {
1041 std::ostringstream message;
1042 G4int oldprc = message.precision(16);
1044 message << "Position:\n";
1048 G4cout.precision(oldprc);
1050 JustWarning, message );
1051 DumpInfo();
1052 }
1053#endif
1054 switch (fTrapType)
1055 {
1056 case 0: // General case
1057 {
1061 G4double dy = std::max(dz,std::max(dy1,dy2));
1062
1067 G4double dist = std::max(dy,std::max(dx1,dx2));
1068 return (dist < 0) ? -dist : 0.;
1069 }
1070 case 1: // YZ section is a rectangle
1071 {
1078 G4double dist = std::max(dy,std::max(dx1,dx2));
1079 return (dist < 0) ? -dist : 0.;
1080 }
1081 case 2: // YZ section is a rectangle and
1082 { // XZ section is an isosceles trapezoid
1087 G4double dist = std::max(dy,dx);
1088 return (dist < 0) ? -dist : 0.;
1089 }
1090 case 3: // YZ section is a rectangle and
1091 { // XY section is an isosceles trapezoid
1096 G4double dist = std::max(dy,dx);
1097 return (dist < 0) ? -dist : 0.;
1098 }
1099 }
1100 return 0.;
1101}
G4GLOB_DLL std::ostream G4cout
◆ DistanceToOut() [2/2]
|
virtual |
Implements G4VSolid.
Definition at line 953 of file G4Trap.cc.
956{
957 // Z intersections
958 //
960 {
961 if (calcNorm)
962 {
963 *validNorm = true;
965 }
966 return 0;
967 }
971
972 // Y intersections
973 //
974 G4int i = 0;
975 for ( ; i<2; ++i)
976 {
978 if (cosa > 0)
979 {
981 if (dist >= -halfCarTolerance)
982 {
983 if (calcNorm)
984 {
985 *validNorm = true;
986 n->set(0, fPlanes[i].b, fPlanes[i].c);
987 }
988 return 0;
989 }
990 G4double tmp = -dist/cosa;
991 if (tmax > tmp) { tmax = tmp; iside = i; }
992 }
993 }
994
995 // X intersections
996 //
997 for ( ; i<4; ++i)
998 {
1000 if (cosa > 0)
1001 {
1004 if (dist >= -halfCarTolerance)
1005 {
1006 if (calcNorm)
1007 {
1008 *validNorm = true;
1009 n->set(fPlanes[i].a, fPlanes[i].b, fPlanes[i].c);
1010 }
1011 return 0;
1012 }
1013 G4double tmp = -dist/cosa;
1014 if (tmax > tmp) { tmax = tmp; iside = i; }
1015 }
1016 }
1017
1018 // Set normal, if required, and return distance
1019 //
1020 if (calcNorm)
1021 {
1022 *validNorm = true;
1023 if (iside < 0)
1025 else
1026 n->set(fPlanes[iside].a, fPlanes[iside].b, fPlanes[iside].c);
1027 }
1028 return tmax;
1029}
◆ GetCubicVolume()
|
virtual |
Reimplemented from G4VSolid.
Definition at line 488 of file G4Trap.cc.
489{
491 {
492 G4ThreeVector pt[8];
493 GetVertices(pt);
494
502
503 fCubicVolume = ((dx1 + dx2 + dx3 + dx4)*(dy1 + dy2) +
504 (dx4 + dx3 - dx2 - dx1)*(dy2 - dy1)/3)*dz*0.125;
505 }
507}
◆ GetEntityType()
|
virtual |
◆ GetPointOnSurface()
|
virtual |
Reimplemented from G4VSolid.
Definition at line 1179 of file G4Trap.cc.
1180{
1181 // Set indeces
1183 { {0,1,3,2}, {0,4,5,1}, {2,3,7,6}, {0,2,6,4}, {1,5,7,3}, {4,6,7,5} };
1184
1185 // Set vertices
1186 G4ThreeVector pt[8];
1187 GetVertices(pt);
1188
1189 // Select face
1190 //
1192 G4int k = 5;
1193 k -= (select <= fAreas[4]);
1194 k -= (select <= fAreas[3]);
1195 k -= (select <= fAreas[2]);
1196 k -= (select <= fAreas[1]);
1197 k -= (select <= fAreas[0]);
1198
1199 // Select sub-triangle
1200 //
1201 G4int i0 = iface[k][0];
1202 G4int i1 = iface[k][1];
1203 G4int i2 = iface[k][2];
1204 G4int i3 = iface[k][3];
1206 if (select > fAreas[k] - s2) i0 = i2;
1207
1208 // Generate point
1209 //
1212 if (u + v > 1.) { u = 1. - u; v = 1. - v; }
1213 return (1.-u-v)*pt[i0] + u*pt[i1] + v*pt[i3];
1214}
double mag() const
static G4ThreeVector TriangleAreaNormal(const G4ThreeVector &A, const G4ThreeVector &B, const G4ThreeVector &C)
Definition: G4GeomTools.cc:598
◆ GetSidePlane()
|
inline |
◆ GetSurfaceArea()
|
virtual |
Reimplemented from G4VSolid.
Definition at line 513 of file G4Trap.cc.
514{
516 {
517 G4ThreeVector pt[8];
518 G4int iface [6][4] =
519 { {0,1,3,2}, {0,4,5,1}, {2,3,7,6}, {0,2,6,4}, {1,5,7,3}, {4,6,7,5} };
520
521 GetVertices(pt);
523 {
525 pt[iface[i][1]],
526 pt[iface[i][2]],
527 pt[iface[i][3]]).mag();
528 }
529 }
531}
static G4ThreeVector QuadAreaNormal(const G4ThreeVector &A, const G4ThreeVector &B, const G4ThreeVector &C, const G4ThreeVector &D)
Definition: G4GeomTools.cc:609
◆ GetSymAxis()
|
inline |
◆ GetTanAlpha1()
|
inline |
◆ GetTanAlpha2()
|
inline |
◆ GetXHalfLength1()
|
inline |
◆ GetXHalfLength2()
|
inline |
◆ GetXHalfLength3()
|
inline |
◆ GetXHalfLength4()
|
inline |
◆ GetYHalfLength1()
|
inline |
◆ GetYHalfLength2()
|
inline |
◆ GetZHalfLength()
|
inline |
◆ Inside()
|
virtual |
Implements G4VSolid.
Definition at line 638 of file G4Trap.cc.
639{
640 switch (fTrapType)
641 {
642 case 0: // General case
643 {
647 G4double dy = std::max(dz,std::max(dy1,dy2));
648
653 G4double dist = std::max(dy,std::max(dx1,dx2));
654
657 }
658 case 1: // YZ section is a rectangle
659 {
666 G4double dist = std::max(dy,std::max(dx1,dx2));
667
670 }
671 case 2: // YZ section is a rectangle and
672 { // XZ section is an isosceles trapezoid
677 G4double dist = std::max(dy,dx);
678
681 }
682 case 3: // YZ section is a rectangle and
683 { // XY section is an isosceles trapezoid
688 G4double dist = std::max(dy,dx);
689
692 }
693 }
695}
Referenced by DistanceToOut().
◆ MakePlane()
|
protected |
Definition at line 402 of file G4Trap.cc.
407{
408 G4ThreeVector normal = ((p4 - p2).cross(p3 - p1)).unit();
412 normal = normal.unit();
413
414 G4ThreeVector centre = (p1 + p2 + p3 + p4)*0.25;
419
420 // compute distances and check planarity
425 G4double dmax = std::max(std::max(std::max(d1,d2),d3),d4);
426
428}
Hep3Vector unit() const
void setY(double)
double dot(const Hep3Vector &) const
void setZ(double)
void setX(double)
Referenced by MakePlanes().
◆ MakePlanes() [1/2]
|
protected |
Definition at line 335 of file G4Trap.cc.
336{
337 G4double DzTthetaCphi = fDz*fTthetaCphi;
338 G4double DzTthetaSphi = fDz*fTthetaSphi;
339 G4double Dy1Talpha1 = fDy1*fTalpha1;
340 G4double Dy2Talpha2 = fDy2*fTalpha2;
341
342 G4ThreeVector pt[8] =
343 {
344 G4ThreeVector(-DzTthetaCphi-Dy1Talpha1-fDx1,-DzTthetaSphi-fDy1,-fDz),
345 G4ThreeVector(-DzTthetaCphi-Dy1Talpha1+fDx1,-DzTthetaSphi-fDy1,-fDz),
346 G4ThreeVector(-DzTthetaCphi+Dy1Talpha1-fDx2,-DzTthetaSphi+fDy1,-fDz),
347 G4ThreeVector(-DzTthetaCphi+Dy1Talpha1+fDx2,-DzTthetaSphi+fDy1,-fDz),
348 G4ThreeVector( DzTthetaCphi-Dy2Talpha2-fDx3, DzTthetaSphi-fDy2, fDz),
349 G4ThreeVector( DzTthetaCphi-Dy2Talpha2+fDx3, DzTthetaSphi-fDy2, fDz),
350 G4ThreeVector( DzTthetaCphi+Dy2Talpha2-fDx4, DzTthetaSphi+fDy2, fDz),
351 G4ThreeVector( DzTthetaCphi+Dy2Talpha2+fDx4, DzTthetaSphi+fDy2, fDz)
352 };
353
354 MakePlanes(pt);
355}
Referenced by G4Trap(), MakePlanes(), and SetAllParameters().
◆ MakePlanes() [2/2]
|
protected |
Definition at line 361 of file G4Trap.cc.
362{
365
367 {
369 pt[iface[i][1]],
370 pt[iface[i][2]],
371 pt[iface[i][3]],
372 fPlanes[i])) continue;
373
374 // Non planar side face
375 G4ThreeVector normal(fPlanes[i].a,fPlanes[i].b,fPlanes[i].c);
376 G4double dmax = 0;
378 {
380 if (std::abs(dist) > std::abs(dmax)) dmax = dist;
381 }
382 std::ostringstream message;
383 message << "Side face " << side[i] << " is not planar for solid: "
385 StreamInfo(message);
387 FatalException, message);
388 }
389
390 // Re-compute parameters
391 SetCachedValues();
392}
G4bool MakePlane(const G4ThreeVector &p1, const G4ThreeVector &p2, const G4ThreeVector &p3, const G4ThreeVector &p4, TrapSidePlane &plane)
Definition: G4Trap.cc:402
◆ operator=()
Definition at line 255 of file G4Trap.cc.
256{
257 // Check assignment to self
258 //
259 if (this == &rhs) { return *this; }
260
261 // Copy base class data
262 //
263 G4CSGSolid::operator=(rhs);
264
265 // Copy data
266 //
267 halfCarTolerance = rhs.halfCarTolerance;
268 fDz = rhs.fDz; fTthetaCphi = rhs.fTthetaCphi; fTthetaSphi = rhs.fTthetaSphi;
269 fDy1 = rhs.fDy1; fDx1 = rhs.fDx1; fDx2 = rhs.fDx2; fTalpha1 = rhs.fTalpha1;
270 fDy2 = rhs.fDy2; fDx3 = rhs.fDx3; fDx4 = rhs.fDx4; fTalpha2 = rhs.fTalpha2;
273 fTrapType = rhs.fTrapType;
274 return *this;
275}
◆ 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 | ||
| ) |
Definition at line 282 of file G4Trap.cc.
293{
294 // Reset data of the base class
295 fCubicVolume = 0;
296 fSurfaceArea = 0;
298
299 // Set parameters
300 fDz = pDz;
301 fTthetaCphi = std::tan(pTheta)*std::cos(pPhi);
302 fTthetaSphi = std::tan(pTheta)*std::sin(pPhi);
303
304 fDy1 = pDy1; fDx1 = pDx1; fDx2 = pDx2; fTalpha1 = std::tan(pAlp1);
305 fDy2 = pDy2; fDx3 = pDx3; fDx4 = pDx4; fTalpha2 = std::tan(pAlp2);
306
307 CheckParameters();
308 MakePlanes();
309}
Referenced by G4ParameterisationTrdX::ComputeDimensions().
◆ SetCachedValues()
|
protected |
Definition at line 434 of file G4Trap.cc.
435{
436 // Set indeces
438 { {0,1,3,2}, {0,4,5,1}, {2,3,7,6}, {0,2,6,4}, {1,5,7,3}, {4,6,7,5} };
439
440 // Get vertices
441 G4ThreeVector pt[8];
442 GetVertices(pt);
443
444 // Set face areas
446 {
447 fAreas[i] = G4GeomTools::QuadAreaNormal(pt[iface[i][0]],
448 pt[iface[i][1]],
449 pt[iface[i][2]],
450 pt[iface[i][3]]).mag();
451 }
453
454 // Define type of trapezoid
455 fTrapType = 0;
456 if (fPlanes[0].b == -1 && fPlanes[1].b == 1 &&
457 std::abs(fPlanes[0].a) < DBL_EPSILON &&
458 std::abs(fPlanes[0].c) < DBL_EPSILON &&
459 std::abs(fPlanes[1].a) < DBL_EPSILON &&
460 std::abs(fPlanes[1].c) < DBL_EPSILON)
461 {
462 fTrapType = 1; // YZ section is a rectangle ...
464 std::abs(fPlanes[2].c - fPlanes[3].c) < DBL_EPSILON &&
465 fPlanes[2].b == 0 &&
466 fPlanes[3].b == 0)
467 {
468 fTrapType = 2; // ... and XZ section is a isosceles trapezoid
471 }
473 std::abs(fPlanes[2].b - fPlanes[3].b) < DBL_EPSILON &&
474 fPlanes[2].c == 0 &&
475 fPlanes[3].c == 0)
476 {
477 fTrapType = 3; // ... and XY section is a isosceles trapezoid
480 }
481 }
482}
Referenced by MakePlanes().
◆ StreamInfo()
|
virtual |
Reimplemented from G4CSGSolid.
Definition at line 1125 of file G4Trap.cc.
1126{
1127 G4double phi = std::atan2(fTthetaSphi,fTthetaCphi);
1128 G4double theta = std::atan(std::sqrt(fTthetaCphi*fTthetaCphi
1129 +fTthetaSphi*fTthetaSphi));
1130 G4double alpha1 = std::atan(fTalpha1);
1131 G4double alpha2 = std::atan(fTalpha2);
1133
1134 G4int oldprc = os.precision(16);
1135 os << "-----------------------------------------------------------\n"
1137 << " ===================================================\n"
1138 << " Solid type: G4Trap\n"
1139 << " Parameters:\n"
1140 << " half length Z: " << fDz/mm << " mm\n"
1141 << " half length Y, face -Dz: " << fDy1/mm << " mm\n"
1142 << " half length X, face -Dz, side -Dy1: " << fDx1/mm << " mm\n"
1143 << " half length X, face -Dz, side +Dy1: " << fDx2/mm << " mm\n"
1144 << " half length Y, face +Dz: " << fDy2/mm << " mm\n"
1145 << " half length X, face +Dz, side -Dy2: " << fDx3/mm << " mm\n"
1146 << " half length X, face +Dz, side +Dy2: " << fDx4/mm << " mm\n"
1147 << " theta: " << theta/degree << signDegree << "\n"
1148 << " phi: " << phi/degree << signDegree << "\n"
1149 << " alpha, face -Dz: " << alpha1/degree << signDegree << "\n"
1150 << " alpha, face +Dz: " << alpha2/degree << signDegree << "\n"
1151 << "-----------------------------------------------------------\n";
1152 os.precision(oldprc);
1153
1154 return os;
1155}
Referenced by MakePlanes().
◆ SurfaceNormal()
|
virtual |
Implements G4VSolid.
Definition at line 701 of file G4Trap.cc.
702{
703 G4double nx = 0, ny = 0, nz = 0;
706
707 switch (fTrapType)
708 {
709 case 0: // General case
710 {
712 {
714 if (std::abs(dy) > halfCarTolerance) continue;
715 ny = fPlanes[i].b;
716 nz += fPlanes[i].c;
717 break;
718 }
720 {
723 if (std::abs(dx) > halfCarTolerance) continue;
724 nx = fPlanes[i].a;
725 ny += fPlanes[i].b;
726 nz += fPlanes[i].c;
727 break;
728 }
729 break;
730 }
731 case 1: // YZ section - rectangle
732 {
736 {
739 if (std::abs(dx) > halfCarTolerance) continue;
740 nx = fPlanes[i].a;
741 ny += fPlanes[i].b;
742 nz += fPlanes[i].c;
743 break;
744 }
745 break;
746 }
747 case 2: // YZ section - rectangle, XZ section - isosceles trapezoid
748 {
753 G4double k = std::abs(dx) <= halfCarTolerance;
755 nz += k*fPlanes[3].c;
756 break;
757 }
758 case 3: // YZ section - rectangle, XY section - isosceles trapezoid
759 {
764 G4double k = std::abs(dx) <= halfCarTolerance;
766 ny += k*fPlanes[3].b;
767 break;
768 }
769 }
770
771 // Return normal
772 //
773 G4double mag2 = nx*nx + ny*ny + nz*nz;
776 else
777 {
778 // Point is not on the surface
779 //
780#ifdef G4CSGDEBUG
781 std::ostringstream message;
782 G4int oldprc = message.precision(16);
783 message << "Point p is not on surface (!?) of solid: "
785 message << "Position:\n";
789 G4cout.precision(oldprc) ;
791 JustWarning, message );
792 DumpInfo();
793#endif
794 return ApproxSurfaceNormal(p);
795 }
796}
The documentation for this class was generated from the following files:
