Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/management/src/G4VisCommandsSceneAdd.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

  1 //
  2 // ********************************************************************
  3 // * License and Disclaimer                                           *
  4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.                             *
 10 // *                                                                  *
 11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                                                  *
 18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // ********************************************************************
 25 //
 26 //
 27 // /vis/scene/add commands - John Allison  9th August 1998
 28 
 29 #include "G4VisCommandsSceneAdd.hh"
 30 
 31 #include "G4TransportationManager.hh"
 32 #include "G4LogicalVolumeStore.hh"
 33 #include "G4PhysicalVolumeModel.hh"
 34 #include "G4LogicalVolumeModel.hh"
 35 #include "G4ModelingParameters.hh"
 36 #include "G4HitsModel.hh"
 37 #include "G4DigiModel.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"
 49 #include "G4ParticleDefinition.hh"
 50 #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"
 59 #include "G4UIcmdWithAString.hh"
 60 #include "G4UIcmdWithoutParameter.hh"
 61 #include "G4UIcmdWithAnInteger.hh"
 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::G4VisCommandSceneAddArrow () {
 90   fpCommand = new G4UIcommand("/vis/scene/add/arrow", this);
 91   fpCommand -> SetGuidance ("Adds arrow to current scene.");
 92   G4bool omitable;
 93   G4UIparameter* parameter;
 94   parameter = new G4UIparameter ("x1", 'd', omitable = false);
 95   fpCommand -> SetParameter (parameter);
 96   parameter = new G4UIparameter ("y1", 'd', omitable = false);
 97   fpCommand -> SetParameter (parameter);
 98   parameter = new G4UIparameter ("z1", 'd', omitable = false);
 99   fpCommand -> SetParameter (parameter);
100   parameter = new G4UIparameter ("x2", 'd', omitable = false);
101   fpCommand -> SetParameter (parameter);
102   parameter = new G4UIparameter ("y2", 'd', omitable = false);
103   fpCommand -> SetParameter (parameter);
104   parameter = new G4UIparameter ("z2", 'd', omitable = false);
105   fpCommand -> SetParameter (parameter);
106   parameter =  new G4UIparameter ("unit", 's', omitable = true);
107   parameter->SetDefaultValue ("m");
108   fpCommand->SetParameter    (parameter);
109 }
110 
111 G4VisCommandSceneAddArrow::~G4VisCommandSceneAddArrow () {
112   delete fpCommand;
113 }
114 
115 G4String G4VisCommandSceneAddArrow::GetCurrentValue (G4UIcommand*) {
116   return "";
117 }
118 
119 void G4VisCommandSceneAddArrow::SetNewValue (G4UIcommand*, G4String newValue)
120 {
121   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
122   G4bool warn(verbosity >= G4VisManager::warnings);
123 
124   G4Scene* pScene = fpVisManager->GetCurrentScene();
125   if (!pScene) {
126     if (verbosity >= G4VisManager::errors) {
127       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
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 >> unitString;
136   G4double unit = G4UIcommand::ValueOf(unitString);
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->GetExtent();
142   G4double arrowWidth =
143     0.005 * fCurrentLineWidth * sceneExtent.GetExtentRadius();
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 -> GetName ();
151   G4bool successful = pScene -> AddRunDurationModel (model, warn);
152   if (successful) {
153     if (verbosity >= G4VisManager::confirmations) {
154       G4cout << "Arrow has been added to scene \""
155        << currentSceneName << "\"."
156        << G4endl;
157     }
158   }
159   else G4VisCommandsSceneAddUnsuccessful(verbosity);
160 
161   CheckSceneAndNotifyHandlers (pScene);
162 }
163 
164 ////////////// /vis/scene/add/arrow2D ///////////////////////////////////////
165 
166 G4VisCommandSceneAddArrow2D::G4VisCommandSceneAddArrow2D () {
167   fpCommand = new G4UIcommand("/vis/scene/add/arrow2D", this);
168   fpCommand -> SetGuidance ("Adds 2D arrow to current scene.");
169   fpCommand -> SetGuidance ("x,y in range [-1,1]");
170   G4bool omitable;
171   G4UIparameter* parameter;
172   parameter = new G4UIparameter ("x1", 'd', omitable = false);
173   fpCommand -> SetParameter (parameter);
174   parameter = new G4UIparameter ("y1", 'd', omitable = false);
175   fpCommand -> SetParameter (parameter);
176   parameter = new G4UIparameter ("x2", 'd', omitable = false);
177   fpCommand -> SetParameter (parameter);
178   parameter = new G4UIparameter ("y2", 'd', omitable = false);
179   fpCommand -> SetParameter (parameter);
180 }
181 
182 G4VisCommandSceneAddArrow2D::~G4VisCommandSceneAddArrow2D () {
183   delete fpCommand;
184 }
185 
186 G4String G4VisCommandSceneAddArrow2D::GetCurrentValue (G4UIcommand*) {
187   return "";
188 }
189 
190 void G4VisCommandSceneAddArrow2D::SetNewValue (G4UIcommand*, G4String newValue)
191 {
192   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
193   G4bool warn(verbosity >= G4VisManager::warnings);
194 
195   G4Scene* pScene = fpVisManager->GetCurrentScene();
196   if (!pScene) {
197     if (verbosity >= G4VisManager::errors) {
198       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
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, fCurrentColour);
209   G4VModel* model =
210     new G4CallbackModel<G4VisCommandSceneAddArrow2D::Arrow2D>(arrow2D);
211   model->SetType("Arrow2D");
212   model->SetGlobalTag("Arrow2D");
213   model->SetGlobalDescription("Arrow2D: " + newValue);
214   const G4String& currentSceneName = pScene -> GetName ();
215   G4bool successful = pScene -> AddRunDurationModel (model, warn);
216   if (successful) {
217     if (verbosity >= G4VisManager::confirmations) {
218       G4cout << "A 2D arrow has been added to scene \""
219        << currentSceneName << "\"."
220        << G4endl;
221     }
222   }
223   else G4VisCommandsSceneAddUnsuccessful(verbosity);
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,y2-y1,0).unit();
237   G4Vector3D arrowPointLeftDirection(arrowDirection);
238   arrowPointLeftDirection.rotateZ(150.*deg);
239   G4Vector3D arrowPointRightDirection(arrowDirection);
240   arrowPointRightDirection.rotateZ(-150.*deg);
241   fHeadPolyline.push_back(G4Point3D(x2,y2,0)+0.04*arrowPointLeftDirection);
242   fHeadPolyline.push_back(G4Point3D(x2,y2,0));
243   fHeadPolyline.push_back(G4Point3D(x2,y2,0)+0.04*arrowPointRightDirection);
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::operator()
252   (G4VGraphicsScene& sceneHandler, const G4ModelingParameters*)
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::G4VisCommandSceneAddAxes () {
263   G4bool omitable;
264   fpCommand = new G4UIcommand ("/vis/scene/add/axes", this);
265   fpCommand -> SetGuidance ("Add axes.");
266   fpCommand -> SetGuidance
267   ("Draws axes at (x0, y0, z0) of given length and colour.");
268   fpCommand -> SetGuidance
269   ("If \"colour-string\" is \"auto\", x, y and z will be red, green and blue"
270    "\n  respectively.  Otherwise it can be one of the pre-defined text-specified"
271    "\n  colours - see information printed by the vis manager at start-up or"
272    "\n  use \"/vis/list\".");
273   fpCommand -> SetGuidance
274   ("If \"length\" is negative, it is set to about 25% of scene extent.");
275   fpCommand -> SetGuidance
276   ("If \"showtext\" is false, annotations are suppressed.");
277   G4UIparameter* parameter;
278   parameter =  new G4UIparameter ("x0", 'd', omitable = true);
279   parameter->SetDefaultValue (0.);
280   fpCommand->SetParameter (parameter);
281   parameter =  new G4UIparameter ("y0", 'd', omitable = true);
282   parameter->SetDefaultValue (0.);
283   fpCommand->SetParameter (parameter);
284   parameter =  new G4UIparameter ("z0", 'd', omitable = true);
285   parameter->SetDefaultValue (0.);
286   fpCommand->SetParameter (parameter);
287   parameter =  new G4UIparameter ("length", 'd', omitable = true);
288   parameter->SetDefaultValue (-1.);
289   fpCommand->SetParameter (parameter);
290   parameter =  new G4UIparameter ("unit", 's', omitable = true);
291   parameter->SetDefaultValue ("m");
292   fpCommand->SetParameter (parameter);
293   parameter =  new G4UIparameter ("colour-string", 's', omitable = true);
294   parameter->SetDefaultValue  ("auto");
295   fpCommand->SetParameter (parameter);
296   parameter =  new G4UIparameter ("showtext", 'b', omitable = true);
297   parameter->SetDefaultValue  ("true");
298   fpCommand->SetParameter (parameter);
299 }
300 
301 G4VisCommandSceneAddAxes::~G4VisCommandSceneAddAxes () {
302   delete fpCommand;
303 }
304 
305 G4String G4VisCommandSceneAddAxes::GetCurrentValue (G4UIcommand*) {
306   return "";
307 }
308 
309 void G4VisCommandSceneAddAxes::SetNewValue (G4UIcommand*, G4String newValue) {
310 
311   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
312   G4bool warn(verbosity >= G4VisManager::warnings);
313 
314   G4Scene* pScene = fpVisManager->GetCurrentScene();
315   if (!pScene) {
316     if (verbosity >= G4VisManager::errors) {
317       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
318     }
319     return;
320   } else {
321     if (pScene->GetExtent().GetExtentRadius() <= 0.) {
322       if (verbosity >= G4VisManager::errors) {
323         G4warn
324   << "ERROR: Scene has no extent. Add volumes or use \"/vis/scene/add/extent\"."
325         << G4endl;
326       }
327       return;
328     }
329   }
330 
331   G4String unitString, colourString, showTextString;
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(showTextString);
337 
338 
339   G4double unit = G4UIcommand::ValueOf(unitString);
340   x0 *= unit; y0 *= unit; z0 *= unit;
341   const G4VisExtent& sceneExtent = pScene->GetExtent();  // Existing extent.
342   if (length < 0.) {
343     const G4double lengthMax = 0.5 * sceneExtent.GetExtentRadius();
344     const G4double intLog10Length = std::floor(std::log10(lengthMax));
345     length = std::pow(10,intLog10Length);
346     if (5.*length < lengthMax) length *= 5.;
347     else if (2.*length < lengthMax) length *= 2.;
348   } else {
349     length *= unit;
350   }
351 
352   // Consult scene for arrow width...
353   G4double arrowWidth =
354     0.05 * fCurrentLineWidth * sceneExtent.GetExtentRadius();
355   // ...but limit it to length/30.
356   if (arrowWidth > length/30.) arrowWidth = length/30.;
357 
358   G4VModel* model = new G4AxesModel
359     (x0, y0, z0, length, arrowWidth, colourString, newValue,
360      showText, fCurrentTextSize);
361 
362   G4bool successful = pScene -> AddRunDurationModel (model, warn);
363   const G4String& currentSceneName = pScene -> GetName ();
364   if (successful) {
365     if (verbosity >= G4VisManager::confirmations) {
366       G4cout << "Axes of length " << G4BestUnit(length,"Length")
367       << "have been added to scene \"" << currentSceneName << "\"."
368       << G4endl;
369     }
370   }
371   else G4VisCommandsSceneAddUnsuccessful(verbosity);
372 
373   CheckSceneAndNotifyHandlers (pScene);
374 }
375 
376 ////////////// /vis/scene/add/date ///////////////////////////////////////
377 
378 G4VisCommandSceneAddDate::G4VisCommandSceneAddDate () {
379   G4bool omitable;
380   fpCommand = new G4UIcommand ("/vis/scene/add/date", this);
381   fpCommand -> SetGuidance ("Adds date to current scene.");
382   fpCommand -> SetGuidance
383   ("If \"date\"is omitted, the current date and time is drawn."
384    "\nOtherwise, the string, including the rest of the line, is drawn.");
385   G4UIparameter* parameter;
386   parameter = new G4UIparameter ("size", 'i', omitable = true);
387   parameter -> SetGuidance ("Screen size of text in pixels.");
388   parameter -> SetDefaultValue (18);
389   fpCommand -> SetParameter (parameter);
390   parameter = new G4UIparameter ("x-position", 'd', omitable = true);
391   parameter -> SetGuidance ("x screen position in range -1 < x < 1.");
392   parameter -> SetDefaultValue (0.95);
393   fpCommand -> SetParameter (parameter);
394   parameter = new G4UIparameter ("y-position", 'd', omitable = true);
395   parameter -> SetGuidance ("y screen position in range -1 < y < 1.");
396   parameter -> SetDefaultValue (0.9);
397   fpCommand -> SetParameter (parameter);
398   parameter = new G4UIparameter ("layout", 's', omitable = true);
399   parameter -> SetGuidance ("Layout, i.e., adjustment: left|centre|right.");
400   parameter -> SetDefaultValue ("right");
401   fpCommand -> SetParameter (parameter);
402   parameter = new G4UIparameter ("date", 's', omitable = true);
403   parameter -> SetDefaultValue ("-");
404   fpCommand -> SetParameter (parameter);
405 }
406 
407 G4VisCommandSceneAddDate::~G4VisCommandSceneAddDate () {
408   delete fpCommand;
409 }
410 
411 G4String G4VisCommandSceneAddDate::GetCurrentValue (G4UIcommand*) {
412   return "";
413 }
414 
415 void G4VisCommandSceneAddDate::SetNewValue (G4UIcommand*, G4String newValue)
416 {
417   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
418   G4bool warn(verbosity >= G4VisManager::warnings);
419 
420   G4Scene* pScene = fpVisManager->GetCurrentScene();
421   if (!pScene) {
422     if (verbosity >= G4VisManager::errors) {
423       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
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 >> dateString;
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 nothing remaining.
437   is.getline(remainder, NREMAINDER);
438   dateString += remainder;
439   G4Text::Layout layout = G4Text::right;
440   if (layoutString[0] == 'l') layout = G4Text::left;
441   else if (layoutString[0] == 'c') layout = G4Text::centre;
442   else if (layoutString[0] == 'r') layout = G4Text::right;
443 
444   Date* date = new Date(fpVisManager, size, x, y, layout, dateString);
445   G4VModel* model =
446     new G4CallbackModel<G4VisCommandSceneAddDate::Date>(date);
447   model->SetType("Date");
448   model->SetGlobalTag("Date");
449   model->SetGlobalDescription("Date: " + newValue);
450   const G4String& currentSceneName = pScene -> GetName ();
451   G4bool successful = pScene -> AddEndOfEventModel(model, warn);
452   if (successful) {
453     if (verbosity >= G4VisManager::confirmations) {
454       G4cout << "Date has been added to scene \""
455        << currentSceneName << "\"."
456        << G4endl;
457     }
458   }
459   else G4VisCommandsSceneAddUnsuccessful(verbosity);
460 
461   CheckSceneAndNotifyHandlers (pScene);
462 }
463 
464 void G4VisCommandSceneAddDate::Date::operator()
465   (G4VGraphicsScene& sceneHandler, const G4ModelingParameters*)
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 erase.
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::G4VisCommandSceneAddDigis () {
489   fpCommand = new G4UIcmdWithoutParameter ("/vis/scene/add/digis", this);
490   fpCommand -> SetGuidance ("Adds digis to current scene.");
491   fpCommand -> SetGuidance
492     ("Digis are drawn at end of event when the scene in which"
493      "\nthey are added is current.");
494 }
495 
496 G4VisCommandSceneAddDigis::~G4VisCommandSceneAddDigis () {
497   delete fpCommand;
498 }
499 
500 G4String G4VisCommandSceneAddDigis::GetCurrentValue (G4UIcommand*) {
501   return "";
502 }
503 
504 void G4VisCommandSceneAddDigis::SetNewValue (G4UIcommand*, G4String) {
505 
506   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
507   G4bool warn(verbosity >= G4VisManager::warnings);
508 
509   G4Scene* pScene = fpVisManager->GetCurrentScene();
510   if (!pScene) {
511     if (verbosity >= G4VisManager::errors) {
512       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
513     }
514     return;
515   }
516 
517   G4VModel* model = new G4DigiModel;
518   const G4String& currentSceneName = pScene -> GetName ();
519   G4bool successful = pScene -> AddEndOfEventModel (model, warn);
520   if (successful) {
521     if (verbosity >= G4VisManager::confirmations) {
522       G4cout << "Digis, if any, will be drawn at end of run in scene \""
523        << currentSceneName << "\"."
524        << G4endl;
525     }
526   }
527   else G4VisCommandsSceneAddUnsuccessful(verbosity);
528 
529   CheckSceneAndNotifyHandlers (pScene);
530 }
531 
532 ////////////// /vis/scene/add/electricField ///////////////////////////////////////
533 
534 G4VisCommandSceneAddElectricField::G4VisCommandSceneAddElectricField () {
535   G4bool omitable;
536   fpCommand = new G4UIcommand ("/vis/scene/add/electricField", this);
537   fpCommand -> SetGuidance
538   ("Adds electric field representation to current scene.");
539   fpCommand -> SetGuidance
540   ("The first parameter is no. of data points per half extent.  So, possibly, at"
541    "\nmaximum, the number of data points sampled is (2*n+1)^3, which can grow"
542    "\nlarge--be warned!"
543    "\nThe default value is 10, i.e., a 21x21x21 array, i.e., 9,261 sampling points."
544    "\nThat may swamp your view, but usually, a field is limited to a small part of"
545    "\nthe extent, so it's not a problem. But if it is, here are some of the things"
546    "\nyou can do:"
547    "\n- reduce the number of data points per half extent (first parameter);"
548    "\n- specify \"lightArrow\" (second parameter);"
549    "\n- restrict the region sampled with \"/vis/set/extentForField\";"
550    "\n- restrict the drawing to a specific volume with"
551    "\n    \"/vis/set/volumeForField\" or \"/vis/touchable/volumeForField\"."
552    "\nNote: you might have to deactivate existing field models with"
553    "\n  \"/vis/scene/activateModel Field false\" and re-issue"
554    "\n  \"/vis/scene/add/...Field\" command again.");
555   fpCommand -> SetGuidance
556   ("In the arrow representation, the length of the arrow is proportional"
557    "\nto the magnitude of the field and the colour is mapped onto the range"
558    "\nas a fraction of the maximum magnitude: 0->0.5->1 is red->green->blue.");
559   G4UIparameter* parameter;
560   parameter = new G4UIparameter ("nDataPointsPerHalfExtent", 'i', omitable = true);
561   parameter -> SetDefaultValue (10);
562   fpCommand -> SetParameter (parameter);
563   parameter = new G4UIparameter ("representation", 's', omitable = true);
564   parameter -> SetParameterCandidates("fullArrow lightArrow");
565   parameter -> SetDefaultValue ("fullArrow");
566   fpCommand -> SetParameter (parameter);
567 }
568 
569 G4VisCommandSceneAddElectricField::~G4VisCommandSceneAddElectricField () {
570   delete fpCommand;
571 }
572 
573 G4String G4VisCommandSceneAddElectricField::GetCurrentValue (G4UIcommand*) {
574   return "";
575 }
576 
577 void G4VisCommandSceneAddElectricField::SetNewValue
578 (G4UIcommand*, G4String newValue) {
579 
580   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
581   G4bool warn(verbosity >= G4VisManager::warnings);
582 
583   G4Scene* pScene = fpVisManager->GetCurrentScene();
584   if (!pScene) {
585     if (verbosity >= G4VisManager::errors) {
586       G4warn <<  "ERROR: No current scene.  Please create one." << G4endl;
587     }
588     return;
589   }
590 
591   G4int nDataPointsPerHalfExtent;
592   G4String representation;
593   std::istringstream iss(newValue);
594   iss >> nDataPointsPerHalfExtent >> representation;
595   G4ElectricFieldModel::Representation
596   modelRepresentation = G4ElectricFieldModel::fullArrow;
597   if (representation == "lightArrow") {
598     modelRepresentation = G4ElectricFieldModel::lightArrow;
599   }
600   G4VModel* model;
601   model = new G4ElectricFieldModel
602   (nDataPointsPerHalfExtent,modelRepresentation,
603    fCurrentArrow3DLineSegmentsPerCircle,
604    fCurrentExtentForField,
605    fCurrrentPVFindingsForField);
606   const G4String& currentSceneName = pScene -> GetName ();
607   G4bool successful = pScene -> AddRunDurationModel (model, warn);
608   if (successful) {
609     if (verbosity >= G4VisManager::confirmations) {
610       G4cout
611       << "Electric field, if any, will be drawn in scene \""
612       << currentSceneName
613       << "\"\n  with "
614       << nDataPointsPerHalfExtent
615       << " data points per half extent and with representation \""
616       << representation
617       << '\"'
618       << G4endl;
619     }
620   }
621   else G4VisCommandsSceneAddUnsuccessful(verbosity);
622 
623   CheckSceneAndNotifyHandlers (pScene);
624 }
625 
626 ////////////// /vis/scene/add/eventID ///////////////////////////////////////
627 
628 G4VisCommandSceneAddEventID::G4VisCommandSceneAddEventID () {
629   G4bool omitable;
630   fpCommand = new G4UIcommand ("/vis/scene/add/eventID", this);
631   fpCommand -> SetGuidance ("Adds eventID to current scene.");
632   fpCommand -> SetGuidance
633     ("Run and event numbers are drawn at end of event or run when"
634      "\n the scene in which they are added is current.");
635   G4UIparameter* parameter;
636   parameter = new G4UIparameter ("size", 'i', omitable = true);
637   parameter -> SetGuidance ("Screen size of text in pixels.");
638   parameter -> SetDefaultValue (18);
639   fpCommand -> SetParameter (parameter);
640   parameter = new G4UIparameter ("x-position", 'd', omitable = true);
641   parameter -> SetGuidance ("x screen position in range -1 < x < 1.");
642   parameter -> SetDefaultValue (-0.95);
643   fpCommand -> SetParameter (parameter);
644   parameter = new G4UIparameter ("y-position", 'd', omitable = true);
645   parameter -> SetGuidance ("y screen position in range -1 < y < 1.");
646   parameter -> SetDefaultValue (0.9);
647   fpCommand -> SetParameter (parameter);
648   parameter = new G4UIparameter ("layout", 's', omitable = true);
649   parameter -> SetGuidance ("Layout, i.e., adjustment: left|centre|right.");
650   parameter -> SetDefaultValue ("left");
651   fpCommand -> SetParameter (parameter);
652 }
653 
654 G4VisCommandSceneAddEventID::~G4VisCommandSceneAddEventID () {
655   delete fpCommand;
656 }
657 
658 G4String G4VisCommandSceneAddEventID::GetCurrentValue (G4UIcommand*) {
659   return "";
660 }
661 
662 void G4VisCommandSceneAddEventID::SetNewValue (G4UIcommand*, G4String newValue)
663 {
664   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
665   G4bool warn(verbosity >= G4VisManager::warnings);
666 
667   G4Scene* pScene = fpVisManager->GetCurrentScene();
668   if (!pScene) {
669     if (verbosity >= G4VisManager::errors) {
670       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
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::left;
683   else if (layoutString[0] == 'c') layout = G4Text::centre;
684   else if (layoutString[0] == 'r') layout = G4Text::right;
685 
686   // For End of Event (only for reviewing kept events one by one)
687   EventID* eoeEventID
688   = new EventID(forEndOfEvent, fpVisManager, size, x, y, layout);
689   G4VModel* eoeModel =
690     new G4CallbackModel<G4VisCommandSceneAddEventID::EventID>(eoeEventID);
691   eoeModel->SetType("EoEEventID");
692   eoeModel->SetGlobalTag("EoEEventID");
693   eoeModel->SetGlobalDescription("EoEEventID: " + newValue);
694   G4bool successfulEoE = pScene -> AddEndOfEventModel (eoeModel, warn);
695 
696   // For End of Run
697   EventID* eorEventID
698   = new EventID(forEndOfRun, fpVisManager, size, x, y, layout);
699   G4VModel* eorModel =
700   new G4CallbackModel<G4VisCommandSceneAddEventID::EventID>(eorEventID);
701   eorModel->SetType("EoREventID");
702   eorModel->SetGlobalTag("EoREventID");
703   eorModel->SetGlobalDescription("EoREventID: " + newValue);
704   G4bool successfulEoR = pScene -> AddEndOfRunModel (eorModel, warn);
705 
706   if (successfulEoE && successfulEoR) {
707     if (verbosity >= G4VisManager::confirmations) {
708       const G4String& currentSceneName = pScene -> GetName ();
709       G4cout << "EventID has been added to scene \""
710       << currentSceneName << "\"."
711       << G4endl;
712     }
713   }
714   else G4VisCommandsSceneAddUnsuccessful(verbosity);
715 
716   CheckSceneAndNotifyHandlers (pScene);
717 }
718 
719 void G4VisCommandSceneAddEventID::EventID::operator()
720 (G4VGraphicsScene& sceneHandler, const G4ModelingParameters* mp)
721 {
722   G4RunManager* runManager = G4RunManagerFactory::GetMasterRunManager();
723   if(!runManager)
724     return;
725 
726   const G4Run* currentRun = runManager->GetCurrentRun();
727   if (!currentRun) return;
728 
729   const G4int currentRunID = currentRun->GetRunID();
730 
731   std::ostringstream oss;
732   switch (fForWhat) {
733     case forEndOfEvent:
734     {
735       // Only use if reviewing kept events
736       if (!fpVisManager->GetReviewingKeptEvents()) return;
737       const G4Event* currentEvent = mp->GetEvent();
738       if (!currentEvent) return;
739       G4int eventID = currentEvent->GetEventID();
740       oss << "Run " << currentRunID << " Event " << eventID;
741       break;
742     }
743     case forEndOfRun:
744     {
745       // Only use if NOT reviewing kept events
746       if (fpVisManager->GetReviewingKeptEvents()) return;
747       const G4int nEvents = currentRun->GetNumberOfEventToBeProcessed();
748       size_t nKeptEvents = (size_t)(currentRun->GetNumberOfKeptEvents());
749       oss << "Run " << currentRunID << " (" << nEvents << " event";
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::G4VisCommandSceneAddExtent () {
771   fpCommand = new G4UIcommand("/vis/scene/add/extent", this);
772   fpCommand -> SetGuidance
773   ("Adds a dummy model with given extent to the current scene."
774    "\nRequires the limits: xmin, xmax, ymin, ymax, zmin, zmax unit."
775    "\nThis can be used to provide an extent to the scene even if"
776    "\nno other models with extent are available. For example,"
777    "\neven if there is no geometry.  In that case, for example:"
778    "\n  /vis/open OGL"
779    "\n  /vis/scene/create"
780    "\n  /vis/scene/add/extent -300 300 -300 300 -300 300 cm"
781    "\n  /vis/sceneHandler/attach");
782   G4bool omitable;
783   G4UIparameter* parameter;
784   parameter = new G4UIparameter ("xmin", 'd', omitable = true);
785   parameter -> SetDefaultValue (0.);
786   fpCommand -> SetParameter (parameter);
787   parameter = new G4UIparameter ("xmax", 'd', omitable = true);
788   parameter -> SetDefaultValue (0.);
789   fpCommand -> SetParameter (parameter);
790   parameter = new G4UIparameter ("ymin", 'd', omitable = true);
791   parameter -> SetDefaultValue (0.);
792   fpCommand -> SetParameter (parameter);
793   parameter = new G4UIparameter ("ymax", 'd', omitable = true);
794   parameter -> SetDefaultValue (0.);
795   fpCommand -> SetParameter (parameter);
796   parameter = new G4UIparameter ("zmin", 'd', omitable = true);
797   parameter -> SetDefaultValue (0.);
798   fpCommand -> SetParameter (parameter);
799   parameter = new G4UIparameter ("zmax", 'd', omitable = true);
800   parameter -> SetDefaultValue (0.);
801   fpCommand -> SetParameter (parameter);
802   parameter =  new G4UIparameter ("unit", 's', omitable = true);
803   parameter -> SetDefaultValue ("m");
804   fpCommand -> SetParameter (parameter);
805 }
806 
807 G4VisCommandSceneAddExtent::~G4VisCommandSceneAddExtent () {
808   delete fpCommand;
809 }
810 
811 G4String G4VisCommandSceneAddExtent::GetCurrentValue (G4UIcommand*) {
812   return "";
813 }
814 
815 void G4VisCommandSceneAddExtent::SetNewValue (G4UIcommand*, G4String newValue)
816 {
817   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
818   G4bool warn(verbosity >= G4VisManager::warnings);
819 
820   G4Scene* pScene = fpVisManager->GetCurrentScene();
821   if (!pScene) {
822     if (verbosity >= G4VisManager::errors) {
823       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
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 >> zmax >> unitString;
832   G4double unit = G4UIcommand::ValueOf(unitString);
833   xmin *= unit; xmax *= unit;
834   ymin *= unit; ymax *= unit;
835   zmin *= unit; zmax *= unit;
836 
837   G4VisExtent visExtent(xmin, xmax, ymin, ymax, zmin, zmax);
838   Extent* extent = new Extent(xmin, xmax, ymin, ymax, zmin, zmax);
839   G4VModel* model =
840   new G4CallbackModel<G4VisCommandSceneAddExtent::Extent>(extent);
841   model->SetType("Extent");
842   model->SetGlobalTag("Extent");
843   model->SetGlobalDescription("Extent: " + newValue);
844   model->SetExtent(visExtent);
845   const G4String& currentSceneName = pScene -> GetName ();
846   G4bool successful = pScene -> AddRunDurationModel (model, warn);
847   if (successful) {
848     if (verbosity >= G4VisManager::confirmations) {
849       G4cout << "A benign model with extent "
850       << visExtent
851       << " has been added to scene \""
852        << currentSceneName << "\"."
853        << G4endl;
854     }
855   }
856   else G4VisCommandsSceneAddUnsuccessful(verbosity);
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::operator()
869 (G4VGraphicsScene&, const G4ModelingParameters*)
870 {}
871 
872 ////////////// /vis/scene/add/frame ///////////////////////////////////////
873 
874 G4VisCommandSceneAddFrame::G4VisCommandSceneAddFrame () {
875   fpCommand = new G4UIcommand("/vis/scene/add/frame", this);
876   fpCommand -> SetGuidance ("Add frame to current scene.");
877   G4bool omitable;
878   G4UIparameter* parameter;
879   parameter = new G4UIparameter ("size", 'd', omitable = true);
880   parameter -> SetGuidance ("Size of frame.  1 = full window.");
881   parameter -> SetParameterRange ("size > 0 && size <=1");
882   parameter -> SetDefaultValue (0.97);
883   fpCommand -> SetParameter (parameter);
884 }
885 
886 G4VisCommandSceneAddFrame::~G4VisCommandSceneAddFrame () {
887   delete fpCommand;
888 }
889 
890 G4String G4VisCommandSceneAddFrame::GetCurrentValue (G4UIcommand*) {
891   return "";
892 }
893 
894 void G4VisCommandSceneAddFrame::SetNewValue (G4UIcommand*, G4String newValue)
895 {
896   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
897   G4bool warn(verbosity >= G4VisManager::warnings);
898 
899   G4Scene* pScene = fpVisManager->GetCurrentScene();
900   if (!pScene) {
901     if (verbosity >= G4VisManager::errors) {
902       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
903     }
904     return;
905   }
906 
907   G4double size;
908   std::istringstream is(newValue);
909   is >> size;
910 
911   Frame* frame = new Frame(size, fCurrentLineWidth, fCurrentColour);
912   G4VModel* model =
913     new G4CallbackModel<G4VisCommandSceneAddFrame::Frame>(frame);
914   model->SetType("Frame");
915   model->SetGlobalTag("Frame");
916   model->SetGlobalDescription("Frame: " + newValue);
917   const G4String& currentSceneName = pScene -> GetName ();
918   G4bool successful = pScene -> AddRunDurationModel (model, warn);
919   if (successful) {
920     if (verbosity >= G4VisManager::confirmations) {
921       G4cout << "Frame has been added to scene \""
922        << currentSceneName << "\"."
923        << G4endl;
924     }
925   }
926   else G4VisCommandsSceneAddUnsuccessful(verbosity);
927 
928   CheckSceneAndNotifyHandlers (pScene);
929 }
930 
931 void G4VisCommandSceneAddFrame::Frame::operator()
932   (G4VGraphicsScene& sceneHandler, const G4ModelingParameters*)
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::G4VisCommandSceneAddGPS () {
952   G4bool omitable;
953   G4UIparameter* parameter;
954   fpCommand = new G4UIcommand ("/vis/scene/add/gps", this);
955   fpCommand -> SetGuidance
956   ("A representation of the source(s) of the General Particle Source"
957    "\nwill be added to current scene and drawn, if applicable.");
958   fpCommand->SetGuidance(ConvertToColourGuidance());
959   fpCommand->SetGuidance("Default: red and transparent.");
960   parameter = new G4UIparameter("red_or_string", 's', omitable = true);
961   parameter -> SetDefaultValue ("1.");
962   fpCommand -> SetParameter (parameter);
963   parameter = new G4UIparameter("green", 'd', omitable = true);
964   parameter -> SetDefaultValue (0.);
965   fpCommand -> SetParameter (parameter);
966   parameter = new G4UIparameter ("blue", 'd', omitable = true);
967   parameter -> SetDefaultValue (0.);
968   fpCommand -> SetParameter (parameter);
969   parameter = new G4UIparameter ("opacity", 'd', omitable = true);
970   parameter -> SetDefaultValue (0.3);
971   fpCommand -> SetParameter (parameter);
972 }
973 
974 G4VisCommandSceneAddGPS::~G4VisCommandSceneAddGPS () {
975   delete fpCommand;
976 }
977 
978 G4String G4VisCommandSceneAddGPS::GetCurrentValue (G4UIcommand*) {
979   return "";
980 }
981 
982 void G4VisCommandSceneAddGPS::SetNewValue (G4UIcommand*, G4String newValue) {
983 
984   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
985   G4bool warn(verbosity >= G4VisManager::warnings);
986 
987   G4Scene* pScene = fpVisManager->GetCurrentScene();
988   if (!pScene) {
989     if (verbosity >= G4VisManager::errors) {
990       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
991     }
992     return;
993   }
994 
995   G4String redOrString;
996   G4double green, blue, opacity;
997   std::istringstream iss(newValue);
998   iss >> redOrString >> green >> blue >> opacity;
999   G4Colour colour(1.,0.,0.,0.3);  // Default red and transparent.
1000   ConvertToColour(colour, redOrString, green, blue, opacity);
1001 
1002   G4VModel* model = new G4GPSModel(colour);
1003   const G4String& currentSceneName = pScene -> GetName ();
1004   G4bool successful = pScene -> AddRunDurationModel (model, warn);
1005   if (successful) {
1006     if (verbosity >= G4VisManager::confirmations) {
1007       G4cout <<
1008       "A representation of the source(s) of the General Particle Source will be drawn"
1009       "\n  in colour " << colour << " for scene \""
1010       << currentSceneName << "\" if applicable."
1011       << G4endl;
1012     }
1013   }
1014   else G4VisCommandsSceneAddUnsuccessful(verbosity);
1015 
1016   CheckSceneAndNotifyHandlers (pScene);
1017 }
1018   
1019 ////////////// /vis/scene/add/hits ///////////////////////////////////////
1020 
1021 G4VisCommandSceneAddHits::G4VisCommandSceneAddHits () {
1022   fpCommand = new G4UIcmdWithoutParameter ("/vis/scene/add/hits", this);
1023   fpCommand -> SetGuidance ("Adds hits to current scene.");
1024   fpCommand -> SetGuidance
1025     ("Hits are drawn at end of event when the scene in which"
1026      "\nthey are added is current.");
1027 }
1028 
1029 G4VisCommandSceneAddHits::~G4VisCommandSceneAddHits () {
1030   delete fpCommand;
1031 }
1032 
1033 G4String G4VisCommandSceneAddHits::GetCurrentValue (G4UIcommand*) {
1034   return "";
1035 }
1036 
1037 void G4VisCommandSceneAddHits::SetNewValue (G4UIcommand*, G4String) {
1038 
1039   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1040   G4bool warn(verbosity >= G4VisManager::warnings);
1041 
1042   G4Scene* pScene = fpVisManager->GetCurrentScene();
1043   if (!pScene) {
1044     if (verbosity >= G4VisManager::errors) {
1045       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
1046     }
1047     return;
1048   }
1049 
1050   G4VModel* model = new G4HitsModel;
1051   const G4String& currentSceneName = pScene -> GetName ();
1052   G4bool successful = pScene -> AddEndOfEventModel (model, warn);
1053   if (successful) {
1054     if (verbosity >= G4VisManager::confirmations) {
1055       G4cout << "Hits, if any, will be drawn at end of run in scene \""
1056        << currentSceneName << "\"."
1057        << G4endl;
1058     }
1059   }
1060   else G4VisCommandsSceneAddUnsuccessful(verbosity);
1061 
1062   CheckSceneAndNotifyHandlers (pScene);
1063 }
1064 
1065 ////////////// /vis/scene/add/line ///////////////////////////////////////
1066 
1067 G4VisCommandSceneAddLine::G4VisCommandSceneAddLine () {
1068   fpCommand = new G4UIcommand("/vis/scene/add/line", this);
1069   fpCommand -> SetGuidance ("Adds line to current scene.");
1070   G4bool omitable;
1071   G4UIparameter* parameter;
1072   parameter = new G4UIparameter ("x1", 'd', omitable = false);
1073   fpCommand -> SetParameter (parameter);
1074   parameter = new G4UIparameter ("y1", 'd', omitable = false);
1075   fpCommand -> SetParameter (parameter);
1076   parameter = new G4UIparameter ("z1", 'd', omitable = false);
1077   fpCommand -> SetParameter (parameter);
1078   parameter = new G4UIparameter ("x2", 'd', omitable = false);
1079   fpCommand -> SetParameter (parameter);
1080   parameter = new G4UIparameter ("y2", 'd', omitable = false);
1081   fpCommand -> SetParameter (parameter);
1082   parameter = new G4UIparameter ("z2", 'd', omitable = false);
1083   fpCommand -> SetParameter (parameter);
1084   parameter =  new G4UIparameter ("unit", 's', omitable = true);
1085   parameter->SetDefaultValue ("m");
1086   fpCommand->SetParameter    (parameter);
1087 }
1088 
1089 G4VisCommandSceneAddLine::~G4VisCommandSceneAddLine () {
1090   delete fpCommand;
1091 }
1092 
1093 G4String G4VisCommandSceneAddLine::GetCurrentValue (G4UIcommand*) {
1094   return "";
1095 }
1096 
1097 void G4VisCommandSceneAddLine::SetNewValue (G4UIcommand*, G4String newValue)
1098 {
1099   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1100   G4bool warn(verbosity >= G4VisManager::warnings);
1101 
1102   G4Scene* pScene = fpVisManager->GetCurrentScene();
1103   if (!pScene) {
1104     if (verbosity >= G4VisManager::errors) {
1105       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
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 >> unitString;
1114   G4double unit = G4UIcommand::ValueOf(unitString);
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, z2,
1119       fCurrentLineWidth, fCurrentColour);
1120   G4VModel* model =
1121     new G4CallbackModel<G4VisCommandSceneAddLine::Line>(line);
1122   model->SetType("Line");
1123   model->SetGlobalTag("Line");
1124   model->SetGlobalDescription("Line: " + newValue);
1125   const G4String& currentSceneName = pScene -> GetName ();
1126   G4bool successful = pScene -> AddRunDurationModel (model, warn);
1127   if (successful) {
1128     if (verbosity >= G4VisManager::confirmations) {
1129       G4cout << "Line has been added to scene \""
1130        << currentSceneName << "\"."
1131        << G4endl;
1132     }
1133   }
1134   else G4VisCommandsSceneAddUnsuccessful(verbosity);
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 G4ModelingParameters*)
1155 {
1156   sceneHandler.BeginPrimitives();
1157   sceneHandler.AddPrimitive(fPolyline);
1158   sceneHandler.EndPrimitives();
1159 }
1160 
1161 ////////////// /vis/scene/add/line2D ///////////////////////////////////////
1162 
1163 G4VisCommandSceneAddLine2D::G4VisCommandSceneAddLine2D () {
1164   fpCommand = new G4UIcommand("/vis/scene/add/line2D", this);
1165   fpCommand -> SetGuidance ("Adds 2D line to current scene.");
1166   fpCommand -> SetGuidance ("x,y in range [-1,1]");
1167   G4bool omitable;
1168   G4UIparameter* parameter;
1169   parameter = new G4UIparameter ("x1", 'd', omitable = false);
1170   fpCommand -> SetParameter (parameter);
1171   parameter = new G4UIparameter ("y1", 'd', omitable = false);
1172   fpCommand -> SetParameter (parameter);
1173   parameter = new G4UIparameter ("x2", 'd', omitable = false);
1174   fpCommand -> SetParameter (parameter);
1175   parameter = new G4UIparameter ("y2", 'd', omitable = false);
1176   fpCommand -> SetParameter (parameter);
1177 }
1178 
1179 G4VisCommandSceneAddLine2D::~G4VisCommandSceneAddLine2D () {
1180   delete fpCommand;
1181 }
1182 
1183 G4String G4VisCommandSceneAddLine2D::GetCurrentValue (G4UIcommand*) {
1184   return "";
1185 }
1186 
1187 void G4VisCommandSceneAddLine2D::SetNewValue (G4UIcommand*, G4String newValue)
1188 {
1189   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1190   G4bool warn(verbosity >= G4VisManager::warnings);
1191 
1192   G4Scene* pScene = fpVisManager->GetCurrentScene();
1193   if (!pScene) {
1194     if (verbosity >= G4VisManager::errors) {
1195       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
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, fCurrentColour);
1206   G4VModel* model =
1207     new G4CallbackModel<G4VisCommandSceneAddLine2D::Line2D>(line2D);
1208   model->SetType("Line2D");
1209   model->SetGlobalTag("Line2D");
1210   model->SetGlobalDescription("Line2D: " + newValue);
1211   const G4String& currentSceneName = pScene -> GetName ();
1212   G4bool successful = pScene -> AddRunDurationModel (model, warn);
1213   if (successful) {
1214     if (verbosity >= G4VisManager::confirmations) {
1215       G4cout << "A 2D line has been added to scene \""
1216        << currentSceneName << "\"."
1217        << G4endl;
1218     }
1219   }
1220   else G4VisCommandsSceneAddUnsuccessful(verbosity);
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::operator()
1240   (G4VGraphicsScene& sceneHandler, const G4ModelingParameters*)
1241 {
1242   sceneHandler.BeginPrimitives2D();
1243   sceneHandler.AddPrimitive(fPolyline);
1244   sceneHandler.EndPrimitives2D();
1245 }
1246 
1247 ////////////// /vis/scene/add/localAxes ///////////////////////////////////////
1248 
1249 G4VisCommandSceneAddLocalAxes::G4VisCommandSceneAddLocalAxes () {
1250   G4bool omitable;
1251   fpCommand = new G4UIcommand ("/vis/scene/add/localAxes", this);
1252   fpCommand -> SetGuidance
1253   ("Adds local axes to physical volume(s).");
1254   G4UIparameter* parameter;
1255   parameter = new G4UIparameter ("physical-volume-name", 's', omitable = false);
1256   fpCommand -> SetParameter (parameter);
1257   parameter = new G4UIparameter ("copy-no", 'i', omitable = true);
1258   parameter -> SetGuidance ("If negative, matches any copy no.");
1259   parameter -> SetDefaultValue (-1);
1260   fpCommand -> SetParameter (parameter);
1261 }
1262 
1263 G4VisCommandSceneAddLocalAxes::~G4VisCommandSceneAddLocalAxes () {
1264   delete fpCommand;
1265 }
1266 
1267 G4String G4VisCommandSceneAddLocalAxes::GetCurrentValue (G4UIcommand*) {
1268   return "world 0 -1";
1269 }
1270 
1271 void G4VisCommandSceneAddLocalAxes::SetNewValue (G4UIcommand*,
1272              G4String newValue) {
1273 
1274   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1275   G4bool warn = verbosity >= G4VisManager::warnings;
1276 
1277   G4Scene* pScene = fpVisManager->GetCurrentScene();
1278   if (!pScene) {
1279     if (verbosity >= G4VisManager::errors) {
1280       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
1281     }
1282     return;
1283   }
1284 
1285   G4String name;
1286   G4int copyNo;
1287   std::istringstream is (newValue);
1288   is >> name >> copyNo;
1289 
1290   std::vector<G4PhysicalVolumesSearchScene::Findings> findingsVector;
1291 
1292   // Search all worlds...
1293   G4TransportationManager* transportationManager =
1294   G4TransportationManager::GetTransportationManager ();
1295   std::vector<G4VPhysicalVolume*>::iterator iterWorld =
1296   transportationManager->GetWorldsIterator();
1297   size_t nWorlds = transportationManager->GetNoWorlds();
1298   for (size_t i = 0; i < nWorlds; ++i, ++iterWorld) {
1299     G4ModelingParameters mp;  // Default - no culling.
1300     G4PhysicalVolumeModel searchModel
1301     (*iterWorld,
1302      G4PhysicalVolumeModel::UNLIMITED,
1303      G4Transform3D(),
1304      &mp,
1305      true);  // Use full extent (avoids initial descent of geometry tree)
1306     G4PhysicalVolumesSearchScene searchScene
1307     (&searchModel, name, copyNo);
1308     searchModel.DescribeYourselfTo (searchScene);  // Initiate search.
1309     for (const auto& findings: searchScene.GetFindings()) {
1310       findingsVector.push_back(findings);
1311     }
1312   }
1313 
1314   G4int id = 0;  // To distinguish axes models by their global description
1315   for (const auto& findings: findingsVector) {
1316 
1317     // Create axes model based on size and transformation of found volume(s).
1318     const auto& extent = findings.fpFoundPV->GetLogicalVolume()->GetSolid()->GetExtent();
1319     const auto& transform = findings.fFoundObjectTransformation;
1320 
1321     const G4double lengthMax = extent.GetExtentRadius()/2.;
1322     const G4double intLog10LengthMax = std::floor(std::log10(lengthMax));
1323     G4double length = std::pow(10,intLog10LengthMax);
1324     if (5.*length < lengthMax) length *= 5.;
1325     else if (2.*length < lengthMax) length *= 2.;
1326 
1327     const auto& axesModel = new G4AxesModel(0.,0.,0.,length,transform);
1328     axesModel->SetGlobalTag("LocalAxesModel");
1329     std::ostringstream oss; oss
1330     << "Local Axes for " << findings.fpFoundPV->GetName()
1331     << ':' << findings.fFoundPVCopyNo << ':' << id++;
1332     axesModel->SetGlobalDescription(oss.str());
1333     // ...so add it to the scene.
1334     G4bool successful = pScene->AddRunDurationModel(axesModel,warn);
1335     if (successful) {
1336       if (verbosity >= G4VisManager::confirmations) {
1337   G4cout << "\"" << findings.fpFoundPV->GetName()
1338   << "\", copy no. " << findings.fFoundPVCopyNo
1339   << ",\n  found in searched volume \""
1340   << findings.fpSearchPV->GetName()
1341   << "\" at depth " << findings.fFoundDepth
1342   << ",\n  base path: \"" << findings.fFoundBasePVPath
1343   << "\".\n  Local axes have been added to scene \""
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(verbosity);
1354     }
1355   }
1356 
1357   if (findingsVector.empty()) {
1358     if (verbosity >= G4VisManager::errors) {
1359       G4warn << "ERROR: Volume \"" << name << "\"";
1360       if (copyNo >= 0) {
1361   G4warn << ", copy no. " << copyNo << ",";
1362       }
1363       G4warn << " not found." << G4endl;
1364     }
1365     G4VisCommandsSceneAddUnsuccessful(verbosity);
1366     return;
1367   }
1368 
1369   CheckSceneAndNotifyHandlers(pScene);
1370 }
1371 
1372 ////////////// /vis/scene/add/logicalVolume //////////////////////////////////
1373 
1374 G4VisCommandSceneAddLogicalVolume::G4VisCommandSceneAddLogicalVolume () {
1375   G4bool omitable;
1376   fpCommand = new G4UIcommand ("/vis/scene/add/logicalVolume", this);
1377   fpCommand -> SetGuidance ("Adds a logical volume to the current scene,");
1378   fpCommand -> SetGuidance
1379   ("Shows boolean components (if any), voxels (if any), readout geometry"
1380    "\n  (if any), local axes and overlaps (if any), under control of the"
1381    "\n  appropriate flag."
1382    "\n  Note: voxels are not constructed until start of run -"
1383    "\n \"/run/beamOn\".  (For voxels without a run, \"/run/beamOn 0\".)");
1384   G4UIparameter* parameter;
1385   parameter = new G4UIparameter ("logical-volume-name", 's', omitable = false);
1386   fpCommand -> SetParameter (parameter);
1387   parameter = new G4UIparameter ("depth-of-descent", 'i', omitable = true);
1388   parameter -> SetGuidance ("Depth of descent of geometry hierarchy.");
1389   parameter -> SetDefaultValue (1);
1390   fpCommand -> SetParameter (parameter);
1391   parameter = new G4UIparameter ("booleans-flag", 'b', omitable = true);
1392   parameter -> SetDefaultValue (true);
1393   fpCommand -> SetParameter (parameter);
1394   parameter = new G4UIparameter ("voxels-flag", 'b', omitable = true);
1395   parameter -> SetDefaultValue (true);
1396   fpCommand -> SetParameter (parameter);
1397   parameter = new G4UIparameter ("readout-flag", 'b', omitable = true);
1398   parameter -> SetDefaultValue (true);
1399   fpCommand -> SetParameter (parameter);
1400   parameter = new G4UIparameter ("axes-flag", 'b', omitable = true);
1401   parameter -> SetDefaultValue (true);
1402   parameter -> SetGuidance ("Set \"false\" to suppress axes.");
1403   fpCommand -> SetParameter (parameter);
1404   parameter = new G4UIparameter("check-overlap-flag", 'b', omitable = true);
1405   parameter->SetDefaultValue(true);
1406   parameter -> SetGuidance ("Set \"false\" to suppress overlap check.");
1407   fpCommand->SetParameter(parameter);
1408 }
1409 
1410 G4VisCommandSceneAddLogicalVolume::~G4VisCommandSceneAddLogicalVolume () {
1411   delete fpCommand;
1412 }
1413 
1414 G4String G4VisCommandSceneAddLogicalVolume::GetCurrentValue (G4UIcommand*) {
1415   return "";
1416 }
1417 
1418 void G4VisCommandSceneAddLogicalVolume::SetNewValue (G4UIcommand*,
1419                  G4String newValue) {
1420 
1421   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1422   G4bool warn(verbosity >= G4VisManager::warnings);
1423 
1424   G4Scene* pScene = fpVisManager->GetCurrentScene();
1425   if (!pScene) {
1426     if (verbosity >= G4VisManager::errors) {
1427       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
1428     }
1429     return;
1430   }
1431 
1432   G4String name;
1433   G4int requestedDepthOfDescent;
1434   G4String booleansString, voxelsString, readoutString, axesString;
1435   G4String overlapString;
1436   std::istringstream is (newValue);
1437   is >> name >> requestedDepthOfDescent
1438      >>  booleansString >> voxelsString >> readoutString >> axesString
1439      >> overlapString;
1440   G4bool booleans = G4UIcommand::ConvertToBool(booleansString);
1441   G4bool voxels = G4UIcommand::ConvertToBool(voxelsString);
1442   G4bool readout = G4UIcommand::ConvertToBool(readoutString);
1443   G4bool axes = G4UIcommand::ConvertToBool(axesString);
1444   G4bool checkOverlaps = G4UIcommand::ConvertToBool(overlapString);
1445 
1446   G4LogicalVolumeStore *pLVStore = G4LogicalVolumeStore::GetInstance();
1447   G4LogicalVolume* pLV = nullptr;
1448   pLV = pLVStore->GetVolume(name);
1449   if (pLV == nullptr) return;  // Volume not found; warning message thrown
1450 
1451   const std::vector<G4Scene::Model>& rdModelList =
1452     pScene -> GetRunDurationModelList();
1453   std::vector<G4Scene::Model>::const_iterator i;
1454   for (i = rdModelList.begin(); i != rdModelList.end(); ++i) {
1455     if (i->fpModel->GetGlobalDescription().find("Volume") != std::string::npos) break;
1456   }
1457   if (i != rdModelList.end()) {
1458     if (verbosity >= G4VisManager::errors) {
1459       G4warn << "There is already a volume, \""
1460              << i->fpModel->GetGlobalDescription()
1461              << "\",\n in the run-duration model list of scene \""
1462              << pScene -> GetName()
1463              << "\".\n Your logical volume must be the only volume in the scene."
1464        << "\n Create a new scene and try again:"
1465        << "\n  /vis/specify " << name
1466        << "\n or"
1467        << "\n  /vis/scene/create"
1468        << "\n  /vis/scene/add/logicalVolume " << name
1469        << "\n  /vis/sceneHandler/attach"
1470        << "\n (and also, if necessary, /vis/viewer/flush)"
1471              << G4endl;
1472     }
1473     return;
1474   }
1475 
1476   G4LogicalVolumeModel* model = new G4LogicalVolumeModel
1477     (pLV, requestedDepthOfDescent, booleans, voxels, readout, checkOverlaps);
1478   const G4String& currentSceneName = pScene -> GetName ();
1479   G4bool successful = pScene -> AddRunDurationModel (model, warn);
1480 
1481   if (successful) {
1482 
1483     G4bool axesSuccessful = false;
1484     if (axes) {
1485       const G4double radius = model->GetExtent().GetExtentRadius();
1486       const G4double axisLengthMax = radius / 2.;
1487       const G4double intLog10Length = std::floor(std::log10(axisLengthMax));
1488       G4double axisLength = std::pow(10,intLog10Length);
1489       if (5.*axisLength < axisLengthMax) axisLength *= 5.;
1490       else if (2.*axisLength < axisLengthMax) axisLength *= 2.;
1491       const G4double axisWidth = axisLength / 20.;
1492       G4VModel* axesModel = new G4AxesModel(0.,0.,0.,axisLength,axisWidth);
1493       axesSuccessful = pScene -> AddRunDurationModel (axesModel, warn);
1494     }
1495 
1496 //    if (verbosity >= G4VisManager::warnings) {
1497 //      const std::map<G4String,G4AttDef>* attDefs = model->GetAttDefs();
1498 //      std::vector<G4AttValue>* attValues = model->CreateCurrentAttValues();
1499 //      G4warn << G4AttCheck(attValues, attDefs);
1500 //      delete attValues;
1501 //    }
1502 
1503     if (verbosity >= G4VisManager::confirmations) {
1504       G4cout << "Logical volume \"" << pLV -> GetName ()
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 \"" << currentSceneName << "\".";
1517       if (axes) {
1518         if (axesSuccessful) {
1519           G4cout <<
1520           "\n  Axes have also been added at the origin of local cooordinates.";
1521         } else {
1522           G4cout <<
1523           "\n  Axes have not been added for some reason possibly stated above.";
1524         }
1525       }
1526       G4cout << G4endl;
1527     }
1528   }
1529   else {
1530     G4VisCommandsSceneAddUnsuccessful(verbosity);
1531     return;
1532   }
1533 
1534   CheckSceneAndNotifyHandlers (pScene);
1535 }
1536 
1537 
1538 ////////////// /vis/scene/add/logo //////////////////////////////////
1539 
1540 G4VisCommandSceneAddLogo::G4VisCommandSceneAddLogo () {
1541   G4bool omitable;
1542   fpCommand = new G4UIcommand ("/vis/scene/add/logo", this);
1543   fpCommand -> SetGuidance ("Adds a G4 logo to the current scene.");
1544   fpCommand -> SetGuidance
1545   ("If \"unit\" is \"auto\", height is roughly one tenth of scene extent.");
1546   fpCommand -> SetGuidance
1547   ("\"direction\" is that of outward-facing normal to front face of logo."
1548    "\nIf \"direction\" is \"auto\", logo faces the user in the current viewer.");
1549   fpCommand -> SetGuidance
1550   ("\nIf \"placement\" is \"auto\", logo is placed at bottom right of screen"
1551    "\n  when viewed from logo direction.");
1552   G4UIparameter* parameter;
1553   parameter = new G4UIparameter ("height", 'd', omitable = true);
1554   parameter->SetDefaultValue (1.);
1555   fpCommand->SetParameter (parameter);
1556   parameter =  new G4UIparameter ("unit", 's', omitable = true);
1557   parameter->SetDefaultValue ("auto");
1558   fpCommand->SetParameter (parameter);
1559   parameter =  new G4UIparameter ("direction", 's', omitable = true);
1560   parameter->SetGuidance ("auto|[-]x|[-]y|[-]z");
1561   parameter->SetDefaultValue ("auto");
1562   fpCommand->SetParameter (parameter);
1563   parameter =  new G4UIparameter ("red", 'd', omitable = true);
1564   parameter->SetDefaultValue (0.);
1565   fpCommand->SetParameter (parameter);
1566   parameter =  new G4UIparameter ("green", 'd', omitable = true);
1567   parameter->SetDefaultValue (1.);
1568   fpCommand->SetParameter (parameter);
1569   parameter =  new G4UIparameter ("blue", 'd', omitable = true);
1570   parameter->SetDefaultValue (0.);
1571   fpCommand->SetParameter (parameter);
1572   parameter =  new G4UIparameter ("placement", 's', omitable = true);
1573   parameter -> SetParameterCandidates("auto manual");
1574   parameter->SetDefaultValue  ("auto");
1575   fpCommand->SetParameter     (parameter);
1576   parameter =  new G4UIparameter ("xmid", 'd', omitable = true);
1577   parameter->SetDefaultValue (0.);
1578   fpCommand->SetParameter (parameter);
1579   parameter =  new G4UIparameter ("ymid", 'd', omitable = true);
1580   parameter->SetDefaultValue (0.);
1581   fpCommand->SetParameter (parameter);
1582   parameter =  new G4UIparameter ("zmid", 'd', omitable = true);
1583   parameter->SetDefaultValue (0.);
1584   fpCommand->SetParameter (parameter);
1585   parameter =  new G4UIparameter ("unit", 's', omitable = true);
1586   parameter->SetDefaultValue ("m");
1587   fpCommand->SetParameter (parameter);
1588 }
1589 
1590 G4VisCommandSceneAddLogo::~G4VisCommandSceneAddLogo () {
1591   delete fpCommand;
1592 }
1593 
1594 G4String G4VisCommandSceneAddLogo::GetCurrentValue (G4UIcommand*) {
1595   return "";
1596 }
1597 
1598 void G4VisCommandSceneAddLogo::SetNewValue (G4UIcommand*, G4String newValue) {
1599 
1600   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1601   G4bool warn = verbosity >= G4VisManager::warnings;
1602 
1603   G4Scene* pScene = fpVisManager->GetCurrentScene();
1604   if (!pScene) {
1605     if (verbosity >= G4VisManager::errors) {
1606       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
1607     }
1608     return;
1609   } else {
1610     if (pScene->GetExtent().GetExtentRadius() <= 0.) {
1611       if (verbosity >= G4VisManager::errors) {
1612         G4warn
1613   << "ERROR: Scene has no extent. Add volumes or use \"/vis/scene/add/extent\"."
1614         << G4endl;
1615       }
1616       return;
1617     }
1618   }
1619 
1620   G4VViewer* pViewer = fpVisManager->GetCurrentViewer();
1621   if (!pViewer) {
1622     if (verbosity >= G4VisManager::errors) {
1623       G4warn <<
1624   "ERROR: G4VisCommandSceneAddLogo::SetNewValue: no viewer."
1625   "\n  Auto direction needs a viewer."
1626        << G4endl;
1627     }
1628     return;
1629   }
1630 
1631   G4double userHeight, red, green, blue, xmid, ymid, zmid;
1632   G4String userHeightUnit, direction, placement, positionUnit;
1633   std::istringstream is (newValue);
1634   is >> userHeight >> userHeightUnit >> direction
1635      >> red >> green >> blue
1636      >> placement
1637      >> xmid >> ymid >> zmid >> positionUnit;
1638 
1639   G4double height = userHeight;
1640   const G4VisExtent& sceneExtent = pScene->GetExtent();  // Existing extent.
1641   if (userHeightUnit == "auto") {
1642     height *= 0.2 * sceneExtent.GetExtentRadius();
1643   } else {
1644     height *= G4UIcommand::ValueOf(userHeightUnit);
1645   }
1646 
1647   G4double unit = G4UIcommand::ValueOf(positionUnit);
1648   xmid *= unit; ymid *= unit; zmid *= unit;
1649 
1650   Direction logoDirection = X;  // Initialise to keep some compilers happy.
1651   if (direction == "auto") {
1652     // Take cue from viewer
1653     const G4Vector3D& vp =
1654       pViewer->GetViewParameters().GetViewpointDirection();
1655     if (vp.x() > vp.y() && vp.x() > vp.z()) logoDirection = X;
1656     else if (vp.x() < vp.y() && vp.x() < vp.z()) logoDirection = minusX;
1657     else if (vp.y() > vp.x() && vp.y() > vp.z()) logoDirection = Y;
1658     else if (vp.y() < vp.x() && vp.y() < vp.z()) logoDirection = minusY;
1659     else if (vp.z() > vp.x() && vp.z() > vp.y()) logoDirection = Z;
1660     else if (vp.z() < vp.x() && vp.z() < vp.y()) logoDirection = minusZ;
1661   }
1662   else if (direction[0] == 'x') logoDirection = X;
1663   else if (direction[0] == 'y') logoDirection = Y;
1664   else if (direction[0] == 'z') logoDirection = Z;
1665   else if (direction[0] == '-') {
1666     if (direction[1] == 'x') logoDirection = minusX;
1667     else if (direction[1] == 'y') logoDirection = minusY;
1668     else if (direction[1] == 'z') logoDirection = minusZ;
1669   } else {
1670     if (verbosity >= G4VisManager::errors) {
1671       G4warn << "ERROR: Unrecogniseed direction: \""
1672        << direction << "\"." << G4endl;
1673       return;
1674     }
1675   }
1676 
1677   G4bool autoPlacing = false; if (placement == "auto") autoPlacing = true;
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 any extent."
1695   "\n  Maybe you have not yet added any geometrical object."
1696        << G4endl;
1697     }
1698   }
1699 
1700   // Useful constants, etc...
1701   const G4double halfHeight(height / 2.);
1702   const G4double comfort(0.01);  // 0.15 seems too big.  0.05 might be better.
1703   const G4double freeHeightFraction (1. + 2. * comfort);
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) < height) room = false;
1711     break;
1712   case Y:
1713   case minusY:
1714     if (freeHeightFraction * (ymax - ymin) < height) room = false;
1715     break;
1716   case Z:
1717   case minusZ:
1718     if (freeHeightFraction * (zmax - zmin) < height) room = false;
1719     break;
1720   }
1721   if (!room) {
1722     worried = true;
1723     if (verbosity >= G4VisManager::warnings) {
1724       G4warn <<
1725   "WARNING: Not enough room in existing scene.  Maybe logo is too large."
1726        << G4endl;
1727     }
1728   }
1729   if (worried) {
1730     if (verbosity >= G4VisManager::warnings) {
1731       G4warn <<
1732   "WARNING: The logo you have asked for is bigger than the existing"
1733   "\n  scene.  Maybe you have added it too soon.  It is recommended that"
1734   "\n  you add the logo last so that it can be correctly auto-positioned"
1735   "\n  so as not to be obscured by any existing object and so that the"
1736   "\n  view parameters can be correctly recalculated."
1737        << G4endl;
1738     }
1739   }
1740 
1741   G4double sxmid(xmid), symid(ymid), szmid(zmid);
1742   if (autoPlacing) {
1743     // Aim to place at bottom right of screen when viewed from logoDirection.
1744     // Give some comfort zone.
1745     const G4double xComfort = comfort * (xmax - xmin);
1746     const G4double yComfort = comfort * (ymax - ymin);
1747     const G4double zComfort = comfort * (zmax - zmin);
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 right?
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 right?
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 left?
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) * G4RotateZ3D(pi);
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) * transform;
1804 
1805   G4VisAttributes visAtts(G4Colour(red, green, blue));
1806   visAtts.SetForceSolid(true);         // Always solid.
1807 
1808   G4Logo* logo = new G4Logo(height,visAtts,transform);
1809   G4VModel* model =
1810     new G4CallbackModel<G4VisCommandSceneAddLogo::G4Logo>(logo);
1811   model->SetType("G4Logo");
1812   model->SetGlobalTag("G4Logo");
1813   model->SetGlobalDescription("G4Logo: " + newValue);
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 scene extent in
1819   // AddRunDurationModel below.
1820   const G4String& currentSceneName = pScene -> GetName ();
1821   G4bool successful = pScene -> AddRunDurationModel (model, warn);
1822   if (successful) {
1823     if (verbosity >= G4VisManager::confirmations) {
1824       G4cout << "G4 Logo of height " << userHeight << ' ' << userHeightUnit
1825        << ", " << direction << "-direction, added to scene \""
1826        << currentSceneName << "\"";
1827       if (verbosity >= G4VisManager::parameters) {
1828   G4cout << "\n  with extent " << extent
1829          << "\n  at " << transform.getRotation()
1830          << "  " << transform.getTranslation();
1831       }
1832       G4cout << G4endl;
1833     }
1834   }
1835   else G4VisCommandsSceneAddUnsuccessful(verbosity);
1836 
1837   CheckSceneAndNotifyHandlers (pScene);
1838 }
1839 
1840 G4VisCommandSceneAddLogo::G4Logo::G4Logo
1841 (G4double height, const G4VisAttributes& visAtts, const G4Transform3D& transform)
1842 {
1843   const G4double& h =  height;
1844   const G4double h2  = 0.5 * h;   // Half height.
1845   const G4double ri  = 0.25 * h;  // Inner radius.
1846   const G4double ro  = 0.5 * h;   // Outer radius.
1847   const G4double ro2 = 0.5 * ro;  // Half outer radius.
1848   const G4double w   = ro - ri;   // Width.
1849   const G4double w2  = 0.5 * w;   // Half width.
1850   const G4double d2  = 0.2 * h;   // Half depth.
1851   const G4double f1  = 0.05 * h;  // left edge of stem of "4".
1852   const G4double f2  = -0.3 * h;  // bottom edge of cross of "4".
1853   const G4double e = 1.e-4 * h;   // epsilon.
1854   const G4double xt = f1, yt = h2;      // Top of slope.
1855   const G4double xb = -h2, yb = f2 + w; // Bottom of slope.
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 * dy);
1861   const G4double ss = h;  // Half height of square subtractor
1862   const G4double y8 = ss; // Choose y of subtractor for outer slope.
1863   const G4double x8 = ((-ss * d - dx * (yt - y8)) / dy) + xt;
1864   G4double y9 = ss; // Choose y of subtractor for inner slope.
1865   G4double x9 = ((-(ss - w) * d - dx * (yt - y8)) / dy) + xt;
1866   // But to get inner, we make a triangle translated by...
1867   const G4double xtr = ss - f1, ytr = -ss - f2 -w;
1868   x9 += xtr; y9 += ytr;
1869 
1870   // The idea here is to create a polyhedron for the G and the 4.  To do
1871   // this we use Geant4 geometry solids and make boolean operations.
1872   // Note that we do not need to keep the solids. We use local objects,
1873   // which, of course, are deleted on leaving this function. This
1874   // is contrary to the usual requirement for solids that are part of the
1875   // detector for which solids MUST be created on the heap (with "new").
1876   // Finally we invoke CreatePolyhedron, which creates a polyhedron on the heap
1877   // and returns a pointer.  It is the user's responsibility to delete,
1878   // which is done in the destructor of this class. Thus the polyhedra,
1879   // created here, remain on the heap for the lifetime of the job.
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,G4Translate3D(ri+w2,-ro2,0.));
1885   // Create with these vis atts (force solid) and current no of sides per circle.
1886   G4Polyhedron::SetNumberOfRotationSteps
1887   (fpVisManager->GetCurrentViewer()->GetViewParameters().GetNoOfSides());
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 Subtractor.
1898   G4SubtractionSolid s1("s1",&b1,&bS,G4Translate3D(f1-ss,f2-ss,0.));
1899   G4SubtractionSolid s2("s2",&s1,&bS,G4Translate3D(f1+ss+w,f2-ss,0.));
1900   G4SubtractionSolid s3("s3",&s2,&bS,G4Translate3D(f1+ss+w,f2+ss+w,0.));
1901   G4SubtractionSolid s4
1902     ("s4",&s3,&bS,G4Transform3D(rm,G4ThreeVector(x8,y8,0.)));
1903   G4SubtractionSolid s5    // Triangular hole.
1904     ("s5",&bS,&bS2,G4Transform3D(rm,G4ThreeVector(x9,y9,0.)));
1905   G4SubtractionSolid logo4("logo4",&s4,&s5,G4Translate3D(-xtr,-ytr,0.));
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,0},{0,0,1*m}};
1911   int faces[][4] = {{1,3,2,0},{1,2,4,0},{1,4,3,0},{2,3,4,0}};
1912   fp4 = new G4Polyhedron();
1913   fp4->createPolyhedron(nNodes,nFaces,xyz,faces);
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 
1925 void G4VisCommandSceneAddLogo::G4Logo::operator()
1926   (G4VGraphicsScene& sceneHandler, const G4ModelingParameters*) {
1927   sceneHandler.BeginPrimitives();
1928   sceneHandler.AddPrimitive(*fpG);
1929   sceneHandler.AddPrimitive(*fp4);
1930   sceneHandler.EndPrimitives();
1931 }
1932 
1933 ////////////// /vis/scene/add/logo2D ///////////////////////////////////////
1934 
1935 G4VisCommandSceneAddLogo2D::G4VisCommandSceneAddLogo2D () {
1936   G4bool omitable;
1937   fpCommand = new G4UIcommand ("/vis/scene/add/logo2D", this);
1938   fpCommand -> SetGuidance ("Adds 2D logo to current scene.");
1939   G4UIparameter* parameter;
1940   parameter = new G4UIparameter ("size", 'i', omitable = true);
1941   parameter -> SetGuidance ("Screen size of text in pixels.");
1942   parameter -> SetDefaultValue (48);
1943   fpCommand -> SetParameter (parameter);
1944   parameter = new G4UIparameter ("x-position", 'd', omitable = true);
1945   parameter -> SetGuidance ("x screen position in range -1 < x < 1.");
1946   parameter -> SetDefaultValue (-0.9);
1947   fpCommand -> SetParameter (parameter);
1948   parameter = new G4UIparameter ("y-position", 'd', omitable = true);
1949   parameter -> SetGuidance ("y screen position in range -1 < y < 1.");
1950   parameter -> SetDefaultValue (-0.9);
1951   fpCommand -> SetParameter (parameter);
1952   parameter = new G4UIparameter ("layout", 's', omitable = true);
1953   parameter -> SetGuidance ("Layout, i.e., adjustment: left|centre|right.");
1954   parameter -> SetDefaultValue ("left");
1955   fpCommand -> SetParameter (parameter);
1956 }
1957 
1958 G4VisCommandSceneAddLogo2D::~G4VisCommandSceneAddLogo2D () {
1959   delete fpCommand;
1960 }
1961 
1962 G4String G4VisCommandSceneAddLogo2D::GetCurrentValue (G4UIcommand*) {
1963   return "";
1964 }
1965 
1966 void G4VisCommandSceneAddLogo2D::SetNewValue (G4UIcommand*, G4String newValue)
1967 {
1968   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
1969   G4bool warn(verbosity >= G4VisManager::warnings);
1970 
1971   G4Scene* pScene = fpVisManager->GetCurrentScene();
1972   if (!pScene) {
1973     if (verbosity >= G4VisManager::errors) {
1974       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
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::left;
1986   else if (layoutString[0] == 'c') layout = G4Text::centre;
1987   else if (layoutString[0] == 'r') layout = G4Text::right;
1988 
1989   Logo2D* logo2D = new Logo2D(fpVisManager, size, x, y, layout);
1990   G4VModel* model =
1991     new G4CallbackModel<G4VisCommandSceneAddLogo2D::Logo2D>(logo2D);
1992   model->SetType("G4Logo2D");
1993   model->SetGlobalTag("G4Logo2D");
1994   model->SetGlobalDescription("G4Logo2D: " + newValue);
1995   const G4String& currentSceneName = pScene -> GetName ();
1996   G4bool successful = pScene -> AddRunDurationModel (model, warn);
1997   if (successful) {
1998     if (verbosity >= G4VisManager::confirmations) {
1999       G4cout << "2D logo has been added to scene \""
2000        << currentSceneName << "\"."
2001        << G4endl;
2002     }
2003   }
2004   else G4VisCommandsSceneAddUnsuccessful(verbosity);
2005 
2006   CheckSceneAndNotifyHandlers (pScene);
2007 }
2008 
2009 void G4VisCommandSceneAddLogo2D::Logo2D::operator()
2010   (G4VGraphicsScene& sceneHandler, const G4ModelingParameters*)
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::G4VisCommandSceneAddMagneticField () {
2025   fpCommand = new G4UIcommand ("/vis/scene/add/magneticField", this);
2026   fpCommand -> SetGuidance
2027   ("Adds magnetic field representation to current scene.");
2028   const G4UIcommandTree* tree = G4UImanager::GetUIpointer()->GetTree();
2029   const G4UIcommand* addElecFieldCmd = tree->FindPath("/vis/scene/add/electricField");
2030   // Pick up additional guidance from /vis/scene/add/electricField
2031   CopyGuidanceFrom(addElecFieldCmd,fpCommand,1);
2032   // Pick up parameters from /vis/scene/add/electricField
2033   CopyParametersFrom(addElecFieldCmd,fpCommand);
2034 }
2035 
2036 G4VisCommandSceneAddMagneticField::~G4VisCommandSceneAddMagneticField () {
2037   delete fpCommand;
2038 }
2039 
2040 G4String G4VisCommandSceneAddMagneticField::GetCurrentValue (G4UIcommand*) {
2041   return "";
2042 }
2043 
2044 void G4VisCommandSceneAddMagneticField::SetNewValue
2045 (G4UIcommand*, G4String newValue) {
2046 
2047   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
2048   G4bool warn(verbosity >= G4VisManager::warnings);
2049 
2050   G4Scene* pScene = fpVisManager->GetCurrentScene();
2051   if (!pScene) {
2052     if (verbosity >= G4VisManager::errors) {
2053       G4warn <<  "ERROR: No current scene.  Please create one." << G4endl;
2054     }
2055     return;
2056   }
2057 
2058   G4int nDataPointsPerHalfScene;
2059   G4String representation;
2060   std::istringstream iss(newValue);
2061   iss >> nDataPointsPerHalfScene >> representation;
2062   G4ElectricFieldModel::Representation
2063   modelRepresentation = G4ElectricFieldModel::fullArrow;
2064   if (representation == "lightArrow") {
2065     modelRepresentation = G4ElectricFieldModel::lightArrow;
2066   }
2067   G4VModel* model;
2068   model = new G4MagneticFieldModel
2069   (nDataPointsPerHalfScene,modelRepresentation,
2070    fCurrentArrow3DLineSegmentsPerCircle,
2071    fCurrentExtentForField,
2072    fCurrrentPVFindingsForField);
2073   const G4String& currentSceneName = pScene -> GetName ();
2074   G4bool successful = pScene -> AddRunDurationModel (model, warn);
2075   if (successful) {
2076     if (verbosity >= G4VisManager::confirmations) {
2077       G4cout
2078       << "Magnetic field, if any, will be drawn in scene \""
2079       << currentSceneName
2080       << "\"\n  with "
2081       << nDataPointsPerHalfScene
2082       << " data points per half extent and with representation \""
2083       << representation
2084       << '\"'
2085       << G4endl;
2086     }
2087   }
2088   else G4VisCommandsSceneAddUnsuccessful(verbosity);
2089 
2090   CheckSceneAndNotifyHandlers (pScene);
2091 }
2092 
2093 ////////////// /vis/scene/add/psHits ///////////////////////////////////////
2094 
2095 G4VisCommandSceneAddPSHits::G4VisCommandSceneAddPSHits () {
2096   G4bool omitable;
2097   fpCommand = new G4UIcmdWithAString ("/vis/scene/add/psHits", this);
2098   fpCommand -> SetGuidance
2099     ("Adds Primitive Scorer Hits (PSHits) to current scene.");
2100   fpCommand -> SetGuidance
2101     ("PSHits are drawn at end of run when the scene in which"
2102      "\nthey are added is current.");
2103   fpCommand -> SetGuidance
2104     ("Optional parameter specifies name of scoring map.  By default all"
2105      "\nscoring maps registered with the G4ScoringManager are drawn.");
2106   fpCommand -> SetParameterName ("mapname", omitable = true);
2107   fpCommand -> SetDefaultValue ("all");
2108 }
2109 
2110 G4VisCommandSceneAddPSHits::~G4VisCommandSceneAddPSHits () {
2111   delete fpCommand;
2112 }
2113 
2114 G4String G4VisCommandSceneAddPSHits::GetCurrentValue (G4UIcommand*) {
2115   return "";
2116 }
2117 
2118 void G4VisCommandSceneAddPSHits::SetNewValue
2119 (G4UIcommand*, G4String newValue)
2120 {
2121   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
2122   G4bool warn(verbosity >= G4VisManager::warnings);
2123 
2124   G4Scene* pScene = fpVisManager->GetCurrentScene();
2125   if (!pScene) {
2126     if (verbosity >= G4VisManager::errors) {
2127       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
2128     }
2129     return;
2130   }
2131 
2132   G4VModel* model = new G4PSHitsModel(newValue);
2133   const G4String& currentSceneName = pScene -> GetName ();
2134   G4bool successful = pScene -> AddEndOfRunModel (model, warn);
2135   if (successful) {
2136     if (verbosity >= G4VisManager::confirmations) {
2137       if (newValue == "all") {
2138   G4cout << "All Primitive Scorer hits";
2139       } else {
2140   G4cout << "Hits of Primitive Scorer \"" << newValue << '"';
2141       }
2142       G4cout << " will be drawn at end of run in scene \""
2143        << currentSceneName << "\"."
2144        << G4endl;
2145     }
2146   }
2147   else G4VisCommandsSceneAddUnsuccessful(verbosity);
2148 
2149   CheckSceneAndNotifyHandlers (pScene);
2150 }
2151 
2152 ////////////// /vis/scene/add/scale //////////////////////////////////
2153 
2154 G4VisCommandSceneAddScale::G4VisCommandSceneAddScale () {
2155   G4bool omitable;
2156   fpCommand = new G4UIcommand ("/vis/scene/add/scale", this);
2157   fpCommand -> SetGuidance
2158   ("Adds an annotated scale line to the current scene.");
2159   fpCommand -> SetGuidance
2160   ("If \"unit\" is \"auto\", length is roughly one tenth of the scene extent.");
2161   fpCommand -> SetGuidance
2162   ("If \"direction\" is \"auto\", scale is roughly in the plane of the current view.");
2163   fpCommand -> SetGuidance
2164   ("If \"placement\" is \"auto\", scale is placed at bottom left of current view."
2165    "\n  Otherwise placed at (xmid,ymid,zmid).");
2166   fpCommand -> SetGuidance
2167   ("An annotated line in the specified direction with tick marks at the"
2168    "\nend.  If autoPlacing is true it is required to be centred at the"
2169    "\nfront, right, bottom corner of the world space, comfortably outside"
2170    "\nthe existing bounding box/sphere so that existing objects do not"
2171    "\nobscure it.  Otherwise it is required to be drawn with mid-point at"
2172    "\n(xmid, ymid, zmid)."
2173    "\n"
2174    "\nThe auto placing algorithm is (approx):"
2175    "\n  x = xmin + (1 + comfort) * (xmax - xmin);"
2176    "\n  y = ymin - comfort * (ymax - ymin);"
2177    "\n  z = zmin + (1 + comfort) * (zmax - zmin);"
2178    "\n  if direction == x then (x - length,y,z) to (x,y,z);"
2179    "\n  if direction == y then (x,y,z) to (x,y + length,z);"
2180    "\n  if direction == z then (x,y,z - length) to (x,y,z);"
2181    );
2182   G4UIparameter* parameter;
2183   parameter = new G4UIparameter ("length", 'd', omitable = true);
2184   parameter->SetDefaultValue (1.);
2185   fpCommand->SetParameter (parameter);
2186   parameter =  new G4UIparameter ("unit", 's', omitable = true);
2187   parameter->SetDefaultValue ("auto");
2188   fpCommand->SetParameter (parameter);
2189   parameter =  new G4UIparameter ("direction", 's', omitable = true);
2190   parameter->SetGuidance ("auto|x|y|z");
2191   parameter->SetDefaultValue ("auto");
2192   fpCommand->SetParameter (parameter);
2193   parameter =  new G4UIparameter ("red", 'd', omitable = true);
2194   parameter->SetDefaultValue (1.);
2195   fpCommand->SetParameter (parameter);
2196   parameter =  new G4UIparameter ("green", 'd', omitable = true);
2197   parameter->SetDefaultValue (0.);
2198   fpCommand->SetParameter (parameter);
2199   parameter =  new G4UIparameter ("blue", 'd', omitable = true);
2200   parameter->SetDefaultValue (0.);
2201   fpCommand->SetParameter (parameter);
2202   parameter =  new G4UIparameter ("placement", 's', omitable = true);
2203   parameter -> SetParameterCandidates("auto manual");
2204   parameter->SetDefaultValue  ("auto");
2205   fpCommand->SetParameter     (parameter);
2206   parameter =  new G4UIparameter ("xmid", 'd', omitable = true);
2207   parameter->SetDefaultValue (0.);
2208   fpCommand->SetParameter (parameter);
2209   parameter =  new G4UIparameter ("ymid", 'd', omitable = true);
2210   parameter->SetDefaultValue (0.);
2211   fpCommand->SetParameter (parameter);
2212   parameter =  new G4UIparameter ("zmid", 'd', omitable = true);
2213   parameter->SetDefaultValue (0.);
2214   fpCommand->SetParameter (parameter);
2215   parameter =  new G4UIparameter ("unit", 's', omitable = true);
2216   parameter->SetDefaultValue ("m");
2217   fpCommand->SetParameter (parameter);
2218 }
2219 
2220 G4VisCommandSceneAddScale::~G4VisCommandSceneAddScale () {
2221   delete fpCommand;
2222 }
2223 
2224 G4String G4VisCommandSceneAddScale::GetCurrentValue (G4UIcommand*) {
2225   return "";
2226 }
2227 
2228 void G4VisCommandSceneAddScale::SetNewValue (G4UIcommand*, G4String newValue) {
2229 
2230   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
2231   G4bool warn = verbosity >= G4VisManager::warnings;
2232 
2233   G4Scene* pScene = fpVisManager->GetCurrentScene();
2234   if (!pScene) {
2235     if (verbosity >= G4VisManager::errors) {
2236       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
2237     }
2238     return;
2239   } else {
2240     if (pScene->GetExtent().GetExtentRadius() <= 0.) {
2241       if (verbosity >= G4VisManager::errors) {
2242         G4warn
2243   << "ERROR: Scene has no extent. Add volumes or use \"/vis/scene/add/extent\"."
2244         << G4endl;
2245       }
2246       return;
2247     }
2248   }
2249 
2250   G4double userLength, red, green, blue, xmid, ymid, zmid;
2251   G4String userLengthUnit, direction, placement, positionUnit;
2252   std::istringstream is (newValue);
2253   is >> userLength >> userLengthUnit >> direction
2254      >> red >> green >> blue
2255      >> placement
2256      >> xmid >> ymid >> zmid >> positionUnit;
2257 
2258   G4double length = userLength;
2259   const G4VisExtent& sceneExtent = pScene->GetExtent();  // Existing extent.
2260   if (userLengthUnit == "auto") {
2261     const G4double lengthMax = 0.5 * sceneExtent.GetExtentRadius();
2262     const G4double intLog10Length = std::floor(std::log10(lengthMax));
2263     length = std::pow(10,intLog10Length);
2264     if (5.*length < lengthMax) length *= 5.;
2265     else if (2.*length < lengthMax) length *= 2.;
2266   } else {
2267     length *= G4UIcommand::ValueOf(userLengthUnit);
2268   }
2269   G4String annotation = G4BestUnit(length,"Length");
2270 
2271   G4double unit = G4UIcommand::ValueOf(positionUnit);
2272   xmid *= unit; ymid *= unit; zmid *= unit;
2273 
2274   Scale::Direction scaleDirection (Scale::x);
2275   if (direction[0] == 'y') scaleDirection = Scale::y;
2276   if (direction[0] == 'z') scaleDirection = Scale::z;
2277 
2278   G4VViewer* pViewer = fpVisManager->GetCurrentViewer();
2279   if (!pViewer) {
2280     if (verbosity >= G4VisManager::errors) {
2281       G4warn <<
2282   "ERROR: G4VisCommandSceneAddScale::SetNewValue: no viewer."
2283   "\n  Auto direction needs a viewer."
2284        << G4endl;
2285     }
2286     return;
2287   }
2288 
2289   const G4Vector3D& vp =
2290     pViewer->GetViewParameters().GetViewpointDirection();
2291   const G4Vector3D& up =
2292     pViewer->GetViewParameters().GetUpVector();
2293 
2294   if (direction == "auto") {  // Takes cue from viewer.
2295     if (std::abs(vp.x()) > std::abs(vp.y()) &&
2296   std::abs(vp.x()) > std::abs(vp.z())) {  // x viewpoint
2297       if (std::abs(up.y()) > std::abs(up.z())) scaleDirection = Scale::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())) {  // y viewpoint
2302       if (std::abs(up.x()) > std::abs(up.z())) scaleDirection = Scale::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())) {  // z viewpoint
2307       if (std::abs(up.y()) > std::abs(up.x())) scaleDirection = Scale::x;
2308     else scaleDirection = Scale::y;
2309     }
2310   }
2311 
2312   G4bool autoPlacing = false; if (placement == "auto") autoPlacing = true;
2313   // Parameters read and interpreted.
2314 
2315   // Useful constants, etc...
2316   const G4double halfLength(length / 2.);
2317   const G4double comfort(0.01);  // 0.15 seems too big.  0.05 might be better.
2318   const G4double freeLengthFraction (1. + 2. * comfort);
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 any extent."
2334   "\n  Maybe you have not yet added any geometrical object."
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) < length) room = false;
2344     break;
2345   case Scale::y:
2346     if (freeLengthFraction * (ymax - ymin) < length) room = false;
2347     break;
2348   case Scale::z:
2349     if (freeLengthFraction * (zmax - zmin) < length) room = false;
2350     break;
2351   }
2352   if (!room) {
2353     worried = true;
2354     if (verbosity >= G4VisManager::warnings) {
2355       G4warn <<
2356   "WARNING: Not enough room in existing scene.  Maybe scale is too long."
2357        << G4endl;
2358     }
2359   }
2360   if (worried) {
2361     if (verbosity >= G4VisManager::warnings) {
2362       G4warn <<
2363   "WARNING: The scale you have asked for is bigger than the existing"
2364   "\n  scene.  Maybe you have added it too soon.  It is recommended that"
2365   "\n  you add the scale last so that it can be correctly auto-positioned"
2366   "\n  so as not to be obscured by any existing object and so that the"
2367   "\n  view parameters can be correctly recalculated."
2368        << G4endl;
2369     }
2370   }
2371 
2372   // Now figure out the extent...
2373   //
2374   // This creates a representation of annotated line in the specified
2375   // direction with tick marks at the end.  If autoPlacing is true it
2376   // is required to be centred at the front, right, bottom corner of
2377   // the world space, comfortably outside the existing bounding
2378   // box/sphere so that existing objects do not obscure it.  Otherwise
2379   // it is required to be drawn with mid-point at (xmid, ymid, zmid).
2380   //
2381   // The auto placing algorithm might be:
2382   //   x = xmin + (1 + comfort) * (xmax - xmin)
2383   //   y = ymin - comfort * (ymax - ymin)
2384   //   z = zmin + (1 + comfort) * (zmax - zmin)
2385   //   if direction == x then (x - length,y,z) to (x,y,z)
2386   //   if direction == y then (x,y,z) to (x,y + length,z)
2387   //   if direction == z then (x,y,z - length) to (x,y,z)
2388   //
2389   // Implement this in two parts.  Here, use the scale's extent to
2390   // "expand" the scene's extent.  Then rendering - in
2391   // G4VSceneHandler::AddPrimitive(const G4Scale&) - simply has to
2392   // ensure it's within the new extent.
2393   //
2394 
2395   G4double sxmid(xmid), symid(ymid), szmid(zmid);
2396   if (autoPlacing) {
2397     // Aim to place at bottom right of screen in current view.
2398     // Give some comfort zone.
2399     const G4double xComfort = comfort * (xmax - xmin);
2400     const G4double yComfort = comfort * (ymax - ymin);
2401     const G4double zComfort = comfort * (zmax - zmin);
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) * transform;
2454   scaleExtent = scaleExtent.Transform(transform);
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>(scale);
2476   model->SetType("Scale");
2477   model->SetGlobalTag("Scale");
2478   model->SetGlobalDescription("Scale: " + newValue);
2479   model->SetExtent(scaleExtent);
2480 
2481   const G4String& currentSceneName = pScene -> GetName ();
2482   G4bool successful = pScene -> AddRunDurationModel (model, warn);
2483   if (successful) {
2484     if (verbosity >= G4VisManager::confirmations) {
2485       G4cout << "Scale of " << annotation
2486        << " added to scene \"" << currentSceneName << "\".";
2487       if (verbosity >= G4VisManager::parameters) {
2488   G4cout << "\n  with extent " << scaleExtent
2489          << "\n  at " << transform.getRotation()
2490          << "  " << transform.getTranslation();
2491       }
2492       G4cout << G4endl;
2493     }
2494   }
2495   else G4VisCommandsSceneAddUnsuccessful(verbosity);
2496 
2497   CheckSceneAndNotifyHandlers (pScene);
2498 }
2499 
2500 G4VisCommandSceneAddScale::Scale::Scale
2501  (const G4VisAttributes& visAtts,
2502   G4double length, const G4Transform3D& transform,
2503   const G4String& annotation, G4double annotationSize,
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 vis attributes...
2512   // (OK to pass address since fVisAtts is long lived.)
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 a scale parallel to the
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 orientation
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::operator()
2550 (G4VGraphicsScene& sceneHandler,const G4ModelingParameters*)
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::G4VisCommandSceneAddText () {
2566   G4bool omitable;
2567   fpCommand = new G4UIcommand ("/vis/scene/add/text", this);
2568   fpCommand -> SetGuidance ("Adds text to current scene.");
2569   fpCommand -> SetGuidance
2570     ("Use \"/vis/set/textColour\" to set colour.");
2571   fpCommand -> SetGuidance
2572     ("Use \"/vis/set/textLayout\" to set layout:");
2573   G4UIparameter* parameter;
2574   parameter = new G4UIparameter ("x", 'd', omitable = true);
2575   parameter->SetDefaultValue (0);
2576   fpCommand->SetParameter (parameter);
2577   parameter =  new G4UIparameter ("y", 'd', omitable = true);
2578   parameter->SetDefaultValue (0);
2579   fpCommand->SetParameter (parameter);
2580   parameter =  new G4UIparameter ("z", 'd', omitable = true);
2581   parameter->SetDefaultValue (0);
2582   fpCommand->SetParameter (parameter);
2583   parameter =  new G4UIparameter ("unit", 's', omitable = true);
2584   parameter->SetDefaultValue ("m");
2585   fpCommand->SetParameter     (parameter);
2586   parameter =  new G4UIparameter ("font_size", 'd', omitable = true);
2587   parameter->SetDefaultValue (12);
2588   parameter->SetGuidance ("pixels");
2589   fpCommand->SetParameter (parameter);
2590   parameter =  new G4UIparameter ("x_offset", 'd', omitable = true);
2591   parameter->SetDefaultValue (0);
2592   parameter->SetGuidance ("pixels");
2593   fpCommand->SetParameter (parameter);
2594   parameter =  new G4UIparameter ("y_offset", 'd', omitable = true);
2595   parameter->SetDefaultValue (0);
2596   parameter->SetGuidance ("pixels");
2597   fpCommand->SetParameter (parameter);
2598   parameter =  new G4UIparameter ("text", 's', omitable = true);
2599   parameter->SetGuidance ("The rest of the line is text.");
2600   parameter->SetDefaultValue ("Hello G4");
2601   fpCommand->SetParameter (parameter);
2602 }
2603 
2604 G4VisCommandSceneAddText::~G4VisCommandSceneAddText () {
2605   delete fpCommand;
2606 }
2607 
2608 G4String G4VisCommandSceneAddText::GetCurrentValue (G4UIcommand*) {
2609   return "";
2610 }
2611 
2612 void G4VisCommandSceneAddText::SetNewValue (G4UIcommand*, G4String newValue) {
2613 
2614   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
2615   G4bool warn = verbosity >= G4VisManager::warnings;
2616 
2617   G4Scene* pScene = fpVisManager->GetCurrentScene();
2618   if (!pScene) {
2619     if (verbosity >= G4VisManager::errors) {
2620       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
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(unitString);
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 -> GetName ();
2646   G4bool successful = pScene -> AddRunDurationModel (model, warn);
2647   if (successful) {
2648     if (verbosity >= G4VisManager::confirmations) {
2649       G4cout << "Text '" << text
2650        << "' has been added to scene \"" << currentSceneName << "\"."
2651        << G4endl;
2652     }
2653   }
2654   else G4VisCommandsSceneAddUnsuccessful(verbosity);
2655 
2656   CheckSceneAndNotifyHandlers (pScene);
2657 }
2658 
2659 
2660 ////////////// /vis/scene/add/text2D //////////////////////////////////
2661 
2662 G4VisCommandSceneAddText2D::G4VisCommandSceneAddText2D () {
2663   G4bool omitable;
2664   fpCommand = new G4UIcommand ("/vis/scene/add/text2D", this);
2665   fpCommand -> SetGuidance ("Adds 2D text to current scene.");
2666   fpCommand -> SetGuidance ("x,y in range [-1,1]");
2667   fpCommand -> SetGuidance
2668     ("Use \"/vis/set/textColour\" to set colour.");
2669   fpCommand -> SetGuidance
2670     ("Use \"/vis/set/textLayout\" to set layout:");
2671   G4UIparameter* parameter;
2672   parameter = new G4UIparameter ("x", 'd', omitable = true);
2673   parameter->SetDefaultValue (0);
2674   fpCommand->SetParameter (parameter);
2675   parameter =  new G4UIparameter ("y", 'd', omitable = true);
2676   parameter->SetDefaultValue (0);
2677   fpCommand->SetParameter (parameter);
2678   parameter =  new G4UIparameter ("font_size", 'd', omitable = true);
2679   parameter->SetDefaultValue (12);
2680   parameter->SetGuidance ("pixels");
2681   fpCommand->SetParameter (parameter);
2682   parameter =  new G4UIparameter ("x_offset", 'd', omitable = true);
2683   parameter->SetDefaultValue (0);
2684   parameter->SetGuidance ("pixels");
2685   fpCommand->SetParameter (parameter);
2686   parameter =  new G4UIparameter ("y_offset", 'd', omitable = true);
2687   parameter->SetDefaultValue (0);
2688   parameter->SetGuidance ("pixels");
2689   fpCommand->SetParameter (parameter);
2690   parameter =  new G4UIparameter ("text", 's', omitable = true);
2691   parameter->SetGuidance ("The rest of the line is text.");
2692   parameter->SetDefaultValue ("Hello G4");
2693   fpCommand->SetParameter (parameter);
2694 }
2695 
2696 G4VisCommandSceneAddText2D::~G4VisCommandSceneAddText2D () {
2697   delete fpCommand;
2698 }
2699 
2700 G4String G4VisCommandSceneAddText2D::GetCurrentValue (G4UIcommand*) {
2701   return "";
2702 }
2703 
2704 void G4VisCommandSceneAddText2D::SetNewValue (G4UIcommand*, G4String newValue) {
2705 
2706   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
2707   G4bool warn = verbosity >= G4VisManager::warnings;
2708 
2709   G4Scene* pScene = fpVisManager->GetCurrentScene();
2710   if (!pScene) {
2711     if (verbosity >= G4VisManager::errors) {
2712       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
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<G4VisCommandSceneAddText2D::G4Text2D>(g4text2D);
2734   model->SetType("Text2D");
2735   model->SetGlobalTag("Text2D");
2736   std::ostringstream oss;
2737   oss << "Text2D: '" << g4text.GetText()
2738   << "' at " << g4text.GetPosition().x() << ',' << g4text.GetPosition().y()
2739   << " with size " << g4text.GetScreenSize()
2740   << " with offsets " << g4text.GetXOffset() << ',' << g4text.GetYOffset();
2741   model->SetGlobalDescription(oss.str());
2742   const G4String& currentSceneName = pScene -> GetName ();
2743   G4bool successful = pScene -> AddRunDurationModel (model, warn);
2744   if (successful) {
2745     if (verbosity >= G4VisManager::confirmations) {
2746       G4cout << "2D text '" << text
2747        << "' has been added to scene \"" << currentSceneName << "\"."
2748        << G4endl;
2749     }
2750   }
2751   else G4VisCommandsSceneAddUnsuccessful(verbosity);
2752 
2753   CheckSceneAndNotifyHandlers (pScene);
2754 }
2755 
2756 G4VisCommandSceneAddText2D::G4Text2D::G4Text2D(const G4Text& text):
2757   fText(text)
2758 {}
2759 
2760 void G4VisCommandSceneAddText2D::G4Text2D::operator()
2761   (G4VGraphicsScene& sceneHandler, const G4ModelingParameters*) {
2762   sceneHandler.BeginPrimitives2D();
2763   sceneHandler.AddPrimitive(fText);
2764   sceneHandler.EndPrimitives2D();
2765 }
2766 
2767 
2768 ////////////// /vis/scene/add/trajectories ///////////////////////////////////
2769 
2770 G4VisCommandSceneAddTrajectories::G4VisCommandSceneAddTrajectories () {
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 drawn at the end of processing an"
2778      "\nevent.  Switches on trajectory storing and sets the"
2779      "\ndefault trajectory type.");
2780   fpCommand -> SetGuidance
2781     ("The command line parameter list determines the default trajectory type."
2782      "\nIf it contains the string \"smooth\", auxiliary inter-step points will"
2783      "\nbe inserted to improve the smoothness of the drawing of a curved"
2784      "\ntrajectory."
2785      "\nIf it contains the string \"rich\", significant extra information will"
2786      "\nbe stored in the trajectory (G4RichTrajectory) amenable to modeling"
2787      "\nand filtering with \"/vis/modeling/trajectories/create/drawByAttribute\""
2788      "\nand \"/vis/filtering/trajectories/create/attributeFilter\" commands."
2789      "\nIt may contain both strings in any order.");
2790   fpCommand -> SetGuidance
2791     ("\nTo switch off trajectory storing: \"/tracking/storeTrajectory 0\"."
2792      "\nSee also \"/vis/scene/endOfEventAction\".");
2793   fpCommand -> SetGuidance
2794     ("Note:  This only sets the default.  Independently of the result of this"
2795      "\ncommand, a user may instantiate a trajectory that overrides this default"
2796      "\nin PreUserTrackingAction.");
2797   fpCommand -> SetParameterName ("default-trajectory-type", omitable = true);
2798   fpCommand -> SetDefaultValue ("");
2799 }
2800 
2801 G4VisCommandSceneAddTrajectories::~G4VisCommandSceneAddTrajectories () {
2802   delete fpCommand;
2803 }
2804 
2805 G4String G4VisCommandSceneAddTrajectories::GetCurrentValue (G4UIcommand*) {
2806   return "";
2807 }
2808 
2809 void G4VisCommandSceneAddTrajectories::SetNewValue (G4UIcommand*,
2810                 G4String newValue) {
2811 
2812   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
2813   G4bool warn = verbosity >= G4VisManager::warnings;
2814 
2815   G4Scene* pScene = fpVisManager->GetCurrentScene();
2816   if (!pScene) {
2817     if (verbosity >= G4VisManager::errors) {
2818       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
2819     }
2820     return;
2821   }
2822   const G4String& currentSceneName = pScene -> GetName ();
2823 
2824   G4bool smooth = false;
2825   G4bool rich = false;
2826   if (newValue.find("smooth") != std::string::npos) smooth = true;
2827   if (newValue.find("rich") != std::string::npos) rich = true;
2828   if (newValue.size() && !(rich || smooth)) {
2829     if (verbosity >= G4VisManager::errors) {
2830       G4warn << "ERROR: Unrecognised parameter \"" << newValue << "\""
2831       "\n  No action taken."
2832       << G4endl;
2833     }
2834     return;
2835   }
2836 
2837   G4UImanager* UImanager = G4UImanager::GetUIpointer();
2838   G4String defaultTrajectoryType;
2839   if (smooth && rich) {
2840     UImanager->ApplyCommand("/tracking/storeTrajectory 4");
2841     defaultTrajectoryType = "G4RichTrajectory configured for smooth steps";
2842   } else if (smooth) {
2843     UImanager->ApplyCommand("/tracking/storeTrajectory 2");
2844     defaultTrajectoryType = "G4SmoothTrajectory";
2845   } else if (rich) {
2846     UImanager->ApplyCommand("/tracking/storeTrajectory 3");
2847     defaultTrajectoryType = "G4RichTrajectory";
2848   } else {
2849     UImanager->ApplyCommand("/tracking/storeTrajectory 1");
2850     defaultTrajectoryType = "G4Trajectory";
2851   }
2852 
2853   if (verbosity >= G4VisManager::errors) {
2854     G4warn <<
2855       "Attributes available for modeling and filtering with"
2856       "\n  \"/vis/modeling/trajectories/create/drawByAttribute\" and"
2857       "\n  \"/vis/filtering/trajectories/create/attributeFilter\" commands:"
2858      << G4endl;
2859     G4warn << *G4TrajectoriesModel().GetAttDefs();
2860     if (rich) {
2861       G4warn << *G4RichTrajectory().GetAttDefs()
2862        << *G4RichTrajectoryPoint().GetAttDefs();
2863     } else if (smooth) {
2864       G4warn << *G4SmoothTrajectory().GetAttDefs()
2865        << *G4SmoothTrajectoryPoint().GetAttDefs();
2866     } else {
2867       G4warn << *G4Trajectory().GetAttDefs()
2868        << *G4TrajectoryPoint().GetAttDefs();
2869     }
2870   }
2871 
2872   const auto& eoeList = pScene->GetEndOfEventModelList();
2873   auto eoeModel = eoeList.begin();
2874   for (; eoeModel != eoeList.end(); ++eoeModel) {
2875     const auto* actualModel = eoeModel->fpModel;
2876     if (dynamic_cast<const G4TrajectoriesModel*>(actualModel)) break;
2877   }
2878   if (eoeModel == eoeList.end()) {
2879     // No trajectories model exists in the scene so create a new one...
2880     G4VModel* model = new G4TrajectoriesModel();
2881     pScene -> AddEndOfEventModel (model, warn);
2882   }  // ...else it already exists and there is no need to add a new one
2883   // because G4TrajectoriesModel simply describes trajectories in the
2884   // trajectories store whatever the type.
2885 
2886   if (verbosity >= G4VisManager::confirmations) {
2887     G4cout << "Default trajectory type " << defaultTrajectoryType
2888      << "\n  will be used to store trajectories for scene \""
2889      << currentSceneName << "\"."
2890      << G4endl;
2891   }
2892 
2893   if (verbosity >= G4VisManager::warnings) {
2894     G4warn <<
2895       "WARNING: Trajectory storing has been requested.  This action may be"
2896       "\n  reversed with \"/tracking/storeTrajectory 0\"."
2897      << G4endl;
2898   }
2899 
2900   CheckSceneAndNotifyHandlers (pScene);
2901 }
2902 
2903 ////////////// /vis/scene/add/userAction ///////////////////////////////////
2904 
2905 G4VisCommandSceneAddUserAction::G4VisCommandSceneAddUserAction () {
2906   G4bool omitable;
2907   fpCommand = new G4UIcmdWithAString("/vis/scene/add/userAction",this);
2908   fpCommand -> SetGuidance
2909     ("Add named Vis User Action to current scene.");
2910   fpCommand -> SetGuidance
2911     ("Attempts to match search string to name of action - use unique sub-string.");
2912   fpCommand -> SetGuidance
2913     ("(Use /vis/list to see names of registered actions.)");
2914   fpCommand -> SetGuidance
2915     ("If name == \"all\" (default), all actions are added.");
2916   fpCommand -> SetParameterName("action-name", omitable = true);
2917   fpCommand -> SetDefaultValue("all");
2918 }
2919 
2920 G4VisCommandSceneAddUserAction::~G4VisCommandSceneAddUserAction () {
2921   delete fpCommand;
2922 }
2923 
2924 G4String G4VisCommandSceneAddUserAction::GetCurrentValue (G4UIcommand*) {
2925   return "";
2926 }
2927 
2928 void G4VisCommandSceneAddUserAction::SetNewValue
2929 (G4UIcommand*, G4String newValue) {
2930 
2931   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
2932 
2933   G4Scene* pScene = fpVisManager->GetCurrentScene();
2934   if (!pScene) {
2935     if (verbosity >= G4VisManager::errors) {
2936       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
2937     }
2938     return;
2939   }
2940 
2941   G4bool any = false;
2942 
2943   const std::vector<G4VisManager::UserVisAction>& runDurationUserVisActions =
2944     fpVisManager->GetRunDurationUserVisActions();
2945   for (size_t i = 0; i < runDurationUserVisActions.size(); i++) {
2946     const G4String& name = runDurationUserVisActions[i].fName;
2947     G4VUserVisAction* visAction = runDurationUserVisActions[i].fpUserVisAction;
2948     if (newValue == "all" || name.find(newValue) != std::string::npos) {
2949       any = true;
2950       AddVisAction(name,visAction,pScene,runDuration,verbosity);
2951     }
2952   }
2953 
2954   const std::vector<G4VisManager::UserVisAction>& endOfEventUserVisActions =
2955     fpVisManager->GetEndOfEventUserVisActions();
2956   for (size_t i = 0; i < endOfEventUserVisActions.size(); i++) {
2957     const G4String& name = endOfEventUserVisActions[i].fName;
2958     G4VUserVisAction* visAction = endOfEventUserVisActions[i].fpUserVisAction;
2959     if (newValue == "all" || name.find(newValue) != std::string::npos) {
2960       any = true;
2961       AddVisAction(name,visAction,pScene,endOfEvent,verbosity);
2962     }
2963   }
2964 
2965   const std::vector<G4VisManager::UserVisAction>& endOfRunUserVisActions =
2966     fpVisManager->GetEndOfRunUserVisActions();
2967   for (size_t i = 0; i < endOfRunUserVisActions.size(); i++) {
2968     const G4String& name = endOfRunUserVisActions[i].fName;
2969     G4VUserVisAction* visAction = endOfRunUserVisActions[i].fpUserVisAction;
2970     if (newValue == "all" || name.find(newValue) != std::string::npos) {
2971       any = true;
2972       AddVisAction(name,visAction,pScene,endOfRun,verbosity);
2973     }
2974   }
2975 
2976   if (!any) {
2977     if (verbosity >= G4VisManager::warnings) {
2978       G4warn << "WARNING: No User Vis Action registered." << G4endl;
2979     }
2980     return;
2981   }
2982 
2983   CheckSceneAndNotifyHandlers (pScene);
2984 }
2985 
2986 void G4VisCommandSceneAddUserAction::AddVisAction
2987 (const G4String& name,
2988  G4VUserVisAction* visAction,
2989  G4Scene* pScene,
2990  G4VisCommandSceneAddUserAction::ActionType type,
2991  G4VisManager::Verbosity verbosity)
2992 {
2993   G4bool warn = verbosity >= G4VisManager::warnings;
2994 
2995   const std::map<G4VUserVisAction*,G4VisExtent>& visExtentMap =
2996     fpVisManager->GetUserVisActionExtents();
2997   G4VisExtent extent;
2998   std::map<G4VUserVisAction*,G4VisExtent>::const_iterator i =
2999     visExtentMap.find(visAction);
3000   if (i != visExtentMap.end()) extent = i->second;
3001   if (warn) {
3002     if (extent.GetExtentRadius() <= 0.) {
3003       G4warn
3004       << "WARNING: User Vis Action \"" << name << "\" extent is null."
3005       << G4endl;
3006     }
3007   }
3008 
3009   G4VModel* model = new G4CallbackModel<G4VUserVisAction>(visAction);
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 -> AddRunDurationModel (model, warn);
3018     break;
3019   case endOfEvent:
3020     successful = pScene -> AddEndOfEventModel (model, warn);
3021     break;
3022   case endOfRun:
3023     successful = pScene -> AddEndOfRunModel (model, warn);
3024     break;
3025   }
3026   if (successful) {
3027     if (verbosity >= G4VisManager::confirmations) {
3028       const G4String& currentSceneName = pScene -> GetName ();
3029       G4cout << "User Vis Action added to scene \""
3030       << currentSceneName << "\"";
3031       if (verbosity >= G4VisManager::parameters) {
3032         G4cout << "\n  with extent " << extent;
3033       }
3034       G4cout << G4endl;
3035     }
3036   }
3037   else G4VisCommandsSceneAddUnsuccessful(verbosity);
3038 }
3039 
3040 ////////////// /vis/scene/add/volume ///////////////////////////////////////
3041 
3042 G4VisCommandSceneAddVolume::G4VisCommandSceneAddVolume () {
3043   G4bool omitable;
3044   fpCommand = new G4UIcommand ("/vis/scene/add/volume", this);
3045   fpCommand -> SetGuidance 
3046    ("Adds a physical volume to current scene, with optional clipping volume.");
3047   fpCommand -> SetGuidance 
3048     ("If physical-volume-name is \"world\" (the default), the top of the"
3049      "\nmain geometry tree (material world) is added. If \"worlds\", the"
3050      "\ntops of all worlds - material world and parallel worlds, if any - are"
3051      "\nadded. Otherwise a search of all worlds is made.");
3052   fpCommand -> SetGuidance
3053     ("In the last case the names of all volumes in all worlds are matched"
3054      "\nagainst physical-volume-name. If this is of the form \"/regexp/\","
3055      "\nwhere regexp is a regular expression (see C++ regex), the match uses"
3056      "\nthe usual rules of regular expression matching. Otherwise an exact"
3057      "\nmatch is required."
3058      "\nFor example, \"/Shap/\" adds \"Shape1\" and \"Shape2\".");
3059   fpCommand -> SetGuidance
3060     ("It may help to see a textual representation of the geometry hierarchy of"
3061      "\nthe worlds. Try \"/vis/drawTree [worlds]\" or one of the driver/browser"
3062      "\ncombinations that have the required functionality, e.g., HepRepFile.");
3063   fpCommand -> SetGuidance
3064     ("If clip-volume-type is specified, the subsequent parameters are used to"
3065      "\nto define a clipping volume. For example,"
3066      "\n\"/vis/scene/add/volume ! ! ! -box km 0 1 0 1 0 1\" will draw the world"
3067      "\nwith the positive octant cut away. (If the Boolean Processor issues"
3068      "\nwarnings try replacing 0 by 0.000000001 or something.)");
3069   fpCommand -> SetGuidance
3070     ("If clip-volume-type is prepended with '-', the clip-volume is subtracted"
3071      "\n(cutaway). (This is the default if there is no prepended character.)"
3072      "\nIf '*' is prepended, the intersection of the physical-volume and the"
3073      "\nclip-volume is made. (You can make a section through the detector with"
3074      "\na thin box, for example).");
3075   fpCommand -> SetGuidance
3076     ("For \"box\", the parameters are xmin,xmax,ymin,ymax,zmin,zmax."
3077      "\nOnly \"box\" is programmed at present.");
3078   G4UIparameter* parameter;
3079   parameter = new G4UIparameter ("physical-volume-name", 's', omitable = true);
3080   parameter -> SetDefaultValue ("world");
3081   fpCommand -> SetParameter (parameter);
3082   parameter = new G4UIparameter ("copy-no", 'i', omitable = true);
3083   parameter -> SetGuidance ("If negative, matches any copy no.");
3084   parameter -> SetDefaultValue (-1);
3085   fpCommand -> SetParameter (parameter);
3086   parameter = new G4UIparameter ("depth-of-descent", 'i', omitable = true);
3087   parameter -> SetGuidance
3088     ("Depth of descent of geometry hierarchy. Default = unlimited depth.");
3089   parameter -> SetDefaultValue (G4PhysicalVolumeModel::UNLIMITED);
3090   fpCommand -> SetParameter (parameter);
3091   parameter = new G4UIparameter ("clip-volume-type", 's', omitable = true);
3092   parameter -> SetParameterCandidates("none box -box *box");
3093   parameter -> SetDefaultValue ("none");
3094   parameter -> SetGuidance("[-|*]type.  See general guidance.");
3095   fpCommand -> SetParameter (parameter);
3096   parameter = new G4UIparameter ("parameter-unit", 's', omitable = true);
3097   parameter -> SetDefaultValue ("m");
3098   fpCommand -> SetParameter (parameter);
3099   parameter = new G4UIparameter ("parameter-1", 'd', omitable = true);
3100   parameter -> SetDefaultValue (0.);
3101   fpCommand -> SetParameter (parameter);
3102   parameter = new G4UIparameter ("parameter-2", 'd', omitable = true);
3103   parameter -> SetDefaultValue (0.);
3104   fpCommand -> SetParameter (parameter);
3105   parameter = new G4UIparameter ("parameter-3", 'd', omitable = true);
3106   parameter -> SetDefaultValue (0.);
3107   fpCommand -> SetParameter (parameter);
3108   parameter = new G4UIparameter ("parameter-4", 'd', omitable = true);
3109   parameter -> SetDefaultValue (0.);
3110   fpCommand -> SetParameter (parameter);
3111   parameter = new G4UIparameter ("parameter-5", 'd', omitable = true);
3112   parameter -> SetDefaultValue (0.);
3113   fpCommand -> SetParameter (parameter);
3114   parameter = new G4UIparameter ("parameter-6", 'd', omitable = true);
3115   parameter -> SetDefaultValue (0.);
3116   fpCommand -> SetParameter (parameter);
3117 }
3118 
3119 G4VisCommandSceneAddVolume::~G4VisCommandSceneAddVolume () {
3120   delete fpCommand;
3121 }
3122 
3123 G4String G4VisCommandSceneAddVolume::GetCurrentValue (G4UIcommand*) {
3124   return "world 0 -1";
3125 }
3126 
3127 void G4VisCommandSceneAddVolume::SetNewValue (G4UIcommand*,
3128                 G4String newValue) {
3129 
3130   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
3131   G4bool warn = verbosity >= G4VisManager::warnings;
3132 
3133   G4Scene* pScene = fpVisManager->GetCurrentScene();
3134   if (!pScene) {
3135     if (verbosity >= G4VisManager::errors) {
3136       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
3137     }
3138     return;
3139   }
3140 
3141   G4String name, clipVolumeType, parameterUnit;
3142   G4int copyNo, requestedDepthOfDescent;
3143   G4double param1, param2, param3, param4, param5, param6;
3144   std::istringstream is (newValue);
3145   is >> name >> copyNo >> requestedDepthOfDescent
3146      >> clipVolumeType >> parameterUnit
3147      >> param1 >> param2 >> param3 >> param4 >> param5 >> param6;
3148   G4PhysicalVolumeModel::ClippingMode clippingMode =
3149     G4PhysicalVolumeModel::subtraction;  // Default subtraction mode.
3150   if (clipVolumeType[size_t(0)] == '-') {
3151     clipVolumeType = clipVolumeType.substr(1);  // Remove first character.
3152   } else if (clipVolumeType[size_t(0)] == '*') {
3153     clippingMode = G4PhysicalVolumeModel::intersection;
3154     clipVolumeType = clipVolumeType.substr(1);
3155   }
3156   G4double unit = G4UIcommand::ValueOf(parameterUnit);
3157   param1 *= unit; param2 *= unit; param3 *= unit;
3158   param4 *= unit; param5 *= unit; param6 *= unit;
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* transportationManager =
3175     G4TransportationManager::GetTransportationManager ();
3176 
3177   size_t nWorlds = transportationManager->GetNoWorlds();
3178   if (nWorlds > 1) {  // Parallel worlds in operation...
3179     if (verbosity >= G4VisManager::warnings) {
3180       static G4bool warned = false;
3181       if (!warned && name != "worlds") {
3182   G4warn <<
3183     "WARNING: Parallel worlds in operation.  To visualise, specify"
3184     "\n  \"worlds\" or the parallel world volume or sub-volume name"
3185     "\n   and control visibility with /vis/geometry."
3186          << G4endl;
3187   std::vector<G4VPhysicalVolume*>::iterator iterWorld =
3188     transportationManager->GetWorldsIterator();
3189   for (size_t i = 0; i < nWorlds; ++i, ++iterWorld) {
3190     G4warn << "  World " << i << ": " << (*iterWorld)->GetName()
3191      << G4endl;
3192     warned = true;
3193   }
3194       }
3195     }
3196   }
3197 
3198   // Get the world (the initial value of the iterator points to the mass world).
3199   G4VPhysicalVolume* world = *(transportationManager->GetWorldsIterator());
3200 
3201   if (!world) {
3202     if (verbosity >= G4VisManager::errors) {
3203       G4warn <<
3204   "ERROR: G4VisCommandSceneAddVolume::SetNewValue:"
3205   "\n  No world.  Maybe the geometry has not yet been defined."
3206   "\n  Try \"/run/initialize\""
3207        << G4endl;
3208     }
3209     return;
3210   }
3211 
3212   std::vector<G4PhysicalVolumesSearchScene::Findings> findingsVector;
3213 
3214   // When it comes to determining the extent of a physical volume we normally
3215   // assume the user wishes to ignore "invisible" volumes. For example, most
3216   // users make the world volume invisible. So we ask the physical volume
3217   // model to traverse the geometry hierarchy, starting at the named physical
3218   // volume, until it finds non-invisible ones, whose extents are accumulated
3219   // to determine the overall extent. (Once a non-invisible volume is found,
3220   // the search is curtailed - daughters are always contained within the mother
3221   // so they have no subsequent influence on the extent of the mother - but the
3222   // search continues at the same level until all highest level non-invisible
3223   // volumes are found an their extents accumulated.) So the default is
3224   G4bool useFullExtent = false;
3225   // However, the above procedure can be time consuming in some situations, such
3226   // as a nested parameterisation whose ultimate volumes are the first non-
3227   // visible ones, which are typical of a medical "phantom". So we assume here
3228   // below that if a user specifies a name other than "world" or "worlds" he/she
3229   // wished the extent to be determined by the volume, whether it is visible
3230   // or not. So we set useFullExtent true at that point below.
3231 
3232   if (name == "world") {
3233 
3234     findingsVector.push_back
3235     (G4PhysicalVolumesSearchScene::Findings(world,world));
3236 
3237   } else if (name == "worlds") {
3238 
3239     if (nWorlds <= 1) {
3240       if (verbosity >= G4VisManager::warnings) {
3241   G4warn <<
3242     "WARNING: G4VisCommandSceneAddVolume::SetNewValue:"
3243     "\n  Parallel worlds requested but none exist."
3244     "\n  Just adding material world."
3245          << G4endl;
3246       }
3247     }
3248     std::vector<G4VPhysicalVolume*>::iterator iterWorld =
3249       transportationManager->GetWorldsIterator();
3250     for (size_t i = 0; i < nWorlds; ++i, ++iterWorld) {
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 assumes the user wants these
3259     // volumes in the findings vector (there could be more than one) to
3260     // determine the scene's extent. Otherwise G4PhysicalVolumeModel would
3261     // re-calculate each volume's extent based on visibility, etc., which
3262     // could be time consuming.
3263     useFullExtent = true;
3264 
3265     std::vector<G4VPhysicalVolume*>::iterator iterWorld =
3266       transportationManager->GetWorldsIterator();
3267     for (size_t i = 0; i < nWorlds; ++i, ++iterWorld) {
3268       G4ModelingParameters mp;  // Default - no culling.
3269       G4PhysicalVolumeModel searchModel
3270       (*iterWorld,
3271        requestedDepthOfDescent,
3272        G4Transform3D(),
3273        &mp,
3274        useFullExtent);
3275       G4PhysicalVolumesSearchScene searchScene(&searchModel, name, copyNo);
3276       searchModel.DescribeYourselfTo (searchScene);  // Initiate search.
3277       for (const auto& findings: searchScene.GetFindings()) {
3278         findingsVector.push_back(findings);
3279       }
3280     }
3281   }
3282 
3283   for (const auto& findings: findingsVector) {
3284     // Set copy number from search findings for replicas and parameterisations.
3285     findings.fpFoundPV->SetCopyNo(findings.fFoundPVCopyNo);
3286     G4PhysicalVolumeModel* foundPVModel = new G4PhysicalVolumeModel
3287     (findings.fpFoundPV,
3288      requestedDepthOfDescent,
3289      findings.fFoundObjectTransformation,
3290      0, // No modelling parameters (these are set later by the scene handler).
3291      useFullExtent,
3292      findings.fFoundBasePVPath);
3293     if (clippingSolid) {
3294       foundPVModel->SetClippingSolid(clippingSolid);
3295       foundPVModel->SetClippingMode(clippingMode);
3296     }
3297     if (!foundPVModel->Validate(warn)) return;
3298     // ...so add it to the scene.
3299     G4bool successful = pScene->AddRunDurationModel(foundPVModel,warn);
3300     if (successful) {
3301       if (verbosity >= G4VisManager::confirmations) {
3302         G4cout << "\"" << findings.fpFoundPV->GetName()
3303         << "\", copy no. " << findings.fFoundPVCopyNo
3304         << ",\n  found in searched volume \""
3305         << findings.fpSearchPV->GetName()
3306         << "\" at depth " << findings.fFoundDepth
3307         << ",\n  base path: \"" << findings.fFoundBasePVPath
3308         << "\",\n  with a requested depth of further descent of ";
3309         if (requestedDepthOfDescent < 0) {
3310           G4cout << "<0 (unlimited)";
3311         }
3312         else {
3313           G4cout << requestedDepthOfDescent;
3314         }
3315         G4cout << ",\n  has been added to scene \"" << pScene->GetName() << "\"."
3316         << G4endl;
3317       }
3318     } else {
3319       G4VisCommandsSceneAddUnsuccessful(verbosity);
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     }
3331     G4VisCommandsSceneAddUnsuccessful(verbosity);
3332     return;
3333   }
3334 
3335   CheckSceneAndNotifyHandlers(pScene);
3336 }
3337 
3338 /////////////////////////////////////////////////////////////////////////////
3339 ////////////// /vis/scene/add/plotter ///////////////////////////////////////
3340 /////////////////////////////////////////////////////////////////////////////
3341 G4VisCommandSceneAddPlotter::G4VisCommandSceneAddPlotter () {
3342   fpCommand = new G4UIcommand("/vis/scene/add/plotter", this);
3343   fpCommand -> SetGuidance ("Add a plotter to current scene.");
3344   
3345   G4UIparameter* parameter;
3346   parameter =  new G4UIparameter ("plotter", 's',false);
3347   fpCommand->SetParameter(parameter);
3348 }
3349 
3350 G4VisCommandSceneAddPlotter::~G4VisCommandSceneAddPlotter () {delete fpCommand;}
3351 
3352 G4String G4VisCommandSceneAddPlotter::GetCurrentValue (G4UIcommand*) {return "";}
3353 
3354 void G4VisCommandSceneAddPlotter::SetNewValue (G4UIcommand*, G4String newValue)
3355 {
3356   G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
3357   G4bool warn(verbosity >= G4VisManager::warnings);
3358 
3359   G4Scene* pScene = fpVisManager->GetCurrentScene();
3360   if (!pScene) {
3361     if (verbosity >= G4VisManager::errors) {
3362       G4warn << "ERROR: No current scene.  Please create one." << G4endl;
3363     }
3364     return;
3365   }
3366 
3367   G4Plotter& _plotter = G4PlotterManager::GetInstance().GetPlotter(newValue);
3368   G4VModel* model = new G4PlotterModel(_plotter,newValue);
3369 
3370   const G4String& currentSceneName = pScene -> GetName ();
3371   G4bool successful = pScene -> AddEndOfRunModel(model, warn);
3372   if (successful) {
3373     if (verbosity >= G4VisManager::confirmations) {
3374       G4cout
3375       << "Plotter \"" << model->GetCurrentDescription()
3376       << "\" has been added to scene \"" << currentSceneName << "\"."
3377       << G4endl;
3378     }
3379   }
3380   else G4VisCommandsSceneAddUnsuccessful(verbosity);
3381 
3382   CheckSceneAndNotifyHandlers (pScene);
3383 }
3384 
3385