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