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 49 of file G4PhysicsListHelper.hh.

Member Function Documentation

AddTransportation()

void G4PhysicsListHelper::AddTransportation

(

)

Definition at line 196 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() != nullptr))
  {
    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 == nullptr) {
      // 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 93 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 288 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 324 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 83 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::ConstructElectronSSProcess(), G4EmBuilder::ConstructIonEmPhysics(), G4EmBuilder::ConstructIonEmPhysicsSS(), G4EmBuilder::ConstructLightHadrons(), G4EmBuilder::ConstructLightHadronsSS(), G4DecayPhysics::ConstructProcess(), G4EmDNAChemistry::ConstructProcess(), G4EmDNAChemistry_option1::ConstructProcess(), G4EmDNAChemistry_option2::ConstructProcess(), G4EmDNAChemistry_option3::ConstructProcess(), G4EmExtraPhysics::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(), G4HadronDElasticPhysics::ConstructProcess(), G4HadronElasticPhysics::ConstructProcess(), G4HadronHElasticPhysics::ConstructProcess(), G4HadronInelasticQBBC::ConstructProcess(), G4HadronInelasticQBBC_ABLA::ConstructProcess(), G4HadronPhysicsFTFQGSP_BERT::ConstructProcess(), G4MuonicAtomDecayPhysics::ConstructProcess(), G4RadioactiveDecayPhysics::ConstructProcess(), G4UnknownDecayPhysics::ConstructProcess(), G4EmDNABuilder::ConstructStandardEmPhysics(), G4EmDNABuilder::FindOrBuildAttachment(), G4EmDNABuilder::FindOrBuildChargeDecrease(), G4EmDNABuilder::FindOrBuildChargeIncrease(), G4EmDNABuilder::FindOrBuildElastic(), G4EmDNABuilder::FindOrBuildElectronSolvation(), G4EmDNABuilder::FindOrBuildExcitation(), G4EmDNABuilder::FindOrBuildIonisation(), G4EmDNABuilder::FindOrBuildNuclearStopping(), G4EmDNABuilder::FindOrBuildVibExcitation(), G4VUserPhysicsList::G4VUserPhysicsList(), G4VUPLData::initialize(), G4VPhysicsConstructor::RegisterProcess(), and G4UserPhysicsListMessenger::SetNewValue().

GetVerboseLevel()

G4int G4PhysicsListHelper::GetVerboseLevel ( ) const

inline

Definition at line 127 of file G4PhysicsListHelper.hh.

{
  return verboseLevel;
}

Referenced by G4MuonicAtomDecayPhysics::ConstructProcess().

RegisterProcess()

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

Definition at line 354 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) {
    auto 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::ConstructElectronSSProcess(), G4EmBuilder::ConstructIonEmPhysics(), G4EmBuilder::ConstructIonEmPhysicsSS(), G4EmBuilder::ConstructLightHadrons(), G4EmBuilder::ConstructLightHadronsSS(), G4DecayPhysics::ConstructProcess(), G4EmDNAChemistry_option1::ConstructProcess(), G4EmDNAChemistry_option3::ConstructProcess(), G4EmExtraPhysics::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(), G4HadronDElasticPhysics::ConstructProcess(), G4HadronElasticPhysics::ConstructProcess(), G4HadronHElasticPhysics::ConstructProcess(), G4HadronInelasticQBBC::ConstructProcess(), G4HadronInelasticQBBC_ABLA::ConstructProcess(), G4HadronPhysicsFTFQGSP_BERT::ConstructProcess(), G4UnknownDecayPhysics::ConstructProcess(), G4EmDNABuilder::ConstructStandardEmPhysics(), G4EmDNABuilder::FindOrBuildAttachment(), G4EmDNABuilder::FindOrBuildChargeDecrease(), G4EmDNABuilder::FindOrBuildChargeIncrease(), G4EmDNABuilder::FindOrBuildElastic(), G4EmDNABuilder::FindOrBuildElectronSolvation(), G4EmDNABuilder::FindOrBuildExcitation(), G4EmDNABuilder::FindOrBuildIonisation(), G4EmDNABuilder::FindOrBuildNuclearStopping(), G4EmDNABuilder::FindOrBuildVibExcitation(), and G4VPhysicsConstructor::RegisterProcess().

SetVerboseLevel()

void G4PhysicsListHelper::SetVerboseLevel ( G4int value )

inline

Definition at line 122 of file G4PhysicsListHelper.hh.

{
  verboseLevel = value;
}

Referenced by G4MuonicAtomDecayPhysics::ConstructProcess().

UseCoupledTransportation()

void G4PhysicsListHelper::UseCoupledTransportation ( G4bool vl = true )

inline

Definition at line 117 of file G4PhysicsListHelper.hh.

{
  useCoupledTransportation = vl;
}

UseHighLooperThresholds()

void G4PhysicsListHelper::UseHighLooperThresholds ( )

inline

Definition at line 69 of file G4PhysicsListHelper.hh.

{ theLooperThresholds = 2; }

UseLowLooperThresholds()

void G4PhysicsListHelper::UseLowLooperThresholds ( )

inline

Definition at line 70 of file G4PhysicsListHelper.hh.

{ theLooperThresholds = 0; }

Friends And Related Symbol Documentation

G4ThreadLocalSingleton< G4PhysicsListHelper >

friend class G4ThreadLocalSingleton< G4PhysicsListHelper >

friend

Definition at line 127 of file G4PhysicsListHelper.hh.

---

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

• G4PhysicsListHelper.hh
• G4PhysicsListHelper.cc