G4EmModelManager Class Reference

#include <G4EmModelManager.hh>

Public Member Functions
	G4EmModelManager ()
	~G4EmModelManager ()
void	Clear ()
const G4DataVector *	Initialise (const G4ParticleDefinition *, const G4ParticleDefinition *, G4double, G4int)
void	FillDEDXVector (G4PhysicsVector *, const G4MaterialCutsCouple *, G4EmTableType t=fRestricted)
void	FillLambdaVector (G4PhysicsVector *, const G4MaterialCutsCouple *, G4bool startFromNull=true, G4EmTableType t=fRestricted)
G4VEmModel *	GetModel (G4int, G4bool ver=false)
void	AddEmModel (G4int, G4VEmModel *, G4VEmFluctuationModel *, const G4Region *)
void	UpdateEmModel (const G4String &, G4double, G4double)
void	DumpModelList (G4int verb)
G4VEmModel *	SelectModel (G4double &energy, size_t &index)
const G4DataVector *	Cuts () const
const G4DataVector *	SubCutoff () const
void	SetFluoFlag (G4bool val)
G4int	NumberOfModels () const

Detailed Description

Definition at line 142 of file G4EmModelManager.hh.

Constructor & Destructor Documentation

G4EmModelManager()

G4EmModelManager::G4EmModelManager

(

)

Definition at line 124 of file G4EmModelManager.cc.

                                  :
  nEmModels(0),
  nRegions(0),
  particle(0),
  verboseLevel(0)
{
  maxSubCutInRange = 0.7*mm;
  models.reserve(4);
  flucModels.reserve(4);
  regions.reserve(4);
  orderOfModels.reserve(4);
  isUsed.reserve(4);
  severalModels = true;
  fluoFlag = false;
  currRegionModel = 0;
  currModel = 0;
  theCuts = 0;
  theSubCuts = 0;
}

~G4EmModelManager()

G4EmModelManager::~G4EmModelManager

(

)

Definition at line 146 of file G4EmModelManager.cc.

{
  verboseLevel = 0; // no verbosity at destruction
  Clear();
  delete theSubCuts;
}

Member Function Documentation

AddEmModel()

void G4EmModelManager::AddEmModel	(	G4int	num,
		G4VEmModel *	p,
		G4VEmFluctuationModel *	fm,
		const G4Region *	r
	)

Definition at line 171 of file G4EmModelManager.cc.

{
  if(!p) {
    G4cout << "G4EmModelManager::AddEmModel WARNING: no model defined." 
       << G4endl;
    return;
  }
  models.push_back(p);
  flucModels.push_back(fm);
  regions.push_back(r);
  orderOfModels.push_back(num);
  isUsed.push_back(0);
  p->DefineForRegion(r);
  ++nEmModels;
}

Referenced by G4VMultipleScattering::AddEmModel(), G4VEmProcess::AddEmModel(), G4VEnergyLossProcess::AddEmModel(), and G4AdjointBremsstrahlungModel::G4AdjointBremsstrahlungModel().

Clear()

void G4EmModelManager::Clear

(

)

Definition at line 155 of file G4EmModelManager.cc.

{
  if(1 < verboseLevel) {
    G4cout << "G4EmModelManager::Clear()" << G4endl;
  }
  size_t n = setOfRegionModels.size();
  if(n > 0) {
    for(size_t i=0; i<n; ++i) {
      delete setOfRegionModels[i];
      setOfRegionModels[i] = 0;
    }
  }
}

Referenced by Initialise(), and ~G4EmModelManager().

Cuts()

const G4DataVector * G4EmModelManager::Cuts ( ) const

inline

Definition at line 243 of file G4EmModelManager.hh.

{
  return theCuts;
}

DumpModelList()

void G4EmModelManager::DumpModelList

(

G4int

verb

)

Definition at line 663 of file G4EmModelManager.cc.

{
  if(verb == 0) { return; }
  for(G4int i=0; i<nRegions; ++i) {
    G4RegionModels* r = setOfRegionModels[i];
    const G4Region* reg = r->Region();
    G4int n = r->NumberOfModels();  
    if(n > 0) {
      G4cout << "      ===== EM models for the G4Region  " << reg->GetName()
         << " ======" << G4endl;;
      for(G4int j=0; j<n; ++j) {
    G4VEmModel* model = models[r->ModelIndex(j)];
        G4double emin = 
      std::max(r->LowEdgeEnergy(j),model->LowEnergyActivationLimit());
        G4double emax = 
      std::min(r->LowEdgeEnergy(j+1),model->HighEnergyActivationLimit());
    G4cout << std::setw(20);
    G4cout << model->GetName() << " :  Emin= " 
           << std::setw(8) << G4BestUnit(emin,"Energy")
           << "   Emax= " 
           << std::setw(8) << G4BestUnit(emax,"Energy");
    G4PhysicsTable* table = model->GetCrossSectionTable();
        if(table) {
      size_t kk = table->size();
          for(size_t k=0; k<kk; ++k) {
        G4PhysicsVector* v = (*table)[k];
        if(v) {
          G4int nn = v->GetVectorLength() - 1;
          G4cout << "  Table with " << nn << " bins Emin= "
             << std::setw(6) << G4BestUnit(v->Energy(0),"Energy")
             << "   Emax= " 
             << std::setw(6) << G4BestUnit(v->Energy(nn),"Energy");
          break;
        }
      }
    }
    G4VEmAngularDistribution* an = model->GetAngularDistribution();
        if(an) { G4cout << "   " << an->GetName(); }
        if(fluoFlag && model->DeexcitationFlag()) { G4cout << "  FluoActive"; }
    G4cout << G4endl;
      }  
    }
    if(1 == nEmModels) { break; }
  }
}

Referenced by G4VMultipleScattering::BuildPhysicsTable(), G4VEmProcess::PrintInfoDefinition(), G4VEnergyLossProcess::PrintInfoDefinition(), and G4VMultipleScattering::PrintInfoDefinition().

FillDEDXVector()

void G4EmModelManager::FillDEDXVector	(	G4PhysicsVector *	aVector,
		const G4MaterialCutsCouple *	couple,
		G4EmTableType	t = fRestricted
	)

Definition at line 510 of file G4EmModelManager.cc.

{
  size_t i = couple->GetIndex();
  G4double cut  = (*theCuts)[i];
  G4double emin = 0.0;
 
  if(fTotal == tType) { cut = DBL_MAX; }
  else if(fSubRestricted == tType) {
    emin = cut;
    if(theSubCuts) { emin = (*theSubCuts)[i]; }
  }
 
  if(1 < verboseLevel) {
    G4cout << "G4EmModelManager::FillDEDXVector() for "
           << couple->GetMaterial()->GetName()
       << "  cut(MeV)= " << cut
       << "  emin(MeV)= " << emin
       << "  Type " << tType
       << "  for " << particle->GetParticleName()
           << G4endl;
  }
 
  G4int reg  = 0;
  if(nRegions > 1 && nEmModels > 1) { reg = idxOfRegionModels[i]; }
  const G4RegionModels* regModels = setOfRegionModels[reg];
  G4int nmod = regModels->NumberOfModels();
 
  // Calculate energy losses vector
 
  //G4cout << "nmod= " << nmod << G4endl;
  size_t totBinsLoss = aVector->GetVectorLength();
  G4double del = 0.0;
  G4int    k0  = 0;
 
  for(size_t j=0; j<totBinsLoss; ++j) {
 
    G4double e = aVector->Energy(j);
 
    // Choose a model of energy losses
    G4int k = 0;
    if (nmod > 1) {
      k = nmod;
      do {--k;} while (k>0 && e <= regModels->LowEdgeEnergy(k));
      //G4cout << "k= " << k << G4endl;
      if(k > 0 && k != k0) {
        k0 = k;
        G4double elow = regModels->LowEdgeEnergy(k);
    G4double dedx1 = ComputeDEDX(models[regModels->ModelIndex(k-1)],
                     couple,elow,cut,emin);
    G4double dedx2 = ComputeDEDX(models[regModels->ModelIndex(k)],
                     couple,elow,cut,emin);
    del = 0.0;
        if(dedx2 > 0.0) { del = (dedx1/dedx2 - 1.0)*elow; }
    //G4cout << "elow= " << elow 
    //       << " dedx1= " << dedx1 << " dedx2= " << dedx2 << G4endl;
      }
    }
    G4double dedx = 
      ComputeDEDX(models[regModels->ModelIndex(k)],couple,e,cut,emin);
    dedx *= (1.0 + del/e); 
 
    if(2 < verboseLevel) {
      G4cout << "Material= " << couple->GetMaterial()->GetName()
         << "   E(MeV)= " << e/MeV
         << "  dEdx(MeV/mm)= " << dedx*mm/MeV
         << "  del= " << del*mm/MeV<< " k= " << k 
         << " modelIdx= " << regModels->ModelIndex(k)
         << G4endl;
    }
    if(dedx < 0.0) { dedx = 0.0; }
    aVector->PutValue(j, dedx);
  }
}

Referenced by G4VEnergyLossProcess::BuildDEDXTable().

FillLambdaVector()

void G4EmModelManager::FillLambdaVector	(	G4PhysicsVector *	aVector,
		const G4MaterialCutsCouple *	couple,
		G4bool	startFromNull = true,
		G4EmTableType	t = fRestricted
	)

Definition at line 588 of file G4EmModelManager.cc.

{
  size_t i = couple->GetIndex();
  G4double cut  = (*theCuts)[i];
  G4double tmax = DBL_MAX;
  if (fSubRestricted == tType) {
    tmax = cut;
    if(theSubCuts) { cut  = (*theSubCuts)[i]; }
  }
 
  G4int reg  = 0;
  if(nRegions > 1 && nEmModels > 1) { reg  = idxOfRegionModels[i]; }
  const G4RegionModels* regModels = setOfRegionModels[reg];
  G4int nmod = regModels->NumberOfModels();
  if(1 < verboseLevel) {
    G4cout << "G4EmModelManager::FillLambdaVector() for "
           << particle->GetParticleName()
           << " in " << couple->GetMaterial()->GetName()
       << " Ecut(MeV)= " << cut
       << " Emax(MeV)= " << tmax
       << " Type " << tType   
       << " nmod= " << nmod
           << G4endl;
  }
 
  // Calculate lambda vector
  size_t totBinsLambda = aVector->GetVectorLength();
  G4double del = 0.0;
  G4int    k0  = 0;
  G4int     k  = 0;
  G4VEmModel* mod = models[regModels->ModelIndex(0)]; 
  for(size_t j=0; j<totBinsLambda; ++j) {
 
    G4double e = aVector->Energy(j);
 
    // Choose a model 
    if (nmod > 1) {
      k = nmod;
      do {--k;} while (k>0 && e <= regModels->LowEdgeEnergy(k));
      if(k > 0 && k != k0) {
        k0 = k;
        G4double elow = regModels->LowEdgeEnergy(k);
        G4VEmModel* mod1 = models[regModels->ModelIndex(k-1)]; 
    G4double xs1  = mod1->CrossSection(couple,particle,elow,cut,tmax);
        mod = models[regModels->ModelIndex(k)]; 
    G4double xs2 = mod->CrossSection(couple,particle,elow,cut,tmax);
    del = 0.0;
        if(xs2 > 0.0) { del = (xs1/xs2 - 1.0)*elow; }
        //G4cout << "New model k=" << k << " E(MeV)= " << e/MeV 
    //       << " Elow(MeV)= " << elow/MeV << " del= " << del << G4endl;
      }
    }
    G4double cross = mod->CrossSection(couple,particle,e,cut,tmax);
    cross *= (1.0 + del/e); 
    if(fIsCrossSectionPrim == tType) { cross *= e; }
    
    if(j==0 && startFromNull) { cross = 0.0; }
 
    if(2 < verboseLevel) {
      G4cout << "FillLambdaVector: " << j << ".   e(MeV)= " << e/MeV
         << "  cross(1/mm)= " << cross*mm
         << " del= " << del*mm << " k= " << k 
         << " modelIdx= " << regModels->ModelIndex(k)
         << G4endl;
    }
    if(cross < 0.0) { cross = 0.0; }
    aVector->PutValue(j, cross);
  }
}

Referenced by G4VEnergyLossProcess::BuildLambdaTable().

GetModel()

G4VEmModel * G4EmModelManager::GetModel	(	G4int	i,
		G4bool	ver = false
	)

Definition at line 209 of file G4EmModelManager.cc.

{
  G4VEmModel* model = 0;
  if(i >= 0 && i < nEmModels) { model = models[i]; }
  else if(verboseLevel > 0 && ver) { 
    G4cout << "G4EmModelManager::GetModel WARNING: "
       << "index " << i << " is wrong Nmodels= "
       << nEmModels;
    if(particle) G4cout << " for " << particle->GetParticleName(); 
    G4cout<< G4endl;
  }
  return model;
}

Referenced by G4VEmProcess::GetModelByIndex(), G4VEnergyLossProcess::GetModelByIndex(), G4VMultipleScattering::GetModelByIndex(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), G4VMultipleScattering::SetIonisation(), G4VMultipleScattering::StartTracking(), and G4VMultipleScattering::StorePhysicsTable().

Initialise()

const G4DataVector * G4EmModelManager::Initialise	(	const G4ParticleDefinition *	p,
		const G4ParticleDefinition *	secondaryParticle,
		G4double	minSubRange,
		G4int	val
	)

Definition at line 226 of file G4EmModelManager.cc.

{
  verboseLevel = val;
  G4String partname = p->GetParticleName();
  if(1 < verboseLevel) {
    G4cout << "G4EmModelManager::Initialise() for "
           << partname << G4endl;
  }
  // Are models defined?
  if(nEmModels < 1) {
    G4ExceptionDescription ed;
    ed << "No models found out for " << p->GetParticleName() 
       << " !" << G4endl;
    G4Exception("G4EmModelManager::Initialise","em0002",
        FatalException, ed);
  }
 
  particle = p;
  Clear(); // needed if run is not first
 
  G4RegionStore* regionStore = G4RegionStore::GetInstance();
  const G4Region* world = 
    regionStore->GetRegion("DefaultRegionForTheWorld", false);
 
  // Identify the list of regions with different set of models
  nRegions = 1;
  std::vector<const G4Region*> setr;
  setr.push_back(world);
  G4bool isWorld = false;
 
  for (G4int ii=0; ii<nEmModels; ++ii) {
    const G4Region* r = regions[ii];
    if ( r == 0 || r == world) {
      isWorld = true;
      regions[ii] = world;
    } else {
      G4bool newRegion = true;
      if (nRegions>1) {
        for (G4int j=1; j<nRegions; ++j) {
      if ( r == setr[j] ) newRegion = false;
        }
      }
      if (newRegion) {
        setr.push_back(r);
    nRegions++;
      }
    }
  }
  // Are models defined?
  if(!isWorld) {
    G4ExceptionDescription ed;
    ed << "No models defined for the World volume for " << p->GetParticleName() 
       << " !" << G4endl;
    G4Exception("G4EmModelManager::Initialise","em0002",
        FatalException, ed);
  }
 
  G4ProductionCutsTable* theCoupleTable=
    G4ProductionCutsTable::GetProductionCutsTable();
  size_t numOfCouples = theCoupleTable->GetTableSize();
 
  // prepare vectors, shortcut for the case of only 1 model
  if(nRegions > 1 && nEmModels > 1) {
    if(numOfCouples > idxOfRegionModels.size()) {
      idxOfRegionModels.resize(numOfCouples);
    }
  }
  size_t nr = 1;
  if(nEmModels > 1) { nr = nRegions; }
  if(nr > setOfRegionModels.size()) { setOfRegionModels.resize(nr); }
 
  std::vector<G4int>    modelAtRegion(nEmModels);
  std::vector<G4int>    modelOrd(nEmModels);
  G4DataVector          eLow(nEmModels+1);
  G4DataVector          eHigh(nEmModels);
 
  // Order models for regions
  for (G4int reg=0; reg<nRegions; ++reg) {
    const G4Region* region = setr[reg];
    G4int n = 0;
 
    for (G4int ii=0; ii<nEmModels; ++ii) {
 
      G4VEmModel* model = models[ii];
      if ( region == regions[ii] ) {
 
    G4double tmin = model->LowEnergyLimit();
    G4double tmax = model->HighEnergyLimit();
    G4int  ord    = orderOfModels[ii];
    G4bool push   = true;
    G4bool insert = false;
    G4int  idx    = n;
 
    if(1 < verboseLevel) {
      G4cout << "Model #" << ii 
         << " <" << model->GetName() << "> for region <";
      if (region) G4cout << region->GetName();
      G4cout << ">  "
         << " tmin(MeV)= " << tmin/MeV
         << "; tmax(MeV)= " << tmax/MeV
         << "; order= " << ord
         << G4endl;
    }
        
    if(n > 0) {
 
      // extend energy range to previous models
      tmin = std::min(tmin, eHigh[n-1]);
      tmax = std::max(tmax, eLow[0]);
      //G4cout << "tmin= " << tmin << "  tmax= " 
      //       << tmax << "  ord= " << ord <<G4endl;
      // empty energy range
      if( tmax - tmin <= eV) push = false;
      // low-energy model
      else if (tmax == eLow[0]) {
        push = false;
        insert = true;
        idx = 0;
        // resolve intersections
      } else if(tmin < eHigh[n-1]) { 
        // compare order
        for(G4int k=0; k<n; ++k) {
          // new model has lower application 
          if(ord >= modelOrd[k]) {
        if(tmin < eHigh[k]  && tmin >= eLow[k]) tmin = eHigh[k];
        if(tmax <= eHigh[k] && tmax >  eLow[k]) tmax = eLow[k];
        if(tmax > eHigh[k] && tmin < eLow[k]) {
          if(tmax - eHigh[k] > eLow[k] - tmin) tmin = eHigh[k];
          else tmax = eLow[k];
        }
        if( tmax - tmin <= eV) {
          push = false;
          break;
        }
          }
        }
        //G4cout << "tmin= " << tmin << "  tmax= " 
        //     << tmax << "  push= " << push << " idx= " << idx <<G4endl;
        if(push) {
          if (tmax == eLow[0]) {
        push = false;
        insert = true;
        idx = 0;
        // continue resolve intersections
          } else if(tmin < eHigh[n-1]) { 
        // last energy interval
        if(tmin > eLow[n-1] && tmax >= eHigh[n-1]) {
          eHigh[n-1] = tmin;
          // first energy interval
        } else if(tmin <= eLow[0] && tmax < eHigh[0]) {
          eLow[0] = tmax;
          push = false;
          insert = true;
          idx = 0;
        } else {
          // find energy interval to replace
          for(G4int k=0; k<n; ++k) { 
            if(tmin <= eLow[k] && tmax >= eHigh[k]) {
              push = false;
              modelAtRegion[k] = ii;
              modelOrd[k] = ord;
              isUsed[ii] = 1;
            } 
          }
        }
          }
        }
      }
    }
    if(insert) {
      for(G4int k=n-1; k>=idx; --k) {    
        modelAtRegion[k+1] = modelAtRegion[k];
        modelOrd[k+1] = modelOrd[k];
        eLow[k+1]  = eLow[k];
        eHigh[k+1] = eHigh[k];
      }
    }
    //G4cout << "push= " << push << " insert= " << insert 
    //<< " idx= " << idx <<G4endl;
    if (push || insert) {
      ++n;
      modelAtRegion[idx] = ii;
      modelOrd[idx] = ord;
      eLow[idx]  = tmin;
      eHigh[idx] = tmax;
      isUsed[ii] = 1;
    }
      }
    }
    eLow[0] = 0.0;
    eLow[n] = eHigh[n-1];
 
    if(1 < verboseLevel) {
      G4cout << "New G4RegionModels set with " << n << " models for region <";
      if (region) G4cout << region->GetName();
      G4cout << ">  Elow(MeV)= ";
      for(G4int ii=0; ii<=n; ++ii) {G4cout << eLow[ii]/MeV << " ";}
      G4cout << G4endl;
    }
    G4RegionModels* rm = new G4RegionModels(n, modelAtRegion, eLow, region);
    setOfRegionModels[reg] = rm;
    if(1 == nEmModels) { break; }
  }
 
  currRegionModel = setOfRegionModels[0];
 
  // Access to materials and build cuts
  size_t idx = 1;
  if(secondaryParticle) {
    if( secondaryParticle == G4Gamma::Gamma() )           { idx = 0; }
    else if( secondaryParticle == G4Positron::Positron()) { idx = 2; }
  }
 
  //theCuts = theCoupleTable->GetEnergyCutsVector(idx);
  theCuts = static_cast<const G4DataVector*>(theCoupleTable->GetEnergyCutsVector(idx));
 
  if(minSubRange < 1.0) {
    if( !theSubCuts ) { theSubCuts = new G4DataVector(); }
    theSubCuts->resize(numOfCouples,DBL_MAX);
  }
  for(size_t i=0; i<numOfCouples; ++i) {
 
    const G4MaterialCutsCouple* couple = 
      theCoupleTable->GetMaterialCutsCouple(i);
    const G4Material* material = couple->GetMaterial();
    const G4ProductionCuts* pcuts = couple->GetProductionCuts();
 
    G4int reg = 0;
    if(nRegions > 1 && nEmModels > 1) {
      reg = nRegions;
      do {--reg;} while (reg>0 && pcuts != (setr[reg]->GetProductionCuts()));
      idxOfRegionModels[i] = reg;
    }
    if(1 < verboseLevel) {
      G4cout << "G4EmModelManager::Initialise() for "
         << material->GetName()
         << " indexOfCouple= " << i
         << " indexOfRegion= " << reg
         << G4endl;
    }
 
    G4double cut = (*theCuts)[i]; 
    if(secondaryParticle) {
 
      // compute subcut 
      if( cut < DBL_MAX && minSubRange < 1.0) {
    G4double subcut = minSubRange*cut;
        G4double rcut = std::min(minSubRange*pcuts->GetProductionCut(idx), 
                 maxSubCutInRange);
    G4double tcutmax = 
      theCoupleTable->ConvertRangeToEnergy(secondaryParticle,material,rcut);
    if(tcutmax < subcut) { subcut = tcutmax; }
    (*theSubCuts)[i] = subcut;
      }
    }
  }
 
  // initialize models
  G4int nn = 0;
  severalModels = true;
  for(G4int jj=0; jj<nEmModels; ++jj) {
    if(1 == isUsed[jj]) {
      ++nn;
      currModel = models[jj];
      currModel->Initialise(particle, *theCuts);
      if(flucModels[jj]) { flucModels[jj]->InitialiseMe(particle); }
    }
  }
  if(1 == nn) { severalModels = false; }
 
  if(1 < verboseLevel) {
    G4cout << "G4EmModelManager for " << particle->GetParticleName() 
           << " is initialised; nRegions=  " << nRegions
           << G4endl;
  }
 
  return theCuts;
}

Referenced by G4AdjointBremsstrahlungModel::AdjointCrossSection(), G4AdjointBremsstrahlungModel::DiffCrossSectionPerVolumePrimToSecond(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), and G4VMultipleScattering::PreparePhysicsTable().

NumberOfModels()

G4int G4EmModelManager::NumberOfModels ( ) const

inline

Definition at line 264 of file G4EmModelManager.hh.

{
  return nEmModels;
}

Referenced by G4VEnergyLossProcess::NumberOfModels(), G4VEmProcess::PreparePhysicsTable(), G4VEnergyLossProcess::PreparePhysicsTable(), G4VMultipleScattering::PreparePhysicsTable(), and G4VMultipleScattering::StorePhysicsTable().

SelectModel()

G4VEmModel * G4EmModelManager::SelectModel ( G4double &  energy, size_t &  index  )

inline

Definition at line 229 of file G4EmModelManager.hh.

{
  if(severalModels) {
    if(nRegions > 1) {
      currRegionModel = setOfRegionModels[idxOfRegionModels[index]];
    }
    currModel = models[currRegionModel->SelectIndex(kinEnergy)];
  }
  return currModel;
}

Referenced by G4VEmProcess::SelectModel(), G4VEnergyLossProcess::SelectModel(), G4VMultipleScattering::SelectModel(), G4VEnergyLossProcess::SelectModelForMaterial(), and G4VEmProcess::SelectModelForMaterial().

SetFluoFlag()

void G4EmModelManager::SetFluoFlag ( G4bool  val )

inline

Definition at line 257 of file G4EmModelManager.hh.

{
  fluoFlag = val;
}

Referenced by G4VEmProcess::PreparePhysicsTable().

SubCutoff()

const G4DataVector * G4EmModelManager::SubCutoff ( ) const

inline

Definition at line 250 of file G4EmModelManager.hh.

{
  return theSubCuts;
}

Referenced by G4VEnergyLossProcess::PreparePhysicsTable().

UpdateEmModel()

void G4EmModelManager::UpdateEmModel	(	const G4String &	nam,
		G4double	emin,
		G4double	emax
	)

Definition at line 190 of file G4EmModelManager.cc.

{
  if (nEmModels > 0) {
    for(G4int i=0; i<nEmModels; ++i) {
      if(nam == models[i]->GetName()) {
        models[i]->SetLowEnergyLimit(emin);
        models[i]->SetHighEnergyLimit(emax);
    break;
      }
    }
  }
  G4cout << "G4EmModelManager::UpdateEmModel WARNING: no model <"
         << nam << "> is found out"
     << G4endl;
}

Referenced by G4VEmProcess::UpdateEmModel(), and G4VEnergyLossProcess::UpdateEmModel().

---

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

• G4EmModelManager.hh
• G4EmModelManager.cc