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 ]

Diff markup

Differences between /visualization/management/src/G4VisCommandsSceneAdd.cc (Version 11.3.0) and /visualization/management/src/G4VisCommandsSceneAdd.cc (Version 10.2.p3)


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