| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer << 3 // * DISCLAIMER *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th << 5 // * The following disclaimer summarizes all the specific disclaimers *
6 // * the Geant4 Collaboration. It is provided << 6 // * of contributors to this software. The specific disclaimers,which *
7 // * conditions of the Geant4 Software License << 7 // * govern, are listed with their locations in: *
8 // * LICENSE and available at http://cern.ch/ << 8 // * http://cern.ch/geant4/license *
9 // * include a list of copyright holders. <<
10 // * 9 // * *
11 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file << 14 // * use. *
16 // * for the full disclaimer and the limitatio <<
17 // * 15 // * *
18 // * This code implementation is the result << 16 // * This code implementation is the intellectual property of the *
19 // * technical work of the GEANT4 collaboratio << 17 // * GEANT4 collaboration. *
20 // * By using, copying, modifying or distri << 18 // * By copying, distributing or modifying the Program (or any work *
21 // * any work based on the software) you ag << 19 // * based on the Program) you indicate your acceptance of this *
22 // * use in resulting scientific publicati << 20 // * statement, and all its terms. *
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* 21 // ********************************************************************
25 // 22 //
26 // Implementation of G4DisplacedSolid class fo << 23 //
>> 24 // $Id: G4DisplacedSolid.cc,v 1.14 2001/07/11 09:59:52 gunter Exp $
>> 25 // GEANT4 tag $Name: geant4-04-00 $
>> 26 //
>> 27 // Implementation for G4DisplacedSolid class for boolean
27 // operations between other solids 28 // operations between other solids
28 // 29 //
29 // 28.10.98 V.Grichine: created << 30 // History:
30 // 28.02.18 E.Tcherniaev: improved contruction << 31 //
31 // ------------------------------------------- << 32 // 28.10.98 V.Grichine, creation according J. Apostolakis's recommendations
>> 33 // 14.11.99 V.Grichine, modifications in CalculateExtent(...) method
>> 34 // 22.11.00 V.Grichine, new set methods for matrix/vectors
32 35
33 #include "G4DisplacedSolid.hh" 36 #include "G4DisplacedSolid.hh"
34 37
>> 38
35 #include "G4VoxelLimits.hh" 39 #include "G4VoxelLimits.hh"
>> 40 #include "G4AffineTransform.hh"
36 41
37 #include "G4VPVParameterisation.hh" 42 #include "G4VPVParameterisation.hh"
38 43
39 #include "G4VGraphicsScene.hh" 44 #include "G4VGraphicsScene.hh"
40 #include "G4Polyhedron.hh" 45 #include "G4Polyhedron.hh"
>> 46 #include "G4NURBS.hh"
>> 47 #include "G4NURBSbox.hh"
41 48
42 ////////////////////////////////////////////// 49 ////////////////////////////////////////////////////////////////
43 // 50 //
44 // Constructor for transformation like rotatio << 51 // Constractor for transformation like rotation of frame then translation
45 // in new frame. It is similar to 1st constrac 52 // in new frame. It is similar to 1st constractor in G4PVPlacement
46 53
47 G4DisplacedSolid::G4DisplacedSolid( const G4St << 54 G4DisplacedSolid::
48 G4VS << 55 G4DisplacedSolid( const G4String& pName,
49 G4Ro << 56 G4VSolid* pSolid ,
50 const G4Th << 57 G4RotationMatrix* rotMatrix,
51 : G4VSolid(pName) << 58 const G4ThreeVector& transVector )
52 { << 59 : G4VSolid(pName)
53 if (pSolid->GetEntityType() == "G4DisplacedS << 60 {
54 { << 61 fPtrSolid = pSolid ;
55 fPtrSolid = ((G4DisplacedSolid*)pSolid)->G << 62 fPtrTransform = new G4AffineTransform(rotMatrix,transVector) ;
56 G4AffineTransform t1 = ((G4DisplacedSolid* << 63 fPtrTransform->Invert() ;
57 G4AffineTransform t2 = G4AffineTransform(r << 64 fDirectTransform = new G4AffineTransform(rotMatrix,transVector) ;
58 fDirectTransform = new G4AffineTransform(t <<
59 } <<
60 else <<
61 { <<
62 fPtrSolid = pSolid; <<
63 fDirectTransform = new G4AffineTransform(r <<
64 } <<
65 fPtrTransform = new G4AffineTransform(fDirec <<
66 } 65 }
67 66
68 ////////////////////////////////////////////// 67 /////////////////////////////////////////////////////////////////////////////////
69 // 68 //
70 // Constructor <<
71 <<
72 G4DisplacedSolid::G4DisplacedSolid( const G4St <<
73 G4VS <<
74 const G4Tr <<
75 : G4VSolid(pName) <<
76 { <<
77 if (pSolid->GetEntityType() == "G4DisplacedS <<
78 { <<
79 fPtrSolid = ((G4DisplacedSolid*)pSolid)->G <<
80 G4AffineTransform t1 = ((G4DisplacedSolid* <<
81 G4AffineTransform t2 = G4AffineTransform(t <<
82 t <<
83 fDirectTransform = new G4AffineTransform(t <<
84 } <<
85 else <<
86 { <<
87 fPtrSolid = pSolid; <<
88 fDirectTransform = new G4AffineTransform(t <<
89 t <<
90 } <<
91 fPtrTransform = new G4AffineTransform(fDirec <<
92 } <<
93 <<
94 ////////////////////////////////////////////// <<
95 // 69 //
96 // Constructor for use with creation of Transi <<
97 // from Persistent object <<
98 <<
99 G4DisplacedSolid::G4DisplacedSolid( const G4St 70 G4DisplacedSolid::G4DisplacedSolid( const G4String& pName,
100 G4VS 71 G4VSolid* pSolid ,
101 const G4Af << 72 const G4Transform3D& transform ) :
102 : G4VSolid(pName) << 73 G4VSolid(pName)
103 { 74 {
104 if (pSolid->GetEntityType() == "G4DisplacedS << 75 fPtrSolid = pSolid ;
105 { << 76 fDirectTransform = new G4AffineTransform(transform.getRotation().inverse(),
106 fPtrSolid = ((G4DisplacedSolid*)pSolid)->G << 77 transform.getTranslation()) ;
107 G4AffineTransform t1 = ((G4DisplacedSolid* << 78
108 auto t2 = G4AffineTransform(directTransfo << 79 fPtrTransform = new G4AffineTransform(transform.getRotation().inverse(),
109 fDirectTransform = new G4AffineTransform(t << 80 transform.getTranslation()) ;
110 } << 81 fPtrTransform->Invert() ;
111 else <<
112 { <<
113 fPtrSolid = pSolid; <<
114 fDirectTransform = new G4AffineTransform(d <<
115 } <<
116 fPtrTransform = new G4AffineTransform(fDirec <<
117 } 82 }
118 83
119 ////////////////////////////////////////////// << 84 /////////////////////////////////////////////////////////////////////////////////
>> 85 // Constructor for use with creation of Transient object from Persistent object
120 // 86 //
121 // Fake default constructor - sets only member <<
122 // for usage restri <<
123 87
124 G4DisplacedSolid::G4DisplacedSolid( __void__& << 88 G4DisplacedSolid::G4DisplacedSolid( const G4String& pName,
125 : G4VSolid(a) << 89 G4VSolid* pSolid ,
126 { << 90 const G4AffineTransform directTransform ) :
>> 91 G4VSolid(pName)
>> 92 {
>> 93 fPtrSolid = pSolid ;
>> 94 fDirectTransform = new G4AffineTransform( directTransform );
>> 95 fPtrTransform = new G4AffineTransform( directTransform.Inverse() ) ;
127 } 96 }
128 97
129 ////////////////////////////////////////////// 98 ///////////////////////////////////////////////////////////////////
130 // 99 //
131 // Destructor <<
132 100
133 G4DisplacedSolid::~G4DisplacedSolid() 101 G4DisplacedSolid::~G4DisplacedSolid()
134 { 102 {
135 CleanTransformations(); << 103 if(fPtrTransform)
136 delete fpPolyhedron; fpPolyhedron = nullptr; <<
137 } <<
138 <<
139 ////////////////////////////////////////////// <<
140 // <<
141 // Copy constructor <<
142 <<
143 G4DisplacedSolid::G4DisplacedSolid(const G4Dis <<
144 : G4VSolid (rhs), fPtrSolid(rhs.fPtrSolid) <<
145 { <<
146 fPtrTransform = new G4AffineTransform(*(rhs. <<
147 fDirectTransform = new G4AffineTransform(*(r <<
148 } <<
149 <<
150 ////////////////////////////////////////////// <<
151 // <<
152 // Assignment operator <<
153 <<
154 G4DisplacedSolid& G4DisplacedSolid::operator = <<
155 { <<
156 // Check assignment to self <<
157 // <<
158 if (this == &rhs) { return *this; } <<
159 <<
160 // Copy base class data <<
161 // <<
162 G4VSolid::operator=(rhs); <<
163 <<
164 // Copy data <<
165 // <<
166 fPtrSolid = rhs.fPtrSolid; <<
167 delete fPtrTransform; delete fDirectTransfor <<
168 fPtrTransform = new G4AffineTransform(*(rhs. <<
169 fDirectTransform = new G4AffineTransform(*(r <<
170 fRebuildPolyhedron = false; <<
171 delete fpPolyhedron; fpPolyhedron = nullptr; <<
172 <<
173 return *this; <<
174 } <<
175 <<
176 void G4DisplacedSolid::CleanTransformations() <<
177 { <<
178 if(fPtrTransform != nullptr) <<
179 { 104 {
180 delete fPtrTransform; fPtrTransform = null << 105 delete fPtrTransform ;
181 delete fDirectTransform; fDirectTransform << 106 delete fDirectTransform;
182 } 107 }
183 } 108 }
184 109
185 const G4DisplacedSolid* G4DisplacedSolid::GetD << 110 G4GeometryType G4DisplacedSolid::GetEntityType() const
186 { 111 {
187 return this; << 112 return G4String("G4DisplacedSolid");
188 } 113 }
189 114
190 G4DisplacedSolid* G4DisplacedSolid::GetDisplac << 115 const G4DisplacedSolid* G4DisplacedSolid::GetDisplacedSolidPtr() const
191 { << 116 { return this; }
192 return this; << 117
193 } << 118 G4DisplacedSolid* G4DisplacedSolid::GetDisplacedSolidPtr()
>> 119 { return this; }
194 120
195 G4VSolid* G4DisplacedSolid::GetConstituentMove 121 G4VSolid* G4DisplacedSolid::GetConstituentMovedSolid() const
196 { 122 {
197 return fPtrSolid; 123 return fPtrSolid;
198 } 124 }
199 125
200 ////////////////////////////////////////////// 126 /////////////////////////////////////////////////////////////////////////////
201 127
202 G4AffineTransform G4DisplacedSolid::GetTransf 128 G4AffineTransform G4DisplacedSolid::GetTransform() const
203 { 129 {
204 G4AffineTransform aTransform = *fPtrTransfor << 130 G4AffineTransform aTransform = *fPtrTransform;
205 return aTransform; << 131 return aTransform;
206 } 132 }
207 133
208 void G4DisplacedSolid::SetTransform(G4AffineTr 134 void G4DisplacedSolid::SetTransform(G4AffineTransform& transform)
209 { 135 {
210 fPtrTransform = &transform ; << 136 fPtrTransform = &transform ;
211 fRebuildPolyhedron = true; <<
212 } 137 }
213 138
214 ////////////////////////////////////////////// 139 //////////////////////////////////////////////////////////////////////////////
215 140
216 G4AffineTransform G4DisplacedSolid::GetDirect 141 G4AffineTransform G4DisplacedSolid::GetDirectTransform() const
217 { 142 {
218 G4AffineTransform aTransform= *fDirectTransf << 143 G4AffineTransform aTransform= *fDirectTransform;
219 return aTransform; << 144 return aTransform;
220 } 145 }
221 146
222 void G4DisplacedSolid::SetDirectTransform(G4Af 147 void G4DisplacedSolid::SetDirectTransform(G4AffineTransform& transform)
223 { 148 {
224 fDirectTransform = &transform ; << 149 fDirectTransform = &transform ;
225 fRebuildPolyhedron = true; <<
226 } 150 }
227 151
228 ////////////////////////////////////////////// 152 /////////////////////////////////////////////////////////////////////////////
229 153
230 G4RotationMatrix G4DisplacedSolid::GetFrameRot 154 G4RotationMatrix G4DisplacedSolid::GetFrameRotation() const
231 { 155 {
232 G4RotationMatrix InvRotation = fDirectTransf << 156 G4RotationMatrix InvRotation= fDirectTransform->NetRotation();
233 return InvRotation; << 157 return InvRotation;
234 } 158 }
235 159
236 void G4DisplacedSolid::SetFrameRotation(const 160 void G4DisplacedSolid::SetFrameRotation(const G4RotationMatrix& matrix)
237 { 161 {
238 fDirectTransform->SetNetRotation(matrix); << 162 fDirectTransform->SetNetRotation(matrix);
239 fRebuildPolyhedron = true; <<
240 } 163 }
241 164
242 ////////////////////////////////////////////// 165 /////////////////////////////////////////////////////////////////////////////
243 166
244 G4ThreeVector G4DisplacedSolid::GetFrameTrans 167 G4ThreeVector G4DisplacedSolid::GetFrameTranslation() const
245 { 168 {
246 return fPtrTransform->NetTranslation(); << 169 return fPtrTransform->NetTranslation();
247 } 170 }
248 171
249 void G4DisplacedSolid::SetFrameTranslation(con 172 void G4DisplacedSolid::SetFrameTranslation(const G4ThreeVector& vector)
250 { 173 {
251 fPtrTransform->SetNetTranslation(vector); 174 fPtrTransform->SetNetTranslation(vector);
252 fRebuildPolyhedron = true; <<
253 } 175 }
254 176
255 ////////////////////////////////////////////// 177 ///////////////////////////////////////////////////////////////
256 178
257 G4RotationMatrix G4DisplacedSolid::GetObjectRo 179 G4RotationMatrix G4DisplacedSolid::GetObjectRotation() const
258 { 180 {
259 G4RotationMatrix Rotation = fPtrTransform->N << 181 G4RotationMatrix Rotation= fPtrTransform->NetRotation();
260 return Rotation; << 182 return Rotation;
261 } 183 }
262 184
263 void G4DisplacedSolid::SetObjectRotation(const 185 void G4DisplacedSolid::SetObjectRotation(const G4RotationMatrix& matrix)
264 { 186 {
265 fPtrTransform->SetNetRotation(matrix); << 187 fPtrTransform->SetNetRotation(matrix);
266 fRebuildPolyhedron = true; <<
267 } 188 }
268 189
269 ////////////////////////////////////////////// 190 ///////////////////////////////////////////////////////////////////////
270 191
271 G4ThreeVector G4DisplacedSolid::GetObjectTran 192 G4ThreeVector G4DisplacedSolid::GetObjectTranslation() const
272 { 193 {
273 return fDirectTransform->NetTranslation(); << 194 return fDirectTransform->NetTranslation();
274 } 195 }
275 196
276 void G4DisplacedSolid::SetObjectTranslation(co 197 void G4DisplacedSolid::SetObjectTranslation(const G4ThreeVector& vector)
277 { 198 {
278 fDirectTransform->SetNetTranslation(vector); 199 fDirectTransform->SetNetTranslation(vector);
279 fRebuildPolyhedron = true; <<
280 } 200 }
281 201
282 ////////////////////////////////////////////// << 202 ///////////////////////////////////////////////////////////////
283 // 203 //
284 // Get bounding box <<
285 <<
286 void G4DisplacedSolid::BoundingLimits(G4ThreeV <<
287 G4ThreeV <<
288 { <<
289 if (!fDirectTransform->IsRotated()) <<
290 { <<
291 // Special case of pure translation <<
292 // <<
293 fPtrSolid->BoundingLimits(pMin,pMax); <<
294 G4ThreeVector offset = fDirectTransform->N <<
295 pMin += offset; <<
296 pMax += offset; <<
297 } <<
298 else <<
299 { <<
300 // General case, use CalculateExtent() to <<
301 // <<
302 G4VoxelLimits unLimit; <<
303 G4double xmin,xmax,ymin,ymax,zmin,zmax; <<
304 fPtrSolid->CalculateExtent(kXAxis,unLimit, <<
305 fPtrSolid->CalculateExtent(kYAxis,unLimit, <<
306 fPtrSolid->CalculateExtent(kZAxis,unLimit, <<
307 pMin.set(xmin,ymin,zmin); <<
308 pMax.set(xmax,ymax,zmax); <<
309 } <<
310 <<
311 // Check correctness of the bounding box <<
312 // <<
313 if (pMin.x() >= pMax.x() || pMin.y() >= pMax <<
314 { <<
315 std::ostringstream message; <<
316 message << "Bad bounding box (min >= max) <<
317 << GetName() << " !" <<
318 << "\npMin = " << pMin <<
319 << "\npMax = " << pMax; <<
320 G4Exception("G4DisplacedSolid::BoundingLim <<
321 JustWarning, message); <<
322 DumpInfo(); <<
323 } <<
324 } <<
325 <<
326 ////////////////////////////////////////////// <<
327 // 204 //
328 // Calculate extent under transform and specif <<
329 205
330 G4bool 206 G4bool
331 G4DisplacedSolid::CalculateExtent( const EAxis 207 G4DisplacedSolid::CalculateExtent( const EAxis pAxis,
332 const G4Vox << 208 const G4VoxelLimits& pVoxelLimit,
333 const G4Aff << 209 const G4AffineTransform& pTransform,
334 G4dou << 210 G4double& pMin,
335 G4dou 211 G4double& pMax ) const
336 { 212 {
337 G4AffineTransform sumTransform ; 213 G4AffineTransform sumTransform ;
338 sumTransform.Product(*fDirectTransform,pTran 214 sumTransform.Product(*fDirectTransform,pTransform) ;
339 return fPtrSolid->CalculateExtent(pAxis,pVox << 215 return fPtrSolid->CalculateExtent(pAxis,pVoxelLimit,sumTransform,
>> 216 pMin,pMax) ;
340 } 217 }
341 218
342 ////////////////////////////////////////////// 219 /////////////////////////////////////////////////////
343 // 220 //
344 // SurfaceNormal << 221 //
345 222
346 EInside G4DisplacedSolid::Inside(const G4Three 223 EInside G4DisplacedSolid::Inside(const G4ThreeVector& p) const
347 { 224 {
348 G4ThreeVector newPoint = fPtrTransform->Tran 225 G4ThreeVector newPoint = fPtrTransform->TransformPoint(p) ;
349 return fPtrSolid->Inside(newPoint) ; 226 return fPtrSolid->Inside(newPoint) ;
350 } 227 }
351 228
352 ////////////////////////////////////////////// 229 //////////////////////////////////////////////////////////////
353 // 230 //
354 // 231 //
355 232
356 G4ThreeVector 233 G4ThreeVector
357 G4DisplacedSolid::SurfaceNormal( const G4Three 234 G4DisplacedSolid::SurfaceNormal( const G4ThreeVector& p ) const
358 { 235 {
359 G4ThreeVector newPoint = fPtrTransform->Tran 236 G4ThreeVector newPoint = fPtrTransform->TransformPoint(p) ;
360 G4ThreeVector normal = fPtrSolid->SurfaceNor 237 G4ThreeVector normal = fPtrSolid->SurfaceNormal(newPoint) ;
361 return fDirectTransform->TransformAxis(norma 238 return fDirectTransform->TransformAxis(normal) ;
>> 239
362 } 240 }
363 241
364 ////////////////////////////////////////////// 242 /////////////////////////////////////////////////////////////
365 // 243 //
366 // The same algorithm as in DistanceToIn(p) 244 // The same algorithm as in DistanceToIn(p)
367 245
368 G4double 246 G4double
369 G4DisplacedSolid::DistanceToIn( const G4ThreeV 247 G4DisplacedSolid::DistanceToIn( const G4ThreeVector& p,
370 const G4ThreeV << 248 const G4ThreeVector& v ) const
371 { 249 {
372 G4ThreeVector newPoint = fPtrTransform->Tran 250 G4ThreeVector newPoint = fPtrTransform->TransformPoint(p) ;
373 G4ThreeVector newDirection = fPtrTransform-> 251 G4ThreeVector newDirection = fPtrTransform->TransformAxis(v) ;
374 return fPtrSolid->DistanceToIn(newPoint,newD 252 return fPtrSolid->DistanceToIn(newPoint,newDirection) ;
375 } 253 }
376 254
377 ////////////////////////////////////////////// 255 ////////////////////////////////////////////////////////
378 // 256 //
379 // Approximate nearest distance from the point 257 // Approximate nearest distance from the point p to the intersection of
380 // two solids 258 // two solids
381 259
382 G4double 260 G4double
383 G4DisplacedSolid::DistanceToIn( const G4ThreeV << 261 G4DisplacedSolid::DistanceToIn( const G4ThreeVector& p) const
384 { 262 {
385 G4ThreeVector newPoint = fPtrTransform->Tran 263 G4ThreeVector newPoint = fPtrTransform->TransformPoint(p) ;
386 return fPtrSolid->DistanceToIn(newPoint) ; 264 return fPtrSolid->DistanceToIn(newPoint) ;
387 } 265 }
388 266
389 ////////////////////////////////////////////// 267 //////////////////////////////////////////////////////////
390 // 268 //
391 // The same algorithm as DistanceToOut(p) 269 // The same algorithm as DistanceToOut(p)
392 270
393 G4double 271 G4double
394 G4DisplacedSolid::DistanceToOut( const G4Three 272 G4DisplacedSolid::DistanceToOut( const G4ThreeVector& p,
395 const G4Three << 273 const G4ThreeVector& v,
396 const G4bool << 274 const G4bool calcNorm,
397 G4bool << 275 G4bool *validNorm,
398 G4Three << 276 G4ThreeVector *n ) const
399 { 277 {
400 G4ThreeVector solNorm ; 278 G4ThreeVector solNorm ;
401 G4ThreeVector newPoint = fPtrTransform->Tran 279 G4ThreeVector newPoint = fPtrTransform->TransformPoint(p) ;
402 G4ThreeVector newDirection = fPtrTransform-> 280 G4ThreeVector newDirection = fPtrTransform->TransformAxis(v) ;
403 G4double dist = fPtrSolid->DistanceToOut(new 281 G4double dist = fPtrSolid->DistanceToOut(newPoint,newDirection,
404 cal << 282 calcNorm,validNorm,&solNorm) ;
405 if(calcNorm) 283 if(calcNorm)
406 { 284 {
407 *n = fDirectTransform->TransformAxis(solNo 285 *n = fDirectTransform->TransformAxis(solNorm) ;
408 } 286 }
409 return dist ; 287 return dist ;
410 } 288 }
411 289
412 ////////////////////////////////////////////// 290 //////////////////////////////////////////////////////////////
413 // 291 //
414 // Inverted algorithm of DistanceToIn(p) 292 // Inverted algorithm of DistanceToIn(p)
415 293
416 G4double 294 G4double
417 G4DisplacedSolid::DistanceToOut( const G4Three 295 G4DisplacedSolid::DistanceToOut( const G4ThreeVector& p ) const
418 { 296 {
419 G4ThreeVector newPoint = fPtrTransform->Tran 297 G4ThreeVector newPoint = fPtrTransform->TransformPoint(p) ;
420 return fPtrSolid->DistanceToOut(newPoint) ; 298 return fPtrSolid->DistanceToOut(newPoint) ;
421 } 299 }
422 300
423 ////////////////////////////////////////////// 301 //////////////////////////////////////////////////////////////
424 // 302 //
425 // ComputeDimensions <<
426 <<
427 void <<
428 G4DisplacedSolid::ComputeDimensions( G4V <<
429 const G4i <<
430 const G4V <<
431 { <<
432 DumpInfo(); <<
433 G4Exception("G4DisplacedSolid::ComputeDimens <<
434 "GeomSolids0001", FatalException <<
435 "Method not applicable in this c <<
436 } <<
437 <<
438 ////////////////////////////////////////////// <<
439 // <<
440 // Return volume <<
441 <<
442 G4double G4DisplacedSolid::GetCubicVolume() <<
443 { <<
444 return fPtrSolid->GetCubicVolume(); <<
445 } <<
446 <<
447 ////////////////////////////////////////////// <<
448 // <<
449 // Return surface area <<
450 <<
451 G4double G4DisplacedSolid::GetSurfaceArea() <<
452 { <<
453 return fPtrSolid->GetSurfaceArea(); <<
454 } <<
455 <<
456 ////////////////////////////////////////////// <<
457 // <<
458 // Returns a point (G4ThreeVector) randomly an <<
459 // on the solid surface <<
460 // <<
461 <<
462 G4ThreeVector G4DisplacedSolid::GetPointOnSurf <<
463 { <<
464 G4ThreeVector p = fPtrSolid->GetPointOnSurfa <<
465 return fDirectTransform->TransformPoint(p); <<
466 } <<
467 <<
468 ////////////////////////////////////////////// <<
469 // 303 //
470 // Return the number of constituents used for <<
471 304
472 G4int G4DisplacedSolid::GetNumOfConstituents() << 305 void
473 { << 306 G4DisplacedSolid::ComputeDimensions( G4VPVParameterisation* p,
474 return fPtrSolid->GetNumOfConstituents(); << 307 const G4int n,
475 } << 308 const G4VPhysicalVolume* pRep )
476 <<
477 ////////////////////////////////////////////// <<
478 // <<
479 // Return true if the solid has only planar fa <<
480 <<
481 G4bool G4DisplacedSolid::IsFaceted() const <<
482 { <<
483 return fPtrSolid->IsFaceted(); <<
484 } <<
485 <<
486 ////////////////////////////////////////////// <<
487 // <<
488 // Return object type name <<
489 <<
490 G4GeometryType G4DisplacedSolid::GetEntityType <<
491 { <<
492 return {"G4DisplacedSolid"}; <<
493 } <<
494 <<
495 ////////////////////////////////////////////// <<
496 // <<
497 // Make a clone of the object <<
498 // <<
499 G4VSolid* G4DisplacedSolid::Clone() const <<
500 { <<
501 return new G4DisplacedSolid(*this); <<
502 } <<
503 <<
504 ////////////////////////////////////////////// <<
505 // <<
506 // Stream object contents to an output stream <<
507 <<
508 std::ostream& G4DisplacedSolid::StreamInfo(std <<
509 { 309 {
510 os << "------------------------------------- << 310 // fPtrSolid->ComputeDimensions(p,n,pRep);
511 << " *** Dump for Displaced solid - " <<
512 << " ================================= <<
513 << " Solid type: " << GetEntityType() << <<
514 << " Parameters of constituent solid: \n" <<
515 << "===================================== <<
516 fPtrSolid->StreamInfo(os); <<
517 os << "===================================== <<
518 << " Transformations: \n" <<
519 << " Direct transformation - translati <<
520 << " " << fDirectTransform->Net <<
521 << " - rotation <<
522 << " "; <<
523 fDirectTransform->NetRotation().print(os); <<
524 os << "\n" <<
525 << "===================================== <<
526 311
527 return os; << 312 G4Exception("ERROR: ComputeDimensions has no meaning for a G4DisplacedSolid. It cannot be called.");
528 } 313 }
529 314
530 ////////////////////////////////////////////// << 315 /////////////////////////////////////////////////
531 // 316 //
532 // DescribeYourselfTo << 317 //
533 318
534 void 319 void
535 G4DisplacedSolid::DescribeYourselfTo ( G4VGrap 320 G4DisplacedSolid::DescribeYourselfTo ( G4VGraphicsScene& scene ) const
536 { 321 {
537 scene.AddSolid (*this); << 322 scene.AddThis (*this);
538 } 323 }
539 324
540 ////////////////////////////////////////////// << 325 ////////////////////////////////////////////////////
>> 326 //
541 // 327 //
542 // CreatePolyhedron <<
543 328
544 G4Polyhedron* 329 G4Polyhedron*
545 G4DisplacedSolid::CreatePolyhedron () const 330 G4DisplacedSolid::CreatePolyhedron () const
546 { 331 {
547 G4Polyhedron* polyhedron = fPtrSolid->Create 332 G4Polyhedron* polyhedron = fPtrSolid->CreatePolyhedron();
548 if (polyhedron != nullptr) << 333 polyhedron->Transform
549 { << 334 (G4Transform3D(GetObjectRotation(),GetObjectTranslation()));
550 polyhedron <<
551 ->Transform(G4Transform3D(GetObjectRotatio <<
552 } <<
553 else <<
554 { <<
555 DumpInfo(); <<
556 G4Exception("G4DisplacedSolid::CreatePolyh <<
557 "GeomSolids2002", JustWarning, <<
558 "No G4Polyhedron for displaced <<
559 } <<
560 return polyhedron; 335 return polyhedron;
561 } 336 }
562 337
563 ////////////////////////////////////////////// << 338 /////////////////////////////////////////////////////////
>> 339 //
564 // 340 //
565 // GetPolyhedron <<
566 341
567 G4Polyhedron* G4DisplacedSolid::GetPolyhedron << 342 G4NURBS*
>> 343 G4DisplacedSolid::CreateNURBS () const
568 { 344 {
569 if (fpPolyhedron == nullptr || << 345 // Take into account local transformation - see CreatePolyhedron.
570 fRebuildPolyhedron || << 346 // return fPtrSolid->CreateNURBS() ;
571 fpPolyhedron->GetNumberOfRotationStepsAt << 347 return 0;
572 fpPolyhedron->GetNumberOfRotationSteps() <<
573 { <<
574 fpPolyhedron = CreatePolyhedron(); <<
575 fRebuildPolyhedron = false; <<
576 } <<
577 return fpPolyhedron; <<
578 } 348 }
579 349