G4PhysicsListHelper Class Reference

#include <G4PhysicsListHelper.hh>

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

Static Public Member Functions
static G4PhysicsListHelper *	GetPhysicsListHelper ()

Private Types
using	G4OrdParamTable = std::vector< G4PhysicsListOrderingParameter >

Private Member Functions
	G4PhysicsListHelper ()
void	ReadInDefaultOrderingParameter ()
void	ReadOrdingParameterTable ()
	~G4PhysicsListHelper ()

Private Attributes
G4ParticleTable::G4PTblDicIterator *	aParticleIterator = nullptr
G4String	ordParamFileName = ""
G4int	sizeOfTable = 0
G4int	theLooperThresholds = 1
G4ParticleTable *	theParticleTable = nullptr
G4OrdParamTable *	theTable = nullptr
G4VProcess *	theTransportationProcess = nullptr
G4bool	useCoupledTransportation = false
G4int	verboseLevel = 1

Static Private Attributes
static G4ThreadLocal G4PhysicsListHelper *	pPLHelper = nullptr

Friends
class	G4ThreadLocalSingleton< G4PhysicsListHelper >

Detailed Description

Definition at line 50 of file G4PhysicsListHelper.hh.

Member Typedef Documentation

G4OrdParamTable

using G4PhysicsListHelper::G4OrdParamTable = std::vector<G4PhysicsListOrderingParameter>

private

Definition at line 100 of file G4PhysicsListHelper.hh.

Constructor & Destructor Documentation

G4PhysicsListHelper()

G4PhysicsListHelper::G4PhysicsListHelper ( )

private

Definition at line 60 of file G4PhysicsListHelper.cc.

{
  // pointer to the particle table
  theParticleTable  = G4ParticleTable::GetParticleTable();
  aParticleIterator = theParticleTable->GetIterator();
 
  ReadOrdingParameterTable();
 
#ifdef G4VERBOSE
  if(verboseLevel > 1)
  {
    DumpOrdingParameterTable();
  }
#endif
}

References aParticleIterator, DumpOrdingParameterTable(), G4ParticleTable::GetIterator(), G4ParticleTable::GetParticleTable(), ReadOrdingParameterTable(), theParticleTable, and verboseLevel.

~G4PhysicsListHelper()

G4PhysicsListHelper::~G4PhysicsListHelper ( )

private

Definition at line 77 of file G4PhysicsListHelper.cc.

{
  if(theTable != nullptr)
  {
    theTable->clear();
    delete theTable;
    theTable    = nullptr;
    sizeOfTable = 0;
  }
}

References sizeOfTable, and theTable.

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);
  }
}

References G4ProcessManager::AddProcess(), aParticleIterator, FatalException, G4cout, G4endl, G4Exception(), G4RunManagerKernel::GetNumberOfParallelWorld(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetParticleType(), G4ParticleDefinition::GetProcessManager(), G4RunManagerKernel::GetRunManagerKernel(), G4ScoringManager::GetScoringManagerIfExist(), idxAlongStep, idxPostStep, G4ParticleTableIterator< K, V >::reset(), G4ProcessManager::SetProcessOrderingToFirst(), theLooperThresholds, theTransportationProcess, useCoupledTransportation, G4ParticleTableIterator< K, V >::value(), and verboseLevel.

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(std::size_t 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
  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");
  }
}

References aParticleIterator, FatalException, fElectromagnetic, G4cout, G4endl, G4Exception(), G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetParticleType(), G4ParticleDefinition::GetPDGCharge(), G4ProcessManager::GetProcessList(), G4ParticleDefinition::GetProcessManager(), G4InuclParticleNames::isElectron(), G4InuclParticleNames::name(), G4ParticleTableIterator< K, V >::reset(), G4ProcessVector::size(), G4ParticleTableIterator< K, V >::value(), and verboseLevel.

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;
  }
}

References G4cout, G4endl, G4PhysicsListOrderingParameter::isDuplicable, G4PhysicsListOrderingParameter::ordering, ordParamFileName, G4PhysicsListOrderingParameter::processSubType, G4PhysicsListOrderingParameter::processType, G4PhysicsListOrderingParameter::processTypeName, sizeOfTable, theTable, and verboseLevel.

Referenced by G4PhysicsListHelper(), and 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;
}

References G4cout, G4endl, G4PhysicsListOrderingParameter::isDuplicable, G4PhysicsListOrderingParameter::ordering, ordParamFileName, G4PhysicsListOrderingParameter::processSubType, G4PhysicsListOrderingParameter::processType, G4PhysicsListOrderingParameter::processTypeName, sizeOfTable, theTable, and verboseLevel.

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;
}

References G4ThreadLocalSingleton< T >::Instance(), and pPLHelper.

Referenced by G4HadronicBuilder::BuildElastic(), G4HadronicBuilder::BuildFTFP_BERT(), G4HadronicBuilder::BuildFTFQGSP_BERT(), G4HadronicBuilder::BuildQGSP_FTFP_BERT(), G4EmBuilder::ConstructBasicEmPhysics(), G4EmBuilder::ConstructCharged(), G4EmBuilder::ConstructChargedSS(), G4EmExtraPhysics::ConstructGammaElectroNuclear(), G4EmDNAPhysics::ConstructGammaPositronProcesses(), G4EmBuilder::ConstructIonEmPhysics(), G4EmBuilder::ConstructIonEmPhysicsSS(), G4EmBuilder::ConstructLightHadrons(), G4EmBuilder::ConstructLightHadronsSS(), G4EmDNAChemistry::ConstructProcess(), G4EmDNAChemistry_option1::ConstructProcess(), G4EmDNAChemistry_option3::ConstructProcess(), G4EmDNAPhysics_option1::ConstructProcess(), G4EmDNAPhysics_option2::ConstructProcess(), G4EmDNAPhysics_option3::ConstructProcess(), G4EmDNAPhysics_option4::ConstructProcess(), G4EmDNAPhysics_option5::ConstructProcess(), G4EmDNAPhysics_option6::ConstructProcess(), G4EmDNAPhysics_option7::ConstructProcess(), G4EmDNAPhysics_option8::ConstructProcess(), G4EmDNAPhysics_stationary_option2::ConstructProcess(), G4EmDNAPhysics_stationary_option4::ConstructProcess(), G4EmDNAPhysics_stationary_option6::ConstructProcess(), G4EmExtraPhysics::ConstructProcess(), G4DecayPhysics::ConstructProcess(), G4MuonicAtomDecayPhysics::ConstructProcess(), G4RadioactiveDecayPhysics::ConstructProcess(), G4UnknownDecayPhysics::ConstructProcess(), G4EmDNAChemistry_option2::ConstructProcess(), G4EmDNAPhysics::ConstructProcess(), G4EmDNAPhysics_stationary::ConstructProcess(), G4EmDNAPhysicsActivator::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(), G4HadronPhysicsFTFQGSP_BERT::ConstructProcess(), 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().

ReadInDefaultOrderingParameter()

void G4PhysicsListHelper::ReadInDefaultOrderingParameter ( )

private

Definition at line 630 of file G4PhysicsListHelper.cc.

{
  G4PhysicsListOrderingParameter tmp;
 
  // NOTE: please use enum values, rather than numerical values, 
  //       for both the processType and processSubType below.
 
  tmp.processTypeName = "Transportation";
  tmp.processType     = fTransportation;
  tmp.processSubType  = TRANSPORTATION;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = 0;
  tmp.ordering[2]     = 0;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "CoupleTrans";
  tmp.processType     = fTransportation;
  tmp.processSubType  = COUPLED_TRANSPORTATION;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = 0;
  tmp.ordering[2]     = 0;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "CoulombScat";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fCoulombScattering;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "Ionisation";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fIonisation;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = 2;
  tmp.ordering[2]     = 2;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "Brems";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fBremsstrahlung;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 3;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "PairProdCharged";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fPairProdByCharged;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 4;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "Annih";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fAnnihilation;
  tmp.ordering[0]     = 5;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 5;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "AnnihToMuMu";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fAnnihilationToMuMu;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 6;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "AnnihToTauTau";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fAnnihilationToTauTau;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 7;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "AnnihToHad";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fAnnihilationToHadrons;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 8;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "NuclearStopp";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fNuclearStopping;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = 9;
  tmp.ordering[2]     = -1;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "ElectronSuper";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fElectronGeneralProcess;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = 1;
  tmp.ordering[2]     = 1;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "Msc";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fMultipleScattering;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = 1;
  tmp.ordering[2]     = -1;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "Rayleigh";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fRayleigh;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "PhotoElectric";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fPhotoElectricEffect;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "Compton";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fComptonScattering;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "Conv";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fGammaConversion;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "ConvToMuMu";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fGammaConversionToMuMu;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "GammaSuper";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fGammaGeneralProcess;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "PositronSuper";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fPositronGeneralProcess;
  tmp.ordering[0]     = 1;
  tmp.ordering[1]     = 1;
  tmp.ordering[2]     = 1;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "Cerenkov";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fCerenkov;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "Scintillation";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fScintillation;
  tmp.ordering[0]     = 9999;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 9999;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "SynchRad";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fSynchrotronRadiation;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "TransRad";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fTransitionRadiation;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "SurfaceRefl";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fSurfaceReflection;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "OpAbsorb";
  tmp.processType     = fOptical;
  tmp.processSubType  = fOpAbsorption;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "OpBoundary";
  tmp.processType     = fOptical;
  tmp.processSubType  = fOpBoundary;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "OpRayleigh";
  tmp.processType     = fOptical;
  tmp.processSubType  = fOpRayleigh;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "OpWLS";
  tmp.processType     = fOptical;
  tmp.processSubType  = fOpWLS;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "OpMieHG";
  tmp.processType     = fOptical;
  tmp.processSubType  = fOpMieHG;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "OpWLS2";
  tmp.processType     = fOptical;
  tmp.processSubType  = fOpWLS2;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "DNAElastic";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fLowEnergyElastic;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "DNAExcit";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fLowEnergyExcitation;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "DNAIonisation";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fLowEnergyIonisation;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "DNAVibExcit";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fLowEnergyVibrationalExcitation;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "DNAAttachment";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fLowEnergyAttachment;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "DNAChargeDec";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fLowEnergyChargeDecrease;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "DNAChargeInc";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fLowEnergyChargeIncrease;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "DNAElecSolv";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fLowEnergyElectronSolvation;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "DNAMolecDecay";
  tmp.processType     = fDecay;
  tmp.processSubType  = fLowEnergyMolecularDecay;
  tmp.ordering[0]     = 1000;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = -1;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "ITTransport";
  tmp.processType     = fTransportation;
  tmp.processSubType  = fLowEnergyTransportation;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = 0;
  tmp.ordering[2]     = 0;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "DNABrownTrans";
  tmp.processType     = fTransportation;
  tmp.processSubType  = fLowEnergyBrownianTransportation;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = 0;
  tmp.ordering[2]     = 0;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "DNADoubleIoni";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fLowEnergyDoubleIonisation;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "DNADoubleCap";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fLowEnergyDoubleCap;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "DNAIoniTransfer";
  tmp.processType     = fElectromagnetic;
  tmp.processSubType  = fLowEnergyIoniTransfer;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "DNAStaticMol";
  tmp.processType     = fUserDefined;
  tmp.processSubType  = fLowEnergyStaticMol;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     =  1000;
  tmp.isDuplicable =  false;
  theTable->push_back(tmp);
  sizeOfTable +=1;
 
  tmp.processTypeName = "HadElastic";
  tmp.processType     = fHadronic;
  tmp.processSubType  = fHadronElastic;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "HadInelastic";
  tmp.processType     = fHadronic;
  tmp.processSubType  = fHadronInelastic;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "HadCapture";
  tmp.processType     = fHadronic;
  tmp.processSubType  = fCapture;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "MuAtomCapture";
  tmp.processType     = fHadronic;
  tmp.processSubType  = fMuAtomicCapture;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "HadFission";
  tmp.processType     = fHadronic;
  tmp.processSubType  = fFission;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "HadAtRest";
  tmp.processType     = fHadronic;
  tmp.processSubType  = fHadronAtRest;
  tmp.ordering[0]     = 1000;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = -1;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "HadCEX";
  tmp.processType     = fHadronic;
  tmp.processSubType  = fChargeExchange;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "Decay";
  tmp.processType     = fDecay;
  tmp.processSubType  = DECAY;
  tmp.ordering[0]     = 1000;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "DecayWSpin";
  tmp.processType     = fDecay;
  tmp.processSubType  = DECAY_WithSpin;
  tmp.ordering[0]     = 1000;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "DecayPiSpin";
  tmp.processType     = fDecay;
  tmp.processSubType  = DECAY_PionMakeSpin;
  tmp.ordering[0]     = 1000;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "DecayRadio";
  tmp.processType     = fDecay;
  tmp.processSubType  = DECAY_Radioactive;
  tmp.ordering[0]     = 1000;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "DecayUnKnown";
  tmp.processType     = fDecay;
  tmp.processSubType  = DECAY_Unknown;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "DecayMuAtom";
  tmp.processType     = fDecay;
  tmp.processSubType  = DECAY_MuAtom;
  tmp.ordering[0]     = 1000;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "DecayExt";
  tmp.processType     = fDecay;
  tmp.processSubType  = DECAY_External;
  tmp.ordering[0]     = 1000;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "StepLimiter";
  tmp.processType     = fGeneral;
  tmp.processSubType  = STEP_LIMITER;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "UsrSepcCuts";
  tmp.processType     = fGeneral;
  tmp.processSubType  = USER_SPECIAL_CUTS;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "NeutronKiller";
  tmp.processType     = fGeneral;
  tmp.processSubType  = NEUTRON_KILLER;
  tmp.ordering[0]     = -1;
  tmp.ordering[1]     = -1;
  tmp.ordering[2]     = 1000;
  tmp.isDuplicable    = false;
  theTable->push_back(tmp);
  sizeOfTable += 1;
 
  tmp.processTypeName = "ParallelWorld";
  tmp.processType     = fParallel;
  tmp.processSubType  = PARALLEL_WORLD_PROCESS;
  tmp.ordering[0]     = 9900;
  tmp.ordering[1]     = 1;
  tmp.ordering[2]     = 9900;
  tmp.isDuplicable    = true;
  theTable->push_back(tmp);
  sizeOfTable += 1;
}

References COUPLED_TRANSPORTATION, DECAY, DECAY_External, DECAY_MuAtom, DECAY_PionMakeSpin, DECAY_Radioactive, DECAY_Unknown, DECAY_WithSpin, fAnnihilation, fAnnihilationToHadrons, fAnnihilationToMuMu, fAnnihilationToTauTau, fBremsstrahlung, fCapture, fCerenkov, fChargeExchange, fComptonScattering, fCoulombScattering, fDecay, fElectromagnetic, fElectronGeneralProcess, fFission, fGammaConversion, fGammaConversionToMuMu, fGammaGeneralProcess, fGeneral, fHadronAtRest, fHadronElastic, fHadronic, fHadronInelastic, fIonisation, fLowEnergyAttachment, fLowEnergyBrownianTransportation, fLowEnergyChargeDecrease, fLowEnergyChargeIncrease, fLowEnergyDoubleCap, fLowEnergyDoubleIonisation, fLowEnergyElastic, fLowEnergyElectronSolvation, fLowEnergyExcitation, fLowEnergyIonisation, fLowEnergyIoniTransfer, fLowEnergyMolecularDecay, fLowEnergyStaticMol, fLowEnergyTransportation, fLowEnergyVibrationalExcitation, fMuAtomicCapture, fMultipleScattering, fNuclearStopping, fOpAbsorption, fOpBoundary, fOpMieHG, fOpRayleigh, fOptical, fOpWLS, fOpWLS2, fPairProdByCharged, fParallel, fPhotoElectricEffect, fPositronGeneralProcess, fRayleigh, fScintillation, fSurfaceReflection, fSynchrotronRadiation, fTransitionRadiation, fTransportation, fUserDefined, G4PhysicsListOrderingParameter::isDuplicable, NEUTRON_KILLER, G4PhysicsListOrderingParameter::ordering, PARALLEL_WORLD_PROCESS, G4PhysicsListOrderingParameter::processSubType, G4PhysicsListOrderingParameter::processType, G4PhysicsListOrderingParameter::processTypeName, sizeOfTable, STEP_LIMITER, theTable, TRANSPORTATION, and USER_SPECIAL_CUTS.

Referenced by ReadOrdingParameterTable().

ReadOrdingParameterTable()

void G4PhysicsListHelper::ReadOrdingParameterTable ( )

private

Definition at line 294 of file G4PhysicsListHelper.cc.

{
  G4bool readInFile = false;
  std::ifstream fIn;
 
  if(std::getenv("G4ORDPARAMTABLE"))
  {
    ordParamFileName = std::getenv("G4ORDPARAMTABLE");
#ifdef G4VERBOSE
    if(verboseLevel > 1)
    {
      G4cout << "G4PhysicsListHelper::ReadOrdingParameterTable  :"
             << ordParamFileName << " is assigned to Ordering Parameter Table "
             << G4endl;
    }
#endif
    // open input file //
    fIn.open(ordParamFileName, std::ios::in);
    // check if the file has been opened successfully
    if(!fIn)
    {
#ifdef G4VERBOSE
      if(verboseLevel > 0)
      {
        G4cout << "G4PhysicsListHelper::ReadOrdingParameterTable  "
               << " Can not open file " << ordParamFileName << G4endl;
      }
#endif
      G4Exception("G4PhysicsListHelper::ReadOrdingParameterTable", "Run0105",
                  JustWarning, "Fail to open ordering parameter table ");
    }
    else
    {
      readInFile = true;
    }
  }
 
  // create OrdParamTable
  if(theTable != nullptr)
  {
    theTable->clear();
    delete theTable;
    theTable    = nullptr;
    sizeOfTable = 0;
  }
  theTable    = new G4OrdParamTable();
  sizeOfTable = 0;
 
  if(readInFile)
  {
    // read in the file and fill the table
    while(!fIn.eof())
    {
      G4PhysicsListOrderingParameter tmp;
      G4int flag;
      fIn >> tmp.processTypeName >> tmp.processType >> tmp.processSubType >>
        tmp.ordering[0] >> tmp.ordering[1] >> tmp.ordering[2] >> flag;
      tmp.isDuplicable = (flag != 0);
      theTable->push_back(tmp);
      ++sizeOfTable;
    }
    fIn.close();
  }
  else
  {
    ReadInDefaultOrderingParameter();
  }
 
  if(sizeOfTable == 0)
  {
#ifdef G4VERBOSE
    if(verboseLevel > 0)
    {
      G4cout << "G4PhysicsListHelper::ReadOrdingParameterTable "
             << " Empty file " << ordParamFileName << G4endl;
    }
#endif
    G4Exception("G4PhysicsListHelper::ReadOrdingParameterTable", "Run0106",
                JustWarning, "The ordering parameter table is empty ");
    delete theTable;
    theTable = nullptr;
  }
  return;
}

References G4cout, G4endl, G4Exception(), G4PhysicsListOrderingParameter::isDuplicable, JustWarning, G4PhysicsListOrderingParameter::ordering, ordParamFileName, G4PhysicsListOrderingParameter::processSubType, G4PhysicsListOrderingParameter::processType, G4PhysicsListOrderingParameter::processTypeName, ReadInDefaultOrderingParameter(), sizeOfTable, theTable, and verboseLevel.

Referenced by G4PhysicsListHelper().

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(std::size_t 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::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;
}

References G4ProcessManager::AddProcess(), FatalException, G4cout, G4endl, G4Exception(), G4ParticleDefinition::GetParticleName(), G4ProcessManager::GetProcessList(), G4ParticleDefinition::GetProcessManager(), G4VProcess::GetProcessName(), G4VProcess::GetProcessSubType(), G4VProcess::GetProcessType(), G4PhysicsListOrderingParameter::isDuplicable, JustWarning, G4PhysicsListOrderingParameter::ordering, ordParamFileName, G4PhysicsListOrderingParameter::processSubType, G4PhysicsListOrderingParameter::processType, G4ProcessManager::SetProcessOrdering(), G4ProcessManager::SetProcessOrderingToFirst(), G4ProcessManager::SetProcessOrderingToLast(), G4ProcessVector::size(), sizeOfTable, theTable, and verboseLevel.

Referenced by G4HadronicBuilder::BuildElastic(), G4HadronicBuilder::BuildFTFP_BERT(), G4HadronicBuilder::BuildFTFQGSP_BERT(), G4HadronicBuilder::BuildQGSP_FTFP_BERT(), G4EmBuilder::ConstructBasicEmPhysics(), G4EmBuilder::ConstructCharged(), G4EmBuilder::ConstructChargedSS(), G4EmExtraPhysics::ConstructGammaElectroNuclear(), G4EmDNAPhysics::ConstructGammaPositronProcesses(), G4EmBuilder::ConstructIonEmPhysics(), G4EmBuilder::ConstructIonEmPhysicsSS(), G4EmBuilder::ConstructLightHadrons(), G4EmBuilder::ConstructLightHadronsSS(), G4EmDNAChemistry_option1::ConstructProcess(), G4EmDNAChemistry_option3::ConstructProcess(), G4EmDNAPhysics_option1::ConstructProcess(), G4EmDNAPhysics_option2::ConstructProcess(), G4EmDNAPhysics_option3::ConstructProcess(), G4EmDNAPhysics_option4::ConstructProcess(), G4EmDNAPhysics_option5::ConstructProcess(), G4EmDNAPhysics_option6::ConstructProcess(), G4EmDNAPhysics_option7::ConstructProcess(), G4EmDNAPhysics_option8::ConstructProcess(), G4EmDNAPhysics_stationary_option2::ConstructProcess(), G4EmDNAPhysics_stationary_option4::ConstructProcess(), G4EmDNAPhysics_stationary_option6::ConstructProcess(), G4EmExtraPhysics::ConstructProcess(), G4DecayPhysics::ConstructProcess(), G4UnknownDecayPhysics::ConstructProcess(), G4EmDNAPhysics::ConstructProcess(), G4EmDNAPhysics_stationary::ConstructProcess(), G4EmDNAPhysicsActivator::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(), G4HadronPhysicsFTFQGSP_BERT::ConstructProcess(), and G4VPhysicsConstructor::RegisterProcess().

SetVerboseLevel()

void G4PhysicsListHelper::SetVerboseLevel ( G4int  value )

inline

Definition at line 126 of file G4PhysicsListHelper.hh.

{
  verboseLevel = value;
}

References verboseLevel.

Referenced by G4MuonicAtomDecayPhysics::ConstructProcess().

UseCoupledTransportation()

void G4PhysicsListHelper::UseCoupledTransportation ( G4bool  vl = true )

inline

Definition at line 121 of file G4PhysicsListHelper.hh.

{
  useCoupledTransportation = vl;
}

References useCoupledTransportation.

UseHighLooperThresholds()

void G4PhysicsListHelper::UseHighLooperThresholds ( )

inline

Definition at line 70 of file G4PhysicsListHelper.hh.

{ theLooperThresholds = 2; }

References theLooperThresholds.

UseLowLooperThresholds()

void G4PhysicsListHelper::UseLowLooperThresholds ( )

inline

Definition at line 71 of file G4PhysicsListHelper.hh.

{ theLooperThresholds = 0; }

References theLooperThresholds.

Friends And Related Function Documentation

G4ThreadLocalSingleton< G4PhysicsListHelper >

friend class G4ThreadLocalSingleton< G4PhysicsListHelper >

friend

Definition at line 131 of file G4PhysicsListHelper.hh.

Field Documentation

aParticleIterator

G4ParticleTable::G4PTblDicIterator* G4PhysicsListHelper::aParticleIterator = nullptr

private

Definition at line 105 of file G4PhysicsListHelper.hh.

Referenced by AddTransportation(), CheckParticleList(), and G4PhysicsListHelper().

ordParamFileName

G4String G4PhysicsListHelper::ordParamFileName = ""

private

Definition at line 116 of file G4PhysicsListHelper.hh.

Referenced by DumpOrdingParameterTable(), GetOrdingParameter(), ReadOrdingParameterTable(), and RegisterProcess().

pPLHelper

G4ThreadLocal G4PhysicsListHelper * G4PhysicsListHelper::pPLHelper = nullptr

staticprivate

Definition at line 102 of file G4PhysicsListHelper.hh.

Referenced by GetPhysicsListHelper().

sizeOfTable

G4int G4PhysicsListHelper::sizeOfTable = 0

private

Definition at line 115 of file G4PhysicsListHelper.hh.

Referenced by DumpOrdingParameterTable(), GetOrdingParameter(), ReadInDefaultOrderingParameter(), ReadOrdingParameterTable(), RegisterProcess(), and ~G4PhysicsListHelper().

theLooperThresholds

G4int G4PhysicsListHelper::theLooperThresholds = 1

private

Definition at line 109 of file G4PhysicsListHelper.hh.

Referenced by AddTransportation(), UseHighLooperThresholds(), and UseLowLooperThresholds().

theParticleTable

G4ParticleTable* G4PhysicsListHelper::theParticleTable = nullptr

private

Definition at line 104 of file G4PhysicsListHelper.hh.

Referenced by G4PhysicsListHelper().

theTable

G4OrdParamTable* G4PhysicsListHelper::theTable = nullptr

private

Definition at line 114 of file G4PhysicsListHelper.hh.

Referenced by DumpOrdingParameterTable(), GetOrdingParameter(), ReadInDefaultOrderingParameter(), ReadOrdingParameterTable(), RegisterProcess(), and ~G4PhysicsListHelper().

theTransportationProcess

G4VProcess* G4PhysicsListHelper::theTransportationProcess = nullptr

private

Definition at line 110 of file G4PhysicsListHelper.hh.

Referenced by AddTransportation().

useCoupledTransportation

G4bool G4PhysicsListHelper::useCoupledTransportation = false

private

Definition at line 108 of file G4PhysicsListHelper.hh.

Referenced by AddTransportation(), and UseCoupledTransportation().

verboseLevel

G4int G4PhysicsListHelper::verboseLevel = 1

private

Definition at line 112 of file G4PhysicsListHelper.hh.

Referenced by AddTransportation(), CheckParticleList(), DumpOrdingParameterTable(), G4PhysicsListHelper(), GetOrdingParameter(), ReadOrdingParameterTable(), RegisterProcess(), and SetVerboseLevel().

---

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

• source/run/include/G4PhysicsListHelper.hh
• source/run/src/G4PhysicsListHelper.cc