Geant4 Cross Reference |
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 // G4ProcessTable class implementation 26 // G4ProcessTable class implementation 27 // 27 // 28 // Author: H.Kurashige, 4 August 1998 28 // Author: H.Kurashige, 4 August 1998 29 // ------------------------------------------- 29 // -------------------------------------------------------------------- 30 30 31 #include "G4ProcessTableMessenger.hh" 31 #include "G4ProcessTableMessenger.hh" 32 #include "G4ProcessTable.hh" 32 #include "G4ProcessTable.hh" 33 #include "G4ParticleTable.hh" 33 #include "G4ParticleTable.hh" 34 #include "G4ios.hh" 34 #include "G4ios.hh" 35 35 36 // ------------------------------------------- 36 // -------------------------------------------------------------------- 37 // Static class variable: ptr to single instan 37 // Static class variable: ptr to single instance of class in a thread 38 G4ThreadLocal G4ProcessTable* G4ProcessTable:: 38 G4ThreadLocal G4ProcessTable* G4ProcessTable::fProcessTable = nullptr; 39 39 40 // ------------------------------------------- 40 // -------------------------------------------------------------------- 41 // Default constructor 41 // Default constructor 42 // 42 // 43 G4ProcessTable::G4ProcessTable() 43 G4ProcessTable::G4ProcessTable() 44 { 44 { 45 #ifdef G4VERBOSE 45 #ifdef G4VERBOSE 46 if (verboseLevel>1) 46 if (verboseLevel>1) 47 { 47 { 48 G4cout << "-- G4ProcessTable constructor 48 G4cout << "-- G4ProcessTable constructor --" << G4endl; 49 } 49 } 50 #endif 50 #endif 51 fProcTblVector = new G4ProcTableVector(); 51 fProcTblVector = new G4ProcTableVector(); 52 fProcNameVector = new G4ProcNameVector(); 52 fProcNameVector = new G4ProcNameVector(); 53 tmpTblVector = new G4ProcTableVector(); 53 tmpTblVector = new G4ProcTableVector(); 54 fProcTblMessenger = new G4ProcessTableMessen 54 fProcTblMessenger = new G4ProcessTableMessenger(this); 55 } 55 } 56 56 57 // ------------------------------------------- 57 // -------------------------------------------------------------------- 58 // Destructor 58 // Destructor 59 // 59 // 60 G4ProcessTable::~G4ProcessTable() 60 G4ProcessTable::~G4ProcessTable() 61 { 61 { 62 if ( tmpTblVector != nullptr ) 62 if ( tmpTblVector != nullptr ) 63 { 63 { 64 tmpTblVector ->clear(); 64 tmpTblVector ->clear(); 65 delete tmpTblVector; 65 delete tmpTblVector; 66 tmpTblVector = nullptr; 66 tmpTblVector = nullptr; 67 } 67 } 68 68 69 if ( fProcTblVector != nullptr ) 69 if ( fProcTblVector != nullptr ) 70 { 70 { 71 for (auto elem : *fProcTblVector) 71 for (auto elem : *fProcTblVector) 72 { 72 { 73 delete elem; 73 delete elem; 74 } 74 } 75 fProcTblVector ->clear(); 75 fProcTblVector ->clear(); 76 delete fProcTblVector; 76 delete fProcTblVector; 77 fProcTblVector = nullptr; 77 fProcTblVector = nullptr; 78 } 78 } 79 79 80 // delete all process except transportation 80 // delete all process except transportation 81 for(auto proc : fListProcesses) 81 for(auto proc : fListProcesses) 82 { 82 { 83 if ( proc != nullptr ) 83 if ( proc != nullptr ) 84 { 84 { 85 G4ProcessType type = proc->GetProcessTyp 85 G4ProcessType type = proc->GetProcessType(); 86 if (type != fTransportation && type != f 86 if (type != fTransportation && type != fParallel 87 && type != fParameterisation) 87 && type != fParameterisation) 88 { 88 { 89 delete proc; 89 delete proc; 90 } 90 } 91 } 91 } 92 } 92 } 93 93 94 fListProcesses.clear(); 94 fListProcesses.clear(); 95 95 96 if ( fProcNameVector != nullptr ) 96 if ( fProcNameVector != nullptr ) 97 { 97 { 98 fProcNameVector ->clear(); 98 fProcNameVector ->clear(); 99 delete fProcNameVector; 99 delete fProcNameVector; 100 fProcNameVector = nullptr; 100 fProcNameVector = nullptr; 101 } 101 } 102 fProcessTable = nullptr; 102 fProcessTable = nullptr; 103 delete fProcTblMessenger; 103 delete fProcTblMessenger; 104 } 104 } 105 105 106 // ------------------------------------------- 106 // -------------------------------------------------------------------- 107 // 107 // 108 G4ProcessTable* G4ProcessTable::GetProcessTabl 108 G4ProcessTable* G4ProcessTable::GetProcessTable() 109 { 109 { 110 if(fProcessTable == nullptr) 110 if(fProcessTable == nullptr) 111 { 111 { 112 static G4ThreadLocalSingleton<G4ProcessTab 112 static G4ThreadLocalSingleton<G4ProcessTable> inst; 113 fProcessTable = inst.Instance(); 113 fProcessTable = inst.Instance(); 114 } 114 } 115 return fProcessTable; 115 return fProcessTable; 116 } 116 } 117 117 118 // ------------------------------------------- 118 // -------------------------------------------------------------------- 119 // 119 // 120 G4int G4ProcessTable::Insert(G4VProcess* aProc 120 G4int G4ProcessTable::Insert(G4VProcess* aProcess, 121 G4ProcessManager* 121 G4ProcessManager* aProcMgr) 122 { 122 { 123 if ( (aProcess == nullptr) || ( aProcMgr == 123 if ( (aProcess == nullptr) || ( aProcMgr == nullptr ) || !fProcTblVector ) 124 { 124 { 125 #ifdef G4VERBOSE 125 #ifdef G4VERBOSE 126 if (verboseLevel>0) 126 if (verboseLevel>0) 127 { 127 { 128 G4cout << "G4ProcessTable::Insert() - ar 128 G4cout << "G4ProcessTable::Insert() - arguments are null pointer " 129 << aProcess << "," << aProcMgr << 129 << aProcess << "," << aProcMgr << G4endl; 130 } 130 } 131 #endif 131 #endif 132 return -1; 132 return -1; 133 } 133 } 134 134 135 #ifdef G4VERBOSE 135 #ifdef G4VERBOSE 136 if (verboseLevel>1) 136 if (verboseLevel>1) 137 { 137 { 138 G4cout << "G4ProcessTable::Insert() -"; 138 G4cout << "G4ProcessTable::Insert() -"; 139 G4cout << " Process[" << aProcess->GetPro 139 G4cout << " Process[" << aProcess->GetProcessName() << "]"; 140 G4cout << " Particle[" << aProcMgr->GetPa 140 G4cout << " Particle[" << aProcMgr->GetParticleType()->GetParticleName() 141 << "]" << G4endl; 141 << "]" << G4endl; 142 } 142 } 143 #endif 143 #endif 144 144 145 G4int idxTbl = 0; 145 G4int idxTbl = 0; 146 G4int nidx = (G4int)fProcTblVector->size(); 146 G4int nidx = (G4int)fProcTblVector->size(); 147 G4ProcTblElement* anElement = nullptr; 147 G4ProcTblElement* anElement = nullptr; 148 // loop over all elements 148 // loop over all elements 149 for (; idxTbl < nidx; ++idxTbl) 149 for (; idxTbl < nidx; ++idxTbl) 150 { 150 { 151 anElement = (*fProcTblVector)[idxTbl]; 151 anElement = (*fProcTblVector)[idxTbl]; 152 if(!anElement) { continue; } 152 if(!anElement) { continue; } 153 // check if this process is included 153 // check if this process is included 154 if (aProcess == anElement->GetProcess()) 154 if (aProcess == anElement->GetProcess()) 155 { 155 { 156 // add the process manager into the elem 156 // add the process manager into the element 157 // unless this process manager is inclu 157 // unless this process manager is included 158 if (!anElement->Contains(aProcMgr)) 158 if (!anElement->Contains(aProcMgr)) 159 { 159 { 160 anElement->Insert(aProcMgr); 160 anElement->Insert(aProcMgr); 161 #ifdef G4VERBOSE 161 #ifdef G4VERBOSE 162 if (verboseLevel>2) 162 if (verboseLevel>2) 163 { 163 { 164 G4cout << " This Process Manager is 164 G4cout << " This Process Manager is registered !! " << G4endl; 165 } 165 } 166 #endif 166 #endif 167 } 167 } 168 return idxTbl; 168 return idxTbl; 169 } 169 } 170 } 170 } 171 // add this process into the table by creati 171 // add this process into the table by creating a new element 172 if (verboseLevel>2) 172 if (verboseLevel>2) 173 { 173 { 174 G4cout << " New element is created !! " << 174 G4cout << " New element is created !! " << G4endl; 175 } 175 } 176 anElement = new G4ProcTblElement(aProcess); 176 anElement = new G4ProcTblElement(aProcess); 177 anElement->Insert(aProcMgr); 177 anElement->Insert(aProcMgr); 178 fProcTblVector->push_back(anElement); 178 fProcTblVector->push_back(anElement); 179 fProcNameVector->push_back(aProcess->GetProc 179 fProcNameVector->push_back(aProcess->GetProcessName() ); 180 return nidx; 180 return nidx; 181 } 181 } 182 182 183 // ------------------------------------------- 183 // -------------------------------------------------------------------- 184 // 184 // 185 G4int G4ProcessTable::Remove( G4VProcess* aPro 185 G4int G4ProcessTable::Remove( G4VProcess* aProcess, 186 G4ProcessManager 186 G4ProcessManager* aProcMgr ) 187 { 187 { 188 if ( (aProcess == nullptr) || ( aProcMgr == 188 if ( (aProcess == nullptr) || ( aProcMgr == nullptr ) || !fProcTblVector ) 189 { 189 { 190 #ifdef G4VERBOSE 190 #ifdef G4VERBOSE 191 if (verboseLevel>0) 191 if (verboseLevel>0) 192 { 192 { 193 G4cout << "G4ProcessTable::Remove() - ar 193 G4cout << "G4ProcessTable::Remove() - arguments are null pointer " 194 << G4endl; 194 << G4endl; 195 } 195 } 196 #endif 196 #endif 197 return -1; 197 return -1; 198 } 198 } 199 199 200 #ifdef G4VERBOSE 200 #ifdef G4VERBOSE 201 if (verboseLevel>1) 201 if (verboseLevel>1) 202 { 202 { 203 G4cout << "G4ProcessTable::Remove() -"; 203 G4cout << "G4ProcessTable::Remove() -"; 204 G4cout << " Process[" << aProcess->GetPro 204 G4cout << " Process[" << aProcess->GetProcessName() << "]"; 205 G4cout << " Particle[" << aProcMgr->GetPar 205 G4cout << " Particle[" << aProcMgr->GetParticleType()->GetParticleName() 206 << "]" << G4endl; 206 << "]" << G4endl; 207 } 207 } 208 #endif 208 #endif 209 209 210 G4int idxTbl = 0; 210 G4int idxTbl = 0; 211 G4int nidx = (G4int)fProcTblVector->size(); 211 G4int nidx = (G4int)fProcTblVector->size(); 212 G4ProcTblElement* anElement =nullptr; 212 G4ProcTblElement* anElement =nullptr; 213 // loop over all elements 213 // loop over all elements 214 for (; idxTbl < nidx; ++idxTbl) 214 for (; idxTbl < nidx; ++idxTbl) 215 { 215 { 216 anElement = (*fProcTblVector)[idxTbl]; 216 anElement = (*fProcTblVector)[idxTbl]; 217 if(!anElement) { continue; } 217 if(!anElement) { continue; } 218 218 219 // check if this process is included 219 // check if this process is included 220 if (aProcess == anElement->GetProcess()) 220 if (aProcess == anElement->GetProcess()) 221 { 221 { 222 if(anElement->Contains(aProcMgr)) 222 if(anElement->Contains(aProcMgr)) 223 { 223 { 224 // remove the process manager from the 224 // remove the process manager from the element 225 anElement->Remove(aProcMgr); 225 anElement->Remove(aProcMgr); 226 #ifdef G4VERBOSE 226 #ifdef G4VERBOSE 227 if (verboseLevel>2) 227 if (verboseLevel>2) 228 { 228 { 229 G4cout << " This Process Manager is 229 G4cout << " This Process Manager is removed !! " << G4endl; 230 } 230 } 231 #endif 231 #endif 232 if(anElement->Length() == 0) 232 if(anElement->Length() == 0) 233 { 233 { 234 delete anElement; 234 delete anElement; 235 (*fProcTblVector)[idxTbl] = nullptr; 235 (*fProcTblVector)[idxTbl] = nullptr; 236 #ifdef G4VERBOSE 236 #ifdef G4VERBOSE 237 if (verboseLevel>1) 237 if (verboseLevel>1) 238 { 238 { 239 G4cout << " This Process is remove 239 G4cout << " This Process is removed !! " << G4endl; 240 } 240 } 241 #endif 241 #endif 242 } 242 } 243 return idxTbl; 243 return idxTbl; 244 } 244 } 245 } 245 } 246 } 246 } 247 #ifdef G4VERBOSE 247 #ifdef G4VERBOSE 248 if (verboseLevel>1) 248 if (verboseLevel>1) 249 { 249 { 250 G4cout << " This Process Manager is not re 250 G4cout << " This Process Manager is not registered to the process!! " 251 << G4endl; 251 << G4endl; 252 } 252 } 253 #endif 253 #endif 254 return -1; 254 return -1; 255 } 255 } 256 256 257 // ------------------------------------------- 257 // -------------------------------------------------------------------- 258 // 258 // 259 void G4ProcessTable::RegisterProcess(G4VProces 259 void G4ProcessTable::RegisterProcess(G4VProcess* ptr) 260 { 260 { 261 for(auto proc : fListProcesses) 261 for(auto proc : fListProcesses) 262 { 262 { 263 if(ptr == proc) { return; } 263 if(ptr == proc) { return; } 264 } 264 } 265 fListProcesses.push_back(ptr); 265 fListProcesses.push_back(ptr); 266 } 266 } 267 267 268 // ------------------------------------------- 268 // -------------------------------------------------------------------- 269 // 269 // 270 void G4ProcessTable::DeRegisterProcess(G4VProc 270 void G4ProcessTable::DeRegisterProcess(G4VProcess* ptr) 271 { 271 { 272 std::size_t nn = fListProcesses.size(); 272 std::size_t nn = fListProcesses.size(); 273 for(std::size_t i=0; i<nn; ++i) 273 for(std::size_t i=0; i<nn; ++i) 274 { 274 { 275 if(ptr == fListProcesses[i]) 275 if(ptr == fListProcesses[i]) 276 { 276 { 277 fListProcesses[i] = nullptr; 277 fListProcesses[i] = nullptr; 278 return; 278 return; 279 } 279 } 280 } 280 } 281 } 281 } 282 282 283 // ------------------------------------------- 283 // -------------------------------------------------------------------- 284 // 284 // 285 G4VProcess* G4ProcessTable::FindProcess(const 285 G4VProcess* G4ProcessTable::FindProcess(const G4String& processName, 286 const 286 const G4String& particleName) const 287 { 287 { 288 return FindProcess(processName, 288 return FindProcess(processName, 289 G4ParticleTable::GetParticleTable()- 289 G4ParticleTable::GetParticleTable()->FindParticle(particleName)); 290 } 290 } 291 291 292 // ------------------------------------------- 292 // -------------------------------------------------------------------- 293 // 293 // 294 G4VProcess* G4ProcessTable::FindProcess(const 294 G4VProcess* G4ProcessTable::FindProcess(const G4String& processName, 295 const 295 const G4ProcessManager* processManager) 296 const 296 const 297 { 297 { 298 for (auto anElement : *fProcTblVector) 298 for (auto anElement : *fProcTblVector) 299 { 299 { 300 // check name and if the processManage is 300 // check name and if the processManage is included 301 if (anElement && anElement->GetProcessName 301 if (anElement && anElement->GetProcessName() == processName 302 && anElement->Contains(processManager) 302 && anElement->Contains(processManager)) 303 { 303 { 304 return anElement->GetProcess(); 304 return anElement->GetProcess(); 305 } 305 } 306 } 306 } 307 #ifdef G4VERBOSE 307 #ifdef G4VERBOSE 308 if (verboseLevel > 1) 308 if (verboseLevel > 1) 309 { 309 { 310 G4cout << " G4ProcessTable::FindProcess() 310 G4cout << " G4ProcessTable::FindProcess() -" ; 311 G4cout << " The Process[" << processName < 311 G4cout << " The Process[" << processName << "] is not found "; 312 G4cout << " for [" << processManager->GetP 312 G4cout << " for [" << processManager->GetParticleType()->GetParticleName() 313 << "]" << G4endl; 313 << "]" << G4endl; 314 } 314 } 315 #endif 315 #endif 316 return nullptr; 316 return nullptr; 317 } 317 } 318 318 319 // ------------------------------------------- 319 // -------------------------------------------------------------------- 320 // 320 // 321 G4VProcess* 321 G4VProcess* 322 G4ProcessTable::FindProcess(G4ProcessType proc 322 G4ProcessTable::FindProcess(G4ProcessType processType, 323 const G4ParticleDe 323 const G4ParticleDefinition* particle) const 324 { 324 { 325 // find the first process of given type for 325 // find the first process of given type for this particle 326 326 327 const G4ProcessManager* processManager = par 327 const G4ProcessManager* processManager = particle->GetProcessManager(); 328 for (auto anElement : *fProcTblVector) 328 for (auto anElement : *fProcTblVector) 329 { 329 { 330 if (anElement && anElement->GetProcess()-> 330 if (anElement && anElement->GetProcess()->GetProcessType() == processType 331 && anElement->Contains(processManager) 331 && anElement->Contains(processManager)) 332 { 332 { 333 return anElement->GetProcess(); 333 return anElement->GetProcess(); 334 } 334 } 335 } 335 } 336 #ifdef G4VERBOSE 336 #ifdef G4VERBOSE 337 if (verboseLevel > 1) 337 if (verboseLevel > 1) 338 { 338 { 339 G4cout << " G4ProcessTable::FindProcess() 339 G4cout << " G4ProcessTable::FindProcess() -"; 340 G4cout << " The Process Type " << processT 340 G4cout << " The Process Type " << processType << " is not found "; 341 G4cout << " for [" << particle->GetParticl 341 G4cout << " for [" << particle->GetParticleName() << "]" << G4endl; 342 } 342 } 343 #endif 343 #endif 344 return nullptr; 344 return nullptr; 345 } 345 } 346 346 347 // ------------------------------------------- 347 // -------------------------------------------------------------------- 348 // 348 // 349 G4VProcess* 349 G4VProcess* 350 G4ProcessTable::FindProcess(G4int procSubType, 350 G4ProcessTable::FindProcess(G4int procSubType, 351 const G4ParticleDe 351 const G4ParticleDefinition* particle) const 352 { 352 { 353 // find the first process of given type for 353 // find the first process of given type for this particle 354 354 355 const G4ProcessManager* processManager = par 355 const G4ProcessManager* processManager = particle->GetProcessManager(); 356 for (auto anElement : *fProcTblVector) 356 for (auto anElement : *fProcTblVector) 357 { 357 { 358 if ( anElement != nullptr 358 if ( anElement != nullptr 359 && anElement->GetProcess()->GetProcessSu 359 && anElement->GetProcess()->GetProcessSubType() == procSubType 360 && anElement->Contains(processManager) ) 360 && anElement->Contains(processManager) ) 361 { 361 { 362 return anElement->GetProcess(); 362 return anElement->GetProcess(); 363 } 363 } 364 } 364 } 365 #ifdef G4VERBOSE 365 #ifdef G4VERBOSE 366 if (verboseLevel > 1) 366 if (verboseLevel > 1) 367 { 367 { 368 G4cout << " G4ProcessTable::FindProcess() 368 G4cout << " G4ProcessTable::FindProcess() -"; 369 G4cout << " The Process SubType " << procS 369 G4cout << " The Process SubType " << procSubType << " is not found "; 370 G4cout << " for [" << particle->GetParticl 370 G4cout << " for [" << particle->GetParticleName() << "]" << G4endl; 371 } 371 } 372 #endif 372 #endif 373 return nullptr; 373 return nullptr; 374 } 374 } 375 375 376 // ------------------------------------------- 376 // -------------------------------------------------------------------- 377 // 377 // 378 G4ProcessTable::G4ProcTableVector* 378 G4ProcessTable::G4ProcTableVector* 379 G4ProcessTable::Find(const G4String& processNa 379 G4ProcessTable::Find(const G4String& processName) 380 { 380 { 381 tmpTblVector->clear(); 381 tmpTblVector->clear(); 382 382 383 G4bool isFound = false; 383 G4bool isFound = false; 384 G4ProcTblElement* anElement = nullptr; 384 G4ProcTblElement* anElement = nullptr; 385 for (auto itr=fProcTblVector->cbegin(); itr! 385 for (auto itr=fProcTblVector->cbegin(); itr!=fProcTblVector->cend(); ++itr) 386 { 386 { 387 anElement = (*itr); 387 anElement = (*itr); 388 // check name 388 // check name 389 if ( anElement != nullptr && anElement->Ge 389 if ( anElement != nullptr && anElement->GetProcessName() == processName ) 390 { 390 { 391 isFound = true; 391 isFound = true; 392 tmpTblVector->push_back(anElement); 392 tmpTblVector->push_back(anElement); 393 } 393 } 394 } 394 } 395 395 396 if (!isFound && verboseLevel>0) 396 if (!isFound && verboseLevel>0) 397 { 397 { 398 #ifdef G4VERBOSE 398 #ifdef G4VERBOSE 399 G4cout << " G4ProcessTable::Find() -" ; 399 G4cout << " G4ProcessTable::Find() -" ; 400 G4cout << " The Process[" << processName < 400 G4cout << " The Process[" << processName << "] is not found " << G4endl; 401 #endif 401 #endif 402 } 402 } 403 403 404 return tmpTblVector; 404 return tmpTblVector; 405 } 405 } 406 406 407 // ------------------------------------------- 407 // -------------------------------------------------------------------- 408 // 408 // 409 G4ProcessTable::G4ProcTableVector* 409 G4ProcessTable::G4ProcTableVector* 410 G4ProcessTable::Find(G4ProcessType processType 410 G4ProcessTable::Find(G4ProcessType processType) 411 { 411 { 412 tmpTblVector->clear(); 412 tmpTblVector->clear(); 413 413 414 G4bool isFound = false; 414 G4bool isFound = false; 415 G4ProcTblElement* anElement = nullptr; 415 G4ProcTblElement* anElement = nullptr; 416 for (auto itr=fProcTblVector->cbegin(); itr! 416 for (auto itr=fProcTblVector->cbegin(); itr!=fProcTblVector->cend(); ++itr) 417 { 417 { 418 anElement = (*itr); 418 anElement = (*itr); 419 // check name 419 // check name 420 if ( anElement != nullptr && anElement->Ge 420 if ( anElement != nullptr && anElement->GetProcess()->GetProcessType() == processType ) 421 { 421 { 422 isFound = true; 422 isFound = true; 423 tmpTblVector->push_back(anElement); 423 tmpTblVector->push_back(anElement); 424 } 424 } 425 } 425 } 426 426 427 if (!isFound && verboseLevel>0) 427 if (!isFound && verboseLevel>0) 428 { 428 { 429 #ifdef G4VERBOSE 429 #ifdef G4VERBOSE 430 G4cout << " G4ProcessTable::Find() -" ; 430 G4cout << " G4ProcessTable::Find() -" ; 431 G4cout << " The ProcessType[" << processTy 431 G4cout << " The ProcessType[" << processType << "] is not found " 432 << G4endl; 432 << G4endl; 433 #endif 433 #endif 434 } 434 } 435 435 436 return tmpTblVector; 436 return tmpTblVector; 437 } 437 } 438 438 439 // ------------------------------------------- 439 // -------------------------------------------------------------------- 440 // 440 // 441 G4ProcessVector* 441 G4ProcessVector* 442 G4ProcessTable::ExtractProcesses(G4ProcTableVe 442 G4ProcessTable::ExtractProcesses(G4ProcTableVector* procTblVector) const 443 { 443 { 444 G4ProcessVector* procList = new G4ProcessVec 444 G4ProcessVector* procList = new G4ProcessVector(); 445 // loop over all elements 445 // loop over all elements 446 for (auto itr=procTblVector->cbegin(); itr!= 446 for (auto itr=procTblVector->cbegin(); itr!=procTblVector->cend(); ++itr) 447 { 447 { 448 G4ProcTblElement* anElement = (*itr); 448 G4ProcTblElement* anElement = (*itr); 449 if ( anElement != nullptr) procList->inser 449 if ( anElement != nullptr) procList->insert( anElement->GetProcess() ); 450 } 450 } 451 return procList; 451 return procList; 452 } 452 } 453 453 454 // ------------------------------------------- 454 // -------------------------------------------------------------------- 455 // 455 // 456 void G4ProcessTable::SetProcessActivation(cons 456 void G4ProcessTable::SetProcessActivation(const G4String& processName, 457 cons 457 const G4String& particleName, 458 458 G4bool fActive ) 459 { 459 { 460 if (particleName == "ALL" ) 460 if (particleName == "ALL" ) 461 { 461 { 462 SetProcessActivation( processName, fActive 462 SetProcessActivation( processName, fActive); 463 } 463 } 464 else 464 else 465 { 465 { 466 SetProcessActivation(processName, 466 SetProcessActivation(processName, 467 G4ParticleTable::GetParticleTable()->F 467 G4ParticleTable::GetParticleTable()->FindParticle(particleName), 468 fActive ); 468 fActive ); 469 } 469 } 470 } 470 } 471 471 472 // ------------------------------------------- 472 // -------------------------------------------------------------------- 473 // 473 // 474 void G4ProcessTable::SetProcessActivation(G4Pr 474 void G4ProcessTable::SetProcessActivation(G4ProcessType processType, 475 cons 475 const G4String& particleName , 476 476 G4bool fActive) 477 { 477 { 478 if ((particleName == "ALL" ) || (particleNam 478 if ((particleName == "ALL" ) || (particleName == "all" )) 479 { 479 { 480 SetProcessActivation( processType, fActive 480 SetProcessActivation( processType, fActive ); 481 } 481 } 482 else 482 else 483 { 483 { 484 SetProcessActivation(processType, 484 SetProcessActivation(processType, 485 G4ParticleTable::GetParticleTable()->F 485 G4ParticleTable::GetParticleTable()->FindParticle(particleName), 486 fActive ); 486 fActive ); 487 } 487 } 488 } 488 } 489 489 490 // ------------------------------------------- 490 // -------------------------------------------------------------------- 491 // 491 // 492 void G4ProcessTable::SetProcessActivation( con 492 void G4ProcessTable::SetProcessActivation( const G4String& processName, 493 G4b 493 G4bool fActive ) 494 { 494 { 495 #ifdef G4VERBOSE 495 #ifdef G4VERBOSE 496 if (verboseLevel>1) 496 if (verboseLevel>1) 497 { 497 { 498 G4cout << " G4ProcessTable::SetProcessActi 498 G4cout << " G4ProcessTable::SetProcessActivation() -" ; 499 G4cout << " The Process[" << processName < 499 G4cout << " The Process[" << processName << "] "<< G4endl; 500 } 500 } 501 #endif 501 #endif 502 502 503 G4ProcTableVector* pTblVector = Find(proces 503 G4ProcTableVector* pTblVector = Find(processName); 504 G4ProcTblElement* anElement; 504 G4ProcTblElement* anElement; 505 // loop over all elements 505 // loop over all elements 506 for (auto itr=pTblVector->cbegin(); itr!=pTb 506 for (auto itr=pTblVector->cbegin(); itr!=pTblVector->cend(); ++itr) 507 { 507 { 508 anElement = (*itr); 508 anElement = (*itr); 509 if ( anElement == nullptr ) continue; 509 if ( anElement == nullptr ) continue; 510 G4VProcess* process = anElement->GetProces 510 G4VProcess* process = anElement->GetProcess(); 511 for (G4int idx = 0 ; idx < anElement->Leng 511 for (G4int idx = 0 ; idx < anElement->Length(); ++idx) 512 { 512 { 513 G4ProcessManager* manager = anElement->G 513 G4ProcessManager* manager = anElement->GetProcessManager(idx); 514 manager->SetProcessActivation(process, f 514 manager->SetProcessActivation(process, fActive); 515 #ifdef G4VERBOSE 515 #ifdef G4VERBOSE 516 if (verboseLevel>1) 516 if (verboseLevel>1) 517 { 517 { 518 G4cout << " for " << manager->GetPart 518 G4cout << " for " << manager->GetParticleType()->GetParticleName(); 519 G4cout << " Index = " << manager->Get 519 G4cout << " Index = " << manager->GetProcessIndex(process); 520 G4cout << G4endl; 520 G4cout << G4endl; 521 } 521 } 522 #endif 522 #endif 523 } 523 } 524 } 524 } 525 } 525 } 526 526 527 // ------------------------------------------- 527 // -------------------------------------------------------------------- 528 // 528 // 529 void G4ProcessTable::SetProcessActivation(cons 529 void G4ProcessTable::SetProcessActivation(const G4String& processName, 530 G4Pr 530 G4ProcessManager* processManager, 531 G4bo 531 G4bool fActive ) 532 { 532 { 533 #ifdef G4VERBOSE 533 #ifdef G4VERBOSE 534 if (verboseLevel>1) 534 if (verboseLevel>1) 535 { 535 { 536 G4cout << " G4ProcessTable::SetProcessActi 536 G4cout << " G4ProcessTable::SetProcessActivation() -" ; 537 G4cout << " The Process[" << processName < 537 G4cout << " The Process[" << processName << "] "<< G4endl; 538 } 538 } 539 #endif 539 #endif 540 540 541 G4VProcess* process = FindProcess( processNa 541 G4VProcess* process = FindProcess( processName, processManager); 542 if ( process != nullptr) 542 if ( process != nullptr) 543 { 543 { 544 processManager->SetProcessActivation(proce 544 processManager->SetProcessActivation(process, fActive); 545 #ifdef G4VERBOSE 545 #ifdef G4VERBOSE 546 if (verboseLevel>1) 546 if (verboseLevel>1) 547 { 547 { 548 G4cout << " for " 548 G4cout << " for " 549 << processManager->GetParticleTyp 549 << processManager->GetParticleType()->GetParticleName(); 550 G4cout << " Index = " 550 G4cout << " Index = " 551 << processManager->GetProcessInde 551 << processManager->GetProcessIndex(process) << G4endl; 552 } 552 } 553 #endif 553 #endif 554 } 554 } 555 } 555 } 556 556 557 // ------------------------------------------- 557 // -------------------------------------------------------------------- 558 // 558 // 559 void G4ProcessTable::SetProcessActivation( G4P 559 void G4ProcessTable::SetProcessActivation( G4ProcessType processType, 560 G4b 560 G4bool fActive ) 561 { 561 { 562 #ifdef G4VERBOSE 562 #ifdef G4VERBOSE 563 if (verboseLevel>1) 563 if (verboseLevel>1) 564 { 564 { 565 G4cout << " G4ProcessTable::SetProcessActi 565 G4cout << " G4ProcessTable::SetProcessActivation() -" ; 566 G4cout << " The ProcessType[" << G4int(pro 566 G4cout << " The ProcessType[" << G4int(processType) << "] "<< G4endl; 567 } 567 } 568 #endif 568 #endif 569 569 570 G4ProcTableVector* pTblVector = Find(process 570 G4ProcTableVector* pTblVector = Find(processType); 571 G4ProcTblElement* anElement; 571 G4ProcTblElement* anElement; 572 // loop over all elements 572 // loop over all elements 573 for (auto itr=pTblVector->cbegin(); itr!=pTb 573 for (auto itr=pTblVector->cbegin(); itr!=pTblVector->cend(); ++itr) 574 { 574 { 575 anElement = (*itr); 575 anElement = (*itr); 576 if ( anElement == nullptr ) continue; 576 if ( anElement == nullptr ) continue; 577 G4VProcess* process = anElement->GetProces 577 G4VProcess* process = anElement->GetProcess(); 578 #ifdef G4VERBOSE 578 #ifdef G4VERBOSE 579 if (verboseLevel>1) 579 if (verboseLevel>1) 580 { 580 { 581 G4cout << " The Process[" << process->Ge 581 G4cout << " The Process[" << process->GetProcessName()<< "] "<< G4endl; 582 } 582 } 583 #endif 583 #endif 584 for (G4int idx = 0 ; idx < anElement->Leng 584 for (G4int idx = 0 ; idx < anElement->Length(); ++idx) 585 { 585 { 586 G4ProcessManager* manager = anElement->G 586 G4ProcessManager* manager = anElement->GetProcessManager(idx); 587 manager->SetProcessActivation(process, f 587 manager->SetProcessActivation(process, fActive); 588 #ifdef G4VERBOSE 588 #ifdef G4VERBOSE 589 if (verboseLevel>1) 589 if (verboseLevel>1) 590 { 590 { 591 G4cout << " for " << manager->GetPart 591 G4cout << " for " << manager->GetParticleType()->GetParticleName(); 592 G4cout << " Index = " << manager->Get 592 G4cout << " Index = " << manager->GetProcessIndex(process) << G4endl; 593 } 593 } 594 #endif 594 #endif 595 } 595 } 596 } 596 } 597 } 597 } 598 598 599 // ------------------------------------------- 599 // -------------------------------------------------------------------- 600 // 600 // 601 void G4ProcessTable::SetProcessActivation( G4P 601 void G4ProcessTable::SetProcessActivation( G4ProcessType processType, 602 G4P 602 G4ProcessManager* processManager, 603 G4b 603 G4bool fActive ) 604 { 604 { 605 #ifdef G4VERBOSE 605 #ifdef G4VERBOSE 606 if (verboseLevel>1) 606 if (verboseLevel>1) 607 { 607 { 608 G4cout << " G4ProcessTable::SetProcessActi 608 G4cout << " G4ProcessTable::SetProcessActivation() -" ; 609 G4cout << " The ProcessType[" << G4int(pro 609 G4cout << " The ProcessType[" << G4int(processType) << "] "<< G4endl; 610 } 610 } 611 #endif 611 #endif 612 612 613 G4ProcessVector* procList = processManager- 613 G4ProcessVector* procList = processManager->GetProcessList(); 614 for (G4int idx = 0; idx < (G4int)procList->l 614 for (G4int idx = 0; idx < (G4int)procList->length(); ++idx) 615 { 615 { 616 G4VProcess* process = (*procList)(idx); 616 G4VProcess* process = (*procList)(idx); 617 if ( process->GetProcessType() == processT 617 if ( process->GetProcessType() == processType) 618 { 618 { 619 processManager->SetProcessActivation(pro 619 processManager->SetProcessActivation(process, fActive); 620 #ifdef G4VERBOSE 620 #ifdef G4VERBOSE 621 if (verboseLevel>1) 621 if (verboseLevel>1) 622 { 622 { 623 G4cout << " The Process[" << process-> 623 G4cout << " The Process[" << process->GetProcessName()<< "] "<< G4endl; 624 G4cout << " for " 624 G4cout << " for " 625 << processManager->GetParticleT 625 << processManager->GetParticleType()->GetParticleName(); 626 G4cout << " Index = " << idx << G4end 626 G4cout << " Index = " << idx << G4endl; 627 } 627 } 628 #endif 628 #endif 629 } 629 } 630 } 630 } 631 } 631 } 632 632 633 // ------------------------------------------- 633 // -------------------------------------------------------------------- 634 // 634 // 635 void G4ProcessTable::DumpInfo(G4VProcess* proc 635 void G4ProcessTable::DumpInfo(G4VProcess* process, 636 const G4Particle 636 const G4ParticleDefinition* particle) 637 { 637 { 638 G4int idxTbl=0; 638 G4int idxTbl=0; 639 G4ProcTblElement* anElement = nullptr; 639 G4ProcTblElement* anElement = nullptr; 640 G4bool isFoundInTbl = false; 640 G4bool isFoundInTbl = false; 641 G4ProcessManager* manager = nullptr; 641 G4ProcessManager* manager = nullptr; 642 G4int idx; 642 G4int idx; 643 // loop over all elements 643 // loop over all elements 644 for (auto itr=fProcTblVector->cbegin(); 644 for (auto itr=fProcTblVector->cbegin(); 645 itr!=fProcTblVector->cend(); ++itr 645 itr!=fProcTblVector->cend(); ++itr, ++idxTbl) 646 { 646 { 647 anElement = (*itr); 647 anElement = (*itr); 648 if ( anElement == nullptr ) continue; 648 if ( anElement == nullptr ) continue; 649 if (process == anElement->GetProcess() ) 649 if (process == anElement->GetProcess() ) 650 { 650 { 651 if (particle != nullptr) 651 if (particle != nullptr) 652 { 652 { 653 for (idx=0; idx<anElement->Length(); + 653 for (idx=0; idx<anElement->Length(); ++idx) 654 { 654 { 655 manager = anElement->GetProcessManag 655 manager = anElement->GetProcessManager(idx); 656 if (particle == manager->GetParticle 656 if (particle == manager->GetParticleType()) 657 { 657 { 658 isFoundInTbl = true; 658 isFoundInTbl = true; 659 break; 659 break; 660 } 660 } 661 } 661 } 662 } 662 } 663 else 663 else 664 { 664 { 665 isFoundInTbl = true; 665 isFoundInTbl = true; 666 } 666 } 667 break; 667 break; 668 } 668 } 669 } 669 } 670 if (!isFoundInTbl ) return; 670 if (!isFoundInTbl ) return; 671 671 672 G4int tmpVerbose = process->GetVerboseLevel( 672 G4int tmpVerbose = process->GetVerboseLevel(); 673 process->SetVerboseLevel(verboseLevel); 673 process->SetVerboseLevel(verboseLevel); 674 process->DumpInfo(); 674 process->DumpInfo(); 675 process->SetVerboseLevel(tmpVerbose); 675 process->SetVerboseLevel(tmpVerbose); 676 if (particle == nullptr) 676 if (particle == nullptr) 677 { 677 { 678 for (idx=0; idx<anElement->Length(); ++idx 678 for (idx=0; idx<anElement->Length(); ++idx) 679 { 679 { 680 manager = anElement->GetProcessManager(i 680 manager = anElement->GetProcessManager(idx); 681 G4cout << " for " << manager->GetParticl 681 G4cout << " for " << manager->GetParticleType()->GetParticleName(); 682 G4cout << G4endl; 682 G4cout << G4endl; 683 #ifdef G4VERBOSE 683 #ifdef G4VERBOSE 684 if (verboseLevel >2) 684 if (verboseLevel >2) 685 { 685 { 686 tmpVerbose = manager->GetVerboseLevel( 686 tmpVerbose = manager->GetVerboseLevel(); 687 manager->SetVerboseLevel(verboseLevel) 687 manager->SetVerboseLevel(verboseLevel); 688 manager->DumpInfo(); 688 manager->DumpInfo(); 689 manager->SetVerboseLevel(tmpVerbose); 689 manager->SetVerboseLevel(tmpVerbose); 690 } 690 } 691 #endif 691 #endif 692 } 692 } 693 } 693 } 694 else 694 else 695 { 695 { 696 G4cout << " for " << manager->GetParticleT 696 G4cout << " for " << manager->GetParticleType()->GetParticleName(); 697 G4cout << G4endl; 697 G4cout << G4endl; 698 #ifdef G4VERBOSE 698 #ifdef G4VERBOSE 699 if (verboseLevel >2) 699 if (verboseLevel >2) 700 { 700 { 701 tmpVerbose = manager->GetVerboseLevel(); 701 tmpVerbose = manager->GetVerboseLevel(); 702 manager->SetVerboseLevel(verboseLevel); 702 manager->SetVerboseLevel(verboseLevel); 703 manager->DumpInfo(); 703 manager->DumpInfo(); 704 manager->SetVerboseLevel(tmpVerbose); 704 manager->SetVerboseLevel(tmpVerbose); 705 } 705 } 706 #endif 706 #endif 707 } 707 } 708 } 708 } 709 709