ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4LogicalVolume.hh
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file G4LogicalVolume.hh
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 // G4LogicalVolume
27 //
28 // Class description:
29 //
30 // Represents a leaf node or unpositioned subtree in the geometry hierarchy.
31 // Logical volumes are named, and may have daughters ascribed to them.
32 // They are responsible for retrieval of the physical and tracking attributes
33 // of the physical volume that it represents: solid, material, magnetic field,
34 // and optionally, user limits, sensitive detectors, regions, biasing weights.
35 //
36 // Get and Set functionality is provided for all attributes, but note that
37 // most set functions should not be used when the geometry is `closed'.
38 // As a further development, `Guard' checks can be added to ensure
39 // only legal operations at tracking time.
40 //
41 // On construction, solid, material and name must be specified.
42 //
43 // Daughters are ascribed and managed by means of a simple
44 // GetNoDaughters,Get/SetDaughter(n),AddDaughter interface.
45 //
46 // Smart voxels as used for tracking optimisation. They're also an attribute.
47 //
48 // Logical volumes self register to the logical volume Store on construction,
49 // and deregister on destruction.
50 //
51 // NOTE: This class is currently *NOT* subclassed, since not meant to
52 // act as a base class. Therefore, the destructor is NOT virtual.
53 //
54 // Data members:
55 //
56 // std::vector<G4VPhysicalVolume*> fDaughters
57 // - Vector of daughters. Given initial size of 0.
58 // G4FieldManager* fFieldManager
59 // - Pointer (possibly 0) to (magnetic or other) field manager object.
60 // G4Material* fMaterial
61 // - Pointer to material at this node.
62 // G4String fName
63 // - Name of logical volume.
64 // G4VSensitiveDetector *fSensitiveDetector
65 // - Pointer (possibly 0) to `Hit' object.
66 // G4VSolid* fSolid
67 // - Pointer to solid.
68 // G4UserLimits* fUserLimits
69 // - Pointer (possibly 0) to user Step limit object for this node.
70 // G4SmartVoxelHeader* fVoxel
71 // - Pointer (possibly 0) to optimisation info objects.
72 // G4bool fOptimise
73 // - Flag to identify if optimisation should be applied or not.
74 // G4bool fRootRegion
75 // - Flag to identify if the logical volume is a root region.
76 // G4double fSmartless
77 // - Quality for optimisation, average number of voxels to be spent
78 // per content.
79 // const G4VisAttributes* fVisAttributes
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 production cuts.
85 // G4double fBiasWeight
86 // - Weight used in the event biasing technique.
87 //
88 // Following data members has been moved to G4Region - M.Asai (Aug/18/2005)
89 // G4FastSimulationManager* fFastSimulationManager
90 // - Pointer (possibly 0) to G4FastSimulationManager object.
91 // G4bool fIsEnvelope
92 // - Flags if the Logical Volume is an envelope for a FastSimulationManager.
93 
94 // 15.01.13 G.Cosmo, A.Dotti: Modified for thread-safety for MT
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 for region cuts handling
97 // 17.05.02 G.Cosmo: Added IsToOptimise() method and related flag
98 // 18.04.01 G.Cosmo: Migrated to STL vector
99 // 12.02.99 S.Giani: Added user defined optimisation quality
100 // 09.11.98 M.Verderi, J.Apostolakis: Added BiasWeight member and accessors
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
103 // 11.07.95 P.Kent: Initial version
104 // ------------------------------------------------------------------------
105 #ifndef G4LOGICALVOLUME_HH
106 #define G4LOGICALVOLUME_HH
107 
108 #include <vector>
109 
110 #include "G4Types.hh"
111 #include "G4Region.hh" // Required by inline methods
112 #include "G4VPhysicalVolume.hh" // Need operator == for vector fdaughters
113 #include "G4GeomSplitter.hh" // Needed for MT RW data splitting
114 #include "G4Threading.hh"
115 
116 // Forward declarations
117 //
118 class G4FieldManager;
119 class G4Material;
121 class G4VSolid;
122 class G4UserLimits;
123 class G4SmartVoxelHeader;
124 class G4VisAttributes;
127 
128 class G4LVData
129 {
130  // Encapsulates the fields associated to the class
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.
151  // Pointer to sensitive detector.
153  // Pointer (possibly nullptr) to (magnetic or other) field manager object.
154  G4Material* fMaterial = nullptr;
155  // Pointer to material at this node.
157  // Mass of the logical volume tree.
159  // Pointer (possibly nullptr) to associated production cuts.
160 };
161 
162 // The type G4LVManager is introduced to encapsulate the methods used by
163 // both the master thread and worker threads to allocate memory space for
164 // the fields encapsulated by the class G4LVData. When each thread
165 // initializes the value for these fields, it refers to them using a macro
166 // definition defined below. For every G4LogicalVolume instance, there is
167 // a corresponding G4LVData instance. All G4LVData instances are organized
168 // by the class G4LVManager as an array.
169 // The field "int instanceID" is added to the class G4LogicalVolume.
170 // The value of this field in each G4LogicalVolume instance is the subscript
171 // of the corresponding G4LVData instance.
172 // In order to use the class G4LVManager, we add a static member in the class
173 // G4LogicalVolume as follows: "static G4LVManager subInstanceManager".
174 // For the master thread, the array for G4LVData instances grows dynamically
175 // along with G4LogicalVolume instances are created. For each worker thread,
176 // it copies the array of G4LVData instances from the master thread.
177 // In addition, it invokes a method similiar to the constructor explicitly
178 // to achieve the partial effect for each instance in the array.
179 //
181 
183 {
184  typedef std::vector<G4VPhysicalVolume*> G4PhysicalVolumeList;
185 
186  public: // with description
187 
188  G4LogicalVolume(G4VSolid* pSolid,
189  G4Material* pMaterial,
190  const G4String& name,
191  G4FieldManager* pFieldMgr = nullptr,
192  G4VSensitiveDetector* pSDetector = nullptr,
193  G4UserLimits* pULimits = nullptr,
194  G4bool optimise = true);
195  // Constructor. The solid and material pointer must be non null.
196  // The parameters for field, detector and user limits are optional.
197  // The volume also enters itself into the logical volume Store.
198  // Optimisation of the geometry (voxelisation) for the volume
199  // hierarchy is applied by default. For parameterised volumes in
200  // the hierarchy, optimisation is -always- applied.
201 
202  virtual ~G4LogicalVolume();
203  // Destructor. Removes the logical volume from the logical volume Store.
204  // This class is NOT meant to act as base class, except for exceptional
205  // circumstances of extended types used in the kernel.
206 
207  G4LogicalVolume(const G4LogicalVolume&) = delete;
208  G4LogicalVolume& operator=(const G4LogicalVolume&) = delete;
209  // Copy-constructor and assignment operator not allowed.
210 
211  inline const G4String& GetName() const;
212  inline void SetName(const G4String& pName);
213  // Returns and sets the name of the logical volume.
214 
215  inline size_t GetNoDaughters() const;
216  // Returns the number of daughters (0 to n).
217  inline G4VPhysicalVolume* GetDaughter(const G4int i) const;
218  // Returns the ith daughter. Note numbering starts from 0,
219  // and no bounds checking is performed.
221  // Adds the volume p as a daughter of the current logical volume.
222  inline G4bool IsDaughter(const G4VPhysicalVolume* p) const;
223  // Returns true if the volume p is a daughter of the current
224  // logical volume.
225  G4bool IsAncestor(const G4VPhysicalVolume* p) const;
226  // Returns true if the volume p is part of the hierarchy of
227  // volumes established by the current logical volume. Scans
228  // recursively the volume tree.
229  void RemoveDaughter(const G4VPhysicalVolume* p);
230  // Removes the volume p from the List of daughter of the current
231  // logical volume.
232  void ClearDaughters();
233  // Clears the list of daughters. Used by the phys-volume store when
234  // the geometry tree is cleared, since modified at run-time.
235  G4int TotalVolumeEntities() const;
236  // Returns the total number of physical volumes (replicated or placed)
237  // in the tree represented by the current logical volume.
238  inline EVolume CharacteriseDaughters() const;
239  // Characterise the daughters of this logical volume.
240  inline EVolume DeduceDaughtersType() const;
241  // Used by CharacteriseDaughters().
242 
243  G4VSolid* GetSolid() const;
244  void SetSolid(G4VSolid* pSolid);
245  // Gets and sets the current solid.
246 
247  G4Material* GetMaterial() const;
248  void SetMaterial(G4Material* pMaterial);
249  // Gets and sets the current material.
250  void UpdateMaterial(G4Material* pMaterial);
251  // Sets material and corresponding MaterialCutsCouple.
252  // This method is invoked by G4Navigator while it is navigating through
253  // material parameterization.
254  G4double GetMass(G4bool forced = false, G4bool propagate = true,
255  G4Material* parMaterial = nullptr);
256  // Returns the mass of the logical volume tree computed from the
257  // estimated geometrical volume of each solid and material associated
258  // to the logical volume and (by default) to its daughters.
259  // NOTE: the computation may require a considerable amount of time,
260  // depending from the complexity of the geometry tree.
261  // The returned value is cached and can be used for successive
262  // calls (default), unless recomputation is forced by providing
263  // 'true' for the boolean argument in input. Computation should
264  // be forced if the geometry setup has changed after the previous
265  // call. By setting the 'propagate' boolean flag to 'false' the
266  // method returns the mass of the present logical volume only
267  // (subtracted for the volume occupied by the daughter volumes).
268  // An optional argument to specify a material is also provided.
269  void ResetMass();
270  // Ensure that cached value of Mass is invalidated - due to change in
271  // state, e.g. change of size of Solid, change of type of solid,
272  // or the addition/deletion of a daughter volume.
273 
275  // Gets current FieldManager.
276  void SetFieldManager(G4FieldManager* pFieldMgr, G4bool forceToAllDaughters);
277  // Sets FieldManager and propagates it:
278  // i) only to daughters with G4FieldManager = nullptr
279  // if forceToAllDaughters=false
280  // ii) to all daughters
281  // if forceToAllDaughters=true
282 
284  // Gets current SensitiveDetector.
285  void SetSensitiveDetector(G4VSensitiveDetector* pSDetector);
286  // Sets SensitiveDetector (can be nullptr).
287 
288  inline G4UserLimits* GetUserLimits() const;
289  inline void SetUserLimits(G4UserLimits *pULimits);
290  // Gets and sets current UserLimits.
291 
292  inline G4SmartVoxelHeader* GetVoxelHeader() const;
293  inline void SetVoxelHeader(G4SmartVoxelHeader *pVoxel);
294  // Gets and sets current VoxelHeader.
295 
296  inline G4double GetSmartless() const;
297  inline void SetSmartless(G4double s);
298  // Gets and sets user defined optimisation quality.
299 
300  inline G4bool IsToOptimise() const;
301  // Replies if geometry optimisation (voxelisation) is to be
302  // applied for this volume hierarchy.
303  inline void SetOptimisation(G4bool optim);
304  // Specifies if to apply or not geometry optimisation to this
305  // volume hierarchy. Note that for parameterised volumes in the
306  // hierarchy, optimisation is always applied.
307 
308  inline G4bool IsRootRegion() const;
309  // Replies if the logical volume represents a root region or not.
310  inline void SetRegionRootFlag(G4bool rreg);
311  // Sets/unsets the volume as a root region for cuts.
312  inline G4bool IsRegion() const;
313  // Replies if the logical volume is part of a cuts region or not.
314  inline void SetRegion(G4Region* reg);
315  // Sets/unsets the volume as cuts region.
316  inline G4Region* GetRegion() const;
317  // Return the region to which the volume belongs, if any.
318  inline void PropagateRegion();
319  // Propagates region pointer to daughters.
320 
323  // Accessors for production cuts.
324 
325  G4bool operator == (const G4LogicalVolume& lv) const;
326  // Equality defined by address only.
327  // Returns true if objects are at same address, else false.
328 
329  inline const G4VisAttributes* GetVisAttributes () const;
330  inline void SetVisAttributes (const G4VisAttributes* pVA);
331  void SetVisAttributes (const G4VisAttributes& VA);
332  // Gets and sets visualization attributes. A copy of 'VA' on the heap
333  // will be made in the case the call with a const reference is used.
334 
336  // Gets current FastSimulationManager pointer if exists, otherwise null.
337 
338  inline void SetBiasWeight (G4double w);
339  inline G4double GetBiasWeight() const;
340  // Sets and gets bias weight.
341 
342  public: // without description
343 
344  G4LogicalVolume(__void__&);
345  // Fake default constructor for usage restricted to direct object
346  // persistency for clients requiring preallocation of memory for
347  // persistifiable objects.
348 
349  virtual G4bool IsExtended() const;
350  // Return true if it is not a base-class object.
351 
352  inline G4FieldManager* GetMasterFieldManager() const;
353  // Gets current FieldManager for the master thread.
355  // Gets current SensitiveDetector for the master thread.
356  inline G4VSolid* GetMasterSolid() const;
357  // Gets current Solid for the master thread.
358 
359  inline G4int GetInstanceID() const;
360  // Returns the instance ID.
361 
362  static const G4LVManager& GetSubInstanceManager();
363  // Returns the private data instance manager.
364 
365  static void Clean();
366  // Clear memory allocated by sub-instance manager.
367 
368  inline void Lock();
369  // Set lock identifier for final deletion of entity.
370 
371  void InitialiseWorker(G4LogicalVolume* ptrMasterObject,
372  G4VSolid* pSolid, G4VSensitiveDetector* pSDetector);
373  // This method is similar to the constructor. It is used by each worker
374  // thread to achieve the partial effect as that of the master thread.
375 
376  void TerminateWorker(G4LogicalVolume* ptrMasterObject);
377  // This method is similar to the destructor. It is used by each worker
378  // thread to achieve the partial effect as that of the master thread.
379 
380  void AssignFieldManager(G4FieldManager* fldMgr);
381  // Set the FieldManager - only at this level (do not push down hierarchy)
382 
383  static G4VSolid* GetSolid(G4LVData& instLVdata) ; // const;
384  static void SetSolid(G4LVData& instLVdata, G4VSolid* pSolid);
385  // Optimised Methods - passing thread instance of worker data
386 
388  // Change the type of the daughters volume to be of type atype.
389  // Meant for the user who wants to use the external navigator for
390  // the contents of a volume.
391  // Returns: success (true) or failure (false).
392 
393  private:
394 
395  // Data members:
396 
398  // Vector of daughters. Given initial size of 0.
400  // Name of logical volume.
402  // Are contents of volume placements, replica, parameterised or external?
403 
405  // Pointer (possibly nullptr) to user Step limit object for this node.
407  // Pointer (possibly nullptr) to optimisation info objects.
409  // Flag to identify if optimisation should be applied or not.
411  // Flag to identify if the logical volume is a root region.
412  G4bool fLock = false;
413  // Flag to identify if entity is locked for final deletion.
415  // Quality for optimisation, average number of voxels to be spent
416  // per content.
417  const G4VisAttributes* fVisAttributes = nullptr;
418  // Pointer (possibly nullptr) to visualization attributes.
419  G4Region* fRegion = nullptr;
420  // Pointer to the cuts region (if any)
422  // Weight used in the event biasing technique.
423 
425  // This new field is used as instance ID.
427  // This new field helps to use the class G4LVManager introduced above.
428 
429  // Shadow of master pointers.
430  // Each worker thread can access this field from the master thread
431  // through these pointers.
432  //
433  G4VSolid* fSolid = nullptr;
436  G4LVData* lvdata = nullptr; // For use of object persistency
437 };
438 
439 #include "G4LogicalVolume.icc"
440 
441 #endif