| 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 // G4ScoreQuantityMessenger
27 //
28 // -------------------------------------------
29 // Modifications
30 // 08-Oct-2010 T.Aso Remove unit of G4PSPassa
31 // 24-Mar-2011 T.Aso Add StepChecker for debu
32 // 24-Mar-2011 T.Aso Size and segmentation fo
33 // 01-Jun-2012 T.Aso Support weighted/divided
34 // in flatCurrent and flatF
35 // 27-Mar-2013 T.Aso Unit option in the kinet
36 // -------------------------------------------
37
38 #include "G4ScoreQuantityMessenger.hh"
39 #include "G4ScoringManager.hh"
40 #include "G4VScoringMesh.hh"
41 #include "G4VPrimitiveScorer.hh"
42
43 #include "G4PSCellCharge3D.hh"
44 #include "G4PSCellFlux3D.hh"
45 #include "G4PSCellFluxForCylinder3D.hh"
46 #include "G4PSPassageCellFlux3D.hh"
47 #include "G4PSPassageCellFluxForCylinder3D.hh"
48 #include "G4PSEnergyDeposit3D.hh"
49 #include "G4PSDoseDeposit3D.hh"
50 #include "G4PSDoseDepositForCylinder3D.hh"
51 #include "G4PSNofStep3D.hh"
52 #include "G4PSNofSecondary3D.hh"
53 //
54 #include "G4PSTrackLength3D.hh"
55 #include "G4PSPassageCellCurrent3D.hh"
56 #include "G4PSPassageTrackLength3D.hh"
57 #include "G4PSFlatSurfaceCurrent3D.hh"
58 #include "G4PSFlatSurfaceFlux3D.hh"
59 #include "G4PSSphereSurfaceCurrent3D.hh"
60 #include "G4PSSphereSurfaceFlux3D.hh"
61 #include "G4PSCylinderSurfaceCurrent3D.hh"
62 #include "G4PSCylinderSurfaceFlux3D.hh"
63 #include "G4PSVolumeFlux3D.hh"
64 #include "G4PSNofCollision3D.hh"
65 #include "G4PSPopulation3D.hh"
66 #include "G4PSTrackCounter3D.hh"
67 #include "G4PSTermination3D.hh"
68 #include "G4PSMinKinEAtGeneration3D.hh"
69
70 #include "G4PSCellCharge.hh"
71 #include "G4PSCellFlux.hh"
72 #include "G4PSPassageCellFlux.hh"
73 #include "G4PSEnergyDeposit.hh"
74 #include "G4PSDoseDeposit.hh"
75 #include "G4PSNofStep.hh"
76 #include "G4PSNofSecondary.hh"
77 //
78 #include "G4PSTrackLength.hh"
79 #include "G4PSPassageCellCurrent.hh"
80 #include "G4PSPassageTrackLength.hh"
81 #include "G4PSFlatSurfaceCurrent.hh"
82 #include "G4PSFlatSurfaceFlux.hh"
83 #include "G4PSSphereSurfaceCurrent.hh"
84 #include "G4PSSphereSurfaceFlux.hh"
85 #include "G4PSCylinderSurfaceCurrent.hh"
86 #include "G4PSCylinderSurfaceFlux.hh"
87 #include "G4PSNofCollision.hh"
88 #include "G4PSPopulation.hh"
89 #include "G4PSTrackCounter.hh"
90 #include "G4PSTermination.hh"
91 #include "G4PSMinKinEAtGeneration.hh"
92
93 //
94 // For debug purpose
95 #include "G4PSStepChecker3D.hh"
96
97 #include "G4SDChargedFilter.hh"
98 #include "G4SDNeutralFilter.hh"
99 #include "G4SDKineticEnergyFilter.hh"
100 #include "G4SDParticleFilter.hh"
101 #include "G4SDParticleWithEnergyFilter.hh"
102
103 #include "G4UIdirectory.hh"
104 #include "G4UIcmdWithoutParameter.hh"
105 #include "G4UIcmdWithAnInteger.hh"
106 #include "G4UIcmdWithAString.hh"
107 #include "G4UIcmdWithABool.hh"
108 #include "G4UIcmdWithADoubleAndUnit.hh"
109 #include "G4UIcmdWith3VectorAndUnit.hh"
110 #include "G4UIcommand.hh"
111 #include "G4UIparameter.hh"
112 #include "G4Tokenizer.hh"
113 #include "G4UnitsTable.hh"
114
115 G4ScoreQuantityMessenger::G4ScoreQuantityMesse
116 : fSMan(SManager)
117 {
118 QuantityCommands();
119 FilterCommands();
120 }
121
122 void G4ScoreQuantityMessenger::QuantityCommand
123 {
124 G4UIparameter* param;
125
126 //
127 // Quantity commands
128 quantityDir = new G4UIdirectory("/score/quan
129 quantityDir->SetGuidance("Scoring quantity o
130 //
131 qTouchCmd = new G4UIcmdWithAString("/score/q
132 qTouchCmd->SetGuidance(
133 "Assign previously defined quantity to the
134 qTouchCmd->SetParameterName("qname", false);
135 //
136 qGetUnitCmd = new G4UIcmdWithoutParameter("/
137 qGetUnitCmd->SetGuidance("Print output unit
138 //
139 qSetUnitCmd = new G4UIcmdWithAString("/score
140 qSetUnitCmd->SetGuidance("Set output unit of
141 qSetUnitCmd->SetParameterName("unit", false)
142
143 // Primitive Scorers
144 qeDepCmd = new G4UIcommand("/score/quantity/
145 qeDepCmd->SetGuidance("Energy deposit scorer
146 qeDepCmd->SetGuidance("[usage] /score/quanti
147 qeDepCmd->SetGuidance(" qname :(String) sc
148 qeDepCmd->SetGuidance(" unit :(String) un
149 param = new G4UIparameter("qname", 's', fals
150 qeDepCmd->SetParameter(param);
151 param = new G4UIparameter("unit", 's', true)
152 param->SetDefaultUnit("MeV");
153 qeDepCmd->SetParameter(param);
154 //
155 qCellChgCmd = new G4UIcommand("/score/quanti
156 qCellChgCmd->SetGuidance("Cell charge scorer
157 qCellChgCmd->SetGuidance("[usage] /score/qua
158 qCellChgCmd->SetGuidance(" qname :(String)
159 qCellChgCmd->SetGuidance(" unit :(String)
160 param = new G4UIparameter("qname", 's', fals
161 qCellChgCmd->SetParameter(param);
162 param = new G4UIparameter("unit", 's', true)
163 param->SetDefaultUnit("e+");
164 qCellChgCmd->SetParameter(param);
165 //
166 qCellFluxCmd = new G4UIcommand("/score/quant
167 qCellFluxCmd->SetGuidance("Cell flux scorer.
168 qCellFluxCmd->SetGuidance("[usage] /score/qu
169 qCellFluxCmd->SetGuidance(" qname :(String
170 qCellFluxCmd->SetGuidance(" unit :(String
171 param = new G4UIparameter("qname", 's', fals
172 qCellFluxCmd->SetParameter(param);
173 param = new G4UIparameter("unit", 's', true)
174 param->SetDefaultValue("percm2");
175 qCellFluxCmd->SetParameter(param);
176 //
177 qPassCellFluxCmd = new G4UIcommand("/score/q
178 qPassCellFluxCmd->SetGuidance("Passage cell
179 qPassCellFluxCmd->SetGuidance(
180 "[usage] /score/quantity/passageCellFlux q
181 qPassCellFluxCmd->SetGuidance(" qname :(St
182 qPassCellFluxCmd->SetGuidance(" unit :(St
183 param = new G4UIparameter("qname", 's', fals
184 qPassCellFluxCmd->SetParameter(param);
185 param = new G4UIparameter("unit", 's', true)
186 param->SetDefaultValue("percm2");
187 qPassCellFluxCmd->SetParameter(param);
188 //
189 qdoseDepCmd = new G4UIcommand("/score/quanti
190 qdoseDepCmd->SetGuidance("Dose deposit score
191 qdoseDepCmd->SetGuidance("[usage] /score/qua
192 qdoseDepCmd->SetGuidance(" qname :(String)
193 qdoseDepCmd->SetGuidance(" unit :(String)
194 param = new G4UIparameter("qname", 's', fals
195 qdoseDepCmd->SetParameter(param);
196 param = new G4UIparameter("unit", 's', true)
197 param->SetDefaultUnit("Gy");
198 qdoseDepCmd->SetParameter(param);
199 //
200 qnOfStepCmd = new G4UIcommand("/score/quanti
201 qnOfStepCmd->SetGuidance("Number of step sco
202 qnOfStepCmd->SetGuidance("[usage] /score/qua
203 qnOfStepCmd->SetGuidance("[usage] /score/qua
204 qnOfStepCmd->SetGuidance(" qname :(String)
205 qnOfStepCmd->SetGuidance(" bflag :(Bool) S
206 qnOfStepCmd->SetGuidance(" at geome
207 param = new G4UIparameter("qname", 's', fals
208 qnOfStepCmd->SetParameter(param);
209 param = new G4UIparameter("bflag", 'b', true
210 param->SetDefaultValue("false");
211 qnOfStepCmd->SetParameter(param);
212 //
213 qnOfSecondaryCmd = new G4UIcommand("/score/q
214 qnOfSecondaryCmd->SetGuidance("Number of sec
215 qnOfSecondaryCmd->SetGuidance("[usage] /scor
216 qnOfSecondaryCmd->SetGuidance(" qname :(St
217 param = new G4UIparameter("qname", 's', fals
218 qnOfSecondaryCmd->SetParameter(param);
219 //
220 qTrackLengthCmd = new G4UIcommand("/score/qu
221 qTrackLengthCmd->SetGuidance("Track length s
222 qTrackLengthCmd->SetGuidance(
223 "[usage] /score/quantity/trackLength qname
224 qTrackLengthCmd->SetGuidance(" qname :(Str
225 qTrackLengthCmd->SetGuidance(" wflag :(Boo
226 qTrackLengthCmd->SetGuidance(" kflag :(Boo
227 qTrackLengthCmd->SetGuidance(" vflag :(Boo
228 qTrackLengthCmd->SetGuidance(" unit :(Str
229 param = new G4UIparameter("qname", 's', fals
230 qTrackLengthCmd->SetParameter(param);
231 param = new G4UIparameter("wflag", 'b', true
232 param->SetDefaultValue("false");
233 qTrackLengthCmd->SetParameter(param);
234 param = new G4UIparameter("kflag", 'b', true
235 param->SetDefaultValue("false");
236 qTrackLengthCmd->SetParameter(param);
237 param = new G4UIparameter("vflag", 'b', true
238 param->SetDefaultValue("false");
239 qTrackLengthCmd->SetParameter(param);
240 param = new G4UIparameter("unit", 's', true)
241 param->SetDefaultValue("mm");
242 qTrackLengthCmd->SetParameter(param);
243 //
244 qPassCellCurrCmd =
245 new G4UIcommand("/score/quantity/passageCe
246 qPassCellCurrCmd->SetGuidance("Passage cell
247 qPassCellCurrCmd->SetGuidance(
248 "[usage] /score/quantity/passageCellCurren
249 qPassCellCurrCmd->SetGuidance(" qname :(St
250 qPassCellCurrCmd->SetGuidance(" wflag :(Bo
251 param = new G4UIparameter("qname", 's', fals
252 qPassCellCurrCmd->SetParameter(param);
253 param = new G4UIparameter("wflag", 'b', true
254 param->SetDefaultValue("true");
255 qPassCellCurrCmd->SetParameter(param);
256 //
257 qPassTrackLengthCmd =
258 new G4UIcommand("/score/quantity/passageTr
259 qPassTrackLengthCmd->SetGuidance("Passage tr
260 qPassTrackLengthCmd->SetGuidance(
261 "[usage] /score/quantity/passageTrackLengt
262 qPassTrackLengthCmd->SetGuidance(" qname :
263 qPassTrackLengthCmd->SetGuidance(" wflag :
264 qPassTrackLengthCmd->SetGuidance(" unit :
265 param = new G4UIparameter("qname", 's', fals
266 qPassTrackLengthCmd->SetParameter(param);
267 param = new G4UIparameter("wflag", 'b', true
268 param->SetDefaultValue("true");
269 qPassTrackLengthCmd->SetParameter(param);
270 param = new G4UIparameter("unit", 's', true)
271 param->SetDefaultUnit("mm");
272 qPassTrackLengthCmd->SetParameter(param);
273 //
274 qFlatSurfCurrCmd =
275 new G4UIcommand("/score/quantity/flatSurfa
276 qFlatSurfCurrCmd->SetGuidance("Flat surface
277 qFlatSurfCurrCmd->SetGuidance(
278 "[usage] /score/quantity/flatSurfaceCurren
279 qFlatSurfCurrCmd->SetGuidance(" qname :(St
280 qFlatSurfCurrCmd->SetGuidance(" dflag :(In
281 qFlatSurfCurrCmd->SetGuidance(" : 0
282 qFlatSurfCurrCmd->SetGuidance(" : 1
283 qFlatSurfCurrCmd->SetGuidance(" : 2
284 qFlatSurfCurrCmd->SetGuidance(" wflag :(Bo
285 qFlatSurfCurrCmd->SetGuidance(" aflag :(Bo
286 qFlatSurfCurrCmd->SetGuidance(" unit :(St
287 param = new G4UIparameter("qname", 's', fals
288 qFlatSurfCurrCmd->SetParameter(param);
289 param = new G4UIparameter("dflag", 'i', true
290 param->SetDefaultValue("0");
291 qFlatSurfCurrCmd->SetParameter(param);
292 param = new G4UIparameter("wflag", 'b', true
293 param->SetDefaultValue("true");
294 qFlatSurfCurrCmd->SetParameter(param);
295 param = new G4UIparameter("aflag", 'b', true
296 param->SetDefaultValue("true");
297 qFlatSurfCurrCmd->SetParameter(param);
298 param = new G4UIparameter("unit", 's', true)
299 param->SetDefaultValue("percm2");
300 qFlatSurfCurrCmd->SetParameter(param);
301 //
302 qFlatSurfFluxCmd = new G4UIcommand("/score/q
303 qFlatSurfFluxCmd->SetGuidance("Flat surface
304 qFlatSurfFluxCmd->SetGuidance(
305 "[usage] /score/quantity/flatSurfaceFlux q
306 qFlatSurfFluxCmd->SetGuidance(" qname :(St
307 qFlatSurfFluxCmd->SetGuidance(" dflag :(In
308 qFlatSurfFluxCmd->SetGuidance(" : 0
309 qFlatSurfFluxCmd->SetGuidance(" : 1
310 qFlatSurfFluxCmd->SetGuidance(" : 2
311 qFlatSurfFluxCmd->SetGuidance(" wflag :(Bo
312 qFlatSurfFluxCmd->SetGuidance(" aflag :(Bo
313 qFlatSurfFluxCmd->SetGuidance(" unit :(St
314 param = new G4UIparameter("qname", 's', fals
315 qFlatSurfFluxCmd->SetParameter(param);
316 param = new G4UIparameter("dflag", 'i', true
317 param->SetDefaultValue("0");
318 qFlatSurfFluxCmd->SetParameter(param);
319 param = new G4UIparameter("wflag", 'b', true
320 param->SetDefaultValue("true");
321 qFlatSurfFluxCmd->SetParameter(param);
322 param = new G4UIparameter("aflag", 'b', true
323 param->SetDefaultValue("true");
324 qFlatSurfFluxCmd->SetParameter(param);
325 param = new G4UIparameter("unit", 's', true)
326 param->SetDefaultValue("percm2");
327 qFlatSurfFluxCmd->SetParameter(param);
328 //
329
330 qVolFluxCmd = new G4UIcommand("/score/quanti
331 qVolFluxCmd->SetGuidance("Volume flux scorer
332 qVolFluxCmd->SetGuidance(
333 "This scorer scores the number of particle
334 "without normalized by the surface area.")
335 qVolFluxCmd->SetGuidance(
336 "[usage] /score/quantity/volumeFlux qname
337 qVolFluxCmd->SetGuidance(" qname :(String)
338 qVolFluxCmd->SetGuidance(" divcos :(Bool) d
339 "is the incident an
340 qVolFluxCmd->SetGuidance(
341 " dflag :(Int) direction, 1 : inward (de
342 param = new G4UIparameter("qname", 's', fals
343 qVolFluxCmd->SetParameter(param);
344 param = new G4UIparameter("divcos", 'b', tru
345 param->SetDefaultValue(0);
346 qVolFluxCmd->SetParameter(param);
347 param = new G4UIparameter("dflag", 'i', true
348 param->SetParameterRange("dflag>=1 && dflag<
349 param->SetDefaultValue(1);
350 qVolFluxCmd->SetParameter(param);
351
352 qNofCollisionCmd = new G4UIcommand("/score/q
353 qNofCollisionCmd->SetGuidance("Number of col
354 qNofCollisionCmd->SetGuidance(
355 "[usage] /score/quantity/nOfCollision qnam
356 qNofCollisionCmd->SetGuidance(" qname :(St
357 param = new G4UIparameter("qname", 's', fals
358 qNofCollisionCmd->SetParameter(param);
359 param = new G4UIparameter("wflag", 'b', true
360 param->SetDefaultValue("false");
361 qNofCollisionCmd->SetParameter(param);
362 //
363 qPopulationCmd = new G4UIcommand("/score/qua
364 qPopulationCmd->SetGuidance("Population scor
365 qPopulationCmd->SetGuidance("[usage] /score/
366 qPopulationCmd->SetGuidance(" qname :(Stri
367 qPopulationCmd->SetGuidance(" wflag :(Bool
368 param = new G4UIparameter("qname", 's', fals
369 qPopulationCmd->SetParameter(param);
370 param = new G4UIparameter("wflag", 'b', true
371 param->SetDefaultValue("false");
372 qPopulationCmd->SetParameter(param);
373
374 //
375 qTrackCountCmd = new G4UIcommand("/score/qua
376 qTrackCountCmd->SetGuidance("Number of track
377 qTrackCountCmd->SetGuidance(
378 "[usage] /score/quantity/nOfTrack qname df
379 qTrackCountCmd->SetGuidance(" qname :(Stri
380 qTrackCountCmd->SetGuidance(" dflag :(Int)
381 qTrackCountCmd->SetGuidance(" : 0 =
382 qTrackCountCmd->SetGuidance(" : 1 =
383 qTrackCountCmd->SetGuidance(" : 2 =
384 qTrackCountCmd->SetGuidance(" wflag :(Bool
385 param = new G4UIparameter("qname", 's', fals
386 qTrackCountCmd->SetParameter(param);
387 param = new G4UIparameter("dflag", 'i', true
388 param->SetDefaultValue("0");
389 qTrackCountCmd->SetParameter(param);
390 param = new G4UIparameter("wflag", 'b', true
391 param->SetDefaultValue("false");
392 qTrackCountCmd->SetParameter(param);
393
394 //
395 qTerminationCmd = new G4UIcommand("/score/qu
396 qTerminationCmd->SetGuidance("Number of term
397 qTerminationCmd->SetGuidance(
398 "[usage] /score/quantity/nOfTerminatedTrac
399 qTerminationCmd->SetGuidance(" qname :(Str
400 qTerminationCmd->SetGuidance(" wflag :(Boo
401 param = new G4UIparameter("qname", 's', fals
402 qTerminationCmd->SetParameter(param);
403 param = new G4UIparameter("wflag", 'b', true
404 param->SetDefaultValue("false");
405 qTerminationCmd->SetParameter(param);
406
407 //
408 qMinKinEAtGeneCmd =
409 new G4UIcommand("/score/quantity/minKinEAt
410 qMinKinEAtGeneCmd->SetGuidance("Min Kinetic
411 qMinKinEAtGeneCmd->SetGuidance(
412 "[usage] /score/quantity/minKinEAtGenerati
413 qMinKinEAtGeneCmd->SetGuidance(" qname :(S
414 qMinKinEAtGeneCmd->SetGuidance(" unit :(S
415 param = new G4UIparameter("qname", 's', fals
416 qMinKinEAtGeneCmd->SetParameter(param);
417 param = new G4UIparameter("unit", 's', true)
418 param->SetDefaultUnit("MeV");
419 qMinKinEAtGeneCmd->SetParameter(param);
420 //
421 qStepCheckerCmd = new G4UIcommand("/score/qu
422 qStepCheckerCmd->SetGuidance("Display a comm
423 qStepCheckerCmd->SetGuidance("[usage] /score
424 qStepCheckerCmd->SetGuidance(" qname :(Str
425 param = new G4UIparameter("qname", 's', fals
426 qStepCheckerCmd->SetParameter(param);
427 }
428
429 void G4ScoreQuantityMessenger::FilterCommands(
430 {
431 G4UIparameter* param;
432
433 //
434 // Filter commands
435 filterDir = new G4UIdirectory("/score/filter
436 filterDir->SetGuidance(" Scoring filter com
437 //
438 fchargedCmd = new G4UIcmdWithAString("/score
439 fchargedCmd->SetGuidance("Charged particle f
440 fchargedCmd->SetParameterName("fname", false
441 //
442 fneutralCmd = new G4UIcmdWithAString("/score
443 fneutralCmd->SetGuidance("Neutral particle f
444 fneutralCmd->SetParameterName("fname", false
445 //
446 fkinECmd = new G4UIcommand("/score/filter/ki
447 fkinECmd->SetGuidance("Kinetic energy filter
448 fkinECmd->SetGuidance(
449 "[usage] /score/filter/kineticEnergy fname
450 fkinECmd->SetGuidance(" fname :(String)
451 fkinECmd->SetGuidance(" Elow :(Double)
452 fkinECmd->SetGuidance(" Ehigh :(Double)
453 fkinECmd->SetGuidance(" unit :(String)
454 param = new G4UIparameter("fname", 's', fals
455 fkinECmd->SetParameter(param);
456 param = new G4UIparameter("elow", 'd', true)
457 param->SetDefaultValue("0.0");
458 fkinECmd->SetParameter(param);
459 param = new G4UIparameter("ehigh", 'd', true
460 fkinECmd->SetParameter(param);
461 G4String smax = DtoS(DBL_MAX);
462 param->SetDefaultValue(smax);
463 param = new G4UIparameter("unit", 's', true)
464 param->SetDefaultUnit("keV");
465 fkinECmd->SetParameter(param);
466 //
467 fparticleCmd = new G4UIcommand("/score/filte
468 fparticleCmd->SetGuidance("Particle filter."
469 fparticleCmd->SetGuidance("[usage] /score/fi
470 fparticleCmd->SetGuidance(" fname :(Str
471 fparticleCmd->SetGuidance(" p0 .. pn :(Str
472 param = new G4UIparameter("fname", 's', fals
473 fparticleCmd->SetParameter(param);
474 param = new G4UIparameter("particlelist", 's
475 param->SetDefaultValue("");
476 fparticleCmd->SetParameter(param);
477 //
478 //
479 //
480 fparticleKinECmd =
481 new G4UIcommand("/score/filter/particleWit
482 fparticleKinECmd->SetGuidance("Particle with
483 fparticleKinECmd->SetGuidance(
484 "[usage] /score/filter/particleWithKinetic
485 ".. pn");
486 fparticleKinECmd->SetGuidance(" fname :
487 fparticleKinECmd->SetGuidance(
488 " Elow :(Double) Lower edge of kinet
489 fparticleKinECmd->SetGuidance(
490 " Ehigh :(Double) Higher edge of kine
491 fparticleKinECmd->SetGuidance(
492 " unit :(String) unit of given kinet
493 fparticleKinECmd->SetGuidance(" p0 .. pn :
494 param = new G4UIparameter("fname", 's', fals
495 fparticleKinECmd->SetParameter(param);
496 param = new G4UIparameter("elow", 'd', false
497 param->SetDefaultValue("0.0");
498 fparticleKinECmd->SetParameter(param);
499 param = new G4UIparameter("ehigh", 'd', true
500 param->SetDefaultValue(smax);
501 fparticleKinECmd->SetParameter(param);
502 param = new G4UIparameter("unit", 's', true)
503 param->SetDefaultUnit("keV");
504 fparticleKinECmd->SetParameter(param);
505 param = new G4UIparameter("particlelist", 's
506 param->SetDefaultValue("");
507 fparticleKinECmd->SetParameter(param);
508 //
509 //
510 }
511
512 G4ScoreQuantityMessenger::~G4ScoreQuantityMess
513 {
514 delete quantityDir;
515 delete qTouchCmd;
516 delete qGetUnitCmd;
517 delete qSetUnitCmd;
518
519 //
520 delete qCellChgCmd;
521 delete qCellFluxCmd;
522 delete qPassCellFluxCmd;
523 delete qeDepCmd;
524 delete qdoseDepCmd;
525 delete qnOfStepCmd;
526 delete qnOfSecondaryCmd;
527 //
528 delete qTrackLengthCmd;
529 delete qPassCellCurrCmd;
530 delete qPassTrackLengthCmd;
531 delete qFlatSurfCurrCmd;
532 delete qFlatSurfFluxCmd;
533 delete qVolFluxCmd;
534
535 delete qNofCollisionCmd;
536 delete qPopulationCmd;
537 delete qTrackCountCmd;
538 delete qTerminationCmd;
539 delete qMinKinEAtGeneCmd;
540 //
541 delete qStepCheckerCmd;
542 //
543 delete filterDir;
544 delete fchargedCmd;
545 delete fneutralCmd;
546 delete fkinECmd;
547 delete fparticleCmd;
548 delete fparticleKinECmd;
549 }
550
551 void G4ScoreQuantityMessenger::SetNewValue(G4U
552 G4S
553 {
554 using MeshShape = G4VScoringMesh::MeshShape;
555
556 G4ExceptionDescription ed;
557
558 //
559 // Get Current Mesh
560 //
561 G4VScoringMesh* mesh = fSMan->GetCurrentMesh
562 if(mesh == nullptr)
563 {
564 ed << "ERROR : No mesh is currently open.
565 "Command ignored.";
566 command->CommandFailed(ed);
567 return;
568 }
569 // Mesh type
570 auto shape = mesh->GetShape();
571 // Tokens
572 G4TokenVec token;
573 FillTokenVec(newVal, token);
574 //
575 // Commands for Current Mesh
576 if(command == qTouchCmd)
577 {
578 mesh->SetCurrentPrimitiveScorer(newVal);
579 }
580 else if(command == qGetUnitCmd)
581 {
582 G4cout << "Unit: " << mesh->GetCurrentPSU
583 }
584 else if(command == qSetUnitCmd)
585 {
586 mesh->SetCurrentPSUnit(newVal);
587 }
588 else if(command == qCellChgCmd)
589 {
590 if(CheckMeshPS(mesh, token[0], command))
591 {
592 G4PSCellCharge* ps = nullptr;
593 if(shape == MeshShape::realWorldLogVol |
594 {
595 ps = new G4PSCellCharge(token[0], mesh
596 }
597 else
598 {
599 ps = new G4PSCellCharge3D(token[0]);
600 }
601 ps->SetUnit(token[1]);
602 mesh->SetPrimitiveScorer(ps);
603 }
604 }
605 else if(command == qCellFluxCmd)
606 {
607 if(CheckMeshPS(mesh, token[0], command))
608 {
609 G4PSCellFlux* ps = nullptr;
610 if(shape == MeshShape::box)
611 {
612 ps = new G4PSCellFlux3D(token[0]);
613 }
614 else if(shape == MeshShape::cylinder)
615 {
616 auto pps =
617 new G4PSCellFluxForCylinder3D(token[
618 pps->SetCylinderSize(mesh->GetSize(),m
619 G4int nSeg[3];
620 mesh->GetNumberOfSegments(nSeg);
621 pps->SetNumberOfSegments(nSeg);
622 ps = pps;
623 }
624 else if(shape == MeshShape::realWorldLog
625 {
626 ed << "Cell flux for real world volume
627 "ignored.";
628 command->CommandFailed(ed);
629 return;
630 }
631 else if(shape == MeshShape::probe)
632 {
633 ps = new G4PSCellFlux(token[0]);
634 }
635 ps->SetUnit(token[1]);
636 mesh->SetPrimitiveScorer(ps);
637 }
638 }
639 else if(command == qPassCellFluxCmd)
640 {
641 if(CheckMeshPS(mesh, token[0], command))
642 {
643 G4PSPassageCellFlux* ps = nullptr;
644 if(shape == MeshShape::box)
645 {
646 ps = new G4PSPassageCellFlux3D(token[0
647 }
648 else if(shape == MeshShape::cylinder)
649 {
650 auto pps =
651 new G4PSPassageCellFluxForCylinder3D
652 pps->SetCylinderSize(mesh->GetSize(),m
653 G4int nSeg[3];
654 mesh->GetNumberOfSegments(nSeg);
655 pps->SetNumberOfSegments(nSeg);
656 ps = pps;
657 }
658 else if(shape == MeshShape::realWorldLog
659 {
660 ed << "Passing cell flux for real worl
661 "Command ignored.";
662 command->CommandFailed(ed);
663 return;
664 }
665 else if(shape == MeshShape::probe)
666 {
667 ps = new G4PSPassageCellFlux(token[0])
668 }
669 ps->SetUnit(token[1]);
670 mesh->SetPrimitiveScorer(ps);
671 }
672 }
673 else if(command == qeDepCmd)
674 {
675 if(CheckMeshPS(mesh, token[0], command))
676 {
677 G4PSEnergyDeposit* ps = nullptr;
678 if(shape == MeshShape::realWorldLogVol |
679 {
680 ps = new G4PSEnergyDeposit(token[0], m
681 }
682 else
683 {
684 ps = new G4PSEnergyDeposit3D(token[0])
685 }
686 ps->SetUnit(token[1]);
687 mesh->SetPrimitiveScorer(ps);
688 }
689 }
690 else if(command == qdoseDepCmd)
691 {
692 if(CheckMeshPS(mesh, token[0], command))
693 {
694 G4PSDoseDeposit* ps = nullptr;
695 if(shape == MeshShape::box)
696 {
697 ps = new G4PSDoseDeposit3D(token[0]);
698 }
699 else if(shape == MeshShape::cylinder)
700 {
701 auto pps =
702 new G4PSDoseDepositForCylinder3D(tok
703 pps->SetUnit(token[1]);
704 pps->SetCylinderSize(mesh->GetSize(),m
705 G4int nSeg[3];
706 mesh->GetNumberOfSegments(nSeg);
707 pps->SetNumberOfSegments(nSeg);
708 ps = pps;
709 }
710 else if(shape == MeshShape::realWorldLog
711 {
712 ps = new G4PSDoseDeposit(token[0], mes
713 }
714 ps->SetUnit(token[1]);
715 mesh->SetPrimitiveScorer(ps);
716 }
717 }
718 else if(command == qnOfStepCmd)
719 {
720 if(CheckMeshPS(mesh, token[0], command))
721 {
722 G4PSNofStep* ps = nullptr;
723 if(shape == MeshShape::realWorldLogVol |
724 {
725 ps = new G4PSNofStep(token[0], mesh->G
726 }
727 else
728 {
729 ps = new G4PSNofStep3D(token[0]);
730 }
731 ps->SetBoundaryFlag(StoB(token[1]));
732 mesh->SetPrimitiveScorer(ps);
733 }
734 }
735 else if(command == qnOfSecondaryCmd)
736 {
737 if(CheckMeshPS(mesh, token[0], command))
738 {
739 G4PSNofSecondary* ps = nullptr;
740 if(shape == MeshShape::realWorldLogVol |
741 {
742 ps = new G4PSNofSecondary(token[0], me
743 }
744 else
745 {
746 ps = new G4PSNofSecondary3D(token[0]);
747 }
748 mesh->SetPrimitiveScorer(ps);
749 }
750 }
751 else if(command == qTrackLengthCmd)
752 {
753 if(CheckMeshPS(mesh, token[0], command))
754 {
755 G4PSTrackLength* ps = nullptr;
756 if(shape == MeshShape::realWorldLogVol |
757 {
758 ps = new G4PSTrackLength(token[0], mes
759 }
760 else
761 {
762 ps = new G4PSTrackLength3D(token[0]);
763 }
764 ps->Weighted(StoB(token[1]));
765 ps->MultiplyKineticEnergy(StoB(token[2])
766 ps->DivideByVelocity(StoB(token[3]));
767 ps->SetUnit(token[4]);
768 mesh->SetPrimitiveScorer(ps);
769 }
770 }
771 else if(command == qPassCellCurrCmd)
772 {
773 if(CheckMeshPS(mesh, token[0], command))
774 {
775 G4PSPassageCellCurrent* ps = nullptr;
776 if(shape == MeshShape::realWorldLogVol |
777 {
778 ps = new G4PSPassageCellCurrent(token[
779 }
780 else
781 {
782 ps = new G4PSPassageCellCurrent3D(toke
783 }
784 ps->Weighted(StoB(token[1]));
785 mesh->SetPrimitiveScorer(ps);
786 }
787 }
788 else if(command == qPassTrackLengthCmd)
789 {
790 if(CheckMeshPS(mesh, token[0], command))
791 {
792 G4PSPassageTrackLength* ps = nullptr;
793 if(shape == MeshShape::realWorldLogVol |
794 {
795 ps = new G4PSPassageTrackLength(token[
796 }
797 else
798 {
799 ps = new G4PSPassageTrackLength3D(toke
800 }
801 ps->Weighted(StoB(token[1]));
802 ps->SetUnit(token[2]);
803 mesh->SetPrimitiveScorer(ps);
804 }
805 }
806 else if(command == qFlatSurfCurrCmd)
807 {
808 if(CheckMeshPS(mesh, token[0], command))
809 {
810 G4PSFlatSurfaceCurrent* ps = nullptr;
811 if(shape == MeshShape::realWorldLogVol |
812 {
813 ps = new G4PSFlatSurfaceCurrent(token[
814 mesh->
815 }
816 else
817 {
818 ps = new G4PSFlatSurfaceCurrent3D(toke
819 }
820 ps->Weighted(StoB(token[2]));
821 ps->DivideByArea(StoB(token[3]));
822 if(StoB(token[3]))
823 {
824 ps->SetUnit(token[4]);
825 }
826 else
827 {
828 ps->SetUnit("");
829 }
830 mesh->SetPrimitiveScorer(ps);
831 }
832 }
833 else if(command == qFlatSurfFluxCmd)
834 {
835 if(CheckMeshPS(mesh, token[0], command))
836 {
837 G4PSFlatSurfaceFlux* ps = nullptr;
838 if(shape == MeshShape::realWorldLogVol |
839 {
840 ps = new G4PSFlatSurfaceFlux(token[0],
841 mesh->Get
842 }
843 else
844 {
845 ps = new G4PSFlatSurfaceFlux3D(token[0
846 }
847 ps->Weighted(StoB(token[2]));
848 ps->DivideByArea(StoB(token[3]));
849 if(StoB(token[3]))
850 {
851 ps->SetUnit(token[4]);
852 }
853 else
854 {
855 ps->SetUnit("");
856 }
857 mesh->SetPrimitiveScorer(ps);
858 }
859 }
860 else if(command == qVolFluxCmd)
861 {
862 if(CheckMeshPS(mesh, token[0], command))
863 {
864 G4PSVolumeFlux* ps = nullptr;
865 if(shape == MeshShape::realWorldLogVol |
866 {
867 ps = new G4PSVolumeFlux(token[0], StoI
868 mesh->GetCopyN
869 }
870 else
871 {
872 ps = new G4PSVolumeFlux3D(token[0], St
873 }
874 ps->SetDivCos(StoI(token[1]) != 0);
875 mesh->SetPrimitiveScorer(ps);
876 }
877 }
878 else if(command == qNofCollisionCmd)
879 {
880 if(CheckMeshPS(mesh, token[0], command))
881 {
882 G4PSNofCollision* ps = nullptr;
883 if(shape == MeshShape::realWorldLogVol |
884 {
885 ps = new G4PSNofCollision3D(token[0],
886 }
887 else
888 {
889 ps = new G4PSNofCollision3D(token[0]);
890 }
891 ps->Weighted(StoB(token[1]));
892 mesh->SetPrimitiveScorer(ps);
893 }
894 }
895 else if(command == qPopulationCmd)
896 {
897 if(CheckMeshPS(mesh, token[0], command))
898 {
899 G4PSPopulation* ps = nullptr;
900 if(shape == MeshShape::realWorldLogVol |
901 {
902 ps = new G4PSPopulation(token[0], mesh
903 }
904 else
905 {
906 ps = new G4PSPopulation3D(token[0]);
907 }
908 ps->Weighted(StoB(token[1]));
909 mesh->SetPrimitiveScorer(ps);
910 }
911 }
912 else if(command == qTrackCountCmd)
913 {
914 if(CheckMeshPS(mesh, token[0], command))
915 {
916 G4PSTrackCounter* ps = nullptr;
917 if(shape == MeshShape::realWorldLogVol |
918 {
919 ps = new G4PSTrackCounter(token[0], St
920 mesh->GetCop
921 }
922 else
923 {
924 ps = new G4PSTrackCounter3D(token[0],
925 }
926 ps->Weighted(StoB(token[2]));
927 mesh->SetPrimitiveScorer(ps);
928 }
929 }
930 else if(command == qTerminationCmd)
931 {
932 if(CheckMeshPS(mesh, token[0], command))
933 {
934 G4PSTermination* ps = nullptr;
935 if(shape == MeshShape::realWorldLogVol |
936 {
937 ps = new G4PSTermination(token[0], mes
938 }
939 else
940 {
941 ps = new G4PSTermination3D(token[0]);
942 }
943 ps->Weighted(StoB(token[1]));
944 mesh->SetPrimitiveScorer(ps);
945 }
946 }
947 else if(command == qMinKinEAtGeneCmd)
948 {
949 if(CheckMeshPS(mesh, token[0], command))
950 {
951 G4PSMinKinEAtGeneration* ps = nullptr;
952 if(shape == MeshShape::realWorldLogVol |
953 {
954 ps = new G4PSMinKinEAtGeneration(token
955 }
956 else
957 {
958 ps = new G4PSMinKinEAtGeneration3D(tok
959 }
960 ps->SetUnit(token[1]);
961 mesh->SetPrimitiveScorer(ps);
962 }
963 }
964 else if(command == qStepCheckerCmd)
965 {
966 if(CheckMeshPS(mesh, token[0], command))
967 {
968 G4PSStepChecker* ps = nullptr;
969 if(shape == MeshShape::realWorldLogVol |
970 {
971 ps = new G4PSStepChecker(token[0], mes
972 }
973 else
974 {
975 ps = new G4PSStepChecker3D(token[0]);
976 }
977 mesh->SetPrimitiveScorer(ps);
978 }
979
980 //
981 // Filters
982 //
983 }
984 else if(command == fchargedCmd)
985 {
986 if(!mesh->IsCurrentPrimitiveScorerNull())
987 {
988 mesh->SetFilter(new G4SDChargedFilter(to
989 }
990 else
991 {
992 ed << "WARNING[" << fchargedCmd->GetComm
993 << "] : Current quantity is not set.
994 command->CommandFailed(ed);
995 }
996 }
997 else if(command == fneutralCmd)
998 {
999 if(!mesh->IsCurrentPrimitiveScorerNull())
1000 {
1001 mesh->SetFilter(new G4SDNeutralFilter(t
1002 }
1003 else
1004 {
1005 ed << "WARNING[" << fneutralCmd->GetCom
1006 << "] : Current quantity is not set.
1007 command->CommandFailed(ed);
1008 }
1009 }
1010 else if(command == fkinECmd)
1011 {
1012 if(!mesh->IsCurrentPrimitiveScorerNull())
1013 {
1014 G4String& name = token[0];
1015 G4double elow = StoD(token[1]);
1016 G4double ehigh = StoD(token[2]);
1017 G4double unitVal = G4UnitDefinition::Ge
1018 mesh->SetFilter(
1019 new G4SDKineticEnergyFilter(name, elo
1020 }
1021 else
1022 {
1023 ed << "WARNING[" << fkinECmd->GetComman
1024 << "] : Current quantity is not set.
1025 command->CommandFailed(ed);
1026 }
1027 }
1028 else if(command == fparticleKinECmd)
1029 {
1030 if(!mesh->IsCurrentPrimitiveScorerNull())
1031 {
1032 FParticleWithEnergyCommand(mesh, token)
1033 }
1034 else
1035 {
1036 ed << "WARNING[" << fparticleKinECmd->G
1037 << "] : Current quantity is not set.
1038 command->CommandFailed(ed);
1039 }
1040 }
1041 else if(command == fparticleCmd)
1042 {
1043 if(!mesh->IsCurrentPrimitiveScorerNull())
1044 {
1045 FParticleCommand(mesh, token);
1046 }
1047 else
1048 {
1049 ed << "WARNING[" << fparticleCmd->GetCo
1050 << "] : Current quantity is not set.
1051 command->CommandFailed(ed);
1052 }
1053 }
1054 }
1055
1056 G4String G4ScoreQuantityMessenger::GetCurrent
1057 {
1058 G4String val;
1059
1060 return val;
1061 }
1062
1063 void G4ScoreQuantityMessenger::FillTokenVec(c
1064 G
1065 {
1066 G4Tokenizer next(newValues);
1067 G4String val;
1068 while(!(val = next()).empty())
1069 { // Loop checking 12.18.2015 M.Asai
1070 token.push_back(val);
1071 }
1072 }
1073
1074 void G4ScoreQuantityMessenger::FParticleComma
1075
1076 {
1077 //
1078 // Filter name
1079 G4String name = token[0];
1080 //
1081 // particle list
1082 std::vector<G4String> pnames;
1083 for(G4int i = 1; i < (G4int) token.size();
1084 {
1085 pnames.push_back(token[i]);
1086 }
1087 //
1088 // Attach Filter
1089 mesh->SetFilter(new G4SDParticleFilter(name
1090 }
1091
1092 void G4ScoreQuantityMessenger::FParticleWithE
1093
1094 {
1095 G4String& name = token[0];
1096 G4double elow = StoD(token[1]);
1097 G4double ehigh = StoD(token[2]);
1098 G4double unitVal = G4UnitDefinition::GetVal
1099 auto filter =
1100 new G4SDParticleWithEnergyFilter(name, el
1101 for(G4int i = 4; i < (G4int) token.size();
1102 {
1103 filter->add(token[i]);
1104 }
1105 mesh->SetFilter(filter);
1106 }
1107
1108 G4bool G4ScoreQuantityMessenger::CheckMeshPS(
1109
1110
1111 {
1112 if(!mesh->FindPrimitiveScorer(psname))
1113 {
1114 return true;
1115 }
1116
1117 G4ExceptionDescription ed;
1118 ed << "WARNING[" << qTouchCmd->GetCommandPa
1119 << psname << "\", is already existing.";
1120 command->CommandFailed(ed);
1121 mesh->SetNullToCurrentPrimitiveScorer();
1122 return false;
1123 }
1124