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