G4EmModelManager Class Reference

#include <G4EmModelManager.hh>

Public Member Functions
void	AddEmModel (G4int, G4VEmModel *, G4VEmFluctuationModel *fm, const G4Region *r)
void	Clear ()
const G4DataVector *	Cuts () const
void	DumpModelList (std::ostream &out, G4int verb)
void	FillDEDXVector (G4PhysicsVector *, const G4MaterialCutsCouple *, G4EmTableType t=fRestricted)
void	FillLambdaVector (G4PhysicsVector *, const G4MaterialCutsCouple *, G4bool startFromNull=true, G4EmTableType t=fRestricted)
	G4EmModelManager ()
	G4EmModelManager (G4EmModelManager &)=delete
G4VEmModel *	GetModel (G4int idx, G4bool ver=false)
G4VEmModel *	GetRegionModel (G4int idx, size_t index_couple)
const G4DataVector *	Initialise (const G4ParticleDefinition *part, const G4ParticleDefinition *secPart, G4double, G4int verb)
G4int	NumberOfModels () const
G4int	NumberOfRegionModels (size_t index_couple) const
G4EmModelManager &	operator= (const G4EmModelManager &right)=delete
G4VEmModel *	SelectModel (G4double energy, size_t index)
void	SetFluoFlag (G4bool val)
void	UpdateEmModel (const G4String &model_name, G4double emin, G4double emax)
	~G4EmModelManager ()

Private Attributes
G4VEmModel *	currModel = nullptr
G4RegionModels *	currRegionModel = nullptr
std::vector< G4VEmFluctuationModel * >	flucModels
G4bool	fluoFlag = false
std::vector< G4int >	idxOfRegionModels
std::vector< G4int >	isUsed
std::vector< G4VEmModel * >	models
G4int	nEmModels = 0
G4int	nRegions = 0
std::vector< G4int >	orderOfModels
const G4ParticleDefinition *	particle = nullptr
std::vector< const G4Region * >	regions
std::vector< G4RegionModels * >	setOfRegionModels
G4bool	severalModels = true
const G4DataVector *	theCuts = nullptr
G4DataVector *	theCutsNew = nullptr
G4int	verboseLevel = 0

Detailed Description

Definition at line 142 of file G4EmModelManager.hh.

Constructor & Destructor Documentation

G4EmModelManager() [1/2]

G4EmModelManager::G4EmModelManager

(

)

Definition at line 97 of file G4EmModelManager.cc.

{
  models.reserve(4);
  flucModels.reserve(4);
  regions.reserve(4);
  orderOfModels.reserve(4);
  isUsed.reserve(4);
}

References flucModels, isUsed, models, orderOfModels, and regions.

~G4EmModelManager()

G4EmModelManager::~G4EmModelManager

(

)

Definition at line 108 of file G4EmModelManager.cc.

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

References Clear(), theCutsNew, and verboseLevel.

G4EmModelManager() [2/2]

G4EmModelManager::G4EmModelManager ( G4EmModelManager &  )

delete

Member Function Documentation

AddEmModel()

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

Definition at line 131 of file G4EmModelManager.cc.

{
  if(nullptr == 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;
}

References G4VEmModel::DefineForRegion(), flucModels, G4cout, G4endl, isUsed, models, nEmModels, orderOfModels, and regions.

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

Clear()

void G4EmModelManager::Clear

(

)

Definition at line 117 of file G4EmModelManager.cc.

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

References G4cout, G4endl, CLHEP::detail::n, setOfRegionModels, and verboseLevel.

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

Cuts()

const G4DataVector * G4EmModelManager::Cuts ( ) const

inline

Definition at line 242 of file G4EmModelManager.hh.

{
  return theCuts;
}

References theCuts.

DumpModelList()

void G4EmModelManager::DumpModelList	(	std::ostream &	out,
		G4int	verb
	)

Definition at line 718 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) {
      out << "      ===== 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());
        if(emax > emin) {
      out << std::setw(20);
      out << model->GetName() << " : Emin=" 
          << std::setw(5) << G4BestUnit(emin,"Energy")
          << " Emax=" 
          << std::setw(5) << G4BestUnit(emax,"Energy");
      G4PhysicsTable* table = model->GetCrossSectionTable();
      if(table) {
        size_t kk = table->size();
        for(size_t k=0; k<kk; ++k) {
          const G4PhysicsVector* v = (*table)[k];
          if(v) {
        G4int nn = v->GetVectorLength() - 1;
        out << " Nbins=" << nn << " "
            << std::setw(3) << G4BestUnit(v->Energy(0),"Energy")
            << " - " 
            << std::setw(3) << G4BestUnit(v->Energy(nn),"Energy");
        break;
          }
        }
          }
      G4VEmAngularDistribution* an = model->GetAngularDistribution();
      if(an) { out << "  " << an->GetName(); }
      if(fluoFlag && model->DeexcitationFlag()) { 
        out << " Fluo"; 
      }
      out << G4endl;
          G4VMscModel* msc = dynamic_cast<G4VMscModel*>(model);
          if(msc != nullptr) msc->DumpParameters(out);
    }
      }  
    }
    if(1 == nEmModels) { break; }
  }
  if(theCutsNew) {
    out << "      ===== Limit on energy threshold has been applied " << G4endl;
  }
}

References G4InuclParticleNames::an, G4VEmModel::DeexcitationFlag(), G4VMscModel::DumpParameters(), emax, G4PhysicsVector::Energy(), fluoFlag, G4BestUnit, G4endl, G4VEmModel::GetAngularDistribution(), G4VEmModel::GetCrossSectionTable(), G4VEmModel::GetName(), G4PhysicsVector::GetVectorLength(), G4VEmModel::HighEnergyActivationLimit(), G4RegionModels::LowEdgeEnergy(), G4VEmModel::LowEnergyActivationLimit(), G4INCL::Math::max(), G4INCL::Math::min(), G4RegionModels::ModelIndex(), models, CLHEP::detail::n, nEmModels, G4InuclParticleNames::nn, nRegions, G4RegionModels::NumberOfModels(), reg, G4RegionModels::Region(), setOfRegionModels, and theCutsNew.

Referenced by G4VEnergyLossProcess::StreamInfo(), G4VEmProcess::StreamInfo(), and G4VMultipleScattering::StreamInfo().

FillDEDXVector()

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

Definition at line 581 of file G4EmModelManager.cc.

{
  size_t i = couple->GetIndex();
  G4double cut  = (fTotal == tType) ? DBL_MAX : (*theCuts)[i];
 
  if(1 < verboseLevel) {
    G4cout << "G4EmModelManager::FillDEDXVector() for "
           << couple->GetMaterial()->GetName()
           << "  cut(MeV)= " << cut
           << "  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
  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;
      // Loop checking, 03-Aug-2015, Vladimir Ivanchenko
      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 = 
      models[regModels->ModelIndex(k-1)]->ComputeDEDX(couple, particle, elow, cut);
        G4double dedx2 = 
      models[regModels->ModelIndex(k)]->ComputeDEDX(couple, particle, elow, cut);
        del = (dedx2 > 0.0) ? (dedx1/dedx2 - 1.0)*elow : 0.0;
        //G4cout << "elow= " << elow 
        //       << " dedx1= " << dedx1 << " dedx2= " << dedx2 << G4endl;
      }
    }
    G4double dedx = (1.0 + del/e)*
      models[regModels->ModelIndex(k)]->ComputeDEDX(couple, particle, e, cut);
 
    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;
    }
    dedx = std::max(dedx, 0.0);
    aVector->PutValue(j, dedx);
  }
}

References DBL_MAX, G4PhysicsVector::Energy(), fTotal, G4cout, G4endl, G4MaterialCutsCouple::GetIndex(), G4MaterialCutsCouple::GetMaterial(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), G4PhysicsVector::GetVectorLength(), idxOfRegionModels, G4InuclParticleNames::k0, G4RegionModels::LowEdgeEnergy(), G4INCL::Math::max(), MeV, mm, G4RegionModels::ModelIndex(), models, nEmModels, nRegions, G4RegionModels::NumberOfModels(), particle, G4PhysicsVector::PutValue(), reg, setOfRegionModels, theCuts, and verboseLevel.

Referenced by G4VEnergyLossProcess::BuildDEDXTable().

FillLambdaVector()

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

Definition at line 647 of file G4EmModelManager.cc.

{
  size_t i = couple->GetIndex();
  G4double cut  = (*theCuts)[i];
  G4double tmax = DBL_MAX;
 
  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()
           << " Emin(MeV)= " << aVector->Energy(0)
           << " Emax(MeV)= " << aVector->GetMaxEnergy()
           << " cut= " << cut
           << " 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;
      // Loop checking, 03-Aug-2015, Vladimir Ivanchenko
      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 = (xs2 > 0.0) ? (xs1/xs2 - 1.0)*elow : 0.0;
        //G4cout << "New model k=" << k << " E(MeV)= " << e/MeV 
        //       << " Elow(MeV)= " << elow/MeV << " del= " << del << G4endl;
      }
    }
    G4double cross = (1.0 + del/e)*mod->CrossSection(couple,particle,e,cut,tmax);
    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;
    }
    cross = std::max(cross, 0.0);
    aVector->PutValue(j, cross);
  }
}

References G4VEmModel::CrossSection(), DBL_MAX, G4PhysicsVector::Energy(), fIsCrossSectionPrim, G4cout, G4endl, G4MaterialCutsCouple::GetIndex(), G4MaterialCutsCouple::GetMaterial(), G4PhysicsVector::GetMaxEnergy(), G4Material::GetName(), G4ParticleDefinition::GetParticleName(), G4PhysicsVector::GetVectorLength(), idxOfRegionModels, G4InuclParticleNames::k0, G4RegionModels::LowEdgeEnergy(), G4INCL::Math::max(), MeV, mm, G4RegionModels::ModelIndex(), models, nEmModels, nRegions, G4RegionModels::NumberOfModels(), particle, G4PhysicsVector::PutValue(), reg, setOfRegionModels, and verboseLevel.

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

GetModel()

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

Definition at line 169 of file G4EmModelManager.cc.

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

References G4cout, G4endl, G4ParticleDefinition::GetParticleName(), models, nEmModels, particle, and verboseLevel.

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

GetRegionModel()

G4VEmModel * G4EmModelManager::GetRegionModel	(	G4int	idx,
		size_t	index_couple
	)

Definition at line 187 of file G4EmModelManager.cc.

{
  G4RegionModels* rm = setOfRegionModels[idxOfRegionModels[idx]];
  return (k < rm->NumberOfModels()) ? models[rm->ModelIndex(k)] : nullptr;
}

References idxOfRegionModels, G4RegionModels::ModelIndex(), models, NumberOfModels(), and setOfRegionModels.

Initialise()

const G4DataVector * G4EmModelManager::Initialise	(	const G4ParticleDefinition *	part,
		const G4ParticleDefinition *	secPart,
		G4double	,
		G4int	verb
	)

Definition at line 204 of file G4EmModelManager.cc.

{
  verboseLevel = verb;
  if(1 < verboseLevel) {
    G4cout << "G4EmModelManager::Initialise() for "
           << p->GetParticleName() << "  Nmodels= " << nEmModels << G4endl;
  }
  // Are models defined?
  if(nEmModels < 1) {
    G4ExceptionDescription ed;
    ed << "No models found out for " << p->GetParticleName() 
       << " !";
    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 == nullptr || 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() << " !";
    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
  // or only one region
  if(nRegions > 1 && nEmModels > 1) {
    idxOfRegionModels.resize(numOfCouples,0);
    setOfRegionModels.resize((size_t)nRegions,0); 
  } else {
    idxOfRegionModels.resize(1,0);
    setOfRegionModels.resize(1,0); 
  }
 
  std::vector<G4int>    modelAtRegion(nEmModels);
  std::vector<G4int>    modelOrd(nEmModels);
  G4DataVector          eLow(nEmModels+1);
  G4DataVector          eHigh(nEmModels);
 
  if(1 < verboseLevel) {
    G4cout << "    Nregions= " << nRegions 
           << "  Nmodels= " << nEmModels << G4endl;
  }
 
  // 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
         << "; tminAct= " << model->LowEnergyActivationLimit()/MeV
         << "; tmaxAct= " << model->HighEnergyActivationLimit()/MeV
                 << G4endl;
        }
        
    static const G4double limitdelta = 0.01*eV;
        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 <= limitdelta) { 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 higher order parameter, 
          // so, its application area may be reduced
          // to avoid intersections
              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 <= limitdelta) {
                  push = false;
                  break;
                }
              }
            }
        // this model has lower order parameter than possible
        // other models, with which there may be intersections
        // so, appliction area of such models may be reduced
 
        // insert below the first model
        if (tmax <= eLow[0]) {
          push = false;
          insert = true;
          idx = 0;
          // 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;
        // loop over all models
          } else {
        for(G4int k=n-1; k>=0; --k) { 
          if(tmin <= eLow[k] && tmax >= eHigh[k]) {
            // full overlap exclude previous model
            isUsed[modelAtRegion[k]] = 0;
            idx = k;
            if(k < n-1) {
              // shift upper models and change index
              for(G4int kk=k; kk<n-1; ++kk) {    
            modelAtRegion[kk] = modelAtRegion[kk+1];
            modelOrd[kk] = modelOrd[kk+1];
            eLow[kk] = eLow[kk+1];
            eHigh[kk] = eHigh[kk+1];
              }
                      ++k;
            }
            --n;
          } else {
            // partially reduce previous model area
            if(tmin <= eLow[k] && tmax > eLow[k]) { 
              eLow[k] = tmax;
                      idx = k;
                      insert = true;
                      push = false;
            } else if(tmin < eHigh[k] && tmax >= eHigh[k]) { 
              eHigh[k] = tmin;
                      idx = k + 1;
                      if(idx < n) { 
            insert = true; 
            push = false;
              }
            } else if(tmin > eLow[k] && tmax < eHigh[k]) {
              if(eHigh[k] - tmax > tmin - eLow[k]) {
            eLow[k] = tmax;
                        idx = k;
                        insert = true;
            push = false;
              } else {
            eHigh[k] = tmin;
            idx = k + 1;
            if(idx < n) { 
              insert = true; 
              push = false;
            }
              }
            }
                  }
                }
              }
            }
          }
        }
    // provide space for the new model
        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;
    // the model is added
        if (push || insert) {
          ++n;
          modelAtRegion[idx] = ii;
          modelOrd[idx] = ord;
          eLow[idx]  = tmin;
          eHigh[idx] = tmax;
          isUsed[ii] = 1;
        }
    // exclude models with zero energy range
    for(G4int k=n-1; k>=0; --k) {
      if(eHigh[k] - eLow[k] <= limitdelta) {
        isUsed[modelAtRegion[k]] = 0;
        if(k < n-1) {
          for(G4int kk=k; kk<n-1; ++kk) {    
        modelAtRegion[kk] = modelAtRegion[kk+1];
        modelOrd[kk] = modelOrd[kk+1];
        eLow[kk] = eLow[kk+1];
        eHigh[kk] = eHigh[kk+1];
          }
        }
        --n;
      }
    }
      }
    }
    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 iii=0; iii<=n; ++iii) {G4cout << eLow[iii]/MeV << " ";}
      G4cout << G4endl;
    }
    G4RegionModels* rm = new G4RegionModels(n, modelAtRegion, eLow, region);
    setOfRegionModels[reg] = rm;
    // shortcut
    if(1 == nEmModels) { break; }
  }
 
  currRegionModel = setOfRegionModels[0];
  currModel = models[0];
 
  // Access to materials and build cuts
  size_t idx = 1;
  if(nullptr != secondaryParticle) {
    if( secondaryParticle == G4Gamma::Gamma() )           { idx = 0; }
    else if( secondaryParticle == G4Electron::Electron()) { idx = 1; }
    else if( secondaryParticle == G4Positron::Positron()) { idx = 2; }
    else { idx = 3; }
  }
 
  theCuts = 
    static_cast<const G4DataVector*>(theCoupleTable->GetEnergyCutsVector(idx));
 
  // for the second run the check on cuts should be repeated
  if(nullptr != theCutsNew) { *theCutsNew = *theCuts; }
 
  //  G4cout << "========Start define cuts" << G4endl;
  // define cut values
  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;
      // Loop checking, 03-Aug-2015, Vladimir Ivanchenko
      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(nullptr != secondaryParticle) {
 
      // note that idxOfRegionModels[] not always filled
      G4int inn = 0;
      G4int nnm = 1;
      if(nRegions > 1 && nEmModels > 1) { 
        inn = idxOfRegionModels[i];
      }
      // check cuts and introduce upper limits
      //G4cout << "idx= " << i << " cut(keV)= " << cut/keV << G4endl;
      currRegionModel = setOfRegionModels[inn];
      nnm = currRegionModel->NumberOfModels();
     
      //G4cout << "idx= " << i << " Nmod= " << nnm << G4endl; 
 
      for(G4int jj=0; jj<nnm; ++jj) {
        //G4cout << "jj= " << jj << "  modidx= " 
        //       << currRegionModel->ModelIndex(jj) << G4endl;
        currModel = models[currRegionModel->ModelIndex(jj)];
        G4double cutlim = currModel->MinEnergyCut(particle,couple);
        if(cutlim > cut) {
          if(nullptr == theCutsNew) { theCutsNew = new G4DataVector(*theCuts); }
          (*theCutsNew)[i] = cutlim;
          /*
          G4cout << "### " << partname << " energy loss model in " 
                 << material->GetName() 
                 << "  Cut was changed from " << cut/keV << " keV to "
                 << cutlim/keV << " keV " << " due to " 
                 << currModel->GetName() << G4endl;
          */
        }
      } 
    }
  }
  if(nullptr != theCutsNew) { theCuts = theCutsNew; }
 
  // 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(nullptr != flucModels[jj]) { flucModels[jj]->InitialiseMe(particle); }
    }
  }
  if(1 == nn) { severalModels = false; }
 
  if(1 < verboseLevel) {
    G4cout << "G4EmModelManager for " << particle->GetParticleName()
           << " is initialised; nRegions=  " << nRegions
           << " severalModels: " << severalModels 
           << G4endl;
  }
  return theCuts;
}

References Clear(), currModel, currRegionModel, G4Electron::Electron(), eV, FatalException, flucModels, G4cout, G4endl, G4Exception(), G4Gamma::Gamma(), G4ProductionCutsTable::GetEnergyCutsVector(), G4RegionStore::GetInstance(), G4MaterialCutsCouple::GetMaterial(), G4ProductionCutsTable::GetMaterialCutsCouple(), G4Region::GetName(), G4VEmModel::GetName(), G4ParticleDefinition::GetParticleName(), G4MaterialCutsCouple::GetProductionCuts(), G4ProductionCutsTable::GetProductionCutsTable(), G4RegionStore::GetRegion(), G4ProductionCutsTable::GetTableSize(), G4VEmModel::HighEnergyActivationLimit(), G4VEmModel::HighEnergyLimit(), idxOfRegionModels, G4VEmModel::Initialise(), isUsed, G4VEmModel::LowEnergyActivationLimit(), G4VEmModel::LowEnergyLimit(), eplot::material, G4INCL::Math::max(), MeV, G4INCL::Math::min(), G4VEmModel::MinEnergyCut(), G4RegionModels::ModelIndex(), models, CLHEP::detail::n, nEmModels, G4InuclParticleNames::nn, nRegions, G4RegionModels::NumberOfModels(), orderOfModels, particle, G4Positron::Positron(), reg, regions, setOfRegionModels, severalModels, theCuts, theCutsNew, and verboseLevel.

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

NumberOfModels()

G4int G4EmModelManager::NumberOfModels ( ) const

inline

Definition at line 256 of file G4EmModelManager.hh.

{
  return nEmModels;
}

References nEmModels.

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

NumberOfRegionModels()

G4int G4EmModelManager::NumberOfRegionModels

(

size_t

index_couple

)

const

Definition at line 195 of file G4EmModelManager.cc.

{
  G4RegionModels* rm = setOfRegionModels[idxOfRegionModels[idx]];
  return rm->NumberOfModels();
}

References idxOfRegionModels, G4RegionModels::NumberOfModels(), and setOfRegionModels.

operator=()

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

delete

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

References currModel, currRegionModel, idxOfRegionModels, models, nRegions, G4RegionModels::SelectIndex(), setOfRegionModels, and severalModels.

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

SetFluoFlag()

void G4EmModelManager::SetFluoFlag ( G4bool  val )

inline

Definition at line 249 of file G4EmModelManager.hh.

{
  fluoFlag = val;
}

References fluoFlag.

Referenced by G4VEmProcess::PreparePhysicsTable().

UpdateEmModel()

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

Definition at line 150 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);
        return;
      }
    }
  }
  G4cout << "G4EmModelManager::UpdateEmModel WARNING: no model <"
         << nam << "> is found out"
         << G4endl;
}

References emax, G4cout, G4endl, models, and nEmModels.

Field Documentation

currModel

G4VEmModel* G4EmModelManager::currModel = nullptr

private

Definition at line 206 of file G4EmModelManager.hh.

Referenced by Initialise(), and SelectModel().

currRegionModel

G4RegionModels* G4EmModelManager::currRegionModel = nullptr

private

Definition at line 205 of file G4EmModelManager.hh.

Referenced by Initialise(), and SelectModel().

flucModels

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

private

Definition at line 216 of file G4EmModelManager.hh.

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

fluoFlag

G4bool G4EmModelManager::fluoFlag = false

private

Definition at line 213 of file G4EmModelManager.hh.

Referenced by DumpModelList(), and SetFluoFlag().

idxOfRegionModels

std::vector<G4int> G4EmModelManager::idxOfRegionModels

private

Definition at line 221 of file G4EmModelManager.hh.

Referenced by FillDEDXVector(), FillLambdaVector(), GetRegionModel(), Initialise(), NumberOfRegionModels(), and SelectModel().

isUsed

std::vector<G4int> G4EmModelManager::isUsed

private

Definition at line 219 of file G4EmModelManager.hh.

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

models

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

private

Definition at line 215 of file G4EmModelManager.hh.

Referenced by AddEmModel(), DumpModelList(), FillDEDXVector(), FillLambdaVector(), G4EmModelManager(), GetModel(), GetRegionModel(), Initialise(), SelectModel(), and UpdateEmModel().

nEmModels

G4int G4EmModelManager::nEmModels = 0

private

Definition at line 208 of file G4EmModelManager.hh.

Referenced by AddEmModel(), DumpModelList(), FillDEDXVector(), FillLambdaVector(), GetModel(), Initialise(), NumberOfModels(), and UpdateEmModel().

nRegions

G4int G4EmModelManager::nRegions = 0

private

Definition at line 209 of file G4EmModelManager.hh.

Referenced by DumpModelList(), FillDEDXVector(), FillLambdaVector(), Initialise(), and SelectModel().

orderOfModels

std::vector<G4int> G4EmModelManager::orderOfModels

private

Definition at line 218 of file G4EmModelManager.hh.

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

particle

const G4ParticleDefinition* G4EmModelManager::particle = nullptr

private

Definition at line 200 of file G4EmModelManager.hh.

Referenced by emcalc_gui.MainWindow::cb_select_particle(), emcalc_gui.MainWindow::cb_show_plot(), FillDEDXVector(), FillLambdaVector(), GetModel(), and Initialise().

regions

std::vector<const G4Region*> G4EmModelManager::regions

private

Definition at line 217 of file G4EmModelManager.hh.

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

setOfRegionModels

std::vector<G4RegionModels*> G4EmModelManager::setOfRegionModels

private

Definition at line 222 of file G4EmModelManager.hh.

Referenced by Clear(), DumpModelList(), FillDEDXVector(), FillLambdaVector(), GetRegionModel(), Initialise(), NumberOfRegionModels(), and SelectModel().

severalModels

G4bool G4EmModelManager::severalModels = true

private

Definition at line 212 of file G4EmModelManager.hh.

Referenced by Initialise(), and SelectModel().

theCuts

const G4DataVector* G4EmModelManager::theCuts = nullptr

private

Definition at line 201 of file G4EmModelManager.hh.

Referenced by Cuts(), FillDEDXVector(), and Initialise().

theCutsNew

G4DataVector* G4EmModelManager::theCutsNew = nullptr

private

Definition at line 202 of file G4EmModelManager.hh.

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

verboseLevel

G4int G4EmModelManager::verboseLevel = 0

private

Definition at line 211 of file G4EmModelManager.hh.

Referenced by Clear(), FillDEDXVector(), FillLambdaVector(), GetModel(), Initialise(), and ~G4EmModelManager().

---

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

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