| 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 G4DisplacedSolid class fo << 26 //
>> 27 // $Id: G4DisplacedSolid.cc,v 1.27 2006/06/29 18:43:41 gunter Exp $
>> 28 // GEANT4 tag $Name: geant4-08-01 $
>> 29 //
>> 30 // Implementation for G4DisplacedSolid class for boolean
27 // operations between other solids 31 // operations between other solids
28 // 32 //
>> 33 // History:
>> 34 //
29 // 28.10.98 V.Grichine: created 35 // 28.10.98 V.Grichine: created
30 // 28.02.18 E.Tcherniaev: improved contruction << 36 // 14.11.99 V.Grichine: modifications in CalculateExtent(...) method
>> 37 // 22.11.00 V.Grichine: new set methods for matrix/vectors
>> 38 //
31 // ------------------------------------------- 39 // --------------------------------------------------------------------
32 40
33 #include "G4DisplacedSolid.hh" 41 #include "G4DisplacedSolid.hh"
34 42
35 #include "G4VoxelLimits.hh" 43 #include "G4VoxelLimits.hh"
36 44
37 #include "G4VPVParameterisation.hh" 45 #include "G4VPVParameterisation.hh"
38 46
39 #include "G4VGraphicsScene.hh" 47 #include "G4VGraphicsScene.hh"
40 #include "G4Polyhedron.hh" 48 #include "G4Polyhedron.hh"
>> 49 #include "G4NURBS.hh"
>> 50 // #include "G4NURBSbox.hh"
41 51
42 ////////////////////////////////////////////// 52 ////////////////////////////////////////////////////////////////
43 // 53 //
44 // Constructor for transformation like rotatio 54 // Constructor for transformation like rotation of frame then translation
45 // in new frame. It is similar to 1st constrac 55 // in new frame. It is similar to 1st constractor in G4PVPlacement
46 56
47 G4DisplacedSolid::G4DisplacedSolid( const G4St 57 G4DisplacedSolid::G4DisplacedSolid( const G4String& pName,
48 G4VS 58 G4VSolid* pSolid ,
49 G4Ro 59 G4RotationMatrix* rotMatrix,
50 const G4Th 60 const G4ThreeVector& transVector )
51 : G4VSolid(pName) << 61 : G4VSolid(pName), fpPolyhedron(0)
52 { 62 {
53 if (pSolid->GetEntityType() == "G4DisplacedS << 63 fPtrSolid = pSolid ;
54 { << 64 fPtrTransform = new G4AffineTransform(rotMatrix,transVector) ;
55 fPtrSolid = ((G4DisplacedSolid*)pSolid)->G << 65 fPtrTransform->Invert() ;
56 G4AffineTransform t1 = ((G4DisplacedSolid* << 66 fDirectTransform = new G4AffineTransform(rotMatrix,transVector) ;
57 G4AffineTransform t2 = G4AffineTransform(r <<
58 fDirectTransform = new G4AffineTransform(t <<
59 } <<
60 else <<
61 { <<
62 fPtrSolid = pSolid; <<
63 fDirectTransform = new G4AffineTransform(r <<
64 } <<
65 fPtrTransform = new G4AffineTransform(fDirec <<
66 } 67 }
67 68
68 ////////////////////////////////////////////// 69 /////////////////////////////////////////////////////////////////////////////////
69 // 70 //
70 // Constructor 71 // Constructor
71 72
72 G4DisplacedSolid::G4DisplacedSolid( const G4St 73 G4DisplacedSolid::G4DisplacedSolid( const G4String& pName,
73 G4VS 74 G4VSolid* pSolid ,
74 const G4Tr 75 const G4Transform3D& transform )
75 : G4VSolid(pName) << 76 : G4VSolid(pName), fpPolyhedron(0)
76 { 77 {
77 if (pSolid->GetEntityType() == "G4DisplacedS << 78 fPtrSolid = pSolid ;
78 { << 79 fDirectTransform = new G4AffineTransform(transform.getRotation().inverse(),
79 fPtrSolid = ((G4DisplacedSolid*)pSolid)->G << 80 transform.getTranslation()) ;
80 G4AffineTransform t1 = ((G4DisplacedSolid* << 81
81 G4AffineTransform t2 = G4AffineTransform(t << 82 fPtrTransform = new G4AffineTransform(transform.getRotation().inverse(),
82 t << 83 transform.getTranslation()) ;
83 fDirectTransform = new G4AffineTransform(t << 84 fPtrTransform->Invert() ;
84 } <<
85 else <<
86 { <<
87 fPtrSolid = pSolid; <<
88 fDirectTransform = new G4AffineTransform(t <<
89 t <<
90 } <<
91 fPtrTransform = new G4AffineTransform(fDirec <<
92 } 85 }
93 86
94 ////////////////////////////////////////////// 87 ///////////////////////////////////////////////////////////////////
95 // 88 //
96 // Constructor for use with creation of Transi 89 // Constructor for use with creation of Transient object
97 // from Persistent object 90 // from Persistent object
98 91
99 G4DisplacedSolid::G4DisplacedSolid( const G4St 92 G4DisplacedSolid::G4DisplacedSolid( const G4String& pName,
100 G4VS 93 G4VSolid* pSolid ,
101 const G4Af 94 const G4AffineTransform directTransform )
102 : G4VSolid(pName) << 95 : G4VSolid(pName), fpPolyhedron(0)
103 { 96 {
104 if (pSolid->GetEntityType() == "G4DisplacedS << 97 fPtrSolid = pSolid ;
105 { << 98 fDirectTransform = new G4AffineTransform( directTransform );
106 fPtrSolid = ((G4DisplacedSolid*)pSolid)->G << 99 fPtrTransform = new G4AffineTransform( directTransform.Inverse() ) ;
107 G4AffineTransform t1 = ((G4DisplacedSolid* <<
108 auto t2 = G4AffineTransform(directTransfo <<
109 fDirectTransform = new G4AffineTransform(t <<
110 } <<
111 else <<
112 { <<
113 fPtrSolid = pSolid; <<
114 fDirectTransform = new G4AffineTransform(d <<
115 } <<
116 fPtrTransform = new G4AffineTransform(fDirec <<
117 } 100 }
118 101
119 ////////////////////////////////////////////// 102 ///////////////////////////////////////////////////////////////////
120 // 103 //
121 // Fake default constructor - sets only member 104 // Fake default constructor - sets only member data and allocates memory
122 // for usage restri 105 // for usage restricted to object persistency.
123 106
124 G4DisplacedSolid::G4DisplacedSolid( __void__& 107 G4DisplacedSolid::G4DisplacedSolid( __void__& a )
125 : G4VSolid(a) << 108 : G4VSolid(a), fPtrSolid(0), fPtrTransform(0),
>> 109 fDirectTransform(0), fpPolyhedron(0)
126 { 110 {
127 } 111 }
128 112
129 ////////////////////////////////////////////// 113 ///////////////////////////////////////////////////////////////////
130 // 114 //
131 // Destructor 115 // Destructor
132 116
133 G4DisplacedSolid::~G4DisplacedSolid() 117 G4DisplacedSolid::~G4DisplacedSolid()
134 { 118 {
135 CleanTransformations(); 119 CleanTransformations();
136 delete fpPolyhedron; fpPolyhedron = nullptr; << 120 delete fpPolyhedron;
137 } 121 }
138 122
139 ////////////////////////////////////////////// << 123 G4GeometryType G4DisplacedSolid::GetEntityType() const
140 // <<
141 // Copy constructor <<
142 <<
143 G4DisplacedSolid::G4DisplacedSolid(const G4Dis <<
144 : G4VSolid (rhs), fPtrSolid(rhs.fPtrSolid) <<
145 { 124 {
146 fPtrTransform = new G4AffineTransform(*(rhs. << 125 return G4String("G4DisplacedSolid");
147 fDirectTransform = new G4AffineTransform(*(r <<
148 } 126 }
149 127
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() 128 void G4DisplacedSolid::CleanTransformations()
177 { 129 {
178 if(fPtrTransform != nullptr) << 130 if(fPtrTransform)
179 { 131 {
180 delete fPtrTransform; fPtrTransform = null << 132 delete fPtrTransform; fPtrTransform=0;
181 delete fDirectTransform; fDirectTransform << 133 delete fDirectTransform; fDirectTransform=0;
182 } 134 }
183 } 135 }
184 136
185 const G4DisplacedSolid* G4DisplacedSolid::GetD 137 const G4DisplacedSolid* G4DisplacedSolid::GetDisplacedSolidPtr() const
186 { 138 {
187 return this; 139 return this;
188 } 140 }
189 141
190 G4DisplacedSolid* G4DisplacedSolid::GetDisplac 142 G4DisplacedSolid* G4DisplacedSolid::GetDisplacedSolidPtr()
191 { 143 {
192 return this; 144 return this;
193 } 145 }
194 146
195 G4VSolid* G4DisplacedSolid::GetConstituentMove 147 G4VSolid* G4DisplacedSolid::GetConstituentMovedSolid() const
196 { 148 {
197 return fPtrSolid; 149 return fPtrSolid;
198 } 150 }
199 151
200 ////////////////////////////////////////////// 152 /////////////////////////////////////////////////////////////////////////////
201 153
202 G4AffineTransform G4DisplacedSolid::GetTransf 154 G4AffineTransform G4DisplacedSolid::GetTransform() const
203 { 155 {
204 G4AffineTransform aTransform = *fPtrTransfor 156 G4AffineTransform aTransform = *fPtrTransform;
205 return aTransform; 157 return aTransform;
206 } 158 }
207 159
208 void G4DisplacedSolid::SetTransform(G4AffineTr 160 void G4DisplacedSolid::SetTransform(G4AffineTransform& transform)
209 { 161 {
210 fPtrTransform = &transform ; 162 fPtrTransform = &transform ;
211 fRebuildPolyhedron = true; << 163 fpPolyhedron = 0;
212 } 164 }
213 165
214 ////////////////////////////////////////////// 166 //////////////////////////////////////////////////////////////////////////////
215 167
216 G4AffineTransform G4DisplacedSolid::GetDirect 168 G4AffineTransform G4DisplacedSolid::GetDirectTransform() const
217 { 169 {
218 G4AffineTransform aTransform= *fDirectTransf 170 G4AffineTransform aTransform= *fDirectTransform;
219 return aTransform; 171 return aTransform;
220 } 172 }
221 173
222 void G4DisplacedSolid::SetDirectTransform(G4Af 174 void G4DisplacedSolid::SetDirectTransform(G4AffineTransform& transform)
223 { 175 {
224 fDirectTransform = &transform ; 176 fDirectTransform = &transform ;
225 fRebuildPolyhedron = true; << 177 fpPolyhedron = 0;
226 } 178 }
227 179
228 ////////////////////////////////////////////// 180 /////////////////////////////////////////////////////////////////////////////
229 181
230 G4RotationMatrix G4DisplacedSolid::GetFrameRot 182 G4RotationMatrix G4DisplacedSolid::GetFrameRotation() const
231 { 183 {
232 G4RotationMatrix InvRotation = fDirectTransf << 184 G4RotationMatrix InvRotation= fDirectTransform->NetRotation();
233 return InvRotation; 185 return InvRotation;
234 } 186 }
235 187
236 void G4DisplacedSolid::SetFrameRotation(const 188 void G4DisplacedSolid::SetFrameRotation(const G4RotationMatrix& matrix)
237 { 189 {
238 fDirectTransform->SetNetRotation(matrix); 190 fDirectTransform->SetNetRotation(matrix);
239 fRebuildPolyhedron = true; << 191 fpPolyhedron = 0;
240 } 192 }
241 193
242 ////////////////////////////////////////////// 194 /////////////////////////////////////////////////////////////////////////////
243 195
244 G4ThreeVector G4DisplacedSolid::GetFrameTrans 196 G4ThreeVector G4DisplacedSolid::GetFrameTranslation() const
245 { 197 {
246 return fPtrTransform->NetTranslation(); 198 return fPtrTransform->NetTranslation();
247 } 199 }
248 200
249 void G4DisplacedSolid::SetFrameTranslation(con 201 void G4DisplacedSolid::SetFrameTranslation(const G4ThreeVector& vector)
250 { 202 {
251 fPtrTransform->SetNetTranslation(vector); 203 fPtrTransform->SetNetTranslation(vector);
252 fRebuildPolyhedron = true; << 204 fpPolyhedron = 0;
253 } 205 }
254 206
255 ////////////////////////////////////////////// 207 ///////////////////////////////////////////////////////////////
256 208
257 G4RotationMatrix G4DisplacedSolid::GetObjectRo 209 G4RotationMatrix G4DisplacedSolid::GetObjectRotation() const
258 { 210 {
259 G4RotationMatrix Rotation = fPtrTransform->N << 211 G4RotationMatrix Rotation= fPtrTransform->NetRotation();
260 return Rotation; 212 return Rotation;
261 } 213 }
262 214
263 void G4DisplacedSolid::SetObjectRotation(const 215 void G4DisplacedSolid::SetObjectRotation(const G4RotationMatrix& matrix)
264 { 216 {
265 fPtrTransform->SetNetRotation(matrix); 217 fPtrTransform->SetNetRotation(matrix);
266 fRebuildPolyhedron = true; << 218 fpPolyhedron = 0;
267 } 219 }
268 220
269 ////////////////////////////////////////////// 221 ///////////////////////////////////////////////////////////////////////
270 222
271 G4ThreeVector G4DisplacedSolid::GetObjectTran 223 G4ThreeVector G4DisplacedSolid::GetObjectTranslation() const
272 { 224 {
273 return fDirectTransform->NetTranslation(); 225 return fDirectTransform->NetTranslation();
274 } 226 }
275 227
276 void G4DisplacedSolid::SetObjectTranslation(co 228 void G4DisplacedSolid::SetObjectTranslation(const G4ThreeVector& vector)
277 { 229 {
278 fDirectTransform->SetNetTranslation(vector); 230 fDirectTransform->SetNetTranslation(vector);
279 fRebuildPolyhedron = true; << 231 fpPolyhedron = 0;
280 } 232 }
281 233
282 ////////////////////////////////////////////// << 234 ///////////////////////////////////////////////////////////////
283 // 235 //
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 // 236 //
328 // Calculate extent under transform and specif <<
329 237
330 G4bool 238 G4bool
331 G4DisplacedSolid::CalculateExtent( const EAxis 239 G4DisplacedSolid::CalculateExtent( const EAxis pAxis,
332 const G4Vox 240 const G4VoxelLimits& pVoxelLimit,
333 const G4Aff 241 const G4AffineTransform& pTransform,
334 G4dou 242 G4double& pMin,
335 G4dou 243 G4double& pMax ) const
336 { 244 {
337 G4AffineTransform sumTransform ; 245 G4AffineTransform sumTransform ;
338 sumTransform.Product(*fDirectTransform,pTran 246 sumTransform.Product(*fDirectTransform,pTransform) ;
339 return fPtrSolid->CalculateExtent(pAxis,pVox 247 return fPtrSolid->CalculateExtent(pAxis,pVoxelLimit,sumTransform,pMin,pMax) ;
340 } 248 }
341 249
342 ////////////////////////////////////////////// 250 /////////////////////////////////////////////////////
343 // 251 //
344 // SurfaceNormal << 252 //
345 253
346 EInside G4DisplacedSolid::Inside(const G4Three 254 EInside G4DisplacedSolid::Inside(const G4ThreeVector& p) const
347 { 255 {
348 G4ThreeVector newPoint = fPtrTransform->Tran 256 G4ThreeVector newPoint = fPtrTransform->TransformPoint(p) ;
349 return fPtrSolid->Inside(newPoint) ; 257 return fPtrSolid->Inside(newPoint) ;
350 } 258 }
351 259
352 ////////////////////////////////////////////// 260 //////////////////////////////////////////////////////////////
353 // 261 //
354 // 262 //
355 263
356 G4ThreeVector 264 G4ThreeVector
357 G4DisplacedSolid::SurfaceNormal( const G4Three 265 G4DisplacedSolid::SurfaceNormal( const G4ThreeVector& p ) const
358 { 266 {
359 G4ThreeVector newPoint = fPtrTransform->Tran 267 G4ThreeVector newPoint = fPtrTransform->TransformPoint(p) ;
360 G4ThreeVector normal = fPtrSolid->SurfaceNor 268 G4ThreeVector normal = fPtrSolid->SurfaceNormal(newPoint) ;
361 return fDirectTransform->TransformAxis(norma 269 return fDirectTransform->TransformAxis(normal) ;
362 } 270 }
363 271
364 ////////////////////////////////////////////// 272 /////////////////////////////////////////////////////////////
365 // 273 //
366 // The same algorithm as in DistanceToIn(p) 274 // The same algorithm as in DistanceToIn(p)
367 275
368 G4double 276 G4double
369 G4DisplacedSolid::DistanceToIn( const G4ThreeV 277 G4DisplacedSolid::DistanceToIn( const G4ThreeVector& p,
370 const G4ThreeV 278 const G4ThreeVector& v ) const
371 { 279 {
372 G4ThreeVector newPoint = fPtrTransform->Tran 280 G4ThreeVector newPoint = fPtrTransform->TransformPoint(p) ;
373 G4ThreeVector newDirection = fPtrTransform-> 281 G4ThreeVector newDirection = fPtrTransform->TransformAxis(v) ;
374 return fPtrSolid->DistanceToIn(newPoint,newD 282 return fPtrSolid->DistanceToIn(newPoint,newDirection) ;
375 } 283 }
376 284
377 ////////////////////////////////////////////// 285 ////////////////////////////////////////////////////////
378 // 286 //
379 // Approximate nearest distance from the point 287 // Approximate nearest distance from the point p to the intersection of
380 // two solids 288 // two solids
381 289
382 G4double 290 G4double
383 G4DisplacedSolid::DistanceToIn( const G4ThreeV 291 G4DisplacedSolid::DistanceToIn( const G4ThreeVector& p ) const
384 { 292 {
385 G4ThreeVector newPoint = fPtrTransform->Tran 293 G4ThreeVector newPoint = fPtrTransform->TransformPoint(p) ;
386 return fPtrSolid->DistanceToIn(newPoint) ; 294 return fPtrSolid->DistanceToIn(newPoint) ;
387 } 295 }
388 296
389 ////////////////////////////////////////////// 297 //////////////////////////////////////////////////////////
390 // 298 //
391 // The same algorithm as DistanceToOut(p) 299 // The same algorithm as DistanceToOut(p)
392 300
393 G4double 301 G4double
394 G4DisplacedSolid::DistanceToOut( const G4Three 302 G4DisplacedSolid::DistanceToOut( const G4ThreeVector& p,
395 const G4Three 303 const G4ThreeVector& v,
396 const G4bool 304 const G4bool calcNorm,
397 G4bool 305 G4bool *validNorm,
398 G4Three 306 G4ThreeVector *n ) const
399 { 307 {
400 G4ThreeVector solNorm ; 308 G4ThreeVector solNorm ;
401 G4ThreeVector newPoint = fPtrTransform->Tran 309 G4ThreeVector newPoint = fPtrTransform->TransformPoint(p) ;
402 G4ThreeVector newDirection = fPtrTransform-> 310 G4ThreeVector newDirection = fPtrTransform->TransformAxis(v) ;
403 G4double dist = fPtrSolid->DistanceToOut(new 311 G4double dist = fPtrSolid->DistanceToOut(newPoint,newDirection,
404 cal 312 calcNorm,validNorm,&solNorm) ;
405 if(calcNorm) 313 if(calcNorm)
406 { 314 {
407 *n = fDirectTransform->TransformAxis(solNo 315 *n = fDirectTransform->TransformAxis(solNorm) ;
408 } 316 }
409 return dist ; 317 return dist ;
410 } 318 }
411 319
412 ////////////////////////////////////////////// 320 //////////////////////////////////////////////////////////////
413 // 321 //
414 // Inverted algorithm of DistanceToIn(p) 322 // Inverted algorithm of DistanceToIn(p)
415 323
416 G4double 324 G4double
417 G4DisplacedSolid::DistanceToOut( const G4Three 325 G4DisplacedSolid::DistanceToOut( const G4ThreeVector& p ) const
418 { 326 {
419 G4ThreeVector newPoint = fPtrTransform->Tran 327 G4ThreeVector newPoint = fPtrTransform->TransformPoint(p) ;
420 return fPtrSolid->DistanceToOut(newPoint) ; 328 return fPtrSolid->DistanceToOut(newPoint) ;
421 } 329 }
422 330
423 ////////////////////////////////////////////// 331 //////////////////////////////////////////////////////////////
424 // 332 //
425 // ComputeDimensions << 333 //
426 334
427 void 335 void
428 G4DisplacedSolid::ComputeDimensions( G4V 336 G4DisplacedSolid::ComputeDimensions( G4VPVParameterisation*,
429 const G4i 337 const G4int,
430 const G4V 338 const G4VPhysicalVolume* )
431 { 339 {
432 DumpInfo(); 340 DumpInfo();
433 G4Exception("G4DisplacedSolid::ComputeDimens 341 G4Exception("G4DisplacedSolid::ComputeDimensions()",
434 "GeomSolids0001", FatalException << 342 "NotApplicable", FatalException,
435 "Method not applicable in this c << 343 "Method not applicable in this context!");
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 } 344 }
455 345
456 ////////////////////////////////////////////// 346 //////////////////////////////////////////////////////////////////////////
457 // 347 //
458 // Returns a point (G4ThreeVector) randomly an 348 // Returns a point (G4ThreeVector) randomly and uniformly selected
459 // on the solid surface 349 // on the solid surface
460 // 350 //
461 351
462 G4ThreeVector G4DisplacedSolid::GetPointOnSurf 352 G4ThreeVector G4DisplacedSolid::GetPointOnSurface() const
463 { 353 {
464 G4ThreeVector p = fPtrSolid->GetPointOnSurfa << 354 G4ThreeVector p = fPtrSolid->GetPointOnSurface();
465 return fDirectTransform->TransformPoint(p); 355 return fDirectTransform->TransformPoint(p);
466 } 356 }
467 357
468 ////////////////////////////////////////////// 358 //////////////////////////////////////////////////////////////////////////
469 // 359 //
470 // Return the number of constituents used for <<
471 <<
472 G4int G4DisplacedSolid::GetNumOfConstituents() <<
473 { <<
474 return fPtrSolid->GetNumOfConstituents(); <<
475 } <<
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 360 // Stream object contents to an output stream
507 361
508 std::ostream& G4DisplacedSolid::StreamInfo(std 362 std::ostream& G4DisplacedSolid::StreamInfo(std::ostream& os) const
509 { 363 {
510 os << "------------------------------------- 364 os << "-----------------------------------------------------------\n"
511 << " *** Dump for Displaced solid - " 365 << " *** Dump for Displaced solid - " << GetName() << " ***\n"
512 << " ================================= 366 << " ===================================================\n"
513 << " Solid type: " << GetEntityType() << 367 << " Solid type: " << GetEntityType() << "\n"
514 << " Parameters of constituent solid: \n" 368 << " Parameters of constituent solid: \n"
515 << "===================================== 369 << "===========================================================\n";
516 fPtrSolid->StreamInfo(os); 370 fPtrSolid->StreamInfo(os);
517 os << "===================================== 371 os << "===========================================================\n"
518 << " Transformations: \n" 372 << " Transformations: \n"
519 << " Direct transformation - translati 373 << " Direct transformation - translation : \n"
520 << " " << fDirectTransform->Net 374 << " " << fDirectTransform->NetTranslation() << "\n"
521 << " - rotation 375 << " - rotation : \n"
522 << " "; 376 << " ";
523 fDirectTransform->NetRotation().print(os); 377 fDirectTransform->NetRotation().print(os);
524 os << "\n" 378 os << "\n"
525 << "===================================== 379 << "===========================================================\n";
526 380
527 return os; 381 return os;
528 } 382 }
529 383
530 ////////////////////////////////////////////// 384 //////////////////////////////////////////////////////////////////////////
531 // 385 //
532 // DescribeYourselfTo << 386 //
533 387
534 void 388 void
535 G4DisplacedSolid::DescribeYourselfTo ( G4VGrap 389 G4DisplacedSolid::DescribeYourselfTo ( G4VGraphicsScene& scene ) const
536 { 390 {
537 scene.AddSolid (*this); 391 scene.AddSolid (*this);
538 } 392 }
539 393
540 ////////////////////////////////////////////// 394 //////////////////////////////////////////////////////////////////////////
541 // 395 //
542 // CreatePolyhedron << 396 //
543 397
544 G4Polyhedron* 398 G4Polyhedron*
545 G4DisplacedSolid::CreatePolyhedron () const 399 G4DisplacedSolid::CreatePolyhedron () const
546 { 400 {
547 G4Polyhedron* polyhedron = fPtrSolid->Create 401 G4Polyhedron* polyhedron = fPtrSolid->CreatePolyhedron();
548 if (polyhedron != nullptr) << 402 polyhedron
549 { <<
550 polyhedron <<
551 ->Transform(G4Transform3D(GetObjectRotatio 403 ->Transform(G4Transform3D(GetObjectRotation(),GetObjectTranslation()));
552 } <<
553 else <<
554 { <<
555 DumpInfo(); <<
556 G4Exception("G4DisplacedSolid::CreatePolyh <<
557 "GeomSolids2002", JustWarning, <<
558 "No G4Polyhedron for displaced <<
559 } <<
560 return polyhedron; 404 return polyhedron;
561 } 405 }
562 406
563 ////////////////////////////////////////////// 407 //////////////////////////////////////////////////////////////////////////
564 // 408 //
565 // GetPolyhedron << 409 //
>> 410
>> 411 G4NURBS*
>> 412 G4DisplacedSolid::CreateNURBS () const
>> 413 {
>> 414 // Take into account local transformation - see CreatePolyhedron.
>> 415 // return fPtrSolid->CreateNURBS() ;
>> 416 return 0;
>> 417 }
>> 418
>> 419 //////////////////////////////////////////////////////////////////////////
>> 420 //
>> 421 //
566 422
567 G4Polyhedron* G4DisplacedSolid::GetPolyhedron 423 G4Polyhedron* G4DisplacedSolid::GetPolyhedron () const
568 { 424 {
569 if (fpPolyhedron == nullptr || << 425 if (!fpPolyhedron ||
570 fRebuildPolyhedron || <<
571 fpPolyhedron->GetNumberOfRotationStepsAt 426 fpPolyhedron->GetNumberOfRotationStepsAtTimeOfCreation() !=
572 fpPolyhedron->GetNumberOfRotationSteps() 427 fpPolyhedron->GetNumberOfRotationSteps())
573 { 428 {
>> 429 delete fpPolyhedron;
574 fpPolyhedron = CreatePolyhedron(); 430 fpPolyhedron = CreatePolyhedron();
575 fRebuildPolyhedron = false; <<
576 } 431 }
577 return fpPolyhedron; 432 return fpPolyhedron;
578 } 433 }
579 434