| 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 27
28 // /vis/viewer/set commands - John Allison 16 28 // /vis/viewer/set commands - John Allison 16th May 2000
29 29
30 #include "G4VisCommandsViewerSet.hh" 30 #include "G4VisCommandsViewerSet.hh"
31 31
32 #include "G4UIcommand.hh" 32 #include "G4UIcommand.hh"
33 #include "G4UIcmdWithoutParameter.hh" <<
34 #include "G4UIcmdWithAString.hh" 33 #include "G4UIcmdWithAString.hh"
35 #include "G4UIcmdWithABool.hh" 34 #include "G4UIcmdWithABool.hh"
36 #include "G4UIcmdWithAnInteger.hh" 35 #include "G4UIcmdWithAnInteger.hh"
37 #include "G4UIcmdWithADouble.hh" 36 #include "G4UIcmdWithADouble.hh"
38 #include "G4UIcmdWith3VectorAndUnit.hh" 37 #include "G4UIcmdWith3VectorAndUnit.hh"
39 #include "G4UnitsTable.hh" 38 #include "G4UnitsTable.hh"
40 #include "G4VisManager.hh" 39 #include "G4VisManager.hh"
41 #include "G4Polyhedron.hh" 40 #include "G4Polyhedron.hh"
42 #include "G4SystemOfUnits.hh" 41 #include "G4SystemOfUnits.hh"
43 42
44 #include <sstream> 43 #include <sstream>
45 #include <iomanip> 44 #include <iomanip>
46 #include <utility> <<
47 <<
48 #define G4warn G4cout <<
49 45
50 G4VisCommandsViewerSet::G4VisCommandsViewerSet 46 G4VisCommandsViewerSet::G4VisCommandsViewerSet ():
51 fLightsVector (G4ThreeVector(1.,1.,1.)), << 47 fLightsVector (G4ThreeVector(1.,1.,1.)),
52 fUpVector (G4ThreeVector(0.,1.,0.)), << 48 fUpVector (G4ThreeVector(0.,1.,0.)),
53 fViewpointVector (G4ThreeVector(0.,0.,1.)) << 49 fViewpointVector (G4ThreeVector(0.,0.,1.))
54 { 50 {
55 G4bool omitable; 51 G4bool omitable;
56 G4UIparameter* parameter; 52 G4UIparameter* parameter;
57 53
58 fpCommandAll = new G4UIcmdWithAString ("/vis 54 fpCommandAll = new G4UIcmdWithAString ("/vis/viewer/set/all",this);
59 fpCommandAll->SetGuidance 55 fpCommandAll->SetGuidance
60 ("Copies view parameters."); << 56 ("Copies view parameters.");
61 fpCommandAll->SetGuidance 57 fpCommandAll->SetGuidance
62 ("Copies ALL view parameters (except the aut 58 ("Copies ALL view parameters (except the autoRefresh status) from"
63 "\nfrom-viewer to current viewer. You may n 59 "\nfrom-viewer to current viewer. You may need \"/vis/viewer/rebuild\".");
64 fpCommandAll->SetGuidance 60 fpCommandAll->SetGuidance
65 ("Note: to copy only the camera-specific par 61 ("Note: to copy only the camera-specific parameters use"
66 "\n\"/vis/viewer/copyfrom\"."); 62 "\n\"/vis/viewer/copyfrom\".");
67 fpCommandAll->SetParameterName ("from-viewer 63 fpCommandAll->SetParameterName ("from-viewer-name",omitable = false);
68 64
69 fpCommandAutoRefresh = new G4UIcmdWithABool 65 fpCommandAutoRefresh = new G4UIcmdWithABool
70 ("/vis/viewer/set/autoRefresh",this); << 66 ("/vis/viewer/set/autoRefresh",this);
71 fpCommandAutoRefresh->SetGuidance("Sets auto 67 fpCommandAutoRefresh->SetGuidance("Sets auto-refresh.");
72 fpCommandAutoRefresh->SetGuidance 68 fpCommandAutoRefresh->SetGuidance
73 ("If true, view is automatically refreshed a << 69 ("If true, view is automatically refreshed after a change of"
74 "\nview parameters."); << 70 "\nview parameters.");
75 fpCommandAutoRefresh->SetParameterName("auto 71 fpCommandAutoRefresh->SetParameterName("auto-refresh",omitable = true);
76 fpCommandAutoRefresh->SetDefaultValue(true); 72 fpCommandAutoRefresh->SetDefaultValue(true);
77 73
78 fpCommandAuxEdge = new G4UIcmdWithABool 74 fpCommandAuxEdge = new G4UIcmdWithABool
79 ("/vis/viewer/set/auxiliaryEdge",this); << 75 ("/vis/viewer/set/auxiliaryEdge",this);
80 fpCommandAuxEdge->SetGuidance("Sets visibili 76 fpCommandAuxEdge->SetGuidance("Sets visibility of auxiliary edges");
81 fpCommandAuxEdge->SetGuidance 77 fpCommandAuxEdge->SetGuidance
82 ("Auxiliary edges, i.e., those that are part << 78 ("Auxiliary edges, i.e., those that are part of a curved surface,"
83 "\nsometimes called soft edges, become visi << 79 "\nsometimes called soft edges, become visible/invisible.");
84 fpCommandAuxEdge->SetParameterName("edge",om 80 fpCommandAuxEdge->SetParameterName("edge",omitable = true);
85 fpCommandAuxEdge->SetDefaultValue(true); 81 fpCommandAuxEdge->SetDefaultValue(true);
86 82
87 fpCommandBackground = new G4UIcommand 83 fpCommandBackground = new G4UIcommand
88 ("/vis/viewer/set/background",this); << 84 ("/vis/viewer/set/background",this);
89 fpCommandBackground->SetGuidance 85 fpCommandBackground->SetGuidance
90 ("Set background colour and transparency (de << 86 ("Set background colour and transparency (default black and opaque).");
91 fpCommandBackground->SetGuidance(ConvertToCo 87 fpCommandBackground->SetGuidance(ConvertToColourGuidance());
92 parameter = new G4UIparameter("red_or_string 88 parameter = new G4UIparameter("red_or_string", 's', omitable = true);
93 parameter -> SetDefaultValue ("0."); 89 parameter -> SetDefaultValue ("0.");
94 fpCommandBackground -> SetParameter (paramet 90 fpCommandBackground -> SetParameter (parameter);
95 parameter = new G4UIparameter("green", 'd', 91 parameter = new G4UIparameter("green", 'd', omitable = true);
96 parameter -> SetDefaultValue (0.); 92 parameter -> SetDefaultValue (0.);
97 fpCommandBackground -> SetParameter (paramet 93 fpCommandBackground -> SetParameter (parameter);
98 parameter = new G4UIparameter ("blue", 'd', 94 parameter = new G4UIparameter ("blue", 'd', omitable = true);
99 parameter -> SetDefaultValue (0.); 95 parameter -> SetDefaultValue (0.);
100 fpCommandBackground -> SetParameter (paramet 96 fpCommandBackground -> SetParameter (parameter);
101 parameter = new G4UIparameter ("opacity", 'd 97 parameter = new G4UIparameter ("opacity", 'd', omitable = true);
102 parameter -> SetDefaultValue (1.); 98 parameter -> SetDefaultValue (1.);
103 fpCommandBackground -> SetParameter (paramet 99 fpCommandBackground -> SetParameter (parameter);
104 100
105 fpCommandCulling = new G4UIcommand("/vis/vie 101 fpCommandCulling = new G4UIcommand("/vis/viewer/set/culling",this);
106 fpCommandCulling->SetGuidance ("Set culling 102 fpCommandCulling->SetGuidance ("Set culling options.");
107 fpCommandCulling->SetGuidance 103 fpCommandCulling->SetGuidance
108 ("\"global\": enables/disables all other cul << 104 ("\"global\": enables/disables all other culling options.");
109 fpCommandCulling->SetGuidance 105 fpCommandCulling->SetGuidance
110 ("\"coveredDaughters\": culls, i.e., elimina << 106 ("\"coveredDaughters\": culls, i.e., eliminates, volumes that would not"
111 "\nbe seen because covered by ancestor volu << 107 "\nbe seen because covered by ancester volumes in surface drawing mode,"
112 "\nand then only if the ancestors are visib << 108 "\nand then only if the ancesters are visible and opaque, and then only"
113 "\nif no sections or cutaways are in operat << 109 "\nif no sections or cutaways are in operation. Intended solely to"
114 "\nimprove the speed of rendering visible v << 110 "\nimprove the speed of rendering visible volumes.");
115 fpCommandCulling->SetGuidance 111 fpCommandCulling->SetGuidance
116 ("\"invisible\": culls objects with the invi << 112 ("\"invisible\": culls objects with the invisible attribute set.");
117 fpCommandCulling->SetGuidance 113 fpCommandCulling->SetGuidance
118 ("\"density\": culls volumes with density lo << 114 ("\"density\": culls volumes with density lower than threshold. Useful"
119 "\nfor eliminating \"container volumes\" wi << 115 "\nfor eliminating \"container volumes\" with no physical correspondence,"
120 "\nwhose material is usually air. If this << 116 "\nwhose material is usually air. If this is selected, provide threshold"
121 "\ndensity and unit (e.g., g/cm3, mg/cm3 or << 117 "\ndensity and unit (e.g., g/cm3, mg/cm3 or kg/m3)."
122 ); << 118 );
123 parameter = new G4UIparameter("culling-optio 119 parameter = new G4UIparameter("culling-option",'s',omitable = false);
124 parameter->SetParameterCandidates 120 parameter->SetParameterCandidates
125 ("global coveredDaughters invisible density" << 121 ("global coveredDaughters invisible density");
126 fpCommandCulling->SetParameter(parameter); 122 fpCommandCulling->SetParameter(parameter);
127 parameter = new G4UIparameter("action",'b',o 123 parameter = new G4UIparameter("action",'b',omitable = true);
128 parameter->SetDefaultValue(1); 124 parameter->SetDefaultValue(1);
129 fpCommandCulling->SetParameter(parameter); 125 fpCommandCulling->SetParameter(parameter);
130 parameter = new G4UIparameter("density-thres 126 parameter = new G4UIparameter("density-threshold",'d',omitable = true);
131 parameter->SetDefaultValue("0.01"); 127 parameter->SetDefaultValue("0.01");
132 fpCommandCulling->SetParameter(parameter); 128 fpCommandCulling->SetParameter(parameter);
133 parameter = new G4UIparameter("unit",'s',omi 129 parameter = new G4UIparameter("unit",'s',omitable = true);
134 // parameter->SetParameterCandidates ("g/cm3 130 // parameter->SetParameterCandidates ("g/cm3 mg/cm3 kg/m3");
135 // Instead of the above, SetNewValue accepts 131 // Instead of the above, SetNewValue accepts *any* density unit.
136 parameter->SetDefaultValue("g/cm3"); 132 parameter->SetDefaultValue("g/cm3");
137 fpCommandCulling->SetParameter(parameter); 133 fpCommandCulling->SetParameter(parameter);
138 134
139 fpCommandCutawayMode = 135 fpCommandCutawayMode =
140 new G4UIcmdWithAString ("/vis/viewer/set/cut << 136 new G4UIcmdWithAString ("/vis/viewer/set/cutawayMode", this);
141 fpCommandCutawayMode->SetGuidance 137 fpCommandCutawayMode->SetGuidance
142 ("Sets cutaway mode - add (union) or multipl << 138 ("Sets cutaway mode - add (union) or multiply (intersection).");
143 fpCommandCutawayMode->SetParameterName ("cut 139 fpCommandCutawayMode->SetParameterName ("cutaway-mode",omitable = false);
144 fpCommandCutawayMode->SetCandidates ("add un 140 fpCommandCutawayMode->SetCandidates ("add union multiply intersection");
145 fpCommandCutawayMode->SetDefaultValue("union 141 fpCommandCutawayMode->SetDefaultValue("union");
146 142
147 fpCommandDefaultColour = new G4UIcommand 143 fpCommandDefaultColour = new G4UIcommand
148 ("/vis/viewer/set/defaultColour",this); << 144 ("/vis/viewer/set/defaultColour",this);
149 fpCommandDefaultColour->SetGuidance 145 fpCommandDefaultColour->SetGuidance
150 ("Set defaultColour colour and transparency << 146 ("Set defaultColour colour and transparency (default white and opaque).");
151 fpCommandDefaultColour->SetGuidance(ConvertT 147 fpCommandDefaultColour->SetGuidance(ConvertToColourGuidance());
152 parameter = new G4UIparameter("red_or_string 148 parameter = new G4UIparameter("red_or_string", 's', omitable = true);
153 parameter -> SetDefaultValue ("1."); 149 parameter -> SetDefaultValue ("1.");
154 fpCommandDefaultColour -> SetParameter (para 150 fpCommandDefaultColour -> SetParameter (parameter);
155 parameter = new G4UIparameter("green", 'd', 151 parameter = new G4UIparameter("green", 'd', omitable = true);
156 parameter -> SetDefaultValue (1.); 152 parameter -> SetDefaultValue (1.);
157 fpCommandDefaultColour -> SetParameter (para 153 fpCommandDefaultColour -> SetParameter (parameter);
158 parameter = new G4UIparameter ("blue", 'd', 154 parameter = new G4UIparameter ("blue", 'd', omitable = true);
159 parameter -> SetDefaultValue (1.); 155 parameter -> SetDefaultValue (1.);
160 fpCommandDefaultColour -> SetParameter (para 156 fpCommandDefaultColour -> SetParameter (parameter);
161 parameter = new G4UIparameter ("opacity", 'd 157 parameter = new G4UIparameter ("opacity", 'd', omitable = true);
162 parameter -> SetDefaultValue (1.); 158 parameter -> SetDefaultValue (1.);
163 fpCommandDefaultColour -> SetParameter (para 159 fpCommandDefaultColour -> SetParameter (parameter);
164 160
165 fpCommandDefaultTextColour = new G4UIcommand 161 fpCommandDefaultTextColour = new G4UIcommand
166 ("/vis/viewer/set/defaultTextColour",this); << 162 ("/vis/viewer/set/defaultTextColour",this);
167 fpCommandDefaultTextColour->SetGuidance 163 fpCommandDefaultTextColour->SetGuidance
168 ("Set defaultTextColour colour and transpare << 164 ("Set defaultTextColour colour and transparency (default blue and opaque).");
169 fpCommandDefaultTextColour->SetGuidance(Conv 165 fpCommandDefaultTextColour->SetGuidance(ConvertToColourGuidance());
170 parameter = new G4UIparameter("red_or_string 166 parameter = new G4UIparameter("red_or_string", 's', omitable = true);
171 parameter -> SetDefaultValue ("0."); 167 parameter -> SetDefaultValue ("0.");
172 fpCommandDefaultTextColour -> SetParameter ( 168 fpCommandDefaultTextColour -> SetParameter (parameter);
173 parameter = new G4UIparameter("green", 'd', 169 parameter = new G4UIparameter("green", 'd', omitable = true);
174 parameter -> SetDefaultValue (0.); 170 parameter -> SetDefaultValue (0.);
175 fpCommandDefaultTextColour -> SetParameter ( 171 fpCommandDefaultTextColour -> SetParameter (parameter);
176 parameter = new G4UIparameter ("blue", 'd', 172 parameter = new G4UIparameter ("blue", 'd', omitable = true);
177 parameter -> SetDefaultValue (1.); 173 parameter -> SetDefaultValue (1.);
178 fpCommandDefaultTextColour -> SetParameter ( 174 fpCommandDefaultTextColour -> SetParameter (parameter);
179 parameter = new G4UIparameter ("opacity", 'd 175 parameter = new G4UIparameter ("opacity", 'd', omitable = true);
180 parameter -> SetDefaultValue (1.); 176 parameter -> SetDefaultValue (1.);
181 fpCommandDefaultTextColour -> SetParameter ( 177 fpCommandDefaultTextColour -> SetParameter (parameter);
182 178
183 fpCommandEdge = new G4UIcmdWithABool("/vis/v 179 fpCommandEdge = new G4UIcmdWithABool("/vis/viewer/set/edge",this);
184 fpCommandEdge->SetGuidance 180 fpCommandEdge->SetGuidance
185 ("Edges become visible/invisible in surface << 181 ("Edges become visible/invisible in surface mode.");
186 fpCommandEdge->SetParameterName("edge",omita 182 fpCommandEdge->SetParameterName("edge",omitable = true);
187 fpCommandEdge->SetDefaultValue(true); 183 fpCommandEdge->SetDefaultValue(true);
188 184
189 fpCommandExplodeFactor = new G4UIcommand 185 fpCommandExplodeFactor = new G4UIcommand
190 ("/vis/viewer/set/explodeFactor", this); << 186 ("/vis/viewer/set/explodeFactor", this);
191 fpCommandExplodeFactor->SetGuidance 187 fpCommandExplodeFactor->SetGuidance
192 ("Moves top-level drawn volumes by this fact << 188 ("Moves top-level drawn volumes by this factor from this centre.");
193 parameter = new G4UIparameter("explodeFactor 189 parameter = new G4UIparameter("explodeFactor", 'd', omitable=true);
194 parameter->SetParameterRange("explodeFactor> 190 parameter->SetParameterRange("explodeFactor>=1.");
195 parameter->SetDefaultValue(1.); 191 parameter->SetDefaultValue(1.);
196 fpCommandExplodeFactor->SetParameter(paramet 192 fpCommandExplodeFactor->SetParameter(parameter);
197 parameter = new G4UIparameter("x",'d',omitab 193 parameter = new G4UIparameter("x",'d',omitable = true);
198 parameter->SetDefaultValue (0); 194 parameter->SetDefaultValue (0);
199 parameter->SetGuidance ("Coordinate of 195 parameter->SetGuidance ("Coordinate of explode centre.");
200 fpCommandExplodeFactor->SetParameter(paramet 196 fpCommandExplodeFactor->SetParameter(parameter);
201 parameter = new G4UIparameter("y",'d',omitab 197 parameter = new G4UIparameter("y",'d',omitable = true);
202 parameter->SetDefaultValue (0); 198 parameter->SetDefaultValue (0);
203 parameter->SetGuidance ("Coordinate of 199 parameter->SetGuidance ("Coordinate of explode centre.");
204 fpCommandExplodeFactor->SetParameter(paramet 200 fpCommandExplodeFactor->SetParameter(parameter);
205 parameter = new G4UIparameter("z",'d',omitab 201 parameter = new G4UIparameter("z",'d',omitable = true);
206 parameter->SetDefaultValue (0); 202 parameter->SetDefaultValue (0);
207 parameter->SetGuidance ("Coordinate of 203 parameter->SetGuidance ("Coordinate of explode centre.");
208 fpCommandExplodeFactor->SetParameter(paramet 204 fpCommandExplodeFactor->SetParameter(parameter);
209 parameter = new G4UIparameter("unit",'s',omi 205 parameter = new G4UIparameter("unit",'s',omitable = true);
210 parameter->SetDefaultValue ("m"); 206 parameter->SetDefaultValue ("m");
211 parameter->SetGuidance ("Unit of explod 207 parameter->SetGuidance ("Unit of explode centre.");
212 fpCommandExplodeFactor->SetParameter(paramet 208 fpCommandExplodeFactor->SetParameter(parameter);
213 209
214 fpCommandGlobalLineWidthScale = new G4UIcmdW 210 fpCommandGlobalLineWidthScale = new G4UIcmdWithADouble
215 ("/vis/viewer/set/globalLineWidthScale", thi << 211 ("/vis/viewer/set/globalLineWidthScale", this);
216 fpCommandGlobalLineWidthScale->SetGuidance 212 fpCommandGlobalLineWidthScale->SetGuidance
217 ("Multiplies line widths by this factor."); << 213 ("Multiplies line widths by this factor.");
218 fpCommandGlobalLineWidthScale-> 214 fpCommandGlobalLineWidthScale->
219 SetParameterName("scale-factor", omitable=tr << 215 SetParameterName("scale-factor", omitable=true);
220 fpCommandGlobalLineWidthScale->SetDefaultVal 216 fpCommandGlobalLineWidthScale->SetDefaultValue(1.);
221 217
222 fpCommandGlobalMarkerScale = new G4UIcmdWith 218 fpCommandGlobalMarkerScale = new G4UIcmdWithADouble
223 ("/vis/viewer/set/globalMarkerScale", this); << 219 ("/vis/viewer/set/globalMarkerScale", this);
224 fpCommandGlobalMarkerScale->SetGuidance 220 fpCommandGlobalMarkerScale->SetGuidance
225 ("Multiplies marker sizes by this factor."); << 221 ("Multiplies marker sizes by this factor.");
226 fpCommandGlobalMarkerScale-> 222 fpCommandGlobalMarkerScale->
227 SetParameterName("scale-factor", omitable=tr << 223 SetParameterName("scale-factor", omitable=true);
228 fpCommandGlobalMarkerScale->SetDefaultValue( 224 fpCommandGlobalMarkerScale->SetDefaultValue(1.);
229 225
230 fpCommandHiddenEdge = 226 fpCommandHiddenEdge =
231 new G4UIcmdWithABool("/vis/viewer/set/hidden << 227 new G4UIcmdWithABool("/vis/viewer/set/hiddenEdge",this);
232 fpCommandHiddenEdge->SetGuidance 228 fpCommandHiddenEdge->SetGuidance
233 ("Edges become hidden/seen in wireframe or s << 229 ("Edges become hidden/seen in wireframe or surface mode.");
234 fpCommandHiddenEdge->SetParameterName("hidde 230 fpCommandHiddenEdge->SetParameterName("hidden-edge",omitable = true);
235 fpCommandHiddenEdge->SetDefaultValue(true); 231 fpCommandHiddenEdge->SetDefaultValue(true);
236 232
237 fpCommandHiddenMarker = 233 fpCommandHiddenMarker =
238 new G4UIcmdWithABool("/vis/viewer/set/hidden << 234 new G4UIcmdWithABool("/vis/viewer/set/hiddenMarker",this);
239 fpCommandHiddenMarker->SetGuidance 235 fpCommandHiddenMarker->SetGuidance
240 ("If true, closer objects hide markers. Othe << 236 ("If true, closer objects hide markers. Otherwise, markers always show.");
241 fpCommandHiddenMarker->SetParameterName("hid 237 fpCommandHiddenMarker->SetParameterName("hidden-marker",omitable = true);
242 fpCommandHiddenMarker->SetDefaultValue(true) 238 fpCommandHiddenMarker->SetDefaultValue(true);
243 239
244 fpCommandLightsMove = new G4UIcmdWithAString 240 fpCommandLightsMove = new G4UIcmdWithAString
245 ("/vis/viewer/set/lightsMove",this); << 241 ("/vis/viewer/set/lightsMove",this);
246 fpCommandLightsMove->SetGuidance 242 fpCommandLightsMove->SetGuidance
247 ("Lights move with camera or with object"); << 243 ("Lights move with camera or with object");
248 fpCommandLightsMove->SetParameterName("light 244 fpCommandLightsMove->SetParameterName("lightsMove",omitable = false);
249 fpCommandLightsMove->SetCandidates 245 fpCommandLightsMove->SetCandidates
250 ("cam camera with-camera obj object with-obj << 246 ("cam camera with-camera obj object with-object");
251 247
252 fpCommandLightsThetaPhi = new G4UIcommand 248 fpCommandLightsThetaPhi = new G4UIcommand
253 ("/vis/viewer/set/lightsThetaPhi", this); << 249 ("/vis/viewer/set/lightsThetaPhi", this);
254 fpCommandLightsThetaPhi->SetGuidance 250 fpCommandLightsThetaPhi->SetGuidance
255 ("Set direction from target to lights."); << 251 ("Set direction from target to lights.");
256 parameter = new G4UIparameter("theta", 'd', 252 parameter = new G4UIparameter("theta", 'd', omitable = true);
257 parameter -> SetDefaultValue(60.); 253 parameter -> SetDefaultValue(60.);
258 fpCommandLightsThetaPhi -> SetParameter (par 254 fpCommandLightsThetaPhi -> SetParameter (parameter);
259 parameter = new G4UIparameter("phi", 'd', om 255 parameter = new G4UIparameter("phi", 'd', omitable = true);
260 parameter -> SetDefaultValue(45.); 256 parameter -> SetDefaultValue(45.);
261 fpCommandLightsThetaPhi -> SetParameter (par 257 fpCommandLightsThetaPhi -> SetParameter (parameter);
262 parameter = new G4UIparameter ("unit", 's', 258 parameter = new G4UIparameter ("unit", 's', omitable = true);
263 parameter -> SetDefaultValue ("deg"); 259 parameter -> SetDefaultValue ("deg");
264 fpCommandLightsThetaPhi -> SetParameter (par 260 fpCommandLightsThetaPhi -> SetParameter (parameter);
265 261
266 fpCommandLightsVector = new G4UIcommand 262 fpCommandLightsVector = new G4UIcommand
267 ("/vis/viewer/set/lightsVector", this); << 263 ("/vis/viewer/set/lightsVector", this);
268 fpCommandLightsVector->SetGuidance 264 fpCommandLightsVector->SetGuidance
269 ("Set direction from target to lights."); << 265 ("Set direction from target to lights.");
270 parameter = new G4UIparameter("x", 'd', omit 266 parameter = new G4UIparameter("x", 'd', omitable = true);
271 parameter -> SetDefaultValue (1); 267 parameter -> SetDefaultValue (1);
272 fpCommandLightsVector -> SetParameter (param 268 fpCommandLightsVector -> SetParameter (parameter);
273 parameter = new G4UIparameter("y", 'd', omit 269 parameter = new G4UIparameter("y", 'd', omitable = true);
274 parameter -> SetDefaultValue (1); 270 parameter -> SetDefaultValue (1);
275 fpCommandLightsVector -> SetParameter (param 271 fpCommandLightsVector -> SetParameter (parameter);
276 parameter = new G4UIparameter ("z", 'd', omi 272 parameter = new G4UIparameter ("z", 'd', omitable = true);
277 parameter -> SetDefaultValue (1); 273 parameter -> SetDefaultValue (1);
278 fpCommandLightsVector -> SetParameter (param 274 fpCommandLightsVector -> SetParameter (parameter);
279 275
280 fpCommandLineSegments = new G4UIcmdWithAnInt 276 fpCommandLineSegments = new G4UIcmdWithAnInteger
281 ("/vis/viewer/set/lineSegmentsPerCircle",thi << 277 ("/vis/viewer/set/lineSegmentsPerCircle",this);
282 fpCommandLineSegments->SetGuidance 278 fpCommandLineSegments->SetGuidance
283 ("Set number of sides per circle for polygon << 279 ("Set number of sides per circle for polygon/polyhedron drawing.");
284 fpCommandLineSegments->SetGuidance 280 fpCommandLineSegments->SetGuidance
285 ("Refers to graphical representation of obje << 281 ("Refers to graphical representation of objects with curved lines/surfaces.");
286 fpCommandLineSegments->SetParameterName("lin 282 fpCommandLineSegments->SetParameterName("line-segments",omitable = true);
287 fpCommandLineSegments->SetDefaultValue(24); 283 fpCommandLineSegments->SetDefaultValue(24);
288 284
289 fpCommandLineWidth = new G4UIcmdWithoutParam <<
290 ("/vis/viewer/set/lineWidth",this); <<
291 fpCommandLineWidth->SetGuidance <<
292 ("Use \"/vis/viewer/set/globalLineWidthScale <<
293 "\nFor trajectories use \"/vis/modeling/tra <<
294 "\nFor volumes use \"/vis/geometry/set/line <<
295 <<
296 fpCommandNumberOfCloudPoints = new G4UIcmdWi <<
297 ("/vis/viewer/set/numberOfCloudPoints",this) <<
298 fpCommandNumberOfCloudPoints->SetGuidance <<
299 ("Set number of points to be used for cloud <<
300 fpCommandNumberOfCloudPoints->SetParameterNa <<
301 fpCommandNumberOfCloudPoints->SetDefaultValu <<
302 <<
303 fpCommandPicking = new G4UIcmdWithABool 285 fpCommandPicking = new G4UIcmdWithABool
304 ("/vis/viewer/set/picking",this); << 286 ("/vis/viewer/set/picking",this);
305 fpCommandPicking->SetGuidance("Sets picking, 287 fpCommandPicking->SetGuidance("Sets picking, if available.");
306 fpCommandPicking->SetGuidance 288 fpCommandPicking->SetGuidance
307 ("If true, view is set up for picking, if av << 289 ("If true, view is set up for picking, if available.");
308 fpCommandPicking->SetGuidance 290 fpCommandPicking->SetGuidance
309 ("You may need to issue \"/vis/viewer/update << 291 ("You may need to issue \"/vis/viewer/update\".");
310 fpCommandPicking->SetGuidance 292 fpCommandPicking->SetGuidance
311 ("For required actions, watch for instructio << 293 ("For required actions, watch for instructions for viewer.");
312 fpCommandPicking->SetParameterName("picking" 294 fpCommandPicking->SetParameterName("picking",omitable = true);
313 fpCommandPicking->SetDefaultValue(true); 295 fpCommandPicking->SetDefaultValue(true);
314 296
315 fpCommandProjection = new G4UIcommand("/vis/ 297 fpCommandProjection = new G4UIcommand("/vis/viewer/set/projection",this);
316 fpCommandProjection->SetGuidance 298 fpCommandProjection->SetGuidance
317 ("Set projection style - o[rthogonal] or p[e << 299 ("Set projection style - o[rthogonal] or p[erspective]."
318 "\nIf p[erspective], also set field half an << 300 "\nIf p[erspective], also set field half angle.");
319 parameter = new G4UIparameter("projection",' 301 parameter = new G4UIparameter("projection",'s',omitable = true);
320 parameter->SetParameterCandidates("o orthogo 302 parameter->SetParameterCandidates("o orthogonal p perspective");
321 parameter->SetDefaultValue("orthogonal"); 303 parameter->SetDefaultValue("orthogonal");
322 fpCommandProjection->SetParameter(parameter) 304 fpCommandProjection->SetParameter(parameter);
323 parameter = new G4UIparameter("field-half-an 305 parameter = new G4UIparameter("field-half-angle",'d',omitable = true);
324 parameter->SetDefaultValue(30.); 306 parameter->SetDefaultValue(30.);
325 //parameter->SetCurrentAsDefault(true); 307 //parameter->SetCurrentAsDefault(true);
326 fpCommandProjection->SetParameter(parameter) 308 fpCommandProjection->SetParameter(parameter);
327 parameter = new G4UIparameter("unit",'s',omi 309 parameter = new G4UIparameter("unit",'s',omitable = true);
328 parameter->SetDefaultValue("deg"); 310 parameter->SetDefaultValue("deg");
329 //parameter->SetCurrentAsDefault(true); 311 //parameter->SetCurrentAsDefault(true);
330 fpCommandProjection->SetParameter(parameter) 312 fpCommandProjection->SetParameter(parameter);
331 313
332 fpCommandRotationStyle = new G4UIcmdWithAStr 314 fpCommandRotationStyle = new G4UIcmdWithAString
333 ("/vis/viewer/set/rotationStyle",this); << 315 ("/vis/viewer/set/rotationStyle",this);
334 fpCommandRotationStyle->SetGuidance 316 fpCommandRotationStyle->SetGuidance
335 ("Set style of rotation - constrainUpDirecti << 317 ("Set style of rotation - constrainUpDirection or freeRotation.");
336 fpCommandRotationStyle->SetGuidance 318 fpCommandRotationStyle->SetGuidance
337 ("constrainUpDirection: conventional HEP vie << 319 ("constrainUpDirection: conventional HEP view.");
338 fpCommandRotationStyle->SetGuidance 320 fpCommandRotationStyle->SetGuidance
339 ("freeRotation: Google-like rotation, using << 321 ("freeRotation: Google-like rotation, using mouse-grab.");
340 fpCommandRotationStyle->SetParameterName ("s 322 fpCommandRotationStyle->SetParameterName ("style",omitable = false);
341 fpCommandRotationStyle->SetCandidates("const 323 fpCommandRotationStyle->SetCandidates("constrainUpDirection freeRotation");
342 324
343 fpCommandSectionPlane = new G4UIcommand("/vi 325 fpCommandSectionPlane = new G4UIcommand("/vis/viewer/set/sectionPlane",this);
344 fpCommandSectionPlane -> SetGuidance 326 fpCommandSectionPlane -> SetGuidance
345 ("Set plane for drawing section (DCUT)."); << 327 ("Set plane for drawing section (DCUT).");
346 fpCommandSectionPlane -> SetGuidance 328 fpCommandSectionPlane -> SetGuidance
347 ("E.g., for a y-z plane at x = 1 cm:" << 329 ("E.g., for a y-z plane at x = 1 cm:"
348 "\n\"/vis/viewer/set/sectionPlane on 1 0 0 << 330 "\n\"/vis/viewer/set/sectionPlane on 1 0 0 cm 1 0 0\"."
349 "\nTo turn off: /vis/viewer/set/sectionPlan << 331 "\nTo turn off: /vis/viewer/set/sectionPlane off");
350 parameter = new G4UIparameter("Selector",' 332 parameter = new G4UIparameter("Selector",'c',true);
351 parameter -> SetDefaultValue ("on"); 333 parameter -> SetDefaultValue ("on");
352 fpCommandSectionPlane->SetParameter(paramete 334 fpCommandSectionPlane->SetParameter(parameter);
353 parameter = new G4UIparameter("x",'d',omit 335 parameter = new G4UIparameter("x",'d',omitable = true);
354 parameter -> SetDefaultValue (0); 336 parameter -> SetDefaultValue (0);
355 parameter -> SetGuidance ("Coordinate 337 parameter -> SetGuidance ("Coordinate of point on the plane.");
356 fpCommandSectionPlane->SetParameter(paramete 338 fpCommandSectionPlane->SetParameter(parameter);
357 parameter = new G4UIparameter("y",'d',omit 339 parameter = new G4UIparameter("y",'d',omitable = true);
358 parameter -> SetDefaultValue (0); 340 parameter -> SetDefaultValue (0);
359 parameter -> SetGuidance ("Coordinate 341 parameter -> SetGuidance ("Coordinate of point on the plane.");
360 fpCommandSectionPlane->SetParameter(paramete 342 fpCommandSectionPlane->SetParameter(parameter);
361 parameter = new G4UIparameter("z",'d',omit 343 parameter = new G4UIparameter("z",'d',omitable = true);
362 parameter -> SetDefaultValue (0); 344 parameter -> SetDefaultValue (0);
363 parameter -> SetGuidance ("Coordinate 345 parameter -> SetGuidance ("Coordinate of point on the plane.");
364 fpCommandSectionPlane->SetParameter(paramete 346 fpCommandSectionPlane->SetParameter(parameter);
365 parameter = new G4UIparameter("unit",'s',o 347 parameter = new G4UIparameter("unit",'s',omitable = true);
366 parameter -> SetDefaultValue ("m"); 348 parameter -> SetDefaultValue ("m");
367 parameter -> SetGuidance ("Unit of poi 349 parameter -> SetGuidance ("Unit of point on the plane.");
368 fpCommandSectionPlane->SetParameter(paramete 350 fpCommandSectionPlane->SetParameter(parameter);
369 parameter = new G4UIparameter("nx",'d',omi 351 parameter = new G4UIparameter("nx",'d',omitable = true);
370 parameter -> SetDefaultValue (1); 352 parameter -> SetDefaultValue (1);
371 parameter -> SetGuidance ("Component o 353 parameter -> SetGuidance ("Component of plane normal.");
372 fpCommandSectionPlane->SetParameter(paramete 354 fpCommandSectionPlane->SetParameter(parameter);
373 parameter = new G4UIparameter("ny",'d',omi 355 parameter = new G4UIparameter("ny",'d',omitable = true);
374 parameter -> SetDefaultValue (0); 356 parameter -> SetDefaultValue (0);
375 parameter -> SetGuidance ("Component o 357 parameter -> SetGuidance ("Component of plane normal.");
376 fpCommandSectionPlane->SetParameter(paramete 358 fpCommandSectionPlane->SetParameter(parameter);
377 parameter = new G4UIparameter("nz",'d',omi 359 parameter = new G4UIparameter("nz",'d',omitable = true);
378 parameter -> SetDefaultValue (0); 360 parameter -> SetDefaultValue (0);
379 parameter -> SetGuidance ("Component o 361 parameter -> SetGuidance ("Component of plane normal.");
380 fpCommandSectionPlane->SetParameter(paramete 362 fpCommandSectionPlane->SetParameter(parameter);
381 363
382 fpCommandSpecialMeshRendering = new G4UIcmdW <<
383 ("/vis/viewer/set/specialMeshRendering",this <<
384 fpCommandSpecialMeshRendering -> SetGuidance <<
385 ("Request special rendering of volumes (mesh <<
386 fpCommandSpecialMeshRendering->SetParameterN <<
387 fpCommandSpecialMeshRendering->SetDefaultVal <<
388 <<
389 fpCommandSpecialMeshRenderingOption = new G4 <<
390 ("/vis/viewer/set/specialMeshRenderingOption <<
391 fpCommandSpecialMeshRenderingOption->SetGuid <<
392 ("Set special mesh rendering option - \"defa <<
393 fpCommandSpecialMeshRenderingOption->SetPara <<
394 fpCommandSpecialMeshRenderingOption->SetCand <<
395 fpCommandSpecialMeshRenderingOption->SetDefa <<
396 <<
397 fpCommandSpecialMeshVolumes = new G4UIcomman <<
398 ("/vis/viewer/set/specialMeshVolumes",this); <<
399 fpCommandSpecialMeshVolumes -> SetGuidance <<
400 ("Specify the volumes for special rendering. <<
401 "\nand is interpreted to mean \"all found m <<
402 fpCommandSpecialMeshVolumes->SetGuidance <<
403 ("Please provide a list of space-separated p <<
404 "\nnumber pairs. Negative copy number means <<
405 parameter = new G4UIparameter("volumes",'s', <<
406 parameter->SetGuidance <<
407 ("List of physical volume names and copy num <<
408 fpCommandSpecialMeshVolumes->SetParameter(pa <<
409 <<
410 fpCommandStyle = new G4UIcmdWithAString ("/v 364 fpCommandStyle = new G4UIcmdWithAString ("/vis/viewer/set/style",this);
411 fpCommandStyle->SetGuidance 365 fpCommandStyle->SetGuidance
412 ("Set style of drawing - w[ireframe] or s[ur << 366 ("Set style of drawing - w[ireframe] or s[urface].");
413 fpCommandStyle->SetGuidance << 367 fpCommandStyle->SetGuidance
414 ("(Hidden line drawing is controlled by \"/v << 368 ("(Hidden line drawing is controlled by \"/vis/viewer/set/hiddenEdge\".)");
415 fpCommandStyle->SetParameterName ("style",om 369 fpCommandStyle->SetParameterName ("style",omitable = false);
416 fpCommandStyle->SetCandidates("w wireframe s << 370 fpCommandStyle->SetCandidates("w wireframe s surface");
417 371
418 fpCommandTargetPoint = new G4UIcmdWith3Vecto 372 fpCommandTargetPoint = new G4UIcmdWith3VectorAndUnit
419 ("/vis/viewer/set/targetPoint", this); << 373 ("/vis/viewer/set/targetPoint", this);
420 fpCommandTargetPoint->SetGuidance 374 fpCommandTargetPoint->SetGuidance
421 ("Set target point."); << 375 ("Set target point.");
422 fpCommandTargetPoint->SetGuidance 376 fpCommandTargetPoint->SetGuidance
423 ("This sets the \"Current Target Point\" rel << 377 ("This sets the \"Current Target Point\" relative to the \"Standard");
424 fpCommandTargetPoint->SetGuidance 378 fpCommandTargetPoint->SetGuidance
425 ("Target Point\" so that the actual target p << 379 ("Target Point\" so that the actual target point is as requested.");
426 fpCommandTargetPoint->SetGuidance 380 fpCommandTargetPoint->SetGuidance
427 ("(See G4ViewParameters.hh for an explanatio << 381 ("(See G4ViewParameters.hh for an explanation of target points.)");
428 fpCommandTargetPoint->SetParameterName("x", 382 fpCommandTargetPoint->SetParameterName("x", "y", "z", omitable = false);
429 fpCommandTargetPoint->SetUnitCategory("Lengt 383 fpCommandTargetPoint->SetUnitCategory("Length");
430 384
431 fpCommandUpThetaPhi = new G4UIcommand 385 fpCommandUpThetaPhi = new G4UIcommand
432 ("/vis/viewer/set/upThetaPhi", this); << 386 ("/vis/viewer/set/upThetaPhi", this);
433 fpCommandUpThetaPhi -> SetGuidance ("Set up 387 fpCommandUpThetaPhi -> SetGuidance ("Set up vector.");
434 fpCommandUpThetaPhi -> SetGuidance 388 fpCommandUpThetaPhi -> SetGuidance
435 ("Viewer will attempt always to show this di << 389 ("Viewer will attempt always to show this direction upwards.");
436 parameter = new G4UIparameter("theta", 'd', 390 parameter = new G4UIparameter("theta", 'd', omitable = true);
437 parameter -> SetDefaultValue (90.); 391 parameter -> SetDefaultValue (90.);
438 fpCommandUpThetaPhi -> SetParameter (paramet 392 fpCommandUpThetaPhi -> SetParameter (parameter);
439 parameter = new G4UIparameter("phi", 'd', om 393 parameter = new G4UIparameter("phi", 'd', omitable = true);
440 parameter -> SetDefaultValue (90.); 394 parameter -> SetDefaultValue (90.);
441 fpCommandUpThetaPhi -> SetParameter (paramet 395 fpCommandUpThetaPhi -> SetParameter (parameter);
442 parameter = new G4UIparameter ("unit", 's', 396 parameter = new G4UIparameter ("unit", 's', omitable = true);
443 parameter -> SetDefaultValue ("deg"); 397 parameter -> SetDefaultValue ("deg");
444 fpCommandUpThetaPhi -> SetParameter (paramet 398 fpCommandUpThetaPhi -> SetParameter (parameter);
445 399
446 fpCommandUpVector = new G4UIcommand 400 fpCommandUpVector = new G4UIcommand
447 ("/vis/viewer/set/upVector", this); << 401 ("/vis/viewer/set/upVector", this);
448 fpCommandUpVector -> SetGuidance ("Set up ve 402 fpCommandUpVector -> SetGuidance ("Set up vector.");
449 fpCommandUpVector -> SetGuidance 403 fpCommandUpVector -> SetGuidance
450 ("Viewer will attempt always to show this di << 404 ("Viewer will attempt always to show this direction upwards.");
451 parameter = new G4UIparameter("x", 'd', omit 405 parameter = new G4UIparameter("x", 'd', omitable = true);
452 parameter -> SetDefaultValue (0.); 406 parameter -> SetDefaultValue (0.);
453 fpCommandUpVector -> SetParameter (parameter 407 fpCommandUpVector -> SetParameter (parameter);
454 parameter = new G4UIparameter("y", 'd', omit 408 parameter = new G4UIparameter("y", 'd', omitable = true);
455 parameter -> SetDefaultValue (1.); 409 parameter -> SetDefaultValue (1.);
456 fpCommandUpVector -> SetParameter (parameter 410 fpCommandUpVector -> SetParameter (parameter);
457 parameter = new G4UIparameter ("z", 'd', omi 411 parameter = new G4UIparameter ("z", 'd', omitable = true);
458 parameter -> SetDefaultValue (0.); 412 parameter -> SetDefaultValue (0.);
459 fpCommandUpVector -> SetParameter (parameter 413 fpCommandUpVector -> SetParameter (parameter);
460 414
461 fpCommandViewpointThetaPhi = new G4UIcommand 415 fpCommandViewpointThetaPhi = new G4UIcommand
462 ("/vis/viewer/set/viewpointThetaPhi", this); << 416 ("/vis/viewer/set/viewpointThetaPhi", this);
463 fpCommandViewpointThetaPhi -> SetGuidance 417 fpCommandViewpointThetaPhi -> SetGuidance
464 ("Set direction from target to camera."); << 418 ("Set direction from target to camera.");
465 fpCommandViewpointThetaPhi -> SetGuidance 419 fpCommandViewpointThetaPhi -> SetGuidance
466 ("Also changes lightpoint direction if light 420 ("Also changes lightpoint direction if lights are set to move with camera.");
467 parameter = new G4UIparameter("theta", 'd', 421 parameter = new G4UIparameter("theta", 'd', omitable = true);
468 parameter -> SetDefaultValue (60.); 422 parameter -> SetDefaultValue (60.);
469 fpCommandViewpointThetaPhi -> SetParameter ( 423 fpCommandViewpointThetaPhi -> SetParameter (parameter);
470 parameter = new G4UIparameter("phi", 'd', om 424 parameter = new G4UIparameter("phi", 'd', omitable = true);
471 parameter -> SetDefaultValue (45.); 425 parameter -> SetDefaultValue (45.);
472 fpCommandViewpointThetaPhi -> SetParameter ( 426 fpCommandViewpointThetaPhi -> SetParameter (parameter);
473 parameter = new G4UIparameter ("unit", 's', 427 parameter = new G4UIparameter ("unit", 's', omitable = true);
474 parameter -> SetDefaultValue ("deg"); 428 parameter -> SetDefaultValue ("deg");
475 fpCommandViewpointThetaPhi -> SetParameter ( 429 fpCommandViewpointThetaPhi -> SetParameter (parameter);
476 430
477 fpCommandViewpointVector = new G4UIcommand 431 fpCommandViewpointVector = new G4UIcommand
478 ("/vis/viewer/set/viewpointVector", this); << 432 ("/vis/viewer/set/viewpointVector", this);
479 fpCommandViewpointVector -> SetGuidance 433 fpCommandViewpointVector -> SetGuidance
480 ("Set direction from target to camera."); << 434 ("Set direction from target to camera.");
481 fpCommandViewpointVector -> SetGuidance 435 fpCommandViewpointVector -> SetGuidance
482 ("Also changes lightpoint direction if light 436 ("Also changes lightpoint direction if lights are set to move with camera.");
483 parameter = new G4UIparameter("x", 'd', omit 437 parameter = new G4UIparameter("x", 'd', omitable = true);
484 parameter -> SetDefaultValue (1.); 438 parameter -> SetDefaultValue (1.);
485 fpCommandViewpointVector -> SetParameter (pa 439 fpCommandViewpointVector -> SetParameter (parameter);
486 parameter = new G4UIparameter("y", 'd', omit 440 parameter = new G4UIparameter("y", 'd', omitable = true);
487 parameter -> SetDefaultValue (1.); 441 parameter -> SetDefaultValue (1.);
488 fpCommandViewpointVector -> SetParameter (pa 442 fpCommandViewpointVector -> SetParameter (parameter);
489 parameter = new G4UIparameter ("z", 'd', omi 443 parameter = new G4UIparameter ("z", 'd', omitable = true);
490 parameter -> SetDefaultValue (1.); 444 parameter -> SetDefaultValue (1.);
491 fpCommandViewpointVector -> SetParameter (pa 445 fpCommandViewpointVector -> SetParameter (parameter);
492 446
493 fpTimeWindowDirectory = new G4UIdirectory (" 447 fpTimeWindowDirectory = new G4UIdirectory ("/vis/viewer/set/timeWindow/");
494 fpTimeWindowDirectory -> SetGuidance ("Set t 448 fpTimeWindowDirectory -> SetGuidance ("Set time window parameters of current viewer.");
495 G4String timeWindowGuidance = 449 G4String timeWindowGuidance =
496 "For these commands use" 450 "For these commands use"
497 "\n /vis/scene/add/trajectories rich" 451 "\n /vis/scene/add/trajectories rich"
498 "\n /vis/modeling/trajectories/drawByCharge 452 "\n /vis/modeling/trajectories/drawByCharge-0/default/setTimeSliceInterval 0.01 ns"
499 "\nthen typically" 453 "\nthen typically"
500 "\n /vis/viewer/set/timeWindow/displayLight 454 "\n /vis/viewer/set/timeWindow/displayLightFront true 0 0 -50 cm -0.5 ns"
501 "\n /vis/viewer/set/timeWindow/displayHeadT 455 "\n /vis/viewer/set/timeWindow/displayHeadTime true"
502 "\n /vis/viewer/set/timeWindow/fadeFactor 1 456 "\n /vis/viewer/set/timeWindow/fadeFactor 1"
503 "\n /run/beamOn # or several until you get 457 "\n /run/beamOn # or several until you get a good event or events"
504 "\n /vis/viewer/set/timeWindow/startTime 0 458 "\n /vis/viewer/set/timeWindow/startTime 0 ns 1 ns"
505 "\n /vis/viewer/save" 459 "\n /vis/viewer/save"
506 "\n /vis/viewer/set/timeWindow/startTime 1 460 "\n /vis/viewer/set/timeWindow/startTime 1 ns 1 ns"
507 "\nthen zoom, pan etc to a view of interest 461 "\nthen zoom, pan etc to a view of interest and"
508 "\n /vis/viewer/save" 462 "\n /vis/viewer/save"
509 "\nthen repeat with next start time, another 463 "\nthen repeat with next start time, another view and a save, then try"
510 "\n /vis/viewer/interpolate"; 464 "\n /vis/viewer/interpolate";
511 465
512 fpCommandTimeWindowDisplayHeadTime = 466 fpCommandTimeWindowDisplayHeadTime =
513 new G4UIcommand("/vis/viewer/set/timeWindow/ 467 new G4UIcommand("/vis/viewer/set/timeWindow/displayHeadTime", this);
514 fpCommandTimeWindowDisplayHeadTime->SetGuida 468 fpCommandTimeWindowDisplayHeadTime->SetGuidance
515 ("Display head time of range in 2D text."); 469 ("Display head time of range in 2D text.");
516 fpCommandTimeWindowDisplayHeadTime->SetGuida 470 fpCommandTimeWindowDisplayHeadTime->SetGuidance(timeWindowGuidance);
517 parameter = new G4UIparameter ("displayHeadT 471 parameter = new G4UIparameter ("displayHeadTime", 'b', omitable = false);
518 parameter->SetDefaultValue(false); 472 parameter->SetDefaultValue(false);
519 fpCommandTimeWindowDisplayHeadTime->SetParam 473 fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
520 parameter = new G4UIparameter ("screenX", 'd 474 parameter = new G4UIparameter ("screenX", 'd', omitable = true);
521 parameter->SetGuidance("-1 < screenX < 1"); 475 parameter->SetGuidance("-1 < screenX < 1");
522 parameter->SetParameterRange("screenX >= -1. 476 parameter->SetParameterRange("screenX >= -1. && screenX <= 1.");
523 parameter->SetDefaultValue(-0.9); 477 parameter->SetDefaultValue(-0.9);
524 fpCommandTimeWindowDisplayHeadTime->SetParam 478 fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
525 parameter = new G4UIparameter ("screenY", 'd 479 parameter = new G4UIparameter ("screenY", 'd', omitable = true);
526 parameter->SetGuidance("-1 < screenY < 1"); 480 parameter->SetGuidance("-1 < screenY < 1");
527 parameter->SetParameterRange("screenY >= -1. 481 parameter->SetParameterRange("screenY >= -1. && screenY <= 1.");
528 parameter->SetDefaultValue(-0.9); 482 parameter->SetDefaultValue(-0.9);
529 fpCommandTimeWindowDisplayHeadTime->SetParam 483 fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
530 parameter = new G4UIparameter ("screenSize", 484 parameter = new G4UIparameter ("screenSize", 'd', omitable = true);
531 parameter->SetDefaultValue(24.); 485 parameter->SetDefaultValue(24.);
532 fpCommandTimeWindowDisplayHeadTime->SetParam 486 fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
533 parameter = new G4UIparameter ("red", 'd', o 487 parameter = new G4UIparameter ("red", 'd', omitable = true);
534 parameter->SetParameterRange("red >= 0. && r 488 parameter->SetParameterRange("red >= 0. && red <= 1.");
535 parameter->SetDefaultValue(0.); 489 parameter->SetDefaultValue(0.);
536 fpCommandTimeWindowDisplayHeadTime->SetParam 490 fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
537 parameter = new G4UIparameter ("green", 'd', 491 parameter = new G4UIparameter ("green", 'd', omitable = true);
538 parameter->SetParameterRange("green >= 0. && 492 parameter->SetParameterRange("green >= 0. && green <= 1.");
539 parameter->SetDefaultValue(1.); 493 parameter->SetDefaultValue(1.);
540 fpCommandTimeWindowDisplayHeadTime->SetParam 494 fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
541 parameter = new G4UIparameter ("blue", 'd', 495 parameter = new G4UIparameter ("blue", 'd', omitable = true);
542 parameter->SetParameterRange("blue >= 0. && 496 parameter->SetParameterRange("blue >= 0. && blue <= 1.");
543 parameter->SetDefaultValue(1.); 497 parameter->SetDefaultValue(1.);
544 fpCommandTimeWindowDisplayHeadTime->SetParam 498 fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
545 499
546 fpCommandTimeWindowDisplayLightFront = 500 fpCommandTimeWindowDisplayLightFront =
547 new G4UIcommand("/vis/viewer/set/timeWindow/ 501 new G4UIcommand("/vis/viewer/set/timeWindow/displayLightFront", this);
548 fpCommandTimeWindowDisplayLightFront->SetGui 502 fpCommandTimeWindowDisplayLightFront->SetGuidance
549 ("Display the light front at head time."); 503 ("Display the light front at head time.");
550 fpCommandTimeWindowDisplayLightFront->SetGui 504 fpCommandTimeWindowDisplayLightFront->SetGuidance
551 ("Tip: The trajectories can appear of jump a 505 ("Tip: The trajectories can appear of jump ahead of the light front"
552 "\nbecause their time range overlaps the vi 506 "\nbecause their time range overlaps the viewer's time range. To"
553 "\naverage out this discrete time effect, a 507 "\naverage out this discrete time effect, advance the light front by"
554 "\nhalf the trajectories interval. E.g., if 508 "\nhalf the trajectories interval. E.g., if the trajectory time slice"
555 "\ninterval is 0.01 ns:" 509 "\ninterval is 0.01 ns:"
556 "\n /vis/viewer/set/timeWindow/displayLigh 510 "\n /vis/viewer/set/timeWindow/displayLightFront true -90 0 0 mm -0.005 ns"
557 "\nTo prevent them beating the light front 511 "\nTo prevent them beating the light front at all:"
558 "\n /vis/viewer/set/timeWindow/displayLigh 512 "\n /vis/viewer/set/timeWindow/displayLightFront true -90 0 0 mm -0.01 ns");
559 fpCommandTimeWindowDisplayLightFront->SetGui 513 fpCommandTimeWindowDisplayLightFront->SetGuidance(timeWindowGuidance);
560 parameter = new G4UIparameter ("displayLight 514 parameter = new G4UIparameter ("displayLightFront", 'b', omitable = true);
561 parameter->SetDefaultValue(true); 515 parameter->SetDefaultValue(true);
562 fpCommandTimeWindowDisplayLightFront->SetPar 516 fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
563 parameter = new G4UIparameter ("originX", 'd 517 parameter = new G4UIparameter ("originX", 'd', omitable = true);
564 parameter->SetDefaultValue(0.); 518 parameter->SetDefaultValue(0.);
565 fpCommandTimeWindowDisplayLightFront->SetPar 519 fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
566 parameter = new G4UIparameter ("originY", 'd 520 parameter = new G4UIparameter ("originY", 'd', omitable = true);
567 parameter->SetDefaultValue(0.); 521 parameter->SetDefaultValue(0.);
568 fpCommandTimeWindowDisplayLightFront->SetPar 522 fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
569 parameter = new G4UIparameter ("originZ", 'd 523 parameter = new G4UIparameter ("originZ", 'd', omitable = true);
570 parameter->SetDefaultValue(0.); 524 parameter->SetDefaultValue(0.);
571 fpCommandTimeWindowDisplayLightFront->SetPar 525 fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
572 parameter = new G4UIparameter ("space_unit", 526 parameter = new G4UIparameter ("space_unit", 's', omitable = true);
573 parameter->SetDefaultValue("m"); 527 parameter->SetDefaultValue("m");
574 fpCommandTimeWindowDisplayLightFront->SetPar 528 fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
575 parameter = new G4UIparameter ("originT", 'd 529 parameter = new G4UIparameter ("originT", 'd', omitable = true);
576 parameter->SetDefaultValue(0.); 530 parameter->SetDefaultValue(0.);
577 fpCommandTimeWindowDisplayLightFront->SetPar 531 fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
578 parameter = new G4UIparameter ("time_unit", 532 parameter = new G4UIparameter ("time_unit", 's', omitable = true);
579 parameter->SetDefaultValue("s"); 533 parameter->SetDefaultValue("s");
580 fpCommandTimeWindowDisplayLightFront->SetPar 534 fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
581 parameter = new G4UIparameter ("red", 'd', o 535 parameter = new G4UIparameter ("red", 'd', omitable = true);
582 parameter->SetParameterRange("red >= 0. && r 536 parameter->SetParameterRange("red >= 0. && red <= 1.");
583 parameter->SetDefaultValue(0.); 537 parameter->SetDefaultValue(0.);
584 fpCommandTimeWindowDisplayLightFront->SetPar 538 fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
585 parameter = new G4UIparameter ("green", 'd', 539 parameter = new G4UIparameter ("green", 'd', omitable = true);
586 parameter->SetParameterRange("green >= 0. && 540 parameter->SetParameterRange("green >= 0. && green <= 1.");
587 parameter->SetDefaultValue(1.); 541 parameter->SetDefaultValue(1.);
588 fpCommandTimeWindowDisplayLightFront->SetPar 542 fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
589 parameter = new G4UIparameter ("blue", 'd', 543 parameter = new G4UIparameter ("blue", 'd', omitable = true);
590 parameter->SetParameterRange("blue >= 0. && 544 parameter->SetParameterRange("blue >= 0. && blue <= 1.");
591 parameter->SetDefaultValue(0.); 545 parameter->SetDefaultValue(0.);
592 fpCommandTimeWindowDisplayLightFront->SetPar 546 fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
593 547
594 fpCommandTimeWindowEndTime = 548 fpCommandTimeWindowEndTime =
595 new G4UIcommand("/vis/viewer/set/timeWindow/ 549 new G4UIcommand("/vis/viewer/set/timeWindow/endTime", this);
596 fpCommandTimeWindowEndTime->SetGuidance("Set 550 fpCommandTimeWindowEndTime->SetGuidance("Set end and range of track time.");
597 fpCommandTimeWindowEndTime->SetGuidance(time 551 fpCommandTimeWindowEndTime->SetGuidance(timeWindowGuidance);
598 parameter = new G4UIparameter ("end-time", ' 552 parameter = new G4UIparameter ("end-time", 'd', omitable = false);
599 parameter->SetDefaultValue(G4VisAttributes:: 553 parameter->SetDefaultValue(G4VisAttributes::fVeryLongTime);
600 fpCommandTimeWindowEndTime->SetParameter(par 554 fpCommandTimeWindowEndTime->SetParameter(parameter);
601 parameter = new G4UIparameter ("end-time-uni 555 parameter = new G4UIparameter ("end-time-unit", 's', omitable = false);
602 parameter->SetDefaultValue("ns"); 556 parameter->SetDefaultValue("ns");
603 fpCommandTimeWindowEndTime->SetParameter(par 557 fpCommandTimeWindowEndTime->SetParameter(parameter);
604 parameter = new G4UIparameter ("time-range", 558 parameter = new G4UIparameter ("time-range", 'd', omitable = true);
605 parameter->SetDefaultValue(-1.); 559 parameter->SetDefaultValue(-1.);
606 fpCommandTimeWindowEndTime->SetParameter(par 560 fpCommandTimeWindowEndTime->SetParameter(parameter);
607 parameter = new G4UIparameter ("time-range-u 561 parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
608 parameter->SetDefaultValue("ns"); 562 parameter->SetDefaultValue("ns");
609 fpCommandTimeWindowEndTime->SetParameter(par 563 fpCommandTimeWindowEndTime->SetParameter(parameter);
610 564
611 fpCommandTimeWindowFadeFactor = 565 fpCommandTimeWindowFadeFactor =
612 new G4UIcmdWithADouble("/vis/viewer/set/time 566 new G4UIcmdWithADouble("/vis/viewer/set/timeWindow/fadeFactor", this);
613 fpCommandTimeWindowFadeFactor->SetGuidance 567 fpCommandTimeWindowFadeFactor->SetGuidance
614 ("0: no fade; 1: maximum fade with time wind 568 ("0: no fade; 1: maximum fade with time window.");
615 fpCommandTimeWindowFadeFactor->SetGuidance(t 569 fpCommandTimeWindowFadeFactor->SetGuidance(timeWindowGuidance);
616 fpCommandTimeWindowFadeFactor->SetParameterN 570 fpCommandTimeWindowFadeFactor->SetParameterName("fade_factor", omitable = false);
617 fpCommandTimeWindowFadeFactor->SetRange("fad 571 fpCommandTimeWindowFadeFactor->SetRange("fade_factor>=0.&&fade_factor<=1.");
618 fpCommandTimeWindowFadeFactor->SetDefaultVal 572 fpCommandTimeWindowFadeFactor->SetDefaultValue(0.);
619 573
620 fpCommandTimeWindowStartTime = 574 fpCommandTimeWindowStartTime =
621 new G4UIcommand("/vis/viewer/set/timeWindow/ 575 new G4UIcommand("/vis/viewer/set/timeWindow/startTime", this);
622 fpCommandTimeWindowStartTime->SetGuidance("S 576 fpCommandTimeWindowStartTime->SetGuidance("Set start and range of track time.");
623 fpCommandTimeWindowStartTime->SetGuidance(ti 577 fpCommandTimeWindowStartTime->SetGuidance(timeWindowGuidance);
624 parameter = new G4UIparameter ("start-time", 578 parameter = new G4UIparameter ("start-time", 'd', omitable = false);
625 parameter->SetDefaultValue(-G4VisAttributes: 579 parameter->SetDefaultValue(-G4VisAttributes::fVeryLongTime);
626 fpCommandTimeWindowStartTime->SetParameter(p 580 fpCommandTimeWindowStartTime->SetParameter(parameter);
627 parameter = new G4UIparameter ("start-time-u 581 parameter = new G4UIparameter ("start-time-unit", 's', omitable = false);
628 parameter->SetDefaultValue("ns"); 582 parameter->SetDefaultValue("ns");
629 fpCommandTimeWindowStartTime->SetParameter(p 583 fpCommandTimeWindowStartTime->SetParameter(parameter);
630 parameter = new G4UIparameter ("time-range", 584 parameter = new G4UIparameter ("time-range", 'd', omitable = true);
631 parameter->SetDefaultValue(-1.); 585 parameter->SetDefaultValue(-1.);
632 fpCommandTimeWindowStartTime->SetParameter(p 586 fpCommandTimeWindowStartTime->SetParameter(parameter);
633 parameter = new G4UIparameter ("time-range-u 587 parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
634 parameter->SetDefaultValue("ns"); 588 parameter->SetDefaultValue("ns");
635 fpCommandTimeWindowStartTime->SetParameter(p 589 fpCommandTimeWindowStartTime->SetParameter(parameter);
636 } 590 }
637 591
638 G4VisCommandsViewerSet::~G4VisCommandsViewerSe 592 G4VisCommandsViewerSet::~G4VisCommandsViewerSet() {
639 delete fpCommandTimeWindowStartTime; 593 delete fpCommandTimeWindowStartTime;
640 delete fpCommandTimeWindowFadeFactor; 594 delete fpCommandTimeWindowFadeFactor;
641 delete fpCommandTimeWindowEndTime; 595 delete fpCommandTimeWindowEndTime;
642 delete fpCommandTimeWindowDisplayLightFront; 596 delete fpCommandTimeWindowDisplayLightFront;
643 delete fpCommandTimeWindowDisplayHeadTime; 597 delete fpCommandTimeWindowDisplayHeadTime;
644 delete fpTimeWindowDirectory; 598 delete fpTimeWindowDirectory;
645 delete fpCommandViewpointVector; 599 delete fpCommandViewpointVector;
646 delete fpCommandViewpointThetaPhi; 600 delete fpCommandViewpointThetaPhi;
647 delete fpCommandUpVector; 601 delete fpCommandUpVector;
648 delete fpCommandUpThetaPhi; 602 delete fpCommandUpThetaPhi;
649 delete fpCommandTargetPoint; 603 delete fpCommandTargetPoint;
650 delete fpCommandStyle; 604 delete fpCommandStyle;
651 delete fpCommandSpecialMeshVolumes; <<
652 delete fpCommandSpecialMeshRenderingOption; <<
653 delete fpCommandSpecialMeshRendering; <<
654 delete fpCommandSectionPlane; 605 delete fpCommandSectionPlane;
655 delete fpCommandRotationStyle; 606 delete fpCommandRotationStyle;
656 delete fpCommandProjection; 607 delete fpCommandProjection;
657 delete fpCommandPicking; 608 delete fpCommandPicking;
658 delete fpCommandNumberOfCloudPoints; <<
659 delete fpCommandLineWidth; <<
660 delete fpCommandLineSegments; 609 delete fpCommandLineSegments;
661 delete fpCommandLightsVector; 610 delete fpCommandLightsVector;
662 delete fpCommandLightsThetaPhi; 611 delete fpCommandLightsThetaPhi;
663 delete fpCommandLightsMove; 612 delete fpCommandLightsMove;
664 delete fpCommandHiddenMarker; 613 delete fpCommandHiddenMarker;
665 delete fpCommandHiddenEdge; 614 delete fpCommandHiddenEdge;
666 delete fpCommandGlobalMarkerScale; 615 delete fpCommandGlobalMarkerScale;
667 delete fpCommandGlobalLineWidthScale; 616 delete fpCommandGlobalLineWidthScale;
668 delete fpCommandExplodeFactor; 617 delete fpCommandExplodeFactor;
669 delete fpCommandEdge; 618 delete fpCommandEdge;
670 delete fpCommandDefaultTextColour; 619 delete fpCommandDefaultTextColour;
671 delete fpCommandDefaultColour; 620 delete fpCommandDefaultColour;
672 delete fpCommandCutawayMode; 621 delete fpCommandCutawayMode;
673 delete fpCommandCulling; 622 delete fpCommandCulling;
674 delete fpCommandBackground; 623 delete fpCommandBackground;
675 delete fpCommandAuxEdge; 624 delete fpCommandAuxEdge;
676 delete fpCommandAutoRefresh; 625 delete fpCommandAutoRefresh;
677 delete fpCommandAll; 626 delete fpCommandAll;
678 } 627 }
679 628
680 G4String G4VisCommandsViewerSet::GetCurrentVal 629 G4String G4VisCommandsViewerSet::GetCurrentValue(G4UIcommand*) {
681 return ""; 630 return "";
682 } 631 }
683 632
684 void G4VisCommandsViewerSet::SetNewValue 633 void G4VisCommandsViewerSet::SetNewValue
685 (G4UIcommand* command,G4String newValue) { 634 (G4UIcommand* command,G4String newValue) {
686 635
687 G4VisManager::Verbosity verbosity = fpVisMan 636 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
688 637
689 G4VViewer* currentViewer = fpVisManager->Get 638 G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
690 if (!currentViewer) { 639 if (!currentViewer) {
691 if (verbosity >= G4VisManager::errors) { 640 if (verbosity >= G4VisManager::errors) {
692 G4warn << << 641 G4cerr <<
693 "ERROR: G4VisCommandsViewerSet::SetNewVa << 642 "ERROR: G4VisCommandsViewerSet::SetNewValue: no current viewer."
694 << G4endl; << 643 << G4endl;
695 } 644 }
696 return; 645 return;
697 } 646 }
698 647
699 G4ViewParameters vp = currentViewer->GetView 648 G4ViewParameters vp = currentViewer->GetViewParameters();
700 649
701 if (command == fpCommandAll) { 650 if (command == fpCommandAll) {
702 G4VViewer* fromViewer = fpVisManager->GetV 651 G4VViewer* fromViewer = fpVisManager->GetViewer(newValue);
703 if (!fromViewer) { 652 if (!fromViewer) {
704 if (verbosity >= G4VisManager::errors) { 653 if (verbosity >= G4VisManager::errors) {
705 G4warn << << 654 G4cerr <<
706 "ERROR: G4VisCommandsViewerSet::SetNew << 655 "ERROR: G4VisCommandsViewerSet::SetNewValue: all:"
707 "\n unrecognised from-viewer." << 656 "\n unrecognised from-viewer."
708 << G4endl; << 657 << G4endl;
709 } 658 }
710 return; 659 return;
711 } 660 }
712 if (fromViewer == currentViewer) { 661 if (fromViewer == currentViewer) {
713 if (verbosity >= G4VisManager::warnings) 662 if (verbosity >= G4VisManager::warnings) {
714 G4warn << << 663 G4cout <<
715 "WARNING: G4VisCommandsViewerSet::SetN << 664 "WARNING: G4VisCommandsViewerSet::SetNewValue: all:"
716 "\n from-viewer and current viewer ar << 665 "\n from-viewer and current viewer are identical."
717 << G4endl; << 666 << G4endl;
718 } 667 }
719 return; 668 return;
720 } 669 }
721 // Copy view parameters except for autoRef << 670 // Copy view parameters except for autoRefresh...
722 auto keepAutoRefresh = vp.IsAutoRefresh(); << 671 G4bool currentAutoRefresh =
723 auto keepBackground = vp.GetBackgroundCol << 672 currentViewer->GetViewParameters().IsAutoRefresh();
724 vp = fromViewer->GetViewParameters(); 673 vp = fromViewer->GetViewParameters();
725 vp.SetAutoRefresh(keepAutoRefresh); << 674 vp.SetAutoRefresh(currentAutoRefresh);
726 vp.SetBackgroundColour(keepBackground); <<
727 // Concatenate any private vis attributes 675 // Concatenate any private vis attributes modifiers...
728 const std::vector<G4ModelingParameters::Vi 676 const std::vector<G4ModelingParameters::VisAttributesModifier>*
729 privateVAMs = fromViewer->GetPrivateVisAtt << 677 privateVAMs = fromViewer->GetPrivateVisAttributesModifiers();
730 if (privateVAMs) { 678 if (privateVAMs) {
731 std::vector<G4ModelingParameters::VisAtt 679 std::vector<G4ModelingParameters::VisAttributesModifier>::const_iterator i;
732 for (i = privateVAMs->begin(); i != priv 680 for (i = privateVAMs->begin(); i != privateVAMs->end(); ++i) {
733 vp.AddVisAttributesModifier(*i); 681 vp.AddVisAttributesModifier(*i);
734 } 682 }
735 } 683 }
736 if (verbosity >= G4VisManager::confirmatio 684 if (verbosity >= G4VisManager::confirmations) {
737 G4cout << "View parameters of viewer \"" 685 G4cout << "View parameters of viewer \"" << currentViewer->GetName()
738 << "\"\n set to those of viewer \"" << << 686 << "\"\n set to those of viewer \"" << fromViewer->GetName()
739 << "\"." << 687 << "\"."
740 << G4endl; << 688 << G4endl;
741 } 689 }
742 if (verbosity >= G4VisManager::warnings) { 690 if (verbosity >= G4VisManager::warnings) {
743 G4warn << "You may need \"/vis/viewer/re << 691 G4cout << "You may need \"/vis/viewer/rebuild\"."
744 << G4endl; << 692 << G4endl;
745 } 693 }
746 } 694 }
747 695
748 else if (command == fpCommandAutoRefresh) { 696 else if (command == fpCommandAutoRefresh) {
749 G4bool autoRefresh = G4UIcommand::ConvertT 697 G4bool autoRefresh = G4UIcommand::ConvertToBool(newValue);
750 const G4ViewParameters& defaultVP = 698 const G4ViewParameters& defaultVP =
751 currentViewer->GetDefaultViewParameters(); << 699 currentViewer->GetDefaultViewParameters();
752 if (autoRefresh && !defaultVP.IsAutoRefres 700 if (autoRefresh && !defaultVP.IsAutoRefresh()) {
753 if (verbosity >= G4VisManager::warnings) 701 if (verbosity >= G4VisManager::warnings) {
754 G4warn << 702 G4cout
755 << "WARNING: " << 703 << "WARNING: "
756 << currentViewer->GetName() << " is NO << 704 << currentViewer->GetName() << " is NOT auto-refesh by default"
757 << "\n so cannot be set to auto-refre << 705 << "\n so cannot be set to auto-refresh."
758 << G4endl; << 706 << G4endl;
759 } 707 }
760 return; 708 return;
761 } 709 }
762 vp.SetAutoRefresh(autoRefresh); 710 vp.SetAutoRefresh(autoRefresh);
763 if (verbosity >= G4VisManager::confirmatio 711 if (verbosity >= G4VisManager::confirmations) {
764 G4cout << "Views will "; 712 G4cout << "Views will ";
765 if (!vp.IsAutoRefresh()) G4cout << "not 713 if (!vp.IsAutoRefresh()) G4cout << "not ";
766 G4cout << "be automatically refreshed af 714 G4cout << "be automatically refreshed after a change of view parameters."
767 << G4endl; << 715 << G4endl;
768 } 716 }
769 if (!vp.IsAutoRefresh()) { 717 if (!vp.IsAutoRefresh()) {
770 currentViewer->SetViewParameters(vp); 718 currentViewer->SetViewParameters(vp);
771 return; // Avoid a refresh if auto-refr 719 return; // Avoid a refresh if auto-refresh has been set to off...
772 } // ...otherwise take normal action. 720 } // ...otherwise take normal action.
773 } 721 }
774 722
775 else if (command == fpCommandAuxEdge) { 723 else if (command == fpCommandAuxEdge) {
776 vp.SetAuxEdgeVisible(G4UIcommand::ConvertT 724 vp.SetAuxEdgeVisible(G4UIcommand::ConvertToBool(newValue));
777 if (verbosity >= G4VisManager::confirmatio 725 if (verbosity >= G4VisManager::confirmations) {
778 G4cout << "Auxiliary edges will "; 726 G4cout << "Auxiliary edges will ";
779 if (!vp.IsAuxEdgeVisible()) G4cout << "n 727 if (!vp.IsAuxEdgeVisible()) G4cout << "not ";
780 G4cout << "be visible." << G4endl; 728 G4cout << "be visible." << G4endl;
781 } 729 }
782 } 730 }
783 731
784 else if (command == fpCommandBackground) { 732 else if (command == fpCommandBackground) {
785 G4String redOrString; 733 G4String redOrString;
786 G4double green, blue, opacity; 734 G4double green, blue, opacity;
787 std::istringstream iss(newValue); 735 std::istringstream iss(newValue);
788 iss >> redOrString >> green >> blue >> opa 736 iss >> redOrString >> green >> blue >> opacity;
789 G4Colour colour(0.,0.,0.); // Default bla 737 G4Colour colour(0.,0.,0.); // Default black and opaque.
790 ConvertToColour(colour, redOrString, green 738 ConvertToColour(colour, redOrString, green, blue, opacity);
791 vp.SetBackgroundColour(colour); 739 vp.SetBackgroundColour(colour);
792 if (verbosity >= G4VisManager::confirmatio 740 if (verbosity >= G4VisManager::confirmations) {
793 G4cout << "Background colour " 741 G4cout << "Background colour "
794 << vp.GetBackgroundColour() << 742 << vp.GetBackgroundColour()
795 << " requested." << 743 << " requested."
796 << G4endl; << 744 << G4endl;
797 } 745 }
798 } 746 }
799 747
800 else if (command == fpCommandCulling) { 748 else if (command == fpCommandCulling) {
801 G4String cullingOption, stringFlag, unit; 749 G4String cullingOption, stringFlag, unit;
802 G4double density; 750 G4double density;
803 std::istringstream is (newValue); 751 std::istringstream is (newValue);
804 is >> cullingOption >> stringFlag >> densi 752 is >> cullingOption >> stringFlag >> density >> unit;
805 G4bool boolFlag = G4UIcommand::ConvertToBo 753 G4bool boolFlag = G4UIcommand::ConvertToBool(stringFlag);
806 if (cullingOption == "global") { 754 if (cullingOption == "global") {
807 vp.SetCulling(boolFlag); 755 vp.SetCulling(boolFlag);
808 if (verbosity >= G4VisManager::confirmat 756 if (verbosity >= G4VisManager::confirmations) {
809 G4cout << << 757 G4cout <<
810 "G4VisCommandsViewerSet::SetNewValue: << 758 "G4VisCommandsViewerSet::SetNewValue: culling: global culling flag"
811 " set to " << G4UIcommand::ConvertToSt << 759 " set to " << G4UIcommand::ConvertToString(boolFlag) <<
812 ".\n Does not change specific culling << 760 ".\n Does not change specific culling flags."
813 << G4endl; << 761 << G4endl;
814 } 762 }
815 } 763 }
816 else if (cullingOption == "coveredDaughter 764 else if (cullingOption == "coveredDaughters") {
817 vp.SetCullingCovered(boolFlag); 765 vp.SetCullingCovered(boolFlag);
818 if (verbosity >= G4VisManager::confirmat 766 if (verbosity >= G4VisManager::confirmations) {
819 G4cout << << 767 G4cout <<
820 "G4VisCommandsViewerSet::SetNewValue: << 768 "G4VisCommandsViewerSet::SetNewValue: culling: culling covered"
821 "\n daughters flag set to " << 769 "\n daughters flag set to "
822 << G4UIcommand::ConvertToString(boolFl << 770 << G4UIcommand::ConvertToString(boolFlag) <<
823 ". Daughters covered by opaque mother << 771 ". Daughters covered by opaque mothers"
824 "\n will be culled, i.e., not drawn, << 772 "\n will be culled, i.e., not drawn, if this flag is true."
825 "\n Note: this is only effective in s << 773 "\n Note: this is only effective in surface drawing style,"
826 "\n and then only if the volumes are << 774 "\n and then only if the volumes are visible and opaque, and then"
827 "\n only if no sections or cutaways a << 775 "\n only if no sections or cutaways are in operation."
828 << G4endl; << 776 << G4endl;
829 } 777 }
830 } 778 }
831 else if (cullingOption == "invisible") { 779 else if (cullingOption == "invisible") {
832 vp.SetCullingInvisible(boolFlag); 780 vp.SetCullingInvisible(boolFlag);
833 if (verbosity >= G4VisManager::confirmat 781 if (verbosity >= G4VisManager::confirmations) {
834 G4cout << << 782 G4cout <<
835 "G4VisCommandsViewerSet::SetNewValue: << 783 "G4VisCommandsViewerSet::SetNewValue: culling: culling invisible"
836 "\n flag set to " << 784 "\n flag set to "
837 << boolFlag << G4UIcommand::ConvertToS << 785 << boolFlag << G4UIcommand::ConvertToString(boolFlag) <<
838 ". Volumes marked invisible will be c << 786 ". Volumes marked invisible will be culled,"
839 "\n i.e., not drawn, if this flag is << 787 "\n i.e., not drawn, if this flag is true."
840 << G4endl; << 788 << G4endl;
841 } 789 }
842 } 790 }
843 else if (cullingOption == "density") { 791 else if (cullingOption == "density") {
844 const G4String where = 792 const G4String where =
845 "G4VisCommandsViewerSet::SetNewValue: cu 793 "G4VisCommandsViewerSet::SetNewValue: culling: culling by density";
846 if (boolFlag) { 794 if (boolFlag) {
847 G4double valueOfUnit; 795 G4double valueOfUnit;
848 // "Volumic Mass" is Michel's phrase f 796 // "Volumic Mass" is Michel's phrase for "Density"
849 if (ProvideValueOfUnit(where,unit,"Vol 797 if (ProvideValueOfUnit(where,unit,"Volumic Mass",valueOfUnit)) {
850 // Successful outcome of unit search 798 // Successful outcome of unit search
851 vp.SetDensityCulling(boolFlag); 799 vp.SetDensityCulling(boolFlag);
852 density *= valueOfUnit; 800 density *= valueOfUnit;
853 vp.SetVisibleDensity(density); 801 vp.SetVisibleDensity(density);
854 } else { 802 } else {
855 // Unsuccessful outcome of unit sear 803 // Unsuccessful outcome of unit search. Flag and density unchanged.
856 density = vp.GetVisibleDensity(); 804 density = vp.GetVisibleDensity();
857 } 805 }
858 } else { // Reset flag but density unch 806 } else { // Reset flag but density unchanged.
859 vp.SetDensityCulling(boolFlag); 807 vp.SetDensityCulling(boolFlag);
860 } 808 }
861 if (verbosity >= G4VisManager::confirmat 809 if (verbosity >= G4VisManager::confirmations) {
862 G4cout 810 G4cout
863 << where 811 << where
864 << "\n flag set to " 812 << "\n flag set to "
865 << std::boolalpha << vp.IsDensityCulli 813 << std::boolalpha << vp.IsDensityCulling()
866 << ". Volumes with density less than 814 << ". Volumes with density less than "
867 << G4BestUnit(density,"Volumic Mass") 815 << G4BestUnit(density,"Volumic Mass")
868 << "\n will be culled, i.e., not draw 816 << "\n will be culled, i.e., not drawn, if this flag is true."
869 << G4endl; 817 << G4endl;
870 } 818 }
871 } 819 }
872 else { 820 else {
873 if (verbosity >= G4VisManager::errors) { 821 if (verbosity >= G4VisManager::errors) {
874 G4warn << << 822 G4cerr <<
875 "ERROR: G4VisCommandsViewerSet::SetNew << 823 "ERROR: G4VisCommandsViewerSet::SetNewValue: culling:"
876 "\n option not recognised." << 824 "\n option not recognised."
877 << G4endl; << 825 << G4endl;
878 } 826 }
879 } 827 }
880 } 828 }
881 829
882 else if (command == fpCommandCutawayMode) { 830 else if (command == fpCommandCutawayMode) {
883 if (newValue == "add" || newValue == "unio 831 if (newValue == "add" || newValue == "union")
884 vp.SetCutawayMode(G4ViewParameters::cuta 832 vp.SetCutawayMode(G4ViewParameters::cutawayUnion);
885 if (newValue == "multiply" || newValue == 833 if (newValue == "multiply" || newValue == "intersection")
886 vp.SetCutawayMode(G4ViewParameters::cuta 834 vp.SetCutawayMode(G4ViewParameters::cutawayIntersection);
887 << 835
888 if (verbosity >= G4VisManager::confirmatio 836 if (verbosity >= G4VisManager::confirmations) {
889 G4cout << "Cutaway mode set to "; 837 G4cout << "Cutaway mode set to ";
890 if (vp.GetCutawayMode() == G4ViewParamet 838 if (vp.GetCutawayMode() == G4ViewParameters::cutawayUnion)
891 G4cout << "cutawayUnion"; << 839 G4cout << "cutawayUnion";
892 if (vp.GetCutawayMode() == G4ViewParamet 840 if (vp.GetCutawayMode() == G4ViewParameters::cutawayIntersection)
893 G4cout << "cutawayIntersection"; << 841 G4cout << "cutawayIntersection";
894 G4cout << G4endl; 842 G4cout << G4endl;
895 } 843 }
896 } 844 }
897 845
898 else if (command == fpCommandDefaultColour) 846 else if (command == fpCommandDefaultColour) {
899 G4String redOrString; 847 G4String redOrString;
900 G4double green, blue, opacity; 848 G4double green, blue, opacity;
901 std::istringstream iss(newValue); 849 std::istringstream iss(newValue);
902 iss >> redOrString >> green >> blue >> opa 850 iss >> redOrString >> green >> blue >> opacity;
903 G4Colour colour(1.,1.,1.); // Default whi 851 G4Colour colour(1.,1.,1.); // Default white and opaque.
904 ConvertToColour(colour, redOrString, green 852 ConvertToColour(colour, redOrString, green, blue, opacity);
905 G4VisAttributes va = vp.GetDefaultVisAttri 853 G4VisAttributes va = vp.GetDefaultVisAttributes();
906 va.SetColour(colour); 854 va.SetColour(colour);
907 vp.SetDefaultVisAttributes(va); 855 vp.SetDefaultVisAttributes(va);
908 if (verbosity >= G4VisManager::confirmatio 856 if (verbosity >= G4VisManager::confirmations) {
909 G4cout << "Default colour " 857 G4cout << "Default colour "
910 << vp.GetDefaultVisAttributes()->GetColo << 858 << vp.GetDefaultVisAttributes()->GetColour()
911 << " requested." << 859 << " requested."
912 << G4endl; << 860 << G4endl;
913 } 861 }
914 } 862 }
915 863
916 else if (command == fpCommandDefaultTextColo 864 else if (command == fpCommandDefaultTextColour) {
917 G4String redOrString; 865 G4String redOrString;
918 G4double green, blue, opacity; 866 G4double green, blue, opacity;
919 std::istringstream iss(newValue); 867 std::istringstream iss(newValue);
920 iss >> redOrString >> green >> blue >> opa 868 iss >> redOrString >> green >> blue >> opacity;
921 G4Colour colour(1.,1.,1.); // Default whi 869 G4Colour colour(1.,1.,1.); // Default white and opaque.
922 ConvertToColour(colour, redOrString, green 870 ConvertToColour(colour, redOrString, green, blue, opacity);
923 G4VisAttributes va = vp.GetDefaultTextVisA 871 G4VisAttributes va = vp.GetDefaultTextVisAttributes();
924 va.SetColour(colour); 872 va.SetColour(colour);
925 vp.SetDefaultTextVisAttributes(va); 873 vp.SetDefaultTextVisAttributes(va);
926 if (verbosity >= G4VisManager::confirmatio 874 if (verbosity >= G4VisManager::confirmations) {
927 G4cout << "Default colour " 875 G4cout << "Default colour "
928 << vp.GetDefaultTextVisAttributes()->Get << 876 << vp.GetDefaultTextVisAttributes()->GetColour()
929 << " requested." << 877 << " requested."
930 << G4endl; << 878 << G4endl;
931 } 879 }
932 } 880 }
933 881
934 else if (command == fpCommandEdge) { 882 else if (command == fpCommandEdge) {
935 G4ViewParameters::DrawingStyle existingSty 883 G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
936 if (G4UIcommand::ConvertToBool(newValue)) << 884 if (G4UIcommand::ConvertToBool(newValue)) {
937 switch (existingStyle) { 885 switch (existingStyle) {
938 case G4ViewParameters::wireframe: << 886 case G4ViewParameters::wireframe:
939 break; << 887 break;
940 case G4ViewParameters::hlr: << 888 case G4ViewParameters::hlr:
941 break; << 889 break;
942 case G4ViewParameters::hsr: << 890 case G4ViewParameters::hsr:
943 vp.SetDrawingStyle(G4ViewParameters: << 891 vp.SetDrawingStyle(G4ViewParameters::hlhsr);
944 break; << 892 break;
945 case G4ViewParameters::hlhsr: << 893 case G4ViewParameters::hlhsr:
946 break; << 894 break;
947 case G4ViewParameters::cloud: <<
948 break; <<
949 } 895 }
950 } 896 }
951 else { // false << 897 else {
952 switch (existingStyle) { 898 switch (existingStyle) {
953 case G4ViewParameters::wireframe: << 899 case G4ViewParameters::wireframe:
954 break; << 900 break;
955 case G4ViewParameters::hlr: << 901 case G4ViewParameters::hlr:
956 break; << 902 break;
957 case G4ViewParameters::hsr: << 903 case G4ViewParameters::hsr:
958 break; << 904 break;
959 case G4ViewParameters::hlhsr: << 905 case G4ViewParameters::hlhsr:
960 vp.SetDrawingStyle(G4ViewParameters: << 906 vp.SetDrawingStyle(G4ViewParameters::hsr);
961 break; << 907 break;
962 case G4ViewParameters::cloud: <<
963 break; <<
964 } 908 }
965 } 909 }
966 if (verbosity >= G4VisManager::confirmatio 910 if (verbosity >= G4VisManager::confirmations) {
967 G4cout << "Drawing style of viewer \"" < 911 G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
968 << "\" set to " << vp.GetDrawingStyle() << 912 << "\" set to " << vp.GetDrawingStyle()
969 << G4endl; << 913 << G4endl;
970 } 914 }
971 } 915 }
972 916
973 else if (command == fpCommandExplodeFactor) 917 else if (command == fpCommandExplodeFactor) {
974 G4double explodeFactor, x, y, z; 918 G4double explodeFactor, x, y, z;
975 G4String unitString; 919 G4String unitString;
976 std::istringstream is (newValue); 920 std::istringstream is (newValue);
977 is >> explodeFactor >> x >> y >> z >> unit 921 is >> explodeFactor >> x >> y >> z >> unitString;
978 G4double unit = G4UIcommand::ValueOf(unitS 922 G4double unit = G4UIcommand::ValueOf(unitString);
979 vp.SetExplodeFactor(explodeFactor); 923 vp.SetExplodeFactor(explodeFactor);
980 vp.SetExplodeCentre(G4Point3D(x * unit, y 924 vp.SetExplodeCentre(G4Point3D(x * unit, y * unit, z * unit));
981 if (verbosity >= G4VisManager::confirmatio 925 if (verbosity >= G4VisManager::confirmations) {
982 G4cout << "Explode factor changed to " < 926 G4cout << "Explode factor changed to " << vp.GetExplodeFactor()
983 << " from centre " << vp.GetExplodeCentr << 927 << " from centre " << vp.GetExplodeCentre()
984 << G4endl; << 928 << G4endl;
985 } 929 }
986 } 930 }
987 931
988 else if (command == fpCommandGlobalLineWidth 932 else if (command == fpCommandGlobalLineWidthScale) {
989 G4double globalLineWidthScale 933 G4double globalLineWidthScale
990 = fpCommandGlobalLineWidthScale->GetNewDou << 934 = fpCommandGlobalLineWidthScale->GetNewDoubleValue(newValue);
991 vp.SetGlobalLineWidthScale(globalLineWidth 935 vp.SetGlobalLineWidthScale(globalLineWidthScale);
992 if (verbosity >= G4VisManager::confirmatio 936 if (verbosity >= G4VisManager::confirmations) {
993 G4cout << "Global Line Width Scale chang 937 G4cout << "Global Line Width Scale changed to "
994 << vp.GetGlobalLineWidthScale() << G4end << 938 << vp.GetGlobalLineWidthScale() << G4endl;
995 } 939 }
996 } 940 }
997 941
998 else if (command == fpCommandGlobalMarkerSca 942 else if (command == fpCommandGlobalMarkerScale) {
999 G4double globalMarkerScale 943 G4double globalMarkerScale
1000 = fpCommandGlobalMarkerScale->GetNewDoubl << 944 = fpCommandGlobalMarkerScale->GetNewDoubleValue(newValue);
1001 vp.SetGlobalMarkerScale(globalMarkerScale 945 vp.SetGlobalMarkerScale(globalMarkerScale);
1002 if (verbosity >= G4VisManager::confirmati 946 if (verbosity >= G4VisManager::confirmations) {
1003 G4cout << "Global Marker Scale changed 947 G4cout << "Global Marker Scale changed to "
1004 << vp.GetGlobalMarkerScale() << G4endl; << 948 << vp.GetGlobalMarkerScale() << G4endl;
1005 } 949 }
1006 } 950 }
1007 951
1008 else if (command == fpCommandHiddenEdge) { 952 else if (command == fpCommandHiddenEdge) {
1009 G4ViewParameters::DrawingStyle existingSt 953 G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
1010 if (G4UIcommand::ConvertToBool(newValue)) 954 if (G4UIcommand::ConvertToBool(newValue)) {
1011 switch (existingStyle) { 955 switch (existingStyle) {
1012 case G4ViewParameters::wireframe: << 956 case G4ViewParameters::wireframe:
1013 vp.SetDrawingStyle(G4ViewParameters << 957 vp.SetDrawingStyle(G4ViewParameters::hlr);
1014 break; << 958 break;
1015 case G4ViewParameters::hlr: << 959 case G4ViewParameters::hlr:
1016 break; << 960 break;
1017 case G4ViewParameters::hsr: << 961 case G4ViewParameters::hsr:
1018 vp.SetDrawingStyle(G4ViewParameters << 962 vp.SetDrawingStyle(G4ViewParameters::hlhsr);
1019 break; << 963 break;
1020 case G4ViewParameters::hlhsr: << 964 case G4ViewParameters::hlhsr:
1021 break; << 965 break;
1022 case G4ViewParameters::cloud: <<
1023 break; <<
1024 } 966 }
1025 } 967 }
1026 else { 968 else {
1027 switch (existingStyle) { 969 switch (existingStyle) {
1028 case G4ViewParameters::wireframe: << 970 case G4ViewParameters::wireframe:
1029 break; << 971 break;
1030 case G4ViewParameters::hlr: << 972 case G4ViewParameters::hlr:
1031 vp.SetDrawingStyle(G4ViewParameters << 973 vp.SetDrawingStyle(G4ViewParameters::wireframe);
1032 break; << 974 break;
1033 case G4ViewParameters::hsr: << 975 case G4ViewParameters::hsr:
1034 break; << 976 break;
1035 case G4ViewParameters::hlhsr: << 977 case G4ViewParameters::hlhsr:
1036 vp.SetDrawingStyle(G4ViewParameters << 978 vp.SetDrawingStyle(G4ViewParameters::hsr);
1037 break; << 979 break;
1038 case G4ViewParameters::cloud: <<
1039 break; <<
1040 } 980 }
1041 } 981 }
1042 if (verbosity >= G4VisManager::confirmati 982 if (verbosity >= G4VisManager::confirmations) {
1043 G4cout << "Drawing style of viewer \"" 983 G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
1044 << "\" set to " << vp.GetDrawingStyle() << 984 << "\" set to " << vp.GetDrawingStyle()
1045 << G4endl; << 985 << G4endl;
1046 } 986 }
1047 } 987 }
1048 988
1049 else if (command == fpCommandHiddenMarker) 989 else if (command == fpCommandHiddenMarker) {
1050 G4bool hidden = G4UIcommand::ConvertToBoo 990 G4bool hidden = G4UIcommand::ConvertToBool(newValue);
1051 if (hidden) vp.SetMarkerHidden(); 991 if (hidden) vp.SetMarkerHidden();
1052 else vp.SetMarkerNotHidden(); 992 else vp.SetMarkerNotHidden();
1053 if (verbosity >= G4VisManager::confirmati 993 if (verbosity >= G4VisManager::confirmations) {
1054 G4cout << "Markers will "; 994 G4cout << "Markers will ";
1055 if (vp.IsMarkerNotHidden()) G4cout << " 995 if (vp.IsMarkerNotHidden()) G4cout << "not ";
1056 G4cout << "be hidden under solid object 996 G4cout << "be hidden under solid objects." << G4endl;
1057 } 997 }
1058 } 998 }
1059 999
1060 else if (command == fpCommandLightsMove) { 1000 else if (command == fpCommandLightsMove) {
1061 if (newValue.find("cam") != G4String::npo 1001 if (newValue.find("cam") != G4String::npos)
1062 vp.SetLightsMoveWithCamera(true); 1002 vp.SetLightsMoveWithCamera(true);
1063 else if(newValue.find("obj") != G4String: 1003 else if(newValue.find("obj") != G4String::npos)
1064 vp.SetLightsMoveWithCamera(false); 1004 vp.SetLightsMoveWithCamera(false);
1065 else { 1005 else {
1066 if (verbosity >= G4VisManager::errors) 1006 if (verbosity >= G4VisManager::errors) {
1067 G4warn << "ERROR: \"" << newValue << << 1007 G4cerr << "ERROR: \"" << newValue << "\" not recognised."
1068 " Looking for \"cam\" or \"obj\" in << 1008 " Looking for \"cam\" or \"obj\" in string." << G4endl;
1069 } 1009 }
1070 } 1010 }
1071 if (verbosity >= G4VisManager::confirmati 1011 if (verbosity >= G4VisManager::confirmations) {
1072 G4cout << "Lights move with "; 1012 G4cout << "Lights move with ";
1073 if (vp.GetLightsMoveWithCamera()) 1013 if (vp.GetLightsMoveWithCamera())
1074 G4cout << "camera (object appears to << 1014 G4cout << "camera (object appears to rotate).";
1075 else G4cout << "object (the viewer appe 1015 else G4cout << "object (the viewer appears to be moving).";
1076 G4cout << G4endl; 1016 G4cout << G4endl;
1077 } 1017 }
1078 } 1018 }
1079 1019
1080 else if (command == fpCommandLightsThetaPhi 1020 else if (command == fpCommandLightsThetaPhi) {
1081 G4double theta, phi; 1021 G4double theta, phi;
1082 if (ConvertToDoublePair(newValue, theta, 1022 if (ConvertToDoublePair(newValue, theta, phi)) {
1083 G4double x = std::sin (theta) * std::co 1023 G4double x = std::sin (theta) * std::cos (phi);
1084 G4double y = std::sin (theta) * std::si 1024 G4double y = std::sin (theta) * std::sin (phi);
1085 G4double z = std::cos (theta); 1025 G4double z = std::cos (theta);
1086 fLightsVector = G4ThreeVector (x, y, z) 1026 fLightsVector = G4ThreeVector (x, y, z);
1087 vp.SetLightpointDirection(fLightsVector 1027 vp.SetLightpointDirection(fLightsVector);
1088 if (verbosity >= G4VisManager::confirma 1028 if (verbosity >= G4VisManager::confirmations) {
1089 G4cout << "Lights direction set to " 1029 G4cout << "Lights direction set to "
1090 << vp.GetLightpointDirection() << G4e 1030 << vp.GetLightpointDirection() << G4endl;
1091 } 1031 }
1092 } 1032 }
1093 } 1033 }
1094 1034
1095 else if (command == fpCommandLightsVector) 1035 else if (command == fpCommandLightsVector) {
1096 fLightsVector = G4UIcommand::ConvertTo3Ve 1036 fLightsVector = G4UIcommand::ConvertTo3Vector(newValue);
1097 vp.SetLightpointDirection(fLightsVector); 1037 vp.SetLightpointDirection(fLightsVector);
1098 if (verbosity >= G4VisManager::confirmati 1038 if (verbosity >= G4VisManager::confirmations) {
1099 G4cout << "Lights direction set to " 1039 G4cout << "Lights direction set to "
1100 << vp.GetLightpointDirection() << G4end << 1040 << vp.GetLightpointDirection() << G4endl;
1101 } <<
1102 } <<
1103 <<
1104 else if (command == fpCommandLineWidth) { <<
1105 if (verbosity >= G4VisManager::errors) { <<
1106 // A do-nothing command <<
1107 G4warn << command->GetGuidanceLine(0) < <<
1108 } 1041 }
1109 } 1042 }
1110 1043
1111 else if (command == fpCommandLineSegments) 1044 else if (command == fpCommandLineSegments) {
1112 G4int nSides = G4UIcommand::ConvertToInt( 1045 G4int nSides = G4UIcommand::ConvertToInt(newValue);
1113 nSides = vp.SetNoOfSides(nSides); 1046 nSides = vp.SetNoOfSides(nSides);
1114 if (verbosity >= G4VisManager::confirmati 1047 if (verbosity >= G4VisManager::confirmations) {
1115 G4cout << 1048 G4cout <<
1116 "Number of line segments per circle in << 1049 "Number of line segements per circle in polygon approximation is "
1117 << nSides << G4endl; << 1050 << nSides << G4endl;
1118 } <<
1119 } <<
1120 <<
1121 else if (command == fpCommandNumberOfCloudP <<
1122 G4int nPoints = G4UIcommand::ConvertToInt <<
1123 nPoints = vp.SetNumberOfCloudPoints(nPoin <<
1124 if (verbosity >= G4VisManager::confirmati <<
1125 G4cout << <<
1126 "Number of points to be used in cloud r <<
1127 << nPoints << G4endl; <<
1128 } 1051 }
1129 } 1052 }
1130 1053
1131 else if (command == fpCommandPicking) { 1054 else if (command == fpCommandPicking) {
1132 vp.SetPicking(G4UIcommand::ConvertToBool( 1055 vp.SetPicking(G4UIcommand::ConvertToBool(newValue));
1133 if (verbosity >= G4VisManager::confirmati 1056 if (verbosity >= G4VisManager::confirmations) {
1134 G4cout << "Picking "; 1057 G4cout << "Picking ";
1135 if (vp.IsPicking()) G4cout << "requeste 1058 if (vp.IsPicking()) G4cout << "requested.";
1136 else G4cout << "inhibited."; 1059 else G4cout << "inhibited.";
1137 G4cout << G4endl; 1060 G4cout << G4endl;
1138 } 1061 }
1139 if (verbosity >= G4VisManager::warnings) 1062 if (verbosity >= G4VisManager::warnings) {
1140 G4warn << "You may need to issue \"/vis << 1063 G4cout << "You may need to issue \"/vis/viewer/update\"."
1141 << G4endl; << 1064 << G4endl;
1142 } 1065 }
1143 } 1066 }
1144 1067
1145 else if (command == fpCommandProjection) { 1068 else if (command == fpCommandProjection) {
1146 G4double fieldHalfAngle; 1069 G4double fieldHalfAngle;
1147 const size_t iPos0 = 0; 1070 const size_t iPos0 = 0;
1148 if (newValue[iPos0] == 'o') { // "orthog 1071 if (newValue[iPos0] == 'o') { // "orthogonal"
1149 fieldHalfAngle = 0.; 1072 fieldHalfAngle = 0.;
1150 } 1073 }
1151 else if (newValue[iPos0] == 'p') { // "p 1074 else if (newValue[iPos0] == 'p') { // "perspective"
1152 G4String dummy; 1075 G4String dummy;
1153 G4String unit; 1076 G4String unit;
1154 std::istringstream is (newValue); 1077 std::istringstream is (newValue);
1155 is >> dummy >> fieldHalfAngle >> unit; 1078 is >> dummy >> fieldHalfAngle >> unit;
1156 fieldHalfAngle *= G4UIcommand::ValueOf( 1079 fieldHalfAngle *= G4UIcommand::ValueOf(unit);
1157 if (fieldHalfAngle > 89.5 * deg || fiel 1080 if (fieldHalfAngle > 89.5 * deg || fieldHalfAngle <= 0.0) {
1158 if (verbosity >= G4VisManager::errors << 1081 if (verbosity >= G4VisManager::errors) {
1159 G4warn << << 1082 G4cerr <<
1160 "ERROR: Field half angle should be << 1083 "ERROR: Field half angle should be 0 < angle <= 89.5 degrees.";
1161 G4warn << G4endl; << 1084 G4cout << G4endl;
1162 } << 1085 }
1163 return; << 1086 return;
1164 } 1087 }
1165 } 1088 }
1166 else { 1089 else {
1167 if (verbosity >= G4VisManager::errors) 1090 if (verbosity >= G4VisManager::errors) {
1168 G4warn << "ERROR: \"" << newValue << << 1091 G4cerr << "ERROR: \"" << newValue << "\" not recognised."
1169 " Looking for 'o' or 'p' first chara << 1092 " Looking for 'o' or 'p' first character." << G4endl;
1170 } 1093 }
1171 return; 1094 return;
1172 } 1095 }
1173 vp.SetFieldHalfAngle(fieldHalfAngle); 1096 vp.SetFieldHalfAngle(fieldHalfAngle);
1174 if (verbosity >= G4VisManager::confirmati 1097 if (verbosity >= G4VisManager::confirmations) {
1175 G4cout << "Projection style of viewer \ 1098 G4cout << "Projection style of viewer \"" << currentViewer->GetName()
1176 << "\" set to "; << 1099 << "\" set to ";
1177 if (fieldHalfAngle == 0.) { 1100 if (fieldHalfAngle == 0.) {
1178 G4cout << "orthogonal."; << 1101 G4cout << "orthogonal.";
1179 } 1102 }
1180 else { 1103 else {
1181 G4cout << "perspective\n with half a << 1104 G4cout << "perspective\n with half angle " << fieldHalfAngle / deg
1182 << " degrees."; << 1105 << " degrees.";
1183 } 1106 }
1184 G4cout << G4endl; 1107 G4cout << G4endl;
1185 } 1108 }
1186 } 1109 }
1187 1110
1188 else if (command == fpCommandRotationStyle) <<
1189 G4ViewParameters::RotationStyle style; <<
1190 if (newValue == "constrainUpDirection") <<
1191 style = G4ViewParameters::constrainUpDi <<
1192 else if (newValue == "freeRotation") <<
1193 style = G4ViewParameters::freeRotation; <<
1194 else { <<
1195 if (verbosity >= G4VisManager::errors) <<
1196 G4warn << "ERROR: \"" << newValue << "\" no <<
1197 } <<
1198 return; <<
1199 } <<
1200 vp.SetRotationStyle(style); <<
1201 if (verbosity >= G4VisManager::confirmati <<
1202 G4cout << "Rotation style of viewer \"" <<
1203 << "\" set to " << vp.GetRotationStyle( <<
1204 << G4endl; <<
1205 } <<
1206 } <<
1207 <<
1208 else if (command == fpCommandSectionPlane) 1111 else if (command == fpCommandSectionPlane) {
1209 G4String choice, unit; 1112 G4String choice, unit;
1210 G4double x, y, z, nx, ny, nz, F = 1.; << 1113 G4double x, y, z, nx, ny, nz;
1211 std::istringstream is (newValue); 1114 std::istringstream is (newValue);
1212 is >> choice >> x >> y >> z >> unit >> nx 1115 is >> choice >> x >> y >> z >> unit >> nx >> ny >> nz;
1213 G4int iSelector = -1; 1116 G4int iSelector = -1;
1214 if (G4StrUtil::icompare(choice, "off") == << 1117 if (choice.compareTo("off",G4String::ignoreCase) == 0 ||
1215 !G4UIcommand::ConvertToBool(choice)) << 1118 !G4UIcommand::ConvertToBool(choice)) iSelector = 0;
1216 if (G4StrUtil::icompare(choice, "on") == << 1119 if (choice.compareTo("on",G4String::ignoreCase) == 0 ||
1217 G4UIcommand::ConvertToBool(choice)) i << 1120 G4UIcommand::ConvertToBool(choice)) iSelector = 1;
1218 if (iSelector < 0) { 1121 if (iSelector < 0) {
1219 if (verbosity >= G4VisManager::errors) 1122 if (verbosity >= G4VisManager::errors) {
1220 G4warn << "Choice not recognised (on/ << 1123 G4cout << "Choice not recognised (on/true or off/false)." << G4endl;
>> 1124 G4cout << "Section drawing is currently: ";
>> 1125 if (vp.IsSection ()) G4cout << "on";
>> 1126 else G4cout << "off";
>> 1127 G4cout << ".\nSection plane is currently: "
>> 1128 << vp.GetSectionPlane ();
>> 1129 G4cout << G4endl;
1221 } 1130 }
1222 goto write_result; << 1131 return;
1223 } 1132 }
>> 1133 G4double F = 1.;
1224 // iSelector can only be 0 or 1 1134 // iSelector can only be 0 or 1
1225 switch (iSelector) { 1135 switch (iSelector) {
1226 case 0: << 1136 case 0:
1227 vp.UnsetSectionPlane(); << 1137 vp.UnsetSectionPlane();
1228 break; << 1138 break;
1229 case 1: << 1139 case 1:
1230 F = G4UIcommand::ValueOf(unit); << 1140 F = G4UIcommand::ValueOf(unit);
1231 x *= F; y *= F; z *= F; << 1141 x *= F; y *= F; z *= F;
1232 if (nx == 0. && ny == 0. && nz == 0.) << 1142 vp.SetSectionPlane(G4Plane3D(G4Normal3D(nx,ny,nz), G4Point3D(x,y,z)));
1233 if (verbosity >= G4VisManager::erro << 1143 vp.SetViewpointDirection(G4Normal3D(nx,ny,nz));
1234 G4warn << "Null normal." << G4end << 1144 break;
1235 } <<
1236 break;; <<
1237 } <<
1238 // Make sure normal is normalised <<
1239 const G4Normal3D& normal = G4Normal3D <<
1240 vp.SetSectionPlane(G4Plane3D(normal, <<
1241 vp.SetViewpointDirection(normal); <<
1242 break; <<
1243 } 1145 }
1244 write_result: <<
1245 if (verbosity >= G4VisManager::confirmati 1146 if (verbosity >= G4VisManager::confirmations) {
1246 G4cout << "Section drawing is: "; << 1147 G4cout << "Section drawing is now: ";
1247 if (vp.IsSection ()) G4cout << "on"; 1148 if (vp.IsSection ()) G4cout << "on";
1248 else G4cout << "off"; << 1149 else G4cout << "off";
1249 G4cout << ".\nSection plane is now: " 1150 G4cout << ".\nSection plane is now: "
1250 << vp.GetSectionPlane (); << 1151 << vp.GetSectionPlane ();
1251 G4cout << G4endl; 1152 G4cout << G4endl;
1252 } 1153 }
1253 } 1154 }
1254 1155
1255 else if (command == fpCommandSpecialMeshRen << 1156 else if (command == fpCommandRotationStyle) {
1256 vp.SetSpecialMeshRendering(G4UIcommand::C << 1157 G4ViewParameters::RotationStyle style;
1257 if (verbosity >= G4VisManager::confirmati << 1158 if (newValue == "constrainUpDirection")
1258 G4cout << "Special mesh rendering"; << 1159 style = G4ViewParameters::constrainUpDirection;
1259 if (vp.IsSpecialMeshRendering()) { << 1160 else if (newValue == "freeRotation")
1260 G4cout << " requested. Current option << 1161 style = G4ViewParameters::freeRotation;
1261 << vp.GetSpecialMeshRenderingOption() << 1162 else {
1262 if (vp.GetSpecialMeshVolumes().empty( << 1163 if (verbosity >= G4VisManager::errors) {
1263 G4cout << "any mesh."; << 1164 G4cerr << "ERROR: \"" << newValue << "\" not recognised." << G4endl;
1264 } else{ <<
1265 G4cout << "selected volumes:"; <<
1266 for (const auto& pvNameCopyNo: vp.G <<
1267 G4cout << "\n " << pvNameCopyNo. <<
1268 if (pvNameCopyNo.GetCopyNo() >= 0 <<
1269 } <<
1270 } <<
1271 } <<
1272 else G4cout << ": off."; <<
1273 G4cout << G4endl; <<
1274 } <<
1275 } <<
1276 <<
1277 else if (command == fpCommandSpecialMeshRen <<
1278 G4ViewParameters::SMROption option = G4Vi <<
1279 if (newValue == "dots") { <<
1280 option = G4ViewParameters::meshAsDots; <<
1281 } <<
1282 else if(newValue == "surfaces") { <<
1283 option = G4ViewParameters::meshAsSurfac <<
1284 } <<
1285 vp.SetSpecialMeshRenderingOption(option); <<
1286 if (verbosity >= G4VisManager::confirmati <<
1287 G4cout << "Special mesh rendering optio <<
1288 << vp.GetSpecialMeshRenderingOption() < <<
1289 << G4endl; <<
1290 } <<
1291 } <<
1292 <<
1293 else if (command == fpCommandSpecialMeshVol <<
1294 std::vector<G4ModelingParameters::PVNameC <<
1295 if (newValue.empty()) { <<
1296 vp.SetSpecialMeshVolumes(requestedMeshe <<
1297 } else { <<
1298 // Algorithm from Josuttis p.476. <<
1299 G4String::size_type iBegin, iEnd; <<
1300 iBegin = newValue.find_first_not_of(' ' <<
1301 while (iBegin != G4String::npos) { <<
1302 iEnd = newValue.find_first_of(' ',iBegin); <<
1303 if (iEnd == G4String::npos) { <<
1304 iEnd = newValue.length(); <<
1305 } <<
1306 const G4String& name(newValue.substr(iBegin <<
1307 iBegin = newValue.find_first_not_of(' ',iEn <<
1308 if (iBegin == G4String::npos) { <<
1309 if (verbosity >= G4VisManager::warnings) <<
1310 G4warn << <<
1311 "WARNING: G4VisCommandsViewerSet::SetNe <<
1312 "\n A pair not found. (There should b <<
1313 "\n Command ignored." <<
1314 << G4endl; <<
1315 return; <<
1316 } <<
1317 } <<
1318 iEnd = newValue.find_first_of(' ',iBegin); <<
1319 if (iEnd == G4String::npos) { <<
1320 iEnd = newValue.length(); <<
1321 } <<
1322 G4int copyNo; <<
1323 std::istringstream iss(newValue.substr(iBeg <<
1324 if (!(iss >> copyNo)) { <<
1325 if (verbosity >= G4VisManager::warnings) <<
1326 G4warn << <<
1327 "WARNING: G4VisCommandsViewerSet::SetNe <<
1328 "\n Error reading copy number - it was <<
1329 "\n Command ignored." <<
1330 << G4endl; <<
1331 return; <<
1332 } <<
1333 } <<
1334 requestedMeshes.push_back(G4ModelingParamet <<
1335 iBegin = newValue.find_first_not_of(' ',iEn <<
1336 } 1165 }
1337 vp.SetSpecialMeshVolumes(requestedMeshe << 1166 return;
1338 } 1167 }
>> 1168 vp.SetRotationStyle(style);
1339 if (verbosity >= G4VisManager::confirmati 1169 if (verbosity >= G4VisManager::confirmations) {
1340 if (vp.GetSpecialMeshVolumes().empty()) << 1170 G4cout << "Rotation style of viewer \"" << currentViewer->GetName()
1341 G4cout << << 1171 << "\" set to " << vp.GetRotationStyle()
1342 "Special mesh list empty, which means \"all << 1172 << G4endl;
1343 << G4endl; <<
1344 } else { <<
1345 G4cout << "Selected special mesh volumes ar <<
1346 for (const auto& pvNameCopyNo: vp.GetSpecia <<
1347 G4cout << "\n " << pvNameCopyNo.GetName( <<
1348 if (pvNameCopyNo.GetCopyNo() >= 0) G4cout <<
1349 } <<
1350 G4cout << G4endl; <<
1351 } <<
1352 } 1173 }
1353 } 1174 }
1354 1175
1355 else if (command == fpCommandStyle) { 1176 else if (command == fpCommandStyle) {
1356 G4ViewParameters::DrawingStyle existingSt 1177 G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
1357 const size_t iPos0 = 0; 1178 const size_t iPos0 = 0;
1358 if (newValue[iPos0] == 'w') { // "wirefr 1179 if (newValue[iPos0] == 'w') { // "wireframe"
1359 switch (existingStyle) { 1180 switch (existingStyle) {
1360 case G4ViewParameters::wireframe: << 1181 case G4ViewParameters::wireframe:
1361 break; << 1182 break;
1362 case G4ViewParameters::hlr: << 1183 case G4ViewParameters::hlr:
1363 break; << 1184 break;
1364 case G4ViewParameters::hsr: << 1185 case G4ViewParameters::hsr:
1365 vp.SetDrawingStyle(G4ViewParameters << 1186 vp.SetDrawingStyle(G4ViewParameters::wireframe);
1366 break; << 1187 break;
1367 case G4ViewParameters::hlhsr: << 1188 case G4ViewParameters::hlhsr:
1368 vp.SetDrawingStyle(G4ViewParameters << 1189 vp.SetDrawingStyle(G4ViewParameters::hlr);
1369 break; << 1190 break;
1370 case G4ViewParameters::cloud: <<
1371 vp.SetDrawingStyle(G4ViewParameters <<
1372 break; <<
1373 } 1191 }
1374 } 1192 }
1375 else if (newValue[iPos0] == 's') { // "s 1193 else if (newValue[iPos0] == 's') { // "surface"
1376 switch (existingStyle) { 1194 switch (existingStyle) {
1377 case G4ViewParameters::wireframe: << 1195 case G4ViewParameters::wireframe:
1378 vp.SetDrawingStyle(G4ViewParameters << 1196 vp.SetDrawingStyle(G4ViewParameters::hsr);
1379 break; << 1197 break;
1380 case G4ViewParameters::hlr: << 1198 case G4ViewParameters::hlr:
1381 vp.SetDrawingStyle(G4ViewParameters << 1199 vp.SetDrawingStyle(G4ViewParameters::hlhsr);
1382 break; << 1200 break;
1383 case G4ViewParameters::hsr: << 1201 case G4ViewParameters::hsr:
1384 break; << 1202 break;
1385 case G4ViewParameters::hlhsr: << 1203 case G4ViewParameters::hlhsr:
1386 break; << 1204 break;
1387 case G4ViewParameters::cloud: <<
1388 vp.SetDrawingStyle(G4ViewParameters <<
1389 break; <<
1390 } <<
1391 } <<
1392 else if (newValue[iPos0] == 'c') { // "c <<
1393 switch (existingStyle) { <<
1394 case G4ViewParameters::wireframe: <<
1395 vp.SetDrawingStyle(G4ViewParameters <<
1396 break; <<
1397 case G4ViewParameters::hlr: <<
1398 vp.SetDrawingStyle(G4ViewParameters <<
1399 break; <<
1400 case G4ViewParameters::hsr: <<
1401 vp.SetDrawingStyle(G4ViewParameters <<
1402 break; <<
1403 case G4ViewParameters::hlhsr: <<
1404 vp.SetDrawingStyle(G4ViewParameters <<
1405 break; <<
1406 case G4ViewParameters::cloud: <<
1407 break; <<
1408 } 1205 }
1409 } 1206 }
1410 else { 1207 else {
1411 if (verbosity >= G4VisManager::errors) 1208 if (verbosity >= G4VisManager::errors) {
1412 G4warn << "ERROR: \"" << newValue << << 1209 G4cerr << "ERROR: \"" << newValue << "\" not recognised."
1413 " Looking for 'w' or 's' or 'c' firs << 1210 " Looking for 'w' or 's' first character." << G4endl;
1414 } 1211 }
1415 return; 1212 return;
1416 } 1213 }
1417 if (verbosity >= G4VisManager::confirmati 1214 if (verbosity >= G4VisManager::confirmations) {
1418 G4cout << "Drawing style of viewer \"" 1215 G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
1419 << "\" set to " << vp.GetDrawingStyle() << 1216 << "\" set to " << vp.GetDrawingStyle()
1420 << G4endl; << 1217 << G4endl;
1421 } 1218 }
1422 } 1219 }
1423 1220
1424 else if (command == fpCommandTargetPoint) { 1221 else if (command == fpCommandTargetPoint) {
1425 G4ThreeVector targetPoint = 1222 G4ThreeVector targetPoint =
1426 fpCommandTargetPoint->GetNew3VectorValue( << 1223 fpCommandTargetPoint->GetNew3VectorValue(newValue);
1427 const G4Point3D& standardTargetPoint = 1224 const G4Point3D& standardTargetPoint =
1428 currentViewer->GetSceneHandler()->GetScen << 1225 currentViewer->GetSceneHandler()->GetScene()->GetStandardTargetPoint();
1429 vp.SetCurrentTargetPoint(targetPoint - st 1226 vp.SetCurrentTargetPoint(targetPoint - standardTargetPoint);
1430 if (verbosity >= G4VisManager::confirmati 1227 if (verbosity >= G4VisManager::confirmations) {
1431 G4cout << "Target point set to " 1228 G4cout << "Target point set to "
1432 << fpCommandTargetPoint->ConvertToStrin << 1229 << fpCommandTargetPoint->ConvertToStringWithBestUnit
1433 (targetPoint) << 1230 (targetPoint)
1434 << "\n\"Current Target Point\" set to << 1231 << "\n\"Current Target Point\" set to "
1435 << fpCommandTargetPoint->ConvertToStrin << 1232 << fpCommandTargetPoint->ConvertToStringWithBestUnit
1436 (vp.GetCurrentTargetPoint()) << 1233 (vp.GetCurrentTargetPoint())
1437 << "\n\"Standard Target Point\" is " << 1234 << "\n\"Standard Target Point\" is "
1438 << fpCommandTargetPoint->ConvertToStrin << 1235 << fpCommandTargetPoint->ConvertToStringWithBestUnit
1439 (standardTargetPoint) << 1236 (standardTargetPoint)
1440 << G4endl; << 1237 << G4endl;
1441 } 1238 }
1442 } 1239 }
1443 1240
1444 else if (command == fpCommandUpThetaPhi) { 1241 else if (command == fpCommandUpThetaPhi) {
1445 G4double theta, phi; 1242 G4double theta, phi;
1446 if (ConvertToDoublePair(newValue, theta, 1243 if (ConvertToDoublePair(newValue, theta, phi)) {
1447 G4double x = std::sin (theta) * std::co 1244 G4double x = std::sin (theta) * std::cos (phi);
1448 G4double y = std::sin (theta) * std::si 1245 G4double y = std::sin (theta) * std::sin (phi);
1449 G4double z = std::cos (theta); 1246 G4double z = std::cos (theta);
1450 fUpVector = G4ThreeVector (x, y, z); 1247 fUpVector = G4ThreeVector (x, y, z);
1451 vp.SetUpVector(fUpVector); 1248 vp.SetUpVector(fUpVector);
1452 if (verbosity >= G4VisManager::confirma 1249 if (verbosity >= G4VisManager::confirmations) {
1453 G4cout << "Up direction set to " << v 1250 G4cout << "Up direction set to " << vp.GetUpVector() << G4endl;
1454 } 1251 }
1455 } 1252 }
1456 } 1253 }
1457 1254
1458 else if (command == fpCommandUpVector) { 1255 else if (command == fpCommandUpVector) {
1459 fUpVector = G4UIcommand::ConvertTo3Vector 1256 fUpVector = G4UIcommand::ConvertTo3Vector(newValue).unit();
1460 vp.SetUpVector(fUpVector); 1257 vp.SetUpVector(fUpVector);
1461 if (verbosity >= G4VisManager::confirmati 1258 if (verbosity >= G4VisManager::confirmations) {
1462 G4cout << "Up direction set to " << vp. 1259 G4cout << "Up direction set to " << vp.GetUpVector() << G4endl;
1463 } 1260 }
1464 } 1261 }
1465 1262
1466 else if (command == fpCommandViewpointTheta 1263 else if (command == fpCommandViewpointThetaPhi) {
1467 G4double theta, phi; 1264 G4double theta, phi;
1468 if (ConvertToDoublePair(newValue, theta, 1265 if (ConvertToDoublePair(newValue, theta, phi)) {
1469 G4double x = std::sin (theta) * std::co 1266 G4double x = std::sin (theta) * std::cos (phi);
1470 G4double y = std::sin (theta) * std::si 1267 G4double y = std::sin (theta) * std::sin (phi);
1471 G4double z = std::cos (theta); 1268 G4double z = std::cos (theta);
1472 fViewpointVector = G4ThreeVector (x, y, 1269 fViewpointVector = G4ThreeVector (x, y, z);
1473 vp.SetViewAndLights(fViewpointVector); 1270 vp.SetViewAndLights(fViewpointVector);
1474 if (verbosity >= G4VisManager::confirma 1271 if (verbosity >= G4VisManager::confirmations) {
1475 G4cout << "Viewpoint direction set to 1272 G4cout << "Viewpoint direction set to "
1476 << vp.GetViewpointDirection() << G4en 1273 << vp.GetViewpointDirection() << G4endl;
1477 if (vp.GetLightsMoveWithCamera ()) { 1274 if (vp.GetLightsMoveWithCamera ()) {
1478 G4cout << "Lightpoint direction set 1275 G4cout << "Lightpoint direction set to "
1479 << vp.GetActualLightpointDirection 1276 << vp.GetActualLightpointDirection () << G4endl;
1480 } 1277 }
1481 } 1278 }
1482 } 1279 }
1483 } 1280 }
1484 1281
1485 else if (command == fpCommandViewpointVecto 1282 else if (command == fpCommandViewpointVector) {
1486 G4ThreeVector viewpointVector = G4UIcomma 1283 G4ThreeVector viewpointVector = G4UIcommand::ConvertTo3Vector(newValue);
1487 if (viewpointVector.mag2() <= 0.) { 1284 if (viewpointVector.mag2() <= 0.) {
1488 if (verbosity >= G4VisManager::errors) 1285 if (verbosity >= G4VisManager::errors) {
1489 G4warn << "ERROR: Null viewpoint vect << 1286 G4cerr << "ERROR: Null viewpoint vector. No action taken." << G4endl;
1490 } 1287 }
1491 } else { 1288 } else {
1492 fViewpointVector = viewpointVector.unit 1289 fViewpointVector = viewpointVector.unit();
1493 vp.SetViewAndLights(fViewpointVector); 1290 vp.SetViewAndLights(fViewpointVector);
1494 if (verbosity >= G4VisManager::confirma 1291 if (verbosity >= G4VisManager::confirmations) {
1495 G4cout << "Viewpoint direction set to 1292 G4cout << "Viewpoint direction set to "
1496 << vp.GetViewpointDirection() << G4en 1293 << vp.GetViewpointDirection() << G4endl;
1497 if (vp.GetLightsMoveWithCamera ()) { 1294 if (vp.GetLightsMoveWithCamera ()) {
1498 G4cout << "Lightpoint direction set 1295 G4cout << "Lightpoint direction set to "
1499 << vp.GetActualLightpointDirection 1296 << vp.GetActualLightpointDirection () << G4endl;
1500 } 1297 }
1501 } 1298 }
1502 } 1299 }
1503 } 1300 }
1504 1301
1505 else if (command == fpCommandTimeWindowDisp 1302 else if (command == fpCommandTimeWindowDisplayHeadTime)
1506 { 1303 {
1507 G4String display; 1304 G4String display;
1508 G4double screenX, screenY, screenSize, re 1305 G4double screenX, screenY, screenSize, red, green, blue;
1509 std::istringstream iss(newValue); 1306 std::istringstream iss(newValue);
1510 iss >> display >> screenX >> screenY 1307 iss >> display >> screenX >> screenY
1511 >> screenSize >> red >> green >> blue; 1308 >> screenSize >> red >> green >> blue;
1512 vp.SetDisplayHeadTime(command->ConvertToB 1309 vp.SetDisplayHeadTime(command->ConvertToBool(display));
1513 vp.SetDisplayHeadTimeX(screenX); 1310 vp.SetDisplayHeadTimeX(screenX);
1514 vp.SetDisplayHeadTimeY(screenY); 1311 vp.SetDisplayHeadTimeY(screenY);
1515 vp.SetDisplayHeadTimeSize(screenSize); 1312 vp.SetDisplayHeadTimeSize(screenSize);
1516 vp.SetDisplayHeadTimeRed(red); 1313 vp.SetDisplayHeadTimeRed(red);
1517 vp.SetDisplayHeadTimeGreen(green); 1314 vp.SetDisplayHeadTimeGreen(green);
1518 vp.SetDisplayHeadTimeBlue(blue); 1315 vp.SetDisplayHeadTimeBlue(blue);
1519 if (verbosity >= G4VisManager::confirmati 1316 if (verbosity >= G4VisManager::confirmations) {
1520 G4cout << "Display head time flag set: 1317 G4cout << "Display head time flag set: "
1521 << vp 1318 << vp
1522 << G4endl; 1319 << G4endl;
1523 } 1320 }
1524 } 1321 }
1525 1322
1526 else if (command == fpCommandTimeWindowDisp 1323 else if (command == fpCommandTimeWindowDisplayLightFront)
1527 { 1324 {
1528 G4String display, originX, originY, origi 1325 G4String display, originX, originY, originZ, unitS, originT, unitT;
1529 G4double red, green, blue; 1326 G4double red, green, blue;
1530 std::istringstream iss(newValue); 1327 std::istringstream iss(newValue);
1531 iss >> display 1328 iss >> display
1532 >> originX >> originY >> originZ >> unitS 1329 >> originX >> originY >> originZ >> unitS
1533 >> originT >> unitT 1330 >> originT >> unitT
1534 >> red >> green >> blue; 1331 >> red >> green >> blue;
1535 vp.SetDisplayLightFront(command->ConvertT 1332 vp.SetDisplayLightFront(command->ConvertToBool(display));
1536 vp.SetDisplayLightFrontX 1333 vp.SetDisplayLightFrontX
1537 (command->ConvertToDimensionedDouble(G4St 1334 (command->ConvertToDimensionedDouble(G4String(originX + ' ' + unitS)));
1538 vp.SetDisplayLightFrontY 1335 vp.SetDisplayLightFrontY
1539 (command->ConvertToDimensionedDouble(G4St 1336 (command->ConvertToDimensionedDouble(G4String(originY + ' ' + unitS)));
1540 vp.SetDisplayLightFrontZ 1337 vp.SetDisplayLightFrontZ
1541 (command->ConvertToDimensionedDouble(G4St 1338 (command->ConvertToDimensionedDouble(G4String(originZ + ' ' + unitS)));
1542 vp.SetDisplayLightFrontT 1339 vp.SetDisplayLightFrontT
1543 (command->ConvertToDimensionedDouble(G4St 1340 (command->ConvertToDimensionedDouble(G4String(originT + ' ' + unitT)));
1544 vp.SetDisplayLightFrontRed(red); 1341 vp.SetDisplayLightFrontRed(red);
1545 vp.SetDisplayLightFrontGreen(green); 1342 vp.SetDisplayLightFrontGreen(green);
1546 vp.SetDisplayLightFrontBlue(blue); 1343 vp.SetDisplayLightFrontBlue(blue);
1547 if (verbosity >= G4VisManager::confirmati 1344 if (verbosity >= G4VisManager::confirmations) {
1548 G4cout << "Display light front flag set 1345 G4cout << "Display light front flag set: "
1549 << vp 1346 << vp
1550 << G4endl; 1347 << G4endl;
1551 } 1348 }
1552 } 1349 }
1553 1350
1554 else if (command == fpCommandTimeWindowEndT 1351 else if (command == fpCommandTimeWindowEndTime)
1555 { 1352 {
1556 G4String end_time_string, end_time_unit, 1353 G4String end_time_string, end_time_unit,
1557 time_range_string, time_range_unit; 1354 time_range_string, time_range_unit;
1558 std::istringstream iss(newValue); 1355 std::istringstream iss(newValue);
1559 iss >> end_time_string >> end_time_unit 1356 iss >> end_time_string >> end_time_unit
1560 >> time_range_string >> time_range_unit; 1357 >> time_range_string >> time_range_unit;
1561 vp.SetEndTime 1358 vp.SetEndTime
1562 (command->ConvertToDimensionedDouble 1359 (command->ConvertToDimensionedDouble
1563 (G4String(end_time_string + ' ' + end_ti 1360 (G4String(end_time_string + ' ' + end_time_unit)));
1564 G4double timeRange = command->ConvertToDi 1361 G4double timeRange = command->ConvertToDimensionedDouble
1565 (G4String(time_range_string + ' ' + time_ 1362 (G4String(time_range_string + ' ' + time_range_unit));
1566 if (timeRange > 0.) { 1363 if (timeRange > 0.) {
1567 vp.SetStartTime 1364 vp.SetStartTime
1568 (vp.GetEndTime() - timeRange); 1365 (vp.GetEndTime() - timeRange);
1569 } 1366 }
1570 if (verbosity >= G4VisManager::confirmati 1367 if (verbosity >= G4VisManager::confirmations) {
1571 G4cout 1368 G4cout
1572 << "Time window start time: " << vp.Get 1369 << "Time window start time: " << vp.GetStartTime()/ns << " ns"
1573 << ", time window end time: " << vp.Get 1370 << ", time window end time: " << vp.GetEndTime()/ns << " ns";
1574 if (timeRange > 0.) { 1371 if (timeRange > 0.) {
1575 G4cout << "\n (time range: " << time 1372 G4cout << "\n (time range: " << timeRange/ns << " ns)";
1576 } 1373 }
1577 G4cout << G4endl; 1374 G4cout << G4endl;
1578 } 1375 }
1579 } 1376 }
1580 1377
1581 else if (command == fpCommandTimeWindowFade 1378 else if (command == fpCommandTimeWindowFadeFactor) {
1582 vp.SetFadeFactor(command->ConvertToDouble 1379 vp.SetFadeFactor(command->ConvertToDouble(newValue));
1583 if (verbosity >= G4VisManager::confirmati 1380 if (verbosity >= G4VisManager::confirmations) {
1584 G4cout << "Time window fade factor chan 1381 G4cout << "Time window fade factor changed to " << vp.GetFadeFactor()
1585 << G4endl; 1382 << G4endl;
1586 } 1383 }
1587 } 1384 }
1588 1385
1589 else if (command == fpCommandTimeWindowStar 1386 else if (command == fpCommandTimeWindowStartTime)
1590 { 1387 {
1591 G4String start_time_string, start_time_un 1388 G4String start_time_string, start_time_unit,
1592 time_range_string, time_range_unit; 1389 time_range_string, time_range_unit;
1593 std::istringstream iss(newValue); 1390 std::istringstream iss(newValue);
1594 iss >> start_time_string >> start_time_un 1391 iss >> start_time_string >> start_time_unit
1595 >> time_range_string >> time_range_unit; 1392 >> time_range_string >> time_range_unit;
1596 vp.SetStartTime 1393 vp.SetStartTime
1597 (command->ConvertToDimensionedDouble 1394 (command->ConvertToDimensionedDouble
1598 (G4String(start_time_string + ' ' + star 1395 (G4String(start_time_string + ' ' + start_time_unit)));
1599 G4double timeRange = command->ConvertToDi 1396 G4double timeRange = command->ConvertToDimensionedDouble
1600 (G4String(time_range_string + ' ' + time_ 1397 (G4String(time_range_string + ' ' + time_range_unit));
1601 if (timeRange > 0.) { 1398 if (timeRange > 0.) {
1602 vp.SetEndTime 1399 vp.SetEndTime
1603 (vp.GetStartTime() + timeRange); 1400 (vp.GetStartTime() + timeRange);
1604 } 1401 }
1605 if (verbosity >= G4VisManager::confirmati 1402 if (verbosity >= G4VisManager::confirmations) {
1606 G4cout 1403 G4cout
1607 << "Time window start time: " << vp.Get 1404 << "Time window start time: " << vp.GetStartTime()/ns << " ns"
1608 << ", time window end time: " << vp.Get 1405 << ", time window end time: " << vp.GetEndTime()/ns << " ns";
1609 if (timeRange > 0.) { 1406 if (timeRange > 0.) {
1610 G4cout << "\n (time range: " << time 1407 G4cout << "\n (time range: " << timeRange/ns << " ns)";
1611 } 1408 }
1612 G4cout << G4endl; 1409 G4cout << G4endl;
1613 } 1410 }
1614 } 1411 }
1615 1412
1616 else { 1413 else {
1617 if (verbosity >= G4VisManager::errors) { 1414 if (verbosity >= G4VisManager::errors) {
1618 G4warn << << 1415 G4cerr <<
1619 "ERROR: G4VisCommandsViewerSet::SetNewV << 1416 "ERROR: G4VisCommandsViewerSet::SetNewValue: unrecognised command."
1620 << G4endl; << 1417 << G4endl;
1621 } 1418 }
1622 return; 1419 return;
1623 } 1420 }
1624 1421
1625 SetViewParameters(currentViewer,vp); 1422 SetViewParameters(currentViewer,vp);
1626 } 1423 }
1627 1424