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 5.0.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.16 2003/01/15 09:37:26 gcosmo Exp $
 29 // 30.06.95 P.Kent, Created.                   <<  25 // GEANT4 tag $Name: geant4-05-00-patch-01 $
 30 // ------------------------------------------- <<  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.
                                                   >>  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 G4std::ostream& operator<< ( G4std::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* p,
138                                  const G4int,  <<  85                            const G4int n,
139                                  const G4VPhys <<  86                                  const G4VPhysicalVolume* pRep)
140 {                                              <<  87 {
141     std::ostringstream message;                <<  88     G4cout << "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     G4cerr << "ERROR - Illegal call to G4VSolid::ComputeDimensions()" << G4endl
144     G4Exception("G4VSolid::ComputeDimensions() <<  91            << "        Method not overloaded by derived class !" << G4endl;
145                 FatalException, message);      <<  92     G4Exception("G4VSolid::ComputeDimensions() - Illegal call");
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 }                                                  93 }
415                                                    94 
416 //////////////////////////////////////////////     95 ///////////////////////////////////////////////////////////////////////////
417 //                                             <<  96 // 
418 // Calculate the maximum and minimum extents o     97 // Calculate the maximum and minimum extents of the polygon described
419 // by the vertices: pSectionIndex->pSectionInd     98 // by the vertices: pSectionIndex->pSectionIndex+1->
420 //                   pSectionIndex+2->pSection     99 //                   pSectionIndex+2->pSectionIndex+3->pSectionIndex
421 // in the List pVertices                          100 // in the List pVertices
422 //                                                101 //
423 // If the minimum is <pMin pMin is set to the     102 // If the minimum is <pMin pMin is set to the new minimum
424 // If the maximum is >pMax pMax is set to the     103 // If the maximum is >pMax pMax is set to the new maximum
425 //                                                104 //
426 // No modifications are made to pVertices         105 // No modifications are made to pVertices
427 //                                                106 //
428                                                   107 
429 void G4VSolid::ClipCrossSection(       G4Three    108 void G4VSolid::ClipCrossSection(       G4ThreeVectorList* pVertices,
430                                  const G4int p << 109                const G4int pSectionIndex,
431                                  const G4Voxel << 110                const G4VoxelLimits& pVoxelLimit,
432                                  const EAxis p << 111                const EAxis pAxis, 
433                                        G4doubl << 112                      G4double& pMin, G4double& pMax) const
434 {                                                 113 {
435                                                   114 
436   G4ThreeVectorList polygon;                      115   G4ThreeVectorList polygon;
437   polygon.reserve(4);                          << 
438   polygon.push_back((*pVertices)[pSectionIndex    116   polygon.push_back((*pVertices)[pSectionIndex]);
439   polygon.push_back((*pVertices)[pSectionIndex    117   polygon.push_back((*pVertices)[pSectionIndex+1]);
440   polygon.push_back((*pVertices)[pSectionIndex    118   polygon.push_back((*pVertices)[pSectionIndex+2]);
441   polygon.push_back((*pVertices)[pSectionIndex    119   polygon.push_back((*pVertices)[pSectionIndex+3]);
                                                   >> 120   //  G4cout<<"ClipCrossSection: 0-1-2-3"<<G4endl;
442   CalculateClippedPolygonExtent(polygon,pVoxel    121   CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
443   return;                                         122   return;
444 }                                                 123 }
445                                                   124 
446 //////////////////////////////////////////////    125 //////////////////////////////////////////////////////////////////////////////////
447 //                                                126 //
448 // Calculate the maximum and minimum extents o    127 // Calculate the maximum and minimum extents of the polygons
449 // joining the CrossSections at pSectionIndex-    128 // joining the CrossSections at pSectionIndex->pSectionIndex+3 and
450 //                              pSectionIndex+    129 //                              pSectionIndex+4->pSectionIndex7
451 //                                                130 //
452 // in the List pVertices, within the boundarie    131 // in the List pVertices, within the boundaries of the voxel limits pVoxelLimit
453 //                                                132 //
454 // If the minimum is <pMin pMin is set to the     133 // If the minimum is <pMin pMin is set to the new minimum
455 // If the maximum is >pMax pMax is set to the     134 // If the maximum is >pMax pMax is set to the new maximum
456 //                                                135 //
457 // No modifications are made to pVertices         136 // No modifications are made to pVertices
458                                                   137 
459 void G4VSolid::ClipBetweenSections(      G4Thr    138 void G4VSolid::ClipBetweenSections(      G4ThreeVectorList* pVertices,
460                                    const G4int << 139                  const G4int pSectionIndex,
461                                    const G4Vox << 140                  const G4VoxelLimits& pVoxelLimit,
462                                    const EAxis << 141                  const EAxis pAxis, 
463                                          G4dou << 142                        G4double& pMin, G4double& pMax) const
464 {                                                 143 {
465   G4ThreeVectorList polygon;                      144   G4ThreeVectorList polygon;
466   polygon.reserve(4);                          << 
467   polygon.push_back((*pVertices)[pSectionIndex    145   polygon.push_back((*pVertices)[pSectionIndex]);
468   polygon.push_back((*pVertices)[pSectionIndex    146   polygon.push_back((*pVertices)[pSectionIndex+4]);
469   polygon.push_back((*pVertices)[pSectionIndex    147   polygon.push_back((*pVertices)[pSectionIndex+5]);
470   polygon.push_back((*pVertices)[pSectionIndex    148   polygon.push_back((*pVertices)[pSectionIndex+1]);
                                                   >> 149   // G4cout<<"ClipBetweenSections: 0-4-5-1"<<G4endl;
471   CalculateClippedPolygonExtent(polygon,pVoxel    150   CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
472   polygon.clear();                                151   polygon.clear();
473                                                   152 
474   polygon.push_back((*pVertices)[pSectionIndex    153   polygon.push_back((*pVertices)[pSectionIndex+1]);
475   polygon.push_back((*pVertices)[pSectionIndex    154   polygon.push_back((*pVertices)[pSectionIndex+5]);
476   polygon.push_back((*pVertices)[pSectionIndex    155   polygon.push_back((*pVertices)[pSectionIndex+6]);
477   polygon.push_back((*pVertices)[pSectionIndex    156   polygon.push_back((*pVertices)[pSectionIndex+2]);
                                                   >> 157   // G4cout<<"ClipBetweenSections: 1-5-6-2"<<G4endl;
478   CalculateClippedPolygonExtent(polygon,pVoxel    158   CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
479   polygon.clear();                                159   polygon.clear();
480                                                   160 
481   polygon.push_back((*pVertices)[pSectionIndex    161   polygon.push_back((*pVertices)[pSectionIndex+2]);
482   polygon.push_back((*pVertices)[pSectionIndex    162   polygon.push_back((*pVertices)[pSectionIndex+6]);
483   polygon.push_back((*pVertices)[pSectionIndex    163   polygon.push_back((*pVertices)[pSectionIndex+7]);
484   polygon.push_back((*pVertices)[pSectionIndex    164   polygon.push_back((*pVertices)[pSectionIndex+3]);
                                                   >> 165   //  G4cout<<"ClipBetweenSections: 2-6-7-3"<<G4endl;
485   CalculateClippedPolygonExtent(polygon,pVoxel    166   CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
486   polygon.clear();                                167   polygon.clear();
487                                                   168 
488   polygon.push_back((*pVertices)[pSectionIndex    169   polygon.push_back((*pVertices)[pSectionIndex+3]);
489   polygon.push_back((*pVertices)[pSectionIndex    170   polygon.push_back((*pVertices)[pSectionIndex+7]);
490   polygon.push_back((*pVertices)[pSectionIndex    171   polygon.push_back((*pVertices)[pSectionIndex+4]);
491   polygon.push_back((*pVertices)[pSectionIndex    172   polygon.push_back((*pVertices)[pSectionIndex]);
                                                   >> 173   //  G4cout<<"ClipBetweenSections: 3-7-4-0"<<G4endl;
492   CalculateClippedPolygonExtent(polygon,pVoxel    174   CalculateClippedPolygonExtent(polygon,pVoxelLimit,pAxis,pMin,pMax);
493   return;                                         175   return;
494 }                                                 176 }
495                                                   177 
496                                                   178 
497 //////////////////////////////////////////////    179 ///////////////////////////////////////////////////////////////////////////////
498 //                                                180 //
499 // Calculate the maximum and minimum extents o    181 // Calculate the maximum and minimum extents of the convex polygon pPolygon
500 // along the axis pAxis, within the limits pVo    182 // along the axis pAxis, within the limits pVoxelLimit
501 //                                                183 //
502                                                   184 
503 void                                           << 185 void G4VSolid::CalculateClippedPolygonExtent(G4ThreeVectorList& pPolygon,
504 G4VSolid::CalculateClippedPolygonExtent(G4Thre << 186             const G4VoxelLimits& pVoxelLimit,
505                                   const G4Voxe << 187             const EAxis pAxis, 
506                                   const EAxis  << 188             G4double& pMin, G4double& pMax) const
507                                         G4doub << 
508                                         G4doub << 
509 {                                                 189 {
510   G4int noLeft,i;                                 190   G4int noLeft,i;
511   G4double component;                             191   G4double component;
512                                                << 192   /*  
                                                   >> 193   G4cout<<G4endl;
                                                   >> 194   for(i = 0 ; i < pPolygon.size() ; i++ )
                                                   >> 195   {
                                                   >> 196       G4cout<<i<<"\t"<<"p.x = "<<pPolygon[i].operator()(pAxis)<<"\t"
                                                   >> 197   //            <<"p.y = "<<pPolygon[i].y()<<"\t"
                                                   >> 198         //             <<"p.z = "<<pPolygon[i].z()<<"\t"
                                                   >> 199             <<G4endl;
                                                   >> 200   }     
                                                   >> 201   G4cout<<G4endl;
                                                   >> 202   */  
513   ClipPolygon(pPolygon,pVoxelLimit,pAxis);        203   ClipPolygon(pPolygon,pVoxelLimit,pAxis);
514   noLeft = (G4int)pPolygon.size();             << 204   noLeft = pPolygon.size();
515                                                   205 
516   if ( noLeft != 0 )                           << 206   if ( noLeft )
517   {                                               207   {
518     for (i=0; i<noLeft; ++i)                   << 208     //  G4cout<<G4endl;
                                                   >> 209     for (i=0;i<noLeft;i++)
519     {                                             210     {
520       component = pPolygon[i].operator()(pAxis    211       component = pPolygon[i].operator()(pAxis);
521                                                << 212       //  G4cout <<i<<"\t"<<component<<G4endl;
522       if (component < pMin)                    << 213  
523       {                                        << 214       if (component < pMin) 
524         pMin = component;                      << 215       { 
                                                   >> 216   //  G4cout <<i<<"\t"<<"Pmin = "<<component<<G4endl;
                                                   >> 217         pMin = component;      
525       }                                           218       }
526       if (component > pMax)                       219       if (component > pMax)
527       {                                        << 220       {  
528         pMax = component;                      << 221   //  G4cout <<i<<"\t"<<"PMax = "<<component<<G4endl;
529       }                                        << 222         pMax = component;  
                                                   >> 223       }    
530     }                                             224     }
                                                   >> 225     //  G4cout<<G4endl;
531   }                                               226   }
                                                   >> 227   // G4cout<<"pMin = "<<pMin<<"\t"<<"pMax = "<<pMax<<G4endl;
532 }                                                 228 }
533                                                   229 
534 //////////////////////////////////////////////    230 /////////////////////////////////////////////////////////////////////////////
535 //                                                231 //
536 // Clip the convex polygon described by the ve    232 // Clip the convex polygon described by the vertices at
537 // pSectionIndex ->pSectionIndex+3 within pVer    233 // pSectionIndex ->pSectionIndex+3 within pVertices to the limits pVoxelLimit
538 //                                                234 //
539 // Set pMin to the smallest                       235 // Set pMin to the smallest
540 //                                                236 //
541 // Calculate the extent of the polygon along p    237 // Calculate the extent of the polygon along pAxis, when clipped to the
542 // limits pVoxelLimit. If the polygon exists a    238 // limits pVoxelLimit. If the polygon exists after clippin, set pMin to
543 // the polygon's minimum extent along the axis    239 // the polygon's minimum extent along the axis if <pMin, and set pMax to
544 // the polygon's maximum extent along the axis    240 // the polygon's maximum extent along the axis if >pMax.
545 //                                                241 //
546 // The polygon is described by a set of vector    242 // The polygon is described by a set of vectors, where each vector represents
547 // a vertex, so that the polygon is described     243 // a vertex, so that the polygon is described by the vertex sequence:
548 //   0th->1st 1st->2nd 2nd->... nth->0th          244 //   0th->1st 1st->2nd 2nd->... nth->0th
549 //                                                245 //
550 // Modifications to the polygon are made          246 // Modifications to the polygon are made
551 //                                                247 //
552 // NOTE: Execessive copying during clipping       248 // NOTE: Execessive copying during clipping
553                                                   249 
554 void G4VSolid::ClipPolygon(      G4ThreeVector    250 void G4VSolid::ClipPolygon(      G4ThreeVectorList& pPolygon,
555                            const G4VoxelLimits << 251          const G4VoxelLimits& pVoxelLimit,
556                            const EAxis         << 252                            const EAxis              pAxis          ) const
557 {                                                 253 {
558   G4ThreeVectorList outputPolygon;                254   G4ThreeVectorList outputPolygon;
559                                                   255 
560   if ( pVoxelLimit.IsLimited() )                  256   if ( pVoxelLimit.IsLimited() )
561   {                                               257   {
562     if (pVoxelLimit.IsXLimited() ) // && pAxis    258     if (pVoxelLimit.IsXLimited() ) // && pAxis != kXAxis)
563     {                                             259     {
564       G4VoxelLimits simpleLimit1;                 260       G4VoxelLimits simpleLimit1;
565       simpleLimit1.AddLimit(kXAxis,pVoxelLimit    261       simpleLimit1.AddLimit(kXAxis,pVoxelLimit.GetMinXExtent(),kInfinity);
                                                   >> 262       //  G4cout<<"MinXExtent()"<<G4endl;
566       ClipPolygonToSimpleLimits(pPolygon,outpu    263       ClipPolygonToSimpleLimits(pPolygon,outputPolygon,simpleLimit1);
567                                                << 264    
568       pPolygon.clear();                           265       pPolygon.clear();
569                                                   266 
570       if ( outputPolygon.empty() )  return;    << 267       if ( !outputPolygon.size() )  return;
571                                                << 268       
572       G4VoxelLimits simpleLimit2;                 269       G4VoxelLimits simpleLimit2;
                                                   >> 270       //  G4cout<<"MaxXExtent()"<<G4endl;
573       simpleLimit2.AddLimit(kXAxis,-kInfinity,    271       simpleLimit2.AddLimit(kXAxis,-kInfinity,pVoxelLimit.GetMaxXExtent());
574       ClipPolygonToSimpleLimits(outputPolygon,    272       ClipPolygonToSimpleLimits(outputPolygon,pPolygon,simpleLimit2);
575                                                   273 
576       if ( pPolygon.empty() )       return;    << 274       if ( !pPolygon.size() )       return;   
577       else                          outputPoly << 275       else                          outputPolygon.clear();  
578     }                                             276     }
579     if ( pVoxelLimit.IsYLimited() ) // && pAxi << 277   if ( pVoxelLimit.IsYLimited() ) // && pAxis != kYAxis)
580     {                                             278     {
581       G4VoxelLimits simpleLimit1;                 279       G4VoxelLimits simpleLimit1;
582       simpleLimit1.AddLimit(kYAxis,pVoxelLimit    280       simpleLimit1.AddLimit(kYAxis,pVoxelLimit.GetMinYExtent(),kInfinity);
583       ClipPolygonToSimpleLimits(pPolygon,outpu    281       ClipPolygonToSimpleLimits(pPolygon,outputPolygon,simpleLimit1);
584                                                   282 
585       // Must always clear pPolygon - for clip    283       // Must always clear pPolygon - for clip to simpleLimit2 and in case of
586       // early exit                               284       // early exit
587                                                   285 
588       pPolygon.clear();                           286       pPolygon.clear();
589                                                   287 
590       if ( outputPolygon.empty() )  return;    << 288       if ( !outputPolygon.size() )  return;
591                                                << 289       
592       G4VoxelLimits simpleLimit2;                 290       G4VoxelLimits simpleLimit2;
593       simpleLimit2.AddLimit(kYAxis,-kInfinity,    291       simpleLimit2.AddLimit(kYAxis,-kInfinity,pVoxelLimit.GetMaxYExtent());
594       ClipPolygonToSimpleLimits(outputPolygon,    292       ClipPolygonToSimpleLimits(outputPolygon,pPolygon,simpleLimit2);
595                                                   293 
596       if ( pPolygon.empty() )       return;    << 294       if ( !pPolygon.size() )       return;
597       else                          outputPoly << 295       else                          outputPolygon.clear();  
598     }                                             296     }
599     if ( pVoxelLimit.IsZLimited() ) // && pAxi    297     if ( pVoxelLimit.IsZLimited() ) // && pAxis != kZAxis)
600     {                                             298     {
601       G4VoxelLimits simpleLimit1;                 299       G4VoxelLimits simpleLimit1;
602       simpleLimit1.AddLimit(kZAxis,pVoxelLimit    300       simpleLimit1.AddLimit(kZAxis,pVoxelLimit.GetMinZExtent(),kInfinity);
603       ClipPolygonToSimpleLimits(pPolygon,outpu    301       ClipPolygonToSimpleLimits(pPolygon,outputPolygon,simpleLimit1);
604                                                   302 
605       // Must always clear pPolygon - for clip    303       // Must always clear pPolygon - for clip to simpleLimit2 and in case of
606       // early exit                               304       // early exit
607                                                   305 
608       pPolygon.clear();                           306       pPolygon.clear();
609                                                   307 
610       if ( outputPolygon.empty() )  return;    << 308       if ( !outputPolygon.size() )  return;
611                                                << 309       
612       G4VoxelLimits simpleLimit2;                 310       G4VoxelLimits simpleLimit2;
613       simpleLimit2.AddLimit(kZAxis,-kInfinity,    311       simpleLimit2.AddLimit(kZAxis,-kInfinity,pVoxelLimit.GetMaxZExtent());
614       ClipPolygonToSimpleLimits(outputPolygon,    312       ClipPolygonToSimpleLimits(outputPolygon,pPolygon,simpleLimit2);
615                                                   313 
616       // Return after final clip - no cleanup     314       // Return after final clip - no cleanup
617     }                                             315     }
618   }                                               316   }
619 }                                                 317 }
620                                                   318 
621 //////////////////////////////////////////////    319 ////////////////////////////////////////////////////////////////////////////
622 //                                                320 //
623 // pVoxelLimits must be only limited along one    321 // pVoxelLimits must be only limited along one axis, and either the maximum
624 // along the axis must be +kInfinity, or the m    322 // along the axis must be +kInfinity, or the minimum -kInfinity
625                                                   323 
626 void                                           << 324 void G4VSolid::ClipPolygonToSimpleLimits( G4ThreeVectorList& pPolygon,
627 G4VSolid::ClipPolygonToSimpleLimits( G4ThreeVe << 325                   G4ThreeVectorList& outputPolygon,
628                                      G4ThreeVe << 326             const G4VoxelLimits& pVoxelLimit       ) const
629                                const G4VoxelLi << 
630 {                                                 327 {
631   G4int i;                                        328   G4int i;
632   auto  noVertices = (G4int)pPolygon.size();   << 329   G4int noVertices=pPolygon.size();
633   G4ThreeVector vEnd,vStart;                      330   G4ThreeVector vEnd,vStart;
634                                                   331 
635   for (i = 0 ; i < noVertices ; ++i )          << 332   for (i = 0 ; i < noVertices ; i++ )
636   {                                               333   {
637     vStart = pPolygon[i];                         334     vStart = pPolygon[i];
                                                   >> 335     // G4cout << "i = " << i << G4endl;
638     if ( i == noVertices-1 )    vEnd = pPolygo    336     if ( i == noVertices-1 )    vEnd = pPolygon[0];
639     else                        vEnd = pPolygo    337     else                        vEnd = pPolygon[i+1];
640                                                << 338     
641     if ( pVoxelLimit.Inside(vStart) )             339     if ( pVoxelLimit.Inside(vStart) )
642     {                                             340     {
643       if (pVoxelLimit.Inside(vEnd))               341       if (pVoxelLimit.Inside(vEnd))
644       {                                           342       {
645         // vStart and vEnd inside -> output en    343         // vStart and vEnd inside -> output end point
646         //                                        344         //
647         outputPolygon.push_back(vEnd);            345         outputPolygon.push_back(vEnd);
648       }                                           346       }
649       else                                        347       else
650       {                                           348       {
651         // vStart inside, vEnd outside -> outp    349         // vStart inside, vEnd outside -> output crossing point
652         //                                        350         //
                                                   >> 351   // G4cout << "vStart inside, vEnd outside" << G4endl;
653         pVoxelLimit.ClipToLimits(vStart,vEnd);    352         pVoxelLimit.ClipToLimits(vStart,vEnd);
654         outputPolygon.push_back(vEnd);         << 353   outputPolygon.push_back(vEnd);
655       }                                        << 354       }     
656     }                                             355     }
657     else                                          356     else
658     {                                             357     {
659       if (pVoxelLimit.Inside(vEnd))               358       if (pVoxelLimit.Inside(vEnd))
660       {                                           359       {
661         // vStart outside, vEnd inside -> outp    360         // vStart outside, vEnd inside -> output inside section
662         //                                        361         //
                                                   >> 362   // G4cout << "vStart outside, vEnd inside" << G4endl;
663         pVoxelLimit.ClipToLimits(vStart,vEnd);    363         pVoxelLimit.ClipToLimits(vStart,vEnd);
664         outputPolygon.push_back(vStart);       << 364   outputPolygon.push_back(vStart);
665         outputPolygon.push_back(vEnd);         << 365   outputPolygon.push_back(vEnd);  
666       }                                           366       }
667       else  // Both point outside -> no output    367       else  // Both point outside -> no output
668       {                                           368       {
669         // outputPolygon.push_back(vStart);    << 369   // outputPolygon.push_back(vStart);
670         // outputPolygon.push_back(vEnd);      << 370   // outputPolygon.push_back(vEnd);  
671       }                                           371       }
672     }                                             372     }
673   }                                               373   }
674 }                                                 374 }
675                                                   375 
676 ////////////////////////////////////////////// << 376 const G4VSolid* G4VSolid::GetConstituentSolid(G4int no) const
677 //                                             << 377 { return 0; } 
678 // Throw exception (warning) for solids not im << 
679                                                   378 
680 void G4VSolid::BoundingLimits(G4ThreeVector& p << 379 G4VSolid* G4VSolid::GetConstituentSolid(G4int no)
681 {                                              << 380 { 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                                                   381 
689   pMin.set(-kInfinity,-kInfinity,-kInfinity);  << 382 const G4DisplacedSolid* G4VSolid::GetDisplacedSolidPtr() const
690   pMax.set( kInfinity, kInfinity, kInfinity);  << 383 { return 0; } 
691 }                                              << 
692                                                   384 
693 ////////////////////////////////////////////// << 385 G4DisplacedSolid* G4VSolid::GetDisplacedSolidPtr() 
694 //                                             << 386 { return 0; } 
695 // Get G4VisExtent - bounding box for graphics << 
696                                                   387 
697 G4VisExtent G4VSolid::GetExtent () const       << 388 G4VisExtent G4VSolid::GetExtent () const 
698 {                                                 389 {
699   G4VisExtent extent;                             390   G4VisExtent extent;
700   G4VoxelLimits voxelLimits;  // Defaults to "    391   G4VoxelLimits voxelLimits;  // Defaults to "infinite" limits.
701   G4AffineTransform affineTransform;              392   G4AffineTransform affineTransform;
702   G4double vmin, vmax;                            393   G4double vmin, vmax;
703   CalculateExtent(kXAxis,voxelLimits,affineTra    394   CalculateExtent(kXAxis,voxelLimits,affineTransform,vmin,vmax);
704   extent.SetXmin (vmin);                          395   extent.SetXmin (vmin);
705   extent.SetXmax (vmax);                          396   extent.SetXmax (vmax);
706   CalculateExtent(kYAxis,voxelLimits,affineTra    397   CalculateExtent(kYAxis,voxelLimits,affineTransform,vmin,vmax);
707   extent.SetYmin (vmin);                          398   extent.SetYmin (vmin);
708   extent.SetYmax (vmax);                          399   extent.SetYmax (vmax);
709   CalculateExtent(kZAxis,voxelLimits,affineTra    400   CalculateExtent(kZAxis,voxelLimits,affineTransform,vmin,vmax);
710   extent.SetZmin (vmin);                          401   extent.SetZmin (vmin);
711   extent.SetZmax (vmax);                          402   extent.SetZmax (vmax);
712   return extent;                                  403   return extent;
713 }                                                 404 }
714                                                   405 
715 G4Polyhedron* G4VSolid::CreatePolyhedron () co    406 G4Polyhedron* G4VSolid::CreatePolyhedron () const
716 {                                                 407 {
717   return nullptr;                              << 408   return 0;
718 }                                                 409 }
719                                                   410 
720 G4Polyhedron* G4VSolid::GetPolyhedron () const << 411 G4NURBS* G4VSolid::CreateNURBS () const
721 {                                                 412 {
722   return nullptr;                              << 413   return 0;
723 }                                                 414 }
724                                                   415