G4ProcessTable Class Reference

#include <G4ProcessTable.hh>


Public Types

typedef std::vector< G4ProcTblElement * > G4ProcTableVector
typedef std::vector< G4String > G4ProcNameVector

Public Member Functions

 G4ProcessTable ()
 ~G4ProcessTable ()
G4int Length () const
G4int Insert (G4VProcess *aProcess, G4ProcessManager *aProcMgr)
G4int Remove (G4VProcess *aProcess, G4ProcessManager *aProcMgr)
G4VProcess * FindProcess (const G4String &processName, const G4String &particleName) const
G4VProcess * FindProcess (const G4String &processName, const G4ParticleDefinition *particle) const
G4VProcess * FindProcess (const G4String &processName, const G4ProcessManager *processManager) const
G4ProcessVector * FindProcesses ()
G4ProcessVector * FindProcesses (const G4ProcessManager *processManager)
G4ProcessVector * FindProcesses (const G4String &processName)
G4ProcessVector * FindProcesses (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)
G4ProcNameVector * GetNameList ()
G4ProcTableVector * GetProcTableVector ()
void DumpInfo (G4VProcess *process, G4ParticleDefinition *particle=0)
G4UImessenger * CreateMessenger ()
void DeleteMessenger ()
void SetVerboseLevel (G4int value)
G4int GetVerboseLevel () const

Static Public Member Functions

static G4ProcessTable * GetProcessTable ()

Detailed Description

Definition at line 59 of file G4ProcessTable.hh.

Member Typedef Documentation

typedef std::vector<G4String> G4ProcessTable::G4ProcNameVector

Definition at line 133 of file G4ProcessTable.hh.

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

Definition at line 132 of file G4ProcessTable.hh.

Constructor & Destructor Documentation

G4ProcessTable::G4ProcessTable (  ) 

Definition at line 44 of file G4ProcessTable.cc.

References G4cout, and G4endl.

00044                               :verboseLevel(1)
00045 {
00046 #ifdef G4VERBOSE
00047   if (verboseLevel>1){
00048     G4cout << "--  G4ProcessTable constructor  --" << G4endl;
00049   }
00050 #endif
00051   fProcTblVector  = new  G4ProcTableVector();
00052   fProcNameVector = new  G4ProcNameVector();
00053   tmpTblVector    = new  G4ProcTableVector();
00054   fProcTblMessenger = 0;
00055 }

G4ProcessTable::~G4ProcessTable (  ) 

Definition at line 73 of file G4ProcessTable.cc.

References G4cout, and G4endl.

00074 {
00075 #ifdef G4VERBOSE
00076   if (verboseLevel>1){
00077     G4cout << "--  G4ProcessTable destructor  --" << G4endl;
00078   }
00079 #endif
00080 
00081   if ( tmpTblVector != 0) {
00082     tmpTblVector ->clear();
00083     delete tmpTblVector;
00084   }
00085 
00086   if ( fProcTblVector != 0) {
00087     G4ProcTableVector::iterator idx;
00088     
00089     // destruction of processes has moved to G4VUserPhysicsList
00090     for (idx=fProcTblVector->begin(); idx!=fProcTblVector->end(); ++idx) {
00091       // delete all processes
00092       // delete (*idx)->GetProcess();
00093       delete (*idx);
00094     }  
00095     fProcTblVector ->clear();
00096     delete fProcTblVector;
00097   }
00098 
00099   if ( fProcNameVector != 0) {
00100     fProcNameVector ->clear();
00101     delete fProcNameVector;
00102   }
00103   fProcessTable =0;
00104 }

Member Function Documentation

G4UImessenger * G4ProcessTable::CreateMessenger (  ) 

Definition at line 107 of file G4ProcessTable.cc.

Referenced by G4RunManager::G4RunManager().

00108 {
00109   if (fProcTblMessenger == 0) {
00110     fProcTblMessenger = new G4ProcessTableMessenger(this);
00111   }
00112   return     fProcTblMessenger;
00113 }

void G4ProcessTable::DeleteMessenger (  ) 

Definition at line 116 of file G4ProcessTable.cc.

Referenced by G4RunManager::~G4RunManager().

00117 {
00118   if (fProcTblMessenger != 0) {
00119     delete fProcTblMessenger;
00120   }
00121 }

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

Definition at line 572 of file G4ProcessTable.cc.

References G4ProcessManager::DumpInfo(), G4VProcess::DumpInfo(), G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4ProcessManager::GetParticleType(), G4ProcTblElement::GetProcess(), G4ProcTblElement::GetProcessManager(), G4ProcessManager::GetVerboseLevel(), G4VProcess::GetVerboseLevel(), G4ProcTblElement::Length(), G4ProcessManager::SetVerboseLevel(), and G4VProcess::SetVerboseLevel().

Referenced by G4ProcessTableMessenger::SetNewValue().

00574 {
00575   G4ProcTableVector::iterator itr; 
00576   G4int idxTbl=0;
00577   G4ProcTblElement* anElement=0;
00578   G4bool isFoundInTbl = false;
00579   G4ProcessManager* manager=0;
00580   G4int idx;
00581   // loop over all elements
00582   for (itr=fProcTblVector->begin(); itr!=fProcTblVector->end(); ++itr, ++idxTbl) {
00583     anElement = (*itr);
00584     if (process == anElement->GetProcess() ){
00585       if (particle!=0) {
00586         for (idx=0; idx<anElement->Length(); idx++){
00587           manager = anElement->GetProcessManager(idx);
00588           if (particle == manager->GetParticleType()) {
00589             isFoundInTbl = true;
00590             break;
00591           }
00592         }
00593       } else {
00594         isFoundInTbl = true;
00595       }
00596       break;
00597     }
00598   }
00599   if  (!isFoundInTbl ) return;
00600   
00601   G4int tmpVerbose = process->GetVerboseLevel();
00602   process->SetVerboseLevel(verboseLevel);
00603   process->DumpInfo();
00604   process->SetVerboseLevel(tmpVerbose);
00605   if (particle==0) {
00606     for (idx=0; idx<anElement->Length(); idx++){
00607       manager = anElement->GetProcessManager(idx);
00608       G4cout << " for " << manager->GetParticleType()->GetParticleName();
00609       G4cout << G4endl;
00610 #ifdef G4VERBOSE
00611       if (verboseLevel >2){
00612         tmpVerbose = manager->GetVerboseLevel();
00613         manager->SetVerboseLevel(verboseLevel);
00614         manager->DumpInfo();
00615         manager->SetVerboseLevel(tmpVerbose);
00616       }
00617 #endif
00618     }
00619   } else {
00620     G4cout << " for " << manager->GetParticleType()->GetParticleName();
00621     G4cout << G4endl;
00622 #ifdef G4VERBOSE
00623     if (verboseLevel >2){
00624       tmpVerbose = manager->GetVerboseLevel();
00625       manager->SetVerboseLevel(verboseLevel);
00626       manager->DumpInfo();
00627       manager->SetVerboseLevel(tmpVerbose);
00628     }
00629 #endif
00630   }
00631 }

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

Definition at line 317 of file G4ProcessTable.cc.

References G4ProcTblElement::Contains(), G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4ProcessManager::GetParticleType(), G4ProcTblElement::GetProcess(), and G4ProcTblElement::GetProcessName().

00320 {
00321   G4ProcTableVector::iterator itr;   
00322   G4int idxTbl = 0;
00323   G4bool isFound = false;
00324   G4ProcTblElement* anElement=0;
00325   for (itr=fProcTblVector->begin(); itr!=fProcTblVector->end(); ++itr, ++idxTbl) {
00326     anElement = (*itr);
00327     // check name
00328     if ( anElement->GetProcessName() == processName ) {
00329       // check if the processManage is included
00330       if ( anElement->Contains(processManager) ) {
00331         isFound = true;
00332         break;
00333       }
00334     }
00335   }
00336 #ifdef G4VERBOSE
00337   if (!isFound && verboseLevel>1){
00338     G4cout << " G4ProcessTable::FindProcess :" ;
00339     G4cout << " The Process[" << processName << "] is not found  ";
00340     G4cout << " for " << processManager->GetParticleType()->GetParticleName() << G4endl;
00341   }
00342 #endif
00343   
00344   if (isFound) return anElement->GetProcess();
00345   else         return 0;
00346 }

G4VProcess * G4ProcessTable::FindProcess ( const G4String &  processName,
const G4ParticleDefinition *  particle 
) const [inline]

Definition at line 72 of file G4ProcessTable.icc.

References FindProcess(), and G4ParticleDefinition::GetProcessManager().

00075 {
00076   if ( particle == 0 ) return 0; 
00077   else return FindProcess(processName, particle->GetProcessManager());
00078 }

G4VProcess * G4ProcessTable::FindProcess ( const G4String &  processName,
const G4String &  particleName 
) const [inline]

Definition at line 82 of file G4ProcessTable.icc.

References G4ParticleTable::GetParticleTable().

Referenced by FindProcess(), and SetProcessActivation().

00084 {
00085   return FindProcess(processName,
00086           G4ParticleTable::GetParticleTable()->FindParticle(particleName));
00087 }

G4ProcessVector * G4ProcessTable::FindProcesses ( G4ProcessType  processType  ) 

Definition at line 441 of file G4ProcessTable.cc.

00442 {
00443   G4ProcTableVector* pTblVector =  Find(fProcTblVector, processType);
00444   return ExtractProcesses(pTblVector);
00445 }

G4ProcessVector * G4ProcessTable::FindProcesses ( const G4String &  processName  ) 

Definition at line 434 of file G4ProcessTable.cc.

00435 {
00436   G4ProcTableVector* pTblVector =  Find(fProcTblVector, processName);
00437   return ExtractProcesses(pTblVector);
00438 }

G4ProcessVector * G4ProcessTable::FindProcesses ( const G4ProcessManager *  processManager  ) 

Definition at line 427 of file G4ProcessTable.cc.

References G4ProcessManager::GetProcessList().

00428 {
00429   G4ProcessVector* procList = pManager->GetProcessList();
00430   return new G4ProcessVector(*procList);
00431 }

G4ProcessVector * G4ProcessTable::FindProcesses (  ) 

Definition at line 421 of file G4ProcessTable.cc.

Referenced by G4ProcessTableMessenger::SetNewValue().

00422 {
00423   return ExtractProcesses(fProcTblVector);
00424 }

G4ProcessTable::G4ProcNameVector * G4ProcessTable::GetNameList (  )  [inline]

Definition at line 57 of file G4ProcessTable.icc.

Referenced by G4ProcessTableMessenger::GetCurrentValue(), and G4ProcessTableMessenger::SetNewValue().

00058 {
00059    return  fProcNameVector;
00060 }

G4ProcessTable * G4ProcessTable::GetProcessTable (  )  [static]

Definition at line 154 of file G4ProcessTable.cc.

Referenced by G4ProcessManager::AddProcess(), G4ProcessManager::G4ProcessManager(), G4RunManager::G4RunManager(), G4ProcessManager::RemoveProcess(), and G4RunManager::~G4RunManager().

00155 {
00156     static G4ProcessTable theProcessTable;
00157     if (!fProcessTable){
00158       fProcessTable =  &theProcessTable;
00159     }
00160     return fProcessTable;
00161 }

G4ProcessTable::G4ProcTableVector * G4ProcessTable::GetProcTableVector (  )  [inline]

Definition at line 64 of file G4ProcessTable.icc.

00065 { 
00066   return fProcTblVector; 
00067 }

G4int G4ProcessTable::GetVerboseLevel (  )  const [inline]

Definition at line 43 of file G4ProcessTable.icc.

Referenced by G4ProcessTableMessenger::GetCurrentValue(), and G4ProductionCuts::SetProductionCuts().

00044 {
00045   return verboseLevel;
00046 }

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

Definition at line 164 of file G4ProcessTable.cc.

References G4ProcTblElement::Contains(), G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4ProcessManager::GetParticleType(), G4ProcTblElement::GetProcess(), G4VProcess::GetProcessName(), and G4ProcTblElement::Insert().

Referenced by G4ProcessManager::AddProcess(), and G4ProcessManager::G4ProcessManager().

00166 {
00167   if ( (aProcess == 0) || ( aProcMgr == 0 ) ){
00168 #ifdef G4VERBOSE
00169     if (verboseLevel>0){
00170       G4cout << "G4ProcessTable::Insert : arguments are 0 pointer "
00171              <<aProcess <<","<<  aProcMgr << G4endl;
00172     }
00173 #endif
00174     return -1;
00175   }
00176     
00177 #ifdef G4VERBOSE
00178   if (verboseLevel>1){
00179     G4cout << "G4ProcessTable::Insert ";
00180     G4cout << " Process["  << aProcess->GetProcessName() << "]";
00181     G4cout << " Particle["  << aProcMgr->GetParticleType()->GetParticleName() << "]";
00182     G4cout << G4endl;
00183   }
00184 #endif
00185 
00186   G4ProcTableVector::iterator itr; 
00187   G4int idxTbl=0;
00188   G4ProcTblElement* anElement;
00189   G4bool isFoundInTbl = false;
00190   // loop over all elements
00191   for (itr=fProcTblVector->begin(); itr!=fProcTblVector->end(); ++itr, ++idxTbl) {
00192     anElement = (*itr);
00193     // check if this process is included
00194     if (aProcess == anElement->GetProcess()) {
00195       isFoundInTbl = true;
00196 
00197       // add the process manager into the element 
00198       //  unless  this process manager is included
00199       if (!anElement->Contains(aProcMgr)) {
00200         anElement->Insert(aProcMgr);
00201 #ifdef G4VERBOSE
00202         if (verboseLevel>2){
00203           G4cout << " This Process Manager is registered !! " << G4endl;
00204         }
00205 #endif
00206       }
00207       break;
00208     }
00209   }
00210   // add this process into the table by creating a new element
00211   if (!isFoundInTbl) {
00212     G4ProcTblElement* newElement = new G4ProcTblElement(aProcess);
00213     newElement->Insert(aProcMgr);
00214     fProcTblVector->push_back(newElement);
00215     // add into name vector     
00216     G4ProcNameVector::iterator ip;
00217     G4bool isFound = false;
00218     for (ip=fProcNameVector->begin(); ip!=fProcNameVector->end(); ++ip) {
00219       isFound |= (aProcess->GetProcessName() == (*ip));
00220     }
00221     if (!isFound) {
00222       fProcNameVector->push_back(aProcess->GetProcessName() );
00223 #ifdef G4VERBOSE
00224       if (verboseLevel>2){
00225         G4cout << " This Process is registered !! " << G4endl;
00226       }
00227 #endif
00228     }
00229   }
00230   return idxTbl;
00231 }

G4int G4ProcessTable::Length (  )  const [inline]

Definition at line 50 of file G4ProcessTable.icc.

00051 {
00052   return fProcTblVector->size();
00053 }

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

Definition at line 234 of file G4ProcessTable.cc.

References G4ProcTblElement::Contains(), G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4ProcessManager::GetParticleType(), G4ProcTblElement::GetProcess(), G4ProcTblElement::GetProcessName(), G4VProcess::GetProcessName(), G4ProcTblElement::Length(), and G4ProcTblElement::Remove().

Referenced by G4ProcessManager::RemoveProcess().

00236 {
00237   if ( (aProcess == 0) || ( aProcMgr == 0 ) ){
00238 #ifdef G4VERBOSE
00239     if (verboseLevel>0){
00240       G4cout << "G4ProcessTable::Remove : arguments are 0 pointer "<< G4endl;
00241     }
00242 #endif
00243     return -1;
00244   }
00245     
00246 #ifdef G4VERBOSE
00247   if (verboseLevel>1){
00248     G4cout << "G4ProcessTable::Remove ";
00249     G4cout << " Process["  << aProcess->GetProcessName() << "]";
00250     G4cout << " Particle[" << aProcMgr->GetParticleType()->GetParticleName() << "]" << G4endl;
00251   }
00252 #endif
00253 
00254   G4ProcTableVector::iterator itr; 
00255   G4int idxTbl=0;
00256   G4ProcTblElement* anElement=0;
00257   G4bool isFound = false;
00258   // loop over all elements
00259   for (itr=fProcTblVector->begin(); itr!=fProcTblVector->end(); ++itr, ++idxTbl) {
00260     anElement = (*itr);
00261 
00262     // check if this process is included
00263     if (aProcess == anElement->GetProcess()) {
00264       isFound = anElement->Contains(aProcMgr);
00265       // remove the process manager from the element
00266       anElement->Remove(aProcMgr);
00267 #ifdef G4VERBOSE
00268       if (verboseLevel>2){
00269         G4cout << " This Process Manager is removed !! " << G4endl;
00270       }
00271 #endif
00272       break;
00273     }
00274   }
00275   // 
00276   if (!isFound) {
00277 #ifdef G4VERBOSE
00278     if (verboseLevel>0){
00279       G4cout << " This Process Manager is not registered !! " << G4endl;
00280     }
00281 #endif
00282     return -1;
00283   }
00284   // remove the element if it has no entry
00285   if (anElement->Length() == 0){
00286     fProcTblVector->erase(itr);
00287     delete anElement;
00288     // check other prcesses with same name exist or not
00289     G4bool isSameName = false;
00290     for (itr=fProcTblVector->begin(); itr!=fProcTblVector->end(); ++itr) {
00291       anElement = (*itr);
00292       if (anElement->GetProcessName() == aProcess->GetProcessName()) {
00293         isSameName = true;
00294         break;
00295       }
00296     }
00297     // remove from name vector
00298     if (!isSameName ) {
00299       G4ProcNameVector::iterator i; 
00300       for (i=fProcNameVector->begin(); i!=fProcNameVector->end(); ++i) {
00301         if ( *i == aProcess->GetProcessName() ) {
00302           fProcNameVector->erase(i);
00303           break;
00304         }
00305       }
00306     }
00307 #ifdef G4VERBOSE
00308     if (verboseLevel>1){
00309       G4cout << " This Process is removed !! " << G4endl;
00310     }
00311 #endif
00312   }
00313   return idxTbl;
00314 }

void G4ProcessTable::SetProcessActivation ( G4ProcessType  processType,
G4ProcessManager *  processManager,
G4bool  fActive 
)

Definition at line 542 of file G4ProcessTable.cc.

References G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4ProcessManager::GetParticleType(), G4ProcessManager::GetProcessList(), G4ProcessVector::length(), and G4ProcessManager::SetProcessActivation().

00546 {
00547 #ifdef G4VERBOSE
00548   if (verboseLevel>1){
00549     G4cout << " G4ProcessTable::SetProcessActivation:" ;
00550     G4cout << " The ProcessType[" << G4int(processType) << "] "<< G4endl;
00551   }
00552 #endif
00553   
00554   G4ProcessVector* procList =  processManager->GetProcessList();
00555   for (G4int idx = 0; idx < procList->length(); idx++) {
00556     G4VProcess* process = (*procList)(idx);
00557     if ( process->GetProcessType() == processType) {
00558       processManager->SetProcessActivation(process, fActive);
00559 #ifdef G4VERBOSE
00560       if (verboseLevel>1){
00561         G4cout << " The Process[" << process->GetProcessName()<< "] "<< G4endl;
00562         G4cout << "  for " << processManager->GetParticleType()->GetParticleName();
00563         G4cout << "  Index = " << idx << G4endl;
00564       }
00565 #endif
00566     }
00567   }
00568 }

void G4ProcessTable::SetProcessActivation ( G4ProcessType  processType,
G4ParticleDefinition *  particle,
G4bool  fActive 
) [inline]

Definition at line 120 of file G4ProcessTable.icc.

References G4ParticleDefinition::GetProcessManager(), and SetProcessActivation().

00124 {       
00125   if ( particle != 0 ) { 
00126     SetProcessActivation( processType, particle->GetProcessManager(), fActive); 
00127   }     
00128 }

void G4ProcessTable::SetProcessActivation ( G4ProcessType  processType,
const G4String &  particleName,
G4bool  fActive 
) [inline]

Definition at line 132 of file G4ProcessTable.icc.

References G4ParticleTable::GetParticleTable(), and SetProcessActivation().

00136 {
00137   if ((particleName == "ALL" )||(particleName == "all" )) {
00138     SetProcessActivation( processType, fActive ); 
00139   } else {
00140     SetProcessActivation( 
00141         processType,    
00142         G4ParticleTable::GetParticleTable()->FindParticle(particleName),
00143         fActive );
00144   }
00145 }

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

Definition at line 506 of file G4ProcessTable.cc.

References G4cout, G4endl, G4ProcTblElement::GetProcess(), G4ProcTblElement::GetProcessManager(), G4VProcess::GetProcessName(), G4ProcTblElement::Length(), and G4ProcessManager::SetProcessActivation().

00508 {
00509 #ifdef G4VERBOSE
00510   if (verboseLevel>1){
00511     G4cout << " G4ProcessTable::SetProcessActivation:" ;
00512     G4cout << " The ProcessType[" << G4int(processType) << "] "<< G4endl;
00513   }
00514 #endif
00515 
00516   G4ProcTableVector* pTblVector =  Find(fProcTblVector, processType);
00517   G4ProcTableVector::iterator itr; 
00518   G4ProcTblElement* anElement;  
00519   // loop over all elements
00520   for (itr=pTblVector->begin(); itr!=pTblVector->end(); ++itr) {
00521     anElement = (*itr);
00522     G4VProcess* process = anElement->GetProcess();
00523 #ifdef G4VERBOSE
00524     if (verboseLevel>1){
00525       G4cout << " The Process[" << process->GetProcessName()<< "] "<< G4endl;
00526     }
00527 #endif
00528     for (G4int idx = 0 ; idx < anElement->Length(); idx++) {
00529       G4ProcessManager* manager = anElement->GetProcessManager(idx);
00530       manager->SetProcessActivation(process, fActive);
00531 #ifdef G4VERBOSE
00532       if (verboseLevel>1){
00533         G4cout << "  for " << manager->GetParticleType()->GetParticleName();
00534         G4cout << "  Index = " << manager->GetProcessIndex(process) << G4endl;
00535       }
00536 #endif
00537     }
00538   }
00539 }

void G4ProcessTable::SetProcessActivation ( const G4String &  processName,
G4ProcessManager *  processManager,
G4bool  fActive 
)

Definition at line 480 of file G4ProcessTable.cc.

References FindProcess(), G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4ProcessManager::GetParticleType(), G4ProcessManager::GetProcessIndex(), and G4ProcessManager::SetProcessActivation().

00484 {
00485 #ifdef G4VERBOSE
00486   if (verboseLevel>1){
00487     G4cout << " G4ProcessTable::SetProcessActivation:" ;
00488     G4cout << " The Process[" << processName << "] "<< G4endl;
00489   }
00490 #endif
00491   
00492   G4VProcess* process = FindProcess( processName,  processManager);
00493   if ( process != 0) {
00494     processManager->SetProcessActivation(process, fActive);
00495 #ifdef G4VERBOSE
00496     if (verboseLevel>1){
00497       G4cout << "  for " << processManager->GetParticleType()->GetParticleName();
00498       G4cout << "  Index = " << processManager->GetProcessIndex(process) << G4endl;
00499     }
00500 #endif
00501   } 
00502 }

void G4ProcessTable::SetProcessActivation ( const G4String &  processName,
G4ParticleDefinition *  particle,
G4bool  fActive 
) [inline]

Definition at line 92 of file G4ProcessTable.icc.

References G4ParticleDefinition::GetProcessManager(), and SetProcessActivation().

00096 {       
00097   if ( particle != 0 ) { 
00098     SetProcessActivation(processName, particle->GetProcessManager(), fActive);  
00099   }     
00100 }

void G4ProcessTable::SetProcessActivation ( const G4String &  processName,
const G4String &  particleName,
G4bool  fActive 
) [inline]

Definition at line 103 of file G4ProcessTable.icc.

References G4ParticleTable::GetParticleTable(), and SetProcessActivation().

00107 {
00108   if (particleName == "ALL" ) {
00109     SetProcessActivation( processName , fActive); 
00110   } else {
00111     SetProcessActivation(
00112         processName, 
00113         G4ParticleTable::GetParticleTable()->FindParticle(particleName),
00114         fActive );
00115   }
00116 }

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

Definition at line 448 of file G4ProcessTable.cc.

References G4cout, G4endl, G4ProcTblElement::GetProcess(), G4ProcTblElement::GetProcessManager(), G4ProcTblElement::Length(), and G4ProcessManager::SetProcessActivation().

Referenced by G4ProcessTableMessenger::SetNewValue(), and SetProcessActivation().

00450 {
00451 #ifdef G4VERBOSE
00452   if (verboseLevel>1){
00453     G4cout << " G4ProcessTable::SetProcessActivation:" ;
00454     G4cout << " The Process[" << processName << "] "<< G4endl;
00455   }
00456 #endif
00457 
00458   G4ProcTableVector* pTblVector =  Find(fProcTblVector, processName);
00459   G4ProcTableVector::iterator itr; 
00460   G4ProcTblElement* anElement;  
00461    // loop over all elements
00462   for (itr=pTblVector->begin(); itr!=pTblVector->end(); ++itr) {
00463     anElement = (*itr);
00464     G4VProcess* process = anElement->GetProcess();
00465     for (G4int idx = 0 ; idx < anElement->Length(); idx++) {
00466       G4ProcessManager* manager = anElement->GetProcessManager(idx);
00467       manager->SetProcessActivation(process, fActive);
00468 #ifdef G4VERBOSE
00469       if (verboseLevel>1){
00470         G4cout << "  for " << manager->GetParticleType()->GetParticleName();
00471         G4cout << "  Index = " << manager->GetProcessIndex(process); 
00472         G4cout << G4endl;
00473       }
00474 #endif
00475     }
00476   }
00477 }

void G4ProcessTable::SetVerboseLevel ( G4int  value  )  [inline]

Definition at line 36 of file G4ProcessTable.icc.

Referenced by G4ProcessTableMessenger::SetNewValue().

00037 {
00038   verboseLevel = value;
00039 }

The documentation for this class was generated from the following files:
Generated on Mon May 27 17:52:59 2013 for Geant4 by  doxygen 1.4.7