Geant4  10.01.p01
G4Region.icc
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: G4Region.icc 67975 2013-03-13 10:19:44Z gcosmo $
28 //
29 //
30 // class G4Region Inline Implementation file
31 //
32 // 19.09.02 - G.Cosmo: Created
33 // --------------------------------------------------------------------
34 
35 // ********************************************************************
36 // Equality operator, defined by address only
37 // ********************************************************************
38 //
39 inline
40 G4bool G4Region::operator==(const G4Region& rg) const
41 {
42  return (this==&rg) ? true : false;
43 }
44 
45 // ********************************************************************
46 // GetInstanceID
47 // ********************************************************************
48 //
49 inline
50 G4int G4Region::GetInstanceID() const
51 {
52  return instanceID;
53 }
54 
55 // ********************************************************************
56 // GetName
57 // ********************************************************************
58 //
59 inline
60 const G4String& G4Region::GetName() const
61 {
62  return fName;
63 }
64 
65 // ********************************************************************
66 // SetName
67 // ********************************************************************
68 //
69 inline
70 void G4Region::SetName(const G4String& pName)
71 {
72  fName = pName;
73 }
74 
75 // ********************************************************************
76 // RegionModified
77 // ********************************************************************
78 //
79 inline
80 void G4Region::RegionModified(G4bool flag)
81 {
82  fRegionMod = flag;
83 }
84 
85 // ********************************************************************
86 // IsModified
87 // ********************************************************************
88 //
89 inline
90 G4bool G4Region::IsModified() const
91 {
92  return fRegionMod;
93 }
94 
95 // ********************************************************************
96 // SetProductionCuts
97 // ********************************************************************
98 //
99 inline
100 void G4Region::SetProductionCuts(G4ProductionCuts* cut)
101 {
102  fCut = cut;
103  fRegionMod = true;
104 }
105 
106 // ********************************************************************
107 // GetProductionCuts
108 // ********************************************************************
109 //
110 inline
111 G4ProductionCuts* G4Region::GetProductionCuts() const
112 {
113  return fCut;
114 }
115 
116 // ********************************************************************
117 // GetLogicalVolumeIterator
118 // ********************************************************************
119 //
120 inline
121 std::vector<G4LogicalVolume*>::iterator
122 G4Region::GetRootLogicalVolumeIterator()
123 {
124  G4RootLVList::iterator iterator =
125  G4RootLVList::iterator(fRootVolumes.begin());
126  return iterator;
127 }
128 
129 // ********************************************************************
130 // GetMaterialIterator
131 // ********************************************************************
132 //
133 inline
134 std::vector<G4Material*>::const_iterator
135 G4Region::GetMaterialIterator() const
136 {
137  G4MaterialList::const_iterator iterator = fMaterials.begin();
138  return iterator;
139 }
140 
141 // ********************************************************************
142 // GetNumberOfMaterials
143 // ********************************************************************
144 //
145 inline
146 size_t G4Region::GetNumberOfMaterials() const
147 {
148  return fMaterials.size();
149 }
150 
151 // ********************************************************************
152 // GetNumberOfRootVolumes
153 // ********************************************************************
154 //
155 inline
156 size_t G4Region::GetNumberOfRootVolumes() const
157 {
158  return fRootVolumes.size();
159 }
160 
161 // ********************************************************************
162 // SetUserInformation
163 // ********************************************************************
164 //
165 inline
166 void G4Region::SetUserInformation(G4VUserRegionInformation* ui)
167 {
168  fUserInfo = ui;
169 }
170 
171 // ********************************************************************
172 // GetUserInformation
173 // ********************************************************************
174 //
175 inline
176 G4VUserRegionInformation* G4Region::GetUserInformation() const
177 {
178  return fUserInfo;
179 }
180 
181 // ********************************************************************
182 // SetUserLimits
183 // ********************************************************************
184 //
185 inline
186 void G4Region::SetUserLimits(G4UserLimits* ul)
187 {
188  fUserLimits = ul;
189 }
190 
191 // ********************************************************************
192 // GetUserLimits
193 // ********************************************************************
194 //
195 inline
196 G4UserLimits* G4Region::GetUserLimits() const
197 {
198  return fUserLimits;
199 }
200 
201 // ********************************************************************
202 // ClearMap
203 // ********************************************************************
204 //
205 inline
206 void G4Region::ClearMap()
207 {
208  if(!(fMaterialCoupleMap.empty()))
209  {
210  G4MaterialCoupleMap::iterator b = fMaterialCoupleMap.begin();
211  G4MaterialCoupleMap::iterator e = fMaterialCoupleMap.end();
212  fMaterialCoupleMap.erase(b,e);
213  }
214 }
215 
216 // ********************************************************************
217 // RegisterMateralCouplePair
218 // ********************************************************************
219 //
220 inline
221 void G4Region::RegisterMaterialCouplePair(G4Material* mat,
222  G4MaterialCutsCouple* couple)
223 {
224  fMaterialCoupleMap.insert(G4MaterialCouplePair(mat,couple));
225 }
226 
227 // ********************************************************************
228 // FindCouple
229 // ********************************************************************
230 //
231 inline
232 G4MaterialCutsCouple* G4Region::FindCouple(G4Material* mat)
233 {
234  G4MaterialCoupleMap::iterator c = fMaterialCoupleMap.find(mat);
235  G4MaterialCutsCouple* couple = 0;
236  if(c!=fMaterialCoupleMap.end()) couple = (*c).second;
237  return couple;
238 }
239 
240 // ********************************************************************
241 // SetFastSimulationManager
242 // ********************************************************************
243 //
244 inline
245 void G4Region::SetFastSimulationManager(G4FastSimulationManager* fsm)
246 {
247  G4MT_fsmanager = fsm;
248 }
249 
250 // ********************************************************************
251 // GetFastSimulationManager
252 // ********************************************************************
253 //
254 inline
255 G4FastSimulationManager* G4Region::GetFastSimulationManager() const
256 {
257  return G4MT_fsmanager;
258 }
259 
260 // ********************************************************************
261 // GetFieldManager
262 // ********************************************************************
263 //
264 inline
265 G4FieldManager* G4Region::GetFieldManager() const
266 {
267  return fFieldManager;
268 }
269 
270 // ********************************************************************
271 // SetFieldManager
272 // ********************************************************************
273 //
274 inline
275 void G4Region::SetFieldManager(G4FieldManager* fm)
276 {
277  fFieldManager = fm;
278 }
279 
280 // ********************************************************************
281 // GetWorldPhysical
282 // ********************************************************************
283 //
284 inline
285 G4VPhysicalVolume* G4Region::GetWorldPhysical() const
286 {
287  return fWorldPhys;
288 }
289 
290 // ********************************************************************
291 // AddMaterial
292 // ********************************************************************
293 //
294 inline
295 void G4Region::AddMaterial(G4Material* aMaterial)
296 {
297  G4MaterialList::iterator pos =
298  std::find(fMaterials.begin(),fMaterials.end(),aMaterial);
299  if (pos == fMaterials.end())
300  {
301  fMaterials.push_back(aMaterial);
302  fRegionMod = true;
303  }
304 }
305 
306 // ********************************************************************
307 // SetRegionalSteppingAction
308 // ********************************************************************
309 //
310 inline
311 void G4Region::SetRegionalSteppingAction(G4UserSteppingAction* rusa)
312 {
313  G4MT_rsaction = rusa;
314 }
315 
316 // ********************************************************************
317 // GetRegionalSteppingAction
318 // ********************************************************************
319 //
320 inline
321 G4UserSteppingAction* G4Region::GetRegionalSteppingAction() const
322 {
323  return G4MT_rsaction;
324 }
325 
326 // ********************************************************************
327 // UsedInMassGeometry
328 // ********************************************************************
329 //
330 inline
331 void G4Region::UsedInMassGeometry(G4bool val)
332 {
333  fInMassGeometry = val;
334 }
335 
336 // ********************************************************************
337 // UsedInParallelGeometry
338 // ********************************************************************
339 //
340 inline
341 void G4Region::UsedInParallelGeometry(G4bool val)
342 {
343  fInParallelGeometry = val;
344 }
345 
346 // ********************************************************************
347 // IsInMassGeometry
348 // ********************************************************************
349 //
350 inline
351 G4bool G4Region::IsInMassGeometry() const
352 {
353  return fInMassGeometry;
354 }
355 
356 // ********************************************************************
357 // IsInParallelGeometry
358 // ********************************************************************
359 //
360 inline
361 G4bool G4Region::IsInParallelGeometry() const
362 {
363  return fInParallelGeometry;
364 }