Loading...
Searching...
No Matches
G4ExtrudedSolid Class Reference
#include <G4ExtrudedSolid.hh>
Inheritance diagram for G4ExtrudedSolid:
Classes | |
| struct | ZSection |
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 G4TessellatedSolid | |
| G4double | kCarToleranceHalf |
| Protected Attributes inherited from G4VSolid | |
| G4double | kCarTolerance |
Detailed Description
Definition at line 71 of file G4ExtrudedSolid.hh.
Constructor & Destructor Documentation
◆ G4ExtrudedSolid() [1/4]
| G4ExtrudedSolid::G4ExtrudedSolid | ( | const G4String & | pName, |
| const std::vector< G4TwoVector > & | polygon, | ||
| const std::vector< ZSection > & | zsections | ||
| ) |
Definition at line 66 of file G4ExtrudedSolid.cc.
69 : G4TessellatedSolid(pName),
70 fNv(polygon.size()),
71 fNz(zsections.size()),
72 fIsConvex(false),
73 fGeometryType("G4ExtrudedSolid"),
74 fSolidType(0)
75{
76 // General constructor
77
78 // First check input parameters
79
80 if (fNv < 3)
81 {
82 std::ostringstream message;
83 message << "Number of vertices in polygon < 3 - " << pName;
85 FatalErrorInArgument, message);
86 }
87
88 if (fNz < 2)
89 {
90 std::ostringstream message;
91 message << "Number of z-sides < 2 - " << pName;
93 FatalErrorInArgument, message);
94 }
95
97 {
98 if ( zsections[i].fZ > zsections[i+1].fZ )
99 {
100 std::ostringstream message;
101 message << "Z-sections have to be ordered by z value (z0 < z1 < z2...) - "
102 << pName;
104 FatalErrorInArgument, message);
105 }
107 {
108 std::ostringstream message;
109 message << "Z-sections with the same z position are not supported - "
110 << pName;
112 FatalException, message);
113 }
114 }
115
116 // Copy polygon
117 //
118 fPolygon = polygon;
119
120 // Remove collinear and coincident vertices, if any
121 //
122 std::vector<G4int> removedVertices;
123 G4GeomTools::RemoveRedundantVertices(fPolygon,removedVertices,
124 2*kCarTolerance);
125 if (removedVertices.size() != 0)
126 {
127 G4int nremoved = removedVertices.size();
128 std::ostringstream message;
129 message << "The following "<< nremoved
130 << " vertices have been removed from polygon in " << pName
131 << "\nas collinear or coincident with other vertices: "
132 << removedVertices[0];
135 JustWarning, message);
136 }
137
138 fNv = fPolygon.size();
139 if (fNv < 3)
140 {
141 std::ostringstream message;
142 message << "Number of vertices in polygon after removal < 3 - " << pName;
144 FatalErrorInArgument, message);
145 }
146
147 // Check if polygon vertices are defined clockwise
148 // (the area is positive if polygon vertices are defined anti-clockwise)
149 //
151 {
152 // Polygon vertices are defined anti-clockwise, we revert them
153 // G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids1001",
154 // JustWarning,
155 // "Polygon vertices defined anti-clockwise, reverting polygon");
156 std::reverse(fPolygon.begin(),fPolygon.end());
157 }
158
159 // Copy z-sections
160 //
161 fZSections = zsections;
162
163 G4bool result = MakeFacets();
164 if (!result)
165 {
166 std::ostringstream message;
167 message << "Making facets failed - " << pName;
169 FatalException, message);
170 }
171 fIsConvex = G4GeomTools::IsConvex(fPolygon);
172
173 ComputeProjectionParameters();
174
175 // Check if the solid is a right prism, if so then set lateral planes
176 //
177 if ((fNz == 2)
178 && (fZSections[0].fScale == 1) && (fZSections[1].fScale == 1)
179 && (fZSections[0].fOffset == G4TwoVector(0,0))
180 && (fZSections[1].fOffset == G4TwoVector(0,0)))
181 {
182 fSolidType = (fIsConvex) ? 1 : 2; // 1 - convex, 2 - non-convex right prism
183 ComputeLateralPlanes();
184 }
185}
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition: G4Exception.cc:35
static void RemoveRedundantVertices(G4TwoVectorList &polygon, std::vector< G4int > &iout, G4double tolerance=0.0)
Definition: G4GeomTools.cc:305
static G4double PolygonArea(const G4TwoVectorList &polygon)
Definition: G4GeomTools.cc:76
static G4bool IsConvex(const G4TwoVectorList &polygon)
Definition: G4GeomTools.cc:165
G4double kCarToleranceHalf
Definition: G4TessellatedSolid.hh:266
◆ G4ExtrudedSolid() [2/4]
| G4ExtrudedSolid::G4ExtrudedSolid | ( | const G4String & | pName, |
| const std::vector< G4TwoVector > & | polygon, | ||
| G4double | halfZ, | ||
| const G4TwoVector & | off1, | ||
| G4double | scale1, | ||
| const G4TwoVector & | off2, | ||
| G4double | scale2 | ||
| ) |
Definition at line 189 of file G4ExtrudedSolid.cc.
194 : G4TessellatedSolid(pName),
195 fNv(polygon.size()),
196 fNz(2),
197 fGeometryType("G4ExtrudedSolid")
198{
199 // Special constructor for solid with 2 z-sections
200
201 // First check input parameters
202 //
203 if (fNv < 3)
204 {
205 std::ostringstream message;
206 message << "Number of vertices in polygon < 3 - " << pName;
208 FatalErrorInArgument, message);
209 }
210
211 // Copy polygon
212 //
213 fPolygon = polygon;
214
215 // Remove collinear and coincident vertices, if any
216 //
217 std::vector<G4int> removedVertices;
218 G4GeomTools::RemoveRedundantVertices(fPolygon,removedVertices,
219 2*kCarTolerance);
220 if (removedVertices.size() != 0)
221 {
222 G4int nremoved = removedVertices.size();
223 std::ostringstream message;
224 message << "The following "<< nremoved
225 << " vertices have been removed from polygon in " << pName
226 << "\nas collinear or coincident with other vertices: "
227 << removedVertices[0];
230 JustWarning, message);
231 }
232
233 fNv = fPolygon.size();
234 if (fNv < 3)
235 {
236 std::ostringstream message;
237 message << "Number of vertices in polygon after removal < 3 - " << pName;
239 FatalErrorInArgument, message);
240 }
241
242 // Check if polygon vertices are defined clockwise
243 // (the area is positive if polygon vertices are defined anti-clockwise)
244 //
246 {
247 // Polygon vertices are defined anti-clockwise, we revert them
248 // G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids1001",
249 // JustWarning,
250 // "Polygon vertices defined anti-clockwise, reverting polygon");
251 std::reverse(fPolygon.begin(),fPolygon.end());
252 }
253
254 // Copy z-sections
255 //
256 fZSections.push_back(ZSection(-dz, off1, scale1));
257 fZSections.push_back(ZSection( dz, off2, scale2));
258
259 G4bool result = MakeFacets();
260 if (!result)
261 {
262 std::ostringstream message;
263 message << "Making facets failed - " << pName;
265 FatalException, message);
266 }
267 fIsConvex = G4GeomTools::IsConvex(fPolygon);
268
269 ComputeProjectionParameters();
270
271 // Check if the solid is a right prism, if so then set lateral planes
272 //
273 if ((scale1 == 1) && (scale2 == 1)
275 {
276 fSolidType = (fIsConvex) ? 1 : 2; // 1 - convex, 2 - non-convex right prism
277 ComputeLateralPlanes();
278 }
279}
◆ ~G4ExtrudedSolid()
|
virtual |
Definition at line 333 of file G4ExtrudedSolid.cc.
334{
335 // Destructor
336}
◆ G4ExtrudedSolid() [3/4]
| G4ExtrudedSolid::G4ExtrudedSolid | ( | __void__ & | a | ) |
Definition at line 283 of file G4ExtrudedSolid.cc.
284 : G4TessellatedSolid(a), fNv(0), fNz(0),
285 fGeometryType("G4ExtrudedSolid")
286{
287 // Fake default constructor - sets only member data and allocates memory
288 // for usage restricted to object persistency.
289}
◆ G4ExtrudedSolid() [4/4]
| G4ExtrudedSolid::G4ExtrudedSolid | ( | const G4ExtrudedSolid & | rhs | ) |
Definition at line 293 of file G4ExtrudedSolid.cc.
294 : G4TessellatedSolid(rhs), fNv(rhs.fNv), fNz(rhs.fNz),
295 fPolygon(rhs.fPolygon), fZSections(rhs.fZSections),
296 fTriangles(rhs.fTriangles), fIsConvex(rhs.fIsConvex),
297 fGeometryType(rhs.fGeometryType),
298 fSolidType(rhs.fSolidType), fPlanes(rhs.fPlanes),
299 fLines(rhs.fLines), fLengths(rhs.fLengths),
300 fKScales(rhs.fKScales), fScale0s(rhs.fScale0s),
301 fKOffsets(rhs.fKOffsets), fOffset0s(rhs.fOffset0s)
302{
303}
Member Function Documentation
◆ BoundingLimits()
|
virtual |
Reimplemented from G4VSolid.
Definition at line 1371 of file G4ExtrudedSolid.cc.
1373{
1374 G4double xmin0 = kInfinity, xmax0 = -kInfinity;
1375 G4double ymin0 = kInfinity, ymax0 = -kInfinity;
1376
1378 {
1379 G4double x = fPolygon[i].x();
1380 if (x < xmin0) xmin0 = x;
1381 if (x > xmax0) xmax0 = x;
1382 G4double y = fPolygon[i].y();
1383 if (y < ymin0) ymin0 = y;
1384 if (y > ymax0) ymax0 = y;
1385 }
1386
1387 G4double xmin = kInfinity, xmax = -kInfinity;
1388 G4double ymin = kInfinity, ymax = -kInfinity;
1389
1392 {
1393 ZSection zsect = GetZSection(i);
1394 G4double dx = zsect.fOffset.x();
1395 G4double dy = zsect.fOffset.y();
1396 G4double scale = zsect.fScale;
1397 xmin = std::min(xmin,xmin0*scale+dx);
1398 xmax = std::max(xmax,xmax0*scale+dx);
1399 ymin = std::min(ymin,ymin0*scale+dy);
1400 ymax = std::max(ymax,ymax0*scale+dy);
1401 }
1402
1405
1406 pMin.set(xmin,ymin,zmin);
1407 pMax.set(xmax,ymax,zmax);
1408
1409 // Check correctness of the bounding box
1410 //
1412 {
1413 std::ostringstream message;
1414 message << "Bad bounding box (min >= max) for solid: "
1416 << "\npMin = " << pMin
1417 << "\npMax = " << pMax;
1420 DumpInfo();
1421 }
1422}
double z() const
double x() const
double y() const
void set(double x, double y, double z)
ZSection GetZSection(G4int index) const
G4int GetNofZSections() const
G4int GetNofVertices() const
G4String GetName() const
void DumpInfo() const
Referenced by CalculateExtent().
◆ CalculateExtent()
|
virtual |
Reimplemented from G4TessellatedSolid.
Definition at line 1428 of file G4ExtrudedSolid.cc.
1432{
1433 G4ThreeVector bmin, bmax;
1434 G4bool exist;
1435
1436 // Check bounding box (bbox)
1437 //
1438 BoundingLimits(bmin,bmax);
1439 G4BoundingEnvelope bbox(bmin,bmax);
1440#ifdef G4BBOX_EXTENT
1441 return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
1442#endif
1443 if (bbox.BoundingBoxVsVoxelLimits(pAxis,pVoxelLimit,pTransform,pMin,pMax))
1444 {
1445 return exist = (pMin < pMax) ? true : false;
1446 }
1447
1448 // To find the extent, the base polygon is subdivided in triangles.
1449 // The extent is calculated as cumulative extent of the parts
1450 // formed by extrusion of the triangles
1451 //
1452 G4TwoVectorList triangles;
1455
1456 // triangulate the base polygon
1458 {
1459 std::ostringstream message;
1460 message << "Triangulation of the base polygon has failed for solid: "
1462 << "\nExtent has been calculated using boundary box";
1465 return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
1466 }
1467
1468 // allocate vector lists
1470 std::vector<const G4ThreeVectorList *> polygons;
1471 polygons.resize(nsect);
1473
1474 // main loop along triangles
1475 pMin = kInfinity;
1476 pMax = -kInfinity;
1477 G4int ntria = triangles.size()/3;
1479 {
1480 G4int i3 = i*3;
1482 {
1483 ZSection zsect = GetZSection(k);
1484 G4double z = zsect.fZ;
1485 G4double dx = zsect.fOffset.x();
1486 G4double dy = zsect.fOffset.y();
1487 G4double scale = zsect.fScale;
1488
1490 G4ThreeVectorList::iterator iter = ptr->begin();
1491 G4double x0 = triangles[i3+0].x()*scale+dx;
1492 G4double y0 = triangles[i3+0].y()*scale+dy;
1493 iter->set(x0,y0,z);
1494 iter++;
1495 G4double x1 = triangles[i3+1].x()*scale+dx;
1496 G4double y1 = triangles[i3+1].y()*scale+dy;
1497 iter->set(x1,y1,z);
1498 iter++;
1499 G4double x2 = triangles[i3+2].x()*scale+dx;
1500 G4double y2 = triangles[i3+2].y()*scale+dy;
1501 iter->set(x2,y2,z);
1502 }
1503
1504 // set sub-envelope and adjust extent
1505 G4double emin,emax;
1506 G4BoundingEnvelope benv(polygons);
1507 if (!benv.CalculateExtent(pAxis,pVoxelLimit,pTransform,emin,emax)) continue;
1508 if (emin < pMin) pMin = emin;
1509 if (emax > pMax) pMax = emax;
1510 if (eminlim > pMin && emaxlim < pMax) break; // max possible extent
1511 }
1512 // free memory
1514 return (pMin < pMax);
1515}
Definition: ThreeVector.h:36
Definition: G4BoundingEnvelope.hh:59
void BoundingLimits(G4ThreeVector &pMin, G4ThreeVector &pMax) const
Definition: G4ExtrudedSolid.cc:1371
static G4bool TriangulatePolygon(const G4TwoVectorList &polygon, G4TwoVectorList &result)
Definition: G4GeomTools.cc:193
G4double GetMinExtent(const EAxis pAxis) const
G4double GetMaxExtent(const EAxis pAxis) const
◆ Clone()
|
virtual |
Reimplemented from G4TessellatedSolid.
Definition at line 850 of file G4ExtrudedSolid.cc.
◆ DistanceToIn() [1/2]
|
virtual |
Reimplemented from G4TessellatedSolid.
Definition at line 1219 of file G4ExtrudedSolid.cc.
1220{
1221 switch (fSolidType)
1222 {
1223 case 1: // convex right prism
1224 {
1226 G4int np = fPlanes.size();
1228 {
1230 if (dd > dist) dist = dd;
1231 }
1232 return (dist > 0) ? dist : 0.;
1233 }
1234 case 2: // non-convex right prism
1235 {
1236 G4bool in = PointInPolygon(p);
1237 if (in)
1238 {
1240 return (distz > 0) ? distz : 0;
1241 }
1242 else
1243 {
1245 G4double dd = DistanceToPolygonSqr(p);
1246 if (distz > 0) dd += distz*distz;
1247 return std::sqrt(dd);
1248 }
1249 }
1250 }
1251
1252 // General case: use tessellated solid
1254}
virtual G4double DistanceToIn(const G4ThreeVector &p, const G4ThreeVector &v) const
Definition: G4TessellatedSolid.cc:1653
◆ DistanceToIn() [2/2]
|
virtual |
Reimplemented from G4TessellatedSolid.
Definition at line 1158 of file G4ExtrudedSolid.cc.
1160{
1162 G4double z1 = fZSections[fNz-1].fZ;
1165
1166 switch (fSolidType)
1167 {
1168 case 1: // convex right prism
1169 {
1170 // Intersection with Z planes
1171 //
1174
1176 G4double ddz = (invz < 0) ? dz : -dz;
1177 G4double tzmin = (pz + ddz)*invz;
1178 G4double tzmax = (pz - ddz)*invz;
1179
1180 // Intersection with lateral planes
1181 //
1182 G4int np = fPlanes.size();
1183 G4double txmin = tzmin, txmax = tzmax;
1185 {
1189 {
1190 if (cosa >= 0) { return kInfinity; }
1191 G4double tmp = -dist/cosa;
1192 if (txmin < tmp) { txmin = tmp; }
1193 }
1194 else if (cosa > 0)
1195 {
1196 G4double tmp = -dist/cosa;
1197 if (txmax > tmp) { txmax = tmp; }
1198 }
1199 }
1200
1201 // Find distance
1202 //
1203 G4double tmin = txmin, tmax = txmax;
1205 {
1206 return kInfinity;
1207 }
1209 }
1210 case 2: // non-convex right prism
1211 {
1212 }
1213 }
1215}
◆ DistanceToOut() [1/2]
|
virtual |
Reimplemented from G4TessellatedSolid.
Definition at line 1340 of file G4ExtrudedSolid.cc.
1341{
1342 switch (fSolidType)
1343 {
1344 case 1: // convex right prism
1345 {
1347 G4int np = fPlanes.size();
1349 {
1351 if (dd > dist) dist = dd;
1352 }
1353 return (dist < 0) ? -dist : 0.;
1354 }
1355 case 2: // non-convex right prism
1356 {
1358 G4bool in = PointInPolygon(p);
1359 if (distz >= 0 || (!in)) return 0; // point is outside
1360 return std::min(-distz,std::sqrt(DistanceToPolygonSqr(p)));
1361 }
1362 }
1363
1364 // General case: use tessellated solid
1366}
virtual G4double DistanceToOut(const G4ThreeVector &p) const
Definition: G4TessellatedSolid.cc:1681
◆ DistanceToOut() [2/2]
|
virtual |
Reimplemented from G4TessellatedSolid.
Definition at line 1258 of file G4ExtrudedSolid.cc.
1263{
1264 G4bool getnorm = calcNorm;
1265 if (getnorm) *validNorm = true;
1266
1268 G4double z1 = fZSections[fNz-1].fZ;
1270 {
1272 return 0;
1273 }
1275 {
1277 return 0;
1278 }
1279
1280 switch (fSolidType)
1281 {
1282 case 1: // convex right prism
1283 {
1284 // Intersection with Z planes
1285 //
1288
1292
1293 // Intersection with lateral planes
1294 //
1295 G4int np = fPlanes.size();
1297 {
1299 if (cosa > 0)
1300 {
1303 {
1305 return 0;
1306 }
1307 G4double tmp = -dist/cosa;
1308 if (tmax > tmp) { tmax = tmp; iside = i; }
1309 }
1310 }
1311
1312 // Set normal, if required, and return distance
1313 //
1314 if (getnorm)
1315 {
1316 if (iside < 0)
1318 else
1319 { n->set(fPlanes[iside].a, fPlanes[iside].b, fPlanes[iside].c); }
1320 }
1321 return tmax;
1322 }
1323 case 2: // non-convex right prism
1324 {
1325 }
1326 }
1327
1328 // Override the base class function to redefine validNorm
1329 // (the solid can be concave)
1330
1331 G4double distOut =
1332 G4TessellatedSolid::DistanceToOut(p, v, calcNorm, validNorm, n);
1333 if (validNorm) { *validNorm = fIsConvex; }
1334
1335 return distOut;
1336}
◆ GetEntityType()
|
virtual |
Reimplemented from G4TessellatedSolid.
Definition at line 841 of file G4ExtrudedSolid.cc.
842{
843 // Return entity type
844
845 return fGeometryType;
846}
◆ GetNofVertices()
|
inline |
Referenced by BoundingLimits(), and G4GDMLWriteSolids::XtruWrite().
◆ GetNofZSections()
|
inline |
Referenced by BoundingLimits(), CalculateExtent(), and G4GDMLWriteSolids::XtruWrite().
◆ GetPolygon()
|
inline |
◆ GetVertex()
|
inline |
Referenced by G4GDMLWriteSolids::XtruWrite().
◆ GetZSection()
Referenced by BoundingLimits(), CalculateExtent(), and G4GDMLWriteSolids::XtruWrite().
◆ GetZSections()
|
inline |
◆ Inside()
|
virtual |
Reimplemented from G4TessellatedSolid.
Definition at line 857 of file G4ExtrudedSolid.cc.
858{
859 switch (fSolidType)
860 {
861 case 1: // convex right prism
862 {
865
866 G4int np = fPlanes.size();
868 {
870 if (dd > dist) { dist = dd; }
871 }
874 }
875 case 2: // non-convex right prism
876 {
879
880 G4bool in = PointInPolygon(p);
882
884 if (in)
885 {
887 }
888 else
889 {
891 }
892 }
893 }
894
895 // Override the base class function as it fails in case of concave polygon.
896 // Project the point in the original polygon scale and check if it is inside
897 // for each triangle.
898
899 // Check first if outside extent
900 //
907 {
908 // G4cout << "G4ExtrudedSolid::Outside extent: " << p << G4endl;
910 }
911
912 // Project point p(z) to the polygon scale p0
913 //
914 G4TwoVector pscaled = ProjectPoint(p);
915
916 // Check if on surface of polygon
917 //
919 {
920 G4int j = (i+1) % fNv;
921 if ( IsSameLineSegment(pscaled, fPolygon[i], fPolygon[j]) )
922 {
923 // G4cout << "G4ExtrudedSolid::Inside return Surface (on polygon) "
924 // << G4endl;
925
927 }
928 }
929
930 // Now check if inside triangles
931 //
932 auto it = fTriangles.cbegin();
934 do // Loop checking, 13.08.2015, G.Cosmo
935 {
936 if ( IsPointInside(fPolygon[(*it)[0]], fPolygon[(*it)[1]],
937 fPolygon[(*it)[2]], pscaled) ) { inside = true; }
938 ++it;
939 } while ( (inside == false) && (it != fTriangles.cend()) );
940
941 if ( inside )
942 {
943 // Check if on surface of z sides
944 //
947 {
948 // G4cout << "G4ExtrudedSolid::Inside return Surface (on z side)"
949 // << G4endl;
950
952 }
953
954 // G4cout << "G4ExtrudedSolid::Inside return Inside" << G4endl;
955
957 }
958
959 // G4cout << "G4ExtrudedSolid::Inside return Outside " << G4endl;
960
962}
Definition: TwoVector.h:44
G4double GetMinYExtent() const
Definition: G4TessellatedSolid.cc:1902
G4double GetMinZExtent() const
Definition: G4TessellatedSolid.cc:1916
G4double GetMaxYExtent() const
Definition: G4TessellatedSolid.cc:1909
G4double GetMaxZExtent() const
Definition: G4TessellatedSolid.cc:1923
G4double GetMaxXExtent() const
Definition: G4TessellatedSolid.cc:1895
G4double GetMinXExtent() const
Definition: G4TessellatedSolid.cc:1888
◆ operator=()
| G4ExtrudedSolid & G4ExtrudedSolid::operator= | ( | const G4ExtrudedSolid & | rhs | ) |
Definition at line 307 of file G4ExtrudedSolid.cc.
308{
309 // Check assignment to self
310 //
311 if (this == &rhs) { return *this; }
312
313 // Copy base class data
314 //
315 G4TessellatedSolid::operator=(rhs);
316
317 // Copy data
318 //
319 fNv = rhs.fNv; fNz = rhs.fNz;
320 fPolygon = rhs.fPolygon; fZSections = rhs.fZSections;
321 fTriangles = rhs.fTriangles; fIsConvex = rhs.fIsConvex;
322 fGeometryType = rhs.fGeometryType;
323 fSolidType = rhs.fSolidType; fPlanes = rhs.fPlanes;
324 fLines = rhs.fLines; fLengths = rhs.fLengths;
325 fKScales = rhs.fKScales; fScale0s = rhs.fScale0s;
326 fKOffsets = rhs.fKOffsets; fOffset0s = rhs.fOffset0s;
327
328 return *this;
329}
G4TessellatedSolid & operator=(const G4TessellatedSolid &right)
Definition: G4TessellatedSolid.cc:138
◆ StreamInfo()
|
virtual |
Reimplemented from G4TessellatedSolid.
Definition at line 1519 of file G4ExtrudedSolid.cc.
1520{
1521 G4int oldprc = os.precision(16);
1522 os << "-----------------------------------------------------------\n"
1524 << " ===================================================\n"
1526
1527 if ( fIsConvex)
1529 else
1531
1533 {
1534 os << std::setw(5) << "#" << i
1535 << " vx = " << fPolygon[i].x()/mm << " mm"
1537 }
1538
1541 {
1542 os << " z = " << fZSections[iz].fZ/mm << " mm "
1543 << " x0= " << fZSections[iz].fOffset.x()/mm << " mm "
1544 << " y0= " << fZSections[iz].fOffset.y()/mm << " mm "
1546 }
1547
1548/*
1549 // Triangles (for debugging)
1550 os << G4endl;
1551 os << " Triangles:" << G4endl;
1552 os << " Triangle # vertex1 vertex2 vertex3" << G4endl;
1553
1554 G4int counter = 0;
1555 std::vector< std::vector<G4int> >::const_iterator it;
1556 for ( it = fTriangles.begin(); it != fTriangles.end(); it++ ) {
1557 std::vector<G4int> triangle = *it;
1558 os << std::setw(10) << counter++
1559 << std::setw(10) << triangle[0] << std::setw(10) << triangle[1]
1560 << std::setw(10) << triangle[2]
1561 << G4endl;
1562 }
1563*/
1564 os.precision(oldprc);
1565
1566 return os;
1567}
◆ SurfaceNormal()
|
virtual |
Reimplemented from G4TessellatedSolid.
Definition at line 966 of file G4ExtrudedSolid.cc.
967{
968 G4int nsurf = 0;
969 G4double nx = 0, ny = 0, nz = 0;
970 switch (fSolidType)
971 {
972 case 1: // convex right prism
973 {
975 {
976 nz = -1; ++nsurf;
977 }
979 {
980 nz = 1; ++nsurf;
981 }
983 {
986 nx += fPlanes[i].a;
987 ny += fPlanes[i].b;
988 ++nsurf;
989 }
990 break;
991 }
992 case 2: // non-convex right prism
993 {
995 {
996 nz = -1; ++nsurf;
997 }
999 {
1000 nz = 1; ++nsurf;
1001 }
1002
1005 {
1008 G4double u = fPlanes[i].a*iy - fPlanes[i].b*ix;
1009 if (u < 0)
1010 {
1011 if (ix*ix + iy*iy > sqrCarToleranceHalf) continue;
1012 }
1013 else if (u > fLengths[i])
1014 {
1017 if (kx*kx + ky*ky > sqrCarToleranceHalf) continue;
1018 }
1019 else
1020 {
1022 if (dd*dd > sqrCarToleranceHalf) continue;
1023 }
1024 nx += fPlanes[i].a;
1025 ny += fPlanes[i].b;
1026 ++nsurf;
1027 }
1028 break;
1029 }
1030 default:
1031 {
1033 }
1034 }
1035
1036 // Return normal (right prism)
1037 //
1038 if (nsurf == 1)
1039 {
1041 }
1042 else if (nsurf != 0) // edge or corner
1043 {
1045 }
1046 else
1047 {
1048 // Point is not on the surface, compute approximate normal
1049 //
1050#ifdef G4CSGDEBUG
1051 std::ostringstream message;
1052 G4int oldprc = message.precision(16);
1053 message << "Point p is not on surface (!?) of solid: "
1055 message << "Position:\n";
1059 G4cout.precision(oldprc) ;
1061 JustWarning, message );
1062 DumpInfo();
1063#endif
1064 return ApproxSurfaceNormal(p);
1065 }
1066}
G4GLOB_DLL std::ostream G4cout
Hep3Vector unit() const
virtual G4ThreeVector SurfaceNormal(const G4ThreeVector &p) const
Definition: G4TessellatedSolid.cc:1632
The documentation for this class was generated from the following files:
