ECCE @ EIC Software
Reference for
ECCE @ EIC
simulation and reconstruction software on GitHub
Home page
Related Pages
Modules
Namespaces
Classes
Files
External Links
File List
File Members
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
;
120
class
G4VSensitiveDetector
;
121
class
G4VSolid
;
122
class
G4UserLimits
;
123
class
G4SmartVoxelHeader
;
124
class
G4VisAttributes
;
125
class
G4FastSimulationManager
;
126
class
G4MaterialCutsCouple
;
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.
150
G4VSensitiveDetector
*
fSensitiveDetector
=
nullptr
;
151
// Pointer to sensitive detector.
152
G4FieldManager
*
fFieldManager
=
nullptr
;
153
// Pointer (possibly nullptr) to (magnetic or other) field manager object.
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
=
nullptr
;
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
//
180
typedef
G4GeomSplitter<G4LVData>
G4LVManager
;
181
182
class
G4LogicalVolume
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.
220
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
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
274
G4FieldManager
*
GetFieldManager
()
const
;
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
283
G4VSensitiveDetector
*
GetSensitiveDetector
()
const
;
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
321
const
G4MaterialCutsCouple
*
GetMaterialCutsCouple
()
const
;
322
void
SetMaterialCutsCouple
(
G4MaterialCutsCouple
* cuts);
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
335
inline
G4FastSimulationManager
*
GetFastSimulationManager
()
const
;
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.
354
inline
G4VSensitiveDetector
*
GetMasterSensitiveDetector
()
const
;
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
387
G4bool
ChangeDaughtersType
(
EVolume
atype);
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
397
G4PhysicalVolumeList
fDaughters
;
398
// Vector of daughters. Given initial size of 0.
399
G4String
fName
;
400
// Name of logical volume.
401
EVolume
fDaughtersVolumeType
;
402
// Are contents of volume placements, replica, parameterised or external?
403
404
G4UserLimits
*
fUserLimits
=
nullptr
;
405
// Pointer (possibly nullptr) to user Step limit object for this node.
406
G4SmartVoxelHeader
*
fVoxel
=
nullptr
;
407
// Pointer (possibly nullptr) to optimisation info objects.
408
G4bool
fOptimise
=
true
;
409
// Flag to identify if optimisation should be applied or not.
410
G4bool
fRootRegion
=
false
;
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.
414
G4double
fSmartless
= 2.0;
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)
421
G4double
fBiasWeight
= 1.0;
422
// Weight used in the event biasing technique.
423
424
G4int
instanceID
;
425
// This new field is used as instance ID.
426
G4GEOM_DLL
static
G4LVManager
subInstanceManager
;
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
;
434
G4VSensitiveDetector
*
fSensitiveDetector
=
nullptr
;
435
G4FieldManager
*
fFieldManager
=
nullptr
;
436
G4LVData
*
lvdata
=
nullptr
;
// For use of object persistency
437
};
438
439
#include "G4LogicalVolume.icc"
440
441
#endif
geant4
tree
geant4-10.6-release
source
geometry
management
include
G4LogicalVolume.hh
Built by
Jin Huang
. updated:
Wed Jun 29 2022 17:25:17
using
1.8.2 with
ECCE GitHub integration