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