| Geant4 Cross Reference |
>> 1 // This code implementation is the intellectual property of
>> 2 // the GEANT4 collaboration.
1 // 3 //
2 // ******************************************* << 4 // By copying, distributing or modifying the Program (or any work
3 // * License and Disclaimer << 5 // based on the Program) you indicate your acceptance of this statement,
4 // * << 6 // and all its terms.
5 // * The Geant4 software is copyright of th <<
6 // * the Geant4 Collaboration. It is provided <<
7 // * conditions of the Geant4 Software License <<
8 // * LICENSE and available at http://cern.ch/ <<
9 // * include a list of copyright holders. <<
10 // * <<
11 // * Neither the authors of this software syst <<
12 // * institutes,nor the agencies providing fin <<
13 // * work make any representation or warran <<
14 // * regarding this software system or assum <<
15 // * use. Please see the license in the file <<
16 // * for the full disclaimer and the limitatio <<
17 // * <<
18 // * This code implementation is the result <<
19 // * technical work of the GEANT4 collaboratio <<
20 // * By using, copying, modifying or distri <<
21 // * any work based on the software) you ag <<
22 // * use in resulting scientific publicati <<
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* <<
25 // 7 //
26 // << 8 // $Id: G4VisCommandsSceneAdd.cc,v 1.9 1999/12/15 14:54:26 gunter Exp $
27 // /vis/scene/add commands - John Allison 9th << 9 // GEANT4 tag $Name: geant4-01-01 $
>> 10
>> 11 // /vis/scene commands - John Allison 9th August 1998
28 12
29 #include "G4VisCommandsSceneAdd.hh" 13 #include "G4VisCommandsSceneAdd.hh"
30 14
>> 15 #include "G4VisManager.hh"
31 #include "G4TransportationManager.hh" 16 #include "G4TransportationManager.hh"
32 #include "G4LogicalVolumeStore.hh" 17 #include "G4LogicalVolumeStore.hh"
33 #include "G4PhysicalVolumeModel.hh" 18 #include "G4PhysicalVolumeModel.hh"
34 #include "G4LogicalVolumeModel.hh" 19 #include "G4LogicalVolumeModel.hh"
35 #include "G4ModelingParameters.hh" 20 #include "G4ModelingParameters.hh"
36 #include "G4HitsModel.hh" << 21 #include "G4PhysicalVolumeSearchScene.hh"
37 #include "G4DigiModel.hh" << 22 #include "G4VGlobalFastSimulationManager.hh"
38 #include "G4GPSModel.hh" <<
39 #include "G4ElectricFieldModel.hh" <<
40 #include "G4MagneticFieldModel.hh" <<
41 #include "G4PSHitsModel.hh" <<
42 #include "G4TrajectoriesModel.hh" <<
43 #include "G4TextModel.hh" <<
44 #include "G4ArrowModel.hh" <<
45 #include "G4AxesModel.hh" <<
46 #include "G4PlotterModel.hh" <<
47 #include "G4PhysicalVolumesSearchScene.hh" <<
48 #include "G4ParticleTable.hh" 23 #include "G4ParticleTable.hh"
49 #include "G4ParticleDefinition.hh" 24 #include "G4ParticleDefinition.hh"
>> 25 #include "G4FlavoredParallelWorldModel.hh"
50 #include "G4ApplicationState.hh" 26 #include "G4ApplicationState.hh"
51 #include "G4VUserVisAction.hh" <<
52 #include "G4CallbackModel.hh" <<
53 #include "G4UnionSolid.hh" <<
54 #include "G4SubtractionSolid.hh" <<
55 #include "G4Polyhedron.hh" <<
56 #include "G4UImanager.hh" <<
57 #include "G4UIcommandTree.hh" <<
58 #include "G4UIcommand.hh" 27 #include "G4UIcommand.hh"
59 #include "G4UIcmdWithAString.hh" 28 #include "G4UIcmdWithAString.hh"
60 #include "G4UIcmdWithoutParameter.hh" << 29 #include "G4ios.hh"
61 #include "G4UIcmdWithAnInteger.hh" << 30 #include "g4std/strstream"
62 #include "G4Tokenizer.hh" <<
63 #include "G4RunManager.hh" <<
64 #include "G4RunManagerFactory.hh" <<
65 #include "G4StateManager.hh" <<
66 #include "G4Run.hh" <<
67 #include "G4Event.hh" <<
68 #include "G4Trajectory.hh" <<
69 #include "G4TrajectoryPoint.hh" <<
70 #include "G4RichTrajectory.hh" <<
71 #include "G4RichTrajectoryPoint.hh" <<
72 #include "G4SmoothTrajectory.hh" <<
73 #include "G4SmoothTrajectoryPoint.hh" <<
74 #include "G4AttDef.hh" <<
75 #include "G4AttCheck.hh" <<
76 #include "G4Polyline.hh" <<
77 #include "G4UnitsTable.hh" <<
78 #include "G4PhysicalConstants.hh" <<
79 #include "G4SystemOfUnits.hh" <<
80 #include "G4GeneralParticleSourceData.hh" <<
81 #include "G4PlotterManager.hh" <<
82 <<
83 #include <sstream> <<
84 <<
85 #define G4warn G4cout <<
86 <<
87 ////////////// /vis/scene/add/arrow ////////// <<
88 <<
89 G4VisCommandSceneAddArrow::G4VisCommandSceneAd <<
90 fpCommand = new G4UIcommand("/vis/scene/add/ <<
91 fpCommand -> SetGuidance ("Adds arrow to cur <<
92 G4bool omitable; <<
93 G4UIparameter* parameter; <<
94 parameter = new G4UIparameter ("x1", 'd', om <<
95 fpCommand -> SetParameter (parameter); <<
96 parameter = new G4UIparameter ("y1", 'd', om <<
97 fpCommand -> SetParameter (parameter); <<
98 parameter = new G4UIparameter ("z1", 'd', om <<
99 fpCommand -> SetParameter (parameter); <<
100 parameter = new G4UIparameter ("x2", 'd', om <<
101 fpCommand -> SetParameter (parameter); <<
102 parameter = new G4UIparameter ("y2", 'd', om <<
103 fpCommand -> SetParameter (parameter); <<
104 parameter = new G4UIparameter ("z2", 'd', om <<
105 fpCommand -> SetParameter (parameter); <<
106 parameter = new G4UIparameter ("unit", 's', <<
107 parameter->SetDefaultValue ("m"); <<
108 fpCommand->SetParameter (parameter); <<
109 } <<
110 <<
111 G4VisCommandSceneAddArrow::~G4VisCommandSceneA <<
112 delete fpCommand; <<
113 } <<
114 <<
115 G4String G4VisCommandSceneAddArrow::GetCurrent <<
116 return ""; <<
117 } <<
118 <<
119 void G4VisCommandSceneAddArrow::SetNewValue (G <<
120 { <<
121 G4VisManager::Verbosity verbosity = fpVisMan <<
122 G4bool warn(verbosity >= G4VisManager::warni <<
123 <<
124 G4Scene* pScene = fpVisManager->GetCurrentSc <<
125 if (!pScene) { <<
126 if (verbosity >= G4VisManager::errors) { <<
127 G4warn << "ERROR: No current scene. Ple <<
128 } <<
129 return; <<
130 } <<
131 <<
132 G4String unitString; <<
133 G4double x1, y1, z1, x2, y2, z2; <<
134 std::istringstream is(newValue); <<
135 is >> x1 >> y1 >> z1 >> x2 >> y2 >> z2 >> un <<
136 G4double unit = G4UIcommand::ValueOf(unitStr <<
137 x1 *= unit; y1 *= unit; z1 *= unit; <<
138 x2 *= unit; y2 *= unit; z2 *= unit; <<
139 <<
140 // Consult scene for arrow width. <<
141 const G4VisExtent& sceneExtent = pScene->Get <<
142 G4double arrowWidth = <<
143 0.005 * fCurrentLineWidth * sceneExtent.Ge <<
144 <<
145 G4VModel* model = new G4ArrowModel <<
146 (x1, y1, z1, x2, y2, z2, <<
147 arrowWidth, fCurrentColour, newValue, <<
148 fCurrentArrow3DLineSegmentsPerCircle); <<
149 <<
150 const G4String& currentSceneName = pScene -> <<
151 G4bool successful = pScene -> AddRunDuration <<
152 if (successful) { <<
153 if (verbosity >= G4VisManager::confirmatio <<
154 G4cout << "Arrow has been added to scene <<
155 << currentSceneName << "\"." <<
156 << G4endl; <<
157 } <<
158 } <<
159 else G4VisCommandsSceneAddUnsuccessful(verbo <<
160 <<
161 CheckSceneAndNotifyHandlers (pScene); <<
162 } <<
163 <<
164 ////////////// /vis/scene/add/arrow2D //////// <<
165 <<
166 G4VisCommandSceneAddArrow2D::G4VisCommandScene <<
167 fpCommand = new G4UIcommand("/vis/scene/add/ <<
168 fpCommand -> SetGuidance ("Adds 2D arrow to <<
169 fpCommand -> SetGuidance ("x,y in range [-1, <<
170 G4bool omitable; <<
171 G4UIparameter* parameter; <<
172 parameter = new G4UIparameter ("x1", 'd', om <<
173 fpCommand -> SetParameter (parameter); <<
174 parameter = new G4UIparameter ("y1", 'd', om <<
175 fpCommand -> SetParameter (parameter); <<
176 parameter = new G4UIparameter ("x2", 'd', om <<
177 fpCommand -> SetParameter (parameter); <<
178 parameter = new G4UIparameter ("y2", 'd', om <<
179 fpCommand -> SetParameter (parameter); <<
180 } <<
181 <<
182 G4VisCommandSceneAddArrow2D::~G4VisCommandScen <<
183 delete fpCommand; <<
184 } <<
185 <<
186 G4String G4VisCommandSceneAddArrow2D::GetCurre <<
187 return ""; <<
188 } <<
189 <<
190 void G4VisCommandSceneAddArrow2D::SetNewValue <<
191 { <<
192 G4VisManager::Verbosity verbosity = fpVisMan <<
193 G4bool warn(verbosity >= G4VisManager::warni <<
194 <<
195 G4Scene* pScene = fpVisManager->GetCurrentSc <<
196 if (!pScene) { <<
197 if (verbosity >= G4VisManager::errors) { <<
198 G4warn << "ERROR: No current scene. Ple <<
199 } <<
200 return; <<
201 } <<
202 <<
203 G4double x1, y1, x2, y2; <<
204 std::istringstream is(newValue); <<
205 is >> x1 >> y1 >> x2 >> y2; <<
206 <<
207 Arrow2D* arrow2D = new Arrow2D <<
208 (x1, y1, x2, y2, fCurrentLineWidth, fCurre <<
209 G4VModel* model = <<
210 new G4CallbackModel<G4VisCommandSceneAddAr <<
211 model->SetType("Arrow2D"); <<
212 model->SetGlobalTag("Arrow2D"); <<
213 model->SetGlobalDescription("Arrow2D: " + ne <<
214 const G4String& currentSceneName = pScene -> <<
215 G4bool successful = pScene -> AddRunDuration <<
216 if (successful) { <<
217 if (verbosity >= G4VisManager::confirmatio <<
218 G4cout << "A 2D arrow has been added to <<
219 << currentSceneName << "\"." <<
220 << G4endl; <<
221 } <<
222 } <<
223 else G4VisCommandsSceneAddUnsuccessful(verbo <<
224 <<
225 CheckSceneAndNotifyHandlers (pScene); <<
226 } <<
227 <<
228 G4VisCommandSceneAddArrow2D::Arrow2D::Arrow2D <<
229 (G4double x1, G4double y1, <<
230 G4double x2, G4double y2, <<
231 G4double width, const G4Colour& colour): <<
232 fWidth(width), fColour(colour) <<
233 { <<
234 fShaftPolyline.push_back(G4Point3D(x1,y1,0)) <<
235 fShaftPolyline.push_back(G4Point3D(x2,y2,0)) <<
236 G4Vector3D arrowDirection = G4Vector3D(x2-x1 <<
237 G4Vector3D arrowPointLeftDirection(arrowDire <<
238 arrowPointLeftDirection.rotateZ(150.*deg); <<
239 G4Vector3D arrowPointRightDirection(arrowDir <<
240 arrowPointRightDirection.rotateZ(-150.*deg); <<
241 fHeadPolyline.push_back(G4Point3D(x2,y2,0)+0 <<
242 fHeadPolyline.push_back(G4Point3D(x2,y2,0)); <<
243 fHeadPolyline.push_back(G4Point3D(x2,y2,0)+0 <<
244 G4VisAttributes va; <<
245 va.SetLineWidth(fWidth); <<
246 va.SetColour(fColour); <<
247 fShaftPolyline.SetVisAttributes(va); <<
248 fHeadPolyline.SetVisAttributes(va); <<
249 } <<
250 <<
251 void G4VisCommandSceneAddArrow2D::Arrow2D::ope <<
252 (G4VGraphicsScene& sceneHandler, const G4Mod <<
253 { <<
254 sceneHandler.BeginPrimitives2D(); <<
255 sceneHandler.AddPrimitive(fShaftPolyline); <<
256 sceneHandler.AddPrimitive(fHeadPolyline); <<
257 sceneHandler.EndPrimitives2D(); <<
258 } <<
259 <<
260 ////////////// /vis/scene/add/axes /////////// <<
261 <<
262 G4VisCommandSceneAddAxes::G4VisCommandSceneAdd <<
263 G4bool omitable; <<
264 fpCommand = new G4UIcommand ("/vis/scene/add <<
265 fpCommand -> SetGuidance ("Add axes."); <<
266 fpCommand -> SetGuidance <<
267 ("Draws axes at (x0, y0, z0) of given length <<
268 fpCommand -> SetGuidance <<
269 ("If \"colour-string\" is \"auto\", x, y and <<
270 "\n respectively. Otherwise it can be one <<
271 "\n colours - see information printed by t <<
272 "\n use \"/vis/list\"."); <<
273 fpCommand -> SetGuidance <<
274 ("If \"length\" is negative, it is set to ab <<
275 fpCommand -> SetGuidance <<
276 ("If \"showtext\" is false, annotations are <<
277 G4UIparameter* parameter; <<
278 parameter = new G4UIparameter ("x0", 'd', o <<
279 parameter->SetDefaultValue (0.); <<
280 fpCommand->SetParameter (parameter); <<
281 parameter = new G4UIparameter ("y0", 'd', o <<
282 parameter->SetDefaultValue (0.); <<
283 fpCommand->SetParameter (parameter); <<
284 parameter = new G4UIparameter ("z0", 'd', o <<
285 parameter->SetDefaultValue (0.); <<
286 fpCommand->SetParameter (parameter); <<
287 parameter = new G4UIparameter ("length", 'd <<
288 parameter->SetDefaultValue (-1.); <<
289 fpCommand->SetParameter (parameter); <<
290 parameter = new G4UIparameter ("unit", 's', <<
291 parameter->SetDefaultValue ("m"); <<
292 fpCommand->SetParameter (parameter); <<
293 parameter = new G4UIparameter ("colour-stri <<
294 parameter->SetDefaultValue ("auto"); <<
295 fpCommand->SetParameter (parameter); <<
296 parameter = new G4UIparameter ("showtext", <<
297 parameter->SetDefaultValue ("true"); <<
298 fpCommand->SetParameter (parameter); <<
299 } <<
300 <<
301 G4VisCommandSceneAddAxes::~G4VisCommandSceneAd <<
302 delete fpCommand; <<
303 } <<
304 <<
305 G4String G4VisCommandSceneAddAxes::GetCurrentV <<
306 return ""; <<
307 } <<
308 <<
309 void G4VisCommandSceneAddAxes::SetNewValue (G4 <<
310 <<
311 G4VisManager::Verbosity verbosity = fpVisMan <<
312 G4bool warn(verbosity >= G4VisManager::warni <<
313 <<
314 G4Scene* pScene = fpVisManager->GetCurrentSc <<
315 if (!pScene) { <<
316 if (verbosity >= G4VisManager::errors) { <<
317 G4warn << "ERROR: No current scene. Ple <<
318 } <<
319 return; <<
320 } else { <<
321 if (pScene->GetExtent().GetExtentRadius() <<
322 if (verbosity >= G4VisManager::errors) { <<
323 G4warn <<
324 << "ERROR: Scene has no extent. Add volumes <<
325 << G4endl; <<
326 } <<
327 return; <<
328 } <<
329 } <<
330 <<
331 G4String unitString, colourString, showTextS <<
332 G4double x0, y0, z0, length; <<
333 std::istringstream is (newValue); <<
334 is >> x0 >> y0 >> z0 >> length >> unitString <<
335 >> colourString >> showTextString; <<
336 G4bool showText = G4UIcommand::ConvertToBool <<
337 <<
338 <<
339 G4double unit = G4UIcommand::ValueOf(unitStr <<
340 x0 *= unit; y0 *= unit; z0 *= unit; <<
341 const G4VisExtent& sceneExtent = pScene->Get <<
342 if (length < 0.) { <<
343 const G4double lengthMax = 0.5 * sceneExte <<
344 const G4double intLog10Length = std::floor <<
345 length = std::pow(10,intLog10Length); <<
346 if (5.*length < lengthMax) length *= 5.; <<
347 else if (2.*length < lengthMax) length *= <<
348 } else { <<
349 length *= unit; <<
350 } <<
351 <<
352 // Consult scene for arrow width... <<
353 G4double arrowWidth = <<
354 0.05 * fCurrentLineWidth * sceneExtent.Get <<
355 // ...but limit it to length/30. <<
356 if (arrowWidth > length/30.) arrowWidth = le <<
357 <<
358 G4VModel* model = new G4AxesModel <<
359 (x0, y0, z0, length, arrowWidth, colourStr <<
360 showText, fCurrentTextSize); <<
361 <<
362 G4bool successful = pScene -> AddRunDuration <<
363 const G4String& currentSceneName = pScene -> <<
364 if (successful) { <<
365 if (verbosity >= G4VisManager::confirmatio <<
366 G4cout << "Axes of length " << G4BestUni <<
367 << "have been added to scene \"" << curr <<
368 << G4endl; <<
369 } <<
370 } <<
371 else G4VisCommandsSceneAddUnsuccessful(verbo <<
372 <<
373 CheckSceneAndNotifyHandlers (pScene); <<
374 } <<
375 <<
376 ////////////// /vis/scene/add/date /////////// <<
377 <<
378 G4VisCommandSceneAddDate::G4VisCommandSceneAdd <<
379 G4bool omitable; <<
380 fpCommand = new G4UIcommand ("/vis/scene/add <<
381 fpCommand -> SetGuidance ("Adds date to curr <<
382 fpCommand -> SetGuidance <<
383 ("If \"date\"is omitted, the current date an <<
384 "\nOtherwise, the string, including the res <<
385 G4UIparameter* parameter; <<
386 parameter = new G4UIparameter ("size", 'i', <<
387 parameter -> SetGuidance ("Screen size of te <<
388 parameter -> SetDefaultValue (18); <<
389 fpCommand -> SetParameter (parameter); <<
390 parameter = new G4UIparameter ("x-position", <<
391 parameter -> SetGuidance ("x screen position <<
392 parameter -> SetDefaultValue (0.95); <<
393 fpCommand -> SetParameter (parameter); <<
394 parameter = new G4UIparameter ("y-position", <<
395 parameter -> SetGuidance ("y screen position <<
396 parameter -> SetDefaultValue (0.9); <<
397 fpCommand -> SetParameter (parameter); <<
398 parameter = new G4UIparameter ("layout", 's' <<
399 parameter -> SetGuidance ("Layout, i.e., adj <<
400 parameter -> SetDefaultValue ("right"); <<
401 fpCommand -> SetParameter (parameter); <<
402 parameter = new G4UIparameter ("date", 's', <<
403 parameter -> SetDefaultValue ("-"); <<
404 fpCommand -> SetParameter (parameter); <<
405 } <<
406 <<
407 G4VisCommandSceneAddDate::~G4VisCommandSceneAd <<
408 delete fpCommand; <<
409 } <<
410 <<
411 G4String G4VisCommandSceneAddDate::GetCurrentV <<
412 return ""; <<
413 } <<
414 <<
415 void G4VisCommandSceneAddDate::SetNewValue (G4 <<
416 { <<
417 G4VisManager::Verbosity verbosity = fpVisMan <<
418 G4bool warn(verbosity >= G4VisManager::warni <<
419 <<
420 G4Scene* pScene = fpVisManager->GetCurrentSc <<
421 if (!pScene) { <<
422 if (verbosity >= G4VisManager::errors) { <<
423 G4warn << "ERROR: No current scene. Ple <<
424 } <<
425 return; <<
426 } <<
427 <<
428 G4int size; <<
429 G4double x, y; <<
430 G4String layoutString, dateString; <<
431 std::istringstream is(newValue); <<
432 is >> size >> x >> y >> layoutString >> date <<
433 // Read rest of line, if any. <<
434 const size_t NREMAINDER = 100; <<
435 char remainder[NREMAINDER]; <<
436 remainder[0]='\0'; // In case there is noth <<
437 is.getline(remainder, NREMAINDER); <<
438 dateString += remainder; <<
439 G4Text::Layout layout = G4Text::right; <<
440 if (layoutString[0] == 'l') layout = G4Text: <<
441 else if (layoutString[0] == 'c') layout = G4 <<
442 else if (layoutString[0] == 'r') layout = G4 <<
443 <<
444 Date* date = new Date(fpVisManager, size, x, <<
445 G4VModel* model = <<
446 new G4CallbackModel<G4VisCommandSceneAddDa <<
447 model->SetType("Date"); <<
448 model->SetGlobalTag("Date"); <<
449 model->SetGlobalDescription("Date: " + newVa <<
450 const G4String& currentSceneName = pScene -> <<
451 G4bool successful = pScene -> AddEndOfEventM <<
452 if (successful) { <<
453 if (verbosity >= G4VisManager::confirmatio <<
454 G4cout << "Date has been added to scene <<
455 << currentSceneName << "\"." <<
456 << G4endl; <<
457 } <<
458 } <<
459 else G4VisCommandsSceneAddUnsuccessful(verbo <<
460 <<
461 CheckSceneAndNotifyHandlers (pScene); <<
462 } <<
463 <<
464 void G4VisCommandSceneAddDate::Date::operator( <<
465 (G4VGraphicsScene& sceneHandler, const G4Mod <<
466 { <<
467 G4String time; <<
468 if (fDate == "-") { <<
469 time = fTimer.GetClockTime(); <<
470 } else { <<
471 time = fDate; <<
472 } <<
473 // Check for \n, starting from back, and era <<
474 std::string::size_type i = time.rfind('\n'); <<
475 if (i != std::string::npos) time.erase(i); <<
476 G4Text text(time, G4Point3D(fX, fY, 0.)); <<
477 text.SetScreenSize(fSize); <<
478 text.SetLayout(fLayout); <<
479 G4VisAttributes textAtts(G4Colour(0.,1.,1)); <<
480 text.SetVisAttributes(textAtts); <<
481 sceneHandler.BeginPrimitives2D(); <<
482 sceneHandler.AddPrimitive(text); <<
483 sceneHandler.EndPrimitives2D(); <<
484 } <<
485 <<
486 ////////////// /vis/scene/add/digis ////////// <<
487 <<
488 G4VisCommandSceneAddDigis::G4VisCommandSceneAd <<
489 fpCommand = new G4UIcmdWithoutParameter ("/v <<
490 fpCommand -> SetGuidance ("Adds digis to cur <<
491 fpCommand -> SetGuidance <<
492 ("Digis are drawn at end of event when the <<
493 "\nthey are added is current."); <<
494 } <<
495 <<
496 G4VisCommandSceneAddDigis::~G4VisCommandSceneA <<
497 delete fpCommand; <<
498 } <<
499 <<
500 G4String G4VisCommandSceneAddDigis::GetCurrent <<
501 return ""; <<
502 } <<
503 <<
504 void G4VisCommandSceneAddDigis::SetNewValue (G <<
505 31
506 G4VisManager::Verbosity verbosity = fpVisMan << 32 ////////////// /vis/scene/add/volume ///////////////////////////////////////
507 G4bool warn(verbosity >= G4VisManager::warni <<
508 <<
509 G4Scene* pScene = fpVisManager->GetCurrentSc <<
510 if (!pScene) { <<
511 if (verbosity >= G4VisManager::errors) { <<
512 G4warn << "ERROR: No current scene. Ple <<
513 } <<
514 return; <<
515 } <<
516 <<
517 G4VModel* model = new G4DigiModel; <<
518 const G4String& currentSceneName = pScene -> <<
519 G4bool successful = pScene -> AddEndOfEventM <<
520 if (successful) { <<
521 if (verbosity >= G4VisManager::confirmatio <<
522 G4cout << "Digis, if any, will be drawn <<
523 << currentSceneName << "\"." <<
524 << G4endl; <<
525 } <<
526 } <<
527 else G4VisCommandsSceneAddUnsuccessful(verbo <<
528 <<
529 CheckSceneAndNotifyHandlers (pScene); <<
530 } <<
531 <<
532 ////////////// /vis/scene/add/electricField // <<
533 33
534 G4VisCommandSceneAddElectricField::G4VisComman << 34 G4VisCommandSceneAddVolume::G4VisCommandSceneAddVolume () {
535 G4bool omitable; 35 G4bool omitable;
536 fpCommand = new G4UIcommand ("/vis/scene/add << 36 fpCommand = new G4UIcommand ("/vis/scene/add/volume", this);
>> 37 fpCommand -> AvailableForStates (Idle, GeomClosed);
537 fpCommand -> SetGuidance 38 fpCommand -> SetGuidance
538 ("Adds electric field representation to curr << 39 ("/vis/scene/add/volume [<physical-volume-name>] [<copy-no>] [<depth-of-descending>]");
>> 40 fpCommand -> SetGuidance ("Adds a physical volume to the current scene.");
539 fpCommand -> SetGuidance 41 fpCommand -> SetGuidance
540 ("The first parameter is no. of data points << 42 ("1st parameter: volume name (default \"world\").");
541 "\nmaximum, the number of data points sampl << 43 // fpCommand -> SetGuidance // Not implemented - should be in geom?
542 "\nlarge--be warned!" << 44 // (" \"list\" to list all volumes.");
543 "\nThe default value is 10, i.e., a 21x21x2 <<
544 "\nThat may swamp your view, but usually, a <<
545 "\nthe extent, so it's not a problem. But i <<
546 "\nyou can do:" <<
547 "\n- reduce the number of data points per h <<
548 "\n- specify \"lightArrow\" (second paramet <<
549 "\n- restrict the region sampled with \"/vi <<
550 "\n- restrict the drawing to a specific vol <<
551 "\n \"/vis/set/volumeForField\" or \"/vi <<
552 "\nNote: you might have to deactivate exist <<
553 "\n \"/vis/scene/activateModel Field false <<
554 "\n \"/vis/scene/add/...Field\" command ag <<
555 fpCommand -> SetGuidance 45 fpCommand -> SetGuidance
556 ("In the arrow representation, the length of << 46 ("2nd parameter: copy number (default 0).");
557 "\nto the magnitude of the field and the co <<
558 "\nas a fraction of the maximum magnitude: <<
559 G4UIparameter* parameter; <<
560 parameter = new G4UIparameter ("nDataPointsP <<
561 parameter -> SetDefaultValue (10); <<
562 fpCommand -> SetParameter (parameter); <<
563 parameter = new G4UIparameter ("representati <<
564 parameter -> SetParameterCandidates("fullArr <<
565 parameter -> SetDefaultValue ("fullArrow"); <<
566 fpCommand -> SetParameter (parameter); <<
567 } <<
568 <<
569 G4VisCommandSceneAddElectricField::~G4VisComma <<
570 delete fpCommand; <<
571 } <<
572 <<
573 G4String G4VisCommandSceneAddElectricField::Ge <<
574 return ""; <<
575 } <<
576 <<
577 void G4VisCommandSceneAddElectricField::SetNew <<
578 (G4UIcommand*, G4String newValue) { <<
579 <<
580 G4VisManager::Verbosity verbosity = fpVisMan <<
581 G4bool warn(verbosity >= G4VisManager::warni <<
582 <<
583 G4Scene* pScene = fpVisManager->GetCurrentSc <<
584 if (!pScene) { <<
585 if (verbosity >= G4VisManager::errors) { <<
586 G4warn << "ERROR: No current scene. Pl <<
587 } <<
588 return; <<
589 } <<
590 <<
591 G4int nDataPointsPerHalfExtent; <<
592 G4String representation; <<
593 std::istringstream iss(newValue); <<
594 iss >> nDataPointsPerHalfExtent >> represent <<
595 G4ElectricFieldModel::Representation <<
596 modelRepresentation = G4ElectricFieldModel:: <<
597 if (representation == "lightArrow") { <<
598 modelRepresentation = G4ElectricFieldModel <<
599 } <<
600 G4VModel* model; <<
601 model = new G4ElectricFieldModel <<
602 (nDataPointsPerHalfExtent,modelRepresentatio <<
603 fCurrentArrow3DLineSegmentsPerCircle, <<
604 fCurrentExtentForField, <<
605 fCurrrentPVFindingsForField); <<
606 const G4String& currentSceneName = pScene -> <<
607 G4bool successful = pScene -> AddRunDuration <<
608 if (successful) { <<
609 if (verbosity >= G4VisManager::confirmatio <<
610 G4cout <<
611 << "Electric field, if any, will be draw <<
612 << currentSceneName <<
613 << "\"\n with " <<
614 << nDataPointsPerHalfExtent <<
615 << " data points per half extent and wit <<
616 << representation <<
617 << '\"' <<
618 << G4endl; <<
619 } <<
620 } <<
621 else G4VisCommandsSceneAddUnsuccessful(verbo <<
622 <<
623 CheckSceneAndNotifyHandlers (pScene); <<
624 } <<
625 <<
626 ////////////// /vis/scene/add/eventID //////// <<
627 <<
628 G4VisCommandSceneAddEventID::G4VisCommandScene <<
629 G4bool omitable; <<
630 fpCommand = new G4UIcommand ("/vis/scene/add <<
631 fpCommand -> SetGuidance ("Adds eventID to c <<
632 fpCommand -> SetGuidance <<
633 ("Run and event numbers are drawn at end o <<
634 "\n the scene in which they are added is <<
635 G4UIparameter* parameter; <<
636 parameter = new G4UIparameter ("size", 'i', <<
637 parameter -> SetGuidance ("Screen size of te <<
638 parameter -> SetDefaultValue (18); <<
639 fpCommand -> SetParameter (parameter); <<
640 parameter = new G4UIparameter ("x-position", <<
641 parameter -> SetGuidance ("x screen position <<
642 parameter -> SetDefaultValue (-0.95); <<
643 fpCommand -> SetParameter (parameter); <<
644 parameter = new G4UIparameter ("y-position", <<
645 parameter -> SetGuidance ("y screen position <<
646 parameter -> SetDefaultValue (0.9); <<
647 fpCommand -> SetParameter (parameter); <<
648 parameter = new G4UIparameter ("layout", 's' <<
649 parameter -> SetGuidance ("Layout, i.e., adj <<
650 parameter -> SetDefaultValue ("left"); <<
651 fpCommand -> SetParameter (parameter); <<
652 } <<
653 <<
654 G4VisCommandSceneAddEventID::~G4VisCommandScen <<
655 delete fpCommand; <<
656 } <<
657 <<
658 G4String G4VisCommandSceneAddEventID::GetCurre <<
659 return ""; <<
660 } <<
661 <<
662 void G4VisCommandSceneAddEventID::SetNewValue <<
663 { <<
664 G4VisManager::Verbosity verbosity = fpVisMan <<
665 G4bool warn(verbosity >= G4VisManager::warni <<
666 <<
667 G4Scene* pScene = fpVisManager->GetCurrentSc <<
668 if (!pScene) { <<
669 if (verbosity >= G4VisManager::errors) { <<
670 G4warn << "ERROR: No current scene. Ple <<
671 } <<
672 return; <<
673 } <<
674 <<
675 G4int size; <<
676 G4double x, y; <<
677 G4String layoutString; <<
678 std::istringstream is(newValue); <<
679 is >> size >> x >> y >> layoutString; <<
680 <<
681 G4Text::Layout layout = G4Text::right; <<
682 if (layoutString[0] == 'l') layout = G4Text: <<
683 else if (layoutString[0] == 'c') layout = G4 <<
684 else if (layoutString[0] == 'r') layout = G4 <<
685 <<
686 // For End of Event (only for reviewing kept <<
687 EventID* eoeEventID <<
688 = new EventID(forEndOfEvent, fpVisManager, s <<
689 G4VModel* eoeModel = <<
690 new G4CallbackModel<G4VisCommandSceneAddEv <<
691 eoeModel->SetType("EoEEventID"); <<
692 eoeModel->SetGlobalTag("EoEEventID"); <<
693 eoeModel->SetGlobalDescription("EoEEventID: <<
694 G4bool successfulEoE = pScene -> AddEndOfEve <<
695 <<
696 // For End of Run <<
697 EventID* eorEventID <<
698 = new EventID(forEndOfRun, fpVisManager, siz <<
699 G4VModel* eorModel = <<
700 new G4CallbackModel<G4VisCommandSceneAddEven <<
701 eorModel->SetType("EoREventID"); <<
702 eorModel->SetGlobalTag("EoREventID"); <<
703 eorModel->SetGlobalDescription("EoREventID: <<
704 G4bool successfulEoR = pScene -> AddEndOfRun <<
705 <<
706 if (successfulEoE && successfulEoR) { <<
707 if (verbosity >= G4VisManager::confirmatio <<
708 const G4String& currentSceneName = pScen <<
709 G4cout << "EventID has been added to sce <<
710 << currentSceneName << "\"." <<
711 << G4endl; <<
712 } <<
713 } <<
714 else G4VisCommandsSceneAddUnsuccessful(verbo <<
715 <<
716 CheckSceneAndNotifyHandlers (pScene); <<
717 } <<
718 <<
719 void G4VisCommandSceneAddEventID::EventID::ope <<
720 (G4VGraphicsScene& sceneHandler, const G4Model <<
721 { <<
722 G4RunManager* runManager = G4RunManagerFacto <<
723 if(!runManager) <<
724 return; <<
725 <<
726 const G4Run* currentRun = runManager->GetCur <<
727 if (!currentRun) return; <<
728 <<
729 const G4int currentRunID = currentRun->GetRu <<
730 <<
731 std::ostringstream oss; <<
732 switch (fForWhat) { <<
733 case forEndOfEvent: <<
734 { <<
735 // Only use if reviewing kept events <<
736 if (!fpVisManager->GetReviewingKeptEvent <<
737 const G4Event* currentEvent = mp->GetEve <<
738 if (!currentEvent) return; <<
739 G4int eventID = currentEvent->GetEventID <<
740 oss << "Run " << currentRunID << " Event <<
741 break; <<
742 } <<
743 case forEndOfRun: <<
744 { <<
745 // Only use if NOT reviewing kept events <<
746 if (fpVisManager->GetReviewingKeptEvents <<
747 const G4int nEvents = currentRun->GetNum <<
748 size_t nKeptEvents = (size_t)(currentRun <<
749 oss << "Run " << currentRunID << " (" << <<
750 if (nEvents != 1) oss << 's'; <<
751 oss << ", " << nKeptEvents << " kept)"; <<
752 break; <<
753 } <<
754 default: <<
755 return; <<
756 } <<
757 <<
758 G4Text text(oss.str(), G4Point3D(fX, fY, 0.) <<
759 text.SetScreenSize(fSize); <<
760 text.SetLayout(fLayout); <<
761 G4VisAttributes textAtts(G4Colour(0.,1.,1)); <<
762 text.SetVisAttributes(textAtts); <<
763 sceneHandler.BeginPrimitives2D(); <<
764 sceneHandler.AddPrimitive(text); <<
765 sceneHandler.EndPrimitives2D(); <<
766 } <<
767 <<
768 ////////////// /vis/scene/add/extent ///////// <<
769 <<
770 G4VisCommandSceneAddExtent::G4VisCommandSceneA <<
771 fpCommand = new G4UIcommand("/vis/scene/add/ <<
772 fpCommand -> SetGuidance 47 fpCommand -> SetGuidance
773 ("Adds a dummy model with given extent to th << 48 ("3rd parameter: depth of descending geometry hierarchy"
774 "\nRequires the limits: xmin, xmax, ymin, y << 49 " (default G4Scene::UNLIMITED (-1)).");
775 "\nThis can be used to provide an extent to <<
776 "\nno other models with extent are availabl <<
777 "\neven if there is no geometry. In that c <<
778 "\n /vis/open OGL" <<
779 "\n /vis/scene/create" <<
780 "\n /vis/scene/add/extent -300 300 -300 30 <<
781 "\n /vis/sceneHandler/attach"); <<
782 G4bool omitable; <<
783 G4UIparameter* parameter; 50 G4UIparameter* parameter;
784 parameter = new G4UIparameter ("xmin", 'd', << 51 parameter = new G4UIparameter ("volume", 's', omitable = true);
785 parameter -> SetDefaultValue (0.); << 52 parameter -> SetDefaultValue ("world");
786 fpCommand -> SetParameter (parameter); <<
787 parameter = new G4UIparameter ("xmax", 'd', <<
788 parameter -> SetDefaultValue (0.); <<
789 fpCommand -> SetParameter (parameter); <<
790 parameter = new G4UIparameter ("ymin", 'd', <<
791 parameter -> SetDefaultValue (0.); <<
792 fpCommand -> SetParameter (parameter); <<
793 parameter = new G4UIparameter ("ymax", 'd', <<
794 parameter -> SetDefaultValue (0.); <<
795 fpCommand -> SetParameter (parameter); <<
796 parameter = new G4UIparameter ("zmin", 'd', <<
797 parameter -> SetDefaultValue (0.); <<
798 fpCommand -> SetParameter (parameter); <<
799 parameter = new G4UIparameter ("zmax", 'd', <<
800 parameter -> SetDefaultValue (0.); <<
801 fpCommand -> SetParameter (parameter); <<
802 parameter = new G4UIparameter ("unit", 's', <<
803 parameter -> SetDefaultValue ("m"); <<
804 fpCommand -> SetParameter (parameter); <<
805 } <<
806 <<
807 G4VisCommandSceneAddExtent::~G4VisCommandScene <<
808 delete fpCommand; <<
809 } <<
810 <<
811 G4String G4VisCommandSceneAddExtent::GetCurren <<
812 return ""; <<
813 } <<
814 <<
815 void G4VisCommandSceneAddExtent::SetNewValue ( <<
816 { <<
817 G4VisManager::Verbosity verbosity = fpVisMan <<
818 G4bool warn(verbosity >= G4VisManager::warni <<
819 <<
820 G4Scene* pScene = fpVisManager->GetCurrentSc <<
821 if (!pScene) { <<
822 if (verbosity >= G4VisManager::errors) { <<
823 G4warn << "ERROR: No current scene. Ple <<
824 } <<
825 return; <<
826 } <<
827 <<
828 G4double xmin, xmax, ymin, ymax, zmin, zmax; <<
829 G4String unitString; <<
830 std::istringstream is(newValue); <<
831 is >> xmin >> xmax >> ymin >> ymax >> zmin > <<
832 G4double unit = G4UIcommand::ValueOf(unitStr <<
833 xmin *= unit; xmax *= unit; <<
834 ymin *= unit; ymax *= unit; <<
835 zmin *= unit; zmax *= unit; <<
836 <<
837 G4VisExtent visExtent(xmin, xmax, ymin, ymax <<
838 Extent* extent = new Extent(xmin, xmax, ymin <<
839 G4VModel* model = <<
840 new G4CallbackModel<G4VisCommandSceneAddExte <<
841 model->SetType("Extent"); <<
842 model->SetGlobalTag("Extent"); <<
843 model->SetGlobalDescription("Extent: " + new <<
844 model->SetExtent(visExtent); <<
845 const G4String& currentSceneName = pScene -> <<
846 G4bool successful = pScene -> AddRunDuration <<
847 if (successful) { <<
848 if (verbosity >= G4VisManager::confirmatio <<
849 G4cout << "A benign model with extent " <<
850 << visExtent <<
851 << " has been added to scene \"" <<
852 << currentSceneName << "\"." <<
853 << G4endl; <<
854 } <<
855 } <<
856 else G4VisCommandsSceneAddUnsuccessful(verbo <<
857 <<
858 CheckSceneAndNotifyHandlers (pScene); <<
859 } <<
860 <<
861 G4VisCommandSceneAddExtent::Extent::Extent <<
862 (G4double xmin, G4double xmax, <<
863 G4double ymin, G4double ymax, <<
864 G4double zmin, G4double zmax): <<
865 fExtent(xmin,xmax,ymin,ymax,zmin,zmax) <<
866 {} <<
867 <<
868 void G4VisCommandSceneAddExtent::Extent::opera <<
869 (G4VGraphicsScene&, const G4ModelingParameters <<
870 {} <<
871 <<
872 ////////////// /vis/scene/add/frame ////////// <<
873 <<
874 G4VisCommandSceneAddFrame::G4VisCommandSceneAd <<
875 fpCommand = new G4UIcommand("/vis/scene/add/ <<
876 fpCommand -> SetGuidance ("Add frame to curr <<
877 G4bool omitable; <<
878 G4UIparameter* parameter; <<
879 parameter = new G4UIparameter ("size", 'd', <<
880 parameter -> SetGuidance ("Size of frame. 1 <<
881 parameter -> SetParameterRange ("size > 0 && <<
882 parameter -> SetDefaultValue (0.97); <<
883 fpCommand -> SetParameter (parameter); <<
884 } <<
885 <<
886 G4VisCommandSceneAddFrame::~G4VisCommandSceneA <<
887 delete fpCommand; <<
888 } <<
889 <<
890 G4String G4VisCommandSceneAddFrame::GetCurrent <<
891 return ""; <<
892 } <<
893 <<
894 void G4VisCommandSceneAddFrame::SetNewValue (G <<
895 { <<
896 G4VisManager::Verbosity verbosity = fpVisMan <<
897 G4bool warn(verbosity >= G4VisManager::warni <<
898 <<
899 G4Scene* pScene = fpVisManager->GetCurrentSc <<
900 if (!pScene) { <<
901 if (verbosity >= G4VisManager::errors) { <<
902 G4warn << "ERROR: No current scene. Ple <<
903 } <<
904 return; <<
905 } <<
906 <<
907 G4double size; <<
908 std::istringstream is(newValue); <<
909 is >> size; <<
910 <<
911 Frame* frame = new Frame(size, fCurrentLineW <<
912 G4VModel* model = <<
913 new G4CallbackModel<G4VisCommandSceneAddFr <<
914 model->SetType("Frame"); <<
915 model->SetGlobalTag("Frame"); <<
916 model->SetGlobalDescription("Frame: " + newV <<
917 const G4String& currentSceneName = pScene -> <<
918 G4bool successful = pScene -> AddRunDuration <<
919 if (successful) { <<
920 if (verbosity >= G4VisManager::confirmatio <<
921 G4cout << "Frame has been added to scene <<
922 << currentSceneName << "\"." <<
923 << G4endl; <<
924 } <<
925 } <<
926 else G4VisCommandsSceneAddUnsuccessful(verbo <<
927 <<
928 CheckSceneAndNotifyHandlers (pScene); <<
929 } <<
930 <<
931 void G4VisCommandSceneAddFrame::Frame::operato <<
932 (G4VGraphicsScene& sceneHandler, const G4Mod <<
933 { <<
934 G4Polyline frame; <<
935 frame.push_back(G4Point3D( fSize, fSize, 0. <<
936 frame.push_back(G4Point3D(-fSize, fSize, 0. <<
937 frame.push_back(G4Point3D(-fSize, -fSize, 0. <<
938 frame.push_back(G4Point3D( fSize, -fSize, 0. <<
939 frame.push_back(G4Point3D( fSize, fSize, 0. <<
940 G4VisAttributes va; <<
941 va.SetLineWidth(fWidth); <<
942 va.SetColour(fColour); <<
943 frame.SetVisAttributes(va); <<
944 sceneHandler.BeginPrimitives2D(); <<
945 sceneHandler.AddPrimitive(frame); <<
946 sceneHandler.EndPrimitives2D(); <<
947 } <<
948 <<
949 ////////////// /vis/scene/add/gps //////////// <<
950 <<
951 G4VisCommandSceneAddGPS::G4VisCommandSceneAddG <<
952 G4bool omitable; <<
953 G4UIparameter* parameter; <<
954 fpCommand = new G4UIcommand ("/vis/scene/add <<
955 fpCommand -> SetGuidance <<
956 ("A representation of the source(s) of the G <<
957 "\nwill be added to current scene and drawn <<
958 fpCommand->SetGuidance(ConvertToColourGuidan <<
959 fpCommand->SetGuidance("Default: red and tra <<
960 parameter = new G4UIparameter("red_or_string <<
961 parameter -> SetDefaultValue ("1."); <<
962 fpCommand -> SetParameter (parameter); <<
963 parameter = new G4UIparameter("green", 'd', <<
964 parameter -> SetDefaultValue (0.); <<
965 fpCommand -> SetParameter (parameter); <<
966 parameter = new G4UIparameter ("blue", 'd', <<
967 parameter -> SetDefaultValue (0.); <<
968 fpCommand -> SetParameter (parameter); <<
969 parameter = new G4UIparameter ("opacity", 'd <<
970 parameter -> SetDefaultValue (0.3); <<
971 fpCommand -> SetParameter (parameter); <<
972 } <<
973 <<
974 G4VisCommandSceneAddGPS::~G4VisCommandSceneAdd <<
975 delete fpCommand; <<
976 } <<
977 <<
978 G4String G4VisCommandSceneAddGPS::GetCurrentVa <<
979 return ""; <<
980 } <<
981 <<
982 void G4VisCommandSceneAddGPS::SetNewValue (G4U <<
983 <<
984 G4VisManager::Verbosity verbosity = fpVisMan <<
985 G4bool warn(verbosity >= G4VisManager::warni <<
986 <<
987 G4Scene* pScene = fpVisManager->GetCurrentSc <<
988 if (!pScene) { <<
989 if (verbosity >= G4VisManager::errors) { <<
990 G4warn << "ERROR: No current scene. Ple <<
991 } <<
992 return; <<
993 } <<
994 <<
995 G4String redOrString; <<
996 G4double green, blue, opacity; <<
997 std::istringstream iss(newValue); <<
998 iss >> redOrString >> green >> blue >> opaci <<
999 G4Colour colour(1.,0.,0.,0.3); // Default r <<
1000 ConvertToColour(colour, redOrString, green, <<
1001 <<
1002 G4VModel* model = new G4GPSModel(colour); <<
1003 const G4String& currentSceneName = pScene - <<
1004 G4bool successful = pScene -> AddRunDuratio <<
1005 if (successful) { <<
1006 if (verbosity >= G4VisManager::confirmati <<
1007 G4cout << <<
1008 "A representation of the source(s) of t <<
1009 "\n in colour " << colour << " for sce <<
1010 << currentSceneName << "\" if applicabl <<
1011 << G4endl; <<
1012 } <<
1013 } <<
1014 else G4VisCommandsSceneAddUnsuccessful(verb <<
1015 <<
1016 CheckSceneAndNotifyHandlers (pScene); <<
1017 } <<
1018 <<
1019 ////////////// /vis/scene/add/hits ////////// <<
1020 <<
1021 G4VisCommandSceneAddHits::G4VisCommandSceneAd <<
1022 fpCommand = new G4UIcmdWithoutParameter ("/ <<
1023 fpCommand -> SetGuidance ("Adds hits to cur <<
1024 fpCommand -> SetGuidance <<
1025 ("Hits are drawn at end of event when the <<
1026 "\nthey are added is current."); <<
1027 } <<
1028 <<
1029 G4VisCommandSceneAddHits::~G4VisCommandSceneA <<
1030 delete fpCommand; <<
1031 } <<
1032 <<
1033 G4String G4VisCommandSceneAddHits::GetCurrent <<
1034 return ""; <<
1035 } <<
1036 <<
1037 void G4VisCommandSceneAddHits::SetNewValue (G <<
1038 <<
1039 G4VisManager::Verbosity verbosity = fpVisMa <<
1040 G4bool warn(verbosity >= G4VisManager::warn <<
1041 <<
1042 G4Scene* pScene = fpVisManager->GetCurrentS <<
1043 if (!pScene) { <<
1044 if (verbosity >= G4VisManager::errors) { <<
1045 G4warn << "ERROR: No current scene. Pl <<
1046 } <<
1047 return; <<
1048 } <<
1049 <<
1050 G4VModel* model = new G4HitsModel; <<
1051 const G4String& currentSceneName = pScene - <<
1052 G4bool successful = pScene -> AddEndOfEvent <<
1053 if (successful) { <<
1054 if (verbosity >= G4VisManager::confirmati <<
1055 G4cout << "Hits, if any, will be drawn <<
1056 << currentSceneName << "\"." <<
1057 << G4endl; <<
1058 } <<
1059 } <<
1060 else G4VisCommandsSceneAddUnsuccessful(verb <<
1061 <<
1062 CheckSceneAndNotifyHandlers (pScene); <<
1063 } <<
1064 <<
1065 ////////////// /vis/scene/add/line ////////// <<
1066 <<
1067 G4VisCommandSceneAddLine::G4VisCommandSceneAd <<
1068 fpCommand = new G4UIcommand("/vis/scene/add <<
1069 fpCommand -> SetGuidance ("Adds line to cur <<
1070 G4bool omitable; <<
1071 G4UIparameter* parameter; <<
1072 parameter = new G4UIparameter ("x1", 'd', o <<
1073 fpCommand -> SetParameter (parameter); <<
1074 parameter = new G4UIparameter ("y1", 'd', o <<
1075 fpCommand -> SetParameter (parameter); <<
1076 parameter = new G4UIparameter ("z1", 'd', o <<
1077 fpCommand -> SetParameter (parameter); <<
1078 parameter = new G4UIparameter ("x2", 'd', o <<
1079 fpCommand -> SetParameter (parameter); <<
1080 parameter = new G4UIparameter ("y2", 'd', o <<
1081 fpCommand -> SetParameter (parameter); <<
1082 parameter = new G4UIparameter ("z2", 'd', o <<
1083 fpCommand -> SetParameter (parameter); <<
1084 parameter = new G4UIparameter ("unit", 's' <<
1085 parameter->SetDefaultValue ("m"); <<
1086 fpCommand->SetParameter (parameter); <<
1087 } <<
1088 <<
1089 G4VisCommandSceneAddLine::~G4VisCommandSceneA <<
1090 delete fpCommand; <<
1091 } <<
1092 <<
1093 G4String G4VisCommandSceneAddLine::GetCurrent <<
1094 return ""; <<
1095 } <<
1096 <<
1097 void G4VisCommandSceneAddLine::SetNewValue (G <<
1098 { <<
1099 G4VisManager::Verbosity verbosity = fpVisMa <<
1100 G4bool warn(verbosity >= G4VisManager::warn <<
1101 <<
1102 G4Scene* pScene = fpVisManager->GetCurrentS <<
1103 if (!pScene) { <<
1104 if (verbosity >= G4VisManager::errors) { <<
1105 G4warn << "ERROR: No current scene. Pl <<
1106 } <<
1107 return; <<
1108 } <<
1109 <<
1110 G4String unitString; <<
1111 G4double x1, y1, z1, x2, y2, z2; <<
1112 std::istringstream is(newValue); <<
1113 is >> x1 >> y1 >> z1 >> x2 >> y2 >> z2 >> u <<
1114 G4double unit = G4UIcommand::ValueOf(unitSt <<
1115 x1 *= unit; y1 *= unit; z1 *= unit; <<
1116 x2 *= unit; y2 *= unit; z2 *= unit; <<
1117 <<
1118 Line* line = new Line(x1, y1, z1, x2, y2, z <<
1119 fCurrentLineWidth, fCurrentColour); <<
1120 G4VModel* model = <<
1121 new G4CallbackModel<G4VisCommandSceneAddL <<
1122 model->SetType("Line"); <<
1123 model->SetGlobalTag("Line"); <<
1124 model->SetGlobalDescription("Line: " + newV <<
1125 const G4String& currentSceneName = pScene - <<
1126 G4bool successful = pScene -> AddRunDuratio <<
1127 if (successful) { <<
1128 if (verbosity >= G4VisManager::confirmati <<
1129 G4cout << "Line has been added to scene <<
1130 << currentSceneName << "\"." <<
1131 << G4endl; <<
1132 } <<
1133 } <<
1134 else G4VisCommandsSceneAddUnsuccessful(verb <<
1135 <<
1136 CheckSceneAndNotifyHandlers (pScene); <<
1137 } <<
1138 <<
1139 G4VisCommandSceneAddLine::Line::Line <<
1140 (G4double x1, G4double y1, G4double z1, <<
1141 G4double x2, G4double y2, G4double z2, <<
1142 G4double width, const G4Colour& colour): <<
1143 fWidth(width), fColour(colour) <<
1144 { <<
1145 fPolyline.push_back(G4Point3D(x1,y1,z1)); <<
1146 fPolyline.push_back(G4Point3D(x2,y2,z2)); <<
1147 G4VisAttributes va; <<
1148 va.SetLineWidth(fWidth); <<
1149 va.SetColour(fColour); <<
1150 fPolyline.SetVisAttributes(va); <<
1151 } <<
1152 <<
1153 void G4VisCommandSceneAddLine::Line::operator <<
1154 (G4VGraphicsScene& sceneHandler, const G4Mo <<
1155 { <<
1156 sceneHandler.BeginPrimitives(); <<
1157 sceneHandler.AddPrimitive(fPolyline); <<
1158 sceneHandler.EndPrimitives(); <<
1159 } <<
1160 <<
1161 ////////////// /vis/scene/add/line2D //////// <<
1162 <<
1163 G4VisCommandSceneAddLine2D::G4VisCommandScene <<
1164 fpCommand = new G4UIcommand("/vis/scene/add <<
1165 fpCommand -> SetGuidance ("Adds 2D line to <<
1166 fpCommand -> SetGuidance ("x,y in range [-1 <<
1167 G4bool omitable; <<
1168 G4UIparameter* parameter; <<
1169 parameter = new G4UIparameter ("x1", 'd', o <<
1170 fpCommand -> SetParameter (parameter); <<
1171 parameter = new G4UIparameter ("y1", 'd', o <<
1172 fpCommand -> SetParameter (parameter); <<
1173 parameter = new G4UIparameter ("x2", 'd', o <<
1174 fpCommand -> SetParameter (parameter); <<
1175 parameter = new G4UIparameter ("y2", 'd', o <<
1176 fpCommand -> SetParameter (parameter); <<
1177 } <<
1178 <<
1179 G4VisCommandSceneAddLine2D::~G4VisCommandScen <<
1180 delete fpCommand; <<
1181 } <<
1182 <<
1183 G4String G4VisCommandSceneAddLine2D::GetCurre <<
1184 return ""; <<
1185 } <<
1186 <<
1187 void G4VisCommandSceneAddLine2D::SetNewValue <<
1188 { <<
1189 G4VisManager::Verbosity verbosity = fpVisMa <<
1190 G4bool warn(verbosity >= G4VisManager::warn <<
1191 <<
1192 G4Scene* pScene = fpVisManager->GetCurrentS <<
1193 if (!pScene) { <<
1194 if (verbosity >= G4VisManager::errors) { <<
1195 G4warn << "ERROR: No current scene. Pl <<
1196 } <<
1197 return; <<
1198 } <<
1199 <<
1200 G4double x1, y1, x2, y2; <<
1201 std::istringstream is(newValue); <<
1202 is >> x1 >> y1 >> x2 >> y2; <<
1203 <<
1204 Line2D* line2D = new Line2D <<
1205 (x1, y1, x2, y2, fCurrentLineWidth, fCurr <<
1206 G4VModel* model = <<
1207 new G4CallbackModel<G4VisCommandSceneAddL <<
1208 model->SetType("Line2D"); <<
1209 model->SetGlobalTag("Line2D"); <<
1210 model->SetGlobalDescription("Line2D: " + ne <<
1211 const G4String& currentSceneName = pScene - <<
1212 G4bool successful = pScene -> AddRunDuratio <<
1213 if (successful) { <<
1214 if (verbosity >= G4VisManager::confirmati <<
1215 G4cout << "A 2D line has been added to <<
1216 << currentSceneName << "\"." <<
1217 << G4endl; <<
1218 } <<
1219 } <<
1220 else G4VisCommandsSceneAddUnsuccessful(verb <<
1221 <<
1222 CheckSceneAndNotifyHandlers (pScene); <<
1223 } <<
1224 <<
1225 G4VisCommandSceneAddLine2D::Line2D::Line2D <<
1226 (G4double x1, G4double y1, <<
1227 G4double x2, G4double y2, <<
1228 G4double width, const G4Colour& colour): <<
1229 fWidth(width), fColour(colour) <<
1230 { <<
1231 fPolyline.push_back(G4Point3D(x1,y1,0)); <<
1232 fPolyline.push_back(G4Point3D(x2,y2,0)); <<
1233 G4VisAttributes va; <<
1234 va.SetLineWidth(fWidth); <<
1235 va.SetColour(fColour); <<
1236 fPolyline.SetVisAttributes(va); <<
1237 } <<
1238 <<
1239 void G4VisCommandSceneAddLine2D::Line2D::oper <<
1240 (G4VGraphicsScene& sceneHandler, const G4Mo <<
1241 { <<
1242 sceneHandler.BeginPrimitives2D(); <<
1243 sceneHandler.AddPrimitive(fPolyline); <<
1244 sceneHandler.EndPrimitives2D(); <<
1245 } <<
1246 <<
1247 ////////////// /vis/scene/add/localAxes ///// <<
1248 <<
1249 G4VisCommandSceneAddLocalAxes::G4VisCommandSc <<
1250 G4bool omitable; <<
1251 fpCommand = new G4UIcommand ("/vis/scene/ad <<
1252 fpCommand -> SetGuidance <<
1253 ("Adds local axes to physical volume(s)."); <<
1254 G4UIparameter* parameter; <<
1255 parameter = new G4UIparameter ("physical-vo <<
1256 fpCommand -> SetParameter (parameter); 53 fpCommand -> SetParameter (parameter);
1257 parameter = new G4UIparameter ("copy-no", ' 54 parameter = new G4UIparameter ("copy-no", 'i', omitable = true);
1258 parameter -> SetGuidance ("If negative, mat << 55 parameter -> SetDefaultValue (0);
1259 parameter -> SetDefaultValue (-1); << 56 fpCommand -> SetParameter (parameter);
>> 57 parameter = new G4UIparameter ("depth", 'i', omitable = true);
>> 58 parameter -> SetDefaultValue (G4Scene::UNLIMITED);
1260 fpCommand -> SetParameter (parameter); 59 fpCommand -> SetParameter (parameter);
1261 } 60 }
1262 61
1263 G4VisCommandSceneAddLocalAxes::~G4VisCommandS << 62 G4VisCommandSceneAddVolume::~G4VisCommandSceneAddVolume () {
1264 delete fpCommand; 63 delete fpCommand;
1265 } 64 }
1266 65
1267 G4String G4VisCommandSceneAddLocalAxes::GetCu << 66 G4String G4VisCommandSceneAddVolume::GetCurrentValue (G4UIcommand* command) {
1268 return "world 0 -1"; 67 return "world 0 -1";
1269 } 68 }
1270 69
1271 void G4VisCommandSceneAddLocalAxes::SetNewVal << 70 void G4VisCommandSceneAddVolume::SetNewValue (G4UIcommand* command,
1272 G4String newValue) { << 71 G4String newValue) {
1273 << 72 G4SceneList& sceneList = fpVisManager -> SetSceneList ();
1274 G4VisManager::Verbosity verbosity = fpVisMa << 73 if (sceneList.isEmpty ()) {
1275 G4bool warn = verbosity >= G4VisManager::wa << 74 G4cout << "No scenes - please create one before adding anything."
1276 << 75 << G4endl;
1277 G4Scene* pScene = fpVisManager->GetCurrentS <<
1278 if (!pScene) { <<
1279 if (verbosity >= G4VisManager::errors) { <<
1280 G4warn << "ERROR: No current scene. Pl <<
1281 } <<
1282 return; 76 return;
1283 } 77 }
1284 78
1285 G4String name; 79 G4String name;
1286 G4int copyNo; 80 G4int copyNo;
1287 std::istringstream is (newValue); << 81 G4int requestedDepthOfDescent;
1288 is >> name >> copyNo; << 82 const char* s = newValue;
1289 << 83 G4std::istrstream is ((char*)s);
1290 std::vector<G4PhysicalVolumesSearchScene::F << 84 is >> name >> copyNo >> requestedDepthOfDescent;
>> 85 G4VPhysicalVolume* world =
>> 86 G4TransportationManager::GetTransportationManager ()
>> 87 -> GetNavigatorForTracking () -> GetWorldVolume ();
>> 88 G4PhysicalVolumeModel* model = 0;
>> 89 G4VPhysicalVolume* foundVolume = 0;
>> 90 G4int foundDepth = 0;
1291 91
1292 // Search all worlds... << 92 if (name == "world") {
1293 G4TransportationManager* transportationMana << 93 if (world) {
1294 G4TransportationManager::GetTransportationM << 94 model = new G4PhysicalVolumeModel (world);
1295 std::vector<G4VPhysicalVolume*>::iterator i << 95 foundVolume = world;
1296 transportationManager->GetWorldsIterator(); << 96 }
1297 size_t nWorlds = transportationManager->Get << 97 else {
1298 for (size_t i = 0; i < nWorlds; ++i, ++iter << 98 G4cerr << "G4VisCommandSceneAddVolume::SetNewValue: *** ERROR ***"
1299 G4ModelingParameters mp; // Default - no << 99 << "\n No world - shouldn't happen if G4ApplicationState is"
1300 G4PhysicalVolumeModel searchModel << 100 << " being properly handled!!" << G4endl;
1301 (*iterWorld, <<
1302 G4PhysicalVolumeModel::UNLIMITED, <<
1303 G4Transform3D(), <<
1304 &mp, <<
1305 true); // Use full extent (avoids initi <<
1306 G4PhysicalVolumesSearchScene searchScene <<
1307 (&searchModel, name, copyNo); <<
1308 searchModel.DescribeYourselfTo (searchSce <<
1309 for (const auto& findings: searchScene.Ge <<
1310 findingsVector.push_back(findings); <<
1311 } 101 }
1312 } 102 }
1313 << 103 else {
1314 G4int id = 0; // To distinguish axes model << 104
1315 for (const auto& findings: findingsVector) << 105 // Create search scene, model and modeling parameters with
1316 << 106 // long-enough life...
1317 // Create axes model based on size and tr << 107 G4PhysicalVolumeSearchScene searchScene (name, copyNo);
1318 const auto& extent = findings.fpFoundPV-> << 108 G4PhysicalVolumeModel searchModel (world);
1319 const auto& transform = findings.fFoundOb << 109 G4ModelingParameters mp;
1320 << 110 searchModel.SetModelingParameters (&mp);
1321 const G4double lengthMax = extent.GetExte << 111
1322 const G4double intLog10LengthMax = std::f << 112 // Initiate search...
1323 G4double length = std::pow(10,intLog10Len << 113 searchModel.DescribeYourselfTo (searchScene);
1324 if (5.*length < lengthMax) length *= 5.; << 114
1325 else if (2.*length < lengthMax) length *= << 115 // OK, what have we got...?
1326 << 116 foundVolume = searchScene.GetFoundVolume ();
1327 const auto& axesModel = new G4AxesModel(0 << 117 const G4Transform3D&
1328 axesModel->SetGlobalTag("LocalAxesModel") << 118 transformation = searchScene.GetFoundTransformation ();
1329 std::ostringstream oss; oss << 119 foundDepth = searchScene.GetFoundDepth ();
1330 << "Local Axes for " << findings.fpFoundP << 120
1331 << ':' << findings.fFoundPVCopyNo << ':' << 121 if (foundVolume) {
1332 axesModel->SetGlobalDescription(oss.str() << 122 model = new G4PhysicalVolumeModel (foundVolume,
1333 // ...so add it to the scene. << 123 requestedDepthOfDescent,
1334 G4bool successful = pScene->AddRunDuratio << 124 transformation);
1335 if (successful) { << 125 }
1336 if (verbosity >= G4VisManager::confirma << 126 else {
1337 G4cout << "\"" << findings.fpFoundPV->GetNa << 127 G4cout << "Volume \"" << name << "\", copy no. " << copyNo
1338 << "\", copy no. " << findings.fFoundPVCopy << 128 << " not found." << G4endl;
1339 << ",\n found in searched volume \"" <<
1340 << findings.fpSearchPV->GetName() <<
1341 << "\" at depth " << findings.fFoundDepth <<
1342 << ",\n base path: \"" << findings.fFoundB <<
1343 << "\".\n Local axes have been added to sc <<
1344 << pScene->GetName() << "\"."; <<
1345 if (verbosity >= G4VisManager::parameters) <<
1346 G4cout << " With extent " << extent <<
1347 << "\n at " << transform.getRotation() <<
1348 << " " << transform.getTranslation(); <<
1349 } <<
1350 G4cout << G4endl; <<
1351 } <<
1352 } else { <<
1353 G4VisCommandsSceneAddUnsuccessful(verbo <<
1354 } 129 }
1355 } 130 }
1356 131
1357 if (findingsVector.empty()) { << 132 if (model) {
1358 if (verbosity >= G4VisManager::errors) { << 133 G4Scene* pScene = fpVisManager -> GetCurrentScene ();
1359 G4warn << "ERROR: Volume \"" << name << << 134 const G4String& currentSceneName = pScene -> GetName ();
1360 if (copyNo >= 0) { << 135 G4bool successful = pScene -> AddRunDurationModel (model);
1361 G4warn << ", copy no. " << copyNo << ","; << 136 UpdateVisManagerScene (currentSceneName);
1362 } << 137 if (successful) {
1363 G4warn << " not found." << G4endl; << 138 G4cout << "First occurrence of \"" << foundVolume -> GetName ()
>> 139 << "\", copy no. " << copyNo
>> 140 << ", found at depth " << foundDepth
>> 141 << ",\n with further requested depth of descent "
>> 142 << requestedDepthOfDescent
>> 143 << ", has been added to scene \"" << currentSceneName << "\""
>> 144 << G4endl;
1364 } 145 }
1365 G4VisCommandsSceneAddUnsuccessful(verbosi <<
1366 return; <<
1367 } 146 }
1368 <<
1369 CheckSceneAndNotifyHandlers(pScene); <<
1370 } 147 }
1371 148
1372 ////////////// /vis/scene/add/logicalVolume / << 149 ////////////// /vis/scene/add/logicalVolume ///////////////////////////////////////
1373 150
1374 G4VisCommandSceneAddLogicalVolume::G4VisComma 151 G4VisCommandSceneAddLogicalVolume::G4VisCommandSceneAddLogicalVolume () {
1375 G4bool omitable; 152 G4bool omitable;
1376 fpCommand = new G4UIcommand ("/vis/scene/ad 153 fpCommand = new G4UIcommand ("/vis/scene/add/logicalVolume", this);
1377 fpCommand -> SetGuidance ("Adds a logical v << 154 fpCommand -> AvailableForStates (Idle, GeomClosed);
>> 155 fpCommand -> SetGuidance
>> 156 ("/vis/scene/add/logicalVolume <logical-volume-name> [<depth-of-descending>]");
>> 157 fpCommand -> SetGuidance ("Adds a logical volume to the current scene.");
1378 fpCommand -> SetGuidance 158 fpCommand -> SetGuidance
1379 ("Shows boolean components (if any), voxels << 159 ("1st parameter: volume name.");
1380 "\n (if any), local axes and overlaps (if << 160 // fpCommand -> SetGuidance // Not implemented - should be in geom?
1381 "\n appropriate flag." << 161 // (" \"list\" to list all volumes.");
1382 "\n Note: voxels are not constructed unti << 162 fpCommand -> SetGuidance
1383 "\n \"/run/beamOn\". (For voxels without << 163 ("2nd parameter: depth of descending geometry hierarchy (default 1).");
1384 G4UIparameter* parameter; 164 G4UIparameter* parameter;
1385 parameter = new G4UIparameter ("logical-vol << 165 parameter = new G4UIparameter ("volume", 's', omitable = false);
1386 fpCommand -> SetParameter (parameter); 166 fpCommand -> SetParameter (parameter);
1387 parameter = new G4UIparameter ("depth-of-de << 167 parameter = new G4UIparameter ("depth", 'i', omitable = true);
1388 parameter -> SetGuidance ("Depth of descent <<
1389 parameter -> SetDefaultValue (1); 168 parameter -> SetDefaultValue (1);
1390 fpCommand -> SetParameter (parameter); 169 fpCommand -> SetParameter (parameter);
1391 parameter = new G4UIparameter ("booleans-fl <<
1392 parameter -> SetDefaultValue (true); <<
1393 fpCommand -> SetParameter (parameter); <<
1394 parameter = new G4UIparameter ("voxels-flag <<
1395 parameter -> SetDefaultValue (true); <<
1396 fpCommand -> SetParameter (parameter); <<
1397 parameter = new G4UIparameter ("readout-fla <<
1398 parameter -> SetDefaultValue (true); <<
1399 fpCommand -> SetParameter (parameter); <<
1400 parameter = new G4UIparameter ("axes-flag", <<
1401 parameter -> SetDefaultValue (true); <<
1402 parameter -> SetGuidance ("Set \"false\" to <<
1403 fpCommand -> SetParameter (parameter); <<
1404 parameter = new G4UIparameter("check-overla <<
1405 parameter->SetDefaultValue(true); <<
1406 parameter -> SetGuidance ("Set \"false\" to <<
1407 fpCommand->SetParameter(parameter); <<
1408 } 170 }
1409 171
1410 G4VisCommandSceneAddLogicalVolume::~G4VisComm 172 G4VisCommandSceneAddLogicalVolume::~G4VisCommandSceneAddLogicalVolume () {
1411 delete fpCommand; 173 delete fpCommand;
1412 } 174 }
1413 175
1414 G4String G4VisCommandSceneAddLogicalVolume::G 176 G4String G4VisCommandSceneAddLogicalVolume::GetCurrentValue (G4UIcommand*) {
1415 return ""; 177 return "";
1416 } 178 }
1417 179
1418 void G4VisCommandSceneAddLogicalVolume::SetNe << 180 void G4VisCommandSceneAddLogicalVolume::SetNewValue (G4UIcommand* command,
1419 G4String newValue) { 181 G4String newValue) {
1420 << 182 G4SceneList& sceneList = fpVisManager -> SetSceneList ();
1421 G4VisManager::Verbosity verbosity = fpVisMa << 183 if (sceneList.isEmpty ()) {
1422 G4bool warn(verbosity >= G4VisManager::warn << 184 G4cout << "No scenes - please create one before adding anything."
1423 << 185 << G4endl;
1424 G4Scene* pScene = fpVisManager->GetCurrentS <<
1425 if (!pScene) { <<
1426 if (verbosity >= G4VisManager::errors) { <<
1427 G4warn << "ERROR: No current scene. Pl <<
1428 } <<
1429 return; 186 return;
1430 } 187 }
1431 188
1432 G4String name; 189 G4String name;
1433 G4int requestedDepthOfDescent; 190 G4int requestedDepthOfDescent;
1434 G4String booleansString, voxelsString, read << 191 const char* s = newValue;
1435 G4String overlapString; << 192 G4std::istrstream is ((char*)s);
1436 std::istringstream is (newValue); << 193 is >> name >> requestedDepthOfDescent;
1437 is >> name >> requestedDepthOfDescent <<
1438 >> booleansString >> voxelsString >> re <<
1439 >> overlapString; <<
1440 G4bool booleans = G4UIcommand::ConvertToBoo <<
1441 G4bool voxels = G4UIcommand::ConvertToBool( <<
1442 G4bool readout = G4UIcommand::ConvertToBool <<
1443 G4bool axes = G4UIcommand::ConvertToBool(ax <<
1444 G4bool checkOverlaps = G4UIcommand::Convert <<
1445 194
1446 G4LogicalVolumeStore *pLVStore = G4LogicalV 195 G4LogicalVolumeStore *pLVStore = G4LogicalVolumeStore::GetInstance();
1447 G4LogicalVolume* pLV = nullptr; << 196 int nLV = pLVStore -> entries ();
1448 pLV = pLVStore->GetVolume(name); << 197 int iLV;
1449 if (pLV == nullptr) return; // Volume not << 198 G4LogicalVolume* pLV;
1450 << 199 for (iLV = 0; iLV < nLV; iLV++ ) {
1451 const std::vector<G4Scene::Model>& rdModelL << 200 pLV = (*pLVStore) [iLV];
1452 pScene -> GetRunDurationModelList(); << 201 if (pLV -> GetName () == name) break;
1453 std::vector<G4Scene::Model>::const_iterator << 202 }
1454 for (i = rdModelList.begin(); i != rdModelL << 203 if (iLV == nLV) {
1455 if (i->fpModel->GetGlobalDescription().fi << 204 G4cout << "Logical volume " << name
1456 } << 205 << " not found in logical volume Store." << G4endl;
1457 if (i != rdModelList.end()) { <<
1458 if (verbosity >= G4VisManager::errors) { <<
1459 G4warn << "There is already a volume, \ <<
1460 << i->fpModel->GetGlobalDescript <<
1461 << "\",\n in the run-duration mo <<
1462 << pScene -> GetName() <<
1463 << "\".\n Your logical volume mu <<
1464 << "\n Create a new scene and try agai <<
1465 << "\n /vis/specify " << name <<
1466 << "\n or" <<
1467 << "\n /vis/scene/create" <<
1468 << "\n /vis/scene/add/logicalVolume " <<
1469 << "\n /vis/sceneHandler/attach" <<
1470 << "\n (and also, if necessary, /vis/v <<
1471 << G4endl; <<
1472 } <<
1473 return; 206 return;
1474 } 207 }
1475 208
1476 G4LogicalVolumeModel* model = new G4Logical << 209 G4VModel* model = new G4LogicalVolumeModel (pLV, requestedDepthOfDescent);
1477 (pLV, requestedDepthOfDescent, booleans, << 210 G4Scene* pScene = fpVisManager -> GetCurrentScene ();
1478 const G4String& currentSceneName = pScene - << 211 const G4String& currentSceneName = pScene -> GetName ();
1479 G4bool successful = pScene -> AddRunDuratio << 212 G4bool succesful = pScene -> AddRunDurationModel (model);
1480 << 213 UpdateVisManagerScene (currentSceneName);
1481 if (successful) { << 214 if (succesful) {
1482 << 215 G4cout << "Logical volume \"" << pLV -> GetName ()
1483 G4bool axesSuccessful = false; << 216 << " with requested depth of descent "
1484 if (axes) { << 217 << requestedDepthOfDescent
1485 const G4double radius = model->GetExten << 218 << ",\n has been added to scene \"" << currentSceneName << "\""
1486 const G4double axisLengthMax = radius / << 219 << G4endl;
1487 const G4double intLog10Length = std::fl <<
1488 G4double axisLength = std::pow(10,intLo <<
1489 if (5.*axisLength < axisLengthMax) axis <<
1490 else if (2.*axisLength < axisLengthMax) <<
1491 const G4double axisWidth = axisLength / <<
1492 G4VModel* axesModel = new G4AxesModel(0 <<
1493 axesSuccessful = pScene -> AddRunDurati <<
1494 } <<
1495 <<
1496 // if (verbosity >= G4VisManager::warnings <<
1497 // const std::map<G4String,G4AttDef>* at <<
1498 // std::vector<G4AttValue>* attValues = <<
1499 // G4warn << G4AttCheck(attValues, attDe <<
1500 // delete attValues; <<
1501 // } <<
1502 <<
1503 if (verbosity >= G4VisManager::confirmati <<
1504 G4cout << "Logical volume \"" << pLV -> <<
1505 << "\" with requested depth of descent <<
1506 << requestedDepthOfDescent <<
1507 << ",\n with"; <<
1508 if (!booleans) G4cout << "out"; <<
1509 G4cout << " boolean components, with"; <<
1510 if (!voxels) G4cout << "out"; <<
1511 G4cout << " voxels,\n with"; <<
1512 if (!readout) G4cout << "out"; <<
1513 G4cout << " readout geometry and with"; <<
1514 if (!checkOverlaps) G4cout << "out"; <<
1515 G4cout << " overlap checking" <<
1516 << "\n has been added to scene \"" << <<
1517 if (axes) { <<
1518 if (axesSuccessful) { <<
1519 G4cout << <<
1520 "\n Axes have also been added at t <<
1521 } else { <<
1522 G4cout << <<
1523 "\n Axes have not been added for s <<
1524 } <<
1525 } <<
1526 G4cout << G4endl; <<
1527 } <<
1528 } <<
1529 else { <<
1530 G4VisCommandsSceneAddUnsuccessful(verbosi <<
1531 return; <<
1532 } <<
1533 <<
1534 CheckSceneAndNotifyHandlers (pScene); <<
1535 } <<
1536 <<
1537 <<
1538 ////////////// /vis/scene/add/logo ////////// <<
1539 <<
1540 G4VisCommandSceneAddLogo::G4VisCommandSceneAd <<
1541 G4bool omitable; <<
1542 fpCommand = new G4UIcommand ("/vis/scene/ad <<
1543 fpCommand -> SetGuidance ("Adds a G4 logo t <<
1544 fpCommand -> SetGuidance <<
1545 ("If \"unit\" is \"auto\", height is roughl <<
1546 fpCommand -> SetGuidance <<
1547 ("\"direction\" is that of outward-facing n <<
1548 "\nIf \"direction\" is \"auto\", logo face <<
1549 fpCommand -> SetGuidance <<
1550 ("\nIf \"placement\" is \"auto\", logo is p <<
1551 "\n when viewed from logo direction."); <<
1552 G4UIparameter* parameter; <<
1553 parameter = new G4UIparameter ("height", 'd <<
1554 parameter->SetDefaultValue (1.); <<
1555 fpCommand->SetParameter (parameter); <<
1556 parameter = new G4UIparameter ("unit", 's' <<
1557 parameter->SetDefaultValue ("auto"); <<
1558 fpCommand->SetParameter (parameter); <<
1559 parameter = new G4UIparameter ("direction" <<
1560 parameter->SetGuidance ("auto|[-]x|[-]y|[-] <<
1561 parameter->SetDefaultValue ("auto"); <<
1562 fpCommand->SetParameter (parameter); <<
1563 parameter = new G4UIparameter ("red", 'd', <<
1564 parameter->SetDefaultValue (0.); <<
1565 fpCommand->SetParameter (parameter); <<
1566 parameter = new G4UIparameter ("green", 'd <<
1567 parameter->SetDefaultValue (1.); <<
1568 fpCommand->SetParameter (parameter); <<
1569 parameter = new G4UIparameter ("blue", 'd' <<
1570 parameter->SetDefaultValue (0.); <<
1571 fpCommand->SetParameter (parameter); <<
1572 parameter = new G4UIparameter ("placement" <<
1573 parameter -> SetParameterCandidates("auto m <<
1574 parameter->SetDefaultValue ("auto"); <<
1575 fpCommand->SetParameter (parameter); <<
1576 parameter = new G4UIparameter ("xmid", 'd' <<
1577 parameter->SetDefaultValue (0.); <<
1578 fpCommand->SetParameter (parameter); <<
1579 parameter = new G4UIparameter ("ymid", 'd' <<
1580 parameter->SetDefaultValue (0.); <<
1581 fpCommand->SetParameter (parameter); <<
1582 parameter = new G4UIparameter ("zmid", 'd' <<
1583 parameter->SetDefaultValue (0.); <<
1584 fpCommand->SetParameter (parameter); <<
1585 parameter = new G4UIparameter ("unit", 's' <<
1586 parameter->SetDefaultValue ("m"); <<
1587 fpCommand->SetParameter (parameter); <<
1588 } <<
1589 <<
1590 G4VisCommandSceneAddLogo::~G4VisCommandSceneA <<
1591 delete fpCommand; <<
1592 } <<
1593 <<
1594 G4String G4VisCommandSceneAddLogo::GetCurrent <<
1595 return ""; <<
1596 } <<
1597 <<
1598 void G4VisCommandSceneAddLogo::SetNewValue (G <<
1599 <<
1600 G4VisManager::Verbosity verbosity = fpVisMa <<
1601 G4bool warn = verbosity >= G4VisManager::wa <<
1602 <<
1603 G4Scene* pScene = fpVisManager->GetCurrentS <<
1604 if (!pScene) { <<
1605 if (verbosity >= G4VisManager::errors) { <<
1606 G4warn << "ERROR: No current scene. Pl <<
1607 } <<
1608 return; <<
1609 } else { <<
1610 if (pScene->GetExtent().GetExtentRadius() <<
1611 if (verbosity >= G4VisManager::errors) <<
1612 G4warn <<
1613 << "ERROR: Scene has no extent. Add volumes <<
1614 << G4endl; <<
1615 } <<
1616 return; <<
1617 } <<
1618 } <<
1619 <<
1620 G4VViewer* pViewer = fpVisManager->GetCurre <<
1621 if (!pViewer) { <<
1622 if (verbosity >= G4VisManager::errors) { <<
1623 G4warn << <<
1624 "ERROR: G4VisCommandSceneAddLogo::SetNewVal <<
1625 "\n Auto direction needs a viewer." <<
1626 << G4endl; <<
1627 } <<
1628 return; <<
1629 } <<
1630 <<
1631 G4double userHeight, red, green, blue, xmid <<
1632 G4String userHeightUnit, direction, placeme <<
1633 std::istringstream is (newValue); <<
1634 is >> userHeight >> userHeightUnit >> direc <<
1635 >> red >> green >> blue <<
1636 >> placement <<
1637 >> xmid >> ymid >> zmid >> positionUnit; <<
1638 <<
1639 G4double height = userHeight; <<
1640 const G4VisExtent& sceneExtent = pScene->Ge <<
1641 if (userHeightUnit == "auto") { <<
1642 height *= 0.2 * sceneExtent.GetExtentRadi <<
1643 } else { <<
1644 height *= G4UIcommand::ValueOf(userHeight <<
1645 } <<
1646 <<
1647 G4double unit = G4UIcommand::ValueOf(positi <<
1648 xmid *= unit; ymid *= unit; zmid *= unit; <<
1649 <<
1650 Direction logoDirection = X; // Initialise <<
1651 if (direction == "auto") { <<
1652 // Take cue from viewer <<
1653 const G4Vector3D& vp = <<
1654 pViewer->GetViewParameters().GetViewpoi <<
1655 if (vp.x() > vp.y() && vp.x() > vp.z()) l <<
1656 else if (vp.x() < vp.y() && vp.x() < vp.z <<
1657 else if (vp.y() > vp.x() && vp.y() > vp.z <<
1658 else if (vp.y() < vp.x() && vp.y() < vp.z <<
1659 else if (vp.z() > vp.x() && vp.z() > vp.y <<
1660 else if (vp.z() < vp.x() && vp.z() < vp.y <<
1661 } <<
1662 else if (direction[0] == 'x') logoDirection <<
1663 else if (direction[0] == 'y') logoDirection <<
1664 else if (direction[0] == 'z') logoDirection <<
1665 else if (direction[0] == '-') { <<
1666 if (direction[1] == 'x') logoDirection = <<
1667 else if (direction[1] == 'y') logoDirecti <<
1668 else if (direction[1] == 'z') logoDirecti <<
1669 } else { <<
1670 if (verbosity >= G4VisManager::errors) { <<
1671 G4warn << "ERROR: Unrecogniseed directi <<
1672 << direction << "\"." << G4endl; <<
1673 return; <<
1674 } <<
1675 } <<
1676 <<
1677 G4bool autoPlacing = false; if (placement = <<
1678 // Parameters read and interpreted. <<
1679 <<
1680 // Current scene extent <<
1681 const G4double xmin = sceneExtent.GetXmin() <<
1682 const G4double xmax = sceneExtent.GetXmax() <<
1683 const G4double ymin = sceneExtent.GetYmin() <<
1684 const G4double ymax = sceneExtent.GetYmax() <<
1685 const G4double zmin = sceneExtent.GetZmin() <<
1686 const G4double zmax = sceneExtent.GetZmax() <<
1687 <<
1688 // Test existing extent and issue warnings. <<
1689 G4bool worried = false; <<
1690 if (sceneExtent.GetExtentRadius() == 0) { <<
1691 worried = true; <<
1692 if (verbosity >= G4VisManager::warnings) <<
1693 G4warn << <<
1694 "WARNING: Existing scene does not yet have <<
1695 "\n Maybe you have not yet added any geome <<
1696 << G4endl; <<
1697 } <<
1698 } <<
1699 <<
1700 // Useful constants, etc... <<
1701 const G4double halfHeight(height / 2.); <<
1702 const G4double comfort(0.01); // 0.15 seem <<
1703 const G4double freeHeightFraction (1. + 2. <<
1704 <<
1705 // Test existing scene for room... <<
1706 G4bool room = true; <<
1707 switch (logoDirection) { <<
1708 case X: <<
1709 case minusX: <<
1710 if (freeHeightFraction * (xmax - xmin) < <<
1711 break; <<
1712 case Y: <<
1713 case minusY: <<
1714 if (freeHeightFraction * (ymax - ymin) < <<
1715 break; <<
1716 case Z: <<
1717 case minusZ: <<
1718 if (freeHeightFraction * (zmax - zmin) < <<
1719 break; <<
1720 } <<
1721 if (!room) { <<
1722 worried = true; <<
1723 if (verbosity >= G4VisManager::warnings) <<
1724 G4warn << <<
1725 "WARNING: Not enough room in existing scene <<
1726 << G4endl; <<
1727 } <<
1728 } <<
1729 if (worried) { <<
1730 if (verbosity >= G4VisManager::warnings) <<
1731 G4warn << <<
1732 "WARNING: The logo you have asked for is bi <<
1733 "\n scene. Maybe you have added it too so <<
1734 "\n you add the logo last so that it can b <<
1735 "\n so as not to be obscured by any existi <<
1736 "\n view parameters can be correctly recal <<
1737 << G4endl; <<
1738 } <<
1739 } <<
1740 <<
1741 G4double sxmid(xmid), symid(ymid), szmid(zm <<
1742 if (autoPlacing) { <<
1743 // Aim to place at bottom right of screen <<
1744 // Give some comfort zone. <<
1745 const G4double xComfort = comfort * (xmax <<
1746 const G4double yComfort = comfort * (ymax <<
1747 const G4double zComfort = comfort * (zmax <<
1748 switch (logoDirection) { <<
1749 case X: // y-axis up, z-axis to left? <<
1750 sxmid = xmax + halfHeight + xComfort; <<
1751 symid = ymin - yComfort; <<
1752 szmid = zmin - zComfort; <<
1753 break; <<
1754 case minusX: // y-axis up, z-axis to rig <<
1755 sxmid = xmin - halfHeight - xComfort; <<
1756 symid = ymin - yComfort; <<
1757 szmid = zmax + zComfort; <<
1758 break; <<
1759 case Y: // z-axis up, x-axis to left? <<
1760 sxmid = xmin - xComfort; <<
1761 symid = ymax + halfHeight + yComfort; <<
1762 szmid = zmin - zComfort; <<
1763 break; <<
1764 case minusY: // z-axis up, x-axis to rig <<
1765 sxmid = xmax + xComfort; <<
1766 symid = ymin - halfHeight - yComfort; <<
1767 szmid = zmin - zComfort; <<
1768 break; <<
1769 case Z: // y-axis up, x-axis to right? <<
1770 sxmid = xmax + xComfort; <<
1771 symid = ymin - yComfort; <<
1772 szmid = zmax + halfHeight + zComfort; <<
1773 break; <<
1774 case minusZ: // y-axis up, x-axis to lef <<
1775 sxmid = xmin - xComfort; <<
1776 symid = ymin - yComfort; <<
1777 szmid = zmin - halfHeight - zComfort; <<
1778 break; <<
1779 } <<
1780 } <<
1781 <<
1782 G4Transform3D transform; <<
1783 switch (logoDirection) { <<
1784 case X: // y-axis up, z-axis to left? <<
1785 transform = G4RotateY3D(halfpi); <<
1786 break; <<
1787 case minusX: // y-axis up, z-axis to right <<
1788 transform = G4RotateY3D(-halfpi); <<
1789 break; <<
1790 case Y: // z-axis up, x-axis to left? <<
1791 transform = G4RotateX3D(-halfpi) * G4Rota <<
1792 break; <<
1793 case minusY: // z-axis up, x-axis to right <<
1794 transform = G4RotateX3D(halfpi); <<
1795 break; <<
1796 case Z: // y-axis up, x-axis to right? <<
1797 // No transformation required. <<
1798 break; <<
1799 case minusZ: // y-axis up, x-axis to left? <<
1800 transform = G4RotateY3D(pi); <<
1801 break; <<
1802 } <<
1803 transform = G4Translate3D(sxmid,symid,szmid <<
1804 <<
1805 G4VisAttributes visAtts(G4Colour(red, green <<
1806 visAtts.SetForceSolid(true); // Alw <<
1807 <<
1808 G4Logo* logo = new G4Logo(height,visAtts,tr <<
1809 G4VModel* model = <<
1810 new G4CallbackModel<G4VisCommandSceneAddL <<
1811 model->SetType("G4Logo"); <<
1812 model->SetGlobalTag("G4Logo"); <<
1813 model->SetGlobalDescription("G4Logo: " + ne <<
1814 G4double& h = height; <<
1815 G4double h2 = h/2.; <<
1816 G4VisExtent extent(-h,h,-h2,h2,-h2,h2); <<
1817 model->SetExtent(extent.Transform(transform <<
1818 // This extent gets "added" to existing sce <<
1819 // AddRunDurationModel below. <<
1820 const G4String& currentSceneName = pScene - <<
1821 G4bool successful = pScene -> AddRunDuratio <<
1822 if (successful) { <<
1823 if (verbosity >= G4VisManager::confirmati <<
1824 G4cout << "G4 Logo of height " << userH <<
1825 << ", " << direction << "-direction, a <<
1826 << currentSceneName << "\""; <<
1827 if (verbosity >= G4VisManager::paramete <<
1828 G4cout << "\n with extent " << extent <<
1829 << "\n at " << transform.getRotatio <<
1830 << " " << transform.getTranslation( <<
1831 } <<
1832 G4cout << G4endl; <<
1833 } <<
1834 } 220 }
1835 else G4VisCommandsSceneAddUnsuccessful(verb <<
1836 <<
1837 CheckSceneAndNotifyHandlers (pScene); <<
1838 } 221 }
1839 222
1840 G4VisCommandSceneAddLogo::G4Logo::G4Logo <<
1841 (G4double height, const G4VisAttributes& visA <<
1842 { <<
1843 const G4double& h = height; <<
1844 const G4double h2 = 0.5 * h; // Half hei <<
1845 const G4double ri = 0.25 * h; // Inner ra <<
1846 const G4double ro = 0.5 * h; // Outer ra <<
1847 const G4double ro2 = 0.5 * ro; // Half out <<
1848 const G4double w = ro - ri; // Width. <<
1849 const G4double w2 = 0.5 * w; // Half wid <<
1850 const G4double d2 = 0.2 * h; // Half dep <<
1851 const G4double f1 = 0.05 * h; // left edg <<
1852 const G4double f2 = -0.3 * h; // bottom e <<
1853 const G4double e = 1.e-4 * h; // epsilon. <<
1854 const G4double xt = f1, yt = h2; // To <<
1855 const G4double xb = -h2, yb = f2 + w; // Bo <<
1856 const G4double dx = xt - xb, dy = yt - yb; <<
1857 const G4double angle = std::atan2(dy,dx); <<
1858 G4RotationMatrix rm; <<
1859 rm.rotateZ(angle*rad); <<
1860 const G4double d = std::sqrt(dx * dx + dy * <<
1861 const G4double ss = h; // Half height of s <<
1862 const G4double y8 = ss; // Choose y of subt <<
1863 const G4double x8 = ((-ss * d - dx * (yt - <<
1864 G4double y9 = ss; // Choose y of subtractor <<
1865 G4double x9 = ((-(ss - w) * d - dx * (yt - <<
1866 // But to get inner, we make a triangle tra <<
1867 const G4double xtr = ss - f1, ytr = -ss - f <<
1868 x9 += xtr; y9 += ytr; <<
1869 <<
1870 // The idea here is to create a polyhedron <<
1871 // this we use Geant4 geometry solids and m <<
1872 // Note that we do not need to keep the sol <<
1873 // which, of course, are deleted on leaving <<
1874 // is contrary to the usual requirement for <<
1875 // detector for which solids MUST be create <<
1876 // Finally we invoke CreatePolyhedron, whic <<
1877 // and returns a pointer. It is the user's <<
1878 // which is done in the destructor of this <<
1879 // created here, remain on the heap for the <<
1880 <<
1881 // G... <<
1882 G4Tubs tG("tG",ri,ro,d2,0.15*pi,1.85*pi); <<
1883 G4Box bG("bG",w2,ro2,d2); <<
1884 G4UnionSolid logoG("logoG",&tG,&bG,G4Transl <<
1885 // Create with these vis atts (force solid) <<
1886 G4Polyhedron::SetNumberOfRotationSteps <<
1887 (fpVisManager->GetCurrentViewer()->GetViewP <<
1888 fpG = logoG.CreatePolyhedron(); <<
1889 G4Polyhedron::ResetNumberOfRotationSteps () <<
1890 fpG->SetVisAttributes(visAtts); <<
1891 fpG->Transform(G4Translate3D(-0.55*h,0.,0.) <<
1892 fpG->Transform(transform); <<
1893 <<
1894 // 4... <<
1895 G4Box b1("b1",h2,h2,d2); <<
1896 G4Box bS("bS",ss,ss,d2+e); // Subtractor. <<
1897 G4Box bS2("bS2",ss,ss,d2+2.*e); // 2nd Sub <<
1898 G4SubtractionSolid s1("s1",&b1,&bS,G4Transl <<
1899 G4SubtractionSolid s2("s2",&s1,&bS,G4Transl <<
1900 G4SubtractionSolid s3("s3",&s2,&bS,G4Transl <<
1901 G4SubtractionSolid s4 <<
1902 ("s4",&s3,&bS,G4Transform3D(rm,G4ThreeVec <<
1903 G4SubtractionSolid s5 // Triangular hole <<
1904 ("s5",&bS,&bS2,G4Transform3D(rm,G4ThreeVe <<
1905 G4SubtractionSolid logo4("logo4",&s4,&s5,G4 <<
1906 fp4 = logo4.CreatePolyhedron(); <<
1907 /* Experiment with creating own polyhedron. <<
1908 int nNodes = 4; <<
1909 int nFaces = 4; <<
1910 double xyz[][3] = {{0,0,0},{1*m,0,0},{0,1*m <<
1911 int faces[][4] = {{1,3,2,0},{1,2,4,0},{1,4, <<
1912 fp4 = new G4Polyhedron(); <<
1913 fp4->createPolyhedron(nNodes,nFaces,xyz,fac <<
1914 */ <<
1915 fp4->SetVisAttributes(visAtts); <<
1916 fp4->Transform(G4Translate3D(0.55*h,0.,0.)) <<
1917 fp4->Transform(transform); <<
1918 } <<
1919 <<
1920 G4VisCommandSceneAddLogo::G4Logo::~G4Logo() { <<
1921 delete fpG; <<
1922 delete fp4; <<
1923 } <<
1924 223
1925 void G4VisCommandSceneAddLogo::G4Logo::operat << 224 ////////////// /vis/scene/add/ghosts ///////////////////////////////////////
1926 (G4VGraphicsScene& sceneHandler, const G4Mo <<
1927 sceneHandler.BeginPrimitives(); <<
1928 sceneHandler.AddPrimitive(*fpG); <<
1929 sceneHandler.AddPrimitive(*fp4); <<
1930 sceneHandler.EndPrimitives(); <<
1931 } <<
1932 <<
1933 ////////////// /vis/scene/add/logo2D //////// <<
1934 225
1935 G4VisCommandSceneAddLogo2D::G4VisCommandScene << 226 G4VisCommandSceneAddGhosts::G4VisCommandSceneAddGhosts () {
1936 G4bool omitable; 227 G4bool omitable;
1937 fpCommand = new G4UIcommand ("/vis/scene/ad << 228 fpCommand = new G4UIcmdWithAString ("/vis/scene/add/ghosts", this);
1938 fpCommand -> SetGuidance ("Adds 2D logo to << 229 fpCommand -> AvailableForStates (Idle, GeomClosed);
1939 G4UIparameter* parameter; <<
1940 parameter = new G4UIparameter ("size", 'i', <<
1941 parameter -> SetGuidance ("Screen size of t <<
1942 parameter -> SetDefaultValue (48); <<
1943 fpCommand -> SetParameter (parameter); <<
1944 parameter = new G4UIparameter ("x-position" <<
1945 parameter -> SetGuidance ("x screen positio <<
1946 parameter -> SetDefaultValue (-0.9); <<
1947 fpCommand -> SetParameter (parameter); <<
1948 parameter = new G4UIparameter ("y-position" <<
1949 parameter -> SetGuidance ("y screen positio <<
1950 parameter -> SetDefaultValue (-0.9); <<
1951 fpCommand -> SetParameter (parameter); <<
1952 parameter = new G4UIparameter ("layout", 's <<
1953 parameter -> SetGuidance ("Layout, i.e., ad <<
1954 parameter -> SetDefaultValue ("left"); <<
1955 fpCommand -> SetParameter (parameter); <<
1956 } <<
1957 <<
1958 G4VisCommandSceneAddLogo2D::~G4VisCommandScen <<
1959 delete fpCommand; <<
1960 } <<
1961 <<
1962 G4String G4VisCommandSceneAddLogo2D::GetCurre <<
1963 return ""; <<
1964 } <<
1965 <<
1966 void G4VisCommandSceneAddLogo2D::SetNewValue <<
1967 { <<
1968 G4VisManager::Verbosity verbosity = fpVisMa <<
1969 G4bool warn(verbosity >= G4VisManager::warn <<
1970 <<
1971 G4Scene* pScene = fpVisManager->GetCurrentS <<
1972 if (!pScene) { <<
1973 if (verbosity >= G4VisManager::errors) { <<
1974 G4warn << "ERROR: No current scene. Pl <<
1975 } <<
1976 return; <<
1977 } <<
1978 <<
1979 G4int size; <<
1980 G4double x, y; <<
1981 G4String layoutString; <<
1982 std::istringstream is(newValue); <<
1983 is >> size >> x >> y >> layoutString; <<
1984 G4Text::Layout layout = G4Text::right; <<
1985 if (layoutString[0] == 'l') layout = G4Text <<
1986 else if (layoutString[0] == 'c') layout = G <<
1987 else if (layoutString[0] == 'r') layout = G <<
1988 <<
1989 Logo2D* logo2D = new Logo2D(fpVisManager, s <<
1990 G4VModel* model = <<
1991 new G4CallbackModel<G4VisCommandSceneAddL <<
1992 model->SetType("G4Logo2D"); <<
1993 model->SetGlobalTag("G4Logo2D"); <<
1994 model->SetGlobalDescription("G4Logo2D: " + <<
1995 const G4String& currentSceneName = pScene - <<
1996 G4bool successful = pScene -> AddRunDuratio <<
1997 if (successful) { <<
1998 if (verbosity >= G4VisManager::confirmati <<
1999 G4cout << "2D logo has been added to sc <<
2000 << currentSceneName << "\"." <<
2001 << G4endl; <<
2002 } <<
2003 } <<
2004 else G4VisCommandsSceneAddUnsuccessful(verb <<
2005 <<
2006 CheckSceneAndNotifyHandlers (pScene); <<
2007 } <<
2008 <<
2009 void G4VisCommandSceneAddLogo2D::Logo2D::oper <<
2010 (G4VGraphicsScene& sceneHandler, const G4Mo <<
2011 { <<
2012 G4Text text("Geant4", G4Point3D(fX, fY, 0.) <<
2013 text.SetScreenSize(fSize); <<
2014 text.SetLayout(fLayout); <<
2015 G4VisAttributes textAtts(G4Colour::Brown()) <<
2016 text.SetVisAttributes(textAtts); <<
2017 sceneHandler.BeginPrimitives2D(); <<
2018 sceneHandler.AddPrimitive(text); <<
2019 sceneHandler.EndPrimitives2D(); <<
2020 } <<
2021 <<
2022 ////////////// /vis/scene/add/magneticField / <<
2023 <<
2024 G4VisCommandSceneAddMagneticField::G4VisComma <<
2025 fpCommand = new G4UIcommand ("/vis/scene/ad <<
2026 fpCommand -> SetGuidance 230 fpCommand -> SetGuidance
2027 ("Adds magnetic field representation to cur << 231 ("/vis/scene/add/ghosts [<particle-name>]");
2028 const G4UIcommandTree* tree = G4UImanager:: <<
2029 const G4UIcommand* addElecFieldCmd = tree-> <<
2030 // Pick up additional guidance from /vis/sc <<
2031 CopyGuidanceFrom(addElecFieldCmd,fpCommand, <<
2032 // Pick up parameters from /vis/scene/add/e <<
2033 CopyParametersFrom(addElecFieldCmd,fpComman <<
2034 } <<
2035 <<
2036 G4VisCommandSceneAddMagneticField::~G4VisComm <<
2037 delete fpCommand; <<
2038 } <<
2039 <<
2040 G4String G4VisCommandSceneAddMagneticField::G <<
2041 return ""; <<
2042 } <<
2043 <<
2044 void G4VisCommandSceneAddMagneticField::SetNe <<
2045 (G4UIcommand*, G4String newValue) { <<
2046 <<
2047 G4VisManager::Verbosity verbosity = fpVisMa <<
2048 G4bool warn(verbosity >= G4VisManager::warn <<
2049 <<
2050 G4Scene* pScene = fpVisManager->GetCurrentS <<
2051 if (!pScene) { <<
2052 if (verbosity >= G4VisManager::errors) { <<
2053 G4warn << "ERROR: No current scene. P <<
2054 } <<
2055 return; <<
2056 } <<
2057 <<
2058 G4int nDataPointsPerHalfScene; <<
2059 G4String representation; <<
2060 std::istringstream iss(newValue); <<
2061 iss >> nDataPointsPerHalfScene >> represent <<
2062 G4ElectricFieldModel::Representation <<
2063 modelRepresentation = G4ElectricFieldModel: <<
2064 if (representation == "lightArrow") { <<
2065 modelRepresentation = G4ElectricFieldMode <<
2066 } <<
2067 G4VModel* model; <<
2068 model = new G4MagneticFieldModel <<
2069 (nDataPointsPerHalfScene,modelRepresentatio <<
2070 fCurrentArrow3DLineSegmentsPerCircle, <<
2071 fCurrentExtentForField, <<
2072 fCurrrentPVFindingsForField); <<
2073 const G4String& currentSceneName = pScene - <<
2074 G4bool successful = pScene -> AddRunDuratio <<
2075 if (successful) { <<
2076 if (verbosity >= G4VisManager::confirmati <<
2077 G4cout <<
2078 << "Magnetic field, if any, will be dra <<
2079 << currentSceneName <<
2080 << "\"\n with " <<
2081 << nDataPointsPerHalfScene <<
2082 << " data points per half extent and wi <<
2083 << representation <<
2084 << '\"' <<
2085 << G4endl; <<
2086 } <<
2087 } <<
2088 else G4VisCommandsSceneAddUnsuccessful(verb <<
2089 <<
2090 CheckSceneAndNotifyHandlers (pScene); <<
2091 } <<
2092 <<
2093 ////////////// /vis/scene/add/psHits //////// <<
2094 <<
2095 G4VisCommandSceneAddPSHits::G4VisCommandScene <<
2096 G4bool omitable; <<
2097 fpCommand = new G4UIcmdWithAString ("/vis/s <<
2098 fpCommand -> SetGuidance 232 fpCommand -> SetGuidance
2099 ("Adds Primitive Scorer Hits (PSHits) to << 233 ("Adds ghost volumes (G4FlavoredParallelWorld) to the current scene.");
2100 fpCommand -> SetGuidance 234 fpCommand -> SetGuidance
2101 ("PSHits are drawn at end of run when the << 235 ("Selects by particle (default = \"all\").");
2102 "\nthey are added is current."); << 236 fpCommand -> SetParameterName ("particle", omitable = true);
2103 fpCommand -> SetGuidance <<
2104 ("Optional parameter specifies name of sc <<
2105 "\nscoring maps registered with the G4Sc <<
2106 fpCommand -> SetParameterName ("mapname", o <<
2107 fpCommand -> SetDefaultValue ("all"); 237 fpCommand -> SetDefaultValue ("all");
2108 } 238 }
2109 239
2110 G4VisCommandSceneAddPSHits::~G4VisCommandScen << 240 G4VisCommandSceneAddGhosts::~G4VisCommandSceneAddGhosts () {
2111 delete fpCommand; <<
2112 } <<
2113 <<
2114 G4String G4VisCommandSceneAddPSHits::GetCurre <<
2115 return ""; <<
2116 } <<
2117 <<
2118 void G4VisCommandSceneAddPSHits::SetNewValue <<
2119 (G4UIcommand*, G4String newValue) <<
2120 { <<
2121 G4VisManager::Verbosity verbosity = fpVisMa <<
2122 G4bool warn(verbosity >= G4VisManager::warn <<
2123 <<
2124 G4Scene* pScene = fpVisManager->GetCurrentS <<
2125 if (!pScene) { <<
2126 if (verbosity >= G4VisManager::errors) { <<
2127 G4warn << "ERROR: No current scene. Pl <<
2128 } <<
2129 return; <<
2130 } <<
2131 <<
2132 G4VModel* model = new G4PSHitsModel(newValu <<
2133 const G4String& currentSceneName = pScene - <<
2134 G4bool successful = pScene -> AddEndOfRunMo <<
2135 if (successful) { <<
2136 if (verbosity >= G4VisManager::confirmati <<
2137 if (newValue == "all") { <<
2138 G4cout << "All Primitive Scorer hits"; <<
2139 } else { <<
2140 G4cout << "Hits of Primitive Scorer \"" << <<
2141 } <<
2142 G4cout << " will be drawn at end of run <<
2143 << currentSceneName << "\"." <<
2144 << G4endl; <<
2145 } <<
2146 } <<
2147 else G4VisCommandsSceneAddUnsuccessful(verb <<
2148 <<
2149 CheckSceneAndNotifyHandlers (pScene); <<
2150 } <<
2151 <<
2152 ////////////// /vis/scene/add/scale ///////// <<
2153 <<
2154 G4VisCommandSceneAddScale::G4VisCommandSceneA <<
2155 G4bool omitable; <<
2156 fpCommand = new G4UIcommand ("/vis/scene/ad <<
2157 fpCommand -> SetGuidance <<
2158 ("Adds an annotated scale line to the curre <<
2159 fpCommand -> SetGuidance <<
2160 ("If \"unit\" is \"auto\", length is roughl <<
2161 fpCommand -> SetGuidance <<
2162 ("If \"direction\" is \"auto\", scale is ro <<
2163 fpCommand -> SetGuidance <<
2164 ("If \"placement\" is \"auto\", scale is pl <<
2165 "\n Otherwise placed at (xmid,ymid,zmid). <<
2166 fpCommand -> SetGuidance <<
2167 ("An annotated line in the specified direct <<
2168 "\nend. If autoPlacing is true it is requ <<
2169 "\nfront, right, bottom corner of the worl <<
2170 "\nthe existing bounding box/sphere so tha <<
2171 "\nobscure it. Otherwise it is required t <<
2172 "\n(xmid, ymid, zmid)." <<
2173 "\n" <<
2174 "\nThe auto placing algorithm is (approx): <<
2175 "\n x = xmin + (1 + comfort) * (xmax - xm <<
2176 "\n y = ymin - comfort * (ymax - ymin);" <<
2177 "\n z = zmin + (1 + comfort) * (zmax - zm <<
2178 "\n if direction == x then (x - length,y, <<
2179 "\n if direction == y then (x,y,z) to (x, <<
2180 "\n if direction == z then (x,y,z - lengt <<
2181 ); <<
2182 G4UIparameter* parameter; <<
2183 parameter = new G4UIparameter ("length", 'd <<
2184 parameter->SetDefaultValue (1.); <<
2185 fpCommand->SetParameter (parameter); <<
2186 parameter = new G4UIparameter ("unit", 's' <<
2187 parameter->SetDefaultValue ("auto"); <<
2188 fpCommand->SetParameter (parameter); <<
2189 parameter = new G4UIparameter ("direction" <<
2190 parameter->SetGuidance ("auto|x|y|z"); <<
2191 parameter->SetDefaultValue ("auto"); <<
2192 fpCommand->SetParameter (parameter); <<
2193 parameter = new G4UIparameter ("red", 'd', <<
2194 parameter->SetDefaultValue (1.); <<
2195 fpCommand->SetParameter (parameter); <<
2196 parameter = new G4UIparameter ("green", 'd <<
2197 parameter->SetDefaultValue (0.); <<
2198 fpCommand->SetParameter (parameter); <<
2199 parameter = new G4UIparameter ("blue", 'd' <<
2200 parameter->SetDefaultValue (0.); <<
2201 fpCommand->SetParameter (parameter); <<
2202 parameter = new G4UIparameter ("placement" <<
2203 parameter -> SetParameterCandidates("auto m <<
2204 parameter->SetDefaultValue ("auto"); <<
2205 fpCommand->SetParameter (parameter); <<
2206 parameter = new G4UIparameter ("xmid", 'd' <<
2207 parameter->SetDefaultValue (0.); <<
2208 fpCommand->SetParameter (parameter); <<
2209 parameter = new G4UIparameter ("ymid", 'd' <<
2210 parameter->SetDefaultValue (0.); <<
2211 fpCommand->SetParameter (parameter); <<
2212 parameter = new G4UIparameter ("zmid", 'd' <<
2213 parameter->SetDefaultValue (0.); <<
2214 fpCommand->SetParameter (parameter); <<
2215 parameter = new G4UIparameter ("unit", 's' <<
2216 parameter->SetDefaultValue ("m"); <<
2217 fpCommand->SetParameter (parameter); <<
2218 } <<
2219 <<
2220 G4VisCommandSceneAddScale::~G4VisCommandScene <<
2221 delete fpCommand; <<
2222 } <<
2223 <<
2224 G4String G4VisCommandSceneAddScale::GetCurren <<
2225 return ""; <<
2226 } <<
2227 <<
2228 void G4VisCommandSceneAddScale::SetNewValue ( <<
2229 <<
2230 G4VisManager::Verbosity verbosity = fpVisMa <<
2231 G4bool warn = verbosity >= G4VisManager::wa <<
2232 <<
2233 G4Scene* pScene = fpVisManager->GetCurrentS <<
2234 if (!pScene) { <<
2235 if (verbosity >= G4VisManager::errors) { <<
2236 G4warn << "ERROR: No current scene. Pl <<
2237 } <<
2238 return; <<
2239 } else { <<
2240 if (pScene->GetExtent().GetExtentRadius() <<
2241 if (verbosity >= G4VisManager::errors) <<
2242 G4warn <<
2243 << "ERROR: Scene has no extent. Add volumes <<
2244 << G4endl; <<
2245 } <<
2246 return; <<
2247 } <<
2248 } <<
2249 <<
2250 G4double userLength, red, green, blue, xmid <<
2251 G4String userLengthUnit, direction, placeme <<
2252 std::istringstream is (newValue); <<
2253 is >> userLength >> userLengthUnit >> direc <<
2254 >> red >> green >> blue <<
2255 >> placement <<
2256 >> xmid >> ymid >> zmid >> positionUnit; <<
2257 <<
2258 G4double length = userLength; <<
2259 const G4VisExtent& sceneExtent = pScene->Ge <<
2260 if (userLengthUnit == "auto") { <<
2261 const G4double lengthMax = 0.5 * sceneExt <<
2262 const G4double intLog10Length = std::floo <<
2263 length = std::pow(10,intLog10Length); <<
2264 if (5.*length < lengthMax) length *= 5.; <<
2265 else if (2.*length < lengthMax) length *= <<
2266 } else { <<
2267 length *= G4UIcommand::ValueOf(userLength <<
2268 } <<
2269 G4String annotation = G4BestUnit(length,"Le <<
2270 <<
2271 G4double unit = G4UIcommand::ValueOf(positi <<
2272 xmid *= unit; ymid *= unit; zmid *= unit; <<
2273 <<
2274 Scale::Direction scaleDirection (Scale::x); <<
2275 if (direction[0] == 'y') scaleDirection = S <<
2276 if (direction[0] == 'z') scaleDirection = S <<
2277 <<
2278 G4VViewer* pViewer = fpVisManager->GetCurre <<
2279 if (!pViewer) { <<
2280 if (verbosity >= G4VisManager::errors) { <<
2281 G4warn << <<
2282 "ERROR: G4VisCommandSceneAddScale::SetNewVa <<
2283 "\n Auto direction needs a viewer." <<
2284 << G4endl; <<
2285 } <<
2286 return; <<
2287 } <<
2288 <<
2289 const G4Vector3D& vp = <<
2290 pViewer->GetViewParameters().GetViewpoint <<
2291 const G4Vector3D& up = <<
2292 pViewer->GetViewParameters().GetUpVector( <<
2293 <<
2294 if (direction == "auto") { // Takes cue fr <<
2295 if (std::abs(vp.x()) > std::abs(vp.y()) & <<
2296 std::abs(vp.x()) > std::abs(vp.z())) { // <<
2297 if (std::abs(up.y()) > std::abs(up.z()) <<
2298 else scaleDirection = Scale::y; <<
2299 } <<
2300 else if (std::abs(vp.y()) > std::abs(vp.x <<
2301 std::abs(vp.y()) > std::abs(vp.z())) { <<
2302 if (std::abs(up.x()) > std::abs(up.z()) <<
2303 else scaleDirection = Scale::x; <<
2304 } <<
2305 else if (std::abs(vp.z()) > std::abs(vp.x <<
2306 std::abs(vp.z()) > std::abs(vp.y())) { <<
2307 if (std::abs(up.y()) > std::abs(up.x()) <<
2308 else scaleDirection = Scale::y; <<
2309 } <<
2310 } <<
2311 <<
2312 G4bool autoPlacing = false; if (placement = <<
2313 // Parameters read and interpreted. <<
2314 <<
2315 // Useful constants, etc... <<
2316 const G4double halfLength(length / 2.); <<
2317 const G4double comfort(0.01); // 0.15 seem <<
2318 const G4double freeLengthFraction (1. + 2. <<
2319 <<
2320 const G4double xmin = sceneExtent.GetXmin() <<
2321 const G4double xmax = sceneExtent.GetXmax() <<
2322 const G4double ymin = sceneExtent.GetYmin() <<
2323 const G4double ymax = sceneExtent.GetYmax() <<
2324 const G4double zmin = sceneExtent.GetZmin() <<
2325 const G4double zmax = sceneExtent.GetZmax() <<
2326 <<
2327 // Test existing extent and issue warnings. <<
2328 G4bool worried = false; <<
2329 if (sceneExtent.GetExtentRadius() == 0) { <<
2330 worried = true; <<
2331 if (verbosity >= G4VisManager::warnings) <<
2332 G4warn << <<
2333 "WARNING: Existing scene does not yet have <<
2334 "\n Maybe you have not yet added any geome <<
2335 << G4endl; <<
2336 } <<
2337 } <<
2338 <<
2339 // Test existing scene for room... <<
2340 G4bool room = true; <<
2341 switch (scaleDirection) { <<
2342 case Scale::x: <<
2343 if (freeLengthFraction * (xmax - xmin) < <<
2344 break; <<
2345 case Scale::y: <<
2346 if (freeLengthFraction * (ymax - ymin) < <<
2347 break; <<
2348 case Scale::z: <<
2349 if (freeLengthFraction * (zmax - zmin) < <<
2350 break; <<
2351 } <<
2352 if (!room) { <<
2353 worried = true; <<
2354 if (verbosity >= G4VisManager::warnings) <<
2355 G4warn << <<
2356 "WARNING: Not enough room in existing scene <<
2357 << G4endl; <<
2358 } <<
2359 } <<
2360 if (worried) { <<
2361 if (verbosity >= G4VisManager::warnings) <<
2362 G4warn << <<
2363 "WARNING: The scale you have asked for is b <<
2364 "\n scene. Maybe you have added it too so <<
2365 "\n you add the scale last so that it can <<
2366 "\n so as not to be obscured by any existi <<
2367 "\n view parameters can be correctly recal <<
2368 << G4endl; <<
2369 } <<
2370 } <<
2371 <<
2372 // Now figure out the extent... <<
2373 // <<
2374 // This creates a representation of annotat <<
2375 // direction with tick marks at the end. I <<
2376 // is required to be centred at the front, <<
2377 // the world space, comfortably outside the <<
2378 // box/sphere so that existing objects do n <<
2379 // it is required to be drawn with mid-poin <<
2380 // <<
2381 // The auto placing algorithm might be: <<
2382 // x = xmin + (1 + comfort) * (xmax - xmi <<
2383 // y = ymin - comfort * (ymax - ymin) <<
2384 // z = zmin + (1 + comfort) * (zmax - zmi <<
2385 // if direction == x then (x - length,y,z <<
2386 // if direction == y then (x,y,z) to (x,y <<
2387 // if direction == z then (x,y,z - length <<
2388 // <<
2389 // Implement this in two parts. Here, use <<
2390 // "expand" the scene's extent. Then rende <<
2391 // G4VSceneHandler::AddPrimitive(const G4Sc <<
2392 // ensure it's within the new extent. <<
2393 // <<
2394 <<
2395 G4double sxmid(xmid), symid(ymid), szmid(zm <<
2396 if (autoPlacing) { <<
2397 // Aim to place at bottom right of screen <<
2398 // Give some comfort zone. <<
2399 const G4double xComfort = comfort * (xmax <<
2400 const G4double yComfort = comfort * (ymax <<
2401 const G4double zComfort = comfort * (zmax <<
2402 switch (scaleDirection) { <<
2403 case Scale::x: <<
2404 if (vp.z() > 0.) { <<
2405 sxmid = xmax + xComfort; <<
2406 symid = ymin - yComfort; <<
2407 szmid = zmin - zComfort; <<
2408 } else { <<
2409 sxmid = xmin - xComfort; <<
2410 symid = ymin - yComfort; <<
2411 szmid = zmax + zComfort; <<
2412 } <<
2413 break; <<
2414 case Scale::y: <<
2415 if (vp.x() > 0.) { <<
2416 sxmid = xmin - xComfort; <<
2417 symid = ymax + yComfort; <<
2418 szmid = zmin - zComfort; <<
2419 } else { <<
2420 sxmid = xmax + xComfort; <<
2421 symid = ymin - yComfort; <<
2422 szmid = zmin - zComfort; <<
2423 } <<
2424 break; <<
2425 case Scale::z: <<
2426 if (vp.x() > 0.) { <<
2427 sxmid = xmax + xComfort; <<
2428 symid = ymin - yComfort; <<
2429 szmid = zmax + zComfort; <<
2430 } else { <<
2431 sxmid = xmin - xComfort; <<
2432 symid = ymin - yComfort; <<
2433 szmid = zmax + zComfort; <<
2434 } <<
2435 break; <<
2436 } <<
2437 } <<
2438 <<
2439 G4Transform3D transform; <<
2440 const G4double h = halfLength; <<
2441 const G4double t = h/5.; <<
2442 G4VisExtent scaleExtent(-h,h,-t,t,-t,t); <<
2443 switch (scaleDirection) { <<
2444 case Scale::x: <<
2445 break; <<
2446 case Scale::y: <<
2447 transform = G4RotateZ3D(halfpi); <<
2448 break; <<
2449 case Scale::z: <<
2450 transform = G4RotateY3D(halfpi); <<
2451 break; <<
2452 } <<
2453 transform = G4Translate3D(sxmid,symid,szmid <<
2454 scaleExtent = scaleExtent.Transform(transfo <<
2455 <<
2456 G4Colour colour(red, green, blue); <<
2457 if (direction == "auto") { <<
2458 switch (scaleDirection) { <<
2459 case Scale::x: <<
2460 colour = G4Colour::Red(); <<
2461 break; <<
2462 case Scale::y: <<
2463 colour = G4Colour::Green(); <<
2464 break; <<
2465 case Scale::z: <<
2466 colour = G4Colour::Blue(); <<
2467 break; <<
2468 } <<
2469 } <<
2470 G4VisAttributes visAttr(colour); <<
2471 <<
2472 Scale* scale = new Scale <<
2473 (visAttr, length, transform, <<
2474 annotation, fCurrentTextSize, colour); <<
2475 G4VModel* model = new G4CallbackModel<Scale <<
2476 model->SetType("Scale"); <<
2477 model->SetGlobalTag("Scale"); <<
2478 model->SetGlobalDescription("Scale: " + new <<
2479 model->SetExtent(scaleExtent); <<
2480 <<
2481 const G4String& currentSceneName = pScene - <<
2482 G4bool successful = pScene -> AddRunDuratio <<
2483 if (successful) { <<
2484 if (verbosity >= G4VisManager::confirmati <<
2485 G4cout << "Scale of " << annotation <<
2486 << " added to scene \"" << currentScen <<
2487 if (verbosity >= G4VisManager::paramete <<
2488 G4cout << "\n with extent " << scaleExtent <<
2489 << "\n at " << transform.getRotatio <<
2490 << " " << transform.getTranslation( <<
2491 } <<
2492 G4cout << G4endl; <<
2493 } <<
2494 } <<
2495 else G4VisCommandsSceneAddUnsuccessful(verb <<
2496 <<
2497 CheckSceneAndNotifyHandlers (pScene); <<
2498 } <<
2499 <<
2500 G4VisCommandSceneAddScale::Scale::Scale <<
2501 (const G4VisAttributes& visAtts, <<
2502 G4double length, const G4Transform3D& trans <<
2503 const G4String& annotation, G4double annota <<
2504 const G4Colour& annotationColour): <<
2505 fVisAtts(visAtts) <<
2506 { <<
2507 // Useful constants... <<
2508 const G4double halfLength(length / 2.); <<
2509 const G4double tickLength(length / 20.); <<
2510 <<
2511 // Create (empty) polylines having the same <<
2512 // (OK to pass address since fVisAtts is lo <<
2513 fScaleLine.SetVisAttributes(&fVisAtts); <<
2514 fTick11.SetVisAttributes(&fVisAtts); <<
2515 fTick12.SetVisAttributes(&fVisAtts); <<
2516 fTick21.SetVisAttributes(&fVisAtts); <<
2517 fTick22.SetVisAttributes(&fVisAtts); <<
2518 <<
2519 // Add points to the polylines to represent <<
2520 // x-axis centred on the origin... <<
2521 G4Point3D r1(G4Point3D(-halfLength, 0., 0.) <<
2522 G4Point3D r2(G4Point3D( halfLength, 0., 0.) <<
2523 fScaleLine.push_back(r1); <<
2524 fScaleLine.push_back(r2); <<
2525 G4Point3D ticky(0., tickLength, 0.); <<
2526 G4Point3D tickz(0., 0., tickLength); <<
2527 fTick11.push_back(r1 + ticky); <<
2528 fTick11.push_back(r1 - ticky); <<
2529 fTick12.push_back(r1 + tickz); <<
2530 fTick12.push_back(r1 - tickz); <<
2531 fTick21.push_back(r2 + ticky); <<
2532 fTick21.push_back(r2 - ticky); <<
2533 fTick22.push_back(r2 + tickz); <<
2534 fTick22.push_back(r2 - tickz); <<
2535 // ...and transform to chosen position and <<
2536 fScaleLine.transform(transform); <<
2537 fTick11.transform(transform); <<
2538 fTick12.transform(transform); <<
2539 fTick21.transform(transform); <<
2540 fTick22.transform(transform); <<
2541 // Similarly for annotation <<
2542 G4Point3D textPosition(0., tickLength, 0.); <<
2543 textPosition.transform(transform); <<
2544 fText = G4Text(annotation,textPosition); <<
2545 fText.SetVisAttributes(annotationColour); <<
2546 fText.SetScreenSize(annotationSize); <<
2547 } <<
2548 <<
2549 void G4VisCommandSceneAddScale::Scale::operat <<
2550 (G4VGraphicsScene& sceneHandler,const G4Model <<
2551 { <<
2552 // Draw... <<
2553 sceneHandler.BeginPrimitives(); <<
2554 sceneHandler.AddPrimitive(fScaleLine); <<
2555 sceneHandler.AddPrimitive(fTick11); <<
2556 sceneHandler.AddPrimitive(fTick12); <<
2557 sceneHandler.AddPrimitive(fTick21); <<
2558 sceneHandler.AddPrimitive(fTick22); <<
2559 sceneHandler.AddPrimitive(fText); <<
2560 sceneHandler.EndPrimitives(); <<
2561 } <<
2562 <<
2563 ////////////// /vis/scene/add/text ////////// <<
2564 <<
2565 G4VisCommandSceneAddText::G4VisCommandSceneAd <<
2566 G4bool omitable; <<
2567 fpCommand = new G4UIcommand ("/vis/scene/ad <<
2568 fpCommand -> SetGuidance ("Adds text to cur <<
2569 fpCommand -> SetGuidance <<
2570 ("Use \"/vis/set/textColour\" to set colo <<
2571 fpCommand -> SetGuidance <<
2572 ("Use \"/vis/set/textLayout\" to set layo <<
2573 G4UIparameter* parameter; <<
2574 parameter = new G4UIparameter ("x", 'd', om <<
2575 parameter->SetDefaultValue (0); <<
2576 fpCommand->SetParameter (parameter); <<
2577 parameter = new G4UIparameter ("y", 'd', o <<
2578 parameter->SetDefaultValue (0); <<
2579 fpCommand->SetParameter (parameter); <<
2580 parameter = new G4UIparameter ("z", 'd', o <<
2581 parameter->SetDefaultValue (0); <<
2582 fpCommand->SetParameter (parameter); <<
2583 parameter = new G4UIparameter ("unit", 's' <<
2584 parameter->SetDefaultValue ("m"); <<
2585 fpCommand->SetParameter (parameter); <<
2586 parameter = new G4UIparameter ("font_size" <<
2587 parameter->SetDefaultValue (12); <<
2588 parameter->SetGuidance ("pixels"); <<
2589 fpCommand->SetParameter (parameter); <<
2590 parameter = new G4UIparameter ("x_offset", <<
2591 parameter->SetDefaultValue (0); <<
2592 parameter->SetGuidance ("pixels"); <<
2593 fpCommand->SetParameter (parameter); <<
2594 parameter = new G4UIparameter ("y_offset", <<
2595 parameter->SetDefaultValue (0); <<
2596 parameter->SetGuidance ("pixels"); <<
2597 fpCommand->SetParameter (parameter); <<
2598 parameter = new G4UIparameter ("text", 's' <<
2599 parameter->SetGuidance ("The rest of the li <<
2600 parameter->SetDefaultValue ("Hello G4"); <<
2601 fpCommand->SetParameter (parameter); <<
2602 } <<
2603 <<
2604 G4VisCommandSceneAddText::~G4VisCommandSceneA <<
2605 delete fpCommand; <<
2606 } <<
2607 <<
2608 G4String G4VisCommandSceneAddText::GetCurrent <<
2609 return ""; <<
2610 } <<
2611 <<
2612 void G4VisCommandSceneAddText::SetNewValue (G <<
2613 <<
2614 G4VisManager::Verbosity verbosity = fpVisMa <<
2615 G4bool warn = verbosity >= G4VisManager::wa <<
2616 <<
2617 G4Scene* pScene = fpVisManager->GetCurrentS <<
2618 if (!pScene) { <<
2619 if (verbosity >= G4VisManager::errors) { <<
2620 G4warn << "ERROR: No current scene. Pl <<
2621 } <<
2622 return; <<
2623 } <<
2624 <<
2625 G4Tokenizer next(newValue); <<
2626 G4double x = StoD(next()); <<
2627 G4double y = StoD(next()); <<
2628 G4double z = StoD(next()); <<
2629 G4String unitString = next(); <<
2630 G4double font_size = StoD(next()); <<
2631 G4double x_offset = StoD(next()); <<
2632 G4double y_offset = StoD(next()); <<
2633 G4String text = next("\n"); <<
2634 <<
2635 G4double unit = G4UIcommand::ValueOf(unitSt <<
2636 x *= unit; y *= unit; z *= unit; <<
2637 <<
2638 G4Text g4text(text, G4Point3D(x,y,z)); <<
2639 G4VisAttributes visAtts(fCurrentTextColour) <<
2640 g4text.SetVisAttributes(visAtts); <<
2641 g4text.SetLayout(fCurrentTextLayout); <<
2642 g4text.SetScreenSize(font_size); <<
2643 g4text.SetOffset(x_offset,y_offset); <<
2644 G4VModel* model = new G4TextModel(g4text); <<
2645 const G4String& currentSceneName = pScene - <<
2646 G4bool successful = pScene -> AddRunDuratio <<
2647 if (successful) { <<
2648 if (verbosity >= G4VisManager::confirmati <<
2649 G4cout << "Text '" << text <<
2650 << "' has been added to scene \"" << c <<
2651 << G4endl; <<
2652 } <<
2653 } <<
2654 else G4VisCommandsSceneAddUnsuccessful(verb <<
2655 <<
2656 CheckSceneAndNotifyHandlers (pScene); <<
2657 } <<
2658 <<
2659 <<
2660 ////////////// /vis/scene/add/text2D //////// <<
2661 <<
2662 G4VisCommandSceneAddText2D::G4VisCommandScene <<
2663 G4bool omitable; <<
2664 fpCommand = new G4UIcommand ("/vis/scene/ad <<
2665 fpCommand -> SetGuidance ("Adds 2D text to <<
2666 fpCommand -> SetGuidance ("x,y in range [-1 <<
2667 fpCommand -> SetGuidance <<
2668 ("Use \"/vis/set/textColour\" to set colo <<
2669 fpCommand -> SetGuidance <<
2670 ("Use \"/vis/set/textLayout\" to set layo <<
2671 G4UIparameter* parameter; <<
2672 parameter = new G4UIparameter ("x", 'd', om <<
2673 parameter->SetDefaultValue (0); <<
2674 fpCommand->SetParameter (parameter); <<
2675 parameter = new G4UIparameter ("y", 'd', o <<
2676 parameter->SetDefaultValue (0); <<
2677 fpCommand->SetParameter (parameter); <<
2678 parameter = new G4UIparameter ("font_size" <<
2679 parameter->SetDefaultValue (12); <<
2680 parameter->SetGuidance ("pixels"); <<
2681 fpCommand->SetParameter (parameter); <<
2682 parameter = new G4UIparameter ("x_offset", <<
2683 parameter->SetDefaultValue (0); <<
2684 parameter->SetGuidance ("pixels"); <<
2685 fpCommand->SetParameter (parameter); <<
2686 parameter = new G4UIparameter ("y_offset", <<
2687 parameter->SetDefaultValue (0); <<
2688 parameter->SetGuidance ("pixels"); <<
2689 fpCommand->SetParameter (parameter); <<
2690 parameter = new G4UIparameter ("text", 's' <<
2691 parameter->SetGuidance ("The rest of the li <<
2692 parameter->SetDefaultValue ("Hello G4"); <<
2693 fpCommand->SetParameter (parameter); <<
2694 } <<
2695 <<
2696 G4VisCommandSceneAddText2D::~G4VisCommandScen <<
2697 delete fpCommand; 241 delete fpCommand;
2698 } 242 }
2699 243
2700 G4String G4VisCommandSceneAddText2D::GetCurre << 244 G4String G4VisCommandSceneAddGhosts::GetCurrentValue (G4UIcommand* command) {
2701 return ""; 245 return "";
2702 } 246 }
2703 247
2704 void G4VisCommandSceneAddText2D::SetNewValue << 248 void G4VisCommandSceneAddGhosts::SetNewValue (G4UIcommand* command,
2705 <<
2706 G4VisManager::Verbosity verbosity = fpVisMa <<
2707 G4bool warn = verbosity >= G4VisManager::wa <<
2708 <<
2709 G4Scene* pScene = fpVisManager->GetCurrentS <<
2710 if (!pScene) { <<
2711 if (verbosity >= G4VisManager::errors) { <<
2712 G4warn << "ERROR: No current scene. Pl <<
2713 } <<
2714 return; <<
2715 } <<
2716 <<
2717 G4Tokenizer next(newValue); <<
2718 G4double x = StoD(next()); <<
2719 G4double y = StoD(next()); <<
2720 G4double font_size = StoD(next()); <<
2721 G4double x_offset = StoD(next()); <<
2722 G4double y_offset = StoD(next()); <<
2723 G4String text = next("\n"); <<
2724 <<
2725 G4Text g4text(text, G4Point3D(x,y,0.)); <<
2726 G4VisAttributes visAtts(fCurrentTextColour) <<
2727 g4text.SetVisAttributes(visAtts); <<
2728 g4text.SetLayout(fCurrentTextLayout); <<
2729 g4text.SetScreenSize(font_size); <<
2730 g4text.SetOffset(x_offset,y_offset); <<
2731 G4Text2D* g4text2D = new G4Text2D(g4text); <<
2732 G4VModel* model = <<
2733 new G4CallbackModel<G4VisCommandSceneAddT <<
2734 model->SetType("Text2D"); <<
2735 model->SetGlobalTag("Text2D"); <<
2736 std::ostringstream oss; <<
2737 oss << "Text2D: '" << g4text.GetText() <<
2738 << "' at " << g4text.GetPosition().x() << ' <<
2739 << " with size " << g4text.GetScreenSize() <<
2740 << " with offsets " << g4text.GetXOffset() <<
2741 model->SetGlobalDescription(oss.str()); <<
2742 const G4String& currentSceneName = pScene - <<
2743 G4bool successful = pScene -> AddRunDuratio <<
2744 if (successful) { <<
2745 if (verbosity >= G4VisManager::confirmati <<
2746 G4cout << "2D text '" << text <<
2747 << "' has been added to scene \"" << c <<
2748 << G4endl; <<
2749 } <<
2750 } <<
2751 else G4VisCommandsSceneAddUnsuccessful(verb <<
2752 <<
2753 CheckSceneAndNotifyHandlers (pScene); <<
2754 } <<
2755 <<
2756 G4VisCommandSceneAddText2D::G4Text2D::G4Text2 <<
2757 fText(text) <<
2758 {} <<
2759 <<
2760 void G4VisCommandSceneAddText2D::G4Text2D::op <<
2761 (G4VGraphicsScene& sceneHandler, const G4Mo <<
2762 sceneHandler.BeginPrimitives2D(); <<
2763 sceneHandler.AddPrimitive(fText); <<
2764 sceneHandler.EndPrimitives2D(); <<
2765 } <<
2766 <<
2767 <<
2768 ////////////// /vis/scene/add/trajectories // <<
2769 <<
2770 G4VisCommandSceneAddTrajectories::G4VisComman <<
2771 G4bool omitable; <<
2772 fpCommand = new G4UIcmdWithAString <<
2773 ("/vis/scene/add/trajectories", this); <<
2774 fpCommand -> SetGuidance <<
2775 ("Adds trajectories to current scene."); <<
2776 fpCommand -> SetGuidance <<
2777 ("Causes trajectories, if any, to be draw <<
2778 "\nevent. Switches on trajectory storin <<
2779 "\ndefault trajectory type."); <<
2780 fpCommand -> SetGuidance <<
2781 ("The command line parameter list determi <<
2782 "\nIf it contains the string \"smooth\", <<
2783 "\nbe inserted to improve the smoothness <<
2784 "\ntrajectory." <<
2785 "\nIf it contains the string \"rich\", s <<
2786 "\nbe stored in the trajectory (G4RichTr <<
2787 "\nand filtering with \"/vis/modeling/tr <<
2788 "\nand \"/vis/filtering/trajectories/cre <<
2789 "\nIt may contain both strings in any or <<
2790 fpCommand -> SetGuidance <<
2791 ("\nTo switch off trajectory storing: \"/ <<
2792 "\nSee also \"/vis/scene/endOfEventActio <<
2793 fpCommand -> SetGuidance <<
2794 ("Note: This only sets the default. Ind <<
2795 "\ncommand, a user may instantiate a tra <<
2796 "\nin PreUserTrackingAction."); <<
2797 fpCommand -> SetParameterName ("default-tra <<
2798 fpCommand -> SetDefaultValue (""); <<
2799 } <<
2800 <<
2801 G4VisCommandSceneAddTrajectories::~G4VisComma <<
2802 delete fpCommand; <<
2803 } <<
2804 <<
2805 G4String G4VisCommandSceneAddTrajectories::Ge <<
2806 return ""; <<
2807 } <<
2808 <<
2809 void G4VisCommandSceneAddTrajectories::SetNew <<
2810 G4String newValue) { <<
2811 <<
2812 G4VisManager::Verbosity verbosity = fpVisMa <<
2813 G4bool warn = verbosity >= G4VisManager::wa <<
2814 <<
2815 G4Scene* pScene = fpVisManager->GetCurrentS <<
2816 if (!pScene) { <<
2817 if (verbosity >= G4VisManager::errors) { <<
2818 G4warn << "ERROR: No current scene. Pl <<
2819 } <<
2820 return; <<
2821 } <<
2822 const G4String& currentSceneName = pScene - <<
2823 <<
2824 G4bool smooth = false; <<
2825 G4bool rich = false; <<
2826 if (newValue.find("smooth") != std::string: <<
2827 if (newValue.find("rich") != std::string::n <<
2828 if (newValue.size() && !(rich || smooth)) { <<
2829 if (verbosity >= G4VisManager::errors) { <<
2830 G4warn << "ERROR: Unrecognised paramete <<
2831 "\n No action taken." <<
2832 << G4endl; <<
2833 } <<
2834 return; <<
2835 } <<
2836 <<
2837 G4UImanager* UImanager = G4UImanager::GetUI <<
2838 G4String defaultTrajectoryType; <<
2839 if (smooth && rich) { <<
2840 UImanager->ApplyCommand("/tracking/storeT <<
2841 defaultTrajectoryType = "G4RichTrajectory <<
2842 } else if (smooth) { <<
2843 UImanager->ApplyCommand("/tracking/storeT <<
2844 defaultTrajectoryType = "G4SmoothTrajecto <<
2845 } else if (rich) { <<
2846 UImanager->ApplyCommand("/tracking/storeT <<
2847 defaultTrajectoryType = "G4RichTrajectory <<
2848 } else { <<
2849 UImanager->ApplyCommand("/tracking/storeT <<
2850 defaultTrajectoryType = "G4Trajectory"; <<
2851 } <<
2852 <<
2853 if (verbosity >= G4VisManager::errors) { <<
2854 G4warn << <<
2855 "Attributes available for modeling and <<
2856 "\n \"/vis/modeling/trajectories/creat <<
2857 "\n \"/vis/filtering/trajectories/crea <<
2858 << G4endl; <<
2859 G4warn << *G4TrajectoriesModel().GetAttDe <<
2860 if (rich) { <<
2861 G4warn << *G4RichTrajectory().GetAttDef <<
2862 << *G4RichTrajectoryPoint().GetAttDefs <<
2863 } else if (smooth) { <<
2864 G4warn << *G4SmoothTrajectory().GetAttD <<
2865 << *G4SmoothTrajectoryPoint().GetAttDe <<
2866 } else { <<
2867 G4warn << *G4Trajectory().GetAttDefs() <<
2868 << *G4TrajectoryPoint().GetAttDefs(); <<
2869 } <<
2870 } <<
2871 <<
2872 const auto& eoeList = pScene->GetEndOfEvent <<
2873 auto eoeModel = eoeList.begin(); <<
2874 for (; eoeModel != eoeList.end(); ++eoeMode <<
2875 const auto* actualModel = eoeModel->fpMod <<
2876 if (dynamic_cast<const G4TrajectoriesMode <<
2877 } <<
2878 if (eoeModel == eoeList.end()) { <<
2879 // No trajectories model exists in the sc <<
2880 G4VModel* model = new G4TrajectoriesModel <<
2881 pScene -> AddEndOfEventModel (model, warn <<
2882 } // ...else it already exists and there i <<
2883 // because G4TrajectoriesModel simply descr <<
2884 // trajectories store whatever the type. <<
2885 <<
2886 if (verbosity >= G4VisManager::confirmation <<
2887 G4cout << "Default trajectory type " << d <<
2888 << "\n will be used to store trajectori <<
2889 << currentSceneName << "\"." <<
2890 << G4endl; <<
2891 } <<
2892 <<
2893 if (verbosity >= G4VisManager::warnings) { <<
2894 G4warn << <<
2895 "WARNING: Trajectory storing has been r <<
2896 "\n reversed with \"/tracking/storeTra <<
2897 << G4endl; <<
2898 } <<
2899 <<
2900 CheckSceneAndNotifyHandlers (pScene); <<
2901 } <<
2902 <<
2903 ////////////// /vis/scene/add/userAction //// <<
2904 <<
2905 G4VisCommandSceneAddUserAction::G4VisCommandS <<
2906 G4bool omitable; <<
2907 fpCommand = new G4UIcmdWithAString("/vis/sc <<
2908 fpCommand -> SetGuidance <<
2909 ("Add named Vis User Action to current sc <<
2910 fpCommand -> SetGuidance <<
2911 ("Attempts to match search string to name <<
2912 fpCommand -> SetGuidance <<
2913 ("(Use /vis/list to see names of register <<
2914 fpCommand -> SetGuidance <<
2915 ("If name == \"all\" (default), all actio <<
2916 fpCommand -> SetParameterName("action-name" <<
2917 fpCommand -> SetDefaultValue("all"); <<
2918 } <<
2919 <<
2920 G4VisCommandSceneAddUserAction::~G4VisCommand <<
2921 delete fpCommand; <<
2922 } <<
2923 <<
2924 G4String G4VisCommandSceneAddUserAction::GetC <<
2925 return ""; <<
2926 } <<
2927 <<
2928 void G4VisCommandSceneAddUserAction::SetNewVa <<
2929 (G4UIcommand*, G4String newValue) { <<
2930 <<
2931 G4VisManager::Verbosity verbosity = fpVisMa <<
2932 <<
2933 G4Scene* pScene = fpVisManager->GetCurrentS <<
2934 if (!pScene) { <<
2935 if (verbosity >= G4VisManager::errors) { <<
2936 G4warn << "ERROR: No current scene. Pl <<
2937 } <<
2938 return; <<
2939 } <<
2940 <<
2941 G4bool any = false; <<
2942 <<
2943 const std::vector<G4VisManager::UserVisActi <<
2944 fpVisManager->GetRunDurationUserVisAction <<
2945 for (size_t i = 0; i < runDurationUserVisAc <<
2946 const G4String& name = runDurationUserVis <<
2947 G4VUserVisAction* visAction = runDuration <<
2948 if (newValue == "all" || name.find(newVal <<
2949 any = true; <<
2950 AddVisAction(name,visAction,pScene,runD <<
2951 } <<
2952 } <<
2953 <<
2954 const std::vector<G4VisManager::UserVisActi <<
2955 fpVisManager->GetEndOfEventUserVisActions <<
2956 for (size_t i = 0; i < endOfEventUserVisAct <<
2957 const G4String& name = endOfEventUserVisA <<
2958 G4VUserVisAction* visAction = endOfEventU <<
2959 if (newValue == "all" || name.find(newVal <<
2960 any = true; <<
2961 AddVisAction(name,visAction,pScene,endO <<
2962 } <<
2963 } <<
2964 <<
2965 const std::vector<G4VisManager::UserVisActi <<
2966 fpVisManager->GetEndOfRunUserVisActions() <<
2967 for (size_t i = 0; i < endOfRunUserVisActio <<
2968 const G4String& name = endOfRunUserVisAct <<
2969 G4VUserVisAction* visAction = endOfRunUse <<
2970 if (newValue == "all" || name.find(newVal <<
2971 any = true; <<
2972 AddVisAction(name,visAction,pScene,endO <<
2973 } <<
2974 } <<
2975 <<
2976 if (!any) { <<
2977 if (verbosity >= G4VisManager::warnings) <<
2978 G4warn << "WARNING: No User Vis Action <<
2979 } <<
2980 return; <<
2981 } <<
2982 <<
2983 CheckSceneAndNotifyHandlers (pScene); <<
2984 } <<
2985 <<
2986 void G4VisCommandSceneAddUserAction::AddVisAc <<
2987 (const G4String& name, <<
2988 G4VUserVisAction* visAction, <<
2989 G4Scene* pScene, <<
2990 G4VisCommandSceneAddUserAction::ActionType t <<
2991 G4VisManager::Verbosity verbosity) <<
2992 { <<
2993 G4bool warn = verbosity >= G4VisManager::wa <<
2994 <<
2995 const std::map<G4VUserVisAction*,G4VisExten <<
2996 fpVisManager->GetUserVisActionExtents(); <<
2997 G4VisExtent extent; <<
2998 std::map<G4VUserVisAction*,G4VisExtent>::co <<
2999 visExtentMap.find(visAction); <<
3000 if (i != visExtentMap.end()) extent = i->se <<
3001 if (warn) { <<
3002 if (extent.GetExtentRadius() <= 0.) { <<
3003 G4warn <<
3004 << "WARNING: User Vis Action \"" << nam <<
3005 << G4endl; <<
3006 } <<
3007 } <<
3008 <<
3009 G4VModel* model = new G4CallbackModel<G4VUs <<
3010 model->SetType("User Vis Action"); <<
3011 model->SetGlobalTag(name); <<
3012 model->SetGlobalDescription(name); <<
3013 model->SetExtent(extent); <<
3014 G4bool successful = false;; <<
3015 switch (type) { <<
3016 case runDuration: <<
3017 successful = pScene -> AddRunDurationMode <<
3018 break; <<
3019 case endOfEvent: <<
3020 successful = pScene -> AddEndOfEventModel <<
3021 break; <<
3022 case endOfRun: <<
3023 successful = pScene -> AddEndOfRunModel ( <<
3024 break; <<
3025 } <<
3026 if (successful) { <<
3027 if (verbosity >= G4VisManager::confirmati <<
3028 const G4String& currentSceneName = pSce <<
3029 G4cout << "User Vis Action added to sce <<
3030 << currentSceneName << "\""; <<
3031 if (verbosity >= G4VisManager::paramete <<
3032 G4cout << "\n with extent " << exten <<
3033 } <<
3034 G4cout << G4endl; <<
3035 } <<
3036 } <<
3037 else G4VisCommandsSceneAddUnsuccessful(verb <<
3038 } <<
3039 <<
3040 ////////////// /vis/scene/add/volume //////// <<
3041 <<
3042 G4VisCommandSceneAddVolume::G4VisCommandScene <<
3043 G4bool omitable; <<
3044 fpCommand = new G4UIcommand ("/vis/scene/ad <<
3045 fpCommand -> SetGuidance <<
3046 ("Adds a physical volume to current scene, <<
3047 fpCommand -> SetGuidance <<
3048 ("If physical-volume-name is \"world\" (t <<
3049 "\nmain geometry tree (material world) i <<
3050 "\ntops of all worlds - material world a <<
3051 "\nadded. Otherwise a search of all worl <<
3052 fpCommand -> SetGuidance <<
3053 ("In the last case the names of all volum <<
3054 "\nagainst physical-volume-name. If this <<
3055 "\nwhere regexp is a regular expression <<
3056 "\nthe usual rules of regular expression <<
3057 "\nmatch is required." <<
3058 "\nFor example, \"/Shap/\" adds \"Shape1 <<
3059 fpCommand -> SetGuidance <<
3060 ("It may help to see a textual representa <<
3061 "\nthe worlds. Try \"/vis/drawTree [worl <<
3062 "\ncombinations that have the required f <<
3063 fpCommand -> SetGuidance <<
3064 ("If clip-volume-type is specified, the s <<
3065 "\nto define a clipping volume. For exam <<
3066 "\n\"/vis/scene/add/volume ! ! ! -box km <<
3067 "\nwith the positive octant cut away. (I <<
3068 "\nwarnings try replacing 0 by 0.0000000 <<
3069 fpCommand -> SetGuidance <<
3070 ("If clip-volume-type is prepended with ' <<
3071 "\n(cutaway). (This is the default if th <<
3072 "\nIf '*' is prepended, the intersection <<
3073 "\nclip-volume is made. (You can make a <<
3074 "\na thin box, for example)."); <<
3075 fpCommand -> SetGuidance <<
3076 ("For \"box\", the parameters are xmin,xm <<
3077 "\nOnly \"box\" is programmed at present <<
3078 G4UIparameter* parameter; <<
3079 parameter = new G4UIparameter ("physical-vo <<
3080 parameter -> SetDefaultValue ("world"); <<
3081 fpCommand -> SetParameter (parameter); <<
3082 parameter = new G4UIparameter ("copy-no", ' <<
3083 parameter -> SetGuidance ("If negative, mat <<
3084 parameter -> SetDefaultValue (-1); <<
3085 fpCommand -> SetParameter (parameter); <<
3086 parameter = new G4UIparameter ("depth-of-de <<
3087 parameter -> SetGuidance <<
3088 ("Depth of descent of geometry hierarchy. <<
3089 parameter -> SetDefaultValue (G4PhysicalVol <<
3090 fpCommand -> SetParameter (parameter); <<
3091 parameter = new G4UIparameter ("clip-volume <<
3092 parameter -> SetParameterCandidates("none b <<
3093 parameter -> SetDefaultValue ("none"); <<
3094 parameter -> SetGuidance("[-|*]type. See g <<
3095 fpCommand -> SetParameter (parameter); <<
3096 parameter = new G4UIparameter ("parameter-u <<
3097 parameter -> SetDefaultValue ("m"); <<
3098 fpCommand -> SetParameter (parameter); <<
3099 parameter = new G4UIparameter ("parameter-1 <<
3100 parameter -> SetDefaultValue (0.); <<
3101 fpCommand -> SetParameter (parameter); <<
3102 parameter = new G4UIparameter ("parameter-2 <<
3103 parameter -> SetDefaultValue (0.); <<
3104 fpCommand -> SetParameter (parameter); <<
3105 parameter = new G4UIparameter ("parameter-3 <<
3106 parameter -> SetDefaultValue (0.); <<
3107 fpCommand -> SetParameter (parameter); <<
3108 parameter = new G4UIparameter ("parameter-4 <<
3109 parameter -> SetDefaultValue (0.); <<
3110 fpCommand -> SetParameter (parameter); <<
3111 parameter = new G4UIparameter ("parameter-5 <<
3112 parameter -> SetDefaultValue (0.); <<
3113 fpCommand -> SetParameter (parameter); <<
3114 parameter = new G4UIparameter ("parameter-6 <<
3115 parameter -> SetDefaultValue (0.); <<
3116 fpCommand -> SetParameter (parameter); <<
3117 } <<
3118 <<
3119 G4VisCommandSceneAddVolume::~G4VisCommandScen <<
3120 delete fpCommand; <<
3121 } <<
3122 <<
3123 G4String G4VisCommandSceneAddVolume::GetCurre <<
3124 return "world 0 -1"; <<
3125 } <<
3126 <<
3127 void G4VisCommandSceneAddVolume::SetNewValue <<
3128 G4String newValue) { 249 G4String newValue) {
>> 250 G4Scene* pCurrentScene = fpVisManager -> GetCurrentScene ();
>> 251 const G4String& currentSceneName = pCurrentScene -> GetName ();
3129 252
3130 G4VisManager::Verbosity verbosity = fpVisMa << 253 G4SceneList& sceneList = fpVisManager -> SetSceneList ();
3131 G4bool warn = verbosity >= G4VisManager::wa << 254 if (sceneList.isEmpty ()) {
3132 << 255 G4cout << "No scenes - please create one before adding anything."
3133 G4Scene* pScene = fpVisManager->GetCurrentS << 256 << G4endl;
3134 if (!pScene) { <<
3135 if (verbosity >= G4VisManager::errors) { <<
3136 G4warn << "ERROR: No current scene. Pl <<
3137 } <<
3138 return; 257 return;
3139 } 258 }
3140 259
3141 G4String name, clipVolumeType, parameterUni << 260 G4VGlobalFastSimulationManager* theGlobalFastSimulationManager;
3142 G4int copyNo, requestedDepthOfDescent; << 261 if(!(theGlobalFastSimulationManager =
3143 G4double param1, param2, param3, param4, pa << 262 G4VGlobalFastSimulationManager::GetConcreteInstance ())){
3144 std::istringstream is (newValue); << 263 G4cout<< "WARNING: no G4GlobalFastSimulationManager" << G4endl;
3145 is >> name >> copyNo >> requestedDepthOfDes <<
3146 >> clipVolumeType >> parameterUnit <<
3147 >> param1 >> param2 >> param3 >> param4 <<
3148 G4PhysicalVolumeModel::ClippingMode clippin <<
3149 G4PhysicalVolumeModel::subtraction; // D <<
3150 if (clipVolumeType[size_t(0)] == '-') { <<
3151 clipVolumeType = clipVolumeType.substr(1) <<
3152 } else if (clipVolumeType[size_t(0)] == '*' <<
3153 clippingMode = G4PhysicalVolumeModel::int <<
3154 clipVolumeType = clipVolumeType.substr(1) <<
3155 } <<
3156 G4double unit = G4UIcommand::ValueOf(parame <<
3157 param1 *= unit; param2 *= unit; param3 *= u <<
3158 param4 *= unit; param5 *= unit; param6 *= u <<
3159 <<
3160 G4VSolid* clippingSolid = nullptr; <<
3161 if (clipVolumeType == "box") { <<
3162 const G4double dX = (param2 - param1) / 2 <<
3163 const G4double dY = (param4 - param3) / 2 <<
3164 const G4double dZ = (param6 - param5) / 2 <<
3165 const G4double x0 = (param2 + param1) / 2 <<
3166 const G4double y0 = (param4 + param3) / 2 <<
3167 const G4double z0 = (param6 + param5) / 2 <<
3168 clippingSolid = new G4DisplacedSolid <<
3169 ("_displaced_clipping_box", <<
3170 new G4Box("_clipping_box",dX,dY,dZ), <<
3171 G4Translate3D(x0,y0,z0)); <<
3172 } <<
3173 <<
3174 G4TransportationManager* transportationMana <<
3175 G4TransportationManager::GetTransportatio <<
3176 <<
3177 size_t nWorlds = transportationManager->Get <<
3178 if (nWorlds > 1) { // Parallel worlds in o <<
3179 if (verbosity >= G4VisManager::warnings) <<
3180 static G4bool warned = false; <<
3181 if (!warned && name != "worlds") { <<
3182 G4warn << <<
3183 "WARNING: Parallel worlds in operation. <<
3184 "\n \"worlds\" or the parallel world vol <<
3185 "\n and control visibility with /vis/ge <<
3186 << G4endl; <<
3187 std::vector<G4VPhysicalVolume*>::iterator i <<
3188 transportationManager->GetWorldsIterator( <<
3189 for (size_t i = 0; i < nWorlds; ++i, ++iter <<
3190 G4warn << " World " << i << ": " << (*it <<
3191 << G4endl; <<
3192 warned = true; <<
3193 } <<
3194 } <<
3195 } <<
3196 } <<
3197 <<
3198 // Get the world (the initial value of the <<
3199 G4VPhysicalVolume* world = *(transportation <<
3200 <<
3201 if (!world) { <<
3202 if (verbosity >= G4VisManager::errors) { <<
3203 G4warn << <<
3204 "ERROR: G4VisCommandSceneAddVolume::SetNewV <<
3205 "\n No world. Maybe the geometry has not <<
3206 "\n Try \"/run/initialize\"" <<
3207 << G4endl; <<
3208 } <<
3209 return; 264 return;
3210 } 265 }
3211 << 266
3212 std::vector<G4PhysicalVolumesSearchScene::F << 267 G4ParticleTable* theParticleTable=G4ParticleTable::GetParticleTable();
3213 << 268
3214 // When it comes to determining the extent << 269 if(newValue=="all") {
3215 // assume the user wishes to ignore "invisi << 270 G4VFlavoredParallelWorld* CurrentFlavoredWorld;
3216 // users make the world volume invisible. S << 271 G4bool successful;
3217 // model to traverse the geometry hierarchy << 272 for (G4int iParticle=0; iParticle<theParticleTable->entries();
3218 // volume, until it finds non-invisible one << 273 iParticle++)
3219 // to determine the overall extent. (Once a << 274 if(CurrentFlavoredWorld=theGlobalFastSimulationManager->
3220 // the search is curtailed - daughters are << 275 GetFlavoredWorldForThis(theParticleTable->
3221 // so they have no subsequent influence on << 276 GetParticle(iParticle)))
3222 // search continues at the same level until << 277 successful = pCurrentScene -> AddRunDurationModel
3223 // volumes are found an their extents accum << 278 (new G4FlavoredParallelWorldModel (CurrentFlavoredWorld));
3224 G4bool useFullExtent = false; << 279 UpdateVisManagerScene ();
3225 // However, the above procedure can be time <<
3226 // as a nested parameterisation whose ultim <<
3227 // visible ones, which are typical of a med <<
3228 // below that if a user specifies a name ot <<
3229 // wished the extent to be determined by th <<
3230 // or not. So we set useFullExtent true at <<
3231 <<
3232 if (name == "world") { <<
3233 <<
3234 findingsVector.push_back <<
3235 (G4PhysicalVolumesSearchScene::Findings(w <<
3236 <<
3237 } else if (name == "worlds") { <<
3238 <<
3239 if (nWorlds <= 1) { <<
3240 if (verbosity >= G4VisManager::warnings <<
3241 G4warn << <<
3242 "WARNING: G4VisCommandSceneAddVolume::Set <<
3243 "\n Parallel worlds requested but none e <<
3244 "\n Just adding material world." <<
3245 << G4endl; <<
3246 } <<
3247 } <<
3248 std::vector<G4VPhysicalVolume*>::iterator <<
3249 transportationManager->GetWorldsIterato <<
3250 for (size_t i = 0; i < nWorlds; ++i, ++it <<
3251 findingsVector.push_back <<
3252 (G4PhysicalVolumesSearchScene::Findings <<
3253 (*iterWorld,*iterWorld)); <<
3254 } <<
3255 <<
3256 } else { // Search all worlds... <<
3257 <<
3258 // Use the model's full extent. This assu <<
3259 // volumes in the findings vector (there <<
3260 // determine the scene's extent. Otherwis <<
3261 // re-calculate each volume's extent base <<
3262 // could be time consuming. <<
3263 useFullExtent = true; <<
3264 <<
3265 std::vector<G4VPhysicalVolume*>::iterator <<
3266 transportationManager->GetWorldsIterato <<
3267 for (size_t i = 0; i < nWorlds; ++i, ++it <<
3268 G4ModelingParameters mp; // Default - <<
3269 G4PhysicalVolumeModel searchModel <<
3270 (*iterWorld, <<
3271 requestedDepthOfDescent, <<
3272 G4Transform3D(), <<
3273 &mp, <<
3274 useFullExtent); <<
3275 G4PhysicalVolumesSearchScene searchScen <<
3276 searchModel.DescribeYourselfTo (searchS <<
3277 for (const auto& findings: searchScene. <<
3278 findingsVector.push_back(findings); <<
3279 } <<
3280 } <<
3281 } <<
3282 <<
3283 for (const auto& findings: findingsVector) <<
3284 // Set copy number from search findings f <<
3285 findings.fpFoundPV->SetCopyNo(findings.fF <<
3286 G4PhysicalVolumeModel* foundPVModel = new <<
3287 (findings.fpFoundPV, <<
3288 requestedDepthOfDescent, <<
3289 findings.fFoundObjectTransformation, <<
3290 0, // No modelling parameters (these are <<
3291 useFullExtent, <<
3292 findings.fFoundBasePVPath); <<
3293 if (clippingSolid) { <<
3294 foundPVModel->SetClippingSolid(clipping <<
3295 foundPVModel->SetClippingMode(clippingM <<
3296 } <<
3297 if (!foundPVModel->Validate(warn)) return <<
3298 // ...so add it to the scene. <<
3299 G4bool successful = pScene->AddRunDuratio <<
3300 if (successful) { 280 if (successful) {
3301 if (verbosity >= G4VisManager::confirma << 281 G4cout << "Ghosts added to the Scene, refresh the view to see it."
3302 G4cout << "\"" << findings.fpFoundPV- << 282 << G4endl;
3303 << "\", copy no. " << findings.fFound <<
3304 << ",\n found in searched volume \"" <<
3305 << findings.fpSearchPV->GetName() <<
3306 << "\" at depth " << findings.fFoundD <<
3307 << ",\n base path: \"" << findings.f <<
3308 << "\",\n with a requested depth of <<
3309 if (requestedDepthOfDescent < 0) { <<
3310 G4cout << "<0 (unlimited)"; <<
3311 } <<
3312 else { <<
3313 G4cout << requestedDepthOfDescent; <<
3314 } <<
3315 G4cout << ",\n has been added to sce <<
3316 << G4endl; <<
3317 } <<
3318 } else { <<
3319 G4VisCommandsSceneAddUnsuccessful(verbo <<
3320 } <<
3321 } <<
3322 <<
3323 if (findingsVector.empty()) { <<
3324 if (verbosity >= G4VisManager::errors) { <<
3325 G4warn << "ERROR: Volume \"" << name << <<
3326 if (copyNo >= 0) { <<
3327 G4warn << ", copy no. " << copyNo << <<
3328 } <<
3329 G4warn << " not found." << G4endl; <<
3330 } 283 }
3331 G4VisCommandsSceneAddUnsuccessful(verbosi <<
3332 return; 284 return;
3333 } 285 }
3334 <<
3335 CheckSceneAndNotifyHandlers(pScene); <<
3336 } <<
3337 <<
3338 ///////////////////////////////////////////// <<
3339 ////////////// /vis/scene/add/plotter /////// <<
3340 ///////////////////////////////////////////// <<
3341 G4VisCommandSceneAddPlotter::G4VisCommandScen <<
3342 fpCommand = new G4UIcommand("/vis/scene/add <<
3343 fpCommand -> SetGuidance ("Add a plotter to <<
3344 286
3345 G4UIparameter* parameter; << 287 G4ParticleDefinition* currentParticle =
3346 parameter = new G4UIparameter ("plotter", << 288 theParticleTable->FindParticle(newValue);
3347 fpCommand->SetParameter(parameter); << 289 if (currentParticle == NULL) {
3348 } << 290 G4cout << "\"" << newValue << "\": not found this particle name!" << G4endl;
3349 <<
3350 G4VisCommandSceneAddPlotter::~G4VisCommandSce <<
3351 <<
3352 G4String G4VisCommandSceneAddPlotter::GetCurr <<
3353 <<
3354 void G4VisCommandSceneAddPlotter::SetNewValue <<
3355 { <<
3356 G4VisManager::Verbosity verbosity = fpVisMa <<
3357 G4bool warn(verbosity >= G4VisManager::warn <<
3358 <<
3359 G4Scene* pScene = fpVisManager->GetCurrentS <<
3360 if (!pScene) { <<
3361 if (verbosity >= G4VisManager::errors) { <<
3362 G4warn << "ERROR: No current scene. Pl <<
3363 } <<
3364 return; 291 return;
3365 } 292 }
3366 293
3367 G4Plotter& _plotter = G4PlotterManager::Get << 294 G4VFlavoredParallelWorld* worldForThis;
3368 G4VModel* model = new G4PlotterModel(_plott << 295 if(worldForThis=theGlobalFastSimulationManager->
3369 << 296 GetFlavoredWorldForThis(currentParticle)) {
3370 const G4String& currentSceneName = pScene - << 297 G4bool successful = pCurrentScene -> AddRunDurationModel
3371 G4bool successful = pScene -> AddEndOfRunMo << 298 (new G4FlavoredParallelWorldModel (worldForThis));
3372 if (successful) { << 299 UpdateVisManagerScene (currentSceneName);
3373 if (verbosity >= G4VisManager::confirmati << 300 if (successful) {
3374 G4cout << 301 G4cout << "Ghosts added to the Scene, refresh the view to see it."
3375 << "Plotter \"" << model->GetCurrentDes << 302 << G4endl;
3376 << "\" has been added to scene \"" << c <<
3377 << G4endl; <<
3378 } 303 }
3379 } 304 }
3380 else G4VisCommandsSceneAddUnsuccessful(verb << 305 else G4cout << "There are no ghosts for \""<<newValue<<"\""<<G4endl;
3381 <<
3382 CheckSceneAndNotifyHandlers (pScene); <<
3383 } 306 }
3384 <<
3385 307