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.15 2005/11/21 03:47:32 kurasige Exp $ 29 // ------------------------------------------- << 25 // GEANT4 tag $Name: geant4-08-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 <iomanip> 47 #include <sstream> 59 #include <sstream> 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(G4State_PreInit,G4State_Init,G4State_Idle,G4State_GeomClosed,G4State_EventProc); 84 101 85 // Command /particle/process/setVerbose << 102 //Commnad /particle/process/setVerbose 86 procVerboseCmd = new G4UIcommand("/process/s 103 procVerboseCmd = new G4UIcommand("/process/setVerbose",this); 87 procVerboseCmd->SetGuidance("Set verbose lev 104 procVerboseCmd->SetGuidance("Set verbose level for processes"); 88 procVerboseCmd->SetGuidance(" setVerbose le 105 procVerboseCmd->SetGuidance(" setVerbose level [type or name] "); 89 procVerboseCmd->SetGuidance(" level: verb 106 procVerboseCmd->SetGuidance(" level: verbose level "); 90 procVerboseCmd->SetGuidance(" name : proc 107 procVerboseCmd->SetGuidance(" name : process name "); 91 procVerboseCmd->SetGuidance(" type : proc 108 procVerboseCmd->SetGuidance(" type : process type "); 92 procVerboseCmd->SetGuidance(" [all] fo << 109 procVerboseCmd->SetGuidance(" [all] for all proceeses "); 93 G4UIparameter* param = new G4UIparameter("ve 110 G4UIparameter* param = new G4UIparameter("verbose",'i',false); 94 procVerboseCmd->SetParameter(param); 111 procVerboseCmd->SetParameter(param); 95 param = new G4UIparameter("type",'s',true); 112 param = new G4UIparameter("type",'s',true); 96 param->SetDefaultValue("all"); 113 param->SetDefaultValue("all"); 97 procVerboseCmd->SetParameter(param); 114 procVerboseCmd->SetParameter(param); 98 procVerboseCmd->AvailableForStates(G4State_I 115 procVerboseCmd->AvailableForStates(G4State_Idle,G4State_GeomClosed,G4State_EventProc); 99 116 100 // Command /particle/process/dump << 117 //Commnad /particle/process/dump 101 dumpCmd = new G4UIcommand("/process/dump",th 118 dumpCmd = new G4UIcommand("/process/dump",this); 102 dumpCmd->SetGuidance("Dump process informati 119 dumpCmd->SetGuidance("Dump process information"); 103 dumpCmd->SetGuidance(" dump name [particle]" 120 dumpCmd->SetGuidance(" dump name [particle]"); 104 dumpCmd->SetGuidance(" name: process n 121 dumpCmd->SetGuidance(" name: process name or type name"); 105 dumpCmd->SetGuidance(" particle: particle 122 dumpCmd->SetGuidance(" particle: particle name [all: for all particles]"); 106 param = new G4UIparameter("procName",'s',fal 123 param = new G4UIparameter("procName",'s',false); 107 dumpCmd->SetParameter(param); 124 dumpCmd->SetParameter(param); 108 param = new G4UIparameter("particle",'s',tru 125 param = new G4UIparameter("particle",'s',true); 109 param->SetDefaultValue("all"); 126 param->SetDefaultValue("all"); 110 dumpCmd->SetParameter(param); 127 dumpCmd->SetParameter(param); 111 dumpCmd->AvailableForStates(G4State_Init,G4S 128 dumpCmd->AvailableForStates(G4State_Init,G4State_Idle,G4State_GeomClosed,G4State_EventProc); 112 129 113 // Command /process/activate << 130 //Commnad /particle/process/activate 114 activateCmd = new G4UIcommand("/process/acti 131 activateCmd = new G4UIcommand("/process/activate",this); 115 activateCmd->SetGuidance("Activate processes 132 activateCmd->SetGuidance("Activate processes "); 116 activateCmd->SetGuidance(" Activate name [p 133 activateCmd->SetGuidance(" Activate name [particle]"); 117 activateCmd->SetGuidance(" name: proce 134 activateCmd->SetGuidance(" name: process name or type name"); 118 activateCmd->SetGuidance(" particle: parti 135 activateCmd->SetGuidance(" particle: particle name [all: for all particles]"); 119 param = new G4UIparameter("procName",'s',fal 136 param = new G4UIparameter("procName",'s',false); 120 activateCmd->SetParameter(param); 137 activateCmd->SetParameter(param); 121 param = new G4UIparameter("particle",'s',tru 138 param = new G4UIparameter("particle",'s',true); 122 param->SetDefaultValue("all"); 139 param->SetDefaultValue("all"); 123 activateCmd->SetParameter(param); 140 activateCmd->SetParameter(param); 124 activateCmd->AvailableForStates(G4State_Idle << 141 activateCmd->AvailableForStates(G4State_Idle,G4State_GeomClosed,G4State_EventProc); 125 142 126 // Command /process/inactivate << 143 //Commnad /particle/process/inactivate 127 inactivateCmd = new G4UIcommand("/process/in 144 inactivateCmd = new G4UIcommand("/process/inactivate",this); 128 inactivateCmd->SetGuidance("Inactivate proce 145 inactivateCmd->SetGuidance("Inactivate process "); 129 inactivateCmd->SetGuidance("Inactivate proce 146 inactivateCmd->SetGuidance("Inactivate processes "); 130 inactivateCmd->SetGuidance(" Inactivate nam 147 inactivateCmd->SetGuidance(" Inactivate name [particle]"); 131 inactivateCmd->SetGuidance(" name: pro 148 inactivateCmd->SetGuidance(" name: process name or type name"); 132 inactivateCmd->SetGuidance(" particle: par 149 inactivateCmd->SetGuidance(" particle: particle name [all: for all particles]"); 133 param = new G4UIparameter("procName",'s',fal 150 param = new G4UIparameter("procName",'s',false); 134 inactivateCmd->SetParameter(param); 151 inactivateCmd->SetParameter(param); 135 param = new G4UIparameter("particle",'s',tru 152 param = new G4UIparameter("particle",'s',true); 136 param->SetDefaultValue("all"); 153 param->SetDefaultValue("all"); 137 inactivateCmd->SetParameter(param); 154 inactivateCmd->SetParameter(param); 138 inactivateCmd->AvailableForStates(G4State_Id << 155 inactivateCmd->AvailableForStates(G4State_Idle,G4State_GeomClosed,G4State_EventProc); 139 } 156 } 140 157 141 // ------------------------------------------- << 158 ////////////////// 142 G4ProcessTableMessenger::~G4ProcessTableMessen 159 G4ProcessTableMessenger::~G4ProcessTableMessenger() 143 { 160 { 144 delete activateCmd; 161 delete activateCmd; 145 delete inactivateCmd; 162 delete inactivateCmd; 146 delete verboseCmd; 163 delete verboseCmd; 147 delete dumpCmd; 164 delete dumpCmd; 148 delete listCmd; 165 delete listCmd; 149 delete procVerboseCmd; 166 delete procVerboseCmd; 150 delete thisDirectory; 167 delete thisDirectory; 151 } 168 } 152 169 153 // ------------------------------------------- << 170 /////////////// 154 void << 171 void G4ProcessTableMessenger::SetNewValue(G4UIcommand * command,G4String newValue) 155 G4ProcessTableMessenger::SetNewValue(G4UIcomma << 156 { 172 { 157 G4ProcessTable::G4ProcNameVector* procNameVe 173 G4ProcessTable::G4ProcNameVector* procNameVector 158 = theProcessTable->Ge 174 = theProcessTable->GetNameList(); >> 175 G4int idx; >> 176 >> 177 G4ProcessVector* tmpVector=0; 159 G4int type = -1; 178 G4int type = -1; 160 G4ExceptionDescription ed; << 161 179 162 if( command == listCmd ) << 180 if( command == listCmd ){ 163 { << 181 //Commnad /process/list 164 // Command /process/list << 165 type = -1; 182 type = -1; 166 if (newValue == "all") << 183 if (newValue == "all") { 167 { << 184 currentProcessTypeName = newValue; 168 currentProcessTypeName = std::move(newVa << 185 } else { 169 } << 170 else << 171 { << 172 type = GetProcessType(newValue); 186 type = GetProcessType(newValue); 173 if (type <0) << 187 if (type <0) { 174 { << 188 G4cout << " illegal type !!! " << G4endl; 175 G4cout << " illegal type !!! " << G4en << 189 } else { 176 } << 190 currentProcessTypeName = newValue; 177 else << 178 { << 179 currentProcessTypeName = std::move(new << 180 } 191 } 181 } 192 } 182 G4int counter = 0; 193 G4int counter = 0; 183 for (auto itr=procNameVector->cbegin(); it << 194 idx =0; 184 { << 195 G4ProcessTable::G4ProcNameVector::iterator itr; 185 G4ProcessVector* tmpVector = theProcessT << 196 for (itr=procNameVector->begin(); itr!=procNameVector->end(); ++itr) { 186 if ( (type <0) || ( ((*tmpVector)(0)->Ge << 197 idx +=1; 187 { << 198 tmpVector = theProcessTable->FindProcesses(*itr); >> 199 if ( (type <0) || ( ((*tmpVector)(0)->GetProcessType()) == type) ) { 188 if ( counter%4 != 0) G4cout << ","; 200 if ( counter%4 != 0) G4cout << ","; 189 G4cout << std::setw(19) << *itr; << 201 G4cout << std::setw(19) <<*itr; 190 if ((counter++)%4 == 3) << 202 if ((counter++)%4 == 3) { 191 { << 192 G4cout << G4endl; 203 G4cout << G4endl; 193 } 204 } 194 } 205 } 195 delete tmpVector; << 196 } 206 } 197 G4cout << G4endl; 207 G4cout << G4endl; 198 } << 208 delete tmpVector; 199 else if( command==procVerboseCmd ) << 209 //Commnad /process/list 200 { << 210 201 // Command /process/setVerbose << 211 } else if( command==procVerboseCmd ) { >> 212 //Commnad /process/setVerbose 202 G4Tokenizer next( newValue ); 213 G4Tokenizer next( newValue ); 203 214 204 // check 1st argument 215 // check 1st argument 205 G4String tmpS = G4String(next()); 216 G4String tmpS = G4String(next()); 206 // inputstream for newValues 217 // inputstream for newValues 207 const char* temp = (const char*)(tmpS); 218 const char* temp = (const char*)(tmpS); 208 std::istringstream is((char*)temp); 219 std::istringstream is((char*)temp); 209 G4int level; 220 G4int level; 210 is >>level; 221 is >>level; 211 222 212 // check 2nd argument 223 // check 2nd argument 213 currentProcessTypeName = G4String(next()); 224 currentProcessTypeName = G4String(next()); 214 if (currentProcessTypeName.empty()) curren << 225 if (currentProcessTypeName.isNull()) currentProcessTypeName = "all"; 215 G4bool isProcName = false; 226 G4bool isProcName = false; 216 G4bool isAll = false; 227 G4bool isAll = false; 217 type = -1; 228 type = -1; 218 229 219 if (currentProcessTypeName == "all") << 230 if (currentProcessTypeName == "all") { 220 { << 221 isAll = true; 231 isAll = true; 222 } << 232 } else { 223 else << 224 { << 225 type = GetProcessType(currentProcessTyp 233 type = GetProcessType(currentProcessTypeName); 226 if (type<0) << 234 if (type<0) { 227 { << 235 isProcName = true; 228 isProcName = true; << 236 currentProcessName = currentProcessTypeName; 229 currentProcessName = currentProcessTyp << 237 currentProcessTypeName = ""; 230 currentProcessTypeName = ""; << 231 } 238 } 232 } 239 } 233 for (auto itr=procNameVector->cbegin(); it << 240 idx =0; 234 { << 241 G4ProcessTable::G4ProcNameVector::iterator itr; 235 G4ProcessVector* tmpVector = theProcessT << 242 for (itr=procNameVector->begin(); itr!=procNameVector->end(); ++itr) { >> 243 idx +=1; >> 244 tmpVector = theProcessTable->FindProcesses(*itr); 236 G4VProcess* p = (*tmpVector)(0); 245 G4VProcess* p = (*tmpVector)(0); 237 if ( isAll || 246 if ( isAll || 238 (!isProcName && ( p->GetProcessType << 247 (!isProcName && ( p->GetProcessType() == type) ) || 239 ( isProcName && ( p->GetProcessName << 248 ( isProcName && ( p->GetProcessName()== currentProcessName) ) ){ 240 { << 249 p->SetVerboseLevel(level); 241 p->SetVerboseLevel(level); << 242 } 250 } 243 delete tmpVector; << 244 } 251 } 245 } << 252 delete tmpVector; 246 else if( command==verboseCmd ) << 253 //Commnad /process/setVerbose 247 { << 254 248 // Command /process/verbose << 255 } else if( command==verboseCmd ) { 249 theProcessTable->SetVerboseLevel(verboseCm << 256 //Commnad /process/verbose 250 } << 257 theProcessTable->SetVerboseLevel(verboseCmd->GetNewIntValue(newValue)); 251 else << 258 //Commnad /process/verbose 252 { << 259 >> 260 } else { 253 G4Tokenizer next( newValue ); 261 G4Tokenizer next( newValue ); 254 262 255 // check 1st argument 263 // check 1st argument 256 currentProcessName = G4String(next()); 264 currentProcessName = G4String(next()); >> 265 G4bool isNameFound = false; 257 G4bool isProcName = false; 266 G4bool isProcName = false; 258 for (auto itr=procNameVector->cbegin(); it << 267 G4ProcessTable::G4ProcNameVector::iterator itr; 259 { << 268 for (itr=procNameVector->begin(); itr!=procNameVector->end(); ++itr) { 260 if ( (*itr) == currentProcessName ) << 269 if ( (*itr) == currentProcessName ) { 261 { << 270 isNameFound = true; 262 isProcName = true; << 271 isProcName = true; 263 break; << 272 break; 264 } 273 } 265 } 274 } 266 if (!isProcName) << 275 if (!isProcName) { 267 { << 268 type = GetProcessType(currentProcessNam 276 type = GetProcessType(currentProcessName); 269 if (type <0 ) << 277 if (type >=0) { 270 { << 278 isNameFound = true; 271 // no processes with specified name << 279 } else { 272 ed << " illegal process (or type) name << 280 // no processes with specifed name 273 << currentProcessName << "]"; << 281 G4cout << " illegal process (or type) name " << G4endl; 274 command->CommandFailed(ed); << 282 currentProcessName = ""; 275 currentProcessName = ""; << 283 return; 276 return; << 277 } 284 } 278 } 285 } 279 286 280 // check 2nd argument 287 // check 2nd argument 281 currentParticleName = G4String(next()); 288 currentParticleName = G4String(next()); 282 G4bool isParticleFound = false; 289 G4bool isParticleFound = false; 283 G4ParticleDefinition* currentParticle = nu << 290 G4ParticleDefinition* currentParticle = 0; 284 if ( currentParticleName == "all" ) << 291 if ( currentParticleName == "all" ) { 285 { << 286 isParticleFound = true; 292 isParticleFound = true; 287 } << 293 288 else << 294 } else { 289 { << 295 isParticleFound = G4ParticleTable::GetParticleTable()->contains(currentParticleName); 290 isParticleFound = G4ParticleTable::GetPa << 296 if (isParticleFound) { 291 ->contains(currentPartic << 297 currentParticle = G4ParticleTable::GetParticleTable()->FindParticle(currentParticleName); 292 if (isParticleFound) << 293 { << 294 currentParticle = G4ParticleTable::Get << 295 ->FindParticle(current << 296 } 298 } >> 299 297 } 300 } 298 301 299 if ( !isParticleFound ) << 302 if ( !isParticleFound ) { 300 { << 303 // no particle with specifed name 301 // no particle with specified name << 304 G4cout << " illegal particle name " << G4endl; 302 ed << " illegal particle name [" << curr << 303 command->CommandFailed(ed); << 304 currentParticleName = ""; 305 currentParticleName = ""; 305 return; 306 return; 306 } 307 } 307 308 308 if( command==dumpCmd ) << 309 if( command==dumpCmd ) { 309 { << 310 // process/dump 310 // process/dump 311 G4ProcessVector* tmpVector; << 311 if (isProcName) { 312 if (isProcName) << 312 tmpVector = theProcessTable->FindProcesses(currentProcessName); 313 { << 313 } else { 314 tmpVector = theProcessTable->FindProce << 314 tmpVector = theProcessTable->FindProcesses(G4ProcessType(type)); 315 } << 316 else << 317 { << 318 tmpVector = theProcessTable->FindProce << 319 } 315 } 320 for (G4int i=0; i<(G4int)tmpVector->leng << 316 for (G4int i=0; i<tmpVector->length(); i++) { 321 { << 317 theProcessTable->DumpInfo( (*tmpVector)(i), currentParticle ); 322 theProcessTable->DumpInfo( (*tmpVector << 323 } 318 } 324 delete tmpVector; 319 delete tmpVector; 325 } << 320 // process/dump 326 else if ( (command==activateCmd) || (comma << 321 327 { << 322 } else if ( (command==activateCmd) || (command==inactivateCmd)) { 328 // process/activate , inactivate 323 // process/activate , inactivate 329 G4bool fActive = (command==activateCmd); 324 G4bool fActive = (command==activateCmd); 330 if (isProcName) << 325 if (isProcName) { 331 { << 326 if ( currentParticle == 0 ) { 332 if ( currentParticle == nullptr ) << 327 theProcessTable->SetProcessActivation(currentProcessName, 333 { << 328 fActive); 334 theProcessTable->SetProcessActivatio << 329 } else { 335 << 330 theProcessTable->SetProcessActivation(currentProcessName, 336 } << 331 currentParticle, 337 else << 332 fActive); 338 { << 333 } 339 theProcessTable->SetProcessActivatio << 334 } else { 340 << 335 if ( currentParticle == 0 ) { 341 << 336 theProcessTable->SetProcessActivation(G4ProcessType(type), 342 } << 337 fActive); 343 } << 338 } else { 344 else << 339 theProcessTable->SetProcessActivation(G4ProcessType(type), 345 { << 340 currentParticle, 346 if ( currentParticle == nullptr ) << 341 fActive); 347 { << 342 } 348 theProcessTable->SetProcessActivatio << 349 << 350 } << 351 else << 352 { << 353 theProcessTable->SetProcessActivatio << 354 << 355 << 356 } << 357 } 343 } 358 G4UImanager::GetUIpointer()->ApplyComman << 344 // process/activate , inactivate 359 } 345 } 360 } 346 } 361 } 347 } 362 348 363 // ------------------------------------------- << 349 364 G4String G4ProcessTableMessenger::GetCurrentVa << 350 ////////////////// >> 351 G4String G4ProcessTableMessenger::GetCurrentValue(G4UIcommand * command) 365 { 352 { 366 if( command==verboseCmd ) << 353 G4ProcessTable::G4ProcNameVector* procNameVector 367 { << 354 = theProcessTable->GetNameList(); 368 // Command /process/verbose << 355 369 return verboseCmd->ConvertToString(theProc << 356 G4String candidates; 370 } << 357 G4String returnValue('\0'); 371 else if ( command==listCmd ) << 358 372 { << 359 std::ostringstream os; 373 // Command /process/list << 360 G4UIparameter * param; 374 return currentProcessTypeName; << 361 375 } << 362 G4int idx; 376 else << 363 377 { << 364 if( command==verboseCmd ){ 378 // Command /process/dump, activate, inac << 365 //Commnad /process/verbose 379 return (currentProcessName + " " + curre << 366 os << theProcessTable->GetVerboseLevel(); >> 367 returnValue = os.str(); >> 368 >> 369 } else if ( command==listCmd ){ >> 370 //Commnad /process/list >> 371 candidates = "all"; >> 372 for (idx = 0; idx < NumberOfProcessType ; idx ++ ) { >> 373 candidates += " " + >> 374 G4VProcess::GetProcessTypeName(G4ProcessType(idx)); >> 375 } >> 376 listCmd->SetCandidates((const char*)(candidates)); >> 377 returnValue = currentProcessTypeName; >> 378 >> 379 } else { >> 380 //Commnad /process/dump, activate, inactivate >> 381 // process name >> 382 param = command->GetParameter(0); >> 383 candidates = ""; >> 384 G4ProcessTable::G4ProcNameVector::iterator itr; >> 385 for (itr=procNameVector->begin(); itr!=procNameVector->end(); ++itr) { >> 386 candidates += " " + (*itr); >> 387 } >> 388 param->SetParameterCandidates((const char*)(candidates)); >> 389 // particle name >> 390 param = command->GetParameter(1); >> 391 candidates = "all"; >> 392 G4ParticleTable::G4PTblDicIterator *piter >> 393 = G4ParticleTable::GetParticleTable()->GetIterator(); >> 394 piter -> reset(); >> 395 while( (*piter)() ){ >> 396 G4ParticleDefinition *particle = piter->value(); >> 397 candidates += " " + particle->GetParticleName(); >> 398 } >> 399 param->SetParameterCandidates((const char*)(candidates)); >> 400 >> 401 returnValue = currentProcessName + " " + currentParticleName; >> 402 380 } 403 } 381 404 382 return ""; << 405 return returnValue; 383 } 406 } 384 407 385 // ------------------------------------------- << 408 ///////////////// 386 G4String G4ProcessTableMessenger::GetProcessTy 409 G4String G4ProcessTableMessenger::GetProcessTypeName(G4ProcessType aType) const 387 { 410 { 388 return G4VProcess::GetProcessTypeName(aType) 411 return G4VProcess::GetProcessTypeName(aType); 389 } 412 } 390 413 391 // ------------------------------------------- << 414 ///////////////// 392 G4int G4ProcessTableMessenger::GetProcessType( 415 G4int G4ProcessTableMessenger::GetProcessType(const G4String& aTypeName) const 393 { 416 { 394 G4int type = -1; 417 G4int type = -1; 395 for (G4int idx = 0; idx < NumberOfProcessTyp << 418 for (G4int idx = 0; idx < NumberOfProcessType ; idx ++ ) { 396 { << 419 if (aTypeName == G4VProcess::GetProcessTypeName(G4ProcessType(idx)) ) { 397 if (aTypeName == G4VProcess::GetProcessTyp << 398 { << 399 type = idx; 420 type = idx; 400 break; 421 break; 401 } 422 } 402 } 423 } 403 return type; 424 return type; 404 } 425 } 405 426 406 // ------------------------------------------- << 427 >> 428 ///////////////// 407 void G4ProcessTableMessenger::SetNumberOfProce 429 void G4ProcessTableMessenger::SetNumberOfProcessType() 408 { 430 { 409 G4bool isFoundEndMark = false; 431 G4bool isFoundEndMark = false; 410 G4int idx; 432 G4int idx; 411 for (idx = 0; idx < 1000 ; ++idx ) << 433 for (idx = 0; idx < 1000 ; idx ++ ) { 412 { << 413 G4String typeName = G4VProcess::GetProcess 434 G4String typeName = G4VProcess::GetProcessTypeName(G4ProcessType(idx)); 414 isFoundEndMark = G4StrUtil::contains(typeN << 435 if ( isFoundEndMark = typeName.contains("---")) break; 415 if ( isFoundEndMark ) break; << 416 } 436 } 417 if ( isFoundEndMark ) << 437 if ( isFoundEndMark ) { 418 { << 419 NumberOfProcessType = idx; 438 NumberOfProcessType = idx; 420 } << 439 } else { 421 else << 440 G4Exception("G4ProcessTableMessenger::SetNumberOfProcessType()","No End Mark", 422 { << 441 FatalException,""); 423 G4Exception("G4ProcessTableMessenger::SetN << 424 "ProcMan014", FatalException, << 425 } 442 } 426 } 443 } >> 444 >> 445 >> 446 >> 447 427 448