Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/digits_hits/utils/src/G4ScoreQuantityMessenger.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /digits_hits/utils/src/G4ScoreQuantityMessenger.cc (Version 11.3.0) and /digits_hits/utils/src/G4ScoreQuantityMessenger.cc (Version 9.2.p1)


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