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 4.1.p1)


  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.13 2002/05/11 14:16:10 grichine Exp $
 29 // 30.06.95 P.Kent, Created.                   <<  25 // GEANT4 tag $Name: geant4-04-01 $
 30 // ------------------------------------------- <<  26 //
                                                   >>  27 // class G4VSolid
                                                   >>  28 //
                                                   >>  29 // Implementation for solid base class
                                                   >>  30 //
                                                   >>  31 // History:
                                                   >>  32 //
                                                   >>  33 //  10.05.02 V.Grichine, bug fixed in ClipPoligon: clip only other axis and limited
                                                   >>  34 //                       voxels
                                                   >>  35 //  15.04.02 V.Grichine, bug fixed in ClipPoligon: clip only one axis
                                                   >>  36 //  13.03.02 V.Grichine, cosmetics of voxel limit functions  
                                                   >>  37 //  15.11.00 D.Williams, V.Grichine change in CalculateClippedPolygonExtent:
                                                   >>  38 //                                  else if(component>pMax) ---> if
                                                   >>  39 //  10.07.95 P.Kent Added == operator, solid Store entry
                                                   >>  40 //  30.06.95 P.Kent
                                                   >>  41 //                                  
 31                                                    42 
 32 #include "G4VSolid.hh"                             43 #include "G4VSolid.hh"
 33 #include "G4SolidStore.hh"                         44 #include "G4SolidStore.hh"
 34 #include "globals.hh"                          << 
 35 #include "G4QuickRand.hh"                      << 
 36 #include "G4GeometryTolerance.hh"              << 
 37                                                    45 
 38 #include "G4VoxelLimits.hh"                        46 #include "G4VoxelLimits.hh"
 39 #include "G4AffineTransform.hh"                    47 #include "G4AffineTransform.hh"
 40 #include "G4VisExtent.hh"                          48 #include "G4VisExtent.hh"
 41                                                    49 
 42 //////////////////////////////////////////////     50 //////////////////////////////////////////////////////////////////////////
 43 //                                                 51 //
 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                                     52 // Constructor
 54 //  - Copies name                                  53 //  - Copies name
 55 //  - Add ourselves to solid Store                 54 //  - Add ourselves to solid Store
 56                                                << 
 57 G4VSolid::G4VSolid(const G4String& name)           55 G4VSolid::G4VSolid(const G4String& name)
 58   : fshapeName(name)                           <<  56   : fshapeName(name) 
 59 {                                                  57 {
 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 {                                              << 
 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                                                << 
 98 G4VSolid::~G4VSolid()                              65 G4VSolid::~G4VSolid()
 99 {                                                  66 {
100     G4SolidStore::GetInstance()->DeRegister(th     67     G4SolidStore::GetInstance()->DeRegister(this);
101 }                                                  68 }
102                                                    69 
103 ////////////////////////////////////////////// <<  70 ////////////////////////////////////////////////////////////////////////
104 //                                             <<  71 //  
105 // Assignment operator                         <<  72 // Returns name by value
106                                                    73 
107 G4VSolid& G4VSolid::operator = (const G4VSolid <<  74 G4String G4VSolid::GetName() const
108 {                                                  75 {
109    // Check assignment to self                 <<  76     return fshapeName;
110    //                                          <<  77 } 
111    if (this == &rhs)  { return *this; }        << 
112                                                    78 
113    // Copy data                                <<  79 /////////////////////////////////////////////////////////////////////////
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                                                    80 
127 void G4VSolid::SetName(const G4String& name)       81 void G4VSolid::SetName(const G4String& name)
128 {                                                  82 {
129   fshapeName = name;                           <<  83     fshapeName=name;
130   G4SolidStore::GetInstance()->SetMapValid(fal <<  84 } 
131 }                                              << 
132                                                    85 
133 //////////////////////////////////////////////     86 //////////////////////////////////////////////////////////////////////////
134 //                                                 87 //
135 // Throw exception if ComputeDimensions called     88 // Throw exception if ComputeDimensions called for illegal derived class
136                                                    89 
137 void G4VSolid::ComputeDimensions(G4VPVParamete <<  90 void G4VSolid::ComputeDimensions(G4VPVParameterisation* p,
138                                  const G4int,  <<  91                            const G4int n,
139                                  const G4VPhys <<  92                                  const G4VPhysicalVolume* pRep)
140 {                                              << 
141     std::ostringstream message;                << 
142     message << "Illegal call to G4VSolid::Comp << 
143             << "Method not overloaded by deriv << 
144     G4Exception("G4VSolid::ComputeDimensions() << 
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 {                                                  93 {
220   G4int iInside=0;                             <<  94     G4Exception("G4VSolid::ComputeDimensions called illegally: not overloaded by derived class");
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 }                                                  95 }
398                                                    96 
399 //////////////////////////////////////////////     97 ///////////////////////////////////////////////////////////////////////////
400 //                                             <<  98 // 
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 }                                              << 
415                                                << 
416 ////////////////////////////////////////////// << 
417 //                                             << 
418 // Calculate the maximum and minimum extents o     99 // Calculate the maximum and minimum extents of the polygon described
419 // by the vertices: pSectionIndex->pSectionInd    100 // by the vertices: pSectionIndex->pSectionIndex+1->
420 //                   pSectionIndex+2->pSection    101 //                   pSectionIndex+2->pSectionIndex+3->pSectionIndex
421 // in the List pVertices                          102 // in the List pVertices
422 //                                                103 //
423 // If the minimum is <pMin pMin is set to the     104 // If the minimum is <pMin pMin is set to the new minimum
424 // If the maximum is >pMax pMax is set to the     105 // If the maximum is >pMax pMax is set to the new maximum
425 //                                                106 //
426 // No modifications are made to pVertices         107 // No modifications are made to pVertices
427 //                                                108 //
428                                                   109 
429 void G4VSolid::ClipCrossSection(       G4Three    110 void G4VSolid::ClipCrossSection(       G4ThreeVectorList* pVertices,
430                                  const G4int p << 111                const G4int pSectionIndex,
431                                  const G4Voxel << 112                const G4VoxelLimits& pVoxelLimit,
432                                  const EAxis p << 113                const EAxis pAxis, 
433                                        G4doubl << 114                      G4double& pMin, G4double& pMax) const
434 {                                                 115 {
435                                                   116 
436   G4ThreeVectorList polygon;                      117   G4ThreeVectorList polygon;
437   polygon.reserve(4);                          << 
438   polygon.push_back((*pVertices)[pSectionIndex    118   polygon.push_back((*pVertices)[pSectionIndex]);
439   polygon.push_back((*pVertices)[pSectionIndex    119   polygon.push_back((*pVertices)[pSectionIndex+1]);
440   polygon.push_back((*pVertices)[pSectionIndex    120   polygon.push_back((*pVertices)[pSectionIndex+2]);
441   polygon.push_back((*pVertices)[pSectionIndex    121   polygon.push_back((*pVertices)[pSectionIndex+3]);
                                                   >> 122   //  G4cout<<"ClipCrossSection: 0-1-2-3"<<G4endl;
442   CalculateClippedPolygonExtent(polygon,pVoxel    123   CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
443   return;                                         124   return;
444 }                                                 125 }
445                                                   126 
446 //////////////////////////////////////////////    127 //////////////////////////////////////////////////////////////////////////////////
447 //                                                128 //
448 // Calculate the maximum and minimum extents o    129 // Calculate the maximum and minimum extents of the polygons
449 // joining the CrossSections at pSectionIndex-    130 // joining the CrossSections at pSectionIndex->pSectionIndex+3 and
450 //                              pSectionIndex+    131 //                              pSectionIndex+4->pSectionIndex7
451 //                                                132 //
452 // in the List pVertices, within the boundarie    133 // in the List pVertices, within the boundaries of the voxel limits pVoxelLimit
453 //                                                134 //
454 // If the minimum is <pMin pMin is set to the     135 // If the minimum is <pMin pMin is set to the new minimum
455 // If the maximum is >pMax pMax is set to the     136 // If the maximum is >pMax pMax is set to the new maximum
456 //                                                137 //
457 // No modifications are made to pVertices         138 // No modifications are made to pVertices
458                                                   139 
459 void G4VSolid::ClipBetweenSections(      G4Thr    140 void G4VSolid::ClipBetweenSections(      G4ThreeVectorList* pVertices,
460                                    const G4int << 141                  const G4int pSectionIndex,
461                                    const G4Vox << 142                  const G4VoxelLimits& pVoxelLimit,
462                                    const EAxis << 143                  const EAxis pAxis, 
463                                          G4dou << 144                        G4double& pMin, G4double& pMax) const
464 {                                                 145 {
465   G4ThreeVectorList polygon;                      146   G4ThreeVectorList polygon;
466   polygon.reserve(4);                          << 
467   polygon.push_back((*pVertices)[pSectionIndex    147   polygon.push_back((*pVertices)[pSectionIndex]);
468   polygon.push_back((*pVertices)[pSectionIndex    148   polygon.push_back((*pVertices)[pSectionIndex+4]);
469   polygon.push_back((*pVertices)[pSectionIndex    149   polygon.push_back((*pVertices)[pSectionIndex+5]);
470   polygon.push_back((*pVertices)[pSectionIndex    150   polygon.push_back((*pVertices)[pSectionIndex+1]);
                                                   >> 151   // G4cout<<"ClipBetweenSections: 0-4-5-1"<<G4endl;
471   CalculateClippedPolygonExtent(polygon,pVoxel    152   CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
472   polygon.clear();                                153   polygon.clear();
473                                                   154 
474   polygon.push_back((*pVertices)[pSectionIndex    155   polygon.push_back((*pVertices)[pSectionIndex+1]);
475   polygon.push_back((*pVertices)[pSectionIndex    156   polygon.push_back((*pVertices)[pSectionIndex+5]);
476   polygon.push_back((*pVertices)[pSectionIndex    157   polygon.push_back((*pVertices)[pSectionIndex+6]);
477   polygon.push_back((*pVertices)[pSectionIndex    158   polygon.push_back((*pVertices)[pSectionIndex+2]);
                                                   >> 159   // G4cout<<"ClipBetweenSections: 1-5-6-2"<<G4endl;
478   CalculateClippedPolygonExtent(polygon,pVoxel    160   CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
479   polygon.clear();                                161   polygon.clear();
480                                                   162 
481   polygon.push_back((*pVertices)[pSectionIndex    163   polygon.push_back((*pVertices)[pSectionIndex+2]);
482   polygon.push_back((*pVertices)[pSectionIndex    164   polygon.push_back((*pVertices)[pSectionIndex+6]);
483   polygon.push_back((*pVertices)[pSectionIndex    165   polygon.push_back((*pVertices)[pSectionIndex+7]);
484   polygon.push_back((*pVertices)[pSectionIndex    166   polygon.push_back((*pVertices)[pSectionIndex+3]);
                                                   >> 167   //  G4cout<<"ClipBetweenSections: 2-6-7-3"<<G4endl;
485   CalculateClippedPolygonExtent(polygon,pVoxel    168   CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
486   polygon.clear();                                169   polygon.clear();
487                                                   170 
488   polygon.push_back((*pVertices)[pSectionIndex    171   polygon.push_back((*pVertices)[pSectionIndex+3]);
489   polygon.push_back((*pVertices)[pSectionIndex    172   polygon.push_back((*pVertices)[pSectionIndex+7]);
490   polygon.push_back((*pVertices)[pSectionIndex    173   polygon.push_back((*pVertices)[pSectionIndex+4]);
491   polygon.push_back((*pVertices)[pSectionIndex    174   polygon.push_back((*pVertices)[pSectionIndex]);
                                                   >> 175   //  G4cout<<"ClipBetweenSections: 3-7-4-0"<<G4endl;
492   CalculateClippedPolygonExtent(polygon,pVoxel    176   CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
493   return;                                         177   return;
494 }                                                 178 }
495                                                   179 
496                                                   180 
497 //////////////////////////////////////////////    181 ///////////////////////////////////////////////////////////////////////////////
498 //                                                182 //
499 // Calculate the maximum and minimum extents o    183 // Calculate the maximum and minimum extents of the convex polygon pPolygon
500 // along the axis pAxis, within the limits pVo    184 // along the axis pAxis, within the limits pVoxelLimit
501 //                                                185 //
502                                                   186 
503 void                                           << 187 void G4VSolid::CalculateClippedPolygonExtent(G4ThreeVectorList& pPolygon,
504 G4VSolid::CalculateClippedPolygonExtent(G4Thre << 188             const G4VoxelLimits& pVoxelLimit,
505                                   const G4Voxe << 189             const EAxis pAxis, 
506                                   const EAxis  << 190             G4double& pMin, G4double& pMax) const
507                                         G4doub << 
508                                         G4doub << 
509 {                                                 191 {
510   G4int noLeft,i;                                 192   G4int noLeft,i;
511   G4double component;                             193   G4double component;
512                                                << 194   /*  
                                                   >> 195   G4cout<<G4endl;
                                                   >> 196   for(i = 0 ; i < pPolygon.size() ; i++ )
                                                   >> 197   {
                                                   >> 198       G4cout<<i<<"\t"<<"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              pAxis          ) 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 G4VSolid::ClipPolygonToSimpleLimits( G4ThreeVectorList& pPolygon,
627 G4VSolid::ClipPolygonToSimpleLimits( G4ThreeVe << 327                   G4ThreeVectorList& outputPolygon,
628                                      G4ThreeVe << 328             const G4VoxelLimits& pVoxelLimit       ) const
629                                const G4VoxelLi << 
630 {                                                 329 {
631   G4int i;                                        330   G4int i;
632   auto  noVertices = (G4int)pPolygon.size();   << 331   G4int noVertices=pPolygon.size();
633   G4ThreeVector vEnd,vStart;                      332   G4ThreeVector vEnd,vStart;
634                                                   333 
635   for (i = 0 ; i < noVertices ; ++i )          << 334   for (i = 0 ; i < noVertices ; i++ )
636   {                                               335   {
637     vStart = pPolygon[i];                         336     vStart = pPolygon[i];
                                                   >> 337     //  G4cout<<"i = "<<i<<G4endl;
638     if ( i == noVertices-1 )    vEnd = pPolygo    338     if ( i == noVertices-1 )    vEnd = pPolygon[0];
639     else                        vEnd = pPolygo    339     else                        vEnd = pPolygon[i+1];
640                                                << 340     
641     if ( pVoxelLimit.Inside(vStart) )             341     if ( pVoxelLimit.Inside(vStart) )
642     {                                             342     {
643       if (pVoxelLimit.Inside(vEnd))               343       if (pVoxelLimit.Inside(vEnd))
644       {                                           344       {
645         // vStart and vEnd inside -> output en << 345 // vStart and vEnd inside -> output end point
646         //                                     << 346 
647         outputPolygon.push_back(vEnd);            347         outputPolygon.push_back(vEnd);
648       }                                           348       }
649       else                                        349       else
650       {                                           350       {
651         // vStart inside, vEnd outside -> outp << 351 // vStart inside, vEnd outside -> output crossing point
652         //                                     << 352   // G4cout<<"vStart inside, vEnd outside"<<G4endl;
653         pVoxelLimit.ClipToLimits(vStart,vEnd);    353         pVoxelLimit.ClipToLimits(vStart,vEnd);
654         outputPolygon.push_back(vEnd);         << 354   outputPolygon.push_back(vEnd);
655       }                                        << 355       }     
656     }                                             356     }
657     else                                          357     else
658     {                                             358     {
659       if (pVoxelLimit.Inside(vEnd))               359       if (pVoxelLimit.Inside(vEnd))
660       {                                           360       {
661         // vStart outside, vEnd inside -> outp << 361 // vStart outside, vEnd inside -> output inside section
662         //                                     << 362   //  G4cout<<"vStart outside, vEnd inside"<<G4endl;
                                                   >> 363 
663         pVoxelLimit.ClipToLimits(vStart,vEnd);    364         pVoxelLimit.ClipToLimits(vStart,vEnd);
664         outputPolygon.push_back(vStart);       << 365   outputPolygon.push_back(vStart);
665         outputPolygon.push_back(vEnd);         << 366   outputPolygon.push_back(vEnd);  
666       }                                           367       }
667       else  // Both point outside -> no output    368       else  // Both point outside -> no output
668       {                                           369       {
669         // outputPolygon.push_back(vStart);    << 370   // outputPolygon.push_back(vStart);
670         // outputPolygon.push_back(vEnd);      << 371   // outputPolygon.push_back(vEnd);  
671       }                                           372       }
672     }                                             373     }
673   }                                               374   }
674 }                                                 375 }
675                                                   376 
676 ////////////////////////////////////////////// << 377 const G4VSolid* G4VSolid::GetConstituentSolid(G4int no) const
677 //                                             << 378 { return 0; } 
678 // Throw exception (warning) for solids not im << 
679                                                   379 
680 void G4VSolid::BoundingLimits(G4ThreeVector& p << 380 G4VSolid* G4VSolid::GetConstituentSolid(G4int no)
681 {                                              << 381 { 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                                                   382 
689   pMin.set(-kInfinity,-kInfinity,-kInfinity);  << 383 const G4DisplacedSolid* G4VSolid::GetDisplacedSolidPtr() const
690   pMax.set( kInfinity, kInfinity, kInfinity);  << 384 { return 0; } 
691 }                                              << 
692                                                   385 
693 ////////////////////////////////////////////// << 386 G4DisplacedSolid* G4VSolid::GetDisplacedSolidPtr() 
694 //                                             << 387 { return 0; } 
695 // Get G4VisExtent - bounding box for graphics << 
696                                                   388 
697 G4VisExtent G4VSolid::GetExtent () const       << 389 G4VisExtent G4VSolid::GetExtent () const 
698 {                                                 390 {
699   G4VisExtent extent;                             391   G4VisExtent extent;
700   G4VoxelLimits voxelLimits;  // Defaults to "    392   G4VoxelLimits voxelLimits;  // Defaults to "infinite" limits.
701   G4AffineTransform affineTransform;              393   G4AffineTransform affineTransform;
702   G4double vmin, vmax;                            394   G4double vmin, vmax;
703   CalculateExtent(kXAxis,voxelLimits,affineTra    395   CalculateExtent(kXAxis,voxelLimits,affineTransform,vmin,vmax);
704   extent.SetXmin (vmin);                          396   extent.SetXmin (vmin);
705   extent.SetXmax (vmax);                          397   extent.SetXmax (vmax);
706   CalculateExtent(kYAxis,voxelLimits,affineTra    398   CalculateExtent(kYAxis,voxelLimits,affineTransform,vmin,vmax);
707   extent.SetYmin (vmin);                          399   extent.SetYmin (vmin);
708   extent.SetYmax (vmax);                          400   extent.SetYmax (vmax);
709   CalculateExtent(kZAxis,voxelLimits,affineTra    401   CalculateExtent(kZAxis,voxelLimits,affineTransform,vmin,vmax);
710   extent.SetZmin (vmin);                          402   extent.SetZmin (vmin);
711   extent.SetZmax (vmax);                          403   extent.SetZmax (vmax);
712   return extent;                                  404   return extent;
713 }                                                 405 }
714                                                   406 
715 G4Polyhedron* G4VSolid::CreatePolyhedron () co    407 G4Polyhedron* G4VSolid::CreatePolyhedron () const
716 {                                                 408 {
717   return nullptr;                              << 409   return 0;
718 }                                                 410 }
719                                                   411 
720 G4Polyhedron* G4VSolid::GetPolyhedron () const << 412 G4NURBS* G4VSolid::CreateNURBS () const
721 {                                                 413 {
722   return nullptr;                              << 414   return 0;
723 }                                                 415 }
724                                                   416