G4EmConfigurator Class Reference

#include <G4EmConfigurator.hh>

Public Member Functions
void	AddModels ()
void	Clear ()
	G4EmConfigurator (const G4EmConfigurator &)=delete
	G4EmConfigurator (G4int verboseLevel=1)
G4EmConfigurator &	operator= (const G4EmConfigurator &right)=delete
void	PrepareModels (const G4ParticleDefinition *aParticle, G4VEmProcess *p)
void	PrepareModels (const G4ParticleDefinition *aParticle, G4VEnergyLossProcess *p)
void	PrepareModels (const G4ParticleDefinition *aParticle, G4VMultipleScattering *p)
void	SetExtraEmModel (const G4String &particleName, const G4String &processName, G4VEmModel *, const G4String &regionName="", G4double emin=0.0, G4double emax=DBL_MAX, G4VEmFluctuationModel *fm=nullptr)
void	SetVerbose (G4int value)
	~G4EmConfigurator ()

Private Member Functions
const G4Region *	FindRegion (const G4String &)
void	SetModelForRegion (G4VEmModel *model, G4VEmFluctuationModel *fm, const G4Region *reg, const G4String &particleName, const G4String &processName, G4double emin, G4double emax)
G4bool	UpdateModelEnergyRange (G4VEmModel *mod, G4double emin, G4double emax)

Private Attributes
std::vector< G4VEmFluctuationModel * >	flucModels
std::vector< G4double >	highEnergy
G4int	index
std::vector< G4double >	lowEnergy
std::vector< G4VEmModel * >	models
std::vector< G4String >	particles
std::vector< G4String >	processes
std::vector< G4String >	regions
G4int	verbose

Detailed Description

Definition at line 62 of file G4EmConfigurator.hh.

Constructor & Destructor Documentation

G4EmConfigurator() [1/2]

G4EmConfigurator::G4EmConfigurator ( G4int  verboseLevel = 1 )

explicit

Definition at line 64 of file G4EmConfigurator.cc.

                                           :verbose(val)
{
  index = -10;
}

References index.

~G4EmConfigurator()

G4EmConfigurator::~G4EmConfigurator

(

)

Definition at line 71 of file G4EmConfigurator.cc.

{}

G4EmConfigurator() [2/2]

G4EmConfigurator::G4EmConfigurator ( const G4EmConfigurator &  )

delete

Member Function Documentation

AddModels()

void G4EmConfigurator::AddModels

(

)

Definition at line 110 of file G4EmConfigurator.cc.

{
  size_t n = models.size();
  if(0 < verbose) {
    G4cout << "### G4EmConfigurator::AddModels n= " << n << G4endl;
  }
  if(n > 0) {
    for(size_t i=0; i<n; ++i) {
      if(nullptr != models[i]) {
        const G4Region* reg = FindRegion(regions[i]);
        if(nullptr != reg) {
          --index;
          SetModelForRegion(models[i],flucModels[i],reg,
                            particles[i],processes[i],
                            lowEnergy[i],highEnergy[i]);
        }
      }
    }
  }
  Clear();
}

References Clear(), FindRegion(), flucModels, G4cout, G4endl, highEnergy, index, lowEnergy, models, CLHEP::detail::n, particles, processes, reg, regions, SetModelForRegion(), and verbose.

Clear()

void G4EmConfigurator::Clear

(

)

Definition at line 344 of file G4EmConfigurator.cc.

{
  particles.clear();
  processes.clear();
  models.clear();
  flucModels.clear();
  regions.clear();
  lowEnergy.clear();
  highEnergy.clear();
}

References flucModels, highEnergy, lowEnergy, models, particles, processes, and regions.

Referenced by AddModels(), G4LossTableManager::BuildPhysicsTable(), and G4LossTableManager::LocalPhysicsTables().

FindRegion()

const G4Region * G4EmConfigurator::FindRegion ( const G4String &  regionName )

private

Definition at line 357 of file G4EmConfigurator.cc.

{
  // search for region
  const G4Region* reg = nullptr;
  G4RegionStore* regStore = G4RegionStore::GetInstance();
  G4String r = regionName;
  if(r == "" || r == "world" || r == "World") { 
    r = "DefaultRegionForTheWorld";
  }
  reg = regStore->GetRegion(r, true); 
  if(nullptr == reg) {
    G4cout << "### G4EmConfigurator WARNING: fails to find a region <"
           << r << G4endl;
  } else if(verbose > 1) {
    G4cout << "### G4EmConfigurator finds out G4Region <" << r << ">" 
           << G4endl;
  } 
  return reg;  
}

References G4cout, G4endl, G4RegionStore::GetInstance(), G4RegionStore::GetRegion(), reg, and verbose.

Referenced by AddModels(), and PrepareModels().

operator=()

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

delete

PrepareModels() [1/3]

void G4EmConfigurator::PrepareModels	(	const G4ParticleDefinition *	aParticle,
		G4VEmProcess *	p
	)

Definition at line 266 of file G4EmConfigurator.cc.

{
  size_t n = particles.size();
  if(1 < verbose) {
    G4cout << " G4EmConfigurator::PrepareModels for EM process n= " 
           << n << G4endl;
  }
  if(n > 0) {
    G4String particleName = aParticle->GetParticleName(); 
    G4String processName  = p->GetProcessName(); 
    //G4cout <<  particleName << "  " <<  particleName << G4endl;
    for(size_t i=0; i<n; ++i) {
      if(processName == processes[i]) {
        if((particleName == particles[i]) ||
           (particles[i] == "all") ||
           (particles[i] == "charged" && aParticle->GetPDGCharge() != 0.0)) {
          const G4Region* reg = FindRegion(regions[i]);
          //G4cout << "Region " << reg << G4endl;
          if(nullptr != reg) {
            --index;
            G4VEmModel* mod = models[i];
            if(nullptr != mod) {
              if(UpdateModelEnergyRange(mod, lowEnergy[i], highEnergy[i])) { 
                p->AddEmModel(index,mod,reg);
                if(1 < verbose) {
                  G4cout << "### Added em model order= " << index << " for " 
                         << particleName << " and " << processName << G4endl;
                }
              }
            }
          }
        }
      }
    }
  }
}

References G4VEmProcess::AddEmModel(), FindRegion(), G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGCharge(), G4VProcess::GetProcessName(), highEnergy, index, lowEnergy, models, CLHEP::detail::n, particles, processes, reg, regions, UpdateModelEnergyRange(), and verbose.

PrepareModels() [2/3]

void G4EmConfigurator::PrepareModels	(	const G4ParticleDefinition *	aParticle,
		G4VEnergyLossProcess *	p
	)

Definition at line 220 of file G4EmConfigurator.cc.

{
  size_t n = particles.size();
  if(1 < verbose) {
    G4cout << " G4EmConfigurator::PrepareModels for EnergyLoss n= " 
           << n << G4endl;
  }
  if(n > 0) {
    G4String particleName = aParticle->GetParticleName(); 
    G4String processName  = p->GetProcessName(); 
    //G4cout <<  particleName << "  " <<  processName << G4endl;
    for(size_t i=0; i<n; ++i) {
      //G4cout <<  particles[i] << "  " <<  processes[i] << G4endl;
      if(processName == processes[i]) {
        if((particleName == particles[i]) ||
           (particles[i] == "all") ||
           (particles[i] == "charged" && aParticle->GetPDGCharge() != 0.0)) {
          const G4Region* reg = FindRegion(regions[i]);
          //G4cout << "Region " << reg << G4endl;
          if(nullptr != reg) {
            --index;
            G4VEmModel* mod = models[i];
            G4VEmFluctuationModel* fm = flucModels[i];
            if(nullptr != mod) {
              if(UpdateModelEnergyRange(mod, lowEnergy[i], highEnergy[i])) {
                p->AddEmModel(index,mod,fm,reg);
                if(1 < verbose) {
                  G4cout << "### Added eloss model order= " << index << " for " 
                         << particleName << " and " << processName 
             << " for " << reg->GetName() << G4endl;
                }
              }
            } else if(nullptr != fm) {
              p->SetFluctModel(fm);
            }
          }
        }
      }
    }
  }
}

References G4VEnergyLossProcess::AddEmModel(), FindRegion(), flucModels, G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGCharge(), G4VProcess::GetProcessName(), highEnergy, index, lowEnergy, models, CLHEP::detail::n, particles, processes, reg, regions, G4VEnergyLossProcess::SetFluctModel(), UpdateModelEnergyRange(), and verbose.

Referenced by G4LossTableManager::PreparePhysicsTable().

PrepareModels() [3/3]

void G4EmConfigurator::PrepareModels	(	const G4ParticleDefinition *	aParticle,
		G4VMultipleScattering *	p
	)

Definition at line 307 of file G4EmConfigurator.cc.

{
  size_t n = particles.size();
  if(1 < verbose) {
    G4cout << " G4EmConfigurator::PrepareModels for MSC process n= " 
           << n << G4endl;
  }
 
  if(n > 0) {
    G4String particleName = aParticle->GetParticleName(); 
    G4String processName  = p->GetProcessName(); 
    for(size_t i=0; i<n; ++i) {
      if(processName == processes[i]) {
        if((particleName == particles[i]) ||
           (particles[i] == "all") ||
           (particles[i] == "charged" && aParticle->GetPDGCharge() != 0.0)) {
          const G4Region* reg = FindRegion(regions[i]);
          if(nullptr != reg) {
            --index;
            G4VEmModel* mod = models[i];
            if(nullptr != mod) {
              if(UpdateModelEnergyRange(mod, lowEnergy[i], highEnergy[i])) { 
                p->AddEmModel(index,mod,reg);
                //G4cout << "### Added msc model order= " << index << " for " 
                //     << particleName << " and " << processName << G4endl;
              }
            }
          }
        }
      }
    }
  }
}

References G4VMultipleScattering::AddEmModel(), FindRegion(), G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4ParticleDefinition::GetPDGCharge(), G4VProcess::GetProcessName(), highEnergy, index, lowEnergy, models, CLHEP::detail::n, particles, processes, reg, regions, UpdateModelEnergyRange(), and verbose.

SetExtraEmModel()

void G4EmConfigurator::SetExtraEmModel	(	const G4String &	particleName,
		const G4String &	processName,
		G4VEmModel *	mod,
		const G4String &	regionName = "",
		G4double	emin = 0.0,
		G4double	emax = DBL_MAX,
		G4VEmFluctuationModel *	fm = nullptr
	)

Definition at line 76 of file G4EmConfigurator.cc.

{
  if(nullptr == mod) { return; }
  if(1 < verbose) {
    G4cout << " G4EmConfigurator::SetExtraEmModel " << mod->GetName()
           << " for " << particleName 
           << " and " << processName 
           << " in the region <" << regionName
           << "> Emin(MeV)= " << emin/MeV
           << " Emax(MeV)= " << emax/MeV
           << G4endl;
  }
 
  models.push_back(mod);
  flucModels.push_back(fm);
  G4double emin0 = std::max(emin, mod->LowEnergyLimit());
  G4double emax0 = std::min(emax, mod->HighEnergyLimit());
  mod->SetActivationHighEnergyLimit(emax0);
 
  particles.push_back(particleName);
  processes.push_back(processName);
  regions.push_back(regionName);
  lowEnergy.push_back(emin0);
  highEnergy.push_back(emax0);
}

References emax, flucModels, G4cout, G4endl, G4VEmModel::GetName(), highEnergy, G4VEmModel::HighEnergyLimit(), lowEnergy, G4VEmModel::LowEnergyLimit(), G4INCL::Math::max(), MeV, G4INCL::Math::min(), models, particles, processes, regions, G4VEmModel::SetActivationHighEnergyLimit(), and verbose.

Referenced by G4EmModelActivator::ActivateEmOptions(), G4EmModelActivator::ActivateMicroElec(), G4EmDNAPhysicsActivator::AddElectronModels0(), G4EmDNAPhysicsActivator::AddElectronModels2(), G4EmDNAPhysicsActivator::AddElectronModels4(), G4EmDNAPhysicsActivator::AddElectronModels4a(), G4EmDNAPhysicsActivator::AddElectronModels6(), G4EmDNAPhysicsActivator::AddElectronModels6a(), G4EmDNAPhysicsActivator::AddElectronModels7(), G4EmDNAPhysicsActivator::AddGenericIonModels0(), G4EmDNAPhysicsActivator::AddHeliumModels0(), G4EmDNAPhysicsActivator::AddProtonModels0(), and G4EmModelActivator::AddStandardScattering().

SetModelForRegion()

void G4EmConfigurator::SetModelForRegion ( G4VEmModel *  model, G4VEmFluctuationModel *  fm, const G4Region *  reg, const G4String &  particleName, const G4String &  processName, G4double  emin, G4double  emax  )

private

Definition at line 134 of file G4EmConfigurator.cc.

{
  if(nullptr == mod) { return; }
  if(1 < verbose) {
    G4cout << " G4EmConfigurator::SetModelForRegion: " << mod->GetName() 
           << G4endl;
    G4cout << " For " << particleName 
           << " and " << processName 
           << " in the region <" << reg->GetName()
           << " Emin(MeV)= " << emin/MeV
           << " Emax(MeV)= " << emax/MeV;
    if(nullptr != fm) { G4cout << " FLmodel " << fm->GetName(); }
    G4cout << G4endl;
  }
 
  // Loop checking, 03-Aug-2015, Vladimir Ivanchenko
  auto myParticleIterator = G4ParticleTable::GetParticleTable()->GetIterator();
  myParticleIterator->reset();
  while( (*myParticleIterator)() ) {
    const G4ParticleDefinition* part = myParticleIterator->value();
 
    if((part->GetParticleName() == particleName) ||
       (particleName == "all") ||
       (particleName == "charged" && part->GetPDGCharge() != 0.0)) {
 
      // search for process
      G4ProcessManager* pmanager = part->GetProcessManager();
      G4ProcessVector* plist = pmanager->GetProcessList();
      G4int np = pmanager->GetProcessListLength();
  
      if(1 < verbose) {
    G4cout << "Check process <" << processName << "> for " 
           << particleName << " in list of " << np << " processes" 
           << G4endl;
      }
      G4VProcess* proc = nullptr;
      for(G4int i=0; i<np; ++i) {
        if(processName == (*plist)[i]->GetProcessName()) {
          proc = (*plist)[i];
          break;
        }
      }
      if(nullptr == proc) {
        G4cout << "### G4EmConfigurator WARNING: fails to find a process <"
               << processName << "> for " << particleName << G4endl;
        return;        
      } 
 
      if(!UpdateModelEnergyRange(mod, emin, emax)) { return; }
      // classify process
      G4int ii = proc->GetProcessSubType();
      if(10 == ii) {
        G4VMultipleScattering* p = static_cast<G4VMultipleScattering*>(proc);
    p->AddEmModel(index,mod,reg);
    if(1 < verbose) {
      G4cout << "### Added msc model order= " << index << " for " 
         << particleName << " and " << processName << G4endl;
    }
      } else if(2 <= ii && 4 >= ii) {
        G4VEnergyLossProcess* p = static_cast<G4VEnergyLossProcess*>(proc);
    p->AddEmModel(index,mod,fm,reg);
    if(1 < verbose) {
      G4cout << "### Added eloss model order= " << index << " for " 
         << particleName << " and " << processName << G4endl;
        }
      } else {
        G4VEmProcess* p = static_cast<G4VEmProcess*>(proc);
        p->AddEmModel(index,mod,reg);
        if(1 < verbose) {
          G4cout << "### Added em model order= " << index << " for " 
                 << particleName << " and " << processName << G4endl;
        }
      } 
      return;
    }
  }
}

References G4VMultipleScattering::AddEmModel(), G4VEmProcess::AddEmModel(), G4VEnergyLossProcess::AddEmModel(), emax, G4cout, G4endl, G4ParticleTable::GetIterator(), G4VEmFluctuationModel::GetName(), G4VEmModel::GetName(), G4ParticleDefinition::GetParticleName(), G4ParticleTable::GetParticleTable(), G4ParticleDefinition::GetPDGCharge(), G4ProcessManager::GetProcessList(), G4ProcessManager::GetProcessListLength(), G4ParticleDefinition::GetProcessManager(), G4VProcess::GetProcessSubType(), index, MeV, reg, G4ParticleTableIterator< K, V >::reset(), UpdateModelEnergyRange(), and verbose.

Referenced by AddModels().

SetVerbose()

void G4EmConfigurator::SetVerbose ( G4int  value )

inline

Definition at line 135 of file G4EmConfigurator.hh.

{
  verbose = value;
}

References verbose.

Referenced by G4LossTableManager::ResetParameters().

UpdateModelEnergyRange()

G4bool G4EmConfigurator::UpdateModelEnergyRange ( G4VEmModel *  mod, G4double  emin, G4double  emax  )

private

Definition at line 379 of file G4EmConfigurator.cc.

{
  // energy limits
  G4double e1 = std::max(emin,mod->LowEnergyLimit());
  G4double e2 = std::min(emax,mod->HighEnergyLimit());
  if(e2 <= e1) {
    G4cout << "### G4EmConfigurator WARNING: empty energy interval"
           << " for <" << mod->GetName() 
           << ">  Emin(MeV)= " << e1/CLHEP::MeV 
           << ">  Emax(MeV)= " << e2/CLHEP::MeV 
           << G4endl;
    return false;        
  }
  mod->SetLowEnergyLimit(e1);
  mod->SetHighEnergyLimit(e2);
  if(verbose > 1) {
    G4cout << "### G4EmConfigurator for " << mod->GetName() 
           << " Emin(MeV)= " << e1/MeV << " Emax(MeV)= " << e2/MeV 
           << G4endl;
  } 
  return true;
}

References e1, e2, emax, G4cout, G4endl, G4VEmModel::GetName(), G4VEmModel::HighEnergyLimit(), G4VEmModel::LowEnergyLimit(), G4INCL::Math::max(), CLHEP::MeV, MeV, G4INCL::Math::min(), G4VEmModel::SetHighEnergyLimit(), G4VEmModel::SetLowEnergyLimit(), and verbose.

Referenced by PrepareModels(), and SetModelForRegion().

Field Documentation

flucModels

std::vector<G4VEmFluctuationModel*> G4EmConfigurator::flucModels

private

Definition at line 122 of file G4EmConfigurator.hh.

Referenced by AddModels(), Clear(), PrepareModels(), and SetExtraEmModel().

highEnergy

std::vector<G4double> G4EmConfigurator::highEnergy

private

Definition at line 127 of file G4EmConfigurator.hh.

Referenced by AddModels(), Clear(), PrepareModels(), and SetExtraEmModel().

index

G4int G4EmConfigurator::index

private

Definition at line 129 of file G4EmConfigurator.hh.

Referenced by AddModels(), G4EmConfigurator(), PrepareModels(), and SetModelForRegion().

lowEnergy

std::vector<G4double> G4EmConfigurator::lowEnergy

private

Definition at line 126 of file G4EmConfigurator.hh.

Referenced by AddModels(), Clear(), PrepareModels(), and SetExtraEmModel().

models

std::vector<G4VEmModel*> G4EmConfigurator::models

private

Definition at line 121 of file G4EmConfigurator.hh.

Referenced by AddModels(), Clear(), PrepareModels(), and SetExtraEmModel().

particles

std::vector<G4String> G4EmConfigurator::particles

private

Definition at line 123 of file G4EmConfigurator.hh.

Referenced by AddModels(), Clear(), PrepareModels(), and SetExtraEmModel().

processes

std::vector<G4String> G4EmConfigurator::processes

private

Definition at line 124 of file G4EmConfigurator.hh.

Referenced by AddModels(), Clear(), PrepareModels(), and SetExtraEmModel().

regions

std::vector<G4String> G4EmConfigurator::regions

private

Definition at line 125 of file G4EmConfigurator.hh.

Referenced by AddModels(), Clear(), PrepareModels(), and SetExtraEmModel().

verbose

G4int G4EmConfigurator::verbose

private

Definition at line 130 of file G4EmConfigurator.hh.

Referenced by AddModels(), FindRegion(), PrepareModels(), SetExtraEmModel(), SetModelForRegion(), SetVerbose(), and UpdateModelEnergyRange().

---

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

• source/processes/electromagnetic/utils/include/G4EmConfigurator.hh
• source/processes/electromagnetic/utils/src/G4EmConfigurator.cc