Geant4  10.03.p03
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
G4ProcessTable Class Reference

#include <G4ProcessTable.hh>

Public Types

typedef std::vector
< G4ProcTblElement * > 
G4ProcTableVector
 
typedef std::vector< G4StringG4ProcNameVector
 

Public Member Functions

 G4ProcessTable ()
 
 ~G4ProcessTable ()
 
G4int Length () const
 
G4int Insert (G4VProcess *aProcess, G4ProcessManager *aProcMgr)
 
G4int Remove (G4VProcess *aProcess, G4ProcessManager *aProcMgr)
 
G4VProcessFindProcess (const G4String &processName, const G4String &particleName) const
 
G4VProcessFindProcess (const G4String &processName, const G4ParticleDefinition *particle) const
 
G4VProcessFindProcess (const G4String &processName, const G4ProcessManager *processManager) const
 
G4ProcessVectorFindProcesses ()
 
G4ProcessVectorFindProcesses (const G4ProcessManager *processManager)
 
G4ProcessVectorFindProcesses (const G4String &processName)
 
G4ProcessVectorFindProcesses (G4ProcessType processType)
 
void SetProcessActivation (const G4String &processName, G4bool fActive)
 
void SetProcessActivation (const G4String &processName, const G4String &particleName, G4bool fActive)
 
void SetProcessActivation (const G4String &processName, G4ParticleDefinition *particle, G4bool fActive)
 
void SetProcessActivation (const G4String &processName, G4ProcessManager *processManager, G4bool fActive)
 
void SetProcessActivation (G4ProcessType processType, G4bool fActive)
 
void SetProcessActivation (G4ProcessType processType, const G4String &particleName, G4bool fActive)
 
void SetProcessActivation (G4ProcessType processType, G4ParticleDefinition *particle, G4bool fActive)
 
void SetProcessActivation (G4ProcessType processType, G4ProcessManager *processManager, G4bool fActive)
 
G4ProcNameVectorGetNameList ()
 
G4ProcTableVectorGetProcTableVector ()
 
void DumpInfo (G4VProcess *process, G4ParticleDefinition *particle=0)
 
G4UImessengerCreateMessenger ()
 
void DeleteMessenger ()
 
void SetVerboseLevel (G4int value)
 
G4int GetVerboseLevel () const
 

Static Public Member Functions

static G4ProcessTableGetProcessTable ()
 

Detailed Description

Definition at line 59 of file G4ProcessTable.hh.

Member Typedef Documentation

Definition at line 133 of file G4ProcessTable.hh.

Definition at line 132 of file G4ProcessTable.hh.

Constructor & Destructor Documentation

G4ProcessTable::G4ProcessTable ( )

Definition at line 44 of file G4ProcessTable.cc.

44  :verboseLevel(1)
45 {
46 #ifdef G4VERBOSE
47  if (verboseLevel>1){
48  G4cout << "-- G4ProcessTable constructor --" << G4endl;
49  }
50 #endif
51  fProcTblVector = new G4ProcTableVector();
52  fProcNameVector = new G4ProcNameVector();
53  tmpTblVector = new G4ProcTableVector();
54  fProcTblMessenger = 0;
55 }
G4GLOB_DLL std::ostream G4cout
std::vector< G4String > G4ProcNameVector
std::vector< G4ProcTblElement * > G4ProcTableVector
#define G4endl
Definition: G4ios.hh:61

Here is the caller graph for this function:

G4ProcessTable::~G4ProcessTable ( )

Definition at line 73 of file G4ProcessTable.cc.

74 {
75 #ifdef G4VERBOSE
76  if (verboseLevel>1){
77  G4cout << "-- G4ProcessTable destructor --" << G4endl;
78  }
79 #endif
80 
81  if ( tmpTblVector != 0) {
82  tmpTblVector ->clear();
83  delete tmpTblVector;
84  }
85 
86  if ( fProcTblVector != 0) {
87  G4ProcTableVector::iterator idx;
88 
89  // destruction of processes has moved to G4VUserPhysicsList
90  for (idx=fProcTblVector->begin(); idx!=fProcTblVector->end(); ++idx) {
91  // delete all processes
92  // delete (*idx)->GetProcess();
93  delete (*idx);
94  }
95  fProcTblVector ->clear();
96  delete fProcTblVector;
97  }
98 
99  if ( fProcNameVector != 0) {
100  fProcNameVector ->clear();
101  delete fProcNameVector;
102  }
103  fProcessTable =0;
104 }
G4GLOB_DLL std::ostream G4cout
#define G4endl
Definition: G4ios.hh:61

Member Function Documentation

G4UImessenger * G4ProcessTable::CreateMessenger ( )

Definition at line 107 of file G4ProcessTable.cc.

108 {
109  if (fProcTblMessenger == 0) {
110  fProcTblMessenger = new G4ProcessTableMessenger(this);
111  }
112  return fProcTblMessenger;
113 }

Here is the caller graph for this function:

void G4ProcessTable::DeleteMessenger ( )

Definition at line 116 of file G4ProcessTable.cc.

117 {
118  if (fProcTblMessenger != 0) {
119  delete fProcTblMessenger;
120  }
121 }

Here is the caller graph for this function:

void G4ProcessTable::DumpInfo ( G4VProcess process,
G4ParticleDefinition particle = 0 
)

Definition at line 570 of file G4ProcessTable.cc.

572 {
573  G4ProcTableVector::iterator itr;
574  G4int idxTbl=0;
575  G4ProcTblElement* anElement=0;
576  G4bool isFoundInTbl = false;
577  G4ProcessManager* manager=0;
578  G4int idx;
579  // loop over all elements
580  for (itr=fProcTblVector->begin(); itr!=fProcTblVector->end(); ++itr, ++idxTbl) {
581  anElement = (*itr);
582  if (process == anElement->GetProcess() ){
583  if (particle!=0) {
584  for (idx=0; idx<anElement->Length(); idx++){
585  manager = anElement->GetProcessManager(idx);
586  if (particle == manager->GetParticleType()) {
587  isFoundInTbl = true;
588  break;
589  }
590  }
591  } else {
592  isFoundInTbl = true;
593  }
594  break;
595  }
596  }
597  if (!isFoundInTbl ) return;
598 
599  G4int tmpVerbose = process->GetVerboseLevel();
600  process->SetVerboseLevel(verboseLevel);
601  process->DumpInfo();
602  process->SetVerboseLevel(tmpVerbose);
603  if (particle==0) {
604  for (idx=0; idx<anElement->Length(); idx++){
605  manager = anElement->GetProcessManager(idx);
606  G4cout << " for " << manager->GetParticleType()->GetParticleName();
607  G4cout << G4endl;
608 #ifdef G4VERBOSE
609  if (verboseLevel >2){
610  tmpVerbose = manager->GetVerboseLevel();
611  manager->SetVerboseLevel(verboseLevel);
612  manager->DumpInfo();
613  manager->SetVerboseLevel(tmpVerbose);
614  }
615 #endif
616  }
617  } else {
618  G4cout << " for " << manager->GetParticleType()->GetParticleName();
619  G4cout << G4endl;
620 #ifdef G4VERBOSE
621  if (verboseLevel >2){
622  tmpVerbose = manager->GetVerboseLevel();
623  manager->SetVerboseLevel(verboseLevel);
624  manager->DumpInfo();
625  manager->SetVerboseLevel(tmpVerbose);
626  }
627 #endif
628  }
629 }
void SetVerboseLevel(G4int value)
G4ProcessManager * GetProcessManager(G4int index) const
G4int GetVerboseLevel() const
int G4int
Definition: G4Types.hh:78
const G4String & GetParticleName() const
G4int Length() const
G4int GetVerboseLevel() const
Definition: G4VProcess.hh:442
G4GLOB_DLL std::ostream G4cout
bool G4bool
Definition: G4Types.hh:79
G4ParticleDefinition * GetParticleType() const
G4VProcess * GetProcess() const
#define G4endl
Definition: G4ios.hh:61
virtual void DumpInfo() const
Definition: G4VProcess.cc:178
void SetVerboseLevel(G4int value)
Definition: G4VProcess.hh:437

Here is the call graph for this function:

Here is the caller graph for this function:

G4VProcess* G4ProcessTable::FindProcess ( const G4String processName,
const G4String particleName 
) const

Here is the caller graph for this function:

G4VProcess* G4ProcessTable::FindProcess ( const G4String processName,
const G4ParticleDefinition particle 
) const
G4VProcess * G4ProcessTable::FindProcess ( const G4String processName,
const G4ProcessManager processManager 
) const

Definition at line 315 of file G4ProcessTable.cc.

318 {
319  G4ProcTableVector::iterator itr;
320  G4int idxTbl = 0;
321  G4bool isFound = false;
322  G4ProcTblElement* anElement=0;
323  for (itr=fProcTblVector->begin(); itr!=fProcTblVector->end(); ++itr, ++idxTbl) {
324  anElement = (*itr);
325  // check name
326  if ( anElement->GetProcessName() == processName ) {
327  // check if the processManage is included
328  if ( anElement->Contains(processManager) ) {
329  isFound = true;
330  break;
331  }
332  }
333  }
334 #ifdef G4VERBOSE
335  if (!isFound && verboseLevel>1){
336  G4cout << " G4ProcessTable::FindProcess :" ;
337  G4cout << " The Process[" << processName << "] is not found ";
338  G4cout << " for " << processManager->GetParticleType()->GetParticleName() << G4endl;
339  }
340 #endif
341 
342  if (isFound) return anElement->GetProcess();
343  else return 0;
344 }
int G4int
Definition: G4Types.hh:78
const G4String & GetParticleName() const
G4GLOB_DLL std::ostream G4cout
G4bool Contains(const G4ProcessManager *pManager) const
bool G4bool
Definition: G4Types.hh:79
const G4String & GetProcessName() const
G4ParticleDefinition * GetParticleType() const
G4VProcess * GetProcess() const
#define G4endl
Definition: G4ios.hh:61

Here is the call graph for this function:

G4ProcessVector * G4ProcessTable::FindProcesses ( )

Definition at line 419 of file G4ProcessTable.cc.

420 {
421  return ExtractProcesses(fProcTblVector);
422 }

Here is the caller graph for this function:

G4ProcessVector * G4ProcessTable::FindProcesses ( const G4ProcessManager processManager)

Definition at line 425 of file G4ProcessTable.cc.

426 {
427  G4ProcessVector* procList = pManager->GetProcessList();
428  return new G4ProcessVector(*procList);
429 }

Here is the call graph for this function:

G4ProcessVector * G4ProcessTable::FindProcesses ( const G4String processName)

Definition at line 432 of file G4ProcessTable.cc.

433 {
434  G4ProcTableVector* pTblVector = Find(fProcTblVector, processName);
435  return ExtractProcesses(pTblVector);
436 }
std::vector< G4ProcTblElement * > G4ProcTableVector
G4ProcessVector * G4ProcessTable::FindProcesses ( G4ProcessType  processType)

Definition at line 439 of file G4ProcessTable.cc.

440 {
441  G4ProcTableVector* pTblVector = Find(fProcTblVector, processType);
442  return ExtractProcesses(pTblVector);
443 }
std::vector< G4ProcTblElement * > G4ProcTableVector
G4ProcNameVector* G4ProcessTable::GetNameList ( )

Here is the caller graph for this function:

G4ProcessTable * G4ProcessTable::GetProcessTable ( )
static

Definition at line 152 of file G4ProcessTable.cc.

153 {
154  static G4ThreadLocal G4ProcessTable *theProcessTable_G4MT_TLS_ = 0 ; if (!theProcessTable_G4MT_TLS_) theProcessTable_G4MT_TLS_ = new G4ProcessTable ; G4ProcessTable &theProcessTable = *theProcessTable_G4MT_TLS_;
155  if (!fProcessTable){
156  fProcessTable = &theProcessTable;
157  }
158  return fProcessTable;
159 }
#define G4ThreadLocal
Definition: tls.hh:89

Here is the call graph for this function:

Here is the caller graph for this function:

G4ProcTableVector* G4ProcessTable::GetProcTableVector ( )
G4int G4ProcessTable::GetVerboseLevel ( ) const

Here is the caller graph for this function:

G4int G4ProcessTable::Insert ( G4VProcess aProcess,
G4ProcessManager aProcMgr 
)

Definition at line 162 of file G4ProcessTable.cc.

164 {
165  if ( (aProcess == 0) || ( aProcMgr == 0 ) ){
166 #ifdef G4VERBOSE
167  if (verboseLevel>0){
168  G4cout << "G4ProcessTable::Insert : arguments are 0 pointer "
169  <<aProcess <<","<< aProcMgr << G4endl;
170  }
171 #endif
172  return -1;
173  }
174 
175 #ifdef G4VERBOSE
176  if (verboseLevel>1){
177  G4cout << "G4ProcessTable::Insert ";
178  G4cout << " Process[" << aProcess->GetProcessName() << "]";
179  G4cout << " Particle[" << aProcMgr->GetParticleType()->GetParticleName() << "]";
180  G4cout << G4endl;
181  }
182 #endif
183 
184  G4ProcTableVector::iterator itr;
185  G4int idxTbl=0;
186  G4ProcTblElement* anElement;
187  G4bool isFoundInTbl = false;
188  // loop over all elements
189  for (itr=fProcTblVector->begin(); itr!=fProcTblVector->end(); ++itr, ++idxTbl) {
190  anElement = (*itr);
191  // check if this process is included
192  if (aProcess == anElement->GetProcess()) {
193  isFoundInTbl = true;
194 
195  // add the process manager into the element
196  // unless this process manager is included
197  if (!anElement->Contains(aProcMgr)) {
198  anElement->Insert(aProcMgr);
199 #ifdef G4VERBOSE
200  if (verboseLevel>2){
201  G4cout << " This Process Manager is registered !! " << G4endl;
202  }
203 #endif
204  }
205  break;
206  }
207  }
208  // add this process into the table by creating a new element
209  if (!isFoundInTbl) {
210  G4ProcTblElement* newElement = new G4ProcTblElement(aProcess);
211  newElement->Insert(aProcMgr);
212  fProcTblVector->push_back(newElement);
213  // add into name vector
214  G4ProcNameVector::iterator ip;
215  G4bool isFound = false;
216  for (ip=fProcNameVector->begin(); ip!=fProcNameVector->end(); ++ip) {
217  isFound |= (aProcess->GetProcessName() == (*ip));
218  }
219  if (!isFound) {
220  fProcNameVector->push_back(aProcess->GetProcessName() );
221 #ifdef G4VERBOSE
222  if (verboseLevel>2){
223  G4cout << " This Process is registered !! " << G4endl;
224  }
225 #endif
226  }
227  }
228  return idxTbl;
229 }
int G4int
Definition: G4Types.hh:78
const G4String & GetParticleName() const
G4GLOB_DLL std::ostream G4cout
G4bool Contains(const G4ProcessManager *pManager) const
bool G4bool
Definition: G4Types.hh:79
void Insert(G4ProcessManager *aProcMgr)
G4ParticleDefinition * GetParticleType() const
const G4String & GetProcessName() const
Definition: G4VProcess.hh:408
G4VProcess * GetProcess() const
#define G4endl
Definition: G4ios.hh:61

Here is the call graph for this function:

Here is the caller graph for this function:

G4int G4ProcessTable::Length ( ) const

Here is the caller graph for this function:

G4int G4ProcessTable::Remove ( G4VProcess aProcess,
G4ProcessManager aProcMgr 
)

Definition at line 232 of file G4ProcessTable.cc.

234 {
235  if ( (aProcess == 0) || ( aProcMgr == 0 ) ){
236 #ifdef G4VERBOSE
237  if (verboseLevel>0){
238  G4cout << "G4ProcessTable::Remove : arguments are 0 pointer "<< G4endl;
239  }
240 #endif
241  return -1;
242  }
243 
244 #ifdef G4VERBOSE
245  if (verboseLevel>1){
246  G4cout << "G4ProcessTable::Remove ";
247  G4cout << " Process[" << aProcess->GetProcessName() << "]";
248  G4cout << " Particle[" << aProcMgr->GetParticleType()->GetParticleName() << "]" << G4endl;
249  }
250 #endif
251 
252  G4ProcTableVector::iterator itr;
253  G4int idxTbl=0;
254  G4ProcTblElement* anElement=0;
255  G4bool isFound = false;
256  // loop over all elements
257  for (itr=fProcTblVector->begin(); itr!=fProcTblVector->end(); ++itr, ++idxTbl) {
258  anElement = (*itr);
259 
260  // check if this process is included
261  if (aProcess == anElement->GetProcess()) {
262  isFound = anElement->Contains(aProcMgr);
263  // remove the process manager from the element
264  anElement->Remove(aProcMgr);
265 #ifdef G4VERBOSE
266  if (verboseLevel>2){
267  G4cout << " This Process Manager is removed !! " << G4endl;
268  }
269 #endif
270  break;
271  }
272  }
273  //
274  if (!isFound) {
275 #ifdef G4VERBOSE
276  if (verboseLevel>0){
277  G4cout << " This Process Manager is not registered !! " << G4endl;
278  }
279 #endif
280  return -1;
281  }
282  // remove the element if it has no entry
283  if (anElement->Length() == 0){
284  fProcTblVector->erase(itr);
285  delete anElement;
286  // check other prcesses with same name exist or not
287  G4bool isSameName = false;
288  for (itr=fProcTblVector->begin(); itr!=fProcTblVector->end(); ++itr) {
289  anElement = (*itr);
290  if (anElement->GetProcessName() == aProcess->GetProcessName()) {
291  isSameName = true;
292  break;
293  }
294  }
295  // remove from name vector
296  if (!isSameName ) {
297  G4ProcNameVector::iterator i;
298  for (i=fProcNameVector->begin(); i!=fProcNameVector->end(); ++i) {
299  if ( *i == aProcess->GetProcessName() ) {
300  fProcNameVector->erase(i);
301  break;
302  }
303  }
304  }
305 #ifdef G4VERBOSE
306  if (verboseLevel>1){
307  G4cout << " This Process is removed !! " << G4endl;
308  }
309 #endif
310  }
311  return idxTbl;
312 }
int G4int
Definition: G4Types.hh:78
const G4String & GetParticleName() const
G4int Length() const
G4GLOB_DLL std::ostream G4cout
G4bool Contains(const G4ProcessManager *pManager) const
bool G4bool
Definition: G4Types.hh:79
const G4String & GetProcessName() const
G4ParticleDefinition * GetParticleType() const
const G4String & GetProcessName() const
Definition: G4VProcess.hh:408
void Remove(G4ProcessManager *aProcMgr)
G4VProcess * GetProcess() const
#define G4endl
Definition: G4ios.hh:61

Here is the call graph for this function:

Here is the caller graph for this function:

void G4ProcessTable::SetProcessActivation ( const G4String processName,
G4bool  fActive 
)

Definition at line 446 of file G4ProcessTable.cc.

448 {
449 #ifdef G4VERBOSE
450  if (verboseLevel>1){
451  G4cout << " G4ProcessTable::SetProcessActivation:" ;
452  G4cout << " The Process[" << processName << "] "<< G4endl;
453  }
454 #endif
455 
456  G4ProcTableVector* pTblVector = Find(fProcTblVector, processName);
457  G4ProcTableVector::iterator itr;
458  G4ProcTblElement* anElement;
459  // loop over all elements
460  for (itr=pTblVector->begin(); itr!=pTblVector->end(); ++itr) {
461  anElement = (*itr);
462  G4VProcess* process = anElement->GetProcess();
463  for (G4int idx = 0 ; idx < anElement->Length(); idx++) {
464  G4ProcessManager* manager = anElement->GetProcessManager(idx);
465  manager->SetProcessActivation(process, fActive);
466 #ifdef G4VERBOSE
467  if (verboseLevel>1){
468  G4cout << " for " << manager->GetParticleType()->GetParticleName();
469  G4cout << " Index = " << manager->GetProcessIndex(process);
470  G4cout << G4endl;
471  }
472 #endif
473  }
474  }
475 }
G4ProcessManager * GetProcessManager(G4int index) const
int G4int
Definition: G4Types.hh:78
const G4String & GetParticleName() const
G4int Length() const
G4VProcess * SetProcessActivation(G4VProcess *aProcess, G4bool fActive)
G4GLOB_DLL std::ostream G4cout
G4ParticleDefinition * GetParticleType() const
G4VProcess * GetProcess() const
std::vector< G4ProcTblElement * > G4ProcTableVector
G4int GetProcessIndex(G4VProcess *) const
#define G4endl
Definition: G4ios.hh:61

Here is the call graph for this function:

Here is the caller graph for this function:

void G4ProcessTable::SetProcessActivation ( const G4String processName,
const G4String particleName,
G4bool  fActive 
)
void G4ProcessTable::SetProcessActivation ( const G4String processName,
G4ParticleDefinition particle,
G4bool  fActive 
)
void G4ProcessTable::SetProcessActivation ( const G4String processName,
G4ProcessManager processManager,
G4bool  fActive 
)

Definition at line 478 of file G4ProcessTable.cc.

482 {
483 #ifdef G4VERBOSE
484  if (verboseLevel>1){
485  G4cout << " G4ProcessTable::SetProcessActivation:" ;
486  G4cout << " The Process[" << processName << "] "<< G4endl;
487  }
488 #endif
489 
490  G4VProcess* process = FindProcess( processName, processManager);
491  if ( process != 0) {
492  processManager->SetProcessActivation(process, fActive);
493 #ifdef G4VERBOSE
494  if (verboseLevel>1){
495  G4cout << " for " << processManager->GetParticleType()->GetParticleName();
496  G4cout << " Index = " << processManager->GetProcessIndex(process) << G4endl;
497  }
498 #endif
499  }
500 }
const G4String & GetParticleName() const
G4VProcess * SetProcessActivation(G4VProcess *aProcess, G4bool fActive)
G4GLOB_DLL std::ostream G4cout
G4ParticleDefinition * GetParticleType() const
G4int GetProcessIndex(G4VProcess *) const
#define G4endl
Definition: G4ios.hh:61
G4VProcess * FindProcess(const G4String &processName, const G4String &particleName) const

Here is the call graph for this function:

void G4ProcessTable::SetProcessActivation ( G4ProcessType  processType,
G4bool  fActive 
)

Definition at line 504 of file G4ProcessTable.cc.

506 {
507 #ifdef G4VERBOSE
508  if (verboseLevel>1){
509  G4cout << " G4ProcessTable::SetProcessActivation:" ;
510  G4cout << " The ProcessType[" << G4int(processType) << "] "<< G4endl;
511  }
512 #endif
513 
514  G4ProcTableVector* pTblVector = Find(fProcTblVector, processType);
515  G4ProcTableVector::iterator itr;
516  G4ProcTblElement* anElement;
517  // loop over all elements
518  for (itr=pTblVector->begin(); itr!=pTblVector->end(); ++itr) {
519  anElement = (*itr);
520  G4VProcess* process = anElement->GetProcess();
521 #ifdef G4VERBOSE
522  if (verboseLevel>1){
523  G4cout << " The Process[" << process->GetProcessName()<< "] "<< G4endl;
524  }
525 #endif
526  for (G4int idx = 0 ; idx < anElement->Length(); idx++) {
527  G4ProcessManager* manager = anElement->GetProcessManager(idx);
528  manager->SetProcessActivation(process, fActive);
529 #ifdef G4VERBOSE
530  if (verboseLevel>1){
531  G4cout << " for " << manager->GetParticleType()->GetParticleName();
532  G4cout << " Index = " << manager->GetProcessIndex(process) << G4endl;
533  }
534 #endif
535  }
536  }
537 }
G4ProcessManager * GetProcessManager(G4int index) const
int G4int
Definition: G4Types.hh:78
const G4String & GetParticleName() const
G4int Length() const
G4VProcess * SetProcessActivation(G4VProcess *aProcess, G4bool fActive)
G4GLOB_DLL std::ostream G4cout
G4ParticleDefinition * GetParticleType() const
const G4String & GetProcessName() const
Definition: G4VProcess.hh:408
G4VProcess * GetProcess() const
std::vector< G4ProcTblElement * > G4ProcTableVector
G4int GetProcessIndex(G4VProcess *) const
#define G4endl
Definition: G4ios.hh:61

Here is the call graph for this function:

void G4ProcessTable::SetProcessActivation ( G4ProcessType  processType,
const G4String particleName,
G4bool  fActive 
)
void G4ProcessTable::SetProcessActivation ( G4ProcessType  processType,
G4ParticleDefinition particle,
G4bool  fActive 
)
void G4ProcessTable::SetProcessActivation ( G4ProcessType  processType,
G4ProcessManager processManager,
G4bool  fActive 
)

Definition at line 540 of file G4ProcessTable.cc.

544 {
545 #ifdef G4VERBOSE
546  if (verboseLevel>1){
547  G4cout << " G4ProcessTable::SetProcessActivation:" ;
548  G4cout << " The ProcessType[" << G4int(processType) << "] "<< G4endl;
549  }
550 #endif
551 
552  G4ProcessVector* procList = processManager->GetProcessList();
553  for (G4int idx = 0; idx < procList->length(); idx++) {
554  G4VProcess* process = (*procList)(idx);
555  if ( process->GetProcessType() == processType) {
556  processManager->SetProcessActivation(process, fActive);
557 #ifdef G4VERBOSE
558  if (verboseLevel>1){
559  G4cout << " The Process[" << process->GetProcessName()<< "] "<< G4endl;
560  G4cout << " for " << processManager->GetParticleType()->GetParticleName();
561  G4cout << " Index = " << idx << G4endl;
562  }
563 #endif
564  }
565  }
566 }
G4ProcessType GetProcessType() const
Definition: G4VProcess.hh:414
int G4int
Definition: G4Types.hh:78
const G4String & GetParticleName() const
G4VProcess * SetProcessActivation(G4VProcess *aProcess, G4bool fActive)
G4GLOB_DLL std::ostream G4cout
G4int length() const
G4ParticleDefinition * GetParticleType() const
const G4String & GetProcessName() const
Definition: G4VProcess.hh:408
#define G4endl
Definition: G4ios.hh:61
G4ProcessVector * GetProcessList() const

Here is the call graph for this function:

void G4ProcessTable::SetVerboseLevel ( G4int  value)

Here is the caller graph for this function:


The documentation for this class was generated from the following files: