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