G4EmModelActivator Class Reference

#include <G4EmModelActivator.hh>

Public Member Functions
	G4EmModelActivator (const G4EmModelActivator &)=delete
	G4EmModelActivator (const G4String &emphys="")
G4EmModelActivator &	operator= (const G4EmModelActivator &right)=delete

Private Member Functions
void	ActivateEmOptions ()
void	ActivateMicroElec ()
void	ActivatePAI ()
void	AddStandardScattering (const G4ParticleDefinition *, G4EmConfigurator *, G4VMscModel *, const G4String &, G4double, G4double, const G4String &)
void	FindOrAddProcess (const G4ParticleDefinition *, const G4String &)
G4bool	HasMsc (G4ProcessManager *) const
void	SetMscParameters (const G4ParticleDefinition *, G4VMscModel *, const G4String &phys)

Private Attributes
G4String	baseName
G4EmParameters *	theParameters

Detailed Description

Definition at line 58 of file G4EmModelActivator.hh.

Constructor & Destructor Documentation

G4EmModelActivator() [1/2]

G4EmModelActivator::G4EmModelActivator ( const G4String &  emphys = "" )

explicit

Definition at line 122 of file G4EmModelActivator.cc.

  : baseName(emphys)
{
  theParameters = G4EmParameters::Instance();
 
  const std::vector<G4String>& regnamesPAI = theParameters->RegionsPAI();
  if(regnamesPAI.size() > 0)
  {
    ActivatePAI();
  }
  const std::vector<G4String>& regnamesME = theParameters->RegionsMicroElec();
  if(regnamesME.size() > 0)
  {
    ActivateMicroElec();
  }
  const std::vector<G4String>& regnamesMSC = theParameters->RegionsPhysics();
  if(regnamesMSC.size() > 0)
  {
    ActivateEmOptions();
  }
}

References ActivateEmOptions(), ActivateMicroElec(), ActivatePAI(), G4EmParameters::Instance(), G4EmParameters::RegionsMicroElec(), G4EmParameters::RegionsPAI(), G4EmParameters::RegionsPhysics(), and theParameters.

G4EmModelActivator() [2/2]

G4EmModelActivator::G4EmModelActivator ( const G4EmModelActivator &  )

delete

Member Function Documentation

ActivateEmOptions()

void G4EmModelActivator::ActivateEmOptions ( )

private

Definition at line 146 of file G4EmModelActivator.cc.

{
  const std::vector<G4String>& regnamesPhys = theParameters->RegionsPhysics();
  G4int nreg = regnamesPhys.size();
  if(0 == nreg) { return; }
  G4int verbose = theParameters->Verbose() - 1; 
  if(verbose > 0) {
    G4cout << "### G4EmModelActivator::ActivateEmOptions for " << nreg << " regions"
           << G4endl;
  }
  const std::vector<G4String>& typesPhys = theParameters->TypesPhysics();
 
  // start configuration of models
  const G4ParticleDefinition* elec = G4Electron::Electron();
  const G4ParticleDefinition* posi = G4Positron::Positron();
  const G4ParticleDefinition* phot = G4Gamma::Gamma();
  const G4ParticleDefinition* prot = G4Proton::Proton();
  G4LossTableManager* man = G4LossTableManager::Instance();
  G4EmConfigurator* em_config = man->EmConfigurator();
  G4VAtomDeexcitation* adeexc = man->AtomDeexcitation(); 
  G4ParticleTable* table = G4ParticleTable::GetParticleTable();
  G4VEmModel* mod;
 
  // high energy limit for low-energy e+- model of msc
  G4double mscEnergyLimit = theParameters->MscEnergyLimit();
 
  // high energy limit for Livermore and Penelope models
  G4double highEnergyLimit = 1*GeV;
 
  // general high energy limit
  G4double highEnergy = theParameters->MaxKinEnergy();
 
  for(G4int i=0; i<nreg; ++i) {
    G4String reg = regnamesPhys[i];
    if(verbose > 0) {
      G4cout << i << ". region <" << reg << ">; type <" << typesPhys[i] << "> " 
         << G4endl;
    }
   
    if(baseName == typesPhys[i]) { continue; }
 
    if("G4EmStandard" == typesPhys[i]) {
      G4UrbanMscModel* msc = new G4UrbanMscModel();
      AddStandardScattering(elec, em_config, msc, reg,  mscEnergyLimit, highEnergy, typesPhys[i]);
      
      msc = new G4UrbanMscModel();
      AddStandardScattering(posi, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
 
    } else if("G4EmStandard_opt1" == typesPhys[i] || "G4EmStandard_opt2" == typesPhys[i]) {
      G4UrbanMscModel* msc = new G4UrbanMscModel();
      AddStandardScattering(elec, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
 
      msc = new G4UrbanMscModel();
      AddStandardScattering(posi, em_config, msc, reg,  mscEnergyLimit, highEnergy, typesPhys[i]);
      
    } else if("G4EmStandard_opt3" == typesPhys[i]) { 
 
      G4DummyModel* dummy = new G4DummyModel();
      G4UrbanMscModel* msc = new G4UrbanMscModel();
      SetMscParameters(elec, msc, typesPhys[i]);
      em_config->SetExtraEmModel("e-", "msc", msc, reg);
      FindOrAddProcess(elec, "CoulombScat");
      em_config->SetExtraEmModel("e-", "CoulombScat", dummy, reg);
 
      msc = new G4UrbanMscModel();
      SetMscParameters(posi, msc, typesPhys[i]);
      em_config->SetExtraEmModel("e+", "msc", msc, reg);
      FindOrAddProcess(posi, "CoulombScat");
      em_config->SetExtraEmModel("e+", "CoulombScat", dummy, reg);
 
      msc = new G4UrbanMscModel();
      SetMscParameters(prot, msc, typesPhys[i]);
      em_config->SetExtraEmModel("proton", "msc", msc, reg);
      FindOrAddProcess(prot, "CoulombScat");
      em_config->SetExtraEmModel("proton", "CoulombScat", dummy, reg);
 
      theParameters->SetNumberOfBinsPerDecade(20);
      if(G4Threading::IsMasterThread()) {
        theParameters->SetDeexActiveRegion(reg, true, false, false);
      }
      theParameters->DefineRegParamForDeex(adeexc);
      FindOrAddProcess(phot, "Rayl");
      mod = new G4LivermoreRayleighModel();
      em_config->SetExtraEmModel("gamma", "Rayl", mod, reg);
      FindOrAddProcess(phot, "phot");
      mod = new G4LivermorePhotoElectricModel();
      em_config->SetExtraEmModel("gamma", "phot", mod, reg);
      FindOrAddProcess(phot, "compt");
      mod = new G4KleinNishinaModel();
      em_config->SetExtraEmModel("gamma", "compt", mod, reg);
 
    } else if("G4EmStandard_opt4" == typesPhys[i]) {
      G4VMscModel* msc = new G4GoudsmitSaundersonMscModel();
      AddStandardScattering(elec, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
 
      msc = new G4GoudsmitSaundersonMscModel();
      AddStandardScattering(posi, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
 
      theParameters->SetNumberOfBinsPerDecade(20);
      theParameters->SetUseMottCorrection(true);  
      if(G4Threading::IsMasterThread()) {
        theParameters->SetDeexActiveRegion(reg, true, false, false);
      }
      theParameters->DefineRegParamForDeex(adeexc);
 
      FindOrAddProcess(phot, "Rayl");
      mod = new G4LivermoreRayleighModel();
      em_config->SetExtraEmModel("gamma", "Rayl", mod, reg);
      FindOrAddProcess(phot, "phot");
      mod = new G4LivermorePhotoElectricModel();
      FindOrAddProcess(phot, "compt");
      mod = new G4KleinNishinaModel();
      em_config->SetExtraEmModel("gamma", "compt", mod, reg);
      mod = new G4LowEPComptonModel();
      mod->SetHighEnergyLimit(20*MeV);
      em_config->SetExtraEmModel("gamma", "compt", mod, reg);
      FindOrAddProcess(phot, "conv");
      mod = new G4BetheHeitler5DModel();
      em_config->SetExtraEmModel("gamma", "conv", mod, reg);
 
    } else if("G4EmStandardGS" == typesPhys[i]) {
      G4GoudsmitSaundersonMscModel* msc = new G4GoudsmitSaundersonMscModel();
      AddStandardScattering(elec, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
 
      msc = new G4GoudsmitSaundersonMscModel();
      AddStandardScattering(posi, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
 
    } else if("G4EmStandardWVI" == typesPhys[i]) {
      G4WentzelVIModel* msc = new G4WentzelVIModel();
      AddStandardScattering(elec, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
 
      msc = new G4WentzelVIModel();
      AddStandardScattering(posi, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
 
      theParameters->SetMscThetaLimit(0.15);
 
      if(G4Threading::IsMasterThread()) {
        theParameters->SetDeexActiveRegion(regnamesPhys[i], true, false, false);
      }
      theParameters->DefineRegParamForDeex(adeexc);
 
    } else if("G4EmStandardSS" == typesPhys[i] && 
          baseName != "G4EmStandard_opt3") {
      G4EmParticleList emList;
      for(const auto& particleName : emList.PartNames()) {
    G4ParticleDefinition* particle = table->FindParticle(particleName);
        if(particle && 0.0 != particle->GetPDGCharge()) {
      FindOrAddProcess(particle, "CoulombScat");
      G4eCoulombScatteringModel* sc = new G4eCoulombScatteringModel();
      sc->SetPolarAngleLimit(0.0);
      sc->SetLocked(true);
      em_config->SetExtraEmModel(particleName, "CoulombScat", sc, reg);
          if(particleName == "mu+" || particleName == "mu-") {
        em_config->SetExtraEmModel(particleName, "muMsc", 
                       new G4DummyModel(), reg);
      } else {
        em_config->SetExtraEmModel(particleName, "msc", 
                       new G4DummyModel(), reg);
      }
    }
      }
      if(G4Threading::IsMasterThread()) {
        theParameters->SetDeexActiveRegion(regnamesPhys[i], true, true, true);
      }
      theParameters->DefineRegParamForDeex(adeexc);
 
    } else if("G4EmLivermore" == typesPhys[i]) {
 
      G4VMscModel* msc = new G4GoudsmitSaundersonMscModel();
      AddStandardScattering(elec, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
 
      msc = new G4GoudsmitSaundersonMscModel();
      AddStandardScattering(posi, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
 
      mod = new G4LivermorePhotoElectricModel();
      em_config->SetExtraEmModel("gamma", "phot", mod, reg);
      mod = new G4LivermoreComptonModel();
      em_config->SetExtraEmModel("gamma", "compt", mod, reg);
      mod = new G4LivermoreGammaConversionModel();
      em_config->SetExtraEmModel("gamma", "conv", mod, reg);
 
      FindOrAddProcess(phot, "Rayl");
      mod = new G4LivermoreRayleighModel();
      em_config->SetExtraEmModel("gamma", "Rayl", mod, reg);
 
      mod = new G4LivermoreIonisationModel();
      G4UniversalFluctuation* uf = new G4UniversalFluctuation();
      em_config->SetExtraEmModel("e-", "eIoni", mod, reg, 0.0, 0.1*MeV, uf);
      mod = new G4LivermoreBremsstrahlungModel();
      em_config->SetExtraEmModel("e-", "eBrem", mod, reg, 0.0, highEnergyLimit);
 
      theParameters->SetNumberOfBinsPerDecade(20);
      theParameters->SetUseMottCorrection(true);  
      if(G4Threading::IsMasterThread()) {
        theParameters->SetDeexActiveRegion(regnamesPhys[i], true, false, false);
      }
      theParameters->DefineRegParamForDeex(adeexc);
 
    } else if("G4EmPenelope" == typesPhys[i]) {
 
      G4VMscModel* msc = new G4GoudsmitSaundersonMscModel();
      AddStandardScattering(elec, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
 
      msc = new G4GoudsmitSaundersonMscModel();
      AddStandardScattering(posi, em_config, msc, reg, mscEnergyLimit, highEnergy, typesPhys[i]);
 
      mod = new G4PenelopePhotoElectricModel();
      em_config->SetExtraEmModel("gamma", "phot", mod, reg);
      mod = new G4PenelopeComptonModel();
      em_config->SetExtraEmModel("gamma", "compt", mod, reg);
      mod = new G4PenelopeGammaConversionModel();
      em_config->SetExtraEmModel("gamma", "conv", mod, reg);
 
      FindOrAddProcess(phot, "Rayl");
      mod = new G4PenelopeRayleighModel();
      em_config->SetExtraEmModel("gamma", "Rayl", mod, reg);
 
      mod = new G4PenelopeIonisationModel();
      G4UniversalFluctuation* uf = new G4UniversalFluctuation();
      em_config->SetExtraEmModel("e-", "eIoni", mod, reg, 0.0, highEnergyLimit, uf);
      mod = new G4PenelopeBremsstrahlungModel();
      em_config->SetExtraEmModel("e-", "eBrem", mod, reg, 0.0, highEnergyLimit);
 
      mod = new G4PenelopeIonisationModel();
      uf = new G4UniversalFluctuation();
      em_config->SetExtraEmModel("e+", "eIoni", mod, reg, 0.0, highEnergyLimit, uf);
      mod = new G4PenelopeBremsstrahlungModel();
      em_config->SetExtraEmModel("e+", "eBrem", mod, reg, 0.0, highEnergyLimit);
      mod = new G4PenelopeAnnihilationModel();
      em_config->SetExtraEmModel("e+", "annihil", mod, reg, 0.0, highEnergyLimit);
 
      theParameters->SetNumberOfBinsPerDecade(20);
      theParameters->SetUseMottCorrection(true);  
      if(G4Threading::IsMasterThread()) {
        theParameters->SetDeexActiveRegion(regnamesPhys[i], true, false, false);
      }
      theParameters->DefineRegParamForDeex(adeexc);
 
    } else {
      if(verbose > 0 && G4Threading::IsMasterThread()) {
        G4cout << "### G4EmModelActivator::ActivateEmOptions WARNING: \n"
           << "    EM Physics configuration name <" << typesPhys[i]
           << "> is not known - ignored" << G4endl;
      }
    }
  }
}

References AddStandardScattering(), G4LossTableManager::AtomDeexcitation(), baseName, G4EmParameters::DefineRegParamForDeex(), G4Electron::Electron(), G4LossTableManager::EmConfigurator(), FindOrAddProcess(), G4ParticleTable::FindParticle(), G4cout, G4endl, G4Gamma::Gamma(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetPDGCharge(), GeV, G4LossTableManager::Instance(), G4Threading::IsMasterThread(), G4EmParameters::MaxKinEnergy(), MeV, G4EmParameters::MscEnergyLimit(), G4EmParticleList::PartNames(), G4Positron::Positron(), G4Proton::Proton(), reg, G4EmParameters::RegionsPhysics(), G4EmParameters::SetDeexActiveRegion(), G4EmConfigurator::SetExtraEmModel(), G4VEmModel::SetHighEnergyLimit(), G4VEmModel::SetLocked(), SetMscParameters(), G4EmParameters::SetMscThetaLimit(), G4EmParameters::SetNumberOfBinsPerDecade(), G4VEmModel::SetPolarAngleLimit(), G4EmParameters::SetUseMottCorrection(), theParameters, G4EmParameters::TypesPhysics(), and G4EmParameters::Verbose().

Referenced by G4EmModelActivator().

ActivateMicroElec()

void G4EmModelActivator::ActivateMicroElec ( )

private

Definition at line 502 of file G4EmModelActivator.cc.

{
  const std::vector<G4String> regnamesME = theParameters->RegionsMicroElec();
  G4int nreg = regnamesME.size();
  if(0 == nreg)
  {
    return;
  }
  G4int verbose = theParameters->Verbose() - 1;
  if(verbose > 0)
  {
    G4cout << "### G4EmModelActivator::ActivateMicroElec for " << nreg
           << " regions" << G4endl;
  }
  G4LossTableManager* man = G4LossTableManager::Instance();
 
  const G4ParticleDefinition* elec = G4Electron::Electron();
  const G4ParticleDefinition* prot = G4Proton::Proton();
  const G4ParticleDefinition* gion = G4GenericIon::GenericIon();
  G4ProcessManager* eman = elec->GetProcessManager();
  G4ProcessManager* pman = prot->GetProcessManager();
  G4ProcessManager* iman = gion->GetProcessManager();
 
  G4bool emsc = HasMsc(eman);
 
  // MicroElec elastic is not active in the world 
  G4MicroElecElastic* eElasProc =
      new G4MicroElecElastic("e-G4MicroElecElastic");
  eman->AddDiscreteProcess(eElasProc);
 
  G4MicroElecInelastic* eInelProc =
      new G4MicroElecInelastic("e-G4MicroElecInelastic");
  eman->AddDiscreteProcess(eInelProc);
 
  G4MicroElecInelastic* pInelProc =
      new G4MicroElecInelastic("p_G4MicroElecInelastic");
  pman->AddDiscreteProcess(pInelProc);
 
  G4MicroElecInelastic* iInelProc =
      new G4MicroElecInelastic("ion_G4MicroElecInelastic");
  iman->AddDiscreteProcess(iInelProc);
 
  // start configuration of models
  G4EmConfigurator* em_config = man->EmConfigurator();
  G4VEmModel* mod;
 
  // limits for MicroElec applicability
  G4double elowest = 16.7 * eV;
  G4double elimel = 100 * MeV;
  G4double elimin = 9 * MeV;
  G4double pmin = 50 * keV;
  G4double pmax = 99.9 * MeV;
 
  G4LowECapture* ecap = new G4LowECapture(elowest);
  eman->AddDiscreteProcess(ecap);
 
  for(G4int i = 0; i < nreg; ++i)
  {
 
    G4String reg = regnamesME[i];
    G4cout << "### MicroElec models are activated for G4Region " << reg
           << G4endl
           << "    Energy limits for e- elastic:    " << elowest/eV << " eV - "
           << elimel/MeV << " MeV"
           << G4endl
           << "    Energy limits for e- inelastic:  " << elowest/eV << " eV - "
           << elimin/MeV << " MeV"
           << G4endl
           << "    Energy limits for hadrons/ions:  " << pmin/MeV << " MeV - "
           << pmax/MeV << " MeV"
           << G4endl;
 
    // e-  
    if(emsc)
    {
      G4UrbanMscModel* msc = new G4UrbanMscModel();
      msc->SetActivationLowEnergyLimit(elimel);
      em_config->SetExtraEmModel("e-", "msc", msc, reg);
    }
    else
    {
      mod = new G4DummyModel();
      em_config->SetExtraEmModel("e-", "CoulombScat", mod, reg, 0.0, elimel);
    }
 
    mod = new G4MicroElecElasticModel();
    em_config->SetExtraEmModel("e-",
                               "e-G4MicroElecElastic",
                               mod,
                               reg,
                               elowest,
                               elimin);
 
    mod = new G4MollerBhabhaModel();
    mod->SetActivationLowEnergyLimit(elimin);
    em_config->SetExtraEmModel("e-",
                               "eIoni",
                               mod,
                               reg,
                               0.0,
                               10 * TeV,
                               new G4UniversalFluctuation());
 
    mod = new G4MicroElecInelasticModel();
    em_config->SetExtraEmModel("e-",
                               "e-G4MicroElecInelastic",
                               mod,
                               reg,
                               elowest,
                               elimin);
 
    // proton
    mod = new G4BraggModel();
    mod->SetActivationHighEnergyLimit(pmin);
    em_config->SetExtraEmModel("proton",
                               "hIoni",
                               mod,
                               reg,
                               0.0,
                               2 * MeV,
                               new G4UniversalFluctuation());
 
    mod = new G4BetheBlochModel();
    mod->SetActivationLowEnergyLimit(pmax);
    em_config->SetExtraEmModel("proton",
                               "hIoni",
                               mod,
                               reg,
                               2 * MeV,
                               10 * TeV,
                               new G4UniversalFluctuation());
 
    mod = new G4MicroElecInelasticModel();
    em_config->SetExtraEmModel("proton",
                               "p_G4MicroElecInelastic",
                               mod,
                               reg,
                               pmin,
                               pmax);
 
    // ions
    mod = new G4BraggIonModel();
    mod->SetActivationHighEnergyLimit(pmin);
    em_config->SetExtraEmModel("GenericIon",
                               "ionIoni",
                               mod,
                               reg,
                               0.0,
                               2 * MeV,
                               new G4IonFluctuations());
 
    mod = new G4BetheBlochModel();
    mod->SetActivationLowEnergyLimit(pmax);
    em_config->SetExtraEmModel("GenericIon",
                               "ionIoni",
                               mod,
                               reg,
                               2 * MeV,
                               10 * TeV,
                               new G4IonFluctuations());
 
    mod = new G4MicroElecInelasticModel();
    em_config->SetExtraEmModel("GenericIon",
                               "ion_G4MicroElecInelastic",
                               mod,
                               reg,
                               pmin,
                               pmax);
  }
}

References G4ProcessManager::AddDiscreteProcess(), G4Electron::Electron(), G4LossTableManager::EmConfigurator(), eV, G4cout, G4endl, G4GenericIon::GenericIon(), G4ParticleDefinition::GetProcessManager(), HasMsc(), G4LossTableManager::Instance(), keV, MeV, G4Proton::Proton(), reg, G4EmParameters::RegionsMicroElec(), G4VEmModel::SetActivationHighEnergyLimit(), G4VEmModel::SetActivationLowEnergyLimit(), G4EmConfigurator::SetExtraEmModel(), TeV, theParameters, and G4EmParameters::Verbose().

Referenced by G4EmModelActivator().

ActivatePAI()

void G4EmModelActivator::ActivatePAI ( )

private

Definition at line 396 of file G4EmModelActivator.cc.

{
  const std::vector<G4String> regnamesPAI = theParameters->RegionsPAI();
  G4int nreg = regnamesPAI.size();
  if(0 == nreg) { return; }
  G4int verbose = theParameters->Verbose() - 1;
  if(verbose > 0) {
    G4cout << "### G4EmModelActivator::ActivatePAI for " << nreg << " regions"
           << G4endl;
  }
  const std::vector<G4String> particlesPAI = theParameters->ParticlesPAI();
  const std::vector<G4String> typesPAI = theParameters->TypesPAI();
 
  const std::vector<G4VEnergyLossProcess*>& v = G4LossTableManager::Instance()
      ->GetEnergyLossProcessVector();
 
  G4RegionStore* regionStore = G4RegionStore::GetInstance();
 
  const G4ParticleDefinition* elec = G4Electron::Electron();
  const G4ParticleDefinition* posi = G4Positron::Positron();
  const G4ParticleDefinition* mupl = G4MuonPlus::MuonPlus();
  const G4ParticleDefinition* mumi = G4MuonMinus::MuonMinus();
  const G4ParticleDefinition* gion = G4GenericIon::GenericIon();
 
  for(G4int i = 0; i < nreg; ++i) {
    const G4ParticleDefinition* p = nullptr;
    if(particlesPAI[i] != "all") {
      p = G4ParticleTable::GetParticleTable()->FindParticle(particlesPAI[i]);
      if(!p) {
        G4cout << "### WARNING: ActivatePAI::FindParticle fails to find "
               << particlesPAI[i] << G4endl;
        continue;
      }
    }
    const G4Region* r = regionStore->GetRegion(regnamesPAI[i], false);
    if(!r) {
      G4cout << "### WARNING: ActivatePAI::GetRegion fails to find "
         << regnamesPAI[i] << G4endl;
      continue;
    }
 
    G4String name = "hIoni";
    if(p == elec || p == posi)
      { name = "eIoni"; }
    else if (p == mupl || p == mumi)
      { name = "muIoni"; }
    else if (p == gion)
      { name = "ionIoni"; }
 
    for(auto proc : v) {
 
      if(!proc->IsIonisationProcess()) { continue; }
 
      G4String namep = proc->GetProcessName();
      if(p) {        
    if(name != namep) { continue; }
      } else {
        if(namep != "hIoni" && namep != "muIoni" && 
       namep != "eIoni" && namep != "ionIoni")
      { continue; }
      }
      G4double emin = 50*CLHEP::keV;
      if(namep == "eIoni") emin = 110*CLHEP::eV;
      else if(namep == "muIoni") emin = 5*CLHEP::keV;
 
      G4VEmModel* em = nullptr;
      G4VEmFluctuationModel* fm = nullptr;
      if(typesPAI[i] == "PAIphoton" || typesPAI[i] == "pai_photon") {
    G4PAIPhotModel* mod = new G4PAIPhotModel(p,"PAIPhotModel");
    em = mod;
    fm = mod;
      } else {
    G4PAIModel* mod = new G4PAIModel(p,"PAIModel");
    em = mod;
    fm = mod;
      }
      // added PAI model above low energy limit
      em->SetLowEnergyLimit(emin);
      proc->AddEmModel(0, em, fm, r);
 
      // added low energy model
      if(namep == "eIoni") {
    em = new G4MollerBhabhaModel();
    fm = new G4UniversalFluctuation();
      } else if(namep == "ionIoni") {
    em = new G4BraggIonModel();
        fm = new G4IonFluctuations();
      } else {
    em = new G4BraggModel();
    fm = new G4UniversalFluctuation();
      }
      em->SetHighEnergyLimit(emin);
      proc->AddEmModel(-1, em, fm, r);
 
      if(verbose > 0) {
    G4cout << "### G4EmModelActivator: add <" << typesPAI[i]
           << "> model for " << particlesPAI[i]
           << " in the " << regnamesPAI[i] 
               << " Emin(keV)= " << emin/CLHEP::keV << G4endl;
      }
    }
  }
}

References G4Electron::Electron(), CLHEP::eV, G4ParticleTable::FindParticle(), G4cout, G4endl, G4GenericIon::GenericIon(), G4LossTableManager::GetEnergyLossProcessVector(), G4RegionStore::GetInstance(), G4ParticleTable::GetParticleTable(), G4RegionStore::GetRegion(), G4LossTableManager::Instance(), CLHEP::keV, G4MuonMinus::MuonMinus(), G4MuonPlus::MuonPlus(), G4InuclParticleNames::name(), G4EmParameters::ParticlesPAI(), G4Positron::Positron(), G4EmParameters::RegionsPAI(), G4VEmModel::SetHighEnergyLimit(), G4VEmModel::SetLowEnergyLimit(), theParameters, G4EmParameters::TypesPAI(), and G4EmParameters::Verbose().

Referenced by G4EmModelActivator().

AddStandardScattering()

void G4EmModelActivator::AddStandardScattering ( const G4ParticleDefinition *  part, G4EmConfigurator *  em_config, G4VMscModel *  mscmod, const G4String &  reg, G4double  e1, G4double  e2, const G4String &  type  )

private

Definition at line 693 of file G4EmModelActivator.cc.

{
  G4String pname = part->GetParticleName();
 
  // low-energy msc model
  SetMscParameters(part, mscmod, type);
  em_config->SetExtraEmModel(pname, "msc", mscmod, reg, 0.0, e1);
 
  // high energy msc model
  G4WentzelVIModel* msc = new G4WentzelVIModel();
  SetMscParameters(part, msc, type);
  em_config->SetExtraEmModel(pname, "msc", msc, reg, e1, e2);
 
  // high energy single scattering model
  FindOrAddProcess(part, "CoulombScat");
  G4eCoulombScatteringModel* mod = new G4eCoulombScatteringModel();
  mod->SetActivationLowEnergyLimit(e1);
  mod->SetLocked(true);
  em_config->SetExtraEmModel(pname, "CoulombScat", mod, reg, 0.0, e2);
}

References e1, e2, FindOrAddProcess(), G4ParticleDefinition::GetParticleName(), eplot::pname, reg, G4VEmModel::SetActivationLowEnergyLimit(), G4EmConfigurator::SetExtraEmModel(), G4VEmModel::SetLocked(), and SetMscParameters().

Referenced by ActivateEmOptions().

FindOrAddProcess()

void G4EmModelActivator::FindOrAddProcess ( const G4ParticleDefinition *  part, const G4String &  name  )

private

Definition at line 747 of file G4EmModelActivator.cc.

{
  G4ProcessManager* pm = part->GetProcessManager();
  G4ProcessVector* pv = pm->GetProcessList();
  G4int nproc = pm->GetProcessListLength();
  for(G4int i = 0; i<nproc; ++i) {
    if(((*pv)[i])->GetProcessName() == name) { return; }
  }
  if(name == "CoulombScat") {
    G4CoulombScattering* cs = new G4CoulombScattering();
    cs->SetEmModel(new G4DummyModel());
    pm->AddDiscreteProcess(cs);
  } else if(name == "Rayl") {
    G4RayleighScattering* rs = new G4RayleighScattering();
    rs->SetEmModel(new G4DummyModel());
    pm->AddDiscreteProcess(rs);
  }
}

References G4ProcessManager::AddDiscreteProcess(), G4ProcessManager::GetProcessList(), G4ProcessManager::GetProcessListLength(), G4ParticleDefinition::GetProcessManager(), G4InuclParticleNames::name(), and G4VEmProcess::SetEmModel().

Referenced by ActivateEmOptions(), and AddStandardScattering().

HasMsc()

G4bool G4EmModelActivator::HasMsc ( G4ProcessManager *  pm ) const

private

Definition at line 675 of file G4EmModelActivator.cc.

{
  G4bool res = false;
  G4ProcessVector* pv = pm->GetProcessList();
  G4int nproc = pm->GetProcessListLength();
  for(G4int i = 0; i < nproc; ++i)
  {
    if(((*pv)[i])->GetProcessSubType() == fMultipleScattering)
    {
      res = true;
      break;
    }
  }
  return res;
}

References fMultipleScattering, G4ProcessManager::GetProcessList(), and G4ProcessManager::GetProcessListLength().

Referenced by ActivateMicroElec().

operator=()

G4EmModelActivator & G4EmModelActivator::operator= ( const G4EmModelActivator &  right )

delete

SetMscParameters()

void G4EmModelActivator::SetMscParameters ( const G4ParticleDefinition *  part, G4VMscModel *  msc, const G4String &  phys  )

private

Definition at line 721 of file G4EmModelActivator.cc.

{
  if(part == G4Electron::Electron() || part == G4Positron::Positron()) {
    if(phys == "G4EmStandard_opt1" || phys == "G4EmStandard_opt2") {
      msc->SetRangeFactor(0.2);
      msc->SetStepLimitType(fMinimal);
    } else if(phys == "G4EmStandard_opt3") {
      msc->SetStepLimitType(fUseDistanceToBoundary);
    } else if(phys == "G4EmStandard_opt4" || phys == "G4EmLivermore" || phys == "G4EmPenelope") {
      msc->SetRangeFactor(0.08);
      msc->SetStepLimitType(fUseSafetyPlus);
      msc->SetSkin(3);
    } else if(phys == "G4EmStandardGS") {
      msc->SetRangeFactor(0.06);
    }
  } else {
    if(phys != "G4EmStandard" && phys != "G4EmStandard_opt1" && phys != "G4EmStandard_opt2") {
      msc->SetLateralDisplasmentFlag(true); 
    }
  }
  msc->SetLocked(true);
}

References G4Electron::Electron(), fMinimal, fUseDistanceToBoundary, fUseSafetyPlus, G4Positron::Positron(), G4VMscModel::SetLateralDisplasmentFlag(), G4VEmModel::SetLocked(), G4VMscModel::SetRangeFactor(), G4VMscModel::SetSkin(), and G4VMscModel::SetStepLimitType().

Referenced by ActivateEmOptions(), and AddStandardScattering().

Field Documentation

baseName

G4String G4EmModelActivator::baseName

private

Definition at line 86 of file G4EmModelActivator.hh.

Referenced by ActivateEmOptions().

theParameters

G4EmParameters* G4EmModelActivator::theParameters

private

Definition at line 85 of file G4EmModelActivator.hh.

Referenced by ActivateEmOptions(), ActivateMicroElec(), ActivatePAI(), and G4EmModelActivator().

---

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

• source/physics_lists/constructors/electromagnetic/include/G4EmModelActivator.hh
• source/physics_lists/constructors/electromagnetic/src/G4EmModelActivator.cc