G4ProcessTable Class Reference

#include <G4ProcessTable.hh>

Public Types
using	G4ProcNameVector = std::vector< G4String >
using	G4ProcTableVector = std::vector< G4ProcTblElement * >

Public Member Functions
void	DeRegisterProcess (G4VProcess *)
void	DumpInfo (G4VProcess *process, const G4ParticleDefinition *particle=nullptr)
G4VProcess *	FindProcess (const G4String &processName, const G4ParticleDefinition *particle) const
G4VProcess *	FindProcess (const G4String &processName, const G4ProcessManager *processManager) const
G4VProcess *	FindProcess (const G4String &processName, const G4String &particleName) const
G4VProcess *	FindProcess (G4int processSubType, const G4ParticleDefinition *particle) const
G4VProcess *	FindProcess (G4ProcessType processType, const G4ParticleDefinition *particle) const
G4ProcessVector *	FindProcesses ()
G4ProcessVector *	FindProcesses (const G4ProcessManager *pManager)
G4ProcessVector *	FindProcesses (const G4String &processName)
G4ProcessVector *	FindProcesses (G4ProcessType processType)
	G4ProcessTable (const G4ProcessTable &)=delete
G4ProcNameVector *	GetNameList ()
G4ProcTableVector *	GetProcTableVector ()
G4int	GetVerboseLevel () const
G4int	Insert (G4VProcess *aProcess, G4ProcessManager *aProcMgr)
G4int	Length () const
G4bool	operator!= (const G4ProcessTable &right) const =delete
G4ProcessTable &	operator= (const G4ProcessTable &)=delete
G4bool	operator== (const G4ProcessTable &right) const =delete
void	RegisterProcess (G4VProcess *)
G4int	Remove (G4VProcess *aProcess, G4ProcessManager *aProcMgr)
void	SetProcessActivation (const G4String &processName, const G4ParticleDefinition *particle, G4bool fActive)
void	SetProcessActivation (const G4String &processName, const G4String &particleName, G4bool fActive)
void	SetProcessActivation (const G4String &processName, G4bool fActive)
void	SetProcessActivation (const G4String &processName, G4ProcessManager *processManager, G4bool fActive)
void	SetProcessActivation (G4ProcessType processType, const G4ParticleDefinition *particle, G4bool fActive)
void	SetProcessActivation (G4ProcessType processType, const G4String &particleName, G4bool fActive)
void	SetProcessActivation (G4ProcessType processType, G4bool fActive)
void	SetProcessActivation (G4ProcessType processType, G4ProcessManager *processManager, G4bool fActive)
void	SetVerboseLevel (G4int value)
	~G4ProcessTable ()

Static Public Member Functions
static G4ProcessTable *	GetProcessTable ()

Private Member Functions
G4ProcessVector *	ExtractProcesses (G4ProcTableVector *) const
G4ProcTableVector *	Find (const G4String &processName)
G4ProcTableVector *	Find (G4ProcessType processType)
	G4ProcessTable ()

Private Attributes
std::vector< G4VProcess * >	fListProcesses
G4ProcNameVector *	fProcNameVector = nullptr
G4ProcessTableMessenger *	fProcTblMessenger = nullptr
G4ProcTableVector *	fProcTblVector = nullptr
G4ProcTableVector *	tmpTblVector = nullptr
G4int	verboseLevel = 1

Static Private Attributes
static G4ThreadLocal G4ProcessTable *	fProcessTable = nullptr

Friends
class	G4ThreadLocalSingleton< G4ProcessTable >

Detailed Description

Definition at line 48 of file G4ProcessTable.hh.

Member Typedef Documentation

G4ProcNameVector

using G4ProcessTable::G4ProcNameVector = std::vector<G4String>

Definition at line 55 of file G4ProcessTable.hh.

G4ProcTableVector

using G4ProcessTable::G4ProcTableVector = std::vector<G4ProcTblElement*>

Definition at line 54 of file G4ProcessTable.hh.

Constructor & Destructor Documentation

~G4ProcessTable()

G4ProcessTable::~G4ProcessTable

(

)

Definition at line 60 of file G4ProcessTable.cc.

{
  if ( tmpTblVector != nullptr )
  {
    tmpTblVector ->clear();
    delete tmpTblVector;
    tmpTblVector = nullptr;
  }
 
  if ( fProcTblVector != nullptr )
  {
    for (auto elem : *fProcTblVector)
    {
      delete elem;
    }  
    fProcTblVector ->clear();
    delete fProcTblVector;
    fProcTblVector = nullptr;
  }
 
  // delete all process except transportation
  for(auto proc : fListProcesses)
  {
    if ( proc != nullptr )
    {
      G4ProcessType type = proc->GetProcessType();
      if (type != fTransportation && type != fParallel
       && type != fParameterisation)
      {
        delete proc;
      } 
    } 
  }
 
  fListProcesses.clear();
 
  if ( fProcNameVector != nullptr )
  {
    fProcNameVector ->clear();
    delete fProcNameVector;
    fProcNameVector = nullptr;
  }
  fProcessTable = nullptr;
  delete fProcTblMessenger;
}

References elem, fListProcesses, fParallel, fParameterisation, fProcessTable, fProcNameVector, fProcTblMessenger, fProcTblVector, fTransportation, and tmpTblVector.

G4ProcessTable() [1/2]

G4ProcessTable::G4ProcessTable ( const G4ProcessTable &  )

delete

G4ProcessTable() [2/2]

G4ProcessTable::G4ProcessTable ( )

private

Definition at line 43 of file G4ProcessTable.cc.

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

References fProcNameVector, fProcTblMessenger, fProcTblVector, G4cout, G4endl, tmpTblVector, and verboseLevel.

Member Function Documentation

DeRegisterProcess()

void G4ProcessTable::DeRegisterProcess

(

G4VProcess *

ptr

)

Definition at line 270 of file G4ProcessTable.cc.

{  
  G4int nn = fListProcesses.size();
  for(G4int i=0; i<nn; ++i)
  {
    if(ptr == fListProcesses[i])
    { 
      fListProcesses[i] = nullptr;
      return; 
    }
  }
}

References fListProcesses, and G4InuclParticleNames::nn.

Referenced by G4VProcess::~G4VProcess().

DumpInfo()

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

Definition at line 635 of file G4ProcessTable.cc.

{
  G4int idxTbl=0;
  G4ProcTblElement* anElement = nullptr;
  G4bool isFoundInTbl = false;
  G4ProcessManager* manager = nullptr;
  G4int idx;
  // loop over all elements
  for (auto itr=fProcTblVector->cbegin();
            itr!=fProcTblVector->cend(); ++itr, ++idxTbl)
  {
    anElement = (*itr);
    if ( anElement == nullptr ) continue;
    if (process == anElement->GetProcess() )
    {
      if (particle != nullptr)
      {
        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 == nullptr)
  {
    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
  }
}

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

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

ExtractProcesses()

G4ProcessVector * G4ProcessTable::ExtractProcesses ( G4ProcTableVector *  procTblVector ) const

private

Definition at line 442 of file G4ProcessTable.cc.

{
  G4ProcessVector* procList = new G4ProcessVector();
  // loop over all elements
  for (auto itr=procTblVector->cbegin(); itr!=procTblVector->cend(); ++itr)
  {
    G4ProcTblElement* anElement = (*itr);
    if ( anElement != nullptr) procList->insert( anElement->GetProcess() );
  }
  return procList;
}

References G4ProcTblElement::GetProcess(), and G4ProcessVector::insert().

Find() [1/2]

G4ProcessTable::G4ProcTableVector * G4ProcessTable::Find ( const G4String &  processName )

private

Definition at line 379 of file G4ProcessTable.cc.

{
  tmpTblVector->clear();
 
  G4bool isFound = false;
  G4ProcTblElement* anElement = nullptr;
  for (auto itr=fProcTblVector->cbegin(); itr!=fProcTblVector->cend(); ++itr)
  {
    anElement = (*itr);
    // check name
    if ( anElement != nullptr && anElement->GetProcessName() == processName )
    {
      isFound = true;
      tmpTblVector->push_back(anElement);
    }
  }
 
  if (!isFound && verboseLevel>0)
  {
#ifdef G4VERBOSE
    G4cout << " G4ProcessTable::Find() -" ;
    G4cout << " The Process[" << processName << "] is not found  " << G4endl;
#endif
  }
 
  return tmpTblVector;
}

References fProcTblVector, G4cout, G4endl, G4ProcTblElement::GetProcessName(), tmpTblVector, and verboseLevel.

Referenced by SetProcessActivation().

Find() [2/2]

G4ProcessTable::G4ProcTableVector * G4ProcessTable::Find ( G4ProcessType  processType )

private

Definition at line 410 of file G4ProcessTable.cc.

{
  tmpTblVector->clear();
 
  G4bool isFound = false;
  G4ProcTblElement* anElement = nullptr;
  for (auto itr=fProcTblVector->cbegin(); itr!=fProcTblVector->cend(); ++itr)
  {
    anElement = (*itr);
    // check name
    if ( anElement != nullptr && anElement->GetProcess()->GetProcessType() == processType )
    {
      isFound = true;
      tmpTblVector->push_back(anElement);
    }
  }
 
  if (!isFound && verboseLevel>0)
  {
#ifdef G4VERBOSE
    G4cout << " G4ProcessTable::Find() -" ;
    G4cout << " The ProcessType[" << processType << "] is not found  "
           << G4endl;
#endif
  }
 
  return tmpTblVector;
}     

References fProcTblVector, G4cout, G4endl, G4ProcTblElement::GetProcess(), G4VProcess::GetProcessType(), tmpTblVector, and verboseLevel.

FindProcess() [1/5]

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

inline

FindProcess() [2/5]

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

Definition at line 294 of file G4ProcessTable.cc.

{
  for (auto anElement : *fProcTblVector)
  {
    // check name and if the processManage is included
    if (anElement && anElement->GetProcessName() == processName
        && anElement->Contains(processManager))
    {
      return anElement->GetProcess();
    }
  }
#ifdef G4VERBOSE
  if (verboseLevel > 1)
  {
    G4cout << " G4ProcessTable::FindProcess() -" ;
    G4cout << " The Process[" << processName << "] is not found  ";
    G4cout << " for [" << processManager->GetParticleType()->GetParticleName()
           << "]" << G4endl;
  }
#endif
  return nullptr;
}

References fProcTblVector, G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4ProcessManager::GetParticleType(), and verboseLevel.

FindProcess() [3/5]

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

Definition at line 285 of file G4ProcessTable.cc.

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

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

Referenced by G4EmDNAChemistry::ConstructProcess(), G4SpinDecayPhysics::ConstructProcess(), FindProcess(), and SetProcessActivation().

FindProcess() [4/5]

G4VProcess * G4ProcessTable::FindProcess	(	G4int	processSubType,
		const G4ParticleDefinition *	particle
	)		const

Definition at line 350 of file G4ProcessTable.cc.

{
  // find the first process of given type for this particle
 
  const G4ProcessManager* processManager = particle->GetProcessManager();
  for (auto anElement : *fProcTblVector)
  {
    if ( anElement != nullptr
      && anElement->GetProcess()->GetProcessSubType() == procSubType
      && anElement->Contains(processManager) )
    {
      return anElement->GetProcess();
    }
  }
#ifdef G4VERBOSE
  if (verboseLevel > 1)
  {
    G4cout << " G4ProcessTable::FindProcess() -";
    G4cout << " The Process SubType " << procSubType << " is not found  ";
    G4cout << " for [" << particle->GetParticleName() << "]" << G4endl;
  }
#endif
  return nullptr;
}

References fProcTblVector, G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4ProcessManager::GetProcess(), G4ParticleDefinition::GetProcessManager(), and verboseLevel.

FindProcess() [5/5]

G4VProcess * G4ProcessTable::FindProcess	(	G4ProcessType	processType,
		const G4ParticleDefinition *	particle
	)		const

Definition at line 322 of file G4ProcessTable.cc.

{
  // find the first process of given type for this particle
 
  const G4ProcessManager* processManager = particle->GetProcessManager();
  for (auto anElement : *fProcTblVector)
  {
    if (anElement && anElement->GetProcess()->GetProcessType() == processType
        && anElement->Contains(processManager))
    {
      return anElement->GetProcess();
    }
  }
#ifdef G4VERBOSE
  if (verboseLevel > 1)
  {
    G4cout << " G4ProcessTable::FindProcess() -";
    G4cout << " The Process Type " << processType << " is not found  ";
    G4cout << " for [" << particle->GetParticleName() << "]" << G4endl;
  }
#endif
  return nullptr;
}

References fProcTblVector, G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4ProcessManager::GetProcess(), G4ParticleDefinition::GetProcessManager(), and verboseLevel.

FindProcesses() [1/4]

G4ProcessVector * G4ProcessTable::FindProcesses ( )

inline

Referenced by G4ProcessTableMessenger::SetNewValue().

FindProcesses() [2/4]

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

inline

FindProcesses() [3/4]

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

inline

FindProcesses() [4/4]

G4ProcessVector * G4ProcessTable::FindProcesses ( G4ProcessType  processType )

inline

GetNameList()

G4ProcNameVector * G4ProcessTable::GetNameList ( )

inline

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

GetProcessTable()

G4ProcessTable * G4ProcessTable::GetProcessTable ( )

static

Definition at line 108 of file G4ProcessTable.cc.

{
  if(fProcessTable == nullptr)
  {
    static G4ThreadLocalSingleton<G4ProcessTable> inst;
    fProcessTable = inst.Instance();
  }
  return fProcessTable;
}

References fProcessTable, and G4ThreadLocalSingleton< T >::Instance().

Referenced by G4ProcessManager::AddProcess(), G4EmDNAChemistry::ConstructProcess(), G4EmDNAChemistry_option1::ConstructProcess(), G4EmDNAChemistry_option3::ConstructProcess(), G4SpinDecayPhysics::ConstructProcess(), G4EmDNAChemistry_option2::ConstructProcess(), export_G4ProcessTable(), G4ProcessManager::G4ProcessManager(), G4RunManager::G4RunManager(), G4VProcess::G4VProcess(), and G4ProcessManager::RemoveProcess().

GetProcTableVector()

G4ProcTableVector * G4ProcessTable::GetProcTableVector ( )

inline

GetVerboseLevel()

G4int G4ProcessTable::GetVerboseLevel ( ) const

inline

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

Insert()

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

Definition at line 120 of file G4ProcessTable.cc.

{
  if ( (aProcess == nullptr) || ( aProcMgr == nullptr ) || !fProcTblVector )
  {
#ifdef G4VERBOSE
    if (verboseLevel>0)
    {
      G4cout << "G4ProcessTable::Insert() - arguments are null pointer "
             << aProcess << "," << aProcMgr << G4endl;
    }
#endif
    return -1;
  }
    
#ifdef G4VERBOSE
  if (verboseLevel>1)
  {
    G4cout << "G4ProcessTable::Insert() -";
    G4cout << " Process["  << aProcess->GetProcessName() << "]";
    G4cout << " Particle["  << aProcMgr->GetParticleType()->GetParticleName()
           << "]" << G4endl;
  }
#endif
 
  G4int idxTbl = 0;
  G4int nidx = fProcTblVector->size();
  G4ProcTblElement* anElement = nullptr;
  // loop over all elements
  for (; idxTbl < nidx; ++idxTbl)
  {
    anElement = (*fProcTblVector)[idxTbl];
    if(!anElement) { continue; }
    // check if this process is included
    if (aProcess == anElement->GetProcess())
    {
      // 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
      }
      return idxTbl;
    }
  }
  // add this process into the table by creating a new element
  if (verboseLevel>2)
  {
    G4cout << " New element is created !! " << G4endl;
  }
  anElement = new G4ProcTblElement(aProcess);
  anElement->Insert(aProcMgr);
  fProcTblVector->push_back(anElement);
  fProcNameVector->push_back(aProcess->GetProcessName() );
  return nidx;
}

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

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

Length()

G4int G4ProcessTable::Length ( ) const

inline

Referenced by export_G4ProcessTable().

operator!=()

G4bool G4ProcessTable::operator!= ( const G4ProcessTable &  right ) const

delete

operator=()

G4ProcessTable & G4ProcessTable::operator= ( const G4ProcessTable &  )

delete

operator==()

G4bool G4ProcessTable::operator== ( const G4ProcessTable &  right ) const

delete

RegisterProcess()

void G4ProcessTable::RegisterProcess

(

G4VProcess *

ptr

)

Definition at line 259 of file G4ProcessTable.cc.

{
  for(auto proc : fListProcesses)
  {
    if(ptr == proc) { return; } 
  }
  fListProcesses.push_back(ptr);
}

References fListProcesses.

Referenced by G4VProcess::G4VProcess().

Remove()

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

Definition at line 185 of file G4ProcessTable.cc.

{
  if ( (aProcess == nullptr) || ( aProcMgr == nullptr ) || !fProcTblVector )
  {
#ifdef G4VERBOSE
    if (verboseLevel>0)
    {
      G4cout << "G4ProcessTable::Remove() - arguments are null pointer "
             << G4endl;
    }
#endif
    return -1;
  }
    
#ifdef G4VERBOSE
  if (verboseLevel>1)
  {
    G4cout << "G4ProcessTable::Remove() -";
    G4cout << " Process["  << aProcess->GetProcessName() << "]";
    G4cout << " Particle[" << aProcMgr->GetParticleType()->GetParticleName()
           << "]" << G4endl;
  }
#endif
 
  G4int idxTbl = 0;
  G4int nidx = fProcTblVector->size();
  G4ProcTblElement* anElement =nullptr;
  // loop over all elements
  for (; idxTbl < nidx; ++idxTbl)
  {
    anElement = (*fProcTblVector)[idxTbl];
    if(!anElement) { continue; }
 
    // check if this process is included
    if (aProcess == anElement->GetProcess())
    {
      if(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
        if(anElement->Length() == 0)
        {
          delete anElement;
          (*fProcTblVector)[idxTbl] = nullptr;
#ifdef G4VERBOSE
          if (verboseLevel>1)
          {
            G4cout << " This Process is removed !! " << G4endl;
          }
#endif
        }
        return idxTbl;
      }
    }
  }
#ifdef G4VERBOSE
  if (verboseLevel>1)
  {
    G4cout << " This Process Manager is not registered to the process!! " 
           << G4endl;
  }
#endif
  return -1;
}

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

Referenced by G4ProcessManager::RemoveProcess().

SetProcessActivation() [1/8]

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

inline

SetProcessActivation() [2/8]

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

Definition at line 456 of file G4ProcessTable.cc.

{
  if (particleName == "ALL" )
  {
    SetProcessActivation( processName, fActive); 
  }
  else
  {
    SetProcessActivation(processName, 
        G4ParticleTable::GetParticleTable()->FindParticle(particleName),
        fActive );
  }
}

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

SetProcessActivation() [3/8]

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

Definition at line 492 of file G4ProcessTable.cc.

{
#ifdef G4VERBOSE
  if (verboseLevel>1)
  {
    G4cout << " G4ProcessTable::SetProcessActivation() -" ;
    G4cout << " The Process[" << processName << "] "<< G4endl;
  }
#endif
 
  G4ProcTableVector* pTblVector =  Find(processName);
  G4ProcTblElement* anElement;  
   // loop over all elements
  for (auto itr=pTblVector->cbegin(); itr!=pTblVector->cend(); ++itr)
  {
    anElement = (*itr);
    if ( anElement == nullptr ) continue;
    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
    }
  }
}

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

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

SetProcessActivation() [4/8]

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

Definition at line 529 of file G4ProcessTable.cc.

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

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

SetProcessActivation() [5/8]

void G4ProcessTable::SetProcessActivation ( G4ProcessType  processType, const G4ParticleDefinition *  particle, G4bool  fActive  )

inline

SetProcessActivation() [6/8]

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

Definition at line 474 of file G4ProcessTable.cc.

{
  if ((particleName == "ALL" ) || (particleName == "all" ))
  {
    SetProcessActivation( processType, fActive ); 
  }
  else
  {
    SetProcessActivation(processType,         
        G4ParticleTable::GetParticleTable()->FindParticle(particleName),
        fActive );
  }
}

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

SetProcessActivation() [7/8]

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

Definition at line 559 of file G4ProcessTable.cc.

{
#ifdef G4VERBOSE
  if (verboseLevel>1)
  {
    G4cout << " G4ProcessTable::SetProcessActivation() -" ;
    G4cout << " The ProcessType[" << G4int(processType) << "] "<< G4endl;
  }
#endif
 
  G4ProcTableVector* pTblVector = Find(processType);
  G4ProcTblElement* anElement;  
  // loop over all elements
  for (auto itr=pTblVector->cbegin(); itr!=pTblVector->cend(); ++itr)
  {
    anElement = (*itr);
    if ( anElement == nullptr ) continue;
    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
    }
  }
}

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

SetProcessActivation() [8/8]

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

Definition at line 601 of file G4ProcessTable.cc.

{
#ifdef G4VERBOSE
  if (verboseLevel>1)
  {
    G4cout << " G4ProcessTable::SetProcessActivation() -" ;
    G4cout << " The ProcessType[" << G4int(processType) << "] "<< G4endl;
  }
#endif
  
  G4ProcessVector* procList =  processManager->GetProcessList();
  for (std::size_t 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
    }
  }
}

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

SetVerboseLevel()

void G4ProcessTable::SetVerboseLevel ( G4int  value )

inline

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

Friends And Related Function Documentation

G4ThreadLocalSingleton< G4ProcessTable >

friend class G4ThreadLocalSingleton< G4ProcessTable >

friend

Definition at line 1 of file G4ProcessTable.hh.

Field Documentation

fListProcesses

std::vector<G4VProcess*> G4ProcessTable::fListProcesses

private

Definition at line 167 of file G4ProcessTable.hh.

Referenced by DeRegisterProcess(), RegisterProcess(), and ~G4ProcessTable().

fProcessTable

G4ThreadLocal G4ProcessTable * G4ProcessTable::fProcessTable = nullptr

staticprivate

Definition at line 158 of file G4ProcessTable.hh.

Referenced by GetProcessTable(), and ~G4ProcessTable().

fProcNameVector

G4ProcNameVector* G4ProcessTable::fProcNameVector = nullptr

private

Definition at line 162 of file G4ProcessTable.hh.

Referenced by G4ProcessTable(), Insert(), and ~G4ProcessTable().

fProcTblMessenger

G4ProcessTableMessenger* G4ProcessTable::fProcTblMessenger = nullptr

private

Definition at line 159 of file G4ProcessTable.hh.

Referenced by G4ProcessTable(), and ~G4ProcessTable().

fProcTblVector

G4ProcTableVector* G4ProcessTable::fProcTblVector = nullptr

private

Definition at line 161 of file G4ProcessTable.hh.

Referenced by DumpInfo(), Find(), FindProcess(), G4ProcessTable(), Insert(), Remove(), and ~G4ProcessTable().

tmpTblVector

G4ProcTableVector* G4ProcessTable::tmpTblVector = nullptr

private

Definition at line 164 of file G4ProcessTable.hh.

Referenced by Find(), G4ProcessTable(), and ~G4ProcessTable().

verboseLevel

G4int G4ProcessTable::verboseLevel = 1

private

Definition at line 170 of file G4ProcessTable.hh.

Referenced by DumpInfo(), Find(), FindProcess(), G4ProcessTable(), Insert(), Remove(), and SetProcessActivation().

---

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

• source/processes/management/include/G4ProcessTable.hh
• source/processes/management/src/G4ProcessTable.cc