G4PhysicsListHelper Class Reference

#include <G4PhysicsListHelper.hh>

Public Member Functions
G4bool	RegisterProcess (G4VProcess *process, G4ParticleDefinition *particle)
void	AddTransportation ()
void	UseCoupledTransportation (G4bool vl=true)
void	CheckParticleList () const
void	DumpOrdingParameterTable (G4int subType=-1) const
G4PhysicsListOrderingParameter	GetOrdingParameter (G4int subType) const
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel () const

Static Public Member Functions
static G4PhysicsListHelper *	GetPhysicsListHelper ()

Detailed Description

Definition at line 50 of file G4PhysicsListHelper.hh.

Member Function Documentation

void G4PhysicsListHelper::AddTransportation

(

)

Definition at line 207 of file G4PhysicsListHelper.cc.

{
  G4int verboseLevelTransport = 0;

#ifdef G4VERBOSE
  if (verboseLevel >2){
    G4cout << "G4PhysicsListHelper::AddTransportation()  "<< G4endl;
  }
#endif

  G4int nParaWorld = 
    G4RunManagerKernel::GetRunManagerKernel()->GetNumberOfParallelWorld();
  
  if ( nParaWorld>0 || 
       useCoupledTransportation || 
       G4ScoringManager::GetScoringManagerIfExist()) {
#ifdef G4VERBOSE
    if (verboseLevel >0) {
      G4cout << " G4PhysicsListHelper::AddTransportation()"
         << "--- G4CoupledTransportation is used " 
         << G4endl;
    }
#endif
    theTransportationProcess = new G4CoupledTransportation(verboseLevelTransport);    
  } else {
    theTransportationProcess = new G4Transportation(verboseLevelTransport);
  }
 
  // loop over all particles in G4ParticleTable
  aParticleIterator->reset();
  while( (*aParticleIterator)() ){
    G4ParticleDefinition* particle = aParticleIterator->value();
    G4ProcessManager* pmanager = particle->GetProcessManager();
    // Add transportation process for all particles 
    if ( pmanager == 0) {
      // Error !! no process manager
#ifdef G4VERBOSE
      if (verboseLevel>0){
    G4cout << "G4PhysicsListHelper::AddTransportation  "
           <<" : No Process Manager for "
           << particle->GetParticleName() << G4endl;
      }
#endif
      G4Exception("G4PhysicsListHelper::AddTransportation",
          "Run0104", FatalException,
          "No process manager");
      continue;
    } 
    // Molecule use different type transportation
    if(particle->GetParticleType() == "Molecule") continue; 

    // add transportation with ordering = ( -1, "first", "first" )
    pmanager ->AddProcess(theTransportationProcess);
    pmanager ->SetProcessOrderingToFirst(theTransportationProcess, idxAlongStep);
    pmanager ->SetProcessOrderingToFirst(theTransportationProcess, idxPostStep);
  }
}

Here is the call graph for this function:

void G4PhysicsListHelper::CheckParticleList

(

)

const

Definition at line 99 of file G4PhysicsListHelper.cc.

{
  bool isElectron = false;
  bool isPositron = false;
  bool isGamma    = false;
  bool isProton   = false;
  bool isGenericIon = false;
  bool isAnyIon   = false;
  bool isAnyChargedBaryon   = false;
  bool isEmProc   = false;

  // loop over all particles in G4ParticleTable
  aParticleIterator->reset();
  while( (*aParticleIterator)() ){
    G4ParticleDefinition* particle = aParticleIterator->value();
    G4String name = particle->GetParticleName();
    // check if any EM process exists
    if (!isEmProc) {
      G4ProcessVector* list = particle->GetProcessManager()->GetProcessList();
      for (int idx=0; idx<list->size(); idx++){
    isEmProc = ((*list)[idx])->GetProcessType() == fElectromagnetic;
    if (isEmProc) break;
      }
    }
    
    if      ( name == "e-") isElectron = true; 
    else if ( name == "e+") isPositron = true; 
    else if ( name == "gamma") isGamma = true; 
    else if ( name == "GenericIon") isGenericIon = true; 
    else if ( name == "proton") isProton = true; 
    else if ( particle->GetParticleType() == "nucleus") isAnyIon = true;
    else if ( particle->GetParticleType() == "baryon") {
       if ( particle->GetPDGCharge() != 0.0 ) isAnyChargedBaryon = true;
    }
  }

  if (!isEmProc) return;

  // RULE 1
  //  e+, e- and gamma should exist 
  //   if one of them exist
  bool isEmBasic =  isElectron || isPositron || isGamma;
  bool isMissingEmBasic =  !isElectron || !isPositron || !isGamma;
  if (isEmBasic && isMissingEmBasic) {
    G4String missingName="";
    if (!isElectron) missingName += "e- ";
    if (!isPositron) missingName += "e+ ";
    if (!isGamma) missingName += "gamma ";

#ifdef G4VERBOSE
    if (verboseLevel >0){
      G4cout << "G4PhysicsListHelper::CheckParticleList: "
         << missingName << " do not exist " << G4endl; 
      G4cout << " These particle are necessary for basic EM processes" 
         << G4endl;
    }
#endif
    G4Exception("G4PhysicsListHelper::CheckParticleList",
        "Run0101", FatalException,
        "Missing EM basic particle");
  }

  // RULE 2
  //  proton should exist 
  //   if any other charged baryon  exist
  if (!isProton && isAnyChargedBaryon) {
    G4String missingName="proton ";

#ifdef G4VERBOSE
    if (verboseLevel >0){
      G4cout << "G4PhysicsListHelper::CheckParticleList: "
         << missingName << " does not exist "<< G4endl; 
      G4cout << " Proton is necessary for EM baryon processes" << G4endl;
    }
#endif
    missingName += " should be created ";
    G4Exception("G4PhysicsListHelper::CheckParticleList",
        "Run0102", FatalException,
        "Missing Proton");
  }
   
  // RULE 3
  //  GenericIonn should exist 
  //   if any other ion  exist
  if (!isGenericIon && isAnyIon) {
    G4String missingName="GenericIon ";

#ifdef G4VERBOSE
    if (verboseLevel >0){
      G4cout << "G4PhysicsListHelper::CheckParticleList: "
         << missingName << " does not exist "<< G4endl; 
      G4cout << " GenericIon should be created if any ion is necessary" << G4endl;
    }
#endif
    G4Exception("G4PhysicsListHelper::CheckParticleList",
        "Run0103", FatalException,
        "Missing GenericIon");
  }
      
}

Here is the call graph for this function:

void G4PhysicsListHelper::DumpOrdingParameterTable

(

G4int

subType = -1

)

const

Definition at line 345 of file G4PhysicsListHelper.cc.

{
 if (theTable==0) {
#ifdef G4VERBOSE
    if (verboseLevel >0) {
      G4cout << "G4PhysicsListHelper::DumpOrdingParameterTable   "
         << " No ordering parameter table  : " << ordParamFileName 
         << G4endl;
    }
#endif
    return;
  }
  G4cout << "G4PhysicsListHelper::DumpOrdingParameterTable  : "
     << ordParamFileName << G4endl; 
  G4cout << "          TypeName  " 
     << "    ProcessType" <<  "        SubType"
     << "         AtRest" <<  "      AlongStep" <<  "        PostStep"
     << "     Duplicable" << G4endl;
  for (int i=0; i<sizeOfTable ; i++){
    G4PhysicsListOrderingParameter* tmp=&(theTable->at(i));
    if ((subType>=0) && (subType!=tmp->processSubType)) continue;
    G4cout << std::setw(18)     << tmp->processTypeName 
       << std::setw(15)     << tmp->processType 
       << std::setw(15) << tmp->processSubType
       << std::setw(15) << tmp->ordering[0] 
       << std::setw(15) << tmp->ordering[1] 
       << std::setw(15) << tmp->ordering[2];
    if (tmp->isDuplicable) {
      G4cout << "  true";
    } else {
      G4cout << "  false";
    }
    G4cout <<G4endl;
  }  
}

Here is the caller graph for this function:

G4PhysicsListOrderingParameter G4PhysicsListHelper::GetOrdingParameter

(

G4int

subType

)

const

Definition at line 382 of file G4PhysicsListHelper.cc.

{
  G4PhysicsListOrderingParameter value;

 if (theTable==0) {
#ifdef G4VERBOSE
    if (verboseLevel >0) {
      G4cout << "G4PhysicsListHelper::GetOrderingParameter : "
         << " No ordering parameter table  : " << ordParamFileName 
         << G4endl;
    }
#endif
    return value;
  }

  for (int i=0; i<sizeOfTable ; i++){
    G4PhysicsListOrderingParameter* tmp=&(theTable->at(i));
    if (subType == tmp->processSubType){
      value.processTypeName = tmp->processTypeName; 
      value.processType     = tmp->processType; 
      value.processSubType  = tmp->processSubType; 
      value.ordering[0]     = tmp->ordering[0]; 
      value.ordering[1]     = tmp->ordering[1]; 
      value.ordering[2]     = tmp->ordering[2]; 
      value.isDuplicable    = tmp->isDuplicable;
    }
  }  
  return value;
}

G4PhysicsListHelper * G4PhysicsListHelper::GetPhysicsListHelper ( )

static

Definition at line 89 of file G4PhysicsListHelper.cc.

{
  if (!pPLHelper)
  {
    pPLHelper = new G4PhysicsListHelper;
  }
  return pPLHelper;
}

Here is the caller graph for this function:

G4int G4PhysicsListHelper::GetVerboseLevel ( ) const

inline

Definition at line 132 of file G4PhysicsListHelper.hh.

{
  return verboseLevel;
}

G4bool G4PhysicsListHelper::RegisterProcess	(	G4VProcess *	process,
		G4ParticleDefinition *	particle
	)

Definition at line 413 of file G4PhysicsListHelper.cc.

{
  if (theTable==0) {
#ifdef G4VERBOSE
    if (verboseLevel >0) {
      G4cout << "G4PhysicsListHelper::RegisterProcess :"
         << " No ordering parameter table  : " << ordParamFileName 
         << G4endl;
    }
#endif
    G4Exception("G4PhysicsListHelper::RegisterPorcess",
        "Run0107", FatalException, 
        "No Ordering Parameter Table");
    return false;
  }

  const G4String pName = process->GetProcessName(); 
  const G4int pType    = process->GetProcessType();
  const G4int pSubType = process->GetProcessSubType();
  
#ifdef G4VERBOSE
  if (verboseLevel >2) {
    G4cout << "G4PhysicsListHelper::RegisterProcess :"
       << pName << " Process Type = " << pType 
       << " SubType = "<< pSubType  
       << " to " << particle->GetParticleName()
       << G4endl;
  }
#endif

  // Check Process Type/SubType
  if ((pType <1)||(pSubType<1)) {
#ifdef G4VERBOSE
    if (verboseLevel >0) {
      G4cout << "G4PhysicsListHelper::RegisterProcess :"
         << pName << " for " << particle->GetParticleName()
         << " has illegal Process Type = " << pType 
         << " SubType = "<< pSubType << G4endl;
    }
#endif
    G4Exception("G4PhysicsListHelper::RegisterPorcess",
        "Run0108", FatalException, 
        "No Matching process Type/SubType");
    return false;
  }
  
  G4bool isFound = false;
  G4int  ord[3];
  G4bool duplicable = false;
  for (int i=0; i<sizeOfTable ; i++){
    G4PhysicsListOrderingParameter* tmp=&(theTable->at(i));
    if ((tmp->processType==pType)&&(tmp->processSubType==pSubType)){
      ord[0] = tmp->ordering[0]; 
      ord[1] = tmp->ordering[1]; 
      ord[2] = tmp->ordering[2];
      duplicable = tmp->isDuplicable;
      isFound = true;
      break;
    }
  } 
  if (!isFound) {
#ifdef G4VERBOSE
    if (verboseLevel >0) {
      G4cout << "G4PhysicsListHelper::RegisterProcess :"
         << pName << " for " << particle->GetParticleName()
         << " with  type/subtype =" 
         << pType << "/" << pSubType 
         << "  is not reigstered in OrdingParameterTable  "
         << G4endl;
    }
#endif
    G4Exception("G4PhysicsListHelper::RegisterPorcess",
        "Run0109", FatalException, 
        "No Matching process Type/SubType");
    return false;
  }

  // Check Process Manager
  G4ProcessManager* pManager = particle->GetProcessManager();
  if ( pManager == 0) {
      // Error !! no process manager
#ifdef G4VERBOSE
    if (verboseLevel>0){
      G4cout << "G4PhysicsListHelper::RegisterProcess "
         <<" : No Process Manager for "
         << particle->GetParticleName() << G4endl;
    }
#endif
    G4Exception("G4PhysicsListHelper::RegisterProcess   ",
        "Riun0110", FatalException,
        "No process manager");
    return false;
  }

  // Check Duplication
  if (!duplicable){
    G4bool duplicated = false;
    G4ProcessVector* pList = pManager->GetProcessList();
    for (G4int idx=0; idx<pList->size(); idx++) {
      const G4VProcess* p = (*pList)[idx];
      if ((p->GetProcessType()== pType)  && 
      (p->GetProcessSubType()== pSubType)){
    duplicated = true;
#ifdef G4VERBOSE
    if (verboseLevel >0) {
      G4cout << "G4PhysicsListHelper::RegisterProcess :"
         << pName << " for " << particle->GetParticleName()
         << " with  type/subtype =" 
         << pType << "/" << pSubType 
         << "  is has same subType as "
         << p->GetProcessName()
         << " for " << particle->GetParticleName()
         << G4endl;
      G4cout << "It will not be added !!" << G4endl;
    }
#endif
    G4Exception("G4PhysicsListHelper::RegisterPorcess",
            "Run0111", JustWarning, 
            "Duplication of processes");
      }
    }
    if (duplicated) return false;
  }

  // Add Process
  G4int code = pManager ->AddProcess(process);
  if (code <0) return false;

  // Set Ordering Parameter
  for(G4int idx=0; idx<3; idx++){
    G4ProcessVectorDoItIndex idxOrd = static_cast<G4ProcessVectorDoItIndex>(idx);
    if (ord[idx]<0) {
      // Do Nothing because NO DOIT
    } else if (ord[idx]==0) {
      pManager->SetProcessOrderingToFirst( process, idxOrd );
    } else if (ord[idx]<9999) {
      pManager->SetProcessOrdering( process, idxOrd , ord[idx]);
    } else {
      pManager->SetProcessOrderingToLast( process, idxOrd );
    } 
  } 
#ifdef G4VERBOSE
  if (verboseLevel >1) {
    G4cout << "G4PhysicsListHelper::RegisterProcess :"
       << pName << " for " << particle->GetParticleName()
       << " with  type/subtype =" 
       << pType << "/" << pSubType 
       << " is sucessfully registered with ordering parameters "
       << ord[0] << ":" << ord[1] << ":" << ord[2]
       << G4endl;
    }
#endif
  return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

void G4PhysicsListHelper::SetVerboseLevel ( G4int  value )

inline

Definition at line 126 of file G4PhysicsListHelper.hh.

{  
  verboseLevel = value;
}

void G4PhysicsListHelper::UseCoupledTransportation ( G4bool  vl = true )

inline

Definition at line 120 of file G4PhysicsListHelper.hh.

{ 
  useCoupledTransportation = vl; 
}

---

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

• source/geant4.10.03.p02/source/run/include/G4PhysicsListHelper.hh
• source/geant4.10.03.p02/source/run/src/G4PhysicsListHelper.cc