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