| 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 // G4ScoringMessenger << 26 //
27 // ------------------------------------------- << 27 // $Id$
>> 28 //
>> 29 // ---------------------------------------------------------------------
28 30
29 #include "G4ScoringMessenger.hh" 31 #include "G4ScoringMessenger.hh"
30 #include "G4ScoringManager.hh" 32 #include "G4ScoringManager.hh"
31 #include "G4VScoringMesh.hh" 33 #include "G4VScoringMesh.hh"
32 #include "G4ScoringBox.hh" 34 #include "G4ScoringBox.hh"
33 #include "G4ScoringCylinder.hh" 35 #include "G4ScoringCylinder.hh"
34 #include "G4ScoringRealWorld.hh" <<
35 #include "G4ScoringProbe.hh" <<
36 36
37 #include "G4UIdirectory.hh" 37 #include "G4UIdirectory.hh"
38 #include "G4UIcmdWithoutParameter.hh" 38 #include "G4UIcmdWithoutParameter.hh"
39 #include "G4UIcmdWithAnInteger.hh" 39 #include "G4UIcmdWithAnInteger.hh"
40 #include "G4UIcmdWithAString.hh" 40 #include "G4UIcmdWithAString.hh"
41 #include "G4UIcmdWithABool.hh" 41 #include "G4UIcmdWithABool.hh"
42 #include "G4UIcmdWithADoubleAndUnit.hh" 42 #include "G4UIcmdWithADoubleAndUnit.hh"
43 #include "G4UIcmdWith3VectorAndUnit.hh" 43 #include "G4UIcmdWith3VectorAndUnit.hh"
44 #include "G4UIcommand.hh" 44 #include "G4UIcommand.hh"
45 #include "G4UIparameter.hh" <<
46 #include "G4Tokenizer.hh" 45 #include "G4Tokenizer.hh"
47 #include "G4UnitsTable.hh" 46 #include "G4UnitsTable.hh"
48 #include "G4VScoreColorMap.hh" 47 #include "G4VScoreColorMap.hh"
49 48
50 #include "G4VPrimitivePlotter.hh" <<
51 #include "G4VScoreHistFiller.hh" <<
52 <<
53 G4ScoringMessenger::G4ScoringMessenger(G4Scori 49 G4ScoringMessenger::G4ScoringMessenger(G4ScoringManager* SManager)
54 : fSMan(SManager) << 50 :fSMan(SManager)
55 { 51 {
56 G4UIparameter* param = nullptr; << 52 G4UIparameter* param;
57 53
58 scoreDir = new G4UIdirectory("/score/"); 54 scoreDir = new G4UIdirectory("/score/");
59 scoreDir->SetGuidance("Interactive scoring c 55 scoreDir->SetGuidance("Interactive scoring commands.");
60 56
61 listCmd = new G4UIcmdWithoutParameter("/scor << 57 listCmd = new G4UIcmdWithoutParameter("/score/list",this);
62 listCmd->SetGuidance("List scoring worlds.") 58 listCmd->SetGuidance("List scoring worlds.");
63 59
64 dumpCmd = new G4UIcmdWithoutParameter("/scor << 60 dumpCmd = new G4UIcmdWithoutParameter("/score/dump",this);
65 dumpCmd->SetGuidance("Dump results of scorer 61 dumpCmd->SetGuidance("Dump results of scorers.");
66 62
67 verboseCmd = new G4UIcmdWithAnInteger("/scor << 63 verboseCmd = new G4UIcmdWithAnInteger("/score/verbose",this);
68 verboseCmd->SetGuidance("Verbosity."); 64 verboseCmd->SetGuidance("Verbosity.");
69 verboseCmd->SetGuidance(" 0) errors or warn 65 verboseCmd->SetGuidance(" 0) errors or warnings,");
70 verboseCmd->SetGuidance(" 1) information wi 66 verboseCmd->SetGuidance(" 1) information with 0)");
71 67
>> 68 meshDir = new G4UIdirectory("/score/mesh/");
>> 69 meshDir->SetGuidance(" Mesh processing commands.");
>> 70
72 meshCreateDir = new G4UIdirectory("/score/cr 71 meshCreateDir = new G4UIdirectory("/score/create/");
73 meshCreateDir->SetGuidance(" Mesh creation 72 meshCreateDir->SetGuidance(" Mesh creation commands.");
74 // 73 //
75 // Mesh commands 74 // Mesh commands
76 meshBoxCreateCmd = new G4UIcmdWithAString("/ << 75 meshBoxCreateCmd = new G4UIcmdWithAString("/score/create/boxMesh",this);
77 meshBoxCreateCmd->SetGuidance("Create scorin 76 meshBoxCreateCmd->SetGuidance("Create scoring box mesh.");
78 meshBoxCreateCmd->SetParameterName("MeshName << 77 meshBoxCreateCmd->SetParameterName("MeshName",false);
79 // 78 //
80 meshCylinderCreateCmd = << 79 meshCylinderCreateCmd = new G4UIcmdWithAString("/score/create/cylinderMesh",this);
81 new G4UIcmdWithAString("/score/create/cyli <<
82 meshCylinderCreateCmd->SetGuidance("Create s 80 meshCylinderCreateCmd->SetGuidance("Create scoring mesh.");
83 meshCylinderCreateCmd->SetParameterName("Mes << 81 meshCylinderCreateCmd->SetParameterName("MeshName",false);
84 <<
85 meshRWLogVolCreateCmd = <<
86 new G4UIcommand("/score/create/realWorldLo <<
87 meshRWLogVolCreateCmd->SetGuidance( <<
88 "Define scorers to a logical volume define <<
89 meshRWLogVolCreateCmd->SetGuidance( <<
90 " - Name of the specified logical volume <<
91 meshRWLogVolCreateCmd->SetGuidance( <<
92 " - /score/mesh commands do not affect fo <<
93 meshRWLogVolCreateCmd->SetGuidance( <<
94 " - If copyNumberLevel is set, the copy n <<
95 meshRWLogVolCreateCmd->SetGuidance( <<
96 " in the geometrical hierarchy is used <<
97 param = new G4UIparameter("logVol", 's', fal <<
98 meshRWLogVolCreateCmd->SetParameter(param); <<
99 param = new G4UIparameter("copyNumberLevel", <<
100 param->SetParameterRange("copyNumberLevel>=0 <<
101 param->SetDefaultValue(0); <<
102 meshRWLogVolCreateCmd->SetParameter(param); <<
103 // <<
104 probeCreateCmd = new G4UIcommand("/score/cre <<
105 probeCreateCmd->SetGuidance("Define scoring <<
106 probeCreateCmd->SetGuidance( <<
107 " halfSize defines the half-width of the <<
108 param = new G4UIparameter("pname", 's', fals <<
109 probeCreateCmd->SetParameter(param); <<
110 param = new G4UIparameter("halfSize", 'd', f <<
111 probeCreateCmd->SetParameter(param); <<
112 param = new G4UIparameter("unit", 's', true) <<
113 param->SetDefaultUnit("mm"); <<
114 probeCreateCmd->SetParameter(param); <<
115 param = new G4UIparameter("checkOverlap", 'b <<
116 param->SetDefaultValue(0); <<
117 probeCreateCmd->SetParameter(param); <<
118 // 82 //
119 meshOpnCmd = new G4UIcmdWithAString("/score/ << 83 // meshSphereCreateCmd = new G4UIcmdWithAString("/score/create/sphereMesh",this);
>> 84 // meshSphereCreateCmd->SetGuidance("Create scoring mesh.");
>> 85 // meshSphereCreateCmd->SetParameterName("MeshName",false);
>> 86 //
>> 87 meshOpnCmd = new G4UIcmdWithAString("/score/open",this);
120 meshOpnCmd->SetGuidance("Open scoring mesh." 88 meshOpnCmd->SetGuidance("Open scoring mesh.");
121 meshOpnCmd->SetParameterName("MeshName", fal << 89 meshOpnCmd->SetParameterName("MeshName",false);
122 // 90 //
123 meshClsCmd = new G4UIcmdWithoutParameter("/s << 91 meshClsCmd = new G4UIcmdWithoutParameter("/score/close",this);
124 meshClsCmd->SetGuidance("Close scoring mesh. 92 meshClsCmd->SetGuidance("Close scoring mesh.");
125 <<
126 meshDir = new G4UIdirectory("/score/mesh/"); <<
127 meshDir->SetGuidance(" Mesh processing co <<
128 // 93 //
129 mBoxSizeCmd = new G4UIcmdWith3VectorAndUnit( << 94 // meshActCmd = new G4UIcmdWithABool("/score/mesh/activate",this);
>> 95 // meshActCmd->SetGuidance("Activate scoring mesh.");
>> 96 // meshActCmd->SetParameterName("MeshName",false);
>> 97 //
>> 98 mBoxSizeCmd = new G4UIcmdWith3VectorAndUnit("/score/mesh/boxSize",this);
130 mBoxSizeCmd->SetGuidance("Define size of the 99 mBoxSizeCmd->SetGuidance("Define size of the scoring mesh.");
131 mBoxSizeCmd->SetGuidance("Dx Dy Dz unit") 100 mBoxSizeCmd->SetGuidance("Dx Dy Dz unit");
132 mBoxSizeCmd->SetParameterName("Di", "Dj", "D << 101 mBoxSizeCmd->SetParameterName("Di","Dj","Dk",false,false);
133 mBoxSizeCmd->SetRange("Di>0. && Dj>0. && Dk> 102 mBoxSizeCmd->SetRange("Di>0. && Dj>0. && Dk>0.");
134 mBoxSizeCmd->SetDefaultUnit("mm"); 103 mBoxSizeCmd->SetDefaultUnit("mm");
135 // 104 //
136 mCylinderSizeCmd = new G4UIcommand("/score/m << 105 mCylinderSizeCmd = new G4UIcommand("/score/mesh/cylinderSize",this);
137 mCylinderSizeCmd->SetGuidance("Define size o 106 mCylinderSizeCmd->SetGuidance("Define size of the scoring mesh.");
138 mCylinderSizeCmd->SetGuidance("R Dz unit" 107 mCylinderSizeCmd->SetGuidance("R Dz unit");
139 param = new G4UIparameter("R", 'd', false); << 108 param = new G4UIparameter("R",'d',false);
140 param->SetParameterRange("R>0"); 109 param->SetParameterRange("R>0");
141 mCylinderSizeCmd->SetParameter(param); 110 mCylinderSizeCmd->SetParameter(param);
142 param = new G4UIparameter("Dz", 'd', false); << 111 param = new G4UIparameter("Dz",'d',false);
143 param->SetParameterRange("Dz>0"); 112 param->SetParameterRange("Dz>0");
144 mCylinderSizeCmd->SetParameter(param); 113 mCylinderSizeCmd->SetParameter(param);
145 param = new G4UIparameter("unit", 's', true) << 114 param = new G4UIparameter("unit",'s',true);
146 param->SetDefaultUnit("mm"); << 115 param->SetDefaultValue("mm");
147 mCylinderSizeCmd->SetParameter(param); 116 mCylinderSizeCmd->SetParameter(param);
148 // 117 //
149 mCylinderRMinCmd = <<
150 new G4UIcmdWithADoubleAndUnit("/score/mesh <<
151 mCylinderRMinCmd->SetGuidance("Define the in <<
152 mCylinderRMinCmd->SetGuidance("This command <<
153 mCylinderRMinCmd->SetParameterName("RMin", f <<
154 mCylinderRMinCmd->SetRange("RMin>=0."); <<
155 mCylinderRMinCmd->SetDefaultUnit("mm"); <<
156 // <<
157 mCylinderAngleCmd = new G4UIcommand("/score/ <<
158 mCylinderAngleCmd->SetGuidance( <<
159 "Define starting angle and span for tube s <<
160 mCylinderAngleCmd->SetGuidance( <<
161 "This command is not needed for cylinder m <<
162 param = new G4UIparameter("startPhi", 'd', f <<
163 mCylinderAngleCmd->SetParameter(param); <<
164 param = new G4UIparameter("deltaPhi", 'd', f <<
165 param->SetParameterRange("deltaPhi>0."); <<
166 mCylinderAngleCmd->SetParameter(param); <<
167 param = new G4UIparameter("unit", 's', true) <<
168 param->SetDefaultUnit("deg"); <<
169 mCylinderAngleCmd->SetParameter(param); <<
170 // <<
171 // Division command 118 // Division command
172 mBinCmd = new G4UIcommand("/score/mesh/nBin" << 119 mBinCmd = new G4UIcommand("/score/mesh/nBin",this);
173 mBinCmd->SetGuidance("Define segments of the 120 mBinCmd->SetGuidance("Define segments of the scoring mesh.");
174 mBinCmd->SetGuidance("[usage] /score/mesh/nB 121 mBinCmd->SetGuidance("[usage] /score/mesh/nBin");
175 mBinCmd->SetGuidance(" In case of boxMesh, p 122 mBinCmd->SetGuidance(" In case of boxMesh, parameters are given in");
176 mBinCmd->SetGuidance(" Ni :(int) Number o 123 mBinCmd->SetGuidance(" Ni :(int) Number of bins i (in x-axis) ");
177 mBinCmd->SetGuidance(" Nj :(int) Number o 124 mBinCmd->SetGuidance(" Nj :(int) Number of bins j (in y-axis) ");
178 mBinCmd->SetGuidance(" Nk :(int) Number o 125 mBinCmd->SetGuidance(" Nk :(int) Number of bins k (in z-axis) ");
179 mBinCmd->SetGuidance(" In case of cylinderMe 126 mBinCmd->SetGuidance(" In case of cylinderMesh, parameters are given in");
180 mBinCmd->SetGuidance(" Nr :(int) Number o 127 mBinCmd->SetGuidance(" Nr :(int) Number of bins in radial axis ");
181 mBinCmd->SetGuidance(" Nz :(int) Number o 128 mBinCmd->SetGuidance(" Nz :(int) Number of bins in z axis ");
182 mBinCmd->SetGuidance(" Nphi:(int) Number o 129 mBinCmd->SetGuidance(" Nphi:(int) Number of bins in phi axis ");
183 << 130 //mBinCmd->SetGuidance(" Axis:(int) Axis of division ");
184 param = new G4UIparameter("Ni", 'i', false); << 131 // mBinCmd->SetGuidance(" P1..Pn-1 :(double) \"paramter from P1 to Pn-1 for division.\"");
>> 132 param = new G4UIparameter("Ni",'i',false);
185 param->SetDefaultValue("1"); 133 param->SetDefaultValue("1");
186 param->SetParameterRange("Ni>0"); 134 param->SetParameterRange("Ni>0");
187 mBinCmd->SetParameter(param); 135 mBinCmd->SetParameter(param);
188 param = new G4UIparameter("Nj", 'i', false); << 136 param = new G4UIparameter("Nj",'i',false);
189 param->SetDefaultValue("1"); 137 param->SetDefaultValue("1");
190 param->SetParameterRange("Nj>0"); 138 param->SetParameterRange("Nj>0");
191 mBinCmd->SetParameter(param); 139 mBinCmd->SetParameter(param);
192 param = new G4UIparameter("Nk", 'i', false); << 140 param = new G4UIparameter("Nk",'i',false);
193 param->SetDefaultValue("1"); 141 param->SetDefaultValue("1");
194 mBinCmd->SetParameter(param); 142 mBinCmd->SetParameter(param);
195 param->SetParameterRange("Nk>0"); 143 param->SetParameterRange("Nk>0");
196 << 144 //param = new G4UIparameter("Axis",'i',true);
>> 145 //param->SetDefaultValue("3");
>> 146 //mBinCmd->SetParameter(param);
>> 147 //
197 // Placement command 148 // Placement command
198 mTransDir = new G4UIdirectory("/score/mesh/t 149 mTransDir = new G4UIdirectory("/score/mesh/translate/");
199 mTransDir->SetGuidance("Mesh translation com 150 mTransDir->SetGuidance("Mesh translation commands.");
200 // 151 //
201 mTResetCmd = new G4UIcmdWithoutParameter("/s << 152 mTResetCmd = new G4UIcmdWithoutParameter("/score/mesh/translate/reset",this);
202 mTResetCmd->SetGuidance("Reset translated po 153 mTResetCmd->SetGuidance("Reset translated position of the scoring mesh.");
203 // 154 //
204 mTXyzCmd = new G4UIcmdWith3VectorAndUnit("/s << 155 mTXyzCmd = new G4UIcmdWith3VectorAndUnit("/score/mesh/translate/xyz",this);
205 mTXyzCmd->SetGuidance("Translate the scoring 156 mTXyzCmd->SetGuidance("Translate the scoring mesh.");
206 mTXyzCmd->SetParameterName("X", "Y", "Z", fa << 157 mTXyzCmd->SetParameterName("X","Y","Z",false,false);
207 mTXyzCmd->SetDefaultUnit("mm"); 158 mTXyzCmd->SetDefaultUnit("mm");
208 // 159 //
209 mRotDir = new G4UIdirectory("/score/mesh/rot 160 mRotDir = new G4UIdirectory("/score/mesh/rotate/");
210 mRotDir->SetGuidance("Mesh rotation commands 161 mRotDir->SetGuidance("Mesh rotation commands.");
211 << 162 //
212 mRotXCmd = new G4UIcmdWithADoubleAndUnit("/s << 163 mRResetCmd = new G4UIcmdWithoutParameter("/score/mesh/rotate/reset",this);
>> 164 mRResetCmd->SetGuidance("Reset rotation angles of the scoring mesh.");
>> 165 //
>> 166 mRotXCmd = new G4UIcmdWithADoubleAndUnit("/score/mesh/rotate/rotateX",this);
213 mRotXCmd->SetGuidance("Rotate the scoring me 167 mRotXCmd->SetGuidance("Rotate the scoring mesh in X axis.");
214 mRotXCmd->SetParameterName("Rx", false); << 168 mRotXCmd->SetParameterName("Rx",false);
215 mRotXCmd->SetDefaultUnit("deg"); 169 mRotXCmd->SetDefaultUnit("deg");
216 // 170 //
217 mRotYCmd = new G4UIcmdWithADoubleAndUnit("/s << 171 mRotYCmd = new G4UIcmdWithADoubleAndUnit("/score/mesh/rotate/rotateY",this);
218 mRotYCmd->SetGuidance("Rotate the scoring me 172 mRotYCmd->SetGuidance("Rotate the scoring mesh in Y axis.");
219 mRotYCmd->SetParameterName("Ry", false); << 173 mRotYCmd->SetParameterName("Ry",false);
220 mRotYCmd->SetDefaultUnit("deg"); 174 mRotYCmd->SetDefaultUnit("deg");
221 // 175 //
222 mRotZCmd = new G4UIcmdWithADoubleAndUnit("/s << 176 mRotZCmd = new G4UIcmdWithADoubleAndUnit("/score/mesh/rotate/rotateZ",this);
223 mRotZCmd->SetGuidance("Rotate the scoring me 177 mRotZCmd->SetGuidance("Rotate the scoring mesh in Z axis.");
224 mRotZCmd->SetParameterName("Rz", false); << 178 mRotZCmd->SetParameterName("Rz",false);
225 mRotZCmd->SetDefaultUnit("deg"); 179 mRotZCmd->SetDefaultUnit("deg");
226 // 180 //
227 probeDir = new G4UIdirectory("/score/probe/" <<
228 probeDir->SetGuidance("Probe commands"); <<
229 <<
230 probeMatCmd = new G4UIcmdWithAString("/score <<
231 probeMatCmd->SetGuidance("Specify a material <<
232 probeMatCmd->SetGuidance("Material name has <<
233 probeMatCmd->SetGuidance("Once this command <<
234 "overlays the mater <<
235 probeMatCmd->SetGuidance("with \"Layered Mas <<
236 "physics quantities <<
237 probeMatCmd->SetGuidance("or dose will be ca <<
238 probeMatCmd->SetGuidance("To switch-off this <<
239 probeMatCmd->SetParameterName("matName", tru <<
240 probeMatCmd->SetDefaultValue("none"); <<
241 <<
242 probeLocateCmd = new G4UIcmdWith3VectorAndUn <<
243 probeLocateCmd->SetGuidance( <<
244 "Locate a probe in the global coordinate s <<
245 probeLocateCmd->SetParameterName("x", "y", " <<
246 probeLocateCmd->SetDefaultUnit("mm"); <<
247 181
248 // Draw Scoring result 182 // Draw Scoring result
249 drawCmd = new G4UIcommand("/score/drawProjec << 183 drawCmd = new G4UIcommand("/score/drawProjection",this);
250 drawCmd->SetGuidance("Draw projection(s) of 184 drawCmd->SetGuidance("Draw projection(s) of scored quantities.");
251 drawCmd->SetGuidance( << 185 drawCmd->SetGuidance("Parameter <proj> specified which projection(s) to be drawn.");
252 "Parameter <proj> specified which projecti << 186 drawCmd->SetGuidance(" 100 : xy-plane, 010 : yz-plane, 001 : zx-plane -- default 111");
253 drawCmd->SetGuidance( << 187 drawCmd->SetGuidance(" 100 : N/A, 010 : z_phi-plane, 001 : r_phi-plane -- default 111");
254 " 100 : xy-plane, 010 : yz-plane, 001 << 188 param = new G4UIparameter("meshName",'s',false);
255 drawCmd->SetGuidance( <<
256 " 100 : N/A, 010 : z_phi-plane, 001 <<
257 param = new G4UIparameter("meshName", 's', f <<
258 drawCmd->SetParameter(param); 189 drawCmd->SetParameter(param);
259 param = new G4UIparameter("psName", 's', fal << 190 param = new G4UIparameter("psName",'s',false);
260 drawCmd->SetParameter(param); 191 drawCmd->SetParameter(param);
261 param = new G4UIparameter("colorMapName", 's << 192 param = new G4UIparameter("colorMapName",'s',true);
262 param->SetDefaultValue("defaultLinearColorMa 193 param->SetDefaultValue("defaultLinearColorMap");
263 drawCmd->SetParameter(param); 194 drawCmd->SetParameter(param);
264 param = new G4UIparameter("proj", 'i', true) << 195 param = new G4UIparameter("proj",'i',true);
265 param->SetDefaultValue(111); 196 param->SetDefaultValue(111);
266 drawCmd->SetParameter(param); 197 drawCmd->SetParameter(param);
267 drawCmd->SetToBeBroadcasted(false); <<
268 198
269 // Draw column 199 // Draw column
270 drawColumnCmd = new G4UIcommand("/score/draw << 200 drawColumnCmd = new G4UIcommand("/score/drawColumn",this);
271 drawColumnCmd->SetGuidance("Draw a cell colu 201 drawColumnCmd->SetGuidance("Draw a cell column.");
272 drawColumnCmd->SetGuidance(" plane = 0 : x-y 202 drawColumnCmd->SetGuidance(" plane = 0 : x-y, 1: y-z, 2: z-x for box mesh");
273 drawColumnCmd->SetGuidance( << 203 drawColumnCmd->SetGuidance(" 0 : z-phi, 1: r-phi, 2: r-z for cylinder mesh");
274 " 0 : z-phi, 1: r-phi, 2: r-z for << 204 param = new G4UIparameter("meshName",'s',false);
275 param = new G4UIparameter("meshName", 's', f <<
276 drawColumnCmd->SetParameter(param); 205 drawColumnCmd->SetParameter(param);
277 param = new G4UIparameter("psName", 's', fal << 206 param = new G4UIparameter("psName",'s',false);
278 drawColumnCmd->SetParameter(param); 207 drawColumnCmd->SetParameter(param);
279 param = new G4UIparameter("plane", 'i', fals << 208 param = new G4UIparameter("plane",'i',false);
280 param->SetParameterRange("plane>=0 && plane< 209 param->SetParameterRange("plane>=0 && plane<=2");
281 drawColumnCmd->SetParameter(param); 210 drawColumnCmd->SetParameter(param);
282 param = new G4UIparameter("column", 'i', fal << 211 param = new G4UIparameter("column",'i',false);
283 drawColumnCmd->SetParameter(param); 212 drawColumnCmd->SetParameter(param);
284 param = new G4UIparameter("colorMapName", 's << 213 param = new G4UIparameter("colorMapName",'s',true);
285 param->SetDefaultValue("defaultLinearColorMa 214 param->SetDefaultValue("defaultLinearColorMap");
286 drawColumnCmd->SetParameter(param); 215 drawColumnCmd->SetParameter(param);
287 drawColumnCmd->SetToBeBroadcasted(false); <<
288 216
289 colorMapDir = new G4UIdirectory("/score/colo 217 colorMapDir = new G4UIdirectory("/score/colorMap/");
290 colorMapDir->SetGuidance("Color map commands 218 colorMapDir->SetGuidance("Color map commands.");
291 219
292 listColorMapCmd = << 220 listColorMapCmd = new G4UIcmdWithoutParameter("/score/colorMap/listScoreColorMaps",this);
293 new G4UIcmdWithoutParameter("/score/colorM <<
294 listColorMapCmd->SetGuidance("List registere 221 listColorMapCmd->SetGuidance("List registered score color maps.");
295 listColorMapCmd->SetToBeBroadcasted(false); <<
296 222
297 floatMinMaxCmd = new G4UIcmdWithAString("/sc << 223 floatMinMaxCmd = new G4UIcmdWithAString("/score/colorMap/floatMinMax",this);
298 floatMinMaxCmd->SetGuidance( << 224 floatMinMaxCmd->SetGuidance("Min/Max of the color map is calculated accorging to the actual scores.");
299 "Min/Max of the color map is calculated ac << 225 floatMinMaxCmd->SetParameterName("colorMapName",true,false);
300 floatMinMaxCmd->SetParameterName("colorMapNa <<
301 floatMinMaxCmd->SetDefaultValue("defaultLine 226 floatMinMaxCmd->SetDefaultValue("defaultLinearColorMap");
302 floatMinMaxCmd->SetToBeBroadcasted(false); <<
303 227
304 colorMapMinMaxCmd = new G4UIcommand("/score/ << 228 colorMapMinMaxCmd = new G4UIcommand("/score/colorMap/setMinMax",this);
305 colorMapMinMaxCmd->SetGuidance("Define min/m 229 colorMapMinMaxCmd->SetGuidance("Define min/max value of the color map.");
306 param = new G4UIparameter("colorMapMame", 's << 230 param = new G4UIparameter("colorMapMame",'s',true);
307 param->SetDefaultValue("defaultLinearColorMa 231 param->SetDefaultValue("defaultLinearColorMap");
308 colorMapMinMaxCmd->SetParameter(param); 232 colorMapMinMaxCmd->SetParameter(param);
309 param = new G4UIparameter("minValue", 'd', f << 233 param = new G4UIparameter("minValue",'d',false);
310 colorMapMinMaxCmd->SetParameter(param); 234 colorMapMinMaxCmd->SetParameter(param);
311 param = new G4UIparameter("maxValue", 'd', f << 235 param = new G4UIparameter("maxValue",'d',false);
312 colorMapMinMaxCmd->SetParameter(param); 236 colorMapMinMaxCmd->SetParameter(param);
313 colorMapMinMaxCmd->SetToBeBroadcasted(false) <<
314 237
315 // Dump a scored quantity << 238 /*
>> 239 chartCmd = new G4UIcommand("/score/drawChart",this);
>> 240 chartCmd->SetGuidance("Draw color chart on the screen.");
>> 241 chartCmd->SetGuidance("[usage] /score/drawChart");
>> 242 chartCmd->SetGuidance(" mesh :(String) Mesh name.");
>> 243 chartCmd->SetGuidance(" psname :(String) PS name.");
>> 244 chartCmd->SetGuidance(" On/Off :(boolean) On or Off the color chart.");
>> 245 chartCmd->SetGuidance(" scale :(String) default=linear, or log ");
>> 246 param = new G4UIparameter("meshName",'s',false);
>> 247 chartCmd->SetParameter(param);
>> 248 param = new G4UIparameter("psName",'s',false);
>> 249 chartCmd->SetParameter(param);
>> 250 param = new G4UIparameter("On",'s',true);
>> 251 param->SetDefaultValue("true");
>> 252 chartCmd->SetParameter(param);
>> 253 param = new G4UIparameter("scale",'s',true);
>> 254 param->SetDefaultValue("linear");
>> 255 chartCmd->SetParameter(param);
>> 256 */
>> 257
>> 258 // Dump a scored quantity
316 dumpQtyToFileCmd = new G4UIcommand("/score/d 259 dumpQtyToFileCmd = new G4UIcommand("/score/dumpQuantityToFile", this);
317 dumpQtyToFileCmd->SetGuidance("Dump one scor 260 dumpQtyToFileCmd->SetGuidance("Dump one scored quantity to file.");
318 param = new G4UIparameter("meshName", 's', f 261 param = new G4UIparameter("meshName", 's', false);
319 dumpQtyToFileCmd->SetParameter(param); 262 dumpQtyToFileCmd->SetParameter(param);
320 param = new G4UIparameter("psName", 's', fal 263 param = new G4UIparameter("psName", 's', false);
321 dumpQtyToFileCmd->SetParameter(param); 264 dumpQtyToFileCmd->SetParameter(param);
322 param = new G4UIparameter("fileName", 's', f 265 param = new G4UIparameter("fileName", 's', false);
323 dumpQtyToFileCmd->SetParameter(param); 266 dumpQtyToFileCmd->SetParameter(param);
324 param = new G4UIparameter("option", 's', tru 267 param = new G4UIparameter("option", 's', true);
325 dumpQtyToFileCmd->SetParameter(param); 268 dumpQtyToFileCmd->SetParameter(param);
326 dumpQtyToFileCmd->SetToBeBroadcasted(false); <<
327 <<
328 dumpQtyWithFactorCmd = new G4UIcommand("/sco <<
329 dumpQtyWithFactorCmd->SetGuidance("Dump one <<
330 dumpQtyWithFactorCmd->SetGuidance( <<
331 "Each value is multiplied by the specified <<
332 param = new G4UIparameter("meshName", 's', f <<
333 dumpQtyWithFactorCmd->SetParameter(param); <<
334 param = new G4UIparameter("psName", 's', fal <<
335 dumpQtyWithFactorCmd->SetParameter(param); <<
336 param = new G4UIparameter("fileName", 's', f <<
337 dumpQtyWithFactorCmd->SetParameter(param); <<
338 param = new G4UIparameter("factor", 'd', fal <<
339 param->SetParameterRange("factor>0."); <<
340 dumpQtyWithFactorCmd->SetParameter(param); <<
341 param = new G4UIparameter("option", 's', tru <<
342 dumpQtyWithFactorCmd->SetParameter(param); <<
343 dumpQtyWithFactorCmd->SetToBeBroadcasted(fal <<
344 269
345 // Dump all scored quantities 270 // Dump all scored quantities
346 dumpAllQtsToFileCmd = new G4UIcommand("/scor 271 dumpAllQtsToFileCmd = new G4UIcommand("/score/dumpAllQuantitiesToFile", this);
347 dumpAllQtsToFileCmd->SetGuidance("Dump all q 272 dumpAllQtsToFileCmd->SetGuidance("Dump all quantities of the mesh to file.");
348 param = new G4UIparameter("meshName", 's', f 273 param = new G4UIparameter("meshName", 's', false);
349 dumpAllQtsToFileCmd->SetParameter(param); 274 dumpAllQtsToFileCmd->SetParameter(param);
350 param = new G4UIparameter("fileName", 's', f 275 param = new G4UIparameter("fileName", 's', false);
351 dumpAllQtsToFileCmd->SetParameter(param); 276 dumpAllQtsToFileCmd->SetParameter(param);
352 param = new G4UIparameter("option", 's', tru 277 param = new G4UIparameter("option", 's', true);
353 dumpAllQtsToFileCmd->SetParameter(param); 278 dumpAllQtsToFileCmd->SetParameter(param);
354 dumpAllQtsToFileCmd->SetToBeBroadcasted(fals <<
355 279
356 dumpAllQtsWithFactorCmd = <<
357 new G4UIcommand("/score/dumpAllQuantitiesW <<
358 dumpAllQtsWithFactorCmd->SetGuidance( <<
359 "Dump all quantities of the mesh to file." <<
360 dumpAllQtsWithFactorCmd->SetGuidance( <<
361 "Each value is multiplied by the specified <<
362 param = new G4UIparameter("meshName", 's', f <<
363 dumpAllQtsWithFactorCmd->SetParameter(param) <<
364 param = new G4UIparameter("fileName", 's', f <<
365 dumpAllQtsWithFactorCmd->SetParameter(param) <<
366 param = new G4UIparameter("factor", 'd', fal <<
367 param->SetParameterRange("factor>0."); <<
368 dumpAllQtsWithFactorCmd->SetParameter(param) <<
369 param = new G4UIparameter("option", 's', tru <<
370 dumpAllQtsWithFactorCmd->SetParameter(param) <<
371 dumpAllQtsWithFactorCmd->SetToBeBroadcasted( <<
372 <<
373 fill1DCmd = new G4UIcommand("/score/fill1D", <<
374 fill1DCmd->SetGuidance("Let a primitive scor <<
375 fill1DCmd->SetGuidance("Before using this co <<
376 "defined and assigned <<
377 fill1DCmd->SetGuidance("Also before using th <<
378 "be defined by /analy <<
379 fill1DCmd->SetGuidance( <<
380 "This command is available only for real-w <<
381 fill1DCmd->SetGuidance("Please note that thi <<
382 "each copy number of <<
383 fill1DCmd->SetGuidance("If same histogram ID <<
384 "than one scorers fil <<
385 param = new G4UIparameter("histID", 'i', fal <<
386 fill1DCmd->SetParameter(param); <<
387 param = new G4UIparameter("meshName", 's', f <<
388 fill1DCmd->SetParameter(param); <<
389 param = new G4UIparameter("scorerName", 's', <<
390 fill1DCmd->SetParameter(param); <<
391 param = new G4UIparameter("copyNo", 'i', tru <<
392 param->SetDefaultValue(0); <<
393 fill1DCmd->SetParameter(param); <<
394 } 280 }
395 281
396 G4ScoringMessenger::~G4ScoringMessenger() 282 G4ScoringMessenger::~G4ScoringMessenger()
397 { 283 {
398 delete listCmd; << 284 delete listCmd;
399 delete verboseCmd; << 285 delete verboseCmd;
400 // << 286 //
401 delete meshBoxCreateCmd; << 287 delete meshCreateDir;
402 delete meshCylinderCreateCmd; << 288 delete meshBoxCreateCmd;
403 delete meshRWLogVolCreateCmd; << 289 delete meshCylinderCreateCmd;
404 delete probeCreateCmd; << 290 // delete meshSphereCreateCmd;
405 delete meshCreateDir; << 291 //
406 // << 292 delete meshOpnCmd;
407 delete meshOpnCmd; << 293 //
408 // << 294 delete meshClsCmd;
409 delete meshClsCmd; << 295 // delete meshActCmd;
410 delete meshDir; << 296 delete meshDir;
411 // << 297 //
412 delete mBoxSizeCmd; << 298 delete mBoxSizeCmd;
413 delete mCylinderSizeCmd; << 299 delete mCylinderSizeCmd;
414 delete mCylinderRMinCmd; << 300 // delete mSphereSizeCmd;
415 delete mCylinderAngleCmd; << 301 //
416 // << 302 delete mBinCmd;
417 delete mBinCmd; << 303 //
418 // << 304 delete mTResetCmd;
419 delete mTResetCmd; << 305 delete mTXyzCmd;
420 delete mTXyzCmd; << 306 delete mTransDir;
421 delete mTransDir; << 307 delete mRResetCmd;
422 delete mRotXCmd; << 308 delete mRotXCmd;
423 delete mRotYCmd; << 309 delete mRotYCmd;
424 delete mRotZCmd; << 310 delete mRotZCmd;
425 delete mRotDir; << 311 delete mRotDir;
426 // << 312 //
427 delete probeLocateCmd; << 313 delete chartCmd;
428 delete probeMatCmd; << 314 delete dumpCmd;
429 delete probeDir; << 315 delete drawCmd;
430 // << 316 delete drawColumnCmd;
431 delete dumpCmd; << 317 delete listColorMapCmd;
432 delete drawCmd; << 318 delete floatMinMaxCmd;
433 delete drawColumnCmd; << 319 delete colorMapMinMaxCmd;
434 delete listColorMapCmd; << 320 delete colorMapDir;
435 delete floatMinMaxCmd; << 321 delete dumpQtyToFileCmd;
436 delete colorMapMinMaxCmd; << 322 delete dumpAllQtsToFileCmd;
437 delete colorMapDir; << 323 //
438 delete dumpQtyToFileCmd; << 324 delete scoreDir;
439 delete dumpQtyWithFactorCmd; <<
440 delete dumpAllQtsToFileCmd; <<
441 delete dumpAllQtsWithFactorCmd; <<
442 delete fill1DCmd; <<
443 // <<
444 delete scoreDir; <<
445 } 325 }
446 326
447 void G4ScoringMessenger::SetNewValue(G4UIcomma << 327 void G4ScoringMessenger::SetNewValue(G4UIcommand * command,G4String newVal)
448 { 328 {
449 using MeshShape = G4VScoringMesh::MeshShape; << 329 if(command==listCmd) {
450 << 330 fSMan->List();
451 if(command == listCmd) << 331 } else if(command==dumpCmd) {
452 { << 332 fSMan->Dump();
453 fSMan->List(); << 333 } else if(command==drawCmd) {
454 } <<
455 else if(command == dumpCmd) <<
456 { <<
457 fSMan->Dump(); <<
458 } <<
459 else if(command == drawCmd) <<
460 { <<
461 G4Tokenizer next(newVal); <<
462 G4String meshName = next(); <<
463 G4String psName = next(); <<
464 G4String colorMapName = next(); <<
465 G4int axflg = StoI(next()); <<
466 fSMan->DrawMesh(meshName, psName, colorMap <<
467 } <<
468 else if(command == drawColumnCmd) <<
469 { <<
470 G4Tokenizer next(newVal); <<
471 G4String meshName = next(); <<
472 G4String psName = next(); <<
473 G4int iPlane = StoI(next()); <<
474 G4int iColumn = StoI(next()); <<
475 G4String colorMapName = next(); <<
476 fSMan->DrawMesh(meshName, psName, iPlane, <<
477 } <<
478 else if(command == dumpQtyToFileCmd) <<
479 { <<
480 G4Tokenizer next(newVal); <<
481 G4String meshName = next(); <<
482 G4String psName = next(); <<
483 G4String fileName = next(); <<
484 G4String option = next("\n"); <<
485 auto mesh = fSMan->FindMesh(meshNa <<
486 if(mesh == nullptr) <<
487 { <<
488 G4ExceptionDescription ed; <<
489 ed << "Mesh name <" << meshName << "> is <<
490 command->CommandFailed(ed); <<
491 return; <<
492 } <<
493 fSMan->DumpQuantityToFile(meshName, psName <<
494 } <<
495 else if(command == dumpQtyWithFactorCmd) <<
496 { <<
497 G4Tokenizer next(newVal); <<
498 G4String meshName = next(); <<
499 G4String psName = next(); <<
500 G4String fileName = next(); <<
501 G4double fac = StoD(next()); <<
502 G4String option = next("\n"); <<
503 auto mesh = fSMan->FindMesh(meshNa <<
504 if(mesh == nullptr) <<
505 { <<
506 G4ExceptionDescription ed; <<
507 ed << "Mesh name <" << meshName << "> is <<
508 command->CommandFailed(ed); <<
509 return; <<
510 } <<
511 fSMan->SetFactor(fac); <<
512 fSMan->DumpQuantityToFile(meshName, psName <<
513 fSMan->SetFactor(1.0); <<
514 } <<
515 else if(command == dumpAllQtsToFileCmd) <<
516 { <<
517 G4Tokenizer next(newVal); <<
518 G4String meshName = next(); <<
519 G4String fileName = next(); <<
520 G4String option = next("\n"); <<
521 auto mesh = fSMan->FindMesh(meshNa <<
522 if(mesh == nullptr) <<
523 { <<
524 G4ExceptionDescription ed; <<
525 ed << "Mesh name <" << meshName << "> is <<
526 command->CommandFailed(ed); <<
527 return; <<
528 } <<
529 fSMan->DumpAllQuantitiesToFile(meshName, f <<
530 } <<
531 else if(command == dumpAllQtsWithFactorCmd) <<
532 { <<
533 G4Tokenizer next(newVal); <<
534 G4String meshName = next(); <<
535 G4String fileName = next(); <<
536 G4double fac = StoD(next()); <<
537 G4String option = next("\n"); <<
538 auto mesh = fSMan->FindMesh(meshNa <<
539 if(mesh == nullptr) <<
540 { <<
541 G4ExceptionDescription ed; <<
542 ed << "Mesh name <" << meshName << "> is <<
543 command->CommandFailed(ed); <<
544 return; <<
545 } <<
546 fSMan->SetFactor(fac); <<
547 fSMan->DumpAllQuantitiesToFile(meshName, f <<
548 fSMan->SetFactor(1.0); <<
549 } <<
550 else if(command == fill1DCmd) <<
551 { <<
552 Fill1D(command, newVal); <<
553 } <<
554 else if(command == verboseCmd) <<
555 { <<
556 fSMan->SetVerboseLevel(verboseCmd->GetNewI <<
557 } <<
558 else if(command == meshBoxCreateCmd) <<
559 { <<
560 G4VScoringMesh* currentmesh = fSMan->GetCu <<
561 if(currentmesh != nullptr) <<
562 { <<
563 G4ExceptionDescription ed; <<
564 ed << "ERROR[" << meshBoxCreateCmd->GetC <<
565 << currentmesh->GetWorldName() <<
566 << "> is still open. Close it first. <<
567 command->CommandFailed(ed); <<
568 } <<
569 else <<
570 { <<
571 G4VScoringMesh* mesh = fSMan->FindMesh(n <<
572 if(mesh == nullptr) <<
573 { <<
574 mesh = new G4ScoringBox(newVal); <<
575 fSMan->RegisterScoringMesh(mesh); <<
576 } <<
577 else <<
578 { <<
579 G4ExceptionDescription ed; <<
580 ed << "ERROR[" << meshBoxCreateCmd->Ge <<
581 << "] : Scoring mesh <" << newVal <<
582 << "> already exists. Command ignor <<
583 command->CommandFailed(ed); <<
584 } <<
585 } <<
586 } <<
587 else if(command == meshCylinderCreateCmd) <<
588 { <<
589 G4VScoringMesh* currentmesh = fSMan->GetCu <<
590 if(currentmesh != nullptr) <<
591 { <<
592 G4ExceptionDescription ed; <<
593 ed << "ERROR[" << meshCylinderCreateCmd- <<
594 << currentmesh->GetWorldName() <<
595 << "> is still open. Close it first. <<
596 command->CommandFailed(ed); <<
597 } <<
598 else <<
599 { <<
600 G4VScoringMesh* mesh = fSMan->FindMesh(n <<
601 if(mesh == nullptr) <<
602 { <<
603 mesh = new G4ScoringCylinder(newVal); <<
604 fSMan->RegisterScoringMesh(mesh); <<
605 } <<
606 else <<
607 { <<
608 G4ExceptionDescription ed; <<
609 ed << "ERROR[" << meshCylinderCreateCm <<
610 << "] : Scoring mesh <" << newVal <<
611 << "> already exists. Command ignor <<
612 command->CommandFailed(ed); <<
613 } <<
614 } <<
615 } <<
616 else if(command == meshRWLogVolCreateCmd) <<
617 { <<
618 auto mesh = fSMan->GetCurrentMesh(); <<
619 if(mesh != nullptr) <<
620 { <<
621 G4ExceptionDescription ed; <<
622 ed << "ERROR[" << meshRWLogVolCreateCmd- <<
623 << mesh->GetWorldName() <<
624 << "> is still open. Close it first. <<
625 command->CommandFailed(ed); <<
626 } <<
627 else <<
628 { <<
629 G4Tokenizer next(newVal); 334 G4Tokenizer next(newVal);
630 G4String meshName = next(); 335 G4String meshName = next();
631 G4int idx = StoI(next()); << 336 G4String psName = next();
632 mesh = fSMan->FindMesh(mesh << 337 G4String colorMapName = next();
633 if(mesh == nullptr) << 338 G4int axflg = StoI(next());
634 { << 339 fSMan->DrawMesh(meshName,psName,colorMapName,axflg);
635 mesh = new G4ScoringRealWorld(meshName << 340 } else if(command==drawColumnCmd) {
636 mesh->SetCopyNumberLevel(idx); <<
637 fSMan->RegisterScoringMesh(mesh); <<
638 } <<
639 else <<
640 { <<
641 G4ExceptionDescription ed; <<
642 ed << "ERROR[" << meshRWLogVolCreateCm <<
643 << "] : Scoring mesh <" << meshName <<
644 << "> already exists. Command ignor <<
645 command->CommandFailed(ed); <<
646 } <<
647 } <<
648 } <<
649 else if(command == probeCreateCmd) <<
650 { <<
651 auto mesh = fSMan->GetCurrentMesh(); <<
652 if(mesh != nullptr) <<
653 { <<
654 G4ExceptionDescription ed; <<
655 ed << "ERROR[" << meshRWLogVolCreateCmd- <<
656 << mesh->GetWorldName() <<
657 << "> is still open. Close it first. <<
658 command->CommandFailed(ed); <<
659 } <<
660 else <<
661 { <<
662 G4Tokenizer next(newVal); 341 G4Tokenizer next(newVal);
663 G4String qname = next(); << 342 G4String meshName = next();
664 G4double halfSize = StoD(next()); << 343 G4String psName = next();
665 halfSize *= G4UIcommand::ValueOf(next()) << 344 G4int iPlane = StoI(next());
666 G4bool checkOverlap = StoB(next()); << 345 G4int iColumn = StoI(next());
667 mesh = fSMan->FindMesh(qn << 346 G4String colorMapName = next();
668 if(mesh == nullptr) << 347 fSMan->DrawMesh(meshName,psName,iPlane,iColumn,colorMapName);
669 { << 348 } else if(command==chartCmd ){
670 mesh = new G4ScoringProbe(qname, halfS << 349 G4Tokenizer next(newVal);
671 fSMan->RegisterScoringMesh(mesh); << 350 G4String meshName = next();
672 } << 351 G4String psName = next();
673 else << 352 //G4bool onFlag = StoB(next());
674 { << 353 G4String scaleOption = next();
675 G4ExceptionDescription ed; << 354 // fSMan->DrawChart(meshName,psName,onFlag,scaleOption);
676 ed << "ERROR[" << probeCreateCmd->GetC <<
677 << qname << "> already exists. Use <<
678 command->CommandFailed(ed); <<
679 } <<
680 } <<
681 } <<
682 else if(command == probeMatCmd || command == <<
683 { <<
684 auto mesh = fSMan->GetCurrentMesh(); <<
685 if(mesh == nullptr) <<
686 { <<
687 G4ExceptionDescription ed; <<
688 ed << "ERROR : No mesh is currently open <<
689 "Command ignored."; <<
690 command->CommandFailed(ed); <<
691 return; <<
692 } <<
693 if(mesh->GetShape() != MeshShape::probe) <<
694 { <<
695 G4ExceptionDescription ed; <<
696 ed << "ERROR : Inconsistent mesh type. C <<
697 "Scoring Probe."; <<
698 command->CommandFailed(ed); <<
699 return; <<
700 } <<
701 355
702 if(command == probeMatCmd) << 356 } else if(command==dumpQtyToFileCmd) {
703 { << 357 G4Tokenizer next(newVal);
704 G4bool succ = static_cast<G4ScoringProbe << 358 G4String meshName = next();
705 if(!succ) << 359 G4String psName = next();
706 { << 360 G4String fileName = next();
707 G4ExceptionDescription ed; << 361 G4String option = next("\n");
708 ed << "Material <" << newVal << 362 fSMan->DumpQuantityToFile(meshName, psName, fileName, option);
709 << "> is not defind in G4NistManage << 363 } else if(command==dumpAllQtsToFileCmd) {
710 << "Use /material/nist/listMaterial << 364 G4Tokenizer next(newVal);
711 "materials."; << 365 G4String meshName = next();
712 command->CommandFailed(ed); << 366 G4String fileName = next();
713 return; << 367 G4String option = next("\n");
714 } << 368 fSMan->DumpAllQuantitiesToFile(meshName, fileName, option);
715 } << 369 } else if(command==verboseCmd) {
716 else if(command == probeLocateCmd) << 370 fSMan->SetVerboseLevel(verboseCmd->GetNewIntValue(newVal));
717 { << 371 } else if(command==meshBoxCreateCmd) {
718 G4ThreeVector loc = probeLocateCmd->GetN << 372 G4VScoringMesh* currentmesh = fSMan->GetCurrentMesh();
719 static_cast<G4ScoringProbe*>(mesh)->Loca << 373 if ( currentmesh ){
720 } << 374 G4cerr << "ERROR[" << meshBoxCreateCmd->GetCommandPath()
721 } << 375 << "] : Mesh <" << currentmesh->GetWorldName()
722 else if(command == listColorMapCmd) << 376 << "> is still open. Close it first. Command ignored." << G4endl;
723 { << 377 } else {
724 fSMan->ListScoreColorMaps(); << 378
725 } << 379 G4VScoringMesh* mesh = fSMan->FindMesh(newVal);
726 else if(command == floatMinMaxCmd) << 380 if ( !mesh ){
727 { << 381 mesh = new G4ScoringBox(newVal);
728 G4VScoreColorMap* colorMap = fSMan->GetSco << 382 fSMan->RegisterScoringMesh(mesh);
729 if(colorMap != nullptr) << 383 }else{
730 { << 384 G4cerr << "ERROR[" << meshBoxCreateCmd->GetCommandPath()
731 colorMap->SetFloatingMinMax(true); << 385 << "] : Scoring mesh <" << newVal
732 } << 386 << "> already exists. Command ignored." << G4endl;
733 else << 387 }
734 { << 388 }
735 G4ExceptionDescription ed; << 389 } else if(command==meshCylinderCreateCmd) {
736 ed << "ERROR[" << floatMinMaxCmd->GetCom << 390 G4VScoringMesh* currentmesh = fSMan->GetCurrentMesh();
737 << newVal << "> is not defined. Comma << 391 if ( currentmesh ){
738 command->CommandFailed(ed); << 392 G4cerr << "ERROR[" << meshBoxCreateCmd->GetCommandPath()
739 } << 393 << "] : Mesh <" << currentmesh->GetWorldName()
740 } << 394 << "> is still open. Close it first. Command ignored." << G4endl;
741 else if(command == colorMapMinMaxCmd) << 395 } else {
742 { << 396
743 G4Tokenizer next(newVal); << 397 G4VScoringMesh* mesh = fSMan->FindMesh(newVal);
744 G4String mapName = next(); << 398 if ( !mesh ){
745 G4double minVal = StoD(next()); << 399 mesh = new G4ScoringCylinder(newVal);
746 G4double maxVal = StoD(next()); << 400 fSMan->RegisterScoringMesh(mesh);
747 G4VScoreColorMap* colorMap = fSMan->GetSco << 401 }else{
748 if(colorMap != nullptr) << 402 G4cerr << "ERROR[" << meshCylinderCreateCmd->GetCommandPath()
749 { << 403 << "] : Scoring mesh <" << newVal
750 colorMap->SetFloatingMinMax(false); << 404 << "> already exists. Command ignored." << G4endl;
751 colorMap->SetMinMax(minVal, maxVal); << 405 }
752 } << 406 }
753 else << 407 } else if(command==listColorMapCmd) {
754 { << 408 fSMan->ListScoreColorMaps();
755 G4ExceptionDescription ed; << 409 } else if(command==floatMinMaxCmd) {
756 ed << "ERROR[" << colorMapMinMaxCmd->Get << 410 G4VScoreColorMap* colorMap = fSMan->GetScoreColorMap(newVal);
757 << newVal << "> is not defined. Comma << 411 if(colorMap)
758 command->CommandFailed(ed); << 412 { colorMap->SetFloatingMinMax(true); }
759 } <<
760 } <<
761 else if(command == meshOpnCmd) <<
762 { <<
763 G4VScoringMesh* currentmesh = fSMan->GetCu <<
764 if(currentmesh != nullptr) <<
765 { <<
766 G4ExceptionDescription ed; <<
767 ed << "ERROR[" << meshOpnCmd->GetCommand <<
768 << currentmesh->GetWorldName() <<
769 << "> is still open. Close it first. <<
770 command->CommandFailed(ed); <<
771 } <<
772 else <<
773 { <<
774 G4VScoringMesh* mesh = fSMan->FindMesh(n <<
775 if(mesh == nullptr) <<
776 { <<
777 G4ExceptionDescription ed; <<
778 ed << "ERROR[" << meshOpnCmd->GetComma <<
779 << newVal << "> does not exist. Com <<
780 command->CommandFailed(ed); <<
781 } <<
782 else 413 else
783 { << 414 { G4cerr << "ERROR[" << floatMinMaxCmd->GetCommandPath()
784 fSMan->SetCurrentMesh(mesh); << 415 << "] : color map <" << newVal << "> is not defined. Command ignored."
785 } << 416 << G4endl;
786 } <<
787 } <<
788 else if(command == meshClsCmd) <<
789 { <<
790 fSMan->CloseCurrentMesh(); <<
791 } <<
792 else <<
793 { <<
794 // <<
795 // Get Current Mesh <<
796 // <<
797 G4VScoringMesh* mesh = fSMan->GetCurrentMe <<
798 // <<
799 // Commands for Current Mesh <<
800 if(mesh != nullptr) <<
801 { <<
802 MeshShape shape = mesh->GetShape(); <<
803 if(shape == MeshShape::realWorldLogVol) <<
804 { <<
805 G4ExceptionDescription ed; <<
806 ed << "ERROR[" << mBinCmd->GetCommandP <<
807 << "] : Number of mesh command cann <<
808 "Command ignored."; <<
809 command->CommandFailed(ed); <<
810 } 417 }
>> 418 } else if(command==colorMapMinMaxCmd) {
>> 419 G4Tokenizer next(newVal);
>> 420 G4String mapName = next();
>> 421 G4double minVal = StoD(next());
>> 422 G4double maxVal = StoD(next());
>> 423 G4VScoreColorMap* colorMap = fSMan->GetScoreColorMap(mapName);
>> 424 if(colorMap)
>> 425 { colorMap->SetFloatingMinMax(false);
>> 426 colorMap->SetMinMax(minVal,maxVal); }
811 else 427 else
812 { << 428 { G4cerr << "ERROR[" << colorMapMinMaxCmd->GetCommandPath()
813 // Tokens << 429 << "] : color map <" << newVal << "> is not defined. Command ignored."
814 G4TokenVec token; << 430 << G4endl;
815 FillTokenVec(newVal, token); << 431 }
816 // << 432 } else if(command==meshOpnCmd) {
817 // Mesh Geometry << 433 G4VScoringMesh* currentmesh = fSMan->GetCurrentMesh();
818 if(command == mBoxSizeCmd) << 434 if ( currentmesh ){
819 { << 435 G4cerr << "ERROR[" << meshOpnCmd->GetCommandPath()
820 if(shape == MeshShape::box) << 436 << "] : Mesh <" << currentmesh->GetWorldName() << "> is still open. Close it first. Command ignored." << G4endl;
821 { << 437 } else {
822 G4ThreeVector size = mBoxSizeCmd-> << 438 G4VScoringMesh* mesh = fSMan->FindMesh(newVal);
823 G4double vsize[3]; << 439 if ( !mesh ){
824 vsize[0] = size.x(); << 440 G4cerr << "ERROR[" << meshOpnCmd->GetCommandPath()
825 vsize[1] = size.y(); << 441 << "] : Scoring mesh <" << newVal << "> does not exist. Command ignored." << G4endl;
826 vsize[2] = size.z(); << 442 } else {
827 mesh->SetSize(vsize); << 443 fSMan->SetCurrentMesh(mesh);
828 } << 444 }
829 else << 445 }
830 { << 446 } else if(command==meshClsCmd) {
831 G4ExceptionDescription ed; << 447 fSMan->CloseCurrentMesh();
832 ed << "ERROR[" << mBoxSizeCmd->Get << 448 } else {
833 << "] : This mesh is not Box. C << 449 //
834 command->CommandFailed(ed); << 450 // Get Current Mesh
835 } << 451 //
836 } << 452 G4VScoringMesh* mesh = fSMan->GetCurrentMesh();
837 else if(command == mCylinderSizeCmd || << 453 //
838 command == mCylinderAngleCmd) << 454 // Commands for Current Mesh
839 { << 455 if ( mesh ){
840 if(shape != MeshShape::cylinder) << 456 // Tokens
841 { << 457 G4TokenVec token;
842 G4ExceptionDescription ed; << 458 FillTokenVec(newVal,token);
843 ed << "ERROR[" << command->GetComm << 459 //
844 << "] : This mesh is not Cylind << 460 // Mesh Geometry
845 command->CommandFailed(ed); << 461 //
846 } << 462 // if(command==meshActCmd) {
847 else << 463 // mesh->Activate(meshActCmd->GetNewBoolValue(newVal));
848 { << 464 // } else
849 if(command == mCylinderSizeCmd) << 465 if(command==mBoxSizeCmd) {
850 { << 466 MeshShape shape = mesh->GetShape();
851 G4double vsize[3]; << 467 if ( shape == boxMesh ){
852 vsize[0] = (mesh->GetSize()) << 468 G4ThreeVector size = mBoxSizeCmd->GetNew3VectorValue(newVal);
853 vsize[1] = StoD(token[0]); << 469 G4double vsize[3];
854 vsize[2] = StoD(token[1]); << 470 vsize[0] = size.x();
855 G4double unt = mCylinderSizeCmd- << 471 vsize[1] = size.y();
856 vsize[1] *= unt; << 472 vsize[2] = size.z();
857 vsize[2] *= unt; << 473 mesh->SetSize(vsize);
858 mesh->SetSize(vsize); << 474 } else {
859 } << 475 G4cerr << "ERROR[" << mBoxSizeCmd->GetCommandPath()
860 else if(command == mCylinderRMinCm << 476 << "] : This mesh is not Box. Command ignored." << G4endl;
861 { << 477 }
862 G4double vsize[3]; << 478 }else if(command==mCylinderSizeCmd) {
863 vsize[0] = mCylinderRMinCmd->Get << 479 MeshShape shape = mesh->GetShape();
864 vsize[1] = (mesh->GetSize()).y() << 480 if ( shape == cylinderMesh ){
865 vsize[2] = (mesh->GetSize()).z() << 481 G4double vsize[3];
866 mesh->SetSize(vsize); << 482 vsize[0] = StoD(token[0]);
867 } << 483 vsize[1] = StoD(token[1]);
868 else if(command == mCylinderAngleC << 484 G4double unt = mCylinderSizeCmd->ValueOf(token[2]);
869 { << 485 vsize[0] *= unt;
870 G4double stphi = StoD(token[0]); << 486 vsize[1] *= unt;
871 G4double spphi = StoD(token[1]); << 487 vsize[2] = 0.0;
872 G4double unt = mCylinderAngleC << 488 mesh->SetSize(vsize);
873 mesh->SetAngles(stphi * unt, spp << 489 } else {
874 } << 490 G4cerr << "ERROR[" << mBoxSizeCmd->GetCommandPath()
875 } << 491 << "] : This mesh is not Box. Command ignored." << G4endl;
876 } << 492 }
877 else if(command == mBinCmd) << 493 } else if(command==mBinCmd) {
878 { << 494 MeshBinCommand(mesh,token);
879 MeshBinCommand(mesh, token); << 495 } else if(command==mTResetCmd) {
880 } << 496 G4double centerPosition[3] ={ 0., 0., 0.};
881 else if(command == mTResetCmd) << 497 mesh->SetCenterPosition(centerPosition);
882 { << 498 } else if(command==mTXyzCmd) {
883 G4double centerPosition[3] = { 0., 0 << 499 G4ThreeVector xyz = mTXyzCmd->GetNew3VectorValue(newVal);
884 mesh->SetCenterPosition(centerPositi << 500 G4double centerPosition[3];
885 } << 501 centerPosition[0] = xyz.x();
886 else if(command == mTXyzCmd) << 502 centerPosition[1] = xyz.y();
887 { << 503 centerPosition[2] = xyz.z();
888 G4ThreeVector xyz = mTXyzCmd->GetNew << 504 mesh->SetCenterPosition(centerPosition);
889 G4double centerPosition[3]; << 505 } else if(command==mRResetCmd) {
890 centerPosition[0] = xyz.x(); << 506 } else if(command==mRotXCmd) {
891 centerPosition[1] = xyz.y(); << 507 G4double value = mRotXCmd->GetNewDoubleValue(newVal);
892 centerPosition[2] = xyz.z(); << 508 mesh->RotateX(value);
893 mesh->SetCenterPosition(centerPositi << 509 } else if(command==mRotYCmd) {
894 } << 510 G4double value = mRotYCmd->GetNewDoubleValue(newVal);
895 else if(command == mRotXCmd) << 511 mesh->RotateY(value);
896 { << 512 } else if(command==mRotZCmd) {
897 G4double value = mRotXCmd->GetNewDou << 513 G4double value = mRotZCmd->GetNewDoubleValue(newVal);
898 mesh->RotateX(value); << 514 mesh->RotateZ(value);
899 } << 515 }
900 else if(command == mRotYCmd) << 516 }else{
901 { << 517 G4cerr << "ERROR: No mesh is currently open. Open/create a mesh first. Command ignored." << G4endl;
902 G4double value = mRotYCmd->GetNewDou <<
903 mesh->RotateY(value); <<
904 } <<
905 else if(command == mRotZCmd) <<
906 { <<
907 G4double value = mRotZCmd->GetNewDou <<
908 mesh->RotateZ(value); <<
909 } <<
910 } 518 }
911 } <<
912 else <<
913 { <<
914 G4ExceptionDescription ed; <<
915 ed << "ERROR: No mesh is currently open. <<
916 "Command ignored."; <<
917 command->CommandFailed(ed); <<
918 } <<
919 } 519 }
920 } 520 }
921 521
922 G4String G4ScoringMessenger::GetCurrentValue(G << 522 G4String G4ScoringMessenger::GetCurrentValue(G4UIcommand * command)
923 { 523 {
924 G4String val; 524 G4String val;
925 if(command == verboseCmd) << 525 if(command==verboseCmd)
926 { << 526 { val = verboseCmd->ConvertToString(fSMan->GetVerboseLevel()); }
927 val = verboseCmd->ConvertToString(fSMan->G <<
928 } <<
929 527
930 return val; 528 return val;
931 } 529 }
932 530
933 void G4ScoringMessenger::FillTokenVec(const G4 << 531 void G4ScoringMessenger::FillTokenVec(G4String newValues, G4TokenVec& token){
934 { <<
935 G4Tokenizer next(newValues); <<
936 G4String val; <<
937 while(!(val = next()).empty()) <<
938 { // Loop checking 12.18.2015 M.Asai <<
939 token.push_back(val); <<
940 } <<
941 } <<
942 532
943 void G4ScoringMessenger::MeshBinCommand(G4VSco << 533 G4Tokenizer next(newValues);
944 { << 534 G4String val;
945 G4int Ni = StoI(token[0]); << 535 while ( !(val = next()).isNull() ) {
946 G4int Nj = StoI(token[1]); << 536 token.push_back(val);
947 G4int Nk = StoI(token[2]); << 537 }
948 G4int nSegment[3]; <<
949 <<
950 if(dynamic_cast<G4ScoringBox*>(mesh) != null <<
951 { <<
952 G4cout << ".... G4ScoringMessenger::MeshBi <<
953 << G4endl; <<
954 nSegment[0] = Ni; <<
955 nSegment[1] = Nj; <<
956 nSegment[2] = Nk; <<
957 } <<
958 else if(dynamic_cast<G4ScoringCylinder*>(mes <<
959 { <<
960 G4cout << ".... G4ScoringMessenger::MeshBi <<
961 << G4endl; <<
962 nSegment[0] = Nj; <<
963 nSegment[1] = Nk; <<
964 nSegment[2] = Ni; <<
965 } <<
966 else <<
967 { <<
968 G4Exception("G4ScoringMessenger::MeshBinCo <<
969 "invalid mesh type"); <<
970 return; <<
971 } <<
972 // <<
973 mesh->SetNumberOfSegments(nSegment); <<
974 } 538 }
975 539
976 void G4ScoringMessenger::Fill1D(G4UIcommand* c <<
977 { <<
978 using MeshShape = G4VScoringMesh::MeshShape; <<
979 <<
980 G4Tokenizer next(newVal); <<
981 G4int histID = StoI(next()); <<
982 G4String meshName = next(); <<
983 G4String primName = next(); <<
984 G4int copyNo = StoI(next()); <<
985 <<
986 auto filler = G4VScoreHistFiller::Instance() <<
987 if(filler == nullptr) <<
988 { <<
989 G4ExceptionDescription ed; <<
990 ed << "G4TScoreHistFiller is not instantia <<
991 cmd->CommandFailed(ed); <<
992 return; <<
993 } <<
994 // <<
995 // To do : check the validity of histID <<
996 // <<
997 <<
998 auto sm = G4ScoringManager::GetScoringMana <<
999 auto mesh = sm->FindMesh(meshName); <<
1000 if(mesh == nullptr) <<
1001 { <<
1002 G4ExceptionDescription ed; <<
1003 ed << "Mesh name <" << meshName << "> is <<
1004 cmd->CommandFailed(ed); <<
1005 return; <<
1006 } <<
1007 auto shape = mesh->GetShape(); <<
1008 if(shape != MeshShape::realWorldLogVol && s <<
1009 { <<
1010 G4ExceptionDescription ed; <<
1011 ed << "Mesh <" << meshName <<
1012 << "> is not real-world logical volume <<
1013 cmd->CommandFailed(ed); <<
1014 return; <<
1015 } <<
1016 <<
1017 auto prim = mesh->GetPrimitiveScorer(primNa <<
1018 if(prim == nullptr) <<
1019 { <<
1020 G4ExceptionDescription ed; <<
1021 ed << "Primitive scorer name <" << primNa <<
1022 cmd->CommandFailed(ed); <<
1023 return; <<
1024 } <<
1025 auto pp = dynamic_cast<G4VPrimitivePlotter* <<
1026 if(pp == nullptr) <<
1027 { <<
1028 G4ExceptionDescription ed; <<
1029 ed << "Primitive scorer <" << primName <<
1030 << "> does not support direct histogra <<
1031 cmd->CommandFailed(ed); <<
1032 return; <<
1033 } <<
1034 540
1035 pp->Plot(copyNo, histID); << 541 void G4ScoringMessenger::MeshBinCommand(G4VScoringMesh* mesh,G4TokenVec& token){
>> 542 G4int Ni = StoI(token[0]);
>> 543 G4int Nj = StoI(token[1]);
>> 544 G4int Nk = StoI(token[2]);
>> 545 G4int nSegment[3];
>> 546
>> 547 if(dynamic_cast<G4ScoringBox*>(mesh)) {
>> 548 G4cout << ".... G4ScoringMessenger::MeshBinCommand - G4ScoringBox" << G4endl;
>> 549 nSegment[0] = Ni;
>> 550 nSegment[1] = Nj;
>> 551 nSegment[2] = Nk;
>> 552 } else if(dynamic_cast<G4ScoringCylinder*>(mesh)) {
>> 553 G4cout << ".... G4ScoringMessenger::MeshBinCommand - G4ScoringCylinder" << G4endl;
>> 554 nSegment[0] = Nj;
>> 555 nSegment[1] = Nk;
>> 556 nSegment[2] = Ni;
>> 557 } else {
>> 558 G4Exception("G4ScoringMessenger::MeshBinCommand()", "001", FatalException, "invalid mesh type");
>> 559 return;
>> 560 }
>> 561 //
>> 562 mesh->SetNumberOfSegments(nSegment);
1036 } 563 }
>> 564
>> 565
1037 566