Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/geometry/solids/Boolean/src/G4BooleanSolid.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/solids/Boolean/src/G4BooleanSolid.cc (Version 11.3.0) and /geometry/solids/Boolean/src/G4BooleanSolid.cc (Version 10.7.p4)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 // Implementation of the base class for solids     26 // Implementation of the base class for solids created by Boolean 
 27 // operations between other solids                 27 // operations between other solids
 28 //                                                 28 //
 29 // 1998.09.10 V.Grichine - created                 29 // 1998.09.10 V.Grichine - created
 30 // -------------------------------------------     30 // --------------------------------------------------------------------
 31                                                    31 
 32 #include "G4BooleanSolid.hh"                       32 #include "G4BooleanSolid.hh"
 33 #include "G4VSolid.hh"                             33 #include "G4VSolid.hh"
 34 #include "G4DisplacedSolid.hh"                     34 #include "G4DisplacedSolid.hh"
 35 #include "G4ReflectedSolid.hh"                     35 #include "G4ReflectedSolid.hh"
 36 #include "G4ScaledSolid.hh"                        36 #include "G4ScaledSolid.hh"
 37 #include "G4Polyhedron.hh"                         37 #include "G4Polyhedron.hh"
 38 #include "HepPolyhedronProcessor.h"                38 #include "HepPolyhedronProcessor.h"
 39 #include "G4QuickRand.hh"                          39 #include "G4QuickRand.hh"
 40                                                    40 
 41 #include "G4AutoLock.hh"                           41 #include "G4AutoLock.hh"
 42                                                    42 
 43 namespace                                          43 namespace
 44 {                                                  44 {
 45   G4RecursiveMutex polyhedronMutex = G4MUTEX_I     45   G4RecursiveMutex polyhedronMutex = G4MUTEX_INITIALIZER;
 46 }                                                  46 }
 47                                                    47 
 48 G4VBooleanProcessor* G4BooleanSolid::fExternal << 
 49                                                << 
 50 //////////////////////////////////////////////     48 //////////////////////////////////////////////////////////////////
 51 //                                                 49 //
 52 // Constructor                                     50 // Constructor
 53                                                    51 
 54 G4BooleanSolid::G4BooleanSolid( const G4String     52 G4BooleanSolid::G4BooleanSolid( const G4String& pName,
 55                                 G4VSolid* pSol     53                                 G4VSolid* pSolidA ,
 56                                 G4VSolid* pSol     54                                 G4VSolid* pSolidB )
 57   : G4VSolid(pName), fPtrSolidA(pSolidA), fPtr     55   : G4VSolid(pName), fPtrSolidA(pSolidA), fPtrSolidB(pSolidB)
 58 {                                                  56 {
 59 }                                                  57 }
 60                                                    58 
 61 //////////////////////////////////////////////     59 //////////////////////////////////////////////////////////////////
 62 //                                                 60 //
 63 // Constructor                                     61 // Constructor
 64                                                    62 
 65 G4BooleanSolid::G4BooleanSolid( const G4String     63 G4BooleanSolid::G4BooleanSolid( const G4String& pName,
 66                                       G4VSolid     64                                       G4VSolid* pSolidA ,
 67                                       G4VSolid     65                                       G4VSolid* pSolidB ,
 68                                       G4Rotati     66                                       G4RotationMatrix* rotMatrix,
 69                                 const G4ThreeV     67                                 const G4ThreeVector& transVector )
 70   : G4VSolid(pName), createdDisplacedSolid(tru     68   : G4VSolid(pName), createdDisplacedSolid(true)
 71 {                                                  69 {
 72   fPtrSolidA = pSolidA ;                           70   fPtrSolidA = pSolidA ;
 73   fPtrSolidB = new G4DisplacedSolid("placedB",     71   fPtrSolidB = new G4DisplacedSolid("placedB",pSolidB,rotMatrix,transVector) ;
 74 }                                                  72 }
 75                                                    73 
 76 //////////////////////////////////////////////     74 //////////////////////////////////////////////////////////////////
 77 //                                                 75 //
 78 // Constructor                                     76 // Constructor
 79                                                    77 
 80 G4BooleanSolid::G4BooleanSolid( const G4String     78 G4BooleanSolid::G4BooleanSolid( const G4String& pName,
 81                                       G4VSolid     79                                       G4VSolid* pSolidA ,
 82                                       G4VSolid     80                                       G4VSolid* pSolidB ,
 83                                 const G4Transf     81                                 const G4Transform3D& transform )
 84   : G4VSolid(pName), createdDisplacedSolid(tru     82   : G4VSolid(pName), createdDisplacedSolid(true)
 85 {                                                  83 {
 86   fPtrSolidA = pSolidA ;                           84   fPtrSolidA = pSolidA ;
 87   fPtrSolidB = new G4DisplacedSolid("placedB",     85   fPtrSolidB = new G4DisplacedSolid("placedB",pSolidB,transform) ;
 88 }                                                  86 }
 89                                                    87 
 90 //////////////////////////////////////////////     88 ///////////////////////////////////////////////////////////////
 91 //                                                 89 //
 92 // Fake default constructor - sets only member     90 // Fake default constructor - sets only member data and allocates memory
 93 //                            for usage restri     91 //                            for usage restricted to object persistency.
 94                                                    92 
 95 G4BooleanSolid::G4BooleanSolid( __void__& a )      93 G4BooleanSolid::G4BooleanSolid( __void__& a )
 96   : G4VSolid(a)                                    94   : G4VSolid(a)
 97 {                                                  95 {
 98 }                                                  96 }
 99                                                    97 
100 //////////////////////////////////////////////     98 ///////////////////////////////////////////////////////////////
101 //                                                 99 //
102 // Destructor deletes transformation contents     100 // Destructor deletes transformation contents of the created displaced solid
103                                                   101 
104 G4BooleanSolid::~G4BooleanSolid()                 102 G4BooleanSolid::~G4BooleanSolid() 
105 {                                                 103 {
106   if(createdDisplacedSolid)                       104   if(createdDisplacedSolid)
107   {                                               105   {
108     ((G4DisplacedSolid*)fPtrSolidB)->CleanTran    106     ((G4DisplacedSolid*)fPtrSolidB)->CleanTransformations();
109   }                                               107   }
110   delete fpPolyhedron; fpPolyhedron = nullptr;    108   delete fpPolyhedron; fpPolyhedron = nullptr;
111 }                                                 109 }
112                                                   110 
113 //////////////////////////////////////////////    111 ///////////////////////////////////////////////////////////////
114 //                                                112 //
115 // Copy constructor                               113 // Copy constructor
116                                                   114 
117 G4BooleanSolid::G4BooleanSolid(const G4Boolean    115 G4BooleanSolid::G4BooleanSolid(const G4BooleanSolid& rhs)
118   : G4VSolid (rhs), fPtrSolidA(rhs.fPtrSolidA)    116   : G4VSolid (rhs), fPtrSolidA(rhs.fPtrSolidA), fPtrSolidB(rhs.fPtrSolidB),
119     fCubicVolume(rhs.fCubicVolume), fSurfaceAr << 117     fStatistics(rhs.fStatistics), fCubVolEpsilon(rhs.fCubVolEpsilon),
120     fCubVolStatistics(rhs.fCubVolStatistics),  << 118     fAreaAccuracy(rhs.fAreaAccuracy), fCubicVolume(rhs.fCubicVolume),
121     fAreaStatistics(rhs.fAreaStatistics),      << 119     fSurfaceArea(rhs.fSurfaceArea), fRebuildPolyhedron(false),
122     fCubVolEpsilon(rhs.fCubVolEpsilon),        << 120     fpPolyhedron(nullptr), createdDisplacedSolid(rhs.createdDisplacedSolid)
123     fAreaAccuracy(rhs.fAreaAccuracy),          << 
124     createdDisplacedSolid(rhs.createdDisplaced << 
125 {                                                 121 {
126   fPrimitives.resize(0); fPrimitivesSurfaceAre    122   fPrimitives.resize(0); fPrimitivesSurfaceArea = 0.;
127 }                                                 123 }
128                                                   124 
129 //////////////////////////////////////////////    125 ///////////////////////////////////////////////////////////////
130 //                                                126 //
131 // Assignment operator                            127 // Assignment operator
132                                                   128 
133 G4BooleanSolid& G4BooleanSolid::operator = (co    129 G4BooleanSolid& G4BooleanSolid::operator = (const G4BooleanSolid& rhs) 
134 {                                                 130 {
135   // Check assignment to self                     131   // Check assignment to self
136   //                                              132   //
137   if (this == &rhs)  { return *this; }            133   if (this == &rhs)  { return *this; }
138                                                   134 
139   // Copy base class data                         135   // Copy base class data
140   //                                              136   //
141   G4VSolid::operator=(rhs);                       137   G4VSolid::operator=(rhs);
142                                                   138 
143   // Copy data                                    139   // Copy data
144   //                                              140   //
145   fPtrSolidA= rhs.fPtrSolidA; fPtrSolidB= rhs.    141   fPtrSolidA= rhs.fPtrSolidA; fPtrSolidB= rhs.fPtrSolidB;
146   fCubicVolume= rhs.fCubicVolume; fSurfaceArea << 142   fStatistics= rhs.fStatistics; fCubVolEpsilon= rhs.fCubVolEpsilon;
147   fCubVolStatistics = rhs.fCubVolStatistics; f << 143   fAreaAccuracy= rhs.fAreaAccuracy; fCubicVolume= rhs.fCubicVolume;
148   fAreaStatistics = rhs.fAreaStatistics; fArea << 144   fSurfaceArea= rhs.fSurfaceArea;
149   createdDisplacedSolid= rhs.createdDisplacedS    145   createdDisplacedSolid= rhs.createdDisplacedSolid;
150                                                << 
151   fRebuildPolyhedron = false;                     146   fRebuildPolyhedron = false;
152   delete fpPolyhedron; fpPolyhedron = nullptr;    147   delete fpPolyhedron; fpPolyhedron = nullptr;
153   fPrimitives.resize(0); fPrimitivesSurfaceAre    148   fPrimitives.resize(0); fPrimitivesSurfaceArea = 0.;
154                                                   149 
155   return *this;                                   150   return *this;
156 }                                                 151 }  
157                                                   152 
158 //////////////////////////////////////////////    153 ///////////////////////////////////////////////////////////////
159 //                                                154 //
160 // If solid is made up from a Boolean operatio    155 // If solid is made up from a Boolean operation of two solids,
161 // return the corresponding solid (for no=0 an    156 // return the corresponding solid (for no=0 and 1)
162 // If the solid is not a "Boolean", return 0      157 // If the solid is not a "Boolean", return 0
163                                                   158 
164 const G4VSolid* G4BooleanSolid::GetConstituent    159 const G4VSolid* G4BooleanSolid::GetConstituentSolid(G4int no) const
165 {                                                 160 {
166   const G4VSolid* subSolid = nullptr;             161   const G4VSolid* subSolid = nullptr;
167   if( no == 0 )                                   162   if( no == 0 )  
168     subSolid = fPtrSolidA;                        163     subSolid = fPtrSolidA;
169   else if( no == 1 )                              164   else if( no == 1 ) 
170     subSolid = fPtrSolidB;                        165     subSolid = fPtrSolidB;
171   else                                            166   else
172   {                                               167   {
173     DumpInfo();                                   168     DumpInfo();
174     G4Exception("G4BooleanSolid::GetConstituen    169     G4Exception("G4BooleanSolid::GetConstituentSolid()",
175                 "GeomSolids0002", FatalExcepti    170                 "GeomSolids0002", FatalException, "Invalid solid index.");
176   }                                               171   }
177   return subSolid;                                172   return subSolid;
178 }                                                 173 }
179                                                   174 
180 //////////////////////////////////////////////    175 ///////////////////////////////////////////////////////////////
181 //                                                176 //
182 // If solid is made up from a Boolean operatio    177 // If solid is made up from a Boolean operation of two solids,
183 // return the corresponding solid (for no=0 an    178 // return the corresponding solid (for no=0 and 1)
184 // If the solid is not a "Boolean", return 0      179 // If the solid is not a "Boolean", return 0
185                                                   180 
186 G4VSolid* G4BooleanSolid::GetConstituentSolid(    181 G4VSolid* G4BooleanSolid::GetConstituentSolid(G4int no)
187 {                                                 182 {
188   G4VSolid* subSolid = nullptr;                   183   G4VSolid* subSolid = nullptr;
189   if( no == 0 )                                   184   if( no == 0 )  
190     subSolid = fPtrSolidA;                        185     subSolid = fPtrSolidA;
191   else if( no == 1 )                              186   else if( no == 1 ) 
192     subSolid = fPtrSolidB;                        187     subSolid = fPtrSolidB;
193   else                                            188   else
194   {                                               189   {
195     DumpInfo();                                   190     DumpInfo();
196     G4Exception("G4BooleanSolid::GetConstituen    191     G4Exception("G4BooleanSolid::GetConstituentSolid()",
197                 "GeomSolids0002", FatalExcepti    192                 "GeomSolids0002", FatalException, "Invalid solid index.");
198   }                                               193   }
199   return subSolid;                                194   return subSolid;
200 }                                                 195 }
201                                                   196 
202 //////////////////////////////////////////////    197 //////////////////////////////////////////////////////////////////////////
203 //                                                198 //
204 // Returns entity type                            199 // Returns entity type
205                                                   200 
206 G4GeometryType G4BooleanSolid::GetEntityType()    201 G4GeometryType G4BooleanSolid::GetEntityType() const 
207 {                                                 202 {
208   return {"G4BooleanSolid"};                   << 203   return G4String("G4BooleanSolid");
209 }                                              << 
210                                                << 
211 ////////////////////////////////////////////// << 
212 //                                             << 
213 // Set number of random points to be used for  << 
214                                                << 
215 void G4BooleanSolid::SetCubVolStatistics(G4int << 
216 {                                              << 
217   if (st != fCubVolStatistics) { fCubicVolume  << 
218   fCubVolStatistics = st;                      << 
219                                                << 
220   // Propagate st to all components of the 1st << 
221   if (fPtrSolidA->GetNumOfConstituents() > 1)  << 
222   {                                            << 
223     G4VSolid* ptr = fPtrSolidA;                << 
224     while(true)                                << 
225     {                                          << 
226       G4String type = ptr->GetEntityType();    << 
227       if (type == "G4DisplacedSolid")          << 
228       {                                        << 
229         ptr = ((G4DisplacedSolid*)ptr)->GetCon << 
230         continue;                              << 
231       }                                        << 
232       if (type == "G4ReflectedSolid")          << 
233       {                                        << 
234         ptr = ((G4ReflectedSolid*)ptr)->GetCon << 
235         continue;                              << 
236       }                                        << 
237       if (type == "G4ScaledSolid")             << 
238       {                                        << 
239         ptr = ((G4ScaledSolid*)ptr)->GetUnscal << 
240         continue;                              << 
241       }                                        << 
242       if (type != "G4MultiUnion") // G4MultiUn << 
243       {                                        << 
244   ((G4BooleanSolid*)ptr)->SetCubVolStatistics( << 
245       }                                        << 
246       break;                                   << 
247     }                                          << 
248   }                                            << 
249                                                << 
250   // Propagate st to all components of the 2nd << 
251   if (fPtrSolidB->GetNumOfConstituents() > 1)  << 
252   {                                            << 
253     G4VSolid* ptr = fPtrSolidB;                << 
254     while(true)                                << 
255     {                                          << 
256       G4String type = ptr->GetEntityType();    << 
257       if (type == "G4DisplacedSolid")          << 
258       {                                        << 
259         ptr = ((G4DisplacedSolid*)ptr)->GetCon << 
260         continue;                              << 
261       }                                        << 
262       if (type == "G4ReflectedSolid")          << 
263       {                                        << 
264         ptr = ((G4ReflectedSolid*)ptr)->GetCon << 
265         continue;                              << 
266       }                                        << 
267       if (type == "G4ScaledSolid")             << 
268       {                                        << 
269         ptr = ((G4ScaledSolid*)ptr)->GetUnscal << 
270         continue;                              << 
271       }                                        << 
272       if (type != "G4MultiUnion") // G4MultiUn << 
273       {                                        << 
274   ((G4BooleanSolid*)ptr)->SetCubVolStatistics( << 
275       }                                        << 
276       break;                                   << 
277     }                                          << 
278   }                                            << 
279 }                                              << 
280                                                << 
281 ////////////////////////////////////////////// << 
282 //                                             << 
283 // Set epsilon for computing cubic volume      << 
284                                                << 
285 void G4BooleanSolid::SetCubVolEpsilon(G4double << 
286 {                                              << 
287   if (ep != fCubVolEpsilon) { fCubicVolume = - << 
288   fCubVolEpsilon = ep;                         << 
289                                                << 
290   // Propagate ep to all components of the 1st << 
291   if (fPtrSolidA->GetNumOfConstituents() > 1)  << 
292   {                                            << 
293     G4VSolid* ptr = fPtrSolidA;                << 
294     while(true)                                << 
295     {                                          << 
296       G4String type = ptr->GetEntityType();    << 
297       if (type == "G4DisplacedSolid")          << 
298       {                                        << 
299         ptr = ((G4DisplacedSolid*)ptr)->GetCon << 
300         continue;                              << 
301       }                                        << 
302       if (type == "G4ReflectedSolid")          << 
303       {                                        << 
304         ptr = ((G4ReflectedSolid*)ptr)->GetCon << 
305         continue;                              << 
306       }                                        << 
307       if (type == "G4ScaledSolid")             << 
308       {                                        << 
309         ptr = ((G4ScaledSolid*)ptr)->GetUnscal << 
310         continue;                              << 
311       }                                        << 
312       if (type != "G4MultiUnion") // G4MultiUn << 
313       {                                        << 
314   ((G4BooleanSolid*)ptr)->SetCubVolEpsilon(ep) << 
315       }                                        << 
316       break;                                   << 
317     }                                          << 
318   }                                            << 
319                                                << 
320   // Propagate ep to all components of the 2nd << 
321   if (fPtrSolidB->GetNumOfConstituents() > 1)  << 
322   {                                            << 
323     G4VSolid* ptr = fPtrSolidB;                << 
324     while(true)                                << 
325     {                                          << 
326       G4String type = ptr->GetEntityType();    << 
327       if (type == "G4DisplacedSolid")          << 
328       {                                        << 
329         ptr = ((G4DisplacedSolid*)ptr)->GetCon << 
330         continue;                              << 
331       }                                        << 
332       if (type == "G4ReflectedSolid")          << 
333       {                                        << 
334         ptr = ((G4ReflectedSolid*)ptr)->GetCon << 
335         continue;                              << 
336       }                                        << 
337       if (type == "G4ScaledSolid")             << 
338       {                                        << 
339         ptr = ((G4ScaledSolid*)ptr)->GetUnscal << 
340         continue;                              << 
341       }                                        << 
342       if (type != "G4MultiUnion") // G4MultiUn << 
343       {                                        << 
344   ((G4BooleanSolid*)ptr)->SetCubVolEpsilon(ep) << 
345       }                                        << 
346       break;                                   << 
347     }                                          << 
348   }                                            << 
349 }                                                 204 }
350                                                   205 
351 //////////////////////////////////////////////    206 //////////////////////////////////////////////////////////////////////////
352 //                                                207 //
353 // Stream object contents to an output stream     208 // Stream object contents to an output stream
354                                                   209 
355 std::ostream& G4BooleanSolid::StreamInfo(std::    210 std::ostream& G4BooleanSolid::StreamInfo(std::ostream& os) const
356 {                                                 211 {
357   os << "-------------------------------------    212   os << "-----------------------------------------------------------\n"
358      << "    *** Dump for Boolean solid - " <<    213      << "    *** Dump for Boolean solid - " << GetName() << " ***\n"
359      << "    =================================    214      << "    ===================================================\n"
360      << " Solid type: " << GetEntityType() <<     215      << " Solid type: " << GetEntityType() << "\n"
361      << " Parameters of constituent solids: \n    216      << " Parameters of constituent solids: \n"
362      << "=====================================    217      << "===========================================================\n";
363   fPtrSolidA->StreamInfo(os);                     218   fPtrSolidA->StreamInfo(os);
364   fPtrSolidB->StreamInfo(os);                     219   fPtrSolidB->StreamInfo(os);
365   os << "=====================================    220   os << "===========================================================\n";
366                                                   221 
367   return os;                                      222   return os;
368 }                                                 223 }
369                                                   224 
370 //////////////////////////////////////////////    225 //////////////////////////////////////////////////////////////////////////
371 //                                                226 //
372 // Creates list of constituent primitives of a    227 // Creates list of constituent primitives of and their placements
373                                                   228 
374 void G4BooleanSolid::GetListOfPrimitives(         229 void G4BooleanSolid::GetListOfPrimitives(
375        std::vector<std::pair<G4VSolid*,G4Trans    230        std::vector<std::pair<G4VSolid*,G4Transform3D>>& primitives,
376        const G4Transform3D& curPlacement) cons    231        const G4Transform3D& curPlacement) const
377 {                                                 232 {
378   G4Transform3D transform;                        233   G4Transform3D transform;
379   G4VSolid* solid;                                234   G4VSolid* solid;
380   G4String type;                                  235   G4String type;
381                                                   236 
382   // Repeat two times, first time for fPtrSoli    237   // Repeat two times, first time for fPtrSolidA and then for fPtrSolidB
383   //                                              238   //
384   for (auto i=0; i<2; ++i)                        239   for (auto i=0; i<2; ++i)
385   {                                               240   {
386     transform = curPlacement;                     241     transform = curPlacement;
387     solid     = (i == 0) ? fPtrSolidA : fPtrSo    242     solid     = (i == 0) ? fPtrSolidA : fPtrSolidB;
388     type      = solid->GetEntityType();           243     type      = solid->GetEntityType();
389                                                   244 
390     // While current solid is a trasformed sol    245     // While current solid is a trasformed solid just modify transform
391     //                                            246     //
392     while (type == "G4DisplacedSolid" ||          247     while (type == "G4DisplacedSolid" ||
393            type == "G4ReflectedSolid" ||          248            type == "G4ReflectedSolid" ||
394            type == "G4ScaledSolid")               249            type == "G4ScaledSolid")
395     {                                             250     {
396       if (type == "G4DisplacedSolid")             251       if (type == "G4DisplacedSolid")
397       {                                           252       {
398         transform = transform * G4Transform3D(    253         transform = transform * G4Transform3D(
399                     ((G4DisplacedSolid*)solid)    254                     ((G4DisplacedSolid*)solid)->GetObjectRotation(),
400                     ((G4DisplacedSolid*)solid)    255                     ((G4DisplacedSolid*)solid)->GetObjectTranslation());
401         solid     = ((G4DisplacedSolid*)solid)    256         solid     = ((G4DisplacedSolid*)solid)->GetConstituentMovedSolid();
402       }                                           257       }
403       else if (type == "G4ReflectedSolid")        258       else if (type == "G4ReflectedSolid")
404       {                                           259       {
405         transform= transform*((G4ReflectedSoli    260         transform= transform*((G4ReflectedSolid*)solid)->GetDirectTransform3D();
406         solid    = ((G4ReflectedSolid*)solid)-    261         solid    = ((G4ReflectedSolid*)solid)->GetConstituentMovedSolid();
407       }                                           262       }
408       else if (type == "G4ScaledSolid")           263       else if (type == "G4ScaledSolid")
409       {                                           264       {
410         transform = transform * ((G4ScaledSoli    265         transform = transform * ((G4ScaledSolid*)solid)->GetScaleTransform();
411         solid     = ((G4ScaledSolid*)solid)->G    266         solid     = ((G4ScaledSolid*)solid)->GetUnscaledSolid();
412       }                                           267       }
413       type  = solid->GetEntityType();             268       type  = solid->GetEntityType();
414     }                                             269     }
415                                                   270 
416     // If current solid is a Boolean solid the    271     // If current solid is a Boolean solid then continue recursion,
417     // otherwise add it to the list of primiti    272     // otherwise add it to the list of primitives
418     //                                            273     //
419     if (type == "G4UnionSolid"        ||          274     if (type == "G4UnionSolid"        ||
420         type == "G4SubtractionSolid"  ||          275         type == "G4SubtractionSolid"  ||
421         type == "G4IntersectionSolid" ||          276         type == "G4IntersectionSolid" ||
422         type == "G4BooleanSolid")                 277         type == "G4BooleanSolid")
423     {                                             278     {
424       ((G4BooleanSolid *)solid)->GetListOfPrim    279       ((G4BooleanSolid *)solid)->GetListOfPrimitives(primitives,transform);
425     }                                             280     }
426     else                                          281     else
427     {                                             282     {
428       primitives.emplace_back(solid,transform) << 283       primitives.push_back(std::pair<G4VSolid*,G4Transform3D>(solid,transform));
429     }                                             284     }
430   }                                               285   }
431 }                                                 286 }
432                                                   287 
433 //////////////////////////////////////////////    288 //////////////////////////////////////////////////////////////////////////
434 //                                                289 //
435 // Returns a point (G4ThreeVector) randomly an    290 // Returns a point (G4ThreeVector) randomly and uniformly selected
436 // on the surface of the solid                    291 // on the surface of the solid
437                                                   292 
438 G4ThreeVector G4BooleanSolid::GetPointOnSurfac    293 G4ThreeVector G4BooleanSolid::GetPointOnSurface() const
439 {                                                 294 {
440   std::size_t nprims = fPrimitives.size();     << 295   size_t nprims = fPrimitives.size();
441   std::pair<G4VSolid *, G4Transform3D> prim;      296   std::pair<G4VSolid *, G4Transform3D> prim;
442                                                   297 
443   // Get list of primitives and find the total    298   // Get list of primitives and find the total area of their surfaces
444   //                                              299   //
445   if (nprims == 0)                                300   if (nprims == 0)
446   {                                               301   {
447     GetListOfPrimitives(fPrimitives, G4Transfo    302     GetListOfPrimitives(fPrimitives, G4Transform3D());
448     nprims = fPrimitives.size();                  303     nprims = fPrimitives.size();
449     fPrimitivesSurfaceArea = 0.;                  304     fPrimitivesSurfaceArea = 0.;
450     for (std::size_t i=0; i<nprims; ++i)       << 305     for (size_t i=0; i<nprims; ++i)
451     {                                             306     {
452       fPrimitivesSurfaceArea += fPrimitives[i]    307       fPrimitivesSurfaceArea += fPrimitives[i].first->GetSurfaceArea();
453     }                                             308     }
454   }                                               309   }
455                                                   310 
456   // Select random primitive, get random point    311   // Select random primitive, get random point on its surface and
457   // check that the point belongs to the surfa    312   // check that the point belongs to the surface of the solid
458   //                                              313   //
459   G4ThreeVector p;                                314   G4ThreeVector p;
460   for (std::size_t k=0; k<100000; ++k) // try  << 315   for (size_t k=0; k<100000; ++k) // try 100k times
461   {                                               316   {
462      G4double rand = fPrimitivesSurfaceArea *     317      G4double rand = fPrimitivesSurfaceArea * G4QuickRand();
463      G4double area = 0.;                          318      G4double area = 0.;
464      for (std::size_t i=0; i<nprims; ++i)      << 319      for (size_t i=0; i<nprims; ++i)
465      {                                            320      {
466        prim  = fPrimitives[i];                    321        prim  = fPrimitives[i];
467        area += prim.first->GetSurfaceArea();      322        area += prim.first->GetSurfaceArea();
468        if (rand < area) break;                    323        if (rand < area) break;
469      }                                            324      }
470      p = prim.first->GetPointOnSurface();         325      p = prim.first->GetPointOnSurface();
471      p = prim.second * G4Point3D(p);              326      p = prim.second * G4Point3D(p);
472      if (Inside(p) == kSurface) return p;         327      if (Inside(p) == kSurface) return p;
473   }                                               328   }
474   std::ostringstream message;                     329   std::ostringstream message;
475   message << "Solid - " << GetName() << "\n"      330   message << "Solid - " << GetName() << "\n"
476           << "All 100k attempts to generate a     331           << "All 100k attempts to generate a point on the surface have failed!\n"
477           << "The solid created may be an inva    332           << "The solid created may be an invalid Boolean construct!";
478   G4Exception("G4BooleanSolid::GetPointOnSurfa    333   G4Exception("G4BooleanSolid::GetPointOnSurface()",
479               "GeomSolids1001", JustWarning, m    334               "GeomSolids1001", JustWarning, message);
480   return p;                                       335   return p;
481 }                                                 336 }
482                                                   337 
483 //////////////////////////////////////////////    338 //////////////////////////////////////////////////////////////////////////
484 //                                                339 //
485 // Return total number of constituents used fo << 
486                                                << 
487 G4int G4BooleanSolid::GetNumOfConstituents() c << 
488 {                                              << 
489   return (fPtrSolidA->GetNumOfConstituents() + << 
490 }                                              << 
491                                                << 
492 ////////////////////////////////////////////// << 
493 //                                             << 
494 // Return true if the resulting solid has only << 
495                                                << 
496 G4bool G4BooleanSolid::IsFaceted() const       << 
497 {                                              << 
498   return (fPtrSolidA->IsFaceted() && fPtrSolid << 
499 }                                              << 
500                                                << 
501 ////////////////////////////////////////////// << 
502 //                                             << 
503 // Returns polyhedron for visualization           340 // Returns polyhedron for visualization
504                                                   341 
505 G4Polyhedron* G4BooleanSolid::GetPolyhedron ()    342 G4Polyhedron* G4BooleanSolid::GetPolyhedron () const
506 {                                                 343 {
507   if (fpPolyhedron == nullptr ||                  344   if (fpPolyhedron == nullptr ||
508       fRebuildPolyhedron ||                       345       fRebuildPolyhedron ||
509       fpPolyhedron->GetNumberOfRotationStepsAt    346       fpPolyhedron->GetNumberOfRotationStepsAtTimeOfCreation() !=
510       fpPolyhedron->GetNumberOfRotationSteps()    347       fpPolyhedron->GetNumberOfRotationSteps())
511     {                                             348     {
512       G4RecursiveAutoLock l(&polyhedronMutex);    349       G4RecursiveAutoLock l(&polyhedronMutex);
513       delete fpPolyhedron;                        350       delete fpPolyhedron;
514       fpPolyhedron = CreatePolyhedron();          351       fpPolyhedron = CreatePolyhedron();
515       fRebuildPolyhedron = false;                 352       fRebuildPolyhedron = false;
516       l.unlock();                                 353       l.unlock();
517     }                                             354     }
518   return fpPolyhedron;                            355   return fpPolyhedron;
519 }                                                 356 }
520                                                   357 
521 //////////////////////////////////////////////    358 //////////////////////////////////////////////////////////////////////////
522 //                                                359 //
523 // Stacks polyhedra for processing. Returns to    360 // Stacks polyhedra for processing. Returns top polyhedron.
524                                                   361 
525 G4Polyhedron*                                     362 G4Polyhedron*
526 G4BooleanSolid::StackPolyhedron(HepPolyhedronP    363 G4BooleanSolid::StackPolyhedron(HepPolyhedronProcessor& processor,
527                                 const G4VSolid    364                                 const G4VSolid* solid) const
528 {                                                 365 {
529   HepPolyhedronProcessor::Operation operation;    366   HepPolyhedronProcessor::Operation operation;
530   const G4String& type = solid->GetEntityType(    367   const G4String& type = solid->GetEntityType();
531   if (type == "G4UnionSolid")                     368   if (type == "G4UnionSolid")
532     { operation = HepPolyhedronProcessor::UNIO    369     { operation = HepPolyhedronProcessor::UNION; }
533   else if (type == "G4IntersectionSolid")         370   else if (type == "G4IntersectionSolid")
534     { operation = HepPolyhedronProcessor::INTE    371     { operation = HepPolyhedronProcessor::INTERSECTION; }
535   else if (type == "G4SubtractionSolid")          372   else if (type == "G4SubtractionSolid")
536     { operation = HepPolyhedronProcessor::SUBT    373     { operation = HepPolyhedronProcessor::SUBTRACTION; }
537   else                                            374   else
538   {                                               375   {
539     std::ostringstream message;                   376     std::ostringstream message;
540     message << "Solid - " << solid->GetName()     377     message << "Solid - " << solid->GetName()
541             << " - Unrecognised composite soli    378             << " - Unrecognised composite solid" << G4endl
542             << " Returning NULL !";               379             << " Returning NULL !";
543     G4Exception("StackPolyhedron()", "GeomSoli    380     G4Exception("StackPolyhedron()", "GeomSolids1001", JustWarning, message);
544     return nullptr;                               381     return nullptr;
545   }                                               382   }
546                                                   383 
547   G4Polyhedron* top = nullptr;                    384   G4Polyhedron* top = nullptr;
548   const G4VSolid* solidA = solid->GetConstitue    385   const G4VSolid* solidA = solid->GetConstituentSolid(0);
549   const G4VSolid* solidB = solid->GetConstitue    386   const G4VSolid* solidB = solid->GetConstituentSolid(1);
550                                                   387 
551   if (solidA->GetConstituentSolid(0) != nullpt    388   if (solidA->GetConstituentSolid(0) != nullptr)
552   {                                               389   {
553     top = StackPolyhedron(processor, solidA);     390     top = StackPolyhedron(processor, solidA);
554   }                                               391   }
555   else                                            392   else
556   {                                               393   {
557     top = solidA->GetPolyhedron();                394     top = solidA->GetPolyhedron();
558   }                                               395   }
559   G4Polyhedron* operand = solidB->GetPolyhedro    396   G4Polyhedron* operand = solidB->GetPolyhedron();
560   if (operand != nullptr)                         397   if (operand != nullptr)
561   {                                               398   {
562     processor.push_back (operation, *operand);    399     processor.push_back (operation, *operand);
563   }                                               400   }
564   else                                            401   else
565   {                                               402   {
566     std::ostringstream message;                   403     std::ostringstream message;
567     message << "Solid - " << solid->GetName()     404     message << "Solid - " << solid->GetName()
568             << " - No G4Polyhedron for Boolean    405             << " - No G4Polyhedron for Boolean component";
569     G4Exception("G4BooleanSolid::StackPolyhedr    406     G4Exception("G4BooleanSolid::StackPolyhedron()",
570                 "GeomSolids2001", JustWarning,    407                 "GeomSolids2001", JustWarning, message);
571   }                                               408   }
572                                                   409 
573   return top;                                     410   return top;
574 }                                              << 
575                                                << 
576                                                << 
577 ////////////////////////////////////////////// << 
578 //                                             << 
579 // Estimate Cubic Volume (capacity) and cache  << 
580                                                << 
581 G4double G4BooleanSolid::GetCubicVolume()      << 
582 {                                              << 
583   if(fCubicVolume < 0.)                        << 
584   {                                            << 
585     fCubicVolume = EstimateCubicVolume(fCubVol << 
586   }                                            << 
587   return fCubicVolume;                         << 
588 }                                              << 
589                                                << 
590 ////////////////////////////////////////////// << 
591 //                                             << 
592 // Set external Boolean processor.             << 
593                                                << 
594 void                                           << 
595 G4BooleanSolid::SetExternalBooleanProcessor(G4 << 
596 {                                              << 
597   fExternalBoolProcessor = extProcessor;       << 
598 }                                              << 
599                                                << 
600 ////////////////////////////////////////////// << 
601 //                                             << 
602 // Get external Boolean processor.             << 
603                                                << 
604 G4VBooleanProcessor* G4BooleanSolid::GetExtern << 
605 {                                              << 
606   return fExternalBoolProcessor;               << 
607 }                                                 411 }
608                                                   412