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