| Geant4 Cross Reference |
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 fCubicVolume(rhs.fCubicVolume), fStatistics(rhs.fStatistics),
120 fCubVolStatistics(rhs.fCubVolStatistics), << 118 fCubVolEpsilon(rhs.fCubVolEpsilon), fAreaAccuracy(rhs.fAreaAccuracy),
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 } 411 }
575 412
576 413
577 ////////////////////////////////////////////// 414 //////////////////////////////////////////////////////////////////////////
578 // 415 //
579 // Estimate Cubic Volume (capacity) and cache << 416 // Estimate Cubic Volume (capacity) and store it for reuse.
580 417
581 G4double G4BooleanSolid::GetCubicVolume() 418 G4double G4BooleanSolid::GetCubicVolume()
582 { 419 {
583 if(fCubicVolume < 0.) 420 if(fCubicVolume < 0.)
584 { 421 {
585 fCubicVolume = EstimateCubicVolume(fCubVol << 422 fCubicVolume = EstimateCubicVolume(fStatistics,fCubVolEpsilon);
586 } 423 }
587 return fCubicVolume; 424 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 } 425 }
608 426