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 // G4LogicalVolume 26 // G4LogicalVolume 27 // 27 // 28 // Class description: 28 // Class description: 29 // 29 // 30 // Represents a leaf node or unpositioned subt 30 // Represents a leaf node or unpositioned subtree in the geometry hierarchy. 31 // Logical volumes are named, and may have dau 31 // Logical volumes are named, and may have daughters ascribed to them. 32 // They are responsible for retrieval of the p 32 // They are responsible for retrieval of the physical and tracking attributes 33 // of the physical volume that it represents: 33 // of the physical volume that it represents: solid, material, magnetic field, 34 // and optionally, user limits, sensitive dete 34 // and optionally, user limits, sensitive detectors, regions, biasing weights. 35 // 35 // 36 // Get and Set functionality is provided for a 36 // Get and Set functionality is provided for all attributes, but note that 37 // most set functions should not be used when 37 // most set functions should not be used when the geometry is `closed'. 38 // As a further development, `Guard' checks c 38 // As a further development, `Guard' checks can be added to ensure 39 // only legal operations at tracking time. 39 // only legal operations at tracking time. 40 // 40 // 41 // On construction, solid, material and name m 41 // On construction, solid, material and name must be specified. 42 // 42 // 43 // Daughters are ascribed and managed by means 43 // Daughters are ascribed and managed by means of a simple 44 // GetNoDaughters,Get/SetDaughter(n),AddDaught 44 // GetNoDaughters,Get/SetDaughter(n),AddDaughter interface. 45 // 45 // 46 // Smart voxels as used for tracking optimisat 46 // Smart voxels as used for tracking optimisation. They're also an attribute. 47 // 47 // 48 // Logical volumes self register to the logica 48 // Logical volumes self register to the logical volume Store on construction, 49 // and deregister on destruction. 49 // and deregister on destruction. 50 // 50 // 51 // NOTE: This class is currently *NOT* subclas 51 // NOTE: This class is currently *NOT* subclassed, since not meant to 52 // act as a base class. Therefore, the d 52 // act as a base class. Therefore, the destructor is NOT virtual. 53 // 53 // 54 // Data members: 54 // Data members: 55 // 55 // 56 // std::vector<G4VPhysicalVolume*> fDaughte 56 // std::vector<G4VPhysicalVolume*> fDaughters 57 // - Vector of daughters. Given initial siz 57 // - Vector of daughters. Given initial size of 0. 58 // G4FieldManager* fFieldManager 58 // G4FieldManager* fFieldManager 59 // - Pointer (possibly 0) to (magnetic or o 59 // - Pointer (possibly 0) to (magnetic or other) field manager object. 60 // G4Material* fMaterial 60 // G4Material* fMaterial 61 // - Pointer to material at this node. 61 // - Pointer to material at this node. 62 // G4String fName 62 // G4String fName 63 // - Name of logical volume. 63 // - Name of logical volume. 64 // G4VSensitiveDetector *fSensitiveDetector 64 // G4VSensitiveDetector *fSensitiveDetector 65 // - Pointer (possibly 0) to `Hit' object. 65 // - Pointer (possibly 0) to `Hit' object. 66 // G4VSolid* fSolid 66 // G4VSolid* fSolid 67 // - Pointer to solid. 67 // - Pointer to solid. 68 // G4UserLimits* fUserLimits 68 // G4UserLimits* fUserLimits 69 // - Pointer (possibly 0) to user Step limi 69 // - Pointer (possibly 0) to user Step limit object for this node. 70 // G4SmartVoxelHeader* fVoxel 70 // G4SmartVoxelHeader* fVoxel 71 // - Pointer (possibly 0) to optimisation i 71 // - Pointer (possibly 0) to optimisation info objects. 72 // G4bool fOptimise 72 // G4bool fOptimise 73 // - Flag to identify if optimisation shoul 73 // - Flag to identify if optimisation should be applied or not. 74 // G4bool fRootRegion 74 // G4bool fRootRegion 75 // - Flag to identify if the logical volume 75 // - Flag to identify if the logical volume is a root region. 76 // G4double fSmartless 76 // G4double fSmartless 77 // - Quality for optimisation, average numb 77 // - Quality for optimisation, average number of voxels to be spent 78 // per content. 78 // per content. 79 // const G4VisAttributes* fVisAttributes 79 // const G4VisAttributes* fVisAttributes 80 // - Pointer (possibly 0) to visualization 80 // - Pointer (possibly 0) to visualization attributes. 81 // G4Region* fRegion 81 // G4Region* fRegion 82 // - Pointer to the cuts region (if any) 82 // - Pointer to the cuts region (if any) 83 // G4MaterialCutsCouple* fCutsCouple 83 // G4MaterialCutsCouple* fCutsCouple 84 // - Pointer (possibly 0) to associated pro 84 // - Pointer (possibly 0) to associated production cuts. 85 // G4double fBiasWeight 85 // G4double fBiasWeight 86 // - Weight used in the event biasing techn 86 // - Weight used in the event biasing technique. 87 // 87 // 88 // Following data members has been moved to G4 88 // Following data members has been moved to G4Region - M.Asai (Aug/18/2005) 89 // G4FastSimulationManager* fFastSimulation 89 // G4FastSimulationManager* fFastSimulationManager 90 // - Pointer (possibly 0) to G4FastSimulati 90 // - Pointer (possibly 0) to G4FastSimulationManager object. 91 // G4bool fIsEnvelope 91 // G4bool fIsEnvelope 92 // - Flags if the Logical Volume is an enve 92 // - Flags if the Logical Volume is an envelope for a FastSimulationManager. 93 93 94 // 15.01.13 G.Cosmo, A.Dotti: Modified for thr 94 // 15.01.13 G.Cosmo, A.Dotti: Modified for thread-safety for MT 95 // 12.11.04 G.Cosmo: Added GetMass() method fo 95 // 12.11.04 G.Cosmo: Added GetMass() method for computing mass of the tree 96 // 24.09.02 G.Cosmo: Added flags and accessors 96 // 24.09.02 G.Cosmo: Added flags and accessors for region cuts handling 97 // 17.05.02 G.Cosmo: Added IsToOptimise() meth 97 // 17.05.02 G.Cosmo: Added IsToOptimise() method and related flag 98 // 18.04.01 G.Cosmo: Migrated to STL vector 98 // 18.04.01 G.Cosmo: Migrated to STL vector 99 // 12.02.99 S.Giani: Added user defined optimi 99 // 12.02.99 S.Giani: Added user defined optimisation quality 100 // 09.11.98 M.Verderi, J.Apostolakis: Added Bi 100 // 09.11.98 M.Verderi, J.Apostolakis: Added BiasWeight member and accessors 101 // 10.20.97 P.M.DeFreitas, J.Apostolakis: Adde << 101 // 10.20.97 P.M.DeFreitas: Added pointer to a FastSimulation >> 102 // J.Apostolakis: & flag to indicate if it is an Envelope for it 102 // 11.07.95 P.Kent: Initial version 103 // 11.07.95 P.Kent: Initial version 103 // ------------------------------------------- 104 // ------------------------------------------------------------------------ 104 #ifndef G4LOGICALVOLUME_HH 105 #ifndef G4LOGICALVOLUME_HH 105 #define G4LOGICALVOLUME_HH 1 << 106 #define G4LOGICALVOLUME_HH 106 107 107 #include <vector> 108 #include <vector> 108 #include <memory> << 109 109 110 #include "G4Types.hh" 110 #include "G4Types.hh" 111 #include "G4Region.hh" // Required b 111 #include "G4Region.hh" // Required by inline methods 112 #include "G4VPhysicalVolume.hh" // Need opera 112 #include "G4VPhysicalVolume.hh" // Need operator == for vector fdaughters 113 #include "G4GeomSplitter.hh" // Needed for 113 #include "G4GeomSplitter.hh" // Needed for MT RW data splitting 114 #include "G4Threading.hh" 114 #include "G4Threading.hh" 115 115 116 // Forward declarations 116 // Forward declarations 117 // 117 // 118 class G4FieldManager; 118 class G4FieldManager; 119 class G4Material; 119 class G4Material; 120 class G4VSensitiveDetector; 120 class G4VSensitiveDetector; 121 class G4VSolid; 121 class G4VSolid; 122 class G4UserLimits; 122 class G4UserLimits; 123 class G4SmartVoxelHeader; 123 class G4SmartVoxelHeader; >> 124 class G4VisAttributes; 124 class G4FastSimulationManager; 125 class G4FastSimulationManager; 125 class G4MaterialCutsCouple; 126 class G4MaterialCutsCouple; 126 class G4VisAttributes; << 127 127 128 class G4LVData 128 class G4LVData 129 { 129 { 130 // Encapsulates the fields associated to the 130 // Encapsulates the fields associated to the class 131 // G4LogicalVolume that may not be read-only 131 // G4LogicalVolume that may not be read-only. 132 132 133 public: 133 public: 134 134 135 G4LVData(); 135 G4LVData(); 136 void initialize() 136 void initialize() 137 { 137 { 138 fSolid = nullptr; 138 fSolid = nullptr; 139 fSensitiveDetector = nullptr; 139 fSensitiveDetector = nullptr; 140 fFieldManager = nullptr; 140 fFieldManager = nullptr; 141 fMaterial = nullptr; 141 fMaterial = nullptr; 142 fMass = 0.0; 142 fMass = 0.0; 143 fCutsCouple = nullptr; 143 fCutsCouple = nullptr; 144 } 144 } 145 145 146 public: 146 public: 147 147 148 G4VSolid* fSolid = nullptr; 148 G4VSolid* fSolid = nullptr; 149 // Pointer to solid. 149 // Pointer to solid. 150 G4VSensitiveDetector* fSensitiveDetector = 150 G4VSensitiveDetector* fSensitiveDetector = nullptr; 151 // Pointer to sensitive detector. 151 // Pointer to sensitive detector. 152 G4FieldManager* fFieldManager = nullptr; 152 G4FieldManager* fFieldManager = nullptr; 153 // Pointer (possibly nullptr) to (magnet 153 // Pointer (possibly nullptr) to (magnetic or other) field manager object. 154 G4Material* fMaterial = nullptr; 154 G4Material* fMaterial = nullptr; 155 // Pointer to material at this node. 155 // Pointer to material at this node. 156 G4double fMass = 0.0; 156 G4double fMass = 0.0; 157 // Mass of the logical volume tree. 157 // Mass of the logical volume tree. 158 G4MaterialCutsCouple* fCutsCouple = nullpt 158 G4MaterialCutsCouple* fCutsCouple = nullptr; 159 // Pointer (possibly nullptr) to associa 159 // Pointer (possibly nullptr) to associated production cuts. 160 }; 160 }; 161 161 162 // The type G4LVManager is introduced to encap 162 // The type G4LVManager is introduced to encapsulate the methods used by 163 // both the master thread and worker threads t 163 // both the master thread and worker threads to allocate memory space for 164 // the fields encapsulated by the class G4LVDa 164 // the fields encapsulated by the class G4LVData. When each thread 165 // initializes the value for these fields, it 165 // initializes the value for these fields, it refers to them using a macro 166 // definition defined below. For every G4Logic 166 // definition defined below. For every G4LogicalVolume instance, there is 167 // a corresponding G4LVData instance. All G4LV 167 // a corresponding G4LVData instance. All G4LVData instances are organized 168 // by the class G4LVManager as an array. 168 // by the class G4LVManager as an array. 169 // The field "int instanceID" is added to the 169 // The field "int instanceID" is added to the class G4LogicalVolume. 170 // The value of this field in each G4LogicalVo 170 // The value of this field in each G4LogicalVolume instance is the subscript 171 // of the corresponding G4LVData instance. 171 // of the corresponding G4LVData instance. 172 // In order to use the class G4LVManager, we a 172 // In order to use the class G4LVManager, we add a static member in the class 173 // G4LogicalVolume as follows: "static G4LVMan 173 // G4LogicalVolume as follows: "static G4LVManager subInstanceManager". 174 // For the master thread, the array for G4LVDa 174 // For the master thread, the array for G4LVData instances grows dynamically 175 // along with G4LogicalVolume instances are cr 175 // along with G4LogicalVolume instances are created. For each worker thread, 176 // it copies the array of G4LVData instances f 176 // it copies the array of G4LVData instances from the master thread. 177 // In addition, it invokes a method similiar t 177 // In addition, it invokes a method similiar to the constructor explicitly 178 // to achieve the partial effect for each inst 178 // to achieve the partial effect for each instance in the array. 179 // 179 // 180 using G4LVManager = G4GeomSplitter<G4LVData>; << 180 typedef G4GeomSplitter<G4LVData> G4LVManager; 181 181 182 class G4LogicalVolume 182 class G4LogicalVolume 183 { 183 { 184 public: << 184 typedef std::vector<G4VPhysicalVolume*> G4PhysicalVolumeList; >> 185 >> 186 public: // with description 185 187 186 G4LogicalVolume(G4VSolid* pSolid, 188 G4LogicalVolume(G4VSolid* pSolid, 187 G4Material* pMaterial, 189 G4Material* pMaterial, 188 const G4String& name, 190 const G4String& name, 189 G4FieldManager* pFieldMgr 191 G4FieldManager* pFieldMgr = nullptr, 190 G4VSensitiveDetector* pSDe 192 G4VSensitiveDetector* pSDetector = nullptr, 191 G4UserLimits* pULimits = n 193 G4UserLimits* pULimits = nullptr, 192 G4bool optimise = true); 194 G4bool optimise = true); 193 // Constructor. The solid and material p 195 // Constructor. The solid and material pointer must be non null. 194 // The parameters for field, detector an 196 // The parameters for field, detector and user limits are optional. 195 // The volume also enters itself into th 197 // The volume also enters itself into the logical volume Store. 196 // Optimisation of the geometry (voxelis 198 // Optimisation of the geometry (voxelisation) for the volume 197 // hierarchy is applied by default. For 199 // hierarchy is applied by default. For parameterised volumes in 198 // the hierarchy, optimisation is -alway 200 // the hierarchy, optimisation is -always- applied. 199 201 200 virtual ~G4LogicalVolume(); 202 virtual ~G4LogicalVolume(); 201 // Destructor. Removes the logical volum 203 // Destructor. Removes the logical volume from the logical volume Store. 202 // This class is NOT meant to act as bas 204 // This class is NOT meant to act as base class, except for exceptional 203 // circumstances of extended types used 205 // circumstances of extended types used in the kernel. 204 206 205 G4LogicalVolume(const G4LogicalVolume&) = 207 G4LogicalVolume(const G4LogicalVolume&) = delete; 206 G4LogicalVolume& operator=(const G4Logical 208 G4LogicalVolume& operator=(const G4LogicalVolume&) = delete; 207 // Copy-constructor and assignment opera 209 // Copy-constructor and assignment operator not allowed. 208 210 209 inline const G4String& GetName() const; 211 inline const G4String& GetName() const; 210 void SetName(const G4String& pName); << 212 inline void SetName(const G4String& pName); 211 // Returns and sets the name of the logi 213 // Returns and sets the name of the logical volume. 212 214 213 inline std::size_t GetNoDaughters() const; << 215 inline size_t GetNoDaughters() const; 214 // Returns the number of daughters (0 to 216 // Returns the number of daughters (0 to n). 215 inline G4VPhysicalVolume* GetDaughter(cons << 217 inline G4VPhysicalVolume* GetDaughter(const G4int i) const; 216 // Returns the ith daughter. Note number 218 // Returns the ith daughter. Note numbering starts from 0, 217 // and no bounds checking is performed. 219 // and no bounds checking is performed. 218 void AddDaughter(G4VPhysicalVolume* p); 220 void AddDaughter(G4VPhysicalVolume* p); 219 // Adds the volume p as a daughter of th 221 // Adds the volume p as a daughter of the current logical volume. 220 inline G4bool IsDaughter(const G4VPhysical 222 inline G4bool IsDaughter(const G4VPhysicalVolume* p) const; 221 // Returns true if the volume p is a dau 223 // Returns true if the volume p is a daughter of the current 222 // logical volume. 224 // logical volume. 223 G4bool IsAncestor(const G4VPhysicalVolume* 225 G4bool IsAncestor(const G4VPhysicalVolume* p) const; 224 // Returns true if the volume p is part 226 // Returns true if the volume p is part of the hierarchy of 225 // volumes established by the current lo 227 // volumes established by the current logical volume. Scans 226 // recursively the volume tree. 228 // recursively the volume tree. 227 void RemoveDaughter(const G4VPhysicalVolum 229 void RemoveDaughter(const G4VPhysicalVolume* p); 228 // Removes the volume p from the List of 230 // Removes the volume p from the List of daughter of the current 229 // logical volume. 231 // logical volume. 230 void ClearDaughters(); 232 void ClearDaughters(); 231 // Clears the list of daughters. Used by 233 // Clears the list of daughters. Used by the phys-volume store when 232 // the geometry tree is cleared, since m 234 // the geometry tree is cleared, since modified at run-time. 233 G4int TotalVolumeEntities() const; 235 G4int TotalVolumeEntities() const; 234 // Returns the total number of physical 236 // Returns the total number of physical volumes (replicated or placed) 235 // in the tree represented by the curren 237 // in the tree represented by the current logical volume. 236 inline EVolume CharacteriseDaughters() con 238 inline EVolume CharacteriseDaughters() const; 237 // Characterise the daughters of this lo 239 // Characterise the daughters of this logical volume. 238 inline EVolume DeduceDaughtersType() const 240 inline EVolume DeduceDaughtersType() const; 239 // Used by CharacteriseDaughters(). 241 // Used by CharacteriseDaughters(). 240 242 241 G4VSolid* GetSolid() const; 243 G4VSolid* GetSolid() const; 242 void SetSolid(G4VSolid* pSolid); 244 void SetSolid(G4VSolid* pSolid); 243 // Gets and sets the current solid. 245 // Gets and sets the current solid. 244 246 245 G4Material* GetMaterial() const; 247 G4Material* GetMaterial() const; 246 void SetMaterial(G4Material* pMaterial); 248 void SetMaterial(G4Material* pMaterial); 247 // Gets and sets the current material. 249 // Gets and sets the current material. 248 void UpdateMaterial(G4Material* pMaterial) 250 void UpdateMaterial(G4Material* pMaterial); 249 // Sets material and corresponding Mater 251 // Sets material and corresponding MaterialCutsCouple. 250 // This method is invoked by G4Navigator 252 // This method is invoked by G4Navigator while it is navigating through 251 // material parameterization. 253 // material parameterization. 252 G4double GetMass(G4bool forced = false, G4 254 G4double GetMass(G4bool forced = false, G4bool propagate = true, 253 G4Material* parMaterial = 255 G4Material* parMaterial = nullptr); 254 // Returns the mass of the logical volum 256 // Returns the mass of the logical volume tree computed from the 255 // estimated geometrical volume of each 257 // estimated geometrical volume of each solid and material associated 256 // to the logical volume and (by default 258 // to the logical volume and (by default) to its daughters. 257 // NOTE: the computation may require a c 259 // NOTE: the computation may require a considerable amount of time, 258 // depending from the complexity o 260 // depending from the complexity of the geometry tree. 259 // The returned value is cached an 261 // The returned value is cached and can be used for successive 260 // calls (default), unless recompu 262 // calls (default), unless recomputation is forced by providing 261 // 'true' for the boolean argument 263 // 'true' for the boolean argument in input. Computation should 262 // be forced if the geometry setup 264 // be forced if the geometry setup has changed after the previous 263 // call. By setting the 'propagate 265 // call. By setting the 'propagate' boolean flag to 'false' the 264 // method returns the mass of the 266 // method returns the mass of the present logical volume only 265 // (subtracted for the volume occu 267 // (subtracted for the volume occupied by the daughter volumes). 266 // An optional argument to specify 268 // An optional argument to specify a material is also provided. 267 void ResetMass(); 269 void ResetMass(); 268 // Ensure that cached value of Mass is i 270 // Ensure that cached value of Mass is invalidated - due to change in 269 // state, e.g. change of size of Solid, 271 // state, e.g. change of size of Solid, change of type of solid, 270 // or the addition/deletion 272 // or the addition/deletion of a daughter volume. 271 273 272 G4FieldManager* GetFieldManager() const; 274 G4FieldManager* GetFieldManager() const; 273 // Gets current FieldManager. 275 // Gets current FieldManager. 274 void SetFieldManager(G4FieldManager* pFiel 276 void SetFieldManager(G4FieldManager* pFieldMgr, G4bool forceToAllDaughters); 275 // Sets FieldManager and propagates it: 277 // Sets FieldManager and propagates it: 276 // i) only to daughters with G4FieldMan 278 // i) only to daughters with G4FieldManager = nullptr 277 // if forceToAllDaughters=false 279 // if forceToAllDaughters=false 278 // ii) to all daughters 280 // ii) to all daughters 279 // if forceToAllDaughters=true 281 // if forceToAllDaughters=true 280 282 281 G4VSensitiveDetector* GetSensitiveDetector 283 G4VSensitiveDetector* GetSensitiveDetector() const; 282 // Gets current SensitiveDetector. 284 // Gets current SensitiveDetector. 283 void SetSensitiveDetector(G4VSensitiveDete 285 void SetSensitiveDetector(G4VSensitiveDetector* pSDetector); 284 // Sets SensitiveDetector (can be nullpt 286 // Sets SensitiveDetector (can be nullptr). 285 287 286 inline G4UserLimits* GetUserLimits() const 288 inline G4UserLimits* GetUserLimits() const; 287 inline void SetUserLimits(G4UserLimits *pU 289 inline void SetUserLimits(G4UserLimits *pULimits); 288 // Gets and sets current UserLimits. 290 // Gets and sets current UserLimits. 289 291 290 inline G4SmartVoxelHeader* GetVoxelHeader( 292 inline G4SmartVoxelHeader* GetVoxelHeader() const; 291 inline void SetVoxelHeader(G4SmartVoxelHea 293 inline void SetVoxelHeader(G4SmartVoxelHeader *pVoxel); 292 // Gets and sets current VoxelHeader. 294 // Gets and sets current VoxelHeader. 293 295 294 inline G4double GetSmartless() const; 296 inline G4double GetSmartless() const; 295 inline void SetSmartless(G4double s); 297 inline void SetSmartless(G4double s); 296 // Gets and sets user defined optimisati 298 // Gets and sets user defined optimisation quality. 297 299 298 inline G4bool IsToOptimise() const; 300 inline G4bool IsToOptimise() const; 299 // Replies if geometry optimisation (vox 301 // Replies if geometry optimisation (voxelisation) is to be 300 // applied for this volume hierarchy. 302 // applied for this volume hierarchy. 301 inline void SetOptimisation(G4bool optim); 303 inline void SetOptimisation(G4bool optim); 302 // Specifies if to apply or not geometry 304 // Specifies if to apply or not geometry optimisation to this 303 // volume hierarchy. Note that for param 305 // volume hierarchy. Note that for parameterised volumes in the 304 // hierarchy, optimisation is always app 306 // hierarchy, optimisation is always applied. 305 307 306 inline G4bool IsRootRegion() const; 308 inline G4bool IsRootRegion() const; 307 // Replies if the logical volume represe 309 // Replies if the logical volume represents a root region or not. 308 inline void SetRegionRootFlag(G4bool rreg) 310 inline void SetRegionRootFlag(G4bool rreg); 309 // Sets/unsets the volume as a root regi 311 // Sets/unsets the volume as a root region for cuts. 310 inline G4bool IsRegion() const; 312 inline G4bool IsRegion() const; 311 // Replies if the logical volume is part 313 // Replies if the logical volume is part of a cuts region or not. 312 inline void SetRegion(G4Region* reg); 314 inline void SetRegion(G4Region* reg); 313 // Sets/unsets the volume as cuts region 315 // Sets/unsets the volume as cuts region. 314 inline G4Region* GetRegion() const; 316 inline G4Region* GetRegion() const; 315 // Return the region to which the volume 317 // Return the region to which the volume belongs, if any. 316 inline void PropagateRegion(); 318 inline void PropagateRegion(); 317 // Propagates region pointer to daughter 319 // Propagates region pointer to daughters. 318 320 319 const G4MaterialCutsCouple* GetMaterialCut 321 const G4MaterialCutsCouple* GetMaterialCutsCouple() const; 320 void SetMaterialCutsCouple(G4MaterialCutsC 322 void SetMaterialCutsCouple(G4MaterialCutsCouple* cuts); 321 // Accessors for production cuts. 323 // Accessors for production cuts. 322 324 323 G4bool operator == (const G4LogicalVolume& 325 G4bool operator == (const G4LogicalVolume& lv) const; 324 // Equality defined by address only. 326 // Equality defined by address only. 325 // Returns true if objects are at same a 327 // Returns true if objects are at same address, else false. 326 328 327 const G4VisAttributes* GetVisAttributes () << 329 inline const G4VisAttributes* GetVisAttributes () const; 328 void SetVisAttributes (const G4VisAttribut << 330 inline void SetVisAttributes (const G4VisAttributes* pVA); 329 void SetVisAttributes (const G4VisAttribut << 331 void SetVisAttributes (const G4VisAttributes& VA); 330 // Gets and sets visualization attribute << 332 // Gets and sets visualization attributes. A copy of 'VA' on the heap 331 // Arguments are converted to shared_ptr << 333 // will be made in the case the call with a const reference is used. 332 334 333 inline G4FastSimulationManager* GetFastSim 335 inline G4FastSimulationManager* GetFastSimulationManager () const; 334 // Gets current FastSimulationManager po 336 // Gets current FastSimulationManager pointer if exists, otherwise null. 335 337 336 inline void SetBiasWeight (G4double w); 338 inline void SetBiasWeight (G4double w); 337 inline G4double GetBiasWeight() const; 339 inline G4double GetBiasWeight() const; 338 // Sets and gets bias weight. 340 // Sets and gets bias weight. 339 341 340 public: << 342 public: // without description 341 343 342 G4LogicalVolume(__void__&); 344 G4LogicalVolume(__void__&); 343 // Fake default constructor for usage re 345 // Fake default constructor for usage restricted to direct object 344 // persistency for clients requiring pre 346 // persistency for clients requiring preallocation of memory for 345 // persistifiable objects. 347 // persistifiable objects. 346 348 347 virtual G4bool IsExtended() const; 349 virtual G4bool IsExtended() const; 348 // Return true if it is not a base-class 350 // Return true if it is not a base-class object. 349 351 350 inline G4FieldManager* GetMasterFieldManag 352 inline G4FieldManager* GetMasterFieldManager() const; 351 // Gets current FieldManager for the mas 353 // Gets current FieldManager for the master thread. 352 inline G4VSensitiveDetector* GetMasterSens 354 inline G4VSensitiveDetector* GetMasterSensitiveDetector() const; 353 // Gets current SensitiveDetector for th 355 // Gets current SensitiveDetector for the master thread. 354 inline G4VSolid* GetMasterSolid() const; 356 inline G4VSolid* GetMasterSolid() const; 355 // Gets current Solid for the master thr 357 // Gets current Solid for the master thread. 356 358 357 inline G4int GetInstanceID() const; 359 inline G4int GetInstanceID() const; 358 // Returns the instance ID. 360 // Returns the instance ID. 359 361 360 static const G4LVManager& GetSubInstanceMa 362 static const G4LVManager& GetSubInstanceManager(); 361 // Returns the private data instance man 363 // Returns the private data instance manager. 362 364 363 static void Clean(); 365 static void Clean(); 364 // Clear memory allocated by sub-instanc 366 // Clear memory allocated by sub-instance manager. 365 367 366 inline void Lock(); 368 inline void Lock(); 367 // Set lock identifier for final deletio 369 // Set lock identifier for final deletion of entity. 368 370 369 void InitialiseWorker(G4LogicalVolume* ptr 371 void InitialiseWorker(G4LogicalVolume* ptrMasterObject, 370 G4VSolid* pSolid, G4 372 G4VSolid* pSolid, G4VSensitiveDetector* pSDetector); 371 // This method is similar to the constru 373 // This method is similar to the constructor. It is used by each worker 372 // thread to achieve the partial effect 374 // thread to achieve the partial effect as that of the master thread. 373 375 374 void TerminateWorker(G4LogicalVolume* ptrM 376 void TerminateWorker(G4LogicalVolume* ptrMasterObject); 375 // This method is similar to the destruc 377 // This method is similar to the destructor. It is used by each worker 376 // thread to achieve the partial effect 378 // thread to achieve the partial effect as that of the master thread. 377 379 378 void AssignFieldManager(G4FieldManager* fl 380 void AssignFieldManager(G4FieldManager* fldMgr); 379 // Set the FieldManager - only at this l 381 // Set the FieldManager - only at this level (do not push down hierarchy) 380 382 381 static G4VSolid* GetSolid(G4LVData& instLV 383 static G4VSolid* GetSolid(G4LVData& instLVdata) ; // const; 382 static void SetSolid(G4LVData& instLVdata, 384 static void SetSolid(G4LVData& instLVdata, G4VSolid* pSolid); 383 // Optimised Methods - passing thread in 385 // Optimised Methods - passing thread instance of worker data 384 386 385 G4bool ChangeDaughtersType(EVolume atype); 387 G4bool ChangeDaughtersType(EVolume atype); 386 // Change the type of the daughters volu 388 // Change the type of the daughters volume to be of type atype. 387 // Meant for the user who wants to use t 389 // Meant for the user who wants to use the external navigator for 388 // the contents of a volume. 390 // the contents of a volume. 389 // Returns: success (true) or failure (f 391 // Returns: success (true) or failure (false). 390 392 391 private: 393 private: 392 << 394 // Data members: 393 using G4PhysicalVolumeList = std::vector<G << 394 395 395 G4GEOM_DLL static G4LVManager subInstanceM 396 G4GEOM_DLL static G4LVManager subInstanceManager; 396 // This new field helps to use the class 397 // This new field helps to use the class G4LVManager introduced above. 397 398 398 G4PhysicalVolumeList fDaughters; 399 G4PhysicalVolumeList fDaughters; 399 // Vector of daughters. Given initial si 400 // Vector of daughters. Given initial size of 0. 400 G4String fName; 401 G4String fName; 401 // Name of logical volume. 402 // Name of logical volume. 402 G4UserLimits* fUserLimits = nullptr; 403 G4UserLimits* fUserLimits = nullptr; 403 // Pointer (possibly nullptr) to user St 404 // Pointer (possibly nullptr) to user Step limit object for this node. 404 G4SmartVoxelHeader* fVoxel = nullptr; 405 G4SmartVoxelHeader* fVoxel = nullptr; 405 // Pointer (possibly nullptr) to optimis 406 // Pointer (possibly nullptr) to optimisation info objects. 406 G4double fSmartless = 2.0; 407 G4double fSmartless = 2.0; 407 // Quality for optimisation, average num 408 // Quality for optimisation, average number of voxels to be spent 408 // per content. 409 // per content. >> 410 const G4VisAttributes* fVisAttributes = nullptr; >> 411 // Pointer (possibly nullptr) to visualization attributes. 409 G4Region* fRegion = nullptr; 412 G4Region* fRegion = nullptr; 410 // Pointer to the cuts region (if any). << 413 // Pointer to the cuts region (if any) 411 G4double fBiasWeight = 1.0; 414 G4double fBiasWeight = 1.0; 412 // Weight used in the event biasing tech 415 // Weight used in the event biasing technique. 413 std::shared_ptr<const G4VisAttributes> fVi << 414 // Pointer to visualization attributes. << 415 416 416 // Shadow of master pointers. 417 // Shadow of master pointers. 417 // Each worker thread can access this fiel 418 // Each worker thread can access this field from the master thread 418 // through these pointers. 419 // through these pointers. 419 // 420 // 420 G4VSolid* fSolid = nullptr; 421 G4VSolid* fSolid = nullptr; 421 G4VSensitiveDetector* fSensitiveDetector = 422 G4VSensitiveDetector* fSensitiveDetector = nullptr; 422 G4FieldManager* fFieldManager = nullptr; 423 G4FieldManager* fFieldManager = nullptr; 423 G4LVData* lvdata = nullptr; // For use of 424 G4LVData* lvdata = nullptr; // For use of object persistency 424 425 425 G4int instanceID; 426 G4int instanceID; 426 // This new field is used as instance ID 427 // This new field is used as instance ID. 427 EVolume fDaughtersVolumeType; 428 EVolume fDaughtersVolumeType; 428 // Are contents of volume placements, re 429 // Are contents of volume placements, replica, parameterised or external? 429 G4bool fOptimise = true; 430 G4bool fOptimise = true; 430 // Flag to identify if optimisation shou 431 // Flag to identify if optimisation should be applied or not. 431 G4bool fRootRegion = false; 432 G4bool fRootRegion = false; 432 // Flag to identify if the logical volum 433 // Flag to identify if the logical volume is a root region. 433 G4bool fLock = false; 434 G4bool fLock = false; 434 // Flag to identify if entity is locked 435 // Flag to identify if entity is locked for final deletion. 435 }; 436 }; 436 437 437 #include "G4LogicalVolume.icc" 438 #include "G4LogicalVolume.icc" 438 439 439 #endif 440 #endif 440 441