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