Geant4-11
G4ScoreQuantityMessengerQCmd.cc
Go to the documentation of this file.
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26//
27//
28// ---------------------------------------------------------------------
29// Modifications
30// 08-Oct-2010 T.Aso remove unit of G4PSPassageCellCurrent.
31// 01-Jun-2012 T.Aso Support weighted/dividedByArea options
32// in flatCurrent and flatFulx commands.
33// 29-Mar-2013 T.Aso Support weighted options in the nOfTrack command.
34// Support a boundary flag option in the nOfStep command
35// for skipping stepLength=0 steps.
36// 13-Feb-2020 T.Aso Change SetDefaultUnit() in trackLength scorer to
37// SetDefaultValue() to support various unit category.
38// ---------------------------------------------------------------------
39
40#include "G4ScoreQuantityMessenger.hh"
41#include "G4ScoringManager.hh"
42#include "G4VScoringMesh.hh"
43
44#include "G4PSCellCharge3D.hh"
45#include "G4PSCellFlux3D.hh"
46#include "G4PSPassageCellFlux3D.hh"
47#include "G4PSEnergyDeposit3D.hh"
48#include "G4PSDoseDeposit3D.hh"
49#include "G4PSNofStep3D.hh"
50#include "G4PSNofSecondary3D.hh"
51//
52#include "G4PSTrackLength3D.hh"
53#include "G4PSPassageCellCurrent3D.hh"
54#include "G4PSPassageTrackLength3D.hh"
55#include "G4PSFlatSurfaceCurrent3D.hh"
56#include "G4PSFlatSurfaceFlux3D.hh"
57#include "G4PSSphereSurfaceCurrent3D.hh"
58#include "G4PSSphereSurfaceFlux3D.hh"
59#include "G4PSCylinderSurfaceCurrent3D.hh"
60#include "G4PSCylinderSurfaceFlux3D.hh"
61#include "G4PSVolumeFlux3D.hh"
62#include "G4PSNofCollision3D.hh"
63#include "G4PSPopulation3D.hh"
64#include "G4PSTrackCounter3D.hh"
65#include "G4PSTermination3D.hh"
66
67#include "G4SDChargedFilter.hh"
68#include "G4SDNeutralFilter.hh"
69#include "G4SDKineticEnergyFilter.hh"
70#include "G4SDParticleFilter.hh"
71#include "G4SDParticleWithEnergyFilter.hh"
72
73#include "G4UIdirectory.hh"
74#include "G4UIcmdWithoutParameter.hh"
75#include "G4UIcmdWithAnInteger.hh"
76#include "G4UIcmdWithAString.hh"
77#include "G4UIcmdWithABool.hh"
78#include "G4UIcmdWithADoubleAndUnit.hh"
79#include "G4UIcmdWith3VectorAndUnit.hh"
80#include "G4UIcommand.hh"
81#include "G4UIparameter.hh"
82#include "G4Tokenizer.hh"
83#include "G4UnitsTable.hh"
84
85void G4ScoreQuantityMessenger::QuantityCommands()
86{
87 G4UIparameter* param;
88
89 //
90 // Quantity commands
91 quantityDir = new G4UIdirectory("/score/quantity/");
92 quantityDir->SetGuidance("Scoring quantity of the mesh.");
93 //
94 qTouchCmd = new G4UIcmdWithAString("/score/quantity/touch", this);
95 qTouchCmd->SetGuidance(
96 "Assign previously defined quantity to the current quantity.");
97 qTouchCmd->SetParameterName("qname", false);
98 //
99 qGetUnitCmd = new G4UIcmdWithoutParameter("/score/quantity/get/unit", this);
100 qGetUnitCmd->SetGuidance("Print output unit of the current quantity.");
101 //
102 qSetUnitCmd = new G4UIcmdWithAString("/score/quantity/set/unit", this);
103 qSetUnitCmd->SetGuidance("Set output unit of the current quantity.");
104 qSetUnitCmd->SetParameterName("unit", false);
105
106 // Primitive Scorers
107 qeDepCmd = new G4UIcommand("/score/quantity/energyDeposit", this);
108 qeDepCmd->SetGuidance("Energy deposit scorer.");
109 qeDepCmd->SetGuidance("[usage] /score/quantity/energyDeposit qname unit");
110 qeDepCmd->SetGuidance(" qname :(String) scorer name");
111 qeDepCmd->SetGuidance(" unit :(String) unit");
112 param = new G4UIparameter("qname", 's', false);
113 qeDepCmd->SetParameter(param);
114 param = new G4UIparameter("unit", 's', true);
115 param->SetDefaultUnit("MeV");
116 qeDepCmd->SetParameter(param);
117 //
118 qCellChgCmd = new G4UIcommand("/score/quantity/cellCharge", this);
119 qCellChgCmd->SetGuidance("Cell charge scorer.");
120 qCellChgCmd->SetGuidance("[usage] /score/quantity/cellCharge qname unit");
121 qCellChgCmd->SetGuidance(" qname :(String) scorer name");
122 qCellChgCmd->SetGuidance(" unit :(String) unit");
123 param = new G4UIparameter("qname", 's', false);
124 qCellChgCmd->SetParameter(param);
125 param = new G4UIparameter("unit", 's', true);
126 param->SetDefaultUnit("e+");
127 qCellChgCmd->SetParameter(param);
128 //
129 qCellFluxCmd = new G4UIcommand("/score/quantity/cellFlux", this);
130 qCellFluxCmd->SetGuidance("Cell flux scorer.");
131 qCellFluxCmd->SetGuidance("[usage] /score/quantity/cellFlux qname unit");
132 qCellFluxCmd->SetGuidance(" qname :(String) scorer name");
133 qCellFluxCmd->SetGuidance(" unit :(String) unit");
134 param = new G4UIparameter("qname", 's', false);
135 qCellFluxCmd->SetParameter(param);
136 param = new G4UIparameter("unit", 's', true);
137 param->SetDefaultValue("percm2");
138 qCellFluxCmd->SetParameter(param);
139 //
140 qPassCellFluxCmd = new G4UIcommand("/score/quantity/passageCellFlux", this);
141 qPassCellFluxCmd->SetGuidance("Passage cell flux scorer");
142 qPassCellFluxCmd->SetGuidance(
143 "[usage] /score/quantity/passageCellFlux qname unit");
144 qPassCellFluxCmd->SetGuidance(" qname :(String) scorer name");
145 qPassCellFluxCmd->SetGuidance(" unit :(String) unit");
146 param = new G4UIparameter("qname", 's', false);
147 qPassCellFluxCmd->SetParameter(param);
148 param = new G4UIparameter("unit", 's', true);
149 param->SetDefaultValue("percm2");
150 qPassCellFluxCmd->SetParameter(param);
151 //
152 qdoseDepCmd = new G4UIcommand("/score/quantity/doseDeposit", this);
153 qdoseDepCmd->SetGuidance("Dose deposit scorer.");
154 qdoseDepCmd->SetGuidance("[usage] /score/quantity/doseDeposit qname unit");
155 qdoseDepCmd->SetGuidance(" qname :(String) scorer name");
156 qdoseDepCmd->SetGuidance(" unit :(String) unit");
157 param = new G4UIparameter("qname", 's', false);
158 qdoseDepCmd->SetParameter(param);
159 param = new G4UIparameter("unit", 's', true);
160 param->SetDefaultUnit("Gy");
161 qdoseDepCmd->SetParameter(param);
162 //
163 qnOfStepCmd = new G4UIcommand("/score/quantity/nOfStep", this);
164 qnOfStepCmd->SetGuidance("Number of step scorer.");
165 qnOfStepCmd->SetGuidance("[usage] /score/quantity/nOfStep qname");
166 qnOfStepCmd->SetGuidance("[usage] /score/quantity/nOfStep qname bflag");
167 qnOfStepCmd->SetGuidance(" qname :(String) scorer name");
168 qnOfStepCmd->SetGuidance(" bflag :(Bool) Skip zero step ");
169 qnOfStepCmd->SetGuidance(" at geometry boundary if true");
170 param = new G4UIparameter("qname", 's', false);
171 qnOfStepCmd->SetParameter(param);
172 param = new G4UIparameter("bflag", 'b', true);
173 param->SetDefaultValue("false");
174 qnOfStepCmd->SetParameter(param);
175 //
176 qnOfSecondaryCmd = new G4UIcommand("/score/quantity/nOfSecondary", this);
177 qnOfSecondaryCmd->SetGuidance("Number of secondary scorer.");
178 qnOfSecondaryCmd->SetGuidance("[usage] /score/quantity/nOfSecondary qname");
179 qnOfSecondaryCmd->SetGuidance(" qname :(String) scorer name");
180 param = new G4UIparameter("qname", 's', false);
181 qnOfSecondaryCmd->SetParameter(param);
182 //
183 qTrackLengthCmd = new G4UIcommand("/score/quantity/trackLength", this);
184 qTrackLengthCmd->SetGuidance("Track length scorer.");
185 qTrackLengthCmd->SetGuidance(
186 "[usage] /score/quantity/trackLength qname wflag kflag vflag unit");
187 qTrackLengthCmd->SetGuidance(" qname :(String) scorer name");
188 qTrackLengthCmd->SetGuidance(" wflag :(Bool) weighted");
189 qTrackLengthCmd->SetGuidance(" kflag :(Bool) multiply kinetic energy");
190 qTrackLengthCmd->SetGuidance(" vflag :(Bool) divide by velocity");
191 qTrackLengthCmd->SetGuidance(" unit :(String) unit");
192 param = new G4UIparameter("qname", 's', false);
193 qTrackLengthCmd->SetParameter(param);
194 param = new G4UIparameter("wflag", 'b', true);
195 param->SetDefaultValue("false");
196 qTrackLengthCmd->SetParameter(param);
197 param = new G4UIparameter("kflag", 'b', true);
198 param->SetDefaultValue("false");
199 qTrackLengthCmd->SetParameter(param);
200 param = new G4UIparameter("vflag", 'b', true);
201 param->SetDefaultValue("false");
202 qTrackLengthCmd->SetParameter(param);
203 param = new G4UIparameter("unit", 's', true);
204 param->SetDefaultValue("mm");
205 qTrackLengthCmd->SetParameter(param);
206 //
207 qPassCellCurrCmd =
208 new G4UIcommand("/score/quantity/passageCellCurrent", this);
209 qPassCellCurrCmd->SetGuidance("Passage cell current scorer.");
210 qPassCellCurrCmd->SetGuidance(
211 "[usage] /score/quantity/passageCellCurrent qname wflag");
212 qPassCellCurrCmd->SetGuidance(" qname :(String) scorer name");
213 qPassCellCurrCmd->SetGuidance(" wflag :(Bool) weighted");
214 param = new G4UIparameter("qname", 's', false);
215 qPassCellCurrCmd->SetParameter(param);
216 param = new G4UIparameter("wflag", 'b', true);
217 param->SetDefaultValue("true");
218 qPassCellCurrCmd->SetParameter(param);
219 //
220 qPassTrackLengthCmd =
221 new G4UIcommand("/score/quantity/passageTrackLength", this);
222 qPassTrackLengthCmd->SetGuidance("Passage track length scorer.");
223 qPassTrackLengthCmd->SetGuidance(
224 "[usage] /score/quantity/passageTrackLength qname wflag unit");
225 qPassTrackLengthCmd->SetGuidance(" qname :(String) scorer name");
226 qPassTrackLengthCmd->SetGuidance(" wflag :(Bool) weighted");
227 qPassTrackLengthCmd->SetGuidance(" unit :(Bool) unit");
228 param = new G4UIparameter("qname", 's', false);
229 qPassTrackLengthCmd->SetParameter(param);
230 param = new G4UIparameter("wflag", 'b', true);
231 param->SetDefaultValue("true");
232 qPassTrackLengthCmd->SetParameter(param);
233 param = new G4UIparameter("unit", 's', true);
234 param->SetDefaultUnit("mm");
235 qPassTrackLengthCmd->SetParameter(param);
236 //
237 qFlatSurfCurrCmd =
238 new G4UIcommand("/score/quantity/flatSurfaceCurrent", this);
239 qFlatSurfCurrCmd->SetGuidance("Flat surface current Scorer.");
240 qFlatSurfCurrCmd->SetGuidance(
241 "[usage] /score/quantity/flatSurfaceCurrent qname dflag wflag aflag unit");
242 qFlatSurfCurrCmd->SetGuidance(" qname :(String) scorer name");
243 qFlatSurfCurrCmd->SetGuidance(" dflag :(Int) direction flag");
244 qFlatSurfCurrCmd->SetGuidance(" : 0 = Both In and Out");
245 qFlatSurfCurrCmd->SetGuidance(" : 1 = In only");
246 qFlatSurfCurrCmd->SetGuidance(" : 2 = Out only");
247 qFlatSurfCurrCmd->SetGuidance(" wflag :(Bool) weighted");
248 qFlatSurfCurrCmd->SetGuidance(" aflag :(Bool) divide by area");
249 qFlatSurfCurrCmd->SetGuidance(" unit :(String) unit");
250 param = new G4UIparameter("qname", 's', false);
251 qFlatSurfCurrCmd->SetParameter(param);
252 param = new G4UIparameter("dflag", 'i', true);
253 param->SetDefaultValue("0");
254 qFlatSurfCurrCmd->SetParameter(param);
255 param = new G4UIparameter("wflag", 'b', true);
256 param->SetDefaultValue("true");
257 qFlatSurfCurrCmd->SetParameter(param);
258 param = new G4UIparameter("aflag", 'b', true);
259 param->SetDefaultValue("true");
260 qFlatSurfCurrCmd->SetParameter(param);
261 param = new G4UIparameter("unit", 's', true);
262 param->SetDefaultValue("percm2");
263 qFlatSurfCurrCmd->SetParameter(param);
264 //
265 qFlatSurfFluxCmd = new G4UIcommand("/score/quantity/flatSurfaceFlux", this);
266 qFlatSurfFluxCmd->SetGuidance("Flat surface flux scorer.");
267 qFlatSurfFluxCmd->SetGuidance(
268 "[usage] /score/quantity/flatSurfaceFlux qname dflag unit");
269 qFlatSurfFluxCmd->SetGuidance(" qname :(String) scorer name");
270 qFlatSurfFluxCmd->SetGuidance(" dflag :(Int) direction flag");
271 qFlatSurfFluxCmd->SetGuidance(" : 0 = Both In and Out");
272 qFlatSurfFluxCmd->SetGuidance(" : 1 = In only");
273 qFlatSurfFluxCmd->SetGuidance(" : 2 = Out only");
274 qFlatSurfFluxCmd->SetGuidance(" wflag :(Bool) weighted");
275 qFlatSurfFluxCmd->SetGuidance(" aflag :(Bool) divide by area");
276 qFlatSurfFluxCmd->SetGuidance(" unit :(String) unit");
277 param = new G4UIparameter("qname", 's', false);
278 qFlatSurfFluxCmd->SetParameter(param);
279 param = new G4UIparameter("dflag", 'i', true);
280 param->SetDefaultValue("0");
281 qFlatSurfFluxCmd->SetParameter(param);
282 param = new G4UIparameter("wflag", 'b', true);
283 param->SetDefaultValue("true");
284 qFlatSurfFluxCmd->SetParameter(param);
285 param = new G4UIparameter("aflag", 'b', true);
286 param->SetDefaultValue("true");
287 qFlatSurfFluxCmd->SetParameter(param);
288 param = new G4UIparameter("unit", 's', true);
289 param->SetDefaultValue("percm2");
290 qFlatSurfFluxCmd->SetParameter(param);
291 //
292
293 qVolFluxCmd = new G4UIcommand("/score/quantity/volumeFlux", this);
294 qVolFluxCmd->SetGuidance("Volume flux scorer.");
295 qVolFluxCmd->SetGuidance(
296 "This scorer scores the number of particles getting into the volume "
297 "without normalized by the surface area.");
298 qVolFluxCmd->SetGuidance(
299 "[usage] /score/quantity/volumeFlux qname divcos dflag");
300 qVolFluxCmd->SetGuidance(" qname :(String) scorer name");
301 qVolFluxCmd->SetGuidance(" divcos :(Bool) divide by cos(theta), where theta "
302 "is the incident angle (default : false)");
303 qVolFluxCmd->SetGuidance(
304 " dflag :(Int) direction, 1 : inward (default), 2 : outward");
305 param = new G4UIparameter("qname", 's', false);
306 qVolFluxCmd->SetParameter(param);
307 param = new G4UIparameter("divcos", 'b', true);
308 param->SetDefaultValue(false);
309 qVolFluxCmd->SetParameter(param);
310 param = new G4UIparameter("dflag", 'i', true);
311 param->SetParameterRange("dflag>=1 && dflag<=2");
312 param->SetDefaultValue(1);
313 qVolFluxCmd->SetParameter(param);
314
315 // qSphereSurfCurrCmd = new
316 // G4UIcommand("/score/quantity/sphereSurfaceCurrent",this);
317 // qSphereSurfCurrCmd->SetGuidance("Sphere surface current Scorer.");
318 // qSphereSurfCurrCmd->
319 // SetGuidance("[usage] /score/quantity/sphereSurfaceCurrent qname dflag
320 // wflag aflag unit");
321 // qSphereSurfCurrCmd->SetGuidance(" qname :(String) scorer name");
322 // qSphereSurfCurrCmd->SetGuidance(" dflag :(Int) direction flag");
323 // qSphereSurfCurrCmd->SetGuidance(" : 0 = Both In and Out");
324 // qSphereSurfCurrCmd->SetGuidance(" : 1 = In only");
325 // qSphereSurfCurrCmd->SetGuidance(" : 2 = Out only");
326 // qSphereSurfCurrCmd->SetGuidance(" wflag :(Bool) Weighted");
327 // qSphereSurfCurrCmd->SetGuidance(" aflag :(Bool) DivideByArea");
328 // qSphereSurfCurrCmd->SetGuidance(" unit :(String) unit");
329 // param = new G4UIparameter("qname",'s',false);
330 // qSphereSurfCurrCmd->SetParameter(param);
331 // param = new G4UIparameter("dflag",'i',true);
332 // param->SetDefaultValue("0");
333 // qSphereSurfCurrCmd->SetParameter(param);
334 // param = new G4UIparameter("wflag",'b',true);
335 // param->SetDefaultValue("true");
336 // qSphereSurfCurrCmd->SetParameter(param);
337 // param = new G4UIparameter("aflag",'b',true);
338 // param->SetDefaultValue("true");
339 // qSphereSurfCurrCmd->SetParameter(param);
340 // param = new G4UIparameter("unit",'s',true);
341 // param->SetDefaultValue("percm2");
342 // qSphereSurfCurrCmd->SetParameter(param);
343
344 //
345 // qSphereSurfFluxCmd = new
346 // G4UIcommand("/score/quantity/sphereSurfaceFlux",this);
347 // qSphereSurfFluxCmd->SetGuidance("Sphere surface Flux Scorer.");
348 // qSphereSurfFluxCmd->
349 // SetGuidance("[usage] /score/quantity/sphereSurfaceFlux qname dflag unit");
350 // qSphereSurfFluxCmd->SetGuidance(" qname :(String) scorer name");
351 // qSphereSurfFluxCmd->SetGuidance(" dflag :(Int) direction flag");
352 // qSphereSurfFluxCmd->SetGuidance(" : 0 = Both In and Out");
353 // qSphereSurfFluxCmd->SetGuidance(" : 1 = In only");
354 // qSphereSurfFluxCmd->SetGuidance(" : 2 = Out only");
355 // qSphereSurfFluxCmd->SetGuidance(" wflag :(Bool) weighted");
356 // qSphereSurfFluxCmd->SetGuidance(" aflag :(Bool) divide by area");
357 // qSphereSurfFluxCmd->SetGuidance(" unit :(String) unit");
358 // param = new G4UIparameter("qname",'s',false);
359 // qSphereSurfFluxCmd->SetParameter(param);
360 // param = new G4UIparameter("dflag",'i',true);
361 // param->SetDefaultValue("0");
362 // qSphereSurfFluxCmd->SetParameter(param);
363 // param = new G4UIparameter("wflag",'b',true);
364 // param->SetDefaultValue("true");
365 // qSphereSurfFluxCmd->SetParameter(param);
366 // param = new G4UIparameter("aflag",'b',true);
367 // param->SetDefaultValue("true");
368 // qSphereSurfFluxCmd->SetParameter(param);
369 // param = new G4UIparameter("unit",'s',true);
370 // param->SetDefaultValue("percm2");
371 // qSphereSurfFluxCmd->SetParameter(param);
372
373 //
374 // qCylSurfCurrCmd = new
375 // G4UIcommand("/score/quantity/cylinderSurfaceCurrent",this);
376 // qCylSurfCurrCmd->SetGuidance("Cylinder surface current Scorer.");
377 // qCylSurfCurrCmd->
378 // SetGuidance("[usage] /score/quantity/cylinderSurfaceCurrent qname dflag
379 // wflag aflag unit"); qCylSurfCurrCmd->SetGuidance(" qname :(String)
380 // scorer name"); qCylSurfCurrCmd->SetGuidance(" dflag :(Int) direction
381 // flag"); qCylSurfCurrCmd->SetGuidance(" : 0 = Both In and Out");
382 // qCylSurfCurrCmd->SetGuidance(" : 1 = In only");
383 // qCylSurfCurrCmd->SetGuidance(" : 2 = Out only");
384 // qCylSurfCurrCmd->SetGuidance(" wflag :(Bool) Weighted");
385 // qCylSurfCurrCmd->SetGuidance(" aflag :(Bool) DivideByArea");
386 // qCylSurfCurrCmd->SetGuidance(" unit :(String) unit");
387 // param = new G4UIparameter("qname",'s',false);
388 // qCylSurfCurrCmd->SetParameter(param);
389 // param = new G4UIparameter("dflag",'i',true);
390 // param->SetDefaultValue("0");
391 // qCylSurfCurrCmd->SetParameter(param);
392 // param = new G4UIparameter("wflag",'b',true);
393 // param->SetDefaultValue("true");
394 // qCylSurfCurrCmd->SetParameter(param);
395 // param = new G4UIparameter("aflag",'b',true);
396 // param->SetDefaultValue("true");
397 // qCylSurfCurrCmd->SetParameter(param);
398 // param = new G4UIparameter("unit",'s',true);
399 // param->SetDefaultValue("percm2");
400 // qCylSurfCurrCmd->SetParameter(param);
401 //
402 // qCylSurfFluxCmd = new
403 // G4UIcommand("/score/quantity/cylinderSurfaceFlux",this);
404 // qCylSurfFluxCmd->SetGuidance("Cylinder surface Flux Scorer.");
405 // qCylSurfFluxCmd->
406 // SetGuidance("[usage] /score/quantity/cylinderSurfaceFlux qname dflag
407 // unit"); qCylSurfFluxCmd->SetGuidance(" qname :(String) scorer name");
408 // qCylSurfFluxCmd->SetGuidance(" dflag :(Int) direction flag");
409 // qCylSurfFluxCmd->SetGuidance(" : 0 = Both In and Out");
410 // qCylSurfFluxCmd->SetGuidance(" : 1 = In only");
411 // qCylSurfFluxCmd->SetGuidance(" : 2 = Out only");
412 // qCylSurfFluxCmd->SetGuidance(" wflag :(Bool) weighted");
413 // qCylSurfFluxCmd->SetGuidance(" aflag :(Bool) divide by area");
414 // qCylSurfFluxCmd->SetGuidance(" unit :(String) unit");
415 // param = new G4UIparameter("qname",'s',false);
416 // qCylSurfFluxCmd->SetParameter(param);
417 // param = new G4UIparameter("dflag",'i',true);
418 // param->SetDefaultValue("0");
419 // qCylSurfFluxCmd->SetParameter(param);
420 // param = new G4UIparameter("wflag",'b',true);
421 // param->SetDefaultValue("true");
422 // qCylSurfFluxCmd->SetParameter(param);
423 // param = new G4UIparameter("aflag",'b',true);
424 // param->SetDefaultValue("true");
425 // qCylSurfFluxCmd->SetParameter(param);
426 // param = new G4UIparameter("unit",'s',true);
427 // param->SetDefaultValue("percm2");
428 // qCylSurfFluxCmd->SetParameter(param);
429 //
430 //
431 qNofCollisionCmd = new G4UIcommand("/score/quantity/nOfCollision", this);
432 qNofCollisionCmd->SetGuidance("Number of collision scorer.");
433 qNofCollisionCmd->SetGuidance(
434 "[usage] /score/quantity/nOfCollision qname wflag");
435 qNofCollisionCmd->SetGuidance(" qname :(String) scorer name");
436 param = new G4UIparameter("qname", 's', false);
437 qNofCollisionCmd->SetParameter(param);
438 param = new G4UIparameter("wflag", 'b', true);
439 param->SetDefaultValue("false");
440 qNofCollisionCmd->SetParameter(param);
441 //
442 qPopulationCmd = new G4UIcommand("/score/quantity/population", this);
443 qPopulationCmd->SetGuidance("Population scorer.");
444 qPopulationCmd->SetGuidance("[usage] /score/quantity/population qname wflag");
445 qPopulationCmd->SetGuidance(" qname :(String) scorer name");
446 qPopulationCmd->SetGuidance(" wflag :(Bool) weighted");
447 param = new G4UIparameter("qname", 's', false);
448 qPopulationCmd->SetParameter(param);
449 param = new G4UIparameter("wflag", 'b', true);
450 param->SetDefaultValue("false");
451 qPopulationCmd->SetParameter(param);
452
453 //
454 qTrackCountCmd = new G4UIcommand("/score/quantity/nOfTrack", this);
455 qTrackCountCmd->SetGuidance("Number of track scorer.");
456 qTrackCountCmd->SetGuidance(
457 "[usage] /score/quantity/nOfTrack qname dflag wflag");
458 qTrackCountCmd->SetGuidance(" qname :(String) scorer name");
459 qTrackCountCmd->SetGuidance(" dflag :(Int) direction");
460 qTrackCountCmd->SetGuidance(" : 0 = Both In and Out");
461 qTrackCountCmd->SetGuidance(" : 1 = In only");
462 qTrackCountCmd->SetGuidance(" : 2 = Out only");
463 qTrackCountCmd->SetGuidance(" wflag :(Bool) weighted");
464 param = new G4UIparameter("qname", 's', false);
465 qTrackCountCmd->SetParameter(param);
466 param = new G4UIparameter("dflag", 'i', true);
467 param->SetDefaultValue("0");
468 qTrackCountCmd->SetParameter(param);
469 param = new G4UIparameter("wflag", 'b', true);
470 param->SetDefaultValue("false");
471 qTrackCountCmd->SetParameter(param);
472
473 //
474 qTerminationCmd = new G4UIcommand("/score/quantity/nOfTerminatedTrack", this);
475 qTerminationCmd->SetGuidance("Number of terminated tracks scorer.");
476 qTerminationCmd->SetGuidance(
477 "[usage] /score/quantity/nOfTerminatedTrack qname wflag");
478 qTerminationCmd->SetGuidance(" qname :(String) scorer name");
479 qTerminationCmd->SetGuidance(" wflag :(Bool) weighted");
480 param = new G4UIparameter("qname", 's', false);
481 qTerminationCmd->SetParameter(param);
482 param = new G4UIparameter("wflag", 'b', true);
483 param->SetDefaultValue("false");
484 qTerminationCmd->SetParameter(param);
485
486 //
487 qMinKinEAtGeneCmd =
488 new G4UIcommand("/score/quantity/minKinEAtGeneration", this);
489 qMinKinEAtGeneCmd->SetGuidance("Min Kinetic Energy at Generation");
490 qMinKinEAtGeneCmd->SetGuidance(
491 "[usage] /score/quantity/minKinEAtGeneration qname unit");
492 qMinKinEAtGeneCmd->SetGuidance(" qname :(String) scorer name");
493 qMinKinEAtGeneCmd->SetGuidance(" unit :(String) unit name");
494 param = new G4UIparameter("qname", 's', false);
495 qMinKinEAtGeneCmd->SetParameter(param);
496 param = new G4UIparameter("unit", 's', true);
497 param->SetDefaultUnit("MeV");
498 qMinKinEAtGeneCmd->SetParameter(param);
499 //
500 qStepCheckerCmd = new G4UIcommand("/score/quantity/stepChecker", this);
501 qStepCheckerCmd->SetGuidance("Display a comment when this PS is invoked");
502 qStepCheckerCmd->SetGuidance("[usage] /score/quantity/stepChecker qname");
503 qStepCheckerCmd->SetGuidance(" qname :(String) scorer name");
504 param = new G4UIparameter("qname", 's', false);
505 qStepCheckerCmd->SetParameter(param);
506}
G4ScoreQuantityMessenger::qGetUnitCmd
G4UIcmdWithoutParameter * qGetUnitCmd
Definition: G4ScoreQuantityMessenger.hh:87
G4UIcmdWithAString::SetParameterName
void SetParameterName(const char *theName, G4bool omittable, G4bool currentAsDefault=false)
Definition: G4UIcmdWithAString.cc:44
G4UIcommand::SetParameter
void SetParameter(G4UIparameter *const newParameter)
Definition: G4UIcommand.hh:146
G4UIcommand::SetGuidance
void SetGuidance(const char *aGuidance)
Definition: G4UIcommand.hh:156
G4UIparameter::SetDefaultValue
void SetDefaultValue(const char *theDefaultValue)
Definition: G4UIparameter.hh:70
G4UIparameter::SetParameterRange
void SetParameterRange(const char *theRange)
Definition: G4UIparameter.hh:87
G4UIparameter::SetDefaultUnit
void SetDefaultUnit(const char *theDefaultUnit)
Definition: G4UIparameter.cc:133
Generated by doxygen 1.9.3