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