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