Geant4  10.03.p03
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Classes | Public Member Functions | List of all members
G4ExtrudedSolid Class Reference

#include <G4ExtrudedSolid.hh>

Inheritance diagram for G4ExtrudedSolid:
Inheritance graph
[legend]
Collaboration diagram for G4ExtrudedSolid:
Collaboration graph
[legend]

Classes

struct  ZSection
 

Public Member Functions

 G4ExtrudedSolid (const G4String &pName, const std::vector< G4TwoVector > &polygon, const std::vector< ZSection > &zsections)
 
 G4ExtrudedSolid (const G4String &pName, const std::vector< G4TwoVector > &polygon, G4double halfZ, const G4TwoVector &off1, G4double scale1, const G4TwoVector &off2, G4double scale2)
 
virtual ~G4ExtrudedSolid ()
 
G4int GetNofVertices () const
 
G4TwoVector GetVertex (G4int index) const
 
std::vector< G4TwoVector > GetPolygon () const
 
G4int GetNofZSections () const
 
ZSection GetZSection (G4int index) const
 
std::vector< ZSection > GetZSections () const
 
EInside Inside (const G4ThreeVector &p) const
 
G4double DistanceToOut (const G4ThreeVector &p, const G4ThreeVector &v, const G4bool calcNorm=false, G4bool *validNorm=0, G4ThreeVector *n=0) const
 
G4double DistanceToOut (const G4ThreeVector &p) const
 
void Extent (G4ThreeVector &pMin, G4ThreeVector &pMax) const
 
G4bool CalculateExtent (const EAxis pAxis, const G4VoxelLimits &pVoxelLimit, const G4AffineTransform &pTransform, G4double &pMin, G4double &pMax) const
 
G4GeometryType GetEntityType () const
 
G4VSolid * Clone () const
 
std::ostream & StreamInfo (std::ostream &os) const
 
 G4ExtrudedSolid (__void__ &)
 
 G4ExtrudedSolid (const G4ExtrudedSolid &rhs)
 
G4ExtrudedSolid & operator= (const G4ExtrudedSolid &rhs)
 
- Public Member Functions inherited from G4TessellatedSolid
 G4TessellatedSolid ()
 
virtual ~G4TessellatedSolid ()
 
 G4TessellatedSolid (const G4String &name)
 
 G4TessellatedSolid (__void__ &)
 
 G4TessellatedSolid (const G4TessellatedSolid &ts)
 
G4TessellatedSolid & operator= (const G4TessellatedSolid &right)
 
G4TessellatedSolid & operator+= (const G4TessellatedSolid &right)
 
G4bool AddFacet (G4VFacet *aFacet)
 
G4VFacet * GetFacet (G4int i) const
 
G4int GetNumberOfFacets () const
 
virtual G4ThreeVector SurfaceNormal (const G4ThreeVector &p) const
 
virtual G4double DistanceToIn (const G4ThreeVector &p, const G4ThreeVector &v) const
 
virtual G4double DistanceToIn (const G4ThreeVector &p) const
 
virtual G4bool Normal (const G4ThreeVector &p, G4ThreeVector &n) const
 
virtual G4double SafetyFromOutside (const G4ThreeVector &p, G4bool aAccurate=false) const
 
virtual G4double SafetyFromInside (const G4ThreeVector &p, G4bool aAccurate=false) const
 
virtual G4ThreeVector GetPointOnSurface () const
 
virtual G4double GetSurfaceArea ()
 
virtual G4double GetCubicVolume ()
 
void SetSolidClosed (const G4bool t)
 
G4bool GetSolidClosed () const
 
void SetMaxVoxels (G4int max)
 
G4SurfaceVoxelizer & GetVoxels ()
 
void Extent (G4ThreeVector &pMin, G4ThreeVector &pMax) const
 
G4double GetMinXExtent () const
 
G4double GetMaxXExtent () const
 
G4double GetMinYExtent () const
 
G4double GetMaxYExtent () const
 
G4double GetMinZExtent () const
 
G4double GetMaxZExtent () const
 
virtual G4Polyhedron * CreatePolyhedron () const
 
virtual G4Polyhedron * GetPolyhedron () const
 
virtual void DescribeYourselfTo (G4VGraphicsScene &scene) const
 
virtual G4VisExtent GetExtent () const
 
G4int AllocatedMemoryWithoutVoxels ()
 
G4int AllocatedMemory ()
 
void DisplayAllocatedMemory ()
 
- Public Member Functions inherited from G4VSolid
 G4VSolid (const G4String &name)
 
virtual ~G4VSolid ()
 
G4bool operator== (const G4VSolid &s) const
 
G4String GetName () const
 
void SetName (const G4String &name)
 
G4double GetTolerance () const
 
virtual void ComputeDimensions (G4VPVParameterisation *p, const G4int n, const G4VPhysicalVolume *pRep)
 
void DumpInfo () const
 
virtual const G4VSolid * GetConstituentSolid (G4int no) const
 
virtual G4VSolid * GetConstituentSolid (G4int no)
 
virtual const G4DisplacedSolid * GetDisplacedSolidPtr () const
 
virtual G4DisplacedSolid * GetDisplacedSolidPtr ()
 
 G4VSolid (__void__ &)
 
 G4VSolid (const G4VSolid &rhs)
 
G4VSolid & operator= (const G4VSolid &rhs)
 
G4double EstimateCubicVolume (G4int nStat, G4double epsilon) const
 
G4double EstimateSurfaceArea (G4int nStat, G4double ell) const
 

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 83 of file G4ExtrudedSolid.hh.

Constructor & Destructor Documentation

G4ExtrudedSolid::G4ExtrudedSolid ( const G4String &  pName,
const std::vector< G4TwoVector > &  polygon,
const std::vector< ZSection > &  zsections 
)

Definition at line 70 of file G4ExtrudedSolid.cc.

73  : G4TessellatedSolid(pName),
74  fNv(polygon.size()),
75  fNz(zsections.size()),
76  fPolygon(),
77  fZSections(),
78  fTriangles(),
79  fIsConvex(false),
80  fGeometryType("G4ExtrudedSolid")
81 
82 {
83  // General constructor
84 
85  // First check input parameters
86 
87  if (fNv < 3)
88  {
89  std::ostringstream message;
90  message << "Number of vertices in polygon < 3 - " << pName;
91  G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids0002",
92  FatalErrorInArgument, message);
93  }
94 
95  if (fNz < 2)
96  {
97  std::ostringstream message;
98  message << "Number of z-sides < 2 - " << pName;
99  G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids0002",
100  FatalErrorInArgument, message);
101  }
102 
103  for ( G4int i=0; i<fNz-1; ++i )
104  {
105  if ( zsections[i].fZ > zsections[i+1].fZ )
106  {
107  std::ostringstream message;
108  message << "Z-sections have to be ordered by z value (z0 < z1 < z2...) - "
109  << pName;
110  G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids0002",
111  FatalErrorInArgument, message);
112  }
113  if ( std::fabs( zsections[i+1].fZ - zsections[i].fZ ) < kCarToleranceHalf )
114  {
115  std::ostringstream message;
116  message << "Z-sections with the same z position are not supported - "
117  << pName;
118  G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids0001",
119  FatalException, message);
120  }
121  }
122 
123  // Copy polygon
124  //
125  fPolygon = polygon;
126 
127  // Remove collinear and coincident vertices, if any
128  //
129  std::vector<G4int> removedVertices;
130  G4GeomTools::RemoveRedundantVertices(fPolygon,removedVertices,
131  2*kCarTolerance);
132  if (removedVertices.size() != 0)
133  {
134  G4int nremoved = removedVertices.size();
135  std::ostringstream message;
136  message << "The following "<< nremoved
137  << " vertices have been removed from polygon in " << pName
138  << "\nas collinear or coincident with other vertices: "
139  << removedVertices[0];
140  for (G4int i=1; i<nremoved; ++i) message << ", " << removedVertices[i];
141  G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids1001",
142  JustWarning, message);
143  }
144 
145  fNv = fPolygon.size();
146  if (fNv < 3)
147  {
148  std::ostringstream message;
149  message << "Number of vertices in polygon after removal < 3 - " << pName;
150  G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids0002",
151  FatalErrorInArgument, message);
152  }
153 
154  // Check if polygon vertices are defined clockwise
155  // (the area is positive if polygon vertices are defined anti-clockwise)
156  //
157  if (G4GeomTools::PolygonArea(fPolygon) > 0.)
158  {
159  // Polygon vertices are defined anti-clockwise, we revert them
160  // G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids1001",
161  // JustWarning,
162  // "Polygon vertices defined anti-clockwise, reverting polygon");
163  std::reverse(fPolygon.begin(),fPolygon.end());
164  }
165 
166  // Copy z-sections
167  //
168  fZSections = zsections;
169 
170  G4bool result = MakeFacets();
171  if (!result)
172  {
173  std::ostringstream message;
174  message << "Making facets failed - " << pName;
175  G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids0003",
176  FatalException, message);
177  }
178  fIsConvex = G4GeomTools::IsConvex(fPolygon);
179 
180  ComputeProjectionParameters();
181 }
result
G4double G4ParticleHPJENDLHEData::G4double result
Definition: G4ParticleHPJENDLHEData.cc:257
G4GeomTools::PolygonArea
static G4double PolygonArea(const G4TwoVectorList &polygon)
Definition: G4GeomTools.cc:82
JustWarning
Definition: G4ExceptionSeverity.hh:64
G4int
int G4int
Definition: G4Types.hh:78
G4bool
bool G4bool
Definition: G4Types.hh:79
reverse
Definition: F04UserTrackInformation.hh:37
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
FatalErrorInArgument
Definition: G4ExceptionSeverity.hh:61
FatalException
Definition: G4ExceptionSeverity.hh:60
G4GeomTools::IsConvex
static G4bool IsConvex(const G4TwoVectorList &polygon)
Definition: G4GeomTools.cc:150
G4VSolid::kCarTolerance
G4double kCarTolerance
Definition: G4VSolid.hh:307
G4GeomTools::RemoveRedundantVertices
static void RemoveRedundantVertices(G4TwoVectorList &polygon, std::vector< G4int > &iout, G4double tolerance=0)
Definition: G4GeomTools.cc:293

Here is the call graph for this function:

Here is the caller graph for this function:

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 185 of file G4ExtrudedSolid.cc.

190  : G4TessellatedSolid(pName),
191  fNv(polygon.size()),
192  fNz(2),
193  fPolygon(),
194  fZSections(),
195  fTriangles(),
196  fIsConvex(false),
197  fGeometryType("G4ExtrudedSolid")
198 
199 {
200  // Special constructor for solid with 2 z-sections
201 
202  // First check input parameters
203  //
204  if (fNv < 3)
205  {
206  std::ostringstream message;
207  message << "Number of vertices in polygon < 3 - " << pName;
208  G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids0002",
209  FatalErrorInArgument, message);
210  }
211 
212  // Copy polygon
213  //
214  fPolygon = polygon;
215 
216  // Remove collinear and coincident vertices, if any
217  //
218  std::vector<G4int> removedVertices;
219  G4GeomTools::RemoveRedundantVertices(fPolygon,removedVertices,
220  2*kCarTolerance);
221  if (removedVertices.size() != 0)
222  {
223  G4int nremoved = removedVertices.size();
224  std::ostringstream message;
225  message << "The following "<< nremoved
226  << " vertices have been removed from polygon in " << pName
227  << "\nas collinear or coincident with other vertices: "
228  << removedVertices[0];
229  for (G4int i=1; i<nremoved; ++i) message << ", " << removedVertices[i];
230  G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids1001",
231  JustWarning, message);
232  }
233 
234  fNv = fPolygon.size();
235  if (fNv < 3)
236  {
237  std::ostringstream message;
238  message << "Number of vertices in polygon after removal < 3 - " << pName;
239  G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids0002",
240  FatalErrorInArgument, message);
241  }
242 
243  // Check if polygon vertices are defined clockwise
244  // (the area is positive if polygon vertices are defined anti-clockwise)
245  //
246  if (G4GeomTools::PolygonArea(fPolygon) > 0.)
247  {
248  // Polygon vertices are defined anti-clockwise, we revert them
249  // G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids1001",
250  // JustWarning,
251  // "Polygon vertices defined anti-clockwise, reverting polygon");
252  std::reverse(fPolygon.begin(),fPolygon.end());
253  }
254 
255  // Copy z-sections
256  //
257  fZSections.push_back(ZSection(-dz, off1, scale1));
258  fZSections.push_back(ZSection( dz, off2, scale2));
259 
260  G4bool result = MakeFacets();
261  if (!result)
262  {
263  std::ostringstream message;
264  message << "Making facets failed - " << pName;
265  G4Exception("G4ExtrudedSolid::G4ExtrudedSolid()", "GeomSolids0003",
266  FatalException, message);
267  }
268  fIsConvex = G4GeomTools::IsConvex(fPolygon);
269 
270  ComputeProjectionParameters();
271 }
result
G4double G4ParticleHPJENDLHEData::G4double result
Definition: G4ParticleHPJENDLHEData.cc:257
G4GeomTools::PolygonArea
static G4double PolygonArea(const G4TwoVectorList &polygon)
Definition: G4GeomTools.cc:82
JustWarning
Definition: G4ExceptionSeverity.hh:64
G4int
int G4int
Definition: G4Types.hh:78
G4bool
bool G4bool
Definition: G4Types.hh:79
reverse
Definition: F04UserTrackInformation.hh:37
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
FatalErrorInArgument
Definition: G4ExceptionSeverity.hh:61
FatalException
Definition: G4ExceptionSeverity.hh:60
G4GeomTools::IsConvex
static G4bool IsConvex(const G4TwoVectorList &polygon)
Definition: G4GeomTools.cc:150
G4VSolid::kCarTolerance
G4double kCarTolerance
Definition: G4VSolid.hh:307
G4GeomTools::RemoveRedundantVertices
static void RemoveRedundantVertices(G4TwoVectorList &polygon, std::vector< G4int > &iout, G4double tolerance=0)
Definition: G4GeomTools.cc:293

Here is the call graph for this function:

G4ExtrudedSolid::~G4ExtrudedSolid ( )
virtual

Definition at line 321 of file G4ExtrudedSolid.cc.

322 {
323  // Destructor
324 }
G4ExtrudedSolid::G4ExtrudedSolid ( __void__ &  a)

Definition at line 275 of file G4ExtrudedSolid.cc.

276  : G4TessellatedSolid(a), fNv(0), fNz(0), fPolygon(), fZSections(),
277  fTriangles(), fIsConvex(false), fGeometryType("G4ExtrudedSolid")
278 {
279  // Fake default constructor - sets only member data and allocates memory
280  // for usage restricted to object persistency.
281 }
a
std::vector< ExP01TrackerHit * > a
Definition: ExP01Classes.hh:33
G4ExtrudedSolid::G4ExtrudedSolid ( const G4ExtrudedSolid &  rhs)

Definition at line 285 of file G4ExtrudedSolid.cc.

286  : G4TessellatedSolid(rhs), fNv(rhs.fNv), fNz(rhs.fNz),
287  fPolygon(rhs.fPolygon), fZSections(rhs.fZSections),
288  fTriangles(rhs.fTriangles), fIsConvex(rhs.fIsConvex),
289  fGeometryType(rhs.fGeometryType), fKScales(rhs.fKScales),
290  fScale0s(rhs.fScale0s), fKOffsets(rhs.fKOffsets), fOffset0s(rhs.fOffset0s)
291 {
292 }

Member Function Documentation

G4bool G4ExtrudedSolid::CalculateExtent ( const EAxis  pAxis,
const G4VoxelLimits &  pVoxelLimit,
const G4AffineTransform &  pTransform,
G4double &  pMin,
G4double &  pMax 
) const
virtual

Reimplemented from G4TessellatedSolid.

Definition at line 968 of file G4ExtrudedSolid.cc.

972 {
973  G4ThreeVector bmin, bmax;
974  G4bool exist;
975 
976  // Check bounding box (bbox)
977  //
978  Extent(bmin,bmax);
979  G4BoundingEnvelope bbox(bmin,bmax);
980 #ifdef G4BBOX_EXTENT
981  if (true) return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
982 #endif
983  if (bbox.BoundingBoxVsVoxelLimits(pAxis,pVoxelLimit,pTransform,pMin,pMax))
984  {
985  return exist = (pMin < pMax) ? true : false;
986  }
987 
988  // To find the extent, the base polygon is subdivided in triangles.
989  // The extent is calculated as cumulative extent of the parts
990  // formed by extrusion of the triangles
991  //
992  G4TwoVectorList triangles;
993  G4double eminlim = pVoxelLimit.GetMinExtent(pAxis);
994  G4double emaxlim = pVoxelLimit.GetMaxExtent(pAxis);
995 
996  // triangulate the base polygon
997  if (!G4GeomTools::TriangulatePolygon(fPolygon,triangles))
998  {
999  std::ostringstream message;
1000  message << "Triangulation of the base polygon has failed for solid: "
1001  << GetName() << " !"
1002  << "\nExtent has been calculated using boundary box";
1003  G4Exception("G4ExtrudedSolid::CalculateExtent()",
1004  "GeomMgt1002",JustWarning,message);
1005  return bbox.CalculateExtent(pAxis,pVoxelLimit,pTransform,pMin,pMax);
1006  }
1007 
1008  // allocate vector lists
1009  G4int nsect = GetNofZSections();
1010  std::vector<const G4ThreeVectorList *> polygons;
1011  polygons.resize(nsect);
1012  for (G4int k=0; k<nsect; ++k) { polygons[k] = new G4ThreeVectorList(3); }
1013 
1014  // main loop along triangles
1015  pMin = kInfinity;
1016  pMax = -kInfinity;
1017  G4int ntria = triangles.size()/3;
1018  for (G4int i=0; i<ntria; ++i)
1019  {
1020  G4int i3 = i*3;
1021  for (G4int k=0; k<nsect; ++k) // extrude triangle
1022  {
1023  ZSection zsect = GetZSection(k);
1024  G4double z = zsect.fZ;
1025  G4double dx = zsect.fOffset.x();
1026  G4double dy = zsect.fOffset.y();
1027  G4double scale = zsect.fScale;
1028 
1029  G4ThreeVectorList* ptr = const_cast<G4ThreeVectorList*>(polygons[k]);
1030  G4ThreeVectorList::iterator iter = ptr->begin();
1031  G4double x0 = triangles[i3+0].x()*scale+dx;
1032  G4double y0 = triangles[i3+0].y()*scale+dy;
1033  iter->set(x0,y0,z);
1034  iter++;
1035  G4double x1 = triangles[i3+1].x()*scale+dx;
1036  G4double y1 = triangles[i3+1].y()*scale+dy;
1037  iter->set(x1,y1,z);
1038  iter++;
1039  G4double x2 = triangles[i3+2].x()*scale+dx;
1040  G4double y2 = triangles[i3+2].y()*scale+dy;
1041  iter->set(x2,y2,z);
1042  }
1043 
1044  // set sub-envelope and adjust extent
1045  G4double emin,emax;
1046  G4BoundingEnvelope benv(polygons);
1047  if (!benv.CalculateExtent(pAxis,pVoxelLimit,pTransform,emin,emax)) continue;
1048  if (emin < pMin) pMin = emin;
1049  if (emax > pMax) pMax = emax;
1050  if (eminlim > pMin && emaxlim < pMax) break; // max possible extent
1051  }
1052  // free memory
1053  for (G4int k=0; k<nsect; ++k) { delete polygons[k]; polygons[k]=0;}
1054  return (pMin < pMax);
1055 }
G4VSolid::GetName
G4String GetName() const
G4ExtrudedSolid::Extent
void Extent(G4ThreeVector &pMin, G4ThreeVector &pMax) const
Definition: G4ExtrudedSolid.cc:911
kInfinity
static const G4double kInfinity
Definition: geomdefs.hh:42
G4TwoVectorList
std::vector< G4TwoVector > G4TwoVectorList
Definition: G4GeomTools.hh:50
JustWarning
Definition: G4ExceptionSeverity.hh:64
G4int
int G4int
Definition: G4Types.hh:78
G4bool
bool G4bool
Definition: G4Types.hh:79
G4GeomTools::TriangulatePolygon
static G4bool TriangulatePolygon(const G4TwoVectorList &polygon, G4TwoVectorList &result)
Definition: G4GeomTools.cc:178
G4ThreeVectorList
std::vector< G4ThreeVector > G4ThreeVectorList
Definition: G4BoundingEnvelope.hh:61
G4ExtrudedSolid::GetNofZSections
G4int GetNofZSections() const
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
emax
static const G4double emax
Definition: G4ChatterjeeCrossSection.hh:39
G4ExtrudedSolid::GetZSection
ZSection GetZSection(G4int index) const
test.z
tuple z
Definition: test.py:28
G4double
double G4double
Definition: G4Types.hh:76
G4VoxelLimits::GetMaxExtent
G4double GetMaxExtent(const EAxis pAxis) const
G4VoxelLimits::GetMinExtent
G4double GetMinExtent(const EAxis pAxis) const

Here is the call graph for this function:

G4VSolid * G4ExtrudedSolid::Clone ( ) const
virtual

Reimplemented from G4TessellatedSolid.

Definition at line 801 of file G4ExtrudedSolid.cc.

802 {
803  return new G4ExtrudedSolid(*this);
804 }
G4ExtrudedSolid::G4ExtrudedSolid
G4ExtrudedSolid(const G4String &pName, const std::vector< G4TwoVector > &polygon, const std::vector< ZSection > &zsections)
Definition: G4ExtrudedSolid.cc:70

Here is the call graph for this function:

G4double G4ExtrudedSolid::DistanceToOut ( const G4ThreeVector &  p,
const G4ThreeVector &  v,
const G4bool  calcNorm = false,
G4bool *  validNorm = 0,
G4ThreeVector *  n = 0 
) const
virtual

Reimplemented from G4TessellatedSolid.

Definition at line 881 of file G4ExtrudedSolid.cc.

886 {
887  // Override the base class function to redefine validNorm
888  // (the solid can be concave)
889 
890  G4double distOut =
891  G4TessellatedSolid::DistanceToOut(p, v, calcNorm, validNorm, n);
892  if (validNorm) { *validNorm = fIsConvex; }
893 
894  return distOut;
895 }
G4TessellatedSolid::DistanceToOut
virtual G4double DistanceToOut(const G4ThreeVector &p) const
Definition: G4TessellatedSolid.cc:1708
G4double
double G4double
Definition: G4Types.hh:76

Here is the call graph for this function:

G4double G4ExtrudedSolid::DistanceToOut ( const G4ThreeVector &  p) const
virtual

Reimplemented from G4TessellatedSolid.

Definition at line 900 of file G4ExtrudedSolid.cc.

901 {
902  // Override the overloaded base class function
903 
904  return G4TessellatedSolid::DistanceToOut(p);
905 }
G4TessellatedSolid::DistanceToOut
virtual G4double DistanceToOut(const G4ThreeVector &p) const
Definition: G4TessellatedSolid.cc:1708

Here is the call graph for this function:

void G4ExtrudedSolid::Extent ( G4ThreeVector &  pMin,
G4ThreeVector &  pMax 
) const
virtual

Reimplemented from G4VSolid.

Definition at line 911 of file G4ExtrudedSolid.cc.

912 {
913  G4double xmin0 = kInfinity, xmax0 = -kInfinity;
914  G4double ymin0 = kInfinity, ymax0 = -kInfinity;
915 
916  for (G4int i=0; i<GetNofVertices(); ++i)
917  {
918  G4double x = fPolygon[i].x();
919  if (x < xmin0) xmin0 = x;
920  if (x > xmax0) xmax0 = x;
921  G4double y = fPolygon[i].y();
922  if (y < ymin0) ymin0 = y;
923  if (y > ymax0) ymax0 = y;
924  }
925 
926  G4double xmin = kInfinity, xmax = -kInfinity;
927  G4double ymin = kInfinity, ymax = -kInfinity;
928 
929  G4int nsect = GetNofZSections();
930  for (G4int i=0; i<nsect; ++i)
931  {
932  ZSection zsect = GetZSection(i);
933  G4double dx = zsect.fOffset.x();
934  G4double dy = zsect.fOffset.y();
935  G4double scale = zsect.fScale;
936  xmin = std::min(xmin,xmin0*scale+dx);
937  xmax = std::max(xmax,xmax0*scale+dx);
938  ymin = std::min(ymin,ymin0*scale+dy);
939  ymax = std::max(ymax,ymax0*scale+dy);
940  }
941 
942  G4double zmin = GetZSection(0).fZ;
943  G4double zmax = GetZSection(nsect-1).fZ;
944 
945  pMin.set(xmin,ymin,zmin);
946  pMax.set(xmax,ymax,zmax);
947 
948  // Check correctness of the bounding box
949  //
950  if (pMin.x() >= pMax.x() || pMin.y() >= pMax.y() || pMin.z() >= pMax.z())
951  {
952  std::ostringstream message;
953  message << "Bad bounding box (min >= max) for solid: "
954  << GetName() << " !"
955  << "\npMin = " << pMin
956  << "\npMax = " << pMax;
957  G4Exception("G4ExtrudedSolid::Extent()",
958  "GeomMgt0001", JustWarning, message);
959  DumpInfo();
960  }
961 }
CLHEP::Hep3Vector::set
void set(double x, double y, double z)
G4VSolid::GetName
G4String GetName() const
kInfinity
static const G4double kInfinity
Definition: geomdefs.hh:42
CLHEP::Hep3Vector::x
double x() const
test.x
tuple x
Definition: test.py:50
JustWarning
Definition: G4ExceptionSeverity.hh:64
G4int
int G4int
Definition: G4Types.hh:78
CLHEP::Hep3Vector::z
double z() const
G4VSolid::DumpInfo
void DumpInfo() const
G4ExtrudedSolid::GetNofVertices
G4int GetNofVertices() const
G4ExtrudedSolid::GetNofZSections
G4int GetNofZSections() const
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *comments)
Definition: G4Exception.cc:41
G4INCL::Math::max
T max(const T t1, const T t2)
brief Return the largest of the two arguments
Definition: G4INCLGlobals.hh:112
CLHEP::Hep3Vector::y
double y() const
G4ExtrudedSolid::GetZSection
ZSection GetZSection(G4int index) const
G4INCL::Math::min
T min(const T t1, const T t2)
brief Return the smallest of the two arguments
Definition: G4INCLGlobals.hh:117
G4double
double G4double
Definition: G4Types.hh:76

Here is the call graph for this function:

Here is the caller graph for this function:

G4GeometryType G4ExtrudedSolid::GetEntityType ( ) const
virtual

Reimplemented from G4TessellatedSolid.

Definition at line 792 of file G4ExtrudedSolid.cc.

793 {
794  // Return entity type
795 
796  return fGeometryType;
797 }
G4int G4ExtrudedSolid::GetNofVertices ( ) const
inline

Here is the caller graph for this function:

G4int G4ExtrudedSolid::GetNofZSections ( ) const
inline

Here is the caller graph for this function:

std::vector<G4TwoVector> G4ExtrudedSolid::GetPolygon ( ) const
inline
G4TwoVector G4ExtrudedSolid::GetVertex ( G4int  index) const
inline

Here is the caller graph for this function:

ZSection G4ExtrudedSolid::GetZSection ( G4int  index) const
inline

Here is the caller graph for this function:

std::vector<ZSection> G4ExtrudedSolid::GetZSections ( ) const
inline
EInside G4ExtrudedSolid::Inside ( const G4ThreeVector &  p) const
virtual

Reimplemented from G4TessellatedSolid.

Definition at line 808 of file G4ExtrudedSolid.cc.

809 {
810  // Override the base class function as it fails in case of concave polygon.
811  // Project the point in the original polygon scale and check if it is inside
812  // for each triangle.
813 
814  // Check first if outside extent
815  //
816  if ( p.x() < GetMinXExtent() - kCarToleranceHalf ||
817  p.x() > GetMaxXExtent() + kCarToleranceHalf ||
818  p.y() < GetMinYExtent() - kCarToleranceHalf ||
819  p.y() > GetMaxYExtent() + kCarToleranceHalf ||
820  p.z() < GetMinZExtent() - kCarToleranceHalf ||
821  p.z() > GetMaxZExtent() + kCarToleranceHalf )
822  {
823  // G4cout << "G4ExtrudedSolid::Outside extent: " << p << G4endl;
824  return kOutside;
825  }
826 
827  // Project point p(z) to the polygon scale p0
828  //
829  G4TwoVector pscaled = ProjectPoint(p);
830 
831  // Check if on surface of polygon
832  //
833  for ( G4int i=0; i<fNv; ++i )
834  {
835  G4int j = (i+1) % fNv;
836  if ( IsSameLineSegment(pscaled, fPolygon[i], fPolygon[j]) )
837  {
838  // G4cout << "G4ExtrudedSolid::Inside return Surface (on polygon) "
839  // << G4endl;
840 
841  return kSurface;
842  }
843  }
844 
845  // Now check if inside triangles
846  //
847  std::vector< std::vector<G4int> >::const_iterator it = fTriangles.begin();
848  G4bool inside = false;
849  do // Loop checking, 13.08.2015, G.Cosmo
850  {
851  if ( IsPointInside(fPolygon[(*it)[0]], fPolygon[(*it)[1]],
852  fPolygon[(*it)[2]], pscaled) ) { inside = true; }
853  ++it;
854  } while ( (inside == false) && (it != fTriangles.end()) );
855 
856  if ( inside )
857  {
858  // Check if on surface of z sides
859  //
860  if ( std::fabs( p.z() - fZSections[0].fZ ) < kCarToleranceHalf ||
861  std::fabs( p.z() - fZSections[fNz-1].fZ ) < kCarToleranceHalf )
862  {
863  // G4cout << "G4ExtrudedSolid::Inside return Surface (on z side)"
864  // << G4endl;
865 
866  return kSurface;
867  }
868 
869  // G4cout << "G4ExtrudedSolid::Inside return Inside" << G4endl;
870 
871  return kInside;
872  }
873 
874  // G4cout << "G4ExtrudedSolid::Inside return Outside " << G4endl;
875 
876  return kOutside;
877 }
CLHEP::Hep3Vector::x
double x() const
G4TessellatedSolid::GetMaxXExtent
G4double GetMaxXExtent() const
Definition: G4TessellatedSolid.cc:1918
G4TessellatedSolid::GetMinXExtent
G4double GetMinXExtent() const
Definition: G4TessellatedSolid.cc:1911
G4TessellatedSolid::GetMaxZExtent
G4double GetMaxZExtent() const
Definition: G4TessellatedSolid.cc:1946
G4int
int G4int
Definition: G4Types.hh:78
CLHEP::Hep3Vector::z
double z() const
G4TessellatedSolid::GetMinZExtent
G4double GetMinZExtent() const
Definition: G4TessellatedSolid.cc:1939
G4bool
bool G4bool
Definition: G4Types.hh:79
CLHEP::Hep3Vector::y
double y() const
G4TessellatedSolid::GetMaxYExtent
G4double GetMaxYExtent() const
Definition: G4TessellatedSolid.cc:1932
G4TessellatedSolid::GetMinYExtent
G4double GetMinYExtent() const
Definition: G4TessellatedSolid.cc:1925

Here is the call graph for this function:

G4ExtrudedSolid & G4ExtrudedSolid::operator= ( const G4ExtrudedSolid &  rhs)

Definition at line 297 of file G4ExtrudedSolid.cc.

298 {
299  // Check assignment to self
300  //
301  if (this == &rhs) { return *this; }
302 
303  // Copy base class data
304  //
305  G4TessellatedSolid::operator=(rhs);
306 
307  // Copy data
308  //
309  fNv = rhs.fNv; fNz = rhs.fNz;
310  fPolygon = rhs.fPolygon; fZSections = rhs.fZSections;
311  fTriangles = rhs.fTriangles; fIsConvex = rhs.fIsConvex;
312  fGeometryType = rhs.fGeometryType; fKScales = rhs.fKScales;
313  fScale0s = rhs.fScale0s; fKOffsets = rhs.fKOffsets;
314  fOffset0s = rhs.fOffset0s;
315 
316  return *this;
317 }
G4TessellatedSolid::operator=
G4TessellatedSolid & operator=(const G4TessellatedSolid &right)
Definition: G4TessellatedSolid.cc:164

Here is the call graph for this function:

std::ostream & G4ExtrudedSolid::StreamInfo ( std::ostream &  os) const
virtual

Reimplemented from G4TessellatedSolid.

Definition at line 1059 of file G4ExtrudedSolid.cc.

1060 {
1061  G4int oldprc = os.precision(16);
1062  os << "-----------------------------------------------------------\n"
1063  << " *** Dump for solid - " << GetName() << " ***\n"
1064  << " ===================================================\n"
1065  << " Solid geometry type: " << fGeometryType << G4endl;
1066 
1067  if ( fIsConvex)
1068  { os << " Convex polygon; list of vertices:" << G4endl; }
1069  else
1070  { os << " Concave polygon; list of vertices:" << G4endl; }
1071 
1072  for ( G4int i=0; i<fNv; ++i )
1073  {
1074  os << std::setw(5) << "#" << i
1075  << " vx = " << fPolygon[i].x()/mm << " mm"
1076  << " vy = " << fPolygon[i].y()/mm << " mm" << G4endl;
1077  }
1078 
1079  os << " Sections:" << G4endl;
1080  for ( G4int iz=0; iz<fNz; ++iz )
1081  {
1082  os << " z = " << fZSections[iz].fZ/mm << " mm "
1083  << " x0= " << fZSections[iz].fOffset.x()/mm << " mm "
1084  << " y0= " << fZSections[iz].fOffset.y()/mm << " mm "
1085  << " scale= " << fZSections[iz].fScale << G4endl;
1086  }
1087 
1088 /*
1089  // Triangles (for debugging)
1090  os << G4endl;
1091  os << " Triangles:" << G4endl;
1092  os << " Triangle # vertex1 vertex2 vertex3" << G4endl;
1093 
1094  G4int counter = 0;
1095  std::vector< std::vector<G4int> >::const_iterator it;
1096  for ( it = fTriangles.begin(); it != fTriangles.end(); it++ ) {
1097  std::vector<G4int> triangle = *it;
1098  os << std::setw(10) << counter++
1099  << std::setw(10) << triangle[0] << std::setw(10) << triangle[1]
1100  << std::setw(10) << triangle[2]
1101  << G4endl;
1102  }
1103 */
1104  os.precision(oldprc);
1105 
1106  return os;
1107 }
G4VSolid::GetName
G4String GetName() const
mm
static constexpr double mm
Definition: G4SIunits.hh:115
G4int
int G4int
Definition: G4Types.hh:78
G4endl
#define G4endl
Definition: G4ios.hh:61

Here is the call graph for this function:

The documentation for this class was generated from the following files: