#include <G4ProcessManager.hh>

Public Types
enum	{ SizeOfProcVectorArray = 6 }

Public Member Functions
G4int	AddContinuousProcess (G4VProcess *aProcess, G4int ord=ordDefault)

G4int	AddDiscreteProcess (G4VProcess *aProcess, G4int ord=ordDefault)

G4int	AddProcess (G4VProcess *aProcess, G4int ordAtRestDoIt=ordInActive, G4int ordAlongSteptDoIt=ordInActive, G4int ordPostStepDoIt=ordInActive)

G4int	AddRestProcess (G4VProcess *aProcess, G4int ord=ordDefault)

void	DumpInfo ()

void	EndTracking ()

	G4ProcessManager ()=delete

	G4ProcessManager (const G4ParticleDefinition *aParticleType)

	G4ProcessManager (G4ProcessManager &right)

G4int	GetAlongStepIndex (G4VProcess *aProcess, G4ProcessVectorTypeIndex typ=typeGPIL) const

G4ProcessVector *	GetAlongStepProcessVector (G4ProcessVectorTypeIndex typ=typeGPIL) const

G4int	GetAtRestIndex (G4VProcess *aProcess, G4ProcessVectorTypeIndex typ=typeGPIL) const

G4ProcessVector *	GetAtRestProcessVector (G4ProcessVectorTypeIndex typ=typeGPIL) const

G4ParticleDefinition *	GetParticleType () const

G4int	GetPostStepIndex (G4VProcess *aProcess, G4ProcessVectorTypeIndex typ=typeGPIL) const

G4ProcessVector *	GetPostStepProcessVector (G4ProcessVectorTypeIndex typ=typeGPIL) const

G4VProcess *	GetProcess (const G4String &) const

G4bool	GetProcessActivation (G4int index) const

G4bool	GetProcessActivation (G4VProcess *aProcess) const

G4int	GetProcessIndex (G4VProcess *) const

G4ProcessVector *	GetProcessList () const

G4int	GetProcessListLength () const

G4int	GetProcessOrdering (G4VProcess *aProcess, G4ProcessVectorDoItIndex idDoIt)

G4ProcessVector *	GetProcessVector (G4ProcessVectorDoItIndex idx, G4ProcessVectorTypeIndex typ=typeGPIL) const

G4int	GetProcessVectorIndex (G4VProcess *aProcess, G4ProcessVectorDoItIndex idx, G4ProcessVectorTypeIndex typ=typeGPIL) const

G4int	GetVerboseLevel () const

G4bool	operator!= (const G4ProcessManager &right) const

G4ProcessManager &	operator= (const G4ProcessManager &)=delete

G4bool	operator== (const G4ProcessManager &right) const

G4VProcess *	RemoveProcess (G4int index)

G4VProcess *	RemoveProcess (G4VProcess *aProcess)

void	SetParticleType (const G4ParticleDefinition *)

G4VProcess *	SetProcessActivation (G4int index, G4bool fActive)

G4VProcess *	SetProcessActivation (G4VProcess *aProcess, G4bool fActive)

void	SetProcessOrdering (G4VProcess *aProcess, G4ProcessVectorDoItIndex idDoIt, G4int ordDoIt=ordDefault)

void	SetProcessOrderingToFirst (G4VProcess *aProcess, G4ProcessVectorDoItIndex idDoIt)

void	SetProcessOrderingToLast (G4VProcess *aProcess, G4ProcessVectorDoItIndex idDoIt)

void	SetProcessOrderingToSecond (G4VProcess *aProcess, G4ProcessVectorDoItIndex idDoIt)

void	SetVerboseLevel (G4int value)

void	StartTracking (G4Track *aTrack=nullptr)

	~G4ProcessManager ()

Private Types
using	G4ProcessAttrVector = std::vector< G4ProcessAttribute * >

Private Member Functions
G4VProcess *	ActivateProcess (G4int index)

void	CheckOrderingParameters (G4VProcess *) const

void	CreateGPILvectors ()

G4int	FindInsertPosition (G4int ord, G4int ivec)

G4ProcessAttribute *	GetAttribute (G4int index) const

G4ProcessAttribute *	GetAttribute (G4VProcess *aProcess) const

G4int	GetProcessVectorId (G4ProcessVectorDoItIndex idx, G4ProcessVectorTypeIndex typ=typeGPIL) const

G4VProcess *	InActivateProcess (G4int index)

G4int	InsertAt (G4int position, G4VProcess *process, G4int ivec)

G4int	RemoveAt (G4int position, G4VProcess *process, G4int ivec)

void	SetIndexToProcessVector (G4int ivec)

Private Attributes
G4bool	duringTracking = false

G4bool	isSetOrderingFirstInvoked [NDoit]

G4bool	isSetOrderingLastInvoked [NDoit]

G4int	numberOfProcesses = 0

G4ProcessAttrVector *	theAttrVector = nullptr

const G4ParticleDefinition *	theParticleType = nullptr

G4ProcessVector *	theProcessList = nullptr

G4ProcessVector *	theProcVector [SizeOfProcVectorArray]

G4int	verboseLevel = 1

Static Private Attributes
static G4ThreadLocal G4int	counterOfObjects = 0

static G4ThreadLocal G4ProcessManagerMessenger *	fProcessManagerMessenger = nullptr

Detailed Description

Definition at line 94 of file G4ProcessManager.hh.

Member Typedef Documentation

◆ G4ProcessAttrVector

using G4ProcessManager::G4ProcessAttrVector = std::vector<G4ProcessAttribute*>

private

Definition at line 96 of file G4ProcessManager.hh.

Member Enumeration Documentation

◆ anonymous enum

anonymous enum

Enumerator
SizeOfProcVectorArray

Definition at line 291 of file G4ProcessManager.hh.

291{SizeOfProcVectorArray = 6};

G4ProcessManager::SizeOfProcVectorArray

@ SizeOfProcVectorArray

Definition: G4ProcessManager.hh:291

Constructor & Destructor Documentation

◆ G4ProcessManager() [1/3]

G4ProcessManager::G4ProcessManager ( const G4ParticleDefinition * aParticleType )

Definition at line 48 of file G4ProcessManager.cc.

  : theParticleType(aParticleType)
{
  // create the process List
  theProcessList = new G4ProcessVector();
  if ( theProcessList == nullptr)
  {
    G4Exception( "G4ProcessManager::G4ProcessManager()","ProcMan012",
                 FatalException, "Can not create G4ProcessList ");
  }
 
  // create process vector
  for (G4int i=0; i<SizeOfProcVectorArray; ++i)
  {
    theProcVector[i] = new G4ProcessVector();
    if ( theProcVector[i] == nullptr)
    {
      G4Exception( "G4ProcessManager::G4ProcessManager()","ProcMan012",
                   FatalException, "Can not create G4ProcessVector ");
    }
  }
 
  // create Process Attribute vector
  theAttrVector = new G4ProcessAttrVector();
 
  // create Process Manager Messenger
  if (fProcessManagerMessenger == nullptr)
  {
    fProcessManagerMessenger = new G4ProcessManagerMessenger();
  }
 
  for (G4int i=0; i<NDoit; ++i)
  {
    isSetOrderingFirstInvoked[i] = false;
    isSetOrderingLastInvoked[i] = false;
  }
 
  // Increment counter of G4ProcessManager objects
  ++counterOfObjects; 
}

References counterOfObjects, FatalException, fProcessManagerMessenger, G4Exception(), isSetOrderingFirstInvoked, isSetOrderingLastInvoked, NDoit, SizeOfProcVectorArray, theAttrVector, theProcessList, and theProcVector.

◆ G4ProcessManager() [2/3]

G4ProcessManager::G4ProcessManager ( G4ProcessManager & right )

Definition at line 90 of file G4ProcessManager.cc.

  : theParticleType(right.theParticleType),
    verboseLevel(right.verboseLevel)
{
#ifdef G4VERBOSE
   if (GetVerboseLevel() > 2)
   {
     G4cout << "G4ProcessManager::G4ProcessManager() [copy constructor]"
            << G4endl; 
   }
#endif
 
   // create the process List and ProcessAttr Vector
   theProcessList = new G4ProcessVector();
   theAttrVector = new G4ProcessAttrVector();
   if ( ( theProcessList == nullptr) || (theAttrVector == nullptr) )
   {
     G4Exception( "G4ProcessManager::G4ProcessManager() [copy constructor]",
                  "ProcMan011",FatalException, "Cannot create G4ProcessList");
   }
 
   for (G4int idx=0; idx < right.numberOfProcesses; ++idx)
   {
     // copy contents in theProcessList
     theProcessList->insert((*right.theProcessList)[idx]);
     // create a G4ProcessAttribute same as source's one
     G4ProcessAttribute* sAttr = (*right.theAttrVector)[idx];
     G4ProcessAttribute* dAttr = new G4ProcessAttribute(*sAttr);
     // adds  a G4ProcessAttribute object
     theAttrVector->push_back(dAttr);
     ++numberOfProcesses;
   }
  
   // fill up theProcVector
   for (G4int i=0; i<SizeOfProcVectorArray; ++i)
   {
     // create i-th ProcessVector in theProcVector
     theProcVector[i] = new G4ProcessVector();
     if ( theProcVector[i] == nullptr )
     {
       G4Exception("G4ProcessManager::G4ProcessManager() [copy constructor]",
                  "ProcMan011",FatalException, "Cannot create G4ProcessVector");
     }
 
     G4ProcessTable* theProcessTable = G4ProcessTable::GetProcessTable();
     G4ProcessVector* src = right.theProcVector[i];
     for (std::size_t j=0; j< src->entries() ; ++j)
     {
       // copy j-th process in i-th ProcessVector 
       theProcVector[i]->insert((*src)[j]);
       //add aProcess and this ProcessManager into ProcesssTable 
       if (  (*src)[j] != nullptr )
       {
         theProcessTable->Insert((*src)[j], this);
       }
     }
   }
 
   for (G4int i=0; i<NDoit; ++i)
   {
     isSetOrderingFirstInvoked[i]= right.isSetOrderingFirstInvoked[i];
     isSetOrderingLastInvoked[i] = right.isSetOrderingLastInvoked[i];
   }
 
   // Increment counter of G4ProcessManager objects
   ++counterOfObjects; 
}

References counterOfObjects, G4ProcessVector::entries(), FatalException, G4cout, G4endl, G4Exception(), G4ProcessTable::GetProcessTable(), GetVerboseLevel(), G4ProcessVector::insert(), G4ProcessTable::Insert(), isSetOrderingFirstInvoked, isSetOrderingLastInvoked, NDoit, numberOfProcesses, SizeOfProcVectorArray, theAttrVector, theProcessList, and theProcVector.

◆ G4ProcessManager() [3/3]

G4ProcessManager::G4ProcessManager ( )

delete

◆ ~G4ProcessManager()

G4ProcessManager::~G4ProcessManager ( )

Definition at line 159 of file G4ProcessManager.cc.

{
  for (G4int i=0; i<SizeOfProcVectorArray; ++i)
  {
    if (theProcVector[i])
    {
      theProcVector[i]->clear();
      delete theProcVector[i];
    }
  }
  theProcessList->clear();
  delete theProcessList;
 
  for (auto itr = theAttrVector->cbegin(); itr!= theAttrVector->cend(); ++itr)
  {
    delete (*itr);
  }
  theAttrVector->clear();
  delete theAttrVector;
 
  --counterOfObjects; 
 
  // delete messenger if this object is last one
  if ( counterOfObjects == 0 )
  {
    delete fProcessManagerMessenger;
    fProcessManagerMessenger = nullptr;
#ifdef G4VERBOSE
    if (GetVerboseLevel() > 1)
    {
      G4cout << "G4ProcessManagerMessenger is deleted" << G4endl;
    } 
#endif
  }
}

References G4ProcessVector::clear(), counterOfObjects, fProcessManagerMessenger, G4cout, G4endl, GetVerboseLevel(), SizeOfProcVectorArray, theAttrVector, theProcessList, and theProcVector.

Member Function Documentation

◆ ActivateProcess()

G4VProcess * G4ProcessManager::ActivateProcess ( G4int index )

private

Definition at line 985 of file G4ProcessManager.cc.

{
  G4ApplicationState currentState 
   = G4StateManager::GetStateManager()->GetCurrentState();
  if ( (currentState == G4State_PreInit) || (currentState == G4State_Init) )
  {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>1)
    {
      G4cout << "G4ProcessManager::ActivateProcess() is not valid in ";
      if (currentState == G4State_PreInit )
      {
        G4cout << "PreInit ";
      }
      else  if (currentState == G4State_Init )
      {
        G4cout << "Init ";
      } 
      G4cout << "state !" << G4endl;
    }
#endif
   return nullptr;
  }
 
  //find the process attribute
  G4ProcessAttribute* pAttr = GetAttribute(index);
  if (pAttr == nullptr) return nullptr;
 
  // remove process
  G4VProcess* pProcess = (*theProcessList)[index];
 
  if (!pAttr->isActive)
  {
    // remove process from vectors if the process is active
    for (G4int i=0; i<SizeOfProcVectorArray; ++i)
    {
      G4ProcessVector* pVector = theProcVector[i];
      G4int idx = pAttr->idxProcVector[i];
      if (idx<0)
      {
        // corresponding DoIt is not active  
      }
      else if ((idx >= 0) && (idx < G4int(pVector->entries())))
      {
        // check pointer and set
        if ((*pVector)[idx] == nullptr)
        {
          (*pVector)[idx] = pProcess;
        }
        else
        {
          G4String anErrorMessage("Bad ProcessList: Bad index in attribute");
          anErrorMessage += "for particle[" + theParticleType->GetParticleName() + "] ";
          anErrorMessage += "process[" + pProcess->GetProcessName() + "]  " ;
          G4Exception("G4ProcessManager::ActivateProcess()", "ProcMan012",
                      FatalException, anErrorMessage);
          return nullptr;
        }    
      }
      else
      {
        // idx is out of range
        G4String anErrorMessage("bad ProcessList: Index is out of range");
        anErrorMessage += "for particle["
                          + theParticleType->GetParticleName() + "] ";
        anErrorMessage += "process[" + pProcess->GetProcessName() + "]  " ;
        G4Exception("G4ProcessManager::ActivateProcess()", "ProcMan012",
                    FatalException, anErrorMessage); 
         return nullptr;
      }
    } 
    pAttr->isActive = true;
  }
  return pProcess;
} 

References G4ProcessVector::entries(), FatalException, G4cout, G4endl, G4Exception(), G4State_Init, G4State_PreInit, GetAttribute(), G4StateManager::GetCurrentState(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4StateManager::GetStateManager(), GetVerboseLevel(), G4ProcessAttribute::idxProcVector, G4ProcessAttribute::isActive, SizeOfProcVectorArray, theParticleType, and theProcVector.

Referenced by RemoveProcess(), and SetProcessActivation().

◆ AddContinuousProcess()

G4int G4ProcessManager::AddContinuousProcess	(	G4VProcess *	aProcess,
		G4int	ord = `ordDefault`
	)

inline

Referenced by G4ErrorPhysicsList::ConstructEM(), and export_G4ProcessManager().

◆ AddDiscreteProcess()

G4int G4ProcessManager::AddDiscreteProcess	(	G4VProcess *	aProcess,
		G4int	ord = `ordDefault`
	)

inline

Referenced by G4EmModelActivator::ActivateMicroElec(), G4IonQMDPhysics::AddProcess(), G4IonINCLXXPhysics::AddProcess(), G4IonPhysics::AddProcess(), G4IonPhysicsXS::AddProcess(), G4IonPhysicsPHP::AddProcess(), LBE::AddTransportation(), G4BertiniElectroNuclearBuilder::Build(), G4TritonBuilder::Build(), G4AlphaBuilder::Build(), G4AntiBarionBuilder::Build(), G4DeuteronBuilder::Build(), G4He3Builder::Build(), G4HyperonBuilder::Build(), G4KaonBuilder::Build(), G4NeutronBuilder::Build(), G4PiKBuilder::Build(), G4PionBuilder::Build(), G4ProtonBuilder::Build(), G4ErrorPhysicsList::ConstructEM(), LBE::ConstructEM(), LBE::ConstructHad(), LBE::ConstructOp(), PhysListEmStandard::ConstructProcess(), G4StepLimiterPhysics::ConstructProcess(), G4EmDNAPhysicsActivator::ConstructProcess(), G4OpticalPhysics::ConstructProcess(), G4ChargeExchangePhysics::ConstructProcess(), G4IonElasticPhysics::ConstructProcess(), export_G4ProcessManager(), G4EmModelActivator::FindOrAddProcess(), G4ErrorTrackLengthTarget::G4ErrorTrackLengthTarget(), and G4RunManagerKernel::SetScoreSplitter().

◆ AddProcess()

G4int G4ProcessManager::AddProcess	(	G4VProcess *	aProcess,
		G4int	ordAtRestDoIt = `ordInActive`,
		G4int	ordAlongSteptDoIt = `ordInActive`,
		G4int	ordPostStepDoIt = `ordInActive`
	)

Definition at line 405 of file G4ProcessManager.cc.

{
  // check the process is applicable to this particle type
  if (  !aProcess->IsApplicable(*theParticleType) )
  {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>1)
    {
      G4cout << "G4ProcessManager::AddProcess()" << G4endl;
      G4cout << "This process is not applicable to this particle" << G4endl;
    }
#endif
    return -1;
  }
 
#ifdef G4VERBOSE
  if (GetVerboseLevel()>2)
  {
    G4cout << "G4ProcessManager::AddProcess()" << G4endl;
  }
#endif
 
  // add aProcess and this ProcessManager into ProcesssTable
  G4ProcessTable* theProcessTable = G4ProcessTable::GetProcessTable();
  theProcessTable->Insert(aProcess, this);
 
  // add aProcess to process List
  theProcessList->insert(aProcess);  
  G4int idx = (theProcessList->entries()) - 1;
 
  // check size of the ProcessVector[0]
  if (numberOfProcesses != idx)
  {
    theProcessList->removeLast();
    G4String anErrorMessage("Inconsistent process List size for ");
    anErrorMessage += "process[" + aProcess->GetProcessName() + "]";
    anErrorMessage += " particle[" + theParticleType->GetParticleName() + "]";
    G4Exception("G4ProcessManager::AddProcess()", "ProcMan012",
                FatalException, anErrorMessage);
    return -1;
  }
 
  // create ProcessAttribute
  G4ProcessAttribute* pAttr = new G4ProcessAttribute(aProcess);
  pAttr->idxProcessList = idx;
 
  // check if ordering parameter is non-zero
  if (ordAtRestDoIt==0)    ordAtRestDoIt    = 1;
  if (ordAlongStepDoIt==0) ordAlongStepDoIt = 1;
  if (ordPostStepDoIt==0)  ordPostStepDoIt  = 1;
 
  // ordering parameter
  pAttr->ordProcVector[0] = ordAtRestDoIt;
  pAttr->ordProcVector[1] = ordAtRestDoIt;
  pAttr->ordProcVector[2] = ordAlongStepDoIt;
  pAttr->ordProcVector[3] = ordAlongStepDoIt;
  pAttr->ordProcVector[4] = ordPostStepDoIt;
  pAttr->ordProcVector[5] = ordPostStepDoIt;
 
  // add aProccess in Process vectors
  for (G4int ivec=1; ivec<SizeOfProcVectorArray; ivec+=2)
  {
    if (pAttr->ordProcVector[ivec] < 0 )
    {
      // DoIt is inactive if ordering parameter is negative
      pAttr->idxProcVector[ivec] = -1;
    }
    else
    {
      // add aProcess in ordering of ordProcVector
      // G4ProcessVector* pVector = theProcVector[ivec];
      // find insert position
      G4int ip = FindInsertPosition(pAttr->ordProcVector[ivec], ivec);
      // insert 
      InsertAt(ip, aProcess, ivec);
      // set index in Process Attribute
      pAttr->idxProcVector[ivec] = ip;
 
#ifdef G4VERBOSE
      if (verboseLevel>2)
      {
        G4cout << "G4ProcessManager::AddProcess()" << G4endl;
        G4cout << aProcess->GetProcessName() << " is inserted at "<< ip;
        G4cout << " in ProcessVetor[" << ivec<< "]";
        G4cout << " with Ordering parameter = " ;
        G4cout <<  pAttr->ordProcVector[ivec]  << G4endl;
      }
#endif
    }
  }
 
  // add ProcessAttribute to ProcessAttrVector
  theAttrVector->push_back(pAttr);
 
  numberOfProcesses += 1;
 
  // check consistencies between ordering parameters and process 
  CheckOrderingParameters(aProcess);
 
  CreateGPILvectors();
 
  // inform process manager pointer to the process 
  aProcess->SetProcessManager(this);
 
  return idx;
}

References CheckOrderingParameters(), CreateGPILvectors(), G4ProcessVector::entries(), FatalException, FindInsertPosition(), G4cout, G4endl, G4Exception(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4ProcessTable::GetProcessTable(), GetVerboseLevel(), G4ProcessAttribute::idxProcessList, G4ProcessAttribute::idxProcVector, G4ProcessVector::insert(), G4ProcessTable::Insert(), InsertAt(), G4VProcess::IsApplicable(), numberOfProcesses, G4ProcessAttribute::ordProcVector, G4ProcessVector::removeLast(), G4VProcess::SetProcessManager(), SizeOfProcVectorArray, theAttrVector, theParticleType, theProcessList, and verboseLevel.

Referenced by G4FastSimulationHelper::ActivateFastSimulation(), G4BiasingHelper::ActivateNonPhysicsBiasing(), G4BiasingHelper::ActivatePhysicsBiasing(), G4BiasingHelper::AddLimiterProcess(), G4ProcessPlacer::AddProcessAs(), G4PhysicsListHelper::AddTransportation(), LBE::ConstructEM(), LBE::ConstructGeneral(), LBE::ConstructOp(), PhysListEmStandard::ConstructProcess(), G4ErrorPhysicsList::ConstructProcess(), G4ParallelWorldPhysics::ConstructProcess(), G4SpinDecayPhysics::ConstructProcess(), G4OpticalPhysics::ConstructProcess(), G4RunManager::ConstructScoringWorlds(), G4WorkerRunManager::ConstructScoringWorlds(), export_G4ProcessManager(), and G4PhysicsListHelper::RegisterProcess().

◆ AddRestProcess()

G4int G4ProcessManager::AddRestProcess	(	G4VProcess *	aProcess,
		G4int	ord = `ordDefault`
	)

inline

Referenced by G4EmDNAChemistry::ConstructProcess(), G4EmDNAChemistry_option1::ConstructProcess(), G4EmDNAChemistry_option3::ConstructProcess(), G4StoppingPhysics::ConstructProcess(), G4StoppingPhysicsFritiofWithBinaryCascade::ConstructProcess(), and export_G4ProcessManager().

◆ CheckOrderingParameters()

void G4ProcessManager::CheckOrderingParameters ( G4VProcess * aProcess ) const

private

Definition at line 1236 of file G4ProcessManager.cc.

{
  if (aProcess == nullptr) return;
  G4ProcessAttribute* pAttr = GetAttribute(aProcess);
  if (pAttr == nullptr)
  {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0)
    {
      G4cout << "G4ProcessManager::CheckOrderingParameters()" << G4endl;
      G4cout << " process " << aProcess->GetProcessName() 
             << " has no attribute" << G4endl;
    }
#endif
    return;
  }
 
  // check consistencies between ordering parameters and 
  // validity of DoIt of the Process  
  G4bool isOK =true;
  if ( (pAttr->ordProcVector[0]>=0) && (!aProcess->isAtRestDoItIsEnabled()) )
  {
 #ifdef G4VERBOSE
    if (GetVerboseLevel()>0)
    {
      G4cerr << "G4ProcessManager::CheckOrderingParameters()" << G4endl;
      G4cerr << "You cannot set ordering parameter ["
             << pAttr->ordProcVector[0]
             << "] for AtRest DoIt  to the process "
             << aProcess->GetProcessName() << G4endl;
    }
#endif
    isOK = false;
  }
 
  if ((pAttr->ordProcVector[2]>=0) && (!aProcess->isAlongStepDoItIsEnabled()))
  {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0)
    {
      G4cerr << "G4ProcessManager::CheckOrderingParameters()" << G4endl;
      G4cerr << "You cannot set ordering parameter ["
             <<  pAttr->ordProcVector[2]
             << "] for AlongStep DoIt to the process "
             << aProcess->GetProcessName() << G4endl;
 
    }
#endif
    isOK = false;
  } 
 
  if ((pAttr->ordProcVector[4]>=0) && (!aProcess->isPostStepDoItIsEnabled()))
  {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0)
    {
      G4cerr << "G4ProcessManager::CheckOrderingParameters()" << G4endl;
      G4cerr << "You cannot set ordering parameter [" 
             << pAttr->ordProcVector[4] 
             << "] for PostStep DoIt to the process"
             << aProcess->GetProcessName() << G4endl;
    }
#endif
    isOK = false;
  } 
 
  if (!isOK)
  {
    G4String msg;
    msg = "Invalid ordering parameters are set for  ";
    msg +=  aProcess->GetProcessName();
    G4Exception( "G4ProcessManager::CheckOrderingParameters()",
                 "ProcMan013", FatalException, msg);
  }
  
  return;
}

References FatalException, G4cerr, G4cout, G4endl, G4Exception(), GetAttribute(), G4VProcess::GetProcessName(), GetVerboseLevel(), G4VProcess::isAlongStepDoItIsEnabled(), G4VProcess::isAtRestDoItIsEnabled(), G4VProcess::isPostStepDoItIsEnabled(), and G4ProcessAttribute::ordProcVector.

Referenced by AddProcess(), SetProcessOrdering(), SetProcessOrderingToFirst(), and SetProcessOrderingToSecond().

◆ CreateGPILvectors()

void G4ProcessManager::CreateGPILvectors ( )

private

Definition at line 1135 of file G4ProcessManager.cc.

{
  // Create GetPhysicalInteractionLength process vectors just as the inverse
  // order of DoIt() process vector
 
  for(std::size_t k=0; k<theProcessList->entries(); ++k)
  {
    GetAttribute((*theProcessList)[k])->idxProcVector[0]=-1;
    GetAttribute((*theProcessList)[k])->idxProcVector[2]=-1;
    GetAttribute((*theProcessList)[k])->idxProcVector[4]=-1;
  }
 
  for(G4int i=0; i<SizeOfProcVectorArray; i += 2)
  {
    G4ProcessVector* procGPIL = theProcVector[i];
    G4ProcessVector* procDoIt = theProcVector[i+1];
    G4int nproc = procDoIt->entries();
    procGPIL->clear();
    for(G4int j=nproc-1;j>=0;--j)
    {
      G4VProcess* aProc = (*procDoIt)[j];
      procGPIL->insert(aProc);
      GetAttribute(aProc)->idxProcVector[i] = procGPIL->entries()-1;
    }
  }
}

References G4ProcessVector::clear(), G4ProcessVector::entries(), GetAttribute(), G4ProcessAttribute::idxProcVector, G4ProcessVector::insert(), SizeOfProcVectorArray, theProcessList, and theProcVector.

Referenced by AddProcess(), RemoveProcess(), SetProcessOrdering(), SetProcessOrderingToFirst(), and SetProcessOrderingToSecond().

◆ DumpInfo()

void G4ProcessManager::DumpInfo ( )

Definition at line 1074 of file G4ProcessManager.cc.

{ 
  // Dump Information
 
  // particle type
  G4cout << "G4ProcessManager: particle[" 
         << theParticleType->GetParticleName() << "]"
         << G4endl;
 
  // loop over all processes
  for (std::size_t idx=0; idx < theProcessList->entries(); ++idx)
  {
    // process name/type
    G4cout << "[" << idx << "]";
    G4cout << "=== process[" << ((*theProcessList)(idx))->GetProcessName()
           << " :"; 
    G4cout << G4VProcess::GetProcessTypeName( ((*theProcessList)(idx))->GetProcessType() )
           << "]";
 
    // process attribute    
    G4ProcessAttribute* pAttr = (*theAttrVector)[idx];
    // status
    if ( pAttr-> isActive )
    {
      G4cout << " Active ";
    }
    else
    {
      G4cout << " InActive ";
    }
    G4cout << G4endl;
 
#ifdef G4VERBOSE
    if (verboseLevel>0)
    {
      // order parameter    
      G4cout << "  Ordering::     ";
      G4cout << "        AtRest             AlongStep          PostStep   ";
      G4cout << G4endl;
      G4cout << "                 ";
      G4cout << "   GetPIL/    DoIt    GetPIL/    DoIt    GetPIL/    DoIt ";
      G4cout << G4endl;
      G4cout << "  Ordering::      " << G4endl;
      G4cout << "  index           ";
      for (G4int idx2 = 0; idx2 <6 ; ++idx2)
      {
        G4cout << std::setw(8) << pAttr->idxProcVector[idx2] << ":";
      }
      G4cout << G4endl;
      G4cout << "  parameter       ";
      for (G4int idx3 = 0; idx3 <6 ; ++idx3)
      {
        G4cout << std::setw(8) << pAttr->ordProcVector[idx3] << ":";
      }
      G4cout << G4endl;
    }
#endif 
  }
}

References G4ProcessVector::entries(), G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessTypeName(), G4ProcessAttribute::idxProcVector, G4ProcessAttribute::ordProcVector, theParticleType, theProcessList, and verboseLevel.

Referenced by G4ProcessTable::DumpInfo(), export_G4ProcessManager(), and G4ProcessManagerMessenger::SetNewValue().

◆ EndTracking()

void G4ProcessManager::EndTracking ( )

Definition at line 1174 of file G4ProcessManager.cc.

{
  for (std::size_t idx = 0; idx<theProcessList->entries(); ++idx)
  {
    if (GetAttribute(idx)->isActive)
      ((*theProcessList)[idx])->EndTracking();
  }
  duringTracking = false;
}

References duringTracking, EndTracking(), G4ProcessVector::entries(), GetAttribute(), and theProcessList.

Referenced by EndTracking(), G4TrackingManager::ProcessOneTrack(), and G4ErrorPropagator::Propagate().

◆ FindInsertPosition()

G4int G4ProcessManager::FindInsertPosition	(	G4int	ord,
		G4int	ivec
	)

private

Definition at line 383 of file G4ProcessManager.cc.

{
  G4ProcessVector* pVector = theProcVector[ivec];
  G4int ip =  pVector->entries();
  G4int tmp = INT_MAX;
  if (ord == ordLast) return ip;
 
  // find insert position
  for (G4int iproc=0; iproc<numberOfProcesses; ++iproc)
  {
    G4ProcessAttribute* aAttr = (*theAttrVector)[iproc];
    if ( (aAttr->ordProcVector[ivec] > ord )
      && (tmp > aAttr->ordProcVector[ivec]))
    {
      tmp = aAttr->ordProcVector[ivec] ;
      if (ip > aAttr->idxProcVector[ivec]) ip = aAttr->idxProcVector[ivec];
    }
  }
  return ip;
}

References G4ProcessVector::entries(), G4ProcessAttribute::idxProcVector, INT_MAX, numberOfProcesses, ordLast, G4ProcessAttribute::ordProcVector, and theProcVector.

Referenced by AddProcess(), and SetProcessOrdering().

◆ GetAlongStepIndex()

G4int G4ProcessManager::GetAlongStepIndex	(	G4VProcess *	aProcess,
		G4ProcessVectorTypeIndex	typ = `typeGPIL`
	)		const

inline

Referenced by export_G4ProcessManager().

◆ GetAlongStepProcessVector()

G4ProcessVector * G4ProcessManager::GetAlongStepProcessVector ( G4ProcessVectorTypeIndex typ = typeGPIL ) const

inline

Referenced by G4RunManagerKernel::ConfirmCoupledTransportation(), G4SteppingManager::GetProcessNumber(), G4VEnergyLossProcess::PreparePhysicsTable(), G4ProcessPlacer::PrintAlongStepDoItVec(), G4ProcessPlacer::PrintAlongStepGPILVec(), and G4ITStepProcessor::SetupGeneralProcessInfo().

◆ GetAtRestIndex()

G4int G4ProcessManager::GetAtRestIndex	(	G4VProcess *	aProcess,
		G4ProcessVectorTypeIndex	typ = `typeGPIL`
	)		const

inline

Referenced by export_G4ProcessManager().

◆ GetAtRestProcessVector()

G4ProcessVector * G4ProcessManager::GetAtRestProcessVector ( G4ProcessVectorTypeIndex typ = typeGPIL ) const

inline

Referenced by G4hImpactIonisation::AlongStepDoIt(), G4ITStepProcessor::DealWithSecondaries(), G4HadronicProcess::FillResult(), G4MuonicAtomDecay::FillResult(), G4SteppingManager::GetProcessNumber(), G4SteppingManager::InvokeAlongStepDoItProcs(), G4SteppingManager::InvokeAtRestDoItProcs(), G4SteppingManager::InvokePSDIP(), G4VEmProcess::PostStepDoIt(), G4VEnergyLossProcess::PostStepDoIt(), G4NeutrinoElectronProcess::PostStepDoIt(), G4ElNeutrinoNucleusProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), G4MuNeutrinoNucleusProcess::PostStepDoIt(), and G4ITStepProcessor::SetupGeneralProcessInfo().

◆ GetAttribute() [1/2]

G4ProcessAttribute * G4ProcessManager::GetAttribute ( G4int index ) const

private

Definition at line 236 of file G4ProcessManager.cc.

{
  // check index range
  if ((index<0) || (index>=numberOfProcesses))
  {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0)
    {
      G4cout << "G4ProcessManager::GetAttribute():";
      G4cout << " particle[" << theParticleType->GetParticleName() << "]";
      G4cout << G4endl;
      G4cout << "  index out of range " << G4endl;
      G4cout << "  #processes[" << numberOfProcesses << "]"; 
      G4cout << "  index [" << index << "]" << G4endl;
    }
#endif
    return nullptr;
  } 
 
  // check process pointer is not null
  G4VProcess* aProcess = (*theProcessList)[index];
  if (aProcess == nullptr)
  {
    G4String aErrorMessage("Bad ProcessList: Null Pointer for ");
    aErrorMessage += theParticleType->GetParticleName() ;
    G4Exception("G4ProcessManager::GetAttribute()","ProcMan012",
                FatalException, aErrorMessage);
    return nullptr;
  }    
 
  // find the process attribute
  if ( ((*theAttrVector)[index])->idxProcessList == index )
  {
    return  (*theAttrVector)[index];
  }
  else
  { 
    // !! Error !!
    // attribute vector index is inconsistent with process List index
#ifdef G4VERBOSE
   if (GetVerboseLevel()>0)
   { 
      G4cout << "G4ProcessManager::GetAttribute():";
      G4cout << " particle[" << theParticleType->GetParticleName() << "]"
             << G4endl;
      G4cout << "Warning: attribute vector index is inconsistent"
             << " with process List index" 
             << G4endl; 
   }
#endif
   // re-ordering attribute vector 
    G4ProcessAttribute* pAttr = nullptr;
    for (auto itr = theAttrVector->cbegin(); itr!= theAttrVector->cend(); ++itr)
    {
      if ( (*itr)->idxProcessList == index)
      {
        pAttr = (*itr);
        break;
      }
    }      
    return pAttr;
  } 
}

References FatalException, G4cout, G4endl, G4Exception(), G4ParticleDefinition::GetParticleName(), GetVerboseLevel(), numberOfProcesses, theAttrVector, and theParticleType.

Referenced by ActivateProcess(), CheckOrderingParameters(), CreateGPILvectors(), EndTracking(), GetAttribute(), GetProcessOrdering(), GetProcessVectorIndex(), InActivateProcess(), RemoveProcess(), SetProcessOrdering(), SetProcessOrderingToFirst(), SetProcessOrderingToSecond(), and StartTracking().

◆ GetAttribute() [2/2]

G4ProcessAttribute * G4ProcessManager::GetAttribute ( G4VProcess * aProcess ) const

private

Definition at line 301 of file G4ProcessManager.cc.

{
  return GetAttribute( GetProcessIndex(aProcess));
}

References GetAttribute(), and GetProcessIndex().

◆ GetParticleType()

G4ParticleDefinition * G4ProcessManager::GetParticleType ( ) const

inline

Referenced by G4BiasingHelper::AddLimiterProcess(), G4ProcessTable::DumpInfo(), export_G4ProcessManager(), G4ProcessTable::FindProcess(), G4ProcessTable::Insert(), G4ProcessTable::Remove(), G4ProcessTable::SetProcessActivation(), and G4ParallelGeometriesLimiterProcess::SetProcessManager().

◆ GetPostStepIndex()

G4int G4ProcessManager::GetPostStepIndex	(	G4VProcess *	aProcess,
		G4ProcessVectorTypeIndex	typ = `typeGPIL`
	)		const

inline

Referenced by export_G4ProcessManager().

◆ GetPostStepProcessVector()

G4ProcessVector * G4ProcessManager::GetPostStepProcessVector ( G4ProcessVectorTypeIndex typ = typeGPIL ) const

inline

Referenced by G4SteppingManager::GetProcessNumber(), G4BiasingProcessInterface::IsFirstPostStepDoItInterface(), G4BiasingProcessInterface::IsFirstPostStepGPILInterface(), G4BiasingProcessInterface::IsLastPostStepDoItInterface(), G4BiasingProcessInterface::IsLastPostStepGPILInterface(), G4ProcessPlacer::PrintPostStepDoItVec(), G4ProcessPlacer::PrintPostStepGPILVec(), G4BiasingProcessInterface::ReorderBiasingVectorAsGPIL(), and G4ITStepProcessor::SetupGeneralProcessInfo().

◆ GetProcess()

G4VProcess * G4ProcessManager::GetProcess ( const G4String & processName ) const

Definition at line 1185 of file G4ProcessManager.cc.

{
  for (G4int k=0; k<numberOfProcesses; ++k)
  {
    G4VProcess* process = (*theProcessList)[k];
    if (process->GetProcessName() == processName) return process;
  }
  return nullptr;
}

References G4VProcess::GetProcessName(), and numberOfProcesses.

Referenced by G4ProcessTable::FindProcess().

◆ GetProcessActivation() [1/2]

G4bool G4ProcessManager::GetProcessActivation ( G4int index ) const

Definition at line 1216 of file G4ProcessManager.cc.

{
  if (index <0)
  {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0)
    {
      G4cout << "G4ProcessManager::GetProcessActivation  ";
      G4cout << " process (or its index) not found ";
    }
#endif
    return false;
  }
  // process attribute    
  G4ProcessAttribute* pAttr = (*theAttrVector)[index];
  // status
  return pAttr->isActive;
}

References G4cout, GetVerboseLevel(), and G4ProcessAttribute::isActive.

◆ GetProcessActivation() [2/2]

G4bool G4ProcessManager::GetProcessActivation ( G4VProcess * aProcess ) const

Definition at line 1210 of file G4ProcessManager.cc.

{
  return GetProcessActivation(GetProcessIndex(aProcess));
} 

References GetProcessActivation(), and GetProcessIndex().

Referenced by G4EmCalculator::ActiveForParticle(), and GetProcessActivation().

◆ GetProcessIndex()

G4int G4ProcessManager::GetProcessIndex ( G4VProcess * ) const

inline

Referenced by export_G4ProcessManager(), GetAttribute(), GetProcessActivation(), GetProcessVectorIndex(), RemoveProcess(), G4ProcessTable::SetProcessActivation(), and SetProcessActivation().

◆ GetProcessList()

G4ProcessVector * G4ProcessManager::GetProcessList ( ) const

inline

Referenced by G4BiasingHelper::ActivatePhysicsBiasing(), G4EmCalculator::ActiveForParticle(), G4ITStepProcessor::ActiveOnlyITProcess(), G4BiasingHelper::AddLimiterProcess(), G4ProcessPlacer::AddProcessAs(), RunAction::BeginOfRunAction(), G4hImpactIonisation::BuildPhysicsTable(), G4VUserChemistryList::BuildPhysicsTable(), G4VUserPhysicsList::BuildPhysicsTable(), G4LossTableManager::BuildTables(), G4PhysicsListHelper::CheckParticleList(), G4FastSimulationPhysics::ConstructProcess(), G4GenericBiasingPhysics::ConstructProcess(), G4TheRayTracer::CreateBitMap(), G4EmDNAPhysicsActivator::DeactivateNuclearStopping(), G4LossTableManager::DumpHtml(), G4PhysListUtil::FindCaptureProcess(), G4PhysListUtil::FindElasticProcess(), G4PhysListUtil::FindFissionProcess(), G4PhysListUtil::FindInelasticProcess(), G4EmModelActivator::FindOrAddProcess(), G4EmCalculator::FindProcess(), G4ErrorTrackLengthTarget::G4ErrorTrackLengthTarget(), G4EmDNAPhysicsActivator::HasMsc(), G4EmModelActivator::HasMsc(), G4VUserPhysicsList::PreparePhysicsTable(), G4PhysicsListHelper::RegisterProcess(), G4ProcessManagerMessenger::SetCurrentParticle(), G4EmConfigurator::SetModelForRegion(), G4ProcessTable::SetProcessActivation(), G4RunManagerKernel::SetupShadowProcess(), G4WorkerRunManagerKernel::SetupShadowProcess(), G4WorkerTaskRunManagerKernel::SetupShadowProcess(), and G4GlobalFastSimulationManager::ShowSetup().

◆ GetProcessListLength()

G4int G4ProcessManager::GetProcessListLength ( ) const

inline

Referenced by G4EmDNAPhysicsActivator::DeactivateNuclearStopping(), G4LossTableManager::DumpHtml(), export_G4ProcessManager(), G4EmModelActivator::FindOrAddProcess(), G4EmDNAPhysicsActivator::HasMsc(), G4EmModelActivator::HasMsc(), and G4EmConfigurator::SetModelForRegion().

◆ GetProcessOrdering()

G4int G4ProcessManager::GetProcessOrdering	(	G4VProcess *	aProcess,
		G4ProcessVectorDoItIndex	idDoIt
	)

Definition at line 600 of file G4ProcessManager.cc.

{
  // get Process Vector Id
  G4int ivec = GetProcessVectorId(idDoIt, typeDoIt);
  if (ivec >=0 )
  {
    // get attribute
    G4ProcessAttribute* pAttr = GetAttribute(aProcess); 
    if (pAttr != nullptr)
    { 
      return pAttr->ordProcVector[ivec];
    }
  }
  return -1;
}

References GetAttribute(), GetProcessVectorId(), G4ProcessAttribute::ordProcVector, and typeDoIt.

Referenced by G4BiasingHelper::ActivatePhysicsBiasing(), and export_G4ProcessManager().

◆ GetProcessVector()

G4ProcessVector * G4ProcessManager::GetProcessVector	(	G4ProcessVectorDoItIndex	idx,
		G4ProcessVectorTypeIndex	typ = `typeGPIL`
	)		const

inline

◆ GetProcessVectorId()

G4int G4ProcessManager::GetProcessVectorId	(	G4ProcessVectorDoItIndex	idx,
		G4ProcessVectorTypeIndex	typ = `typeGPIL`
	)		const

inlineprivate

Referenced by GetProcessOrdering(), GetProcessVectorIndex(), SetProcessOrdering(), SetProcessOrderingToFirst(), and SetProcessOrderingToSecond().

◆ GetProcessVectorIndex()

G4int G4ProcessManager::GetProcessVectorIndex	(	G4VProcess *	aProcess,
		G4ProcessVectorDoItIndex	idx,
		G4ProcessVectorTypeIndex	typ = `typeGPIL`
	)		const

Definition at line 196 of file G4ProcessManager.cc.

{
  G4int idxVect = -1;
  G4int idxProc = GetProcessIndex(aProcess); 
  G4int ivec = GetProcessVectorId(idx, typ);
 
  if ( ( idxProc >=0) && (ivec >=0) )
  {
    idxVect = GetAttribute(idxProc)->idxProcVector[ivec];
  }
  else
  {
#ifdef G4VERBOSE
    if (verboseLevel>0)
    {
      G4cout << " G4ProcessManager::GetProcessVectorIndex:";
      G4cout << "particle[" << theParticleType->GetParticleName() << "] " ;
      G4cout <<  "process[" << aProcess->GetProcessName() << "]" ;
      G4cout << G4endl;
      if (idxProc <0)
      { 
        G4cout << " is not registered yet ";
      }
      if (ivec <0)
      {
        G4cout << " illegal DoIt Index [= " << G4int(idx) << ","
                                            << G4int(typ) << "]";
      }
      G4cout << G4endl;
    }
#endif
  }
  return idxVect;
}

References G4cout, G4endl, GetAttribute(), G4ParticleDefinition::GetParticleName(), GetProcessIndex(), G4VProcess::GetProcessName(), GetProcessVectorId(), G4ProcessAttribute::idxProcVector, theParticleType, pyG4ProcessManager::typ, and verboseLevel.

Referenced by export_G4ProcessManager().

◆ GetVerboseLevel()

G4int G4ProcessManager::GetVerboseLevel ( ) const

inline

Referenced by ActivateProcess(), AddProcess(), CheckOrderingParameters(), G4ProcessTable::DumpInfo(), export_G4ProcessManager(), G4ProcessManager(), GetAttribute(), G4ProcessManagerMessenger::GetCurrentValue(), GetProcessActivation(), InActivateProcess(), InsertAt(), RemoveAt(), SetProcessOrdering(), SetProcessOrderingToSecond(), and ~G4ProcessManager().

◆ InActivateProcess()

G4VProcess * G4ProcessManager::InActivateProcess ( G4int index )

private

Definition at line 906 of file G4ProcessManager.cc.

{
  G4ApplicationState currentState 
   = G4StateManager::GetStateManager()->GetCurrentState();
  if ( (currentState == G4State_PreInit) || (currentState == G4State_Init) )
  {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>1)
    {
      G4cout << "G4ProcessManager::InActivateProcess is not valid in ";
      if (currentState == G4State_PreInit )
      {
        G4cout << "PreInit ";
      }
      else if  (currentState == G4State_Init )
      {
        G4cout << "Init ";
      } 
      G4cout << "state !" << G4endl;
    }
#endif
   return nullptr;
  }
 
  // find the process attribute
  G4ProcessAttribute* pAttr = GetAttribute(index);
  if (pAttr == nullptr) return nullptr;
 
  // remove process
  G4VProcess* pProcess = (*theProcessList)[index];
 
  const G4String aErrorMessage("G4ProcessManager::InactivateProcess() - ");
 
  if (pAttr->isActive)
  {
    // remove process from vectors if the process is active
    for (G4int i=0; i<SizeOfProcVectorArray; ++i)
    {
      G4ProcessVector* pVector = theProcVector[i];
      G4int idx = pAttr->idxProcVector[i];
 
      if (idx<0)
      {
        // corresponding DoIt is not active  
      }
      else if ((idx >= 0) && (idx < G4int(pVector->entries())))
      {
        //check pointer and set to 0
        if ((*pVector)[idx]== pProcess)
        {
          (*pVector)[idx]= nullptr;
        }
        else
        {
          G4String anErrorMessage("Bad ProcessList: Bad index in attribute");
          anErrorMessage += "for particle[" + theParticleType->GetParticleName() + "] ";
          anErrorMessage += "process[" + pProcess->GetProcessName() + "]  " ;
          G4Exception( "G4ProcessManager::InactivateProcess()", "ProcMan012",
                       FatalException, anErrorMessage); 
          return nullptr;
        }    
      }
      else
      {
        // idx is out of range
        G4String anErrorMessage("Bad ProcessList:  Index is out of range");
        anErrorMessage += "for particle[" + theParticleType->GetParticleName() + "] ";
        anErrorMessage += "process[" + pProcess->GetProcessName() + "]  " ;
        G4Exception( "G4ProcessManager::InactivateProcess()", "ProcMan012",
                     FatalException, anErrorMessage); 
        return nullptr;
      }
    } 
    pAttr->isActive = false;
  }
  return pProcess;
} 

References G4ProcessVector::entries(), FatalException, G4cout, G4endl, G4Exception(), G4State_Init, G4State_PreInit, GetAttribute(), G4StateManager::GetCurrentState(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4StateManager::GetStateManager(), GetVerboseLevel(), G4ProcessAttribute::idxProcVector, G4ProcessAttribute::isActive, SizeOfProcVectorArray, theParticleType, and theProcVector.

Referenced by SetProcessActivation().

◆ InsertAt()

G4int G4ProcessManager::InsertAt	(	G4int	position,
		G4VProcess *	process,
		G4int	ivec
	)

private

Definition at line 307 of file G4ProcessManager.cc.

{
  G4ProcessVector* pVector = theProcVector[ivec];
  // check position
  if ( (ip<0) || (ip > G4int(pVector->entries())) ) return -1;
  
  // insert in pVector
  pVector->insertAt(ip, process);
 
  // correct index in ProcessAttributes of processes
  for (G4int iproc=0; iproc<numberOfProcesses; ++iproc)
  {
    G4ProcessAttribute* aAttr = (*theAttrVector)[iproc];
    if (aAttr != nullptr)
    {
      if (aAttr->idxProcVector[ivec] >= ip)
      {
        aAttr->idxProcVector[ivec] += 1;
      }
    }
    else
    {
#ifdef G4VERBOSE
      if (GetVerboseLevel()>0)
      { 
        G4cout << " G4ProcessManager::InsertAt : No Process Attribute "
               << G4endl;
      }
#endif
    }
  }
  return ip;
}

References G4ProcessVector::entries(), G4cout, G4endl, GetVerboseLevel(), G4ProcessAttribute::idxProcVector, G4ProcessVector::insertAt(), numberOfProcesses, and theProcVector.

Referenced by AddProcess(), SetProcessOrdering(), SetProcessOrderingToFirst(), and SetProcessOrderingToSecond().

◆ operator!=()

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

Definition at line 1068 of file G4ProcessManager.cc.

{
  return (this != &right);
}

◆ operator=()

G4ProcessManager & G4ProcessManager::operator= ( const G4ProcessManager & )

delete

◆ operator==()

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

Definition at line 1062 of file G4ProcessManager.cc.

{
  return (this == &right);
}

◆ RemoveAt()

G4int G4ProcessManager::RemoveAt	(	G4int	position,
		G4VProcess *	process,
		G4int	ivec
	)

private

Definition at line 342 of file G4ProcessManager.cc.

{
  G4ProcessVector* pVector = theProcVector[ivec];
 
  // check position
  if ( (ip<0) || (ip >= G4int(pVector->entries())) ) return -1;
 
  // remove process
  pVector->removeAt(ip);
 
  // correct index
  for(G4int iproc=0; iproc<numberOfProcesses; ++iproc)
  {
    G4ProcessAttribute* aAttr = (*theAttrVector)[iproc];
    if (aAttr != nullptr)
    {
      if (ip < aAttr->idxProcVector[ivec])
      {
        aAttr->idxProcVector[ivec] -=1;
      }
      else if (ip ==  aAttr->idxProcVector[ivec])
      {
        aAttr->idxProcVector[ivec] = -1;
        aAttr->ordProcVector[ivec] = ordInActive;
      }
    }
    else
    {
#ifdef G4VERBOSE
      if (GetVerboseLevel()>0)
      { 
        G4cout << " G4ProcessManager::RemoveAt(): No Process Attribute "
               << G4endl;
      }
#endif
    }
  } 
  return ip;
}

References G4ProcessVector::entries(), G4cout, G4endl, GetVerboseLevel(), G4ProcessAttribute::idxProcVector, numberOfProcesses, ordInActive, G4ProcessAttribute::ordProcVector, G4ProcessVector::removeAt(), and theProcVector.

Referenced by RemoveProcess(), SetProcessOrdering(), SetProcessOrderingToFirst(), and SetProcessOrderingToSecond().

◆ RemoveProcess() [1/2]

G4VProcess * G4ProcessManager::RemoveProcess ( G4int index )

Definition at line 518 of file G4ProcessManager.cc.

{
  //find the process attribute
  G4ProcessAttribute* pAttr = GetAttribute(index);
  if (pAttr == nullptr) return nullptr;
 
  // remove process
  G4VProcess* removedProcess = (*theProcessList)[index];
 
  if (!(pAttr->isActive)) { ActivateProcess(index);}
  // remove process from vectors if the process is active
  for (G4int ivec=0; ivec<SizeOfProcVectorArray; ++ivec)
  {
    G4ProcessVector* pVector = theProcVector[ivec];
    G4int idx = pAttr->idxProcVector[ivec];
    if ((idx >= 0) && (idx < G4int(pVector->entries())))
    {
      // remove
      if (RemoveAt(idx, removedProcess, ivec) <0)
      {
        G4String anErrorMessage("Bad index in attribute");
        anErrorMessage += "for particle["
                          + theParticleType->GetParticleName() + "] ";
        anErrorMessage += "process["
                          + removedProcess->GetProcessName() + "]  " ;
        G4Exception( "G4ProcessManager::RemoveProcess()","Fatal Error",
                     FatalException,anErrorMessage); 
        return nullptr;
      }    
    }
    else if (idx<0)
    {
      // corresponding DoIt is not active  
    } 
    else
    {
      // idx is out of range
      G4String anErrorMessage("Bad ProcessList: Index is out of range ");
      anErrorMessage += "for particle[" + theParticleType->GetParticleName() + "] ";
      anErrorMessage += "process[" + removedProcess->GetProcessName() + "]  " ;
      G4Exception( "G4ProcessManager::RemoveProcess()","ProcMan012",
                   FatalException,anErrorMessage); 
      return nullptr;
    }
  }
  pAttr->isActive = false;
  // remove from the process List and delete the attribute
  theProcessList->removeAt(index);
  for (auto itr = theAttrVector->cbegin(); itr!= theAttrVector->cend(); ++itr)
  {
    if ( (*itr) == pAttr)
    {
      theAttrVector->erase(itr);
      break;
    }
  }
  delete pAttr;
  --numberOfProcesses;
  
  // correct index
  for(G4int i=0; i<numberOfProcesses; ++i)
  {
    G4ProcessAttribute* aAttr = (*theAttrVector)[i];
    if (index < aAttr->idxProcessList) aAttr->idxProcessList -=1;
  }
 
  CreateGPILvectors();
 
  // remove aProcess from ProcesssTable
  G4ProcessTable* theProcessTable = G4ProcessTable::GetProcessTable();
  theProcessTable->Remove(removedProcess, this);
 
  return removedProcess;
} 

References ActivateProcess(), CreateGPILvectors(), G4ProcessVector::entries(), FatalException, G4Exception(), GetAttribute(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), G4ProcessTable::GetProcessTable(), G4ProcessAttribute::idxProcessList, G4ProcessAttribute::idxProcVector, G4ProcessAttribute::isActive, numberOfProcesses, G4ProcessTable::Remove(), G4ProcessVector::removeAt(), RemoveAt(), SizeOfProcVectorArray, theAttrVector, theParticleType, theProcessList, and theProcVector.

◆ RemoveProcess() [2/2]

G4VProcess * G4ProcessManager::RemoveProcess ( G4VProcess * aProcess )

Definition at line 594 of file G4ProcessManager.cc.

{
  return RemoveProcess(GetProcessIndex(aProcess));
} 

References GetProcessIndex(), and RemoveProcess().

Referenced by G4BiasingHelper::ActivatePhysicsBiasing(), G4SpinDecayPhysics::ConstructProcess(), G4ErrorTrackLengthTarget::G4ErrorTrackLengthTarget(), RemoveProcess(), and G4ProcessPlacer::RemoveProcess().

◆ SetIndexToProcessVector()

void G4ProcessManager::SetIndexToProcessVector ( G4int ivec )

private

◆ SetParticleType()

void G4ProcessManager::SetParticleType ( const G4ParticleDefinition * )

inline

Referenced by export_G4ProcessManager().

◆ SetProcessActivation() [1/2]

G4VProcess * G4ProcessManager::SetProcessActivation	(	G4int	index,
		G4bool	fActive
	)

Definition at line 1203 of file G4ProcessManager.cc.

{
  if (fActive) return ActivateProcess(index);
  else         return InActivateProcess(index);
}

References ActivateProcess(), and InActivateProcess().

◆ SetProcessActivation() [2/2]

G4VProcess * G4ProcessManager::SetProcessActivation	(	G4VProcess *	aProcess,
		G4bool	fActive
	)

Definition at line 1196 of file G4ProcessManager.cc.

{
  return SetProcessActivation(GetProcessIndex(aProcess), fActive);
} 

References GetProcessIndex(), and SetProcessActivation().

Referenced by G4ITStepProcessor::ActiveOnlyITProcess(), G4ProcessManagerMessenger::SetNewValue(), G4ProcessTable::SetProcessActivation(), and SetProcessActivation().

◆ SetProcessOrdering()

void G4ProcessManager::SetProcessOrdering	(	G4VProcess *	aProcess,
		G4ProcessVectorDoItIndex	idDoIt,
		G4int	ordDoIt = `ordDefault`
	)

Definition at line 620 of file G4ProcessManager.cc.

{
  const G4String aErrorMessage("G4ProcessManager::SetProcessOrdering() - ");
 
#ifdef G4VERBOSE
  if (GetVerboseLevel()>2)
  {
    G4cout << aErrorMessage ;
    G4cout << "particle[" + theParticleType->GetParticleName() +"] " ;
    G4cout <<"process[" + aProcess->GetProcessName() + "]"<<  G4endl;
  }
#endif
 
  // get Process Vector Id
  G4int ivec = GetProcessVectorId(idDoIt, typeDoIt);
  if (ivec <0 )
  {
#ifdef G4VERBOSE
    if (verboseLevel>0)
    {
      G4cout <<  aErrorMessage << G4endl;
      G4cout << "particle[" << theParticleType->GetParticleName()  << "] " ;
      G4cout << "process[" << aProcess->GetProcessName() << "]"<<  G4endl;
      G4cout << " illegal DoIt Index [= " << G4int(idDoIt) << "]";
      G4cout << G4endl;
    }
#endif
    return;
  }
 
  if (ordDoIt>ordLast) ordDoIt = ordLast;
  // get attribute 
  G4ProcessAttribute* pAttr = GetAttribute(aProcess); 
  if (pAttr == nullptr)
  {
    // can not get process attribute
    return;
  }
  else
  {
    G4int ip = pAttr->idxProcVector[ivec];
    // remove a process from the process vector
    if ( ip >=0 )
    {
      RemoveAt(ip, aProcess, ivec);
    }
 
    // set ordering parameter to non-zero
    if (ordDoIt == 0) ordDoIt = 1;
    pAttr->ordProcVector[ivec-1] = ordDoIt;
    pAttr->ordProcVector[ivec] = ordDoIt;
 
    // insert in process vector  if ordDoIt >0
    if (ordDoIt >0)
    {
      // find insert position
      ip = FindInsertPosition(pAttr->ordProcVector[ivec], ivec);
      // insert 
      InsertAt(ip, aProcess, ivec);
      // set index in Process Attribute
      pAttr->idxProcVector[ivec] = ip;
#ifdef G4VERBOSE
      if (verboseLevel>2)
      {
        G4cout << aErrorMessage << G4endl;
        G4cout << "particle[" << theParticleType->GetParticleName() << "] " ;
        G4cout <<"process[" << aProcess->GetProcessName() << "]"<< G4endl;
        G4cout << aProcess->GetProcessName() << " is inserted at "<< ip;
        G4cout << " in ProcessVetor[" << ivec<< "]";
        G4cout << " with Ordering parameter = " << ordDoIt ;
        G4cout << G4endl;
      }
#endif
    }
  }
  // check consistencies between ordering parameters and process 
  CheckOrderingParameters(aProcess);
 
  // create GPIL vectors 
  CreateGPILvectors();
}

References CheckOrderingParameters(), CreateGPILvectors(), FindInsertPosition(), G4cout, G4endl, GetAttribute(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), GetProcessVectorId(), GetVerboseLevel(), G4ProcessAttribute::idxProcVector, InsertAt(), ordLast, G4ProcessAttribute::ordProcVector, RemoveAt(), theParticleType, typeDoIt, and verboseLevel.

Referenced by G4FastSimulationHelper::ActivateFastSimulation(), LBE::ConstructGeneral(), G4ParallelWorldPhysics::ConstructProcess(), G4SpinDecayPhysics::ConstructProcess(), G4OpticalPhysics::ConstructProcess(), G4RunManager::ConstructScoringWorlds(), G4WorkerRunManager::ConstructScoringWorlds(), export_G4ProcessManager(), G4PhysicsListHelper::RegisterProcess(), and SetProcessOrderingToLast().

◆ SetProcessOrderingToFirst()

void G4ProcessManager::SetProcessOrderingToFirst	(	G4VProcess *	aProcess,
		G4ProcessVectorDoItIndex	idDoIt
	)

Definition at line 707 of file G4ProcessManager.cc.

{ 
  // get Process Vector Id
  G4int ivec = GetProcessVectorId(idDoIt, typeDoIt);
  if (ivec <0 )
  {
#ifdef G4VERBOSE
    if (verboseLevel>0)
    {
      G4cout << "G4ProcessManager::SetProcessOrderingToFirst(): ";
      G4cout << " illegal DoIt Index [= " << G4int(idDoIt) << "]";
      G4cout << G4endl;
    }
#endif
    return;
  }
 
    // get attribute
   G4ProcessAttribute* pAttr = GetAttribute(aProcess); 
   if (pAttr == nullptr)
   {
     return;
   }
   else
   {
     G4int ip = pAttr->idxProcVector[ivec];
 
     // remove a process from the process vector
     if ( ip >=0 )
     {
       RemoveAt(ip, aProcess, ivec);
     }
 
     // set ordering parameter to zero
     pAttr->ordProcVector[ivec] = 0;
     pAttr->ordProcVector[ivec-1] = 0;
 
     // insert 
     InsertAt(0, aProcess, ivec);
 
     // set index in Process Attribute
     pAttr->idxProcVector[ivec] = 0;
 
#ifdef G4VERBOSE
     if (verboseLevel>2)
     {
       G4cout << "G4ProcessManager::SetProcessOrderingToFirst(): ";
       G4cout << aProcess->GetProcessName() << " is inserted at top ";
       G4cout << " in ProcessVetor[" << ivec<< "]";
       G4cout << G4endl;
     }
#endif
   }
 
   if (isSetOrderingFirstInvoked[idDoIt])
   {
     G4String anErrMsg = "Set Ordering First is invoked twice for ";
     anErrMsg += aProcess->GetProcessName();
     anErrMsg += " to ";
     anErrMsg += theParticleType->GetParticleName();
     G4Exception("G4ProcessManager::SetProcessOrderingToFirst()",
                 "ProcMan113", JustWarning, anErrMsg); 
   }
   isSetOrderingFirstInvoked[idDoIt] = true;
 
   // check consistencies between ordering parameters and process 
   CheckOrderingParameters(aProcess);
 
   // create GPIL vectors 
   CreateGPILvectors();
}

References CheckOrderingParameters(), CreateGPILvectors(), G4cout, G4endl, G4Exception(), GetAttribute(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), GetProcessVectorId(), G4ProcessAttribute::idxProcVector, InsertAt(), isSetOrderingFirstInvoked, JustWarning, G4ProcessAttribute::ordProcVector, RemoveAt(), theParticleType, typeDoIt, and verboseLevel.

Referenced by G4PhysicsListHelper::AddTransportation(), G4ErrorPhysicsList::ConstructProcess(), export_G4ProcessManager(), and G4PhysicsListHelper::RegisterProcess().

◆ SetProcessOrderingToLast()

void G4ProcessManager::SetProcessOrderingToLast	(	G4VProcess *	aProcess,
		G4ProcessVectorDoItIndex	idDoIt
	)

Definition at line 886 of file G4ProcessManager.cc.

{
  SetProcessOrdering(aProcess, idDoIt, ordLast );
 
  if (isSetOrderingLastInvoked[idDoIt])
  {
    G4String anErrMsg = "Set Ordering Last is invoked twice for ";
    anErrMsg += aProcess->GetProcessName();
    anErrMsg += " to ";
    anErrMsg += theParticleType->GetParticleName();
    G4Exception( "G4ProcessManager::SetProcessOrderingToLast()","ProcMan114",
                 JustWarning,anErrMsg); 
  }
  isSetOrderingLastInvoked[idDoIt] = true;
}

References G4Exception(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), isSetOrderingLastInvoked, JustWarning, ordLast, SetProcessOrdering(), and theParticleType.

Referenced by G4FastSimulationHelper::ActivateFastSimulation(), G4BiasingHelper::AddLimiterProcess(), LBE::ConstructOp(), G4OpticalPhysics::ConstructProcess(), export_G4ProcessManager(), and G4PhysicsListHelper::RegisterProcess().

◆ SetProcessOrderingToSecond()

void G4ProcessManager::SetProcessOrderingToSecond	(	G4VProcess *	aProcess,
		G4ProcessVectorDoItIndex	idDoIt
	)

Definition at line 783 of file G4ProcessManager.cc.

{
  const G4String aErrorMessage("G4ProcessManager::SetProcessOrderingToSecond() - ");
 
#ifdef G4VERBOSE
  if (GetVerboseLevel()>2)
  {
    G4cout << aErrorMessage ;
    G4cout << "particle[" << theParticleType->GetParticleName()  << "] " ;
    G4cout <<"process[" << aProcess->GetProcessName() <<  "]"<<  G4endl;
  }
#endif
 
  // get Process Vector Id
  G4int ivec = GetProcessVectorId(idDoIt, typeDoIt);
  if (ivec <0 )
  {
#ifdef G4VERBOSE
    if (verboseLevel>0)
    {
      G4cout <<  aErrorMessage << G4endl;
      G4cout << "particle[" << theParticleType->GetParticleName() << "] " ;
      G4cout << "process[" << aProcess->GetProcessName() << "]"<<  G4endl;
      G4cout << " illegal DoIt Index [= " << G4int(idDoIt) << "]";
      G4cout << G4endl;
    }
#endif
    return;
  }
 
  // get attribute 
  G4ProcessAttribute* pAttr = GetAttribute(aProcess); 
  if (pAttr == nullptr)
  {
    // can not get process attribute
    return;
  }
  else
  {
    G4int ip = pAttr->idxProcVector[ivec];
    // remove a process from the process vector
    if ( ip >=0 )
    {
      RemoveAt(ip, aProcess, ivec);
    }
  }
 
  // set ordering parameter
  pAttr->ordProcVector[ivec-1] = 0;
  pAttr->ordProcVector[ivec]   = 0;
 
  // find insert position
  G4ProcessVector* pVector = theProcVector[ivec];
  G4int ip = pVector->entries();
  G4int tmp = INT_MAX;
 
  // find insert position
  for (G4int iproc=0; iproc<numberOfProcesses; ++iproc)
  {
    G4ProcessAttribute* aAttr = (*theAttrVector)[iproc];
    if ( aAttr->idxProcVector[ivec] >= 0 )
    {
      if ( (aAttr->ordProcVector[ivec] !=0 )  &&
           (tmp >= aAttr->ordProcVector[ivec]) )
      {
        tmp = aAttr->ordProcVector[ivec];
        if ( ip > aAttr->idxProcVector[ivec] )
        {  
          ip = aAttr->idxProcVector[ivec] ;
        }
      }
    }
  }
  
  // insert 
  InsertAt(ip, aProcess, ivec);
 
  // set index in Process Attribute
  pAttr->idxProcVector[ivec] = ip;
#ifdef G4VERBOSE
  if (verboseLevel>2)
  {
    G4cout <<  aErrorMessage << G4endl;
    G4cout << "particle[" << theParticleType->GetParticleName()  << "] " ;
    G4cout <<"process[" << aProcess->GetProcessName() << "]"<<  G4endl;
    G4cout << aProcess->GetProcessName() << " is inserted at "<< ip;
    G4cout << " in ProcessVetor[" << ivec<< "]";
    G4cout << " with Ordering parameter = 1 ";
    G4cout << G4endl;
  }
#endif
 
  // check consistencies between ordering parameters and process 
  CheckOrderingParameters(aProcess);
 
  // create GPIL vectors 
  CreateGPILvectors();
}

References CheckOrderingParameters(), CreateGPILvectors(), G4ProcessVector::entries(), G4cout, G4endl, GetAttribute(), G4ParticleDefinition::GetParticleName(), G4VProcess::GetProcessName(), GetProcessVectorId(), GetVerboseLevel(), G4ProcessAttribute::idxProcVector, InsertAt(), INT_MAX, numberOfProcesses, G4ProcessAttribute::ordProcVector, RemoveAt(), theParticleType, theProcVector, typeDoIt, and verboseLevel.

Referenced by G4BiasingHelper::AddLimiterProcess(), G4ProcessPlacer::AddProcessAs(), G4ParallelWorldPhysics::ConstructProcess(), G4RunManager::ConstructScoringWorlds(), and G4WorkerRunManager::ConstructScoringWorlds().

◆ SetVerboseLevel()

void G4ProcessManager::SetVerboseLevel ( G4int value )

inline

Referenced by LBE::ConstructGeneral(), G4ProcessTable::DumpInfo(), export_G4ProcessManager(), and G4ProcessManagerMessenger::SetNewValue().

◆ StartTracking()

void G4ProcessManager::StartTracking ( G4Track * aTrack = nullptr )

Definition at line 1163 of file G4ProcessManager.cc.

{
  for (std::size_t idx = 0; idx<theProcessList->entries(); ++idx)
  {
    if (GetAttribute(idx)->isActive)
      ((*theProcessList)[idx])->StartTracking(aTrack);
  }
  if(aTrack) duringTracking = true;
}

References duringTracking, G4ProcessVector::entries(), GetAttribute(), StartTracking(), and theProcessList.

Referenced by G4ErrorPropagator::InitG4Track(), G4TrackingManager::ProcessOneTrack(), G4ITTrackingManager::StartTracking(), and StartTracking().

Field Documentation

◆ counterOfObjects

G4ThreadLocal G4int G4ProcessManager::counterOfObjects = 0

staticprivate

Definition at line 346 of file G4ProcessManager.hh.

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

◆ duringTracking

G4bool G4ProcessManager::duringTracking = false

private

Definition at line 338 of file G4ProcessManager.hh.

Referenced by EndTracking(), and StartTracking().

◆ fProcessManagerMessenger

G4ThreadLocal G4ProcessManagerMessenger * G4ProcessManager::fProcessManagerMessenger = nullptr

staticprivate

Definition at line 345 of file G4ProcessManager.hh.

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

◆ isSetOrderingFirstInvoked

G4bool G4ProcessManager::isSetOrderingFirstInvoked[NDoit]

private

Definition at line 340 of file G4ProcessManager.hh.

Referenced by G4ProcessManager(), and SetProcessOrderingToFirst().

◆ isSetOrderingLastInvoked

G4bool G4ProcessManager::isSetOrderingLastInvoked[NDoit]

private

Definition at line 341 of file G4ProcessManager.hh.

Referenced by G4ProcessManager(), and SetProcessOrderingToLast().

◆ numberOfProcesses

G4int G4ProcessManager::numberOfProcesses = 0

private

Definition at line 334 of file G4ProcessManager.hh.

Referenced by AddProcess(), FindInsertPosition(), G4ProcessManager(), GetAttribute(), GetProcess(), InsertAt(), RemoveAt(), RemoveProcess(), and SetProcessOrderingToSecond().

◆ theAttrVector

G4ProcessAttrVector* G4ProcessManager::theAttrVector = nullptr

private

Definition at line 328 of file G4ProcessManager.hh.

Referenced by AddProcess(), G4ProcessManager(), GetAttribute(), RemoveProcess(), and ~G4ProcessManager().

◆ theParticleType

const G4ParticleDefinition* G4ProcessManager::theParticleType = nullptr

private

Definition at line 331 of file G4ProcessManager.hh.

Referenced by ActivateProcess(), AddProcess(), DumpInfo(), GetAttribute(), GetProcessVectorIndex(), InActivateProcess(), RemoveProcess(), SetProcessOrdering(), SetProcessOrderingToFirst(), SetProcessOrderingToLast(), and SetProcessOrderingToSecond().

◆ theProcessList

G4ProcessVector* G4ProcessManager::theProcessList = nullptr

private

Definition at line 335 of file G4ProcessManager.hh.

Referenced by AddProcess(), CreateGPILvectors(), DumpInfo(), EndTracking(), G4ProcessManager(), RemoveProcess(), StartTracking(), and ~G4ProcessManager().

◆ theProcVector

G4ProcessVector* G4ProcessManager::theProcVector[SizeOfProcVectorArray]

private

Definition at line 325 of file G4ProcessManager.hh.

Referenced by ActivateProcess(), CreateGPILvectors(), FindInsertPosition(), G4ProcessManager(), InActivateProcess(), InsertAt(), RemoveAt(), RemoveProcess(), SetProcessOrderingToSecond(), and ~G4ProcessManager().

◆ verboseLevel

G4int G4ProcessManager::verboseLevel = 1

private

Definition at line 343 of file G4ProcessManager.hh.

Referenced by AddProcess(), DumpInfo(), GetProcessVectorIndex(), SetProcessOrdering(), SetProcessOrderingToFirst(), and SetProcessOrderingToSecond().

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

source/processes/management/include/G4ProcessManager.hh
source/processes/management/src/G4ProcessManager.cc

Public Types

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Member Typedef Documentation

◆ G4ProcessAttrVector

Member Enumeration Documentation

◆ anonymous enum

Constructor & Destructor Documentation

◆ G4ProcessManager() [1/3]

◆ G4ProcessManager() [2/3]

◆ G4ProcessManager() [3/3]

◆ ~G4ProcessManager()

Member Function Documentation

◆ ActivateProcess()

◆ AddContinuousProcess()

◆ AddDiscreteProcess()

◆ AddProcess()

◆ AddRestProcess()

◆ CheckOrderingParameters()

◆ CreateGPILvectors()

◆ DumpInfo()

◆ EndTracking()

◆ FindInsertPosition()

◆ GetAlongStepIndex()

◆ GetAlongStepProcessVector()

◆ GetAtRestIndex()

◆ GetAtRestProcessVector()

◆ GetAttribute() [1/2]

◆ GetAttribute() [2/2]

◆ GetParticleType()

◆ GetPostStepIndex()

◆ GetPostStepProcessVector()

◆ GetProcess()

◆ GetProcessActivation() [1/2]

◆ GetProcessActivation() [2/2]

◆ GetProcessIndex()

◆ GetProcessList()

◆ GetProcessListLength()

◆ GetProcessOrdering()

◆ GetProcessVector()

◆ GetProcessVectorId()

◆ GetProcessVectorIndex()

◆ GetVerboseLevel()

◆ InActivateProcess()

◆ InsertAt()

◆ operator!=()

◆ operator=()

◆ operator==()

◆ RemoveAt()

◆ RemoveProcess() [1/2]

◆ RemoveProcess() [2/2]

◆ SetIndexToProcessVector()

◆ SetParticleType()

◆ SetProcessActivation() [1/2]

◆ SetProcessActivation() [2/2]

◆ SetProcessOrdering()

◆ SetProcessOrderingToFirst()

◆ SetProcessOrderingToLast()

◆ SetProcessOrderingToSecond()

◆ SetVerboseLevel()

◆ StartTracking()

Field Documentation

◆ counterOfObjects

◆ duringTracking

◆ fProcessManagerMessenger

◆ isSetOrderingFirstInvoked

◆ isSetOrderingLastInvoked

◆ numberOfProcesses

◆ theAttrVector

◆ theParticleType

◆ theProcessList

◆ theProcVector

◆ verboseLevel