| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer << 3 // * DISCLAIMER *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th << 5 // * The following disclaimer summarizes all the specific disclaimers *
6 // * the Geant4 Collaboration. It is provided << 6 // * of contributors to this software. The specific disclaimers,which *
7 // * conditions of the Geant4 Software License << 7 // * govern, are listed with their locations in: *
8 // * LICENSE and available at http://cern.ch/ << 8 // * http://cern.ch/geant4/license *
9 // * include a list of copyright holders. <<
10 // * 9 // * *
11 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file << 14 // * use. *
16 // * for the full disclaimer and the limitatio <<
17 // * 15 // * *
18 // * This code implementation is the result << 16 // * This code implementation is the intellectual property of the *
19 // * technical work of the GEANT4 collaboratio << 17 // * GEANT4 collaboration. *
20 // * By using, copying, modifying or distri << 18 // * By copying, distributing or modifying the Program (or any work *
21 // * any work based on the software) you ag << 19 // * based on the Program) you indicate your acceptance of this *
22 // * use in resulting scientific publicati << 20 // * statement, and all its terms. *
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* 21 // ********************************************************************
25 // 22 //
26 // G4ProcessTableMessenger class implementatio <<
27 // 23 //
28 // Author: H.Kurashige, 15 August 1998 << 24 // $Id: G4ProcessTableMessenger.cc,v 1.10 2001/10/11 13:53:10 gcosmo Exp $
29 // ------------------------------------------- << 25 // GEANT4 tag $Name: geant4-04-00 $
>> 26 //
>> 27 //
>> 28 //---------------------------------------------------------------
>> 29 //
>> 30 // G4ProcessTableMessenger.cc
>> 31 //
>> 32 // Description:
>> 33 // This is a messenger class to interface to exchange information
>> 34 // between ProcessTable and UI.
>> 35 //
>> 36 //
>> 37 // History:
>> 38 // 15 Aug. 1998, H. Kurashige
>> 39 // Use STL vector instead of RW vector 1. Mar 00 H.Kurashige
>> 40 //
>> 41 //---------------------------------------------------------------
30 42
31 #include "G4ProcessTableMessenger.hh" 43 #include "G4ProcessTableMessenger.hh"
32 44
33 #include "G4UImanager.hh" 45 #include "G4UImanager.hh"
34 #include "G4UIdirectory.hh" 46 #include "G4UIdirectory.hh"
35 #include "G4UIcmdWithoutParameter.hh" 47 #include "G4UIcmdWithoutParameter.hh"
36 #include "G4UIcmdWithAnInteger.hh" 48 #include "G4UIcmdWithAnInteger.hh"
37 #include "G4UIcmdWithAString.hh" 49 #include "G4UIcmdWithAString.hh"
38 50
39 #include "G4VProcess.hh" 51 #include "G4VProcess.hh"
40 #include "G4ProcessManager.hh" 52 #include "G4ProcessManager.hh"
41 #include "G4ProcessTable.hh" 53 #include "G4ProcessTable.hh"
42 #include "G4ParticleTable.hh" 54 #include "G4ParticleTable.hh"
43 55
44 #include "G4ios.hh" 56 #include "G4ios.hh"
45 #include "G4Tokenizer.hh" 57 #include "G4Tokenizer.hh"
46 #include <iomanip> << 58 #include "g4std/iomanip"
47 #include <sstream> << 59 #include "g4std/strstream"
48 60
49 G4ThreadLocal G4int G4ProcessTableMessenger::N << 61 /////////////////////////////////////////
>> 62 G4int G4ProcessTableMessenger::NumberOfProcessType = 10;
50 63
51 // ------------------------------------------- << 64 //////////////////////////
52 G4ProcessTableMessenger::G4ProcessTableMesseng 65 G4ProcessTableMessenger::G4ProcessTableMessenger(G4ProcessTable* pTable)
53 : theProcessTable(pTable) << 66 :theProcessTable(pTable),
>> 67 currentProcessTypeName("all"),
>> 68 currentProcessName("all"),
>> 69 currentParticleName("all")
54 { 70 {
55 // Command /particle/process << 71 //Commnad /particle/process
56 thisDirectory = new G4UIdirectory("/process/ 72 thisDirectory = new G4UIdirectory("/process/");
57 thisDirectory->SetGuidance("Process Table co 73 thisDirectory->SetGuidance("Process Table control commands.");
58 74
59 // Command /particle/process/list << 75
>> 76 //Commnad /particle/process/list
60 listCmd = new G4UIcmdWithAString("/process/l 77 listCmd = new G4UIcmdWithAString("/process/list",this);
61 listCmd->SetGuidance("List up process names" 78 listCmd->SetGuidance("List up process names");
62 listCmd->SetGuidance(" list [type] "); 79 listCmd->SetGuidance(" list [type] ");
63 listCmd->SetGuidance(" type: process type << 80 listCmd->SetGuidance(" type: process type [all:for all proceeses]");
64 listCmd->SetParameterName("type", true); 81 listCmd->SetParameterName("type", true);
65 listCmd->SetDefaultValue("all"); 82 listCmd->SetDefaultValue("all");
66 SetNumberOfProcessType(); 83 SetNumberOfProcessType();
67 84
68 G4String candidates("all"); 85 G4String candidates("all");
69 for (G4int idx = 0; idx < NumberOfProcessTyp << 86 for (G4int idx = 0; idx < NumberOfProcessType ; idx ++ ) {
70 { << 87 candidates += " " +
71 candidates += " " + G4VProcess::GetProcess << 88 G4VProcess::GetProcessTypeName(G4ProcessType(idx));
72 } 89 }
73 listCmd->SetCandidates((const char*)(candida 90 listCmd->SetCandidates((const char*)(candidates));
74 91
75 // Command /particle/process/verbose << 92 //Commnad /particle/process/Verbose
76 verboseCmd = new G4UIcmdWithAnInteger("/proc 93 verboseCmd = new G4UIcmdWithAnInteger("/process/verbose",this);
77 verboseCmd->SetGuidance("Set Verbose Level f 94 verboseCmd->SetGuidance("Set Verbose Level for Process Table");
78 verboseCmd->SetGuidance(" verbose [level]") 95 verboseCmd->SetGuidance(" verbose [level]");
79 verboseCmd->SetGuidance(" level: verbose l 96 verboseCmd->SetGuidance(" level: verbose level");
80 verboseCmd->SetParameterName("verbose", true 97 verboseCmd->SetParameterName("verbose", true);
81 verboseCmd->SetDefaultValue(1); 98 verboseCmd->SetDefaultValue(1);
82 verboseCmd->SetRange("verbose >=0"); 99 verboseCmd->SetRange("verbose >=0");
83 verboseCmd->AvailableForStates(G4State_PreIn << 100 verboseCmd->AvailableForStates(PreInit,Init,Idle,GeomClosed,EventProc);
84 101
85 // Command /particle/process/setVerbose << 102 //Commnad /particle/process/dump
86 procVerboseCmd = new G4UIcommand("/process/s <<
87 procVerboseCmd->SetGuidance("Set verbose lev <<
88 procVerboseCmd->SetGuidance(" setVerbose le <<
89 procVerboseCmd->SetGuidance(" level: verb <<
90 procVerboseCmd->SetGuidance(" name : proc <<
91 procVerboseCmd->SetGuidance(" type : proc <<
92 procVerboseCmd->SetGuidance(" [all] fo <<
93 G4UIparameter* param = new G4UIparameter("ve <<
94 procVerboseCmd->SetParameter(param); <<
95 param = new G4UIparameter("type",'s',true); <<
96 param->SetDefaultValue("all"); <<
97 procVerboseCmd->SetParameter(param); <<
98 procVerboseCmd->AvailableForStates(G4State_I <<
99 <<
100 // Command /particle/process/dump <<
101 dumpCmd = new G4UIcommand("/process/dump",th 103 dumpCmd = new G4UIcommand("/process/dump",this);
102 dumpCmd->SetGuidance("Dump process informati 104 dumpCmd->SetGuidance("Dump process information");
103 dumpCmd->SetGuidance(" dump name [particle]" 105 dumpCmd->SetGuidance(" dump name [particle]");
104 dumpCmd->SetGuidance(" name: process n 106 dumpCmd->SetGuidance(" name: process name or type name");
105 dumpCmd->SetGuidance(" particle: particle 107 dumpCmd->SetGuidance(" particle: particle name [all: for all particles]");
106 param = new G4UIparameter("procName",'s',fal << 108 G4UIparameter* param = new G4UIparameter("procName",'s',false);
107 dumpCmd->SetParameter(param); 109 dumpCmd->SetParameter(param);
108 param = new G4UIparameter("particle",'s',tru 110 param = new G4UIparameter("particle",'s',true);
109 param->SetDefaultValue("all"); 111 param->SetDefaultValue("all");
110 dumpCmd->SetParameter(param); 112 dumpCmd->SetParameter(param);
111 dumpCmd->AvailableForStates(G4State_Init,G4S << 113 dumpCmd->AvailableForStates(Init,Idle,GeomClosed,EventProc);
112 114
113 // Command /process/activate << 115 //Commnad /particle/process/activate
114 activateCmd = new G4UIcommand("/process/acti 116 activateCmd = new G4UIcommand("/process/activate",this);
115 activateCmd->SetGuidance("Activate processes 117 activateCmd->SetGuidance("Activate processes ");
116 activateCmd->SetGuidance(" Activate name [p 118 activateCmd->SetGuidance(" Activate name [particle]");
117 activateCmd->SetGuidance(" name: proce 119 activateCmd->SetGuidance(" name: process name or type name");
118 activateCmd->SetGuidance(" particle: parti 120 activateCmd->SetGuidance(" particle: particle name [all: for all particles]");
119 param = new G4UIparameter("procName",'s',fal 121 param = new G4UIparameter("procName",'s',false);
120 activateCmd->SetParameter(param); 122 activateCmd->SetParameter(param);
121 param = new G4UIparameter("particle",'s',tru 123 param = new G4UIparameter("particle",'s',true);
122 param->SetDefaultValue("all"); 124 param->SetDefaultValue("all");
123 activateCmd->SetParameter(param); 125 activateCmd->SetParameter(param);
124 activateCmd->AvailableForStates(G4State_Idle << 126 activateCmd->AvailableForStates(Idle,GeomClosed,EventProc);
125 127
126 // Command /process/inactivate << 128 //Commnad /particle/process/inactivate
127 inactivateCmd = new G4UIcommand("/process/in 129 inactivateCmd = new G4UIcommand("/process/inactivate",this);
128 inactivateCmd->SetGuidance("Inactivate proce 130 inactivateCmd->SetGuidance("Inactivate process ");
129 inactivateCmd->SetGuidance("Inactivate proce 131 inactivateCmd->SetGuidance("Inactivate processes ");
130 inactivateCmd->SetGuidance(" Inactivate nam 132 inactivateCmd->SetGuidance(" Inactivate name [particle]");
131 inactivateCmd->SetGuidance(" name: pro 133 inactivateCmd->SetGuidance(" name: process name or type name");
132 inactivateCmd->SetGuidance(" particle: par 134 inactivateCmd->SetGuidance(" particle: particle name [all: for all particles]");
133 param = new G4UIparameter("procName",'s',fal 135 param = new G4UIparameter("procName",'s',false);
134 inactivateCmd->SetParameter(param); 136 inactivateCmd->SetParameter(param);
135 param = new G4UIparameter("particle",'s',tru 137 param = new G4UIparameter("particle",'s',true);
136 param->SetDefaultValue("all"); 138 param->SetDefaultValue("all");
137 inactivateCmd->SetParameter(param); 139 inactivateCmd->SetParameter(param);
138 inactivateCmd->AvailableForStates(G4State_Id << 140 inactivateCmd->AvailableForStates(Idle,GeomClosed,EventProc);
139 } 141 }
140 142
141 // ------------------------------------------- << 143 //////////////////
142 G4ProcessTableMessenger::~G4ProcessTableMessen 144 G4ProcessTableMessenger::~G4ProcessTableMessenger()
143 { 145 {
144 delete activateCmd; 146 delete activateCmd;
145 delete inactivateCmd; 147 delete inactivateCmd;
146 delete verboseCmd; 148 delete verboseCmd;
147 delete dumpCmd; 149 delete dumpCmd;
148 delete listCmd; 150 delete listCmd;
149 delete procVerboseCmd; <<
150 delete thisDirectory; 151 delete thisDirectory;
151 } 152 }
152 153
153 // ------------------------------------------- << 154 ///////////////
154 void << 155 void G4ProcessTableMessenger::SetNewValue(G4UIcommand * command,G4String newValue)
155 G4ProcessTableMessenger::SetNewValue(G4UIcomma <<
156 { 156 {
157 G4ProcessTable::G4ProcNameVector* procNameVe 157 G4ProcessTable::G4ProcNameVector* procNameVector
158 = theProcessTable->Ge 158 = theProcessTable->GetNameList();
>> 159 G4int idx;
>> 160
>> 161 G4ProcessVector* tmpVector=0;
159 G4int type = -1; 162 G4int type = -1;
160 G4ExceptionDescription ed; <<
161 163
162 if( command == listCmd ) << 164 if( command == listCmd ){
163 { << 165 //Commnad /process/list
164 // Command /process/list <<
165 type = -1; 166 type = -1;
166 if (newValue == "all") << 167 if (newValue == "all") {
167 { << 168 currentProcessTypeName = newValue;
168 currentProcessTypeName = std::move(newVa << 169 } else {
169 } <<
170 else <<
171 { <<
172 type = GetProcessType(newValue); 170 type = GetProcessType(newValue);
173 if (type <0) << 171 if (type <0) {
174 { << 172 G4cout << " illegal type !!! " << G4endl;
175 G4cout << " illegal type !!! " << G4en << 173 } else {
176 } << 174 currentProcessTypeName = newValue;
177 else <<
178 { <<
179 currentProcessTypeName = std::move(new <<
180 } 175 }
181 } 176 }
182 G4int counter = 0; 177 G4int counter = 0;
183 for (auto itr=procNameVector->cbegin(); it << 178 idx =0;
184 { << 179 G4ProcessTable::G4ProcNameVector::iterator itr;
185 G4ProcessVector* tmpVector = theProcessT << 180 for (itr=procNameVector->begin(); itr!=procNameVector->end(); ++itr) {
186 if ( (type <0) || ( ((*tmpVector)(0)->Ge << 181 idx +=1;
187 { << 182 tmpVector = theProcessTable->FindProcesses(*itr);
>> 183 if ( (type <0) || ( ((*tmpVector)(0)->GetProcessType()) == type) ) {
188 if ( counter%4 != 0) G4cout << ","; 184 if ( counter%4 != 0) G4cout << ",";
189 G4cout << std::setw(19) << *itr; << 185 G4cout << G4std::setw(19) <<*itr;
190 if ((counter++)%4 == 3) << 186 if ((counter++)%4 == 3) {
191 { <<
192 G4cout << G4endl; 187 G4cout << G4endl;
193 } 188 }
194 } 189 }
195 delete tmpVector; <<
196 } 190 }
197 G4cout << G4endl; 191 G4cout << G4endl;
198 } << 192 delete tmpVector;
199 else if( command==procVerboseCmd ) << 193 //Commnad /process/list
200 { <<
201 // Command /process/setVerbose <<
202 G4Tokenizer next( newValue ); <<
203 194
204 // check 1st argument << 195 } else if( command==verboseCmd ) {
205 G4String tmpS = G4String(next()); << 196 //Commnad /process/verbose
206 // inputstream for newValues << 197 theProcessTable->SetVerboseLevel(verboseCmd->GetNewIntValue(newValue));
207 const char* temp = (const char*)(tmpS); << 198 //Commnad /process/verbose
208 std::istringstream is((char*)temp); <<
209 G4int level; <<
210 is >>level; <<
211 <<
212 // check 2nd argument <<
213 currentProcessTypeName = G4String(next()); <<
214 if (currentProcessTypeName.empty()) curren <<
215 G4bool isProcName = false; <<
216 G4bool isAll = false; <<
217 type = -1; <<
218 199
219 if (currentProcessTypeName == "all") << 200 } else {
220 { <<
221 isAll = true; <<
222 } <<
223 else <<
224 { <<
225 type = GetProcessType(currentProcessTyp <<
226 if (type<0) <<
227 { <<
228 isProcName = true; <<
229 currentProcessName = currentProcessTyp <<
230 currentProcessTypeName = ""; <<
231 } <<
232 } <<
233 for (auto itr=procNameVector->cbegin(); it <<
234 { <<
235 G4ProcessVector* tmpVector = theProcessT <<
236 G4VProcess* p = (*tmpVector)(0); <<
237 if ( isAll || <<
238 (!isProcName && ( p->GetProcessType <<
239 ( isProcName && ( p->GetProcessName <<
240 { <<
241 p->SetVerboseLevel(level); <<
242 } <<
243 delete tmpVector; <<
244 } <<
245 } <<
246 else if( command==verboseCmd ) <<
247 { <<
248 // Command /process/verbose <<
249 theProcessTable->SetVerboseLevel(verboseCm <<
250 } <<
251 else <<
252 { <<
253 G4Tokenizer next( newValue ); 201 G4Tokenizer next( newValue );
254 202
255 // check 1st argument 203 // check 1st argument
256 currentProcessName = G4String(next()); 204 currentProcessName = G4String(next());
>> 205 G4bool isNameFound = false;
257 G4bool isProcName = false; 206 G4bool isProcName = false;
258 for (auto itr=procNameVector->cbegin(); it << 207 G4ProcessTable::G4ProcNameVector::iterator itr;
259 { << 208 for (itr=procNameVector->begin(); itr!=procNameVector->end(); ++itr) {
260 if ( (*itr) == currentProcessName ) << 209 if ( (*itr) == currentProcessName ) {
261 { << 210 isNameFound = true;
262 isProcName = true; << 211 isProcName = true;
263 break; << 212 break;
264 } 213 }
265 } 214 }
266 if (!isProcName) << 215 if (!isProcName) {
267 { <<
268 type = GetProcessType(currentProcessNam 216 type = GetProcessType(currentProcessName);
269 if (type <0 ) << 217 if (type >=0) {
270 { << 218 isNameFound = true;
271 // no processes with specified name << 219 } else {
272 ed << " illegal process (or type) name << 220 // no processes with specifed name
273 << currentProcessName << "]"; << 221 G4cout << " illegal process (or type) name " << G4endl;
274 command->CommandFailed(ed); << 222 currentProcessName = "";
275 currentProcessName = ""; << 223 return;
276 return; <<
277 } 224 }
278 } 225 }
279 226
280 // check 2nd argument 227 // check 2nd argument
281 currentParticleName = G4String(next()); 228 currentParticleName = G4String(next());
282 G4bool isParticleFound = false; 229 G4bool isParticleFound = false;
283 G4ParticleDefinition* currentParticle = nu << 230 G4ParticleDefinition* currentParticle = 0;
284 if ( currentParticleName == "all" ) << 231 if ( currentParticleName == "all" ) {
285 { <<
286 isParticleFound = true; 232 isParticleFound = true;
287 } << 233
288 else << 234 } else {
289 { << 235 isParticleFound = G4ParticleTable::GetParticleTable()->contains(currentParticleName);
290 isParticleFound = G4ParticleTable::GetPa << 236 if (isParticleFound) {
291 ->contains(currentPartic << 237 currentParticle = G4ParticleTable::GetParticleTable()->FindParticle(currentParticleName);
292 if (isParticleFound) <<
293 { <<
294 currentParticle = G4ParticleTable::Get <<
295 ->FindParticle(current <<
296 } 238 }
>> 239
297 } 240 }
298 241
299 if ( !isParticleFound ) << 242 if ( !isParticleFound ) {
300 { << 243 // no particle with specifed name
301 // no particle with specified name << 244 G4cout << " illegal particle name " << G4endl;
302 ed << " illegal particle name [" << curr <<
303 command->CommandFailed(ed); <<
304 currentParticleName = ""; 245 currentParticleName = "";
305 return; 246 return;
306 } 247 }
307 248
308 if( command==dumpCmd ) << 249 if( command==dumpCmd ) {
309 { <<
310 // process/dump 250 // process/dump
311 G4ProcessVector* tmpVector; << 251 if (isProcName) {
312 if (isProcName) << 252 tmpVector = theProcessTable->FindProcesses(currentProcessName);
313 { << 253 } else {
314 tmpVector = theProcessTable->FindProce << 254 tmpVector = theProcessTable->FindProcesses(G4ProcessType(type));
315 } <<
316 else <<
317 { <<
318 tmpVector = theProcessTable->FindProce <<
319 } 255 }
320 for (G4int i=0; i<(G4int)tmpVector->leng << 256 for (G4int i=0; i<tmpVector->length(); i++) {
321 { << 257 theProcessTable->DumpInfo( (*tmpVector)(i), currentParticle );
322 theProcessTable->DumpInfo( (*tmpVector <<
323 } 258 }
324 delete tmpVector; 259 delete tmpVector;
325 } << 260 // process/dump
326 else if ( (command==activateCmd) || (comma << 261
327 { << 262 } else if ( (command==activateCmd) || (command==inactivateCmd)) {
328 // process/activate , inactivate 263 // process/activate , inactivate
329 G4bool fActive = (command==activateCmd); 264 G4bool fActive = (command==activateCmd);
330 if (isProcName) << 265 if (isProcName) {
331 { << 266 if ( currentParticle == 0 ) {
332 if ( currentParticle == nullptr ) << 267 theProcessTable->SetProcessActivation(currentProcessName,
333 { << 268 fActive);
334 theProcessTable->SetProcessActivatio << 269 } else {
335 << 270 theProcessTable->SetProcessActivation(currentProcessName,
336 } << 271 currentParticle,
337 else << 272 fActive);
338 { << 273 }
339 theProcessTable->SetProcessActivatio << 274 } else {
340 << 275 if ( currentParticle == 0 ) {
341 << 276 theProcessTable->SetProcessActivation(G4ProcessType(type),
342 } << 277 fActive);
>> 278 } else {
>> 279 theProcessTable->SetProcessActivation(G4ProcessType(type),
>> 280 currentParticle,
>> 281 fActive);
>> 282 }
343 } 283 }
344 else << 284 // process/activate , inactivate
345 { <<
346 if ( currentParticle == nullptr ) <<
347 { <<
348 theProcessTable->SetProcessActivatio <<
349 <<
350 } <<
351 else <<
352 { <<
353 theProcessTable->SetProcessActivatio <<
354 <<
355 <<
356 } <<
357 } <<
358 G4UImanager::GetUIpointer()->ApplyComman <<
359 } 285 }
360 } 286 }
361 } 287 }
362 288
363 // ------------------------------------------- << 289
364 G4String G4ProcessTableMessenger::GetCurrentVa << 290 //////////////////
>> 291 G4String G4ProcessTableMessenger::GetCurrentValue(G4UIcommand * command)
365 { 292 {
366 if( command==verboseCmd ) << 293 G4ProcessTable::G4ProcNameVector* procNameVector
367 { << 294 = theProcessTable->GetNameList();
368 // Command /process/verbose << 295
369 return verboseCmd->ConvertToString(theProc << 296 G4String candidates;
370 } << 297 G4String returnValue('\0');
371 else if ( command==listCmd ) << 298
372 { << 299 char line[255];
373 // Command /process/list << 300 G4std::ostrstream os(line,255);
374 return currentProcessTypeName; << 301 G4UIparameter * param;
375 } << 302
376 else << 303 G4int idx;
377 { << 304
378 // Command /process/dump, activate, inac << 305 if( command==verboseCmd ){
379 return (currentProcessName + " " + curre << 306 //Commnad /process/verbose
>> 307 os << theProcessTable->GetVerboseLevel() << '\0';
>> 308 returnValue = G4String(line);
>> 309
>> 310 } else if ( command==listCmd ){
>> 311 //Commnad /process/list
>> 312 candidates = "all";
>> 313 for (idx = 0; idx < NumberOfProcessType ; idx ++ ) {
>> 314 candidates += " " +
>> 315 G4VProcess::GetProcessTypeName(G4ProcessType(idx));
>> 316 }
>> 317 listCmd->SetCandidates((const char*)(candidates));
>> 318 returnValue = currentProcessTypeName;
>> 319
>> 320 } else {
>> 321 //Commnad /process/dump, activate, inactivate
>> 322 // process name
>> 323 param = command->GetParameter(0);
>> 324 candidates = "";
>> 325 G4ProcessTable::G4ProcNameVector::iterator itr;
>> 326 for (itr=procNameVector->begin(); itr!=procNameVector->end(); ++itr) {
>> 327 candidates += " " + (*itr);
>> 328 }
>> 329 param->SetParameterCandidates((const char*)(candidates));
>> 330 // particle name
>> 331 param = command->GetParameter(1);
>> 332 candidates = "all";
>> 333 G4ParticleTable::G4PTblDicIterator *piter
>> 334 = G4ParticleTable::GetParticleTable()->GetIterator();
>> 335 piter -> reset();
>> 336 while( (*piter)() ){
>> 337 G4ParticleDefinition *particle = piter->value();
>> 338 candidates += " " + particle->GetParticleName();
>> 339 }
>> 340 param->SetParameterCandidates((const char*)(candidates));
>> 341
>> 342 returnValue = currentProcessName + " " + currentParticleName;
>> 343
380 } 344 }
381 345
382 return ""; << 346 return returnValue;
383 } 347 }
384 348
385 // ------------------------------------------- << 349 /////////////////
386 G4String G4ProcessTableMessenger::GetProcessTy 350 G4String G4ProcessTableMessenger::GetProcessTypeName(G4ProcessType aType) const
387 { 351 {
388 return G4VProcess::GetProcessTypeName(aType) 352 return G4VProcess::GetProcessTypeName(aType);
389 } 353 }
390 354
391 // ------------------------------------------- << 355 /////////////////
392 G4int G4ProcessTableMessenger::GetProcessType( 356 G4int G4ProcessTableMessenger::GetProcessType(const G4String& aTypeName) const
393 { 357 {
394 G4int type = -1; 358 G4int type = -1;
395 for (G4int idx = 0; idx < NumberOfProcessTyp << 359 for (G4int idx = 0; idx < NumberOfProcessType ; idx ++ ) {
396 { << 360 if (aTypeName == G4VProcess::GetProcessTypeName(G4ProcessType(idx)) ) {
397 if (aTypeName == G4VProcess::GetProcessTyp <<
398 { <<
399 type = idx; 361 type = idx;
400 break; 362 break;
401 } 363 }
402 } 364 }
403 return type; 365 return type;
404 } 366 }
405 367
406 // ------------------------------------------- << 368
>> 369 /////////////////
407 void G4ProcessTableMessenger::SetNumberOfProce 370 void G4ProcessTableMessenger::SetNumberOfProcessType()
408 { 371 {
409 G4bool isFoundEndMark = false; 372 G4bool isFoundEndMark = false;
410 G4int idx; 373 G4int idx;
411 for (idx = 0; idx < 1000 ; ++idx ) << 374 for (idx = 0; idx < 1000 ; idx ++ ) {
412 { <<
413 G4String typeName = G4VProcess::GetProcess 375 G4String typeName = G4VProcess::GetProcessTypeName(G4ProcessType(idx));
414 isFoundEndMark = G4StrUtil::contains(typeN << 376 if ( isFoundEndMark = typeName.contains("---")) break;
415 if ( isFoundEndMark ) break; <<
416 } 377 }
417 if ( isFoundEndMark ) << 378 if ( isFoundEndMark ) {
418 { <<
419 NumberOfProcessType = idx; 379 NumberOfProcessType = idx;
420 } << 380 } else {
421 else << 381 G4Exception("G4ProcessTableMessenger::SetNumberOfProcessType(): No End Mark for G4VProcess::GetProcessTypeName() ");
422 { <<
423 G4Exception("G4ProcessTableMessenger::SetN <<
424 "ProcMan014", FatalException, <<
425 } 382 }
426 } 383 }
>> 384
>> 385
>> 386
>> 387
427 388