| 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 // G4VCSGfaceted implementation; a virtual cla << 26 // the GEANT4 collaboration.
27 // that is built entirely out of G4VCSGface fa << 27 //
>> 28 // By copying, distributing or modifying the Program (or any work
>> 29 // based on the Program) you indicate your acceptance of this statement,
>> 30 // and all its terms.
>> 31 //
>> 32 // $Id: G4VCSGfaceted.cc 84624 2014-10-17 09:56:00Z gcosmo $
>> 33 //
>> 34 //
>> 35 // --------------------------------------------------------------------
>> 36 // GEANT 4 class source file
>> 37 //
>> 38 //
>> 39 // G4VCSGfaceted.cc
>> 40 //
>> 41 // Implementation of the virtual class of a CSG type shape that is built
>> 42 // entirely out of G4VCSGface faces.
28 // 43 //
29 // Author: David C. Williams (davidw@scipp.ucs <<
30 // ------------------------------------------- 44 // --------------------------------------------------------------------
31 45
32 #include "G4VCSGfaceted.hh" 46 #include "G4VCSGfaceted.hh"
33 #include "G4VCSGface.hh" 47 #include "G4VCSGface.hh"
34 #include "G4SolidExtentList.hh" 48 #include "G4SolidExtentList.hh"
35 49
36 #include "G4VoxelLimits.hh" 50 #include "G4VoxelLimits.hh"
37 #include "G4AffineTransform.hh" 51 #include "G4AffineTransform.hh"
38 52
39 #include "Randomize.hh" 53 #include "Randomize.hh"
40 54
41 #include "G4Polyhedron.hh" 55 #include "G4Polyhedron.hh"
42 #include "G4VGraphicsScene.hh" 56 #include "G4VGraphicsScene.hh"
43 #include "G4VisExtent.hh" 57 #include "G4VisExtent.hh"
44 58
45 #include "G4AutoLock.hh" 59 #include "G4AutoLock.hh"
46 60
47 namespace 61 namespace
48 { 62 {
49 G4Mutex polyhedronMutex = G4MUTEX_INITIALIZE 63 G4Mutex polyhedronMutex = G4MUTEX_INITIALIZER;
50 } 64 }
51 65
52 // 66 //
53 // Constructor 67 // Constructor
54 // 68 //
55 G4VCSGfaceted::G4VCSGfaceted( const G4String& 69 G4VCSGfaceted::G4VCSGfaceted( const G4String& name )
56 : G4VSolid(name), 70 : G4VSolid(name),
>> 71 numFace(0), faces(0), fCubicVolume(0.), fSurfaceArea(0.),
>> 72 fRebuildPolyhedron(false), fpPolyhedron(0),
57 fStatistics(1000000), fCubVolEpsilon(0.001 73 fStatistics(1000000), fCubVolEpsilon(0.001), fAreaAccuracy(-1.)
58 { 74 {
59 } 75 }
60 76
61 77
62 // 78 //
63 // Fake default constructor - sets only member 79 // Fake default constructor - sets only member data and allocates memory
64 // for usage restri 80 // for usage restricted to object persistency.
65 // 81 //
66 G4VCSGfaceted::G4VCSGfaceted( __void__& a ) 82 G4VCSGfaceted::G4VCSGfaceted( __void__& a )
67 : G4VSolid(a), 83 : G4VSolid(a),
>> 84 numFace(0), faces(0), fCubicVolume(0.), fSurfaceArea(0.),
>> 85 fRebuildPolyhedron(false), fpPolyhedron(0),
68 fStatistics(1000000), fCubVolEpsilon(0.001 86 fStatistics(1000000), fCubVolEpsilon(0.001), fAreaAccuracy(-1.)
69 { 87 {
70 } 88 }
71 89
72 // 90 //
73 // Destructor 91 // Destructor
74 // 92 //
75 G4VCSGfaceted::~G4VCSGfaceted() 93 G4VCSGfaceted::~G4VCSGfaceted()
76 { 94 {
77 DeleteStuff(); 95 DeleteStuff();
78 delete fpPolyhedron; fpPolyhedron = nullptr; << 96 delete fpPolyhedron; fpPolyhedron = 0;
79 } 97 }
80 98
81 99
82 // 100 //
83 // Copy constructor 101 // Copy constructor
84 // 102 //
85 G4VCSGfaceted::G4VCSGfaceted( const G4VCSGface << 103 G4VCSGfaceted::G4VCSGfaceted( const G4VCSGfaceted &source )
86 : G4VSolid( source ) 104 : G4VSolid( source )
87 { 105 {
88 fStatistics = source.fStatistics; 106 fStatistics = source.fStatistics;
89 fCubVolEpsilon = source.fCubVolEpsilon; 107 fCubVolEpsilon = source.fCubVolEpsilon;
90 fAreaAccuracy = source.fAreaAccuracy; 108 fAreaAccuracy = source.fAreaAccuracy;
91 109
92 CopyStuff( source ); 110 CopyStuff( source );
93 } 111 }
94 112
95 113
96 // 114 //
97 // Assignment operator 115 // Assignment operator
98 // 116 //
99 G4VCSGfaceted& G4VCSGfaceted::operator=( const << 117 G4VCSGfaceted &G4VCSGfaceted::operator=( const G4VCSGfaceted &source )
100 { 118 {
101 if (&source == this) { return *this; } 119 if (&source == this) { return *this; }
102 120
103 // Copy base class data 121 // Copy base class data
104 // 122 //
105 G4VSolid::operator=(source); 123 G4VSolid::operator=(source);
106 124
107 // Copy data 125 // Copy data
108 // 126 //
109 fStatistics = source.fStatistics; 127 fStatistics = source.fStatistics;
110 fCubVolEpsilon = source.fCubVolEpsilon; 128 fCubVolEpsilon = source.fCubVolEpsilon;
111 fAreaAccuracy = source.fAreaAccuracy; 129 fAreaAccuracy = source.fAreaAccuracy;
112 130
113 DeleteStuff(); 131 DeleteStuff();
114 CopyStuff( source ); 132 CopyStuff( source );
115 133
116 return *this; 134 return *this;
117 } 135 }
118 136
119 137
120 // 138 //
121 // CopyStuff (protected) 139 // CopyStuff (protected)
122 // 140 //
123 // Copy the contents of source 141 // Copy the contents of source
124 // 142 //
125 void G4VCSGfaceted::CopyStuff( const G4VCSGfac << 143 void G4VCSGfaceted::CopyStuff( const G4VCSGfaceted &source )
126 { 144 {
127 numFace = source.numFace; 145 numFace = source.numFace;
128 if (numFace == 0) { return; } // odd, but 146 if (numFace == 0) { return; } // odd, but permissable?
129 147
130 faces = new G4VCSGface*[numFace]; 148 faces = new G4VCSGface*[numFace];
131 149
132 G4VCSGface **face = faces, 150 G4VCSGface **face = faces,
133 **sourceFace = source.faces; 151 **sourceFace = source.faces;
134 do // Loop checking, 13.08.2015, G.Cosmo << 152 do
135 { 153 {
136 *face = (*sourceFace)->Clone(); 154 *face = (*sourceFace)->Clone();
137 } while( ++sourceFace, ++face < faces+numFac 155 } while( ++sourceFace, ++face < faces+numFace );
138 fCubicVolume = source.fCubicVolume; 156 fCubicVolume = source.fCubicVolume;
139 fSurfaceArea = source.fSurfaceArea; 157 fSurfaceArea = source.fSurfaceArea;
140 fRebuildPolyhedron = false; 158 fRebuildPolyhedron = false;
141 fpPolyhedron = nullptr; << 159 fpPolyhedron = 0;
142 } 160 }
143 161
144 162
145 // 163 //
146 // DeleteStuff (protected) 164 // DeleteStuff (protected)
147 // 165 //
148 // Delete all allocated objects 166 // Delete all allocated objects
149 // 167 //
150 void G4VCSGfaceted::DeleteStuff() 168 void G4VCSGfaceted::DeleteStuff()
151 { 169 {
152 if (numFace != 0) << 170 if (numFace)
153 { 171 {
154 G4VCSGface **face = faces; 172 G4VCSGface **face = faces;
155 do // Loop checking, 13.08.2015, G.Cosm << 173 do
156 { 174 {
157 delete *face; 175 delete *face;
158 } while( ++face < faces + numFace ); 176 } while( ++face < faces + numFace );
159 177
160 delete [] faces; 178 delete [] faces;
161 } 179 }
162 delete fpPolyhedron; fpPolyhedron = nullptr; << 180 delete fpPolyhedron; fpPolyhedron = 0;
163 } 181 }
164 182
165 183
166 // 184 //
167 // CalculateExtent 185 // CalculateExtent
168 // 186 //
169 G4bool G4VCSGfaceted::CalculateExtent( const E 187 G4bool G4VCSGfaceted::CalculateExtent( const EAxis axis,
170 const G << 188 const G4VoxelLimits &voxelLimit,
171 const G << 189 const G4AffineTransform &transform,
172 G << 190 G4double &min,
173 G << 191 G4double &max ) const
174 { 192 {
175 G4SolidExtentList extentList( axis, voxelLi 193 G4SolidExtentList extentList( axis, voxelLimit );
176 194
177 // 195 //
178 // Loop over all faces, checking min/max ext 196 // Loop over all faces, checking min/max extent as we go.
179 // 197 //
180 G4VCSGface **face = faces; 198 G4VCSGface **face = faces;
181 do // Loop checking, 13.08.2015, G.Cosmo << 199 do
182 { 200 {
183 (*face)->CalculateExtent( axis, voxelLimit 201 (*face)->CalculateExtent( axis, voxelLimit, transform, extentList );
184 } while( ++face < faces + numFace ); 202 } while( ++face < faces + numFace );
185 203
186 // 204 //
187 // Return min/max value 205 // Return min/max value
188 // 206 //
189 return extentList.GetExtent( min, max ); 207 return extentList.GetExtent( min, max );
190 } 208 }
191 209
192 210
193 // 211 //
194 // Inside 212 // Inside
195 // 213 //
196 // It could be a good idea to override this vi 214 // It could be a good idea to override this virtual
197 // member to add first a simple test (such as 215 // member to add first a simple test (such as spherical
198 // test or whatnot) and to call this version o 216 // test or whatnot) and to call this version only if
199 // the simplier test fails. 217 // the simplier test fails.
200 // 218 //
201 EInside G4VCSGfaceted::Inside( const G4ThreeVe << 219 EInside G4VCSGfaceted::Inside( const G4ThreeVector &p ) const
202 { 220 {
203 EInside answer=kOutside; 221 EInside answer=kOutside;
204 G4VCSGface **face = faces; 222 G4VCSGface **face = faces;
205 G4double best = kInfinity; 223 G4double best = kInfinity;
206 do // Loop checking, 13.08.2015, G.Cosmo << 224 do
207 { 225 {
208 G4double distance; 226 G4double distance;
209 EInside result = (*face)->Inside( p, kCarT 227 EInside result = (*face)->Inside( p, kCarTolerance/2, &distance );
210 if (result == kSurface) { return kSurface; 228 if (result == kSurface) { return kSurface; }
211 if (distance < best) 229 if (distance < best)
212 { 230 {
213 best = distance; 231 best = distance;
214 answer = result; 232 answer = result;
215 } 233 }
216 } while( ++face < faces + numFace ); 234 } while( ++face < faces + numFace );
217 235
218 return answer; 236 return answer;
219 } 237 }
220 238
221 239
222 // 240 //
223 // SurfaceNormal 241 // SurfaceNormal
224 // 242 //
225 G4ThreeVector G4VCSGfaceted::SurfaceNormal( co 243 G4ThreeVector G4VCSGfaceted::SurfaceNormal( const G4ThreeVector& p ) const
226 { 244 {
227 G4ThreeVector answer; 245 G4ThreeVector answer;
228 G4VCSGface **face = faces; 246 G4VCSGface **face = faces;
229 G4double best = kInfinity; 247 G4double best = kInfinity;
230 do // Loop checking, 13.08.2015, G.Cosmo << 248 do
231 { 249 {
232 G4double distance = kInfinity; << 250 G4double distance;
233 G4ThreeVector normal = (*face)->Normal( p, 251 G4ThreeVector normal = (*face)->Normal( p, &distance );
234 if (distance < best) 252 if (distance < best)
235 { 253 {
236 best = distance; 254 best = distance;
237 answer = normal; 255 answer = normal;
238 } 256 }
239 } while( ++face < faces + numFace ); 257 } while( ++face < faces + numFace );
240 258
241 return answer; 259 return answer;
242 } 260 }
243 261
244 262
245 // 263 //
246 // DistanceToIn(p,v) 264 // DistanceToIn(p,v)
247 // 265 //
248 G4double G4VCSGfaceted::DistanceToIn( const G4 << 266 G4double G4VCSGfaceted::DistanceToIn( const G4ThreeVector &p,
249 const G4 << 267 const G4ThreeVector &v ) const
250 { 268 {
251 G4double distance = kInfinity; 269 G4double distance = kInfinity;
252 G4double distFromSurface = kInfinity; 270 G4double distFromSurface = kInfinity;
253 G4VCSGface **face = faces; 271 G4VCSGface **face = faces;
254 G4VCSGface *bestFace = *face; 272 G4VCSGface *bestFace = *face;
255 do // Loop checking, 13.08.2015, G.Cosmo << 273 do
256 { 274 {
257 G4double faceDistance, 275 G4double faceDistance,
258 faceDistFromSurface; 276 faceDistFromSurface;
259 G4ThreeVector faceNormal; 277 G4ThreeVector faceNormal;
260 G4bool faceAllBehind; 278 G4bool faceAllBehind;
261 if ((*face)->Intersect( p, v, false, kCarT 279 if ((*face)->Intersect( p, v, false, kCarTolerance/2,
262 faceDistance, faceDistFromSurf 280 faceDistance, faceDistFromSurface,
263 faceNormal, faceAllBehind ) ) 281 faceNormal, faceAllBehind ) )
264 { 282 {
265 // 283 //
266 // Intersecting face 284 // Intersecting face
267 // 285 //
268 if (faceDistance < distance) 286 if (faceDistance < distance)
269 { 287 {
270 distance = faceDistance; 288 distance = faceDistance;
271 distFromSurface = faceDistFromSurface; 289 distFromSurface = faceDistFromSurface;
272 bestFace = *face; 290 bestFace = *face;
273 if (distFromSurface <= 0) { return 0; 291 if (distFromSurface <= 0) { return 0; }
274 } 292 }
275 } 293 }
276 } while( ++face < faces + numFace ); 294 } while( ++face < faces + numFace );
277 295
278 if (distance < kInfinity && distFromSurface< 296 if (distance < kInfinity && distFromSurface<kCarTolerance/2)
279 { 297 {
280 if (bestFace->Distance(p,false) < kCarTole 298 if (bestFace->Distance(p,false) < kCarTolerance/2) { distance = 0; }
281 } 299 }
282 300
283 return distance; 301 return distance;
284 } 302 }
285 303
286 304
287 // 305 //
288 // DistanceToIn(p) 306 // DistanceToIn(p)
289 // 307 //
290 G4double G4VCSGfaceted::DistanceToIn( const G4 << 308 G4double G4VCSGfaceted::DistanceToIn( const G4ThreeVector &p ) const
291 { 309 {
292 return DistanceTo( p, false ); 310 return DistanceTo( p, false );
293 } 311 }
294 312
295 313
296 // 314 //
297 // DistanceToOut(p,v) 315 // DistanceToOut(p,v)
298 // 316 //
299 G4double G4VCSGfaceted::DistanceToOut( const G << 317 G4double G4VCSGfaceted::DistanceToOut( const G4ThreeVector &p,
300 const G << 318 const G4ThreeVector &v,
301 const G 319 const G4bool calcNorm,
302 G << 320 G4bool *validNorm,
303 G << 321 G4ThreeVector *n ) const
304 { 322 {
305 G4bool allBehind = true; 323 G4bool allBehind = true;
306 G4double distance = kInfinity; 324 G4double distance = kInfinity;
307 G4double distFromSurface = kInfinity; 325 G4double distFromSurface = kInfinity;
308 G4ThreeVector normal; 326 G4ThreeVector normal;
309 327
310 G4VCSGface **face = faces; 328 G4VCSGface **face = faces;
311 G4VCSGface *bestFace = *face; 329 G4VCSGface *bestFace = *face;
312 do // Loop checking, 13.08.2015, G.Cosmo << 330 do
313 { 331 {
314 G4double faceDistance, 332 G4double faceDistance,
315 faceDistFromSurface; 333 faceDistFromSurface;
316 G4ThreeVector faceNormal; 334 G4ThreeVector faceNormal;
317 G4bool faceAllBehind; 335 G4bool faceAllBehind;
318 if ((*face)->Intersect( p, v, true, kCarTo 336 if ((*face)->Intersect( p, v, true, kCarTolerance/2,
319 faceDistance, faceDistFromSurf 337 faceDistance, faceDistFromSurface,
320 faceNormal, faceAllBehind ) ) 338 faceNormal, faceAllBehind ) )
321 { 339 {
322 // 340 //
323 // Intersecting face 341 // Intersecting face
324 // 342 //
325 if ( (distance < kInfinity) || (!faceAll 343 if ( (distance < kInfinity) || (!faceAllBehind) ) { allBehind = false; }
326 if (faceDistance < distance) 344 if (faceDistance < distance)
327 { 345 {
328 distance = faceDistance; 346 distance = faceDistance;
329 distFromSurface = faceDistFromSurface; 347 distFromSurface = faceDistFromSurface;
330 normal = faceNormal; 348 normal = faceNormal;
331 bestFace = *face; 349 bestFace = *face;
332 if (distFromSurface <= 0.) { break; } << 350 if (distFromSurface <= 0) { break; }
333 } 351 }
334 } 352 }
335 } while( ++face < faces + numFace ); 353 } while( ++face < faces + numFace );
336 354
337 if (distance < kInfinity) 355 if (distance < kInfinity)
338 { 356 {
339 if (distFromSurface <= 0.) << 357 if (distFromSurface <= 0)
340 { 358 {
341 distance = 0.; << 359 distance = 0;
342 } 360 }
343 else if (distFromSurface<kCarTolerance/2) 361 else if (distFromSurface<kCarTolerance/2)
344 { 362 {
345 if (bestFace->Distance(p,true) < kCarTol << 363 if (bestFace->Distance(p,true) < kCarTolerance/2) { distance = 0; }
346 } 364 }
347 365
348 if (calcNorm) 366 if (calcNorm)
349 { 367 {
350 *validNorm = allBehind; 368 *validNorm = allBehind;
351 *n = normal; 369 *n = normal;
352 } 370 }
353 } 371 }
354 else 372 else
355 { 373 {
356 if (Inside(p) == kSurface) { distance = 0 << 374 if (Inside(p) == kSurface) { distance = 0; }
357 if (calcNorm) { *validNorm = false; } 375 if (calcNorm) { *validNorm = false; }
358 } 376 }
359 377
360 return distance; 378 return distance;
361 } 379 }
362 380
363 381
364 // 382 //
365 // DistanceToOut(p) 383 // DistanceToOut(p)
366 // 384 //
367 G4double G4VCSGfaceted::DistanceToOut( const G << 385 G4double G4VCSGfaceted::DistanceToOut( const G4ThreeVector &p ) const
368 { 386 {
369 return DistanceTo( p, true ); 387 return DistanceTo( p, true );
370 } 388 }
371 389
372 390
373 // 391 //
374 // DistanceTo 392 // DistanceTo
375 // 393 //
376 // Protected routine called by DistanceToIn an 394 // Protected routine called by DistanceToIn and DistanceToOut
377 // 395 //
378 G4double G4VCSGfaceted::DistanceTo( const G4Th << 396 G4double G4VCSGfaceted::DistanceTo( const G4ThreeVector &p,
379 const G4bo 397 const G4bool outgoing ) const
380 { 398 {
381 G4VCSGface **face = faces; 399 G4VCSGface **face = faces;
382 G4double best = kInfinity; 400 G4double best = kInfinity;
383 do // Loop checking, 13.08.2015, G.Cosmo << 401 do
384 { 402 {
385 G4double distance = (*face)->Distance( p, 403 G4double distance = (*face)->Distance( p, outgoing );
386 if (distance < best) { best = distance; } 404 if (distance < best) { best = distance; }
387 } while( ++face < faces + numFace ); 405 } while( ++face < faces + numFace );
388 406
389 return (best < 0.5*kCarTolerance) ? 0. : bes << 407 return (best < 0.5*kCarTolerance) ? 0 : best;
390 } 408 }
391 409
392 410
393 // 411 //
394 // DescribeYourselfTo 412 // DescribeYourselfTo
395 // 413 //
396 void G4VCSGfaceted::DescribeYourselfTo( G4VGra 414 void G4VCSGfaceted::DescribeYourselfTo( G4VGraphicsScene& scene ) const
397 { 415 {
398 scene.AddSolid( *this ); 416 scene.AddSolid( *this );
399 } 417 }
400 418
401 419
402 // 420 //
403 // GetExtent 421 // GetExtent
404 // 422 //
405 // Define the sides of the box into which our 423 // Define the sides of the box into which our solid instance would fit.
406 // 424 //
407 G4VisExtent G4VCSGfaceted::GetExtent() const 425 G4VisExtent G4VCSGfaceted::GetExtent() const
408 { 426 {
409 static const G4ThreeVector xMax(1,0,0), xMin 427 static const G4ThreeVector xMax(1,0,0), xMin(-1,0,0),
410 yMax(0,1,0), yMin 428 yMax(0,1,0), yMin(0,-1,0),
411 zMax(0,0,1), zMin 429 zMax(0,0,1), zMin(0,0,-1);
412 static const G4ThreeVector *axes[6] = 430 static const G4ThreeVector *axes[6] =
413 { &xMin, &xMax, &yMin, &yMax, &zMin, &zMa 431 { &xMin, &xMax, &yMin, &yMax, &zMin, &zMax };
414 432
415 G4double answers[6] = 433 G4double answers[6] =
416 {-kInfinity, -kInfinity, -kInfinity, -kIn 434 {-kInfinity, -kInfinity, -kInfinity, -kInfinity, -kInfinity, -kInfinity};
417 435
418 G4VCSGface **face = faces; 436 G4VCSGface **face = faces;
419 do // Loop checking, 13.08.2015, G.Cosmo << 437 do
420 { 438 {
421 const G4ThreeVector **axis = axes+5 ; 439 const G4ThreeVector **axis = axes+5 ;
422 G4double* answer = answers+5; << 440 G4double *answer = answers+5;
423 do // Loop checking, 13.08.2015, G.Cosm << 441 do
424 { 442 {
425 G4double testFace = (*face)->Extent( **a 443 G4double testFace = (*face)->Extent( **axis );
426 if (testFace > *answer) { *answer = tes 444 if (testFace > *answer) { *answer = testFace; }
427 } 445 }
428 while( --axis, --answer >= answers ); 446 while( --axis, --answer >= answers );
429 447
430 } while( ++face < faces + numFace ); 448 } while( ++face < faces + numFace );
431 449
432 return { -answers[0], answers[1], << 450 return G4VisExtent( -answers[0], answers[1],
433 -answers[2], answers[3], << 451 -answers[2], answers[3],
434 -answers[4], answers[5] }; << 452 -answers[4], answers[5] );
435 } 453 }
436 454
437 455
438 // 456 //
439 // GetEntityType 457 // GetEntityType
440 // 458 //
441 G4GeometryType G4VCSGfaceted::GetEntityType() 459 G4GeometryType G4VCSGfaceted::GetEntityType() const
442 { 460 {
443 return {"G4CSGfaceted"}; << 461 return G4String("G4CSGfaceted");
444 } 462 }
445 463
446 464
447 // 465 //
448 // Stream object contents to an output stream 466 // Stream object contents to an output stream
449 // 467 //
450 std::ostream& G4VCSGfaceted::StreamInfo( std:: 468 std::ostream& G4VCSGfaceted::StreamInfo( std::ostream& os ) const
451 { 469 {
452 os << "------------------------------------- 470 os << "-----------------------------------------------------------\n"
453 << " *** Dump for solid - " << GetName 471 << " *** Dump for solid - " << GetName() << " ***\n"
454 << " ================================= 472 << " ===================================================\n"
455 << " Solid type: G4VCSGfaceted\n" 473 << " Solid type: G4VCSGfaceted\n"
456 << " Parameters: \n" 474 << " Parameters: \n"
457 << " number of faces: " << numFace << 475 << " number of faces: " << numFace << "\n"
458 << "------------------------------------- 476 << "-----------------------------------------------------------\n";
459 477
460 return os; 478 return os;
461 } 479 }
462 480
463 481
464 // 482 //
465 // GetCubVolStatistics 483 // GetCubVolStatistics
466 // 484 //
467 G4int G4VCSGfaceted::GetCubVolStatistics() con 485 G4int G4VCSGfaceted::GetCubVolStatistics() const
468 { 486 {
469 return fStatistics; 487 return fStatistics;
470 } 488 }
471 489
472 490
473 // 491 //
474 // GetCubVolEpsilon 492 // GetCubVolEpsilon
475 // 493 //
476 G4double G4VCSGfaceted::GetCubVolEpsilon() con 494 G4double G4VCSGfaceted::GetCubVolEpsilon() const
477 { 495 {
478 return fCubVolEpsilon; 496 return fCubVolEpsilon;
479 } 497 }
480 498
481 499
482 // 500 //
483 // SetCubVolStatistics 501 // SetCubVolStatistics
484 // 502 //
485 void G4VCSGfaceted::SetCubVolStatistics(G4int 503 void G4VCSGfaceted::SetCubVolStatistics(G4int st)
486 { 504 {
487 fCubicVolume=0.; 505 fCubicVolume=0.;
488 fStatistics=st; 506 fStatistics=st;
489 } 507 }
490 508
491 509
492 // 510 //
493 // SetCubVolEpsilon 511 // SetCubVolEpsilon
494 // 512 //
495 void G4VCSGfaceted::SetCubVolEpsilon(G4double 513 void G4VCSGfaceted::SetCubVolEpsilon(G4double ep)
496 { 514 {
497 fCubicVolume=0.; 515 fCubicVolume=0.;
498 fCubVolEpsilon=ep; 516 fCubVolEpsilon=ep;
499 } 517 }
500 518
501 519
502 // 520 //
503 // GetAreaStatistics 521 // GetAreaStatistics
504 // 522 //
505 G4int G4VCSGfaceted::GetAreaStatistics() const 523 G4int G4VCSGfaceted::GetAreaStatistics() const
506 { 524 {
507 return fStatistics; 525 return fStatistics;
508 } 526 }
509 527
510 528
511 // 529 //
512 // GetAreaAccuracy 530 // GetAreaAccuracy
513 // 531 //
514 G4double G4VCSGfaceted::GetAreaAccuracy() cons 532 G4double G4VCSGfaceted::GetAreaAccuracy() const
515 { 533 {
516 return fAreaAccuracy; 534 return fAreaAccuracy;
517 } 535 }
518 536
519 537
520 // 538 //
521 // SetAreaStatistics 539 // SetAreaStatistics
522 // 540 //
523 void G4VCSGfaceted::SetAreaStatistics(G4int st 541 void G4VCSGfaceted::SetAreaStatistics(G4int st)
524 { 542 {
525 fSurfaceArea=0.; 543 fSurfaceArea=0.;
526 fStatistics=st; 544 fStatistics=st;
527 } 545 }
528 546
529 547
530 // 548 //
531 // SetAreaAccuracy 549 // SetAreaAccuracy
532 // 550 //
533 void G4VCSGfaceted::SetAreaAccuracy(G4double e 551 void G4VCSGfaceted::SetAreaAccuracy(G4double ep)
534 { 552 {
535 fSurfaceArea=0.; 553 fSurfaceArea=0.;
536 fAreaAccuracy=ep; 554 fAreaAccuracy=ep;
537 } 555 }
538 556
539 557
540 // 558 //
541 // GetCubicVolume 559 // GetCubicVolume
542 // 560 //
543 G4double G4VCSGfaceted::GetCubicVolume() 561 G4double G4VCSGfaceted::GetCubicVolume()
544 { 562 {
545 if(fCubicVolume != 0.) {;} 563 if(fCubicVolume != 0.) {;}
546 else { fCubicVolume = EstimateCubicVolume( 564 else { fCubicVolume = EstimateCubicVolume(fStatistics,fCubVolEpsilon); }
547 return fCubicVolume; 565 return fCubicVolume;
548 } 566 }
549 567
550 568
551 // 569 //
552 // GetSurfaceArea 570 // GetSurfaceArea
553 // 571 //
554 G4double G4VCSGfaceted::GetSurfaceArea() 572 G4double G4VCSGfaceted::GetSurfaceArea()
555 { 573 {
556 if(fSurfaceArea != 0.) {;} 574 if(fSurfaceArea != 0.) {;}
557 else { fSurfaceArea = EstimateSurfaceArea( 575 else { fSurfaceArea = EstimateSurfaceArea(fStatistics,fAreaAccuracy); }
558 return fSurfaceArea; 576 return fSurfaceArea;
559 } 577 }
560 578
561 579
562 // 580 //
563 // GetPolyhedron 581 // GetPolyhedron
564 // 582 //
565 G4Polyhedron* G4VCSGfaceted::GetPolyhedron () 583 G4Polyhedron* G4VCSGfaceted::GetPolyhedron () const
566 { 584 {
567 if (fpPolyhedron == nullptr || << 585 if (!fpPolyhedron ||
568 fRebuildPolyhedron || 586 fRebuildPolyhedron ||
569 fpPolyhedron->GetNumberOfRotationStepsAt 587 fpPolyhedron->GetNumberOfRotationStepsAtTimeOfCreation() !=
570 fpPolyhedron->GetNumberOfRotationSteps() 588 fpPolyhedron->GetNumberOfRotationSteps())
571 { 589 {
572 G4AutoLock l(&polyhedronMutex); 590 G4AutoLock l(&polyhedronMutex);
573 delete fpPolyhedron; 591 delete fpPolyhedron;
574 fpPolyhedron = CreatePolyhedron(); 592 fpPolyhedron = CreatePolyhedron();
575 fRebuildPolyhedron = false; 593 fRebuildPolyhedron = false;
576 l.unlock(); 594 l.unlock();
577 } 595 }
578 return fpPolyhedron; 596 return fpPolyhedron;
579 } 597 }
580 598
581 599
582 // 600 //
583 // GetPointOnSurfaceGeneric proportional to Ar 601 // GetPointOnSurfaceGeneric proportional to Areas of faces
584 // in case of GenericPolycone or GenericPolyhe 602 // in case of GenericPolycone or GenericPolyhedra
585 // 603 //
586 G4ThreeVector G4VCSGfaceted::GetPointOnSurface 604 G4ThreeVector G4VCSGfaceted::GetPointOnSurfaceGeneric( ) const
587 { 605 {
588 // Preparing variables 606 // Preparing variables
589 // 607 //
590 G4ThreeVector answer=G4ThreeVector(0.,0.,0.) 608 G4ThreeVector answer=G4ThreeVector(0.,0.,0.);
591 G4VCSGface **face = faces; 609 G4VCSGface **face = faces;
592 G4double area = 0.; << 610 G4double area = 0;
593 G4int i; 611 G4int i;
594 std::vector<G4double> areas; 612 std::vector<G4double> areas;
595 613
596 // First step: calculate surface areas 614 // First step: calculate surface areas
597 // 615 //
598 do // Loop checking, 13.08.2015, G.Cosmo << 616 do
599 { 617 {
600 G4double result = (*face)->SurfaceArea( ); 618 G4double result = (*face)->SurfaceArea( );
601 areas.push_back(result); 619 areas.push_back(result);
602 area=area+result; 620 area=area+result;
603 } while( ++face < faces + numFace ); 621 } while( ++face < faces + numFace );
604 622
605 // Second Step: choose randomly one surface 623 // Second Step: choose randomly one surface
606 // 624 //
607 G4VCSGface **face1 = faces; 625 G4VCSGface **face1 = faces;
608 G4double chose = area*G4UniformRand(); 626 G4double chose = area*G4UniformRand();
609 G4double Achose1, Achose2; 627 G4double Achose1, Achose2;
610 Achose1=0.; Achose2=0.; << 628 Achose1=0; Achose2=0.;
611 i=0; 629 i=0;
612 630
613 do 631 do
614 { 632 {
615 Achose2+=areas[i]; 633 Achose2+=areas[i];
616 if(chose>=Achose1 && chose<Achose2) 634 if(chose>=Achose1 && chose<Achose2)
617 { 635 {
618 G4ThreeVector point; 636 G4ThreeVector point;
619 point= (*face1)->GetPointOnFace(); 637 point= (*face1)->GetPointOnFace();
620 return point; 638 return point;
621 } 639 }
622 ++i; << 640 i++;
623 Achose1=Achose2; 641 Achose1=Achose2;
624 } while( ++face1 < faces + numFace ); 642 } while( ++face1 < faces + numFace );
625 643
626 return answer; 644 return answer;
627 } 645 }
628 646