| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
24 // *******************************************
25 //
26 // class G4LogicalVolume inline implementation
27 //
28 // 15.01.13 - G.Cosmo, A.Dotti: Modified for t
29 // 10.20.97 - P. MoraDeFreitas : Added SetFast
30 // 05.11.98 - M. Verderi: Add Get/Set methods
31 // 09.11.98 - J.Apostolakis: Changed Magnetic
32 // 12.02.99 - S.Giani: Added set/get methods f
33 // 18.04.01 - G.Cosmo: Migrated to STL vector
34 // 17.05.02 - G.Cosmo: Added IsToOptimise() me
35 // -------------------------------------------
36
37 // *******************************************
38 // GetName
39 // *******************************************
40 //
41 inline
42 const G4String& G4LogicalVolume::GetName() con
43 {
44 return fName;
45 }
46
47 // *******************************************
48 // GetInstanceID
49 // *******************************************
50 //
51 inline
52 G4int G4LogicalVolume::GetInstanceID() const
53 {
54 return instanceID;
55 }
56
57 // *******************************************
58 // GetMasterFieldManager
59 // *******************************************
60 //
61 inline
62 G4FieldManager* G4LogicalVolume::GetMasterFiel
63 {
64 return fFieldManager;
65 }
66
67 // *******************************************
68 // GetNoDaughters
69 // *******************************************
70 //
71 inline
72 std::size_t G4LogicalVolume::GetNoDaughters()
73 {
74 return fDaughters.size();
75 }
76
77 // *******************************************
78 // GetDaughter
79 // *******************************************
80 //
81 inline
82 G4VPhysicalVolume* G4LogicalVolume::GetDaughte
83 {
84 return fDaughters[i];
85 }
86
87 // *******************************************
88 // GetFastSimulationManager
89 // *******************************************
90 //
91 inline
92 G4FastSimulationManager* G4LogicalVolume::GetF
93 {
94 G4FastSimulationManager* fFSM = nullptr;
95 if(fRegion != nullptr) fFSM = fRegion->GetFa
96 return fFSM;
97 }
98
99 // *******************************************
100 // IsDaughter
101 // *******************************************
102 //
103 inline
104 G4bool G4LogicalVolume::IsDaughter(const G4VPh
105 {
106 for (const auto & daughter : fDaughters)
107 {
108 if (*daughter==*p) return true;
109 }
110 return false;
111 }
112
113 // *******************************************
114 // CharacteriseDaughters
115 // *******************************************
116 //
117 inline
118 EVolume G4LogicalVolume::CharacteriseDaughters
119 {
120 return fDaughtersVolumeType;
121 }
122
123 // *******************************************
124 // DeduceDaughtersType
125 // *******************************************
126 //
127 inline
128 EVolume G4LogicalVolume::DeduceDaughtersType()
129 {
130 EVolume type= kNormal;
131 G4VPhysicalVolume* pVol;
132
133 if ( GetNoDaughters() >= 1 )
134 {
135 pVol = GetDaughter(0);
136 type = pVol->VolumeType();
137 }
138 return type;
139 }
140
141 // *******************************************
142 // GetMasterSolid
143 // *******************************************
144 //
145 inline
146 G4VSolid* G4LogicalVolume::GetMasterSolid() co
147 {
148 return fSolid;
149 }
150
151 // *******************************************
152 // GetMasterSensitiveDetector
153 // *******************************************
154 //
155 inline
156 G4VSensitiveDetector* G4LogicalVolume::GetMast
157 {
158 return fSensitiveDetector;
159 }
160
161 // *******************************************
162 // GetUserLimits
163 // *******************************************
164 //
165 inline
166 G4UserLimits* G4LogicalVolume::GetUserLimits()
167 {
168 if(fUserLimits != nullptr) return fUserLimit
169 if(fRegion != nullptr) return fRegion->GetUs
170 return nullptr;
171 }
172
173 // *******************************************
174 // SetUserLimits
175 // *******************************************
176 //
177 inline
178 void G4LogicalVolume::SetUserLimits(G4UserLimi
179 {
180 fUserLimits = pULimits;
181 }
182
183 // *******************************************
184 // GetVoxelHeader
185 // *******************************************
186 //
187 inline
188 G4SmartVoxelHeader* G4LogicalVolume::GetVoxelH
189 {
190 return fVoxel;
191 }
192
193 // *******************************************
194 // SetVoxelHeader
195 // *******************************************
196 //
197 inline
198 void G4LogicalVolume::SetVoxelHeader(G4SmartVo
199 {
200 fVoxel = pVoxel;
201 }
202
203 // *******************************************
204 // GetSmartless
205 // *******************************************
206 //
207 inline
208 G4double G4LogicalVolume::GetSmartless() const
209 {
210 return fSmartless;
211 }
212
213 // *******************************************
214 // SetSmartless
215 // *******************************************
216 //
217 inline
218 void G4LogicalVolume::SetSmartless(G4double sm
219 {
220 fSmartless = smt;
221 }
222
223 // *******************************************
224 // IsToOptimise
225 // *******************************************
226 //
227 inline
228 G4bool G4LogicalVolume::IsToOptimise() const
229 {
230 return fOptimise;
231 }
232
233 // *******************************************
234 // SetOptimisation
235 // *******************************************
236 //
237 inline
238 void G4LogicalVolume::SetOptimisation(G4bool o
239 {
240 fOptimise = optim;
241 }
242
243 // *******************************************
244 // IsRootRegion
245 // *******************************************
246 //
247 inline
248 G4bool G4LogicalVolume::IsRootRegion() const
249 {
250 return fRootRegion;
251 }
252
253 // *******************************************
254 // SetRegionRootFlag
255 // *******************************************
256 //
257 inline
258 void G4LogicalVolume::SetRegionRootFlag(G4bool
259 {
260 fRootRegion = rreg;
261 }
262
263 // *******************************************
264 // IsRegion
265 // *******************************************
266 //
267 inline
268 G4bool G4LogicalVolume::IsRegion() const
269 {
270 G4bool reg = false;
271 if (fRegion != nullptr) reg = true;
272 return reg;
273 }
274
275 // *******************************************
276 // SetRegion
277 // *******************************************
278 //
279 inline
280 void G4LogicalVolume::SetRegion(G4Region* reg)
281 {
282 fRegion = reg;
283 }
284
285 // *******************************************
286 // GetRegion
287 // *******************************************
288 //
289 inline
290 G4Region* G4LogicalVolume::GetRegion() const
291 {
292 return fRegion;
293 }
294
295 // *******************************************
296 // PropagateRegion
297 // *******************************************
298 //
299 inline
300 void G4LogicalVolume::PropagateRegion()
301 {
302 fRegion->ScanVolumeTree(this, true);
303 }
304
305 // *******************************************
306 // Lock
307 // *******************************************
308 //
309 inline
310 void G4LogicalVolume::Lock()
311 {
312 fLock = true;
313 }
314
315 // *******************************************
316 // Operator ==
317 // *******************************************
318 //
319 inline
320 G4bool G4LogicalVolume::operator == ( const G4
321 {
322 return this==&lv;
323 }
324
325 // *******************************************
326 // SetBiasWeight
327 // *******************************************
328 //
329 inline
330 void G4LogicalVolume::SetBiasWeight(G4double w
331 {
332 fBiasWeight = weight;
333 }
334
335 // *******************************************
336 // GetBiasWeight
337 // *******************************************
338 //
339 inline
340 G4double G4LogicalVolume::GetBiasWeight() cons
341 {
342 return fBiasWeight;
343 }
344
345 // *******************************************
346 // GetVisAttributes
347 // *******************************************
348 //
349 inline
350 const G4VisAttributes* G4LogicalVolume::GetVis
351 {
352 return fVisAttributes.get();
353 }
354