| 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.7.2.1 2001/06/28 19:08:25 gunter Exp $
>> 25 // GEANT4 tag $Name: $
>> 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 are 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 NULL) 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 NULL) 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 NULL) to user Step limit object for this node.
70 // G4SmartVoxelHeader* fVoxel << 72 // G4SmartVoxelHeader *fVoxel
71 // - Pointer (possibly 0) to optimisation i << 73 // - Pointer (possibly NULL) to optimisation info objects.
72 // G4bool fOptimise <<
73 // - Flag to identify if optimisation shoul <<
74 // G4bool fRootRegion <<
75 // - Flag to identify if the logical volume <<
76 // G4double fSmartless 74 // G4double fSmartless
77 // - Quality for optimisation, average numb 75 // - Quality for optimisation, average number of voxels to be spent
78 // per content. 76 // per content.
79 // const G4VisAttributes* fVisAttributes 77 // const G4VisAttributes* fVisAttributes
80 // - Pointer (possibly 0) to visualization << 78 // - Pointer (possibly NULL) to visualization attributes.
81 // G4Region* fRegion << 79 // G4FastSimulationManager *fFastSimulationManager
82 // - Pointer to the cuts region (if any) << 80 // - Pointer (possibly NULL) to G4FastSimulationManager object.
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 <<
90 // - Pointer (possibly 0) to G4FastSimulati <<
91 // G4bool fIsEnvelope 81 // G4bool fIsEnvelope
92 // - Flags if the Logical Volume is an enve 82 // - Flags if the Logical Volume is an envelope for a FastSimulationManager.
>> 83 // G4double fBiasWeight
>> 84 // - Weight used in the event biasing technique.
93 85
94 // 15.01.13 G.Cosmo, A.Dotti: Modified for thr << 86 // 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 <<
98 // 18.04.01 G.Cosmo: Migrated to STL vector 87 // 18.04.01 G.Cosmo: Migrated to STL vector
99 // 12.02.99 S.Giani: Added user defined optimi 88 // 12.02.99 S.Giani: Added user defined optimisation quality
100 // 09.11.98 M.Verderi, J.Apostolakis: Added Bi << 89 // 09.11.98 J. Apostolakis: Changed G4MagneticField to G4FieldManager
101 // 10.20.97 P.M.DeFreitas, J.Apostolakis: Adde << 90 // 09.11.98 M. Verderi & JA. : added BiasWeight member and Get/Set methods
102 // 11.07.95 P.Kent: Initial version << 91 // 10.20.97 P. MoraDeFreitas : added pointer to a FastSimulation
103 // ------------------------------------------- << 92 // (J.Apostolakis) & flag to indicate if it is an Envelope for it
104 #ifndef G4LOGICALVOLUME_HH << 93 // 19.11.96 J.Allison Replaced G4Visible with explicit const G4VisAttributes*.
105 #define G4LOGICALVOLUME_HH 1 << 94 // 19.08.96 P.Kent Split -> hh/icc/cc files; G4VSensitiveDetector change
>> 95 // 11.07.95 P.Kent Initial version.
106 96
107 #include <vector> << 97 #ifndef G4LOGICALVOLUME_HH
108 #include <memory> << 98 #define G4LOGICALVOLUME_HH
109 99
110 #include "G4Types.hh" << 100 #include "globals.hh"
111 #include "G4Region.hh" // Required b << 101 #include "G4VPhysicalVolume.hh" // Need operator == for vector fdaughters
112 #include "G4VPhysicalVolume.hh" // Need opera << 102 #include "g4std/vector"
113 #include "G4GeomSplitter.hh" // Needed for << 103 #include <assert.h>
114 #include "G4Threading.hh" <<
115 104
116 // Forward declarations 105 // Forward declarations
117 // <<
118 class G4FieldManager; 106 class G4FieldManager;
119 class G4Material; 107 class G4Material;
120 class G4VSensitiveDetector; 108 class G4VSensitiveDetector;
121 class G4VSolid; 109 class G4VSolid;
122 class G4UserLimits; 110 class G4UserLimits;
123 class G4SmartVoxelHeader; 111 class G4SmartVoxelHeader;
124 class G4FastSimulationManager; <<
125 class G4MaterialCutsCouple; <<
126 class G4VisAttributes; 112 class G4VisAttributes;
127 << 113 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 114
182 class G4LogicalVolume 115 class G4LogicalVolume
183 { 116 {
184 public: << 117 typedef G4std::vector<G4VPhysicalVolume*> G4PhysicalVolumeList;
185 << 118
186 G4LogicalVolume(G4VSolid* pSolid, << 119 public: // with description
187 G4Material* pMaterial, << 120
188 const G4String& name, << 121 G4LogicalVolume(G4VSolid *pSolid, G4Material *pMaterial,
189 G4FieldManager* pFieldMgr << 122 const G4String& name,
190 G4VSensitiveDetector* pSDe << 123 G4FieldManager *pFieldMgr=0,
191 G4UserLimits* pULimits = n << 124 G4VSensitiveDetector *pSDetector=0,
192 G4bool optimise = true); << 125 G4UserLimits *pULimits=0);
193 // Constructor. The solid and material p << 126 // Constructor. The solid and material pointer must be non null. The
194 // The parameters for field, detector an << 127 // parameters for field, detector and user limits are optional.
195 // The volume also enters itself into th 128 // The volume also enters itself into the logical volume Store.
196 // Optimisation of the geometry (voxelis <<
197 // hierarchy is applied by default. For <<
198 // the hierarchy, optimisation is -alway <<
199 129
200 virtual ~G4LogicalVolume(); << 130 ~G4LogicalVolume();
201 // Destructor. Removes the logical volum 131 // Destructor. Removes the logical volume from the logical volume Store.
202 // This class is NOT meant to act as bas << 132 // 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 133
209 inline const G4String& GetName() const; << 134 inline G4String GetName() const;
210 void SetName(const G4String& pName); << 135 inline void SetName(const G4String& pName);
211 // Returns and sets the name of the logi 136 // Returns and sets the name of the logical volume.
212 137
213 inline std::size_t GetNoDaughters() const; << 138 inline G4int GetNoDaughters() const;
214 // Returns the number of daughters (0 to 139 // Returns the number of daughters (0 to n).
215 inline G4VPhysicalVolume* GetDaughter(cons << 140 inline G4VPhysicalVolume* GetDaughter(const G4int i) const;
216 // Returns the ith daughter. Note number << 141 // Return the ith daughter. Note numbering starts from 0,
217 // and no bounds checking is performed. 142 // and no bounds checking is performed.
218 void AddDaughter(G4VPhysicalVolume* p); << 143 inline void AddDaughter(G4VPhysicalVolume* p);
219 // Adds the volume p as a daughter of th << 144 // Add the volume p as a daughter of the current logical volume.
220 inline G4bool IsDaughter(const G4VPhysical 145 inline G4bool IsDaughter(const G4VPhysicalVolume* p) const;
221 // Returns true if the volume p is a dau << 146 // Returns true is the volume p is a daughter of the current
222 // logical volume. 147 // logical volume.
223 G4bool IsAncestor(const G4VPhysicalVolume* << 148 inline void RemoveDaughter(const G4VPhysicalVolume* p);
224 // Returns true if the volume p is part << 149 // 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. 150 // logical volume.
230 void ClearDaughters(); << 151
231 // Clears the list of daughters. Used by << 152 inline G4VSolid* GetSolid() const;
232 // the geometry tree is cleared, since m << 153 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. 154 // Gets and sets the current solid.
244 155
245 G4Material* GetMaterial() const; << 156 inline G4Material* GetMaterial() const;
246 void SetMaterial(G4Material* pMaterial); << 157 inline void SetMaterial(G4Material *pMaterial);
247 // Gets and sets the current material. 158 // Gets and sets the current material.
248 void UpdateMaterial(G4Material* pMaterial) << 159
249 // Sets material and corresponding Mater << 160 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. 161 // Gets current FieldManager.
274 void SetFieldManager(G4FieldManager* pFiel << 162 void SetFieldManager(G4FieldManager *pFieldMgr, G4bool forceToAllDaughters);
275 // Sets FieldManager and propagates it: 163 // Sets FieldManager and propagates it:
276 // i) only to daughters with G4FieldMan << 164 // i) only to daughters with G4FieldManager = 0
277 // if forceToAllDaughters=false 165 // if forceToAllDaughters=false
278 // ii) to all daughters 166 // ii) to all daughters
279 // if forceToAllDaughters=true 167 // if forceToAllDaughters=true
280 168
281 G4VSensitiveDetector* GetSensitiveDetector << 169 inline G4VSensitiveDetector* GetSensitiveDetector() const;
282 // Gets current SensitiveDetector. 170 // Gets current SensitiveDetector.
283 void SetSensitiveDetector(G4VSensitiveDete << 171 inline void SetSensitiveDetector(G4VSensitiveDetector *pSDetector);
284 // Sets SensitiveDetector (can be nullpt << 172 // Sets SensitiveDetector (can be NULL).
285 173
286 inline G4UserLimits* GetUserLimits() const 174 inline G4UserLimits* GetUserLimits() const;
287 inline void SetUserLimits(G4UserLimits *pU 175 inline void SetUserLimits(G4UserLimits *pULimits);
288 // Gets and sets current UserLimits. 176 // Gets and sets current UserLimits.
289 177
290 inline G4SmartVoxelHeader* GetVoxelHeader( 178 inline G4SmartVoxelHeader* GetVoxelHeader() const;
291 inline void SetVoxelHeader(G4SmartVoxelHea 179 inline void SetVoxelHeader(G4SmartVoxelHeader *pVoxel);
292 // Gets and sets current VoxelHeader. 180 // Gets and sets current VoxelHeader.
293 181
294 inline G4double GetSmartless() const; << 182 inline G4double GetSmartless();
295 inline void SetSmartless(G4double s); 183 inline void SetSmartless(G4double s);
296 // Gets and sets user defined optimisati 184 // Gets and sets user defined optimisation quality.
297 185
298 inline G4bool IsToOptimise() const; << 186 G4bool operator == ( const G4LogicalVolume& lv) const;
299 // Replies if geometry optimisation (vox << 187 // Equality defined by address only- return true if objects are at
300 // applied for this volume hierarchy. << 188 // same address, else false.
301 inline void SetOptimisation(G4bool optim); << 189
302 // Specifies if to apply or not geometry << 190 inline const G4VisAttributes* GetVisAttributes () const;
303 // volume hierarchy. Note that for param << 191 inline void SetVisAttributes (const G4VisAttributes* pVA);
304 // hierarchy, optimisation is always app << 192 inline void SetVisAttributes (const G4VisAttributes& VA);
305 <<
306 inline G4bool IsRootRegion() 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. <<
325 // Returns true if objects are at same a <<
326 <<
327 const G4VisAttributes* GetVisAttributes () <<
328 void SetVisAttributes (const G4VisAttribut <<
329 void SetVisAttributes (const G4VisAttribut <<
330 // Gets and sets visualization attribute 193 // Gets and sets visualization attributes.
331 // Arguments are converted to shared_ptr <<
332 194
>> 195 inline void BecomeEnvelopeForFastSimulation(G4FastSimulationManager* );
>> 196 // Makes this an Envelope for given FastSimulationManager.
>> 197 // Ensures that all its daughter volumes get it too - unless they
>> 198 // have one already.
>> 199 void ClearEnvelopeForFastSimulation(G4LogicalVolume* motherLV= 0);
>> 200 // Erase volume's Envelope status and propagate the FastSimulationManager
>> 201 // of its mother volume to itself and its daughters.
333 inline G4FastSimulationManager* GetFastSim 202 inline G4FastSimulationManager* GetFastSimulationManager () const;
334 // Gets current FastSimulationManager po << 203 // Gets current FastSimulationManager pointer.
335 204
336 inline void SetBiasWeight (G4double w); 205 inline void SetBiasWeight (G4double w);
337 inline G4double GetBiasWeight() const; 206 inline G4double GetBiasWeight() const;
338 // Sets and gets bias weight. 207 // Sets and gets bias weight.
339 208
340 public: << 209 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 <<
374 void TerminateWorker(G4LogicalVolume* ptrM <<
375 // This method is similar to the destruc <<
376 // thread to achieve the partial effect <<
377 210
378 void AssignFieldManager(G4FieldManager* fl << 211 void SetFastSimulationManager (G4FastSimulationManager* pPA,
379 // Set the FieldManager - only at this l << 212 G4bool IsEnvelope);
380 << 213 // Sets the fast simulation manager. Private method called by the
381 static G4VSolid* GetSolid(G4LVData& instLV << 214 // public SetIsEnvelope method with IsEnvelope = TRUE. It is
382 static void SetSolid(G4LVData& instLVdata, << 215 // then called recursivaly to the daughters to propagate the
383 // Optimised Methods - passing thread in << 216 // FastSimulationManager pointer with IsEnvelope = FALSE.
384 << 217
385 G4bool ChangeDaughtersType(EVolume atype); << 218 G4LogicalVolume* FindMotherLogicalVolumeForEnvelope();
386 // Change the type of the daughters volu << 219
387 // Meant for the user who wants to use t << 220 G4LogicalVolume(const G4LogicalVolume&);
388 // the contents of a volume. << 221 G4LogicalVolume& operator=(const G4LogicalVolume&);
389 // Returns: success (true) or failure (f << 222 // Private copy-constructor and assignment operator.
390 223
391 private: 224 private:
392 225
393 using G4PhysicalVolumeList = std::vector<G << 226 // Data members:
394 <<
395 G4GEOM_DLL static G4LVManager subInstanceM <<
396 // This new field helps to use the class <<
397 227
398 G4PhysicalVolumeList fDaughters; 228 G4PhysicalVolumeList fDaughters;
399 // Vector of daughters. Given initial si 229 // Vector of daughters. Given initial size of 0.
>> 230 G4FieldManager *fFieldManager;
>> 231 // Pointer (possibly NULL) to (magnetic or other) field manager object.
>> 232 G4Material *fMaterial;
>> 233 // Pointer to material at this node.
400 G4String fName; 234 G4String fName;
401 // Name of logical volume. 235 // Name of logical volume.
402 G4UserLimits* fUserLimits = nullptr; << 236 G4VSensitiveDetector *fSensitiveDetector;
403 // Pointer (possibly nullptr) to user St << 237 // Pointer (possibly NULL) to `Hit' object.
404 G4SmartVoxelHeader* fVoxel = nullptr; << 238 G4VSolid *fSolid;
405 // Pointer (possibly nullptr) to optimis << 239 // Pointer to solid.
406 G4double fSmartless = 2.0; << 240 G4UserLimits *fUserLimits;
>> 241 // Pointer (possibly NULL) to user Step limit object for this node.
>> 242 G4SmartVoxelHeader *fVoxel;
>> 243 // Pointer (possibly NULL) to optimisation info objects.
>> 244 G4double fSmartless;
407 // Quality for optimisation, average num 245 // Quality for optimisation, average number of voxels to be spent
408 // per content. 246 // per content.
409 G4Region* fRegion = nullptr; << 247 const G4VisAttributes* fVisAttributes;
410 // Pointer to the cuts region (if any). << 248 // Pointer (possibly NULL) to visualization attributes.
411 G4double fBiasWeight = 1.0; << 249 G4FastSimulationManager *fFastSimulationManager;
>> 250 // Pointer (possibly NULL) to G4FastSimulationManager object.
>> 251 G4bool fIsEnvelope;
>> 252 // Flags if the Logical Volume is an envelope for a
>> 253 // FastSimulationManager.
>> 254 G4double fBiasWeight;
412 // Weight used in the event biasing tech 255 // 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 }; 256 };
436 257
437 #include "G4LogicalVolume.icc" 258 #include "G4LogicalVolume.icc"
438 259
439 #endif 260 #endif
440 261