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
G4VPhysicalVolume.hh
Go to the documentation of this file.
Or view
the newest version in sPHENIX GitHub for file G4VPhysicalVolume.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
// G4VPhysicalVolume
27
//
28
// Class description:
29
//
30
// This is an Abstract Base class for the representation of positioned volume.
31
// The volume is placed within a mother volume, relative to its coordinate
32
// system. Either a single positioned volume or many positioned volume can
33
// be represented by a particular G4VPhysicalVolume.
34
35
// 15.01.13, G.Cosmo, A.Dotti: Modified for thread-safety for MT
36
// 28.08.96, P.Kent: Replaced transform by rotmat + vector
37
// 25.07.96, P.Kent: Modified interface for new `Replica' capable geometry
38
// 24.07.95, P.Kent: First non-stub version
39
// --------------------------------------------------------------------
40
#ifndef G4VPHYSICALVOLUME_HH
41
#define G4VPHYSICALVOLUME_HH
42
43
#include "
G4Types.hh
"
44
#include "G4String.hh"
45
46
#include "
geomdefs.hh
"
47
48
#include "
G4RotationMatrix.hh
"
49
#include "
G4ThreeVector.hh
"
50
#include "
G4GeomSplitter.hh
"
51
52
class
G4LogicalVolume
;
53
class
G4VPVParameterisation
;
54
55
class
G4PVData
56
{
57
// Encapsulates the fields associated to G4VPhysicalVolume
58
// that are not read-only - they will change during simulation
59
// and must have a per-thread state.
60
61
public
:
62
63
G4PVData
() {}
64
65
void
initialize
()
66
{
67
frot
=
nullptr
;
68
tx
= 0.;
ty
= 0.;
tz
= 0.;
69
}
70
71
G4RotationMatrix
*
frot
=
nullptr
;
72
G4double
tx
= 0.,
ty
= 0.,
tz
= 0.;
73
};
74
75
typedef
G4GeomSplitter<G4PVData>
G4PVManager
;
76
// Implementation detail for use of G4PVData objects
77
78
class
G4VPhysicalVolume
79
{
80
public
:
// with description
81
82
G4VPhysicalVolume
(
G4RotationMatrix
* pRot,
83
const
G4ThreeVector
& tlate,
84
const
G4String
& pName,
85
G4LogicalVolume
* pLogical,
86
G4VPhysicalVolume
* pMother);
87
// Initialise volume, positioned in a frame which is rotated by *pRot,
88
// relative to the coordinate system of the mother volume pMother.
89
// The center of the object is then placed at tlate in the new
90
// coordinates. If pRot=0 the volume is unrotated with respect to its
91
// mother. The physical volume is added to the mother's logical volume.
92
//
93
// Must be called by all subclasses. pMother must point to a valid parent
94
// volume, except in the case of the world/top volume, when it =0.
95
//
96
// The constructor also registers volume with physical volume Store.
97
// Note that the Store may be removed or dynamically built in future
98
// because of memory constraints.
99
100
virtual
~G4VPhysicalVolume
();
101
// Destructor, will be subclassed. Removes volume from volume Store.
102
103
G4VPhysicalVolume
(
const
G4VPhysicalVolume
&) =
delete
;
104
G4VPhysicalVolume
&
operator=
(
const
G4VPhysicalVolume
&) =
delete
;
105
// No copy constructor and assignment operator.
106
107
inline
G4bool
operator ==
(
const
G4VPhysicalVolume
&
p
)
const
;
108
// Equality defined by equal addresses only.
109
110
// Access functions
111
//
112
// The following are accessor functions that make a distinction
113
// between whether the rotation/translation is being made for the
114
// frame or the object/volume that is being placed.
115
// (They are the inverse of each other).
116
117
G4RotationMatrix
*
GetObjectRotation
()
const
;
// Obsolete
118
G4RotationMatrix
GetObjectRotationValue
()
const
;
// Replacement
119
G4ThreeVector
GetObjectTranslation
()
const
;
120
// Return the rotation/translation of the Object relative to the mother.
121
const
G4RotationMatrix
*
GetFrameRotation
()
const
;
122
G4ThreeVector
GetFrameTranslation
()
const
;
123
// Return the rotation/translation of the Frame used to position
124
// this volume in its mother volume (opposite of object rot/trans).
125
126
// Older access functions, that do not distinguish between frame/object!
127
128
const
G4ThreeVector
GetTranslation
()
const
;
129
const
G4RotationMatrix
*
GetRotation
()
const
;
130
// Old access functions, that do not distinguish between frame/object!
131
// They return the translation/rotation of the volume.
132
133
// Set functions
134
135
void
SetTranslation
(
const
G4ThreeVector
&
v
);
136
G4RotationMatrix
*
GetRotation
();
137
void
SetRotation
(
G4RotationMatrix
*);
138
// NOT INTENDED FOR GENERAL USE.
139
// Non constant versions of above. Used to change transformation
140
// for replication/parameterisation mechanism.
141
142
inline
G4LogicalVolume
*
GetLogicalVolume
()
const
;
143
// Return the associated logical volume.
144
inline
void
SetLogicalVolume
(
G4LogicalVolume
* pLogical);
145
// Set the logical volume. Must not be called when geometry closed.
146
147
inline
G4LogicalVolume
*
GetMotherLogical
()
const
;
148
// Return the current mother logical volume pointer.
149
inline
void
SetMotherLogical
(
G4LogicalVolume
* pMother);
150
// Set the mother logical volume. Must not be called when geometry closed.
151
152
inline
const
G4String
&
GetName
()
const
;
153
// Return the volume's name.
154
inline
void
SetName
(
const
G4String
& pName);
155
// Set the volume's name.
156
157
virtual
G4int
GetMultiplicity
()
const
;
158
// Returns number of object entities (1 for normal placements,
159
// n for replicas or parameterised).
160
161
// Functions required of subclasses
162
163
virtual
EVolume
VolumeType
()
const
= 0;
164
// Characterise the type of volume - normal/replicated/parameterised.
165
virtual
G4bool
IsMany
()
const
= 0;
166
// Return true if the volume is MANY (not implemented yet).
167
virtual
G4int
GetCopyNo
()
const
= 0;
168
// Return the volumes copy number.
169
virtual
void
SetCopyNo
(
G4int
CopyNo) = 0;
170
// Set the volumes copy number.
171
virtual
G4bool
IsReplicated
()
const
= 0;
172
// Return true if replicated (single object instance represents
173
// many real volumes), else false.
174
virtual
G4bool
IsParameterised
()
const
= 0;
175
// Return true if parameterised (single object instance represents
176
// many real parameterised volumes), else false.
177
virtual
G4VPVParameterisation
*
GetParameterisation
()
const
= 0;
178
// Return replicas parameterisation object (able to compute dimensions
179
// and transformations of replicas), or NULL if not applicable.
180
virtual
void
GetReplicationData
(
EAxis
& axis,
181
G4int
& nReplicas,
182
G4double
&
width
,
183
G4double
&
offset
,
184
G4bool
& consuming)
const
= 0;
185
// Return replication information. No-op for no replicated volumes.
186
virtual
G4bool
IsRegularStructure
()
const
= 0;
187
// Returns true if the underlying volume structure is regular.
188
virtual
G4int
GetRegularStructureId
()
const
= 0;
189
// Returns non-zero code in case the underlying volume structure
190
// is regular, voxel-like. Value is id for structure type.
191
// If non-zero the volume is a candidate for specialised
192
// navigation such as 'nearest neighbour' directly on volumes.
193
virtual
G4bool
CheckOverlaps
(
G4int
res=1000,
G4double
tol=0.,
194
G4bool
verbose=
true
,
G4int
errMax=1);
195
// Verifies if the placed volume is overlapping with existing
196
// daughters or with the mother volume. Provides default resolution
197
// for the number of points to be generated and verified.
198
// Concrete implementation is done and required only for placed and
199
// parameterised volumes. Returns true if the volume is overlapping.
200
201
public
:
// without description
202
203
G4VPhysicalVolume
(__void__&);
204
// Fake default constructor for usage restricted to direct object
205
// persistency for clients requiring preallocation of memory for
206
// persistifiable objects.
207
208
inline
G4int
GetInstanceID
()
const
;
209
// Returns the instance ID.
210
211
static
const
G4PVManager
&
GetSubInstanceManager
();
212
// Returns the private data instance manager.
213
214
static
void
Clean
();
215
// Clear memory allocated by sub-instance manager.
216
217
inline
EVolume
DeduceVolumeType
()
const
;
218
// Old VolumeType() method, replaced by virtual method,
219
// kept for checking
220
221
protected
:
222
223
void
InitialiseWorker
(
G4VPhysicalVolume
* pMasterObject,
224
G4RotationMatrix
* pRot,
const
G4ThreeVector
& tlate);
225
// This method is similar to the constructor. It is used by each worker
226
// thread to achieve the partial effect as that of the master thread.
227
228
void
TerminateWorker
(
G4VPhysicalVolume
* pMasterObject);
229
// This method is similar to the destructor. It is used by each worker
230
// thread to achieve the partial effect as that of the master thread.
231
232
protected
:
233
234
G4int
instanceID
;
235
// For use in implementing the per-thread data,
236
// It is equivalent to a pointer to a G4PVData object.
237
G4GEOM_DLL
static
G4PVManager
subInstanceManager
;
238
// Needed to use G4PVManager for the G4PVData per-thread objects.
239
240
private
:
241
242
G4LogicalVolume
*
flogical
=
nullptr
;
// The logical volume representing the
243
// physical and tracking attributes of
244
// the volume
245
G4String
fname
;
// The name of the volume
246
G4LogicalVolume
*
flmother
=
nullptr
;
// The current mother logical volume
247
248
G4PVData
*
pvdata
=
nullptr
;
// Shadow pointer for use of object persistency
249
};
250
251
// NOTE:
252
// The type G4PVManager is introduced to encapsulate the methods used by
253
// both the master thread and worker threads to allocate memory space for
254
// the fields encapsulated by the class G4PVData. When each thread
255
// initializes the value for these fields, it refers to them using a macro
256
// definition defined below. For every G4VPhysicalVolume instance, there is
257
// a corresponding G4PVData instance. All G4PVData instances are organized
258
// by the class G4PVManager as an array.
259
// The field "int instanceID" is added to the class G4VPhysicalVolume.
260
// The value of this field in each G4VPhysicalVolume instance is the subscript
261
// of the corresponding G4PVData instance.
262
// In order to use the class G4PVManager, we add a static member in the class
263
// G4VPhysicalVolume as follows: "static G4PVManager subInstanceManager;".
264
// For the master thread, the array for G4PVData instances grows dynamically
265
// along with G4VPhysicalVolume instances are created. For each worker thread,
266
// it copies the array of G4PVData instances from the master thread.
267
// In addition, it invokes a method similiar to the constructor explicitly
268
// to achieve the partial effect for each instance in the array.
269
//
270
271
#include "G4VPhysicalVolume.icc"
272
273
#endif
geant4
tree
geant4-10.6-release
source
geometry
management
include
G4VPhysicalVolume.hh
Built by
Jin Huang
. updated:
Wed Jun 29 2022 17:25:17
using
1.8.2 with
ECCE GitHub integration