Geant4 11.3.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Member Functions | Protected Member Functions | List of all members
G4ScoringMessenger Class Reference

#include <G4ScoringMessenger.hh>

+ Inheritance diagram for G4ScoringMessenger:

Public Member Functions

 G4ScoringMessenger (G4ScoringManager *SManager)
 
 ~G4ScoringMessenger () override
 
void SetNewValue (G4UIcommand *command, G4String newValues) override
 
G4String GetCurrentValue (G4UIcommand *command) override
 
- Public Member Functions inherited from G4UImessenger
 G4UImessenger ()=default
 
 G4UImessenger (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
 
virtual ~G4UImessenger ()
 
G4bool CommandsShouldBeInMaster () const
 

Protected Member Functions

void FillTokenVec (const G4String &newValues, G4TokenVec &token)
 
void MeshBinCommand (G4VScoringMesh *mesh, G4TokenVec &token)
 
void Fill1D (G4UIcommand *cmd, const G4String &newValues)
 
- Protected Member Functions inherited from G4UImessenger
G4String ItoS (G4int i)
 
G4String LtoS (G4long l)
 
G4String DtoS (G4double a)
 
G4String BtoS (G4bool b)
 
G4int StoI (const G4String &s)
 
G4long StoL (const G4String &s)
 
G4double StoD (const G4String &s)
 
G4bool StoB (const G4String &s)
 
void AddUIcommand (G4UIcommand *newCommand)
 
void CreateDirectory (const G4String &path, const G4String &dsc, G4bool commandsToBeBroadcasted=true)
 
template<typename T>
T * CreateCommand (const G4String &cname, const G4String &dsc)
 

Additional Inherited Members

- Protected Attributes inherited from G4UImessenger
G4UIdirectory * baseDir = nullptr
 
G4String baseDirName = ""
 
G4bool commandsShouldBeInMaster = false
 

Detailed Description

Definition at line 56 of file G4ScoringMessenger.hh.

Constructor & Destructor Documentation

◆ G4ScoringMessenger()

G4ScoringMessenger::G4ScoringMessenger ( G4ScoringManager * SManager)

Definition at line 53 of file G4ScoringMessenger.cc.

54 : fSMan(SManager)
55{
56 G4UIparameter* param = nullptr;
57
58 scoreDir = new G4UIdirectory("/score/");
59 scoreDir->SetGuidance("Interactive scoring commands.");
60
61 listCmd = new G4UIcmdWithoutParameter("/score/list", this);
62 listCmd->SetGuidance("List scoring worlds.");
63
64 dumpCmd = new G4UIcmdWithoutParameter("/score/dump", this);
65 dumpCmd->SetGuidance("Dump results of scorers.");
66
67 verboseCmd = new G4UIcmdWithAnInteger("/score/verbose", this);
68 verboseCmd->SetGuidance("Verbosity.");
69 verboseCmd->SetGuidance(" 0) errors or warnings,");
70 verboseCmd->SetGuidance(" 1) information with 0)");
71
72 meshCreateDir = new G4UIdirectory("/score/create/");
73 meshCreateDir->SetGuidance(" Mesh creation commands.");
74 //
75 // Mesh commands
76 meshBoxCreateCmd = new G4UIcmdWithAString("/score/create/boxMesh", this);
77 meshBoxCreateCmd->SetGuidance("Create scoring box mesh.");
78 meshBoxCreateCmd->SetParameterName("MeshName", false);
79 //
80 meshCylinderCreateCmd =
81 new G4UIcmdWithAString("/score/create/cylinderMesh", this);
82 meshCylinderCreateCmd->SetGuidance("Create scoring mesh.");
83 meshCylinderCreateCmd->SetParameterName("MeshName", false);
84
85 meshRWLogVolCreateCmd =
86 new G4UIcommand("/score/create/realWorldLogVol", this);
87 meshRWLogVolCreateCmd->SetGuidance(
88 "Define scorers to a logical volume defined in the real world.");
89 meshRWLogVolCreateCmd->SetGuidance(
90 " - Name of the specified logical volume is used as the mesh name.");
91 meshRWLogVolCreateCmd->SetGuidance(
92 " - /score/mesh commands do not affect for this mesh.");
93 meshRWLogVolCreateCmd->SetGuidance(
94 " - If copyNumberLevel is set, the copy number of that-level higher");
95 meshRWLogVolCreateCmd->SetGuidance(
96 " in the geometrical hierarchy is used as the index.");
97 param = new G4UIparameter("logVol", 's', false);
98 meshRWLogVolCreateCmd->SetParameter(param);
99 param = new G4UIparameter("copyNumberLevel", 'i', true);
100 param->SetParameterRange("copyNumberLevel>=0");
101 param->SetDefaultValue(0);
102 meshRWLogVolCreateCmd->SetParameter(param);
103 //
104 probeCreateCmd = new G4UIcommand("/score/create/probe", this);
105 probeCreateCmd->SetGuidance("Define scoring probe.");
106 probeCreateCmd->SetGuidance(
107 " halfSize defines the half-width of the probing cube.");
108 param = new G4UIparameter("pname", 's', false);
109 probeCreateCmd->SetParameter(param);
110 param = new G4UIparameter("halfSize", 'd', false);
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', true);
116 param->SetDefaultValue(0);
117 probeCreateCmd->SetParameter(param);
118 //
119 meshOpnCmd = new G4UIcmdWithAString("/score/open", this);
120 meshOpnCmd->SetGuidance("Open scoring mesh.");
121 meshOpnCmd->SetParameterName("MeshName", false);
122 //
123 meshClsCmd = new G4UIcmdWithoutParameter("/score/close", this);
124 meshClsCmd->SetGuidance("Close scoring mesh.");
125
126 meshDir = new G4UIdirectory("/score/mesh/");
127 meshDir->SetGuidance(" Mesh processing commands.");
128 //
129 mBoxSizeCmd = new G4UIcmdWith3VectorAndUnit("/score/mesh/boxSize", this);
130 mBoxSizeCmd->SetGuidance("Define size of the scoring mesh.");
131 mBoxSizeCmd->SetGuidance("Dx Dy Dz unit");
132 mBoxSizeCmd->SetParameterName("Di", "Dj", "Dk", false, false);
133 mBoxSizeCmd->SetRange("Di>0. && Dj>0. && Dk>0.");
134 mBoxSizeCmd->SetDefaultUnit("mm");
135 //
136 mCylinderSizeCmd = new G4UIcommand("/score/mesh/cylinderSize", this);
137 mCylinderSizeCmd->SetGuidance("Define size of the scoring mesh.");
138 mCylinderSizeCmd->SetGuidance("R Dz unit");
139 param = new G4UIparameter("R", 'd', false);
140 param->SetParameterRange("R>0");
141 mCylinderSizeCmd->SetParameter(param);
142 param = new G4UIparameter("Dz", 'd', false);
143 param->SetParameterRange("Dz>0");
144 mCylinderSizeCmd->SetParameter(param);
145 param = new G4UIparameter("unit", 's', true);
146 param->SetDefaultUnit("mm");
147 mCylinderSizeCmd->SetParameter(param);
148 //
149 mCylinderRMinCmd =
150 new G4UIcmdWithADoubleAndUnit("/score/mesh/cylinderRMin", this);
151 mCylinderRMinCmd->SetGuidance("Define the inner radius of the tube mesh.");
152 mCylinderRMinCmd->SetGuidance("This command is not needed for cylinder mesh");
153 mCylinderRMinCmd->SetParameterName("RMin", false, false);
154 mCylinderRMinCmd->SetRange("RMin>=0.");
155 mCylinderRMinCmd->SetDefaultUnit("mm");
156 //
157 mCylinderAngleCmd = new G4UIcommand("/score/mesh/cylinderAngles", this);
158 mCylinderAngleCmd->SetGuidance(
159 "Define starting angle and span for tube segment mesh.");
160 mCylinderAngleCmd->SetGuidance(
161 "This command is not needed for cylinder mesh");
162 param = new G4UIparameter("startPhi", 'd', false);
163 mCylinderAngleCmd->SetParameter(param);
164 param = new G4UIparameter("deltaPhi", 'd', false);
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
172 mBinCmd = new G4UIcommand("/score/mesh/nBin", this);
173 mBinCmd->SetGuidance("Define segments of the scoring mesh.");
174 mBinCmd->SetGuidance("[usage] /score/mesh/nBin");
175 mBinCmd->SetGuidance(" In case of boxMesh, parameters are given in");
176 mBinCmd->SetGuidance(" Ni :(int) Number of bins i (in x-axis) ");
177 mBinCmd->SetGuidance(" Nj :(int) Number of bins j (in y-axis) ");
178 mBinCmd->SetGuidance(" Nk :(int) Number of bins k (in z-axis) ");
179 mBinCmd->SetGuidance(" In case of cylinderMesh, parameters are given in");
180 mBinCmd->SetGuidance(" Nr :(int) Number of bins in radial axis ");
181 mBinCmd->SetGuidance(" Nz :(int) Number of bins in z axis ");
182 mBinCmd->SetGuidance(" Nphi:(int) Number of bins in phi axis ");
183
184 param = new G4UIparameter("Ni", 'i', false);
185 param->SetDefaultValue("1");
186 param->SetParameterRange("Ni>0");
187 mBinCmd->SetParameter(param);
188 param = new G4UIparameter("Nj", 'i', false);
189 param->SetDefaultValue("1");
190 param->SetParameterRange("Nj>0");
191 mBinCmd->SetParameter(param);
192 param = new G4UIparameter("Nk", 'i', false);
193 param->SetDefaultValue("1");
194 mBinCmd->SetParameter(param);
195 param->SetParameterRange("Nk>0");
196
197 // Placement command
198 mTransDir = new G4UIdirectory("/score/mesh/translate/");
199 mTransDir->SetGuidance("Mesh translation commands.");
200 //
201 mTResetCmd = new G4UIcmdWithoutParameter("/score/mesh/translate/reset", this);
202 mTResetCmd->SetGuidance("Reset translated position of the scoring mesh.");
203 //
204 mTXyzCmd = new G4UIcmdWith3VectorAndUnit("/score/mesh/translate/xyz", this);
205 mTXyzCmd->SetGuidance("Translate the scoring mesh.");
206 mTXyzCmd->SetParameterName("X", "Y", "Z", false, false);
207 mTXyzCmd->SetDefaultUnit("mm");
208 //
209 mRotDir = new G4UIdirectory("/score/mesh/rotate/");
210 mRotDir->SetGuidance("Mesh rotation commands.");
211
212 mRotXCmd = new G4UIcmdWithADoubleAndUnit("/score/mesh/rotate/rotateX", this);
213 mRotXCmd->SetGuidance("Rotate the scoring mesh in X axis.");
214 mRotXCmd->SetParameterName("Rx", false);
215 mRotXCmd->SetDefaultUnit("deg");
216 //
217 mRotYCmd = new G4UIcmdWithADoubleAndUnit("/score/mesh/rotate/rotateY", this);
218 mRotYCmd->SetGuidance("Rotate the scoring mesh in Y axis.");
219 mRotYCmd->SetParameterName("Ry", false);
220 mRotYCmd->SetDefaultUnit("deg");
221 //
222 mRotZCmd = new G4UIcmdWithADoubleAndUnit("/score/mesh/rotate/rotateZ", this);
223 mRotZCmd->SetGuidance("Rotate the scoring mesh in Z axis.");
224 mRotZCmd->SetParameterName("Rz", false);
225 mRotZCmd->SetDefaultUnit("deg");
226 //
227 probeDir = new G4UIdirectory("/score/probe/");
228 probeDir->SetGuidance("Probe commands");
229
230 probeMatCmd = new G4UIcmdWithAString("/score/probe/material", this);
231 probeMatCmd->SetGuidance("Specify a material to the probe cube.");
232 probeMatCmd->SetGuidance("Material name has to be taken from G4NistManager.");
233 probeMatCmd->SetGuidance("Once this command is used, the specified material "
234 "overlays the material in the mass geometry");
235 probeMatCmd->SetGuidance("with \"Layered Mass Geometry\" mechanism so that "
236 "physics quantities such as energy deposition");
237 probeMatCmd->SetGuidance("or dose will be calculated with this material.");
238 probeMatCmd->SetGuidance("To switch-off this overlaying, use \"none\".");
239 probeMatCmd->SetParameterName("matName", true);
240 probeMatCmd->SetDefaultValue("none");
241
242 probeLocateCmd = new G4UIcmdWith3VectorAndUnit("/score/probe/locate", this);
243 probeLocateCmd->SetGuidance(
244 "Locate a probe in the global coordinate system.");
245 probeLocateCmd->SetParameterName("x", "y", "z", false);
246 probeLocateCmd->SetDefaultUnit("mm");
247
248 // Draw Scoring result
249 drawCmd = new G4UIcommand("/score/drawProjection", this);
250 drawCmd->SetGuidance("Draw projection(s) of scored quantities.");
251 drawCmd->SetGuidance(
252 "Parameter <proj> specified which projection(s) to be drawn.");
253 drawCmd->SetGuidance(
254 " 100 : xy-plane, 010 : yz-plane, 001 : zx-plane -- default 111");
255 drawCmd->SetGuidance(
256 " 100 : N/A, 010 : z_phi-plane, 001 : r_phi-plane -- default 111");
257 param = new G4UIparameter("meshName", 's', false);
258 drawCmd->SetParameter(param);
259 param = new G4UIparameter("psName", 's', false);
260 drawCmd->SetParameter(param);
261 param = new G4UIparameter("colorMapName", 's', true);
262 param->SetDefaultValue("defaultLinearColorMap");
263 drawCmd->SetParameter(param);
264 param = new G4UIparameter("proj", 'i', true);
265 param->SetDefaultValue(111);
266 drawCmd->SetParameter(param);
267 drawCmd->SetToBeBroadcasted(false);
268
269 // Draw column
270 drawColumnCmd = new G4UIcommand("/score/drawColumn", this);
271 drawColumnCmd->SetGuidance("Draw a cell column.");
272 drawColumnCmd->SetGuidance(" plane = 0 : x-y, 1: y-z, 2: z-x for box mesh");
273 drawColumnCmd->SetGuidance(
274 " 0 : z-phi, 1: r-phi, 2: r-z for cylinder mesh");
275 param = new G4UIparameter("meshName", 's', false);
276 drawColumnCmd->SetParameter(param);
277 param = new G4UIparameter("psName", 's', false);
278 drawColumnCmd->SetParameter(param);
279 param = new G4UIparameter("plane", 'i', false);
280 param->SetParameterRange("plane>=0 && plane<=2");
281 drawColumnCmd->SetParameter(param);
282 param = new G4UIparameter("column", 'i', false);
283 drawColumnCmd->SetParameter(param);
284 param = new G4UIparameter("colorMapName", 's', true);
285 param->SetDefaultValue("defaultLinearColorMap");
286 drawColumnCmd->SetParameter(param);
287 drawColumnCmd->SetToBeBroadcasted(false);
288
289 colorMapDir = new G4UIdirectory("/score/colorMap/");
290 colorMapDir->SetGuidance("Color map commands.");
291
292 listColorMapCmd =
293 new G4UIcmdWithoutParameter("/score/colorMap/listScoreColorMaps", this);
294 listColorMapCmd->SetGuidance("List registered score color maps.");
295 listColorMapCmd->SetToBeBroadcasted(false);
296
297 floatMinMaxCmd = new G4UIcmdWithAString("/score/colorMap/floatMinMax", this);
298 floatMinMaxCmd->SetGuidance(
299 "Min/Max of the color map is calculated according to the actual scores.");
300 floatMinMaxCmd->SetParameterName("colorMapName", true, false);
301 floatMinMaxCmd->SetDefaultValue("defaultLinearColorMap");
302 floatMinMaxCmd->SetToBeBroadcasted(false);
303
304 colorMapMinMaxCmd = new G4UIcommand("/score/colorMap/setMinMax", this);
305 colorMapMinMaxCmd->SetGuidance("Define min/max value of the color map.");
306 param = new G4UIparameter("colorMapMame", 's', true);
307 param->SetDefaultValue("defaultLinearColorMap");
308 colorMapMinMaxCmd->SetParameter(param);
309 param = new G4UIparameter("minValue", 'd', false);
310 colorMapMinMaxCmd->SetParameter(param);
311 param = new G4UIparameter("maxValue", 'd', false);
312 colorMapMinMaxCmd->SetParameter(param);
313 colorMapMinMaxCmd->SetToBeBroadcasted(false);
314
315 // Dump a scored quantity
316 dumpQtyToFileCmd = new G4UIcommand("/score/dumpQuantityToFile", this);
317 dumpQtyToFileCmd->SetGuidance("Dump one scored quantity to file.");
318 param = new G4UIparameter("meshName", 's', false);
319 dumpQtyToFileCmd->SetParameter(param);
320 param = new G4UIparameter("psName", 's', false);
321 dumpQtyToFileCmd->SetParameter(param);
322 param = new G4UIparameter("fileName", 's', false);
323 dumpQtyToFileCmd->SetParameter(param);
324 param = new G4UIparameter("option", 's', true);
325 dumpQtyToFileCmd->SetParameter(param);
326 dumpQtyToFileCmd->SetToBeBroadcasted(false);
327
328 dumpQtyWithFactorCmd = new G4UIcommand("/score/dumpQuantityWithFactor", this);
329 dumpQtyWithFactorCmd->SetGuidance("Dump one scored quantity to file.");
330 dumpQtyWithFactorCmd->SetGuidance(
331 "Each value is multiplied by the specified factor.");
332 param = new G4UIparameter("meshName", 's', false);
333 dumpQtyWithFactorCmd->SetParameter(param);
334 param = new G4UIparameter("psName", 's', false);
335 dumpQtyWithFactorCmd->SetParameter(param);
336 param = new G4UIparameter("fileName", 's', false);
337 dumpQtyWithFactorCmd->SetParameter(param);
338 param = new G4UIparameter("factor", 'd', false);
339 param->SetParameterRange("factor>0.");
340 dumpQtyWithFactorCmd->SetParameter(param);
341 param = new G4UIparameter("option", 's', true);
342 dumpQtyWithFactorCmd->SetParameter(param);
343 dumpQtyWithFactorCmd->SetToBeBroadcasted(false);
344
345 // Dump all scored quantities
346 dumpAllQtsToFileCmd = new G4UIcommand("/score/dumpAllQuantitiesToFile", this);
347 dumpAllQtsToFileCmd->SetGuidance("Dump all quantities of the mesh to file.");
348 param = new G4UIparameter("meshName", 's', false);
349 dumpAllQtsToFileCmd->SetParameter(param);
350 param = new G4UIparameter("fileName", 's', false);
351 dumpAllQtsToFileCmd->SetParameter(param);
352 param = new G4UIparameter("option", 's', true);
353 dumpAllQtsToFileCmd->SetParameter(param);
354 dumpAllQtsToFileCmd->SetToBeBroadcasted(false);
355
356 dumpAllQtsWithFactorCmd =
357 new G4UIcommand("/score/dumpAllQuantitiesWithFactor", this);
358 dumpAllQtsWithFactorCmd->SetGuidance(
359 "Dump all quantities of the mesh to file.");
360 dumpAllQtsWithFactorCmd->SetGuidance(
361 "Each value is multiplied by the specified factor.");
362 param = new G4UIparameter("meshName", 's', false);
363 dumpAllQtsWithFactorCmd->SetParameter(param);
364 param = new G4UIparameter("fileName", 's', false);
365 dumpAllQtsWithFactorCmd->SetParameter(param);
366 param = new G4UIparameter("factor", 'd', false);
367 param->SetParameterRange("factor>0.");
368 dumpAllQtsWithFactorCmd->SetParameter(param);
369 param = new G4UIparameter("option", 's', true);
370 dumpAllQtsWithFactorCmd->SetParameter(param);
371 dumpAllQtsWithFactorCmd->SetToBeBroadcasted(false);
372
373 fill1DCmd = new G4UIcommand("/score/fill1D", this);
374 fill1DCmd->SetGuidance("Let a primitive scorer fill 1-D histogram");
375 fill1DCmd->SetGuidance("Before using this command, primitive scorer must be "
376 "defined and assigned.");
377 fill1DCmd->SetGuidance("Also before using this command, a histogram has to "
378 "be defined by /analysis/h1/create command.");
379 fill1DCmd->SetGuidance(
380 "This command is available only for real-world volume or probe.");
381 fill1DCmd->SetGuidance("Please note that this command has to be applied to "
382 "each copy number of the scoring volume.");
383 fill1DCmd->SetGuidance("If same histogram ID is used more than once, more "
384 "than one scorers fill that histogram.");
385 param = new G4UIparameter("histID", 'i', false);
386 fill1DCmd->SetParameter(param);
387 param = new G4UIparameter("meshName", 's', false);
388 fill1DCmd->SetParameter(param);
389 param = new G4UIparameter("scorerName", 's', false);
390 fill1DCmd->SetParameter(param);
391 param = new G4UIparameter("copyNo", 'i', true);
392 param->SetDefaultValue(0);
393 fill1DCmd->SetParameter(param);
394}
G4UIparameter::SetDefaultValue
void SetDefaultValue(const char *theDefaultValue)
Definition G4UIparameter.hh:68
G4UIparameter::SetParameterRange
void SetParameterRange(const char *theRange)
Definition G4UIparameter.hh:86
G4UIparameter::SetDefaultUnit
void SetDefaultUnit(const char *theDefaultUnit)
Definition G4UIparameter.cc:103

◆ ~G4ScoringMessenger()

G4ScoringMessenger::~G4ScoringMessenger ( )
override

Definition at line 396 of file G4ScoringMessenger.cc.

397{
398 delete listCmd;
399 delete verboseCmd;
400 //
401 delete meshBoxCreateCmd;
402 delete meshCylinderCreateCmd;
403 delete meshRWLogVolCreateCmd;
404 delete probeCreateCmd;
405 delete meshCreateDir;
406 //
407 delete meshOpnCmd;
408 //
409 delete meshClsCmd;
410 delete meshDir;
411 //
412 delete mBoxSizeCmd;
413 delete mCylinderSizeCmd;
414 delete mCylinderRMinCmd;
415 delete mCylinderAngleCmd;
416 //
417 delete mBinCmd;
418 //
419 delete mTResetCmd;
420 delete mTXyzCmd;
421 delete mTransDir;
422 delete mRotXCmd;
423 delete mRotYCmd;
424 delete mRotZCmd;
425 delete mRotDir;
426 //
427 delete probeLocateCmd;
428 delete probeMatCmd;
429 delete probeDir;
430 //
431 delete dumpCmd;
432 delete drawCmd;
433 delete drawColumnCmd;
434 delete listColorMapCmd;
435 delete floatMinMaxCmd;
436 delete colorMapMinMaxCmd;
437 delete colorMapDir;
438 delete dumpQtyToFileCmd;
439 delete dumpQtyWithFactorCmd;
440 delete dumpAllQtsToFileCmd;
441 delete dumpAllQtsWithFactorCmd;
442 delete fill1DCmd;
443 //
444 delete scoreDir;
445}

Member Function Documentation

◆ Fill1D()

void G4ScoringMessenger::Fill1D ( G4UIcommand * cmd,
const G4String & newValues )
protected

Definition at line 976 of file G4ScoringMessenger.cc.

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 instantiated in this application.";
991 cmd->CommandFailed(ed);
992 return;
993 }
994 //
995 // To do : check the validity of histID
996 //
997
998 auto sm = G4ScoringManager::GetScoringManagerIfExist();
999 auto mesh = sm->FindMesh(meshName);
1000 if(mesh == nullptr)
1001 {
1002 G4ExceptionDescription ed;
1003 ed << "Mesh name <" << meshName << "> is not found.";
1004 cmd->CommandFailed(ed);
1005 return;
1006 }
1007 auto shape = mesh->GetShape();
1008 if(shape != MeshShape::realWorldLogVol && shape != MeshShape::probe)
1009 {
1010 G4ExceptionDescription ed;
1011 ed << "Mesh <" << meshName
1012 << "> is not real-world logical volume or probe.";
1013 cmd->CommandFailed(ed);
1014 return;
1015 }
1016
1017 auto prim = mesh->GetPrimitiveScorer(primName);
1018 if(prim == nullptr)
1019 {
1020 G4ExceptionDescription ed;
1021 ed << "Primitive scorer name <" << primName << "> is not found.";
1022 cmd->CommandFailed(ed);
1023 return;
1024 }
1025 auto pp = dynamic_cast<G4VPrimitivePlotter*>(prim);
1026 if(pp == nullptr)
1027 {
1028 G4ExceptionDescription ed;
1029 ed << "Primitive scorer <" << primName
1030 << "> does not support direct histogram filling.";
1031 cmd->CommandFailed(ed);
1032 return;
1033 }
1034
1035 pp->Plot(copyNo, histID);
1036}
G4ExceptionDescription
std::ostringstream G4ExceptionDescription
Definition G4Exception.hh:40
G4int
int G4int
Definition G4Types.hh:85
G4ScoringManager::GetScoringManagerIfExist
static G4ScoringManager * GetScoringManagerIfExist()
Definition G4ScoringManager.cc:51
G4UIcommand::CommandFailed
void CommandFailed(G4int errCode, G4ExceptionDescription &ed)
Definition G4UIcommand.hh:159
G4UImessenger::StoI
G4int StoI(const G4String &s)
Definition G4UImessenger.cc:96
G4VScoreHistFiller::Instance
static G4VScoreHistFiller * Instance()
Definition G4VScoreHistFiller.cc:43

Referenced by SetNewValue().

◆ FillTokenVec()

void G4ScoringMessenger::FillTokenVec ( const G4String & newValues,
G4TokenVec & token )
protected

Definition at line 933 of file G4ScoringMessenger.cc.

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}

Referenced by SetNewValue().

◆ GetCurrentValue()

G4String G4ScoringMessenger::GetCurrentValue ( G4UIcommand * command)
overridevirtual

Reimplemented from G4UImessenger.

Definition at line 922 of file G4ScoringMessenger.cc.

923{
924 G4String val;
925 if(command == verboseCmd)
926 {
927 val = verboseCmd->ConvertToString(fSMan->GetVerboseLevel());
928 }
929
930 return val;
931}

◆ MeshBinCommand()

void G4ScoringMessenger::MeshBinCommand ( G4VScoringMesh * mesh,
G4TokenVec & token )
protected

Definition at line 943 of file G4ScoringMessenger.cc.

944{
945 G4int Ni = StoI(token[0]);
946 G4int Nj = StoI(token[1]);
947 G4int Nk = StoI(token[2]);
948 G4int nSegment[3];
949
950 if(dynamic_cast<G4ScoringBox*>(mesh) != nullptr)
951 {
952 G4cout << ".... G4ScoringMessenger::MeshBinCommand - G4ScoringBox"
953 << G4endl;
954 nSegment[0] = Ni;
955 nSegment[1] = Nj;
956 nSegment[2] = Nk;
957 }
958 else if(dynamic_cast<G4ScoringCylinder*>(mesh) != nullptr)
959 {
960 G4cout << ".... G4ScoringMessenger::MeshBinCommand - G4ScoringCylinder"
961 << G4endl;
962 nSegment[0] = Nj;
963 nSegment[1] = Nk;
964 nSegment[2] = Ni;
965 }
966 else
967 {
968 G4Exception("G4ScoringMessenger::MeshBinCommand()", "001", FatalException,
969 "invalid mesh type");
970 return;
971 }
972 //
973 mesh->SetNumberOfSegments(nSegment);
974}
FatalException
@ FatalException
Definition G4ExceptionSeverity.hh:67
G4Exception
void G4Exception(const char *originOfException, const char *exceptionCode, G4ExceptionSeverity severity, const char *description)
Definition G4Exception.cc:59
G4endl
#define G4endl
Definition G4ios.hh:67
G4cout
G4GLOB_DLL std::ostream G4cout
G4VScoringMesh::SetNumberOfSegments
void SetNumberOfSegments(G4int nSegment[3])
Definition G4VScoringMesh.cc:116

Referenced by SetNewValue().

◆ SetNewValue()

void G4ScoringMessenger::SetNewValue ( G4UIcommand * command,
G4String newValues )
overridevirtual

Reimplemented from G4UImessenger.

Definition at line 447 of file G4ScoringMessenger.cc.

448{
449 using MeshShape = G4VScoringMesh::MeshShape;
450
451 if(command == listCmd)
452 {
453 fSMan->List();
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, colorMapName, axflg);
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, iColumn, colorMapName);
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(meshName);
486 if(mesh == nullptr)
487 {
488 G4ExceptionDescription ed;
489 ed << "Mesh name <" << meshName << "> is not found. Command ignored.";
490 command->CommandFailed(ed);
491 return;
492 }
493 fSMan->DumpQuantityToFile(meshName, psName, fileName, option);
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(meshName);
504 if(mesh == nullptr)
505 {
506 G4ExceptionDescription ed;
507 ed << "Mesh name <" << meshName << "> is not found. Command ignored.";
508 command->CommandFailed(ed);
509 return;
510 }
511 fSMan->SetFactor(fac);
512 fSMan->DumpQuantityToFile(meshName, psName, fileName, option);
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(meshName);
522 if(mesh == nullptr)
523 {
524 G4ExceptionDescription ed;
525 ed << "Mesh name <" << meshName << "> is not found. Command ignored.";
526 command->CommandFailed(ed);
527 return;
528 }
529 fSMan->DumpAllQuantitiesToFile(meshName, fileName, option);
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(meshName);
539 if(mesh == nullptr)
540 {
541 G4ExceptionDescription ed;
542 ed << "Mesh name <" << meshName << "> is not found. Command ignored.";
543 command->CommandFailed(ed);
544 return;
545 }
546 fSMan->SetFactor(fac);
547 fSMan->DumpAllQuantitiesToFile(meshName, fileName, option);
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->GetNewIntValue(newVal));
557 }
558 else if(command == meshBoxCreateCmd)
559 {
560 G4VScoringMesh* currentmesh = fSMan->GetCurrentMesh();
561 if(currentmesh != nullptr)
562 {
563 G4ExceptionDescription ed;
564 ed << "ERROR[" << meshBoxCreateCmd->GetCommandPath() << "] : Mesh <"
565 << currentmesh->GetWorldName()
566 << "> is still open. Close it first. Command ignored.";
567 command->CommandFailed(ed);
568 }
569 else
570 {
571 G4VScoringMesh* mesh = fSMan->FindMesh(newVal);
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->GetCommandPath()
581 << "] : Scoring mesh <" << newVal
582 << "> already exists. Command ignored.";
583 command->CommandFailed(ed);
584 }
585 }
586 }
587 else if(command == meshCylinderCreateCmd)
588 {
589 G4VScoringMesh* currentmesh = fSMan->GetCurrentMesh();
590 if(currentmesh != nullptr)
591 {
592 G4ExceptionDescription ed;
593 ed << "ERROR[" << meshCylinderCreateCmd->GetCommandPath() << "] : Mesh <"
594 << currentmesh->GetWorldName()
595 << "> is still open. Close it first. Command ignored.";
596 command->CommandFailed(ed);
597 }
598 else
599 {
600 G4VScoringMesh* mesh = fSMan->FindMesh(newVal);
601 if(mesh == nullptr)
602 {
603 mesh = new G4ScoringCylinder(newVal);
604 fSMan->RegisterScoringMesh(mesh);
605 }
606 else
607 {
608 G4ExceptionDescription ed;
609 ed << "ERROR[" << meshCylinderCreateCmd->GetCommandPath()
610 << "] : Scoring mesh <" << newVal
611 << "> already exists. Command ignored.";
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->GetCommandPath() << "] : Mesh <"
623 << mesh->GetWorldName()
624 << "> is still open. Close it first. Command ignored.";
625 command->CommandFailed(ed);
626 }
627 else
628 {
629 G4Tokenizer next(newVal);
630 G4String meshName = next();
631 G4int idx = StoI(next());
632 mesh = fSMan->FindMesh(meshName);
633 if(mesh == nullptr)
634 {
635 mesh = new G4ScoringRealWorld(meshName);
636 mesh->SetCopyNumberLevel(idx);
637 fSMan->RegisterScoringMesh(mesh);
638 }
639 else
640 {
641 G4ExceptionDescription ed;
642 ed << "ERROR[" << meshRWLogVolCreateCmd->GetCommandPath()
643 << "] : Scoring mesh <" << meshName
644 << "> already exists. Command ignored.";
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->GetCommandPath() << "] : Mesh <"
656 << mesh->GetWorldName()
657 << "> is still open. Close it first. Command ignored.";
658 command->CommandFailed(ed);
659 }
660 else
661 {
662 G4Tokenizer next(newVal);
663 G4String qname = next();
664 G4double halfSize = StoD(next());
665 halfSize *= G4UIcommand::ValueOf(next());
666 G4bool checkOverlap = StoB(next());
667 mesh = fSMan->FindMesh(qname);
668 if(mesh == nullptr)
669 {
670 mesh = new G4ScoringProbe(qname, halfSize, checkOverlap);
671 fSMan->RegisterScoringMesh(mesh);
672 }
673 else
674 {
675 G4ExceptionDescription ed;
676 ed << "ERROR[" << probeCreateCmd->GetCommandPath() << "] : Mesh name <"
677 << qname << "> already exists. Use another name.";
678 command->CommandFailed(ed);
679 }
680 }
681 }
682 else if(command == probeMatCmd || command == probeLocateCmd)
683 {
684 auto mesh = fSMan->GetCurrentMesh();
685 if(mesh == nullptr)
686 {
687 G4ExceptionDescription ed;
688 ed << "ERROR : No mesh is currently open. Open/create a mesh first. "
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. Close current mesh and open "
697 "Scoring Probe.";
698 command->CommandFailed(ed);
699 return;
700 }
701
702 if(command == probeMatCmd)
703 {
704 G4bool succ = static_cast<G4ScoringProbe*>(mesh)->SetMaterial(newVal);
705 if(!succ)
706 {
707 G4ExceptionDescription ed;
708 ed << "Material <" << newVal
709 << "> is not defind in G4NistManager. Command is ignored.\n"
710 << "Use /material/nist/listMaterials command to see the available "
711 "materials.";
712 command->CommandFailed(ed);
713 return;
714 }
715 }
716 else if(command == probeLocateCmd)
717 {
718 G4ThreeVector loc = probeLocateCmd->GetNew3VectorValue(newVal);
719 static_cast<G4ScoringProbe*>(mesh)->LocateProbe(loc);
720 }
721 }
722 else if(command == listColorMapCmd)
723 {
724 fSMan->ListScoreColorMaps();
725 }
726 else if(command == floatMinMaxCmd)
727 {
728 G4VScoreColorMap* colorMap = fSMan->GetScoreColorMap(newVal);
729 if(colorMap != nullptr)
730 {
731 colorMap->SetFloatingMinMax(true);
732 }
733 else
734 {
735 G4ExceptionDescription ed;
736 ed << "ERROR[" << floatMinMaxCmd->GetCommandPath() << "] : color map <"
737 << newVal << "> is not defined. Command ignored.";
738 command->CommandFailed(ed);
739 }
740 }
741 else if(command == colorMapMinMaxCmd)
742 {
743 G4Tokenizer next(newVal);
744 G4String mapName = next();
745 G4double minVal = StoD(next());
746 G4double maxVal = StoD(next());
747 G4VScoreColorMap* colorMap = fSMan->GetScoreColorMap(mapName);
748 if(colorMap != nullptr)
749 {
750 colorMap->SetFloatingMinMax(false);
751 colorMap->SetMinMax(minVal, maxVal);
752 }
753 else
754 {
755 G4ExceptionDescription ed;
756 ed << "ERROR[" << colorMapMinMaxCmd->GetCommandPath() << "] : color map <"
757 << newVal << "> is not defined. Command ignored." << G4endl;
758 command->CommandFailed(ed);
759 }
760 }
761 else if(command == meshOpnCmd)
762 {
763 G4VScoringMesh* currentmesh = fSMan->GetCurrentMesh();
764 if(currentmesh != nullptr)
765 {
766 G4ExceptionDescription ed;
767 ed << "ERROR[" << meshOpnCmd->GetCommandPath() << "] : Mesh <"
768 << currentmesh->GetWorldName()
769 << "> is still open. Close it first. Command ignored.";
770 command->CommandFailed(ed);
771 }
772 else
773 {
774 G4VScoringMesh* mesh = fSMan->FindMesh(newVal);
775 if(mesh == nullptr)
776 {
777 G4ExceptionDescription ed;
778 ed << "ERROR[" << meshOpnCmd->GetCommandPath() << "] : Scoring mesh <"
779 << newVal << "> does not exist. Command ignored.";
780 command->CommandFailed(ed);
781 }
782 else
783 {
784 fSMan->SetCurrentMesh(mesh);
785 }
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->GetCurrentMesh();
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->GetCommandPath()
807 << "] : Number of mesh command cannot be set for this type of mesh. "
808 "Command ignored.";
809 command->CommandFailed(ed);
810 }
811 else
812 {
813 // Tokens
814 G4TokenVec token;
815 FillTokenVec(newVal, token);
816 //
817 // Mesh Geometry
818 if(command == mBoxSizeCmd)
819 {
820 if(shape == MeshShape::box)
821 {
822 G4ThreeVector size = mBoxSizeCmd->GetNew3VectorValue(newVal);
823 G4double vsize[3];
824 vsize[0] = size.x();
825 vsize[1] = size.y();
826 vsize[2] = size.z();
827 mesh->SetSize(vsize);
828 }
829 else
830 {
831 G4ExceptionDescription ed;
832 ed << "ERROR[" << mBoxSizeCmd->GetCommandPath()
833 << "] : This mesh is not Box. Command ignored.";
834 command->CommandFailed(ed);
835 }
836 }
837 else if(command == mCylinderSizeCmd || command == mCylinderRMinCmd ||
838 command == mCylinderAngleCmd)
839 {
840 if(shape != MeshShape::cylinder)
841 {
842 G4ExceptionDescription ed;
843 ed << "ERROR[" << command->GetCommandPath()
844 << "] : This mesh is not Cylinder. Command ignored.";
845 command->CommandFailed(ed);
846 }
847 else
848 {
849 if(command == mCylinderSizeCmd)
850 {
851 G4double vsize[3];
852 vsize[0] = (mesh->GetSize()).x();
853 vsize[1] = StoD(token[0]);
854 vsize[2] = StoD(token[1]);
855 G4double unt = mCylinderSizeCmd->ValueOf(token[2]);
856 vsize[1] *= unt;
857 vsize[2] *= unt;
858 mesh->SetSize(vsize);
859 }
860 else if(command == mCylinderRMinCmd)
861 {
862 G4double vsize[3];
863 vsize[0] = mCylinderRMinCmd->GetNewDoubleValue(newVal);
864 vsize[1] = (mesh->GetSize()).y();
865 vsize[2] = (mesh->GetSize()).z();
866 mesh->SetSize(vsize);
867 }
868 else if(command == mCylinderAngleCmd)
869 {
870 G4double stphi = StoD(token[0]);
871 G4double spphi = StoD(token[1]);
872 G4double unt = mCylinderAngleCmd->ValueOf(token[2]);
873 mesh->SetAngles(stphi * unt, spphi * unt);
874 }
875 }
876 }
877 else if(command == mBinCmd)
878 {
879 MeshBinCommand(mesh, token);
880 }
881 else if(command == mTResetCmd)
882 {
883 G4double centerPosition[3] = { 0., 0., 0. };
884 mesh->SetCenterPosition(centerPosition);
885 }
886 else if(command == mTXyzCmd)
887 {
888 G4ThreeVector xyz = mTXyzCmd->GetNew3VectorValue(newVal);
889 G4double centerPosition[3];
890 centerPosition[0] = xyz.x();
891 centerPosition[1] = xyz.y();
892 centerPosition[2] = xyz.z();
893 mesh->SetCenterPosition(centerPosition);
894 }
895 else if(command == mRotXCmd)
896 {
897 G4double value = mRotXCmd->GetNewDoubleValue(newVal);
898 mesh->RotateX(value);
899 }
900 else if(command == mRotYCmd)
901 {
902 G4double value = mRotYCmd->GetNewDoubleValue(newVal);
903 mesh->RotateY(value);
904 }
905 else if(command == mRotZCmd)
906 {
907 G4double value = mRotZCmd->GetNewDoubleValue(newVal);
908 mesh->RotateZ(value);
909 }
910 }
911 }
912 else
913 {
914 G4ExceptionDescription ed;
915 ed << "ERROR: No mesh is currently open. Open/create a mesh first. "
916 "Command ignored.";
917 command->CommandFailed(ed);
918 }
919 }
920}
G4TokenVec
std::vector< G4String > G4TokenVec
Definition G4ScoringMessenger.hh:54
G4ThreeVector
CLHEP::Hep3Vector G4ThreeVector
Definition G4ThreeVector.hh:36
G4double
double G4double
Definition G4Types.hh:83
G4bool
bool G4bool
Definition G4Types.hh:86
CLHEP::Hep3Vector::z
double z() const
CLHEP::Hep3Vector::x
double x() const
CLHEP::Hep3Vector::y
double y() const
G4ScoringMessenger::MeshBinCommand
void MeshBinCommand(G4VScoringMesh *mesh, G4TokenVec &token)
Definition G4ScoringMessenger.cc:943
G4ScoringMessenger::FillTokenVec
void FillTokenVec(const G4String &newValues, G4TokenVec &token)
Definition G4ScoringMessenger.cc:933
G4ScoringMessenger::Fill1D
void Fill1D(G4UIcommand *cmd, const G4String &newValues)
Definition G4ScoringMessenger.cc:976
G4UIcommand::ValueOf
static G4double ValueOf(const char *unitName)
Definition G4UIcommand.cc:282
G4UIcommand::GetCommandPath
const G4String & GetCommandPath() const
Definition G4UIcommand.hh:125
G4UImessenger::StoB
G4bool StoB(const G4String &s)
Definition G4UImessenger.cc:114
G4UImessenger::StoD
G4double StoD(const G4String &s)
Definition G4UImessenger.cc:108
G4VScoreColorMap::SetMinMax
void SetMinMax(G4double minVal, G4double maxVal)
Definition G4VScoreColorMap.hh:49
G4VScoreColorMap::SetFloatingMinMax
void SetFloatingMinMax(G4bool vl=true)
Definition G4VScoreColorMap.hh:47
G4VScoringMesh::GetSize
G4ThreeVector GetSize() const
Definition G4VScoringMesh.cc:97
G4VScoringMesh::GetShape
MeshShape GetShape() const
Definition G4VScoringMesh.hh:91
G4VScoringMesh::RotateY
void RotateY(G4double delta)
Definition G4VScoringMesh.cc:147
G4VScoringMesh::SetAngles
void SetAngles(G4double, G4double)
Definition G4VScoringMesh.cc:104
G4VScoringMesh::GetWorldName
const G4String & GetWorldName() const
Definition G4VScoringMesh.hh:85
G4VScoringMesh::SetCenterPosition
void SetCenterPosition(G4double centerPosition[3])
Definition G4VScoringMesh.cc:110
G4VScoringMesh::SetCopyNumberLevel
void SetCopyNumberLevel(G4int val)
Definition G4VScoringMesh.hh:213
G4VScoringMesh::RotateX
void RotateX(G4double delta)
Definition G4VScoringMesh.cc:140
G4VScoringMesh::SetSize
void SetSize(G4double size[3])
Definition G4VScoringMesh.cc:78
G4VScoringMesh::RotateZ
void RotateZ(G4double delta)
Definition G4VScoringMesh.cc:154
The documentation for this class was generated from the following files: