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; }
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 )
508 G4Exception(
"G4GenericTrap::SurfaceNormal(p)",
"GeomSolids1002",
513 else if ( noSurfaces == 1 ) { sumnorm = sumnorm; }
514 else { sumnorm = sumnorm.unit(); }
522 const G4int ipl )
const
572 lnorm=-(p1-
p0).cross(p2-p0);
574 else { lnorm=lnorm.unit(); }
584 if (proj<0) { proj=0; }
585 if (proj>normP) { proj=normP; }
591 r1=r1+proj*(r2-r1)/normP;
592 r3=r3+proj*(r4-r3)/normP;
594 r4=r2.cross(p2-p0);r4=r4.unit();
606 const G4int ipl)
const
642 G4double a = (dtx*v.y()-dty*v.x()+(tx1*ty2-tx2*ty1)*v.z())*v.z();
643 G4double b = dxs*v.y()-dys*v.x()+(dtx*p.y()-dty*p.x()+ty2*xs1-ty1*xs2
644 + tx1*ys2-tx2*ys1)*v.z();
645 G4double c=dxs*p.y()-dys*p.x()+xs1*ys2-xs2*ys1;
669 if (std::fabs(zi)<
fDz)
677 zi = (xp-x1)*(xp-x2)+(yp-y1)*(yp-y2);
686 if (a>0) { q=0.5*(-b-std::sqrt(d))/a; }
687 else { q=0.5*(-b+std::sqrt(d))/a; }
701 if (a>0) { q=0.5*(-b+std::sqrt(d))/a; }
702 else { q=0.5*(-b-std::sqrt(d))/a; }
709 if (std::fabs(zi)<
fDz)
717 zi = (xp-x1)*(xp-x2)+(yp-y1)*(yp-y2);
721 if (a>0) { q=0.5*(-b+std::sqrt(d))/a; }
722 else { q=0.5*(-b-std::sqrt(d))/a; }
736 if (a>0) { q=0.5*(-b-std::sqrt(d))/a; }
737 else { q=0.5*(-b+std::sqrt(d))/a; }
744 if (std::fabs(zi)<
fDz)
752 zi = (xp-x1)*(xp-x2)+(yp-y1)*(yp-y2);
793 dist[4] = (
fDz-p.z())/v.z();
797 dist[4] = (-
fDz-p.z())/v.z();
809 if (n.dot(v)<0) { dist[4]=0.; }
820 if (dist[i] < distmin) { distmin = dist[i]; }
842 if(safz<0) { safz=0; }
848 for (iseg=0; iseg<4; iseg++)
851 if (safxy>safe) { safe=safxy; }
871 safe = (p-
p1).dot(norm);
908 G4double c=(xb-xa)*(yc-ya)-(xc-xa)*(yb-ya);
914 t=-(a*p.x()+b*p.y()+c*p.z()+d)/t;
948 G4bool lateral_cross =
false;
951 if (calcNorm) { *validNorm=
true; }
955 distmin=(-
fDz-p.z())/v.z();
962 distmin = (
fDz-p.z())/v.z();
972 for (
G4int ipl=0; ipl<4; ipl++)
988 if ( (q>=0) && (q<distmin) )
1009 G4double a = (dtx*v.y()-dty*v.x()+(tx1*ty2-tx2*ty1)*v.z())*v.z();
1010 G4double b = dxs*v.y()-dys*v.x()+(dtx*p.y()-dty*p.x()+ty2*xs1-ty1*xs2
1011 + tx1*ys2-tx2*ys1)*v.z();
1012 G4double c=dxs*p.y()-dys*p.x()+xs1*ys2-xs2*ys1;
1037 if (a > 0) { q=0.5*(-b-std::sqrt(d))/a; }
1038 else { q=0.5*(-b+std::sqrt(d))/a; }
1050 if (a > 0) { q=0.5*(-b+std::sqrt(d))/a; }
1051 else { q=0.5*(-b-std::sqrt(d))/a; }
1055 lateral_cross =
true;
1062 lateral_cross =
true;
1068 if (a > 0) { q=0.5*(-b+std::sqrt(d))/a; }
1069 else { q=0.5*(-b-std::sqrt(d))/a; }
1079 if (a > 0) { q=0.5*(-b-std::sqrt(d))/a; }
1080 else { q=0.5*(-b+std::sqrt(d))/a; }
1084 lateral_cross =
true;
1091 lateral_cross =
true;
1105 if (v.z()>0.) { i=4; }
1106 std::vector<G4TwoVector> xy;
1122 if(v.z()>0) {side=
kPZ;}
1152 std::ostringstream message;
1153 G4int oldprc = message.precision(16);
1154 message <<
"Undefined side for valid surface normal to solid." <<
G4endl
1156 <<
" p.x() = " << p.x()/
mm <<
" mm" <<
G4endl
1157 <<
" p.y() = " << p.y()/
mm <<
" mm" <<
G4endl
1158 <<
" p.z() = " << p.z()/
mm <<
" mm" <<
G4endl
1159 <<
"Direction:" <<
G4endl
1160 <<
" v.x() = " << v.x() <<
G4endl
1161 <<
" v.y() = " << v.y() <<
G4endl
1162 <<
" v.z() = " << v.z() <<
G4endl
1163 <<
"Proposed distance :" <<
G4endl
1164 <<
" distmin = " << distmin/
mm <<
" mm";
1165 message.precision(oldprc);
1166 G4Exception(
"G4GenericTrap::DistanceToOut(p,v,..)",
1190 if (safz<0) { safz = 0; }
1195 for (
G4int iseg=0; iseg<4; iseg++)
1198 if (safxy < safe) { safe = safxy; }
1215 pTransform, pMin, pMax);
1224 Dx = 0.5*(maxVec.x()- minVec.x());
1225 Dy = 0.5*(maxVec.y()- minVec.y());
1332 G4bool existsAfterClip=
false;
1347 existsAfterClip=
true;
1368 existsAfterClip=
true;
1374 return existsAfterClip;
1397 vertices->reserve(8);
1418 G4Exception(
"G4GenericTrap::CreateRotatedVertices()",
"FatalError",
1442 G4int oldprc = os.precision(16);
1443 os <<
"-----------------------------------------------------------\n"
1444 <<
" *** Dump for solid - " <<
GetName() <<
" *** \n"
1445 <<
" =================================================== \n"
1447 <<
" half length Z: " <<
fDz/
mm <<
" mm \n"
1448 <<
" list of vertices:\n";
1452 os << std::setw(5) <<
"#" << i
1456 os.precision(oldprc);
1475 G4double rand,area,chose,cf,lambda0,lambda1,alfa,beta,zp;
1478 std::vector<G4ThreeVector> vertices;
1479 for (
G4int i=0; i<4;i++)
1483 for (
G4int i=4; i<8;i++)
1491 vertices[2],vertices[3]);
1493 vertices[5],vertices[4]);
1495 vertices[4],vertices[7]);
1497 vertices[7],vertices[6]);
1499 vertices[5],vertices[6]);
1501 vertices[6],vertices[7]);
1503 area = Surface0+Surface1+Surface2+Surface3+Surface4+Surface5;
1506 if ( ( chose < Surface0)
1507 || ( chose > (Surface0+Surface1+Surface2+Surface3+Surface4)) )
1511 if(chose < Surface0)
1526 lambda0=alfa-lambda1;
1529 v = u+lambda0*v+lambda1*w;
1533 if (chose < Surface0+Surface1) { ipl=0; }
1534 else if (chose < Surface0+Surface1+Surface2) { ipl=1; }
1535 else if (chose < Surface0+Surface1+Surface2+Surface3) { ipl=2; }
1539 cf = 0.5*(fDz-zp)/fDz;
1565 std::vector<G4ThreeVector> vertices;
1566 for (
G4int i=0; i<4;i++)
1570 for (
G4int i=4; i<8;i++)
1578 vertices[2],vertices[3]);
1580 vertices[5],vertices[4]);
1582 vertices[4],vertices[7]);
1584 vertices[7],vertices[6]);
1586 vertices[5],vertices[6]);
1588 vertices[6],vertices[7]);
1595 + fSurface3+fSurface4+fSurface5;
1623 aOne = 0.5*Area.mag();
1626 aTwo = 0.5*Area.mag();
1642 for (
G4int i=0; i<4; i++ )
1646 if ( (dx1 == 0) && (dy1 == 0) ) {
continue; }
1651 if ( dx2 == 0 && dy2 == 0 ) {
continue; }
1652 G4double twist_angle = std::fabs(dy1*dx2 - dx1*dy2);
1659 twist_angle = std::acos( (dx1*dx2 + dy1*dy2)
1660 / (std::sqrt(dx1*dx1+dy1*dy1)
1661 * std::sqrt(dx2*dx2+dy2*dy2)) );
1665 std::ostringstream message;
1666 message <<
"Twisted Angle is bigger than 90 degrees - " <<
GetName()
1668 <<
" Potential problem of malformed Solid !" <<
G4endl
1669 <<
" TwistANGLE = " << twist_angle
1670 <<
"*rad for lateral plane N= " << i;
1671 G4Exception(
"G4GenericTrap::ComputeIsTwisted()",
"GeomSolids1002",
1686 G4bool clockwise_order=
true;
1691 for (
G4int i=0; i<4; i++)
1694 sum1 += vertices[i].x()*vertices[j].y() - vertices[j].x()*vertices[i].y();
1695 sum2 += vertices[i+4].x()*vertices[j+4].y()
1696 - vertices[j+4].x()*vertices[i+4].y();
1700 std::ostringstream message;
1701 message <<
"Lower/upper faces defined with opposite clockwise - "
1703 G4Exception(
"G4GenericTrap::CheckOrder()",
"GeomSolids0002",
1707 if ((sum1 > 0.)||(sum2 > 0.))
1709 std::ostringstream message;
1710 message <<
"Vertices must be defined in clockwise XY planes - "
1712 G4Exception(
"G4GenericTrap::CheckOrder()",
"GeomSolids1001",
1714 clockwise_order =
false;
1719 G4bool illegal_cross =
false;
1721 vertices[1],vertices[5]);
1726 vertices[3],vertices[7]);
1732 vertices[2],vertices[3]);
1737 vertices[1],vertices[2]);
1742 vertices[6],vertices[7]);
1747 vertices[5],vertices[6]);
1752 std::ostringstream message;
1753 message <<
"Malformed polygone with opposite sides - " <<
GetName();
1754 G4Exception(
"G4GenericTrap::CheckOrderAndSetup()",
1757 return clockwise_order;
1766 std::vector<G4ThreeVector> oldVertices(vertices);
1768 for (
G4int i=0; i <
G4int(oldVertices.size()); ++i )
1770 vertices[i] = oldVertices[oldVertices.size()-1-i];
1792 a1 = (b.x()*a.y()-a.x()*b.y())/dx1;
1797 a2 = (d.x()*c.y()-c.x()*d.y())/dx2;
1800 if (stand1 && stand2)
1811 || ((b.y()-c.y())*(b.y()-d.y())<-
fgkTolerance) ) {
return true; }
1845 || ((b.x()-c.x())*(b.x()-d.x())<-
fgkTolerance) ) {
return true; }
1856 G4double check = (xm-a.x())*(xm-b.x())+(ym-a.y())*(ym-b.y());
1858 check = (xm-c.x())*(xm-d.x())+(ym-c.y())*(ym-d.y());
1892 (std::fabs((p4-p3).y()) <
kCarTolerance ) ) {
return false; }
1896 det = dv.x()*v1.y()*v2.z()+dv.y()*v1.z()*v2.x()
1897 - dv.x()*v1.z()*v2.y()-dv.y()*v1.x()*v2.z();
1901 temp1 = v1.cross(v2);
1902 temp2 = (p2-
p1).cross(v2);
1903 if (temp1.dot(temp2) < 0) {
return false; }
1907 q = ((dv).cross(v2)).mag()/q;
1924 if ( (fromVertices[ind1] == fromVertices[ind2]) ||
1925 (fromVertices[ind2] == fromVertices[ind3]) ||
1926 (fromVertices[ind1] == fromVertices[ind3]) ) {
return 0; }
1928 std::vector<G4ThreeVector> vertices;
1929 vertices.push_back(fromVertices[ind1]);
1930 vertices.push_back(fromVertices[ind2]);
1931 vertices.push_back(fromVertices[ind3]);
1935 G4ThreeVector cross=(vertices[1]-vertices[0]).cross(vertices[2]-vertices[1]);
1937 if ( cross.z() > 0.0 )
1941 std::ostringstream message;
1942 message <<
"Vertices in wrong order - " <<
GetName();
1943 G4Exception(
"G4GenericTrap::MakeDownFacet",
"GeomSolids0002",
1961 if ( (fromVertices[ind1] == fromVertices[ind2]) ||
1962 (fromVertices[ind2] == fromVertices[ind3]) ||
1963 (fromVertices[ind1] == fromVertices[ind3]) ) {
return 0; }
1965 std::vector<G4ThreeVector> vertices;
1966 vertices.push_back(fromVertices[ind1]);
1967 vertices.push_back(fromVertices[ind2]);
1968 vertices.push_back(fromVertices[ind3]);
1972 G4ThreeVector cross=(vertices[1]-vertices[0]).cross(vertices[2]-vertices[1]);
1974 if ( cross.z() < 0.0 )
1978 std::ostringstream message;
1979 message <<
"Vertices in wrong order - " <<
GetName();
1980 G4Exception(
"G4GenericTrap::MakeUpFacet",
"GeomSolids0002",
1998 if ( (downVertex0 == downVertex1) && (upVertex0 == upVertex1) )
2003 if ( downVertex0 == downVertex1 )
2008 if ( upVertex0 == upVertex1 )
2024 std::vector<G4ThreeVector> downVertices;
2025 for (
G4int i=0; i<nv; i++ )
2031 std::vector<G4ThreeVector> upVertices;
2032 for (
G4int i=nv; i<2*nv; i++ )
2041 = (downVertices[1]-downVertices[0]).cross(downVertices[2]-downVertices[1]);
2043 = (upVertices[1]-upVertices[0]).cross(upVertices[2]-upVertices[1]);
2044 if ( (cross.z() > 0.0) || (cross1.z() > 0.0) )
2054 if (facet) { tessellatedSolid->
AddFacet( facet ); }
2056 if (facet) { tessellatedSolid->
AddFacet( facet ); }
2058 if (facet) { tessellatedSolid->
AddFacet( facet ); }
2060 if (facet) { tessellatedSolid->
AddFacet( facet ); }
2064 for (
G4int i = 0; i < nv; ++i )
2066 G4int j = (i+1) % nv;
2068 upVertices[i], upVertices[j]);
2070 if ( facet ) { tessellatedSolid->
AddFacet( facet ); }
2075 return tessellatedSolid;
2156 Dx = 0.5*(maxVec.x()- minVec.x());
2157 Dy = 0.5*(maxVec.y()- minVec.y());
2178 size_t nVertices, nFacets;
2180 G4int subdivisions=0;
2203 Dx = 0.5*(maxVec.x()- minVec.y());
2204 Dy = 0.5*(maxVec.y()- minVec.y());
2205 if (Dy > Dx) { Dx=Dy; }
2207 subdivisions=8*
G4int(maxTwist/(Dx*Dx*Dx)*
fDz);
2208 if (subdivisions<4) { subdivisions=4; }
2209 if (subdivisions>30) { subdivisions=30; }
2212 G4int sub4=4*subdivisions;
2213 nVertices = 8+subdivisions*4;
2214 nFacets = 6+subdivisions*4;
2225 for( i=0;i<subdivisions;i++)
2227 for(
G4int j=0;j<4;j++)
2242 for (i=0;i<subdivisions+1;i++)
2245 polyhedron->
AddFacet(5+is,8+is,4+is,1+is);
2246 polyhedron->
AddFacet(8+is,7+is,3+is,4+is);
2247 polyhedron->
AddFacet(7+is,6+is,2+is,3+is);
2248 polyhedron->
AddFacet(6+is,5+is,1+is,2+is);
2250 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
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
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