| 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 75567 2013-11-04 11:35:11Z 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 <<
119 "\nOr use \"/vis/scene/add/extent\" <<
120 "\n\"/vis/scene/list\" to see list of mod 150 "\n\"/vis/scene/list\" to see list of models.");
121 } 151 }
122 } 152 }
123 153
124 G4bool G4Scene::AddWorldIfEmpty (G4bool warn) 154 G4bool G4Scene::AddWorldIfEmpty (G4bool warn) {
125 G4bool successful = true; 155 G4bool successful = true;
126 if (IsEmpty ()) { 156 if (IsEmpty ()) {
127 successful = false; 157 successful = false;
128 G4VPhysicalVolume* pWorld = 158 G4VPhysicalVolume* pWorld =
129 G4TransportationManager::GetTransportati 159 G4TransportationManager::GetTransportationManager ()
130 -> GetNavigatorForTracking () -> GetWorl 160 -> GetNavigatorForTracking () -> GetWorldVolume ();
131 if (pWorld) { 161 if (pWorld) {
132 const G4VisAttributes* pVisAttribs = 162 const G4VisAttributes* pVisAttribs =
133 pWorld -> GetLogicalVolume () -> GetVisAttri 163 pWorld -> GetLogicalVolume () -> GetVisAttributes ();
134 if (!pVisAttribs || pVisAttribs -> IsVis 164 if (!pVisAttribs || pVisAttribs -> IsVisible ()) {
135 if (warn) { 165 if (warn) {
136 G4warn << << 166 G4cout <<
137 "Your \"world\" has no vis attributes or 167 "Your \"world\" has no vis attributes or is marked as visible."
138 "\n For a better view of the contents, 168 "\n For a better view of the contents, mark the world as"
139 " invisible, e.g.," 169 " invisible, e.g.,"
140 "\n myWorldLogicalVol ->" 170 "\n myWorldLogicalVol ->"
141 " SetVisAttributes (G4VisAttributes::GetIn << 171 " SetVisAttributes (G4VisAttributes::Invisible);"
142 << G4endl; 172 << G4endl;
143 } 173 }
144 } 174 }
145 successful = AddRunDurationModel (new G4 175 successful = AddRunDurationModel (new G4PhysicalVolumeModel (pWorld));
146 // Note: default depth and no modeling p 176 // Note: default depth and no modeling parameters.
147 if (successful) { 177 if (successful) {
148 if (warn) { 178 if (warn) {
149 G4warn << << 179 G4cout <<
150 "G4Scene::AddWorldIfEmpty: The scene had n << 180 "G4Scene::AddWorldIfEmpty: The scene was empty of run-duration models."
151 "\n \"world\" has been added."; 181 "\n \"world\" has been added.";
152 G4warn << G4endl; << 182 G4cout << G4endl;
153 } 183 }
154 } 184 }
155 } 185 }
156 } 186 }
157 return successful; 187 return successful;
158 } 188 }
159 189
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* 190 G4bool G4Scene::AddEndOfEventModel (G4VModel* pModel, G4bool warn) {
185 std::size_t i, nModels = fEndOfEventModelLis << 191 G4int i, nModels = fEndOfEventModelList.size ();
186 for (i = 0; i < nModels; ++i) { << 192 for (i = 0; i < nModels; i++) {
187 if (pModel -> GetGlobalDescription () == 193 if (pModel -> GetGlobalDescription () ==
188 fEndOfEventModelList[i].fpModel -> GetGlobal 194 fEndOfEventModelList[i].fpModel -> GetGlobalDescription ()) break;
189 } 195 }
190 if (i < nModels) { 196 if (i < nModels) {
191 if (warn) { 197 if (warn) {
192 G4warn << "G4Scene::AddEndOfEventModel: << 198 G4cout << "G4Scene::AddEndOfEventModel: a model \""
193 << pModel -> GetGlobalDescription () 199 << pModel -> GetGlobalDescription ()
194 << "\"\n is already in the end-of-even 200 << "\"\n is already in the end-of-event list of scene \""
195 << fName << "\"." 201 << fName << "\"."
196 << G4endl; 202 << G4endl;
197 } 203 }
198 return false; 204 return false;
199 } 205 }
200 fEndOfEventModelList.push_back (Model(pModel 206 fEndOfEventModelList.push_back (Model(pModel));
201 CalculateExtent (); <<
202 return true; 207 return true;
203 } 208 }
204 209
205 G4bool G4Scene::AddEndOfRunModel (G4VModel* pM 210 G4bool G4Scene::AddEndOfRunModel (G4VModel* pModel, G4bool warn) {
206 std::size_t i, nModels = fEndOfRunModelList. << 211 G4int i, nModels = fEndOfRunModelList.size ();
207 for (i = 0; i < nModels; ++i) { << 212 for (i = 0; i < nModels; i++) {
208 if (pModel -> GetGlobalDescription () == 213 if (pModel -> GetGlobalDescription () ==
209 fEndOfRunModelList[i].fpModel -> GetGlobalDe 214 fEndOfRunModelList[i].fpModel -> GetGlobalDescription ()) break;
210 } 215 }
211 if (i < nModels) { 216 if (i < nModels) {
212 if (warn) { 217 if (warn) {
213 G4warn << "G4Scene::AddEndOfRunModel: a << 218 G4cout << "G4Scene::AddEndOfRunModel: a model \""
214 << pModel -> GetGlobalDescription () 219 << pModel -> GetGlobalDescription ()
215 << "\"\n is already in the end-of-run 220 << "\"\n is already in the end-of-run list of scene \""
216 << fName << "\"." 221 << fName << "\"."
217 << G4endl; 222 << G4endl;
218 } 223 }
219 return false; 224 return false;
220 } 225 }
221 fEndOfRunModelList.push_back (pModel); 226 fEndOfRunModelList.push_back (pModel);
222 CalculateExtent (); <<
223 return true; 227 return true;
224 } 228 }
225 229
226 std::ostream& operator << (std::ostream& os, c 230 std::ostream& operator << (std::ostream& os, const G4Scene& scene) {
227 231
228 size_t i; 232 size_t i;
229 233
230 os << "Scene data:"; 234 os << "Scene data:";
231 235
232 os << "\n Run-duration model list:"; 236 os << "\n Run-duration model list:";
233 if (scene.fRunDurationModelList.size () == 0 <<
234 os << " none"; <<
235 } <<
236 for (i = 0; i < scene.fRunDurationModelList. 237 for (i = 0; i < scene.fRunDurationModelList.size (); i++) {
237 if (scene.fRunDurationModelList[i].fActive 238 if (scene.fRunDurationModelList[i].fActive) os << "\n Active: ";
238 else os << "\n Inactive: "; 239 else os << "\n Inactive: ";
239 os << *(scene.fRunDurationModelList[i].fpM 240 os << *(scene.fRunDurationModelList[i].fpModel);
240 } 241 }
241 242
242 os << "\n End-of-event model list:"; 243 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 244 for (i = 0; i < scene.fEndOfEventModelList.size (); i++) {
247 if (scene.fEndOfEventModelList[i].fActive) 245 if (scene.fEndOfEventModelList[i].fActive) os << "\n Active: ";
248 else os << "\n Inactive: "; 246 else os << "\n Inactive: ";
249 os << *(scene.fEndOfEventModelList[i].fpMo 247 os << *(scene.fEndOfEventModelList[i].fpModel);
250 } 248 }
251 249
252 os << "\n End-of-run model list:"; 250 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 251 for (i = 0; i < scene.fEndOfRunModelList.size (); i++) {
257 if (scene.fEndOfRunModelList[i].fActive) o 252 if (scene.fEndOfRunModelList[i].fActive) os << "\n Active: ";
258 else os << "\n Inactive: "; 253 else os << "\n Inactive: ";
259 os << *(scene.fEndOfRunModelList[i].fpMode 254 os << *(scene.fEndOfRunModelList[i].fpModel);
260 } 255 }
261 256
262 os << "\n Overall extent or bounding box: " << 257 os << "\n Extent or bounding box: " << scene.fExtent;
263 258
264 os << "\n Standard target point: " << scen 259 os << "\n Standard target point: " << scene.fStandardTargetPoint;
265 260
266 os << "\n End of event action set to \""; 261 os << "\n End of event action set to \"";
267 if (scene.fRefreshAtEndOfEvent) os << "refre 262 if (scene.fRefreshAtEndOfEvent) os << "refresh\"";
268 else { 263 else {
269 os << "accumulate (maximum number of kept 264 os << "accumulate (maximum number of kept events: ";
270 if (scene.fMaxNumberOfKeptEvents >= 0) os 265 if (scene.fMaxNumberOfKeptEvents >= 0) os << scene.fMaxNumberOfKeptEvents;
271 else os << "unlimited"; 266 else os << "unlimited";
272 os << ")"; 267 os << ")";
273 } 268 }
274 269
275 os << "\n End of run action set to \""; 270 os << "\n End of run action set to \"";
276 if (scene.fRefreshAtEndOfRun) os << "refresh 271 if (scene.fRefreshAtEndOfRun) os << "refresh";
277 else os << "accumulate"; 272 else os << "accumulate";
278 os << "\""; 273 os << "\"";
279 274
280 return os; 275 return os;
281 } 276 }
282 277
283 G4bool G4Scene::operator != (const G4Scene& sc 278 G4bool G4Scene::operator != (const G4Scene& scene) const {
284 if ( 279 if (
285 (fRunDurationModelList.size () != 280 (fRunDurationModelList.size () !=
286 scene.fRunDurationModelList.size ()) 281 scene.fRunDurationModelList.size ()) ||
287 (fEndOfEventModelList.size () != 282 (fEndOfEventModelList.size () !=
288 scene.fEndOfEventModelList.size ()) 283 scene.fEndOfEventModelList.size ()) ||
289 (fEndOfRunModelList.size () != 284 (fEndOfRunModelList.size () !=
290 scene.fEndOfRunModelList.size ()) 285 scene.fEndOfRunModelList.size ()) ||
291 (fExtent != scene.fExtent) 286 (fExtent != scene.fExtent) ||
292 !(fStandardTargetPoint == scene.fStandar 287 !(fStandardTargetPoint == scene.fStandardTargetPoint) ||
293 fRefreshAtEndOfEvent != scene.fRefresh 288 fRefreshAtEndOfEvent != scene.fRefreshAtEndOfEvent ||
294 fRefreshAtEndOfRun != scene.fRefresh 289 fRefreshAtEndOfRun != scene.fRefreshAtEndOfRun ||
295 fMaxNumberOfKeptEvents != scene.fMaxNumb 290 fMaxNumberOfKeptEvents != scene.fMaxNumberOfKeptEvents
296 ) return true; 291 ) return true;
297 292
298 /* A complete comparison should, perhaps, in 293 /* A complete comparison should, perhaps, include a comparison of
299 individual models, but it is not easy to 294 individual models, but it is not easy to implement operator!= for
300 all models. Also, it would be unfeasible 295 all models. Also, it would be unfeasible to ask users to
301 implement opeerator!= if we ever get roun 296 implement opeerator!= if we ever get round to allowing
302 user-defined models. Moreover, there is 297 user-defined models. Moreover, there is no editing of G4Scene
303 objects, apart from changing fRefreshAtEn 298 objects, apart from changing fRefreshAtEndOfEvent, etc; as far as
304 models are concerned, all you can ever do 299 models are concerned, all you can ever do is add them, so a test
305 on size (above) is enough. 300 on size (above) is enough.
306 301
307 for (size_t i = 0; i < fRunDurationModelList 302 for (size_t i = 0; i < fRunDurationModelList.size (); i++) {
308 if (fRunDurationModelList[i] != scene.fRun 303 if (fRunDurationModelList[i] != scene.fRunDurationModelList[i])
309 return true; 304 return true;
310 } 305 }
311 306
312 for (size_t i = 0; i < fEndOfEventModelList. 307 for (size_t i = 0; i < fEndOfEventModelList.size (); i++) {
313 if (fEndOfEventModelList[i] != scene.fEndO 308 if (fEndOfEventModelList[i] != scene.fEndOfEventModelList[i])
314 return true; 309 return true;
315 } 310 }
316 311
317 for (size_t i = 0; i < fEndOfRunModelList.si 312 for (size_t i = 0; i < fEndOfRunModelList.size (); i++) {
318 if (fEndOfRunModelList[i] != scene.fEndOfR 313 if (fEndOfRunModelList[i] != scene.fEndOfRunModelList[i])
319 return true; 314 return true;
320 } 315 }
321 */ 316 */
322 317
323 return false; 318 return false;
324 } 319 }
325 320