| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
5 // * The Geant4 software is copyright of th
6 // * the Geant4 Collaboration. It is provided
7 // * conditions of the Geant4 Software License
8 // * LICENSE and available at http://cern.ch/
9 // * include a list of copyright holders.
10 // *
11 // * Neither the authors of this software syst
12 // * institutes,nor the agencies providing fin
13 // * work make any representation or warran
14 // * regarding this software system or assum
15 // * use. Please see the license in the file
16 // * for the full disclaimer and the limitatio
17 // *
18 // * This code implementation is the result
19 // * technical work of the GEANT4 collaboratio
20 // * By using, copying, modifying or distri
21 // * any work based on the software) you ag
22 // * use in resulting scientific publicati
23 // * acceptance of all terms of the Geant4 Sof
24 // *******************************************
25 //
26 // G4ScoringMessenger
27 // -------------------------------------------
28
29 #include "G4ScoringMessenger.hh"
30 #include "G4ScoringManager.hh"
31 #include "G4VScoringMesh.hh"
32 #include "G4ScoringBox.hh"
33 #include "G4ScoringCylinder.hh"
34 #include "G4ScoringRealWorld.hh"
35 #include "G4ScoringProbe.hh"
36
37 #include "G4UIdirectory.hh"
38 #include "G4UIcmdWithoutParameter.hh"
39 #include "G4UIcmdWithAnInteger.hh"
40 #include "G4UIcmdWithAString.hh"
41 #include "G4UIcmdWithABool.hh"
42 #include "G4UIcmdWithADoubleAndUnit.hh"
43 #include "G4UIcmdWith3VectorAndUnit.hh"
44 #include "G4UIcommand.hh"
45 #include "G4UIparameter.hh"
46 #include "G4Tokenizer.hh"
47 #include "G4UnitsTable.hh"
48 #include "G4VScoreColorMap.hh"
49
50 #include "G4VPrimitivePlotter.hh"
51 #include "G4VScoreHistFiller.hh"
52
53 G4ScoringMessenger::G4ScoringMessenger(G4Scori
54 : fSMan(SManager)
55 {
56 G4UIparameter* param = nullptr;
57
58 scoreDir = new G4UIdirectory("/score/");
59 scoreDir->SetGuidance("Interactive scoring c
60
61 listCmd = new G4UIcmdWithoutParameter("/scor
62 listCmd->SetGuidance("List scoring worlds.")
63
64 dumpCmd = new G4UIcmdWithoutParameter("/scor
65 dumpCmd->SetGuidance("Dump results of scorer
66
67 verboseCmd = new G4UIcmdWithAnInteger("/scor
68 verboseCmd->SetGuidance("Verbosity.");
69 verboseCmd->SetGuidance(" 0) errors or warn
70 verboseCmd->SetGuidance(" 1) information wi
71
72 meshCreateDir = new G4UIdirectory("/score/cr
73 meshCreateDir->SetGuidance(" Mesh creation
74 //
75 // Mesh commands
76 meshBoxCreateCmd = new G4UIcmdWithAString("/
77 meshBoxCreateCmd->SetGuidance("Create scorin
78 meshBoxCreateCmd->SetParameterName("MeshName
79 //
80 meshCylinderCreateCmd =
81 new G4UIcmdWithAString("/score/create/cyli
82 meshCylinderCreateCmd->SetGuidance("Create s
83 meshCylinderCreateCmd->SetParameterName("Mes
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 //
119 meshOpnCmd = new G4UIcmdWithAString("/score/
120 meshOpnCmd->SetGuidance("Open scoring mesh."
121 meshOpnCmd->SetParameterName("MeshName", fal
122 //
123 meshClsCmd = new G4UIcmdWithoutParameter("/s
124 meshClsCmd->SetGuidance("Close scoring mesh.
125
126 meshDir = new G4UIdirectory("/score/mesh/");
127 meshDir->SetGuidance(" Mesh processing co
128 //
129 mBoxSizeCmd = new G4UIcmdWith3VectorAndUnit(
130 mBoxSizeCmd->SetGuidance("Define size of the
131 mBoxSizeCmd->SetGuidance("Dx Dy Dz unit")
132 mBoxSizeCmd->SetParameterName("Di", "Dj", "D
133 mBoxSizeCmd->SetRange("Di>0. && Dj>0. && Dk>
134 mBoxSizeCmd->SetDefaultUnit("mm");
135 //
136 mCylinderSizeCmd = new G4UIcommand("/score/m
137 mCylinderSizeCmd->SetGuidance("Define size o
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
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
172 mBinCmd = new G4UIcommand("/score/mesh/nBin"
173 mBinCmd->SetGuidance("Define segments of the
174 mBinCmd->SetGuidance("[usage] /score/mesh/nB
175 mBinCmd->SetGuidance(" In case of boxMesh, p
176 mBinCmd->SetGuidance(" Ni :(int) Number o
177 mBinCmd->SetGuidance(" Nj :(int) Number o
178 mBinCmd->SetGuidance(" Nk :(int) Number o
179 mBinCmd->SetGuidance(" In case of cylinderMe
180 mBinCmd->SetGuidance(" Nr :(int) Number o
181 mBinCmd->SetGuidance(" Nz :(int) Number o
182 mBinCmd->SetGuidance(" Nphi:(int) Number o
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/t
199 mTransDir->SetGuidance("Mesh translation com
200 //
201 mTResetCmd = new G4UIcmdWithoutParameter("/s
202 mTResetCmd->SetGuidance("Reset translated po
203 //
204 mTXyzCmd = new G4UIcmdWith3VectorAndUnit("/s
205 mTXyzCmd->SetGuidance("Translate the scoring
206 mTXyzCmd->SetParameterName("X", "Y", "Z", fa
207 mTXyzCmd->SetDefaultUnit("mm");
208 //
209 mRotDir = new G4UIdirectory("/score/mesh/rot
210 mRotDir->SetGuidance("Mesh rotation commands
211
212 mRotXCmd = new G4UIcmdWithADoubleAndUnit("/s
213 mRotXCmd->SetGuidance("Rotate the scoring me
214 mRotXCmd->SetParameterName("Rx", false);
215 mRotXCmd->SetDefaultUnit("deg");
216 //
217 mRotYCmd = new G4UIcmdWithADoubleAndUnit("/s
218 mRotYCmd->SetGuidance("Rotate the scoring me
219 mRotYCmd->SetParameterName("Ry", false);
220 mRotYCmd->SetDefaultUnit("deg");
221 //
222 mRotZCmd = new G4UIcmdWithADoubleAndUnit("/s
223 mRotZCmd->SetGuidance("Rotate the scoring me
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
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
248 // Draw Scoring result
249 drawCmd = new G4UIcommand("/score/drawProjec
250 drawCmd->SetGuidance("Draw projection(s) of
251 drawCmd->SetGuidance(
252 "Parameter <proj> specified which projecti
253 drawCmd->SetGuidance(
254 " 100 : xy-plane, 010 : yz-plane, 001
255 drawCmd->SetGuidance(
256 " 100 : N/A, 010 : z_phi-plane, 001
257 param = new G4UIparameter("meshName", 's', f
258 drawCmd->SetParameter(param);
259 param = new G4UIparameter("psName", 's', fal
260 drawCmd->SetParameter(param);
261 param = new G4UIparameter("colorMapName", 's
262 param->SetDefaultValue("defaultLinearColorMa
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/draw
271 drawColumnCmd->SetGuidance("Draw a cell colu
272 drawColumnCmd->SetGuidance(" plane = 0 : x-y
273 drawColumnCmd->SetGuidance(
274 " 0 : z-phi, 1: r-phi, 2: r-z for
275 param = new G4UIparameter("meshName", 's', f
276 drawColumnCmd->SetParameter(param);
277 param = new G4UIparameter("psName", 's', fal
278 drawColumnCmd->SetParameter(param);
279 param = new G4UIparameter("plane", 'i', fals
280 param->SetParameterRange("plane>=0 && plane<
281 drawColumnCmd->SetParameter(param);
282 param = new G4UIparameter("column", 'i', fal
283 drawColumnCmd->SetParameter(param);
284 param = new G4UIparameter("colorMapName", 's
285 param->SetDefaultValue("defaultLinearColorMa
286 drawColumnCmd->SetParameter(param);
287 drawColumnCmd->SetToBeBroadcasted(false);
288
289 colorMapDir = new G4UIdirectory("/score/colo
290 colorMapDir->SetGuidance("Color map commands
291
292 listColorMapCmd =
293 new G4UIcmdWithoutParameter("/score/colorM
294 listColorMapCmd->SetGuidance("List registere
295 listColorMapCmd->SetToBeBroadcasted(false);
296
297 floatMinMaxCmd = new G4UIcmdWithAString("/sc
298 floatMinMaxCmd->SetGuidance(
299 "Min/Max of the color map is calculated ac
300 floatMinMaxCmd->SetParameterName("colorMapNa
301 floatMinMaxCmd->SetDefaultValue("defaultLine
302 floatMinMaxCmd->SetToBeBroadcasted(false);
303
304 colorMapMinMaxCmd = new G4UIcommand("/score/
305 colorMapMinMaxCmd->SetGuidance("Define min/m
306 param = new G4UIparameter("colorMapMame", 's
307 param->SetDefaultValue("defaultLinearColorMa
308 colorMapMinMaxCmd->SetParameter(param);
309 param = new G4UIparameter("minValue", 'd', f
310 colorMapMinMaxCmd->SetParameter(param);
311 param = new G4UIparameter("maxValue", 'd', f
312 colorMapMinMaxCmd->SetParameter(param);
313 colorMapMinMaxCmd->SetToBeBroadcasted(false)
314
315 // Dump a scored quantity
316 dumpQtyToFileCmd = new G4UIcommand("/score/d
317 dumpQtyToFileCmd->SetGuidance("Dump one scor
318 param = new G4UIparameter("meshName", 's', f
319 dumpQtyToFileCmd->SetParameter(param);
320 param = new G4UIparameter("psName", 's', fal
321 dumpQtyToFileCmd->SetParameter(param);
322 param = new G4UIparameter("fileName", 's', f
323 dumpQtyToFileCmd->SetParameter(param);
324 param = new G4UIparameter("option", 's', tru
325 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
345 // Dump all scored quantities
346 dumpAllQtsToFileCmd = new G4UIcommand("/scor
347 dumpAllQtsToFileCmd->SetGuidance("Dump all q
348 param = new G4UIparameter("meshName", 's', f
349 dumpAllQtsToFileCmd->SetParameter(param);
350 param = new G4UIparameter("fileName", 's', f
351 dumpAllQtsToFileCmd->SetParameter(param);
352 param = new G4UIparameter("option", 's', tru
353 dumpAllQtsToFileCmd->SetParameter(param);
354 dumpAllQtsToFileCmd->SetToBeBroadcasted(fals
355
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 }
395
396 G4ScoringMessenger::~G4ScoringMessenger()
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 }
446
447 void G4ScoringMessenger::SetNewValue(G4UIcomma
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, 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);
630 G4String meshName = next();
631 G4int idx = StoI(next());
632 mesh = fSMan->FindMesh(mesh
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[" << 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);
663 G4String qname = next();
664 G4double halfSize = StoD(next());
665 halfSize *= G4UIcommand::ValueOf(next())
666 G4bool checkOverlap = StoB(next());
667 mesh = fSMan->FindMesh(qn
668 if(mesh == nullptr)
669 {
670 mesh = new G4ScoringProbe(qname, halfS
671 fSMan->RegisterScoringMesh(mesh);
672 }
673 else
674 {
675 G4ExceptionDescription ed;
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
702 if(command == probeMatCmd)
703 {
704 G4bool succ = static_cast<G4ScoringProbe
705 if(!succ)
706 {
707 G4ExceptionDescription ed;
708 ed << "Material <" << newVal
709 << "> is not defind in G4NistManage
710 << "Use /material/nist/listMaterial
711 "materials.";
712 command->CommandFailed(ed);
713 return;
714 }
715 }
716 else if(command == probeLocateCmd)
717 {
718 G4ThreeVector loc = probeLocateCmd->GetN
719 static_cast<G4ScoringProbe*>(mesh)->Loca
720 }
721 }
722 else if(command == listColorMapCmd)
723 {
724 fSMan->ListScoreColorMaps();
725 }
726 else if(command == floatMinMaxCmd)
727 {
728 G4VScoreColorMap* colorMap = fSMan->GetSco
729 if(colorMap != nullptr)
730 {
731 colorMap->SetFloatingMinMax(true);
732 }
733 else
734 {
735 G4ExceptionDescription ed;
736 ed << "ERROR[" << floatMinMaxCmd->GetCom
737 << newVal << "> is not defined. Comma
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->GetSco
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->Get
757 << newVal << "> is not defined. Comma
758 command->CommandFailed(ed);
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
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->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 }
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->
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->Get
833 << "] : This mesh is not Box. C
834 command->CommandFailed(ed);
835 }
836 }
837 else if(command == mCylinderSizeCmd ||
838 command == mCylinderAngleCmd)
839 {
840 if(shape != MeshShape::cylinder)
841 {
842 G4ExceptionDescription ed;
843 ed << "ERROR[" << command->GetComm
844 << "] : This mesh is not Cylind
845 command->CommandFailed(ed);
846 }
847 else
848 {
849 if(command == mCylinderSizeCmd)
850 {
851 G4double vsize[3];
852 vsize[0] = (mesh->GetSize())
853 vsize[1] = StoD(token[0]);
854 vsize[2] = StoD(token[1]);
855 G4double unt = mCylinderSizeCmd-
856 vsize[1] *= unt;
857 vsize[2] *= unt;
858 mesh->SetSize(vsize);
859 }
860 else if(command == mCylinderRMinCm
861 {
862 G4double vsize[3];
863 vsize[0] = mCylinderRMinCmd->Get
864 vsize[1] = (mesh->GetSize()).y()
865 vsize[2] = (mesh->GetSize()).z()
866 mesh->SetSize(vsize);
867 }
868 else if(command == mCylinderAngleC
869 {
870 G4double stphi = StoD(token[0]);
871 G4double spphi = StoD(token[1]);
872 G4double unt = mCylinderAngleC
873 mesh->SetAngles(stphi * unt, spp
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
884 mesh->SetCenterPosition(centerPositi
885 }
886 else if(command == mTXyzCmd)
887 {
888 G4ThreeVector xyz = mTXyzCmd->GetNew
889 G4double centerPosition[3];
890 centerPosition[0] = xyz.x();
891 centerPosition[1] = xyz.y();
892 centerPosition[2] = xyz.z();
893 mesh->SetCenterPosition(centerPositi
894 }
895 else if(command == mRotXCmd)
896 {
897 G4double value = mRotXCmd->GetNewDou
898 mesh->RotateX(value);
899 }
900 else if(command == mRotYCmd)
901 {
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 }
911 }
912 else
913 {
914 G4ExceptionDescription ed;
915 ed << "ERROR: No mesh is currently open.
916 "Command ignored.";
917 command->CommandFailed(ed);
918 }
919 }
920 }
921
922 G4String G4ScoringMessenger::GetCurrentValue(G
923 {
924 G4String val;
925 if(command == verboseCmd)
926 {
927 val = verboseCmd->ConvertToString(fSMan->G
928 }
929
930 return val;
931 }
932
933 void G4ScoringMessenger::FillTokenVec(const G4
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
943 void G4ScoringMessenger::MeshBinCommand(G4VSco
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) != 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 }
975
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
1035 pp->Plot(copyNo, histID);
1036 }
1037