Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/examples/advanced/underground_physics/src/DMXPhysicsList.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 /examples/advanced/underground_physics/src/DMXPhysicsList.cc (Version 11.3.0) and /examples/advanced/underground_physics/src/DMXPhysicsList.cc (Version 10.0.p4)


  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 //                                                 26 //
 27 // -------------------------------------------     27 // --------------------------------------------------------------
 28 //   GEANT 4 - Underground Dark Matter Detecto     28 //   GEANT 4 - Underground Dark Matter Detector Advanced Example
 29 //                                                 29 //
 30 //      For information related to this code c     30 //      For information related to this code contact: Alex Howard
 31 //      e-mail: alexander.howard@cern.ch           31 //      e-mail: alexander.howard@cern.ch
 32 // -------------------------------------------     32 // --------------------------------------------------------------
 33 // Comments                                        33 // Comments
 34 //                                                 34 //
 35 //                  Underground Advanced           35 //                  Underground Advanced
 36 //               by A. Howard and H. Araujo        36 //               by A. Howard and H. Araujo 
 37 //                    (27th November 2001)         37 //                    (27th November 2001)
 38 //                                                 38 //
 39 // PhysicsList program                             39 // PhysicsList program
 40 //                                                 40 //
 41 // Modified:                                       41 // Modified:
 42 //                                                 42 //
 43 // 14-02-03 Fix bugs in msc and hIon instancia     43 // 14-02-03 Fix bugs in msc and hIon instanciation + cut per region
 44 //                                                 44 //
 45 // 05-02-05 AH - changes to G4Decay - added is     45 // 05-02-05 AH - changes to G4Decay - added is not short lived protection
 46 //          and redefined particles to allow n     46 //          and redefined particles to allow non-static creation
 47 //          i.e. changed construction to G4Mes     47 //          i.e. changed construction to G4MesonConstructor, G4BaryonConstructor
 48 //                                                 48 // 
 49 // 23-10-09 LP - migrated EM physics from the      49 // 23-10-09 LP - migrated EM physics from the LowEnergy processes (not supported) to 
 50 //          the new G4Livermore model implemen     50 //          the new G4Livermore model implementation. Results unchanged.
 51 //                                                 51 //
 52 // -------------------------------------------     52 // --------------------------------------------------------------
 53                                                    53 
 54 #include <iomanip>                                 54 #include <iomanip>  
 55                                                    55 
 56 #include "DMXPhysicsList.hh"                       56 #include "DMXPhysicsList.hh"
 57                                                    57 
 58 #include "globals.hh"                              58 #include "globals.hh"
 59 #include "G4SystemOfUnits.hh"                      59 #include "G4SystemOfUnits.hh"
 60 #include "G4ProcessManager.hh"                     60 #include "G4ProcessManager.hh"
 61 #include "G4ProcessVector.hh"                      61 #include "G4ProcessVector.hh"
 62                                                    62 
 63 #include "G4ParticleDefinition.hh"                 63 #include "G4ParticleDefinition.hh"
 64 #include "G4ParticleWithCuts.hh"                   64 #include "G4ParticleWithCuts.hh"
 65 #include "G4ParticleTypes.hh"                      65 #include "G4ParticleTypes.hh"
 66 #include "G4ParticleTable.hh"                      66 #include "G4ParticleTable.hh"
 67                                                    67 
 68 #include "G4ios.hh"                                68 #include "G4ios.hh"
 69 #include "G4UserLimits.hh"                         69 #include "G4UserLimits.hh"
 70                                                    70 
 71 #include "G4MesonConstructor.hh"               << 
 72 #include "G4BaryonConstructor.hh"              << 
 73 #include "G4IonConstructor.hh"                 << 
 74 #include "G4ShortLivedConstructor.hh"          << 
 75                                                << 
 76 #include "DMXMaxTimeCuts.hh"                   << 
 77 #include "DMXMinEkineCuts.hh"                  << 
 78 #include "G4StepLimiter.hh"                    << 
 79                                                << 
 80 // gamma                                       << 
 81 #include "G4PhotoElectricEffect.hh"            << 
 82 #include "G4LivermorePhotoElectricModel.hh"    << 
 83                                                << 
 84 #include "G4ComptonScattering.hh"              << 
 85 #include "G4LivermoreComptonModel.hh"          << 
 86                                                << 
 87 #include "G4GammaConversion.hh"                << 
 88 #include "G4BetheHeitler5DModel.hh"            << 
 89                                                << 
 90 #include "G4RayleighScattering.hh"             << 
 91 #include "G4LivermoreRayleighModel.hh"         << 
 92                                                << 
 93 // e-                                          << 
 94 #include "G4eMultipleScattering.hh"            << 
 95                                                << 
 96 #include "G4eIonisation.hh"                    << 
 97 #include "G4LivermoreIonisationModel.hh"       << 
 98                                                << 
 99 #include "G4eBremsstrahlung.hh"                << 
100 #include "G4UniversalFluctuation.hh"           << 
101                                                << 
102 // e+                                          << 
103 #include "G4eIonisation.hh"                    << 
104 #include "G4eBremsstrahlung.hh"                << 
105 #include "G4eplusAnnihilation.hh"              << 
106                                                << 
107 // alpha and GenericIon and deuterons, triton, << 
108 //muon:                                        << 
109 #include "G4MuIonisation.hh"                   << 
110 #include "G4MuBremsstrahlung.hh"               << 
111 #include "G4MuPairProduction.hh"               << 
112 #include "G4MuMultipleScattering.hh"           << 
113 #include "G4MuonMinusCapture.hh"               << 
114                                                << 
115 //OTHERS:                                      << 
116 #include "G4hIonisation.hh"                    << 
117 #include "G4hMultipleScattering.hh"            << 
118 #include "G4hBremsstrahlung.hh"                << 
119 #include "G4ionIonisation.hh"                  << 
120 #include "G4IonParametrisedLossModel.hh"       << 
121 #include "G4NuclearStopping.hh"                << 
122                                                << 
123 //em process options to allow msc step-limitat << 
124 #include "G4EmParameters.hh"                   << 
125 #include "G4VAtomDeexcitation.hh"              << 
126 #include "G4UAtomicDeexcitation.hh"            << 
127 #include "G4LossTableManager.hh"               << 
128                                                << 
129 #include "G4Scintillation.hh"                  << 
130 #include "G4OpAbsorption.hh"                   << 
131 #include "G4OpBoundaryProcess.hh"              << 
132 #include "G4OpticalParameters.hh"              << 
133                                                << 
134 // Elastic processes:                          << 
135 #include "G4HadronElasticProcess.hh"           << 
136 #include "G4ChipsElasticModel.hh"              << 
137 #include "G4ElasticHadrNucleusHE.hh"           << 
138                                                << 
139 // Inelastic processes:                        << 
140 #include "G4HadronInelasticProcess.hh"         << 
141                                                << 
142 // High energy FTFP model and Bertini cascade  << 
143 #include "G4FTFModel.hh"                       << 
144 #include "G4LundStringFragmentation.hh"        << 
145 #include "G4ExcitedStringDecay.hh"             << 
146 #include "G4PreCompoundModel.hh"               << 
147 #include "G4GeneratorPrecompoundInterface.hh"  << 
148 #include "G4TheoFSGenerator.hh"                << 
149 #include "G4CascadeInterface.hh"               << 
150                                                << 
151 // Cross sections                              << 
152 #include "G4VCrossSectionDataSet.hh"           << 
153 #include "G4CrossSectionDataSetRegistry.hh"    << 
154                                                << 
155 #include "G4CrossSectionElastic.hh"            << 
156 #include "G4CrossSectionInelastic.hh"          << 
157 #include "G4BGGPionElasticXS.hh"               << 
158 #include "G4BGGPionInelasticXS.hh"             << 
159 #include "G4AntiNuclElastic.hh"                << 
160                                                << 
161 #include "G4CrossSectionInelastic.hh"          << 
162 #include "G4BGGNucleonInelasticXS.hh"          << 
163 #include "G4BGGNucleonElasticXS.hh"            << 
164 #include "G4NeutronInelasticXS.hh"             << 
165 #include "G4NeutronElasticXS.hh"               << 
166 #include "G4ComponentAntiNuclNuclearXS.hh"     << 
167 #include "G4ComponentGGNuclNuclXsc.hh"         << 
168 #include "G4ComponentGGHadronNucleusXsc.hh"    << 
169                                                << 
170 #include "G4HadronElastic.hh"                  << 
171 #include "G4NeutronCaptureProcess.hh"          << 
172                                                << 
173 // Neutron high-precision models: <20 MeV      << 
174 #include "G4ParticleHPElastic.hh"              << 
175 #include "G4ParticleHPElasticData.hh"          << 
176 #include "G4ParticleHPCapture.hh"              << 
177 #include "G4ParticleHPCaptureData.hh"          << 
178 #include "G4ParticleHPInelastic.hh"            << 
179 #include "G4ParticleHPInelasticData.hh"        << 
180                                                << 
181 // Stopping processes                          << 
182 #include "G4HadronStoppingProcess.hh"          << 
183 #include "G4HadronicAbsorptionBertini.hh"      << 
184 #include "G4HadronicAbsorptionFritiof.hh"      << 
185                                                << 
186 #include "G4HadronicParameters.hh"             << 
187                                                << 
188 #include "G4Decay.hh"                          << 
189 #include "G4RadioactiveDecay.hh"               << 
190 #include "G4PhysicsListHelper.hh"              << 
191 #include "G4NuclideTable.hh"                   << 
192 #include "G4NuclearLevelData.hh"               << 
193                                                << 
194 // Constructor ///////////////////////////////     71 // Constructor /////////////////////////////////////////////////////////////
195 DMXPhysicsList::DMXPhysicsList() : G4VUserPhys     72 DMXPhysicsList::DMXPhysicsList() : G4VUserPhysicsList() 
196 {                                                  73 {
197                                                    74 
198   defaultCutValue     = 1.0*micrometer; //         75   defaultCutValue     = 1.0*micrometer; //
199   cutForGamma         = defaultCutValue;           76   cutForGamma         = defaultCutValue;
200   cutForElectron      = 1.0*nanometer;             77   cutForElectron      = 1.0*nanometer;
201   cutForPositron      = defaultCutValue;           78   cutForPositron      = defaultCutValue;
202                                                    79 
203   VerboseLevel = 1;                                80   VerboseLevel = 1;
204   OpVerbLevel = 0;                                 81   OpVerbLevel = 0;
205                                                    82 
206   //set a finer grid of the physic tables in o << 
207   //former LowEnergy models have 200 bins up t << 
208   G4EmParameters* param = G4EmParameters::Inst << 
209   param->SetMaxEnergy(100*GeV);                << 
210   param->SetNumberOfBinsPerDecade(20);         << 
211   param->SetMscStepLimitType(fMinimal);        << 
212   param->SetFluo(true);                        << 
213   param->SetPixe(true);                        << 
214   param->SetAuger(true);                       << 
215                                                << 
216   G4EmParameters::Instance()->AddPhysics("Worl << 
217   G4DeexPrecoParameters* deex = G4NuclearLevel << 
218   deex->SetStoreICLevelData(true);             << 
219   deex->SetMaxLifeTime(G4NuclideTable::GetInst << 
220                        /std::log(2.));         << 
221   SetVerboseLevel(VerboseLevel);                   83   SetVerboseLevel(VerboseLevel);
222 }                                                  84 }
223                                                    85 
                                                   >>  86 
224 // Destructor ////////////////////////////////     87 // Destructor //////////////////////////////////////////////////////////////
225 DMXPhysicsList::~DMXPhysicsList()                  88 DMXPhysicsList::~DMXPhysicsList() 
226 {;}                                                89 {;}
227                                                    90 
                                                   >>  91 
228 // Construct Particles ///////////////////////     92 // Construct Particles /////////////////////////////////////////////////////
229 void DMXPhysicsList::ConstructParticle()           93 void DMXPhysicsList::ConstructParticle() 
230 {                                                  94 {
                                                   >>  95 
231   // In this method, static member functions s     96   // In this method, static member functions should be called
232   // for all particles which you want to use.      97   // for all particles which you want to use.
233   // This ensures that objects of these partic     98   // This ensures that objects of these particle types will be
234   // created in the program.                       99   // created in the program. 
235                                                   100 
236   ConstructMyBosons();                            101   ConstructMyBosons();
237   ConstructMyLeptons();                           102   ConstructMyLeptons();
238   ConstructMyHadrons();                           103   ConstructMyHadrons();
239   ConstructMyShortLiveds();                       104   ConstructMyShortLiveds();
                                                   >> 105 
240 }                                                 106 }
241                                                   107 
                                                   >> 108 
242 // construct Bosons://////////////////////////    109 // construct Bosons://///////////////////////////////////////////////////
243 void DMXPhysicsList::ConstructMyBosons()          110 void DMXPhysicsList::ConstructMyBosons()
244 {                                                 111 {
245   // pseudo-particles                             112   // pseudo-particles
246   G4Geantino::GeantinoDefinition();               113   G4Geantino::GeantinoDefinition();
247   G4ChargedGeantino::ChargedGeantinoDefinition    114   G4ChargedGeantino::ChargedGeantinoDefinition();
248                                                   115   
249   // gamma                                        116   // gamma
250   G4Gamma::GammaDefinition();                     117   G4Gamma::GammaDefinition();
251                                                   118 
252   //OpticalPhotons                                119   //OpticalPhotons
253   G4OpticalPhoton::OpticalPhotonDefinition();     120   G4OpticalPhoton::OpticalPhotonDefinition();
254                                                   121 
255 }                                                 122 }
256                                                   123 
                                                   >> 124 
257 // construct Leptons://///////////////////////    125 // construct Leptons://///////////////////////////////////////////////////
258 void DMXPhysicsList::ConstructMyLeptons()         126 void DMXPhysicsList::ConstructMyLeptons()
259 {                                                 127 {
260   // leptons                                      128   // leptons
261   G4Electron::ElectronDefinition();               129   G4Electron::ElectronDefinition();
262   G4Positron::PositronDefinition();               130   G4Positron::PositronDefinition();
263   G4MuonPlus::MuonPlusDefinition();               131   G4MuonPlus::MuonPlusDefinition();
264   G4MuonMinus::MuonMinusDefinition();             132   G4MuonMinus::MuonMinusDefinition();
265                                                   133 
266   G4NeutrinoE::NeutrinoEDefinition();             134   G4NeutrinoE::NeutrinoEDefinition();
267   G4AntiNeutrinoE::AntiNeutrinoEDefinition();     135   G4AntiNeutrinoE::AntiNeutrinoEDefinition();
268   G4NeutrinoMu::NeutrinoMuDefinition();           136   G4NeutrinoMu::NeutrinoMuDefinition();
269   G4AntiNeutrinoMu::AntiNeutrinoMuDefinition()    137   G4AntiNeutrinoMu::AntiNeutrinoMuDefinition();
270 }                                                 138 }
271                                                   139 
                                                   >> 140 
                                                   >> 141 #include "G4MesonConstructor.hh"
                                                   >> 142 #include "G4BaryonConstructor.hh"
                                                   >> 143 #include "G4IonConstructor.hh"
                                                   >> 144 
272 // construct Hadrons://///////////////////////    145 // construct Hadrons://///////////////////////////////////////////////////
273 void DMXPhysicsList::ConstructMyHadrons()         146 void DMXPhysicsList::ConstructMyHadrons()
274 {                                                 147 {
275  //  mesons                                       148  //  mesons
276   G4MesonConstructor mConstructor;                149   G4MesonConstructor mConstructor;
277   mConstructor.ConstructParticle();               150   mConstructor.ConstructParticle();
278                                                   151 
279  //  baryons                                      152  //  baryons
280   G4BaryonConstructor bConstructor;               153   G4BaryonConstructor bConstructor;
281   bConstructor.ConstructParticle();               154   bConstructor.ConstructParticle();
282                                                   155 
283  //  ions                                         156  //  ions
284   G4IonConstructor iConstructor;                  157   G4IonConstructor iConstructor;
285   iConstructor.ConstructParticle();               158   iConstructor.ConstructParticle();
                                                   >> 159 
286 }                                                 160 }
287                                                   161 
                                                   >> 162 
288 // construct Shortliveds://///////////////////    163 // construct Shortliveds://///////////////////////////////////////////////////
289 void DMXPhysicsList::ConstructMyShortLiveds()     164 void DMXPhysicsList::ConstructMyShortLiveds()
290 {                                                 165 {
291   G4ShortLivedConstructor slConstructor;       << 166   // ShortLiveds
292   slConstructor.ConstructParticle();           << 167   ;
293 }                                                 168 }
294                                                   169 
                                                   >> 170 
                                                   >> 171 
                                                   >> 172 
295 // Construct Processes ///////////////////////    173 // Construct Processes //////////////////////////////////////////////////////
296 void DMXPhysicsList::ConstructProcess()           174 void DMXPhysicsList::ConstructProcess() 
297 {                                                 175 {
                                                   >> 176 
298   AddTransportation();                            177   AddTransportation();
299                                                   178 
300   ConstructEM();                                  179   ConstructEM();
301                                                   180 
302   ConstructOp();                                  181   ConstructOp();
303                                                   182 
304   ConstructHad();                                 183   ConstructHad();
305                                                   184 
306   ConstructGeneral();                             185   ConstructGeneral();
                                                   >> 186 
307 }                                                 187 }
308                                                   188 
                                                   >> 189 
309 // Transportation ////////////////////////////    190 // Transportation ///////////////////////////////////////////////////////////
                                                   >> 191 #include "DMXMaxTimeCuts.hh"
                                                   >> 192 #include "DMXMinEkineCuts.hh"
                                                   >> 193 #include "G4StepLimiter.hh"
                                                   >> 194 
310 void DMXPhysicsList::AddTransportation() {        195 void DMXPhysicsList::AddTransportation() {
311                                                   196   
312   G4VUserPhysicsList::AddTransportation();        197   G4VUserPhysicsList::AddTransportation();
313                                                   198   
314   auto particleIterator=GetParticleIterator(); << 199   theParticleIterator->reset();
315   particleIterator->reset();                   << 200   while( (*theParticleIterator)() ){
316   while( (*particleIterator)() ){              << 201     G4ParticleDefinition* particle = theParticleIterator->value();
317     G4ParticleDefinition* particle = particleI << 
318     G4ProcessManager* pmanager = particle->Get    202     G4ProcessManager* pmanager = particle->GetProcessManager();
319     G4String particleName = particle->GetParti    203     G4String particleName = particle->GetParticleName();
320     // time cuts for ONLY neutrons:               204     // time cuts for ONLY neutrons:
321     if(particleName == "neutron")                 205     if(particleName == "neutron") 
322       pmanager->AddDiscreteProcess(new DMXMaxT    206       pmanager->AddDiscreteProcess(new DMXMaxTimeCuts());
323     // Energy cuts to kill charged (embedded i    207     // Energy cuts to kill charged (embedded in method) particles:
324     pmanager->AddDiscreteProcess(new DMXMinEki    208     pmanager->AddDiscreteProcess(new DMXMinEkineCuts());
325                                                   209 
326     // Step limit applied to all particles:       210     // Step limit applied to all particles:
327     pmanager->AddDiscreteProcess(new G4StepLim << 211     pmanager->AddProcess(new G4StepLimiter,       -1,-1,1);
                                                   >> 212 
328   }                                               213   }         
329 }                                                 214 }
330                                                   215 
                                                   >> 216 
331 // Electromagnetic Processes /////////////////    217 // Electromagnetic Processes ////////////////////////////////////////////////
332 // all charged particles                          218 // all charged particles
333 void DMXPhysicsList::ConstructEM() {           << 
334                                                << 
335   G4LossTableManager* man = G4LossTableManager << 
336   man->SetAtomDeexcitation(new G4UAtomicDeexci << 
337                                                   219 
338   G4EmParameters* em_params = G4EmParameters:: << 220 // gamma
                                                   >> 221 #include "G4PhotoElectricEffect.hh"
                                                   >> 222 #include "G4LivermorePhotoElectricModel.hh"
                                                   >> 223 
                                                   >> 224 #include "G4ComptonScattering.hh"
                                                   >> 225 #include "G4LivermoreComptonModel.hh"
                                                   >> 226 
                                                   >> 227 #include "G4GammaConversion.hh"
                                                   >> 228 #include "G4LivermoreGammaConversionModel.hh"
                                                   >> 229 
                                                   >> 230 #include "G4RayleighScattering.hh" 
                                                   >> 231 #include "G4LivermoreRayleighModel.hh"
                                                   >> 232 
                                                   >> 233 
                                                   >> 234 // e-
                                                   >> 235 #include "G4eMultipleScattering.hh"
                                                   >> 236 
                                                   >> 237 #include "G4eIonisation.hh"
                                                   >> 238 #include "G4LivermoreIonisationModel.hh"
                                                   >> 239 
                                                   >> 240 #include "G4eBremsstrahlung.hh"
                                                   >> 241 #include "G4LivermoreBremsstrahlungModel.hh"
                                                   >> 242 
                                                   >> 243 
                                                   >> 244 // e+
                                                   >> 245 #include "G4eIonisation.hh" 
                                                   >> 246 #include "G4eBremsstrahlung.hh" 
                                                   >> 247 #include "G4eplusAnnihilation.hh"
                                                   >> 248 
                                                   >> 249 
                                                   >> 250 // alpha and GenericIon and deuterons, triton, He3:
                                                   >> 251 
                                                   >> 252 //muon:
                                                   >> 253 #include "G4MuIonisation.hh"
                                                   >> 254 #include "G4MuBremsstrahlung.hh"
                                                   >> 255 #include "G4MuPairProduction.hh"
                                                   >> 256 #include "G4MuonMinusCaptureAtRest.hh"
                                                   >> 257 
                                                   >> 258 //OTHERS:
                                                   >> 259 #include "G4hIonisation.hh" 
                                                   >> 260 #include "G4hMultipleScattering.hh"
                                                   >> 261 #include "G4hBremsstrahlung.hh"
                                                   >> 262 #include "G4ionIonisation.hh"
                                                   >> 263 #include "G4IonParametrisedLossModel.hh"
                                                   >> 264 
                                                   >> 265 //em process options to allow msc step-limitation to be switched off
                                                   >> 266 #include "G4EmProcessOptions.hh"
                                                   >> 267 
                                                   >> 268 void DMXPhysicsList::ConstructEM() {
339                                                   269   
340   auto particleIterator=GetParticleIterator(); << 270   //set a finer grid of the physic tables in order to improve precision
341   particleIterator->reset();                   << 271   //former LowEnergy models have 200 bins up to 100 GeV
342   while( (*particleIterator)() ){              << 272   G4EmProcessOptions opt;
343     G4ParticleDefinition* particle = particleI << 273   opt.SetMaxEnergy(100*GeV);
                                                   >> 274   opt.SetDEDXBinning(200);
                                                   >> 275   opt.SetLambdaBinning(200);
                                                   >> 276 
                                                   >> 277   theParticleIterator->reset();
                                                   >> 278   while( (*theParticleIterator)() ){
                                                   >> 279     G4ParticleDefinition* particle = theParticleIterator->value();
344     G4ProcessManager* pmanager = particle->Get    280     G4ProcessManager* pmanager = particle->GetProcessManager();
345     G4String particleName = particle->GetParti    281     G4String particleName = particle->GetParticleName();
346     G4String particleType = particle->GetParti    282     G4String particleType = particle->GetParticleType();
347     G4double charge = particle->GetPDGCharge()    283     G4double charge = particle->GetPDGCharge();
348                                                   284     
349     if (particleName == "gamma")                  285     if (particleName == "gamma") 
350       {                                           286       {
351   //gamma                                         287   //gamma
352   G4RayleighScattering* theRayleigh = new G4Ra    288   G4RayleighScattering* theRayleigh = new G4RayleighScattering();
                                                   >> 289   theRayleigh->SetEmModel(new G4LivermoreRayleighModel());  //not strictly necessary
353   pmanager->AddDiscreteProcess(theRayleigh);      290   pmanager->AddDiscreteProcess(theRayleigh);
354                                                   291 
355   G4PhotoElectricEffect* thePhotoElectricEffec    292   G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
356   thePhotoElectricEffect->SetEmModel(new G4Liv    293   thePhotoElectricEffect->SetEmModel(new G4LivermorePhotoElectricModel());
357   pmanager->AddDiscreteProcess(thePhotoElectri    294   pmanager->AddDiscreteProcess(thePhotoElectricEffect);
358                                                   295   
359   G4ComptonScattering* theComptonScattering =     296   G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
360   theComptonScattering->SetEmModel(new G4Liver    297   theComptonScattering->SetEmModel(new G4LivermoreComptonModel());
361   pmanager->AddDiscreteProcess(theComptonScatt    298   pmanager->AddDiscreteProcess(theComptonScattering);
362                                                   299   
363   G4GammaConversion* theGammaConversion = new     300   G4GammaConversion* theGammaConversion = new G4GammaConversion();
364   theGammaConversion->SetEmModel(new G4BetheHe << 301   theGammaConversion->SetEmModel(new G4LivermoreGammaConversionModel());
365   pmanager->AddDiscreteProcess(theGammaConvers    302   pmanager->AddDiscreteProcess(theGammaConversion);
366                                                   303 
367       }                                           304       } 
368     else if (particleName == "e-")                305     else if (particleName == "e-") 
369       {                                           306       {
370   //electron                                      307   //electron
371   // process ordering: AddProcess(name, at res    308   // process ordering: AddProcess(name, at rest, along step, post step)
372   // Multiple scattering                          309   // Multiple scattering
373   G4eMultipleScattering* msc = new G4eMultiple    310   G4eMultipleScattering* msc = new G4eMultipleScattering();
374   em_params->SetMscStepLimitType(fUseDistanceT << 311   msc->SetStepLimitType(fUseDistanceToBoundary);
375   pmanager->AddProcess(msc,-1, 1, -1);         << 312   pmanager->AddProcess(msc,-1, 1, 1);
376                                                   313 
377   // Ionisation                                   314   // Ionisation
378   G4eIonisation* eIonisation = new G4eIonisati    315   G4eIonisation* eIonisation = new G4eIonisation();
379         G4VEmModel* theIoniLiv = new G4Livermo << 316   eIonisation->SetEmModel(new G4LivermoreIonisationModel());
380         theIoniLiv->SetHighEnergyLimit(0.1*MeV << 317   eIonisation->SetStepFunction(0.2, 100*um); //improved precision in tracking  
381         eIonisation->AddEmModel(0, theIoniLiv, << 318   pmanager->AddProcess(eIonisation,-1, 2, 2);
382   em_params->SetStepFunction(0.2, 100*um); //i << 
383   pmanager->AddProcess(eIonisation,-1, 2, 1);  << 
384                                                   319   
385   // Bremsstrahlung                               320   // Bremsstrahlung
386   G4eBremsstrahlung* eBremsstrahlung = new G4e    321   G4eBremsstrahlung* eBremsstrahlung = new G4eBremsstrahlung();
387   pmanager->AddProcess(eBremsstrahlung, -1,-3, << 322   eBremsstrahlung->SetEmModel(new G4LivermoreBremsstrahlungModel());
                                                   >> 323   pmanager->AddProcess(eBremsstrahlung, -1,-3, 3);
388       }                                           324       } 
389     else if (particleName == "e+")                325     else if (particleName == "e+") 
390       {                                           326       {
391   //positron                                      327   //positron  
392   G4eMultipleScattering* msc = new G4eMultiple    328   G4eMultipleScattering* msc = new G4eMultipleScattering();
393   msc->SetStepLimitType(fUseDistanceToBoundary    329   msc->SetStepLimitType(fUseDistanceToBoundary);
394   pmanager->AddProcess(msc,-1, 1, -1);         << 330   pmanager->AddProcess(msc,-1, 1, 1);
395                                                   331   
396   // Ionisation                                   332   // Ionisation
397   G4eIonisation* eIonisation = new G4eIonisati    333   G4eIonisation* eIonisation = new G4eIonisation();
398   // eIonisation->SetStepFunction(0.2, 100*um) << 334   eIonisation->SetStepFunction(0.2, 100*um); //     
399   pmanager->AddProcess(eIonisation,            << 335   pmanager->AddProcess(eIonisation,                 -1, 2, 2);
400                                                   336 
401   //Bremsstrahlung (use default, no low-energy    337   //Bremsstrahlung (use default, no low-energy available)
402   pmanager->AddProcess(new G4eBremsstrahlung() << 338   pmanager->AddProcess(new G4eBremsstrahlung(), -1,-1, 3);
403                                                   339 
404   //Annihilation                                  340   //Annihilation
405   pmanager->AddProcess(new G4eplusAnnihilation << 341   pmanager->AddProcess(new G4eplusAnnihilation(),0,-1, 4);      
406       }                                           342       } 
407     else if( particleName == "mu+" ||             343     else if( particleName == "mu+" || 
408        particleName == "mu-"    )                 344        particleName == "mu-"    ) 
409       {                                           345       {
410   //muon                                          346   //muon  
411   pmanager->AddProcess(new G4MuMultipleScatter << 347   pmanager->AddProcess(new G4eMultipleScattering,           -1, 1, 1);
412   pmanager->AddProcess(new G4MuIonisation(),   << 348   pmanager->AddProcess(new G4MuIonisation(),          -1, 2, 2);
413   pmanager->AddProcess(new G4MuBremsstrahlung( << 349   pmanager->AddProcess(new G4MuBremsstrahlung(),      -1,-1, 3);
414   pmanager->AddProcess(new G4MuPairProduction( << 350   pmanager->AddProcess(new G4MuPairProduction(),      -1,-1, 4);
415   if( particleName == "mu-" )                     351   if( particleName == "mu-" )
416     pmanager->AddProcess(new G4MuonMinusCaptur << 352     pmanager->AddProcess(new G4MuonMinusCaptureAtRest(), 0,-1,-1);
417       }                                           353       } 
418     else if (particleName == "proton" ||          354     else if (particleName == "proton" || 
419        particleName == "pi+" ||                   355        particleName == "pi+" || 
420        particleName == "pi-")                     356        particleName == "pi-")
421       {                                           357       {
422   //multiple scattering                           358   //multiple scattering
423   pmanager->AddProcess(new G4hMultipleScatteri << 359   pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
424                                                   360       
425   //ionisation                                    361   //ionisation
426   G4hIonisation* hIonisation = new G4hIonisati    362   G4hIonisation* hIonisation = new G4hIonisation();
427   em_params->SetStepFunctionMuHad(0.2, 50*um); << 363   hIonisation->SetStepFunction(0.2, 50*um);
428   pmanager->AddProcess(hIonisation,            << 364   pmanager->AddProcess(hIonisation,                     -1, 2, 2);      
429                                                   365   
430   //bremmstrahlung                                366   //bremmstrahlung
431   pmanager->AddProcess(new G4hBremsstrahlung,  << 367   pmanager->AddProcess(new G4hBremsstrahlung,     -1,-3, 3);
432       }                                           368       }
433     else if(particleName == "alpha"      ||       369     else if(particleName == "alpha"      ||
434        particleName == "deuteron"   ||            370        particleName == "deuteron"   ||
435        particleName == "triton"     ||            371        particleName == "triton"     ||
436        particleName == "He3")                     372        particleName == "He3")
437       {                                           373       {
438   //multiple scattering                           374   //multiple scattering
439   pmanager->AddProcess(new G4hMultipleScatteri << 375   pmanager->AddProcess(new G4hMultipleScattering,-1,1,1);
440                                                   376   
441   //ionisation                                    377   //ionisation
442   G4ionIonisation* ionIoni = new G4ionIonisati    378   G4ionIonisation* ionIoni = new G4ionIonisation();
443   em_params->SetStepFunctionLightIons(0.1, 1*C << 379   ionIoni->SetStepFunction(0.1, 20*um);
444   pmanager->AddProcess(ionIoni,                << 380   pmanager->AddProcess(ionIoni,                   -1, 2, 2);
445   pmanager->AddProcess(new G4NuclearStopping() << 
446       }                                           381       }
447     else if (particleName == "GenericIon")        382     else if (particleName == "GenericIon")
448       {                                           383       {
449   // OBJECT may be dynamically created as eith    384   // OBJECT may be dynamically created as either a GenericIon or nucleus
450   // G4Nucleus exists and therefore has partic    385   // G4Nucleus exists and therefore has particle type nucleus
451   // genericIon:                                  386   // genericIon:
452                                                   387   
453   //multiple scattering                           388   //multiple scattering
454   pmanager->AddProcess(new G4hMultipleScatteri << 389   pmanager->AddProcess(new G4hMultipleScattering,-1,1,1);
455                                                   390 
456   //ionisation                                    391   //ionisation
457   G4ionIonisation* ionIoni = new G4ionIonisati    392   G4ionIonisation* ionIoni = new G4ionIonisation();
458   em_params->SetStepFunctionIons(0.1, 1*CLHEP: << 393   ionIoni->SetEmModel(new G4IonParametrisedLossModel());
459   pmanager->AddProcess(ionIoni,                << 394   ionIoni->SetStepFunction(0.1, 20*um);
460   pmanager->AddProcess(new G4NuclearStopping() << 395   pmanager->AddProcess(ionIoni,                   -1, 2, 2);
461       }                                           396       } 
462                                                   397 
463     else if ((!particle->IsShortLived()) &&       398     else if ((!particle->IsShortLived()) &&
464        (charge != 0.0) &&                         399        (charge != 0.0) && 
465        (particle->GetParticleName() != "charge    400        (particle->GetParticleName() != "chargedgeantino")) 
466       {                                           401       {
467   //all others charged particles except geanti    402   //all others charged particles except geantino
468         G4hMultipleScattering* aMultipleScatte    403         G4hMultipleScattering* aMultipleScattering = new G4hMultipleScattering();
469         G4hIonisation* ahadronIon = new G4hIon    404         G4hIonisation* ahadronIon = new G4hIonisation();
470                                                   405   
471   //multiple scattering                           406   //multiple scattering
472   pmanager->AddProcess(aMultipleScattering,-1, << 407   pmanager->AddProcess(aMultipleScattering,-1,1,1);
473                                                   408 
474   //ionisation                                    409   //ionisation
475   pmanager->AddProcess(ahadronIon,       -1,2, << 410   pmanager->AddProcess(ahadronIon,       -1,2,2);      
476       }                                           411       }
                                                   >> 412     
477   }                                               413   }
                                                   >> 414 
                                                   >> 415   // turn off msc step-limitation - especially as electron cut 1nm
                                                   >> 416   opt.SetMscStepLimitation(fMinimal);
                                                   >> 417 
                                                   >> 418   // switch on fluorescence, PIXE and Auger:
                                                   >> 419   opt.SetFluo(true);
                                                   >> 420   opt.SetPIXE(true);
                                                   >> 421   opt.SetAuger(true);
                                                   >> 422 
478 }                                                 423 }
479                                                   424 
                                                   >> 425 
480 // Optical Processes /////////////////////////    426 // Optical Processes ////////////////////////////////////////////////////////
                                                   >> 427 #include "G4Scintillation.hh"
                                                   >> 428 #include "G4OpAbsorption.hh"
                                                   >> 429 //#include "G4OpRayleigh.hh"
                                                   >> 430 #include "G4OpBoundaryProcess.hh"
                                                   >> 431 
481 void DMXPhysicsList::ConstructOp()                432 void DMXPhysicsList::ConstructOp() 
482 {                                                 433 {
483   G4OpticalParameters* opParams = G4OpticalPar << 434   // default scintillation process
484   G4Scintillation* theScintProcessDef = new G4    435   G4Scintillation* theScintProcessDef = new G4Scintillation("Scintillation");
485   opParams->SetScintTrackSecondariesFirst(true << 436   // theScintProcessDef->DumpPhysicsTable();
486   opParams->SetScintByParticleType(true);      << 437   theScintProcessDef->SetTrackSecondariesFirst(true);
                                                   >> 438   theScintProcessDef->SetScintillationYieldFactor(1.0); //
                                                   >> 439   theScintProcessDef->SetScintillationExcitationRatio(0.0); //
                                                   >> 440   theScintProcessDef->SetVerboseLevel(OpVerbLevel);
                                                   >> 441 
                                                   >> 442   // scintillation process for alpha:
                                                   >> 443   G4Scintillation* theScintProcessAlpha = new G4Scintillation("Scintillation");
                                                   >> 444   // theScintProcessNuc->DumpPhysicsTable();
                                                   >> 445   theScintProcessAlpha->SetTrackSecondariesFirst(true);
                                                   >> 446   theScintProcessAlpha->SetScintillationYieldFactor(1.1);
                                                   >> 447   theScintProcessAlpha->SetScintillationExcitationRatio(1.0);
                                                   >> 448   theScintProcessAlpha->SetVerboseLevel(OpVerbLevel);
                                                   >> 449 
                                                   >> 450   // scintillation process for heavy nuclei
                                                   >> 451   G4Scintillation* theScintProcessNuc = new G4Scintillation("Scintillation");
                                                   >> 452   // theScintProcessNuc->DumpPhysicsTable();
                                                   >> 453   theScintProcessNuc->SetTrackSecondariesFirst(true);
                                                   >> 454   theScintProcessNuc->SetScintillationYieldFactor(0.2);
                                                   >> 455   theScintProcessNuc->SetScintillationExcitationRatio(1.0);
                                                   >> 456   theScintProcessNuc->SetVerboseLevel(OpVerbLevel);
487                                                   457 
488   // optical processes                            458   // optical processes
489   G4OpAbsorption* theAbsorptionProcess = new G    459   G4OpAbsorption* theAbsorptionProcess = new G4OpAbsorption();
                                                   >> 460   //  G4OpRayleigh* theRayleighScatteringProcess = new G4OpRayleigh();
490   G4OpBoundaryProcess* theBoundaryProcess = ne    461   G4OpBoundaryProcess* theBoundaryProcess = new G4OpBoundaryProcess();
                                                   >> 462   //  theAbsorptionProcess->DumpPhysicsTable();
                                                   >> 463   //  theRayleighScatteringProcess->DumpPhysicsTable();
                                                   >> 464   theAbsorptionProcess->SetVerboseLevel(OpVerbLevel);
                                                   >> 465   // theRayleighScatteringProcess->SetVerboseLevel(OpVerbLevel);
                                                   >> 466   theBoundaryProcess->SetVerboseLevel(OpVerbLevel);
491                                                   467 
492   auto particleIterator=GetParticleIterator(); << 468   theParticleIterator->reset();
493   particleIterator->reset();                   << 469   while( (*theParticleIterator)() )
494   while( (*particleIterator)() )               << 
495     {                                             470     {
496       G4ParticleDefinition* particle = particl << 471       G4ParticleDefinition* particle = theParticleIterator->value();
497       G4ProcessManager* pmanager = particle->G    472       G4ProcessManager* pmanager = particle->GetProcessManager();
498       G4String particleName = particle->GetPar    473       G4String particleName = particle->GetParticleName();
499       if (theScintProcessDef->IsApplicable(*pa    474       if (theScintProcessDef->IsApplicable(*particle)) {
500         pmanager->AddProcess(theScintProcessDe << 475   //      if(particle->GetPDGMass() > 5.0*GeV) 
501         pmanager->SetProcessOrderingToLast(the << 476   if(particle->GetParticleName() == "GenericIon") {
502         pmanager->SetProcessOrderingToLast(the << 477     pmanager->AddProcess(theScintProcessNuc); // AtRestDiscrete
                                                   >> 478     pmanager->SetProcessOrderingToLast(theScintProcessNuc,idxAtRest);
                                                   >> 479     pmanager->SetProcessOrderingToLast(theScintProcessNuc,idxPostStep);
                                                   >> 480   }   
                                                   >> 481   else if(particle->GetParticleName() == "alpha") {
                                                   >> 482     pmanager->AddProcess(theScintProcessAlpha);
                                                   >> 483     pmanager->SetProcessOrderingToLast(theScintProcessAlpha,idxAtRest);
                                                   >> 484     pmanager->SetProcessOrderingToLast(theScintProcessAlpha,idxPostStep);
                                                   >> 485   }
                                                   >> 486   else {
                                                   >> 487     pmanager->AddProcess(theScintProcessDef);
                                                   >> 488     pmanager->SetProcessOrderingToLast(theScintProcessDef,idxAtRest);
                                                   >> 489     pmanager->SetProcessOrderingToLast(theScintProcessDef,idxPostStep);
                                                   >> 490   }   
503       }                                           491       }
504                                                   492       
505       if (particleName == "opticalphoton") {      493       if (particleName == "opticalphoton") {
506   pmanager->AddDiscreteProcess(theAbsorptionPr    494   pmanager->AddDiscreteProcess(theAbsorptionProcess);
                                                   >> 495   //  pmanager->AddDiscreteProcess(theRayleighScatteringProcess);
507   pmanager->AddDiscreteProcess(theBoundaryProc    496   pmanager->AddDiscreteProcess(theBoundaryProcess);
508       }                                           497       }
509     }                                             498     }
510 }                                                 499 }
511                                                   500 
                                                   >> 501 
512 // Hadronic processes ////////////////////////    502 // Hadronic processes ////////////////////////////////////////////////////////
513                                                   503 
                                                   >> 504 // Elastic processes:
                                                   >> 505 #include "G4HadronElasticProcess.hh"
                                                   >> 506 #include "G4ChipsElasticModel.hh"
                                                   >> 507 #include "G4ElasticHadrNucleusHE.hh"
                                                   >> 508 
                                                   >> 509 // Inelastic processes:
                                                   >> 510 #include "G4PionPlusInelasticProcess.hh"
                                                   >> 511 #include "G4PionMinusInelasticProcess.hh"
                                                   >> 512 #include "G4KaonPlusInelasticProcess.hh"
                                                   >> 513 #include "G4KaonZeroSInelasticProcess.hh"
                                                   >> 514 #include "G4KaonZeroLInelasticProcess.hh"
                                                   >> 515 #include "G4KaonMinusInelasticProcess.hh"
                                                   >> 516 #include "G4ProtonInelasticProcess.hh"
                                                   >> 517 #include "G4AntiProtonInelasticProcess.hh"
                                                   >> 518 #include "G4NeutronInelasticProcess.hh"
                                                   >> 519 #include "G4AntiNeutronInelasticProcess.hh"
                                                   >> 520 #include "G4DeuteronInelasticProcess.hh"
                                                   >> 521 #include "G4TritonInelasticProcess.hh"
                                                   >> 522 #include "G4AlphaInelasticProcess.hh"
                                                   >> 523 
                                                   >> 524 // High energy FTFP model and Bertini cascade
                                                   >> 525 #include "G4FTFModel.hh"
                                                   >> 526 #include "G4LundStringFragmentation.hh"
                                                   >> 527 #include "G4ExcitedStringDecay.hh"
                                                   >> 528 #include "G4PreCompoundModel.hh"
                                                   >> 529 #include "G4GeneratorPrecompoundInterface.hh"
                                                   >> 530 #include "G4TheoFSGenerator.hh"
                                                   >> 531 #include "G4CascadeInterface.hh"
                                                   >> 532 
                                                   >> 533 // Cross sections
                                                   >> 534 #include "G4VCrossSectionDataSet.hh"
                                                   >> 535 #include "G4CrossSectionDataSetRegistry.hh"
                                                   >> 536 
                                                   >> 537 #include "G4CrossSectionElastic.hh"
                                                   >> 538 #include "G4BGGPionElasticXS.hh"
                                                   >> 539 #include "G4AntiNuclElastic.hh"
                                                   >> 540 
                                                   >> 541 #include "G4CrossSectionInelastic.hh"
                                                   >> 542 #include "G4PiNuclearCrossSection.hh"
                                                   >> 543 #include "G4CrossSectionPairGG.hh"
                                                   >> 544 #include "G4BGGNucleonInelasticXS.hh"
                                                   >> 545 #include "G4ComponentAntiNuclNuclearXS.hh"
                                                   >> 546 #include "G4GGNuclNuclCrossSection.hh"
                                                   >> 547 
                                                   >> 548 #include "G4HadronElastic.hh"
                                                   >> 549 #include "G4HadronCaptureProcess.hh"
                                                   >> 550 
                                                   >> 551 // Neutron high-precision models: <20 MeV
                                                   >> 552 #include "G4NeutronHPElastic.hh"
                                                   >> 553 #include "G4NeutronHPElasticData.hh"
                                                   >> 554 #include "G4NeutronHPCapture.hh"
                                                   >> 555 #include "G4NeutronHPCaptureData.hh"
                                                   >> 556 #include "G4NeutronHPInelastic.hh"
                                                   >> 557 #include "G4NeutronHPInelasticData.hh"
                                                   >> 558 
                                                   >> 559 // Stopping processes
                                                   >> 560 #include "G4PiMinusAbsorptionBertini.hh"
                                                   >> 561 #include "G4KaonMinusAbsorptionBertini.hh"
                                                   >> 562 #include "G4AntiProtonAbsorptionFritiof.hh"
                                                   >> 563 
                                                   >> 564 
                                                   >> 565 
514 void DMXPhysicsList::ConstructHad()               566 void DMXPhysicsList::ConstructHad() 
515 {                                                 567 {
516   //Elastic models                                568   //Elastic models
                                                   >> 569   const G4double elastic_elimitPi = 1.0*GeV;
                                                   >> 570 
517   G4HadronElastic* elastic_lhep0 = new G4Hadro    571   G4HadronElastic* elastic_lhep0 = new G4HadronElastic();
                                                   >> 572   G4HadronElastic* elastic_lhep1 = new G4HadronElastic();
                                                   >> 573   elastic_lhep1->SetMaxEnergy( elastic_elimitPi );
518   G4ChipsElasticModel* elastic_chip = new G4Ch    574   G4ChipsElasticModel* elastic_chip = new G4ChipsElasticModel();
519   G4ElasticHadrNucleusHE* elastic_he = new G4E    575   G4ElasticHadrNucleusHE* elastic_he = new G4ElasticHadrNucleusHE(); 
                                                   >> 576   elastic_he->SetMinEnergy( elastic_elimitPi );
                                                   >> 577 
520                                                   578   
521   // Inelastic scattering                         579   // Inelastic scattering
522   const G4double theFTFMin0 =    0.0*GeV;         580   const G4double theFTFMin0 =    0.0*GeV;
523   const G4double theFTFMin1 =    3.0*GeV;      << 581   const G4double theFTFMin1 =    4.0*GeV;
524   const G4double theFTFMax = G4HadronicParamet << 582   const G4double theFTFMax =   100.0*TeV;
525   const G4double theBERTMin0 =   0.0*GeV;         583   const G4double theBERTMin0 =   0.0*GeV;
526   const G4double theBERTMin1 =  19.0*MeV;         584   const G4double theBERTMin1 =  19.0*MeV;
527   const G4double theBERTMax =    6.0*GeV;      << 585   const G4double theBERTMax =    5.0*GeV;
528   const G4double theHPMin =      0.0*GeV;         586   const G4double theHPMin =      0.0*GeV;
529   const G4double theHPMax =     20.0*MeV;         587   const G4double theHPMax =     20.0*MeV;
530                                                   588 
531   G4FTFModel * theStringModel = new G4FTFModel    589   G4FTFModel * theStringModel = new G4FTFModel;
532   G4ExcitedStringDecay * theStringDecay = new     590   G4ExcitedStringDecay * theStringDecay = new G4ExcitedStringDecay( new G4LundStringFragmentation );
533   theStringModel->SetFragmentationModel( theSt    591   theStringModel->SetFragmentationModel( theStringDecay );
534   G4PreCompoundModel * thePreEquilib = new G4P    592   G4PreCompoundModel * thePreEquilib = new G4PreCompoundModel( new G4ExcitationHandler );
535   G4GeneratorPrecompoundInterface * theCascade    593   G4GeneratorPrecompoundInterface * theCascade = new G4GeneratorPrecompoundInterface( thePreEquilib );
536                                                   594 
537   G4TheoFSGenerator * theFTFModel0 = new G4The    595   G4TheoFSGenerator * theFTFModel0 = new G4TheoFSGenerator( "FTFP" );
538   theFTFModel0->SetHighEnergyGenerator( theStr    596   theFTFModel0->SetHighEnergyGenerator( theStringModel );
539   theFTFModel0->SetTransport( theCascade );       597   theFTFModel0->SetTransport( theCascade );
540   theFTFModel0->SetMinEnergy( theFTFMin0 );       598   theFTFModel0->SetMinEnergy( theFTFMin0 );
541   theFTFModel0->SetMaxEnergy( theFTFMax );        599   theFTFModel0->SetMaxEnergy( theFTFMax );
542                                                   600 
543   G4TheoFSGenerator * theFTFModel1 = new G4The    601   G4TheoFSGenerator * theFTFModel1 = new G4TheoFSGenerator( "FTFP" );
544   theFTFModel1->SetHighEnergyGenerator( theStr    602   theFTFModel1->SetHighEnergyGenerator( theStringModel );
545   theFTFModel1->SetTransport( theCascade );       603   theFTFModel1->SetTransport( theCascade );
546   theFTFModel1->SetMinEnergy( theFTFMin1 );       604   theFTFModel1->SetMinEnergy( theFTFMin1 );
547   theFTFModel1->SetMaxEnergy( theFTFMax );        605   theFTFModel1->SetMaxEnergy( theFTFMax );
548                                                   606 
549   G4CascadeInterface * theBERTModel0 = new G4C    607   G4CascadeInterface * theBERTModel0 = new G4CascadeInterface;
550   theBERTModel0->SetMinEnergy( theBERTMin0 );     608   theBERTModel0->SetMinEnergy( theBERTMin0 );
551   theBERTModel0->SetMaxEnergy( theBERTMax );      609   theBERTModel0->SetMaxEnergy( theBERTMax );
552                                                   610 
553   G4CascadeInterface * theBERTModel1 = new G4C    611   G4CascadeInterface * theBERTModel1 = new G4CascadeInterface;
554   theBERTModel1->SetMinEnergy( theBERTMin1 );     612   theBERTModel1->SetMinEnergy( theBERTMin1 );
555   theBERTModel1->SetMaxEnergy( theBERTMax );      613   theBERTModel1->SetMaxEnergy( theBERTMax );
556                                                   614 
                                                   >> 615   G4VCrossSectionDataSet * thePiData = new G4CrossSectionPairGG( new G4PiNuclearCrossSection, 91*GeV );
557   G4VCrossSectionDataSet * theAntiNucleonData     616   G4VCrossSectionDataSet * theAntiNucleonData = new G4CrossSectionInelastic( new G4ComponentAntiNuclNuclearXS );
558   G4ComponentGGNuclNuclXsc * ggNuclNuclXsec =  << 617   G4VCrossSectionDataSet * theGGNuclNuclData = G4CrossSectionDataSetRegistry::Instance()->
559   G4VCrossSectionDataSet * theGGNuclNuclData = << 618     GetCrossSectionDataSet(G4GGNuclNuclCrossSection::Default_Name());
560   G4VCrossSectionDataSet * theGGNNEl = new G4C << 619 
561   G4ComponentGGHadronNucleusXsc * ggHNXsec = n << 620 
562   G4VCrossSectionDataSet * theGGHNEl = new G4C << 621   theParticleIterator->reset();
563   G4VCrossSectionDataSet * theGGHNInel = new G << 622   while ((*theParticleIterator)()) 
564                                                << 
565   auto particleIterator=GetParticleIterator(); << 
566   particleIterator->reset();                   << 
567   while ((*particleIterator)())                << 
568     {                                             623     {
569       G4ParticleDefinition* particle = particl << 624       G4ParticleDefinition* particle = theParticleIterator->value();
570       G4ProcessManager* pmanager = particle->G    625       G4ProcessManager* pmanager = particle->GetProcessManager();
571       G4String particleName = particle->GetPar    626       G4String particleName = particle->GetParticleName();
572                                                   627 
573       if (particleName == "pi+")                  628       if (particleName == "pi+") 
574   {                                               629   {
575     // Elastic scattering                         630     // Elastic scattering
576           G4HadronElasticProcess* theElasticPr    631           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
577           theElasticProcess->AddDataSet( new G    632           theElasticProcess->AddDataSet( new G4BGGPionElasticXS( particle ) );
                                                   >> 633           theElasticProcess->RegisterMe( elastic_lhep1 );
578           theElasticProcess->RegisterMe( elast    634           theElasticProcess->RegisterMe( elastic_he );
579     pmanager->AddDiscreteProcess( theElasticPr    635     pmanager->AddDiscreteProcess( theElasticProcess );
580     //Inelastic scattering                        636     //Inelastic scattering
581     G4HadronInelasticProcess* theInelasticProc << 637     G4PionPlusInelasticProcess* theInelasticProcess = 
582       new G4HadronInelasticProcess( "inelastic << 638       new G4PionPlusInelasticProcess("inelastic");
583     theInelasticProcess->AddDataSet( new G4BGG << 639     theInelasticProcess->AddDataSet( thePiData );
584     theInelasticProcess->RegisterMe( theFTFMod    640     theInelasticProcess->RegisterMe( theFTFModel1 );
585           theInelasticProcess->RegisterMe( the    641           theInelasticProcess->RegisterMe( theBERTModel0 );
586     pmanager->AddDiscreteProcess( theInelastic    642     pmanager->AddDiscreteProcess( theInelasticProcess );
587   }                                               643   } 
588                                                   644 
589       else if (particleName == "pi-")             645       else if (particleName == "pi-") 
590   {                                               646   {
591     // Elastic scattering                         647     // Elastic scattering
592           G4HadronElasticProcess* theElasticPr    648           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
593           theElasticProcess->AddDataSet( new G    649           theElasticProcess->AddDataSet( new G4BGGPionElasticXS( particle ) );
                                                   >> 650           theElasticProcess->RegisterMe( elastic_lhep1 );
594           theElasticProcess->RegisterMe( elast    651           theElasticProcess->RegisterMe( elastic_he );
595     pmanager->AddDiscreteProcess( theElasticPr    652     pmanager->AddDiscreteProcess( theElasticProcess );
596     //Inelastic scattering                        653     //Inelastic scattering
597     G4HadronInelasticProcess* theInelasticProc << 654     G4PionMinusInelasticProcess* theInelasticProcess = 
598       new G4HadronInelasticProcess( "inelastic << 655       new G4PionMinusInelasticProcess("inelastic");
599     theInelasticProcess->AddDataSet( new G4BGG << 656     theInelasticProcess->AddDataSet( thePiData );
600     theInelasticProcess->RegisterMe( theFTFMod    657     theInelasticProcess->RegisterMe( theFTFModel1 );
601           theInelasticProcess->RegisterMe( the    658           theInelasticProcess->RegisterMe( theBERTModel0 );
602     pmanager->AddDiscreteProcess( theInelastic    659     pmanager->AddDiscreteProcess( theInelasticProcess );    
603     //Absorption                                  660     //Absorption
604     pmanager->AddRestProcess(new G4HadronicAbs << 661     pmanager->AddRestProcess(new G4PiMinusAbsorptionBertini, ordDefault);
605   }                                               662   }
                                                   >> 663       
606       else if (particleName == "kaon+")           664       else if (particleName == "kaon+") 
607   {                                               665   {
608     // Elastic scattering                         666     // Elastic scattering
609           G4HadronElasticProcess* theElasticPr    667           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
610     theElasticProcess->AddDataSet( theGGHNEl ) << 
611           theElasticProcess->RegisterMe( elast    668           theElasticProcess->RegisterMe( elastic_lhep0 );
612     pmanager->AddDiscreteProcess( theElasticPr    669     pmanager->AddDiscreteProcess( theElasticProcess );
613           // Inelastic scattering                 670           // Inelastic scattering 
614     G4HadronInelasticProcess* theInelasticProc << 671     G4KaonPlusInelasticProcess* theInelasticProcess = 
615       new G4HadronInelasticProcess( "inelastic << 672       new G4KaonPlusInelasticProcess("inelastic");
616     theInelasticProcess->AddDataSet( theGGHNIn << 673     theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->
                                                   >> 674              GetCrossSectionDataSet(G4ChipsKaonPlusInelasticXS::Default_Name()));
617     theInelasticProcess->RegisterMe( theFTFMod    675     theInelasticProcess->RegisterMe( theFTFModel1 );
618           theInelasticProcess->RegisterMe( the    676           theInelasticProcess->RegisterMe( theBERTModel0 );
619     pmanager->AddDiscreteProcess( theInelastic    677     pmanager->AddDiscreteProcess( theInelasticProcess );
620   }                                            << 678   }
                                                   >> 679       
621       else if (particleName == "kaon0S")          680       else if (particleName == "kaon0S") 
622   {                                               681   {
623     // Elastic scattering                         682     // Elastic scattering
624           G4HadronElasticProcess* theElasticPr    683           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
625     theElasticProcess->AddDataSet( theGGHNEl ) << 
626           theElasticProcess->RegisterMe( elast    684           theElasticProcess->RegisterMe( elastic_lhep0 );
627     pmanager->AddDiscreteProcess( theElasticPr    685     pmanager->AddDiscreteProcess( theElasticProcess );
628           // Inelastic scattering                 686           // Inelastic scattering  
629     G4HadronInelasticProcess* theInelasticProc << 687     G4KaonZeroSInelasticProcess* theInelasticProcess = 
630       new G4HadronInelasticProcess( "inelastic << 688       new G4KaonZeroSInelasticProcess("inelastic");
631     theInelasticProcess->AddDataSet( theGGHNIn << 689     theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->
                                                   >> 690              GetCrossSectionDataSet(G4ChipsKaonZeroInelasticXS::Default_Name()));
632     theInelasticProcess->RegisterMe( theFTFMod    691     theInelasticProcess->RegisterMe( theFTFModel1 );
633           theInelasticProcess->RegisterMe( the    692           theInelasticProcess->RegisterMe( theBERTModel0 );
634     pmanager->AddDiscreteProcess( theInelastic    693     pmanager->AddDiscreteProcess( theInelasticProcess );    
635   }                                               694   }
636                                                   695 
637       else if (particleName == "kaon0L")          696       else if (particleName == "kaon0L") 
638   {                                               697   {
639     // Elastic scattering                         698     // Elastic scattering
640           G4HadronElasticProcess* theElasticPr    699           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
641     theElasticProcess->AddDataSet( theGGHNEl ) << 
642           theElasticProcess->RegisterMe( elast    700           theElasticProcess->RegisterMe( elastic_lhep0 );
643     pmanager->AddDiscreteProcess( theElasticPr    701     pmanager->AddDiscreteProcess( theElasticProcess );
644     // Inelastic scattering                       702     // Inelastic scattering
645     G4HadronInelasticProcess* theInelasticProc << 703     G4KaonZeroLInelasticProcess* theInelasticProcess = 
646       new G4HadronInelasticProcess( "inelastic << 704       new G4KaonZeroLInelasticProcess("inelastic");
647     theInelasticProcess->AddDataSet( theGGHNIn << 705     theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->
                                                   >> 706              GetCrossSectionDataSet(G4ChipsKaonZeroInelasticXS::Default_Name()));
648     theInelasticProcess->RegisterMe( theFTFMod    707     theInelasticProcess->RegisterMe( theFTFModel1 );
649           theInelasticProcess->RegisterMe( the    708           theInelasticProcess->RegisterMe( theBERTModel0 ); 
650     pmanager->AddDiscreteProcess( theInelastic    709     pmanager->AddDiscreteProcess( theInelasticProcess );    
651   }                                               710   }
652                                                   711 
653       else if (particleName == "kaon-")           712       else if (particleName == "kaon-") 
654   {                                               713   {
655     // Elastic scattering                         714     // Elastic scattering
656           G4HadronElasticProcess* theElasticPr    715           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
657     theElasticProcess->AddDataSet( theGGHNEl ) << 
658           theElasticProcess->RegisterMe( elast    716           theElasticProcess->RegisterMe( elastic_lhep0 );
659     pmanager->AddDiscreteProcess( theElasticPr    717     pmanager->AddDiscreteProcess( theElasticProcess );
660           // Inelastic scattering                 718           // Inelastic scattering
661     G4HadronInelasticProcess* theInelasticProc << 719     G4KaonMinusInelasticProcess* theInelasticProcess = 
662       new G4HadronInelasticProcess( "inelastic << 720       new G4KaonMinusInelasticProcess("inelastic"); 
663           theInelasticProcess->AddDataSet( the << 721           theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->
                                                   >> 722              GetCrossSectionDataSet(G4ChipsKaonMinusInelasticXS::Default_Name()));
664     theInelasticProcess->RegisterMe( theFTFMod    723     theInelasticProcess->RegisterMe( theFTFModel1 );
665           theInelasticProcess->RegisterMe( the    724           theInelasticProcess->RegisterMe( theBERTModel0 );
666     pmanager->AddDiscreteProcess( theInelastic    725     pmanager->AddDiscreteProcess( theInelasticProcess );
667     pmanager->AddRestProcess(new G4HadronicAbs << 726     pmanager->AddRestProcess(new G4KaonMinusAbsorptionBertini, ordDefault);
668   }                                               727   }
669                                                   728 
670       else if (particleName == "proton")          729       else if (particleName == "proton") 
671   {                                               730   {
672     // Elastic scattering                         731     // Elastic scattering
673           G4HadronElasticProcess* theElasticPr    732           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
674           theElasticProcess->AddDataSet( new G << 733           theElasticProcess->AddDataSet(G4CrossSectionDataSetRegistry::Instance()->
                                                   >> 734           GetCrossSectionDataSet(G4ChipsProtonElasticXS::Default_Name()));
675           theElasticProcess->RegisterMe( elast    735           theElasticProcess->RegisterMe( elastic_chip );
676     pmanager->AddDiscreteProcess( theElasticPr    736     pmanager->AddDiscreteProcess( theElasticProcess );
677     // Inelastic scattering                       737     // Inelastic scattering
678     G4HadronInelasticProcess* theInelasticProc << 738     G4ProtonInelasticProcess* theInelasticProcess = 
679       new G4HadronInelasticProcess( "inelastic << 739       new G4ProtonInelasticProcess("inelastic");
680     theInelasticProcess->AddDataSet( new G4BGG    740     theInelasticProcess->AddDataSet( new G4BGGNucleonInelasticXS( G4Proton::Proton() ) );
681     theInelasticProcess->RegisterMe( theFTFMod    741     theInelasticProcess->RegisterMe( theFTFModel1 );
682           theInelasticProcess->RegisterMe( the    742           theInelasticProcess->RegisterMe( theBERTModel0 );
683     pmanager->AddDiscreteProcess( theInelastic    743     pmanager->AddDiscreteProcess( theInelasticProcess );
684   }                                               744   }
685       else if (particleName == "anti_proton")     745       else if (particleName == "anti_proton") 
686   {                                               746   {
687     // Elastic scattering                         747     // Elastic scattering
688           const G4double elastic_elimitAntiNuc << 748           const G4double elastic_elimitAntiNuc = 100.0*CLHEP::MeV;
689           G4AntiNuclElastic* elastic_anuc = ne    749           G4AntiNuclElastic* elastic_anuc = new G4AntiNuclElastic();
690           elastic_anuc->SetMinEnergy( elastic_    750           elastic_anuc->SetMinEnergy( elastic_elimitAntiNuc );
691           G4CrossSectionElastic* elastic_anucx    751           G4CrossSectionElastic* elastic_anucxs = new G4CrossSectionElastic( elastic_anuc->GetComponentCrossSection() );
692           G4HadronElastic* elastic_lhep2 = new    752           G4HadronElastic* elastic_lhep2 = new G4HadronElastic();
693           elastic_lhep2->SetMaxEnergy( elastic    753           elastic_lhep2->SetMaxEnergy( elastic_elimitAntiNuc );
694           G4HadronElasticProcess* theElasticPr    754           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
695           theElasticProcess->AddDataSet( elast    755           theElasticProcess->AddDataSet( elastic_anucxs );
696           theElasticProcess->RegisterMe( elast    756           theElasticProcess->RegisterMe( elastic_lhep2 );
697           theElasticProcess->RegisterMe( elast    757           theElasticProcess->RegisterMe( elastic_anuc );
698     pmanager->AddDiscreteProcess( theElasticPr    758     pmanager->AddDiscreteProcess( theElasticProcess );
699     // Inelastic scattering                       759     // Inelastic scattering
700     G4HadronInelasticProcess* theInelasticProc << 760     G4AntiProtonInelasticProcess* theInelasticProcess = 
701       new G4HadronInelasticProcess( "inelastic << 761       new G4AntiProtonInelasticProcess("inelastic");
702     theInelasticProcess->AddDataSet( theAntiNu    762     theInelasticProcess->AddDataSet( theAntiNucleonData );
703     theInelasticProcess->RegisterMe( theFTFMod    763     theInelasticProcess->RegisterMe( theFTFModel0 );
704     pmanager->AddDiscreteProcess( theInelastic    764     pmanager->AddDiscreteProcess( theInelasticProcess );
705     // Absorption                                 765     // Absorption
706     pmanager->AddRestProcess(new G4HadronicAbs << 766     pmanager->AddRestProcess(new G4AntiProtonAbsorptionFritiof, ordDefault);
707   }                                               767   }
                                                   >> 768 
708       else if (particleName == "neutron") {       769       else if (particleName == "neutron") {
709   // elastic scattering                           770   // elastic scattering
710   G4HadronElasticProcess* theElasticProcess =     771   G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
711         theElasticProcess->AddDataSet(new G4Ne << 772         theElasticProcess->AddDataSet(G4CrossSectionDataSetRegistry::Instance()->GetCrossSectionDataSet(G4ChipsNeutronElasticXS::Default_Name()));
712         G4HadronElastic* elastic_neutronChipsM    773         G4HadronElastic* elastic_neutronChipsModel = new G4ChipsElasticModel();
713   elastic_neutronChipsModel->SetMinEnergy( 19. << 774   elastic_neutronChipsModel->SetMinEnergy( 19.0*CLHEP::MeV );
714         theElasticProcess->RegisterMe( elastic    775         theElasticProcess->RegisterMe( elastic_neutronChipsModel );
715   G4ParticleHPElastic * theElasticNeutronHP =  << 776   G4NeutronHPElastic * theElasticNeutronHP = new G4NeutronHPElastic;
716         theElasticNeutronHP->SetMinEnergy( the    777         theElasticNeutronHP->SetMinEnergy( theHPMin );
717         theElasticNeutronHP->SetMaxEnergy( the    778         theElasticNeutronHP->SetMaxEnergy( theHPMax );
718   theElasticProcess->RegisterMe( theElasticNeu    779   theElasticProcess->RegisterMe( theElasticNeutronHP );
719   theElasticProcess->AddDataSet( new G4Particl << 780   theElasticProcess->AddDataSet( new G4NeutronHPElasticData );
720   pmanager->AddDiscreteProcess( theElasticProc    781   pmanager->AddDiscreteProcess( theElasticProcess );
721   // inelastic scattering                         782   // inelastic scattering   
722   G4HadronInelasticProcess* theInelasticProces << 783   G4NeutronInelasticProcess* theInelasticProcess =
723     new G4HadronInelasticProcess( "inelastic", << 784     new G4NeutronInelasticProcess("inelastic");
724   theInelasticProcess->AddDataSet( new G4Neutr << 785   theInelasticProcess->AddDataSet( new G4BGGNucleonInelasticXS( G4Neutron::Neutron() ) );
725   theInelasticProcess->RegisterMe( theFTFModel    786   theInelasticProcess->RegisterMe( theFTFModel1 );
726         theInelasticProcess->RegisterMe( theBE    787         theInelasticProcess->RegisterMe( theBERTModel1 );
727   G4ParticleHPInelastic * theNeutronInelasticH << 788   G4NeutronHPInelastic * theNeutronInelasticHPModel = new G4NeutronHPInelastic;
728         theNeutronInelasticHPModel->SetMinEner    789         theNeutronInelasticHPModel->SetMinEnergy( theHPMin );
729         theNeutronInelasticHPModel->SetMaxEner    790         theNeutronInelasticHPModel->SetMaxEnergy( theHPMax );
730   theInelasticProcess->RegisterMe( theNeutronI    791   theInelasticProcess->RegisterMe( theNeutronInelasticHPModel );
731   theInelasticProcess->AddDataSet( new G4Parti << 792   theInelasticProcess->AddDataSet( new G4NeutronHPInelasticData );
732   pmanager->AddDiscreteProcess(theInelasticPro    793   pmanager->AddDiscreteProcess(theInelasticProcess);
733   // capture                                      794   // capture
734   G4NeutronCaptureProcess* theCaptureProcess = << 795   G4HadronCaptureProcess* theCaptureProcess =
735     new G4NeutronCaptureProcess;               << 796     new G4HadronCaptureProcess;
736   G4ParticleHPCapture * theLENeutronCaptureMod << 797   G4NeutronHPCapture * theLENeutronCaptureModel = new G4NeutronHPCapture;
737   theLENeutronCaptureModel->SetMinEnergy(theHP    798   theLENeutronCaptureModel->SetMinEnergy(theHPMin);
738   theLENeutronCaptureModel->SetMaxEnergy(theHP    799   theLENeutronCaptureModel->SetMaxEnergy(theHPMax);
739   theCaptureProcess->RegisterMe(theLENeutronCa    800   theCaptureProcess->RegisterMe(theLENeutronCaptureModel);
740   theCaptureProcess->AddDataSet( new G4Particl << 801   theCaptureProcess->AddDataSet( new G4NeutronHPCaptureData);
741   pmanager->AddDiscreteProcess(theCaptureProce    802   pmanager->AddDiscreteProcess(theCaptureProcess);
                                                   >> 803 
742       }                                           804       }
743       else if (particleName == "anti_neutron")    805       else if (particleName == "anti_neutron") 
744   {                                               806   {
745     // Elastic scattering                         807     // Elastic scattering
746           G4HadronElasticProcess* theElasticPr    808           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
747     theElasticProcess->AddDataSet( theGGHNEl ) << 
748           theElasticProcess->RegisterMe( elast    809           theElasticProcess->RegisterMe( elastic_lhep0 );
749     pmanager->AddDiscreteProcess( theElasticPr    810     pmanager->AddDiscreteProcess( theElasticProcess );
750           // Inelastic scattering (include ann    811           // Inelastic scattering (include annihilation on-fly)
751     G4HadronInelasticProcess* theInelasticProc << 812     G4AntiNeutronInelasticProcess* theInelasticProcess = 
752       new G4HadronInelasticProcess( "inelastic << 813       new G4AntiNeutronInelasticProcess("inelastic");
753     theInelasticProcess->AddDataSet( theAntiNu    814     theInelasticProcess->AddDataSet( theAntiNucleonData );
754     theInelasticProcess->RegisterMe( theFTFMod    815     theInelasticProcess->RegisterMe( theFTFModel0 );
755     pmanager->AddDiscreteProcess( theInelastic    816     pmanager->AddDiscreteProcess( theInelasticProcess );    
756   }                                               817   }
                                                   >> 818 
757       else if (particleName == "deuteron")        819       else if (particleName == "deuteron") 
758   {                                               820   {
759     // Elastic scattering                         821     // Elastic scattering
760           G4HadronElasticProcess* theElasticPr    822           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
761     theElasticProcess->AddDataSet( theGGNNEl ) << 
762           theElasticProcess->RegisterMe( elast    823           theElasticProcess->RegisterMe( elastic_lhep0 );
763     pmanager->AddDiscreteProcess( theElasticPr    824     pmanager->AddDiscreteProcess( theElasticProcess );
764           // Inelastic scattering                 825           // Inelastic scattering
765     G4HadronInelasticProcess* theInelasticProc << 826     G4DeuteronInelasticProcess* theInelasticProcess = 
766       new G4HadronInelasticProcess( "inelastic << 827       new G4DeuteronInelasticProcess("inelastic");
767     theInelasticProcess->AddDataSet( theGGNucl    828     theInelasticProcess->AddDataSet( theGGNuclNuclData );
768     theInelasticProcess->RegisterMe( theFTFMod    829     theInelasticProcess->RegisterMe( theFTFModel1 );
769           theInelasticProcess->RegisterMe( the    830           theInelasticProcess->RegisterMe( theBERTModel0 );
770     pmanager->AddDiscreteProcess( theInelastic    831     pmanager->AddDiscreteProcess( theInelasticProcess );
771   }                                               832   }
                                                   >> 833       
772       else if (particleName == "triton")          834       else if (particleName == "triton") 
773   {                                               835   {
774     // Elastic scattering                         836     // Elastic scattering
775           G4HadronElasticProcess* theElasticPr    837           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
776     theElasticProcess->AddDataSet( theGGNNEl ) << 
777           theElasticProcess->RegisterMe( elast    838           theElasticProcess->RegisterMe( elastic_lhep0 );
778     pmanager->AddDiscreteProcess( theElasticPr    839     pmanager->AddDiscreteProcess( theElasticProcess );
779           // Inelastic scattering                 840           // Inelastic scattering
780     G4HadronInelasticProcess* theInelasticProc << 841     G4TritonInelasticProcess* theInelasticProcess = 
781       new G4HadronInelasticProcess( "inelastic << 842       new G4TritonInelasticProcess("inelastic");
782     theInelasticProcess->AddDataSet( theGGNucl    843     theInelasticProcess->AddDataSet( theGGNuclNuclData );
783     theInelasticProcess->RegisterMe( theFTFMod    844     theInelasticProcess->RegisterMe( theFTFModel1 );
784           theInelasticProcess->RegisterMe( the    845           theInelasticProcess->RegisterMe( theBERTModel0 );
785     pmanager->AddDiscreteProcess( theInelastic    846     pmanager->AddDiscreteProcess( theInelasticProcess );
786   }                                               847   }
787       else if (particleName == "alpha")           848       else if (particleName == "alpha") 
788   {                                               849   {
789     // Elastic scattering                         850     // Elastic scattering
790           G4HadronElasticProcess* theElasticPr    851           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
791     theElasticProcess->AddDataSet( theGGNNEl ) << 
792           theElasticProcess->RegisterMe( elast    852           theElasticProcess->RegisterMe( elastic_lhep0 );
793     pmanager->AddDiscreteProcess( theElasticPr    853     pmanager->AddDiscreteProcess( theElasticProcess );
794           // Inelastic scattering                 854           // Inelastic scattering
795     G4HadronInelasticProcess* theInelasticProc << 855     G4AlphaInelasticProcess* theInelasticProcess = 
796       new G4HadronInelasticProcess( "inelastic << 856       new G4AlphaInelasticProcess("inelastic");  
797           theInelasticProcess->AddDataSet( the    857           theInelasticProcess->AddDataSet( theGGNuclNuclData );
798     theInelasticProcess->RegisterMe( theFTFMod    858     theInelasticProcess->RegisterMe( theFTFModel1 );
799           theInelasticProcess->RegisterMe( the    859           theInelasticProcess->RegisterMe( theBERTModel0 );
800     pmanager->AddDiscreteProcess( theInelastic    860     pmanager->AddDiscreteProcess( theInelasticProcess );
801   }                                               861   }
                                                   >> 862 
802     }                                             863     }
803 }                                                 864 }
804                                                   865 
                                                   >> 866 
805 // Decays ////////////////////////////////////    867 // Decays ///////////////////////////////////////////////////////////////////
                                                   >> 868 #include "G4Decay.hh"
                                                   >> 869 #include "G4RadioactiveDecay.hh"
                                                   >> 870 #include "G4IonTable.hh"
                                                   >> 871 #include "G4Ions.hh"
                                                   >> 872 
806 void DMXPhysicsList::ConstructGeneral() {         873 void DMXPhysicsList::ConstructGeneral() {
807                                                   874 
808   // Add Decay Process                            875   // Add Decay Process
809   G4Decay* theDecayProcess = new G4Decay();       876   G4Decay* theDecayProcess = new G4Decay();
810   auto particleIterator=GetParticleIterator(); << 877   theParticleIterator->reset();
811   particleIterator->reset();                   << 878   while( (*theParticleIterator)() )
812   while( (*particleIterator)() )               << 
813     {                                             879     {
814       G4ParticleDefinition* particle = particl << 880       G4ParticleDefinition* particle = theParticleIterator->value();
815       G4ProcessManager* pmanager = particle->G    881       G4ProcessManager* pmanager = particle->GetProcessManager();
816                                                   882       
817       if (theDecayProcess->IsApplicable(*parti    883       if (theDecayProcess->IsApplicable(*particle) && !particle->IsShortLived()) 
818   {                                               884   { 
819     pmanager ->AddProcess(theDecayProcess);       885     pmanager ->AddProcess(theDecayProcess);
820     // set ordering for PostStepDoIt and AtRes    886     // set ordering for PostStepDoIt and AtRestDoIt
821     pmanager ->SetProcessOrdering(theDecayProc    887     pmanager ->SetProcessOrdering(theDecayProcess, idxPostStep);
822     pmanager ->SetProcessOrdering(theDecayProc    888     pmanager ->SetProcessOrdering(theDecayProcess, idxAtRest);
823   }                                               889   }
824     }                                             890     }
825                                                   891 
826   // Declare radioactive decay to the GenericI    892   // Declare radioactive decay to the GenericIon in the IonTable.
827   G4LossTableManager* man = G4LossTableManager << 893   const G4IonTable *theIonTable = 
828   G4VAtomDeexcitation* ad = man->AtomDeexcitat << 894     G4ParticleTable::GetParticleTable()->GetIonTable();
829   if(!ad) {                                    << 895   G4RadioactiveDecay *theRadioactiveDecay = new G4RadioactiveDecay();
830     G4EmParameters::Instance()->SetAugerCascad << 
831     ad = new G4UAtomicDeexcitation();          << 
832     man->SetAtomDeexcitation(ad);              << 
833     ad->InitialiseAtomicDeexcitation();        << 
834   }                                            << 
835                                                   896 
836   G4PhysicsListHelper::GetPhysicsListHelper()- << 897   for (G4int i=0; i<theIonTable->Entries(); i++) 
837     RegisterProcess(new G4RadioactiveDecay(),  << 898     {
                                                   >> 899       G4String particleName = theIonTable->GetParticle(i)->GetParticleName();
                                                   >> 900       G4String particleType = theIonTable->GetParticle(i)->GetParticleType();
                                                   >> 901       
                                                   >> 902       if (particleName == "GenericIon") 
                                                   >> 903   {
                                                   >> 904     G4ProcessManager* pmanager = 
                                                   >> 905       theIonTable->GetParticle(i)->GetProcessManager();
                                                   >> 906     pmanager->SetVerboseLevel(VerboseLevel);
                                                   >> 907     pmanager ->AddProcess(theRadioactiveDecay);
                                                   >> 908     pmanager ->SetProcessOrdering(theRadioactiveDecay, idxPostStep);
                                                   >> 909     pmanager ->SetProcessOrdering(theRadioactiveDecay, idxAtRest);
                                                   >> 910   } 
                                                   >> 911     }
838 }                                                 912 }
839                                                   913 
840 // Cuts //////////////////////////////////////    914 // Cuts /////////////////////////////////////////////////////////////////////
841 void DMXPhysicsList::SetCuts()                    915 void DMXPhysicsList::SetCuts() 
842 {                                                 916 {
843                                                   917   
844   if (verboseLevel >1)                            918   if (verboseLevel >1)
845     G4cout << "DMXPhysicsList::SetCuts:";         919     G4cout << "DMXPhysicsList::SetCuts:";
846                                                   920   
847   if (verboseLevel>0){                            921   if (verboseLevel>0){
848     G4cout << "DMXPhysicsList::SetCuts:";         922     G4cout << "DMXPhysicsList::SetCuts:";
849     G4cout << "CutLength : "                      923     G4cout << "CutLength : " 
850      << G4BestUnit(defaultCutValue,"Length") <    924      << G4BestUnit(defaultCutValue,"Length") << G4endl;
851   }                                               925   }
852                                                   926 
853   //special for low energy physics                927   //special for low energy physics
854   G4double lowlimit=250*eV;                       928   G4double lowlimit=250*eV;  
855   G4ProductionCutsTable::GetProductionCutsTabl    929   G4ProductionCutsTable::GetProductionCutsTable()->SetEnergyRange(lowlimit,100.*GeV);
856                                                   930 
857   // set cut values for gamma at first and for    931   // set cut values for gamma at first and for e- second and next for e+,
858   // because some processes for e+/e- need cut    932   // because some processes for e+/e- need cut values for gamma 
859   SetCutValue(cutForGamma, "gamma");              933   SetCutValue(cutForGamma, "gamma");
860   SetCutValue(cutForElectron, "e-");              934   SetCutValue(cutForElectron, "e-");
861   SetCutValue(cutForPositron, "e+");              935   SetCutValue(cutForPositron, "e+");
862                                                   936   
863   if (verboseLevel>0) DumpCutValuesTable();       937   if (verboseLevel>0) DumpCutValuesTable();
864 }                                                 938 }
865                                                   939 
866                                                   940