Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/processes/electromagnetic/utils/src/G4LossTableManager.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/G4LossTableManager.cc (Version 11.3.0) and /processes/electromagnetic/utils/src/G4LossTableManager.cc (Version 7.0.p1)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                    <<   3 // * DISCLAIMER                                                       *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th <<   5 // * The following disclaimer summarizes all the specific disclaimers *
  6 // * the Geant4 Collaboration.  It is provided <<   6 // * of contributors to this software. The specific disclaimers,which *
  7 // * conditions of the Geant4 Software License <<   7 // * govern, are listed with their locations in:                      *
  8 // * LICENSE and available at  http://cern.ch/ <<   8 // *   http://cern.ch/geant4/license                                  *
  9 // * include a list of copyright holders.      << 
 10 // *                                                9 // *                                                                  *
 11 // * Neither the authors of this software syst     10 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     11 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     12 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     13 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file  <<  14 // * use.                                                             *
 16 // * for the full disclaimer and the limitatio << 
 17 // *                                               15 // *                                                                  *
 18 // * This  code  implementation is the result  <<  16 // * This  code  implementation is the  intellectual property  of the *
 19 // * technical work of the GEANT4 collaboratio <<  17 // * GEANT4 collaboration.                                            *
 20 // * By using,  copying,  modifying or  distri <<  18 // * By copying,  distributing  or modifying the Program (or any work *
 21 // * any work based  on the software)  you  ag <<  19 // * based  on  the Program)  you indicate  your  acceptance of  this *
 22 // * use  in  resulting  scientific  publicati <<  20 // * statement, and all its terms.                                    *
 23 // * acceptance of all terms of the Geant4 Sof << 
 24 // *******************************************     21 // ********************************************************************
 25 //                                                 22 //
                                                   >>  23 // $Id: G4LossTableManager.cc,v 1.53 2005/01/25 19:10:23 vnivanch Exp $
                                                   >>  24 // GEANT4 tag $Name: geant4-07-00-patch-01 $
                                                   >>  25 //
 26 // -------------------------------------------     26 // -------------------------------------------------------------------
 27 //                                                 27 //
 28 // GEANT4 Class file                               28 // GEANT4 Class file
 29 //                                                 29 //
 30 //                                                 30 //
 31 // File name:     G4LossTableManager               31 // File name:     G4LossTableManager
 32 //                                                 32 //
 33 // Author:        Vladimir Ivanchenko              33 // Author:        Vladimir Ivanchenko
 34 //                                                 34 //
 35 // Creation date: 03.01.2002                       35 // Creation date: 03.01.2002
 36 //                                                 36 //
 37 // Modifications: by V.Ivanchenko              <<  37 // Modifications:
 38 //                                                 38 //
                                                   >>  39 // 20-01-03 Migrade to cut per region (V.Ivanchenko)
                                                   >>  40 // 15-02-03 Lambda table can be scaled (V.Ivanchenko)
                                                   >>  41 // 17-02-03 Fix problem of store/restore tables (V.Ivanchenko)
                                                   >>  42 // 10-03-03 Add Ion registration (V.Ivanchenko)
                                                   >>  43 // 25-03-03 Add deregistration (V.Ivanchenko)
                                                   >>  44 // 02-04-03 Change messenger (V.Ivanchenko)
                                                   >>  45 // 26-04-03 Fix retrieve tables (V.Ivanchenko)
                                                   >>  46 // 13-05-03 Add calculation of precise range (V.Ivanchenko)
                                                   >>  47 // 23-07-03 Add exchange with G4EnergyLossTables (V.Ivanchenko)
                                                   >>  48 // 05-10-03 Add G4VEmProcesses registration and Verbose command (V.Ivanchenko)
                                                   >>  49 // 17-10-03 Add SetParameters method (V.Ivanchenko)
                                                   >>  50 // 23-10-03 Add control on inactive processes (V.Ivanchenko)
                                                   >>  51 // 04-11-03 Add checks in RetrievePhysicsTable (V.Ivanchenko)
                                                   >>  52 // 12-11-03 G4EnergyLossSTD -> G4EnergyLossProcess (V.Ivanchenko)
                                                   >>  53 // 14-01-04 Activate precise range calculation (V.Ivanchenko)
                                                   >>  54 // 10-03-04 Fix a problem of Precise Range table (V.Ivanchenko)
                                                   >>  55 // 08-11-04 Migration to new interface of Store/Retrieve tables (V.Ivanchenko)
                                                   >>  56 // 13-01-04 Fix problem which takes place for inactivate eIoni (V.Ivanchenko)
                                                   >>  57 // 25-01-04 Fix initialisation problem for ions (V.Ivanchenko)
 39 //                                                 58 //
 40 // Class Description:                              59 // Class Description:
 41 //                                                 60 //
 42 // -------------------------------------------     61 // -------------------------------------------------------------------
 43 //                                                 62 //
 44 //....oooOO0OOooo........oooOO0OOooo........oo     63 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 45 //....oooOO0OOooo........oooOO0OOooo........oo     64 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
 46                                                    65 
 47 #include "G4LossTableManager.hh"                   66 #include "G4LossTableManager.hh"
 48 #include "G4SystemOfUnits.hh"                  <<  67 #include "G4EnergyLossMessenger.hh"
 49                                                << 
 50 #include "G4VMultipleScattering.hh"            << 
 51 #include "G4VEmProcess.hh"                     << 
 52                                                << 
 53 #include "G4EmParameters.hh"                   << 
 54 #include "G4EmSaturation.hh"                   << 
 55 #include "G4EmConfigurator.hh"                 << 
 56 #include "G4ElectronIonPair.hh"                << 
 57 #include "G4NIELCalculator.hh"                 << 
 58 #include "G4EmCorrections.hh"                  << 
 59 #include "G4LossTableBuilder.hh"               << 
 60 #include "G4VAtomDeexcitation.hh"              << 
 61 #include "G4VSubCutProducer.hh"                << 
 62                                                << 
 63 #include "G4PhysicsTable.hh"                       68 #include "G4PhysicsTable.hh"
 64 #include "G4ParticleDefinition.hh"                 69 #include "G4ParticleDefinition.hh"
 65 #include "G4MaterialCutsCouple.hh"                 70 #include "G4MaterialCutsCouple.hh"
 66 #include "G4ProcessManager.hh"                     71 #include "G4ProcessManager.hh"
 67 #include "G4Electron.hh"                           72 #include "G4Electron.hh"
 68 #include "G4Proton.hh"                             73 #include "G4Proton.hh"
                                                   >>  74 #include "G4VMultipleScattering.hh"
                                                   >>  75 #include "G4VEmProcess.hh"
 69 #include "G4ProductionCutsTable.hh"                76 #include "G4ProductionCutsTable.hh"
 70 #include "G4PhysicsTableHelper.hh"                 77 #include "G4PhysicsTableHelper.hh"
 71 #include "G4EmTableType.hh"                    << 
 72 #include "G4Region.hh"                         << 
 73 #include "G4PhysicalConstants.hh"              << 
 74                                                << 
 75 #include "G4Gamma.hh"                          << 
 76 #include "G4Positron.hh"                       << 
 77 #include "G4OpticalPhoton.hh"                  << 
 78 #include "G4Neutron.hh"                        << 
 79 #include "G4MuonPlus.hh"                       << 
 80 #include "G4MuonMinus.hh"                      << 
 81 #include "G4GenericIon.hh"                     << 
 82                                                    78 
 83 //....oooOO0OOooo........oooOO0OOooo........oo <<  79 G4LossTableManager* G4LossTableManager::theInstance = 0;
 84                                                    80 
 85 static std::once_flag applyOnce;               <<  81 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
 86 G4ThreadLocal G4LossTableManager* G4LossTableM << 
 87                                                    82 
 88 G4LossTableManager* G4LossTableManager::Instan     83 G4LossTableManager* G4LossTableManager::Instance()
 89 {                                                  84 {
 90   if(nullptr == instance) {                    <<  85   if(0 == theInstance) {
 91     static G4ThreadLocalSingleton<G4LossTableM <<  86     static G4LossTableManager manager;
 92     instance = inst.Instance();                <<  87     theInstance = &manager;
 93   }                                                88   }
 94   return instance;                             <<  89   return theInstance;
 95 }                                                  90 }
 96                                                    91 
 97 //....oooOO0OOooo........oooOO0OOooo........oo     92 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
 98                                                    93 
 99 G4LossTableManager::~G4LossTableManager()          94 G4LossTableManager::~G4LossTableManager()
100 {                                                  95 {
101   for (auto const & p : loss_vector) { delete  <<  96   for (G4int i=0; i<n_loss; i++) {
102   for (auto const & p : msc_vector) { delete p <<  97     if( loss_vector[i] ) delete loss_vector[i];
103   for (auto const & p : emp_vector) { delete p <<  98   }
104   for (auto const & p : p_vector) { delete p;  <<  99   size_t msc = msc_vector.size();
105                                                << 100   for (size_t j=0; j<msc; j++) {
106   std::size_t mod = mod_vector.size();         << 101     if(msc_vector[j] ) delete msc_vector[j];
107   std::size_t fmod = fmod_vector.size();       << 102   }
108   for (std::size_t a=0; a<mod; ++a) {          << 103   size_t emp = emp_vector.size();
109     if( nullptr != mod_vector[a] ) {           << 104   for (size_t k=0; k<emp; k++) {
110       for (std::size_t b=0; b<fmod; ++b) {     << 105     if(emp_vector[k] ) delete emp_vector[k];
111         if((G4VEmModel*)(fmod_vector[b]) == mo << 
112           fmod_vector[b] = nullptr;            << 
113         }                                      << 
114       }                                        << 
115       delete mod_vector[a];                    << 
116       mod_vector[a] = nullptr;                 << 
117     }                                          << 
118   }                                               106   }
119   for (auto const & p : fmod_vector) { delete  << 
120                                                << 
121   Clear();                                        107   Clear();
                                                   >> 108   delete theMessenger;
122   delete tableBuilder;                            109   delete tableBuilder;
123   delete emCorrections;                        << 
124   delete emConfigurator;                       << 
125   delete emElectronIonPair;                    << 
126   delete nielCalculator;                       << 
127   delete atomDeexcitation;                     << 
128   delete subcutProducer;                       << 
129 }                                                 110 }
130                                                   111 
131 //....oooOO0OOooo........oooOO0OOooo........oo    112 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
132                                                   113 
133 G4LossTableManager::G4LossTableManager()          114 G4LossTableManager::G4LossTableManager()
134 {                                                 115 {
135   theParameters = G4EmParameters::Instance();  << 116   n_loss = 0;
136   theElectron = G4Electron::Electron();        << 117   first_entry = true;
137                                                << 118   all_tables_are_built = false;
138   // only one thread is the master             << 119   all_tables_are_stored = false;
139   std::call_once(applyOnce, [this]() { isMaste << 120   currentLoss = 0;
140   verbose = isMaster ? theParameters->Verbose( << 121   currentParticle = 0;
141                                                << 122   lossFluctuationFlag = true;
142   tableBuilder = new G4LossTableBuilder(isMast << 123   subCutoffFlag = false;
143   emCorrections = new G4EmCorrections(verbose) << 124   rndmStepFlag = false;
144                                                << 125   minSubRange = 0.0;
145   std::size_t n = 70;                          << 126   maxRangeVariation = 1.0;
146   loss_vector.reserve(n);                      << 127   maxFinalStep = 0.0;
147   part_vector.reserve(n);                      << 128   minKinEnergy = 0.1*keV;
148   base_part_vector.reserve(n);                 << 129   maxKinEnergy = 100.0*TeV;
149   dedx_vector.reserve(n);                      << 130   maxKinEnergyForMuons = 100.*TeV;
150   range_vector.reserve(n);                     << 131   theMessenger = new G4EnergyLossMessenger();
151   inv_range_vector.reserve(n);                 << 132   theElectron  = G4Electron::Electron();
152   tables_are_built.reserve(n);                 << 133   tableBuilder = new G4LossTableBuilder();
153   isActive.reserve(n);                         << 134   integral = true;
154   msc_vector.reserve(10);                      << 135   integralActive = false;
155   emp_vector.reserve(16);                      << 136   buildPreciseRange = false;
156   mod_vector.reserve(150);                     << 137   minEnergyActive = false;
157   fmod_vector.reserve(60);                     << 138   maxEnergyActive = false;
                                                   >> 139   maxEnergyForMuonsActive = false;
                                                   >> 140   stepFunctionActive = false;
                                                   >> 141   verbose = 0;
158 }                                                 142 }
159                                                   143 
160 //....oooOO0OOooo........oooOO0OOooo........oo    144 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
161                                                   145 
162 void G4LossTableManager::Clear()                  146 void G4LossTableManager::Clear()
163 {                                                 147 {
164   all_tables_are_built = false;                   148   all_tables_are_built = false;
165   currentLoss = nullptr;                       << 149   currentLoss = 0;
166   currentParticle = nullptr;                   << 150   currentParticle = 0;
167   if(n_loss) {                                 << 151   if(n_loss)
168     dedx_vector.clear();                       << 152     {
169     range_vector.clear();                      << 153       dedx_vector.clear();
170     inv_range_vector.clear();                  << 154       range_vector.clear();
171     loss_map.clear();                          << 155       inv_range_vector.clear();
172     loss_vector.clear();                       << 156       loss_map.clear();
173     part_vector.clear();                       << 157       loss_vector.clear();
174     base_part_vector.clear();                  << 158       part_vector.clear();
175     tables_are_built.clear();                  << 159       base_part_vector.clear();
176     isActive.clear();                          << 160       tables_are_built.clear();
177     n_loss = 0;                                << 161       n_loss = 0;
178   }                                            << 162     }
179 }                                                 163 }
180                                                   164 
181 //....oooOO0OOooo........oooOO0OOooo........oo    165 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
182                                                   166 
183 void G4LossTableManager::Register(G4VEnergyLos    167 void G4LossTableManager::Register(G4VEnergyLossProcess* p)
184 {                                                 168 {
185   if (nullptr == p) { return; }                << 169   n_loss++;
186   for (G4int i=0; i<n_loss; ++i) {             << 
187     if(loss_vector[i] == p) { return; }        << 
188   }                                            << 
189   if(verbose > 1) {                            << 
190     G4cout << "G4LossTableManager::Register G4 << 
191            << p->GetProcessName() << "  idx= " << 
192   }                                            << 
193   ++n_loss;                                    << 
194   loss_vector.push_back(p);                       170   loss_vector.push_back(p);
195   part_vector.push_back(nullptr);              << 171   part_vector.push_back(0);
196   base_part_vector.push_back(nullptr);         << 172   base_part_vector.push_back(0);
197   dedx_vector.push_back(nullptr);              << 173   dedx_vector.push_back(0);
198   range_vector.push_back(nullptr);             << 174   range_vector.push_back(0);
199   inv_range_vector.push_back(nullptr);         << 175   inv_range_vector.push_back(0);
200   tables_are_built.push_back(false);              176   tables_are_built.push_back(false);
201   isActive.push_back(true);                    << 
202   all_tables_are_built = false;                   177   all_tables_are_built = false;
203 }                                              << 178   if(!lossFluctuationFlag) p->SetLossFluctuations(false);
204                                                << 179   if(subCutoffFlag)        p->SetSubCutoff(true);
205 //....oooOO0OOooo........oooOO0OOooo........oo << 180   if(stepFunctionActive)   p->SetStepFunction(maxRangeVariation, maxFinalStep);
206                                                << 181   if(integralActive)       p->SetIntegral(integral);
207 void G4LossTableManager::ResetParameters()     << 182   if(minEnergyActive)      p->SetMinKinEnergy(minKinEnergy);
208 {                                              << 183   if(maxEnergyActive)      p->SetMaxKinEnergy(maxKinEnergy);
209   // initialisation once per run               << 
210   if (!resetParam) { return; }                 << 
211   resetParam = false;                          << 
212   startInitialisation = true;                  << 
213   verbose = theParameters->Verbose();          << 
214   if(!isMaster) {                              << 
215     verbose = theParameters->WorkerVerbose();  << 
216   } else {                                     << 
217     if(verbose > 0) { theParameters->Dump(); } << 
218   }                                            << 
219                                                << 
220   tableBuilder->InitialiseBaseMaterials();     << 
221   if (nullptr != nielCalculator) { nielCalcula << 
222                                                << 
223   emCorrections->SetVerbose(verbose);          << 
224   if(nullptr != emConfigurator) { emConfigurat << 
225   if(nullptr != emElectronIonPair) { emElectro << 
226   if(nullptr != atomDeexcitation) {            << 
227     atomDeexcitation->SetVerboseLevel(verbose) << 
228     atomDeexcitation->InitialiseAtomicDeexcita << 
229   }                                            << 
230   if (1 < verbose) {                           << 
231     G4cout << "====== G4LossTableManager::Rese << 
232            << " Nloss=" << loss_vector.size()  << 
233      << " run=" << run << " master=" << isMast << 
234      << G4endl;                                << 
235   }                                            << 
236 }                                                 184 }
237                                                   185 
238 //....oooOO0OOooo........oooOO0OOooo........oo    186 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
239                                                   187 
240 void G4LossTableManager::DeRegister(G4VEnergyL    188 void G4LossTableManager::DeRegister(G4VEnergyLossProcess* p)
241 {                                                 189 {
242   if (nullptr == p) { return; }                << 190   for (G4int i=0; i<n_loss; i++) {
243   for (G4int i=0; i<n_loss; ++i) {             << 191     if(loss_vector[i] == p) loss_vector[i] = 0;
244     if(loss_vector[i] == p) {                  << 
245       loss_vector[i] = nullptr;                << 
246       break;                                   << 
247     }                                          << 
248   }                                               192   }
249 }                                                 193 }
250                                                   194 
251 //....oooOO0OOooo........oooOO0OOooo........oo    195 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
252                                                   196 
253 void G4LossTableManager::Register(G4VMultipleS    197 void G4LossTableManager::Register(G4VMultipleScattering* p)
254 {                                                 198 {
255   if (nullptr == p) { return; }                << 
256   std::size_t n = msc_vector.size();           << 
257   for (std::size_t i=0; i<n; ++i) {            << 
258     if(msc_vector[i] == p) { return; }         << 
259   }                                            << 
260   if(verbose > 1) {                            << 
261     G4cout << "G4LossTableManager::Register G4 << 
262            << p->GetProcessName() << "  idx= " << 
263   }                                            << 
264   msc_vector.push_back(p);                        199   msc_vector.push_back(p);
265 }                                                 200 }
266                                                   201 
267 //....oooOO0OOooo........oooOO0OOooo........oo    202 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
268                                                   203 
269 void G4LossTableManager::DeRegister(G4VMultipl    204 void G4LossTableManager::DeRegister(G4VMultipleScattering* p)
270 {                                                 205 {
271   if (nullptr == p) { return; }                << 206   size_t msc = msc_vector.size();
272   std::size_t msc = msc_vector.size();         << 207   for (size_t i=0; i<msc; i++) {
273   for (std::size_t i=0; i<msc; ++i) {          << 208     if(msc_vector[i] == p) msc_vector[i] = 0;
274     if(msc_vector[i] == p) {                   << 
275       msc_vector[i] = nullptr;                 << 
276       break;                                   << 
277     }                                          << 
278   }                                               209   }
279 }                                                 210 }
280                                                   211 
281 //....oooOO0OOooo........oooOO0OOooo........oo    212 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
282                                                   213 
283 void G4LossTableManager::Register(G4VEmProcess    214 void G4LossTableManager::Register(G4VEmProcess* p)
284 {                                                 215 {
285   if (nullptr == p) { return; }                << 
286   std::size_t n = emp_vector.size();           << 
287   for (std::size_t i=0; i<n; ++i) {            << 
288     if(emp_vector[i] == p) { return; }         << 
289   }                                            << 
290   if(verbose > 1) {                            << 
291     G4cout << "G4LossTableManager::Register G4 << 
292            << p->GetProcessName() << "  idx= " << 
293   }                                            << 
294   emp_vector.push_back(p);                        216   emp_vector.push_back(p);
295 }                                                 217 }
296                                                   218 
297 //....oooOO0OOooo........oooOO0OOooo........oo    219 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
298                                                   220 
299 void G4LossTableManager::DeRegister(G4VEmProce    221 void G4LossTableManager::DeRegister(G4VEmProcess* p)
300 {                                                 222 {
301   if (nullptr == p) { return; }                << 223   size_t emp = emp_vector.size();
302   std::size_t emp = emp_vector.size();         << 224   for (size_t i=0; i<emp; i++) {
303   for (std::size_t i=0; i<emp; ++i) {          << 225     if(emp_vector[i] == p) emp_vector[i] = 0;
304     if(emp_vector[i] == p) {                   << 
305       emp_vector[i] = nullptr;                 << 
306       break;                                   << 
307     }                                          << 
308   }                                               226   }
309 }                                                 227 }
310                                                   228 
311 //....oooOO0OOooo........oooOO0OOooo........oo    229 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
312                                                   230 
313 void G4LossTableManager::Register(G4VProcess*  << 231 void G4LossTableManager::RegisterIon(const G4ParticleDefinition* ion, G4VEnergyLossProcess* p)
314 {                                                 232 {
315   if (nullptr == p) { return; }                << 233   loss_map[ion] = p;
316   std::size_t n = p_vector.size();             << 
317   for (std::size_t i=0; i<n; ++i) {            << 
318     if(p_vector[i] == p) { return; }           << 
319   }                                            << 
320   if(verbose > 1) {                            << 
321     G4cout << "G4LossTableManager::Register G4 << 
322            << p->GetProcessName() << "  idx= " << 
323   }                                            << 
324   p_vector.push_back(p);                       << 
325 }                                                 234 }
326                                                   235 
327 //....oooOO0OOooo........oooOO0OOooo........oo    236 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
328                                                   237 
329 void G4LossTableManager::DeRegister(G4VProcess << 238 void G4LossTableManager::RegisterExtraParticle(const G4ParticleDefinition* part,
                                                   >> 239                                                      G4VEnergyLossProcess* p)
330 {                                                 240 {
331   if (nullptr == p) { return; }                << 241   n_loss++;
332   std::size_t emp = p_vector.size();           << 242   loss_vector.push_back(p);
333   for (std::size_t i=0; i<emp; ++i) {          << 243   part_vector.push_back(part);
334     if(p_vector[i] == p) {                     << 244   base_part_vector.push_back(p->BaseParticle());
335       p_vector[i] = nullptr;                   << 245   dedx_vector.push_back(0);
336       break;                                   << 246   range_vector.push_back(0);
337     }                                          << 247   inv_range_vector.push_back(0);
338   }                                            << 248   tables_are_built.push_back(false);
339 }                                              << 249   all_tables_are_built = false;
340                                                << 
341 //....oooOO0OOooo........oooOO0OOooo........oo << 
342                                                << 
343 void G4LossTableManager::Register(G4VEmModel*  << 
344 {                                              << 
345   mod_vector.push_back(p);                     << 
346   if(verbose > 1) {                            << 
347     G4cout << "G4LossTableManager::Register G4 << 
348            << p->GetName() << "  " << p << "   << 
349   }                                            << 
350 }                                                 250 }
351                                                   251 
352 //....oooOO0OOooo........oooOO0OOooo........oo    252 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
353                                                   253 
354 void G4LossTableManager::DeRegister(G4VEmModel << 254 void G4LossTableManager::EnergyLossProcessIsInitialised(
                                                   >> 255                    const G4ParticleDefinition* particle, G4VEnergyLossProcess* p)
355 {                                                 256 {
356   //G4cout << "G4LossTableManager::DeRegister  << 257   if (first_entry || (particle == firstParticle && all_tables_are_built) ) {
357   std::size_t n = mod_vector.size();           << 258     all_tables_are_built = true;
358   for (std::size_t i=0; i<n; ++i) {            << 259     
359     if(mod_vector[i] == p) {                   << 260     for (G4int i=0; i<n_loss; i++) {
360       mod_vector[i] = nullptr;                 << 261       G4VEnergyLossProcess* el = loss_vector[i];
361       break;                                   << 
362     }                                          << 
363   }                                            << 
364 }                                              << 
365                                                   262 
366 //....oooOO0OOooo........oooOO0OOooo........oo << 263       if(el) {
367                                                   264 
368 void G4LossTableManager::Register(G4VEmFluctua << 265   const G4ProcessManager* pm = el->GetProcessManager();
369 {                                              << 266         if (pm->GetProcessActivation(el)) tables_are_built[i] = false;
370   fmod_vector.push_back(p);                    << 267         else                              tables_are_built[i] = true;
371   if(verbose > 1) {                            << 
372     G4cout << "G4LossTableManager::Register G4 << 
373            << p->GetName() << "  " << fmod_vec << 
374   }                                            << 
375 }                                              << 
376                                                   268 
377 //....oooOO0OOooo........oooOO0OOooo........oo << 269   if (!tables_are_built[i]) all_tables_are_built = false;
378                                                   270 
379 void G4LossTableManager::DeRegister(G4VEmFluct << 271       } else {
380 {                                              << 272         tables_are_built[i] = true;
381   std::size_t n = fmod_vector.size();          << 273         part_vector[i] = 0;
382   for (std::size_t i=0; i<n; ++i) {            << 
383     if(fmod_vector[i] == p) { fmod_vector[i] = << 
384   }                                            << 
385 }                                              << 
386                                                << 
387 //....oooOO0OOooo........oooOO0OOooo........oo << 
388                                                   274 
389 void G4LossTableManager::RegisterExtraParticle << 275       }
390      const G4ParticleDefinition* part,         << 
391      G4VEnergyLossProcess* p)                  << 
392 {                                              << 
393   if (nullptr == p || nullptr == part) { retur << 
394   for (G4int i=0; i<n_loss; ++i) {             << 
395     if(loss_vector[i] == p) { return; }        << 
396   }                                            << 
397   if(verbose > 1) {                            << 
398     G4cout << "G4LossTableManager::RegisterExt << 
399            << part->GetParticleName() << "  G4 << 
400            << p->GetProcessName() << "  idx= " << 
401   }                                            << 
402   ++n_loss;                                    << 
403   loss_vector.push_back(p);                    << 
404   part_vector.push_back(part);                 << 
405   base_part_vector.push_back(p->BaseParticle() << 
406   dedx_vector.push_back(nullptr);              << 
407   range_vector.push_back(nullptr);             << 
408   inv_range_vector.push_back(nullptr);         << 
409   tables_are_built.push_back(false);           << 
410   all_tables_are_built = false;                << 
411 }                                              << 
412                                                   276 
413 //....oooOO0OOooo........oooOO0OOooo........oo << 277     }
414                                                   278 
415 G4VEnergyLossProcess*                          << 279     if (first_entry) {
416 G4LossTableManager::GetEnergyLossProcess(const << 280       first_entry = false;
417 {                                              << 281       firstParticle = particle;
418   if(aParticle != currentParticle) {           << 
419     currentParticle = aParticle;               << 
420     std::map<PD,G4VEnergyLossProcess*,std::les << 
421     if ((pos = loss_map.find(aParticle)) != lo << 
422       currentLoss = (*pos).second;             << 
423     } else {                                   << 
424       currentLoss = nullptr;                   << 
425       if(0.0 != aParticle->GetPDGCharge() &&   << 
426    (pos = loss_map.find(theGenericIon)) != los << 
427   currentLoss = (*pos).second;                 << 
428       }                                        << 
429     }                                             282     }
430   }                                               283   }
431   return currentLoss;                          << 
432 }                                              << 
433                                                   284 
434 //....oooOO0OOooo........oooOO0OOooo........oo << 285   SetParameters(p);
                                                   >> 286   for (G4int j=0; j<n_loss; j++) {
                                                   >> 287     if (p == loss_vector[j]) {
435                                                   288 
436 void                                           << 289       if (!part_vector[j]) {
437 G4LossTableManager::PreparePhysicsTable(const  << 
438                                         G4VEne << 
439 {                                              << 
440   if (1 < verbose) {                           << 
441     G4cout << "G4LossTableManager::PreparePhys << 
442            << particle->GetParticleName()      << 
443            << " and " << p->GetProcessName() < << 
444            << "   loss_vector " << loss_vector << 
445      << " run=" << run << " master=" << isMast << 
446      << G4endl;                                << 
447   }                                            << 
448                                                << 
449   // start initialisation for the first run    << 
450   if( -1 == run ) {                            << 
451     if (nullptr != emConfigurator) { emConfigu << 
452                                                << 
453     // initialise particles for given process  << 
454     for (G4int j=0; j<n_loss; ++j) {           << 
455       if (p == loss_vector[j] && nullptr == pa << 
456         part_vector[j] = particle;                290         part_vector[j] = particle;
457         if (particle->GetParticleName() == "Ge << 291         base_part_vector[j] = p->BaseParticle();
458           theGenericIon = particle;            << 292       }
459         }                                      << 293       if(maxEnergyForMuonsActive) {
                                                   >> 294         G4double dm = std::fabs(particle->GetPDGMass() - 105.7*MeV);
                                                   >> 295   if(dm < 5.*MeV) p->SetMaxKinEnergy(maxKinEnergyForMuons);
                                                   >> 296       }
                                                   >> 297 
                                                   >> 298       if(0 < verbose) {
                                                   >> 299         G4cout << "For " << p->GetProcessName()
                                                   >> 300                << " for " << part_vector[j]->GetParticleName()
                                                   >> 301                << " tables_are_built= " << tables_are_built[j]
                                                   >> 302                << " procFlag= " << loss_vector[j]->TablesAreBuilt()
                                                   >> 303                << " all_tables_are_built= "     << all_tables_are_built
                                                   >> 304                << G4endl;
460       }                                           305       }
461     }                                             306     }
462   }                                               307   }
463   ResetParameters();                           << 
464 }                                                 308 }
465                                                   309 
466 //....oooOO0OOooo........oooOO0OOooo........oo    310 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
467                                                   311 
468 void                                           << 312 G4EnergyLossMessenger* G4LossTableManager::GetMessenger()
469 G4LossTableManager::PreparePhysicsTable(const  << 
470                                         G4VEmP << 
471 {                                                 313 {
472   if (1 < verbose) {                           << 314   return theMessenger;
473     G4cout << "G4LossTableManager::PreparePhys << 
474            << particle->GetParticleName()      << 
475            << " and " << p->GetProcessName()   << 
476      << " run=" << run << " master=" << isMast << 
477      << G4endl;                                << 
478   }                                            << 
479                                                << 
480   // start initialisation for the first run    << 
481   if( -1 == run ) {                            << 
482     if (nullptr != emConfigurator) { emConfigu << 
483   }                                            << 
484                                                << 
485   ResetParameters();                           << 
486 }                                                 315 }
487                                                   316 
488 //....oooOO0OOooo........oooOO0OOooo........oo    317 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
489                                                   318 
490 void                                           << 319 void G4LossTableManager::ParticleHaveNoLoss(const G4ParticleDefinition* aParticle)
491 G4LossTableManager::PreparePhysicsTable(const  << 
492                                         G4VMul << 
493 {                                                 320 {
494   if (1 < verbose) {                           << 321   G4String s = "G4LossTableManager:: dE/dx table not found for "
495     G4cout << "G4LossTableManager::PreparePhys << 322              + aParticle->GetParticleName() + "!";
496            << particle->GetParticleName()      << 323   G4Exception(s);
497            << " and " << p->GetProcessName()   << 324   exit(1);
498      << " run=" << run << " master=" << isMast << 
499      << G4endl;                                << 
500   }                                            << 
501                                                << 
502   // start initialisation for the first run    << 
503   if ( -1 == run ) {                           << 
504     if (nullptr != emConfigurator) { emConfigu << 
505   }                                            << 
506                                                << 
507   ResetParameters();                           << 
508 }                                                 325 }
509                                                   326 
510 //....oooOO0OOooo........oooOO0OOooo........oo << 327 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
511                                                   328 
512 void                                           << 329 G4bool G4LossTableManager::BuildPreciseRange() const
513 G4LossTableManager::BuildPhysicsTable(const G4 << 
514 {                                                 330 {
515   if(-1 == run && startInitialisation) {       << 331   return buildPreciseRange;
516     if (nullptr != emConfigurator) { emConfigu << 
517   }                                            << 
518   if (startInitialisation) { resetParam = true << 
519 }                                                 332 }
520                                                   333 
521 //....oooOO0OOooo........oooOO0OOooo........oo << 334 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
522                                                   335 
523 void G4LossTableManager::LocalPhysicsTables(   << 336 void G4LossTableManager::BuildPhysicsTable(const G4ParticleDefinition* aParticle,
524      const G4ParticleDefinition* aParticle,    << 337                                                  G4VEnergyLossProcess* p)
525      G4VEnergyLossProcess* p)                  << 
526 {                                                 338 {
527   if (1 < verbose) {                           << 339 
528     G4cout << "### G4LossTableManager::LocalPh << 340   if(0 < verbose) {
                                                   >> 341     G4cout << "### G4LossTableManager::BuildDEDXTable() is requested for "
529            << aParticle->GetParticleName()        342            << aParticle->GetParticleName()
530            << " and process " << p->GetProcess << 343      << " and process " << p->GetProcessName()
531            << G4endl;                             344            << G4endl;
532   }                                               345   }
                                                   >> 346   if (all_tables_are_built) return;
                                                   >> 347   all_tables_are_built = true;
533                                                   348 
534   if(-1 == run && startInitialisation) {       << 349   for(G4int i=0; i<n_loss; i++) {
535     if (nullptr != emConfigurator) { emConfigu << 
536     firstParticle = aParticle;                 << 
537   }                                            << 
538                                                   350 
539   if (startInitialisation) {                   << 351     if(!tables_are_built[i] && !base_part_vector[i]) {
540     ++run;                                     << 352 
541     if (1 < verbose) {                         << 353       const G4ParticleDefinition* curr_part = part_vector[i];
542       G4cout << "===== G4LossTableManager::Loc << 354       G4VEnergyLossProcess* curr_proc = BuildTables(curr_part);
543              << run << " =====" << G4endl;     << 355       CopyTables(curr_part, curr_proc);
544     }                                          << 
545     currentParticle = nullptr;                 << 
546     startInitialisation = false;               << 
547     resetParam = true;                         << 
548     for (G4int i=0; i<n_loss; ++i) {           << 
549       if (nullptr != loss_vector[i]) {         << 
550         tables_are_built[i] = false;           << 
551       } else {                                 << 
552         tables_are_built[i] = true;            << 
553         part_vector[i] = nullptr;              << 
554       }                                        << 
555     }                                             356     }
556   }                                               357   }
557                                                   358 
558   all_tables_are_built= true;                  << 359   for (G4int ii=0; ii<n_loss; ii++) {
559   for (G4int i=0; i<n_loss; ++i) {             << 360     if ( !tables_are_built[ii] ) {
560     if(p == loss_vector[i]) {                  << 
561       tables_are_built[i] = true;              << 
562       isActive[i] = true;                      << 
563       part_vector[i] = p->Particle();          << 
564       base_part_vector[i] = p->BaseParticle(); << 
565       dedx_vector[i] = p->DEDXTable();         << 
566       range_vector[i] = p->RangeTableForLoss() << 
567       inv_range_vector[i] = p->InverseRangeTab << 
568       if(0 == run && p->IsIonisationProcess()) << 
569         loss_map[part_vector[i]] = p;          << 
570       }                                        << 
571                                                << 
572       if(1 < verbose) {                        << 
573         G4cout << i <<".   "<< p->GetProcessNa << 
574         if(part_vector[i]) {                   << 
575           G4cout << "  for "  << part_vector[i << 
576         }                                      << 
577         G4cout << "  active= " << isActive[i]  << 
578                << "  table= " << tables_are_bu << 
579                << "  isIonisation= " << p->IsI << 
580                << G4endl;                      << 
581       }                                        << 
582       break;                                   << 
583     } else if(!tables_are_built[i]) {          << 
584       all_tables_are_built = false;               361       all_tables_are_built = false;
                                                   >> 362       break;
585     }                                             363     }
586   }                                               364   }
587                                                   365 
588   if(1 < verbose) {                            << 366   if(0 < verbose) {
589     G4cout << "### G4LossTableManager::LocalPh << 367     G4cout << "### G4LossTableManager::BuildDEDXTable end: "
                                                   >> 368            << "all_tables_are_built= " << all_tables_are_built
590            << G4endl;                             369            << G4endl;
591   }                                            << 
592   if(all_tables_are_built) {                   << 
593     if(1 < verbose) {                          << 
594       G4cout << "%%%%% All dEdx and Range tabl << 
595              << run << " %%%%%" << G4endl;     << 
596     }                                          << 
597   }                                            << 
598 }                                              << 
599                                                << 
600 //....oooOO0OOooo........oooOO0OOooo........oo << 
601                                                   370 
602 void G4LossTableManager::BuildPhysicsTable(    << 371     if(all_tables_are_built)
603      const G4ParticleDefinition* aParticle,    << 372       G4cout << "### All dEdx and Range tables are built #####" << G4endl;
604      G4VEnergyLossProcess* p)                  << 
605 {                                              << 
606   if(1 < verbose) {                            << 
607     G4cout << "### G4LossTableManager::BuildPh << 
608            << aParticle->GetParticleName()     << 
609            << " and process " << p->GetProcess << 
610   }                                            << 
611   // clear configurator                        << 
612   if(-1 == run && startInitialisation) {       << 
613     if( nullptr != emConfigurator) { emConfigu << 
614     firstParticle = aParticle;                 << 
615   }                                            << 
616   if(startInitialisation) {                    << 
617     ++run;                                     << 
618     resetParam = true;                         << 
619     startInitialisation = false;               << 
620     if(1 < verbose) {                          << 
621       G4cout << "===== G4LossTableManager::Bui << 
622              << run << " ===== " << atomDeexci << 
623     }                                          << 
624     currentParticle = nullptr;                 << 
625     all_tables_are_built = false;              << 
626                                                << 
627     for (G4int i=0; i<n_loss; ++i) {           << 
628       G4VEnergyLossProcess* el = loss_vector[i << 
629                                                << 
630       if(nullptr != el) {                      << 
631         isActive[i] = true;                    << 
632         part_vector[i] = el->Particle();       << 
633         base_part_vector[i] = el->BaseParticle << 
634         tables_are_built[i] = false;           << 
635         if(1 < verbose) {                      << 
636           G4cout << i <<".   "<< el->GetProces << 
637           if(el->Particle()) {                 << 
638             G4cout << "  for "  << el->Particl << 
639           }                                    << 
640           G4cout << "  active= " << isActive[i << 
641                  << "  table= " << tables_are_ << 
642                  << "  isIonisation= " << el-> << 
643           if(base_part_vector[i]) {            << 
644             G4cout << "  base particle "       << 
645                    << base_part_vector[i]->Get << 
646           }                                    << 
647           G4cout << G4endl;                    << 
648         }                                      << 
649       } else {                                 << 
650         tables_are_built[i] = true;            << 
651         part_vector[i] = nullptr;              << 
652         isActive[i] = false;                   << 
653       }                                        << 
654     }                                          << 
655   }                                            << 
656                                                << 
657   if (all_tables_are_built) {                  << 
658     theParameters->SetIsPrintedFlag(true);     << 
659     return;                                    << 
660   }                                            << 
661                                                << 
662   // Build tables for given particle           << 
663   all_tables_are_built = true;                 << 
664                                                << 
665   for(G4int i=0; i<n_loss; ++i) {              << 
666     if(p == loss_vector[i] && !tables_are_buil << 
667       const G4ParticleDefinition* curr_part =  << 
668       if(1 < verbose) {                        << 
669         G4cout << "### Build Table for " << p- << 
670                << " and " << curr_part->GetPar << 
671                << "  " << tables_are_built[i]  << 
672                << G4endl;                      << 
673       }                                        << 
674       G4VEnergyLossProcess* curr_proc = BuildT << 
675       if(curr_proc) {                          << 
676         CopyTables(curr_part, curr_proc);      << 
677         if(p == curr_proc && 0 == run && p->Is << 
678           loss_map[aParticle] = p;             << 
679           //G4cout << "G4LossTableManager::Bui << 
680           //     << aParticle->GetParticleName << 
681           //         << " added to map " << p  << 
682         }                                      << 
683       }                                        << 
684     }                                          << 
685     if ( !tables_are_built[i] ) { all_tables_a << 
686   }                                            << 
687   if(1 < verbose) {                            << 
688     G4cout << "### G4LossTableManager::BuildPh << 
689            << "all_tables_are_built= " << all_ << 
690            << aParticle->GetParticleName() <<  << 
691   }                                               373   }
692 }                                                 374 }
693                                                   375 
694 //....oooOO0OOooo........oooOO0OOooo........oo << 376 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
695                                                   377 
696 void G4LossTableManager::CopyTables(const G4Pa    378 void G4LossTableManager::CopyTables(const G4ParticleDefinition* part,
697                                     G4VEnergyL << 379                                           G4VEnergyLossProcess* base_proc)
698 {                                                 380 {
699   for (G4int j=0; j<n_loss; ++j) {             << 381   for (G4int j=0; j<n_loss; j++) {
700                                                   382 
701     G4VEnergyLossProcess* proc = loss_vector[j    383     G4VEnergyLossProcess* proc = loss_vector[j];
                                                   >> 384     if(proc == base_proc || proc->Particle() == part) tables_are_built[j] = true;
702                                                   385 
703     if (!tables_are_built[j] && part == base_p    386     if (!tables_are_built[j] && part == base_part_vector[j]) {
704       tables_are_built[j] = true;                 387       tables_are_built[j] = true;
705       // for base particle approach only ionis << 388       proc->SetDEDXTable(base_proc->DEDXTable());
706       proc->SetDEDXTable(base_proc->Ionisation << 389       proc->SetDEDXunRestrictedTable(base_proc->DEDXunRestrictedTable());
707       proc->SetDEDXTable(base_proc->DEDXunRest << 390       proc->SetPreciseRangeTable(base_proc->PreciseRangeTable());
708       proc->SetCSDARangeTable(base_proc->CSDAR << 
709       proc->SetRangeTableForLoss(base_proc->Ra    391       proc->SetRangeTableForLoss(base_proc->RangeTableForLoss());
710       proc->SetInverseRangeTable(base_proc->In    392       proc->SetInverseRangeTable(base_proc->InverseRangeTable());
711       proc->SetLambdaTable(base_proc->LambdaTa    393       proc->SetLambdaTable(base_proc->LambdaTable());
712       if(proc->IsIonisationProcess()) {        << 394       proc->SetSubLambdaTable(base_proc->SubLambdaTable());
713         range_vector[j] = base_proc->RangeTabl << 395       loss_map[part_vector[j]] = proc;
714         inv_range_vector[j] = base_proc->Inver << 396       if (0 < verbose) {
715         loss_map[part_vector[j]] = proc;       << 397          G4cout << "For " << proc->GetProcessName()
716         //G4cout << "G4LossTableManager::CopyT << 
717         //       << part_vector[j]->GetParticl << 
718         //       << " added to map " << proc < << 
719       }                                        << 
720       if (1 < verbose) {                       << 
721          G4cout << "   CopyTables for " << pro << 
722                 << " for " << part_vector[j]->    398                 << " for " << part_vector[j]->GetParticleName()
723                 << " base_part= " << part->Get    399                 << " base_part= " << part->GetParticleName()
724                 << " tables are assigned"      << 400                 << " tables are assigned "
725                 << G4endl;                        401                 << G4endl;
726       }                                           402       }
727     }                                             403     }
                                                   >> 404 
                                                   >> 405     if (theElectron == part && theElectron == proc->SecondaryParticle() )
                                                   >> 406       proc->SetSecondaryRangeTable(base_proc->RangeTableForLoss());
728   }                                               407   }
729 }                                                 408 }
730                                                   409 
731 //....oooOO0OOooo........oooOO0OOooo........oo << 410 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
732                                                   411 
733 G4VEnergyLossProcess* G4LossTableManager::Buil << 412 G4VEnergyLossProcess* G4LossTableManager::BuildTables(const G4ParticleDefinition* aParticle)
734                       const G4ParticleDefiniti << 
735 {                                                 413 {
736   if(1 < verbose) {                            << 414   if(0 < verbose) {
737     G4cout << "   G4LossTableManager::BuildTab << 415     G4cout << "G4LossTableManager::BuildTables() for "
738            << aParticle->GetParticleName() <<     416            << aParticle->GetParticleName() << G4endl;
739   }                                               417   }
740                                                   418 
741   std::vector<G4PhysicsTable*> t_list;         << 419   std::vector<G4PhysicsTable*> list;
                                                   >> 420   list.clear();
742   std::vector<G4VEnergyLossProcess*> loss_list    421   std::vector<G4VEnergyLossProcess*> loss_list;
743   std::vector<G4bool> build_flags;             << 422   loss_list.clear();
744   G4VEnergyLossProcess* em = nullptr;          << 423   G4VEnergyLossProcess* em = 0;
745   G4VEnergyLossProcess* p = nullptr;           << 
746   G4int iem = 0;                                  424   G4int iem = 0;
747   G4PhysicsTable* dedx = nullptr;              << 
748   G4int i;                                     << 
749                                                   425 
750   G4ProcessVector* pvec =                      << 426   for (G4int i=0; i<n_loss; i++) {
751     aParticle->GetProcessManager()->GetProcess << 427     if (aParticle == part_vector[i] && !tables_are_built[i] && loss_vector[i]) {
752   G4int nvec = (G4int)pvec->size();            << 428       if (loss_vector[i]->IsIonisationProcess() || !em) {
753                                                << 429         em = loss_vector[i];
754   for (i=0; i<n_loss; ++i) {                   << 430         iem= i;
755     p = loss_vector[i];                        << 
756     if (nullptr != p) {                        << 
757       G4bool yes = (aParticle == part_vector[i << 
758                                                << 
759       // possible case of process sharing betw << 
760       if(!yes) {                               << 
761         auto ptr = static_cast<G4VProcess*>(p) << 
762         for(G4int j=0; j<nvec; ++j) {          << 
763           //G4cout << "j= " << j << " " << (*p << 
764           if(ptr == (*pvec)[j]) {              << 
765             yes = true;                        << 
766             break;                             << 
767           }                                    << 
768         }                                      << 
769       }                                        << 
770       // process belong to this particle       << 
771       if(yes && isActive[i]) {                 << 
772         if (p->IsIonisationProcess() || !em) { << 
773           em = p;                              << 
774           iem= i;                              << 
775         }                                      << 
776         // tables may be shared between partic << 
777         G4bool val = false;                    << 
778         if (!tables_are_built[i]) {            << 
779           val = true;                          << 
780           dedx = p->BuildDEDXTable(fRestricted << 
781           //G4cout << "===Build DEDX table for << 
782           // << " idx= " << i << " dedx:" << d << 
783           p->SetDEDXTable(dedx,fRestricted);   << 
784           tables_are_built[i] = true;          << 
785         } else {                               << 
786           dedx = p->DEDXTable();               << 
787         }                                      << 
788         t_list.push_back(dedx);                << 
789         loss_list.push_back(p);                << 
790         build_flags.push_back(val);            << 
791       }                                           431       }
                                                   >> 432       list.push_back(loss_vector[i]->BuildDEDXTable());
                                                   >> 433       loss_list.push_back(loss_vector[i]);
                                                   >> 434       tables_are_built[i] = true;
792     }                                             435     }
793   }                                               436   }
794                                                   437 
795   G4int n_dedx = (G4int)t_list.size();         << 438   G4int n_dedx = list.size();
796   if (0 == n_dedx || !em) {                    << 439   if (!n_dedx) return 0;
797     G4cout << "G4LossTableManager WARNING: no  << 
798            << aParticle->GetParticleName() <<  << 
799     return nullptr;                            << 
800   }                                            << 
801   G4int nSubRegions = em->NumberOfSubCutoffReg << 
802                                                   440 
803   if (1 < verbose) {                              441   if (1 < verbose) {
804     G4cout << "     Start to build the sum of  << 442     G4cout << "G4LossTableManager::BuildTables() start to build range tables"
805            << " iem= " << iem << " em= " << em << 443            << " and the sum of " << n_dedx << " processes"
806            << " buildCSDARange= " << theParame << 444            << " iem= " << iem << " em= " << em
807            << " nSubRegions= " << nSubRegions; << 445      << G4endl;
808     if(subcutProducer) {                       << 
809       G4cout << " SubCutProducer " << subcutPr << 
810     }                                          << 
811     G4cout << G4endl;                          << 
812   }                                               446   }
813   // do not build tables if producer class is  << 
814   if(subcutProducer) { nSubRegions = 0; }      << 
815                                                << 
816   dedx = em->DEDXTable();                      << 
817   em->SetDEDXTable(dedx, fIsIonisation);       << 
818                                                   447 
819   if (1 < n_dedx) {                            << 448   G4PhysicsTable* dedx = em->DEDXTable();
820     dedx = nullptr;                            << 449   if (1 < n_dedx) tableBuilder->BuildDEDXTable(dedx, list);
821     dedx = G4PhysicsTableHelper::PreparePhysic << 
822     tableBuilder->BuildDEDXTable(dedx, t_list) << 
823     em->SetDEDXTable(dedx, fRestricted);       << 
824   }                                            << 
825                                                   450 
826   dedx_vector[iem] = dedx;                        451   dedx_vector[iem] = dedx;
827                                                   452 
828   G4PhysicsTable* range = em->RangeTableForLos    453   G4PhysicsTable* range = em->RangeTableForLoss();
829   if(!range) range  = G4PhysicsTableHelper::Pr    454   if(!range) range  = G4PhysicsTableHelper::PreparePhysicsTable(range);
830   range_vector[iem] = range;                      455   range_vector[iem] = range;
831                                                   456 
832   G4PhysicsTable* invrange = em->InverseRangeT    457   G4PhysicsTable* invrange = em->InverseRangeTable();
833   if(!invrange) invrange = G4PhysicsTableHelpe    458   if(!invrange) invrange = G4PhysicsTableHelper::PreparePhysicsTable(invrange);
834   inv_range_vector[iem]  = invrange;              459   inv_range_vector[iem]  = invrange;
835                                                   460 
836   tableBuilder->BuildRangeTable(dedx, range);     461   tableBuilder->BuildRangeTable(dedx, range);
837   tableBuilder->BuildInverseRangeTable(range,     462   tableBuilder->BuildInverseRangeTable(range, invrange);
838                                                   463 
839   em->SetRangeTableForLoss(range);             << 464   if(buildPreciseRange) {
840   em->SetInverseRangeTable(invrange);          << 465     std::vector<G4PhysicsTable*> newlist;
841                                                << 466     newlist.clear();
842   std::vector<G4PhysicsTable*> listCSDA;       << 467     G4PhysicsTable* dedxForRange = em->DEDXunRestrictedTable();
843                                                << 468     for (G4int i=0; i<n_dedx; i++) {
844   for (i=0; i<n_dedx; ++i) {                   << 469       newlist.push_back(loss_list[i]->BuildDEDXTableForPreciseRange());
845     p = loss_list[i];                          << 470     }
846     if(build_flags[i]) {                       << 471     if (1 < n_dedx) tableBuilder->BuildDEDXTable(dedxForRange, newlist);
847       p->SetLambdaTable(p->BuildLambdaTable(fR << 472 
848     }                                          << 473     em->SetDEDXunRestrictedTable(dedxForRange);
849     if(theParameters->BuildCSDARange()) {      << 474     range = em->PreciseRangeTable();
850       dedx = p->BuildDEDXTable(fTotal);        << 475     if(!range) range  = G4PhysicsTableHelper::PreparePhysicsTable(range);
851       p->SetDEDXTable(dedx,fTotal);            << 476     tableBuilder->BuildRangeTable(dedxForRange, range);
852       listCSDA.push_back(dedx);                << 477     em->SetPreciseRangeTable(range);
853     }                                          << 478   }
854   }                                            << 479 
855                                                << 480   loss_map[aParticle] = em;
856   if(theParameters->BuildCSDARange()) {        << 481   for (G4int j=0; j<n_dedx; j++) {
857     G4PhysicsTable* dedxCSDA = em->DEDXunRestr << 482     G4PhysicsTable* lambdaTable = loss_list[j]->BuildLambdaTable();
858     if (1 < n_dedx) {                          << 483     loss_list[j]->SetLambdaTable(lambdaTable);
859       dedxCSDA = G4PhysicsTableHelper::Prepare << 484     if (0 < loss_list[j]->NumberOfSubCutoffRegions()) {
860       tableBuilder->BuildDEDXTable(dedxCSDA, l << 485       lambdaTable = loss_list[j]->BuildLambdaSubTable();
861       em->SetDEDXTable(dedxCSDA,fTotal);       << 486       loss_list[j]->SetSubLambdaTable(lambdaTable);
862     }                                             487     }
863     G4PhysicsTable* rCSDA = em->CSDARangeTable << 
864     if(!rCSDA) { rCSDA = G4PhysicsTableHelper: << 
865     tableBuilder->BuildRangeTable(dedxCSDA, rC << 
866     em->SetCSDARangeTable(rCSDA);              << 
867   }                                               488   }
868                                                << 489   if (0 < verbose) {
869   if (1 < verbose) {                           << 
870     G4cout << "G4LossTableManager::BuildTables    490     G4cout << "G4LossTableManager::BuildTables: Tables are built for "
871            << aParticle->GetParticleName()        491            << aParticle->GetParticleName()
872            << "; ionisation process: " << em-> << 492      << "; ionisation process: " << em->GetProcessName()
873            << "  " << em                       << 
874            << G4endl;                             493            << G4endl;
875   }                                               494   }
876   return em;                                      495   return em;
877 }                                                 496 }
878                                                   497 
879 //....oooOO0OOooo........oooOO0OOooo........oo << 498 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
880                                                   499 
881 void G4LossTableManager::ParticleHaveNoLoss(   << 500 void G4LossTableManager::SetLossFluctuations(G4bool val)
882      const G4ParticleDefinition* aParticle)    << 
883 {                                                 501 {
884   G4ExceptionDescription ed;                   << 502   lossFluctuationFlag = val;
885   ed << "Energy loss process not found for " < << 503   for(G4int i=0; i<n_loss; i++) {
886      << " !";                                  << 504     if(loss_vector[i]) loss_vector[i]->SetLossFluctuations(val);
887   G4Exception("G4LossTableManager::ParticleHav << 505   }
888               FatalException, ed);             << 
889 }                                                 506 }
890                                                   507 
891 //....oooOO0OOooo........oooOO0OOooo........oo << 508 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
892                                                   509 
893 void G4LossTableManager::SetVerbose(G4int val) << 510 void G4LossTableManager::SetSubCutoff(G4bool val)
894 {                                                 511 {
895   verbose = val;                               << 512   subCutoffFlag = val;
                                                   >> 513   for(G4int i=0; i<n_loss; i++) {
                                                   >> 514     if(loss_vector[i]) loss_vector[i]->SetSubCutoff(val);
                                                   >> 515   }
896 }                                                 516 }
897                                                   517 
898 //....oooOO0OOooo........oooOO0OOooo........oo << 518 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
899                                                   519 
900 const std::vector<G4VEnergyLossProcess*>&      << 520 void G4LossTableManager::SetIntegral(G4bool val)
901 G4LossTableManager::GetEnergyLossProcessVector << 
902 {                                                 521 {
903   return loss_vector;                          << 522   integral = val;
                                                   >> 523   integralActive = true;
                                                   >> 524   for(G4int i=0; i<n_loss; i++) {
                                                   >> 525     if(loss_vector[i]) loss_vector[i]->SetIntegral(val);
                                                   >> 526   }
                                                   >> 527   size_t emp = emp_vector.size();
                                                   >> 528   for (size_t k=0; k<emp; k++) {
                                                   >> 529     if(emp_vector[k]) emp_vector[k]->SetIntegral(val);
                                                   >> 530   }
904 }                                                 531 }
905                                                   532 
906 //....oooOO0OOooo........oooOO0OOooo........oo << 533 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
907                                                   534 
908 const std::vector<G4VEmProcess*>& G4LossTableM << 535 void G4LossTableManager::SetMinSubRange(G4double val)
909 {                                                 536 {
910   return emp_vector;                           << 537   minSubRange = val;
                                                   >> 538   for(G4int i=0; i<n_loss; i++) {
                                                   >> 539     if(loss_vector[i]) loss_vector[i]->SetMinSubRange(val);
                                                   >> 540   }
911 }                                                 541 }
912                                                   542 
913 //....oooOO0OOooo........oooOO0OOooo........oo << 543 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
                                                   >> 544 
                                                   >> 545 void G4LossTableManager::SetRandomStep(G4bool)
                                                   >> 546 {}
914                                                   547 
915 const std::vector<G4VMultipleScattering*>&     << 548 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
916 G4LossTableManager::GetMultipleScatteringVecto << 549 
                                                   >> 550 void G4LossTableManager::SetMinEnergy(G4double val)
917 {                                                 551 {
918   return msc_vector;                           << 552   minEnergyActive = true;
                                                   >> 553   minKinEnergy = val;
                                                   >> 554   for(G4int i=0; i<n_loss; i++) {
                                                   >> 555     if(loss_vector[i]) loss_vector[i]->SetMinKinEnergy(val);
                                                   >> 556   }
                                                   >> 557   size_t msc = msc_vector.size();
                                                   >> 558   for (size_t j=0; j<msc; j++) {
                                                   >> 559     if(msc_vector[j]) msc_vector[j]->SetMinKinEnergy(val);
                                                   >> 560   }
                                                   >> 561   size_t emp = emp_vector.size();
                                                   >> 562   for (size_t k=0; k<emp; k++) {
                                                   >> 563     if(emp_vector[k]) emp_vector[k]->SetMinKinEnergy(val);
                                                   >> 564   }
919 }                                                 565 }
920                                                   566 
921 //....oooOO0OOooo........oooOO0OOooo........oo    567 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
922                                                   568 
923 G4EmSaturation* G4LossTableManager::EmSaturati << 569 void G4LossTableManager::SetMaxEnergy(G4double val)
924 {                                                 570 {
925   return theParameters->GetEmSaturation();     << 571   maxEnergyActive = true;
                                                   >> 572   maxKinEnergy = val;
                                                   >> 573   for(G4int i=0; i<n_loss; i++) {
                                                   >> 574     if(loss_vector[i]) loss_vector[i]->SetMaxKinEnergy(val);
                                                   >> 575   }
                                                   >> 576   size_t msc = msc_vector.size();
                                                   >> 577   for (size_t j=0; j<msc; j++) {
                                                   >> 578     if(msc_vector[j]) msc_vector[j]->SetMaxKinEnergy(val);
                                                   >> 579   }
                                                   >> 580   size_t emp = emp_vector.size();
                                                   >> 581   for (size_t k=0; k<emp; k++) {
                                                   >> 582     if(emp_vector[k]) emp_vector[k]->SetMaxKinEnergy(val);
                                                   >> 583   }
926 }                                                 584 }
927                                                   585 
928 //....oooOO0OOooo........oooOO0OOooo........oo    586 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
929                                                   587 
930 G4EmConfigurator* G4LossTableManager::EmConfig << 588 void G4LossTableManager::SetMaxEnergyForPreciseRange(G4double val)
931 {                                                 589 {
932   if(!emConfigurator) {                        << 590   for(G4int i=0; i<n_loss; i++) {
933     emConfigurator = new G4EmConfigurator(verb << 591     if(loss_vector[i]) loss_vector[i]->SetMaxKinEnergyForPreciseRange(val);
934   }                                               592   }
935   return emConfigurator;                       << 
936 }                                                 593 }
937                                                   594 
938 //....oooOO0OOooo........oooOO0OOooo........oo    595 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
939                                                   596 
940 G4ElectronIonPair* G4LossTableManager::Electro << 597 void G4LossTableManager::SetMaxEnergyForMuons(G4double val)
                                                   >> 598 {
                                                   >> 599   maxEnergyForMuonsActive = true;
                                                   >> 600   maxKinEnergyForMuons = val;
                                                   >> 601 }
                                                   >> 602 
                                                   >> 603 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
                                                   >> 604 
                                                   >> 605 void G4LossTableManager::SetDEDXBinning(G4int val)
941 {                                                 606 {
942   if(!emElectronIonPair) {                     << 607   for(G4int i=0; i<n_loss; i++) {
943     emElectronIonPair = new G4ElectronIonPair( << 608     if(loss_vector[i]) loss_vector[i]->SetDEDXBinning(val);
944   }                                               609   }
945   return emElectronIonPair;                    << 
946 }                                                 610 }
947                                                   611 
                                                   >> 612 
948 //....oooOO0OOooo........oooOO0OOooo........oo    613 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
949                                                   614 
950 void G4LossTableManager::SetNIELCalculator(G4N << 615 void G4LossTableManager::SetDEDXBinningForPreciseRange(G4int val)
951 {                                                 616 {
952   if(nullptr != ptr && ptr != nielCalculator)  << 617   for(G4int i=0; i<n_loss; i++) {
953     delete nielCalculator;                     << 618     if(loss_vector[i]) loss_vector[i]->SetDEDXBinningForPreciseRange(val);
954     nielCalculator = ptr;                      << 
955   }                                               619   }
956 }                                                 620 }
957                                                   621 
958 //....oooOO0OOooo........oooOO0OOooo........oo    622 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
959                                                   623 
960 G4NIELCalculator* G4LossTableManager::NIELCalc << 624 void G4LossTableManager::SetLambdaBinning(G4int val)
961 {                                                 625 {
962   if(!nielCalculator) {                        << 626   for(G4int i=0; i<n_loss; i++) {
963     nielCalculator = new G4NIELCalculator(null << 627     if(loss_vector[i]) loss_vector[i]->SetLambdaBinning(val);
                                                   >> 628   }
                                                   >> 629   size_t msc = msc_vector.size();
                                                   >> 630   for (size_t j=0; j<msc; j++) {
                                                   >> 631     if(msc_vector[j]) msc_vector[j]->SetBinning(val);
                                                   >> 632   }
                                                   >> 633   size_t emp = emp_vector.size();
                                                   >> 634   for (size_t k=0; k<emp; k++) {
                                                   >> 635     if(emp_vector[k]) emp_vector[k]->SetLambdaBinning(val);
964   }                                               636   }
965   return nielCalculator;                       << 
966 }                                                 637 }
967                                                   638 
968 //....oooOO0OOooo........oooOO0OOooo........oo << 639 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
969                                                << 640 
970 void G4LossTableManager::SetAtomDeexcitation(G << 641 void G4LossTableManager::SetVerbose(G4int val)
971 {                                                 642 {
972   if(atomDeexcitation != p) {                  << 643   verbose = val;
973     delete atomDeexcitation;                   << 644   for(G4int i=0; i<n_loss; i++) {
974     atomDeexcitation = p;                      << 645     if(loss_vector[i]) loss_vector[i]->SetVerboseLevel(val);
                                                   >> 646   }
                                                   >> 647   size_t msc = msc_vector.size();
                                                   >> 648   for (size_t j=0; j<msc; j++) {
                                                   >> 649     if(msc_vector[j]) msc_vector[j]->SetVerboseLevel(val);
                                                   >> 650   }
                                                   >> 651   size_t emp = emp_vector.size();
                                                   >> 652   for (size_t k=0; k<emp; k++) {
                                                   >> 653     if(emp_vector[k]) emp_vector[k]->SetVerboseLevel(val);
975   }                                               654   }
976 }                                                 655 }
977                                                   656 
978 //....oooOO0OOooo........oooOO0OOooo........oo << 657 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
979                                                   658 
980 void G4LossTableManager::SetSubCutProducer(G4V << 659 void G4LossTableManager::SetStepLimits(G4double v1, G4double v2)
981 {                                                 660 {
982   if(subcutProducer != p) {                    << 661   stepFunctionActive = true;
983     delete subcutProducer;                     << 662   maxRangeVariation = v1;
984     subcutProducer = p;                        << 663   maxFinalStep = v2;
                                                   >> 664   for(G4int i=0; i<n_loss; i++) {
                                                   >> 665     if(loss_vector[i]) loss_vector[i]->SetStepFunction(v1, v2);
985   }                                               666   }
986 }                                                 667 }
987                                                   668 
988 //....oooOO0OOooo........oooOO0OOooo........oo << 669 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
989                                                   670 
990 void G4LossTableManager::PrintEWarning(G4Strin << 671 void G4LossTableManager::SetBuildPreciseRange(G4bool val)
991 {                                                 672 {
992   G4String ss = "G4LossTableManager::" + tit;  << 673   buildPreciseRange = val;
993   G4ExceptionDescription ed;                   << 
994   /*                                           << 
995   ed << "Parameter is out of range: " << val   << 
996      << " it will have no effect!\n" << " ## " << 
997      << " nbins= " << nbinsLambda              << 
998      << " nbinsPerDecade= " << nbinsPerDecade  << 
999      << " Emin(keV)= " << minKinEnergy/keV     << 
1000      << " Emax(GeV)= " << maxKinEnergy/GeV;   << 
1001   */                                          << 
1002   G4Exception(ss, "em0044", JustWarning, ed); << 
1003 }                                                674 }
1004                                                  675 
1005 //....oooOO0OOooo........oooOO0OOooo........o << 676 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
1006                                                  677 
1007 void G4LossTableManager::DumpHtml()           << 678 void G4LossTableManager::SetParameters(G4VEnergyLossProcess* p)
1008 {                                                679 {
1009   // Automatic generation of html documentati << 680   if(stepFunctionActive) p->SetStepFunction(maxRangeVariation, maxFinalStep);
1010   // List processes and models for the most i << 681   if(integralActive)     p->SetIntegral(integral);
1011   // particles in descending order of importa << 682   if(minEnergyActive)    p->SetMinKinEnergy(minKinEnergy);
1012   // NB. for model names with length > 18 cha << 683   if(maxEnergyActive)    p->SetMaxKinEnergy(maxKinEnergy);
1013   //  to be edited by hand. Or modify G4EmMod << 684   p->SetVerboseLevel(verbose);
1014                                               << 685 }
1015   char* dirName = std::getenv("G4PhysListDocD << 
1016   char* physList = std::getenv("G4PhysListNam << 
1017   if (dirName && physList) {                  << 
1018     G4String physListName = G4String(physList << 
1019     G4String pathName = G4String(dirName) + " << 
1020                                               << 
1021     std::ofstream outFile;                    << 
1022     outFile.open(pathName);                   << 
1023                                               << 
1024     outFile << physListName << G4endl;        << 
1025     outFile << std::string(physListName.lengt << 
1026                                               << 
1027     std::vector<G4ParticleDefinition*> partic << 
1028         G4Gamma::Gamma(),                     << 
1029         G4Electron::Electron(),               << 
1030         G4Positron::Positron(),               << 
1031         G4Proton::ProtonDefinition(),         << 
1032         G4MuonPlus::MuonPlusDefinition(),     << 
1033         G4MuonMinus::MuonMinusDefinition(),   << 
1034       };                                      << 
1035                                               << 
1036     std::vector<G4VEmProcess*> emproc_vector  << 
1037     std::vector<G4VEnergyLossProcess*> enloss << 
1038       GetEnergyLossProcessVector();           << 
1039     std::vector<G4VMultipleScattering*> mscat << 
1040       GetMultipleScatteringVector();          << 
1041                                               << 
1042     for (auto theParticle : particles) {      << 
1043       outFile << G4endl << "**" << theParticl << 
1044               << "**" << G4endl << G4endl <<  << 
1045                                               << 
1046       G4ProcessManager* pm = theParticle->Get << 
1047       G4ProcessVector*  pv = pm->GetProcessLi << 
1048       G4int plen = pm->GetProcessListLength() << 
1049                                               << 
1050       for (auto emproc : emproc_vector) {     << 
1051         for (G4int i = 0; i < plen; ++i) {    << 
1052           G4VProcess* proc = (*pv)[i];        << 
1053           if (proc == emproc) {               << 
1054             outFile << G4endl;                << 
1055             proc->ProcessDescription(outFile) << 
1056             break;                            << 
1057           }                                   << 
1058         }                                     << 
1059       }                                       << 
1060                                                  686 
1061       for (auto mscproc : mscat_vector) {     << 687 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
1062         for (G4int i = 0; i < plen; ++i) {    << 
1063           G4VProcess* proc = (*pv)[i];        << 
1064           if (proc == mscproc) {              << 
1065             outFile << G4endl;                << 
1066             proc->ProcessDescription(outFile) << 
1067             break;                            << 
1068           }                                   << 
1069         }                                     << 
1070       }                                       << 
1071                                                  688 
1072       for (auto enlossproc : enloss_vector) { << 689 const std::vector<G4VEnergyLossProcess*>& G4LossTableManager::GetEnergyLossProcessVector()
1073         for (G4int i = 0; i < plen; ++i) {    << 690 {
1074           G4VProcess* proc = (*pv)[i];        << 691   return loss_vector;
1075           if (proc == enlossproc) {           << 
1076             outFile << G4endl;                << 
1077             proc->ProcessDescription(outFile) << 
1078             break;                            << 
1079           }                                   << 
1080         }                                     << 
1081       }                                       << 
1082     }                                         << 
1083     outFile.close();                          << 
1084   }                                           << 
1085 }                                                692 }
1086                                                  693 
1087 //....oooOO0OOooo........oooOO0OOooo........o << 694 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
                                                   >> 695 
                                                   >> 696 const std::vector<G4VEmProcess*>& G4LossTableManager::GetEmProcessVector()
                                                   >> 697 {
                                                   >> 698   return emp_vector;
                                                   >> 699 }
1088                                                  700 
                                                   >> 701 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
                                                   >> 702 
                                                   >> 703 const std::vector<G4VMultipleScattering*>& G4LossTableManager::GetMultipleScatteringVector()
                                                   >> 704 {
                                                   >> 705   return msc_vector;
                                                   >> 706 }
                                                   >> 707 
                                                   >> 708 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo....
1089                                                  709