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.

Referenced by GetProcessTable().

                              :verboseLevel(1)
{
#ifdef G4VERBOSE
  if (verboseLevel>1){
    G4cout << "--  G4ProcessTable constructor  --" << G4endl;
  }
#endif
  fProcTblVector  = new  G4ProcTableVector();
  fProcNameVector = new  G4ProcNameVector();
  tmpTblVector    = new  G4ProcTableVector();
  fProcTblMessenger = 0;
}

G4ProcessTable::~G4ProcessTable

(

)

Definition at line 73 of file G4ProcessTable.cc.

References G4cout, and G4endl.

{
#ifdef G4VERBOSE
  if (verboseLevel>1){
    G4cout << "--  G4ProcessTable destructor  --" << G4endl;
  }
#endif

  if ( tmpTblVector != 0) {
    tmpTblVector ->clear();
    delete tmpTblVector;
  }

  if ( fProcTblVector != 0) {
    G4ProcTableVector::iterator idx;
    
    // destruction of processes has moved to G4VUserPhysicsList
    for (idx=fProcTblVector->begin(); idx!=fProcTblVector->end(); ++idx) {
      // delete all processes
      // delete (*idx)->GetProcess();
      delete (*idx);
    }  
    fProcTblVector ->clear();
    delete fProcTblVector;
  }

  if ( fProcNameVector != 0) {
    fProcNameVector ->clear();
    delete fProcNameVector;
  }
  fProcessTable =0;
}

Member Function Documentation

G4UImessenger * G4ProcessTable::CreateMessenger

(

)

Definition at line 107 of file G4ProcessTable.cc.

Referenced by G4RunManager::G4RunManager().

{
  if (fProcTblMessenger == 0) {
    fProcTblMessenger = new G4ProcessTableMessenger(this);
  }
  return     fProcTblMessenger;
}

void G4ProcessTable::DeleteMessenger

(

)

Definition at line 116 of file G4ProcessTable.cc.

Referenced by G4RunManager::~G4RunManager().

{
  if (fProcTblMessenger != 0) {
    delete fProcTblMessenger;
  }
}

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 export_G4ProcessTable(), and G4ProcessTableMessenger::SetNewValue().

{
  G4ProcTableVector::iterator itr; 
  G4int idxTbl=0;
  G4ProcTblElement* anElement=0;
  G4bool isFoundInTbl = false;
  G4ProcessManager* manager=0;
  G4int idx;
  // loop over all elements
  for (itr=fProcTblVector->begin(); itr!=fProcTblVector->end(); ++itr, ++idxTbl) {
    anElement = (*itr);
    if (process == anElement->GetProcess() ){
      if (particle!=0) {
    for (idx=0; idx<anElement->Length(); idx++){
      manager = anElement->GetProcessManager(idx);
      if (particle == manager->GetParticleType()) {
        isFoundInTbl = true;
        break;
      }
    }
      } else {
    isFoundInTbl = true;
      }
      break;
    }
  }
  if  (!isFoundInTbl ) return;
  
  G4int tmpVerbose = process->GetVerboseLevel();
  process->SetVerboseLevel(verboseLevel);
  process->DumpInfo();
  process->SetVerboseLevel(tmpVerbose);
  if (particle==0) {
    for (idx=0; idx<anElement->Length(); idx++){
      manager = anElement->GetProcessManager(idx);
      G4cout << " for " << manager->GetParticleType()->GetParticleName();
      G4cout << G4endl;
#ifdef G4VERBOSE
      if (verboseLevel >2){
    tmpVerbose = manager->GetVerboseLevel();
    manager->SetVerboseLevel(verboseLevel);
    manager->DumpInfo();
    manager->SetVerboseLevel(tmpVerbose);
      }
#endif
    }
  } else {
    G4cout << " for " << manager->GetParticleType()->GetParticleName();
    G4cout << G4endl;
#ifdef G4VERBOSE
    if (verboseLevel >2){
      tmpVerbose = manager->GetVerboseLevel();
      manager->SetVerboseLevel(verboseLevel);
      manager->DumpInfo();
      manager->SetVerboseLevel(tmpVerbose);
    }
#endif
  }
}

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

Referenced by exrdmAnalysisManager::BeginOfRun(), F05PhysicsList::ConstructProcess(), F04PhysicsList::ConstructProcess(), WLSPhysicsList::ConstructProcess(), exrdmAnalysisManager::EndOfRun(), PhysicsList::SetAnnihiToHadronFac(), PhysicsList::SetAnnihiToMuPairFac(), PhysicsList::SetGammaToMuPairFac(), and SetProcessActivation().

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

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().

{
  G4ProcTableVector::iterator itr;   
  G4int idxTbl = 0;
  G4bool isFound = false;
  G4ProcTblElement* anElement=0;
  for (itr=fProcTblVector->begin(); itr!=fProcTblVector->end(); ++itr, ++idxTbl) {
    anElement = (*itr);
    // check name
    if ( anElement->GetProcessName() == processName ) {
      // check if the processManage is included
      if ( anElement->Contains(processManager) ) {
    isFound = true;
    break;
      }
    }
  }
#ifdef G4VERBOSE
  if (!isFound && verboseLevel>1){
    G4cout << " G4ProcessTable::FindProcess :" ;
    G4cout << " The Process[" << processName << "] is not found  ";
    G4cout << " for " << processManager->GetParticleType()->GetParticleName() << G4endl;
  }
#endif
  
  if (isFound) return anElement->GetProcess();
  else         return 0;
}

G4ProcessVector * G4ProcessTable::FindProcesses

(

)

Definition at line 421 of file G4ProcessTable.cc.

Referenced by G4ProcessTableMessenger::SetNewValue().

{
  return ExtractProcesses(fProcTblVector);
}

G4ProcessVector * G4ProcessTable::FindProcesses

(

const G4ProcessManager *

processManager

)

Definition at line 427 of file G4ProcessTable.cc.

References G4ProcessManager::GetProcessList().

{
  G4ProcessVector* procList = pManager->GetProcessList();
  return new G4ProcessVector(*procList);
}

G4ProcessVector * G4ProcessTable::FindProcesses

(

const G4String &

processName

)

Definition at line 434 of file G4ProcessTable.cc.

{
  G4ProcTableVector* pTblVector =  Find(fProcTblVector, processName);
  return ExtractProcesses(pTblVector);
}

G4ProcessVector * G4ProcessTable::FindProcesses

(

G4ProcessType

processType

)

Definition at line 441 of file G4ProcessTable.cc.

{
  G4ProcTableVector* pTblVector =  Find(fProcTblVector, processType);
  return ExtractProcesses(pTblVector);
}

G4ProcNameVector* G4ProcessTable::GetNameList

(

)

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

G4ProcessTable * G4ProcessTable::GetProcessTable ( )

static

Definition at line 154 of file G4ProcessTable.cc.

References G4ProcessTable(), and G4ThreadLocal.

Referenced by G4ProcessManager::AddProcess(), exrdmAnalysisManager::BeginOfRun(), F05PhysicsList::ConstructProcess(), F04PhysicsList::ConstructProcess(), WLSPhysicsList::ConstructProcess(), exrdmAnalysisManager::EndOfRun(), export_G4ProcessTable(), G4ProcessManager::G4ProcessManager(), G4RunManager::G4RunManager(), G4ProcessManager::RemoveProcess(), PhysicsList::SetAnnihiToHadronFac(), PhysicsList::SetAnnihiToMuPairFac(), PhysicsList::SetGammaToMuPairFac(), and G4RunManager::~G4RunManager().

{
    static G4ThreadLocal G4ProcessTable *theProcessTable_G4MT_TLS_ = 0 ; if (!theProcessTable_G4MT_TLS_) theProcessTable_G4MT_TLS_ = new  G4ProcessTable  ;  G4ProcessTable &theProcessTable = *theProcessTable_G4MT_TLS_;
    if (!fProcessTable){
      fProcessTable =  &theProcessTable;
    }
    return fProcessTable;
}

G4ProcTableVector* G4ProcessTable::GetProcTableVector

(

)

G4int G4ProcessTable::GetVerboseLevel

(

)

const

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

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().

{
  if ( (aProcess == 0) || ( aProcMgr == 0 ) ){
#ifdef G4VERBOSE
    if (verboseLevel>0){
      G4cout << "G4ProcessTable::Insert : arguments are 0 pointer "
         <<aProcess <<","<<  aProcMgr << G4endl;
    }
#endif
    return -1;
  }
    
#ifdef G4VERBOSE
  if (verboseLevel>1){
    G4cout << "G4ProcessTable::Insert ";
    G4cout << " Process["  << aProcess->GetProcessName() << "]";
    G4cout << " Particle["  << aProcMgr->GetParticleType()->GetParticleName() << "]";
    G4cout << G4endl;
  }
#endif

  G4ProcTableVector::iterator itr; 
  G4int idxTbl=0;
  G4ProcTblElement* anElement;
  G4bool isFoundInTbl = false;
  // loop over all elements
  for (itr=fProcTblVector->begin(); itr!=fProcTblVector->end(); ++itr, ++idxTbl) {
    anElement = (*itr);
    // check if this process is included
    if (aProcess == anElement->GetProcess()) {
      isFoundInTbl = true;

      // add the process manager into the element 
      //  unless  this process manager is included
      if (!anElement->Contains(aProcMgr)) {
    anElement->Insert(aProcMgr);
#ifdef G4VERBOSE
    if (verboseLevel>2){
      G4cout << " This Process Manager is registered !! " << G4endl;
    }
#endif
      }
      break;
    }
  }
  // add this process into the table by creating a new element
  if (!isFoundInTbl) {
    G4ProcTblElement* newElement = new G4ProcTblElement(aProcess);
    newElement->Insert(aProcMgr);
    fProcTblVector->push_back(newElement);
    // add into name vector     
    G4ProcNameVector::iterator ip;
    G4bool isFound = false;
    for (ip=fProcNameVector->begin(); ip!=fProcNameVector->end(); ++ip) {
      isFound |= (aProcess->GetProcessName() == (*ip));
    }
    if (!isFound) {
      fProcNameVector->push_back(aProcess->GetProcessName() );
#ifdef G4VERBOSE
      if (verboseLevel>2){
    G4cout << " This Process is registered !! " << G4endl;
      }
#endif
    }
  }
  return idxTbl;
}

G4int G4ProcessTable::Length

(

)

const

Referenced by export_G4ProcessTable().

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().

{
  if ( (aProcess == 0) || ( aProcMgr == 0 ) ){
#ifdef G4VERBOSE
    if (verboseLevel>0){
      G4cout << "G4ProcessTable::Remove : arguments are 0 pointer "<< G4endl;
    }
#endif
    return -1;
  }
    
#ifdef G4VERBOSE
  if (verboseLevel>1){
    G4cout << "G4ProcessTable::Remove ";
    G4cout << " Process["  << aProcess->GetProcessName() << "]";
    G4cout << " Particle[" << aProcMgr->GetParticleType()->GetParticleName() << "]" << G4endl;
  }
#endif

  G4ProcTableVector::iterator itr; 
  G4int idxTbl=0;
  G4ProcTblElement* anElement=0;
  G4bool isFound = false;
  // loop over all elements
  for (itr=fProcTblVector->begin(); itr!=fProcTblVector->end(); ++itr, ++idxTbl) {
    anElement = (*itr);

    // check if this process is included
    if (aProcess == anElement->GetProcess()) {
      isFound = anElement->Contains(aProcMgr);
      // remove the process manager from the element
      anElement->Remove(aProcMgr);
#ifdef G4VERBOSE
      if (verboseLevel>2){
    G4cout << " This Process Manager is removed !! " << G4endl;
      }
#endif
      break;
    }
  }
  // 
  if (!isFound) {
#ifdef G4VERBOSE
    if (verboseLevel>0){
      G4cout << " This Process Manager is not registered !! " << G4endl;
    }
#endif
    return -1;
  }
  // remove the element if it has no entry
  if (anElement->Length() == 0){
    fProcTblVector->erase(itr);
    delete anElement;
    // check other prcesses with same name exist or not
    G4bool isSameName = false;
    for (itr=fProcTblVector->begin(); itr!=fProcTblVector->end(); ++itr) {
      anElement = (*itr);
      if (anElement->GetProcessName() == aProcess->GetProcessName()) {
    isSameName = true;
    break;
      }
    }
    // remove from name vector
    if (!isSameName ) {
      G4ProcNameVector::iterator i; 
      for (i=fProcNameVector->begin(); i!=fProcNameVector->end(); ++i) {
    if ( *i == aProcess->GetProcessName() ) {
      fProcNameVector->erase(i);
      break;
    }
      }
    }
#ifdef G4VERBOSE
    if (verboseLevel>1){
      G4cout << " This Process is removed !! " << G4endl;
    }
#endif
  }
  return idxTbl;
}

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

Definition at line 448 of file G4ProcessTable.cc.

References G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4ProcessManager::GetParticleType(), G4ProcTblElement::GetProcess(), G4ProcessManager::GetProcessIndex(), G4ProcTblElement::GetProcessManager(), G4ProcTblElement::Length(), and G4ProcessManager::SetProcessActivation().

Referenced by G4ProcessTableMessenger::SetNewValue().

{
#ifdef G4VERBOSE
  if (verboseLevel>1){
    G4cout << " G4ProcessTable::SetProcessActivation:" ;
    G4cout << " The Process[" << processName << "] "<< G4endl;
  }
#endif

  G4ProcTableVector* pTblVector =  Find(fProcTblVector, processName);
  G4ProcTableVector::iterator itr; 
  G4ProcTblElement* anElement;  
   // loop over all elements
  for (itr=pTblVector->begin(); itr!=pTblVector->end(); ++itr) {
    anElement = (*itr);
    G4VProcess* process = anElement->GetProcess();
    for (G4int idx = 0 ; idx < anElement->Length(); idx++) {
      G4ProcessManager* manager = anElement->GetProcessManager(idx);
      manager->SetProcessActivation(process, fActive);
#ifdef G4VERBOSE
      if (verboseLevel>1){
        G4cout << "  for " << manager->GetParticleType()->GetParticleName();
    G4cout << "  Index = " << manager->GetProcessIndex(process); 
        G4cout << G4endl;
      }
#endif
    }
  }
}

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 480 of file G4ProcessTable.cc.

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

{
#ifdef G4VERBOSE
  if (verboseLevel>1){
    G4cout << " G4ProcessTable::SetProcessActivation:" ;
    G4cout << " The Process[" << processName << "] "<< G4endl;
  }
#endif
  
  G4VProcess* process = FindProcess( processName,  processManager);
  if ( process != 0) {
    processManager->SetProcessActivation(process, fActive);
#ifdef G4VERBOSE
    if (verboseLevel>1){
      G4cout << "  for " << processManager->GetParticleType()->GetParticleName();
      G4cout << "  Index = " << processManager->GetProcessIndex(process) << G4endl;
    }
#endif
  } 
}

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

Definition at line 506 of file G4ProcessTable.cc.

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

{
#ifdef G4VERBOSE
  if (verboseLevel>1){
    G4cout << " G4ProcessTable::SetProcessActivation:" ;
    G4cout << " The ProcessType[" << G4int(processType) << "] "<< G4endl;
  }
#endif

  G4ProcTableVector* pTblVector =  Find(fProcTblVector, processType);
  G4ProcTableVector::iterator itr; 
  G4ProcTblElement* anElement;  
  // loop over all elements
  for (itr=pTblVector->begin(); itr!=pTblVector->end(); ++itr) {
    anElement = (*itr);
    G4VProcess* process = anElement->GetProcess();
#ifdef G4VERBOSE
    if (verboseLevel>1){
      G4cout << " The Process[" << process->GetProcessName()<< "] "<< G4endl;
    }
#endif
    for (G4int idx = 0 ; idx < anElement->Length(); idx++) {
      G4ProcessManager* manager = anElement->GetProcessManager(idx);
      manager->SetProcessActivation(process, fActive);
#ifdef G4VERBOSE
      if (verboseLevel>1){
        G4cout << "  for " << manager->GetParticleType()->GetParticleName();
    G4cout << "  Index = " << manager->GetProcessIndex(process) << G4endl;
      }
#endif
    }
  }
}

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 542 of file G4ProcessTable.cc.

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

{
#ifdef G4VERBOSE
  if (verboseLevel>1){
    G4cout << " G4ProcessTable::SetProcessActivation:" ;
    G4cout << " The ProcessType[" << G4int(processType) << "] "<< G4endl;
  }
#endif
  
  G4ProcessVector* procList =  processManager->GetProcessList();
  for (G4int idx = 0; idx < procList->length(); idx++) {
    G4VProcess* process = (*procList)(idx);
    if ( process->GetProcessType() == processType) {
      processManager->SetProcessActivation(process, fActive);
#ifdef G4VERBOSE
      if (verboseLevel>1){
        G4cout << " The Process[" << process->GetProcessName()<< "] "<< G4endl;
    G4cout << "  for " << processManager->GetParticleType()->GetParticleName();
    G4cout << "  Index = " << idx << G4endl;
      }
#endif
    }
  }
}

void G4ProcessTable::SetVerboseLevel

(

G4int

value

)

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

---

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

• G4ProcessTable.hh
• G4ProcessTable.cc