| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer << 3 // * DISCLAIMER *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th << 5 // * The following disclaimer summarizes all the specific disclaimers *
6 // * the Geant4 Collaboration. It is provided << 6 // * of contributors to this software. The specific disclaimers,which *
7 // * conditions of the Geant4 Software License << 7 // * govern, are listed with their locations in: *
8 // * LICENSE and available at http://cern.ch/ << 8 // * http://cern.ch/geant4/license *
9 // * include a list of copyright holders. <<
10 // * 9 // * *
11 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file << 14 // * use. *
16 // * for the full disclaimer and the limitatio <<
17 // * 15 // * *
18 // * This code implementation is the result << 16 // * This code implementation is the intellectual property of the *
19 // * technical work of the GEANT4 collaboratio << 17 // * GEANT4 collaboration. *
20 // * By using, copying, modifying or distri << 18 // * By copying, distributing or modifying the Program (or any work *
21 // * any work based on the software) you ag << 19 // * based on the Program) you indicate your acceptance of this *
22 // * use in resulting scientific publicati << 20 // * statement, and all its terms. *
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* 21 // ********************************************************************
>> 22 //
>> 23 //
>> 24 // $Id: G4Region.icc,v 1.11 2005/08/18 16:51:37 asaim Exp $
>> 25 // GEANT4 tag $Name: geant4-08-00 $
>> 26 //
25 // 27 //
26 // G4Region inline implementation << 28 // class G4Region Inline Implementation file
27 // 29 //
28 // 19.09.02, G.Cosmo - Created << 30 // 19.09.02 - G.Cosmo: Created
29 // ------------------------------------------- 31 // --------------------------------------------------------------------
30 32
31 // ******************************************* 33 // ********************************************************************
32 // Equality operator, defined by address only 34 // Equality operator, defined by address only
33 // ******************************************* 35 // ********************************************************************
34 // 36 //
35 inline 37 inline
36 G4bool G4Region::operator==(const G4Region& rg 38 G4bool G4Region::operator==(const G4Region& rg) const
37 { 39 {
38 return this==&rg; << 40 return (this==&rg) ? true : false;
39 } 41 }
40 42
41 // ******************************************* 43 // ********************************************************************
42 // GetInstanceID << 44 // GetName
43 // ******************************************* 45 // ********************************************************************
44 // 46 //
45 inline 47 inline
46 G4int G4Region::GetInstanceID() const << 48 const G4String& G4Region::GetName() const
47 { 49 {
48 return instanceID; << 50 return fName;
49 } 51 }
50 52
51 // ******************************************* 53 // ********************************************************************
52 // GetName << 54 // SetName
53 // ******************************************* 55 // ********************************************************************
54 // 56 //
55 inline 57 inline
56 const G4String& G4Region::GetName() const << 58 void G4Region::SetName(const G4String& pName)
57 { 59 {
58 return fName; << 60 fName = pName;
59 } 61 }
60 << 62
61 // ******************************************* 63 // ********************************************************************
62 // RegionModified 64 // RegionModified
63 // ******************************************* 65 // ********************************************************************
64 // 66 //
65 inline 67 inline
66 void G4Region::RegionModified(G4bool flag) 68 void G4Region::RegionModified(G4bool flag)
67 { 69 {
68 fRegionMod = flag; 70 fRegionMod = flag;
69 } 71 }
70 72
71 // ******************************************* 73 // ********************************************************************
72 // IsModified 74 // IsModified
73 // ******************************************* 75 // ********************************************************************
74 // 76 //
75 inline 77 inline
76 G4bool G4Region::IsModified() const 78 G4bool G4Region::IsModified() const
77 { 79 {
78 return fRegionMod; 80 return fRegionMod;
79 } 81 }
80 82
81 // ******************************************* 83 // ********************************************************************
82 // SetProductionCuts 84 // SetProductionCuts
83 // ******************************************* 85 // ********************************************************************
84 // 86 //
85 inline 87 inline
86 void G4Region::SetProductionCuts(G4ProductionC 88 void G4Region::SetProductionCuts(G4ProductionCuts* cut)
87 { 89 {
88 fCut = cut; 90 fCut = cut;
89 fRegionMod = true; 91 fRegionMod = true;
90 } 92 }
91 93
92 // ******************************************* 94 // ********************************************************************
93 // GetProductionCuts 95 // GetProductionCuts
94 // ******************************************* 96 // ********************************************************************
95 // 97 //
96 inline 98 inline
97 G4ProductionCuts* G4Region::GetProductionCuts( 99 G4ProductionCuts* G4Region::GetProductionCuts() const
98 { 100 {
99 return fCut; 101 return fCut;
100 } 102 }
101 103
102 // ******************************************* 104 // ********************************************************************
103 // GetLogicalVolumeIterator 105 // GetLogicalVolumeIterator
104 // ******************************************* 106 // ********************************************************************
105 // 107 //
106 inline 108 inline
107 std::vector<G4LogicalVolume*>::iterator 109 std::vector<G4LogicalVolume*>::iterator
108 G4Region::GetRootLogicalVolumeIterator() 110 G4Region::GetRootLogicalVolumeIterator()
109 { 111 {
110 return G4RootLVList::iterator(fRootVolumes.b << 112 G4RootLVList::iterator iterator =
>> 113 G4RootLVList::iterator(fRootVolumes.begin());
>> 114 return iterator;
111 } 115 }
112 116
113 // ******************************************* 117 // ********************************************************************
114 // GetMaterialIterator 118 // GetMaterialIterator
115 // ******************************************* 119 // ********************************************************************
116 // 120 //
117 inline 121 inline
118 std::vector<G4Material*>::const_iterator 122 std::vector<G4Material*>::const_iterator
119 G4Region::GetMaterialIterator() const 123 G4Region::GetMaterialIterator() const
120 { 124 {
121 return fMaterials.cbegin(); << 125 G4MaterialList::const_iterator iterator = fMaterials.begin();
>> 126 return iterator;
122 } 127 }
123 128
124 // ******************************************* 129 // ********************************************************************
125 // GetNumberOfMaterials 130 // GetNumberOfMaterials
126 // ******************************************* 131 // ********************************************************************
127 // 132 //
128 inline 133 inline
129 size_t G4Region::GetNumberOfMaterials() const 134 size_t G4Region::GetNumberOfMaterials() const
130 { 135 {
131 return fMaterials.size(); 136 return fMaterials.size();
132 } 137 }
133 138
134 // ******************************************* 139 // ********************************************************************
135 // GetNumberOfRootVolumes 140 // GetNumberOfRootVolumes
136 // ******************************************* 141 // ********************************************************************
137 // 142 //
138 inline 143 inline
139 size_t G4Region::GetNumberOfRootVolumes() cons 144 size_t G4Region::GetNumberOfRootVolumes() const
140 { 145 {
141 return fRootVolumes.size(); 146 return fRootVolumes.size();
142 } 147 }
143 148
144 // ******************************************* 149 // ********************************************************************
145 // SetUserInformation 150 // SetUserInformation
146 // ******************************************* 151 // ********************************************************************
147 // 152 //
148 inline 153 inline
149 void G4Region::SetUserInformation(G4VUserRegio 154 void G4Region::SetUserInformation(G4VUserRegionInformation* ui)
150 { 155 {
151 fUserInfo = ui; 156 fUserInfo = ui;
152 } 157 }
153 158
154 // ******************************************* 159 // ********************************************************************
155 // GetUserInformation 160 // GetUserInformation
156 // ******************************************* 161 // ********************************************************************
157 // 162 //
158 inline 163 inline
159 G4VUserRegionInformation* G4Region::GetUserInf 164 G4VUserRegionInformation* G4Region::GetUserInformation() const
160 { 165 {
161 return fUserInfo; 166 return fUserInfo;
162 } 167 }
163 168
164 // ******************************************* 169 // ********************************************************************
165 // SetUserLimits 170 // SetUserLimits
166 // ******************************************* 171 // ********************************************************************
167 // 172 //
168 inline 173 inline
169 void G4Region::SetUserLimits(G4UserLimits* ul) 174 void G4Region::SetUserLimits(G4UserLimits* ul)
170 { 175 {
171 fUserLimits = ul; 176 fUserLimits = ul;
172 } 177 }
173 178
174 // ******************************************* 179 // ********************************************************************
175 // GetUserLimits 180 // GetUserLimits
176 // ******************************************* 181 // ********************************************************************
177 // 182 //
178 inline 183 inline
179 G4UserLimits* G4Region::GetUserLimits() const 184 G4UserLimits* G4Region::GetUserLimits() const
180 { 185 {
181 return fUserLimits; 186 return fUserLimits;
182 } 187 }
183 188
184 // ******************************************* 189 // ********************************************************************
185 // ClearMap 190 // ClearMap
186 // ******************************************* 191 // ********************************************************************
187 // 192 //
188 inline 193 inline
189 void G4Region::ClearMap() 194 void G4Region::ClearMap()
190 { 195 {
191 if(!(fMaterialCoupleMap.empty())) 196 if(!(fMaterialCoupleMap.empty()))
192 { 197 {
193 auto b = fMaterialCoupleMap.cbegin(); << 198 G4MaterialCoupleMap::iterator b = fMaterialCoupleMap.begin();
194 auto e = fMaterialCoupleMap.cend(); << 199 G4MaterialCoupleMap::iterator e = fMaterialCoupleMap.end();
195 fMaterialCoupleMap.erase(b,e); 200 fMaterialCoupleMap.erase(b,e);
196 } 201 }
197 } 202 }
198 203
199 // ******************************************* 204 // ********************************************************************
200 // RegisterMateralCouplePair 205 // RegisterMateralCouplePair
201 // ******************************************* 206 // ********************************************************************
202 // 207 //
203 inline 208 inline
204 void G4Region::RegisterMaterialCouplePair(G4Ma 209 void G4Region::RegisterMaterialCouplePair(G4Material* mat,
205 G4Ma 210 G4MaterialCutsCouple* couple)
206 { 211 {
207 fMaterialCoupleMap.insert(G4MaterialCouplePa 212 fMaterialCoupleMap.insert(G4MaterialCouplePair(mat,couple));
208 } 213 }
209 214
210 // ******************************************* 215 // ********************************************************************
211 // FindCouple 216 // FindCouple
212 // ******************************************* 217 // ********************************************************************
213 // 218 //
214 inline 219 inline
215 G4MaterialCutsCouple* G4Region::FindCouple(G4M 220 G4MaterialCutsCouple* G4Region::FindCouple(G4Material* mat)
216 { 221 {
217 auto c = fMaterialCoupleMap.find(mat); << 222 G4MaterialCoupleMap::iterator c = fMaterialCoupleMap.find(mat);
218 G4MaterialCutsCouple* couple = nullptr; << 223 G4MaterialCutsCouple* couple = 0;
219 if(c!=fMaterialCoupleMap.cend()) couple = (* << 224 if(c!=fMaterialCoupleMap.end()) couple = (*c).second;
220 return couple; 225 return couple;
221 } 226 }
222 227
223 // ******************************************* 228 // ********************************************************************
224 // GetFieldManager << 229 // SetFastSimulationManager
225 // ******************************************* 230 // ********************************************************************
226 // 231 //
227 inline << 232 inline
228 G4FieldManager* G4Region::GetFieldManager() co << 233 void G4Region::SetFastSimulationManager(G4FastSimulationManager* fsm)
229 { 234 {
230 return fFieldManager; << 235 fFastSimulationManager = fsm;
231 } 236 }
232 237
233 // ******************************************* 238 // ********************************************************************
234 // SetFieldManager << 239 // GetFastSimulationManager
235 // ******************************************* 240 // ********************************************************************
236 // 241 //
237 inline << 242 inline
238 void G4Region::SetFieldManager(G4FieldManager* << 243 G4FastSimulationManager* G4Region::GetFastSimulationManager() const
239 { 244 {
240 fFieldManager = fm; << 245 return fFastSimulationManager;
241 } 246 }
242 247
243 // ******************************************* 248 // ********************************************************************
244 // GetWorldPhysical 249 // GetWorldPhysical
245 // ******************************************* 250 // ********************************************************************
246 // 251 //
247 inline 252 inline
248 G4VPhysicalVolume* G4Region::GetWorldPhysical( 253 G4VPhysicalVolume* G4Region::GetWorldPhysical() const
249 { 254 {
250 return fWorldPhys; 255 return fWorldPhys;
251 } 256 }
252 257
253 // ******************************************* <<
254 // AddMaterial <<
255 // ******************************************* <<
256 // <<
257 inline <<
258 void G4Region::AddMaterial(G4Material* aMateri <<
259 { <<
260 auto pos = std::find(fMaterials.cbegin(),fMa <<
261 if (pos == fMaterials.cend()) <<
262 { <<
263 fMaterials.push_back(aMaterial); <<
264 fRegionMod = true; <<
265 } <<
266 } <<
267 258
268 // ******************************************* <<
269 // UsedInMassGeometry <<
270 // ******************************************* <<
271 // <<
272 inline <<
273 void G4Region::UsedInMassGeometry(G4bool val) <<
274 { <<
275 fInMassGeometry = val; <<
276 } <<
277 <<
278 // ******************************************* <<
279 // UsedInParallelGeometry <<
280 // ******************************************* <<
281 // <<
282 inline <<
283 void G4Region::UsedInParallelGeometry(G4bool v <<
284 { <<
285 fInParallelGeometry = val; <<
286 } <<
287 <<
288 // ******************************************* <<
289 // IsInMassGeometry <<
290 // ******************************************* <<
291 // <<
292 inline <<
293 G4bool G4Region::IsInMassGeometry() const <<
294 { <<
295 return fInMassGeometry; <<
296 } <<
297 259
298 // ******************************************* <<
299 // IsInParallelGeometry <<
300 // ******************************************* <<
301 // <<
302 inline <<
303 G4bool G4Region::IsInParallelGeometry() const <<
304 { <<
305 return fInParallelGeometry; <<
306 } <<
307 260