Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/electromagnetic/utils/src/G4EmModelManager.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /processes/electromagnetic/utils/src/G4EmModelManager.cc (Version 11.3.0) and /processes/electromagnetic/utils/src/G4EmModelManager.cc (Version 8.3.p1)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
                                                   >>  26 // $Id: G4EmModelManager.cc,v 1.38 2007/03/17 19:24:39 vnivanch Exp $
                                                   >>  27 // GEANT4 tag $Name: geant4-08-03-patch-01 $
 26 //                                                 28 //
 27 // -------------------------------------------     29 // -------------------------------------------------------------------
 28 //                                                 30 //
 29 // GEANT4 Class file                               31 // GEANT4 Class file
 30 //                                                 32 //
 31 //                                                 33 //
 32 // File name:     G4EmModelManager                 34 // File name:     G4EmModelManager
 33 //                                                 35 //
 34 // Author:        Vladimir Ivanchenko              36 // Author:        Vladimir Ivanchenko
 35 //                                                 37 //
 36 // Creation date: 07.05.2002                       38 // Creation date: 07.05.2002
 37 //                                                 39 //
 38 // Modifications: V.Ivanchenko                 <<  40 // Modifications:
                                                   >>  41 //
                                                   >>  42 // 23-12-02 V.Ivanchenko change interface in order to move
                                                   >>  43 //                           to cut per region
                                                   >>  44 // 20-01-03 Migrade to cut per region (V.Ivanchenko)
                                                   >>  45 // 24-01-03 Make models region aware (V.Ivanchenko)
                                                   >>  46 // 13-02-03 The set of models is defined for region (V.Ivanchenko)
                                                   >>  47 // 06-03-03 Fix in energy intervals for models (V.Ivanchenko)
                                                   >>  48 // 13-04-03 Add startFromNull (V.Ivanchenko)
                                                   >>  49 // 13-05-03 Add calculation of precise range (V.Ivanchenko)
                                                   >>  50 // 16-07-03 Replace G4Material by G4MaterialCutCouple in dE/dx and CrossSection
                                                   >>  51 //          calculation (V.Ivanchenko)
                                                   >>  52 // 21-07-03 Add UpdateEmModel method (V.Ivanchenko)
                                                   >>  53 // 03-11-03 Substitute STL vector for G4RegionModels (V.Ivanchenko)
                                                   >>  54 // 26-01-04 Fix in energy range conditions (V.Ivanchenko)
                                                   >>  55 // 24-03-05 Remove check or IsInCharge (V.Ivanchenko)
                                                   >>  56 // 08-04-05 Major optimisation of internal interfaces (V.Ivantchenko)
                                                   >>  57 // 18-08-05 Fix cut for e+e- pair production (V.Ivanchenko)
                                                   >>  58 // 29-11-05 Add protection for arithmetic operations with cut=DBL_MAX (V.Ivanchenko)
                                                   >>  59 // 20-01-06 Introduce G4EmTableType and reducing number of methods (VI)
                                                   >>  60 // 13-05-06 Add GetModel by index method (VI)
                                                   >>  61 // 15-03-07 Add maxCutInRange (V.Ivanchenko)
 39 //                                                 62 //
 40 // Class Description:                              63 // Class Description:
 41 //                                                 64 //
 42 // It is the unified energy loss process it ca     65 // It is the unified energy loss process it calculates the continuous
 43 // energy loss for charged particles using a s     66 // energy loss for charged particles using a set of Energy Loss
 44 // models valid for different energy regions.      67 // models valid for different energy regions. There are a possibility
 45 // to create and access to dE/dx and range tab     68 // to create and access to dE/dx and range tables, or to calculate
 46 // that information on fly.                        69 // that information on fly.
 47 // -------------------------------------------     70 // -------------------------------------------------------------------
 48 //                                                 71 //
 49 //....oooOO0OOooo........oooOO0OOooo........oo     72 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 50 //....oooOO0OOooo........oooOO0OOooo........oo     73 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 51                                                    74 
 52 #include "G4EmModelManager.hh"                     75 #include "G4EmModelManager.hh"
 53 #include "G4SystemOfUnits.hh"                  <<  76 #include "G4LossTableManager.hh"
 54 #include "G4PhysicsTable.hh"                   << 
 55 #include "G4PhysicsVector.hh"                  << 
 56 #include "G4VMscModel.hh"                      << 
 57                                                << 
 58 #include "G4Step.hh"                               77 #include "G4Step.hh"
 59 #include "G4ParticleDefinition.hh"                 78 #include "G4ParticleDefinition.hh"
                                                   >>  79 #include "G4DataVector.hh"
 60 #include "G4PhysicsVector.hh"                      80 #include "G4PhysicsVector.hh"
                                                   >>  81 #include "G4Gamma.hh"
                                                   >>  82 #include "G4Positron.hh"
 61 #include "G4MaterialCutsCouple.hh"                 83 #include "G4MaterialCutsCouple.hh"
 62 #include "G4ProductionCutsTable.hh"                84 #include "G4ProductionCutsTable.hh"
                                                   >>  85 #include "G4Region.hh"
 63 #include "G4RegionStore.hh"                        86 #include "G4RegionStore.hh"
 64 #include "G4Gamma.hh"                          <<  87 
 65 #include "G4Electron.hh"                       << 
 66 #include "G4Positron.hh"                       << 
 67 #include "G4UnitsTable.hh"                     << 
 68 #include "G4DataVector.hh"                     << 
 69                                                    88 
 70 //....oooOO0OOooo........oooOO0OOooo........oo     89 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 71                                                    90 
 72 G4RegionModels::G4RegionModels(G4int nMod, std <<  91 G4RegionModels::G4RegionModels(G4int nMod, std::vector<G4int>& list, G4DataVector& lowE)
 73                                G4DataVector& l << 
 74 {                                                  92 {
 75   nModelsForRegion      = nMod;                    93   nModelsForRegion      = nMod;
 76   theListOfModelIndexes = new G4int [nModelsFo     94   theListOfModelIndexes = new G4int [nModelsForRegion];
 77   lowKineticEnergy      = new G4double [nModel <<  95   lowKineticEnergy      = new G4double [nModelsForRegion];
 78   for (G4int i=0; i<nModelsForRegion; ++i) {   <<  96   for (G4int i=0; i<nModelsForRegion; i++) {
 79     theListOfModelIndexes[i] = indx[i];        <<  97     theListOfModelIndexes[i] = list[i];
 80     lowKineticEnergy[i] = lowE[i];                 98     lowKineticEnergy[i] = lowE[i];
 81   }                                                99   }
 82   lowKineticEnergy[nModelsForRegion] = lowE[nM << 
 83   theRegion = reg;                             << 
 84 }                                                 100 }
 85                                                   101 
 86 //....oooOO0OOooo........oooOO0OOooo........oo    102 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 87                                                   103 
 88 G4RegionModels::~G4RegionModels()                 104 G4RegionModels::~G4RegionModels()
 89 {                                                 105 {
 90   delete [] theListOfModelIndexes;                106   delete [] theListOfModelIndexes;
 91   delete [] lowKineticEnergy;                     107   delete [] lowKineticEnergy;
 92 }                                                 108 }
 93                                                   109 
 94 //....oooOO0OOooo........oooOO0OOooo........oo    110 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 95 //....oooOO0OOooo........oooOO0OOooo........oo << 
 96                                                   111 
 97 G4EmModelManager::G4EmModelManager()           << 112 G4EmModelManager::G4EmModelManager():
 98 {                                              << 113   nEmModels(0),
 99   models.reserve(4);                           << 114   nRegions(0),
100   flucModels.reserve(4);                       << 115   nCouples(0),
101   regions.reserve(4);                          << 116   idxOfRegionModels(0),
102   orderOfModels.reserve(4);                    << 117   setOfRegionModels(0),
103   isUsed.reserve(4);                           << 118   minSubRange(0.1),
                                                   >> 119   particle(0),
                                                   >> 120   verboseLevel(0)
                                                   >> 121 {
                                                   >> 122   models.clear();
                                                   >> 123   flucModels.clear();
                                                   >> 124   regions.clear();
                                                   >> 125   orderOfModels.clear();
                                                   >> 126   upperEkin.clear();
                                                   >> 127   maxCutInRange    = 12.*cm;
                                                   >> 128   maxSubCutInRange = 0.7*mm;
104 }                                                 129 }
105                                                   130 
106 //....oooOO0OOooo........oooOO0OOooo........oo    131 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
107                                                   132 
108 G4EmModelManager::~G4EmModelManager()             133 G4EmModelManager::~G4EmModelManager()
109 {                                                 134 {
110   verboseLevel = 0; // no verbosity at destruc << 135   G4int i,j;
111   Clear();                                        136   Clear();
112   delete theCutsNew;                           << 137   for(i = 0; i<nEmModels; i++) {
                                                   >> 138     orderOfModels[i] = 1;
                                                   >> 139   }
                                                   >> 140   for(i = 0; i<nEmModels; i++) {
                                                   >> 141     if (orderOfModels[i]) {
                                                   >> 142       orderOfModels[i] = 0;
                                                   >> 143       for(j = i+1; j<nEmModels; j++) {
                                                   >> 144         if(models[i] == models[j]) orderOfModels[j] = 0;
                                                   >> 145       }
                                                   >> 146       G4String nam = models[i]->GetName();
                                                   >> 147       if(nam != "PAI" && nam != "PAIModel" ) delete models[i];
                                                   >> 148     }
                                                   >> 149   }
                                                   >> 150   for(i = 0; i<nEmModels; i++) {
                                                   >> 151     orderOfModels[i] = 1;
                                                   >> 152   }
                                                   >> 153   for(i = 0; i<nEmModels; i++) {
                                                   >> 154     if (orderOfModels[i]) {
                                                   >> 155       orderOfModels[i] = 0;
                                                   >> 156       for(j = i+1; j<nEmModels; j++) {
                                                   >> 157         if(flucModels[i] == flucModels[j]) orderOfModels[j] = 0;
                                                   >> 158       }
                                                   >> 159       delete flucModels[i];
                                                   >> 160     }
                                                   >> 161   }
113 }                                                 162 }
114                                                   163 
115 //....oooOO0OOooo........oooOO0OOooo........oo    164 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
116                                                   165 
117 void G4EmModelManager::Clear()                    166 void G4EmModelManager::Clear()
118 {                                                 167 {
119   if(1 < verboseLevel) {                          168   if(1 < verboseLevel) {
120     G4cout << "G4EmModelManager::Clear()" << G    169     G4cout << "G4EmModelManager::Clear()" << G4endl;
121   }                                               170   }
122   std::size_t n = setOfRegionModels.size();    << 171 
123   for(std::size_t i=0; i<n; ++i) {             << 172   theCuts.clear();
124     delete setOfRegionModels[i];               << 173   theSubCuts.clear();
125     setOfRegionModels[i] = nullptr;            << 174   upperEkin.clear();
                                                   >> 175   if(idxOfRegionModels) delete [] idxOfRegionModels;
                                                   >> 176   if(setOfRegionModels && nRegions) {
                                                   >> 177     for(G4int i=0; i<nRegions; i++) {
                                                   >> 178       delete (setOfRegionModels[i]);
                                                   >> 179     }
                                                   >> 180     delete [] setOfRegionModels;
126   }                                               181   }
                                                   >> 182   idxOfRegionModels = 0;
                                                   >> 183   setOfRegionModels = 0;
127 }                                                 184 }
128                                                   185 
129 //....oooOO0OOooo........oooOO0OOooo........oo    186 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
130                                                   187 
131 void G4EmModelManager::AddEmModel(G4int num, G    188 void G4EmModelManager::AddEmModel(G4int num, G4VEmModel* p,
132                                   G4VEmFluctua    189                                   G4VEmFluctuationModel* fm, const G4Region* r)
133 {                                                 190 {
134   if(nullptr == p) {                           << 191   if(!p) {
135     G4cout << "G4EmModelManager::AddEmModel WA    192     G4cout << "G4EmModelManager::AddEmModel WARNING: no model defined." 
136            << G4endl;                          << 193      << G4endl;
137     return;                                       194     return;
138   }                                               195   }
139   models.push_back(p);                            196   models.push_back(p);
140   flucModels.push_back(fm);                       197   flucModels.push_back(fm);
141   regions.push_back(r);                           198   regions.push_back(r);
142   orderOfModels.push_back(num);                   199   orderOfModels.push_back(num);
143   isUsed.push_back(0);                         << 
144   p->DefineForRegion(r);                          200   p->DefineForRegion(r);
145   ++nEmModels;                                 << 201   if (nEmModels>0) {
                                                   >> 202     G4int idx = nEmModels;
                                                   >> 203     do {idx--;} while (idx && num < orderOfModels[idx]);
                                                   >> 204     if (num >= orderOfModels[idx] && num <= orderOfModels[idx+1]) idx++;
                                                   >> 205     if (idx < nEmModels) {
                                                   >> 206       models[nEmModels] = models[idx];
                                                   >> 207       flucModels[nEmModels] = flucModels[idx];
                                                   >> 208       regions[nEmModels] = regions[idx];
                                                   >> 209       orderOfModels[nEmModels] = orderOfModels[idx];
                                                   >> 210       models[idx] = p;
                                                   >> 211       flucModels[idx] = fm;
                                                   >> 212       regions[idx] = r;
                                                   >> 213       orderOfModels[idx] = num;
                                                   >> 214     }
                                                   >> 215   }
                                                   >> 216   nEmModels++;
146 }                                                 217 }
147                                                   218 
148 //....oooOO0OOooo........oooOO0OOooo........oo    219 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
149                                                   220 
150 G4VEmModel* G4EmModelManager::GetModel(G4int i << 221 void G4EmModelManager::UpdateEmModel(const G4String& nam, 
151 {                                              << 222              G4double emin, G4double emax)
152   G4VEmModel* model = nullptr;                 << 223 {
153   if(idx >= 0 && idx < nEmModels) { model = mo << 224   if (nEmModels) {
154   else if(verboseLevel > 0 && ver) {           << 225     for(G4int i=0; i<nEmModels; i++) {
155     G4cout << "G4EmModelManager::GetModel WARN << 226       if(nam == models[i]->GetName()) {
156            << "index " << idx << " is wrong Nm << 227         models[i]->SetLowEnergyLimit(emin);
157            << nEmModels;                       << 228         models[i]->SetHighEnergyLimit(emax);
158     if(nullptr != particle) {                  << 229   break;
159       G4cout << " for " << particle->GetPartic << 230       }
160     }                                             231     }
161     G4cout<< G4endl;                           << 
162   }                                               232   }
163   return model;                                << 233   G4cout << "G4EmModelManager::UpdateEmModel WARNING: no model <"
164 }                                              << 234          << nam << "> is found out"
165                                                << 235    << G4endl;
166 //....oooOO0OOooo........oooOO0OOooo........oo << 
167                                                << 
168 G4VEmModel* G4EmModelManager::GetRegionModel(G << 
169 {                                              << 
170   G4RegionModels* rm = setOfRegionModels[idxOf << 
171   return (k < rm->NumberOfModels()) ? models[r << 
172 }                                                 236 }
173                                                   237 
174 //....oooOO0OOooo........oooOO0OOooo........oo    238 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
175                                                   239 
176 G4int G4EmModelManager::NumberOfRegionModels(s << 240 G4VEmModel* G4EmModelManager::GetModel(G4int i)
177 {                                                 241 {
178   G4RegionModels* rm = setOfRegionModels[idxOf << 242   G4VEmModel* m = 0;
179   return rm->NumberOfModels();                 << 243   if(i >= 0 && i < nEmModels) m = models[i];
                                                   >> 244   else if(verboseLevel > 0) 
                                                   >> 245     G4cout << "G4EmModelManager::GetModel WARNING: "
                                                   >> 246      << "index " << i << " is wrong Nmodels= "
                                                   >> 247      << nEmModels << G4endl;
                                                   >> 248   return m;
180 }                                                 249 }
181                                                   250 
182 //....oooOO0OOooo........oooOO0OOooo........oo    251 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
183                                                   252 
184 const G4DataVector*                            << 253 const G4DataVector* G4EmModelManager::Initialise(const G4ParticleDefinition* p,
185 G4EmModelManager::Initialise(const G4ParticleD << 254                                                  const G4ParticleDefinition* sp,
186                              const G4ParticleD << 255                    G4double theMinSubRange,
187                              G4int verb)       << 256                                                        G4int val)
188 {                                                 257 {
189   verboseLevel = verb;                         << 258   verboseLevel = val;
190   if(1 < verboseLevel) {                          259   if(1 < verboseLevel) {
191     G4cout << "G4EmModelManager::Initialise()     260     G4cout << "G4EmModelManager::Initialise() for "
192            << p->GetParticleName() << "  Nmode << 261            << p->GetParticleName()
                                                   >> 262            << G4endl;
193   }                                               263   }
194   // Are models defined?                          264   // Are models defined?
195   if(nEmModels < 1) {                          << 265   if(!nEmModels) {
196     G4ExceptionDescription ed;                 << 266     G4Exception("G4EmModelManager::Initialise without any model defined");
197     ed << "No models found out for " << p->Get << 
198        << " !";                                << 
199     G4Exception("G4EmModelManager::Initialise" << 
200                 FatalException, ed);           << 
201   }                                               267   }
202                                                << 
203   particle = p;                                   268   particle = p;
204   Clear(); // needed if run is not first       << 269   secondaryParticle = sp;
                                                   >> 270   minSubRange = theMinSubRange;
205                                                   271 
                                                   >> 272   Clear();
206   G4RegionStore* regionStore = G4RegionStore::    273   G4RegionStore* regionStore = G4RegionStore::GetInstance();
207   const G4Region* world =                         274   const G4Region* world = 
208     regionStore->GetRegion("DefaultRegionForTh    275     regionStore->GetRegion("DefaultRegionForTheWorld", false);
209                                                   276 
210   // Identify the list of regions with differe    277   // Identify the list of regions with different set of models
211   nRegions = 1;                                   278   nRegions = 1;
212   std::vector<const G4Region*> setr;           << 279   std::vector<const G4Region*> set;
213   setr.push_back(world);                       << 280   set.push_back(world);
214   G4bool isWorld = false;                         281   G4bool isWorld = false;
215                                                   282 
216   for (G4int ii=0; ii<nEmModels; ++ii) {       << 283   for (G4int ii=0; ii<nEmModels; ii++) {
217     const G4Region* r = regions[ii];              284     const G4Region* r = regions[ii];
218     if ( r == nullptr || r == world) {         << 285     if ( r == 0 || r == world) {
219       isWorld = true;                             286       isWorld = true;
220       regions[ii] = world;                        287       regions[ii] = world;
221     } else {                                      288     } else {
222       G4bool newRegion = true;                    289       G4bool newRegion = true;
223       if (nRegions>1) {                           290       if (nRegions>1) {
224         for (G4int j=1; j<nRegions; ++j) {     << 291         for (G4int j=1; j<nRegions; j++) {
225           if ( r == setr[j] ) { newRegion = fa << 292     if ( r == set[j] ) newRegion = false;
226         }                                         293         }
227       }                                           294       }
228       if (newRegion) {                            295       if (newRegion) {
229         setr.push_back(r);                     << 296         set.push_back(r);
230         ++nRegions;                            << 297   nRegions++;
231       }                                           298       }
232     }                                             299     }
233   }                                               300   }
234   // Are models defined?                       << 
235   if(!isWorld) {                               << 
236     G4ExceptionDescription ed;                 << 
237     ed << "No models defined for the World vol << 
238        << p->GetParticleName() << " !";        << 
239     G4Exception("G4EmModelManager::Initialise" << 
240                 FatalException, ed);           << 
241   }                                            << 
242                                                   301 
243   G4ProductionCutsTable* theCoupleTable=          302   G4ProductionCutsTable* theCoupleTable=
244     G4ProductionCutsTable::GetProductionCutsTa    303     G4ProductionCutsTable::GetProductionCutsTable();
245   std::size_t numOfCouples = theCoupleTable->G << 304   G4int numOfCouples = theCoupleTable->GetTableSize();
246                                                << 305   idxOfRegionModels = new G4int[numOfCouples+1];
247   // prepare vectors, shortcut for the case of << 306   idxOfRegionModels[numOfCouples] = 0;
248   // or only one region                        << 307   setOfRegionModels = new G4RegionModels*[nRegions];
249   if(nRegions > 1 && nEmModels > 1) {          << 308   upperEkin.resize(nEmModels);
250     idxOfRegionModels.resize(numOfCouples,0);  << 
251     setOfRegionModels.resize((std::size_t)nReg << 
252   } else {                                     << 
253     idxOfRegionModels.resize(1,0);             << 
254     setOfRegionModels.resize(1,nullptr);       << 
255   }                                            << 
256                                                << 
257   std::vector<G4int>    modelAtRegion(nEmModel << 
258   std::vector<G4int>    modelOrd(nEmModels);   << 
259   G4DataVector          eLow(nEmModels+1);     << 
260   G4DataVector          eHigh(nEmModels);      << 
261                                                << 
262   if(1 < verboseLevel) {                       << 
263     G4cout << "    Nregions= " << nRegions     << 
264            << "  Nmodels= " << nEmModels << G4 << 
265   }                                            << 
266                                                   309 
267   // Order models for regions                     310   // Order models for regions
268   for (G4int reg=0; reg<nRegions; ++reg) {     << 311   for (G4int reg=0; reg<nRegions; reg++) {
269     const G4Region* region = setr[reg];        << 312     const G4Region* region = set[reg];
270     G4int n = 0;                               << 
271                                                   313 
272     for (G4int ii=0; ii<nEmModels; ++ii) {     << 314     G4int n = 0;
273                                                << 
274       G4VEmModel* model = models[ii];          << 
275       if ( region == regions[ii] ) {           << 
276                                                   315 
277         G4double tmin = model->LowEnergyLimit( << 316     std::vector<G4int>    modelAtRegion;
278         G4double tmax = model->HighEnergyLimit << 317     G4DataVector            eLow;
279         G4int  ord    = orderOfModels[ii];     << 318     G4DataVector            eHigh;
280         G4bool push   = true;                  << 319     modelAtRegion.clear();
281         G4bool insert = false;                 << 320     eLow.clear();
282         G4int  idx    = n;                     << 321     eHigh.clear();
283                                                << 322 
284         if(1 < verboseLevel) {                 << 323     if(isWorld || 0 < reg) {
285           G4cout << "Model #" << ii            << 324 
286                  << " <" << model->GetName() < << 325       for (G4int ii=0; ii<nEmModels; ii++) {
287           if (region) G4cout << region->GetNam << 326 
288           G4cout << ">  "                      << 327   G4VEmModel* model = models[ii];
289                  << " tmin(MeV)= " << tmin/MeV << 328   if ( region == regions[ii] ) {
                                                   >> 329 
                                                   >> 330     G4double tmin = model->LowEnergyLimit();
                                                   >> 331     G4double tmax = model->HighEnergyLimit();
                                                   >> 332     if (n>0) tmin = std::max(tmin, eHigh[n-1]);
                                                   >> 333 
                                                   >> 334     if(1 < verboseLevel) {
                                                   >> 335       G4cout << "Model #" << ii 
                                                   >> 336        << " <" << model->GetName() << "> for region <";
                                                   >> 337       if (region) G4cout << region->GetName();
                                                   >> 338       G4cout << ">  "
                                                   >> 339            << " tmin(MeV)= " << tmin/MeV
290                  << "; tmax(MeV)= " << tmax/Me    340                  << "; tmax(MeV)= " << tmax/MeV
291                  << "; order= " << ord         << 341      << "; order= " << orderOfModels[ii]
292      << "; tminAct= " << model->LowEnergyActiv << 
293      << "; tmaxAct= " << model->HighEnergyActi << 
294                  << G4endl;                       342                  << G4endl;
295         }                                      << 343     }
296                                                << 344 
297   static const G4double limitdelta = 0.01*eV;  << 345     if (tmin < tmax) {
298         if(n > 0) {                            << 346       modelAtRegion.push_back(ii);
299                                                << 347       eLow.push_back(tmin);
300           // extend energy range to previous m << 348       eHigh.push_back(tmax);
301           tmin = std::min(tmin, eHigh[n-1]);   << 349       upperEkin[ii] = tmax;
302           tmax = std::max(tmax, eLow[0]);      << 350       n++;
303           //G4cout << "tmin= " << tmin << "  t << 
304           //           << tmax << "  ord= " << << 
305           // empty energy range                << 
306           if( tmax - tmin <= limitdelta) { pus << 
307           // low-energy model                  << 
308           else if (tmax == eLow[0]) {          << 
309             push = false;                      << 
310             insert = true;                     << 
311             idx = 0;                           << 
312             // resolve intersections           << 
313           } else if(tmin < eHigh[n-1]) {       << 
314             // compare order                   << 
315             for(G4int k=0; k<n; ++k) {         << 
316               // new model has higher order pa << 
317         // so, its application area may be red << 
318         // to avoid intersections              << 
319               if(ord >= modelOrd[k]) {         << 
320                 if(tmin < eHigh[k]  && tmin >= << 
321                 if(tmax <= eHigh[k] && tmax >  << 
322                 if(tmax > eHigh[k] && tmin < e << 
323                   if(tmax - eHigh[k] > eLow[k] << 
324                   else { tmax = eLow[k]; }     << 
325                 }                              << 
326                 if( tmax - tmin <= limitdelta) << 
327                   push = false;                << 
328                   break;                       << 
329                 }                              << 
330               }                                << 
331             }                                  << 
332       // this model has lower order parameter  << 
333       // other models, with which there may be << 
334       // so, appliction area of such models ma << 
335                                                << 
336       // insert below the first model          << 
337       if (tmax <= eLow[0]) {                   << 
338         push = false;                          << 
339         insert = true;                         << 
340         idx = 0;                               << 
341         // resolve intersections               << 
342       } else if(tmin < eHigh[n-1]) {           << 
343         // last energy interval                << 
344         if(tmin > eLow[n-1] && tmax >= eHigh[n << 
345     eHigh[n-1] = tmin;                         << 
346     // first energy interval                   << 
347         } else if(tmin <= eLow[0] && tmax < eH << 
348     eLow[0] = tmax;                            << 
349     push = false;                              << 
350     insert = true;                             << 
351     idx = 0;                                   << 
352     // loop over all models                    << 
353         } else {                               << 
354     for(G4int k=n-1; k>=0; --k) {              << 
355       if(tmin <= eLow[k] && tmax >= eHigh[k])  << 
356         // full overlap exclude previous model << 
357         isUsed[modelAtRegion[k]] = 0;          << 
358         idx = k;                               << 
359         if(k < n-1) {                          << 
360           // shift upper models and change ind << 
361           for(G4int kk=k; kk<n-1; ++kk) {      << 
362       modelAtRegion[kk] = modelAtRegion[kk+1]; << 
363       modelOrd[kk] = modelOrd[kk+1];           << 
364       eLow[kk] = eLow[kk+1];                   << 
365       eHigh[kk] = eHigh[kk+1];                 << 
366           }                                    << 
367                       ++k;                     << 
368         }                                      << 
369         --n;                                   << 
370       } else {                                 << 
371         // partially reduce previous model are << 
372         if(tmin <= eLow[k] && tmax > eLow[k])  << 
373           eLow[k] = tmax;                      << 
374                       idx = k;                 << 
375                       insert = true;           << 
376                       push = false;            << 
377         } else if(tmin < eHigh[k] && tmax >= e << 
378           eHigh[k] = tmin;                     << 
379                       idx = k + 1;             << 
380                       if(idx < n) {            << 
381       insert = true;                           << 
382       push = false;                            << 
383           }                                    << 
384         } else if(tmin > eLow[k] && tmax < eHi << 
385           if(eHigh[k] - tmax > tmin - eLow[k]) << 
386       eLow[k] = tmax;                          << 
387                         idx = k;               << 
388                         insert = true;         << 
389       push = false;                            << 
390           } else {                             << 
391       eHigh[k] = tmin;                         << 
392       idx = k + 1;                             << 
393       if(idx < n) {                            << 
394         insert = true;                         << 
395         push = false;                          << 
396       }                                        << 
397           }                                    << 
398         }                                      << 
399                   }                            << 
400                 }                              << 
401               }                                << 
402             }                                  << 
403           }                                    << 
404         }                                      << 
405   // provide space for the new model           << 
406         if(insert) {                           << 
407           for(G4int k=n-1; k>=idx; --k) {      << 
408             modelAtRegion[k+1] = modelAtRegion << 
409             modelOrd[k+1] = modelOrd[k];       << 
410             eLow[k+1]  = eLow[k];              << 
411             eHigh[k+1] = eHigh[k];             << 
412           }                                    << 
413         }                                      << 
414         //G4cout << "push= " << push << " inse << 
415   //       << " idx= " << idx <<G4endl;        << 
416   // the model is added                        << 
417         if (push || insert) {                  << 
418           ++n;                                 << 
419           modelAtRegion[idx] = ii;             << 
420           modelOrd[idx] = ord;                 << 
421           eLow[idx]  = tmin;                   << 
422           eHigh[idx] = tmax;                   << 
423           isUsed[ii] = 1;                      << 
424         }                                      << 
425   // exclude models with zero energy range     << 
426   for(G4int k=n-1; k>=0; --k) {                << 
427     if(eHigh[k] - eLow[k] <= limitdelta) {     << 
428       isUsed[modelAtRegion[k]] = 0;            << 
429       if(k < n-1) {                            << 
430         for(G4int kk=k; kk<n-1; ++kk) {        << 
431     modelAtRegion[kk] = modelAtRegion[kk+1];   << 
432     modelOrd[kk] = modelOrd[kk+1];             << 
433     eLow[kk] = eLow[kk+1];                     << 
434     eHigh[kk] = eHigh[kk+1];                   << 
435         }                                      << 
436       }                                        << 
437       --n;                                     << 
438     }                                             351     }
439   }                                               352   }
440       }                                           353       }
                                                   >> 354     } else {
                                                   >> 355       n = 1;
                                                   >> 356       models.push_back(0);
                                                   >> 357       modelAtRegion.push_back(nEmModels);
                                                   >> 358       eLow.push_back(0.0);
                                                   >> 359       eHigh.push_back(DBL_MAX);
                                                   >> 360       upperEkin.push_back(DBL_MAX);
441     }                                             361     }
442     eLow[0] = 0.0;                                362     eLow[0] = 0.0;
443     eLow[n] = eHigh[n-1];                      << 
444                                                   363 
445     if(1 < verboseLevel) {                        364     if(1 < verboseLevel) {
446       G4cout << "### New G4RegionModels set wi << 365       G4cout << "New G4RegionModels set with " << n << " models for region <";
447              << " models for region <";        << 366       if (region) G4cout << region->GetName();
448       if (region) { G4cout << region->GetName( << 
449       G4cout << ">  Elow(MeV)= ";                 367       G4cout << ">  Elow(MeV)= ";
450       for(G4int iii=0; iii<=n; ++iii) {G4cout  << 368       for(G4int ii=0; ii<n; ii++) {G4cout << eLow[ii]/MeV << " ";}
451       G4cout << G4endl;                           369       G4cout << G4endl;
452     }                                             370     }
453     auto rm = new G4RegionModels(n, modelAtReg << 371     G4RegionModels* rm = new G4RegionModels(n, modelAtRegion, eLow);
454     setOfRegionModels[reg] = rm;                  372     setOfRegionModels[reg] = rm;
455     // shortcut                                << 
456     if(1 == nEmModels) { break; }              << 
457   }                                               373   }
458                                                   374 
459   currRegionModel = setOfRegionModels[0];      << 
460   currModel = models[0];                       << 
461                                                << 
462   // Access to materials and build cuts           375   // Access to materials and build cuts
463   std::size_t idx = 1;                         << 376 
464   if(nullptr != secondaryParticle) {           << 377   for(G4int i=0; i<numOfCouples; i++) {
465     if( secondaryParticle == G4Gamma::Gamma()  << 
466     else if( secondaryParticle == G4Electron:: << 
467     else if( secondaryParticle == G4Positron:: << 
468     else { idx = 3; }                          << 
469   }                                            << 
470                                                << 
471   theCuts =                                    << 
472     static_cast<const G4DataVector*>(theCouple << 
473                                                << 
474   // for the second run the check on cuts shou << 
475   if(nullptr != theCutsNew) { *theCutsNew = *t << 
476                                                << 
477   //  G4cout << "========Start define cuts" << << 
478   // define cut values                         << 
479   for(std::size_t i=0; i<numOfCouples; ++i) {  << 
480                                                   378 
481     const G4MaterialCutsCouple* couple =          379     const G4MaterialCutsCouple* couple = 
482       theCoupleTable->GetMaterialCutsCouple((G << 380       theCoupleTable->GetMaterialCutsCouple(i);
483     const G4Material* material = couple->GetMa    381     const G4Material* material = couple->GetMaterial();
484     const G4ProductionCuts* pcuts = couple->Ge    382     const G4ProductionCuts* pcuts = couple->GetProductionCuts();
485                                                   383  
486     G4int reg = 0;                             << 384     G4int reg = nRegions;
487     if(nRegions > 1 && nEmModels > 1) {        << 385     do {reg--;} while (reg>0 && pcuts != (set[reg]->GetProductionCuts()));
488       reg = nRegions;                          << 386     idxOfRegionModels[i] = reg;
489       // Loop checking, 03-Aug-2015, Vladimir  << 387 
490       do {--reg;} while (reg>0 && pcuts != (se << 
491       idxOfRegionModels[i] = reg;              << 
492     }                                          << 
493     if(1 < verboseLevel) {                        388     if(1 < verboseLevel) {
494       G4cout << "G4EmModelManager::Initialise(    389       G4cout << "G4EmModelManager::Initialise() for "
495              << material->GetName()               390              << material->GetName()
496              << " indexOfCouple= " << i           391              << " indexOfCouple= " << i
497              << " indexOfRegion= " << reg         392              << " indexOfRegion= " << reg
498              << G4endl;                           393              << G4endl;
499     }                                             394     }
500                                                   395 
501     G4double cut = (*theCuts)[i];              << 396     G4double cut = DBL_MAX;
502     if(nullptr != secondaryParticle) {         << 397     G4double subcut = DBL_MAX;
                                                   >> 398     if(secondaryParticle) {
                                                   >> 399       size_t idx = 1;
                                                   >> 400       if( secondaryParticle == G4Gamma::Gamma() ) idx = 0;
                                                   >> 401       cut = (*theCoupleTable->GetEnergyCutsVector(idx))[i];
                                                   >> 402       if( secondaryParticle == G4Positron::Positron() && cut < DBL_MAX )
                                                   >> 403         cut += (*theCoupleTable->GetEnergyCutsVector(2))[i] + 
                                                   >> 404          2.0*electron_mass_c2;
                                                   >> 405 
                                                   >> 406       // compute subcut 
                                                   >> 407       if( cut < DBL_MAX ) subcut = minSubRange*cut;
                                                   >> 408       if(pcuts->GetProductionCut(idx) < maxCutInRange) {
                                                   >> 409   G4double tcutmax = 
                                                   >> 410     theCoupleTable->ConvertRangeToEnergy(secondaryParticle,
                                                   >> 411                  material,maxSubCutInRange);
                                                   >> 412   if(tcutmax < subcut) subcut = tcutmax;
                                                   >> 413       }
                                                   >> 414     }
                                                   >> 415 
                                                   >> 416     G4int nm = setOfRegionModels[reg]->NumberOfModels();
                                                   >> 417     for(G4int j=0; j<nm; j++) {
                                                   >> 418 
                                                   >> 419       G4VEmModel* model = models[setOfRegionModels[reg]->ModelIndex(j)];
                                                   >> 420 
                                                   >> 421       G4double tcutmin = model->MinEnergyCut(particle, couple);
503                                                   422 
504       // note that idxOfRegionModels[] not alw << 423       if(cut < tcutmin) cut = tcutmin;
505       G4int inn = 0;                           << 424       if(subcut < tcutmin) subcut = tcutmin;
506       G4int nnm = 1;                           << 425       if(1 < verboseLevel) {
507       if(nRegions > 1 && nEmModels > 1) {      << 426             G4cout << "The model # " << j
508         inn = idxOfRegionModels[i];            << 427                    << "; tcutmin(MeV)= " << tcutmin/MeV
                                                   >> 428                    << "; tcut(MeV)= " << cut/MeV
                                                   >> 429                    << "; tsubcut(MeV)= " << subcut/MeV
                                                   >> 430                    << " for " << particle->GetParticleName()
                                                   >> 431        << G4endl;
509       }                                           432       }
510       // check cuts and introduce upper limits << 
511       //G4cout << "idx= " << i << " cut(keV)=  << 
512       currRegionModel = setOfRegionModels[inn] << 
513       nnm = currRegionModel->NumberOfModels(); << 
514                                                << 
515       //G4cout << "idx= " << i << " Nmod= " << << 
516                                                << 
517       for(G4int jj=0; jj<nnm; ++jj) {          << 
518         //G4cout << "jj= " << jj << "  modidx= << 
519         //       << currRegionModel->ModelInde << 
520         currModel = models[currRegionModel->Mo << 
521         G4double cutlim = currModel->MinEnergy << 
522         if(cutlim > cut) {                     << 
523           if(nullptr == theCutsNew) { theCutsN << 
524           (*theCutsNew)[i] = cutlim;           << 
525           /*                                   << 
526           G4cout << "### " << partname << " en << 
527                  << material->GetName()        << 
528                  << "  Cut was changed from "  << 
529                  << cutlim/keV << " keV " << " << 
530                  << currModel->GetName() << G4 << 
531           */                                   << 
532         }                                      << 
533       }                                        << 
534     }                                             433     }
                                                   >> 434     theCuts.push_back(cut);
                                                   >> 435     theSubCuts.push_back(subcut);
535   }                                               436   }
536   if(nullptr != theCutsNew) { theCuts = theCut << 
537                                                   437 
538   // initialize models                         << 438   for(G4int jj=0; jj<nEmModels; jj++) {
539   G4int nn = 0;                                << 439     models[jj]->Initialise(particle, theCuts);
540   severalModels = true;                        << 440     if(flucModels[jj]) flucModels[jj]->InitialiseMe(particle);
541   for(G4int jj=0; jj<nEmModels; ++jj) {        << 
542     if(1 == isUsed[jj]) {                      << 
543       ++nn;                                    << 
544       currModel = models[jj];                  << 
545       currModel->Initialise(particle, *theCuts << 
546       if(nullptr != flucModels[jj]) { flucMode << 
547     }                                          << 
548   }                                               441   }
549   if(1 == nn) { severalModels = false; }       << 442 
550                                                   443 
551   if(1 < verboseLevel) {                          444   if(1 < verboseLevel) {
552     G4cout << "G4EmModelManager for " << parti << 445     G4cout << "G4EmModelManager for " << particle->GetParticleName() 
553            << " is initialised; nRegions=  " <    446            << " is initialised; nRegions=  " << nRegions
554            << " severalModels: " << severalMod << 
555            << G4endl;                             447            << G4endl;
556   }                                               448   }
557   return theCuts;                              << 449 
                                                   >> 450   return &theCuts;
558 }                                                 451 }
559                                                   452 
560 //....oooOO0OOooo........oooOO0OOooo........oo    453 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
561                                                   454 
562 void G4EmModelManager::FillDEDXVector(G4Physic    455 void G4EmModelManager::FillDEDXVector(G4PhysicsVector* aVector,
563                                       const G4 << 456               const G4MaterialCutsCouple* couple,
564                                       G4EmTabl    457                                       G4EmTableType tType)
565 {                                                 458 {
566   std::size_t i = couple->GetIndex();          << 459 
567   G4double cut  = (fTotal == tType) ? DBL_MAX  << 460   // vectors to provide continues dE/dx
                                                   >> 461   G4DataVector factor;
                                                   >> 462   G4DataVector dedxLow;
                                                   >> 463   G4DataVector dedxHigh;
                                                   >> 464 
                                                   >> 465   G4double e;
                                                   >> 466 
                                                   >> 467   size_t i = couple->GetIndex();
                                                   >> 468   G4double cut = theCuts[i];
                                                   >> 469   G4double subcut = 0.0;
                                                   >> 470 
                                                   >> 471   if(fTotal == tType) cut = DBL_MAX;
                                                   >> 472   else if(fSubRestricted == tType) subcut = theSubCuts[i];
568                                                   473 
569   if(1 < verboseLevel) {                          474   if(1 < verboseLevel) {
570     G4cout << "G4EmModelManager::FillDEDXVecto    475     G4cout << "G4EmModelManager::FillDEDXVector() for "
571            << couple->GetMaterial()->GetName()    476            << couple->GetMaterial()->GetName()
572            << "  cut(MeV)= " << cut            << 477      << "  Ecut(MeV)= " << cut
573            << "  Type " << tType               << 478      << "  Esubcut(MeV)= " << subcut
574            << "  for " << particle->GetParticl << 479      << "  Type " << tType
                                                   >> 480      << "  for " << particle->GetParticleName()
575            << G4endl;                             481            << G4endl;
576   }                                               482   }
577                                                   483 
578   G4int reg  = 0;                              << 484   G4int reg  = idxOfRegionModels[i];
579   if(nRegions > 1 && nEmModels > 1) { reg = id << 
580   const G4RegionModels* regModels = setOfRegio    485   const G4RegionModels* regModels = setOfRegionModels[reg];
581   G4int nmod = regModels->NumberOfModels();       486   G4int nmod = regModels->NumberOfModels();
                                                   >> 487   factor.resize(nmod);
                                                   >> 488   dedxLow.resize(nmod);
                                                   >> 489   dedxHigh.resize(nmod);
                                                   >> 490 
                                                   >> 491   if(1 < verboseLevel) {
                                                   >> 492       G4cout << "There are " << nmod << " models for "
                                                   >> 493              << couple->GetMaterial()->GetName()
                                                   >> 494        << " at the region #" << reg
                                                   >> 495        << G4endl;
                                                   >> 496   }
                                                   >> 497 
                                                   >> 498 
                                                   >> 499   // calculate factors to provide continuity of energy loss
                                                   >> 500   factor[0] = 1.0;
                                                   >> 501   G4int j;
                                                   >> 502 
                                                   >> 503   G4int totBinsLoss = aVector->GetVectorLength();
                                                   >> 504 
                                                   >> 505   dedxLow[0]  = 0.0;
                                                   >> 506 
                                                   >> 507   e = upperEkin[regModels->ModelIndex(0)];
                                                   >> 508   G4VEmModel* model = models[regModels->ModelIndex(0)]; 
                                                   >> 509   dedxHigh[0] = 0.0;
                                                   >> 510   if(model && cut > subcut) {
                                                   >> 511     dedxHigh[0] = model->ComputeDEDX(couple,particle,e,cut);
                                                   >> 512     if(subcut > 0.0) 
                                                   >> 513       dedxHigh[0] -= model->ComputeDEDX(couple,particle,e,subcut);
                                                   >> 514   }
                                                   >> 515   if(nmod > 1) {
                                                   >> 516     for(j=1; j<nmod; j++) {
                                                   >> 517 
                                                   >> 518       e = upperEkin[regModels->ModelIndex(j-1)];
                                                   >> 519       G4int idx = regModels->ModelIndex(j); 
                                                   >> 520 
                                                   >> 521       dedxLow[j] = models[idx]->ComputeDEDX(couple,particle,e,cut);
                                                   >> 522       if(subcut > 0.0) 
                                                   >> 523   dedxLow[j] -= models[idx]->ComputeDEDX(couple,particle,e,subcut);
                                                   >> 524       if(subcut == cut) dedxLow[j] = 0.0;
                                                   >> 525 
                                                   >> 526       e = upperEkin[idx];
                                                   >> 527       dedxHigh[j] = models[idx]->ComputeDEDX(couple,particle,e,cut);
                                                   >> 528       if(subcut > 0.0) 
                                                   >> 529   dedxHigh[j] -= models[idx]->ComputeDEDX(couple,particle,e,subcut);
                                                   >> 530       if(subcut == cut) dedxHigh[j] = 0.0;
                                                   >> 531     }
                                                   >> 532 
                                                   >> 533     for(j=1; j<nmod; j++) {
                                                   >> 534       if(dedxLow[j] > 0.0) factor[j] = (dedxHigh[j-1]/dedxLow[j] - 1.0);
                                                   >> 535       else                 factor[j] = 0.0;
                                                   >> 536     }
                                                   >> 537 
                                                   >> 538     if(2 < verboseLevel) {
                                                   >> 539       G4cout << "Loop over " << totBinsLoss << " bins start " << G4endl;
                                                   >> 540     }
                                                   >> 541   }
582                                                   542 
583   // Calculate energy losses vector               543   // Calculate energy losses vector
584   std::size_t totBinsLoss = aVector->GetVector << 544   for(j=0; j<totBinsLoss; j++) {
585   G4double del = 0.0;                          << 
586   G4int    k0  = 0;                            << 
587                                                   545 
588   for(std::size_t j=0; j<totBinsLoss; ++j) {   << 546     G4double e = aVector->GetLowEdgeEnergy(j);
589     G4double e = aVector->Energy(j);           << 547     G4double fac = 1.0;
590                                                   548 
591     // Choose a model of energy losses         << 549       // Choose a model of energy losses
592     G4int k = 0;                                  550     G4int k = 0;
593     if (nmod > 1) {                            << 551     if (nmod > 1 && e > upperEkin[regModels->ModelIndex(0)]) {
594       k = nmod;                                << 552       do {
595       // Loop checking, 03-Aug-2015, Vladimir  << 553         k++;
596       do {--k;} while (k>0 && e <= regModels-> << 554         fac *= (1.0 + factor[k]*upperEkin[regModels->ModelIndex(k-1)]/e);
597       //G4cout << "k= " << k << G4endl;        << 555       } while (k<nmod-1 && e > upperEkin[regModels->ModelIndex(k)] );
598       if(k > 0 && k != k0) {                   << 556     }
599         k0 = k;                                << 557 
600         G4double elow = regModels->LowEdgeEner << 558     model = models[regModels->ModelIndex(k)];
601   G4double dedx1 =                             << 559     G4double dedx = 0.0;
602     models[regModels->ModelIndex(k-1)]->Comput << 560     G4double dedx0 = 0.0;
603         G4double dedx2 =                       << 561     if(model && cut > subcut) {
604     models[regModels->ModelIndex(k)]->ComputeD << 562       dedx = model->ComputeDEDX(couple,particle,e,cut); 
605         del = (dedx2 > 0.0) ? (dedx1/dedx2 - 1 << 563       dedx0 = dedx;
606         //G4cout << "elow= " << elow           << 564       if(subcut > 0.0) dedx -= model->ComputeDEDX(couple,particle,e,subcut); 
607         //       << " dedx1= " << dedx1 << " d << 565       dedx *= fac;
608       }                                        << 
609     }                                             566     }
610     G4double dedx = (1.0 + del/e)*             << 
611     models[regModels->ModelIndex(k)]->ComputeD << 
612                                                   567 
                                                   >> 568     if(dedx < 0.0) dedx = 0.0;
613     if(2 < verboseLevel) {                        569     if(2 < verboseLevel) {
614       G4cout << "Material= " << couple->GetMat << 570         G4cout << "Material= " << couple->GetMaterial()->GetName()
615              << "   E(MeV)= " << e/MeV         << 571                << "   E(MeV)= " << e/MeV
616              << "  dEdx(MeV/mm)= " << dedx*mm/ << 572                << "  dEdx(MeV/mm)= " << dedx*mm/MeV
617              << "  del= " << del*mm/MeV<< " k= << 573                << "  dEdx0(MeV/mm)= " << dedx0*mm/MeV
618              << " modelIdx= " << regModels->Mo << 574                << "  fac= " << fac
619              << G4endl;                        << 575                << G4endl;
620     }                                             576     }
621     dedx = std::max(dedx, 0.0);                << 
622     aVector->PutValue(j, dedx);                   577     aVector->PutValue(j, dedx);
623   }                                               578   }
624 }                                                 579 }
625                                                   580 
626 //....oooOO0OOooo........oooOO0OOooo........oo    581 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
627                                                   582 
628 void G4EmModelManager::FillLambdaVector(G4Phys    583 void G4EmModelManager::FillLambdaVector(G4PhysicsVector* aVector,
629                                         const  << 584           const G4MaterialCutsCouple* couple,
630                                         G4bool << 585                 G4bool startFromNull,
631                                         G4EmTa << 586           G4EmTableType tType)
632 {                                              << 587 {
633   std::size_t i = couple->GetIndex();          << 588   // vectors to provide continues cross section
634   G4double cut  = (*theCuts)[i];               << 589   G4DataVector factor;
                                                   >> 590   G4DataVector sigmaLow;
                                                   >> 591   G4DataVector sigmaHigh;
                                                   >> 592 
                                                   >> 593   G4double e;
                                                   >> 594 
                                                   >> 595   size_t i = couple->GetIndex();
                                                   >> 596   G4double cut  = theCuts[i];
635   G4double tmax = DBL_MAX;                        597   G4double tmax = DBL_MAX;
                                                   >> 598   if (fSubRestricted == tType) {
                                                   >> 599     tmax = cut;
                                                   >> 600     cut  = theSubCuts[i];
                                                   >> 601   }
636                                                   602 
637   G4int reg  = 0;                              << 
638   if(nRegions > 1 && nEmModels > 1) { reg  = i << 
639   const G4RegionModels* regModels = setOfRegio << 
640   G4int nmod = regModels->NumberOfModels();    << 
641   if(1 < verboseLevel) {                          603   if(1 < verboseLevel) {
642     G4cout << "G4EmModelManager::FillLambdaVec << 604     G4cout << "G4EmModelManager::FillLambdaVector() for particle "
643            << particle->GetParticleName()         605            << particle->GetParticleName()
644            << " in " << couple->GetMaterial()-    606            << " in " << couple->GetMaterial()->GetName()
645            << " Emin(MeV)= " << aVector->Energ << 607      << "  Ecut(MeV)= " << cut
646            << " Emax(MeV)= " << aVector->GetMa << 608      << "  Emax(MeV)= " << tmax
647            << " cut= " << cut                  << 609      << "  Type " << tType   
648            << " Type " << tType                << 
649            << " nmod= " << nmod                << 
650            << G4endl;                             610            << G4endl;
651   }                                               611   }
652                                                   612 
653   // Calculate lambda vector                   << 613   G4int reg  = idxOfRegionModels[i];
654   std::size_t totBinsLambda = aVector->GetVect << 614   const G4RegionModels* regModels = setOfRegionModels[reg];
655   G4double del = 0.0;                          << 615   G4int nmod = regModels->NumberOfModels();
656   G4int    k0  = 0;                            << 616   factor.resize(nmod);
657   G4int     k  = 0;                            << 617   sigmaLow.resize(nmod);
658   G4VEmModel* mod = models[regModels->ModelInd << 618   sigmaHigh.resize(nmod);
659   for(std::size_t j=0; j<totBinsLambda; ++j) { << 619 
660                                                << 620   if(2 < verboseLevel) {
661     G4double e = aVector->Energy(j);           << 621       G4cout << "There are " << nmod << " models for "
662                                                << 622              << couple->GetMaterial()->GetName() << G4endl;
663     // Choose a model                          << 623   }
664     if (nmod > 1) {                            << 624 
665       k = nmod;                                << 625   // calculate factors to provide continuity of energy loss
666       // Loop checking, 03-Aug-2015, Vladimir  << 626   factor[0] = 1.0;
667       do {--k;} while (k>0 && e <= regModels-> << 627   G4int j;
668       if(k > 0 && k != k0) {                   << 628   G4int totBinsLambda = aVector->GetVectorLength();
669         k0 = k;                                << 629 
670         G4double elow = regModels->LowEdgeEner << 630   sigmaLow[0]  = 0.0;
671         G4VEmModel* mod1 = models[regModels->M << 631 
672         G4double xs1  = mod1->CrossSection(cou << 632   e = upperEkin[regModels->ModelIndex(0)];
673         mod = models[regModels->ModelIndex(k)] << 633   G4VEmModel* model = models[regModels->ModelIndex(0)];
674         G4double xs2 = mod->CrossSection(coupl << 634   sigmaHigh[0] = 0.0;
675         del = (xs2 > 0.0) ? (xs1/xs2 - 1.0)*el << 635   if(model) sigmaHigh[0] = model->CrossSection(couple,particle,e,cut,tmax);
676         //G4cout << "New model k=" << k << " E << 636 
677         //       << " Elow(MeV)= " << elow/MeV << 637   if(2 < verboseLevel) {
                                                   >> 638       G4cout << "### For material " << couple->GetMaterial()->GetName()
                                                   >> 639              << "  " << nmod
                                                   >> 640              << " models"
                                                   >> 641              << " Ecut(MeV)= " << cut/MeV
                                                   >> 642              << " Emax(MeV)= " << e/MeV
                                                   >> 643              << " nbins= "  << totBinsLambda
                                                   >> 644              << G4endl;
                                                   >> 645       G4cout << " model #0   eUp= " << e 
                                                   >> 646        << "  sigmaUp= " << sigmaHigh[0] << G4endl;
                                                   >> 647   }
                                                   >> 648 
                                                   >> 649 
                                                   >> 650   if(nmod > 1) {
                                                   >> 651 
                                                   >> 652     for(j=1; j<nmod; j++) {
                                                   >> 653 
                                                   >> 654       e  = upperEkin[regModels->ModelIndex(j-1)];
                                                   >> 655       sigmaLow[j] = 
                                                   >> 656   models[regModels->ModelIndex(j)]->CrossSection(couple,particle,e,cut,tmax);
                                                   >> 657       e  = upperEkin[regModels->ModelIndex(j)];
                                                   >> 658       sigmaHigh[j] = 
                                                   >> 659   models[regModels->ModelIndex(j)]->CrossSection(couple,particle,e,cut,tmax);
                                                   >> 660       if(1 < verboseLevel) {
                                                   >> 661         G4cout << " model #" << j << "   eUp= " << e 
                                                   >> 662          << "  sigmaUp= " << sigmaHigh[j]
                                                   >> 663          << "  sigmaDown= " << sigmaLow[j]
                                                   >> 664          << G4endl;
678       }                                           665       }
679     }                                             666     }
680     G4double cross = (1.0 + del/e)*mod->CrossS << 667     for(j=1; j<nmod; j++) {
681     if(fIsCrossSectionPrim == tType) { cross * << 668       if(sigmaLow[j] > 0.0) factor[j] = (sigmaHigh[j-1]/sigmaLow[j] - 1.0);
682                                                << 669       else                  factor[j] = 0.0;
683     if(j==0 && startFromNull) { cross = 0.0; } << 
684                                                << 
685     if(2 < verboseLevel) {                     << 
686       G4cout << "FillLambdaVector: " << j << " << 
687              << "  cross(1/mm)= " << cross*mm  << 
688              << " del= " << del*mm << " k= " < << 
689              << " modelIdx= " << regModels->Mo << 
690              << G4endl;                        << 
691     }                                             670     }
692     cross = std::max(cross, 0.0);              << 
693     aVector->PutValue(j, cross);               << 
694   }                                               671   }
695 }                                              << 
696                                                   672 
697 //....oooOO0OOooo........oooOO0OOooo........oo << 673   // Calculate lambda vector
                                                   >> 674   for(j=0; j<totBinsLambda; j++) {
698                                                   675 
699 void G4EmModelManager::DumpModelList(std::ostr << 676     e = aVector->GetLowEdgeEnergy(j);
700 {                                              << 677 
701   if(verb == 0) { return; }                    << 678     // Choose a model of energy losses
702   for(G4int i=0; i<nRegions; ++i) {            << 679     G4int k = 0;
703     G4RegionModels* r = setOfRegionModels[i];  << 680     G4double fac = 1.0;
704     const G4Region* reg = r->Region();         << 681     if (nmod > 1 && e > upperEkin[regModels->ModelIndex(0)]) {
705     G4int n = r->NumberOfModels();             << 682       do {
706     if(n > 0) {                                << 683         k++;
707       out << "      ===== EM models for the G4 << 684         fac *= (1.0 + factor[k]*upperEkin[regModels->ModelIndex(k-1)]/e);
708     << " ======" << G4endl;                    << 685       } while (k<nmod-1 && e > upperEkin[regModels->ModelIndex(k)] );
709       for(G4int j=0; j<n; ++j) {               << 
710         G4VEmModel* model = models[r->ModelInd << 
711         G4double emin =                        << 
712           std::max(r->LowEdgeEnergy(j),model-> << 
713         G4double emax =                        << 
714           std::min(r->LowEdgeEnergy(j+1),model << 
715         if(emax > emin) {                      << 
716     out << std::setw(20);                      << 
717     out << model->GetName() << " : Emin="      << 
718         << std::setw(5) << G4BestUnit(emin,"En << 
719         << " Emax="                            << 
720         << std::setw(5) << G4BestUnit(emax,"En << 
721     G4PhysicsTable* table = model->GetCrossSec << 
722     if(table) {                                << 
723       std::size_t kk = table->size();          << 
724       for(std::size_t k=0; k<kk; ++k) {        << 
725         const G4PhysicsVector* v = (*table)[k] << 
726         if(v) {                                << 
727     G4int nn = G4int(v->GetVectorLength() - 1) << 
728     out << " Nbins=" << nn << " "              << 
729         << std::setw(3) << G4BestUnit(v->Energ << 
730         << " - "                               << 
731         << std::setw(3) << G4BestUnit(v->Energ << 
732     break;                                     << 
733         }                                      << 
734       }                                        << 
735           }                                    << 
736     G4VEmAngularDistribution* an = model->GetA << 
737     if(an) { out << "  " << an->GetName(); }   << 
738     if(fluoFlag && model->DeexcitationFlag())  << 
739       out << " Fluo";                          << 
740     }                                          << 
741     out << G4endl;                             << 
742           auto msc = dynamic_cast<G4VMscModel* << 
743           if(msc != nullptr) msc->DumpParamete << 
744   }                                            << 
745       }                                        << 
746     }                                             686     }
747     if(1 == nEmModels) { break; }              << 687 
748   }                                            << 688     model = models[regModels->ModelIndex(k)];
749   if(theCutsNew) {                             << 689     G4double cross = 0.0;
750     out << "      ===== Limit on energy thresh << 690     if(model) cross = model->CrossSection(couple,particle,e,cut,tmax)*fac;
                                                   >> 691     if(j==0 && startFromNull) cross = 0.0;
                                                   >> 692 
                                                   >> 693     if(2 < verboseLevel) {
                                                   >> 694       G4cout << "FillLambdaVector: " << j << ".   e(MeV)= " << e/MeV
                                                   >> 695        << "  cross(1/mm)= " << cross*mm
                                                   >> 696        << " fac= " << fac << " k= " << k 
                                                   >> 697        << " model= " << regModels->ModelIndex(k)
                                                   >> 698        << G4endl;
                                                   >> 699     }
                                                   >> 700     if(cross < 0.0) cross = 0.0;
                                                   >> 701 
                                                   >> 702     aVector->PutValue(j, cross);
751   }                                               703   }
752 }                                                 704 }
753                                                   705 
754 //....oooOO0OOooo........oooOO0OOooo........oo    706 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
755                                                   707