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