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-03-patch-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