Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/run/src/G4VUserPhysicsList.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 /run/src/G4VUserPhysicsList.cc (Version 11.3.0) and /run/src/G4VUserPhysicsList.cc (Version 9.1.p2)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 // G4VUserPhysicsList implementation           << 
 27 //                                                 26 //
 28 // Original author: H.Kurashige (Kobe Universi <<  27 // $Id: G4VUserPhysicsList.cc,v 1.62.2.1 2008/04/17 09:10:27 kurasige Exp $
 29 // ------------------------------------------- <<  28 // GEANT4 tag $Name: geant4-09-01-patch-02 $
                                                   >>  29 //
                                                   >>  30 // 
                                                   >>  31 // ------------------------------------------------------------
                                                   >>  32 //  GEANT 4 class header file 
                                                   >>  33 //
                                                   >>  34 // ------------------------------------------------------------
                                                   >>  35 //  History
                                                   >>  36 //       first version                    09 Jan 1998 by H.Kurashige
                                                   >>  37 //       Added SetEnergyRange             18 Jun 1998 by H.Kurashige 
                                                   >>  38 //       Change for short lived particles 27 Jun 1998 by H.Kurashige
                                                   >>  39 //       G4BestUnit on output             12 nov 1998 by M.Maire
                                                   >>  40 //       Added RemoveProcessManager        9 Feb 1999 by H.Kurashige
                                                   >>  41 //       Fixed RemoveProcessManager       15 Apr 1999 by H.Kurashige
                                                   >>  42 //       Removed ConstructAllParticles()  15 Apr 1999 by H.Kurashige
                                                   >>  43 //       Modified for CUTS per REGION     10 Oct 2002 by H.Kurashige
                                                   >>  44 //       Check if particle IsShortLived   18 Jun 2003 by V.Ivanchenko
                                                   >>  45 //       Modify PreparePhysicsList        18 Jan 2006 by H.Kurashige
                                                   >>  46 // ------------------------------------------------------------
 30                                                    47 
                                                   >>  48 #include "globals.hh"
 31 #include "G4VUserPhysicsList.hh"                   49 #include "G4VUserPhysicsList.hh"
 32                                                << 
 33 #include "G4Material.hh"                       << 
 34 #include "G4MaterialCutsCouple.hh"             << 
 35 #include "G4ParticleDefinition.hh"                 50 #include "G4ParticleDefinition.hh"
 36 #include "G4ParticleTable.hh"                  << 
 37 #include "G4PhysicsListHelper.hh"              << 
 38 #include "G4ProcessManager.hh"                     51 #include "G4ProcessManager.hh"
 39 #include "G4ProductionCuts.hh"                 <<  52 #include "G4ParticleTable.hh"
 40 #include "G4ProductionCutsTable.hh"                53 #include "G4ProductionCutsTable.hh"
 41 #include "G4Region.hh"                         <<  54 #include "G4Material.hh"
 42 #include "G4RegionStore.hh"                    <<  55 #include "G4UserPhysicsListMessenger.hh"
 43 #include "G4SystemOfUnits.hh"                  << 
 44 #include "G4UImanager.hh"                          56 #include "G4UImanager.hh"
 45 #include "G4UnitsTable.hh"                         57 #include "G4UnitsTable.hh"
 46 #include "G4UserPhysicsListMessenger.hh"       <<  58 #include "G4RegionStore.hh"
 47 #include "G4VTrackingManager.hh"               <<  59 #include "G4Region.hh"
 48 #include "G4ios.hh"                            <<  60 #include "G4ProductionCutsTable.hh"
 49 #include "globals.hh"                          <<  61 #include "G4ProductionCuts.hh"
                                                   >>  62 #include "G4MaterialCutsCouple.hh"
 50                                                    63 
 51 #include <fstream>                             <<  64 #include "G4ios.hh"
 52 #include <iomanip>                                 65 #include <iomanip>
 53 #include <unordered_set>                       <<  66 #include <fstream>
 54                                                << 
 55 // This static member is thread local. For eac << 
 56 // size of G4VUPLData instances.               << 
 57 //                                             << 
 58 #define G4MT_theMessenger ((this->subInstanceM << 
 59 #define G4MT_thePLHelper ((this->subInstanceMa << 
 60 #define fIsPhysicsTableBuilt \                 << 
 61   ((this->subInstanceManager.offset[this->g4vu << 
 62 #define fDisplayThreshold \                    << 
 63   ((this->subInstanceManager.offset[this->g4vu << 
 64 #define theParticleIterator \                  << 
 65   ((this->subInstanceManager.offset[this->g4vu << 
 66                                                << 
 67 // This field helps to use the class G4VUPLMan << 
 68 //                                             << 
 69 G4VUPLManager G4VUserPhysicsList::subInstanceM << 
 70                                                << 
 71 // ------------------------------------------- << 
 72 void G4VUPLData::initialize()                  << 
 73 {                                              << 
 74   _theParticleIterator = G4ParticleTable::GetP << 
 75   _theMessenger = nullptr;                     << 
 76   _thePLHelper = G4PhysicsListHelper::GetPhysi << 
 77   _fIsPhysicsTableBuilt = false;               << 
 78   _fDisplayThreshold = 0;                      << 
 79 }                                              << 
 80                                                    67 
 81 // ------------------------------------------- <<  68 ////////////////////////////////////////////////////////
 82 G4VUserPhysicsList::G4VUserPhysicsList()           69 G4VUserPhysicsList::G4VUserPhysicsList()
                                                   >>  70                    :verboseLevel(1),
                                                   >>  71         fRetrievePhysicsTable(false),
                                                   >>  72         fStoredInAscii(true),
                                                   >>  73         fIsCheckedForRetrievePhysicsTable(false),
                                                   >>  74         fIsRestoredCutValues(false),
                                                   >>  75                     directoryPhysicsTable("."),
                                                   >>  76                     fDisplayThreshold(0),
                                                   >>  77                     useCoupledTransportation(false)
 83 {                                                  78 {
 84   g4vuplInstanceID = subInstanceManager.Create << 
 85   // default cut value  (1.0mm)                    79   // default cut value  (1.0mm)
 86   defaultCutValue = 1.0 * mm;                  <<  80   defaultCutValue = 1.0*mm;
 87                                                    81 
 88   // pointer to the particle table                 82   // pointer to the particle table
 89   theParticleTable = G4ParticleTable::GetParti     83   theParticleTable = G4ParticleTable::GetParticleTable();
                                                   >>  84   theParticleIterator = theParticleTable->GetIterator();
 90                                                    85 
 91   // pointer to the cuts table                     86   // pointer to the cuts table
 92   fCutsTable = G4ProductionCutsTable::GetProdu <<  87   fCutsTable =  G4ProductionCutsTable::GetProductionCutsTable();
 93                                                    88 
 94   // set energy range for SetCut calcuration       89   // set energy range for SetCut calcuration
 95   fCutsTable->SetEnergyRange(0.99 * keV, 100 * <<  90   fCutsTable->SetEnergyRange(0.99*keV, 100*TeV);
 96                                                    91 
 97   // UI Messenger                                  92   // UI Messenger
 98   G4MT_theMessenger = new G4UserPhysicsListMes <<  93   theMessenger = new G4UserPhysicsListMessenger(this);
 99                                                << 
100   // PhysicsListHelper                         << 
101   G4MT_thePLHelper->SetVerboseLevel(verboseLev << 
102                                                << 
103   fIsPhysicsTableBuilt = false;                << 
104   fDisplayThreshold = 0;                       << 
105 }                                                  94 }
106                                                    95 
107 // ------------------------------------------- <<  96 ////////////////////////////////////////////////////////
108 void G4VUserPhysicsList::InitializeWorker()    <<  97 G4VUserPhysicsList::~G4VUserPhysicsList()
109 {                                              << 
110   // Remember messengers are per-thread, so th << 
111   // worker and due to the presence of "this"  << 
112   // G4VUPLData::initialize()                  << 
113   G4MT_theMessenger = new G4UserPhysicsListMes << 
114 }                                              << 
115                                                << 
116 // ------------------------------------------- << 
117 void G4VUserPhysicsList::TerminateWorker()     << 
118 {                                                  98 {
                                                   >>  99   if (theMessenger != 0) {
                                                   >> 100     delete theMessenger;
                                                   >> 101     theMessenger = 0;
                                                   >> 102   }
119   RemoveProcessManager();                         103   RemoveProcessManager();
120   RemoveTrackingManager();                     << 
121   delete G4MT_theMessenger;                    << 
122   G4MT_theMessenger = nullptr;                 << 
123 }                                                 104 }
124                                                   105 
125 // ------------------------------------------- << 106 ////////////////////////////////////////////////////////
126 G4VUserPhysicsList::~G4VUserPhysicsList()      << 107 void G4VUserPhysicsList::SetVerboseLevel(G4int value)
127 {                                                 108 {
128   delete G4MT_theMessenger;                    << 109   verboseLevel = value;
129   G4MT_theMessenger = nullptr;                 << 110   // set verboseLevel for G4ProductionCutsTable same as one for G4VUserPhysicsList: 
130                                                << 111   fCutsTable->SetVerboseLevel(value);
131   RemoveProcessManager();                      << 
132   RemoveTrackingManager();                     << 
133                                                   112 
134   // invoke DeleteAllParticle                  << 113 #ifdef G4VERBOSE
135   theParticleTable->DeleteAllParticles();      << 114   if (verboseLevel >1){
                                                   >> 115     G4cout << "G4VUserPhysicsList::SetVerboseLevel  :";
                                                   >> 116     G4cout << " Verbose level is set to " << verboseLevel << G4endl;
                                                   >> 117   }
                                                   >> 118 #endif
136 }                                                 119 }
137                                                   120 
138 // ------------------------------------------- << 121 ////////////////////////////////////////////////////////
139 G4VUserPhysicsList::G4VUserPhysicsList(const G << 122 void G4VUserPhysicsList::AddProcessManager(G4ParticleDefinition* newParticle,
140   : verboseLevel(right.verboseLevel),          << 123              G4ProcessManager*     newManager)
141     defaultCutValue(right.defaultCutValue),    << 
142     isSetDefaultCutValue(right.isSetDefaultCut << 
143     fRetrievePhysicsTable(right.fRetrievePhysi << 
144     fStoredInAscii(right.fStoredInAscii),      << 
145     fIsCheckedForRetrievePhysicsTable(right.fI << 
146     fIsRestoredCutValues(right.fIsRestoredCutV << 
147     directoryPhysicsTable(right.directoryPhysi << 
148     fDisableCheckParticleList(right.fDisableCh << 
149 {                                                 124 {
150   g4vuplInstanceID = subInstanceManager.Create << 125   if (newParticle == 0) return;
151   // pointer to the particle table             << 126   if (newParticle->GetProcessManager() != 0) {
152   theParticleTable = G4ParticleTable::GetParti << 127 #ifdef G4VERBOSE
153   theParticleIterator = theParticleTable->GetI << 128     if (verboseLevel >1){
154   // pointer to the cuts table                 << 129       G4cout << "G4VUserPhysicsList::AddProcessManager: ";
155   fCutsTable = G4ProductionCutsTable::GetProdu << 130       G4cout  << newParticle->GetParticleName();
                                                   >> 131       G4cout << " already has ProcessManager " << G4endl;
                                                   >> 132     }
                                                   >> 133 #endif
                                                   >> 134     return;
                                                   >> 135   }
156                                                   136 
157   // UI Messenger                              << 137   // create new process manager if newManager  == 0
158   G4MT_theMessenger = new G4UserPhysicsListMes << 138   if (newManager  == 0){
                                                   >> 139     // Add ProcessManager
                                                   >> 140     if (newParticle->GetParticleType() == "nucleus") {
                                                   >> 141       // Create a copy of the process manager of "GenericIon" in case of "nucleus"
                                                   >> 142       G4ParticleDefinition* genericIon =
                                                   >> 143      (G4ParticleTable::GetParticleTable())->FindParticle("GenericIon");
159                                                   144 
160   // PhysicsListHelper                         << 145       if (genericIon != 0) {
161   G4MT_thePLHelper = G4PhysicsListHelper::GetP << 146   G4ProcessManager* ionMan = genericIon->GetProcessManager();
162   G4MT_thePLHelper->SetVerboseLevel(verboseLev << 147   if (ionMan != 0) {
                                                   >> 148     newManager = new G4ProcessManager(*ionMan);
                                                   >> 149   } else {
                                                   >> 150     // no process manager has been registered yet
                                                   >> 151     newManager = new G4ProcessManager(newParticle);
                                                   >> 152   }
                                                   >> 153       } else {
                                                   >> 154   // "GenericIon" does not exist
                                                   >> 155   newManager = new G4ProcessManager(newParticle);
                                                   >> 156       }
163                                                   157 
164   fIsPhysicsTableBuilt =                       << 158     } else {
165     right.GetSubInstanceManager().offset[right << 159       // create process manager for particles other than "nucleus"
166   fDisplayThreshold =                          << 160       newManager = new G4ProcessManager(newParticle);
167     right.GetSubInstanceManager().offset[right << 161     }
168 }                                              << 162   }
169                                                   163 
170 // ------------------------------------------- << 164   // set particle type
171 G4VUserPhysicsList& G4VUserPhysicsList::operat << 165   newManager->SetParticleType(newParticle);
172 {                                              << 166 
173   if (this != &right) {                        << 167   // add the process manager
174     verboseLevel = right.verboseLevel;         << 168   newParticle->SetProcessManager(newManager);
175     defaultCutValue = right.defaultCutValue;   << 169 
176     isSetDefaultCutValue = right.isSetDefaultC << 170 #ifdef G4VERBOSE
177     fRetrievePhysicsTable = right.fRetrievePhy << 171  if (verboseLevel >2){
178     fStoredInAscii = right.fStoredInAscii;     << 172     G4cout << "G4VUserPhysicsList::AddProcessManager: ";
179     fIsCheckedForRetrievePhysicsTable = right. << 173     G4cout  << "adds ProcessManager to ";
180     fIsRestoredCutValues = right.fIsRestoredCu << 174     G4cout  << newParticle->GetParticleName() << G4endl;
181     directoryPhysicsTable = right.directoryPhy << 175     newManager->DumpInfo();
182     fIsPhysicsTableBuilt =                     << 176   }
183       right.GetSubInstanceManager().offset[rig << 177 #endif
184     fDisplayThreshold =                        << 178   if (newParticle->GetParticleType() == "nucleus") {
185       right.GetSubInstanceManager().offset[rig << 179     PreparePhysicsTable(newParticle);
186     fDisableCheckParticleList = right.fDisable << 180     BuildPhysicsTable(newParticle);
187   }                                               181   }
188   return *this;                                << 
189 }                                                 182 }
190                                                   183 
191 // ------------------------------------------- << 
192 void G4VUserPhysicsList::AddProcessManager(G4P << 
193 {                                              << 
194   if (newParticle == nullptr) return;          << 
195   G4Exception("G4VUserPhysicsList::AddProcessM << 
196               "This method is obsolete");      << 
197 }                                              << 
198                                                   184 
199 // ------------------------------------------- << 185 ////////////////////////////////////////////////////////
200 void G4VUserPhysicsList::InitializeProcessMana    186 void G4VUserPhysicsList::InitializeProcessManager()
201 {                                                 187 {
202   // Request lock for particle table access. S << 
203   // this critical region.                     << 
204 #ifdef G4MULTITHREADED                         << 
205   G4MUTEXLOCK(&G4ParticleTable::particleTableM << 
206   G4ParticleTable::lockCount()++;              << 
207 #endif                                         << 
208   G4ParticleDefinition* gion = G4ParticleTable << 
209                                                << 
210   // loop over all particles in G4ParticleTabl    188   // loop over all particles in G4ParticleTable
211   theParticleIterator->reset();                   189   theParticleIterator->reset();
212   while ((*theParticleIterator)()) {           << 190   while( (*theParticleIterator)() ){
213     G4ParticleDefinition* particle = thePartic    191     G4ParticleDefinition* particle = theParticleIterator->value();
214     G4ProcessManager* pmanager = particle->Get    192     G4ProcessManager* pmanager = particle->GetProcessManager();
215                                                << 193     if  (pmanager==0) {
216     if (pmanager == nullptr) {                 << 194       // create process manager if the particle has no its one
217       // create process manager if the particl << 
218       pmanager = new G4ProcessManager(particle    195       pmanager = new G4ProcessManager(particle);
219       particle->SetProcessManager(pmanager);      196       particle->SetProcessManager(pmanager);
220       if (particle->GetMasterProcessManager()  << 
221         particle->SetMasterProcessManager(pman << 
222 #ifdef G4VERBOSE                               << 
223       if (verboseLevel > 2) {                  << 
224         G4cout << "G4VUserPhysicsList::Initial << 
225                   "ProcessManager to "         << 
226                << particle->GetParticleName()  << 
227       }                                        << 
228 #endif                                         << 
229     }                                             197     }
230   }                                               198   }
231                                                << 
232   if (gion != nullptr) {                       << 
233     G4ProcessManager* gionPM = gion->GetProces << 
234     // loop over all particles once again (thi << 
235     theParticleIterator->reset(false);         << 
236     while ((*theParticleIterator)()) {         << 
237       G4ParticleDefinition* particle = thePart << 
238       if (particle->IsGeneralIon()) {          << 
239         particle->SetProcessManager(gionPM);   << 
240 #ifdef G4VERBOSE                               << 
241         if (verboseLevel > 2) {                << 
242           G4cout << "G4VUserPhysicsList::Initi << 
243                     "ProcessManager to "       << 
244                  << particle->GetParticleName( << 
245         }                                      << 
246 #endif                                         << 
247       }                                        << 
248     }                                          << 
249   }                                            << 
250                                                << 
251   // release lock for particle table access    << 
252 #ifdef G4MULTITHREADED                         << 
253   G4MUTEXUNLOCK(&G4ParticleTable::particleTabl << 
254 #endif                                         << 
255 }                                                 199 }
256                                                   200 
257 // ------------------------------------------- << 201 ////////////////////////////////////////////////////////
258 void G4VUserPhysicsList::RemoveProcessManager(    202 void G4VUserPhysicsList::RemoveProcessManager()
259 {                                                 203 {
260   // Request lock for particle table access. S << 
261   // this critical region.                     << 
262 #ifdef G4MULTITHREADED                         << 
263   G4MUTEXLOCK(&G4ParticleTable::particleTableM << 
264   G4ParticleTable::lockCount()++;              << 
265 #endif                                         << 
266                                                << 
267   // loop over all particles in G4ParticleTabl    204   // loop over all particles in G4ParticleTable
268   theParticleIterator->reset();                   205   theParticleIterator->reset();
269   while ((*theParticleIterator)()) {           << 206   while( (*theParticleIterator)() ){
270     G4ParticleDefinition* particle = thePartic    207     G4ParticleDefinition* particle = theParticleIterator->value();
271     if (particle->GetInstanceID() < G4Particle << 208     G4ProcessManager* pmanager = particle->GetProcessManager();
272       if (particle->GetParticleSubType() != "g << 209     if  (pmanager!=0) delete pmanager;
273           || particle->GetParticleName() == "G << 210     particle->SetProcessManager(0);
274       {                                        << 211 #ifdef G4VERBOSE
275         G4ProcessManager* pmanager = particle- << 212     if (verboseLevel >2){
276                                                << 213       G4cout << "G4VUserPhysicsList::RemoveProcessManager: ";
277         delete pmanager;                       << 214       G4cout  << "remove ProcessManager from ";
278 #ifdef G4VERBOSE                               << 215       G4cout  << particle->GetParticleName() << G4endl;
279         if (verboseLevel > 2) {                << 
280           G4cout << "G4VUserPhysicsList::Remov << 
281           G4cout << "remove ProcessManager fro << 
282           G4cout << particle->GetParticleName( << 
283         }                                      << 
284 #endif                                         << 
285       }                                        << 
286       particle->SetProcessManager(nullptr);    << 
287     }                                             216     }
288   }                                            << 
289                                                << 
290   // release lock for particle table access    << 
291 #ifdef G4MULTITHREADED                         << 
292   G4MUTEXUNLOCK(&G4ParticleTable::particleTabl << 
293 #endif                                            217 #endif
                                                   >> 218   }
294 }                                                 219 }
295                                                   220 
296 // ------------------------------------------- << 221 
297 void G4VUserPhysicsList::RemoveTrackingManager << 222 ////////////////////////////////////////////////////////
                                                   >> 223 #include "G4Transportation.hh"
                                                   >> 224 #include "G4CoupledTransportation.hh"
                                                   >> 225 #include "G4RunManagerKernel.hh"
                                                   >> 226 #include "G4ScoringManager.hh"
                                                   >> 227 
                                                   >> 228 void G4VUserPhysicsList::AddTransportation()
298 {                                                 229 {
299   // One tracking manager may be registered fo << 230   G4int verboseLevelTransport = 0;
300   // to delete every object only once.         << 231   G4VProcess* theTransportationProcess = 0;
301   std::unordered_set<G4VTrackingManager*> trac << 232   G4int nParaWorld = G4RunManagerKernel::GetRunManagerKernel()->GetNumberOfParallelWorld();
                                                   >> 233 
                                                   >> 234   if(nParaWorld || useCoupledTransportation || G4ScoringManager::GetScoringManagerIfExist())
                                                   >> 235     {
                                                   >> 236       theTransportationProcess = new G4CoupledTransportation(verboseLevelTransport);
                                                   >> 237       G4cout << "#############################################################################" << G4endl
                                                   >> 238              << " G4VUserPhysicsList::AddTransportation() --- G4CoupledTransportation is used " << G4endl
                                                   >> 239              << "#############################################################################" << G4endl;
                                                   >> 240     }
                                                   >> 241   else
                                                   >> 242     { theTransportationProcess = new G4Transportation(verboseLevelTransport); }
                                                   >> 243  
                                                   >> 244 #ifdef G4VERBOSE
                                                   >> 245     if (verboseLevel >2){
                                                   >> 246       G4cout << "G4VUserPhysicsList::AddTransportation()  "<< G4endl;
                                                   >> 247     }
                                                   >> 248 #endif
302                                                   249 
303   // loop over all particles in G4ParticleTabl    250   // loop over all particles in G4ParticleTable
304   theParticleIterator->reset();                   251   theParticleIterator->reset();
305   while ((*theParticleIterator)()) {           << 252   while( (*theParticleIterator)() ){
306     G4ParticleDefinition* particle = thePartic    253     G4ParticleDefinition* particle = theParticleIterator->value();
307     if (auto* trackingManager = particle->GetT << 254     G4ProcessManager* pmanager = particle->GetProcessManager();
308 #ifdef G4VERBOSE                               << 255     if (!particle->IsShortLived()) {
309       if (verboseLevel > 2) {                  << 256       // Add transportation process for all particles other than  "shortlived"
310         G4cout << "G4VUserPhysicsList::RemoveT << 257       if ( pmanager == 0) {
311         G4cout << "remove TrackingManager from << 258   // Error !! no process manager
312         G4cout << particle->GetParticleName()  << 259   G4String particleName = particle->GetParticleName();
                                                   >> 260   G4Exception("G4VUserPhysicsList::AddTransportation","No process manager",
                                                   >> 261         RunMustBeAborted, particleName );
                                                   >> 262       } else {
                                                   >> 263   // add transportation with ordering = ( -1, "first", "first" )
                                                   >> 264   pmanager ->AddProcess(theTransportationProcess);
                                                   >> 265   pmanager ->SetProcessOrderingToFirst(theTransportationProcess, idxAlongStep);
                                                   >> 266   pmanager ->SetProcessOrderingToFirst(theTransportationProcess, idxPostStep);
                                                   >> 267       }
                                                   >> 268     } else {
                                                   >> 269       // shortlived particle case
                                                   >> 270       // Add transportation process for all particles other than  "shortlived"
                                                   >> 271       if ( pmanager == 0) {
                                                   >> 272         // Error !! no process manager
                                                   >> 273         G4String particleName = particle->GetParticleName();
                                                   >> 274         G4Exception("G4VUserPhysicsList::AddTransportation","No process manager",
                                                   >> 275                     RunMustBeAborted, particleName );
                                                   >> 276       } else {
                                                   >> 277         // add transportation with ordering = ( -1, "first", "first" )
                                                   >> 278         pmanager ->AddProcess(theTransportationProcess);
                                                   >> 279         pmanager ->SetProcessOrderingToFirst(theTransportationProcess, idxAlongStep);
                                                   >> 280         pmanager ->SetProcessOrderingToFirst(theTransportationProcess, idxPostStep);
313       }                                           281       }
314 #endif                                         << 
315       trackingManagers.insert(trackingManager) << 
316       particle->SetTrackingManager(nullptr);   << 
317     }                                          << 
318   }                                            << 
319                                                   282 
320   for (G4VTrackingManager* tm : trackingManage << 283     }
321     delete tm;                                 << 
322   }                                               284   }
323 }                                                 285 }
324                                                   286 
325 // ------------------------------------------- << 
326 void G4VUserPhysicsList::SetCuts()             << 
327 {                                              << 
328   if (!isSetDefaultCutValue) {                 << 
329     SetDefaultCutValue(defaultCutValue);       << 
330   }                                            << 
331                                                   287 
332 #ifdef G4VERBOSE                               << 288 ////////////////////////////////////////////////////////
333   if (verboseLevel > 1) {                      << 
334     G4cout << "G4VUserPhysicsList::SetCuts:    << 
335     G4cout << "Cut for gamma: " << GetCutValue << 
336     G4cout << "Cut  for e-: " << GetCutValue(" << 
337     G4cout << "Cut  for e+: " << GetCutValue(" << 
338     G4cout << "Cut  for proton: " << GetCutVal << 
339   }                                            << 
340 #endif                                         << 
341                                                << 
342   // dump Cut values if verboseLevel==3        << 
343   if (verboseLevel > 2) {                      << 
344     DumpCutValuesTable();                      << 
345   }                                            << 
346 }                                              << 
347                                                << 
348 // ------------------------------------------- << 
349 void G4VUserPhysicsList::SetDefaultCutValue(G4    289 void G4VUserPhysicsList::SetDefaultCutValue(G4double value)
350 {                                                 290 {
351   if (value < 0.0) {                           << 291    if (value<=0.0) {
352 #ifdef G4VERBOSE                                  292 #ifdef G4VERBOSE
353     if (verboseLevel > 0) {                    << 293      if (verboseLevel >0){
354       G4cout << "G4VUserPhysicsList::SetDefaul << 294        G4cout << "G4VUserPhysicsList::SetDefaultCutValue: negative cut values";
355              << "  :" << value / mm << "[mm]"  << 295        G4cout << "  :" << value/mm << "[mm]" << G4endl;
356     }                                          << 296      }
357 #endif                                            297 #endif
358     return;                                    << 298    } else {
359   }                                            << 
360                                                << 
361   defaultCutValue = value;                     << 
362   isSetDefaultCutValue = true;                 << 
363                                                << 
364   // set cut values for gamma at first and for << 
365   SetCutValue(defaultCutValue, "gamma");       << 
366   SetCutValue(defaultCutValue, "e-");          << 
367   SetCutValue(defaultCutValue, "e+");          << 
368   SetCutValue(defaultCutValue, "proton");      << 
369                                                << 
370 #ifdef G4VERBOSE                                  299 #ifdef G4VERBOSE
371   if (verboseLevel > 1) {                      << 300      if (verboseLevel >1){
372     G4cout << "G4VUserPhysicsList::SetDefaultC << 301        G4cout << "G4VUserPhysicsList::SetDefaultCutValue:";
373            << "default cut value is changed to << 302        G4cout << "default cut value is changed to   :" ;
374   }                                            << 303        G4cout << value/mm << "[mm]" << G4endl;
                                                   >> 304      }
375 #endif                                            305 #endif
376 }                                              << 306      defaultCutValue = value;
377                                                   307 
378 // ------------------------------------------- << 308    }
379 G4double G4VUserPhysicsList::GetCutValue(const << 
380 {                                              << 
381   std::size_t nReg = (G4RegionStore::GetInstan << 
382   if (nReg == 0) {                             << 
383 #ifdef G4VERBOSE                               << 
384     if (verboseLevel > 0) {                    << 
385       G4cout << "G4VUserPhysicsList::GetCutVal << 
386              << " : No Default Region " << G4e << 
387     }                                          << 
388 #endif                                         << 
389     G4Exception("G4VUserPhysicsList::GetCutVal << 
390     return -1. * mm;                           << 
391   }                                            << 
392   G4Region* region = G4RegionStore::GetInstanc << 
393   return region->GetProductionCuts()->GetProdu << 
394 }                                                 309 }
395                                                   310 
396 // ------------------------------------------- << 311 
                                                   >> 312 ////////////////////////////////////////////////////////
397 void G4VUserPhysicsList::SetCutValue(G4double     313 void G4VUserPhysicsList::SetCutValue(G4double aCut, const G4String& name)
398 {                                                 314 {
399   SetParticleCuts(aCut, name);                 << 315   G4ParticleDefinition* particle = theParticleTable->FindParticle(name);
                                                   >> 316   if (particle != 0){
                                                   >> 317     if (!particle->IsShortLived()) {
                                                   >> 318       //set cut value
                                                   >> 319       SetParticleCuts( aCut ,particle );
                                                   >> 320     }
                                                   >> 321   }
400 }                                                 322 }
401                                                   323 
402 // ------------------------------------------- << 324 ////////////////////////////////////////////////////////
403 void G4VUserPhysicsList::SetCutValue(G4double  << 325 void G4VUserPhysicsList::SetCutValue
                                                   >> 326 (G4double aCut, const G4String& pname, const G4String& rname)
404 {                                                 327 {
                                                   >> 328   G4ParticleDefinition* particle = theParticleTable->FindParticle(pname);
405   G4Region* region = G4RegionStore::GetInstanc    329   G4Region* region = G4RegionStore::GetInstance()->GetRegion(rname);
406   if (region != nullptr) {                     << 330   if (particle != 0 && region != 0){
407     // set cut value                           << 331     if (!particle->IsShortLived()) {
408     SetParticleCuts(aCut, pname, region);      << 332       //set cut value
409   }                                            << 333       SetParticleCuts( aCut ,particle, region );
410   else {                                       << 
411 #ifdef G4VERBOSE                               << 
412     if (verboseLevel > 0) {                    << 
413       G4cout << "G4VUserPhysicsList::SetCutVal << 
414              << " : No Region of " << rname << << 
415     }                                             334     }
416 #endif                                         << 
417   }                                               335   }
418 }                                                 336 }
419                                                   337 
420 // ------------------------------------------- << 338 
                                                   >> 339 
                                                   >> 340 ////////////////////////////////////////////////////////
421 void G4VUserPhysicsList::SetCutsWithDefault()     341 void G4VUserPhysicsList::SetCutsWithDefault()
422 {                                                 342 {
423   SetDefaultCutValue(defaultCutValue);         << 343   // default cut value
424   G4VUserPhysicsList::SetCuts();               << 344   G4double cut = defaultCutValue;
                                                   >> 345 
                                                   >> 346 #ifdef G4VERBOSE
                                                   >> 347   if (verboseLevel >1){
                                                   >> 348     G4cout << "G4VUserPhysicsList::SetCutsWithDefault:";
                                                   >> 349     G4cout << "CutLength : " << cut/mm << " (mm)" << G4endl;
                                                   >> 350   }
                                                   >> 351 #endif
                                                   >> 352 
                                                   >> 353   // set cut values for gamma at first and for e- and e+
                                                   >> 354   SetCutValue(cut, "gamma");
                                                   >> 355   SetCutValue(cut, "e-");
                                                   >> 356   SetCutValue(cut, "e+");
                                                   >> 357 
                                                   >> 358   // dump Cut values if verboseLevel==3
                                                   >> 359   if (verboseLevel>2) {
                                                   >> 360     DumpCutValuesTable();
                                                   >> 361   }
425 }                                                 362 }
426                                                   363 
427 // ------------------------------------------- << 364 
                                                   >> 365 ////////////////////////////////////////////////////////
428 void G4VUserPhysicsList::SetCutsForRegion(G4do    366 void G4VUserPhysicsList::SetCutsForRegion(G4double aCut, const G4String& rname)
429 {                                                 367 {
430   // set cut values for gamma at first and for    368   // set cut values for gamma at first and for e- and e+
431   SetCutValue(aCut, "gamma", rname);              369   SetCutValue(aCut, "gamma", rname);
432   SetCutValue(aCut, "e-", rname);                 370   SetCutValue(aCut, "e-", rname);
433   SetCutValue(aCut, "e+", rname);                 371   SetCutValue(aCut, "e+", rname);
434   SetCutValue(aCut, "proton", rname);          << 
435 }                                              << 
436                                                << 
437 // ------------------------------------------- << 
438 void G4VUserPhysicsList::SetParticleCuts(G4dou << 
439                                          G4Reg << 
440 {                                              << 
441   SetParticleCuts(cut, particle->GetParticleNa << 
442 }                                                 372 }
443                                                   373 
444 // ------------------------------------------- << 
445 void G4VUserPhysicsList::SetParticleCuts(G4dou << 
446                                          G4Reg << 
447 {                                              << 
448   if (cut < 0.0) {                             << 
449 #ifdef G4VERBOSE                               << 
450     if (verboseLevel > 0) {                    << 
451       G4cout << "G4VUserPhysicsList::SetPartic << 
452              << "  :" << cut / mm << "[mm]"    << 
453              << " for " << particleName << G4e << 
454     }                                          << 
455 #endif                                         << 
456     return;                                    << 
457   }                                            << 
458                                                   374 
459   G4Region* world_region =                     << 
460     G4RegionStore::GetInstance()->GetRegion("D << 
461   if (region == nullptr) {                     << 
462     std::size_t nReg = G4RegionStore::GetInsta << 
463     if (nReg == 0) {                           << 
464 #ifdef G4VERBOSE                               << 
465       if (verboseLevel > 0) {                  << 
466         G4cout << "G4VUserPhysicsList::SetPart << 
467                << " : No Default Region " << G << 
468       }                                        << 
469 #endif                                         << 
470       G4Exception("G4VUserPhysicsList::SetPart << 
471                   "No Default Region");        << 
472       return;                                  << 
473     }                                          << 
474     region = world_region;                     << 
475   }                                            << 
476                                                << 
477   if (!isSetDefaultCutValue) {                 << 
478     SetDefaultCutValue(defaultCutValue);       << 
479   }                                            << 
480                                                   375 
                                                   >> 376 ////////////////////////////////////////////////////////
                                                   >> 377 ////////////////////////////////////////////////////////
                                                   >> 378 void G4VUserPhysicsList::SetParticleCuts( G4double cut, G4ParticleDefinition* particle, G4Region* region)
                                                   >> 379 {
                                                   >> 380   if(!region) region = (*(G4RegionStore::GetInstance()))[0];
481   G4ProductionCuts* pcuts = region->GetProduct    381   G4ProductionCuts* pcuts = region->GetProductionCuts();
482   if (region != world_region                   << 382   pcuts->SetProductionCut(cut,particle);
483       && pcuts == G4ProductionCutsTable::GetPr << 
484   {  // This region had no unique cuts yet but << 
485      // Need to create a new object before set << 
486     pcuts = new G4ProductionCuts(              << 
487       *(G4ProductionCutsTable::GetProductionCu << 
488     region->SetProductionCuts(pcuts);          << 
489   }                                            << 
490   pcuts->SetProductionCut(cut, particleName);  << 
491 #ifdef G4VERBOSE                               << 
492   if (verboseLevel > 2) {                      << 
493     G4cout << "G4VUserPhysicsList::SetParticle << 
494            << "  :" << cut / mm << "[mm]"      << 
495            << " for " << particleName << G4end << 
496   }                                            << 
497 #endif                                         << 
498 }                                                 383 }
499                                                   384 
500 // ------------------------------------------- << 385 ///////////////////////////////////////////////////////////////
501 void G4VUserPhysicsList::BuildPhysicsTable()      386 void G4VUserPhysicsList::BuildPhysicsTable()
502 {                                                 387 {
503   // Prepare Physics table for all particles   << 388   //Prepare Physics table for all particles 
504   theParticleIterator->reset();                   389   theParticleIterator->reset();
505   while ((*theParticleIterator)()) {           << 390   while( (*theParticleIterator)() ){
506     G4ParticleDefinition* particle = thePartic    391     G4ParticleDefinition* particle = theParticleIterator->value();
507     PreparePhysicsTable(particle);             << 392     PreparePhysicsTable(particle); 
508   }                                               393   }
509                                                   394 
510   // ask processes to prepare physics table    << 395   // ask processes to prepare physics table 
511   if (fRetrievePhysicsTable) {                    396   if (fRetrievePhysicsTable) {
512     fIsRestoredCutValues = fCutsTable->Retriev    397     fIsRestoredCutValues = fCutsTable->RetrieveCutsTable(directoryPhysicsTable, fStoredInAscii);
513     // check if retrieve Cut Table successfull    398     // check if retrieve Cut Table successfully
514     if (!fIsRestoredCutValues) {                  399     if (!fIsRestoredCutValues) {
515 #ifdef G4VERBOSE                                  400 #ifdef G4VERBOSE
516       if (verboseLevel > 0) {                  << 401       if (verboseLevel>0){
517         G4cout << "G4VUserPhysicsList::BuildPh << 402   G4cout << "G4VUserPhysicsList::BuildPhysicsTable";
518                << " Retrieve Cut Table failed  << 403   G4cout << " Retrieve Cut Table failed !!" << G4endl;
519       }                                        << 404       }
520 #endif                                         << 405 #endif  
521       G4Exception("G4VUserPhysicsList::BuildPh << 406       G4Exception("G4VUserPhysicsList::BuildPhysicsTable","Fail to Retreive",
522                   "Fail to retrieve Production << 407       RunMustBeAborted,"Production Cut Table can not be retreived");
523     }                                          << 408     } else {
524     else {                                     << 409 #ifdef G4VERBOSE
525 #ifdef G4VERBOSE                               << 410       if (verboseLevel>2){
526       if (verboseLevel > 2) {                  << 411   G4cout << "G4VUserPhysicsList::BuildPhysicsTable";
527         G4cout << "G4VUserPhysicsList::BuildPh << 412   G4cout << "  Retrieve Cut Table successfully " << G4endl;
528                << "  Retrieve Cut Table succes << 413       }
529       }                                        << 414 #endif 
530 #endif                                         << 415     }     
531     }                                          << 416   } else {
532   }                                            << 417 #ifdef G4VERBOSE
533   else {                                       << 418     if (verboseLevel>2){
534 #ifdef G4VERBOSE                               << 419       G4cout << "G4VUserPhysicsList::BuildPhysicsTable";
535     if (verboseLevel > 2) {                    << 420       G4cout << " does not retrieve Cut Table but calculate " << G4endl;
536       G4cout << "G4VUserPhysicsList::BuildPhys << 421     } 
537              << " does not retrieve Cut Table  << 422 #endif      
538     }                                          << 
539 #endif                                         << 
540   }                                               423   }
541                                                   424 
542   // Sets a value to particle                     425   // Sets a value to particle
543   // set cut values for gamma at first and for    426   // set cut values for gamma at first and for e- and e+
544   G4String particleName;                          427   G4String particleName;
545   G4ParticleDefinition* GammaP = theParticleTa    428   G4ParticleDefinition* GammaP = theParticleTable->FindParticle("gamma");
546   if (GammaP != nullptr) BuildPhysicsTable(Gam << 429   if(GammaP) BuildPhysicsTable(GammaP);
547   G4ParticleDefinition* EMinusP = theParticleT    430   G4ParticleDefinition* EMinusP = theParticleTable->FindParticle("e-");
548   if (EMinusP != nullptr) BuildPhysicsTable(EM << 431   if(EMinusP) BuildPhysicsTable(EMinusP);
549   G4ParticleDefinition* EPlusP = theParticleTa    432   G4ParticleDefinition* EPlusP = theParticleTable->FindParticle("e+");
550   if (EPlusP != nullptr) BuildPhysicsTable(EPl << 433   if(EPlusP) BuildPhysicsTable(EPlusP);
551   G4ParticleDefinition* ProtonP = theParticleT    434   G4ParticleDefinition* ProtonP = theParticleTable->FindParticle("proton");
552   if (ProtonP != nullptr) BuildPhysicsTable(Pr << 435   if(ProtonP) BuildPhysicsTable(ProtonP);
                                                   >> 436 
553                                                   437 
554   theParticleIterator->reset();                   438   theParticleIterator->reset();
555   while ((*theParticleIterator)()) {           << 439   while( (*theParticleIterator)() ){
556     G4ParticleDefinition* particle = thePartic    440     G4ParticleDefinition* particle = theParticleIterator->value();
557     if (particle != GammaP && particle != EMin << 441     if( particle!=GammaP && 
558       BuildPhysicsTable(particle);             << 442   particle!=EMinusP && 
                                                   >> 443   particle!=EPlusP && 
                                                   >> 444   particle!=ProtonP   ){
                                                   >> 445       BuildPhysicsTable(particle); 
559     }                                             446     }
560   }                                               447   }
561                                                << 
562   // Set flag                                  << 
563   fIsPhysicsTableBuilt = true;                 << 
564 }                                                 448 }
565                                                << 449 ///////////////////////////////////////////////////////////////
566 // ------------------------------------------- << 
567 void G4VUserPhysicsList::BuildPhysicsTable(G4P    450 void G4VUserPhysicsList::BuildPhysicsTable(G4ParticleDefinition* particle)
568 {                                                 451 {
569   if (auto* trackingManager = particle->GetTra << 
570 #ifdef G4VERBOSE                               << 
571     if (verboseLevel > 2) {                    << 
572       G4cout << "G4VUserPhysicsList::BuildPhys << 
573              << "Calculate Physics Table for " << 
574              << " via custom TrackingManager"  << 
575     }                                          << 
576 #endif                                         << 
577     trackingManager->BuildPhysicsTable(*partic << 
578     return;                                    << 
579   }                                            << 
580                                                << 
581   // Change in order to share physics tables f << 
582                                                << 
583   if (particle->GetMasterProcessManager() == n << 
584 #ifdef G4VERBOSE                               << 
585     if (verboseLevel > 0) {                    << 
586       G4cout << "#### G4VUserPhysicsList::Buil << 
587              << particle->GetParticleName() << << 
588     }                                          << 
589 #endif                                         << 
590     return;                                    << 
591   }                                            << 
592   if (fRetrievePhysicsTable) {                    452   if (fRetrievePhysicsTable) {
593     if (!fIsRestoredCutValues) {               << 453     if ( !fIsRestoredCutValues){
594       // fail to retrieve cut tables           << 454       // fail to retreive cut tables
595 #ifdef G4VERBOSE                                  455 #ifdef G4VERBOSE
596       if (verboseLevel > 0) {                  << 456       if (verboseLevel>0){
597         G4cout << "G4VUserPhysicsList::BuildPh << 457   G4cout << "G4VUserPhysicsList::BuildPhysicsTable  ";
598                << "Physics table can not be re << 458   G4cout << "Physics table can not be retreived and will be calculated "<< G4endl;
599       }                                           459       }
600 #endif                                            460 #endif
601       fRetrievePhysicsTable = false;           << 461       fRetrievePhysicsTable = false; 
602     }                                          << 462 
603     else {                                     << 463     } else {
604 #ifdef G4VERBOSE                                  464 #ifdef G4VERBOSE
605       if (verboseLevel > 2) {                  << 465       if (verboseLevel>2){
606         G4cout << "G4VUserPhysicsList::BuildPh << 466   G4cout << "G4VUserPhysicsList::BuildPhysicsTable  ";
607                << " Retrieve Physics Table for << 467   G4cout << " Retrieve Physics Table for ";
                                                   >> 468   G4cout << particle->GetParticleName() << G4endl;
608       }                                           469       }
609 #endif                                            470 #endif
610       //  Retrieve PhysicsTable from files for    471       //  Retrieve PhysicsTable from files for proccesses
611       RetrievePhysicsTable(particle, directory    472       RetrievePhysicsTable(particle, directoryPhysicsTable, fStoredInAscii);
612     }                                             473     }
613   }                                               474   }
614                                                   475 
615 #ifdef G4VERBOSE                                  476 #ifdef G4VERBOSE
616   if (verboseLevel > 2) {                      << 477   if (verboseLevel>2){
617     G4cout << "G4VUserPhysicsList::BuildPhysic << 478     G4cout << "G4VUserPhysicsList::BuildPhysicsTable  ";
618            << "Calculate Physics Table for " < << 479     G4cout << "Calculate Physics Table for " << particle->GetParticleName() << G4endl;
619   }                                               480   }
620 #endif                                            481 #endif
621   // Rebuild the physics tables for every proc    482   // Rebuild the physics tables for every process for this particle type
622   // if particle is not ShortLived                483   // if particle is not ShortLived
623   if (!particle->IsShortLived()) {             << 484   if(!particle->IsShortLived()) {
624     G4ProcessManager* pManager = particle->Get << 485     G4ProcessVector* pVector = particle->GetProcessManager()->GetProcessList();
625     if (pManager == nullptr) {                 << 486     for (G4int j=0; j < pVector->size(); ++j) {
626 #ifdef G4VERBOSE                               << 487       (*pVector)[j]->BuildPhysicsTable(*particle);
627       if (verboseLevel > 0) {                  << 
628         G4cout << "G4VUserPhysicsList::BuildPh << 
629                << " : No Process Manager for " << 
630         G4cout << particle->GetParticleName()  << 
631       }                                        << 
632 #endif                                         << 
633       G4Exception("G4VUserPhysicsList::BuildPh << 
634                   "No process manager");       << 
635       return;                                  << 
636     }                                          << 
637                                                << 
638     // Get processes from master thread;       << 
639     G4ProcessManager* pManagerShadow = particl << 
640                                                << 
641     G4ProcessVector* pVector = pManager->GetPr << 
642     if (pVector == nullptr) {                  << 
643 #ifdef G4VERBOSE                               << 
644       if (verboseLevel > 0) {                  << 
645         G4cout << "G4VUserPhysicsList::BuildPh << 
646                << " : No Process Vector for "  << 
647       }                                        << 
648 #endif                                         << 
649       G4Exception("G4VUserPhysicsList::BuildPh << 
650                   "No process Vector");        << 
651       return;                                  << 
652     }                                          << 
653 #ifdef G4VERBOSE                               << 
654     if (verboseLevel > 2) {                    << 
655       G4cout << "G4VUserPhysicsList::BuildPhys << 
656              << G4endl;                        << 
657       G4cout << " ProcessManager : " << pManag << 
658              << G4endl;                        << 
659       for (G4int iv1 = 0; iv1 < (G4int)pVector << 
660         G4cout << "  " << iv1 << " - " << (*pV << 
661       }                                        << 
662       G4cout << "----------------------------- << 
663       G4ProcessVector* pVectorShadow = pManage << 
664                                                << 
665       for (G4int iv2 = 0; iv2 < (G4int)pVector << 
666         G4cout << "  " << iv2 << " - " << (*pV << 
667       }                                        << 
668     }                                             488     }
669 #endif                                         << 489   }
670     for (G4int j = 0; j < (G4int)pVector->size << 
671       // Andrea July 16th 2013 : migration to  << 
672       // Infer if we are in a worker thread or << 
673       // Master thread is the one in which the << 
674       // and process manager shadow pointers a << 
675       if (pManagerShadow == pManager) {        << 
676         (*pVector)[j]->BuildPhysicsTable(*part << 
677       }                                        << 
678       else {                                   << 
679         (*pVector)[j]->BuildWorkerPhysicsTable << 
680       }                                        << 
681                                                << 
682     }  // End loop on processes vector         << 
683   }  // End if short-lived                     << 
684 }                                                 490 }
685                                                   491 
686 // ------------------------------------------- << 492 ///////////////////////////////////////////////////////////////
687 void G4VUserPhysicsList::PreparePhysicsTable(G    493 void G4VUserPhysicsList::PreparePhysicsTable(G4ParticleDefinition* particle)
688 {                                                 494 {
689   if (auto* trackingManager = particle->GetTra << 
690     trackingManager->PreparePhysicsTable(*part << 
691     return;                                    << 
692   }                                            << 
693                                                << 
694   if ((particle->GetMasterProcessManager()) == << 
695     return;                                    << 
696   }                                            << 
697   // Prepare the physics tables for every proc    495   // Prepare the physics tables for every process for this particle type
698   // if particle is not ShortLived                496   // if particle is not ShortLived
699   if (!particle->IsShortLived()) {             << 497   if(!particle->IsShortLived()) {
700     G4ProcessManager* pManager = particle->Get << 498     G4ProcessManager* pManager =  particle->GetProcessManager();
701     if (pManager == nullptr) {                 << 499     if (!pManager) {
702 #ifdef G4VERBOSE                               << 500       G4cerr << "G4VUserPhysicsList::PreparePhysicsTable  : No Process Manager for " 
703       if (verboseLevel > 0) {                  << 501              << particle->GetParticleName() <<G4endl;
704         G4cout << "G4VUserPhysicsList::Prepare << 502       G4cerr << particle->GetParticleName() << " should be created in your PhysicsList" <<G4endl;
705                << ": No Process Manager for "  << 503       G4Exception("G4VUserPhysicsList::PreparePhysicsTable","No process manager",
706         G4cout << particle->GetParticleName()  << 504                     RunMustBeAborted,  particle->GetParticleName() );
707       }                                        << 
708 #endif                                         << 
709       G4Exception("G4VUserPhysicsList::Prepare << 
710                   "No process manager");       << 
711       return;                                  << 
712     }                                             505     }
713                                                   506 
714     // Get processes from master thread        << 
715     G4ProcessManager* pManagerShadow = particl << 
716                                                << 
717     G4ProcessVector* pVector = pManager->GetPr    507     G4ProcessVector* pVector = pManager->GetProcessList();
718     if (pVector == nullptr) {                  << 508     for (G4int j=0; j < pVector->size(); ++j) {
719 #ifdef G4VERBOSE                               << 509       (*pVector)[j]->PreparePhysicsTable(*particle);
720       if (verboseLevel > 0) {                  << 510     }
721         G4cout << "G4VUserPhysicsList::Prepare << 511   }
722                << ": No Process Vector for " < << 
723       }                                        << 
724 #endif                                         << 
725       G4Exception("G4VUserPhysicsList::Prepare << 
726                   "No process Vector");        << 
727       return;                                  << 
728     }                                          << 
729     for (G4int j = 0; j < (G4int)pVector->size << 
730       // Andrea July 16th 2013 : migration to  << 
731       // Infer if we are in a worker thread or << 
732       // Master thread is the one in which the << 
733       // and process manager shadow pointers a << 
734       if (pManagerShadow == pManager) {        << 
735         (*pVector)[j]->PreparePhysicsTable(*pa << 
736       }                                        << 
737       else {                                   << 
738         (*pVector)[j]->PrepareWorkerPhysicsTab << 
739       }                                        << 
740     }  // End loop on processes vector         << 
741   }  // End if pn ShortLived                   << 
742 }                                                 512 }
743                                                   513 
744 // ------------------------------------------- << 514 ///////////////////////////////////////////////////////////////
745 void G4VUserPhysicsList::BuildIntegralPhysicsT << 515 void  G4VUserPhysicsList::BuildIntegralPhysicsTable(G4VProcess* process,
746                                                << 516                 G4ParticleDefinition* particle)
747 {                                                 517 {
748   // TODO Should we change this function?      << 518   //*********************************************************************
749   //****************************************** << 519   // temporary addition to make the integral schema of electromagnetic
750   // Temporary addition to make the integral s << 
751   // processes work.                              520   // processes work.
                                                   >> 521   //
752                                                   522 
753   if ((process->GetProcessName() == "Imsc") || << 523   if ( (process->GetProcessName() == "Imsc") ||
754       || (process->GetProcessName() == "IeBrem << 524        (process->GetProcessName() == "IeIoni") ||
755       || (process->GetProcessName() == "IhIoni << 525        (process->GetProcessName() == "IeBrems") ||
756       || (process->GetProcessName() == "IMuBre << 526        (process->GetProcessName() == "Iannihil") ||
757   {                                            << 527        (process->GetProcessName() == "IhIoni") ||
758 #ifdef G4VERBOSE                               << 528        (process->GetProcessName() == "IMuIoni") ||
759     if (verboseLevel > 2) {                    << 529        (process->GetProcessName() == "IMuBrems") ||
760       G4cout << "G4VUserPhysicsList::BuildInte << 530        (process->GetProcessName() == "IMuPairProd")  ) {
761              << " BuildPhysicsTable is invoked << 531 #ifdef G4VERBOSE
762              << particle->GetParticleName() << << 532     if (verboseLevel>2){
                                                   >> 533       G4cout << "G4VUserPhysicsList::BuildIntegralPhysicsTable  ";
                                                   >> 534       G4cout << " BuildPhysicsTable is invoked for ";
                                                   >> 535       G4cout << process->GetProcessName();
                                                   >> 536       G4cout << "(" << particle->GetParticleName() << ")" << G4endl;
763     }                                             537     }
764 #endif                                            538 #endif
765     process->BuildPhysicsTable(*particle);        539     process->BuildPhysicsTable(*particle);
766   }                                               540   }
767 }                                                 541 }
768                                                   542 
769 // ------------------------------------------- << 543 ///////////////////////////////////////////////////////////////
770 void G4VUserPhysicsList::DumpList() const         544 void G4VUserPhysicsList::DumpList() const
771 {                                                 545 {
772   theParticleIterator->reset();                   546   theParticleIterator->reset();
773   G4int idx = 0;                                  547   G4int idx = 0;
774   while ((*theParticleIterator)()) {           << 548   while( (*theParticleIterator)() ){
775     G4ParticleDefinition* particle = thePartic    549     G4ParticleDefinition* particle = theParticleIterator->value();
776     G4cout << particle->GetParticleName();        550     G4cout << particle->GetParticleName();
777     if ((idx++ % 4) == 3) {                       551     if ((idx++ % 4) == 3) {
778       G4cout << G4endl;                           552       G4cout << G4endl;
779     }                                          << 553     } else {
780     else {                                     << 
781       G4cout << ", ";                             554       G4cout << ", ";
782     }                                          << 555     }      
783   }                                               556   }
784   G4cout << G4endl;                               557   G4cout << G4endl;
785 }                                                 558 }
786                                                   559 
787 // ------------------------------------------- << 560 
788 void G4VUserPhysicsList::DumpCutValuesTable(G4 << 561 
789 {                                              << 562 ///////////////////////////////////////////////////////////////
790   fDisplayThreshold = flag;                    << 563 void G4VUserPhysicsList::DumpCutValuesTable(G4int nParticles) 
                                                   >> 564 { 
                                                   >> 565   fDisplayThreshold = nParticles; 
791 }                                                 566 }
792                                                   567 
793 // ------------------------------------------- << 568 ///////////////////////////////////////////////////////////////
794 void G4VUserPhysicsList::DumpCutValuesTableIfR    569 void G4VUserPhysicsList::DumpCutValuesTableIfRequested()
795 {                                                 570 {
796   if (fDisplayThreshold == 0) return;          << 571   if(fDisplayThreshold==0) return;
797   G4ProductionCutsTable::GetProductionCutsTabl    572   G4ProductionCutsTable::GetProductionCutsTable()->DumpCouples();
798   fDisplayThreshold = 0;                          573   fDisplayThreshold = 0;
799 }                                                 574 }
800                                                   575 
801 // ------------------------------------------- << 576 
                                                   >> 577 ///////////////////////////////////////////////////////////////
                                                   >> 578 ///////////////////////////////////////////////////////////////
802 G4bool G4VUserPhysicsList::StorePhysicsTable(c    579 G4bool G4VUserPhysicsList::StorePhysicsTable(const G4String& directory)
803 {                                                 580 {
804   G4bool ascii = fStoredInAscii;               << 581   G4bool   ascii = fStoredInAscii;
805   G4String dir = directory;                    << 582   G4String dir   = directory;
806   if (dir.empty())                             << 583   if (dir.isNull()) dir = directoryPhysicsTable; 
807     dir = directoryPhysicsTable;               << 584   else directoryPhysicsTable = dir; 
808   else                                         << 
809     directoryPhysicsTable = dir;               << 
810                                                   585 
811   // store CutsTable info                         586   // store CutsTable info
812   if (!fCutsTable->StoreCutsTable(dir, ascii))    587   if (!fCutsTable->StoreCutsTable(dir, ascii)) {
813     G4Exception("G4VUserPhysicsList::StorePhys << 588     G4Exception("G4VUserPhysicsList::StorePhysicsTable","Faile to store ",
814                 "Fail to store Cut Table");    << 589     JustWarning,"Cut Table can not be stored");   
815     return false;                                 590     return false;
816   }                                               591   }
817 #ifdef G4VERBOSE                               << 592 #ifdef G4VERBOSE  
818   if (verboseLevel > 2) {                      << 593   if (verboseLevel>2){
819     G4cout << "G4VUserPhysicsList::StorePhysic << 594     G4cout << "G4VUserPhysicsList::StorePhysicsTable   ";
820            << " Store material and cut values  << 595     G4cout << " Store material and cut values successfully" << G4endl;
821   }                                               596   }
822 #endif                                            597 #endif
823                                                   598 
824   G4bool success = true;                       << 599   G4bool success= true;
825                                                   600 
826   // loop over all particles in G4ParticleTabl << 601   // loop over all particles in G4ParticleTable 
827   theParticleIterator->reset();                   602   theParticleIterator->reset();
828   while ((*theParticleIterator)()) {           << 603   while( (*theParticleIterator)() ){
829     G4ParticleDefinition* particle = thePartic    604     G4ParticleDefinition* particle = theParticleIterator->value();
830     // Store physics tables for every process     605     // Store physics tables for every process for this particle type
831     G4ProcessVector* pVector = (particle->GetP    606     G4ProcessVector* pVector = (particle->GetProcessManager())->GetProcessList();
832     for (G4int j = 0; j < (G4int)pVector->size << 607     G4int  j;
833       if (!(*pVector)[j]->StorePhysicsTable(pa << 608     for ( j=0; j < pVector->size(); ++j) {
834         G4String comment = "Fail to store phys << 609       if (!(*pVector)[j]->StorePhysicsTable(particle,dir,ascii)){   
835         comment += (*pVector)[j]->GetProcessNa << 610   G4String comment =  "Fail to store for " + (*pVector)[j]->GetProcessName();
836         comment += "(" + particle->GetParticle << 611   comment += "(" + particle->GetParticleName()  + ")";
837         G4Exception("G4VUserPhysicsList::Store << 612   G4Exception("G4VUserPhysicsList::StorePhysicsTable","Faile to store ",
838         success = false;                       << 613         JustWarning,comment);   
                                                   >> 614   success = false;
839       }                                           615       }
840     }                                             616     }
841     // end loop over processes                    617     // end loop over processes
842   }                                               618   }
843   // end loop over particles                      619   // end loop over particles
844   return success;                                 620   return success;
845 }                                                 621 }
846                                                   622 
847 // ------------------------------------------- << 623 
848 void G4VUserPhysicsList::SetPhysicsTableRetrie << 624 
                                                   >> 625 ///////////////////////////////////////////////////////////////
                                                   >> 626 void  G4VUserPhysicsList::SetPhysicsTableRetrieved(const G4String& directory)
849 {                                                 627 {
850   fRetrievePhysicsTable = true;                   628   fRetrievePhysicsTable = true;
851   if (!directory.empty()) {                    << 629   if(!directory.isNull()) {
852     directoryPhysicsTable = directory;            630     directoryPhysicsTable = directory;
853   }                                               631   }
854   fIsCheckedForRetrievePhysicsTable = false;   << 632   fIsCheckedForRetrievePhysicsTable=false;
855   fIsRestoredCutValues = false;                   633   fIsRestoredCutValues = false;
856 }                                                 634 }
857                                                   635 
858 // ------------------------------------------- << 636 ///////////////////////////////////////////////////////////////
859 void G4VUserPhysicsList::RetrievePhysicsTable( << 637 void G4VUserPhysicsList::RetrievePhysicsTable(G4ParticleDefinition* particle, 
860                                                << 638                 const G4String& directory,
                                                   >> 639                 G4bool          ascii)
861 {                                                 640 {
862   G4bool success[100];                         << 641   G4int  j;
                                                   >> 642   G4bool success[100];  
863   // Retrieve physics tables for every process    643   // Retrieve physics tables for every process for this particle type
864   G4ProcessVector* pVector = (particle->GetPro    644   G4ProcessVector* pVector = (particle->GetProcessManager())->GetProcessList();
865   for (G4int j = 0; j < (G4int)pVector->size() << 645   for ( j=0; j < pVector->size(); ++j) {
866     success[j] = (*pVector)[j]->RetrievePhysic << 646     success[j] = 
                                                   >> 647        (*pVector)[j]->RetrievePhysicsTable(particle,directory,ascii);
867                                                   648 
868     if (!success[j]) {                            649     if (!success[j]) {
869 #ifdef G4VERBOSE                               << 650 #ifdef G4VERBOSE  
870       if (verboseLevel > 2) {                  << 651       if (verboseLevel>2){
871         G4cout << "G4VUserPhysicsList::Retriev << 652   G4cout << "G4VUserPhysicsList::RetrievePhysicsTable   ";
872                << " Fail to retrieve Physics T << 653   G4cout << " Fail to retrieve Physics Table for ";
873                << G4endl;                      << 654         G4cout << (*pVector)[j]->GetProcessName() << G4endl;
874         G4cout << "Calculate Physics Table for << 655   G4cout << "Calculate Physics Table for " << particle->GetParticleName() << G4endl;
875       }                                           656       }
876 #endif                                            657 #endif
877       (*pVector)[j]->BuildPhysicsTable(*partic    658       (*pVector)[j]->BuildPhysicsTable(*particle);
878     }                                             659     }
879   }                                               660   }
880   for (G4int j = 0; j < (G4int)pVector->size() << 661   for ( j=0; j < pVector->size(); ++j) {
881     // temporary addition to make the integral    662     // temporary addition to make the integral schema
882     if (!success[j]) BuildIntegralPhysicsTable << 663     if (!success[j]) BuildIntegralPhysicsTable((*pVector)[j], particle); 
883   }                                               664   }
884 }                                                 665 }
885                                                   666 
886 // ------------------------------------------- << 667 void G4VUserPhysicsList::ResetCuts()
                                                   >> 668 {
                                                   >> 669 #ifdef G4VERBOSE  
                                                   >> 670   if (verboseLevel>0){
                                                   >> 671     G4cout << "G4VUserPhysicsList::ResetCuts() is obsolete.";
                                                   >> 672     G4cout << " This method gives no effect and you can remove it. "<< G4endl;
                                                   >> 673   }
                                                   >> 674 #endif
                                                   >> 675 }
                                                   >> 676 
887 void G4VUserPhysicsList::SetApplyCuts(G4bool v    677 void G4VUserPhysicsList::SetApplyCuts(G4bool value, const G4String& name)
888 {                                                 678 {
889 #ifdef G4VERBOSE                               << 679 #ifdef G4VERBOSE  
890   if (verboseLevel > 2) {                      << 680   if (verboseLevel>2){
891     G4cout << "G4VUserPhysicsList::SetApplyCut    681     G4cout << "G4VUserPhysicsList::SetApplyCuts for " << name << G4endl;
892   }                                               682   }
893 #endif                                            683 #endif
894   if (name == "all") {                         << 684   if(name=="all") {
895     theParticleTable->FindParticle("gamma")->S    685     theParticleTable->FindParticle("gamma")->SetApplyCutsFlag(value);
896     theParticleTable->FindParticle("e-")->SetA    686     theParticleTable->FindParticle("e-")->SetApplyCutsFlag(value);
897     theParticleTable->FindParticle("e+")->SetA    687     theParticleTable->FindParticle("e+")->SetApplyCutsFlag(value);
898     theParticleTable->FindParticle("proton")-> << 688   } else {
899   }                                            << 
900   else {                                       << 
901     theParticleTable->FindParticle(name)->SetA    689     theParticleTable->FindParticle(name)->SetApplyCutsFlag(value);
902   }                                               690   }
903 }                                                 691 }
904                                                   692 
905 // ------------------------------------------- << 
906 G4bool G4VUserPhysicsList::GetApplyCuts(const     693 G4bool G4VUserPhysicsList::GetApplyCuts(const G4String& name) const
907 {                                                 694 {
908   return theParticleTable->FindParticle(name)-    695   return theParticleTable->FindParticle(name)->GetApplyCutsFlag();
909 }                                                 696 }
910                                                   697 
911 // ------------------------------------------- << 
912 void G4VUserPhysicsList::CheckParticleList()   << 
913 {                                              << 
914   if (!fDisableCheckParticleList) {            << 
915     G4MT_thePLHelper->CheckParticleList();     << 
916   }                                            << 
917 }                                              << 
918                                                   698 
919 // ------------------------------------------- << 
920 void G4VUserPhysicsList::AddTransportation()   << 
921 {                                              << 
922   G4MT_thePLHelper->AddTransportation();       << 
923 }                                              << 
924                                                   699 
925 // ------------------------------------------- << 
926 void G4VUserPhysicsList::UseCoupledTransportat << 
927 {                                              << 
928   G4MT_thePLHelper->UseCoupledTransportation(v << 
929 }                                              << 
930                                                   700 
931 // ------------------------------------------- << 701 /// obsolete methods
932 G4bool G4VUserPhysicsList::RegisterProcess(G4V << 
933 {                                              << 
934   return G4MT_thePLHelper->RegisterProcess(pro << 
935 }                                              << 
936                                                   702 
937 // ------------------------------------------- << 703 
938 G4ParticleTable::G4PTblDicIterator* G4VUserPhy << 704 void G4VUserPhysicsList::DumpCutValues(const G4String &particle_name)
939 {                                                 705 {
940   return (subInstanceManager.offset[g4vuplInst << 706   G4cerr << "WARNING !" << G4endl;
                                                   >> 707   G4cerr << " Obsolete DumpCutValues() method is invoked for " << particle_name << G4endl;
                                                   >> 708   G4cerr << " Please use DumpCutValuesTable() instead." << G4endl;
                                                   >> 709   G4cerr << " This dummy method implementation will be removed soon." << G4endl;
                                                   >> 710   DumpCutValuesTable();
941 }                                                 711 }
942                                                   712 
943 // ------------------------------------------- << 713 void G4VUserPhysicsList::DumpCutValues(G4ParticleDefinition* )
944 void G4VUserPhysicsList::SetVerboseLevel(G4int << 
945 {                                                 714 {
946   verboseLevel = value;                        << 715   G4cerr << "WARNING !" << G4endl;
947   // set verboseLevel for G4ProductionCutsTabl << 716   G4cerr << " DumpCutValues() became obsolete." << G4endl;
948   // G4VUserPhysicsList:                       << 717   G4cerr << " Please use DumpCutValuesTable() instead." << G4endl;
949   fCutsTable->SetVerboseLevel(verboseLevel);   << 718   G4cerr << " This dummy method implementation will be removed soon." << G4endl;
950                                                << 719   DumpCutValuesTable();
951   G4MT_thePLHelper->SetVerboseLevel(verboseLev << 
952                                                << 
953 #ifdef G4VERBOSE                               << 
954   if (verboseLevel > 1) {                      << 
955     G4cout << "G4VUserPhysicsList::SetVerboseL << 
956            << " Verbose level is set to " << v << 
957   }                                            << 
958 #endif                                         << 
959 }                                                 720 }
960                                                   721