Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/management/src/G4ProcessTableMessenger.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 /processes/management/src/G4ProcessTableMessenger.cc (Version 11.3.0) and /processes/management/src/G4ProcessTableMessenger.cc (Version 11.1.3)


  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 // G4ProcessTableMessenger class implementatio     26 // G4ProcessTableMessenger class implementation
 27 //                                                 27 //
 28 // Author: H.Kurashige, 15 August 1998             28 // Author: H.Kurashige, 15 August 1998
 29 // -------------------------------------------     29 // --------------------------------------------------------------------
 30                                                    30 
 31 #include "G4ProcessTableMessenger.hh"              31 #include "G4ProcessTableMessenger.hh"
 32                                                    32 
 33 #include "G4UImanager.hh"                          33 #include "G4UImanager.hh"
 34 #include "G4UIdirectory.hh"                        34 #include "G4UIdirectory.hh"
 35 #include "G4UIcmdWithoutParameter.hh"              35 #include "G4UIcmdWithoutParameter.hh"
 36 #include "G4UIcmdWithAnInteger.hh"                 36 #include "G4UIcmdWithAnInteger.hh"
 37 #include "G4UIcmdWithAString.hh"                   37 #include "G4UIcmdWithAString.hh"
 38                                                    38 
 39 #include "G4VProcess.hh"                           39 #include "G4VProcess.hh"
 40 #include "G4ProcessManager.hh"                     40 #include "G4ProcessManager.hh"
 41 #include "G4ProcessTable.hh"                       41 #include "G4ProcessTable.hh"
 42 #include "G4ParticleTable.hh"                      42 #include "G4ParticleTable.hh"
 43                                                    43 
 44 #include "G4ios.hh"                                44 #include "G4ios.hh"                 
 45 #include "G4Tokenizer.hh"                          45 #include "G4Tokenizer.hh"
 46 #include <iomanip>                                 46 #include <iomanip>               
 47 #include <sstream>                                 47 #include <sstream>
 48                                                    48 
 49 G4ThreadLocal G4int G4ProcessTableMessenger::N     49 G4ThreadLocal G4int G4ProcessTableMessenger::NumberOfProcessType = 10;
 50                                                    50 
 51 // -------------------------------------------     51 // --------------------------------------------------------------------
 52 G4ProcessTableMessenger::G4ProcessTableMesseng     52 G4ProcessTableMessenger::G4ProcessTableMessenger(G4ProcessTable* pTable)
 53   : theProcessTable(pTable)                        53   : theProcessTable(pTable)
 54 {                                                  54 { 
 55   // Command   /particle/process                   55   // Command   /particle/process
 56   thisDirectory = new G4UIdirectory("/process/     56   thisDirectory = new G4UIdirectory("/process/");
 57   thisDirectory->SetGuidance("Process Table co     57   thisDirectory->SetGuidance("Process Table control commands.");
 58                                                    58 
 59   // Command   /particle/process/list              59   // Command   /particle/process/list
 60   listCmd = new G4UIcmdWithAString("/process/l     60   listCmd = new G4UIcmdWithAString("/process/list",this);
 61   listCmd->SetGuidance("List up process names"     61   listCmd->SetGuidance("List up process names");
 62   listCmd->SetGuidance("  list [type] ");          62   listCmd->SetGuidance("  list [type] ");
 63   listCmd->SetGuidance("    type: process type     63   listCmd->SetGuidance("    type: process type [all:for all processes]");
 64   listCmd->SetParameterName("type", true);         64   listCmd->SetParameterName("type", true);
 65   listCmd->SetDefaultValue("all");                 65   listCmd->SetDefaultValue("all");
 66   SetNumberOfProcessType();                        66   SetNumberOfProcessType();
 67                                                    67  
 68   G4String candidates("all");                      68   G4String candidates("all");
 69   for (G4int idx = 0; idx < NumberOfProcessTyp     69   for (G4int idx = 0; idx < NumberOfProcessType ; ++idx )
 70   {                                                70   {
 71     candidates += " " + G4VProcess::GetProcess     71     candidates += " " + G4VProcess::GetProcessTypeName(G4ProcessType(idx));
 72   }                                                72   }
 73   listCmd->SetCandidates((const char*)(candida     73   listCmd->SetCandidates((const char*)(candidates));
 74                                                    74 
 75   // Command   /particle/process/verbose           75   // Command   /particle/process/verbose
 76   verboseCmd = new G4UIcmdWithAnInteger("/proc     76   verboseCmd = new G4UIcmdWithAnInteger("/process/verbose",this);
 77   verboseCmd->SetGuidance("Set Verbose Level f     77   verboseCmd->SetGuidance("Set Verbose Level for Process Table");
 78   verboseCmd->SetGuidance("  verbose [level]")     78   verboseCmd->SetGuidance("  verbose [level]");
 79   verboseCmd->SetGuidance("   level: verbose l     79   verboseCmd->SetGuidance("   level: verbose level");
 80   verboseCmd->SetParameterName("verbose", true     80   verboseCmd->SetParameterName("verbose", true);
 81   verboseCmd->SetDefaultValue(1);                  81   verboseCmd->SetDefaultValue(1);
 82   verboseCmd->SetRange("verbose >=0");             82   verboseCmd->SetRange("verbose >=0");
 83   verboseCmd->AvailableForStates(G4State_PreIn     83   verboseCmd->AvailableForStates(G4State_PreInit,G4State_Init,G4State_Idle,G4State_GeomClosed,G4State_EventProc);
 84                                                    84 
 85   // Command   /particle/process/setVerbose        85   // Command   /particle/process/setVerbose
 86   procVerboseCmd = new G4UIcommand("/process/s     86   procVerboseCmd = new G4UIcommand("/process/setVerbose",this);
 87   procVerboseCmd->SetGuidance("Set verbose lev     87   procVerboseCmd->SetGuidance("Set verbose level for processes");
 88   procVerboseCmd->SetGuidance("  setVerbose le     88   procVerboseCmd->SetGuidance("  setVerbose level [type or name] ");
 89   procVerboseCmd->SetGuidance("    level: verb     89   procVerboseCmd->SetGuidance("    level: verbose level ");
 90   procVerboseCmd->SetGuidance("    name : proc     90   procVerboseCmd->SetGuidance("    name : process name ");
 91   procVerboseCmd->SetGuidance("    type : proc     91   procVerboseCmd->SetGuidance("    type : process type ");
 92   procVerboseCmd->SetGuidance("       [all] fo     92   procVerboseCmd->SetGuidance("       [all] for all processes ");
 93   G4UIparameter* param = new G4UIparameter("ve     93   G4UIparameter* param = new G4UIparameter("verbose",'i',false);
 94   procVerboseCmd->SetParameter(param);             94   procVerboseCmd->SetParameter(param);
 95   param = new G4UIparameter("type",'s',true);      95   param = new G4UIparameter("type",'s',true);
 96   param->SetDefaultValue("all");                   96   param->SetDefaultValue("all");
 97   procVerboseCmd->SetParameter(param);             97   procVerboseCmd->SetParameter(param);
 98   procVerboseCmd->AvailableForStates(G4State_I     98   procVerboseCmd->AvailableForStates(G4State_Idle,G4State_GeomClosed,G4State_EventProc);
 99                                                    99  
100   // Command   /particle/process/dump             100   // Command   /particle/process/dump
101   dumpCmd = new G4UIcommand("/process/dump",th    101   dumpCmd = new G4UIcommand("/process/dump",this);
102   dumpCmd->SetGuidance("Dump process informati    102   dumpCmd->SetGuidance("Dump process information");
103   dumpCmd->SetGuidance(" dump name [particle]"    103   dumpCmd->SetGuidance(" dump name [particle]");
104   dumpCmd->SetGuidance("   name:     process n    104   dumpCmd->SetGuidance("   name:     process name or type name");
105   dumpCmd->SetGuidance("   particle: particle     105   dumpCmd->SetGuidance("   particle: particle name [all: for all particles]");
106   param = new G4UIparameter("procName",'s',fal    106   param = new G4UIparameter("procName",'s',false);
107   dumpCmd->SetParameter(param);                   107   dumpCmd->SetParameter(param);
108   param = new G4UIparameter("particle",'s',tru    108   param = new G4UIparameter("particle",'s',true);
109   param->SetDefaultValue("all");                  109   param->SetDefaultValue("all");
110   dumpCmd->SetParameter(param);                   110   dumpCmd->SetParameter(param);
111   dumpCmd->AvailableForStates(G4State_Init,G4S    111   dumpCmd->AvailableForStates(G4State_Init,G4State_Idle,G4State_GeomClosed,G4State_EventProc);
112                                                   112 
113   // Command   /process/activate                  113   // Command   /process/activate
114   activateCmd = new G4UIcommand("/process/acti    114   activateCmd = new G4UIcommand("/process/activate",this);
115   activateCmd->SetGuidance("Activate processes    115   activateCmd->SetGuidance("Activate processes  ");
116   activateCmd->SetGuidance(" Activate  name [p    116   activateCmd->SetGuidance(" Activate  name [particle]");
117   activateCmd->SetGuidance("   name:     proce    117   activateCmd->SetGuidance("   name:     process name or type name");
118   activateCmd->SetGuidance("   particle: parti    118   activateCmd->SetGuidance("   particle: particle name [all: for all particles]");
119   param = new G4UIparameter("procName",'s',fal    119   param = new G4UIparameter("procName",'s',false);
120   activateCmd->SetParameter(param);               120   activateCmd->SetParameter(param);
121   param = new G4UIparameter("particle",'s',tru    121   param = new G4UIparameter("particle",'s',true);
122   param->SetDefaultValue("all");                  122   param->SetDefaultValue("all");
123   activateCmd->SetParameter(param);               123   activateCmd->SetParameter(param);
124   activateCmd->AvailableForStates(G4State_Idle    124   activateCmd->AvailableForStates(G4State_Idle);
125                                                   125   
126   // Command   /process/inactivate                126   // Command   /process/inactivate
127   inactivateCmd = new G4UIcommand("/process/in    127   inactivateCmd = new G4UIcommand("/process/inactivate",this);
128   inactivateCmd->SetGuidance("Inactivate proce    128   inactivateCmd->SetGuidance("Inactivate process  ");
129   inactivateCmd->SetGuidance("Inactivate proce    129   inactivateCmd->SetGuidance("Inactivate processes  ");
130   inactivateCmd->SetGuidance(" Inactivate  nam    130   inactivateCmd->SetGuidance(" Inactivate  name [particle]");
131   inactivateCmd->SetGuidance("   name:     pro    131   inactivateCmd->SetGuidance("   name:     process name or type name");
132   inactivateCmd->SetGuidance("   particle: par    132   inactivateCmd->SetGuidance("   particle: particle name [all: for all particles]");
133   param = new G4UIparameter("procName",'s',fal    133   param = new G4UIparameter("procName",'s',false);
134   inactivateCmd->SetParameter(param);             134   inactivateCmd->SetParameter(param);
135   param = new G4UIparameter("particle",'s',tru    135   param = new G4UIparameter("particle",'s',true);
136   param->SetDefaultValue("all");                  136   param->SetDefaultValue("all");
137   inactivateCmd->SetParameter(param);             137   inactivateCmd->SetParameter(param);
138   inactivateCmd->AvailableForStates(G4State_Id    138   inactivateCmd->AvailableForStates(G4State_Idle);
139 }                                                 139 }
140                                                   140 
141 // -------------------------------------------    141 // --------------------------------------------------------------------
142 G4ProcessTableMessenger::~G4ProcessTableMessen    142 G4ProcessTableMessenger::~G4ProcessTableMessenger()
143 {                                                 143 {
144   delete activateCmd;                             144   delete activateCmd; 
145   delete inactivateCmd;                           145   delete inactivateCmd; 
146   delete verboseCmd;                              146   delete verboseCmd;
147   delete dumpCmd;                                 147   delete dumpCmd;
148   delete listCmd;                                 148   delete listCmd;
149   delete procVerboseCmd;                          149   delete procVerboseCmd;
150   delete thisDirectory;                           150   delete thisDirectory;
151 }                                                 151 }
152                                                   152 
153 // -------------------------------------------    153 // --------------------------------------------------------------------
154 void                                              154 void
155 G4ProcessTableMessenger::SetNewValue(G4UIcomma    155 G4ProcessTableMessenger::SetNewValue(G4UIcommand* command, G4String newValue)
156 {                                                 156 {
157   G4ProcessTable::G4ProcNameVector* procNameVe    157   G4ProcessTable::G4ProcNameVector* procNameVector 
158                          = theProcessTable->Ge    158                          = theProcessTable->GetNameList(); 
159   G4int type = -1;                                159   G4int type = -1;
160   G4ExceptionDescription ed;                      160   G4ExceptionDescription ed;
161                                                   161 
162   if( command == listCmd )                        162   if( command == listCmd )
163   {                                               163   {
164     // Command  /process/list                     164     // Command  /process/list
165     type = -1;                                    165     type = -1;
166     if (newValue == "all")                        166     if (newValue == "all")
167     {                                             167     {
168       currentProcessTypeName = std::move(newVa << 168       currentProcessTypeName = newValue;
169     }                                             169     }
170     else                                          170     else
171     {                                             171     {
172       type  = GetProcessType(newValue);           172       type  = GetProcessType(newValue);
173       if (type <0)                                173       if (type <0)
174       {                                           174       {
175         G4cout << " illegal type !!! " << G4en    175         G4cout << " illegal type !!! " << G4endl;
176       }                                           176       }
177       else                                        177       else
178       {                                           178       {
179         currentProcessTypeName = std::move(new << 179         currentProcessTypeName = newValue;
180       }                                           180       }
181     }                                             181     }    
182     G4int counter = 0;                            182     G4int counter = 0;
183     for (auto itr=procNameVector->cbegin(); it    183     for (auto itr=procNameVector->cbegin(); itr!=procNameVector->cend(); ++itr)
184     {                                             184     {
185       G4ProcessVector* tmpVector = theProcessT    185       G4ProcessVector* tmpVector = theProcessTable->FindProcesses(*itr);
186       if ( (type <0) || ( ((*tmpVector)(0)->Ge    186       if ( (type <0) || ( ((*tmpVector)(0)->GetProcessType()) == type) )
187       {                                           187       {
188         if ( counter%4 != 0) G4cout << ",";       188         if ( counter%4 != 0) G4cout << ",";
189         G4cout << std::setw(19) << *itr;          189         G4cout << std::setw(19) << *itr;
190         if ((counter++)%4 == 3)                   190         if ((counter++)%4 == 3)
191         {                                         191         {
192           G4cout << G4endl;                       192           G4cout << G4endl;
193         }                                         193         }
194       }                                           194       }
195       delete tmpVector;                           195       delete tmpVector;
196     }                                             196     }
197     G4cout << G4endl;                             197     G4cout << G4endl;
198   }                                               198   }
199   else if( command==procVerboseCmd )              199   else if( command==procVerboseCmd )
200   {                                               200   {
201     // Command  /process/setVerbose               201     // Command  /process/setVerbose
202     G4Tokenizer next( newValue );                 202     G4Tokenizer next( newValue );
203                                                   203 
204     // check 1st argument                         204     // check 1st argument
205     G4String tmpS = G4String(next());             205     G4String tmpS = G4String(next());
206     //  inputstream for newValues                 206     //  inputstream for newValues
207     const char* temp = (const char*)(tmpS);       207     const char* temp = (const char*)(tmpS);
208     std::istringstream is((char*)temp);           208     std::istringstream is((char*)temp);
209     G4int level;                                  209     G4int level;
210     is  >>level;                                  210     is  >>level;
211                                                   211 
212     // check 2nd argument                         212     // check 2nd argument
213     currentProcessTypeName = G4String(next());    213     currentProcessTypeName = G4String(next());
214     if (currentProcessTypeName.empty()) curren    214     if (currentProcessTypeName.empty()) currentProcessTypeName = "all";
215     G4bool isProcName = false;                    215     G4bool isProcName = false;
216     G4bool isAll = false;                         216     G4bool isAll = false;
217     type = -1;                                    217     type = -1;
218                                                   218 
219     if (currentProcessTypeName == "all")          219     if (currentProcessTypeName == "all")
220     {                                             220     {
221       isAll = true;                               221       isAll = true; 
222     }                                             222     }
223     else                                          223     else
224     {                                             224     {
225       type  = GetProcessType(currentProcessTyp    225       type  = GetProcessType(currentProcessTypeName);
226       if (type<0)                                 226       if (type<0)
227       {                                           227       {
228         isProcName = true;                        228         isProcName = true;
229         currentProcessName = currentProcessTyp    229         currentProcessName = currentProcessTypeName;
230         currentProcessTypeName = "";              230         currentProcessTypeName = "";
231       }                                           231       }
232     }                                             232     }  
233     for (auto itr=procNameVector->cbegin(); it    233     for (auto itr=procNameVector->cbegin(); itr!=procNameVector->cend(); ++itr)
234     {                                             234     {
235       G4ProcessVector* tmpVector = theProcessT    235       G4ProcessVector* tmpVector = theProcessTable->FindProcesses(*itr);
236       G4VProcess* p = (*tmpVector)(0);            236       G4VProcess* p = (*tmpVector)(0);
237       if ( isAll ||                               237       if ( isAll || 
238            (!isProcName && ( p->GetProcessType    238            (!isProcName && ( p->GetProcessType() == type) ) ||
239            ( isProcName && ( p->GetProcessName    239            ( isProcName && ( p->GetProcessName()== currentProcessName) ) )
240       {                                           240       {
241         p->SetVerboseLevel(level);                241         p->SetVerboseLevel(level);
242       }                                           242       }
243       delete tmpVector;                           243       delete tmpVector;
244     }                                             244     }
245   }                                               245   }
246   else if( command==verboseCmd )                  246   else if( command==verboseCmd )
247   {                                               247   {
248     // Command   /process/verbose                 248     // Command   /process/verbose
249     theProcessTable->SetVerboseLevel(verboseCm    249     theProcessTable->SetVerboseLevel(verboseCmd->GetNewIntValue(newValue));
250   }                                               250   }
251   else                                            251   else
252   {                                               252   {
253     G4Tokenizer next( newValue );                 253     G4Tokenizer next( newValue );
254                                                   254 
255     // check 1st argument                         255     // check 1st argument
256     currentProcessName = G4String(next());        256     currentProcessName = G4String(next());
257     G4bool isProcName = false;                    257     G4bool isProcName = false; 
258     for (auto itr=procNameVector->cbegin(); it    258     for (auto itr=procNameVector->cbegin(); itr!=procNameVector->cend(); ++itr)
259     {                                             259     {
260       if ( (*itr) == currentProcessName )         260       if ( (*itr) == currentProcessName )
261       {                                           261       {
262         isProcName = true;                        262         isProcName = true; 
263         break;                                    263         break;
264       }                                           264       }
265     }                                             265     }
266     if (!isProcName)                              266     if (!isProcName)
267     {                                             267     {
268       type  = GetProcessType(currentProcessNam    268       type  = GetProcessType(currentProcessName);
269       if (type <0 )                               269       if (type <0 )
270       {                                           270       {
271         // no processes with specified name       271         // no processes with specified name
272         ed << " illegal process (or type) name    272         ed << " illegal process (or type) name ["
273            << currentProcessName << "]";          273            << currentProcessName << "]";
274         command->CommandFailed(ed);               274         command->CommandFailed(ed);
275         currentProcessName = "";                  275         currentProcessName = "";
276         return;                                   276         return;
277       }                                           277       }
278     }                                             278     }
279                                                   279   
280     // check 2nd argument                         280     // check 2nd argument
281     currentParticleName = G4String(next());       281     currentParticleName = G4String(next());
282     G4bool isParticleFound = false;               282     G4bool isParticleFound = false;
283     G4ParticleDefinition* currentParticle = nu    283     G4ParticleDefinition* currentParticle = nullptr;
284     if ( currentParticleName == "all" )           284     if ( currentParticleName == "all" )
285     {                                             285     {
286       isParticleFound = true;                     286       isParticleFound = true;
287     }                                             287     }
288     else                                          288     else
289     {                                             289     {
290       isParticleFound = G4ParticleTable::GetPa    290       isParticleFound = G4ParticleTable::GetParticleTable()
291                       ->contains(currentPartic    291                       ->contains(currentParticleName);
292       if (isParticleFound)                        292       if (isParticleFound)
293       {                                           293       {
294         currentParticle = G4ParticleTable::Get    294         currentParticle = G4ParticleTable::GetParticleTable()
295                         ->FindParticle(current    295                         ->FindParticle(currentParticleName);
296       }                                           296       }
297     }                                             297     }
298                                                   298 
299     if ( !isParticleFound )                       299     if ( !isParticleFound )
300     {                                             300     {
301       // no particle with specified name          301       // no particle with specified name
302       ed << " illegal particle name [" << curr    302       ed << " illegal particle name [" << currentParticleName << "]";
303       command->CommandFailed(ed);                 303       command->CommandFailed(ed);
304       currentParticleName = "";                   304       currentParticleName = "";
305       return;                                     305       return;
306     }                                             306     }
307                                                   307         
308     if( command==dumpCmd )                        308     if( command==dumpCmd )
309     {                                             309     {
310       // process/dump                             310       // process/dump
311       G4ProcessVector* tmpVector;                 311       G4ProcessVector* tmpVector;
312       if (isProcName)                             312       if (isProcName)
313       {                                           313       {
314         tmpVector = theProcessTable->FindProce    314         tmpVector = theProcessTable->FindProcesses(currentProcessName);
315       }                                           315       }
316       else                                        316       else
317       {                                           317       {
318         tmpVector = theProcessTable->FindProce    318         tmpVector = theProcessTable->FindProcesses(G4ProcessType(type));
319       }                                           319       }
320       for (G4int i=0; i<(G4int)tmpVector->leng    320       for (G4int i=0; i<(G4int)tmpVector->length(); ++i)
321       {                                           321       {
322         theProcessTable->DumpInfo( (*tmpVector    322         theProcessTable->DumpInfo( (*tmpVector)(i), currentParticle );
323       }                                           323       }
324       delete tmpVector;                           324       delete tmpVector;
325     }                                             325     }
326     else if ( (command==activateCmd) || (comma    326     else if ( (command==activateCmd) || (command==inactivateCmd))
327     {                                             327     {
328       // process/activate , inactivate            328       // process/activate , inactivate
329       G4bool fActive = (command==activateCmd);    329       G4bool fActive = (command==activateCmd);
330       if (isProcName)                             330       if (isProcName)
331       {                                           331       {
332         if ( currentParticle == nullptr )         332         if ( currentParticle == nullptr )
333         {                                         333         {
334           theProcessTable->SetProcessActivatio    334           theProcessTable->SetProcessActivation(currentProcessName, 
335                                                   335                                                 fActive);
336         }                                         336         }
337         else                                      337         else
338         {                                         338         {
339           theProcessTable->SetProcessActivatio    339           theProcessTable->SetProcessActivation(currentProcessName,
340                                                   340                                                 currentParticle,
341                                                   341                                                 fActive);
342         }                                         342         }
343       }                                           343       }
344       else                                        344       else
345       {                                           345       {
346         if ( currentParticle == nullptr )         346         if ( currentParticle == nullptr )
347         {                                         347         {
348           theProcessTable->SetProcessActivatio    348           theProcessTable->SetProcessActivation(G4ProcessType(type),
349                                                   349                                                 fActive);
350         }                                         350         }
351         else                                      351         else
352         {                                         352         {
353           theProcessTable->SetProcessActivatio    353           theProcessTable->SetProcessActivation(G4ProcessType(type),
354                                                   354                                                 currentParticle,
355                                                   355                                                 fActive);
356         }                                         356         }
357       }                                           357       }
358       G4UImanager::GetUIpointer()->ApplyComman    358       G4UImanager::GetUIpointer()->ApplyCommand("/run/physicsModified");
359     }                                             359     } 
360   }                                               360   }
361 }                                                 361 }
362                                                   362 
363 // -------------------------------------------    363 // --------------------------------------------------------------------
364 G4String G4ProcessTableMessenger::GetCurrentVa    364 G4String G4ProcessTableMessenger::GetCurrentValue(G4UIcommand* command)
365 {                                                 365 {
366   if( command==verboseCmd )                       366   if( command==verboseCmd )
367   {                                               367   {
368     // Command   /process/verbose                 368     // Command   /process/verbose
369     return verboseCmd->ConvertToString(theProc    369     return verboseCmd->ConvertToString(theProcessTable->GetVerboseLevel());
370   }                                               370   }
371   else if ( command==listCmd )                    371   else if ( command==listCmd )
372   {                                               372   {
373     // Command   /process/list                    373     // Command   /process/list
374     return currentProcessTypeName;                374     return currentProcessTypeName;
375   }                                               375   }
376   else                                            376   else
377   {                                               377   {
378     // Command   /process/dump, activate, inac    378     // Command   /process/dump, activate, inactivate
379     return   (currentProcessName + " " + curre    379     return   (currentProcessName + " " + currentParticleName);
380   }                                               380   }
381                                                   381 
382   return "";                                      382   return "";
383 }                                                 383 }
384                                                   384 
385 // -------------------------------------------    385 // --------------------------------------------------------------------
386 G4String G4ProcessTableMessenger::GetProcessTy    386 G4String G4ProcessTableMessenger::GetProcessTypeName(G4ProcessType aType) const
387 {                                                 387 {
388   return G4VProcess::GetProcessTypeName(aType)    388   return G4VProcess::GetProcessTypeName(aType);
389 }                                                 389 }
390                                                   390 
391 // -------------------------------------------    391 // --------------------------------------------------------------------
392 G4int G4ProcessTableMessenger::GetProcessType(    392 G4int G4ProcessTableMessenger::GetProcessType(const G4String& aTypeName) const
393 {                                                 393 {
394   G4int type = -1;                                394   G4int type = -1;
395   for (G4int idx = 0; idx < NumberOfProcessTyp    395   for (G4int idx = 0; idx < NumberOfProcessType ; ++idx )
396   {                                               396   {
397     if (aTypeName == G4VProcess::GetProcessTyp    397     if (aTypeName == G4VProcess::GetProcessTypeName(G4ProcessType(idx)) )
398     {                                             398     {
399       type = idx;                                 399       type = idx;
400       break;                                      400       break;
401     }                                             401     }
402   }                                               402   }
403   return type;                                    403   return type;
404 }                                                 404 }
405                                                   405 
406 // -------------------------------------------    406 // --------------------------------------------------------------------
407 void G4ProcessTableMessenger::SetNumberOfProce    407 void G4ProcessTableMessenger::SetNumberOfProcessType()
408 {                                                 408 {
409   G4bool isFoundEndMark = false;                  409   G4bool isFoundEndMark = false;
410   G4int idx;                                      410   G4int idx;
411   for (idx = 0; idx < 1000 ; ++idx )              411   for (idx = 0; idx < 1000 ; ++idx )
412   {                                               412   {
413     G4String typeName = G4VProcess::GetProcess    413     G4String typeName = G4VProcess::GetProcessTypeName(G4ProcessType(idx));
414     isFoundEndMark = G4StrUtil::contains(typeN    414     isFoundEndMark = G4StrUtil::contains(typeName, "---");
415     if ( isFoundEndMark ) break;                  415     if ( isFoundEndMark ) break;
416   }                                               416   }
417   if ( isFoundEndMark )                           417   if ( isFoundEndMark )
418   {                                               418   {
419     NumberOfProcessType = idx;                    419     NumberOfProcessType = idx;
420   }                                               420   }
421   else                                            421   else
422   {                                               422   {
423     G4Exception("G4ProcessTableMessenger::SetN    423     G4Exception("G4ProcessTableMessenger::SetNumberOfProcessType()",
424                 "ProcMan014", FatalException,     424                 "ProcMan014", FatalException, "No End Mark");
425   }                                               425   } 
426 }                                                 426 }
427                                                   427