G4ProcessManager Class Reference

#include <G4ProcessManager.hh>

Public Types
enum	{ SizeOfProcVectorArray = 6 }

Public Member Functions
	G4ProcessManager (G4ProcessManager &right)
	G4ProcessManager (const G4ParticleDefinition *aParticleType)
	~G4ProcessManager ()
G4int	operator== (const G4ProcessManager &right) const
G4int	operator!= (const G4ProcessManager &right) const
G4ProcessVector *	GetProcessList () const
G4int	GetProcessListLength () const
G4int	GetProcessIndex (G4VProcess *) const
G4ProcessVector *	GetProcessVector (G4ProcessVectorDoItIndex idx, G4ProcessVectorTypeIndex typ=typeGPIL) const
G4ProcessVector *	GetAtRestProcessVector (G4ProcessVectorTypeIndex typ=typeGPIL) const
G4ProcessVector *	GetAlongStepProcessVector (G4ProcessVectorTypeIndex typ=typeGPIL) const
G4ProcessVector *	GetPostStepProcessVector (G4ProcessVectorTypeIndex typ=typeGPIL) const
G4int	GetProcessVectorIndex (G4VProcess *aProcess, G4ProcessVectorDoItIndex idx, G4ProcessVectorTypeIndex typ=typeGPIL) const
G4int	GetAtRestIndex (G4VProcess *aProcess, G4ProcessVectorTypeIndex typ=typeGPIL) const
G4int	GetAlongStepIndex (G4VProcess *aProcess, G4ProcessVectorTypeIndex typ=typeGPIL) const
G4int	GetPostStepIndex (G4VProcess *aProcess, G4ProcessVectorTypeIndex typ=typeGPIL) const
G4int	AddProcess (G4VProcess *aProcess, G4int ordAtRestDoIt=ordInActive, G4int ordAlongSteptDoIt=ordInActive, G4int ordPostStepDoIt=ordInActive)
G4int	AddRestProcess (G4VProcess *aProcess, G4int ord=ordDefault)
G4int	AddDiscreteProcess (G4VProcess *aProcess, G4int ord=ordDefault)
G4int	AddContinuousProcess (G4VProcess *aProcess, G4int ord=ordDefault)
G4int	GetProcessOrdering (G4VProcess *aProcess, G4ProcessVectorDoItIndex idDoIt)
void	SetProcessOrdering (G4VProcess *aProcess, G4ProcessVectorDoItIndex idDoIt, G4int ordDoIt=ordDefault)
void	SetProcessOrderingToFirst (G4VProcess *aProcess, G4ProcessVectorDoItIndex idDoIt)
void	SetProcessOrderingToSecond (G4VProcess *aProcess, G4ProcessVectorDoItIndex idDoIt)
void	SetProcessOrderingToLast (G4VProcess *aProcess, G4ProcessVectorDoItIndex idDoIt)
G4VProcess *	RemoveProcess (G4VProcess *aProcess)
G4VProcess *	RemoveProcess (G4int index)
G4VProcess *	SetProcessActivation (G4VProcess *aProcess, G4bool fActive)
G4VProcess *	SetProcessActivation (G4int index, G4bool fActive)
G4bool	GetProcessActivation (G4VProcess *aProcess) const
G4bool	GetProcessActivation (G4int index) const
G4ParticleDefinition *	GetParticleType () const
void	SetParticleType (const G4ParticleDefinition *)
void	StartTracking (G4Track *aTrack=0)
void	EndTracking ()
void	DumpInfo ()
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel () const

Protected Member Functions
G4int	InsertAt (G4int position, G4VProcess *process, G4int ivec)
G4int	RemoveAt (G4int position, G4VProcess *process, G4int ivec)
G4int	FindInsertPosition (G4int ord, G4int ivec)
G4int	GetProcessVectorId (G4ProcessVectorDoItIndex idx, G4ProcessVectorTypeIndex typ=typeGPIL) const
void	CheckOrderingParameters (G4VProcess *) const

Protected Attributes
G4int	verboseLevel

Detailed Description

Definition at line 106 of file G4ProcessManager.hh.

Member Enumeration Documentation

anonymous enum

anonymous enum

Enumerator
SizeOfProcVectorArray

Definition at line 297 of file G4ProcessManager.hh.

{SizeOfProcVectorArray = 6};

Constructor & Destructor Documentation

G4ProcessManager() [1/2]

G4ProcessManager::G4ProcessManager

(

G4ProcessManager &

right

)

Definition at line 100 of file G4ProcessManager.cc.

            : theParticleType(right.theParticleType),
          numberOfProcesses(0),
          duringTracking(false),
          verboseLevel(right.verboseLevel)
{
#ifdef G4VERBOSE
   if (GetVerboseLevel() > 2) {
     G4cout <<  "G4ProcessManageer:: copy constructor " <<G4endl; 
    }
#endif
 
   // create the process List and ProcessAttr Vector
   theProcessList = new G4ProcessVector();
   theAttrVector = new G4ProcessAttrVector();
   if ( ( theProcessList == 0) || (theAttrVector == 0) ){
     G4Exception( "G4ProcessManager::G4ProcessManager() [coopy constructor]",
          "ProcMan011",FatalException, "Can not 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 +=1;
   }
  
 
  // fill up theProcVector
  for (G4int i=0; i<SizeOfProcVectorArray; ++i) {
    // create i-th ProcessVector in theProcVector
    theProcVector[i] = new G4ProcessVector();
    if ( theProcVector[i] == 0) {
      G4Exception( "G4ProcessManager::G4ProcessManager() [coopy constructor]",
           "ProcMan011",FatalException, "Can not create G4ProcessVector ");
    }
 
    G4ProcessTable* theProcessTable = G4ProcessTable::GetProcessTable();
    G4ProcessVector* src = right.theProcVector[i];
    for (G4int 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] !=0 ) {
    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+=1; 
}

Referenced by G4ProcessManager().

G4ProcessManager() [2/2]

G4ProcessManager::G4ProcessManager

(

const G4ParticleDefinition *

aParticleType

)

Definition at line 60 of file G4ProcessManager.cc.

                                                                           :
                theParticleType(aParticleType),
                numberOfProcesses(0),
                duringTracking(false),     
        verboseLevel(1)
{
  // create the process List
  theProcessList = new G4ProcessVector();
  if ( theProcessList == 0) {
    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] == 0) {
      G4Exception( "G4ProcessManager::G4ProcessManager()","ProcMan012",
           FatalException, "Can not create G4ProcessVector ");
    }
  }
 
  // create Process Attribute vector
  theAttrVector = new G4ProcessAttrVector();
 
  // create Process Manager Messenger
  if (fProcessManagerMessenger == 0){
    fProcessManagerMessenger = new G4ProcessManagerMessenger();
  }
 
  for (G4int i=0; i<NDoit; ++i) {
    isSetOrderingFirstInvoked[i]=false;
    isSetOrderingLastInvoked[i]=false;
  }
 
  // Increment counter of G4ProcessManager objects
  counterOfObjects+=1; 
}

~G4ProcessManager()

G4ProcessManager::~G4ProcessManager

(

)

Definition at line 201 of file G4ProcessManager.cc.

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

Member Function Documentation

AddContinuousProcess()

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

Referenced by G4ErrorPhysicsList::ConstructEM().

AddDiscreteProcess()

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

Referenced by G4AntiBarionBuilder::Build(), G4BertiniElectroNuclearBuilder::Build(), G4ElectroNuclearBuilder::Build(), G4HyperonCHIPSBuilder::Build(), G4HyperonFTFPBuilder::Build(), G4HyperonLHEPBuilder::Build(), G4KaonBuilder::Build(), G4LHEPAntiBarionBuilder::Build(), G4MiscBuilder::Build(), G4MiscCHIPSBuilder::Build(), G4MiscLHEPBuilder::Build(), G4MiscQGSCBuilder::Build(), G4NeutronBuilder::Build(), G4PiKBuilder::Build(), G4PionBuilder::Build(), G4ProtonBuilder::Build(), G4QInelasticCHIPS_HPBuilder::Build(), G4QInelasticCHIPSBuilder::Build(), G4QNeutronBuilder::Build(), G4QNeutronHPBuilder::Build(), G4QProtonBuilder::Build(), G4ErrorPhysicsList::ConstructEM(), G4ChargeExchangePhysics::ConstructProcess(), G4HadronDElasticPhysics::ConstructProcess(), G4HadronElasticPhysics::ConstructProcess(), G4HadronElasticPhysicsLHEP::ConstructProcess(), G4HadronHElasticPhysics::ConstructProcess(), G4HadronQElasticPhysics::ConstructProcess(), G4IonLHEPPhysics::ConstructProcess(), G4OpticalPhysics::ConstructProcess(), G4QAtomicPhysics::ConstructProcess(), G4QElasticPhysics::ConstructProcess(), G4QEmExtraPhysics::ConstructProcess(), G4QIonPhysics::ConstructProcess(), G4StepLimiterBuilder::ConstructProcess(), HadronPhysicsFTFP_BERT_TRV::ConstructProcess(), G4VHadronPhysics::FindCaptureProcess(), G4VHadronPhysics::FindElasticProcess(), G4VHadronPhysics::FindFissionProcess(), G4VHadronPhysics::FindInelasticProcess(), and G4ErrorTrackLengthTarget::G4ErrorTrackLengthTarget().

AddProcess()

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

Definition at line 410 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("Bad ProcessList: 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;
}

Referenced by G4PhysicsListHelper::AddTransportation(), G4ErrorPhysicsList::ConstructProcess(), G4OpticalPhysics::ConstructProcess(), G4QAtomicPhysics::ConstructProcess(), G4RunManager::ConstructScoringWorlds(), and G4PhysicsListHelper::RegisterProcess().

AddRestProcess()

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

Referenced by G4LHEPStoppingHadronBuilder::Build(), G4StoppingHadronBuilder::Build(), G4LHEPStoppingPhysics::ConstructProcess(), G4QCaptureAtRestPhysics::ConstructProcess(), G4QStoppingPhysics::ConstructProcess(), and G4StoppingPhysics::ConstructProcess().

CheckOrderingParameters()

void G4ProcessManager::CheckOrderingParameters ( G4VProcess *  aProcess ) const

protected

Definition at line 1149 of file G4ProcessManager.cc.

{
  if (aProcess==0) return;
  G4ProcessAttribute* pAttr = GetAttribute(aProcess);
  if (pAttr ==0) {
#ifdef G4VERBOSE
    if (GetVerboseLevel()>0) {
      G4cout << "G4ProcessManager::CheckOrderingParameters ";
      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 ";
      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 ";
      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 ";
      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;
}

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

DumpInfo()

void G4ProcessManager::DumpInfo

(

)

Definition at line 1007 of file G4ProcessManager.cc.

{ 
  // Dump Information
 
  // particle type
  G4cout << "G4ProcessManager:  particle[" 
     << theParticleType->GetParticleName() << "]"
     << G4endl;
 
  // loop over all processes
  for (G4int 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 
  }
}

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

EndTracking()

void G4ProcessManager::EndTracking

(

)

Definition at line 1098 of file G4ProcessManager.cc.

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

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

FindInsertPosition()

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

protected

Definition at line 391 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;
}

Referenced by AddProcess(), and SetProcessOrdering().

GetAlongStepIndex()

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

GetAlongStepProcessVector()

G4ProcessVector * G4ProcessManager::GetAlongStepProcessVector

(

G4ProcessVectorTypeIndex

typ = typeGPIL

)

const

Referenced by G4SteppingManager::GetProcessNumber(), and G4ITStepProcessor::SetupGeneralProcessInfo().

GetAtRestIndex()

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

GetAtRestProcessVector()

G4ProcessVector * G4ProcessManager::GetAtRestProcessVector

(

G4ProcessVectorTypeIndex

typ = typeGPIL

)

const

Referenced by G4hImpactIonisation::AlongStepDoIt(), G4ITStepProcessor::DealWithSecondaries(), G4HadronicProcess::FillResult(), G4SteppingManager::GetProcessNumber(), G4VEmProcess::PostStepDoIt(), G4VEnergyLossProcess::PostStepDoIt(), G4HadronElasticProcess::PostStepDoIt(), G4WHadronElasticProcess::PostStepDoIt(), and G4ITStepProcessor::SetupGeneralProcessInfo().

GetParticleType()

G4ParticleDefinition * G4ProcessManager::GetParticleType

(

)

const

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

GetPostStepIndex()

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

GetPostStepProcessVector()

G4ProcessVector * G4ProcessManager::GetPostStepProcessVector

(

G4ProcessVectorTypeIndex

typ = typeGPIL

)

const

Referenced by G4HadronElasticPhysicsXS::AddXSection(), G4SteppingManager::GetProcessNumber(), and G4ITStepProcessor::SetupGeneralProcessInfo().

GetProcessActivation() [1/2]

G4bool G4ProcessManager::GetProcessActivation

(

G4int

index

)

const

Definition at line 1131 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;
}

GetProcessActivation() [2/2]

G4bool G4ProcessManager::GetProcessActivation

(

G4VProcess *

aProcess

)

const

Definition at line 1124 of file G4ProcessManager.cc.

{
  return GetProcessActivation(GetProcessIndex(aProcess));
} 

Referenced by G4LossTableManager::BuildPhysicsTable(), and GetProcessActivation().

GetProcessIndex()

G4int G4ProcessManager::GetProcessIndex

(

G4VProcess *

)

const

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

GetProcessList()

G4ProcessVector * G4ProcessManager::GetProcessList

(

)

const

Referenced by G4ITStepProcessor::ActiveOnlyITProcess(), G4hImpactIonisation::BuildPhysicsTable(), G4VUserPhysicsList::BuildPhysicsTable(), G4PhysicsListHelper::CheckParticleList(), HadronPhysicsFTFP_BERT_TRV::ConstructProcess(), G4TheRayTracer::CreateBitMap(), G4VHadronPhysics::FindCaptureProcess(), G4VHadronPhysics::FindElasticProcess(), G4VHadronPhysics::FindFissionProcess(), G4PhysListUtil::FindInelasticProcess(), G4VHadronPhysics::FindInelasticProcess(), G4ProcessTable::FindProcesses(), G4ErrorTrackLengthTarget::G4ErrorTrackLengthTarget(), G4VUserPhysicsList::PreparePhysicsTable(), G4PhysicsListHelper::RegisterProcess(), G4ProcessTable::SetProcessActivation(), and G4GlobalFastSimulationManager::ShowSetup().

GetProcessListLength()

G4int G4ProcessManager::GetProcessListLength

(

)

const

GetProcessOrdering()

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

Definition at line 588 of file G4ProcessManager.cc.

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

GetProcessVector()

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

GetProcessVectorId()

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

protected

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

GetProcessVectorIndex()

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

Definition at line 236 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;
}

GetVerboseLevel()

G4int G4ProcessManager::GetVerboseLevel

(

)

const

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

InsertAt()

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

protected

Definition at line 332 of file G4ProcessManager.cc.

{
  G4ProcessVector* pVector = theProcVector[ivec];
  // check position
  if ( (ip<0) || (ip > 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 != 0) {
      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;
}

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

operator!=()

G4int G4ProcessManager::operator!=

(

const G4ProcessManager &

right

)

const

Definition at line 1001 of file G4ProcessManager.cc.

{
  return (this != &right);
}

operator==()

G4int G4ProcessManager::operator==

(

const G4ProcessManager &

right

)

const

Definition at line 995 of file G4ProcessManager.cc.

{
  return (this == &right);
}

RemoveAt()

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

protected

Definition at line 360 of file G4ProcessManager.cc.

{
  G4ProcessVector* pVector = theProcVector[ivec];
  // check position
  if ( (ip<0) || (ip >= pVector->entries()) ) return -1;
 
  // remove process
  pVector->removeAt(ip);
 
  // correct index
  for(G4int iproc=0; iproc<numberOfProcesses; iproc++) {
    G4ProcessAttribute* aAttr = (*theAttrVector)[iproc];
    if (aAttr != 0) {
      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;
}

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

RemoveProcess() [1/2]

G4VProcess * G4ProcessManager::RemoveProcess

(

G4int

index

)

Definition at line 517 of file G4ProcessManager.cc.

{
  //find the process attribute
  G4ProcessAttribute* pAttr = GetAttribute(index);
  if (pAttr == 0) return 0;
 
  // 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 < 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 0;
      }    
    } 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 0;
    }
  }
  pAttr->isActive = false;
  // remove from the process List and delete the attribute
  theProcessList->removeAt(index);
  G4ProcessAttrVector::iterator itr;
  for (itr = theAttrVector->begin(); itr!= theAttrVector->end(); ++itr) {
    if ( (*itr) == pAttr) {
      theAttrVector->erase(itr);
      break;
    }
  }
  delete pAttr;
  numberOfProcesses -= 1;
  
  // 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;
} 

RemoveProcess() [2/2]

G4VProcess * G4ProcessManager::RemoveProcess

(

G4VProcess *

aProcess

)

Definition at line 582 of file G4ProcessManager.cc.

{
  return RemoveProcess(GetProcessIndex(aProcess));
} 

Referenced by G4ErrorTrackLengthTarget::G4ErrorTrackLengthTarget(), RemoveProcess(), and G4ProcessPlacer::RemoveProcess().

SetParticleType()

void G4ProcessManager::SetParticleType

(

const G4ParticleDefinition *

)

Referenced by G4VUserPhysicsList::AddProcessManager().

SetProcessActivation() [1/2]

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

Definition at line 1117 of file G4ProcessManager.cc.

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

SetProcessActivation() [2/2]

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

Definition at line 1109 of file G4ProcessManager.cc.

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

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

SetProcessOrdering()

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

Definition at line 607 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 == 0) {
    // 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();
}

Referenced by G4OpticalPhysics::ConstructProcess(), G4RunManager::ConstructScoringWorlds(), G4PhysicsListHelper::RegisterProcess(), and SetProcessOrderingToLast().

SetProcessOrderingToFirst()

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

Definition at line 688 of file G4ProcessManager.cc.

{ 
  // get Process Vector Id(
  G4int ivec = GetProcessVectorId(idDoIt, typeDoIt);
  if (ivec <0 ) {
#ifdef G4VERBOSE
    if (verboseLevel>0) {
      G4cout << "G4ProcessManager::SetProcessOrdering: ";
      G4cout << " illegal DoIt Index [= " << G4int(idDoIt) << "]";
      G4cout << G4endl;
    }
#endif
    return;
  }
 
    // get attribute
   G4ProcessAttribute* pAttr = GetAttribute(aProcess); 
   if (pAttr == 0) {
     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();
 
}

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

SetProcessOrderingToLast()

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

Definition at line 849 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;
}

Referenced by G4OpticalPhysics::ConstructProcess(), and G4PhysicsListHelper::RegisterProcess().

SetProcessOrderingToSecond()

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

Definition at line 758 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 == 0) {
    // 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 1
  pAttr->ordProcVector[ivec-1] = 1;
  pAttr->ordProcVector[ivec]   = 1;
 
  // 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();
}

Referenced by G4RunManager::ConstructScoringWorlds().

SetVerboseLevel()

void G4ProcessManager::SetVerboseLevel

(

G4int

value

)

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

StartTracking()

void G4ProcessManager::StartTracking

(

G4Track *

aTrack = 0

)

Definition at line 1088 of file G4ProcessManager.cc.

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

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

Member Data Documentation

verboseLevel

G4int G4ProcessManager::verboseLevel

protected

Definition at line 360 of file G4ProcessManager.hh.

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

---

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

• G4ProcessManager.hh
• G4ProcessManager.cc