G4EmConfigurator Class Reference

#include <G4EmConfigurator.hh>

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

Detailed Description

Definition at line 63 of file G4EmConfigurator.hh.

Constructor & Destructor Documentation

G4EmConfigurator() [1/2]

G4EmConfigurator::G4EmConfigurator ( G4int verboseLevel = 1 )

explicit

Definition at line 66 of file G4EmConfigurator.cc.

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

~G4EmConfigurator()

G4EmConfigurator::~G4EmConfigurator ( )

default

G4EmConfigurator() [2/2]

G4EmConfigurator::G4EmConfigurator ( const G4EmConfigurator & )

delete

Member Function Documentation

AddModels()

void G4EmConfigurator::AddModels

(

)

Definition at line 111 of file G4EmConfigurator.cc.

{
  size_t n = models.size();
  if(1 < 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 = G4EmUtility::FindRegion(regions[i]);
        if(nullptr != reg) {
          --index;
          SetModelForRegion(models[i],flucModels[i],reg,
                            particles[i],processes[i],
                            lowEnergy[i],highEnergy[i]);
        }
      }
    }
  }
  Clear();
}

Clear()

void G4EmConfigurator::Clear

(

)

Definition at line 381 of file G4EmConfigurator.cc.

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

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

operator=()

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

delete

PrepareModels() [1/3]

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

Definition at line 298 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 = G4EmUtility::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;
                }
              }
            }
          }
        }
      }
    }
  }
}

PrepareModels() [2/3]

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

Definition at line 252 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 = G4EmUtility::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);
            }
          }
        }
      }
    }
  }
}

Referenced by G4LossTableManager::PreparePhysicsTable(), G4LossTableManager::PreparePhysicsTable(), G4LossTableManager::PreparePhysicsTable(), and G4TransportationWithMsc::PreparePhysicsTable().

PrepareModels() [3/3]

void G4EmConfigurator::PrepareModels	(	const G4ParticleDefinition *	aParticle,
		G4VMultipleScattering *	p,
		G4TransportationWithMsc *	trans = nullptr )

Definition at line 339 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 = (nullptr == p) ? G4String("msc") : 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 = G4EmUtility::FindRegion(regions[i]);
      if(nullptr != reg) {
        --index;
        auto mod = dynamic_cast<G4VMscModel*>(models[i]);
            if(nullptr != mod) {
              if(UpdateModelEnergyRange(mod, lowEnergy[i], highEnergy[i])) {
                if(nullptr != p) {
          p->AddEmModel(index,mod,reg);
        } else {
          trans->AddMscModel(mod,index,reg);
        }
                //G4cout << "### Added msc model order= " << index << " for " 
                //   << particleName << " and " << processName << G4endl;
              }
            }
          }
        }
      }
    }
  }
}

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

SetVerbose()

void G4EmConfigurator::SetVerbose ( G4int value )

inline

Definition at line 135 of file G4EmConfigurator.hh.

{
  verbose = value;
}

Referenced by G4LossTableManager::ResetParameters().

---

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

• G4EmConfigurator.hh
• G4EmConfigurator.cc