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