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