Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/run/src/G4UserPhysicsListMessenger.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 /run/src/G4UserPhysicsListMessenger.cc (Version 11.3.0) and /run/src/G4UserPhysicsListMessenger.cc (Version 9.6)


  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 // G4UserPhysicsListMessenger implementation   << 
 27 //                                                 26 //
 28 // Original author: H.Kurashige, 9 January 199 <<  27 // $Id$
 29 // ------------------------------------------- <<  28 //
                                                   >>  29 // 
                                                   >>  30 //---------------------------------------------------------------
                                                   >>  31 //
                                                   >>  32 //  G4UserPhysicsListMessenger.cc
                                                   >>  33 // ------------------------------------------------------------
                                                   >>  34 //  History
                                                   >>  35 //        first version                   09 Jan. 1998 by H.Kurashige 
                                                   >>  36 //        add buildPhysicsTable command   13 Apr. 1999 by H.Kurashige
                                                   >>  37 //        add setStoredInAscii command    12 Mar. 2001 by H.Kurashige
                                                   >>  38 //        add dumpOrderingParam command    3 May. 2011 by H.Kurashige
                                                   >>  39 // ------------------------------------------------------------
                                                   >>  40 
                                                   >>  41 #include <sstream>
 30                                                    42 
 31 #include "G4UserPhysicsListMessenger.hh"           43 #include "G4UserPhysicsListMessenger.hh"
 32                                                    44 
 33 #include "G4ParticleTable.hh"                  << 
 34 #include "G4PhysicsListHelper.hh"              << 
 35 #include "G4SystemOfUnits.hh"                      45 #include "G4SystemOfUnits.hh"
 36 #include "G4Tokenizer.hh"                      <<  46 #include "G4VUserPhysicsList.hh"
                                                   >>  47 #include "G4PhysicsListHelper.hh"
                                                   >>  48 #include "G4UIdirectory.hh"
                                                   >>  49 #include "G4UIcmdWithoutParameter.hh"
                                                   >>  50 #include "G4UIcmdWithAnInteger.hh"
 37 #include "G4UIcmdWithADoubleAndUnit.hh"            51 #include "G4UIcmdWithADoubleAndUnit.hh"
 38 #include "G4UIcmdWithAString.hh"                   52 #include "G4UIcmdWithAString.hh"
 39 #include "G4UIcmdWithAnInteger.hh"             <<  53 #include "G4ParticleTable.hh"
 40 #include "G4UIcmdWithoutParameter.hh"          << 
 41 #include "G4UIdirectory.hh"                    << 
 42 #include "G4UIparameter.hh"                    << 
 43 #include "G4VUserPhysicsList.hh"               << 
 44 #include "G4ios.hh"                                54 #include "G4ios.hh"
                                                   >>  55 #include "G4Tokenizer.hh"           
 45                                                    56 
 46 #include <sstream>                             <<  57 G4UserPhysicsListMessenger::G4UserPhysicsListMessenger(G4VUserPhysicsList* pParticleList):thePhysicsList(pParticleList)
 47                                                << 
 48 G4UserPhysicsListMessenger::G4UserPhysicsListM << 
 49   : thePhysicsList(pParticleList)              << 
 50 {                                                  58 {
 51   G4UIparameter* param = nullptr;              <<  59   G4UIparameter* param = 0;
 52   // /run/particle    directory                    60   // /run/particle    directory
 53   theDirectory = new G4UIdirectory("/run/parti     61   theDirectory = new G4UIdirectory("/run/particle/");
 54   theDirectory->SetGuidance("Commands for G4VU     62   theDirectory->SetGuidance("Commands for G4VUserPhysicsList.");
 55                                                    63 
 56   // /run/particle/Verbose command                 64   // /run/particle/Verbose command
 57   verboseCmd = new G4UIcmdWithAnInteger("/run/ <<  65   verboseCmd = new G4UIcmdWithAnInteger("/run/particle/verbose",this);
 58   verboseCmd->SetGuidance("Set the Verbose lev     66   verboseCmd->SetGuidance("Set the Verbose level of G4VUserPhysicsList.");
 59   verboseCmd->SetGuidance(" 0 : Silent (defaul     67   verboseCmd->SetGuidance(" 0 : Silent (default)");
 60   verboseCmd->SetGuidance(" 1 : Display warnin     68   verboseCmd->SetGuidance(" 1 : Display warning messages");
 61   verboseCmd->SetGuidance(" 2 : Display more")     69   verboseCmd->SetGuidance(" 2 : Display more");
 62   verboseCmd->SetParameterName("level", true); <<  70   verboseCmd->SetParameterName("level",true);
 63   verboseCmd->SetDefaultValue(0);                  71   verboseCmd->SetDefaultValue(0);
 64   verboseCmd->SetRange("level >=0 && level <=3     72   verboseCmd->SetRange("level >=0 && level <=3");
 65                                                <<  73   
 66   // /run/setCut command                           74   // /run/setCut command
 67   setCutCmd = new G4UIcmdWithADoubleAndUnit("/ <<  75   setCutCmd = new G4UIcmdWithADoubleAndUnit("/run/setCut",this);
 68   setCutCmd->SetGuidance("Set default cut valu     76   setCutCmd->SetGuidance("Set default cut value ");
 69   setCutCmd->SetParameterName("cut", false);   <<  77   setCutCmd->SetParameterName("cut",false);
 70   setCutCmd->SetDefaultValue(1.0);                 78   setCutCmd->SetDefaultValue(1.0);
 71   setCutCmd->SetRange("cut >=0.0");                79   setCutCmd->SetRange("cut >=0.0");
 72   setCutCmd->SetDefaultUnit("mm");                 80   setCutCmd->SetDefaultUnit("mm");
 73   setCutCmd->AvailableForStates(G4State_PreIni <<  81   setCutCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 74                                                    82 
 75   // /run/setCutForAGivenParticle command          83   // /run/setCutForAGivenParticle command
 76   setCutForAGivenParticleCmd = new G4UIcommand <<  84   setCutForAGivenParticleCmd = new G4UIcommand("/run/setCutForAGivenParticle",this) ;
 77   setCutForAGivenParticleCmd->SetGuidance("Set <<  85   setCutForAGivenParticleCmd->SetGuidance("Set a cut value to a specific particle ") ;
 78   setCutForAGivenParticleCmd->SetGuidance("Usa <<  86   setCutForAGivenParticleCmd->SetGuidance("Usage: /run/setCutForAGivenParticle  gamma  1. mm") ;
 79   param = new G4UIparameter("particleName", 's <<  87   param = new G4UIparameter("particleName",'s',false) ;
 80   param->SetParameterCandidates("e- e+ gamma p     88   param->SetParameterCandidates("e- e+ gamma proton");
 81   setCutForAGivenParticleCmd->SetParameter(par <<  89   setCutForAGivenParticleCmd->SetParameter(param) ;
 82   param = new G4UIparameter("cut", 'd', false) <<  90   param = new G4UIparameter("cut",'d',false) ;
 83   param->SetDefaultValue("1.");                <<  91   param->SetDefaultValue("1.") ;
 84   param->SetParameterRange("cut>=0.0");        <<  92   param->SetParameterRange("cut>=0.0") ;
 85   setCutForAGivenParticleCmd->SetParameter(par <<  93   setCutForAGivenParticleCmd->SetParameter(param) ;
 86   param = new G4UIparameter("unit", 's', false <<  94   param = new G4UIparameter("unit",'s',false) ;
 87   param->SetDefaultUnit("mm");                 <<  95   param->SetDefaultValue("mm") ;
 88   setCutForAGivenParticleCmd->SetParameter(par <<  96   setCutForAGivenParticleCmd->SetParameter(param) ;
 89   setCutForAGivenParticleCmd->AvailableForStat <<  97   setCutForAGivenParticleCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
 90                                                    98 
 91   // /run/getCutForAGivenParticle command          99   // /run/getCutForAGivenParticle command
 92   getCutForAGivenParticleCmd = new G4UIcmdWith << 100   getCutForAGivenParticleCmd = new G4UIcmdWithAString("/run/getCutForAGivenParticle",this) ;
 93   getCutForAGivenParticleCmd->SetGuidance("Get << 101   getCutForAGivenParticleCmd->SetGuidance("Get a cut value to a specific particle ") ;
 94   getCutForAGivenParticleCmd->SetGuidance("Usa << 102   getCutForAGivenParticleCmd->SetGuidance("Usage: /run/getCutForAGivenParticle  gamma ") ;
 95   getCutForAGivenParticleCmd->SetParameterName << 103   getCutForAGivenParticleCmd->SetParameterName("particleName",false,false) ;
 96   getCutForAGivenParticleCmd->SetCandidates("e    104   getCutForAGivenParticleCmd->SetCandidates("e- e+ gamma proton");
 97   getCutForAGivenParticleCmd->AvailableForStat << 105   getCutForAGivenParticleCmd->AvailableForStates(G4State_PreInit,G4State_Idle,G4State_GeomClosed,G4State_EventProc);
 98                                                << 
 99                                                   106 
100   // /run/setCutForRegion command                 107   // /run/setCutForRegion command
101   setCutRCmd = new G4UIcommand("/run/setCutFor << 108   setCutRCmd = new G4UIcommand("/run/setCutForRegion",this);
102   setCutRCmd->SetGuidance("Set cut value for a    109   setCutRCmd->SetGuidance("Set cut value for a region");
103   param = new G4UIparameter("Region", 's', fal << 110   param = new G4UIparameter("Region",'s',false);
104   setCutRCmd->SetParameter(param);                111   setCutRCmd->SetParameter(param);
105   param = new G4UIparameter("cut", 'd', false) << 112   param = new G4UIparameter("cut",'d',false);
106   param->SetParameterRange("cut >=0.0");          113   param->SetParameterRange("cut >=0.0");
107   setCutRCmd->SetParameter(param);                114   setCutRCmd->SetParameter(param);
108   param = new G4UIparameter("Unit", 's', true) << 115   param = new G4UIparameter("Unit",'s',true);
109   param->SetDefaultValue("mm");                   116   param->SetDefaultValue("mm");
110   param->SetParameterCandidates(setCutRCmd->Un    117   param->SetParameterCandidates(setCutRCmd->UnitsList(setCutRCmd->CategoryOf("mm")));
111   setCutRCmd->SetParameter(param);                118   setCutRCmd->SetParameter(param);
112   setCutRCmd->AvailableForStates(G4State_Idle)    119   setCutRCmd->AvailableForStates(G4State_Idle);
113                                                   120 
114   // /run/particle/DumpList command               121   // /run/particle/DumpList command
115   dumpListCmd = new G4UIcmdWithoutParameter("/ << 122   dumpListCmd = new G4UIcmdWithoutParameter("/run/particle/dumpList",this);
116   dumpListCmd->SetGuidance("Dump List of parti    123   dumpListCmd->SetGuidance("Dump List of particles in G4VUserPhysicsList. ");
117                                                   124 
118   // /run/particle/addProcManager command         125   // /run/particle/addProcManager command
119   addProcManCmd = new G4UIcmdWithAString("/run    126   addProcManCmd = new G4UIcmdWithAString("/run/particle/addProcManager", this);
120   addProcManCmd->SetToBeBroadcasted(false);    << 
121   addProcManCmd->SetGuidance("add process mana    127   addProcManCmd->SetGuidance("add process manager to specified particle type");
122   addProcManCmd->SetParameterName("particleTyp    128   addProcManCmd->SetParameterName("particleType", true);
123   addProcManCmd->SetDefaultValue("");             129   addProcManCmd->SetDefaultValue("");
124   addProcManCmd->AvailableForStates(G4State_Pr << 130   addProcManCmd->AvailableForStates(G4State_Init,G4State_Idle,G4State_GeomClosed,G4State_EventProc);
125                                     G4State_Ev << 
126                                                   131 
127   // /run/particle/buildPhysicsTable command      132   // /run/particle/buildPhysicsTable command
128   buildPTCmd = new G4UIcmdWithAString("/run/pa    133   buildPTCmd = new G4UIcmdWithAString("/run/particle/buildPhysicsTable", this);
129   buildPTCmd->SetGuidance("build physics table    134   buildPTCmd->SetGuidance("build physics table of specified particle type");
130   buildPTCmd->SetParameterName("particleType",    135   buildPTCmd->SetParameterName("particleType", true);
131   buildPTCmd->SetDefaultValue("");                136   buildPTCmd->SetDefaultValue("");
132   buildPTCmd->AvailableForStates(G4State_Init, << 137   buildPTCmd->AvailableForStates(G4State_Init,G4State_Idle,G4State_GeomClosed,G4State_EventProc);
133                                                   138 
134   // /run/particle/storePhysicsTable command      139   // /run/particle/storePhysicsTable command
135   storeCmd = new G4UIcmdWithAString("/run/part << 140   storeCmd = new G4UIcmdWithAString("/run/particle/storePhysicsTable",this);
136   storeCmd->SetGuidance("Store Physics Table")    141   storeCmd->SetGuidance("Store Physics Table");
137   storeCmd->SetGuidance("  Enter directory nam    142   storeCmd->SetGuidance("  Enter directory name");
138   storeCmd->SetParameterName("dirName", true); << 143   storeCmd->SetParameterName("dirName",true);
139   storeCmd->SetDefaultValue("");                  144   storeCmd->SetDefaultValue("");
140   storeCmd->AvailableForStates(G4State_Idle);     145   storeCmd->AvailableForStates(G4State_Idle);
141                                                   146 
142   //  /run/particle/retrievePhysicsTable comma    147   //  /run/particle/retrievePhysicsTable command
143   retrieveCmd = new G4UIcmdWithAString("/run/p << 148   retrieveCmd = new G4UIcmdWithAString("/run/particle/retrievePhysicsTable",this);
144   retrieveCmd->SetGuidance("Retrieve Physics T    149   retrieveCmd->SetGuidance("Retrieve Physics Table");
145   retrieveCmd->SetGuidance("  Enter directory     150   retrieveCmd->SetGuidance("  Enter directory name or OFF to switch off");
146   retrieveCmd->SetParameterName("dirName", tru << 151   retrieveCmd->SetParameterName("dirName",true);
147   retrieveCmd->SetDefaultValue("");               152   retrieveCmd->SetDefaultValue("");
148   retrieveCmd->AvailableForStates(G4State_PreI << 153   retrieveCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
149                                                   154 
150   //  /run/particle/setStoredInAscii command      155   //  /run/particle/setStoredInAscii command
151   asciiCmd = new G4UIcmdWithAnInteger("/run/pa << 156   asciiCmd = new G4UIcmdWithAnInteger("/run/particle/setStoredInAscii",this);
152   asciiCmd->SetGuidance("Switch on/off ascii m << 157   asciiCmd->SetGuidance("Switch on/off ascii mode in store/retreive Physics Table");
153   asciiCmd->SetGuidance("  Enter 0(binary) or     158   asciiCmd->SetGuidance("  Enter 0(binary) or 1(ascii)");
154   asciiCmd->SetParameterName("ascii", true);   << 159   asciiCmd->SetParameterName("ascii",true);
155   asciiCmd->SetDefaultValue(0);                   160   asciiCmd->SetDefaultValue(0);
156   asciiCmd->AvailableForStates(G4State_PreInit << 161   asciiCmd->AvailableForStates(G4State_PreInit,G4State_Idle);
157   asciiCmd->SetRange("ascii ==0 || ascii ==1")    162   asciiCmd->SetRange("ascii ==0 || ascii ==1");
158                                                   163 
159   // Commnad    /run/particle/applyCuts comman << 164   //Commnad    /run/particle/applyCuts command
160   applyCutsCmd = new G4UIcommand("/run/particl << 165   applyCutsCmd = new G4UIcommand("/run/particle/applyCuts",this);
161   applyCutsCmd->SetGuidance("Set applyCuts fla    166   applyCutsCmd->SetGuidance("Set applyCuts flag for a particle.");
162   applyCutsCmd->SetGuidance(" Some EM processe    167   applyCutsCmd->SetGuidance(" Some EM processes which do not have infrared divergence");
163   applyCutsCmd->SetGuidance("may generate gamm    168   applyCutsCmd->SetGuidance("may generate gamma, e- and/or e+ with kinetic energies");
164   applyCutsCmd->SetGuidance("below the product    169   applyCutsCmd->SetGuidance("below the production threshold. By setting this flag,");
165   applyCutsCmd->SetGuidance("such secondaries     170   applyCutsCmd->SetGuidance("such secondaries below threshold are eliminated and");
166   applyCutsCmd->SetGuidance("kinetic energies     171   applyCutsCmd->SetGuidance("kinetic energies of such secondaries are accumulated");
167   applyCutsCmd->SetGuidance("to the energy dep    172   applyCutsCmd->SetGuidance("to the energy deposition of their mother.");
168   applyCutsCmd->SetGuidance(" Note that 'apply    173   applyCutsCmd->SetGuidance(" Note that 'applyCuts' makes sense only for gamma,");
169   applyCutsCmd->SetGuidance("e- and e+. If thi    174   applyCutsCmd->SetGuidance("e- and e+. If this command is issued for other particle,");
170   applyCutsCmd->SetGuidance("a warning message    175   applyCutsCmd->SetGuidance("a warning message is displayed and the command is");
171   applyCutsCmd->SetGuidance("ignored.");          176   applyCutsCmd->SetGuidance("ignored.");
172   applyCutsCmd->SetGuidance(" If particle name    177   applyCutsCmd->SetGuidance(" If particle name is 'all', this command affects on");
173   applyCutsCmd->SetGuidance("gamma, e- and e+.    178   applyCutsCmd->SetGuidance("gamma, e- and e+.");
174   param = new G4UIparameter("Flag", 's', true) << 179   param = new G4UIparameter("Flag",'s',true);
175   param->SetDefaultValue("true");                 180   param->SetDefaultValue("true");
176   applyCutsCmd->SetParameter(param);              181   applyCutsCmd->SetParameter(param);
177   param = new G4UIparameter("Particle", 's', t << 182   param = new G4UIparameter("Particle",'s',true);
178   param->SetDefaultValue("all");                  183   param->SetDefaultValue("all");
179   applyCutsCmd->SetParameter(param);              184   applyCutsCmd->SetParameter(param);
180   applyCutsCmd->AvailableForStates(G4State_Pre << 185   applyCutsCmd->AvailableForStates(G4State_PreInit,G4State_Init,G4State_Idle);
181                                                   186 
182   //  /run/particle/dumpCutValues command         187   //  /run/particle/dumpCutValues command
183   dumpCutValuesCmd = new G4UIcmdWithAString("/ << 188   dumpCutValuesCmd = new G4UIcmdWithAString("/run/particle/dumpCutValues",this);
184   dumpCutValuesCmd->SetGuidance("Dump a list o    189   dumpCutValuesCmd->SetGuidance("Dump a list of production threshold values in range and energy");
185   dumpCutValuesCmd->SetGuidance("for all regis    190   dumpCutValuesCmd->SetGuidance("for all registered material-cuts-couples.");
186   dumpCutValuesCmd->SetGuidance("Dumping a lis    191   dumpCutValuesCmd->SetGuidance("Dumping a list takes place when you issue 'beamOn' and");
187   dumpCutValuesCmd->SetGuidance("actual conver    192   dumpCutValuesCmd->SetGuidance("actual conversion tables from range to energy are available.");
188   dumpCutValuesCmd->SetGuidance(               << 193   dumpCutValuesCmd->SetGuidance("If you want a list 'immediately', use '/run/dumpRegion' for threshold");
189     "If you want a list 'immediately', use '/r << 194   dumpCutValuesCmd->SetGuidance("list given in gange only. Also, '/run/dumpCouples' gives you the");
190   dumpCutValuesCmd->SetGuidance("list given in << 195   dumpCutValuesCmd->SetGuidance("current list if you have already issued 'run/beamOn' at least once.");
191   dumpCutValuesCmd->SetGuidance(               << 196   dumpCutValuesCmd->SetParameterName("particle",true);
192     "current list if you have already issued ' << 
193   dumpCutValuesCmd->SetParameterName("particle << 
194   dumpCutValuesCmd->SetDefaultValue("all");       197   dumpCutValuesCmd->SetDefaultValue("all");
195   dumpCutValuesCmd->AvailableForStates(G4State    198   dumpCutValuesCmd->AvailableForStates(G4State_Idle);
196                                                   199 
197   //  /run/particle/dumpCutValues command         200   //  /run/particle/dumpCutValues command
198   dumpOrdParamCmd = new G4UIcmdWithAnInteger(" << 201   dumpOrdParamCmd = new G4UIcmdWithAnInteger("/run/particle/dumpOrderingParam",this);
199   dumpOrdParamCmd->SetGuidance("Dump a list of    202   dumpOrdParamCmd->SetGuidance("Dump a list of ordering parameter ");
200   dumpOrdParamCmd->SetParameterName("subtype", << 203   dumpOrdParamCmd->SetParameterName("subtype",true);
201   dumpOrdParamCmd->SetDefaultValue(-1);           204   dumpOrdParamCmd->SetDefaultValue(-1);
202   dumpOrdParamCmd->AvailableForStates(G4State_ << 205   dumpOrdParamCmd->AvailableForStates(G4State_PreInit,G4State_Init,G4State_Idle);
203 }                                                 206 }
204                                                   207 
205 // ------------------------------------------- << 
206 G4UserPhysicsListMessenger::~G4UserPhysicsList    208 G4UserPhysicsListMessenger::~G4UserPhysicsListMessenger()
207 {                                                 209 {
208   delete setCutCmd;                            << 210   delete setCutCmd; 
209   delete setCutRCmd;                              211   delete setCutRCmd;
210   delete setCutForAGivenParticleCmd;              212   delete setCutForAGivenParticleCmd;
211   delete getCutForAGivenParticleCmd;              213   delete getCutForAGivenParticleCmd;
212   delete verboseCmd;                              214   delete verboseCmd;
213   delete dumpListCmd;                             215   delete dumpListCmd;
214   delete addProcManCmd;                           216   delete addProcManCmd;
215   delete buildPTCmd;                              217   delete buildPTCmd;
216   delete storeCmd;                             << 218   delete storeCmd;  
217   delete retrieveCmd;                             219   delete retrieveCmd;
218   delete asciiCmd;                                220   delete asciiCmd;
219   delete applyCutsCmd;                            221   delete applyCutsCmd;
220   delete dumpCutValuesCmd;                        222   delete dumpCutValuesCmd;
221   delete dumpOrdParamCmd;                         223   delete dumpOrdParamCmd;
222   delete theDirectory;                            224   delete theDirectory;
223 }                                                 225 }
224                                                   226 
225 // ------------------------------------------- << 227 void G4UserPhysicsListMessenger::SetNewValue(G4UIcommand * command,G4String newValue)
226 void G4UserPhysicsListMessenger::SetNewValue(G << 
227 {                                                 228 {
228   G4ExceptionDescription ed;                   << 229   if( command==setCutCmd ){
229   if (command == setCutCmd) {                  << 230     G4double newCut = setCutCmd->GetNewDoubleValue(newValue); 
230     G4double newCut = setCutCmd->GetNewDoubleV << 
231     thePhysicsList->SetDefaultCutValue(newCut)    231     thePhysicsList->SetDefaultCutValue(newCut);
232     thePhysicsList->SetCuts();                    232     thePhysicsList->SetCuts();
233   }                                            << 233 
234   else if (command == setCutForAGivenParticleC << 234   } else if( command==setCutForAGivenParticleCmd ){
235     G4String particleName, unit;               << 235     G4String particleName, unit ; G4double cut ;
236     G4double cut;                              << 236     std::istringstream str (newValue) ;
237     std::istringstream str(newValue);          << 237     str >> particleName >> cut >> unit ;
238     str >> particleName >> cut >> unit;        << 238     thePhysicsList->SetCutValue(cut*G4UIcommand::ValueOf(unit), particleName) ; 
239     thePhysicsList->SetCutValue(cut * G4UIcomm << 239 
240   }                                            << 240    } else if( command==getCutForAGivenParticleCmd ){
241   else if (command == getCutForAGivenParticleC << 241     G4cout << thePhysicsList->GetCutValue(newValue)/mm <<"[mm]" << G4endl ;
242     G4cout << thePhysicsList->GetCutValue(newV << 242 
243   }                                            << 243   } else if( command==setCutRCmd ){
244   else if (command == setCutRCmd) {            << 
245     std::istringstream is(newValue);              244     std::istringstream is(newValue);
246     G4String regName;                             245     G4String regName;
247     G4String uniName;                             246     G4String uniName;
248     G4double cVal = -1.0;                         247     G4double cVal = -1.0;
249     is >> regName >> cVal >> uniName;             248     is >> regName >> cVal >> uniName;
250     if (is.fail()) {                              249     if (is.fail()) {
251       ed << "illegal arguments : " << newValue << 250       G4cout << "illegal arguments : try again " << G4endl;
252       command->CommandFailed(ed);              << 
253       return;                                     251       return;
254     }                                             252     }
255     thePhysicsList->SetCutsForRegion(cVal * (s << 253     thePhysicsList->SetCutsForRegion(cVal*(setCutRCmd->ValueOf(uniName)),regName);
256   }                                            << 254 
257   else if (command == verboseCmd) {            << 255   } else if( command==verboseCmd ) {
258     thePhysicsList->SetVerboseLevel(verboseCmd << 256     thePhysicsList->SetVerboseLevel(verboseCmd->GetNewIntValue(newValue)); 
259   }                                            << 257 
260   else if (command == dumpListCmd) {           << 258   } else if( command==dumpListCmd ){
261     thePhysicsList->DumpList();                   259     thePhysicsList->DumpList();
262   }                                            << 260 
263   else if (command == dumpOrdParamCmd) {       << 261   } else if( command==dumpOrdParamCmd ){
264     G4int stype = dumpOrdParamCmd->GetNewIntVa    262     G4int stype = dumpOrdParamCmd->GetNewIntValue(newValue);
265     G4PhysicsListHelper::GetPhysicsListHelper(    263     G4PhysicsListHelper::GetPhysicsListHelper()->DumpOrdingParameterTable(stype);
266   }                                            << 264 
267   else if (command == addProcManCmd) {         << 265   }  else if( command == addProcManCmd ){
268     G4ParticleDefinition* particle = (G4Partic    266     G4ParticleDefinition* particle = (G4ParticleTable::GetParticleTable())->FindParticle(newValue);
269     if (particle == nullptr) {                 << 267     if (particle == 0) return;
270       ed << " Particle is not found : " << new << 268     if (particle->GetProcessManager() != 0) return;
271       command->CommandFailed(ed);              << 
272       return;                                  << 
273     }                                          << 
274     if (particle->GetProcessManager() != nullp << 
275       ed << " Particle is not initialized : "  << 
276       command->CommandFailed(ed);              << 
277       return;                                  << 
278     }                                          << 
279     thePhysicsList->AddProcessManager(particle    269     thePhysicsList->AddProcessManager(particle);
280   }                                            << 270 
281   else if (command == buildPTCmd) {            << 271   }  else if( command == buildPTCmd ){
282     G4ParticleDefinition* particle = (G4Partic    272     G4ParticleDefinition* particle = (G4ParticleTable::GetParticleTable())->FindParticle(newValue);
283     if (particle == nullptr) {                 << 273     if (particle == 0) return;
284       ed << " Particle is not found : " << new << 
285       command->CommandFailed(ed);              << 
286       return;                                  << 
287     }                                          << 
288     thePhysicsList->PreparePhysicsTable(partic    274     thePhysicsList->PreparePhysicsTable(particle);
289     thePhysicsList->BuildPhysicsTable(particle    275     thePhysicsList->BuildPhysicsTable(particle);
290   }                                            << 276     
291   else if (command == storeCmd) {              << 277   } else if ( command == storeCmd ){
292     thePhysicsList->StorePhysicsTable(newValue    278     thePhysicsList->StorePhysicsTable(newValue);
293   }                                            << 279   
294   else if (command == retrieveCmd) {           << 280   } else if( command == retrieveCmd ) {
295     if ((newValue == "OFF") || (newValue == "o << 281     if ((newValue == "OFF") || (newValue == "off") ){
296       thePhysicsList->ResetPhysicsTableRetriev    282       thePhysicsList->ResetPhysicsTableRetrieved();
297     }                                          << 283     } else {
298     else {                                     << 
299       thePhysicsList->SetPhysicsTableRetrieved    284       thePhysicsList->SetPhysicsTableRetrieved(newValue);
300     }                                             285     }
301   }                                            << 286 
302   else if (command == asciiCmd) {              << 287   } else if( command == asciiCmd ) {
303     if (asciiCmd->GetNewIntValue(newValue) ==     288     if (asciiCmd->GetNewIntValue(newValue) == 0) {
304       thePhysicsList->ResetStoredInAscii();       289       thePhysicsList->ResetStoredInAscii();
305     }                                          << 290     } else {
306     else {                                     << 
307       thePhysicsList->SetStoredInAscii();         291       thePhysicsList->SetStoredInAscii();
308     }                                             292     }
309   }                                            << 293 
310   else if (command == applyCutsCmd) {          << 294   } else if( command == applyCutsCmd ) {
311     G4Tokenizer next(newValue);                << 295     G4Tokenizer next( newValue );
312                                                   296 
313     // check 1st argument                         297     // check 1st argument
314     G4String temp = G4String(next());             298     G4String temp = G4String(next());
315     G4bool flag = (temp == "true" || temp == " << 299     G4bool flag = (temp =="true" || temp=="TRUE");
316                                                   300 
317     // check 2nd argument                         301     // check 2nd argument
318     G4String name = G4String(next());             302     G4String name = G4String(next());
319                                                   303 
320     thePhysicsList->SetApplyCuts(flag, name);     304     thePhysicsList->SetApplyCuts(flag, name);
321   }                                            << 305  
322   else if (command == dumpCutValuesCmd) {      << 306   } else if( command == dumpCutValuesCmd ) {
323     thePhysicsList->DumpCutValuesTable(1);        307     thePhysicsList->DumpCutValuesTable(1);
                                                   >> 308 
324   }                                               309   }
325 }                                              << 310 } 
326                                                   311 
327 // ------------------------------------------- << 312 G4String G4UserPhysicsListMessenger::GetCurrentValue(G4UIcommand * command)
328 G4String G4UserPhysicsListMessenger::GetCurren << 
329 {                                                 313 {
330   G4String cv;                                    314   G4String cv;
331   G4String candidates("none");                    315   G4String candidates("none");
332   auto piter = G4ParticleTable::GetParticleTab << 316   G4ParticleTable::G4PTblDicIterator *piter = (G4ParticleTable::GetParticleTable())->GetIterator();
333                                                << 317   
334   if (command == setCutCmd) {                  << 318   if( command==setCutCmd ) {
335     cv = setCutCmd->ConvertToString(thePhysics << 319     cv = setCutCmd->ConvertToString( thePhysicsList->GetDefaultCutValue(), "mm" );
336   }                                            << 320     
337   else if (command == verboseCmd) {            << 321   } else if( command==verboseCmd ){
338     cv = verboseCmd->ConvertToString(thePhysic    322     cv = verboseCmd->ConvertToString(thePhysicsList->GetVerboseLevel());
339   }                                            << 323     
340   else if (command == addProcManCmd) {         << 324   }  else if( command== addProcManCmd ){
341     // set candidate list                         325     // set candidate list
342     piter->reset();                            << 326     piter -> reset();
343     while ((*piter)()) {                       << 327     while( (*piter)() ){
344       G4ParticleDefinition* particle = piter-> << 328       G4ParticleDefinition *particle = piter->value();
345       candidates += " " + particle->GetParticl    329       candidates += " " + particle->GetParticleName();
346     }                                             330     }
347     addProcManCmd->SetCandidates(candidates);  << 331     addProcManCmd->SetCandidates(candidates);   
348     cv = "";                                      332     cv = "";
349   }                                            << 333     
350   else if (command == buildPTCmd) {            << 334   }  else if( command== buildPTCmd ){
351     // set candidate list                         335     // set candidate list
352     piter->reset();                            << 336     piter -> reset();
353     while ((*piter)()) {                       << 337     while( (*piter)() ){
354       G4ParticleDefinition* particle = piter-> << 338       G4ParticleDefinition *particle = piter->value();
355       candidates += " " + particle->GetParticl    339       candidates += " " + particle->GetParticleName();
356     }                                             340     }
357     addProcManCmd->SetCandidates(candidates);  << 341     addProcManCmd->SetCandidates(candidates);   
358     cv = "";                                      342     cv = "";
359   }                                            << 343     
360   else if (command == storeCmd) {              << 344   } else if ( command == storeCmd ){
361     cv = thePhysicsList->GetPhysicsTableDirect    345     cv = thePhysicsList->GetPhysicsTableDirectory();
362   }                                            << 346 
363   else if (command == retrieveCmd) {           << 347   }else if( command == retrieveCmd ) {
364     if (thePhysicsList->IsPhysicsTableRetrieve    348     if (thePhysicsList->IsPhysicsTableRetrieved()) {
365       cv = thePhysicsList->GetPhysicsTableDire    349       cv = thePhysicsList->GetPhysicsTableDirectory();
366     }                                          << 350     } else {
367     else {                                     << 
368       cv = "OFF";                                 351       cv = "OFF";
369     }                                             352     }
370   }                                            << 353 
371   else if (command == asciiCmd) {              << 354   } else if( command==asciiCmd ){
372     if (thePhysicsList->IsStoredInAscii()) {   << 355     if (thePhysicsList->IsStoredInAscii()){
373       cv = "1";                                   356       cv = "1";
374     }                                          << 357     } else {
375     else {                                     << 
376       cv = "0";                                   358       cv = "0";
377     }                                             359     }
378   }                                            << 
379                                                   360 
                                                   >> 361 //  } else if( command == applyCutsCmd ) {
                                                   >> 362 //   if (thePhysicsList->GetApplyCuts("gamma")){
                                                   >> 363 //     cv =  "true";
                                                   >> 364 //   } else {
                                                   >> 365 //     cv =  "false";
                                                   >> 366 //   } 
                                                   >> 367   }
                                                   >> 368    
380   return cv;                                      369   return cv;
381 }                                                 370 }
382                                                   371