Geant4.10
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4LogicalVolume.hh
Go to the documentation of this file.
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 //
27 // $Id: G4LogicalVolume.hh 78050 2013-12-03 08:17:33Z gcosmo $
28 //
29 //
30 // class G4LogicalVolume
31 //
32 // Class description:
33 //
34 // Represents a leaf node or unpositioned subtree in the geometry hierarchy.
35 // Logical volumes are named, and may have daughters ascribed to them.
36 // They are responsible for retrieval of the physical and tracking attributes
37 // of the physical volume that it represents: solid, material, magnetic field,
38 // and optionally, user limits, sensitive detectors, regions, biasing weights.
39 //
40 // Get and Set functionality is provided for all attributes, but note that
41 // most set functions should not be used when the geometry is `closed'.
42 // As a further development, `Guard' checks can be added to ensure
43 // only legal operations at tracking time.
44 //
45 // On construction, solid, material and name must be specified.
46 //
47 // Daughters are ascribed and managed by means of a simple
48 // GetNoDaughters,Get/SetDaughter(n),AddDaughter interface.
49 //
50 // Smart voxels as used for tracking optimisation. They're also an attribute.
51 //
52 // Logical volumes self register to the logical volume Store on construction,
53 // and deregister on destruction.
54 //
55 // NOTE: This class is currently *NOT* subclassed, since not meant to
56 // act as a base class. Therefore, the destructor is NOT virtual.
57 //
58 // Data members:
59 //
60 // std::vector<G4VPhysicalVolume*> fDaughters
61 // - Vector of daughters. Given initial size of 0.
62 // G4FieldManager* fFieldManager
63 // - Pointer (possibly 0) to (magnetic or other) field manager object.
64 // G4Material* fMaterial
65 // - Pointer to material at this node.
66 // G4String fName
67 // - Name of logical volume.
68 // G4VSensitiveDetector *fSensitiveDetector
69 // - Pointer (possibly 0) to `Hit' object.
70 // G4VSolid* fSolid
71 // - Pointer to solid.
72 // G4UserLimits* fUserLimits
73 // - Pointer (possibly 0) to user Step limit object for this node.
74 // G4SmartVoxelHeader* fVoxel
75 // - Pointer (possibly 0) to optimisation info objects.
76 // G4bool fOptimise
77 // - Flag to identify if optimisation should be applied or not.
78 // G4bool fRootRegion
79 // - Flag to identify if the logical volume is a root region.
80 // G4double fSmartless
81 // - Quality for optimisation, average number of voxels to be spent
82 // per content.
83 // const G4VisAttributes* fVisAttributes
84 // - Pointer (possibly 0) to visualization attributes.
85 // G4Region* fRegion
86 // - Pointer to the cuts region (if any)
87 // G4MaterialCutsCouple* fCutsCouple
88 // - Pointer (possibly 0) to associated production cuts.
89 // G4double fBiasWeight
90 // - Weight used in the event biasing technique.
91 //
92 // Following data members has been moved to G4Region - M.Asai (Aug/18/2005)
93 // G4FastSimulationManager* fFastSimulationManager
94 // - Pointer (possibly 0) to G4FastSimulationManager object.
95 // G4bool fIsEnvelope
96 // - Flags if the Logical Volume is an envelope for a FastSimulationManager.
97 
98 // History:
99 // 15.01.13 G.Cosmo, A.Dotti: Modified for thread-safety for MT
100 // 12.11.04 G.Cosmo: Added GetMass() method for computing mass of the tree
101 // 24.09.02 G.Cosmo: Added flags and accessors for region cuts handling
102 // 17.05.02 G.Cosmo: Added IsToOptimise() method and related flag
103 // 18.04.01 G.Cosmo: Migrated to STL vector
104 // 12.02.99 S.Giani: Added user defined optimisation quality
105 // 09.11.98 J.Apostolakis: Changed G4MagneticField to G4FieldManager
106 // 09.11.98 M.Verderi, J.Apostolakis: Added BiasWeight member and accessors
107 // 10.20.97 P.M.DeFreitas: Added pointer to a FastSimulation
108 // J.Apostolakis: & flag to indicate if it is an Envelope for it
109 // 19.11.96 J.Allison: Replaced G4Visible with explicit const G4VisAttributes*
110 // 19.08.96 P.Kent: Split -> hh/icc/cc files; G4VSensitiveDetector change
111 // 11.07.95 P.Kent: Initial version.
112 // ------------------------------------------------------------------------
113 #ifndef G4LOGICALVOLUME_HH
114 #define G4LOGICALVOLUME_HH
115 
116 #include <vector>
117 
118 #include "G4Types.hh"
119 #include "G4Region.hh" // Required by inline methods
120 #include "G4VPhysicalVolume.hh" // Need operator == for vector fdaughters
121 #include "G4GeomSplitter.hh" // Needed for MT RW data splitting
122 
123 // Forward declarations
124 //
125 class G4FieldManager;
126 class G4Material;
128 class G4VSolid;
129 class G4UserLimits;
130 class G4SmartVoxelHeader;
131 class G4VisAttributes;
134 
135 class G4LVData
136 {
137  // Encapsulates the fields associated to the class
138  // G4LogicalVolume that may not be read-only.
139 
140  public:
141  G4LVData();
142  void initialize() {
143  fSolid = 0;
144  fSensitiveDetector = 0;
145  fFieldManager = 0;
146  fMaterial = 0;
147  fMass = 0.0;
148  fCutsCouple = 0;
149  }
150 
151  public:
152 
154  // Pointer to solid.
156  // Pointer to sensitive detector.
158  // Pointer (possibly 0) to (magnetic or other) field manager object.
160  // Pointer to material at this node.
162  // Mass of the logical volume tree.
164  // Pointer (possibly 0) to associated production cuts.
165 };
166 
167 // The type G4LVManager is introduced to encapsulate the methods used by
168 // both the master thread and worker threads to allocate memory space for
169 // the fields encapsulated by the class G4LVData. When each thread
170 // initializes the value for these fields, it refers to them using a macro
171 // definition defined below. For every G4LogicalVolume instance, there is
172 // a corresponding G4LVData instance. All G4LVData instances are organized
173 // by the class G4LVManager as an array.
174 // The field "int instanceID" is added to the class G4LogicalVolume.
175 // The value of this field in each G4LogicalVolume instance is the subscript
176 // of the corresponding G4LVData instance.
177 // In order to use the class G4LVManager, we add a static member in the class
178 // G4LogicalVolume as follows: "static G4LVManager subInstanceManager".
179 // For the master thread, the array for G4LVData instances grows dynamically
180 // along with G4LogicalVolume instances are created. For each worker thread,
181 // it copies the array of G4LVData instances from the master thread.
182 // In addition, it invokes a method similiar to the constructor explicitly
183 // to achieve the partial effect for each instance in the array.
184 //
186 
188 {
189  typedef std::vector<G4VPhysicalVolume*> G4PhysicalVolumeList;
190 
191  public: // with description
192 
193  G4LogicalVolume(G4VSolid* pSolid,
194  G4Material* pMaterial,
195  const G4String& name,
196  G4FieldManager* pFieldMgr=0,
197  G4VSensitiveDetector* pSDetector=0,
198  G4UserLimits* pULimits=0,
199  G4bool optimise=true);
200  // Constructor. The solid and material pointer must be non null.
201  // The parameters for field, detector and user limits are optional.
202  // The volume also enters itself into the logical volume Store.
203  // Optimisation of the geometry (voxelisation) for the volume
204  // hierarchy is applied by default. For parameterised volumes in
205  // the hierarchy, optimisation is -always- applied.
206 
208  // Destructor. Removes the logical volume from the logical volume Store.
209  // NOT virtual, since not meant to act as base class.
210 
211  inline G4String GetName() const;
212  inline void SetName(const G4String& pName);
213  // Returns and sets the name of the logical volume.
214 
215  inline G4int 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.
220  inline void AddDaughter(G4VPhysicalVolume* p);
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  inline void RemoveDaughter(const G4VPhysicalVolume* p);
230  // Removes the volume p from the List of daughter of the current
231  // logical volume.
232  inline 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 
241  inline G4VSolid* GetSolid() const;
242  inline void SetSolid(G4VSolid *pSolid);
243  // Gets and sets the current solid.
244 
245  inline G4Material* GetMaterial() const;
246  inline void SetMaterial(G4Material *pMaterial);
247  // Gets and sets the current material.
248  inline void UpdateMaterial(G4Material *pMaterial);
249  // Sets material and corresponding MaterialCutsCouple.
250  // This method is invoked by G4Navigator while it is navigating through
251  // material parameterization.
252  G4double GetMass(G4bool forced=false, G4bool propagate=true,
253  G4Material* parMaterial=0);
254  // Returns the mass of the logical volume tree computed from the
255  // estimated geometrical volume of each solid and material associated
256  // to the logical volume and (by default) to its daughters.
257  // NOTE: the computation may require a considerable amount of time,
258  // depending from the complexity of the geometry tree.
259  // The returned value is cached and can be used for successive
260  // calls (default), unless recomputation is forced by providing
261  // 'true' for the boolean argument in input. Computation should
262  // be forced if the geometry setup has changed after the previous
263  // call. By setting the 'propagate' boolean flag to 'false' the
264  // method returns the mass of the present logical volume only
265  // (subtracted for the volume occupied by the daughter volumes).
266  // An optional argument to specify a material is also provided.
267  void ResetMass();
268  // Ensure that cached value of Mass is invalidated - due to change in
269  // state, e.g. change of size of Solid, change of type of solid,
270  // or the addition/deletion of a daughter volume.
271 
272  inline G4FieldManager* GetFieldManager() const;
273  // Gets current FieldManager.
274  void SetFieldManager(G4FieldManager *pFieldMgr, G4bool forceToAllDaughters);
275  // Sets FieldManager and propagates it:
276  // i) only to daughters with G4FieldManager = 0
277  // if forceToAllDaughters=false
278  // ii) to all daughters
279  // if forceToAllDaughters=true
280 
282  // Gets current SensitiveDetector.
283  inline void SetSensitiveDetector(G4VSensitiveDetector *pSDetector);
284  // Sets SensitiveDetector (can be 0).
285 
286  inline G4UserLimits* GetUserLimits() const;
287  inline void SetUserLimits(G4UserLimits *pULimits);
288  // Gets and sets current UserLimits.
289 
290  inline G4SmartVoxelHeader* GetVoxelHeader() const;
291  inline void SetVoxelHeader(G4SmartVoxelHeader *pVoxel);
292  // Gets and sets current VoxelHeader.
293 
294  inline G4double GetSmartless() const;
295  inline void SetSmartless(G4double s);
296  // Gets and sets user defined optimisation quality.
297 
298  inline G4bool IsToOptimise() const;
299  // Replies if geometry optimisation (voxelisation) is to be
300  // applied for this volume hierarchy.
301  inline void SetOptimisation(G4bool optim);
302  // Specifies if to apply or not geometry optimisation to this
303  // volume hierarchy. Note that for parameterised volumes in the
304  // hierarchy, optimisation is always applied.
305 
306  inline G4bool IsRootRegion() const;
307  // Replies if the logical volume represents a root region or not.
308  inline void SetRegionRootFlag(G4bool rreg);
309  // Sets/unsets the volume as a root region for cuts.
310  inline G4bool IsRegion() const;
311  // Replies if the logical volume is part of a cuts region or not.
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 belongs, if any.
316  inline void PropagateRegion();
317  // Propagates region pointer to daughters.
318 
319  inline const G4MaterialCutsCouple* GetMaterialCutsCouple() const;
320  inline void SetMaterialCutsCouple(G4MaterialCutsCouple* cuts);
321  // Accessors for production cuts.
322 
323  G4bool operator == (const G4LogicalVolume& lv) const;
324  // Equality defined by address only.
325  // Returns true if objects are at same address, else false.
326 
327  inline const G4VisAttributes* GetVisAttributes () const;
328  inline void SetVisAttributes (const G4VisAttributes* pVA);
329  void SetVisAttributes (const G4VisAttributes& VA);
330  // Gets and sets visualization attributes. A copy of 'VA' on the heap
331  // will be made in the case the call with a const reference is used.
332 
334  // Gets current FastSimulationManager pointer if exists, otherwise null.
335 
336  inline void SetBiasWeight (G4double w);
337  inline G4double GetBiasWeight() const;
338  // Sets and gets bias weight.
339 
340  public: // without description
341 
342  G4LogicalVolume(__void__&);
343  // Fake default constructor for usage restricted to direct object
344  // persistency for clients requiring preallocation of memory for
345  // persistifiable objects.
346 
347  inline G4FieldManager* GetMasterFieldManager() const;
348  // Gets current FieldManager for the master thread.
350  // Gets current SensitiveDetector for the master thread.
351  inline G4VSolid* GetMasterSolid() const;
352  // Gets current Solid for the master thread.
353 
354  inline G4int GetInstanceID() const;
355  // Returns the instance ID.
356  static const G4LVManager& GetSubInstanceManager();
357 
358  // Sets the private data instance manager - in order to use a particular Workspace
359 
360  // static const G4LVManager* GetSubInstanceManagerPtr();
361  // static const G4LVManager SetSubInstanceManager(G4LVManager* subInstanceManager);
362  // Revised Implementation - to enable Workspaces which can used by different
363  // threads at different times (only one thread or task can use a workspace at a time. )
364 
365  inline void Lock();
366  // Set lock identifier for final deletion of entity.
367 
368  void InitialiseWorker(G4LogicalVolume *ptrMasterObject,
369  G4VSolid* pSolid, G4VSensitiveDetector* pSDetector);
370  // This method is similar to the constructor. It is used by each worker
371  // thread to achieve the partial effect as that of the master thread.
372 
373  void TerminateWorker(G4LogicalVolume *ptrMasterObject);
374  // This method is similar to the destructor. It is used by each worker
375  // thread to achieve the partial effect as that of the master thread.
376 
377  inline void AssignFieldManager( G4FieldManager *fldMgr);
378  // Set the FieldManager - only at this level (do not push down hierarchy)
379 
380  // Optimised Methods - passing thread instance of worker data
381  inline static G4VSolid* GetSolid(G4LVData &instLVdata) ; // const;
382  inline static void SetSolid(G4LVData &instLVdata, G4VSolid *pSolid);
383 
384  private:
385 
387  G4LogicalVolume& operator=(const G4LogicalVolume&);
388  // Private copy-constructor and assignment operator.
389 
390  private:
391 
392  // Data members:
393 
394  G4PhysicalVolumeList fDaughters;
395  // Vector of daughters. Given initial size of 0.
396  G4String fName;
397  // Name of logical volume.
398  // Pointer (possibly 0) to `Hit' object.
399 
400  G4UserLimits* fUserLimits;
401  // Pointer (possibly 0) to user Step limit object for this node.
402  G4SmartVoxelHeader* fVoxel;
403  // Pointer (possibly 0) to optimisation info objects.
404  G4bool fOptimise;
405  // Flag to identify if optimisation should be applied or not.
406  G4bool fRootRegion;
407  // Flag to identify if the logical volume is a root region.
408  G4bool fLock;
409  // Flag to identify if entity is locked for final deletion.
410  G4double fSmartless;
411  // Quality for optimisation, average number of voxels to be spent
412  // per content.
413  const G4VisAttributes* fVisAttributes;
414  // Pointer (possibly 0) to visualization attributes.
415  G4Region* fRegion;
416  // Pointer to the cuts region (if any)
417  G4double fBiasWeight;
418  // Weight used in the event biasing technique.
419 
420  G4bool fChangedState;
421  // Invalidates any estimations from previous state
422 
423  G4int instanceID;
424  // This new field is used as instance ID.
425  G4GEOM_DLL static G4LVManager subInstanceManager;
426  // This new field helps to use the class G4LVManager introduced above.
427 
428  // Shadow of master pointers.
429  // Each worker thread can access this field from the master thread
430  // through these pointers.
431  //
432  G4VSolid* fSolid;
433  G4VSensitiveDetector* fSensitiveDetector;
434  G4FieldManager* fFieldManager;
435 };
436 
437 #include "G4LogicalVolume.icc"
438 
439 #endif
G4SmartVoxelHeader * GetVoxelHeader() const
G4double GetSmartless() const
void ClearDaughters()
void UpdateMaterial(G4Material *pMaterial)
G4String GetName() const
void SetRegionRootFlag(G4bool rreg)
G4VSolid * GetMasterSolid() const
const XML_Char * s
G4bool IsAncestor(const G4VPhysicalVolume *p) const
G4Material * GetMaterial() const
G4bool operator==(const G4LogicalVolume &lv) const
G4GeomSplitter< G4LVData > G4LVManager
const char * p
Definition: xmltok.h:285
static const G4LVManager & GetSubInstanceManager()
void SetUserLimits(G4UserLimits *pULimits)
G4double fMass
G4VPhysicalVolume * GetDaughter(const G4int i) const
const XML_Char * name
G4MaterialCutsCouple * fCutsCouple
void SetSolid(G4VSolid *pSolid)
G4FieldManager * GetMasterFieldManager() const
G4Region * GetRegion() const
G4VSensitiveDetector * fSensitiveDetector
int G4int
Definition: G4Types.hh:78
void InitialiseWorker(G4LogicalVolume *ptrMasterObject, G4VSolid *pSolid, G4VSensitiveDetector *pSDetector)
void SetFieldManager(G4FieldManager *pFieldMgr, G4bool forceToAllDaughters)
void SetVoxelHeader(G4SmartVoxelHeader *pVoxel)
void SetRegion(G4Region *reg)
G4double GetBiasWeight() const
void AssignFieldManager(G4FieldManager *fldMgr)
G4FieldManager * GetFieldManager() const
G4FieldManager * fFieldManager
G4VSensitiveDetector * GetMasterSensitiveDetector() const
bool G4bool
Definition: G4Types.hh:79
void SetOptimisation(G4bool optim)
G4FastSimulationManager * GetFastSimulationManager() const
G4bool IsRootRegion() const
G4bool IsRegion() const
const G4VisAttributes * GetVisAttributes() const
EVolume CharacteriseDaughters() const
void SetMaterialCutsCouple(G4MaterialCutsCouple *cuts)
void PropagateRegion()
G4int TotalVolumeEntities() const
G4LogicalVolume(G4VSolid *pSolid, G4Material *pMaterial, const G4String &name, G4FieldManager *pFieldMgr=0, G4VSensitiveDetector *pSDetector=0, G4UserLimits *pULimits=0, G4bool optimise=true)
G4int GetNoDaughters() const
G4UserLimits * GetUserLimits() const
G4Material * fMaterial
void TerminateWorker(G4LogicalVolume *ptrMasterObject)
void SetSmartless(G4double s)
G4bool IsDaughter(const G4VPhysicalVolume *p) const
void initialize()
void SetName(const G4String &pName)
G4int GetInstanceID() const
G4double GetMass(G4bool forced=false, G4bool propagate=true, G4Material *parMaterial=0)
const G4MaterialCutsCouple * GetMaterialCutsCouple() const
EVolume
Definition: geomdefs.hh:68
G4bool IsToOptimise() const
double G4double
Definition: G4Types.hh:76
void SetBiasWeight(G4double w)
void AddDaughter(G4VPhysicalVolume *p)
void SetMaterial(G4Material *pMaterial)
G4VSensitiveDetector * GetSensitiveDetector() const
#define G4GEOM_DLL
Definition: geomwdefs.hh:48
void SetVisAttributes(const G4VisAttributes *pVA)
void SetSensitiveDetector(G4VSensitiveDetector *pSDetector)
G4VSolid * GetSolid() const
G4VSolid * fSolid
void RemoveDaughter(const G4VPhysicalVolume *p)