G4PhysicsListHelper Class Reference

#include <G4PhysicsListHelper.hh>

Public Member Functions
G4bool	RegisterProcess (G4VProcess *process, G4ParticleDefinition *particle)
void	AddTransportation ()
void	UseCoupledTransportation (G4bool vl=true)
void	UseHighLooperThresholds ()
void	UseLowLooperThresholds ()
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 ()

Friends
class	G4ThreadLocalSingleton< G4PhysicsListHelper >

Detailed Description

Definition at line 50 of file G4PhysicsListHelper.hh.

Member Function Documentation

AddTransportation()

void G4PhysicsListHelper::AddTransportation

(

)

Definition at line 221 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())
  {
    auto coupledTransport = new G4CoupledTransportation(verboseLevelTransport);
    if(theLooperThresholds == 0)
      coupledTransport->SetLowLooperThresholds();
    if(theLooperThresholds == 2)
      coupledTransport->SetHighLooperThresholds();
    theTransportationProcess = coupledTransport;
 
    if(verboseLevel > 0)
    {
      G4cout << "--- G4CoupledTransportation is used " << G4endl;
    }
  }
  else
  {
    auto simpleTransport = new G4Transportation(verboseLevelTransport);
    if(theLooperThresholds == 0)
      simpleTransport->SetLowLooperThresholds();
    if(theLooperThresholds == 2)
      simpleTransport->SetHighLooperThresholds();
    theTransportationProcess = simpleTransport;
  }
 
  // 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);
  }
}

CheckParticleList()

void G4PhysicsListHelper::CheckParticleList

(

)

const

Definition at line 100 of file G4PhysicsListHelper.cc.

{
  G4bool isElectron         = false;
  G4bool isPositron         = false;
  G4bool isGamma            = false;
  G4bool isProton           = false;
  G4bool isGenericIon       = false;
  G4bool isAnyIon           = false;
  G4bool isAnyChargedBaryon = false;
  G4bool 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(G4int idx = 0; idx < (G4int)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
  G4bool isEmBasic        = isElectron || isPositron || isGamma;
  G4bool 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");
  }
}

DumpOrdingParameterTable()

void G4PhysicsListHelper::DumpOrdingParameterTable

(

G4int

subType = -1

)

const

Definition at line 380 of file G4PhysicsListHelper.cc.

{
  if(theTable == nullptr)
  {
#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(G4int 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;
  }
}

Referenced by G4UserPhysicsListMessenger::SetNewValue().

GetOrdingParameter()

G4PhysicsListOrderingParameter G4PhysicsListHelper::GetOrdingParameter

(

G4int

subType

)

const

Definition at line 426 of file G4PhysicsListHelper.cc.

{
  G4PhysicsListOrderingParameter value;
 
  if(theTable == nullptr)
  {
#ifdef G4VERBOSE
    if(verboseLevel > 0)
    {
      G4cout << "G4PhysicsListHelper::GetOrderingParameter : "
             << " No ordering parameter table  : " << ordParamFileName
             << G4endl;
    }
#endif
    return value;
  }
 
  for(G4int 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;
}

GetPhysicsListHelper()

G4PhysicsListHelper * G4PhysicsListHelper::GetPhysicsListHelper ( )

static

Definition at line 89 of file G4PhysicsListHelper.cc.

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

Referenced by G4HadronicBuilder::BuildElastic(), G4HadronicBuilder::BuildFTFP_INCLXX(), G4HadProcesses::BuildNeutronElastic(), G4HadProcesses::BuildNeutronInelasticAndCapture(), G4EmBuilder::ConstructBasicEmPhysics(), G4EmBuilder::ConstructCharged(), G4EmBuilder::ConstructChargedSS(), G4EmBuilder::ConstructElectronMscProcess(), G4EmBuilder::ConstructIonEmPhysics(), G4EmBuilder::ConstructIonEmPhysicsSS(), G4EmBuilder::ConstructLightHadrons(), G4EmBuilder::ConstructLightHadronsSS(), G4EmDNAChemistry::ConstructProcess(), G4EmDNAChemistry_option1::ConstructProcess(), G4EmDNAChemistry_option3::ConstructProcess(), G4DecayPhysics::ConstructProcess(), G4MuonicAtomDecayPhysics::ConstructProcess(), G4RadioactiveDecayPhysics::ConstructProcess(), G4UnknownDecayPhysics::ConstructProcess(), G4EmDNAChemistry_option2::ConstructProcess(), G4EmLivermorePhysics::ConstructProcess(), G4EmLowEPPhysics::ConstructProcess(), G4EmPenelopePhysics::ConstructProcess(), G4EmStandardPhysics::ConstructProcess(), G4EmStandardPhysics_option1::ConstructProcess(), G4EmStandardPhysics_option2::ConstructProcess(), G4EmStandardPhysics_option3::ConstructProcess(), G4EmStandardPhysics_option4::ConstructProcess(), G4EmStandardPhysicsGS::ConstructProcess(), G4EmStandardPhysicsSS::ConstructProcess(), G4EmStandardPhysicsWVI::ConstructProcess(), G4EmExtraPhysics::ConstructProcess(), G4HadronDElasticPhysics::ConstructProcess(), G4HadronElasticPhysics::ConstructProcess(), G4HadronHElasticPhysics::ConstructProcess(), G4HadronInelasticQBBC::ConstructProcess(), G4HadronPhysicsFTFQGSP_BERT::ConstructProcess(), G4EmDNABuilder::ConstructStandardEmPhysics(), G4EmDNABuilder::FindOrBuildAttachment(), G4EmDNABuilder::FindOrBuildChargeDecrease(), G4EmDNABuilder::FindOrBuildChargeIncrease(), G4EmDNABuilder::FindOrBuildElastic(), G4EmDNABuilder::FindOrBuildElectronSolvation(), G4EmDNABuilder::FindOrBuildExcitation(), G4EmDNABuilder::FindOrBuildIonisation(), G4EmDNABuilder::FindOrBuildVibExcitation(), G4VUserPhysicsList::G4VUserPhysicsList(), G4VUPLData::initialize(), G4VPhysicsConstructor::RegisterProcess(), and G4UserPhysicsListMessenger::SetNewValue().

GetVerboseLevel()

G4int G4PhysicsListHelper::GetVerboseLevel ( ) const

inline

Definition at line 131 of file G4PhysicsListHelper.hh.

{
  return verboseLevel;
}

Referenced by G4MuonicAtomDecayPhysics::ConstructProcess().

RegisterProcess()

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

Definition at line 461 of file G4PhysicsListHelper.cc.

{
  if(theTable == nullptr)
  {
#ifdef G4VERBOSE
    if(verboseLevel > 0)
    {
      G4cout << "G4PhysicsListHelper::RegisterProcess :"
             << " No ordering parameter table  : " << ordParamFileName
             << G4endl;
    }
#endif
    G4Exception("G4PhysicsListHelper::RegisterProcess", "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::RegisterProcess", "Run0108",
                FatalException, "No Matching process Type/SubType");
    return false;
  }
 
  G4bool isFound = false;
  G4int ord[3];
  G4bool duplicable = false;
  for(G4int 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 registered in OrdingParameterTable  " << G4endl;
    }
#endif
    G4Exception("G4PhysicsListHelper::RegisterProcess", "Run0109",
                FatalException, "No Matching process Type/SubType");
    return false;
  }
 
  // Check Process Manager
  G4ProcessManager* pManager = particle->GetProcessManager();
  if(pManager == nullptr)
  {
    // 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 < (G4int)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::RegisterProcess", "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 successfully registered with ordering parameters " << ord[0]
           << ":" << ord[1] << ":" << ord[2] << G4endl;
  }
#endif
  return true;
}

Referenced by G4HadronicBuilder::BuildElastic(), G4HadronicBuilder::BuildFTFP_INCLXX(), G4HadProcesses::BuildNeutronElastic(), G4HadProcesses::BuildNeutronInelasticAndCapture(), G4EmBuilder::ConstructBasicEmPhysics(), G4EmBuilder::ConstructCharged(), G4EmBuilder::ConstructChargedSS(), G4EmBuilder::ConstructElectronMscProcess(), G4EmBuilder::ConstructIonEmPhysics(), G4EmBuilder::ConstructIonEmPhysicsSS(), G4EmBuilder::ConstructLightHadrons(), G4EmBuilder::ConstructLightHadronsSS(), G4EmDNAChemistry_option1::ConstructProcess(), G4EmDNAChemistry_option3::ConstructProcess(), G4DecayPhysics::ConstructProcess(), G4UnknownDecayPhysics::ConstructProcess(), G4EmLivermorePhysics::ConstructProcess(), G4EmLowEPPhysics::ConstructProcess(), G4EmPenelopePhysics::ConstructProcess(), G4EmStandardPhysics::ConstructProcess(), G4EmStandardPhysics_option1::ConstructProcess(), G4EmStandardPhysics_option2::ConstructProcess(), G4EmStandardPhysics_option3::ConstructProcess(), G4EmStandardPhysics_option4::ConstructProcess(), G4EmStandardPhysicsGS::ConstructProcess(), G4EmStandardPhysicsSS::ConstructProcess(), G4EmStandardPhysicsWVI::ConstructProcess(), G4EmExtraPhysics::ConstructProcess(), G4HadronDElasticPhysics::ConstructProcess(), G4HadronElasticPhysics::ConstructProcess(), G4HadronHElasticPhysics::ConstructProcess(), G4HadronInelasticQBBC::ConstructProcess(), G4HadronPhysicsFTFQGSP_BERT::ConstructProcess(), G4EmDNABuilder::ConstructStandardEmPhysics(), G4EmDNABuilder::FindOrBuildAttachment(), G4EmDNABuilder::FindOrBuildChargeDecrease(), G4EmDNABuilder::FindOrBuildChargeIncrease(), G4EmDNABuilder::FindOrBuildElastic(), G4EmDNABuilder::FindOrBuildElectronSolvation(), G4EmDNABuilder::FindOrBuildExcitation(), G4EmDNABuilder::FindOrBuildIonisation(), G4EmDNABuilder::FindOrBuildVibExcitation(), and G4VPhysicsConstructor::RegisterProcess().

SetVerboseLevel()

void G4PhysicsListHelper::SetVerboseLevel ( G4int  value )

inline

Definition at line 126 of file G4PhysicsListHelper.hh.

{
  verboseLevel = value;
}

Referenced by G4MuonicAtomDecayPhysics::ConstructProcess().

UseCoupledTransportation()

void G4PhysicsListHelper::UseCoupledTransportation ( G4bool  vl = true )

inline

Definition at line 121 of file G4PhysicsListHelper.hh.

{
  useCoupledTransportation = vl;
}

UseHighLooperThresholds()

void G4PhysicsListHelper::UseHighLooperThresholds ( )

inline

Definition at line 70 of file G4PhysicsListHelper.hh.

{ theLooperThresholds = 2; }

UseLowLooperThresholds()

void G4PhysicsListHelper::UseLowLooperThresholds ( )

inline

Definition at line 71 of file G4PhysicsListHelper.hh.

{ theLooperThresholds = 0; }

Friends And Related Function Documentation

G4ThreadLocalSingleton< G4PhysicsListHelper >

friend class G4ThreadLocalSingleton< G4PhysicsListHelper >

friend

Definition at line 131 of file G4PhysicsListHelper.hh.

---

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

• G4PhysicsListHelper.hh
• G4PhysicsListHelper.cc