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 // 26 // >> 27 // $Id: G4PhysicalVolumeModel.cc,v 1.63 2007/11/10 14:56:36 allison Exp $ >> 28 // GEANT4 tag $Name: geant4-09-02-patch-04 $ 27 // 29 // 28 // 30 // 29 // John Allison 31st December 1997. 31 // John Allison 31st December 1997. 30 // Model for physical volumes. 32 // Model for physical volumes. 31 33 32 #include "G4PhysicalVolumeModel.hh" 34 #include "G4PhysicalVolumeModel.hh" 33 35 >> 36 #include "G4ModelingParameters.hh" 34 #include "G4VGraphicsScene.hh" 37 #include "G4VGraphicsScene.hh" 35 #include "G4VPhysicalVolume.hh" 38 #include "G4VPhysicalVolume.hh" 36 #include "G4PhysicalVolumeStore.hh" << 37 #include "G4VPVParameterisation.hh" 39 #include "G4VPVParameterisation.hh" 38 #include "G4LogicalVolume.hh" 40 #include "G4LogicalVolume.hh" 39 #include "G4VSolid.hh" 41 #include "G4VSolid.hh" 40 #include "G4SubtractionSolid.hh" << 41 #include "G4IntersectionSolid.hh" << 42 #include "G4Material.hh" 42 #include "G4Material.hh" 43 #include "G4VisAttributes.hh" 43 #include "G4VisAttributes.hh" 44 #include "G4BoundingExtentScene.hh" << 44 #include "G4BoundingSphereScene.hh" >> 45 #include "G4PhysicalVolumeSearchScene.hh" 45 #include "G4TransportationManager.hh" 46 #include "G4TransportationManager.hh" 46 #include "G4Polyhedron.hh" 47 #include "G4Polyhedron.hh" 47 #include "HepPolyhedronProcessor.h" << 48 #include "G4AttDefStore.hh" 48 #include "G4AttDefStore.hh" 49 #include "G4AttDef.hh" 49 #include "G4AttDef.hh" 50 #include "G4AttValue.hh" 50 #include "G4AttValue.hh" 51 #include "G4UnitsTable.hh" 51 #include "G4UnitsTable.hh" 52 #include "G4Vector3D.hh" 52 #include "G4Vector3D.hh" 53 #include "G4Mesh.hh" << 54 53 55 #include <sstream> 54 #include <sstream> 56 #include <iomanip> << 57 << 58 #define G4warn G4cout << 59 55 60 G4PhysicalVolumeModel::G4PhysicalVolumeModel << 56 G4bool G4PhysicalVolumeModel::G4PhysicalVolumeNodeID::operator< 61 (G4VPhysicalVolume* pVPV << 57 (const G4PhysicalVolumeModel::G4PhysicalVolumeNodeID& right) const 62 , G4int requestedDepth << 63 , const G4Transform3D& modelTransform << 64 , const G4ModelingParameters* pMP << 65 , G4bool useFullExtent << 66 , const std::vector<G4PhysicalVolumeNodeID>& << 67 : G4VModel (pMP) << 68 , fpTopPV (pVPV) << 69 , fTopPVCopyNo (pVPV? pVPV->GetCopyNo(): << 70 , fRequestedDepth (requestedDepth) << 71 , fUseFullExtent (useFullExtent) << 72 , fTransform (modelTransform) << 73 , fCurrentDepth (0) << 74 , fpCurrentPV (fpTopPV) << 75 , fCurrentPVCopyNo (fpTopPV? fpTopPV->GetCop << 76 , fpCurrentLV (fpTopPV? fpTopPV->GetLog << 77 , fpCurrentMaterial (fpCurrentLV? fpCurrentLV << 78 , fCurrentTransform (modelTransform) << 79 , fBaseFullPVPath (baseFullPVPath) << 80 , fFullPVPath (fBaseFullPVPath) << 81 , fAbort (false) << 82 , fCurtailDescent (false) << 83 , fpClippingSolid (0) << 84 , fClippingMode (subtraction) << 85 , fNClippers (0) << 86 , fTotalTouchables (0) << 87 { 58 { 88 fType = "G4PhysicalVolumeModel"; << 59 if (fpPV < right.fpPV) return true; 89 << 60 if (fpPV == right.fpPV) { 90 if (!fpTopPV) { << 61 if (fCopyNo < right.fCopyNo) return true; 91 << 62 if (fCopyNo == right.fCopyNo) 92 // In some circumstances creating an "empt << 63 return fNonCulledDepth < right.fNonCulledDepth; 93 // allowed, so I have supressed the G4Exce << 94 // be a problem we might have to re-instat << 95 // be used except by visualisation experts << 96 // where it is used simply to get a list o << 97 // G4Exception << 98 // ("G4PhysicalVolumeModel::G4PhysicalV << 99 // "modeling0010", FatalException, "Nu << 100 << 101 fTopPVName = "NULL"; << 102 fGlobalTag = "Empty"; << 103 fGlobalDescription = "G4PhysicalVolumeMode << 104 << 105 } else { << 106 << 107 fTopPVName = fpTopPV -> GetName (); << 108 std::ostringstream oss; << 109 oss << fpTopPV->GetName() << ':' << fpTopP << 110 << " BasePath:" << fBaseFullPVPath; << 111 fGlobalTag = oss.str(); << 112 fGlobalDescription = "G4PhysicalVolumeMode << 113 CalculateExtent (); << 114 } 64 } >> 65 return false; 115 } 66 } 116 67 117 G4PhysicalVolumeModel::~G4PhysicalVolumeModel << 68 std::ostream& operator<< >> 69 (std::ostream& os, const G4PhysicalVolumeModel::G4PhysicalVolumeNodeID node) 118 { 70 { 119 delete fpClippingSolid; << 71 G4VPhysicalVolume* pPV = node.GetPhysicalVolume(); >> 72 if (pPV) { >> 73 os << pPV->GetName() >> 74 << ':' << node.GetCopyNo() >> 75 << '[' << node.GetNonCulledDepth() << ']'; >> 76 } else { >> 77 os << "Null node"; >> 78 } >> 79 return os; 120 } 80 } 121 81 122 G4ModelingParameters::PVNameCopyNoPath G4Physi << 82 G4PhysicalVolumeModel::G4PhysicalVolumeModel 123 (const std::vector<G4PhysicalVolumeNodeID>& pa << 83 (G4VPhysicalVolume* pVPV, 124 { << 84 G4int requestedDepth, 125 G4ModelingParameters::PVNameCopyNoPath PVNam << 85 const G4Transform3D& modelTransformation, 126 for (const auto& node: path) { << 86 const G4ModelingParameters* pMP, 127 PVNameCopyNoPath.push_back << 87 G4bool useFullExtent): 128 (G4ModelingParameters::PVNameCopyNo << 88 G4VModel (modelTransformation, pMP), 129 (node.GetPhysicalVolume()->GetName(),node << 89 fpTopPV (pVPV), 130 } << 90 fTopPVName (pVPV -> GetName ()), 131 return PVNameCopyNoPath; << 91 fTopPVCopyNo (pVPV -> GetCopyNo ()), >> 92 fRequestedDepth (requestedDepth), >> 93 fUseFullExtent (useFullExtent), >> 94 fCurrentDepth (0), >> 95 fpCurrentPV (0), >> 96 fpCurrentLV (0), >> 97 fpCurrentMaterial (0), >> 98 fpCurrentTransform (0), >> 99 fCurtailDescent (false), >> 100 fpClippingPolyhedron (0), >> 101 fClippingMode (subtraction) >> 102 { >> 103 std::ostringstream o; >> 104 o << fpTopPV -> GetCopyNo (); >> 105 fGlobalTag = fpTopPV -> GetName () + "." + o.str(); >> 106 fGlobalDescription = "G4PhysicalVolumeModel " + fGlobalTag; >> 107 >> 108 CalculateExtent (); 132 } 109 } 133 110 134 G4String G4PhysicalVolumeModel::GetPVNamePathS << 111 G4PhysicalVolumeModel::~G4PhysicalVolumeModel () 135 (const std::vector<G4PhysicalVolumeNodeID>& pa << 136 // Converts to path string, e.g., " World 0 En << 137 // Note leading space character. << 138 { 112 { 139 std::ostringstream oss; << 113 delete fpClippingPolyhedron; 140 oss << path; << 141 return oss.str(); << 142 } 114 } 143 115 144 void G4PhysicalVolumeModel::CalculateExtent () 116 void G4PhysicalVolumeModel::CalculateExtent () 145 { 117 { 146 // To handle paramaterisations, set copy num << 147 // to get extent right << 148 G4VPVParameterisation* pP = fpTopPV -> GetPa << 149 if (pP) { << 150 fpTopPV -> SetCopyNo (fTopPVCopyNo); << 151 G4VSolid* solid = pP -> ComputeSolid (fTop << 152 solid -> ComputeDimensions (pP, fTopPVCopy << 153 } << 154 if (fUseFullExtent) { 118 if (fUseFullExtent) { 155 fExtent = fpTopPV -> GetLogicalVolume () - 119 fExtent = fpTopPV -> GetLogicalVolume () -> GetSolid () -> GetExtent (); 156 } else { << 120 } 157 // Calculate extent of *drawn* volumes, i. << 121 else { 158 // invisible volumes, by traversing the wh << 122 G4BoundingSphereScene bsScene(this); 159 // this physical volume. << 160 G4BoundingExtentScene beScene(this); << 161 const G4int tempRequestedDepth = fRequeste 123 const G4int tempRequestedDepth = fRequestedDepth; 162 const G4Transform3D tempTransform = fTrans << 163 const G4ModelingParameters* tempMP = fpMP; << 164 fRequestedDepth = -1; // Always search to 124 fRequestedDepth = -1; // Always search to all depths to define extent. 165 fTransform = G4Transform3D(); // Extent i << 125 const G4ModelingParameters* tempMP = fpMP; 166 G4ModelingParameters mParams 126 G4ModelingParameters mParams 167 (0, // No default vis attributes ne 127 (0, // No default vis attributes needed. 168 G4ModelingParameters::wf, // wireframe 128 G4ModelingParameters::wf, // wireframe (not relevant for this). 169 true, // Global culling. 129 true, // Global culling. 170 true, // Cull invisible volumes. 130 true, // Cull invisible volumes. 171 false, // Density culling. 131 false, // Density culling. 172 0., // Density (not relevant if den 132 0., // Density (not relevant if density culling false). 173 true, // Cull daughters of opaque mot 133 true, // Cull daughters of opaque mothers. 174 24); // No of sides (not relevant fo 134 24); // No of sides (not relevant for this operation). 175 mParams.SetSpecialMeshRendering(true); // << 176 fpMP = &mParams; 135 fpMP = &mParams; 177 DescribeYourselfTo (beScene); << 136 DescribeYourselfTo (bsScene); 178 fExtent = beScene.GetBoundingExtent(); << 137 G4double radius = bsScene.GetRadius(); >> 138 if (radius < 0.) { // Nothing in the scene. >> 139 fExtent = fpTopPV -> GetLogicalVolume () -> GetSolid () -> GetExtent (); >> 140 } else { >> 141 // Transform back to coordinates relative to the top >> 142 // transformation, which is in G4VModel::fTransform. This makes >> 143 // it conform to all models, which are defined by a >> 144 // transformation and an extent relative to that >> 145 // transformation... >> 146 G4Point3D centre = bsScene.GetCentre(); >> 147 centre.transform(fTransform.inverse()); >> 148 fExtent = G4VisExtent(centre, radius); >> 149 } 179 fpMP = tempMP; 150 fpMP = tempMP; 180 fTransform = tempTransform; << 181 fRequestedDepth = tempRequestedDepth; 151 fRequestedDepth = tempRequestedDepth; 182 } 152 } 183 G4double radius = fExtent.GetExtentRadius(); << 184 if (radius < 0.) { // Nothing in the scene << 185 fExtent = fpTopPV -> GetLogicalVolume () - << 186 } << 187 fExtent.Transform(fTransform); << 188 } 153 } 189 154 190 void G4PhysicalVolumeModel::DescribeYourselfTo 155 void G4PhysicalVolumeModel::DescribeYourselfTo 191 (G4VGraphicsScene& sceneHandler) 156 (G4VGraphicsScene& sceneHandler) 192 { 157 { 193 if (!fpTopPV) { << 158 if (!fpMP) G4Exception 194 G4Exception << 159 ("G4PhysicalVolumeModel::DescribeYourselfTo: No modeling parameters."); 195 ("G4PhysicalVolumeModel::DescribeYourselfT << 196 "modeling0012", FatalException, "No model << 197 return; // Should never reach here, but k << 198 } << 199 160 200 if (!fpMP) { << 161 // For safety... 201 G4Exception << 162 fCurrentDepth = 0; 202 ("G4PhysicalVolumeModel::DescribeYourselfT << 203 "modeling0013", FatalException, "No model << 204 return; // Should never reach here, but k << 205 } << 206 << 207 fNClippers = 0; << 208 G4DisplacedSolid* pSectionSolid = fpMP->GetS << 209 G4DisplacedSolid* pCutawaySolid = fpMP->GetC << 210 if (fpClippingSolid) fNClippers++; << 211 if (pSectionSolid) fNClippers++; << 212 if (pCutawaySolid) fNClippers++; << 213 if (fNClippers > 1) { << 214 G4ExceptionDescription ed; << 215 ed << "More than one solid cutter/clipper: << 216 if (fpClippingSolid) ed << "\nclipper in f << 217 if (pSectionSolid) ed << "\nsectioner in << 218 if (pCutawaySolid) ed << "\ncutaway in f << 219 G4Exception("G4PhysicalVolumeModel::Descri << 220 } << 221 163 222 G4Transform3D startingTransformation = fTran 164 G4Transform3D startingTransformation = fTransform; 223 165 224 fNTouchables.clear(); // Keeps count of tou << 225 << 226 VisitGeometryAndGetVisReps 166 VisitGeometryAndGetVisReps 227 (fpTopPV, 167 (fpTopPV, 228 fRequestedDepth, 168 fRequestedDepth, 229 startingTransformation, 169 startingTransformation, 230 sceneHandler); 170 sceneHandler); 231 171 232 fTotalTouchables = 0; << 172 // Clear data... 233 for (const auto& entry : fNTouchables) { << 234 fTotalTouchables += entry.second; << 235 } << 236 << 237 // Reset or clear data... << 238 fCurrentDepth = 0; 173 fCurrentDepth = 0; 239 fpCurrentPV = fpTopPV; << 174 fpCurrentPV = 0; 240 fCurrentPVCopyNo = fpTopPV->GetCopyNo(); << 175 fpCurrentLV = 0; 241 fpCurrentLV = fpTopPV->GetLogicalVolum << 176 fpCurrentMaterial = 0; 242 fpCurrentMaterial = fpCurrentLV? fpCurrentLV << 177 fFullPVPath.clear(); 243 fFullPVPath = fBaseFullPVPath; << 244 fDrawnPVPath.clear(); 178 fDrawnPVPath.clear(); 245 fAbort = false; << 246 fCurtailDescent = false; << 247 } 179 } 248 180 249 G4String G4PhysicalVolumeModel::GetCurrentTag 181 G4String G4PhysicalVolumeModel::GetCurrentTag () const 250 { 182 { 251 if (fpCurrentPV) { 183 if (fpCurrentPV) { 252 std::ostringstream o; 184 std::ostringstream o; 253 o << fpCurrentPV -> GetCopyNo (); 185 o << fpCurrentPV -> GetCopyNo (); 254 return fpCurrentPV -> GetName () + ":" + o << 186 return fpCurrentPV -> GetName () + "." + o.str(); 255 } 187 } 256 else { 188 else { 257 return "WARNING: NO CURRENT VOLUME - globa 189 return "WARNING: NO CURRENT VOLUME - global tag is " + fGlobalTag; 258 } 190 } 259 } 191 } 260 192 261 G4String G4PhysicalVolumeModel::GetCurrentDesc 193 G4String G4PhysicalVolumeModel::GetCurrentDescription () const 262 { 194 { 263 return "G4PhysicalVolumeModel " + GetCurrent 195 return "G4PhysicalVolumeModel " + GetCurrentTag (); 264 } 196 } 265 197 266 void G4PhysicalVolumeModel::VisitGeometryAndGe 198 void G4PhysicalVolumeModel::VisitGeometryAndGetVisReps 267 (G4VPhysicalVolume* pVPV, 199 (G4VPhysicalVolume* pVPV, 268 G4int requestedDepth, 200 G4int requestedDepth, 269 const G4Transform3D& theAT, 201 const G4Transform3D& theAT, 270 G4VGraphicsScene& sceneHandler) 202 G4VGraphicsScene& sceneHandler) 271 { 203 { 272 // Visits geometry structure to a given dept 204 // Visits geometry structure to a given depth (requestedDepth), starting 273 // at given physical volume with given sta 205 // at given physical volume with given starting transformation and 274 // describes volumes to the scene handler. 206 // describes volumes to the scene handler. 275 // requestedDepth < 0 (default) implies full 207 // requestedDepth < 0 (default) implies full visit. 276 // theAT is the Accumulated Transformation. 208 // theAT is the Accumulated Transformation. 277 209 278 // Find corresponding logical volume and (la 210 // Find corresponding logical volume and (later) solid, storing in 279 // local variables to preserve re-entrancy. 211 // local variables to preserve re-entrancy. 280 G4LogicalVolume* pLV = pVPV -> GetLogicalVo 212 G4LogicalVolume* pLV = pVPV -> GetLogicalVolume (); 281 G4VSolid* pSol = nullptr; << 213 282 G4Material* pMaterial = nullptr; << 214 G4VSolid* pSol; >> 215 G4Material* pMaterial; 283 216 284 if (!(pVPV -> IsReplicated ())) { 217 if (!(pVPV -> IsReplicated ())) { 285 // Non-replicated physical volume. 218 // Non-replicated physical volume. 286 pSol = pLV -> GetSolid (); 219 pSol = pLV -> GetSolid (); 287 pMaterial = pLV -> GetMaterial (); 220 pMaterial = pLV -> GetMaterial (); 288 DescribeAndDescend (pVPV, requestedDepth, 221 DescribeAndDescend (pVPV, requestedDepth, pLV, pSol, pMaterial, 289 theAT, sceneHandler); 222 theAT, sceneHandler); 290 } 223 } 291 else { 224 else { 292 // Replicated or parametrised physical vol 225 // Replicated or parametrised physical volume. 293 EAxis axis; 226 EAxis axis; 294 G4int nReplicas; 227 G4int nReplicas; 295 G4double width; 228 G4double width; 296 G4double offset; 229 G4double offset; 297 G4bool consuming; 230 G4bool consuming; 298 pVPV -> GetReplicationData (axis, nReplica 231 pVPV -> GetReplicationData (axis, nReplicas, width, offset, consuming); 299 G4int nBegin = 0; << 300 G4int nEnd = nReplicas; << 301 if (fCurrentDepth == 0) { // i.e., top vol << 302 nBegin = fTopPVCopyNo; // Describe only << 303 nEnd = nBegin + 1; // specified by << 304 } << 305 G4VPVParameterisation* pP = pVPV -> GetPar 232 G4VPVParameterisation* pP = pVPV -> GetParameterisation (); 306 if (pP) { // Parametrised volume. 233 if (pP) { // Parametrised volume. 307 for (int n = nBegin; n < nEnd; n++) { << 234 for (int n = 0; n < nReplicas; n++) { 308 pSol = pP -> ComputeSolid (n, pVPV); << 235 pSol = pP -> ComputeSolid (n, pVPV); 309 pP -> ComputeTransformation (n, pVPV); << 236 pMaterial = pP -> ComputeMaterial (n, pVPV); 310 pSol -> ComputeDimensions (pP, n, pVPV << 237 pP -> ComputeTransformation (n, pVPV); 311 pVPV -> SetCopyNo (n); << 238 pSol -> ComputeDimensions (pP, n, pVPV); 312 fCurrentPVCopyNo = n; << 239 pVPV -> SetCopyNo (n); 313 // Create a touchable of current paren << 240 DescribeAndDescend (pVPV, requestedDepth, pLV, pSol, pMaterial, 314 // fFullPVPath has not been updated ye << 241 theAT, sceneHandler); 315 // corresponds to the parent. << 316 G4PhysicalVolumeModelTouchable parentT << 317 pMaterial = pP -> ComputeMaterial (n, << 318 DescribeAndDescend (pVPV, requestedDep << 319 theAT, sceneHandle << 320 } 242 } 321 } 243 } 322 else { // Plain replicated volume. From 244 else { // Plain replicated volume. From geometry_guide.txt... 323 // The replica's positions are claculate 245 // The replica's positions are claculated by means of a linear formula. 324 // Replication may occur along: 246 // Replication may occur along: 325 // 247 // 326 // o Cartesian axes (kXAxis,kYAxis,kZAxi 248 // o Cartesian axes (kXAxis,kYAxis,kZAxis) 327 // 249 // 328 // The replications, of specified widt 250 // The replications, of specified width have coordinates of 329 // form (-width*(nReplicas-1)*0.5+n*wi 251 // form (-width*(nReplicas-1)*0.5+n*width,0,0) where n=0.. nReplicas-1 330 // for the case of kXAxis, and are unr 252 // for the case of kXAxis, and are unrotated. 331 // 253 // 332 // o Radial axis (cylindrical polar) (kR 254 // o Radial axis (cylindrical polar) (kRho) 333 // 255 // 334 // The replications are cons/tubs sect 256 // The replications are cons/tubs sections, centred on the origin 335 // and are unrotated. 257 // and are unrotated. 336 // They have radii of width*n+offset t 258 // They have radii of width*n+offset to width*(n+1)+offset 337 // where n=0..nRepl 259 // where n=0..nReplicas-1 338 // 260 // 339 // o Phi axis (cylindrical polar) (kPhi) 261 // o Phi axis (cylindrical polar) (kPhi) 340 // The replications are `phi sections' 262 // The replications are `phi sections' or wedges, and of cons/tubs form 341 // They have phi of offset+n*width to 263 // They have phi of offset+n*width to offset+(n+1)*width where 342 // n=0..nReplicas-1 264 // n=0..nReplicas-1 343 // 265 // 344 pSol = pLV -> GetSolid (); 266 pSol = pLV -> GetSolid (); 345 pMaterial = pLV -> GetMaterial (); 267 pMaterial = pLV -> GetMaterial (); 346 G4ThreeVector originalTranslation = pVPV 268 G4ThreeVector originalTranslation = pVPV -> GetTranslation (); 347 G4RotationMatrix* pOriginalRotation = pV 269 G4RotationMatrix* pOriginalRotation = pVPV -> GetRotation (); 348 G4double originalRMin = 0., originalRMax 270 G4double originalRMin = 0., originalRMax = 0.; 349 if (axis == kRho && pSol->GetEntityType( 271 if (axis == kRho && pSol->GetEntityType() == "G4Tubs") { 350 originalRMin = ((G4Tubs*)pSol)->GetInn << 272 originalRMin = ((G4Tubs*)pSol)->GetInnerRadius(); 351 originalRMax = ((G4Tubs*)pSol)->GetOut << 273 originalRMax = ((G4Tubs*)pSol)->GetOuterRadius(); 352 } 274 } 353 G4bool visualisable = true; 275 G4bool visualisable = true; 354 for (int n = nBegin; n < nEnd; n++) { << 276 for (int n = 0; n < nReplicas; n++) { 355 G4ThreeVector translation; // Identit << 277 G4ThreeVector translation; // Null. 356 G4RotationMatrix rotation; // Identit << 278 G4RotationMatrix rotation; // Null - life long enough for visualizing. 357 G4RotationMatrix* pRotation = 0; << 279 G4RotationMatrix* pRotation = 0; 358 switch (axis) { << 280 switch (axis) { 359 default: << 281 default: 360 case kXAxis: << 282 case kXAxis: 361 translation = G4ThreeVector (-widt << 283 translation = G4ThreeVector (-width*(nReplicas-1)*0.5+n*width,0,0); 362 break; << 284 break; 363 case kYAxis: << 285 case kYAxis: 364 translation = G4ThreeVector (0,-wi << 286 translation = G4ThreeVector (0,-width*(nReplicas-1)*0.5+n*width,0); 365 break; << 287 break; 366 case kZAxis: << 288 case kZAxis: 367 translation = G4ThreeVector (0,0,- << 289 translation = G4ThreeVector (0,0,-width*(nReplicas-1)*0.5+n*width); 368 break; << 290 break; 369 case kRho: << 291 case kRho: 370 if (pSol->GetEntityType() == "G4Tu << 292 if (pSol->GetEntityType() == "G4Tubs") { 371 ((G4Tubs*)pSol)->SetInnerRadius( << 293 ((G4Tubs*)pSol)->SetInnerRadius(width*n+offset); 372 ((G4Tubs*)pSol)->SetOuterRadius( << 294 ((G4Tubs*)pSol)->SetOuterRadius(width*(n+1)+offset); 373 } else { << 295 } else { 374 if (fpMP->IsWarning()) << 296 if (fpMP->IsWarning()) 375 G4warn << << 297 G4cout << 376 "G4PhysicalVolumeModel::VisitG << 298 "G4PhysicalVolumeModel::VisitGeometryAndGetVisReps: WARNING:" 377 "\n built-in replicated volum << 299 "\n built-in replicated volumes replicated in radius for " 378 << pSol->GetEntityType() << << 300 << pSol->GetEntityType() << 379 "-type\n solids (your solid \ << 301 "-type\n solids (your solid \"" 380 << pSol->GetName() << << 302 << pSol->GetName() << 381 "\") are not visualisable." << 303 "\") are not visualisable." 382 << G4endl; << 304 << G4endl; 383 visualisable = false; << 305 visualisable = false; 384 } << 306 } 385 break; << 307 break; 386 case kPhi: << 308 case kPhi: 387 rotation.rotateZ (-(offset+(n+0.5) << 309 rotation.rotateZ (-(offset+(n+0.5)*width)); 388 // Minus Sign because for the phys << 310 // Minus Sign because for the physical volume we need the 389 // coordinate system rotation. << 311 // coordinate system rotation. 390 pRotation = &rotation; << 312 pRotation = &rotation; 391 break; << 313 break; 392 } << 314 } 393 pVPV -> SetTranslation (translation); << 315 pVPV -> SetTranslation (translation); 394 pVPV -> SetRotation (pRotation); << 316 pVPV -> SetRotation (pRotation); 395 pVPV -> SetCopyNo (n); << 317 pVPV -> SetCopyNo (n); 396 fCurrentPVCopyNo = n; << 318 if (visualisable) { 397 if (visualisable) { << 319 DescribeAndDescend (pVPV, requestedDepth, pLV, pSol, pMaterial, 398 DescribeAndDescend (pVPV, requestedD << 320 theAT, sceneHandler); 399 theAT, sceneHand << 321 } 400 } << 401 } 322 } 402 // Restore originals... 323 // Restore originals... 403 pVPV -> SetTranslation (originalTranslat 324 pVPV -> SetTranslation (originalTranslation); 404 pVPV -> SetRotation (pOriginalRotatio 325 pVPV -> SetRotation (pOriginalRotation); 405 if (axis == kRho && pSol->GetEntityType( 326 if (axis == kRho && pSol->GetEntityType() == "G4Tubs") { 406 ((G4Tubs*)pSol)->SetInnerRadius(origin << 327 ((G4Tubs*)pSol)->SetInnerRadius(originalRMin); 407 ((G4Tubs*)pSol)->SetOuterRadius(origin << 328 ((G4Tubs*)pSol)->SetOuterRadius(originalRMax); 408 } 329 } 409 } 330 } 410 } 331 } >> 332 >> 333 return; 411 } 334 } 412 335 413 void G4PhysicalVolumeModel::DescribeAndDescend 336 void G4PhysicalVolumeModel::DescribeAndDescend 414 (G4VPhysicalVolume* pVPV, 337 (G4VPhysicalVolume* pVPV, 415 G4int requestedDepth, 338 G4int requestedDepth, 416 G4LogicalVolume* pLV, 339 G4LogicalVolume* pLV, 417 G4VSolid* pSol, 340 G4VSolid* pSol, 418 G4Material* pMaterial, 341 G4Material* pMaterial, 419 const G4Transform3D& theAT, 342 const G4Transform3D& theAT, 420 G4VGraphicsScene& sceneHandler) 343 G4VGraphicsScene& sceneHandler) 421 { 344 { 422 // Maintain useful data members... 345 // Maintain useful data members... 423 fpCurrentPV = pVPV; 346 fpCurrentPV = pVPV; 424 fCurrentPVCopyNo = pVPV->GetCopyNo(); << 425 fpCurrentLV = pLV; 347 fpCurrentLV = pLV; 426 fpCurrentMaterial = pMaterial; 348 fpCurrentMaterial = pMaterial; 427 349 428 // Create a nodeID for use below - note the << 429 G4int copyNo = fpCurrentPV->GetCopyNo(); << 430 auto nodeID = G4PhysicalVolumeNodeID << 431 (fpCurrentPV,copyNo,fCurrentDepth,fCurrentTr << 432 << 433 // Update full path of physical volumes... << 434 fFullPVPath.push_back(nodeID); << 435 << 436 const G4RotationMatrix objectRotation = pVPV 350 const G4RotationMatrix objectRotation = pVPV -> GetObjectRotationValue (); 437 const G4ThreeVector& translation = pVPV 351 const G4ThreeVector& translation = pVPV -> GetTranslation (); 438 G4Transform3D theLT (G4Transform3D (objectRo 352 G4Transform3D theLT (G4Transform3D (objectRotation, translation)); 439 353 440 // Compute the accumulated transformation... 354 // Compute the accumulated transformation... 441 // Note that top volume's transformation rel 355 // Note that top volume's transformation relative to the world 442 // coordinate system is specified in theAT = 356 // coordinate system is specified in theAT == startingTransformation 443 // = fTransform (see DescribeYourselfTo), so 357 // = fTransform (see DescribeYourselfTo), so first time through the 444 // volume's own transformation, which is onl 358 // volume's own transformation, which is only relative to its 445 // mother, i.e., not relative to the world c 359 // mother, i.e., not relative to the world coordinate system, should 446 // not be accumulated. 360 // not be accumulated. 447 G4Transform3D theNewAT (theAT); 361 G4Transform3D theNewAT (theAT); 448 if (fCurrentDepth != 0) theNewAT = theAT * t 362 if (fCurrentDepth != 0) theNewAT = theAT * theLT; 449 fCurrentTransform = theNewAT; << 363 fpCurrentTransform = &theNewAT; >> 364 >> 365 /******************************************************** >> 366 G4cout << "G4PhysicalVolumeModel::DescribeAndDescend: " >> 367 << pVPV -> GetName () << "." << pVPV -> GetCopyNo (); >> 368 G4cout << "\n theAT: "; >> 369 G4cout << "\n Rotation: "; >> 370 G4RotationMatrix rotation = theAT.getRotation (); >> 371 G4cout << rotation.thetaX() << ", " >> 372 << rotation.phiX() << ", " >> 373 << rotation.thetaY() << ", " >> 374 << rotation.phiY() << ", " >> 375 << rotation.thetaZ() << ", " >> 376 << rotation.phiZ(); >> 377 G4cout << "\n Translation: " << theAT.getTranslation(); >> 378 G4cout << "\n theNewAT: "; >> 379 G4cout << "\n Rotation: "; >> 380 rotation = theNewAT.getRotation (); >> 381 G4cout << rotation.thetaX() << ", " >> 382 << rotation.phiX() << ", " >> 383 << rotation.thetaY() << ", " >> 384 << rotation.phiY() << ", " >> 385 << rotation.thetaZ() << ", " >> 386 << rotation.phiZ(); >> 387 G4cout << "\n Translation: " << theNewAT.getTranslation(); >> 388 G4cout << G4endl; >> 389 **********************************************************/ 450 390 >> 391 // Make decision to draw... 451 const G4VisAttributes* pVisAttribs = pLV->Ge 392 const G4VisAttributes* pVisAttribs = pLV->GetVisAttributes(); 452 // If the volume does not have any vis attr << 393 if (!pVisAttribs) pVisAttribs = fpMP->GetDefaultVisAttributes(); 453 G4VisAttributes* tempVisAtts = nullptr; << 394 // Beware - pVisAttribs might still be zero - create a temporary default one... >> 395 G4bool visAttsCreated = false; 454 if (!pVisAttribs) { 396 if (!pVisAttribs) { 455 if (fpMP->GetDefaultVisAttributes()) { << 397 pVisAttribs = new G4VisAttributes; 456 tempVisAtts = new G4VisAttributes(*fpMP- << 398 visAttsCreated = true; 457 } else { << 458 tempVisAtts = new G4VisAttributes; << 459 } << 460 // The user may request /vis/viewer/set/co << 461 if (fpMP->GetCBDAlgorithmNumber() == 1) { << 462 // Algorithm 1: 3 parameters: Simple rai << 463 if (fpMP->GetCBDParameters().size() != 3 << 464 G4Exception("G4PhysicalVolumeModelTouc << 465 "modeling0014", << 466 FatalErrorInArgument, << 467 "Algorithm-parameter misma << 468 } else { << 469 const G4double d = pMaterial? pMateria << 470 const G4double d0 = fpMP->GetCBDParame << 471 const G4double d1 = fpMP->GetCBDParame << 472 const G4double d2 = fpMP->GetCBDParame << 473 if (d < d0) { // Density < d0 is invis << 474 tempVisAtts->SetVisibility(false); << 475 } else { // Intermediate densities are << 476 G4double red, green, blue; << 477 if (d < d1) { << 478 red = (d1-d)/(d1-d0); green = (d-d << 479 } else if (d < d2) { << 480 red = 0.; green = (d2-d)/(d2-d1); << 481 } else { // Density >= d2 is blue. << 482 red = 0.; green = 0.; blue = 1.; << 483 } << 484 tempVisAtts->SetColour(G4Colour(red, << 485 } << 486 } << 487 } else if (fpMP->GetCBDAlgorithmNumber() = << 488 // Algorithm 2 << 489 // ...etc. << 490 } << 491 pVisAttribs = tempVisAtts; << 492 } 399 } 493 // From here, can assume pVisAttribs is a va << 494 // because PreAddSolid needs a vis attribute << 495 400 496 // Check if vis attributes are to be modifie << 401 // From here, can assume pVisAttribs is a valid pointer. 497 const auto& vams = fpMP->GetVisAttributesMod << 498 if (vams.size()) { << 499 // OK, we have some VAMs (Vis Attributes M << 500 for (const auto& vam: vams) { << 501 const auto& vamPath = vam.GetPVNameCopyN << 502 if (vamPath.size() == fFullPVPath.size() << 503 // OK, we have a size match. << 504 // Check the volume name/copy number p << 505 auto iVAMNameCopyNo = vamPath.begin(); << 506 auto iPVNodeId = fFullPVPath.begin(); << 507 for (; iVAMNameCopyNo != vamPath.end() << 508 if (!( << 509 iVAMNameCopyNo->GetName() == << 510 iPVNodeId->GetPhysicalVolume() << 511 iVAMNameCopyNo->GetCopyNo() == << 512 iPVNodeId->GetPhysicalVolume() << 513 )) { << 514 // This path element does NOT matc << 515 break; << 516 } << 517 } << 518 if (iVAMNameCopyNo == vamPath.end()) { << 519 // OK, the paths match (the above lo << 520 // Create a vis atts object for the << 521 // It is static so that we may retur << 522 static G4VisAttributes modifiedVisAt << 523 // Initialise it with the current vi << 524 modifiedVisAtts = *pVisAttribs; << 525 pVisAttribs = &modifiedVisAtts; << 526 const G4VisAttributes& transVisAtts << 527 switch (vam.GetVisAttributesSignifie << 528 case G4ModelingParameters::VASVisi << 529 modifiedVisAtts.SetVisibility(tr << 530 break; << 531 case G4ModelingParameters::VASDaug << 532 modifiedVisAtts.SetDaughtersInvi << 533 (transVisAtts.IsDaughtersInvisib << 534 break; << 535 case G4ModelingParameters::VASColo << 536 modifiedVisAtts.SetColour(transV << 537 break; << 538 case G4ModelingParameters::VASLine << 539 modifiedVisAtts.SetLineStyle(tra << 540 break; << 541 case G4ModelingParameters::VASLine << 542 modifiedVisAtts.SetLineWidth(tra << 543 break; << 544 case G4ModelingParameters::VASForc << 545 if (transVisAtts.IsForceDrawingS << 546 if (transVisAtts.GetForcedDraw << 547 G4VisAttributes::wireframe << 548 modifiedVisAtts.SetForceWire << 549 } << 550 } << 551 break; << 552 case G4ModelingParameters::VASForc << 553 if (transVisAtts.IsForceDrawingS << 554 if (transVisAtts.GetForcedDraw << 555 G4VisAttributes::solid) { << 556 modifiedVisAtts.SetForceSoli << 557 } << 558 } << 559 break; << 560 case G4ModelingParameters::VASForc << 561 if (transVisAtts.IsForceDrawingS << 562 if (transVisAtts.GetForcedDraw << 563 G4VisAttributes::cloud) { << 564 modifiedVisAtts.SetForceClou << 565 } << 566 } << 567 break; << 568 case G4ModelingParameters::VASForc << 569 modifiedVisAtts.SetForceNumberOf << 570 (transVisAtts.GetForcedNumberOfC << 571 break; << 572 case G4ModelingParameters::VASForc << 573 if (transVisAtts.IsForceAuxEdgeV << 574 modifiedVisAtts.SetForceAuxEdg << 575 (transVisAtts.IsForcedAuxEdgeV << 576 } << 577 break; << 578 case G4ModelingParameters::VASForc << 579 modifiedVisAtts.SetForceLineSegm << 580 (transVisAtts.GetForcedLineSegme << 581 break; << 582 } << 583 } << 584 } << 585 } << 586 } << 587 << 588 // Check for special mesh rendering << 589 if (fpMP->IsSpecialMeshRendering()) { << 590 G4bool potentialG4Mesh = false; << 591 if (fpMP->GetSpecialMeshVolumes().empty()) << 592 // No volumes specified - all are potent << 593 potentialG4Mesh = true; << 594 } else { << 595 // Name and (optionally) copy number of << 596 for (const auto& pvNameCopyNo: fpMP->Get << 597 if (pVPV->GetName() == pvNameCopyNo.Ge << 598 // We have a name match << 599 if (pvNameCopyNo.GetCopyNo() < 0) { << 600 // Any copy number is OK << 601 potentialG4Mesh = true; << 602 } else { << 603 if (pVPV->GetCopyNo() == pvNameCop << 604 // We have a name and copy numbe << 605 potentialG4Mesh = true; << 606 } << 607 } << 608 } << 609 } << 610 } << 611 if (potentialG4Mesh) { << 612 // Create - or at least attempt to creat << 613 // out of this pVPV the type will be "in << 614 G4Mesh mesh(pVPV,theNewAT); << 615 if (mesh.GetMeshType() != G4Mesh::invali << 616 // Create "artificial" nodeID to repre << 617 G4int artCopyNo = 0; << 618 auto artPV = mesh.GetParameterisedVolu << 619 auto artDepth = fCurrentDepth + 1; << 620 auto artNodeID = G4PhysicalVolumeNodeI << 621 fFullPVPath.push_back(artNodeID); << 622 fDrawnPVPath.push_back(artNodeID); << 623 sceneHandler.AddCompound(mesh); << 624 fFullPVPath.pop_back(); << 625 fDrawnPVPath.pop_back(); << 626 delete tempVisAtts; // Needs cleaning << 627 return; // Mesh found and processed - << 628 } // else continue processing << 629 } << 630 } << 631 402 632 // Make decision to draw... << 633 G4bool thisToBeDrawn = true; 403 G4bool thisToBeDrawn = true; 634 404 635 // There are various reasons why this volume 405 // There are various reasons why this volume 636 // might not be drawn... 406 // might not be drawn... 637 G4bool culling = fpMP->IsCulling(); 407 G4bool culling = fpMP->IsCulling(); 638 G4bool cullingInvisible = fpMP->IsCullingInv 408 G4bool cullingInvisible = fpMP->IsCullingInvisible(); 639 G4bool markedVisible << 409 G4bool markedVisible = pVisAttribs->IsVisible(); 640 = pVisAttribs->IsVisible() && pVisAttribs->G << 641 G4bool cullingLowDensity = fpMP->IsDensityCu 410 G4bool cullingLowDensity = fpMP->IsDensityCulling(); 642 G4double density = pMaterial? pMaterial->Get 411 G4double density = pMaterial? pMaterial->GetDensity(): 0; 643 G4double densityCut = fpMP -> GetVisibleDens 412 G4double densityCut = fpMP -> GetVisibleDensity (); 644 413 645 // 1) Global culling is on.... 414 // 1) Global culling is on.... 646 if (culling) { 415 if (culling) { 647 // 2) Culling of invisible volumes is on.. 416 // 2) Culling of invisible volumes is on... 648 if (cullingInvisible) { 417 if (cullingInvisible) { 649 // 3) ...and the volume is marked not vi 418 // 3) ...and the volume is marked not visible... 650 if (!markedVisible) thisToBeDrawn = fals 419 if (!markedVisible) thisToBeDrawn = false; 651 } 420 } 652 // 4) Or culling of low density volumes is 421 // 4) Or culling of low density volumes is on... 653 if (cullingLowDensity) { 422 if (cullingLowDensity) { 654 // 5) ...and density is less than cut va 423 // 5) ...and density is less than cut value... 655 if (density < densityCut) thisToBeDrawn 424 if (density < densityCut) thisToBeDrawn = false; 656 } 425 } 657 } 426 } 658 // 6) The user has asked for all further tra << 659 if (fAbort) thisToBeDrawn = false; << 660 427 661 // Set "drawn" flag (it was true by default) << 428 // Update full path of physical volumes... 662 nodeID.SetDrawn(thisToBeDrawn); << 429 G4int copyNo = fpCurrentPV->GetCopyNo(); >> 430 fFullPVPath.push_back >> 431 (G4PhysicalVolumeNodeID(fpCurrentPV,copyNo,fCurrentDepth)); 663 432 664 if (thisToBeDrawn) { 433 if (thisToBeDrawn) { 665 434 666 // Update path of drawn physical volumes.. 435 // Update path of drawn physical volumes... 667 fDrawnPVPath.push_back(nodeID); << 436 G4int copyNo = fpCurrentPV->GetCopyNo(); >> 437 fDrawnPVPath.push_back >> 438 (G4PhysicalVolumeNodeID(fpCurrentPV,copyNo,fCurrentDepth)); 668 439 669 if (fpMP->IsExplode() && fDrawnPVPath.size 440 if (fpMP->IsExplode() && fDrawnPVPath.size() == 1) { 670 // For top-level drawn volumes, explode 441 // For top-level drawn volumes, explode along radius... 671 G4Transform3D centering = G4Translate3D( 442 G4Transform3D centering = G4Translate3D(fpMP->GetExplodeCentre()); 672 G4Transform3D centred = centering.invers 443 G4Transform3D centred = centering.inverse() * theNewAT; 673 G4Scale3D oldScale; << 444 G4Scale3D scale; 674 G4Rotate3D oldRotation; << 445 G4Rotate3D rotation; 675 G4Translate3D oldTranslation; << 446 G4Translate3D translation; 676 centred.getDecomposition(oldScale, oldRo << 447 centred.getDecomposition(scale, rotation, translation); 677 G4double explodeFactor = fpMP->GetExplod 448 G4double explodeFactor = fpMP->GetExplodeFactor(); 678 G4Translate3D newTranslation = 449 G4Translate3D newTranslation = 679 G4Translate3D(explodeFactor * oldTranslation << 450 G4Translate3D(explodeFactor * translation.dx(), 680 explodeFactor * oldTranslation.dy(), << 451 explodeFactor * translation.dy(), 681 explodeFactor * oldTranslation.dz()) << 452 explodeFactor * translation.dz()); 682 theNewAT = centering * newTranslation * << 453 theNewAT = centering * newTranslation * rotation * scale; 683 } 454 } 684 455 685 auto fullDepth = fCurrentDepth + (G4int)fB << 686 fNTouchables[fullDepth]++; // Increment f << 687 << 688 DescribeSolid (theNewAT, pSol, pVisAttribs 456 DescribeSolid (theNewAT, pSol, pVisAttribs, sceneHandler); 689 457 690 } 458 } 691 459 692 // Make decision to draw daughters, if any. 460 // Make decision to draw daughters, if any. There are various 693 // reasons why daughters might not be drawn. 461 // reasons why daughters might not be drawn... 694 462 695 // First, reasons that do not depend on cull 463 // First, reasons that do not depend on culling policy... 696 G4int nDaughters = (G4int)pLV->GetNoDaughter << 464 G4int nDaughters = pLV->GetNoDaughters(); 697 G4bool daughtersToBeDrawn = true; 465 G4bool daughtersToBeDrawn = true; 698 // 1) There are no daughters... 466 // 1) There are no daughters... 699 if (!nDaughters) daughtersToBeDrawn = false; 467 if (!nDaughters) daughtersToBeDrawn = false; 700 // 2) We are at the limit if requested depth 468 // 2) We are at the limit if requested depth... 701 else if (requestedDepth == 0) daughtersToBeD 469 else if (requestedDepth == 0) daughtersToBeDrawn = false; 702 // 3) The user has asked for all further tra << 470 // 3) The user has asked that the descent be curtailed... 703 else if (fAbort) daughtersToBeDrawn = false; << 704 // 4) The user has asked that the descent be << 705 else if (fCurtailDescent) daughtersToBeDrawn 471 else if (fCurtailDescent) daughtersToBeDrawn = false; 706 472 707 // Now, reasons that depend on culling polic 473 // Now, reasons that depend on culling policy... 708 else { 474 else { >> 475 G4bool culling = fpMP->IsCulling(); >> 476 G4bool cullingInvisible = fpMP->IsCullingInvisible(); 709 G4bool daughtersInvisible = pVisAttribs->I 477 G4bool daughtersInvisible = pVisAttribs->IsDaughtersInvisible(); 710 // Culling of covered daughters request. 478 // Culling of covered daughters request. This is computed in 711 // G4VSceneHandler::CreateModelingParamete 479 // G4VSceneHandler::CreateModelingParameters() depending on view 712 // parameters... 480 // parameters... 713 G4bool cullingCovered = fpMP->IsCullingCov 481 G4bool cullingCovered = fpMP->IsCullingCovered(); 714 G4bool surfaceDrawing = 482 G4bool surfaceDrawing = 715 fpMP->GetDrawingStyle() == G4ModelingPar 483 fpMP->GetDrawingStyle() == G4ModelingParameters::hsr || 716 fpMP->GetDrawingStyle() == G4ModelingPar 484 fpMP->GetDrawingStyle() == G4ModelingParameters::hlhsr; 717 if (pVisAttribs->IsForceDrawingStyle()) { 485 if (pVisAttribs->IsForceDrawingStyle()) { 718 switch (pVisAttribs->GetForcedDrawingSty 486 switch (pVisAttribs->GetForcedDrawingStyle()) { 719 default: 487 default: 720 case G4VisAttributes::wireframe: surface 488 case G4VisAttributes::wireframe: surfaceDrawing = false; break; 721 case G4VisAttributes::solid: surfaceDraw 489 case G4VisAttributes::solid: surfaceDrawing = true; break; 722 } 490 } 723 } 491 } 724 G4bool opaque = pVisAttribs->GetColour().G 492 G4bool opaque = pVisAttribs->GetColour().GetAlpha() >= 1.; 725 // 5) Global culling is on.... << 493 // 4) Global culling is on.... 726 if (culling) { 494 if (culling) { 727 // 6) ..and culling of invisible volumes << 495 // 5) ..and culling of invisible volumes is on... 728 if (cullingInvisible) { 496 if (cullingInvisible) { 729 // 7) ...and the mother requests daughters i << 497 // 6) ...and the mother requests daughters invisible 730 if (daughtersInvisible) daughtersToBeDrawn = 498 if (daughtersInvisible) daughtersToBeDrawn = false; 731 } 499 } 732 // 8) Or culling of covered daughters is << 500 // 7) Or culling of covered daughters is requested... 733 if (cullingCovered) { 501 if (cullingCovered) { 734 // 9) ...and surface drawing is operating... << 502 // 8) ...and surface drawing is operating... 735 if (surfaceDrawing) { 503 if (surfaceDrawing) { 736 // 10) ...but only if mother is visible... << 504 // 9) ...but only if mother is visible... 737 if (thisToBeDrawn) { 505 if (thisToBeDrawn) { 738 // 11) ...and opaque... << 506 // 10) ...and opaque... 739 if (opaque) daughtersToBeDrawn = false 507 if (opaque) daughtersToBeDrawn = false; 740 } 508 } 741 } 509 } 742 } 510 } 743 } 511 } 744 } 512 } 745 513 >> 514 // Vis atts for this volume no longer needed if created... >> 515 if (visAttsCreated) delete pVisAttribs; >> 516 746 if (daughtersToBeDrawn) { 517 if (daughtersToBeDrawn) { 747 for (G4int iDaughter = 0; iDaughter < nDau 518 for (G4int iDaughter = 0; iDaughter < nDaughters; iDaughter++) { 748 // Store daughter pVPV in local variable << 519 G4VPhysicalVolume* pVPV = pLV -> GetDaughter (iDaughter); 749 G4VPhysicalVolume* pDaughterVPV = pLV -> << 750 // Descend the geometry structure recurs 520 // Descend the geometry structure recursively... 751 fCurrentDepth++; 521 fCurrentDepth++; 752 VisitGeometryAndGetVisReps 522 VisitGeometryAndGetVisReps 753 (pDaughterVPV, requestedDepth - 1, theNewAT, << 523 (pVPV, requestedDepth - 1, theNewAT, sceneHandler); 754 fCurrentDepth--; 524 fCurrentDepth--; 755 } 525 } 756 } 526 } 757 527 758 // Clean up << 759 delete tempVisAtts; << 760 << 761 // Reset for normal descending of next volum 528 // Reset for normal descending of next volume at this level... 762 fCurtailDescent = false; 529 fCurtailDescent = false; 763 530 764 // Pop item from paths physical volumes... 531 // Pop item from paths physical volumes... 765 fFullPVPath.pop_back(); 532 fFullPVPath.pop_back(); 766 if (thisToBeDrawn) { 533 if (thisToBeDrawn) { 767 fDrawnPVPath.pop_back(); 534 fDrawnPVPath.pop_back(); 768 } 535 } 769 } 536 } 770 537 771 namespace << 772 { << 773 G4bool SubtractionBoundingLimits(const G4VSo << 774 { << 775 // Algorithm from G4SubtractionSolid::Boun << 776 // Since it is unclear how the shape of th << 777 // after subtraction, just return its orig << 778 G4ThreeVector pMin, pMax; << 779 const auto& pSolA = target; << 780 pSolA->BoundingLimits(pMin,pMax); << 781 // Check correctness of the bounding box << 782 if (pMin.x() >= pMax.x() || pMin.y() >= pM << 783 // Bad bounding box (min >= max) << 784 // This signifies a subtraction of non-i << 785 return false; << 786 } << 787 return true; << 788 } << 789 << 790 G4bool IntersectionBoundingLimits(const G4VS << 791 { << 792 // Algorithm from G4IntersectionSolid::Bou << 793 G4ThreeVector pMin, pMax; << 794 G4ThreeVector minA,maxA, minB,maxB; << 795 const auto& pSolA = target; << 796 const auto& pSolB = intersector; << 797 pSolA->BoundingLimits(minA,maxA); << 798 pSolB->BoundingLimits(minB,maxB); << 799 pMin.set(std::max(minA.x(),minB.x()), << 800 std::max(minA.y(),minB.y()), << 801 std::max(minA.z(),minB.z())); << 802 pMax.set(std::min(maxA.x(),maxB.x()), << 803 std::min(maxA.y(),maxB.y()), << 804 std::min(maxA.z(),maxB.z())); << 805 if (pMin.x() >= pMax.x() || pMin.y() >= pM << 806 // Bad bounding box (min >= max) << 807 // This signifies a subtraction of non-i << 808 return false; << 809 } << 810 return true; << 811 } << 812 } << 813 << 814 void G4PhysicalVolumeModel::DescribeSolid 538 void G4PhysicalVolumeModel::DescribeSolid 815 (const G4Transform3D& theAT, 539 (const G4Transform3D& theAT, 816 G4VSolid* pSol, 540 G4VSolid* pSol, 817 const G4VisAttributes* pVisAttribs, 541 const G4VisAttributes* pVisAttribs, 818 G4VGraphicsScene& sceneHandler) 542 G4VGraphicsScene& sceneHandler) 819 { 543 { 820 G4DisplacedSolid* pSectionSolid = fpMP->GetS << 544 sceneHandler.PreAddSolid (theAT, *pVisAttribs); 821 G4DisplacedSolid* pCutawaySolid = fpMP->GetC << 822 545 823 if (fNClippers <= 0 || fNClippers > 1) { << 546 const G4Polyhedron* pSectionPolyhedron = fpMP->GetSectionPolyhedron(); >> 547 const G4Polyhedron* pCutawayPolyhedron = fpMP->GetCutawayPolyhedron(); >> 548 >> 549 if (!fpClippingPolyhedron && !pSectionPolyhedron && !pCutawayPolyhedron) { 824 550 825 // Normal case - no clipping, etc. - or, i << 826 sceneHandler.PreAddSolid (theAT, *pVisAttr << 827 pSol -> DescribeYourselfTo (sceneHandler); 551 pSol -> DescribeYourselfTo (sceneHandler); // Standard treatment. 828 sceneHandler.PostAddSolid (); << 829 552 830 } else { // fNClippers == 1 << 553 } else { >> 554 >> 555 // Clipping, etc., performed by Boolean operations on polyhedron objects. >> 556 >> 557 // First, get polyhedron for current solid... >> 558 if (pVisAttribs->IsForceLineSegmentsPerCircle()) >> 559 G4Polyhedron::SetNumberOfRotationSteps >> 560 (pVisAttribs->GetForcedLineSegmentsPerCircle()); >> 561 else >> 562 G4Polyhedron::SetNumberOfRotationSteps(fpMP->GetNoOfSides()); >> 563 G4Polyhedron* pOriginal = pSol->GetPolyhedron(); >> 564 G4Polyhedron::ResetNumberOfRotationSteps(); >> 565 if (!pOriginal) { >> 566 if (fpMP->IsWarning()) >> 567 G4cout << >> 568 "WARNING: G4PhysicalVolumeModel::DescribeSolid: solid\n \"" >> 569 << pSol->GetName() << >> 570 "\" has no polyhedron. Cannot by clipped." >> 571 << G4endl; >> 572 pSol -> DescribeYourselfTo (sceneHandler); // Standard treatment. >> 573 } else { 831 574 832 G4VSolid* pResultantSolid = nullpt << 575 G4Polyhedron resultant = *pOriginal; 833 G4DisplacedSolid* pDisplacedSolid = nullpt << 834 576 835 if (fpClippingSolid) { << 577 if (fpClippingPolyhedron) { 836 pDisplacedSolid = new G4DisplacedSolid(" << 578 G4Polyhedron clipper = *fpClippingPolyhedron; // Local copy. 837 switch (fClippingMode) { << 579 clipper.Transform(theAT.inverse()); 838 case subtraction: << 580 switch (fClippingMode) { 839 if (SubtractionBoundingLimits(pSol)) << 581 default: 840 pResultantSolid = new G4Subtractio << 582 case subtraction: resultant = resultant.subtract(clipper); break; 841 ("subtracted_clipped_solid", pSol, << 583 case intersection: resultant = resultant.intersect(clipper); break; 842 } << 584 } 843 break; << 585 if(resultant.IsErrorBooleanProcess()) { 844 case intersection: << 586 if (fpMP->IsWarning()) 845 if (IntersectionBoundingLimits(pSol, << 587 G4cout << 846 pResultantSolid = new G4Intersecti << 588 "WARNING: G4PhysicalVolumeModel::DescribeSolid: clipped polyhedron for" 847 ("intersected_clipped_solid", pSol << 589 "\n solid \"" << pSol->GetName() << 848 } << 590 "\" not defined due to error during Boolean processing." 849 break; << 591 << G4endl; >> 592 // Nevertheless, keep resultant. >> 593 } 850 } 594 } 851 595 852 } else if (pSectionSolid) { << 596 if (pSectionPolyhedron) { 853 pDisplacedSolid = new G4DisplacedSolid(" << 597 G4Polyhedron sectioner = *pSectionPolyhedron; // Local copy. 854 if (IntersectionBoundingLimits(pSol, pDi << 598 sectioner.Transform(theAT.inverse()); 855 pResultantSolid = new G4IntersectionSo << 599 resultant = resultant.intersect(sectioner); >> 600 if(resultant.IsErrorBooleanProcess()) { >> 601 if (fpMP->IsWarning()) >> 602 G4cout << >> 603 "WARNING: G4PhysicalVolumeModel::DescribeSolid: sectioned polyhedron for" >> 604 "\n solid \"" << pSol->GetName() << >> 605 "\" not defined due to error during Boolean processing." >> 606 << G4endl; >> 607 // Nevertheless, keep resultant. >> 608 } 856 } 609 } 857 610 858 } else if (pCutawaySolid) { << 611 if (pCutawayPolyhedron) { 859 pDisplacedSolid = new G4DisplacedSolid(" << 612 G4Polyhedron cutter = *pCutawayPolyhedron; // Local copy. 860 switch (fpMP->GetCutawayMode()) { << 613 cutter.Transform(theAT.inverse()); 861 case G4ModelingParameters::cutawayUnio << 614 resultant = resultant.subtract(cutter); 862 if (SubtractionBoundingLimits(pSol)) << 615 if(resultant.IsErrorBooleanProcess()) { 863 pResultantSolid = new G4Subtractio << 616 if (fpMP->IsWarning()) 864 } << 617 G4cout << 865 break; << 618 "WARNING: G4PhysicalVolumeModel::DescribeSolid: cutaway polyhedron for" 866 case G4ModelingParameters::cutawayInte << 619 "\n solid \"" << pSol->GetName() << 867 if (IntersectionBoundingLimits(pSol, << 620 "\" not defined due to error during Boolean processing." 868 pResultantSolid = new G4Intersecti << 621 << G4endl; 869 } << 622 // Nevertheless, keep resultant. 870 break; << 623 } 871 } 624 } 872 } << 873 625 874 if (pResultantSolid) { << 626 // Finally, force polyhedron drawing... 875 sceneHandler.PreAddSolid (theAT, *pVisAt << 627 resultant.SetVisAttributes(pVisAttribs); 876 pResultantSolid -> DescribeYourselfTo (s << 628 sceneHandler.BeginPrimitives(theAT); 877 sceneHandler.PostAddSolid (); << 629 sceneHandler.AddPrimitive(resultant); >> 630 sceneHandler.EndPrimitives(); 878 } 631 } 879 << 880 delete pResultantSolid; << 881 delete pDisplacedSolid; << 882 } 632 } >> 633 sceneHandler.PostAddSolid (); 883 } 634 } 884 635 885 G4bool G4PhysicalVolumeModel::Validate (G4bool 636 G4bool G4PhysicalVolumeModel::Validate (G4bool warn) 886 { 637 { 887 // Not easy to see how to validate this sort o << 638 G4VPhysicalVolume* world = 888 // a check that a volume of the same name (fTo << 639 G4TransportationManager::GetTransportationManager () 889 // the geometry tree but under some circumstan << 640 -> GetNavigatorForTracking () -> GetWorldVolume (); 890 // time. Instead, let us simply check that the << 641 // The idea now is to seek a PV with the same name and copy no 891 // physical volume store. << 642 // in the hope it's the same one!! 892 const auto& pvStore = G4PhysicalVolumeStore: << 643 if (warn) { 893 auto iterator = find(pvStore->begin(),pvStor << 644 G4cout << "G4PhysicalVolumeModel::Validate() called." << G4endl; 894 if (iterator == pvStore->end()) { << 645 } >> 646 G4PhysicalVolumeModel searchModel (world); >> 647 G4PhysicalVolumeSearchScene searchScene >> 648 (&searchModel, fTopPVName, fTopPVCopyNo); >> 649 G4ModelingParameters mp; // Default modeling parameters for this search. >> 650 mp.SetDefaultVisAttributes(fpMP? fpMP->GetDefaultVisAttributes(): 0); >> 651 searchModel.SetModelingParameters (&mp); >> 652 searchModel.DescribeYourselfTo (searchScene); >> 653 G4VPhysicalVolume* foundVolume = searchScene.GetFoundVolume (); >> 654 if (foundVolume) { 895 if (warn) { 655 if (warn) { 896 G4ExceptionDescription ed; << 656 G4cout << " Volume of the same name and copy number (\"" 897 ed << "Attempt to validate a volume that << 657 << fTopPVName << "\", copy " << fTopPVCopyNo 898 G4Exception("G4PhysicalVolumeModel::Vali << 658 << ") still exists and is being used." >> 659 "\n WARNING: This does not necessarily guarantee it's the same" >> 660 "\n volume you originally specified in /vis/scene/add/." >> 661 << G4endl; 899 } 662 } 900 return false; << 663 fpTopPV = foundVolume; 901 } else { << 664 CalculateExtent (); 902 return true; 665 return true; 903 } 666 } >> 667 else { >> 668 if (warn) { >> 669 G4cout << " A volume of the same name and copy number (\"" >> 670 << fTopPVName << "\", copy " << fTopPVCopyNo >> 671 << ") no longer exists." >> 672 << G4endl; >> 673 } >> 674 return false; >> 675 } 904 } 676 } 905 677 906 const std::map<G4String,G4AttDef>* G4PhysicalV 678 const std::map<G4String,G4AttDef>* G4PhysicalVolumeModel::GetAttDefs() const 907 { 679 { 908 G4bool isNew; 680 G4bool isNew; 909 std::map<G4String,G4AttDef>* store 681 std::map<G4String,G4AttDef>* store 910 = G4AttDefStore::GetInstance("G4Physical 682 = G4AttDefStore::GetInstance("G4PhysicalVolumeModel", isNew); 911 if (isNew) { 683 if (isNew) { 912 (*store)["PVPath"] = 684 (*store)["PVPath"] = 913 G4AttDef("PVPath","Physical Volume Path" << 685 G4AttDef("PVPath","Physical Volume Path","Physics","","G4String"); 914 (*store)["BasePVPath"] = << 915 G4AttDef("BasePVPath","Base Physical Vol << 916 (*store)["LVol"] = 686 (*store)["LVol"] = 917 G4AttDef("LVol","Logical Volume","Physic << 687 G4AttDef("LVol","Logical Volume","Physics","","G4String"); 918 (*store)["Solid"] = 688 (*store)["Solid"] = 919 G4AttDef("Solid","Solid Name","Physics", << 689 G4AttDef("Solid","Solid Name","Physics","","G4String"); 920 (*store)["EType"] = 690 (*store)["EType"] = 921 G4AttDef("EType","Entity Type","Physics" << 691 G4AttDef("EType","Entity Type","Physics","","G4String"); 922 (*store)["DmpSol"] = 692 (*store)["DmpSol"] = 923 G4AttDef("DmpSol","Dump of Solid propert << 693 G4AttDef("DmpSol","Dump of Solid properties","Physics","","G4String"); 924 (*store)["LocalTrans"] = << 694 (*store)["Trans"] = 925 G4AttDef("LocalTrans","Local transformat << 695 G4AttDef("Trans","Transformation of volume","Physics","","G4String"); 926 (*store)["LocalExtent"] = << 927 G4AttDef("LocalExtent","Local extent of << 928 (*store)["GlobalTrans"] = << 929 G4AttDef("GlobalTrans","Global transform << 930 (*store)["GlobalExtent"] = << 931 G4AttDef("GlobalExtent","Global extent o << 932 (*store)["Material"] = 696 (*store)["Material"] = 933 G4AttDef("Material","Material Name","Phy << 697 G4AttDef("Material","Material Name","Physics","","G4String"); 934 (*store)["Density"] = 698 (*store)["Density"] = 935 G4AttDef("Density","Material Density","P << 699 G4AttDef("Density","Material Density","Physics","G4BestUnit","G4double"); 936 (*store)["State"] = 700 (*store)["State"] = 937 G4AttDef("State","Material State (enum u << 701 G4AttDef("State","Material State (enum undefined,solid,liquid,gas)","Physics","","G4String"); 938 (*store)["Radlen"] = 702 (*store)["Radlen"] = 939 G4AttDef("Radlen","Material Radiation Le << 703 G4AttDef("Radlen","Material Radiation Length","Physics","G4BestUnit","G4double"); >> 704 } 940 (*store)["Region"] = 705 (*store)["Region"] = 941 G4AttDef("Region","Cuts Region","Physics << 706 G4AttDef("Region","Cuts Region","Physics","","G4String"); 942 (*store)["RootRegion"] = 707 (*store)["RootRegion"] = 943 G4AttDef("RootRegion","Root Region (0/1 << 708 G4AttDef("RootRegion","Root Region (0/1 = false/true)","Physics","","G4bool"); 944 } << 709 return store; 945 return store; << 946 } 710 } 947 711 >> 712 #include <iomanip> >> 713 948 static std::ostream& operator<< (std::ostream& 714 static std::ostream& operator<< (std::ostream& o, const G4Transform3D t) 949 { 715 { 950 using namespace std; 716 using namespace std; 951 717 952 G4Scale3D sc; << 718 G4Scale3D s; 953 G4Rotate3D r; 719 G4Rotate3D r; 954 G4Translate3D tl; 720 G4Translate3D tl; 955 t.getDecomposition(sc, r, tl); << 721 t.getDecomposition(s, r, tl); 956 722 957 const int w = 10; 723 const int w = 10; 958 724 959 // Transformation itself 725 // Transformation itself 960 o << setw(w) << t.xx() << setw(w) << t.xy() 726 o << setw(w) << t.xx() << setw(w) << t.xy() << setw(w) << t.xz() << setw(w) << t.dx() << endl; 961 o << setw(w) << t.yx() << setw(w) << t.yy() 727 o << setw(w) << t.yx() << setw(w) << t.yy() << setw(w) << t.yz() << setw(w) << t.dy() << endl; 962 o << setw(w) << t.zx() << setw(w) << t.zy() 728 o << setw(w) << t.zx() << setw(w) << t.zy() << setw(w) << t.zz() << setw(w) << t.dz() << endl; 963 729 964 // Translation 730 // Translation 965 o << "= translation:" << endl; 731 o << "= translation:" << endl; 966 o << setw(w) << tl.dx() << setw(w) << tl.dy( 732 o << setw(w) << tl.dx() << setw(w) << tl.dy() << setw(w) << tl.dz() << endl; 967 733 968 // Rotation 734 // Rotation 969 o << "* rotation:" << endl; 735 o << "* rotation:" << endl; 970 o << setw(w) << r.xx() << setw(w) << r.xy() 736 o << setw(w) << r.xx() << setw(w) << r.xy() << setw(w) << r.xz() << endl; 971 o << setw(w) << r.yx() << setw(w) << r.yy() 737 o << setw(w) << r.yx() << setw(w) << r.yy() << setw(w) << r.yz() << endl; 972 o << setw(w) << r.zx() << setw(w) << r.zy() 738 o << setw(w) << r.zx() << setw(w) << r.zy() << setw(w) << r.zz() << endl; 973 739 974 // Scale 740 // Scale 975 o << "* scale:" << endl; 741 o << "* scale:" << endl; 976 o << setw(w) << sc.xx() << setw(w) << sc.yy( << 742 o << setw(w) << s.xx() << setw(w) << s.yy() << setw(w) << s.zz() << endl; 977 743 978 // Transformed axes 744 // Transformed axes 979 o << "Transformed axes:" << endl; 745 o << "Transformed axes:" << endl; 980 o << "x': " << r * G4Vector3D(1., 0., 0.) << 746 o << "x': " << r * G4Vector3D(1., 0., 0.) << endl; 981 o << "y': " << r * G4Vector3D(0., 1., 0.) << 747 o << "y': " << r * G4Vector3D(0., 1., 0.) << endl; 982 o << "z': " << r * G4Vector3D(0., 0., 1.) << 748 o << "z': " << r * G4Vector3D(0., 0., 1.) << endl; 983 749 984 return o; 750 return o; 985 } 751 } 986 752 987 std::vector<G4AttValue>* G4PhysicalVolumeModel 753 std::vector<G4AttValue>* G4PhysicalVolumeModel::CreateCurrentAttValues() const 988 { 754 { 989 std::vector<G4AttValue>* values = new std::v 755 std::vector<G4AttValue>* values = new std::vector<G4AttValue>; 990 << 756 std::ostringstream oss; 991 if (!fpCurrentLV) { << 757 for (size_t i = 0; i < fFullPVPath.size(); ++i) { 992 G4Exception << 758 oss << fFullPVPath[i].GetPhysicalVolume()->GetName() 993 ("G4PhysicalVolumeModel::CreateCurrent << 759 << ':' << fFullPVPath[i].GetCopyNo(); 994 "modeling0004", << 760 if (i != fFullPVPath.size() - 1) oss << '/'; 995 JustWarning, << 996 "Current logical volume not defined." << 997 return values; << 998 } 761 } 999 << 1000 std::ostringstream oss; oss << fFullPVPath; << 1001 values->push_back(G4AttValue("PVPath", oss. 762 values->push_back(G4AttValue("PVPath", oss.str(),"")); 1002 << 1003 oss.str(""); oss << fBaseFullPVPath; << 1004 values->push_back(G4AttValue("BasePVPath", << 1005 << 1006 values->push_back(G4AttValue("LVol", fpCurr 763 values->push_back(G4AttValue("LVol", fpCurrentLV->GetName(),"")); 1007 G4VSolid* pSol = fpCurrentLV->GetSolid(); 764 G4VSolid* pSol = fpCurrentLV->GetSolid(); 1008 << 1009 values->push_back(G4AttValue("Solid", pSol- 765 values->push_back(G4AttValue("Solid", pSol->GetName(),"")); 1010 << 1011 values->push_back(G4AttValue("EType", pSol- 766 values->push_back(G4AttValue("EType", pSol->GetEntityType(),"")); 1012 << 1013 oss.str(""); oss << '\n' << *pSol; 767 oss.str(""); oss << '\n' << *pSol; 1014 values->push_back(G4AttValue("DmpSol", oss. 768 values->push_back(G4AttValue("DmpSol", oss.str(),"")); 1015 << 769 oss.str(""); oss << '\n' << *fpCurrentTransform; 1016 const G4RotationMatrix localRotation = fpCu << 770 values->push_back(G4AttValue("Trans", oss.str(),"")); 1017 const G4ThreeVector& localTranslation = fpC << 1018 oss.str(""); oss << '\n' << G4Transform3D(l << 1019 values->push_back(G4AttValue("LocalTrans", << 1020 << 1021 oss.str(""); oss << '\n' << pSol->GetExtent << 1022 values->push_back(G4AttValue("LocalExtent", << 1023 << 1024 oss.str(""); oss << '\n' << fCurrentTransfo << 1025 values->push_back(G4AttValue("GlobalTrans", << 1026 << 1027 oss.str(""); oss << '\n' << (pSol->GetExten << 1028 values->push_back(G4AttValue("GlobalExtent" << 1029 << 1030 G4String matName = fpCurrentMaterial? fpCur 771 G4String matName = fpCurrentMaterial? fpCurrentMaterial->GetName(): G4String("No material"); 1031 values->push_back(G4AttValue("Material", ma 772 values->push_back(G4AttValue("Material", matName,"")); 1032 << 1033 G4double matDensity = fpCurrentMaterial? fp 773 G4double matDensity = fpCurrentMaterial? fpCurrentMaterial->GetDensity(): 0.; 1034 values->push_back(G4AttValue("Density", G4B 774 values->push_back(G4AttValue("Density", G4BestUnit(matDensity,"Volumic Mass"),"")); 1035 << 1036 G4State matState = fpCurrentMaterial? fpCur 775 G4State matState = fpCurrentMaterial? fpCurrentMaterial->GetState(): kStateUndefined; 1037 oss.str(""); oss << matState; 776 oss.str(""); oss << matState; 1038 values->push_back(G4AttValue("State", oss.s 777 values->push_back(G4AttValue("State", oss.str(),"")); 1039 << 1040 G4double matRadlen = fpCurrentMaterial? fpC 778 G4double matRadlen = fpCurrentMaterial? fpCurrentMaterial->GetRadlen(): 0.; 1041 values->push_back(G4AttValue("Radlen", G4Be 779 values->push_back(G4AttValue("Radlen", G4BestUnit(matRadlen,"Length"),"")); 1042 << 1043 G4Region* region = fpCurrentLV->GetRegion() 780 G4Region* region = fpCurrentLV->GetRegion(); 1044 G4String regionName = region? region->GetNa 781 G4String regionName = region? region->GetName(): G4String("No region"); 1045 values->push_back(G4AttValue("Region", regi 782 values->push_back(G4AttValue("Region", regionName,"")); 1046 << 1047 oss.str(""); oss << fpCurrentLV->IsRootRegi 783 oss.str(""); oss << fpCurrentLV->IsRootRegion(); 1048 values->push_back(G4AttValue("RootRegion", 784 values->push_back(G4AttValue("RootRegion", oss.str(),"")); 1049 << 1050 return values; 785 return values; 1051 } << 1052 << 1053 G4bool G4PhysicalVolumeModel::G4PhysicalVolum << 1054 (const G4PhysicalVolumeModel::G4PhysicalVol << 1055 { << 1056 if (fpPV < right.fpPV) return true; << 1057 if (fpPV == right.fpPV) { << 1058 if (fCopyNo < right.fCopyNo) return true; << 1059 if (fCopyNo == right.fCopyNo) << 1060 return fNonCulledDepth < right.fNonCull << 1061 } << 1062 return false; << 1063 } << 1064 << 1065 G4bool G4PhysicalVolumeModel::G4PhysicalVolum << 1066 (const G4PhysicalVolumeModel::G4PhysicalVol << 1067 { << 1068 if (fpPV != right.fpPV || << 1069 fCopyNo != right.fCopyNo || << 1070 fNonCulledDepth != right.fNonCulledDept << 1071 fTransform != right.fTransform || << 1072 fDrawn != right.fDrawn) return << 1073 return false; << 1074 } << 1075 << 1076 std::ostream& operator<< << 1077 (std::ostream& os, const G4PhysicalVolumeMo << 1078 { << 1079 G4VPhysicalVolume* pPV = node.GetPhysicalVo << 1080 if (pPV) { << 1081 os << pPV->GetName() << 1082 << ' ' << node.GetCopyNo() << 1083 // << '[' << node.GetNonCulledDepth() < << 1084 // << ':' << node.GetTransform() << 1085 ; << 1086 // os << " ("; << 1087 // if (!node.GetDrawn()) os << "not "; << 1088 // os << "drawn)"; << 1089 } else { << 1090 os << " (Null PV node)"; << 1091 } << 1092 return os; << 1093 } << 1094 << 1095 std::ostream& operator<< << 1096 (std::ostream& os, const std::vector<G4Physic << 1097 { << 1098 if (path.empty()) { << 1099 os << " TOP"; << 1100 } else { << 1101 for (const auto& nodeID: path) { << 1102 os << ' ' << nodeID; << 1103 } << 1104 } << 1105 return os; << 1106 } << 1107 << 1108 G4PhysicalVolumeModel::G4PhysicalVolumeModelT << 1109 (const std::vector<G4PhysicalVolumeNodeID>& f << 1110 fFullPVPath(fullPVPath) {} << 1111 << 1112 const G4ThreeVector& G4PhysicalVolumeModel::G << 1113 { << 1114 size_t i = fFullPVPath.size() - depth - 1; << 1115 if (i >= fFullPVPath.size()) { << 1116 G4Exception("G4PhysicalVolumeModelTouchab << 1117 "modeling0005", << 1118 FatalErrorInArgument, << 1119 "Index out of range. Asking for non-exist << 1120 } << 1121 static G4ThreeVector tempTranslation; << 1122 tempTranslation = fFullPVPath[i].GetTransfo << 1123 return tempTranslation; << 1124 } << 1125 << 1126 const G4RotationMatrix* G4PhysicalVolumeModel << 1127 { << 1128 size_t i = fFullPVPath.size() - depth - 1; << 1129 if (i >= fFullPVPath.size()) { << 1130 G4Exception("G4PhysicalVolumeModelTouchab << 1131 "modeling0006", << 1132 FatalErrorInArgument, << 1133 "Index out of range. Asking for non-exist << 1134 } << 1135 static G4RotationMatrix tempRotation; << 1136 tempRotation = fFullPVPath[i].GetTransform( << 1137 return &tempRotation; << 1138 } << 1139 << 1140 G4VPhysicalVolume* G4PhysicalVolumeModel::G4P << 1141 { << 1142 size_t i = fFullPVPath.size() - depth - 1; << 1143 if (i >= fFullPVPath.size()) { << 1144 G4Exception("G4PhysicalVolumeModelTouchab << 1145 "modeling0007", << 1146 FatalErrorInArgument, << 1147 "Index out of range. Asking for non-exist << 1148 } << 1149 return fFullPVPath[i].GetPhysicalVolume(); << 1150 } << 1151 << 1152 G4VSolid* G4PhysicalVolumeModel::G4PhysicalVo << 1153 { << 1154 size_t i = fFullPVPath.size() - depth - 1; << 1155 if (i >= fFullPVPath.size()) { << 1156 G4Exception("G4PhysicalVolumeModelTouchab << 1157 "modeling0008", << 1158 FatalErrorInArgument, << 1159 "Index out of range. Asking for non-exist << 1160 } << 1161 return fFullPVPath[i].GetPhysicalVolume()-> << 1162 } << 1163 << 1164 G4int G4PhysicalVolumeModel::G4PhysicalVolume << 1165 { << 1166 size_t i = fFullPVPath.size() - depth - 1; << 1167 if (i >= fFullPVPath.size()) { << 1168 G4Exception("G4PhysicalVolumeModelTouchab << 1169 "modeling0009", << 1170 FatalErrorInArgument, << 1171 "Index out of range. Asking for non-exist << 1172 } << 1173 return fFullPVPath[i].GetCopyNo(); << 1174 } 786 } 1175 787