| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer 3 // * License and Disclaimer *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th 5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided 6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License 7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/ 8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. 9 // * include a list of copyright holders. *
10 // * 10 // * *
11 // * Neither the authors of this software syst 11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file 15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitatio 16 // * for the full disclaimer and the limitation of liability. *
17 // * 17 // * *
18 // * This code implementation is the result 18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboratio 19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distri 20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you ag 21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publicati 22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Sof 23 // * acceptance of all terms of the Geant4 Software license. *
24 // ******************************************* 24 // ********************************************************************
25 // 25 //
26 // 26 //
>> 27 // $Id: G4Scene.cc 101958 2016-12-12 08:04:35Z gcosmo $
27 // 28 //
28 // 29 //
29 // Scene data John Allison 19th July 1996. 30 // Scene data John Allison 19th July 1996.
30 31
31 #include "G4Scene.hh" 32 #include "G4Scene.hh"
32 33
33 #include "G4Vector3D.hh" 34 #include "G4Vector3D.hh"
34 #include "G4BoundingExtentScene.hh" << 35 #include "G4BoundingSphereScene.hh"
35 #include "G4VisAttributes.hh" 36 #include "G4VisAttributes.hh"
36 #include "G4PhysicalVolumeModel.hh" 37 #include "G4PhysicalVolumeModel.hh"
37 #include "G4TransportationManager.hh" 38 #include "G4TransportationManager.hh"
38 39
39 #include <set> 40 #include <set>
40 41
41 #define G4warn G4cout <<
42 <<
43 G4Scene::G4Scene (const G4String& name): 42 G4Scene::G4Scene (const G4String& name):
44 fName (name), 43 fName (name),
45 fRefreshAtEndOfEvent(true), 44 fRefreshAtEndOfEvent(true),
46 fRefreshAtEndOfRun(true), 45 fRefreshAtEndOfRun(true),
47 fMaxNumberOfKeptEvents(100) 46 fMaxNumberOfKeptEvents(100)
48 {} // Note all other data members have default 47 {} // Note all other data members have default initial values.
49 48
50 G4Scene::~G4Scene () {} 49 G4Scene::~G4Scene () {}
51 50
52 namespace { << 51 G4bool G4Scene::AddRunDurationModel (G4VModel* pModel, G4bool warn)
53 void PrintInvalidModel(const G4VModel* model << 52 {
54 { << 53 std::vector<Model>::const_iterator i;
55 G4ExceptionDescription ed; << 54 for (i = fRunDurationModelList.begin ();
56 ed << "Invalid model \"" << model->GetGlob << 55 i != fRunDurationModelList.end (); ++i) {
57 << "\".\n Not included in extent calculat << 56 if (pModel -> GetGlobalDescription () ==
58 G4Exception << 57 i->fpModel->GetGlobalDescription ()) break;
59 ("G4Scene::CalculateExtent", <<
60 "visman0201", JustWarning, ed); <<
61 } 58 }
>> 59 if (i != fRunDurationModelList.end ()) {
>> 60 if (warn) {
>> 61 G4cout << "G4Scene::AddRunDurationModel: model \""
>> 62 << pModel -> GetGlobalDescription ()
>> 63 << "\"\n is already in the run-duration list of scene \""
>> 64 << fName
>> 65 << "\"."
>> 66 << G4endl;
>> 67 }
>> 68 return false;
>> 69 }
>> 70
>> 71 for (i = fRunDurationModelList.begin ();
>> 72 i != fRunDurationModelList.end (); ++i) {
>> 73 if (pModel -> GetGlobalTag () ==
>> 74 i->fpModel->GetGlobalTag ()) break;
>> 75 }
>> 76 if (i != fRunDurationModelList.end ()) {
>> 77 if (warn) {
>> 78 G4cout
>> 79 << "G4Scene::AddRunDurationModel: The tag \""
>> 80 << pModel->GetGlobalTag()
>> 81 << "\"\n duplicates one already in scene \""
>> 82 << fName
>> 83 <<
>> 84 "\".\n This may be intended but if not, you may inspect the scene with"
>> 85 "\n \"/vis/scene/list\" and deactivate unwanted models with"
>> 86 "\n \"/vis/scene/activateModel\". Or create a new scene."
>> 87 << G4endl;
>> 88 }
>> 89 }
>> 90
>> 91 fRunDurationModelList.push_back (Model(pModel));
>> 92
>> 93 CalculateExtent ();
>> 94
>> 95 return true;
62 } 96 }
63 97
64 void G4Scene::CalculateExtent () 98 void G4Scene::CalculateExtent ()
65 { 99 {
66 G4BoundingExtentScene boundingExtentScene; << 100 G4BoundingSphereScene boundingSphereScene;
67 101
68 for (size_t i = 0; i < fRunDurationModelList 102 for (size_t i = 0; i < fRunDurationModelList.size(); i++) {
69 if (fRunDurationModelList[i].fActive) { 103 if (fRunDurationModelList[i].fActive) {
70 G4VModel* model = fRunDurationModelList[ 104 G4VModel* model = fRunDurationModelList[i].fpModel;
71 if (model -> Validate()) { << 105 if (model -> Validate()) { // Validates and also recomputes extent.
72 const G4VisExtent& thisExtent = model << 106 const G4VisExtent& thisExtent = model -> GetExtent ();
73 if (thisExtent != G4VisExtent::GetNull << 107 G4double thisRadius = thisExtent.GetExtentRadius ();
74 boundingExtentScene.AccrueBoundingEx << 108 if (thisRadius > 0.) {
75 } << 109 G4Point3D thisCentre = thisExtent.GetExtentCentre ();
>> 110 thisCentre.transform (model -> GetTransformation ());
>> 111 boundingSphereScene.AccrueBoundingSphere (thisCentre, thisRadius);
>> 112 }
76 } else { 113 } else {
77 PrintInvalidModel(model); << 114 G4ExceptionDescription ed;
>> 115 ed << "Invalid model \"" << model->GetGlobalDescription()
>> 116 << "\".\n Not included in extent calculation.";
>> 117 G4Exception
>> 118 ("G4Scene::CalculateExtent",
>> 119 "visman0201", JustWarning, ed);
78 } 120 }
79 } 121 }
80 } 122 }
81 123
82 for (size_t i = 0; i < fEndOfEventModelList. 124 for (size_t i = 0; i < fEndOfEventModelList.size(); i++) {
83 if (fEndOfEventModelList[i].fActive) { 125 if (fEndOfEventModelList[i].fActive) {
84 G4VModel* model = fEndOfEventModelList[i 126 G4VModel* model = fEndOfEventModelList[i].fpModel;
85 if (model -> Validate()) { << 127 if (model -> Validate()) { // Validates and also recomputes extent.
86 const G4VisExtent& thisExtent = model << 128 const G4VisExtent& thisExtent = model -> GetExtent ();
87 if (thisExtent != G4VisExtent::GetNull << 129 G4double thisRadius = thisExtent.GetExtentRadius ();
88 boundingExtentScene.AccrueBoundingEx << 130 if (thisRadius > 0.) {
89 } << 131 G4Point3D thisCentre = thisExtent.GetExtentCentre ();
>> 132 thisCentre.transform (model -> GetTransformation ());
>> 133 boundingSphereScene.AccrueBoundingSphere (thisCentre, thisRadius);
>> 134 }
90 } else { 135 } else {
91 PrintInvalidModel(model); << 136 G4ExceptionDescription ed;
>> 137 ed << "Invalid model \"" << model->GetGlobalDescription()
>> 138 << "\".\n Not included in extent calculation.";
>> 139 G4Exception
>> 140 ("G4Scene::CalculateExtent",
>> 141 "visman0201", JustWarning, ed);
92 } 142 }
93 } 143 }
94 } 144 }
95 145
96 for (size_t i = 0; i < fEndOfRunModelList.si 146 for (size_t i = 0; i < fEndOfRunModelList.size(); i++) {
97 if (fEndOfRunModelList[i].fActive) { 147 if (fEndOfRunModelList[i].fActive) {
98 G4VModel* model = fEndOfRunModelList[i]. 148 G4VModel* model = fEndOfRunModelList[i].fpModel;
99 if (model -> Validate()) { << 149 if (model -> Validate()) { // Validates and also recomputes extent.
100 const G4VisExtent& thisExtent = model << 150 const G4VisExtent& thisExtent = model -> GetExtent ();
101 if (thisExtent != G4VisExtent::GetNull << 151 G4double thisRadius = thisExtent.GetExtentRadius ();
102 boundingExtentScene.AccrueBoundingEx << 152 if (thisRadius > 0.) {
103 } << 153 G4Point3D thisCentre = thisExtent.GetExtentCentre ();
>> 154 thisCentre.transform (model -> GetTransformation ());
>> 155 boundingSphereScene.AccrueBoundingSphere (thisCentre, thisRadius);
>> 156 }
104 } else { 157 } else {
105 PrintInvalidModel(model); << 158 G4ExceptionDescription ed;
>> 159 ed << "Invalid model \"" << model->GetGlobalDescription()
>> 160 << "\".\n Not included in extent calculation.";
>> 161 G4Exception
>> 162 ("G4Scene::CalculateExtent",
>> 163 "visman0201", JustWarning, ed);
106 } 164 }
107 } 165 }
108 } 166 }
109 167
110 fExtent = boundingExtentScene.GetBoundingExt << 168 fExtent = boundingSphereScene.GetBoundingSphereExtent ();
111 fStandardTargetPoint = fExtent.GetExtentCent 169 fStandardTargetPoint = fExtent.GetExtentCentre ();
112 if (fExtent.GetExtentRadius() <= 0.) { 170 if (fExtent.GetExtentRadius() <= 0.) {
113 G4Exception 171 G4Exception
114 ("G4Scene::CalculateExtent", 172 ("G4Scene::CalculateExtent",
115 "visman0202", JustWarning, 173 "visman0202", JustWarning,
116 "Scene has no extent. Please activate or 174 "Scene has no extent. Please activate or add something."
117 "\nThe camera needs to have something to 175 "\nThe camera needs to have something to point at!"
118 "\nAdd a volume. (You may need \"/r 176 "\nAdd a volume. (You may need \"/run/initialize\".)"
119 "\nOr use \"/vis/scene/add/extent\" 177 "\nOr use \"/vis/scene/add/extent\"."
120 "\n\"/vis/scene/list\" to see list of mod 178 "\n\"/vis/scene/list\" to see list of models.");
121 } 179 }
122 } 180 }
123 181
124 G4bool G4Scene::AddWorldIfEmpty (G4bool warn) 182 G4bool G4Scene::AddWorldIfEmpty (G4bool warn) {
125 G4bool successful = true; 183 G4bool successful = true;
126 if (IsEmpty ()) { 184 if (IsEmpty ()) {
127 successful = false; 185 successful = false;
128 G4VPhysicalVolume* pWorld = 186 G4VPhysicalVolume* pWorld =
129 G4TransportationManager::GetTransportati 187 G4TransportationManager::GetTransportationManager ()
130 -> GetNavigatorForTracking () -> GetWorl 188 -> GetNavigatorForTracking () -> GetWorldVolume ();
131 if (pWorld) { 189 if (pWorld) {
132 const G4VisAttributes* pVisAttribs = 190 const G4VisAttributes* pVisAttribs =
133 pWorld -> GetLogicalVolume () -> GetVisAttri 191 pWorld -> GetLogicalVolume () -> GetVisAttributes ();
134 if (!pVisAttribs || pVisAttribs -> IsVis 192 if (!pVisAttribs || pVisAttribs -> IsVisible ()) {
135 if (warn) { 193 if (warn) {
136 G4warn << << 194 G4cout <<
137 "Your \"world\" has no vis attributes or 195 "Your \"world\" has no vis attributes or is marked as visible."
138 "\n For a better view of the contents, 196 "\n For a better view of the contents, mark the world as"
139 " invisible, e.g.," 197 " invisible, e.g.,"
140 "\n myWorldLogicalVol ->" 198 "\n myWorldLogicalVol ->"
141 " SetVisAttributes (G4VisAttributes::GetIn 199 " SetVisAttributes (G4VisAttributes::GetInvisible());"
142 << G4endl; 200 << G4endl;
143 } 201 }
144 } 202 }
145 successful = AddRunDurationModel (new G4 203 successful = AddRunDurationModel (new G4PhysicalVolumeModel (pWorld));
146 // Note: default depth and no modeling p 204 // Note: default depth and no modeling parameters.
147 if (successful) { 205 if (successful) {
148 if (warn) { 206 if (warn) {
149 G4warn << << 207 G4cout <<
150 "G4Scene::AddWorldIfEmpty: The scene had n << 208 "G4Scene::AddWorldIfEmpty: The scene was empty of run-duration models."
151 "\n \"world\" has been added."; 209 "\n \"world\" has been added.";
152 G4warn << G4endl; << 210 G4cout << G4endl;
153 } 211 }
154 } 212 }
155 } 213 }
156 } 214 }
157 return successful; 215 return successful;
158 } 216 }
159 217
160 G4bool G4Scene::AddRunDurationModel (G4VModel* <<
161 { <<
162 std::vector<Model>::const_iterator i; <<
163 for (i = fRunDurationModelList.begin (); <<
164 i != fRunDurationModelList.end (); ++i) <<
165 if (pModel -> GetGlobalDescription () == <<
166 i->fpModel->GetGlobalDescription ()) break; <<
167 } <<
168 if (i != fRunDurationModelList.end ()) { <<
169 if (warn) { <<
170 G4warn << "G4Scene::AddRunDurationModel: <<
171 << pModel -> GetGlobalDescription () <<
172 << "\"\n is already in the run-duration <<
173 << fName <<
174 << "\"." <<
175 << G4endl; <<
176 } <<
177 return false; <<
178 } <<
179 fRunDurationModelList.push_back (Model(pMode <<
180 CalculateExtent (); <<
181 return true; <<
182 } <<
183 <<
184 G4bool G4Scene::AddEndOfEventModel (G4VModel* 218 G4bool G4Scene::AddEndOfEventModel (G4VModel* pModel, G4bool warn) {
185 std::size_t i, nModels = fEndOfEventModelLis << 219 G4int i, nModels = fEndOfEventModelList.size ();
186 for (i = 0; i < nModels; ++i) { << 220 for (i = 0; i < nModels; i++) {
187 if (pModel -> GetGlobalDescription () == 221 if (pModel -> GetGlobalDescription () ==
188 fEndOfEventModelList[i].fpModel -> GetGlobal 222 fEndOfEventModelList[i].fpModel -> GetGlobalDescription ()) break;
189 } 223 }
190 if (i < nModels) { 224 if (i < nModels) {
191 if (warn) { 225 if (warn) {
192 G4warn << "G4Scene::AddEndOfEventModel: << 226 G4cout << "G4Scene::AddEndOfEventModel: a model \""
193 << pModel -> GetGlobalDescription () 227 << pModel -> GetGlobalDescription ()
194 << "\"\n is already in the end-of-even 228 << "\"\n is already in the end-of-event list of scene \""
195 << fName << "\"." 229 << fName << "\"."
196 << G4endl; 230 << G4endl;
197 } 231 }
198 return false; 232 return false;
199 } 233 }
200 fEndOfEventModelList.push_back (Model(pModel 234 fEndOfEventModelList.push_back (Model(pModel));
201 CalculateExtent (); <<
202 return true; 235 return true;
203 } 236 }
204 237
205 G4bool G4Scene::AddEndOfRunModel (G4VModel* pM 238 G4bool G4Scene::AddEndOfRunModel (G4VModel* pModel, G4bool warn) {
206 std::size_t i, nModels = fEndOfRunModelList. << 239 G4int i, nModels = fEndOfRunModelList.size ();
207 for (i = 0; i < nModels; ++i) { << 240 for (i = 0; i < nModels; i++) {
208 if (pModel -> GetGlobalDescription () == 241 if (pModel -> GetGlobalDescription () ==
209 fEndOfRunModelList[i].fpModel -> GetGlobalDe 242 fEndOfRunModelList[i].fpModel -> GetGlobalDescription ()) break;
210 } 243 }
211 if (i < nModels) { 244 if (i < nModels) {
212 if (warn) { 245 if (warn) {
213 G4warn << "G4Scene::AddEndOfRunModel: a << 246 G4cout << "G4Scene::AddEndOfRunModel: a model \""
214 << pModel -> GetGlobalDescription () 247 << pModel -> GetGlobalDescription ()
215 << "\"\n is already in the end-of-run 248 << "\"\n is already in the end-of-run list of scene \""
216 << fName << "\"." 249 << fName << "\"."
217 << G4endl; 250 << G4endl;
218 } 251 }
219 return false; 252 return false;
220 } 253 }
221 fEndOfRunModelList.push_back (pModel); 254 fEndOfRunModelList.push_back (pModel);
222 CalculateExtent (); <<
223 return true; 255 return true;
224 } 256 }
225 257
226 std::ostream& operator << (std::ostream& os, c 258 std::ostream& operator << (std::ostream& os, const G4Scene& scene) {
227 259
228 size_t i; 260 size_t i;
229 261
230 os << "Scene data:"; 262 os << "Scene data:";
231 263
232 os << "\n Run-duration model list:"; 264 os << "\n Run-duration model list:";
233 if (scene.fRunDurationModelList.size () == 0 <<
234 os << " none"; <<
235 } <<
236 for (i = 0; i < scene.fRunDurationModelList. 265 for (i = 0; i < scene.fRunDurationModelList.size (); i++) {
237 if (scene.fRunDurationModelList[i].fActive 266 if (scene.fRunDurationModelList[i].fActive) os << "\n Active: ";
238 else os << "\n Inactive: "; 267 else os << "\n Inactive: ";
239 os << *(scene.fRunDurationModelList[i].fpM 268 os << *(scene.fRunDurationModelList[i].fpModel);
240 } 269 }
241 270
242 os << "\n End-of-event model list:"; 271 os << "\n End-of-event model list:";
243 if (scene.fEndOfEventModelList.size () == 0) <<
244 os << " none"; <<
245 } <<
246 for (i = 0; i < scene.fEndOfEventModelList.s 272 for (i = 0; i < scene.fEndOfEventModelList.size (); i++) {
247 if (scene.fEndOfEventModelList[i].fActive) 273 if (scene.fEndOfEventModelList[i].fActive) os << "\n Active: ";
248 else os << "\n Inactive: "; 274 else os << "\n Inactive: ";
249 os << *(scene.fEndOfEventModelList[i].fpMo 275 os << *(scene.fEndOfEventModelList[i].fpModel);
250 } 276 }
251 277
252 os << "\n End-of-run model list:"; 278 os << "\n End-of-run model list:";
253 if (scene.fEndOfRunModelList.size () == 0) { <<
254 os << " none"; <<
255 } <<
256 for (i = 0; i < scene.fEndOfRunModelList.siz 279 for (i = 0; i < scene.fEndOfRunModelList.size (); i++) {
257 if (scene.fEndOfRunModelList[i].fActive) o 280 if (scene.fEndOfRunModelList[i].fActive) os << "\n Active: ";
258 else os << "\n Inactive: "; 281 else os << "\n Inactive: ";
259 os << *(scene.fEndOfRunModelList[i].fpMode 282 os << *(scene.fEndOfRunModelList[i].fpModel);
260 } 283 }
261 284
262 os << "\n Overall extent or bounding box: " << 285 os << "\n Extent or bounding box: " << scene.fExtent;
263 286
264 os << "\n Standard target point: " << scen 287 os << "\n Standard target point: " << scene.fStandardTargetPoint;
265 288
266 os << "\n End of event action set to \""; 289 os << "\n End of event action set to \"";
267 if (scene.fRefreshAtEndOfEvent) os << "refre 290 if (scene.fRefreshAtEndOfEvent) os << "refresh\"";
268 else { 291 else {
269 os << "accumulate (maximum number of kept 292 os << "accumulate (maximum number of kept events: ";
270 if (scene.fMaxNumberOfKeptEvents >= 0) os 293 if (scene.fMaxNumberOfKeptEvents >= 0) os << scene.fMaxNumberOfKeptEvents;
271 else os << "unlimited"; 294 else os << "unlimited";
272 os << ")"; 295 os << ")";
273 } 296 }
274 297
275 os << "\n End of run action set to \""; 298 os << "\n End of run action set to \"";
276 if (scene.fRefreshAtEndOfRun) os << "refresh 299 if (scene.fRefreshAtEndOfRun) os << "refresh";
277 else os << "accumulate"; 300 else os << "accumulate";
278 os << "\""; 301 os << "\"";
279 302
280 return os; 303 return os;
281 } 304 }
282 305
283 G4bool G4Scene::operator != (const G4Scene& sc 306 G4bool G4Scene::operator != (const G4Scene& scene) const {
284 if ( 307 if (
285 (fRunDurationModelList.size () != 308 (fRunDurationModelList.size () !=
286 scene.fRunDurationModelList.size ()) 309 scene.fRunDurationModelList.size ()) ||
287 (fEndOfEventModelList.size () != 310 (fEndOfEventModelList.size () !=
288 scene.fEndOfEventModelList.size ()) 311 scene.fEndOfEventModelList.size ()) ||
289 (fEndOfRunModelList.size () != 312 (fEndOfRunModelList.size () !=
290 scene.fEndOfRunModelList.size ()) 313 scene.fEndOfRunModelList.size ()) ||
291 (fExtent != scene.fExtent) 314 (fExtent != scene.fExtent) ||
292 !(fStandardTargetPoint == scene.fStandar 315 !(fStandardTargetPoint == scene.fStandardTargetPoint) ||
293 fRefreshAtEndOfEvent != scene.fRefresh 316 fRefreshAtEndOfEvent != scene.fRefreshAtEndOfEvent ||
294 fRefreshAtEndOfRun != scene.fRefresh 317 fRefreshAtEndOfRun != scene.fRefreshAtEndOfRun ||
295 fMaxNumberOfKeptEvents != scene.fMaxNumb 318 fMaxNumberOfKeptEvents != scene.fMaxNumberOfKeptEvents
296 ) return true; 319 ) return true;
297 320
298 /* A complete comparison should, perhaps, in 321 /* A complete comparison should, perhaps, include a comparison of
299 individual models, but it is not easy to 322 individual models, but it is not easy to implement operator!= for
300 all models. Also, it would be unfeasible 323 all models. Also, it would be unfeasible to ask users to
301 implement opeerator!= if we ever get roun 324 implement opeerator!= if we ever get round to allowing
302 user-defined models. Moreover, there is 325 user-defined models. Moreover, there is no editing of G4Scene
303 objects, apart from changing fRefreshAtEn 326 objects, apart from changing fRefreshAtEndOfEvent, etc; as far as
304 models are concerned, all you can ever do 327 models are concerned, all you can ever do is add them, so a test
305 on size (above) is enough. 328 on size (above) is enough.
306 329
307 for (size_t i = 0; i < fRunDurationModelList 330 for (size_t i = 0; i < fRunDurationModelList.size (); i++) {
308 if (fRunDurationModelList[i] != scene.fRun 331 if (fRunDurationModelList[i] != scene.fRunDurationModelList[i])
309 return true; 332 return true;
310 } 333 }
311 334
312 for (size_t i = 0; i < fEndOfEventModelList. 335 for (size_t i = 0; i < fEndOfEventModelList.size (); i++) {
313 if (fEndOfEventModelList[i] != scene.fEndO 336 if (fEndOfEventModelList[i] != scene.fEndOfEventModelList[i])
314 return true; 337 return true;
315 } 338 }
316 339
317 for (size_t i = 0; i < fEndOfRunModelList.si 340 for (size_t i = 0; i < fEndOfRunModelList.size (); i++) {
318 if (fEndOfRunModelList[i] != scene.fEndOfR 341 if (fEndOfRunModelList[i] != scene.fEndOfRunModelList[i])
319 return true; 342 return true;
320 } 343 }
321 */ 344 */
322 345
323 return false; 346 return false;
324 } 347 }
325 348