46 #if !defined(G4GEOM_USE_UGENERICTRAP)
77 const std::vector<G4TwoVector>& vertices )
79 fRebuildPolyhedron(false),
96 G4String errorDescription =
"InvalidSetup in \" ";
97 errorDescription +=
name;
98 errorDescription +=
"\"";
106 G4Exception(
"G4GenericTrap::G4GenericTrap()",
"GeomSolids0002",
114 G4Exception(
"G4GenericTrap::G4GenericTrap()",
"GeomSolids0002",
132 for (
G4int j=0; j < 2; j++)
134 for (
G4int i=1; i<4; ++i)
140 std::ostringstream message;
141 message <<
"Length segment is too small." <<
G4endl
142 <<
"Distance between " <<
fVertices[k-1] <<
" and "
143 <<
fVertices[k] <<
" is only " << length <<
" mm !";
144 G4Exception(
"G4GenericTrap::G4GenericTrap()",
"GeomSolids1001",
145 JustWarning, message,
"Vertices will be collapsed.");
172 fRebuildPolyhedron(false),
174 halfCarTolerance(0.),
178 fTessellatedSolid(0),
201 fRebuildPolyhedron(false), fpPolyhedron(0),
202 halfCarTolerance(rhs.halfCarTolerance),
203 fDz(rhs.fDz), fVertices(rhs.fVertices),
204 fIsTwisted(rhs.fIsTwisted), fTessellatedSolid(0),
205 fMinBBoxVector(rhs.fMinBBoxVector), fMaxBBoxVector(rhs.fMaxBBoxVector),
206 fVisSubdivisions(rhs.fVisSubdivisions),
207 fSurfaceArea(rhs.fSurfaceArea), fCubicVolume(rhs.fCubicVolume)
209 for (
size_t i=0; i<4; ++i) {
fTwist[i] = rhs.
fTwist[i]; }
222 if (
this == &rhs) {
return *
this; }
237 for (
size_t i=0; i<4; ++i) {
fTwist[i] = rhs.
fTwist[i]; }
252 const std::vector<G4TwoVector>& poly)
const
258 for (
G4int i = 0; i < 4; i++)
262 cross = (p.x()-poly[i].x())*(poly[j].y()-poly[i].y())-
263 (p.y()-poly[i].y())*(poly[j].
x()-poly[i].x());
265 len2=(poly[i]-poly[j]).mag2();
277 if (poly[j].
x() > poly[i].x())
286 if ( p.x() > poly[iMax].x()+halfCarTolerance
292 if (poly[j].y() > poly[i].y())
302 if ( p.y() > poly[iMax].y()+halfCarTolerance
308 if ( poly[iMax].
x() != poly[iMin].x() )
310 test = (p.x()-poly[iMin].x())/(poly[iMax].
x()-poly[iMin].x())
311 * (poly[iMax].y()-poly[iMin].y())+poly[iMin].y();
320 if( (test>=(poly[iMin].y()-halfCarTolerance))
321 && (test<=(poly[iMax].y()+halfCarTolerance)) )
330 else if (cross<0.) {
return kOutside; }
342 if ( (std::fabs(p.x()-poly[0].x())+std::fabs(p.y()-poly[0].y())) >
halfCarTolerance )
364 std::vector<G4TwoVector> xy;
371 for (
G4int i=0; i<4; i++)
401 p0, p1, p2, r1, r2, r3, r4;
402 G4int noSurfaces = 0;
406 distz =
fDz-std::fabs(p.z());
423 std:: vector<G4TwoVector> vertices;
425 for (
G4int i=0; i<4; i++)
432 for (
G4int q=0; q<4; q++)
443 p2=
G4ThreeVector(vertices[(q+1)%4].
x(),vertices[(q+1)%4].y(),p.z());
458 lnorm = (p1-p0).cross(p2-p0);
459 lnorm = lnorm.unit();
460 if(zPlusSide) { lnorm=-lnorm; }
469 G4double proj=(p-p0).dot(p2-p0)/normP;
470 if(proj<0) { proj=0; }
471 if(proj>normP) { proj=normP; }
477 r1=r1+proj*(r2-r1)/normP;
478 r3=r3+proj*(r4-r3)/normP;
480 r4=r2.cross(p2-p0); r4=r4.unit();
485 distxy=std::fabs((p0-p).dot(lnorm));
492 sumnorm=sumnorm+lnorm;
506 if ( noSurfaces == 0 )
509 G4Exception(
"G4GenericTrap::SurfaceNormal(p)",
"GeomSolids1002",
515 else if ( noSurfaces == 1 ) { sumnorm = sumnorm; }
516 else { sumnorm = sumnorm.unit(); }
524 const G4int ipl )
const
576 lnorm=-(p1-p0).cross(p2-p0);
578 else { lnorm=lnorm.unit(); }
587 G4double proj=(p-p0).dot(p2-p0)/normP;
588 if (proj<0) { proj=0; }
589 if (proj>normP) { proj=normP; }
595 r1=r1+proj*(r2-r1)/normP;
596 r3=r3+proj*(r4-r3)/normP;
598 r4=r2.cross(p2-p0);r4=r4.unit();
610 const G4int ipl)
const
646 G4double a = (dtx*v.y()-dty*v.x()+(tx1*ty2-tx2*ty1)*v.z())*v.z();
647 G4double b = dxs*v.y()-dys*v.x()+(dtx*p.y()-dty*p.x()+ty2*xs1-ty1*xs2
648 + tx1*ys2-tx2*ys1)*v.z();
649 G4double c=dxs*p.y()-dys*p.x()+xs1*ys2-xs2*ys1;
673 if (std::fabs(zi)<
fDz)
681 zi = (xp-x1)*(xp-x2)+(yp-y1)*(yp-y2);
690 if (a>0) { q=0.5*(-b-std::sqrt(d))/a; }
691 else { q=0.5*(-b+std::sqrt(d))/a; }
705 if (a>0) { q=0.5*(-b+std::sqrt(d))/a; }
706 else { q=0.5*(-b-std::sqrt(d))/a; }
713 if (std::fabs(zi)<
fDz)
721 zi = (xp-x1)*(xp-x2)+(yp-y1)*(yp-y2);
725 if (a>0) { q=0.5*(-b+std::sqrt(d))/a; }
726 else { q=0.5*(-b-std::sqrt(d))/a; }
740 if (a>0) { q=0.5*(-b-std::sqrt(d))/a; }
741 else { q=0.5*(-b+std::sqrt(d))/a; }
748 if (std::fabs(zi)<
fDz)
756 zi = (xp-x1)*(xp-x2)+(yp-y1)*(yp-y2);
797 dist[4] = (
fDz-p.z())/v.z();
801 dist[4] = (-
fDz-p.z())/v.z();
813 if (n.dot(v)<0) { dist[4]=0.; }
824 if (dist[i] < distmin) { distmin = dist[i]; }
846 if(safz<0) { safz=0; }
852 for (iseg=0; iseg<4; iseg++)
855 if (safxy>safe) { safe=safxy; }
875 safe = (p-p1).dot(norm);
912 G4double c=(xb-xa)*(yc-ya)-(xc-xa)*(yb-ya);
918 t=-(a*p.x()+b*p.y()+c*p.z()+d)/t;
952 G4bool lateral_cross =
false;
955 if (calcNorm) { *validNorm=
true; }
959 distmin=(-
fDz-p.z())/v.z();
966 distmin = (
fDz-p.z())/v.z();
976 for (
G4int ipl=0; ipl<4; ipl++)
992 if ( (q>=0) && (q<distmin) )
1013 G4double a = (dtx*v.y()-dty*v.x()+(tx1*ty2-tx2*ty1)*v.z())*v.z();
1014 G4double b = dxs*v.y()-dys*v.x()+(dtx*p.y()-dty*p.x()+ty2*xs1-ty1*xs2
1015 + tx1*ys2-tx2*ys1)*v.z();
1016 G4double c=dxs*p.y()-dys*p.x()+xs1*ys2-xs2*ys1;
1041 if (a > 0) { q=0.5*(-b-std::sqrt(d))/a; }
1042 else { q=0.5*(-b+std::sqrt(d))/a; }
1054 if (a > 0) { q=0.5*(-b+std::sqrt(d))/a; }
1055 else { q=0.5*(-b-std::sqrt(d))/a; }
1059 lateral_cross =
true;
1066 lateral_cross =
true;
1072 if (a > 0) { q=0.5*(-b+std::sqrt(d))/a; }
1073 else { q=0.5*(-b-std::sqrt(d))/a; }
1083 if (a > 0) { q=0.5*(-b-std::sqrt(d))/a; }
1084 else { q=0.5*(-b+std::sqrt(d))/a; }
1088 lateral_cross =
true;
1095 lateral_cross =
true;
1109 if (v.z()>0.) { i=4; }
1110 std::vector<G4TwoVector> xy;
1126 if(v.z()>0) {side=
kPZ;}
1156 std::ostringstream message;
1157 G4int oldprc = message.precision(16);
1158 message <<
"Undefined side for valid surface normal to solid." <<
G4endl
1160 <<
" p.x() = " << p.x()/
mm <<
" mm" <<
G4endl
1161 <<
" p.y() = " << p.y()/
mm <<
" mm" <<
G4endl
1162 <<
" p.z() = " << p.z()/
mm <<
" mm" <<
G4endl
1163 <<
"Direction:" <<
G4endl
1164 <<
" v.x() = " << v.x() <<
G4endl
1165 <<
" v.y() = " << v.y() <<
G4endl
1166 <<
" v.z() = " << v.z() <<
G4endl
1167 <<
"Proposed distance :" <<
G4endl
1168 <<
" distmin = " << distmin/
mm <<
" mm";
1169 message.precision(oldprc);
1170 G4Exception(
"G4GenericTrap::DistanceToOut(p,v,..)",
1194 if (safz<0) { safz = 0; }
1199 for (
G4int iseg=0; iseg<4; iseg++)
1202 if (safxy < safe) { safe = safxy; }
1219 pTransform, pMin, pMax);
1239 xMin=xoffset+minVec.x();
1240 xMax=xoffset+maxVec.x();
1262 yMin=yoffset+minVec.y();
1263 yMax=yoffset+maxVec.y();
1285 zMin=zoffset+minVec.z();
1286 zMax=zoffset+maxVec.z();
1333 G4bool existsAfterClip=
false;
1348 existsAfterClip=
true;
1369 existsAfterClip=
true;
1375 return existsAfterClip;
1398 vertices->reserve(8);
1419 G4Exception(
"G4GenericTrap::CreateRotatedVertices()",
"FatalError",
1443 G4int oldprc = os.precision(16);
1444 os <<
"-----------------------------------------------------------\n"
1445 <<
" *** Dump for solid - " <<
GetName() <<
" *** \n"
1446 <<
" =================================================== \n"
1448 <<
" half length Z: " <<
fDz/
mm <<
" mm \n"
1449 <<
" list of vertices:\n";
1453 os << std::setw(5) <<
"#" << i
1457 os.precision(oldprc);
1476 G4double rand,area,chose,cf,lambda0,lambda1,alfa,beta,zp;
1479 std::vector<G4ThreeVector> vertices;
1480 for (
G4int i=0; i<4;i++)
1484 for (
G4int i=4; i<8;i++)
1492 vertices[2],vertices[3]);
1494 vertices[5],vertices[4]);
1496 vertices[4],vertices[7]);
1498 vertices[7],vertices[6]);
1500 vertices[5],vertices[6]);
1502 vertices[6],vertices[7]);
1504 area = Surface0+Surface1+Surface2+Surface3+Surface4+Surface5;
1507 if ( ( chose < Surface0)
1508 || ( chose > (Surface0+Surface1+Surface2+Surface3+Surface4)) )
1512 if(chose < Surface0)
1527 lambda0=alfa-lambda1;
1530 v = u+lambda0*v+lambda1*
w;
1534 if (chose < Surface0+Surface1) { ipl=0; }
1535 else if (chose < Surface0+Surface1+Surface2) { ipl=1; }
1536 else if (chose < Surface0+Surface1+Surface2+Surface3) { ipl=2; }
1540 cf = 0.5*(fDz-zp)/fDz;
1566 std::vector<G4ThreeVector> vertices;
1567 for (
G4int i=0; i<4;i++)
1571 for (
G4int i=4; i<8;i++)
1579 vertices[2],vertices[3]);
1581 vertices[5],vertices[4]);
1583 vertices[4],vertices[7]);
1585 vertices[7],vertices[6]);
1587 vertices[5],vertices[6]);
1589 vertices[6],vertices[7]);
1596 + fSurface3+fSurface4+fSurface5;
1624 aOne = 0.5*Area.mag();
1627 aTwo = 0.5*Area.mag();
1643 for (
G4int i=0; i<4; i++ )
1647 if ( (dx1 == 0) && (dy1 == 0) ) {
continue; }
1652 if ( dx2 == 0 && dy2 == 0 ) {
continue; }
1653 G4double twist_angle = std::fabs(dy1*dx2 - dx1*dy2);
1660 twist_angle = std::acos( (dx1*dx2 + dy1*dy2)
1661 / (std::sqrt(dx1*dx1+dy1*dy1)
1662 * std::sqrt(dx2*dx2+dy2*dy2)) );
1666 std::ostringstream message;
1667 message <<
"Twisted Angle is bigger than 90 degrees - " <<
GetName()
1669 <<
" Potential problem of malformed Solid !" <<
G4endl
1670 <<
" TwistANGLE = " << twist_angle
1671 <<
"*rad for lateral plane N= " << i;
1672 G4Exception(
"G4GenericTrap::ComputeIsTwisted()",
"GeomSolids1002",
1687 G4bool clockwise_order=
true;
1692 for (
G4int i=0; i<4; i++)
1695 sum1 += vertices[i].x()*vertices[j].y() - vertices[j].x()*vertices[i].y();
1696 sum2 += vertices[i+4].x()*vertices[j+4].y()
1697 - vertices[j+4].x()*vertices[i+4].y();
1701 std::ostringstream message;
1702 message <<
"Lower/upper faces defined with opposite clockwise - "
1704 G4Exception(
"G4GenericTrap::CheckOrder()",
"GeomSolids0002",
1708 if ((sum1 > 0.)||(sum2 > 0.))
1710 std::ostringstream message;
1711 message <<
"Vertices must be defined in clockwise XY planes - "
1713 G4Exception(
"G4GenericTrap::CheckOrder()",
"GeomSolids1001",
1715 clockwise_order =
false;
1720 G4bool illegal_cross =
false;
1722 vertices[1],vertices[5]);
1727 vertices[3],vertices[7]);
1733 vertices[2],vertices[3]);
1738 vertices[1],vertices[2]);
1743 vertices[6],vertices[7]);
1748 vertices[5],vertices[6]);
1753 std::ostringstream message;
1754 message <<
"Malformed polygone with opposite sides - " <<
GetName();
1755 G4Exception(
"G4GenericTrap::CheckOrderAndSetup()",
1758 return clockwise_order;
1767 std::vector<G4ThreeVector> oldVertices(vertices);
1769 for (
G4int i=0; i <
G4int(oldVertices.size()); ++i )
1771 vertices[i] = oldVertices[oldVertices.size()-1-i];
1793 a1 = (b.x()*a.y()-a.x()*b.y())/dx1;
1798 a2 = (d.x()*c.y()-c.x()*d.y())/dx2;
1801 if (stand1 && stand2)
1812 || ((b.y()-c.y())*(b.y()-d.y())<-
fgkTolerance) ) {
return true; }
1846 || ((b.x()-c.x())*(b.x()-d.x())<-
fgkTolerance) ) {
return true; }
1857 G4double check = (xm-a.x())*(xm-b.x())+(ym-a.y())*(ym-b.y());
1859 check = (xm-c.x())*(xm-d.x())+(ym-c.y())*(ym-d.y());
1893 (std::fabs((p4-p3).y()) <
kCarTolerance ) ) {
return false; }
1897 det = dv.x()*v1.y()*v2.z()+dv.y()*v1.z()*v2.x()
1898 - dv.x()*v1.z()*v2.y()-dv.y()*v1.x()*v2.z();
1902 temp1 = v1.cross(v2);
1903 temp2 = (p2-p1).cross(v2);
1904 if (temp1.dot(temp2) < 0) {
return false; }
1908 q = ((dv).cross(v2)).mag()/q;
1925 if ( (fromVertices[ind1] == fromVertices[ind2]) ||
1926 (fromVertices[ind2] == fromVertices[ind3]) ||
1927 (fromVertices[ind1] == fromVertices[ind3]) ) {
return 0; }
1929 std::vector<G4ThreeVector> vertices;
1930 vertices.push_back(fromVertices[ind1]);
1931 vertices.push_back(fromVertices[ind2]);
1932 vertices.push_back(fromVertices[ind3]);
1936 G4ThreeVector cross=(vertices[1]-vertices[0]).cross(vertices[2]-vertices[1]);
1938 if ( cross.z() > 0.0 )
1942 std::ostringstream message;
1943 message <<
"Vertices in wrong order - " <<
GetName();
1944 G4Exception(
"G4GenericTrap::MakeDownFacet",
"GeomSolids0002",
1962 if ( (fromVertices[ind1] == fromVertices[ind2]) ||
1963 (fromVertices[ind2] == fromVertices[ind3]) ||
1964 (fromVertices[ind1] == fromVertices[ind3]) ) {
return 0; }
1966 std::vector<G4ThreeVector> vertices;
1967 vertices.push_back(fromVertices[ind1]);
1968 vertices.push_back(fromVertices[ind2]);
1969 vertices.push_back(fromVertices[ind3]);
1973 G4ThreeVector cross=(vertices[1]-vertices[0]).cross(vertices[2]-vertices[1]);
1975 if ( cross.z() < 0.0 )
1979 std::ostringstream message;
1980 message <<
"Vertices in wrong order - " <<
GetName();
1981 G4Exception(
"G4GenericTrap::MakeUpFacet",
"GeomSolids0002",
1999 if ( (downVertex0 == downVertex1) && (upVertex0 == upVertex1) )
2004 if ( downVertex0 == downVertex1 )
2009 if ( upVertex0 == upVertex1 )
2025 std::vector<G4ThreeVector> downVertices;
2026 for (
G4int i=0; i<nv; i++ )
2032 std::vector<G4ThreeVector> upVertices;
2033 for (
G4int i=nv; i<2*nv; i++ )
2042 = (downVertices[1]-downVertices[0]).cross(downVertices[2]-downVertices[1]);
2044 = (upVertices[1]-upVertices[0]).cross(upVertices[2]-upVertices[1]);
2045 if ( (cross.z() > 0.0) || (cross1.z() > 0.0) )
2055 if (facet) { tessellatedSolid->
AddFacet( facet ); }
2057 if (facet) { tessellatedSolid->
AddFacet( facet ); }
2059 if (facet) { tessellatedSolid->
AddFacet( facet ); }
2061 if (facet) { tessellatedSolid->
AddFacet( facet ); }
2065 for (
G4int i = 0; i < nv; ++i )
2067 G4int j = (i+1) % nv;
2069 upVertices[i], upVertices[j]);
2071 if ( facet ) { tessellatedSolid->
AddFacet( facet ); }
2076 return tessellatedSolid;
2157 minVec.y(), maxVec.y(),
2158 minVec.z(), maxVec.z());
2177 size_t nVertices, nFacets;
2179 G4int subdivisions=0;
2202 Dx = 0.5*(maxVec.x()- minVec.y());
2203 Dy = 0.5*(maxVec.y()- minVec.y());
2204 if (Dy > Dx) { Dx=Dy; }
2206 subdivisions=8*
G4int(maxTwist/(Dx*Dx*Dx)*
fDz);
2207 if (subdivisions<4) { subdivisions=4; }
2208 if (subdivisions>30) { subdivisions=30; }
2211 G4int sub4=4*subdivisions;
2212 nVertices = 8+subdivisions*4;
2213 nFacets = 6+subdivisions*4;
2224 for( i=0;i<subdivisions;i++)
2226 for(
G4int j=0;j<4;j++)
2241 for (i=0;i<subdivisions+1;i++)
2244 polyhedron->
AddFacet(5+is,8+is,4+is,1+is);
2245 polyhedron->
AddFacet(8+is,7+is,3+is,4+is);
2246 polyhedron->
AddFacet(7+is,6+is,2+is,3+is);
2247 polyhedron->
AddFacet(6+is,5+is,1+is,2+is);
2249 polyhedron->
AddFacet(5+sub4,6+sub4,7+sub4,8+sub4);
static const G4int fgkNofVertices
void ClipCrossSection(G4ThreeVectorList *pVertices, const G4int pSectionIndex, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const
G4Polyhedron * GetPolyhedron() const
G4int GetVisSubdivisions() const
void SetTwistAngle(G4int index, G4double twist)
void SetSolidClosed(const G4bool t)
G4bool IsSegCrossingZ(const G4TwoVector &a, const G4TwoVector &b, const G4TwoVector &c, const G4TwoVector &d) const
G4GenericTrap(const G4String &name, G4double halfZ, const std::vector< G4TwoVector > &vertices)
static const G4double kInfinity
G4double GetMinYExtent() const
CLHEP::Hep3Vector G4ThreeVector
G4VisExtent GetExtent() const
G4TessellatedSolid * CreateTessellatedSolid() const
virtual void DescribeYourselfTo(G4VGraphicsScene &scene) const
G4Polyhedron * fpPolyhedron
G4double DistToPlane(const G4ThreeVector &p, const G4ThreeVector &v, const G4int ipl) const
G4bool IsYLimited() const
G4VFacet * MakeSideFacet(const G4ThreeVector &downVertex0, const G4ThreeVector &downVertex1, const G4ThreeVector &upVertex1, const G4ThreeVector &upVertex0) const
virtual G4VisExtent GetExtent() const
virtual G4double GetCubicVolume()
G4double GetFaceSurfaceArea(const G4ThreeVector &p0, const G4ThreeVector &p1, const G4ThreeVector &p2, const G4ThreeVector &p3) const
G4ThreeVector NormalToPlane(const G4ThreeVector &p, const G4int ipl) const
const G4double w[NPOINTSGL]
G4bool CalculateExtent(const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pmin, G4double &pmax) const
G4GeometryType GetEntityType() const
G4bool IsXLimited() const
G4VFacet * MakeUpFacet(const std::vector< G4ThreeVector > &fromVertices, G4int ind1, G4int ind2, G4int ind3) const
virtual void AddSolid(const G4Box &)=0
G4bool ComputeIsTwisted()
G4double SafetyToFace(const G4ThreeVector &p, const G4int iseg) const
#define G4MUTEX_INITIALIZER
G4ThreeVector SurfaceNormal(const G4ThreeVector &p) const
G4double GetSurfaceArea()
G4ThreeVector GetMaximumBBox() const
static double normal(HepRandomEngine *eptr)
G4double GetMaxXExtent() const
G4double GetMinZExtent() const
G4TessellatedSolid * fTessellatedSolid
G4ThreeVector GetPointOnSurface() const
G4VFacet * MakeDownFacet(const std::vector< G4ThreeVector > &fromVertices, G4int ind1, G4int ind2, G4int ind3) const
virtual G4double DistanceToOut(const G4ThreeVector &p) const
G4GenericTrap & operator=(const G4GenericTrap &rhs)
virtual G4Polyhedron * CreatePolyhedron() const
virtual EInside Inside(const G4ThreeVector &p) const
std::ostream & StreamInfo(std::ostream &os) const
G4bool AddFacet(G4VFacet *aFacet)
G4double GetTwistAngle(G4int index) const
G4double DistToTriangle(const G4ThreeVector &p, const G4ThreeVector &v, const G4int ipl) const
std::vector< G4ThreeVector > G4ThreeVectorList
G4double DistanceToOut(const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool *validNorm=0, G4ThreeVector *n=0) const
G4double GetCubicVolume()
virtual G4double DistanceToIn(const G4ThreeVector &p, const G4ThreeVector &v) const
std::vector< G4TwoVector > fVertices
void AddVertex(const G4ThreeVector &v)
EInside Inside(const G4ThreeVector &p) const
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
G4ThreeVectorList * CreateRotatedVertices(const G4AffineTransform &pTransform) const
virtual G4Polyhedron * GetPolyhedron() const
G4ThreeVector GetMinimumBBox() const
G4double GetMinXExtent() const
G4Polyhedron * CreatePolyhedron() const
G4double GetMaxZExtent() const
void ReorderVertices(std::vector< G4ThreeVector > &vertices) const
EInside InsidePolygone(const G4ThreeVector &p, const std::vector< G4TwoVector > &poly) const
const G4double x[NPOINTSGL]
void AddFacet(const G4int iv1, const G4int iv2, const G4int iv3, const G4int iv4=0)
CLHEP::Hep2Vector G4TwoVector
G4double GetMaxYExtent() const
G4VSolid & operator=(const G4VSolid &rhs)
G4int GetNumberOfRotationStepsAtTimeOfCreation() const
G4double halfCarTolerance
G4bool IsSegCrossing(const G4TwoVector &a, const G4TwoVector &b, const G4TwoVector &c, const G4TwoVector &d) const
G4double DistanceToIn(const G4ThreeVector &p, const G4ThreeVector &v) const
G4bool CheckOrder(const std::vector< G4TwoVector > &vertices) const
G4double GetMaxExtent(const EAxis pAxis) const
virtual G4bool CalculateExtent(const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pMin, G4double &pMax) const
G4bool IsZLimited() const
virtual G4double GetSurfaceArea()
virtual G4ThreeVector GetPointOnSurface() const
G4bool fRebuildPolyhedron
G4ThreeVector fMinBBoxVector
virtual G4ThreeVector SurfaceNormal(const G4ThreeVector &p) const
static const G4double fgkTolerance
void ClipBetweenSections(G4ThreeVectorList *pVertices, const G4int pSectionIndex, const G4VoxelLimits &pVoxelLimit, const EAxis pAxis, G4double &pMin, G4double &pMax) const
G4double GetMinExtent(const EAxis pAxis) const
G4ThreeVector fMaxBBoxVector
void DescribeYourselfTo(G4VGraphicsScene &scene) const