#include <G4EmModelManager.hh>

Public Member Functions
	G4EmModelManager ()

	~G4EmModelManager ()

void	Clear ()

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

void	FillDEDXVector (G4PhysicsVector , const G4MaterialCutsCouple , G4EmTableType t=fRestricted)

void	FillLambdaVector (G4PhysicsVector , const G4MaterialCutsCouple , G4bool startFromNull=true, G4EmTableType t=fRestricted)

void	AddEmModel (G4int, G4VEmModel , G4VEmFluctuationModel , const G4Region *)

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

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

G4VEmModel *	GetRegionModel (G4int idx, size_t index_couple)

G4int	NumberOfRegionModels (size_t index_couple) const

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 143 of file G4EmModelManager.hh.

Constructor & Destructor Documentation

G4EmModelManager::G4EmModelManager ( )

Definition at line 123 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 = nullptr;
   currModel  = nullptr;
   theCuts    = nullptr;
   theCutsNew = nullptr;
   theSubCuts = nullptr;
 }

G4EmModelManager::~G4EmModelManager ( )

Definition at line 146 of file G4EmModelManager.cc.

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

Here is the call graph for this function:

Member Function Documentation

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

Definition at line 172 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;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

void G4EmModelManager::Clear ( )

Definition at line 156 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] = nullptr;
     }
   }
 }

Here is the caller graph for this function:

const G4DataVector * G4EmModelManager::Cuts ( ) const

inline

Definition at line 259 of file G4EmModelManager.hh.

 {
   return theCuts;
 }

void G4EmModelManager::DumpModelList ( G4int verb )

Definition at line 801 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());
         if(emax > emin) {
       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; }
   }
   if(theCutsNew) {
     G4cout << "      ===== Limit on energy threshold has been applied " 
            << G4endl;
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 644 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;
       // 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 = 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);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 723 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()
            << " Emin(MeV)= " << aVector->Energy(0)
            << " Emax(MeV)= " << aVector->GetMaxEnergy()
            << " cut= " << cut
            << " Type " << tType   
            << " nmod= " << nmod
            << " theSubCuts " << theSubCuts
            << 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 = 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);
   }
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 210 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(particle) { G4cout << " for " << particle->GetParticleName(); } 
     G4cout<< G4endl;
   }
   return model;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

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

Definition at line 226 of file G4EmModelManager.cc.

 {
   G4RegionModels* rm = setOfRegionModels[idxOfRegionModels[idx]];
   G4VEmModel* mod = models[rm->ModelIndex(k)];
   return mod;
 }

Here is the caller graph for this function:

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

Definition at line 244 of file G4EmModelManager.cc.

 {
   verboseLevel = val;
   G4String partname = p->GetParticleName();
   if(1 < verboseLevel) {
     G4cout << "G4EmModelManager::Initialise() for "
            << partname << "  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 == 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() << " !";
     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
             //G4cout << "tmin= " << tmin << "  tmax= " 
             //       << tmax << "  push= " << push << " idx= " << idx <<G4endl;
         //G4cout << "n= " << n << " eLow[0]= " <<  eLow[0] << " eLow[n-1]= " << eLow[n-1]
         //     << " eHigh[0]= " << eHigh[0] << " eHigh[n-1]= " << eHigh[n-1] << G4endl;
 
         // 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(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(theCutsNew) { *theCutsNew = *theCuts; }
 
   if(minSubRange < 1.0) {
     if( !theSubCuts ) { theSubCuts = new G4DataVector(); }
     theSubCuts->resize(numOfCouples,DBL_MAX);
   }
 
   //  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(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;
       }
 
       // 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(!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(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(flucModels[jj]) { flucModels[jj]->InitialiseMe(particle); }
     }
   }
   if(1 == nn) { severalModels = false; }
 
   if(1 < verboseLevel) {
     G4cout << "G4EmModelManager for " << partname 
            << " is initialised; nRegions=  " << nRegions
            << " severalModels: " << severalModels 
            << G4endl;
   }
 
   return theCuts;
 }

Here is the call graph for this function:

Here is the caller graph for this function:

G4int G4EmModelManager::NumberOfModels ( ) const

inline

Definition at line 280 of file G4EmModelManager.hh.

 {
   return nEmModels;
 }

Here is the caller graph for this function:

G4int G4EmModelManager::NumberOfRegionModels ( size_t index_couple ) const

Definition at line 235 of file G4EmModelManager.cc.

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

Here is the caller graph for this function:

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

inline

Definition at line 245 of file G4EmModelManager.hh.

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

Here is the caller graph for this function:

void G4EmModelManager::SetFluoFlag ( G4bool val )

inline

Definition at line 273 of file G4EmModelManager.hh.

 {
   fluoFlag = val;
 }

Here is the caller graph for this function:

const G4DataVector * G4EmModelManager::SubCutoff ( ) const

inline

Definition at line 266 of file G4EmModelManager.hh.

 {
   return theSubCuts;
 }

Here is the caller graph for this function:

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

Definition at line 191 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;
 }

Here is the caller graph for this function:

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

geant4.10.03.p01/source/processes/electromagnetic/utils/include/G4EmModelManager.hh
geant4.10.03.p01/source/processes/electromagnetic/utils/src/G4EmModelManager.cc

Public Member Functions

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation