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