Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/management/src/G4VSolid.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /geometry/management/src/G4VSolid.cc (Version 11.3.0) and /geometry/management/src/G4VSolid.cc (Version 6.1)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                    <<   3 // * DISCLAIMER                                                       *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th <<   5 // * The following disclaimer summarizes all the specific disclaimers *
  6 // * the Geant4 Collaboration.  It is provided <<   6 // * of contributors to this software. The specific disclaimers,which *
  7 // * conditions of the Geant4 Software License <<   7 // * govern, are listed with their locations in:                      *
  8 // * LICENSE and available at  http://cern.ch/ <<   8 // *   http://cern.ch/geant4/license                                  *
  9 // * include a list of copyright holders.      << 
 10 // *                                                9 // *                                                                  *
 11 // * Neither the authors of this software syst     10 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     11 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     12 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     13 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  <<  14 // * use.                                                             *
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                               15 // *                                                                  *
 18 // * This  code  implementation is the result  <<  16 // * This  code  implementation is the  intellectual property  of the *
 19 // * technical work of the GEANT4 collaboratio <<  17 // * GEANT4 collaboration.                                            *
 20 // * By using,  copying,  modifying or  distri <<  18 // * By copying,  distributing  or modifying the Program (or any work *
 21 // * any work based  on the software)  you  ag <<  19 // * based  on  the Program)  you indicate  your  acceptance of  this *
 22 // * use  in  resulting  scientific  publicati <<  20 // * statement, and all its terms.                                    *
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // *******************************************     21 // ********************************************************************
 25 //                                                 22 //
 26 // G4VSolid implementation for solid base clas << 
 27 //                                                 23 //
 28 // 10.10.18 E.Tcherniaev, more robust Estimate <<  24 // $Id: G4VSolid.cc,v 1.20 2003/11/02 14:01:24 gcosmo Exp $
 29 // 30.06.95 P.Kent, Created.                   <<  25 // GEANT4 tag $Name: geant4-06-00-patch-01 $
                                                   >>  26 //
                                                   >>  27 // class G4VSolid
                                                   >>  28 //
                                                   >>  29 // Implementation for solid base class
                                                   >>  30 //
                                                   >>  31 // History:
                                                   >>  32 //
                                                   >>  33 //  06.12.02 V.Grichine, restored original conditions in ClipPolygon()
                                                   >>  34 //  10.05.02 V.Grichine, ClipPolygon(): clip only other axis and limited voxels
                                                   >>  35 //  15.04.02 V.Grichine, bug fixed in ClipPolygon(): clip only one axis
                                                   >>  36 //  13.03.02 V.Grichine, cosmetics of voxel limit functions  
                                                   >>  37 //  15.11.00 D.Williams, V.Grichine, fix in CalculateClippedPolygonExtent()
                                                   >>  38 //  10.07.95 P.Kent, Added == operator, solid Store entry
                                                   >>  39 //  30.06.95 P.Kent, Created.
 30 // -------------------------------------------     40 // --------------------------------------------------------------------
 31                                                    41 
 32 #include "G4VSolid.hh"                             42 #include "G4VSolid.hh"
 33 #include "G4SolidStore.hh"                         43 #include "G4SolidStore.hh"
 34 #include "globals.hh"                          << 
 35 #include "G4QuickRand.hh"                      << 
 36 #include "G4GeometryTolerance.hh"              << 
 37                                                    44 
 38 #include "G4VoxelLimits.hh"                        45 #include "G4VoxelLimits.hh"
 39 #include "G4AffineTransform.hh"                    46 #include "G4AffineTransform.hh"
 40 #include "G4VisExtent.hh"                          47 #include "G4VisExtent.hh"
 41                                                    48 
 42 //////////////////////////////////////////////     49 //////////////////////////////////////////////////////////////////////////
 43 //                                                 50 //
 44 // Streaming operator dumping solid contents   << 
 45                                                << 
 46 std::ostream& operator<< ( std::ostream& os, c << 
 47 {                                              << 
 48     return e.StreamInfo(os);                   << 
 49 }                                              << 
 50                                                << 
 51 ////////////////////////////////////////////// << 
 52 //                                             << 
 53 // Constructor                                     51 // Constructor
 54 //  - Copies name                                  52 //  - Copies name
 55 //  - Add ourselves to solid Store                 53 //  - Add ourselves to solid Store
 56                                                    54 
 57 G4VSolid::G4VSolid(const G4String& name)           55 G4VSolid::G4VSolid(const G4String& name)
 58   : fshapeName(name)                           <<  56   : fshapeName(name) 
 59 {                                              << 
 60     kCarTolerance = G4GeometryTolerance::GetIn << 
 61                                                << 
 62     // Register to store                       << 
 63     //                                         << 
 64     G4SolidStore::GetInstance()->Register(this << 
 65 }                                              << 
 66                                                << 
 67 ////////////////////////////////////////////// << 
 68 //                                             << 
 69 // Copy constructor                            << 
 70 //                                             << 
 71                                                << 
 72 G4VSolid::G4VSolid(const G4VSolid& rhs)        << 
 73   : kCarTolerance(rhs.kCarTolerance), fshapeNa << 
 74 {                                              << 
 75     // Register to store                       << 
 76     //                                         << 
 77     G4SolidStore::GetInstance()->Register(this << 
 78 }                                              << 
 79                                                << 
 80 ////////////////////////////////////////////// << 
 81 //                                             << 
 82 // Fake default constructor - sets only member << 
 83 //                            for usage restri << 
 84 //                                             << 
 85 G4VSolid::G4VSolid( __void__& )                << 
 86   : fshapeName("")                             << 
 87 {                                                  57 {
 88     // Register to store                       << 
 89     //                                         << 
 90     G4SolidStore::GetInstance()->Register(this     58     G4SolidStore::GetInstance()->Register(this);
 91 }                                                  59 }
 92                                                    60 
 93 //////////////////////////////////////////////     61 //////////////////////////////////////////////////////////////////////////
 94 //                                                 62 //
 95 // Destructor (virtual)                            63 // Destructor (virtual)
 96 // - Remove ourselves from solid Store             64 // - Remove ourselves from solid Store
 97                                                    65 
 98 G4VSolid::~G4VSolid()                              66 G4VSolid::~G4VSolid()
 99 {                                                  67 {
100     G4SolidStore::GetInstance()->DeRegister(th     68     G4SolidStore::GetInstance()->DeRegister(this);
101 }                                                  69 }
102                                                    70 
103 //////////////////////////////////////////////     71 //////////////////////////////////////////////////////////////////////////
104 //                                                 72 //
105 // Assignment operator                         <<  73 // Streaming operator dumping solid contents
106                                                << 
107 G4VSolid& G4VSolid::operator = (const G4VSolid << 
108 {                                              << 
109    // Check assignment to self                 << 
110    //                                          << 
111    if (this == &rhs)  { return *this; }        << 
112                                                << 
113    // Copy data                                << 
114    //                                          << 
115    kCarTolerance = rhs.kCarTolerance;          << 
116    fshapeName = rhs.fshapeName;                << 
117                                                << 
118    return *this;                               << 
119 }                                              << 
120                                                << 
121                                                << 
122                                                << 
123 ////////////////////////////////////////////// << 
124 //                                             << 
125 // Set solid name and notify store of the chan << 
126                                                    74 
127 void G4VSolid::SetName(const G4String& name)   <<  75 std::ostream& operator<< ( std::ostream& os, const G4VSolid& e )
128 {                                                  76 {
129   fshapeName = name;                           <<  77     return e.StreamInfo(os);
130   G4SolidStore::GetInstance()->SetMapValid(fal << 
131 }                                                  78 }
132                                                    79 
133 //////////////////////////////////////////////     80 //////////////////////////////////////////////////////////////////////////
134 //                                                 81 //
135 // Throw exception if ComputeDimensions called     82 // Throw exception if ComputeDimensions called for illegal derived class
136                                                    83 
137 void G4VSolid::ComputeDimensions(G4VPVParamete     84 void G4VSolid::ComputeDimensions(G4VPVParameterisation*,
138                                  const G4int,      85                                  const G4int,
139                                  const G4VPhys     86                                  const G4VPhysicalVolume*)
140 {                                                  87 {
141     std::ostringstream message;                <<  88     G4cerr << "ERROR - Illegal call to G4VSolid::ComputeDimensions()" << G4endl
142     message << "Illegal call to G4VSolid::Comp <<  89            << "        Method not overloaded by derived class !" << G4endl;
143             << "Method not overloaded by deriv <<  90     G4Exception("G4VSolid::ComputeDimensions()", "NotApplicable",
144     G4Exception("G4VSolid::ComputeDimensions() <<  91                 FatalException, "Illegal call to case class.");
145                 FatalException, message);      << 
146 }                                              << 
147                                                << 
148 ////////////////////////////////////////////// << 
149 //                                             << 
150 // Throw exception (warning) for solids not im << 
151                                                << 
152 G4ThreeVector G4VSolid::GetPointOnSurface() co << 
153 {                                              << 
154     std::ostringstream message;                << 
155     message << "Not implemented for solid: "   << 
156             << GetEntityType() << " !" << G4en << 
157             << "Returning origin.";            << 
158     G4Exception("G4VSolid::GetPointOnSurface() << 
159                 JustWarning, message);         << 
160     return {0,0,0};                            << 
161 }                                              << 
162                                                << 
163 ////////////////////////////////////////////// << 
164 //                                             << 
165 // Returns total number of constituents that w << 
166 // of the solid. For non-Boolean solids the re << 
167                                                << 
168 G4int G4VSolid::GetNumOfConstituents() const   << 
169 { return 1; }                                  << 
170                                                << 
171 ////////////////////////////////////////////// << 
172 //                                             << 
173 // Returns true if the solid has only planar f << 
174                                                << 
175 G4bool G4VSolid::IsFaceted() const             << 
176 { return false; }                              << 
177                                                << 
178 ////////////////////////////////////////////// << 
179 //                                             << 
180 // Dummy implementations ...                   << 
181                                                << 
182 const G4VSolid* G4VSolid::GetConstituentSolid( << 
183 { return nullptr; }                            << 
184                                                << 
185 G4VSolid* G4VSolid::GetConstituentSolid(G4int) << 
186 { return nullptr; }                            << 
187                                                << 
188 const G4DisplacedSolid* G4VSolid::GetDisplaced << 
189 { return nullptr; }                            << 
190                                                << 
191 G4DisplacedSolid* G4VSolid::GetDisplacedSolidP << 
192 { return nullptr; }                            << 
193                                                << 
194 ////////////////////////////////////////////// << 
195 //                                             << 
196 // Returns an estimation of the solid volume i << 
197 // The number of statistics and error accuracy << 
198 // This method may be overloaded by derived cl << 
199 // exact geometrical quantity for solids where << 
200 // or anyway to cache the computed value.      << 
201 // This implementation does NOT cache the comp << 
202                                                << 
203 G4double G4VSolid::GetCubicVolume()            << 
204 {                                              << 
205   G4int cubVolStatistics = 1000000;            << 
206   G4double cubVolEpsilon = 0.001;              << 
207   return EstimateCubicVolume(cubVolStatistics, << 
208 }                                              << 
209                                                << 
210 ////////////////////////////////////////////// << 
211 //                                             << 
212 // Calculate cubic volume based on Inside() me << 
213 // Accuracy is limited by the second argument  << 
214 // expressed by the first argument.            << 
215 // Implementation is courtesy of Vasiliki Desp << 
216 // University of Athens.                       << 
217                                                << 
218 G4double G4VSolid::EstimateCubicVolume(G4int n << 
219 {                                              << 
220   G4int iInside=0;                             << 
221   G4double px,py,pz,minX,maxX,minY,maxY,minZ,m << 
222   G4ThreeVector p;                             << 
223   EInside in;                                  << 
224                                                << 
225   // values needed for CalculateExtent signatu << 
226                                                << 
227   G4VoxelLimits limit;                // Unlim << 
228   G4AffineTransform origin;                    << 
229                                                << 
230   // min max extents of pSolid along X,Y,Z     << 
231                                                << 
232   CalculateExtent(kXAxis,limit,origin,minX,max << 
233   CalculateExtent(kYAxis,limit,origin,minY,max << 
234   CalculateExtent(kZAxis,limit,origin,minZ,max << 
235                                                << 
236   // limits                                    << 
237                                                << 
238   if(nStat < 100)    nStat   = 100;            << 
239   if(epsilon > 0.01) epsilon = 0.01;           << 
240   halfepsilon = 0.5*epsilon;                   << 
241                                                << 
242   for(auto i = 0; i < nStat; ++i )             << 
243   {                                            << 
244     px = minX-halfepsilon+(maxX-minX+epsilon)* << 
245     py = minY-halfepsilon+(maxY-minY+epsilon)* << 
246     pz = minZ-halfepsilon+(maxZ-minZ+epsilon)* << 
247     p  = G4ThreeVector(px,py,pz);              << 
248     in = Inside(p);                            << 
249     if(in != kOutside) ++iInside;              << 
250   }                                            << 
251   volume = (maxX-minX+epsilon)*(maxY-minY+epsi << 
252          * (maxZ-minZ+epsilon)*iInside/nStat;  << 
253   return volume;                               << 
254 }                                              << 
255                                                << 
256 ////////////////////////////////////////////// << 
257 //                                             << 
258 // Returns an estimation of the solid surface  << 
259 // The number of statistics and error accuracy << 
260 // This method may be overloaded by derived cl << 
261 // exact geometrical quantity for solids where << 
262 // or anyway to cache the computed value.      << 
263 // This implementation does NOT cache the comp << 
264                                                << 
265 G4double G4VSolid::GetSurfaceArea()            << 
266 {                                              << 
267   G4int stat = 1000000;                        << 
268   G4double ell = -1.;                          << 
269   return EstimateSurfaceArea(stat,ell);        << 
270 }                                              << 
271                                                << 
272 ////////////////////////////////////////////// << 
273 //                                             << 
274 // Calculate surface area by estimating volume << 
275 // surrounding the surface using Monte-Carlo m << 
276 // Input parameters:                           << 
277 //    nstat - statistics (number of random poi << 
278 //    eps   - shell thinkness                  << 
279                                                << 
280 G4double G4VSolid::EstimateSurfaceArea(G4int n << 
281 {                                              << 
282   static const G4double s2 = 1./std::sqrt(2.); << 
283   static const G4double s3 = 1./std::sqrt(3.); << 
284   static const G4ThreeVector directions[64] =  << 
285   {                                            << 
286     G4ThreeVector(  0,  0,  0), G4ThreeVector( << 
287     G4ThreeVector(  1,  0,  0), G4ThreeVector( << 
288     G4ThreeVector(  0, -1,  0), G4ThreeVector( << 
289     G4ThreeVector( s2, -s2, 0), G4ThreeVector( << 
290                                                << 
291     G4ThreeVector(  0,  1,  0), G4ThreeVector( << 
292     G4ThreeVector( s2, s2,  0), G4ThreeVector( << 
293     G4ThreeVector(  0, -1,  0), G4ThreeVector( << 
294     G4ThreeVector(  1,  0,  0), G4ThreeVector( << 
295                                                << 
296     G4ThreeVector(  0,  0, -1), G4ThreeVector( << 
297     G4ThreeVector( s2,  0,-s2), G4ThreeVector( << 
298     G4ThreeVector(  0,-s2,-s2), G4ThreeVector( << 
299     G4ThreeVector( s3,-s3,-s3), G4ThreeVector( << 
300                                                << 
301     G4ThreeVector(  0, s2,-s2), G4ThreeVector( << 
302     G4ThreeVector( s3, s3,-s3), G4ThreeVector( << 
303     G4ThreeVector(  0,  0, -1), G4ThreeVector( << 
304     G4ThreeVector( s2,  0,-s2), G4ThreeVector( << 
305                                                << 
306     G4ThreeVector(  0,  0,  1), G4ThreeVector( << 
307     G4ThreeVector( s2,  0, s2), G4ThreeVector( << 
308     G4ThreeVector(  0,-s2, s2), G4ThreeVector( << 
309     G4ThreeVector( s3,-s3, s3), G4ThreeVector( << 
310                                                << 
311     G4ThreeVector(  0, s2, s2), G4ThreeVector( << 
312     G4ThreeVector( s3, s3, s3), G4ThreeVector( << 
313     G4ThreeVector(  0,  0,  1), G4ThreeVector( << 
314     G4ThreeVector( s2,  0, s2), G4ThreeVector( << 
315                                                << 
316     G4ThreeVector(  0,  0, -1), G4ThreeVector( << 
317     G4ThreeVector(  1,  0,  0), G4ThreeVector( << 
318     G4ThreeVector(  0, -1,  0), G4ThreeVector( << 
319     G4ThreeVector( s2, -s2, 0), G4ThreeVector( << 
320                                                << 
321     G4ThreeVector(  0,  1,  0), G4ThreeVector( << 
322     G4ThreeVector( s2, s2,  0), G4ThreeVector( << 
323     G4ThreeVector(  0, -1,  0), G4ThreeVector( << 
324     G4ThreeVector(  1,  0,  0), G4ThreeVector( << 
325   };                                           << 
326                                                << 
327   G4ThreeVector bmin, bmax;                    << 
328   BoundingLimits(bmin, bmax);                  << 
329                                                << 
330   G4double dX = bmax.x() - bmin.x();           << 
331   G4double dY = bmax.y() - bmin.y();           << 
332   G4double dZ = bmax.z() - bmin.z();           << 
333                                                << 
334   // Define statistics and shell thickness     << 
335   //                                           << 
336   G4int npoints = (nstat < 1000) ? 1000 : nsta << 
337   G4double coeff = 0.5 / std::cbrt(G4double(np << 
338   G4double eps = (ell > 0) ? ell : coeff * std << 
339   G4double del = 1.8 * eps; // shold be more t << 
340                                                << 
341   G4double minX = bmin.x() - eps;              << 
342   G4double minY = bmin.y() - eps;              << 
343   G4double minZ = bmin.z() - eps;              << 
344                                                << 
345   G4double dd = 2. * eps;                      << 
346   dX += dd;                                    << 
347   dY += dd;                                    << 
348   dZ += dd;                                    << 
349                                                << 
350   // Calculate surface area                    << 
351   //                                           << 
352   G4int icount = 0;                            << 
353   for(auto i = 0; i < npoints; ++i)            << 
354   {                                            << 
355     G4double px = minX + dX*G4QuickRand();     << 
356     G4double py = minY + dY*G4QuickRand();     << 
357     G4double pz = minZ + dZ*G4QuickRand();     << 
358     G4ThreeVector p  = G4ThreeVector(px, py, p << 
359     EInside in = Inside(p);                    << 
360     G4double dist = 0;                         << 
361     if (in == kInside)                         << 
362     {                                          << 
363       if (DistanceToOut(p) >= eps) continue;   << 
364       G4int icase = 0;                         << 
365       if (Inside(G4ThreeVector(px-del, py, pz) << 
366       if (Inside(G4ThreeVector(px+del, py, pz) << 
367       if (Inside(G4ThreeVector(px, py-del, pz) << 
368       if (Inside(G4ThreeVector(px, py+del, pz) << 
369       if (Inside(G4ThreeVector(px, py, pz-del) << 
370       if (Inside(G4ThreeVector(px, py, pz+del) << 
371       if (icase == 0) continue;                << 
372       G4ThreeVector v = directions[icase];     << 
373       dist = DistanceToOut(p, v);              << 
374       G4ThreeVector n = SurfaceNormal(p + v*di << 
375       dist *= v.dot(n);                        << 
376     }                                          << 
377     else if (in == kOutside)                   << 
378     {                                          << 
379       if (DistanceToIn(p) >= eps) continue;    << 
380       G4int icase = 0;                         << 
381       if (Inside(G4ThreeVector(px-del, py, pz) << 
382       if (Inside(G4ThreeVector(px+del, py, pz) << 
383       if (Inside(G4ThreeVector(px, py-del, pz) << 
384       if (Inside(G4ThreeVector(px, py+del, pz) << 
385       if (Inside(G4ThreeVector(px, py, pz-del) << 
386       if (Inside(G4ThreeVector(px, py, pz+del) << 
387       if (icase == 0) continue;                << 
388       G4ThreeVector v = directions[icase];     << 
389       dist = DistanceToIn(p, v);               << 
390       if (dist == kInfinity) continue;         << 
391       G4ThreeVector n = SurfaceNormal(p + v*di << 
392       dist *= -(v.dot(n));                     << 
393     }                                          << 
394     if (dist < eps) ++icount;                  << 
395   }                                            << 
396   return dX*dY*dZ*icount/npoints/dd;           << 
397 }                                              << 
398                                                << 
399 ////////////////////////////////////////////// << 
400 //                                             << 
401 // Returns a pointer of a dynamically allocate << 
402 // Returns NULL pointer with warning in case t << 
403 // implement this method. The caller has respo << 
404 //                                             << 
405                                                << 
406 G4VSolid* G4VSolid::Clone() const              << 
407 {                                              << 
408   std::ostringstream message;                  << 
409   message << "Clone() method not implemented f << 
410           << GetEntityType() << "!" << G4endl  << 
411           << "Returning NULL pointer!";        << 
412   G4Exception("G4VSolid::Clone()", "GeomMgt100 << 
413   return nullptr;                              << 
414 }                                                  92 }
415                                                    93 
416 //////////////////////////////////////////////     94 ///////////////////////////////////////////////////////////////////////////
417 //                                             <<  95 // 
418 // Calculate the maximum and minimum extents o     96 // Calculate the maximum and minimum extents of the polygon described
419 // by the vertices: pSectionIndex->pSectionInd     97 // by the vertices: pSectionIndex->pSectionIndex+1->
420 //                   pSectionIndex+2->pSection     98 //                   pSectionIndex+2->pSectionIndex+3->pSectionIndex
421 // in the List pVertices                           99 // in the List pVertices
422 //                                                100 //
423 // If the minimum is <pMin pMin is set to the     101 // If the minimum is <pMin pMin is set to the new minimum
424 // If the maximum is >pMax pMax is set to the     102 // If the maximum is >pMax pMax is set to the new maximum
425 //                                                103 //
426 // No modifications are made to pVertices         104 // No modifications are made to pVertices
427 //                                                105 //
428                                                   106 
429 void G4VSolid::ClipCrossSection(       G4Three    107 void G4VSolid::ClipCrossSection(       G4ThreeVectorList* pVertices,
430                                  const G4int p    108                                  const G4int pSectionIndex,
431                                  const G4Voxel    109                                  const G4VoxelLimits& pVoxelLimit,
432                                  const EAxis p << 110                                  const EAxis pAxis, 
433                                        G4doubl    111                                        G4double& pMin, G4double& pMax) const
434 {                                                 112 {
435                                                   113 
436   G4ThreeVectorList polygon;                      114   G4ThreeVectorList polygon;
437   polygon.reserve(4);                          << 
438   polygon.push_back((*pVertices)[pSectionIndex    115   polygon.push_back((*pVertices)[pSectionIndex]);
439   polygon.push_back((*pVertices)[pSectionIndex    116   polygon.push_back((*pVertices)[pSectionIndex+1]);
440   polygon.push_back((*pVertices)[pSectionIndex    117   polygon.push_back((*pVertices)[pSectionIndex+2]);
441   polygon.push_back((*pVertices)[pSectionIndex    118   polygon.push_back((*pVertices)[pSectionIndex+3]);
                                                   >> 119   //  G4cout<<"ClipCrossSection: 0-1-2-3"<<G4endl;
442   CalculateClippedPolygonExtent(polygon,pVoxel    120   CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
443   return;                                         121   return;
444 }                                                 122 }
445                                                   123 
446 //////////////////////////////////////////////    124 //////////////////////////////////////////////////////////////////////////////////
447 //                                                125 //
448 // Calculate the maximum and minimum extents o    126 // Calculate the maximum and minimum extents of the polygons
449 // joining the CrossSections at pSectionIndex-    127 // joining the CrossSections at pSectionIndex->pSectionIndex+3 and
450 //                              pSectionIndex+    128 //                              pSectionIndex+4->pSectionIndex7
451 //                                                129 //
452 // in the List pVertices, within the boundarie    130 // in the List pVertices, within the boundaries of the voxel limits pVoxelLimit
453 //                                                131 //
454 // If the minimum is <pMin pMin is set to the     132 // If the minimum is <pMin pMin is set to the new minimum
455 // If the maximum is >pMax pMax is set to the     133 // If the maximum is >pMax pMax is set to the new maximum
456 //                                                134 //
457 // No modifications are made to pVertices         135 // No modifications are made to pVertices
458                                                   136 
459 void G4VSolid::ClipBetweenSections(      G4Thr    137 void G4VSolid::ClipBetweenSections(      G4ThreeVectorList* pVertices,
460                                    const G4int    138                                    const G4int pSectionIndex,
461                                    const G4Vox    139                                    const G4VoxelLimits& pVoxelLimit,
462                                    const EAxis << 140                                    const EAxis pAxis, 
463                                          G4dou    141                                          G4double& pMin, G4double& pMax) const
464 {                                                 142 {
465   G4ThreeVectorList polygon;                      143   G4ThreeVectorList polygon;
466   polygon.reserve(4);                          << 
467   polygon.push_back((*pVertices)[pSectionIndex    144   polygon.push_back((*pVertices)[pSectionIndex]);
468   polygon.push_back((*pVertices)[pSectionIndex    145   polygon.push_back((*pVertices)[pSectionIndex+4]);
469   polygon.push_back((*pVertices)[pSectionIndex    146   polygon.push_back((*pVertices)[pSectionIndex+5]);
470   polygon.push_back((*pVertices)[pSectionIndex    147   polygon.push_back((*pVertices)[pSectionIndex+1]);
                                                   >> 148   // G4cout<<"ClipBetweenSections: 0-4-5-1"<<G4endl;
471   CalculateClippedPolygonExtent(polygon,pVoxel    149   CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
472   polygon.clear();                                150   polygon.clear();
473                                                   151 
474   polygon.push_back((*pVertices)[pSectionIndex    152   polygon.push_back((*pVertices)[pSectionIndex+1]);
475   polygon.push_back((*pVertices)[pSectionIndex    153   polygon.push_back((*pVertices)[pSectionIndex+5]);
476   polygon.push_back((*pVertices)[pSectionIndex    154   polygon.push_back((*pVertices)[pSectionIndex+6]);
477   polygon.push_back((*pVertices)[pSectionIndex    155   polygon.push_back((*pVertices)[pSectionIndex+2]);
                                                   >> 156   // G4cout<<"ClipBetweenSections: 1-5-6-2"<<G4endl;
478   CalculateClippedPolygonExtent(polygon,pVoxel    157   CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
479   polygon.clear();                                158   polygon.clear();
480                                                   159 
481   polygon.push_back((*pVertices)[pSectionIndex    160   polygon.push_back((*pVertices)[pSectionIndex+2]);
482   polygon.push_back((*pVertices)[pSectionIndex    161   polygon.push_back((*pVertices)[pSectionIndex+6]);
483   polygon.push_back((*pVertices)[pSectionIndex    162   polygon.push_back((*pVertices)[pSectionIndex+7]);
484   polygon.push_back((*pVertices)[pSectionIndex    163   polygon.push_back((*pVertices)[pSectionIndex+3]);
                                                   >> 164   //  G4cout<<"ClipBetweenSections: 2-6-7-3"<<G4endl;
485   CalculateClippedPolygonExtent(polygon,pVoxel    165   CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
486   polygon.clear();                                166   polygon.clear();
487                                                   167 
488   polygon.push_back((*pVertices)[pSectionIndex    168   polygon.push_back((*pVertices)[pSectionIndex+3]);
489   polygon.push_back((*pVertices)[pSectionIndex    169   polygon.push_back((*pVertices)[pSectionIndex+7]);
490   polygon.push_back((*pVertices)[pSectionIndex    170   polygon.push_back((*pVertices)[pSectionIndex+4]);
491   polygon.push_back((*pVertices)[pSectionIndex    171   polygon.push_back((*pVertices)[pSectionIndex]);
                                                   >> 172   //  G4cout<<"ClipBetweenSections: 3-7-4-0"<<G4endl;
492   CalculateClippedPolygonExtent(polygon,pVoxel    173   CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
493   return;                                         174   return;
494 }                                                 175 }
495                                                   176 
496                                                   177 
497 //////////////////////////////////////////////    178 ///////////////////////////////////////////////////////////////////////////////
498 //                                                179 //
499 // Calculate the maximum and minimum extents o    180 // Calculate the maximum and minimum extents of the convex polygon pPolygon
500 // along the axis pAxis, within the limits pVo    181 // along the axis pAxis, within the limits pVoxelLimit
501 //                                                182 //
502                                                   183 
503 void                                              184 void
504 G4VSolid::CalculateClippedPolygonExtent(G4Thre    185 G4VSolid::CalculateClippedPolygonExtent(G4ThreeVectorList& pPolygon,
505                                   const G4Voxe    186                                   const G4VoxelLimits& pVoxelLimit,
506                                   const EAxis  << 187                                   const EAxis pAxis, 
507                                         G4doub    188                                         G4double& pMin,
508                                         G4doub    189                                         G4double& pMax) const
509 {                                                 190 {
510   G4int noLeft,i;                                 191   G4int noLeft,i;
511   G4double component;                             192   G4double component;
512                                                << 193   /*  
                                                   >> 194   G4cout<<G4endl;
                                                   >> 195   for(i = 0 ; i < pPolygon.size() ; i++ )
                                                   >> 196   {
                                                   >> 197       G4cout << i << "\t"
                                                   >> 198              << "p.x = " << pPolygon[i].operator()(pAxis) << "\t"
                                                   >> 199         //   << "p.y = " << pPolygon[i].y() << "\t"
                                                   >> 200         //   << "p.z = " << pPolygon[i].z() << "\t"
                                                   >> 201              << G4endl;
                                                   >> 202   }    
                                                   >> 203   G4cout<<G4endl;
                                                   >> 204   */  
513   ClipPolygon(pPolygon,pVoxelLimit,pAxis);        205   ClipPolygon(pPolygon,pVoxelLimit,pAxis);
514   noLeft = (G4int)pPolygon.size();             << 206   noLeft = pPolygon.size();
515                                                   207 
516   if ( noLeft != 0 )                           << 208   if ( noLeft )
517   {                                               209   {
518     for (i=0; i<noLeft; ++i)                   << 210     //  G4cout<<G4endl;
                                                   >> 211     for (i=0;i<noLeft;i++)
519     {                                             212     {
520       component = pPolygon[i].operator()(pAxis    213       component = pPolygon[i].operator()(pAxis);
521                                                << 214       //  G4cout <<i<<"\t"<<component<<G4endl;
522       if (component < pMin)                    << 215  
523       {                                        << 216       if (component < pMin) 
524         pMin = component;                      << 217       { 
                                                   >> 218         //  G4cout <<i<<"\t"<<"Pmin = "<<component<<G4endl;
                                                   >> 219         pMin = component;      
525       }                                           220       }
526       if (component > pMax)                       221       if (component > pMax)
527       {                                        << 222       {  
528         pMax = component;                      << 223         //  G4cout <<i<<"\t"<<"PMax = "<<component<<G4endl;
529       }                                        << 224         pMax = component;  
                                                   >> 225       }    
530     }                                             226     }
                                                   >> 227     //  G4cout<<G4endl;
531   }                                               228   }
                                                   >> 229   // G4cout<<"pMin = "<<pMin<<"\t"<<"pMax = "<<pMax<<G4endl;
532 }                                                 230 }
533                                                   231 
534 //////////////////////////////////////////////    232 /////////////////////////////////////////////////////////////////////////////
535 //                                                233 //
536 // Clip the convex polygon described by the ve    234 // Clip the convex polygon described by the vertices at
537 // pSectionIndex ->pSectionIndex+3 within pVer    235 // pSectionIndex ->pSectionIndex+3 within pVertices to the limits pVoxelLimit
538 //                                                236 //
539 // Set pMin to the smallest                       237 // Set pMin to the smallest
540 //                                                238 //
541 // Calculate the extent of the polygon along p    239 // Calculate the extent of the polygon along pAxis, when clipped to the
542 // limits pVoxelLimit. If the polygon exists a    240 // limits pVoxelLimit. If the polygon exists after clippin, set pMin to
543 // the polygon's minimum extent along the axis    241 // the polygon's minimum extent along the axis if <pMin, and set pMax to
544 // the polygon's maximum extent along the axis    242 // the polygon's maximum extent along the axis if >pMax.
545 //                                                243 //
546 // The polygon is described by a set of vector    244 // The polygon is described by a set of vectors, where each vector represents
547 // a vertex, so that the polygon is described     245 // a vertex, so that the polygon is described by the vertex sequence:
548 //   0th->1st 1st->2nd 2nd->... nth->0th          246 //   0th->1st 1st->2nd 2nd->... nth->0th
549 //                                                247 //
550 // Modifications to the polygon are made          248 // Modifications to the polygon are made
551 //                                                249 //
552 // NOTE: Execessive copying during clipping       250 // NOTE: Execessive copying during clipping
553                                                   251 
554 void G4VSolid::ClipPolygon(      G4ThreeVector    252 void G4VSolid::ClipPolygon(      G4ThreeVectorList& pPolygon,
555                            const G4VoxelLimits    253                            const G4VoxelLimits& pVoxelLimit,
556                            const EAxis            254                            const EAxis                        ) const
557 {                                                 255 {
558   G4ThreeVectorList outputPolygon;                256   G4ThreeVectorList outputPolygon;
559                                                   257 
560   if ( pVoxelLimit.IsLimited() )                  258   if ( pVoxelLimit.IsLimited() )
561   {                                               259   {
562     if (pVoxelLimit.IsXLimited() ) // && pAxis    260     if (pVoxelLimit.IsXLimited() ) // && pAxis != kXAxis)
563     {                                             261     {
564       G4VoxelLimits simpleLimit1;                 262       G4VoxelLimits simpleLimit1;
565       simpleLimit1.AddLimit(kXAxis,pVoxelLimit    263       simpleLimit1.AddLimit(kXAxis,pVoxelLimit.GetMinXExtent(),kInfinity);
                                                   >> 264       //  G4cout<<"MinXExtent()"<<G4endl;
566       ClipPolygonToSimpleLimits(pPolygon,outpu    265       ClipPolygonToSimpleLimits(pPolygon,outputPolygon,simpleLimit1);
567                                                << 266    
568       pPolygon.clear();                           267       pPolygon.clear();
569                                                   268 
570       if ( outputPolygon.empty() )  return;    << 269       if ( !outputPolygon.size() )  return;
571                                                   270 
572       G4VoxelLimits simpleLimit2;                 271       G4VoxelLimits simpleLimit2;
                                                   >> 272       //  G4cout<<"MaxXExtent()"<<G4endl;
573       simpleLimit2.AddLimit(kXAxis,-kInfinity,    273       simpleLimit2.AddLimit(kXAxis,-kInfinity,pVoxelLimit.GetMaxXExtent());
574       ClipPolygonToSimpleLimits(outputPolygon,    274       ClipPolygonToSimpleLimits(outputPolygon,pPolygon,simpleLimit2);
575                                                   275 
576       if ( pPolygon.empty() )       return;    << 276       if ( !pPolygon.size() )       return;
577       else                          outputPoly    277       else                          outputPolygon.clear();
578     }                                             278     }
579     if ( pVoxelLimit.IsYLimited() ) // && pAxi    279     if ( pVoxelLimit.IsYLimited() ) // && pAxis != kYAxis)
580     {                                             280     {
581       G4VoxelLimits simpleLimit1;                 281       G4VoxelLimits simpleLimit1;
582       simpleLimit1.AddLimit(kYAxis,pVoxelLimit    282       simpleLimit1.AddLimit(kYAxis,pVoxelLimit.GetMinYExtent(),kInfinity);
583       ClipPolygonToSimpleLimits(pPolygon,outpu    283       ClipPolygonToSimpleLimits(pPolygon,outputPolygon,simpleLimit1);
584                                                   284 
585       // Must always clear pPolygon - for clip    285       // Must always clear pPolygon - for clip to simpleLimit2 and in case of
586       // early exit                               286       // early exit
587                                                   287 
588       pPolygon.clear();                           288       pPolygon.clear();
589                                                   289 
590       if ( outputPolygon.empty() )  return;    << 290       if ( !outputPolygon.size() )  return;
591                                                   291 
592       G4VoxelLimits simpleLimit2;                 292       G4VoxelLimits simpleLimit2;
593       simpleLimit2.AddLimit(kYAxis,-kInfinity,    293       simpleLimit2.AddLimit(kYAxis,-kInfinity,pVoxelLimit.GetMaxYExtent());
594       ClipPolygonToSimpleLimits(outputPolygon,    294       ClipPolygonToSimpleLimits(outputPolygon,pPolygon,simpleLimit2);
595                                                   295 
596       if ( pPolygon.empty() )       return;    << 296       if ( !pPolygon.size() )       return;
597       else                          outputPoly    297       else                          outputPolygon.clear();
598     }                                             298     }
599     if ( pVoxelLimit.IsZLimited() ) // && pAxi    299     if ( pVoxelLimit.IsZLimited() ) // && pAxis != kZAxis)
600     {                                             300     {
601       G4VoxelLimits simpleLimit1;                 301       G4VoxelLimits simpleLimit1;
602       simpleLimit1.AddLimit(kZAxis,pVoxelLimit    302       simpleLimit1.AddLimit(kZAxis,pVoxelLimit.GetMinZExtent(),kInfinity);
603       ClipPolygonToSimpleLimits(pPolygon,outpu    303       ClipPolygonToSimpleLimits(pPolygon,outputPolygon,simpleLimit1);
604                                                   304 
605       // Must always clear pPolygon - for clip    305       // Must always clear pPolygon - for clip to simpleLimit2 and in case of
606       // early exit                               306       // early exit
607                                                   307 
608       pPolygon.clear();                           308       pPolygon.clear();
609                                                   309 
610       if ( outputPolygon.empty() )  return;    << 310       if ( !outputPolygon.size() )  return;
611                                                   311 
612       G4VoxelLimits simpleLimit2;                 312       G4VoxelLimits simpleLimit2;
613       simpleLimit2.AddLimit(kZAxis,-kInfinity,    313       simpleLimit2.AddLimit(kZAxis,-kInfinity,pVoxelLimit.GetMaxZExtent());
614       ClipPolygonToSimpleLimits(outputPolygon,    314       ClipPolygonToSimpleLimits(outputPolygon,pPolygon,simpleLimit2);
615                                                   315 
616       // Return after final clip - no cleanup     316       // Return after final clip - no cleanup
617     }                                             317     }
618   }                                               318   }
619 }                                                 319 }
620                                                   320 
621 //////////////////////////////////////////////    321 ////////////////////////////////////////////////////////////////////////////
622 //                                                322 //
623 // pVoxelLimits must be only limited along one    323 // pVoxelLimits must be only limited along one axis, and either the maximum
624 // along the axis must be +kInfinity, or the m    324 // along the axis must be +kInfinity, or the minimum -kInfinity
625                                                   325 
626 void                                              326 void
627 G4VSolid::ClipPolygonToSimpleLimits( G4ThreeVe    327 G4VSolid::ClipPolygonToSimpleLimits( G4ThreeVectorList& pPolygon,
628                                      G4ThreeVe    328                                      G4ThreeVectorList& outputPolygon,
629                                const G4VoxelLi    329                                const G4VoxelLimits& pVoxelLimit       ) const
630 {                                                 330 {
631   G4int i;                                        331   G4int i;
632   auto  noVertices = (G4int)pPolygon.size();   << 332   G4int noVertices=pPolygon.size();
633   G4ThreeVector vEnd,vStart;                      333   G4ThreeVector vEnd,vStart;
634                                                   334 
635   for (i = 0 ; i < noVertices ; ++i )          << 335   for (i = 0 ; i < noVertices ; i++ )
636   {                                               336   {
637     vStart = pPolygon[i];                         337     vStart = pPolygon[i];
                                                   >> 338     // G4cout << "i = " << i << G4endl;
638     if ( i == noVertices-1 )    vEnd = pPolygo    339     if ( i == noVertices-1 )    vEnd = pPolygon[0];
639     else                        vEnd = pPolygo    340     else                        vEnd = pPolygon[i+1];
640                                                   341 
641     if ( pVoxelLimit.Inside(vStart) )             342     if ( pVoxelLimit.Inside(vStart) )
642     {                                             343     {
643       if (pVoxelLimit.Inside(vEnd))               344       if (pVoxelLimit.Inside(vEnd))
644       {                                           345       {
645         // vStart and vEnd inside -> output en    346         // vStart and vEnd inside -> output end point
646         //                                        347         //
647         outputPolygon.push_back(vEnd);            348         outputPolygon.push_back(vEnd);
648       }                                           349       }
649       else                                        350       else
650       {                                           351       {
651         // vStart inside, vEnd outside -> outp    352         // vStart inside, vEnd outside -> output crossing point
652         //                                        353         //
                                                   >> 354         // G4cout << "vStart inside, vEnd outside" << G4endl;
653         pVoxelLimit.ClipToLimits(vStart,vEnd);    355         pVoxelLimit.ClipToLimits(vStart,vEnd);
654         outputPolygon.push_back(vEnd);            356         outputPolygon.push_back(vEnd);
655       }                                        << 357       }    
656     }                                             358     }
657     else                                          359     else
658     {                                             360     {
659       if (pVoxelLimit.Inside(vEnd))               361       if (pVoxelLimit.Inside(vEnd))
660       {                                           362       {
661         // vStart outside, vEnd inside -> outp    363         // vStart outside, vEnd inside -> output inside section
662         //                                        364         //
                                                   >> 365         // G4cout << "vStart outside, vEnd inside" << G4endl;
663         pVoxelLimit.ClipToLimits(vStart,vEnd);    366         pVoxelLimit.ClipToLimits(vStart,vEnd);
664         outputPolygon.push_back(vStart);          367         outputPolygon.push_back(vStart);
665         outputPolygon.push_back(vEnd);         << 368         outputPolygon.push_back(vEnd);  
666       }                                           369       }
667       else  // Both point outside -> no output    370       else  // Both point outside -> no output
668       {                                           371       {
669         // outputPolygon.push_back(vStart);       372         // outputPolygon.push_back(vStart);
670         // outputPolygon.push_back(vEnd);      << 373         // outputPolygon.push_back(vEnd);  
671       }                                           374       }
672     }                                             375     }
673   }                                               376   }
674 }                                                 377 }
675                                                   378 
676 ////////////////////////////////////////////// << 379 const G4VSolid* G4VSolid::GetConstituentSolid(G4int) const
677 //                                             << 380 { return 0; } 
678 // Throw exception (warning) for solids not im << 
679                                                   381 
680 void G4VSolid::BoundingLimits(G4ThreeVector& p << 382 G4VSolid* G4VSolid::GetConstituentSolid(G4int)
681 {                                              << 383 { return 0; } 
682   std::ostringstream message;                  << 
683   message << "Not implemented for solid: "     << 
684           << GetEntityType() << " !"           << 
685           << "\nReturning infinite boundinx bo << 
686   G4Exception("G4VSolid::BoundingLimits()", "G << 
687               JustWarning, message);           << 
688                                                   384 
689   pMin.set(-kInfinity,-kInfinity,-kInfinity);  << 385 const G4DisplacedSolid* G4VSolid::GetDisplacedSolidPtr() const
690   pMax.set( kInfinity, kInfinity, kInfinity);  << 386 { return 0; } 
691 }                                              << 
692                                                   387 
693 ////////////////////////////////////////////// << 388 G4DisplacedSolid* G4VSolid::GetDisplacedSolidPtr() 
694 //                                             << 389 { return 0; } 
695 // Get G4VisExtent - bounding box for graphics << 
696                                                   390 
697 G4VisExtent G4VSolid::GetExtent () const       << 391 G4VisExtent G4VSolid::GetExtent () const 
698 {                                                 392 {
699   G4VisExtent extent;                             393   G4VisExtent extent;
700   G4VoxelLimits voxelLimits;  // Defaults to "    394   G4VoxelLimits voxelLimits;  // Defaults to "infinite" limits.
701   G4AffineTransform affineTransform;              395   G4AffineTransform affineTransform;
702   G4double vmin, vmax;                            396   G4double vmin, vmax;
703   CalculateExtent(kXAxis,voxelLimits,affineTra    397   CalculateExtent(kXAxis,voxelLimits,affineTransform,vmin,vmax);
704   extent.SetXmin (vmin);                          398   extent.SetXmin (vmin);
705   extent.SetXmax (vmax);                          399   extent.SetXmax (vmax);
706   CalculateExtent(kYAxis,voxelLimits,affineTra    400   CalculateExtent(kYAxis,voxelLimits,affineTransform,vmin,vmax);
707   extent.SetYmin (vmin);                          401   extent.SetYmin (vmin);
708   extent.SetYmax (vmax);                          402   extent.SetYmax (vmax);
709   CalculateExtent(kZAxis,voxelLimits,affineTra    403   CalculateExtent(kZAxis,voxelLimits,affineTransform,vmin,vmax);
710   extent.SetZmin (vmin);                          404   extent.SetZmin (vmin);
711   extent.SetZmax (vmax);                          405   extent.SetZmax (vmax);
712   return extent;                                  406   return extent;
713 }                                                 407 }
714                                                   408 
715 G4Polyhedron* G4VSolid::CreatePolyhedron () co    409 G4Polyhedron* G4VSolid::CreatePolyhedron () const
716 {                                                 410 {
717   return nullptr;                              << 411   return 0;
718 }                                                 412 }
719                                                   413 
720 G4Polyhedron* G4VSolid::GetPolyhedron () const << 414 G4NURBS* G4VSolid::CreateNURBS () const
721 {                                                 415 {
722   return nullptr;                              << 416   return 0;
723 }                                                 417 }
724                                                   418