| 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 99418 2016-09-21 09:18:42Z 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 <<
41 #define G4warn G4cout <<
42 <<
43 G4Scene::G4Scene (const G4String& name): 40 G4Scene::G4Scene (const G4String& name):
44 fName (name), 41 fName (name),
45 fRefreshAtEndOfEvent(true), 42 fRefreshAtEndOfEvent(true),
46 fRefreshAtEndOfRun(true), 43 fRefreshAtEndOfRun(true),
47 fMaxNumberOfKeptEvents(100) 44 fMaxNumberOfKeptEvents(100)
48 {} // Note all other data members have default 45 {} // Note all other data members have default initial values.
49 46
50 G4Scene::~G4Scene () {} 47 G4Scene::~G4Scene () {}
51 48
52 namespace { << 49 G4bool G4Scene::AddRunDurationModel (G4VModel* pModel, G4bool warn) {
53 void PrintInvalidModel(const G4VModel* model << 50 std::vector<Model>::const_iterator i;
54 { << 51 for (i = fRunDurationModelList.begin ();
55 G4ExceptionDescription ed; << 52 i != fRunDurationModelList.end (); ++i) {
56 ed << "Invalid model \"" << model->GetGlob << 53 if (pModel -> GetGlobalDescription () ==
57 << "\".\n Not included in extent calculat << 54 i->fpModel->GetGlobalDescription ()) break;
58 G4Exception << 55 }
59 ("G4Scene::CalculateExtent", << 56 if (i != fRunDurationModelList.end ()) {
60 "visman0201", JustWarning, ed); << 57 if (warn) {
>> 58 G4cout << "G4Scene::AddRunDurationModel: model \""
>> 59 << pModel -> GetGlobalDescription ()
>> 60 << "\"\n is already in the run-duration list of scene \""
>> 61 << fName
>> 62 << "\"."
>> 63 << G4endl;
>> 64 }
>> 65 return false;
61 } 66 }
>> 67 fRunDurationModelList.push_back (Model(pModel));
>> 68 CalculateExtent ();
>> 69 return true;
62 } 70 }
63 71
64 void G4Scene::CalculateExtent () 72 void G4Scene::CalculateExtent ()
65 { 73 {
66 G4BoundingExtentScene boundingExtentScene; << 74 G4BoundingSphereScene boundingSphereScene;
67 75
68 for (size_t i = 0; i < fRunDurationModelList 76 for (size_t i = 0; i < fRunDurationModelList.size(); i++) {
69 if (fRunDurationModelList[i].fActive) { 77 if (fRunDurationModelList[i].fActive) {
70 G4VModel* model = fRunDurationModelList[ 78 G4VModel* model = fRunDurationModelList[i].fpModel;
71 if (model -> Validate()) { << 79 if (model -> Validate()) { // Validates and also recomputes extent.
72 const G4VisExtent& thisExtent = model << 80 const G4VisExtent& thisExtent = model -> GetExtent ();
73 if (thisExtent != G4VisExtent::GetNull << 81 G4double thisRadius = thisExtent.GetExtentRadius ();
74 boundingExtentScene.AccrueBoundingEx << 82 if (thisRadius > 0.) {
75 } << 83 G4Point3D thisCentre = thisExtent.GetExtentCentre ();
>> 84 thisCentre.transform (model -> GetTransformation ());
>> 85 boundingSphereScene.AccrueBoundingSphere (thisCentre, thisRadius);
>> 86 }
76 } else { 87 } else {
77 PrintInvalidModel(model); << 88 G4ExceptionDescription ed;
>> 89 ed << "Invalid model \"" << model->GetGlobalDescription()
>> 90 << "\".\n Not included in extent calculation.";
>> 91 G4Exception
>> 92 ("G4Scene::CalculateExtent",
>> 93 "visman0201", JustWarning, ed);
78 } 94 }
79 } 95 }
80 } 96 }
81 97
82 for (size_t i = 0; i < fEndOfEventModelList. 98 for (size_t i = 0; i < fEndOfEventModelList.size(); i++) {
83 if (fEndOfEventModelList[i].fActive) { 99 if (fEndOfEventModelList[i].fActive) {
84 G4VModel* model = fEndOfEventModelList[i 100 G4VModel* model = fEndOfEventModelList[i].fpModel;
85 if (model -> Validate()) { << 101 if (model -> Validate()) { // Validates and also recomputes extent.
86 const G4VisExtent& thisExtent = model << 102 const G4VisExtent& thisExtent = model -> GetExtent ();
87 if (thisExtent != G4VisExtent::GetNull << 103 G4double thisRadius = thisExtent.GetExtentRadius ();
88 boundingExtentScene.AccrueBoundingEx << 104 if (thisRadius > 0.) {
89 } << 105 G4Point3D thisCentre = thisExtent.GetExtentCentre ();
>> 106 thisCentre.transform (model -> GetTransformation ());
>> 107 boundingSphereScene.AccrueBoundingSphere (thisCentre, thisRadius);
>> 108 }
90 } else { 109 } else {
91 PrintInvalidModel(model); << 110 G4ExceptionDescription ed;
>> 111 ed << "Invalid model \"" << model->GetGlobalDescription()
>> 112 << "\".\n Not included in extent calculation.";
>> 113 G4Exception
>> 114 ("G4Scene::CalculateExtent",
>> 115 "visman0201", JustWarning, ed);
92 } 116 }
93 } 117 }
94 } 118 }
95 119
96 for (size_t i = 0; i < fEndOfRunModelList.si 120 for (size_t i = 0; i < fEndOfRunModelList.size(); i++) {
97 if (fEndOfRunModelList[i].fActive) { 121 if (fEndOfRunModelList[i].fActive) {
98 G4VModel* model = fEndOfRunModelList[i]. 122 G4VModel* model = fEndOfRunModelList[i].fpModel;
99 if (model -> Validate()) { << 123 if (model -> Validate()) { // Validates and also recomputes extent.
100 const G4VisExtent& thisExtent = model << 124 const G4VisExtent& thisExtent = model -> GetExtent ();
101 if (thisExtent != G4VisExtent::GetNull << 125 G4double thisRadius = thisExtent.GetExtentRadius ();
102 boundingExtentScene.AccrueBoundingEx << 126 if (thisRadius > 0.) {
103 } << 127 G4Point3D thisCentre = thisExtent.GetExtentCentre ();
>> 128 thisCentre.transform (model -> GetTransformation ());
>> 129 boundingSphereScene.AccrueBoundingSphere (thisCentre, thisRadius);
>> 130 }
104 } else { 131 } else {
105 PrintInvalidModel(model); << 132 G4ExceptionDescription ed;
>> 133 ed << "Invalid model \"" << model->GetGlobalDescription()
>> 134 << "\".\n Not included in extent calculation.";
>> 135 G4Exception
>> 136 ("G4Scene::CalculateExtent",
>> 137 "visman0201", JustWarning, ed);
106 } 138 }
107 } 139 }
108 } 140 }
109 141
110 fExtent = boundingExtentScene.GetBoundingExt << 142 fExtent = boundingSphereScene.GetBoundingSphereExtent ();
111 fStandardTargetPoint = fExtent.GetExtentCent 143 fStandardTargetPoint = fExtent.GetExtentCentre ();
112 if (fExtent.GetExtentRadius() <= 0.) { 144 if (fExtent.GetExtentRadius() <= 0.) {
113 G4Exception 145 G4Exception
114 ("G4Scene::CalculateExtent", 146 ("G4Scene::CalculateExtent",
115 "visman0202", JustWarning, 147 "visman0202", JustWarning,
116 "Scene has no extent. Please activate or 148 "Scene has no extent. Please activate or add something."
117 "\nThe camera needs to have something to 149 "\nThe camera needs to have something to point at!"
118 "\nAdd a volume. (You may need \"/r 150 "\nAdd a volume. (You may need \"/run/initialize\".)"
119 "\nOr use \"/vis/scene/add/extent\" 151 "\nOr use \"/vis/scene/add/extent\"."
120 "\n\"/vis/scene/list\" to see list of mod 152 "\n\"/vis/scene/list\" to see list of models.");
121 } 153 }
122 } 154 }
123 155
124 G4bool G4Scene::AddWorldIfEmpty (G4bool warn) 156 G4bool G4Scene::AddWorldIfEmpty (G4bool warn) {
125 G4bool successful = true; 157 G4bool successful = true;
126 if (IsEmpty ()) { 158 if (IsEmpty ()) {
127 successful = false; 159 successful = false;
128 G4VPhysicalVolume* pWorld = 160 G4VPhysicalVolume* pWorld =
129 G4TransportationManager::GetTransportati 161 G4TransportationManager::GetTransportationManager ()
130 -> GetNavigatorForTracking () -> GetWorl 162 -> GetNavigatorForTracking () -> GetWorldVolume ();
131 if (pWorld) { 163 if (pWorld) {
132 const G4VisAttributes* pVisAttribs = 164 const G4VisAttributes* pVisAttribs =
133 pWorld -> GetLogicalVolume () -> GetVisAttri 165 pWorld -> GetLogicalVolume () -> GetVisAttributes ();
134 if (!pVisAttribs || pVisAttribs -> IsVis 166 if (!pVisAttribs || pVisAttribs -> IsVisible ()) {
135 if (warn) { 167 if (warn) {
136 G4warn << << 168 G4cout <<
137 "Your \"world\" has no vis attributes or 169 "Your \"world\" has no vis attributes or is marked as visible."
138 "\n For a better view of the contents, 170 "\n For a better view of the contents, mark the world as"
139 " invisible, e.g.," 171 " invisible, e.g.,"
140 "\n myWorldLogicalVol ->" 172 "\n myWorldLogicalVol ->"
141 " SetVisAttributes (G4VisAttributes::GetIn 173 " SetVisAttributes (G4VisAttributes::GetInvisible());"
142 << G4endl; 174 << G4endl;
143 } 175 }
144 } 176 }
145 successful = AddRunDurationModel (new G4 177 successful = AddRunDurationModel (new G4PhysicalVolumeModel (pWorld));
146 // Note: default depth and no modeling p 178 // Note: default depth and no modeling parameters.
147 if (successful) { 179 if (successful) {
148 if (warn) { 180 if (warn) {
149 G4warn << << 181 G4cout <<
150 "G4Scene::AddWorldIfEmpty: The scene had n << 182 "G4Scene::AddWorldIfEmpty: The scene was empty of run-duration models."
151 "\n \"world\" has been added."; 183 "\n \"world\" has been added.";
152 G4warn << G4endl; << 184 G4cout << G4endl;
153 } 185 }
154 } 186 }
155 } 187 }
156 } 188 }
157 return successful; 189 return successful;
158 } 190 }
159 191
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* 192 G4bool G4Scene::AddEndOfEventModel (G4VModel* pModel, G4bool warn) {
185 std::size_t i, nModels = fEndOfEventModelLis << 193 G4int i, nModels = fEndOfEventModelList.size ();
186 for (i = 0; i < nModels; ++i) { << 194 for (i = 0; i < nModels; i++) {
187 if (pModel -> GetGlobalDescription () == 195 if (pModel -> GetGlobalDescription () ==
188 fEndOfEventModelList[i].fpModel -> GetGlobal 196 fEndOfEventModelList[i].fpModel -> GetGlobalDescription ()) break;
189 } 197 }
190 if (i < nModels) { 198 if (i < nModels) {
191 if (warn) { 199 if (warn) {
192 G4warn << "G4Scene::AddEndOfEventModel: << 200 G4cout << "G4Scene::AddEndOfEventModel: a model \""
193 << pModel -> GetGlobalDescription () 201 << pModel -> GetGlobalDescription ()
194 << "\"\n is already in the end-of-even 202 << "\"\n is already in the end-of-event list of scene \""
195 << fName << "\"." 203 << fName << "\"."
196 << G4endl; 204 << G4endl;
197 } 205 }
198 return false; 206 return false;
199 } 207 }
200 fEndOfEventModelList.push_back (Model(pModel 208 fEndOfEventModelList.push_back (Model(pModel));
201 CalculateExtent (); <<
202 return true; 209 return true;
203 } 210 }
204 211
205 G4bool G4Scene::AddEndOfRunModel (G4VModel* pM 212 G4bool G4Scene::AddEndOfRunModel (G4VModel* pModel, G4bool warn) {
206 std::size_t i, nModels = fEndOfRunModelList. << 213 G4int i, nModels = fEndOfRunModelList.size ();
207 for (i = 0; i < nModels; ++i) { << 214 for (i = 0; i < nModels; i++) {
208 if (pModel -> GetGlobalDescription () == 215 if (pModel -> GetGlobalDescription () ==
209 fEndOfRunModelList[i].fpModel -> GetGlobalDe 216 fEndOfRunModelList[i].fpModel -> GetGlobalDescription ()) break;
210 } 217 }
211 if (i < nModels) { 218 if (i < nModels) {
212 if (warn) { 219 if (warn) {
213 G4warn << "G4Scene::AddEndOfRunModel: a << 220 G4cout << "G4Scene::AddEndOfRunModel: a model \""
214 << pModel -> GetGlobalDescription () 221 << pModel -> GetGlobalDescription ()
215 << "\"\n is already in the end-of-run 222 << "\"\n is already in the end-of-run list of scene \""
216 << fName << "\"." 223 << fName << "\"."
217 << G4endl; 224 << G4endl;
218 } 225 }
219 return false; 226 return false;
220 } 227 }
221 fEndOfRunModelList.push_back (pModel); 228 fEndOfRunModelList.push_back (pModel);
222 CalculateExtent (); <<
223 return true; 229 return true;
224 } 230 }
225 231
226 std::ostream& operator << (std::ostream& os, c 232 std::ostream& operator << (std::ostream& os, const G4Scene& scene) {
227 233
228 size_t i; 234 size_t i;
229 235
230 os << "Scene data:"; 236 os << "Scene data:";
231 237
232 os << "\n Run-duration model list:"; 238 os << "\n Run-duration model list:";
233 if (scene.fRunDurationModelList.size () == 0 <<
234 os << " none"; <<
235 } <<
236 for (i = 0; i < scene.fRunDurationModelList. 239 for (i = 0; i < scene.fRunDurationModelList.size (); i++) {
237 if (scene.fRunDurationModelList[i].fActive 240 if (scene.fRunDurationModelList[i].fActive) os << "\n Active: ";
238 else os << "\n Inactive: "; 241 else os << "\n Inactive: ";
239 os << *(scene.fRunDurationModelList[i].fpM 242 os << *(scene.fRunDurationModelList[i].fpModel);
240 } 243 }
241 244
242 os << "\n End-of-event model list:"; 245 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 246 for (i = 0; i < scene.fEndOfEventModelList.size (); i++) {
247 if (scene.fEndOfEventModelList[i].fActive) 247 if (scene.fEndOfEventModelList[i].fActive) os << "\n Active: ";
248 else os << "\n Inactive: "; 248 else os << "\n Inactive: ";
249 os << *(scene.fEndOfEventModelList[i].fpMo 249 os << *(scene.fEndOfEventModelList[i].fpModel);
250 } 250 }
251 251
252 os << "\n End-of-run model list:"; 252 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 253 for (i = 0; i < scene.fEndOfRunModelList.size (); i++) {
257 if (scene.fEndOfRunModelList[i].fActive) o 254 if (scene.fEndOfRunModelList[i].fActive) os << "\n Active: ";
258 else os << "\n Inactive: "; 255 else os << "\n Inactive: ";
259 os << *(scene.fEndOfRunModelList[i].fpMode 256 os << *(scene.fEndOfRunModelList[i].fpModel);
260 } 257 }
261 258
262 os << "\n Overall extent or bounding box: " << 259 os << "\n Extent or bounding box: " << scene.fExtent;
263 260
264 os << "\n Standard target point: " << scen 261 os << "\n Standard target point: " << scene.fStandardTargetPoint;
265 262
266 os << "\n End of event action set to \""; 263 os << "\n End of event action set to \"";
267 if (scene.fRefreshAtEndOfEvent) os << "refre 264 if (scene.fRefreshAtEndOfEvent) os << "refresh\"";
268 else { 265 else {
269 os << "accumulate (maximum number of kept 266 os << "accumulate (maximum number of kept events: ";
270 if (scene.fMaxNumberOfKeptEvents >= 0) os 267 if (scene.fMaxNumberOfKeptEvents >= 0) os << scene.fMaxNumberOfKeptEvents;
271 else os << "unlimited"; 268 else os << "unlimited";
272 os << ")"; 269 os << ")";
273 } 270 }
274 271
275 os << "\n End of run action set to \""; 272 os << "\n End of run action set to \"";
276 if (scene.fRefreshAtEndOfRun) os << "refresh 273 if (scene.fRefreshAtEndOfRun) os << "refresh";
277 else os << "accumulate"; 274 else os << "accumulate";
278 os << "\""; 275 os << "\"";
279 276
280 return os; 277 return os;
281 } 278 }
282 279
283 G4bool G4Scene::operator != (const G4Scene& sc 280 G4bool G4Scene::operator != (const G4Scene& scene) const {
284 if ( 281 if (
285 (fRunDurationModelList.size () != 282 (fRunDurationModelList.size () !=
286 scene.fRunDurationModelList.size ()) 283 scene.fRunDurationModelList.size ()) ||
287 (fEndOfEventModelList.size () != 284 (fEndOfEventModelList.size () !=
288 scene.fEndOfEventModelList.size ()) 285 scene.fEndOfEventModelList.size ()) ||
289 (fEndOfRunModelList.size () != 286 (fEndOfRunModelList.size () !=
290 scene.fEndOfRunModelList.size ()) 287 scene.fEndOfRunModelList.size ()) ||
291 (fExtent != scene.fExtent) 288 (fExtent != scene.fExtent) ||
292 !(fStandardTargetPoint == scene.fStandar 289 !(fStandardTargetPoint == scene.fStandardTargetPoint) ||
293 fRefreshAtEndOfEvent != scene.fRefresh 290 fRefreshAtEndOfEvent != scene.fRefreshAtEndOfEvent ||
294 fRefreshAtEndOfRun != scene.fRefresh 291 fRefreshAtEndOfRun != scene.fRefreshAtEndOfRun ||
295 fMaxNumberOfKeptEvents != scene.fMaxNumb 292 fMaxNumberOfKeptEvents != scene.fMaxNumberOfKeptEvents
296 ) return true; 293 ) return true;
297 294
298 /* A complete comparison should, perhaps, in 295 /* A complete comparison should, perhaps, include a comparison of
299 individual models, but it is not easy to 296 individual models, but it is not easy to implement operator!= for
300 all models. Also, it would be unfeasible 297 all models. Also, it would be unfeasible to ask users to
301 implement opeerator!= if we ever get roun 298 implement opeerator!= if we ever get round to allowing
302 user-defined models. Moreover, there is 299 user-defined models. Moreover, there is no editing of G4Scene
303 objects, apart from changing fRefreshAtEn 300 objects, apart from changing fRefreshAtEndOfEvent, etc; as far as
304 models are concerned, all you can ever do 301 models are concerned, all you can ever do is add them, so a test
305 on size (above) is enough. 302 on size (above) is enough.
306 303
307 for (size_t i = 0; i < fRunDurationModelList 304 for (size_t i = 0; i < fRunDurationModelList.size (); i++) {
308 if (fRunDurationModelList[i] != scene.fRun 305 if (fRunDurationModelList[i] != scene.fRunDurationModelList[i])
309 return true; 306 return true;
310 } 307 }
311 308
312 for (size_t i = 0; i < fEndOfEventModelList. 309 for (size_t i = 0; i < fEndOfEventModelList.size (); i++) {
313 if (fEndOfEventModelList[i] != scene.fEndO 310 if (fEndOfEventModelList[i] != scene.fEndOfEventModelList[i])
314 return true; 311 return true;
315 } 312 }
316 313
317 for (size_t i = 0; i < fEndOfRunModelList.si 314 for (size_t i = 0; i < fEndOfRunModelList.size (); i++) {
318 if (fEndOfRunModelList[i] != scene.fEndOfR 315 if (fEndOfRunModelList[i] != scene.fEndOfRunModelList[i])
319 return true; 316 return true;
320 } 317 }
321 */ 318 */
322 319
323 return false; 320 return false;
324 } 321 }
325 322