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.5.p1)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 //                                                 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 #include "G4ShortLivedConstructor.hh"
                                                   >> 163 
288 // construct Shortliveds://///////////////////    164 // construct Shortliveds://///////////////////////////////////////////////////
289 void DMXPhysicsList::ConstructMyShortLiveds()     165 void DMXPhysicsList::ConstructMyShortLiveds()
290 {                                                 166 {
291   G4ShortLivedConstructor slConstructor;          167   G4ShortLivedConstructor slConstructor;
292   slConstructor.ConstructParticle();              168   slConstructor.ConstructParticle();
293 }                                                 169 }
294                                                   170 
                                                   >> 171 
                                                   >> 172 
                                                   >> 173 
295 // Construct Processes ///////////////////////    174 // Construct Processes //////////////////////////////////////////////////////
296 void DMXPhysicsList::ConstructProcess()           175 void DMXPhysicsList::ConstructProcess() 
297 {                                                 176 {
                                                   >> 177 
298   AddTransportation();                            178   AddTransportation();
299                                                   179 
300   ConstructEM();                                  180   ConstructEM();
301                                                   181 
302   ConstructOp();                                  182   ConstructOp();
303                                                   183 
304   ConstructHad();                                 184   ConstructHad();
305                                                   185 
306   ConstructGeneral();                             186   ConstructGeneral();
                                                   >> 187 
307 }                                                 188 }
308                                                   189 
                                                   >> 190 
309 // Transportation ////////////////////////////    191 // Transportation ///////////////////////////////////////////////////////////
                                                   >> 192 #include "DMXMaxTimeCuts.hh"
                                                   >> 193 #include "DMXMinEkineCuts.hh"
                                                   >> 194 #include "G4StepLimiter.hh"
                                                   >> 195 
310 void DMXPhysicsList::AddTransportation() {        196 void DMXPhysicsList::AddTransportation() {
311                                                   197   
312   G4VUserPhysicsList::AddTransportation();        198   G4VUserPhysicsList::AddTransportation();
313                                                   199   
314   auto particleIterator=GetParticleIterator();    200   auto particleIterator=GetParticleIterator();
315   particleIterator->reset();                      201   particleIterator->reset();
316   while( (*particleIterator)() ){                 202   while( (*particleIterator)() ){
317     G4ParticleDefinition* particle = particleI    203     G4ParticleDefinition* particle = particleIterator->value();
318     G4ProcessManager* pmanager = particle->Get    204     G4ProcessManager* pmanager = particle->GetProcessManager();
319     G4String particleName = particle->GetParti    205     G4String particleName = particle->GetParticleName();
320     // time cuts for ONLY neutrons:               206     // time cuts for ONLY neutrons:
321     if(particleName == "neutron")                 207     if(particleName == "neutron") 
322       pmanager->AddDiscreteProcess(new DMXMaxT    208       pmanager->AddDiscreteProcess(new DMXMaxTimeCuts());
323     // Energy cuts to kill charged (embedded i    209     // Energy cuts to kill charged (embedded in method) particles:
324     pmanager->AddDiscreteProcess(new DMXMinEki    210     pmanager->AddDiscreteProcess(new DMXMinEkineCuts());
325                                                   211 
326     // Step limit applied to all particles:       212     // Step limit applied to all particles:
327     pmanager->AddDiscreteProcess(new G4StepLim << 213     pmanager->AddProcess(new G4StepLimiter,       -1,-1,1);
                                                   >> 214 
328   }                                               215   }         
329 }                                                 216 }
330                                                   217 
                                                   >> 218 
331 // Electromagnetic Processes /////////////////    219 // Electromagnetic Processes ////////////////////////////////////////////////
332 // all charged particles                          220 // all charged particles
                                                   >> 221 
                                                   >> 222 // gamma
                                                   >> 223 #include "G4PhotoElectricEffect.hh"
                                                   >> 224 #include "G4LivermorePhotoElectricModel.hh"
                                                   >> 225 
                                                   >> 226 #include "G4ComptonScattering.hh"
                                                   >> 227 #include "G4LivermoreComptonModel.hh"
                                                   >> 228 
                                                   >> 229 #include "G4GammaConversion.hh"
                                                   >> 230 #include "G4LivermoreGammaConversionModel.hh"
                                                   >> 231 
                                                   >> 232 #include "G4RayleighScattering.hh" 
                                                   >> 233 #include "G4LivermoreRayleighModel.hh"
                                                   >> 234 
                                                   >> 235 
                                                   >> 236 // e-
                                                   >> 237 #include "G4eMultipleScattering.hh"
                                                   >> 238 
                                                   >> 239 #include "G4eIonisation.hh"
                                                   >> 240 #include "G4LivermoreIonisationModel.hh"
                                                   >> 241 
                                                   >> 242 #include "G4eBremsstrahlung.hh"
                                                   >> 243 #include "G4LivermoreBremsstrahlungModel.hh"
                                                   >> 244 
                                                   >> 245 
                                                   >> 246 // e+
                                                   >> 247 #include "G4eIonisation.hh" 
                                                   >> 248 #include "G4eBremsstrahlung.hh" 
                                                   >> 249 #include "G4eplusAnnihilation.hh"
                                                   >> 250 
                                                   >> 251 
                                                   >> 252 // alpha and GenericIon and deuterons, triton, He3:
                                                   >> 253 
                                                   >> 254 //muon:
                                                   >> 255 #include "G4MuIonisation.hh"
                                                   >> 256 #include "G4MuBremsstrahlung.hh"
                                                   >> 257 #include "G4MuPairProduction.hh"
                                                   >> 258 #include "G4MuonMinusCapture.hh"
                                                   >> 259 
                                                   >> 260 //OTHERS:
                                                   >> 261 #include "G4hIonisation.hh" 
                                                   >> 262 #include "G4hMultipleScattering.hh"
                                                   >> 263 #include "G4hBremsstrahlung.hh"
                                                   >> 264 #include "G4ionIonisation.hh"
                                                   >> 265 #include "G4IonParametrisedLossModel.hh"
                                                   >> 266 
                                                   >> 267 //em process options to allow msc step-limitation to be switched off
                                                   >> 268 #include "G4EmParameters.hh"
                                                   >> 269 #include "G4VAtomDeexcitation.hh"
                                                   >> 270 #include "G4UAtomicDeexcitation.hh"
                                                   >> 271 #include "G4LossTableManager.hh"
                                                   >> 272 
333 void DMXPhysicsList::ConstructEM() {              273 void DMXPhysicsList::ConstructEM() {
334                                                   274   
                                                   >> 275   //set a finer grid of the physic tables in order to improve precision
                                                   >> 276   //former LowEnergy models have 200 bins up to 100 GeV
                                                   >> 277   G4EmParameters* param = G4EmParameters::Instance();
                                                   >> 278   param->SetMaxEnergy(100*GeV);
                                                   >> 279   param->SetNumberOfBinsPerDecade(20);
                                                   >> 280   param->SetMscStepLimitType(fMinimal);
                                                   >> 281   param->SetFluo(true);
                                                   >> 282   param->SetPixe(true);
                                                   >> 283   param->SetAuger(true);
335   G4LossTableManager* man = G4LossTableManager    284   G4LossTableManager* man = G4LossTableManager::Instance();
336   man->SetAtomDeexcitation(new G4UAtomicDeexci << 285   G4VAtomDeexcitation* ad = man->AtomDeexcitation();
                                                   >> 286   if(!ad) {
                                                   >> 287     man->SetAtomDeexcitation(new G4UAtomicDeexcitation());
                                                   >> 288   }
337                                                   289 
338   G4EmParameters* em_params = G4EmParameters:: << 
339                                                << 
340   auto particleIterator=GetParticleIterator();    290   auto particleIterator=GetParticleIterator();
341   particleIterator->reset();                      291   particleIterator->reset();
342   while( (*particleIterator)() ){                 292   while( (*particleIterator)() ){
343     G4ParticleDefinition* particle = particleI    293     G4ParticleDefinition* particle = particleIterator->value();
344     G4ProcessManager* pmanager = particle->Get    294     G4ProcessManager* pmanager = particle->GetProcessManager();
345     G4String particleName = particle->GetParti    295     G4String particleName = particle->GetParticleName();
346     G4String particleType = particle->GetParti    296     G4String particleType = particle->GetParticleType();
347     G4double charge = particle->GetPDGCharge()    297     G4double charge = particle->GetPDGCharge();
348                                                   298     
349     if (particleName == "gamma")                  299     if (particleName == "gamma") 
350       {                                           300       {
351   //gamma                                         301   //gamma
352   G4RayleighScattering* theRayleigh = new G4Ra    302   G4RayleighScattering* theRayleigh = new G4RayleighScattering();
353   pmanager->AddDiscreteProcess(theRayleigh);      303   pmanager->AddDiscreteProcess(theRayleigh);
354                                                   304 
355   G4PhotoElectricEffect* thePhotoElectricEffec    305   G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
356   thePhotoElectricEffect->SetEmModel(new G4Liv    306   thePhotoElectricEffect->SetEmModel(new G4LivermorePhotoElectricModel());
357   pmanager->AddDiscreteProcess(thePhotoElectri    307   pmanager->AddDiscreteProcess(thePhotoElectricEffect);
358                                                   308   
359   G4ComptonScattering* theComptonScattering =     309   G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
360   theComptonScattering->SetEmModel(new G4Liver    310   theComptonScattering->SetEmModel(new G4LivermoreComptonModel());
361   pmanager->AddDiscreteProcess(theComptonScatt    311   pmanager->AddDiscreteProcess(theComptonScattering);
362                                                   312   
363   G4GammaConversion* theGammaConversion = new     313   G4GammaConversion* theGammaConversion = new G4GammaConversion();
364   theGammaConversion->SetEmModel(new G4BetheHe << 314   theGammaConversion->SetEmModel(new G4LivermoreGammaConversionModel());
365   pmanager->AddDiscreteProcess(theGammaConvers    315   pmanager->AddDiscreteProcess(theGammaConversion);
366                                                   316 
367       }                                           317       } 
368     else if (particleName == "e-")                318     else if (particleName == "e-") 
369       {                                           319       {
370   //electron                                      320   //electron
371   // process ordering: AddProcess(name, at res    321   // process ordering: AddProcess(name, at rest, along step, post step)
372   // Multiple scattering                          322   // Multiple scattering
373   G4eMultipleScattering* msc = new G4eMultiple    323   G4eMultipleScattering* msc = new G4eMultipleScattering();
374   em_params->SetMscStepLimitType(fUseDistanceT << 324   msc->SetStepLimitType(fUseDistanceToBoundary);
375   pmanager->AddProcess(msc,-1, 1, -1);            325   pmanager->AddProcess(msc,-1, 1, -1);
376                                                   326 
377   // Ionisation                                   327   // Ionisation
378   G4eIonisation* eIonisation = new G4eIonisati    328   G4eIonisation* eIonisation = new G4eIonisation();
379         G4VEmModel* theIoniLiv = new G4Livermo << 329   eIonisation->SetEmModel(new G4LivermoreIonisationModel());
380         theIoniLiv->SetHighEnergyLimit(0.1*MeV << 330   eIonisation->SetStepFunction(0.2, 100*um); //improved precision in tracking  
381         eIonisation->AddEmModel(0, theIoniLiv, << 331   pmanager->AddProcess(eIonisation,-1, 2, 2);
382   em_params->SetStepFunction(0.2, 100*um); //i << 
383   pmanager->AddProcess(eIonisation,-1, 2, 1);  << 
384                                                   332   
385   // Bremsstrahlung                               333   // Bremsstrahlung
386   G4eBremsstrahlung* eBremsstrahlung = new G4e    334   G4eBremsstrahlung* eBremsstrahlung = new G4eBremsstrahlung();
387   pmanager->AddProcess(eBremsstrahlung, -1,-3, << 335   eBremsstrahlung->SetEmModel(new G4LivermoreBremsstrahlungModel());
                                                   >> 336   pmanager->AddProcess(eBremsstrahlung, -1,-3, 3);
388       }                                           337       } 
389     else if (particleName == "e+")                338     else if (particleName == "e+") 
390       {                                           339       {
391   //positron                                      340   //positron  
392   G4eMultipleScattering* msc = new G4eMultiple    341   G4eMultipleScattering* msc = new G4eMultipleScattering();
393   msc->SetStepLimitType(fUseDistanceToBoundary    342   msc->SetStepLimitType(fUseDistanceToBoundary);
394   pmanager->AddProcess(msc,-1, 1, -1);         << 343   pmanager->AddProcess(msc,-1, 1, 1);
395                                                   344   
396   // Ionisation                                   345   // Ionisation
397   G4eIonisation* eIonisation = new G4eIonisati    346   G4eIonisation* eIonisation = new G4eIonisation();
398   // eIonisation->SetStepFunction(0.2, 100*um) << 347   eIonisation->SetStepFunction(0.2, 100*um); //     
399   pmanager->AddProcess(eIonisation,            << 348   pmanager->AddProcess(eIonisation,                 -1, 2, 2);
400                                                   349 
401   //Bremsstrahlung (use default, no low-energy    350   //Bremsstrahlung (use default, no low-energy available)
402   pmanager->AddProcess(new G4eBremsstrahlung() << 351   pmanager->AddProcess(new G4eBremsstrahlung(), -1,-1, 3);
403                                                   352 
404   //Annihilation                                  353   //Annihilation
405   pmanager->AddProcess(new G4eplusAnnihilation << 354   pmanager->AddProcess(new G4eplusAnnihilation(),0,-1, 4);      
406       }                                           355       } 
407     else if( particleName == "mu+" ||             356     else if( particleName == "mu+" || 
408        particleName == "mu-"    )                 357        particleName == "mu-"    ) 
409       {                                           358       {
410   //muon                                          359   //muon  
411   pmanager->AddProcess(new G4MuMultipleScatter << 360   pmanager->AddProcess(new G4eMultipleScattering,           -1, 1, 1);
412   pmanager->AddProcess(new G4MuIonisation(),   << 361   pmanager->AddProcess(new G4MuIonisation(),          -1, 2, 2);
413   pmanager->AddProcess(new G4MuBremsstrahlung( << 362   pmanager->AddProcess(new G4MuBremsstrahlung(),      -1,-1, 3);
414   pmanager->AddProcess(new G4MuPairProduction( << 363   pmanager->AddProcess(new G4MuPairProduction(),      -1,-1, 4);
415   if( particleName == "mu-" )                     364   if( particleName == "mu-" )
416     pmanager->AddProcess(new G4MuonMinusCaptur    365     pmanager->AddProcess(new G4MuonMinusCapture(), 0,-1,-1);
417       }                                           366       } 
418     else if (particleName == "proton" ||          367     else if (particleName == "proton" || 
419        particleName == "pi+" ||                   368        particleName == "pi+" || 
420        particleName == "pi-")                     369        particleName == "pi-")
421       {                                           370       {
422   //multiple scattering                           371   //multiple scattering
423   pmanager->AddProcess(new G4hMultipleScatteri << 372   pmanager->AddProcess(new G4hMultipleScattering, -1, 1, 1);
424                                                   373       
425   //ionisation                                    374   //ionisation
426   G4hIonisation* hIonisation = new G4hIonisati    375   G4hIonisation* hIonisation = new G4hIonisation();
427   em_params->SetStepFunctionMuHad(0.2, 50*um); << 376   hIonisation->SetStepFunction(0.2, 50*um);
428   pmanager->AddProcess(hIonisation,            << 377   pmanager->AddProcess(hIonisation,                     -1, 2, 2);      
429                                                   378   
430   //bremmstrahlung                                379   //bremmstrahlung
431   pmanager->AddProcess(new G4hBremsstrahlung,  << 380   pmanager->AddProcess(new G4hBremsstrahlung,     -1,-3, 3);
432       }                                           381       }
433     else if(particleName == "alpha"      ||       382     else if(particleName == "alpha"      ||
434        particleName == "deuteron"   ||            383        particleName == "deuteron"   ||
435        particleName == "triton"     ||            384        particleName == "triton"     ||
436        particleName == "He3")                     385        particleName == "He3")
437       {                                           386       {
438   //multiple scattering                           387   //multiple scattering
439   pmanager->AddProcess(new G4hMultipleScatteri << 388   pmanager->AddProcess(new G4hMultipleScattering,-1,1,1);
440                                                   389   
441   //ionisation                                    390   //ionisation
442   G4ionIonisation* ionIoni = new G4ionIonisati    391   G4ionIonisation* ionIoni = new G4ionIonisation();
443   em_params->SetStepFunctionLightIons(0.1, 1*C << 392   ionIoni->SetStepFunction(0.1, 20*um);
444   pmanager->AddProcess(ionIoni,                << 393   pmanager->AddProcess(ionIoni,                   -1, 2, 2);
445   pmanager->AddProcess(new G4NuclearStopping() << 
446       }                                           394       }
447     else if (particleName == "GenericIon")        395     else if (particleName == "GenericIon")
448       {                                           396       {
449   // OBJECT may be dynamically created as eith    397   // OBJECT may be dynamically created as either a GenericIon or nucleus
450   // G4Nucleus exists and therefore has partic    398   // G4Nucleus exists and therefore has particle type nucleus
451   // genericIon:                                  399   // genericIon:
452                                                   400   
453   //multiple scattering                           401   //multiple scattering
454   pmanager->AddProcess(new G4hMultipleScatteri << 402   pmanager->AddProcess(new G4hMultipleScattering,-1,1,1);
455                                                   403 
456   //ionisation                                    404   //ionisation
457   G4ionIonisation* ionIoni = new G4ionIonisati    405   G4ionIonisation* ionIoni = new G4ionIonisation();
458   em_params->SetStepFunctionIons(0.1, 1*CLHEP: << 406   ionIoni->SetEmModel(new G4IonParametrisedLossModel());
459   pmanager->AddProcess(ionIoni,                << 407   ionIoni->SetStepFunction(0.1, 20*um);
460   pmanager->AddProcess(new G4NuclearStopping() << 408   pmanager->AddProcess(ionIoni,                   -1, 2, 2);
461       }                                           409       } 
462                                                   410 
463     else if ((!particle->IsShortLived()) &&       411     else if ((!particle->IsShortLived()) &&
464        (charge != 0.0) &&                         412        (charge != 0.0) && 
465        (particle->GetParticleName() != "charge    413        (particle->GetParticleName() != "chargedgeantino")) 
466       {                                           414       {
467   //all others charged particles except geanti    415   //all others charged particles except geantino
468         G4hMultipleScattering* aMultipleScatte    416         G4hMultipleScattering* aMultipleScattering = new G4hMultipleScattering();
469         G4hIonisation* ahadronIon = new G4hIon    417         G4hIonisation* ahadronIon = new G4hIonisation();
470                                                   418   
471   //multiple scattering                           419   //multiple scattering
472   pmanager->AddProcess(aMultipleScattering,-1, << 420   pmanager->AddProcess(aMultipleScattering,-1,1,1);
473                                                   421 
474   //ionisation                                    422   //ionisation
475   pmanager->AddProcess(ahadronIon,       -1,2, << 423   pmanager->AddProcess(ahadronIon,       -1,2,2);      
476       }                                           424       }
                                                   >> 425     
477   }                                               426   }
478 }                                                 427 }
479                                                   428 
                                                   >> 429 
480 // Optical Processes /////////////////////////    430 // Optical Processes ////////////////////////////////////////////////////////
                                                   >> 431 #include "G4Scintillation.hh"
                                                   >> 432 #include "G4OpAbsorption.hh"
                                                   >> 433 //#include "G4OpRayleigh.hh"
                                                   >> 434 #include "G4OpBoundaryProcess.hh"
                                                   >> 435 
481 void DMXPhysicsList::ConstructOp()                436 void DMXPhysicsList::ConstructOp() 
482 {                                                 437 {
483   G4OpticalParameters* opParams = G4OpticalPar << 438   // default scintillation process
484   G4Scintillation* theScintProcessDef = new G4    439   G4Scintillation* theScintProcessDef = new G4Scintillation("Scintillation");
485   opParams->SetScintTrackSecondariesFirst(true << 440   // theScintProcessDef->DumpPhysicsTable();
486   opParams->SetScintByParticleType(true);      << 441   theScintProcessDef->SetTrackSecondariesFirst(true);
                                                   >> 442   theScintProcessDef->SetScintillationYieldFactor(1.0); //
                                                   >> 443   theScintProcessDef->SetScintillationExcitationRatio(0.0); //
                                                   >> 444   theScintProcessDef->SetVerboseLevel(OpVerbLevel);
                                                   >> 445 
                                                   >> 446   // scintillation process for alpha:
                                                   >> 447   G4Scintillation* theScintProcessAlpha = new G4Scintillation("Scintillation");
                                                   >> 448   // theScintProcessNuc->DumpPhysicsTable();
                                                   >> 449   theScintProcessAlpha->SetTrackSecondariesFirst(true);
                                                   >> 450   theScintProcessAlpha->SetScintillationYieldFactor(1.1);
                                                   >> 451   theScintProcessAlpha->SetScintillationExcitationRatio(1.0);
                                                   >> 452   theScintProcessAlpha->SetVerboseLevel(OpVerbLevel);
                                                   >> 453 
                                                   >> 454   // scintillation process for heavy nuclei
                                                   >> 455   G4Scintillation* theScintProcessNuc = new G4Scintillation("Scintillation");
                                                   >> 456   // theScintProcessNuc->DumpPhysicsTable();
                                                   >> 457   theScintProcessNuc->SetTrackSecondariesFirst(true);
                                                   >> 458   theScintProcessNuc->SetScintillationYieldFactor(0.2);
                                                   >> 459   theScintProcessNuc->SetScintillationExcitationRatio(1.0);
                                                   >> 460   theScintProcessNuc->SetVerboseLevel(OpVerbLevel);
487                                                   461 
488   // optical processes                            462   // optical processes
489   G4OpAbsorption* theAbsorptionProcess = new G    463   G4OpAbsorption* theAbsorptionProcess = new G4OpAbsorption();
                                                   >> 464   //  G4OpRayleigh* theRayleighScatteringProcess = new G4OpRayleigh();
490   G4OpBoundaryProcess* theBoundaryProcess = ne    465   G4OpBoundaryProcess* theBoundaryProcess = new G4OpBoundaryProcess();
                                                   >> 466   //  theAbsorptionProcess->DumpPhysicsTable();
                                                   >> 467   //  theRayleighScatteringProcess->DumpPhysicsTable();
                                                   >> 468   theAbsorptionProcess->SetVerboseLevel(OpVerbLevel);
                                                   >> 469   // theRayleighScatteringProcess->SetVerboseLevel(OpVerbLevel);
                                                   >> 470   theBoundaryProcess->SetVerboseLevel(OpVerbLevel);
491                                                   471 
492   auto particleIterator=GetParticleIterator();    472   auto particleIterator=GetParticleIterator();
493   particleIterator->reset();                      473   particleIterator->reset();
494   while( (*particleIterator)() )                  474   while( (*particleIterator)() )
495     {                                             475     {
496       G4ParticleDefinition* particle = particl    476       G4ParticleDefinition* particle = particleIterator->value();
497       G4ProcessManager* pmanager = particle->G    477       G4ProcessManager* pmanager = particle->GetProcessManager();
498       G4String particleName = particle->GetPar    478       G4String particleName = particle->GetParticleName();
499       if (theScintProcessDef->IsApplicable(*pa    479       if (theScintProcessDef->IsApplicable(*particle)) {
500         pmanager->AddProcess(theScintProcessDe << 480   //      if(particle->GetPDGMass() > 5.0*GeV) 
501         pmanager->SetProcessOrderingToLast(the << 481   if(particle->GetParticleName() == "GenericIon") {
502         pmanager->SetProcessOrderingToLast(the << 482     pmanager->AddProcess(theScintProcessNuc); // AtRestDiscrete
                                                   >> 483     pmanager->SetProcessOrderingToLast(theScintProcessNuc,idxAtRest);
                                                   >> 484     pmanager->SetProcessOrderingToLast(theScintProcessNuc,idxPostStep);
                                                   >> 485   }   
                                                   >> 486   else if(particle->GetParticleName() == "alpha") {
                                                   >> 487     pmanager->AddProcess(theScintProcessAlpha);
                                                   >> 488     pmanager->SetProcessOrderingToLast(theScintProcessAlpha,idxAtRest);
                                                   >> 489     pmanager->SetProcessOrderingToLast(theScintProcessAlpha,idxPostStep);
                                                   >> 490   }
                                                   >> 491   else {
                                                   >> 492     pmanager->AddProcess(theScintProcessDef);
                                                   >> 493     pmanager->SetProcessOrderingToLast(theScintProcessDef,idxAtRest);
                                                   >> 494     pmanager->SetProcessOrderingToLast(theScintProcessDef,idxPostStep);
                                                   >> 495   }   
503       }                                           496       }
504                                                   497       
505       if (particleName == "opticalphoton") {      498       if (particleName == "opticalphoton") {
506   pmanager->AddDiscreteProcess(theAbsorptionPr    499   pmanager->AddDiscreteProcess(theAbsorptionProcess);
                                                   >> 500   //  pmanager->AddDiscreteProcess(theRayleighScatteringProcess);
507   pmanager->AddDiscreteProcess(theBoundaryProc    501   pmanager->AddDiscreteProcess(theBoundaryProcess);
508       }                                           502       }
509     }                                             503     }
510 }                                                 504 }
511                                                   505 
                                                   >> 506 
512 // Hadronic processes ////////////////////////    507 // Hadronic processes ////////////////////////////////////////////////////////
513                                                   508 
                                                   >> 509 // Elastic processes:
                                                   >> 510 #include "G4HadronElasticProcess.hh"
                                                   >> 511 #include "G4ChipsElasticModel.hh"
                                                   >> 512 #include "G4ElasticHadrNucleusHE.hh"
                                                   >> 513 
                                                   >> 514 // Inelastic processes:
                                                   >> 515 #include "G4PionPlusInelasticProcess.hh"
                                                   >> 516 #include "G4PionMinusInelasticProcess.hh"
                                                   >> 517 #include "G4KaonPlusInelasticProcess.hh"
                                                   >> 518 #include "G4KaonZeroSInelasticProcess.hh"
                                                   >> 519 #include "G4KaonZeroLInelasticProcess.hh"
                                                   >> 520 #include "G4KaonMinusInelasticProcess.hh"
                                                   >> 521 #include "G4ProtonInelasticProcess.hh"
                                                   >> 522 #include "G4AntiProtonInelasticProcess.hh"
                                                   >> 523 #include "G4NeutronInelasticProcess.hh"
                                                   >> 524 #include "G4AntiNeutronInelasticProcess.hh"
                                                   >> 525 #include "G4DeuteronInelasticProcess.hh"
                                                   >> 526 #include "G4TritonInelasticProcess.hh"
                                                   >> 527 #include "G4AlphaInelasticProcess.hh"
                                                   >> 528 
                                                   >> 529 // High energy FTFP model and Bertini cascade
                                                   >> 530 #include "G4FTFModel.hh"
                                                   >> 531 #include "G4LundStringFragmentation.hh"
                                                   >> 532 #include "G4ExcitedStringDecay.hh"
                                                   >> 533 #include "G4PreCompoundModel.hh"
                                                   >> 534 #include "G4GeneratorPrecompoundInterface.hh"
                                                   >> 535 #include "G4TheoFSGenerator.hh"
                                                   >> 536 #include "G4CascadeInterface.hh"
                                                   >> 537 
                                                   >> 538 // Cross sections
                                                   >> 539 #include "G4VCrossSectionDataSet.hh"
                                                   >> 540 #include "G4CrossSectionDataSetRegistry.hh"
                                                   >> 541 
                                                   >> 542 #include "G4CrossSectionElastic.hh"
                                                   >> 543 #include "G4BGGPionElasticXS.hh"
                                                   >> 544 #include "G4AntiNuclElastic.hh"
                                                   >> 545 
                                                   >> 546 #include "G4CrossSectionInelastic.hh"
                                                   >> 547 #include "G4PiNuclearCrossSection.hh"
                                                   >> 548 #include "G4CrossSectionPairGG.hh"
                                                   >> 549 #include "G4BGGNucleonInelasticXS.hh"
                                                   >> 550 #include "G4ComponentAntiNuclNuclearXS.hh"
                                                   >> 551 #include "G4ComponentGGNuclNuclXsc.hh"
                                                   >> 552 
                                                   >> 553 #include "G4HadronElastic.hh"
                                                   >> 554 #include "G4HadronCaptureProcess.hh"
                                                   >> 555 
                                                   >> 556 // Neutron high-precision models: <20 MeV
                                                   >> 557 #include "G4ParticleHPElastic.hh"
                                                   >> 558 #include "G4ParticleHPElasticData.hh"
                                                   >> 559 #include "G4ParticleHPCapture.hh"
                                                   >> 560 #include "G4ParticleHPCaptureData.hh"
                                                   >> 561 #include "G4ParticleHPInelastic.hh"
                                                   >> 562 #include "G4ParticleHPInelasticData.hh"
                                                   >> 563 
                                                   >> 564 // Stopping processes
                                                   >> 565 #include "G4PiMinusAbsorptionBertini.hh"
                                                   >> 566 #include "G4KaonMinusAbsorptionBertini.hh"
                                                   >> 567 #include "G4AntiProtonAbsorptionFritiof.hh"
                                                   >> 568 #include "G4HadronicParameters.hh"
                                                   >> 569 
                                                   >> 570 
514 void DMXPhysicsList::ConstructHad()               571 void DMXPhysicsList::ConstructHad() 
515 {                                                 572 {
516   //Elastic models                                573   //Elastic models
                                                   >> 574   const G4double elastic_elimitPi = 1.0*GeV;
                                                   >> 575 
517   G4HadronElastic* elastic_lhep0 = new G4Hadro    576   G4HadronElastic* elastic_lhep0 = new G4HadronElastic();
                                                   >> 577   G4HadronElastic* elastic_lhep1 = new G4HadronElastic();
                                                   >> 578   elastic_lhep1->SetMaxEnergy( elastic_elimitPi );
518   G4ChipsElasticModel* elastic_chip = new G4Ch    579   G4ChipsElasticModel* elastic_chip = new G4ChipsElasticModel();
519   G4ElasticHadrNucleusHE* elastic_he = new G4E    580   G4ElasticHadrNucleusHE* elastic_he = new G4ElasticHadrNucleusHE(); 
                                                   >> 581   elastic_he->SetMinEnergy( elastic_elimitPi );
                                                   >> 582 
520                                                   583   
521   // Inelastic scattering                         584   // Inelastic scattering
522   const G4double theFTFMin0 =    0.0*GeV;         585   const G4double theFTFMin0 =    0.0*GeV;
523   const G4double theFTFMin1 =    3.0*GeV;      << 586   const G4double theFTFMin1 =    4.0*GeV;
524   const G4double theFTFMax = G4HadronicParamet    587   const G4double theFTFMax = G4HadronicParameters::Instance()->GetMaxEnergy();
525   const G4double theBERTMin0 =   0.0*GeV;         588   const G4double theBERTMin0 =   0.0*GeV;
526   const G4double theBERTMin1 =  19.0*MeV;         589   const G4double theBERTMin1 =  19.0*MeV;
527   const G4double theBERTMax =    6.0*GeV;      << 590   const G4double theBERTMax =    5.0*GeV;
528   const G4double theHPMin =      0.0*GeV;         591   const G4double theHPMin =      0.0*GeV;
529   const G4double theHPMax =     20.0*MeV;         592   const G4double theHPMax =     20.0*MeV;
530                                                   593 
531   G4FTFModel * theStringModel = new G4FTFModel    594   G4FTFModel * theStringModel = new G4FTFModel;
532   G4ExcitedStringDecay * theStringDecay = new     595   G4ExcitedStringDecay * theStringDecay = new G4ExcitedStringDecay( new G4LundStringFragmentation );
533   theStringModel->SetFragmentationModel( theSt    596   theStringModel->SetFragmentationModel( theStringDecay );
534   G4PreCompoundModel * thePreEquilib = new G4P    597   G4PreCompoundModel * thePreEquilib = new G4PreCompoundModel( new G4ExcitationHandler );
535   G4GeneratorPrecompoundInterface * theCascade    598   G4GeneratorPrecompoundInterface * theCascade = new G4GeneratorPrecompoundInterface( thePreEquilib );
536                                                   599 
537   G4TheoFSGenerator * theFTFModel0 = new G4The    600   G4TheoFSGenerator * theFTFModel0 = new G4TheoFSGenerator( "FTFP" );
538   theFTFModel0->SetHighEnergyGenerator( theStr    601   theFTFModel0->SetHighEnergyGenerator( theStringModel );
539   theFTFModel0->SetTransport( theCascade );       602   theFTFModel0->SetTransport( theCascade );
540   theFTFModel0->SetMinEnergy( theFTFMin0 );       603   theFTFModel0->SetMinEnergy( theFTFMin0 );
541   theFTFModel0->SetMaxEnergy( theFTFMax );        604   theFTFModel0->SetMaxEnergy( theFTFMax );
542                                                   605 
543   G4TheoFSGenerator * theFTFModel1 = new G4The    606   G4TheoFSGenerator * theFTFModel1 = new G4TheoFSGenerator( "FTFP" );
544   theFTFModel1->SetHighEnergyGenerator( theStr    607   theFTFModel1->SetHighEnergyGenerator( theStringModel );
545   theFTFModel1->SetTransport( theCascade );       608   theFTFModel1->SetTransport( theCascade );
546   theFTFModel1->SetMinEnergy( theFTFMin1 );       609   theFTFModel1->SetMinEnergy( theFTFMin1 );
547   theFTFModel1->SetMaxEnergy( theFTFMax );        610   theFTFModel1->SetMaxEnergy( theFTFMax );
548                                                   611 
549   G4CascadeInterface * theBERTModel0 = new G4C    612   G4CascadeInterface * theBERTModel0 = new G4CascadeInterface;
550   theBERTModel0->SetMinEnergy( theBERTMin0 );     613   theBERTModel0->SetMinEnergy( theBERTMin0 );
551   theBERTModel0->SetMaxEnergy( theBERTMax );      614   theBERTModel0->SetMaxEnergy( theBERTMax );
552                                                   615 
553   G4CascadeInterface * theBERTModel1 = new G4C    616   G4CascadeInterface * theBERTModel1 = new G4CascadeInterface;
554   theBERTModel1->SetMinEnergy( theBERTMin1 );     617   theBERTModel1->SetMinEnergy( theBERTMin1 );
555   theBERTModel1->SetMaxEnergy( theBERTMax );      618   theBERTModel1->SetMaxEnergy( theBERTMax );
556                                                   619 
                                                   >> 620   G4VCrossSectionDataSet * thePiData = new G4CrossSectionPairGG( new G4PiNuclearCrossSection, 91*GeV );
557   G4VCrossSectionDataSet * theAntiNucleonData     621   G4VCrossSectionDataSet * theAntiNucleonData = new G4CrossSectionInelastic( new G4ComponentAntiNuclNuclearXS );
558   G4ComponentGGNuclNuclXsc * ggNuclNuclXsec =     622   G4ComponentGGNuclNuclXsc * ggNuclNuclXsec = new G4ComponentGGNuclNuclXsc();
559   G4VCrossSectionDataSet * theGGNuclNuclData =    623   G4VCrossSectionDataSet * theGGNuclNuclData = new G4CrossSectionInelastic(ggNuclNuclXsec);
560   G4VCrossSectionDataSet * theGGNNEl = new G4C << 
561   G4ComponentGGHadronNucleusXsc * ggHNXsec = n << 
562   G4VCrossSectionDataSet * theGGHNEl = new G4C << 
563   G4VCrossSectionDataSet * theGGHNInel = new G << 
564                                                   624 
565   auto particleIterator=GetParticleIterator();    625   auto particleIterator=GetParticleIterator();
566   particleIterator->reset();                      626   particleIterator->reset();
567   while ((*particleIterator)())                   627   while ((*particleIterator)())
568     {                                             628     {
569       G4ParticleDefinition* particle = particl    629       G4ParticleDefinition* particle = particleIterator->value();
570       G4ProcessManager* pmanager = particle->G    630       G4ProcessManager* pmanager = particle->GetProcessManager();
571       G4String particleName = particle->GetPar    631       G4String particleName = particle->GetParticleName();
572                                                   632 
573       if (particleName == "pi+")                  633       if (particleName == "pi+") 
574   {                                               634   {
575     // Elastic scattering                         635     // Elastic scattering
576           G4HadronElasticProcess* theElasticPr    636           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
577           theElasticProcess->AddDataSet( new G    637           theElasticProcess->AddDataSet( new G4BGGPionElasticXS( particle ) );
                                                   >> 638           theElasticProcess->RegisterMe( elastic_lhep1 );
578           theElasticProcess->RegisterMe( elast    639           theElasticProcess->RegisterMe( elastic_he );
579     pmanager->AddDiscreteProcess( theElasticPr    640     pmanager->AddDiscreteProcess( theElasticProcess );
580     //Inelastic scattering                        641     //Inelastic scattering
581     G4HadronInelasticProcess* theInelasticProc << 642     G4PionPlusInelasticProcess* theInelasticProcess = 
582       new G4HadronInelasticProcess( "inelastic << 643       new G4PionPlusInelasticProcess("inelastic");
583     theInelasticProcess->AddDataSet( new G4BGG << 644     theInelasticProcess->AddDataSet( thePiData );
584     theInelasticProcess->RegisterMe( theFTFMod    645     theInelasticProcess->RegisterMe( theFTFModel1 );
585           theInelasticProcess->RegisterMe( the    646           theInelasticProcess->RegisterMe( theBERTModel0 );
586     pmanager->AddDiscreteProcess( theInelastic    647     pmanager->AddDiscreteProcess( theInelasticProcess );
587   }                                               648   } 
588                                                   649 
589       else if (particleName == "pi-")             650       else if (particleName == "pi-") 
590   {                                               651   {
591     // Elastic scattering                         652     // Elastic scattering
592           G4HadronElasticProcess* theElasticPr    653           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
593           theElasticProcess->AddDataSet( new G    654           theElasticProcess->AddDataSet( new G4BGGPionElasticXS( particle ) );
                                                   >> 655           theElasticProcess->RegisterMe( elastic_lhep1 );
594           theElasticProcess->RegisterMe( elast    656           theElasticProcess->RegisterMe( elastic_he );
595     pmanager->AddDiscreteProcess( theElasticPr    657     pmanager->AddDiscreteProcess( theElasticProcess );
596     //Inelastic scattering                        658     //Inelastic scattering
597     G4HadronInelasticProcess* theInelasticProc << 659     G4PionMinusInelasticProcess* theInelasticProcess = 
598       new G4HadronInelasticProcess( "inelastic << 660       new G4PionMinusInelasticProcess("inelastic");
599     theInelasticProcess->AddDataSet( new G4BGG << 661     theInelasticProcess->AddDataSet( thePiData );
600     theInelasticProcess->RegisterMe( theFTFMod    662     theInelasticProcess->RegisterMe( theFTFModel1 );
601           theInelasticProcess->RegisterMe( the    663           theInelasticProcess->RegisterMe( theBERTModel0 );
602     pmanager->AddDiscreteProcess( theInelastic    664     pmanager->AddDiscreteProcess( theInelasticProcess );    
603     //Absorption                                  665     //Absorption
604     pmanager->AddRestProcess(new G4HadronicAbs << 666     pmanager->AddRestProcess(new G4PiMinusAbsorptionBertini, ordDefault);
605   }                                               667   }
                                                   >> 668       
606       else if (particleName == "kaon+")           669       else if (particleName == "kaon+") 
607   {                                               670   {
608     // Elastic scattering                         671     // Elastic scattering
609           G4HadronElasticProcess* theElasticPr    672           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
610     theElasticProcess->AddDataSet( theGGHNEl ) << 
611           theElasticProcess->RegisterMe( elast    673           theElasticProcess->RegisterMe( elastic_lhep0 );
612     pmanager->AddDiscreteProcess( theElasticPr    674     pmanager->AddDiscreteProcess( theElasticProcess );
613           // Inelastic scattering                 675           // Inelastic scattering 
614     G4HadronInelasticProcess* theInelasticProc << 676     G4KaonPlusInelasticProcess* theInelasticProcess = 
615       new G4HadronInelasticProcess( "inelastic << 677       new G4KaonPlusInelasticProcess("inelastic");
616     theInelasticProcess->AddDataSet( theGGHNIn << 678     theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->
                                                   >> 679              GetCrossSectionDataSet(G4ChipsKaonPlusInelasticXS::Default_Name()));
617     theInelasticProcess->RegisterMe( theFTFMod    680     theInelasticProcess->RegisterMe( theFTFModel1 );
618           theInelasticProcess->RegisterMe( the    681           theInelasticProcess->RegisterMe( theBERTModel0 );
619     pmanager->AddDiscreteProcess( theInelastic    682     pmanager->AddDiscreteProcess( theInelasticProcess );
620   }                                            << 683   }
                                                   >> 684       
621       else if (particleName == "kaon0S")          685       else if (particleName == "kaon0S") 
622   {                                               686   {
623     // Elastic scattering                         687     // Elastic scattering
624           G4HadronElasticProcess* theElasticPr    688           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
625     theElasticProcess->AddDataSet( theGGHNEl ) << 
626           theElasticProcess->RegisterMe( elast    689           theElasticProcess->RegisterMe( elastic_lhep0 );
627     pmanager->AddDiscreteProcess( theElasticPr    690     pmanager->AddDiscreteProcess( theElasticProcess );
628           // Inelastic scattering                 691           // Inelastic scattering  
629     G4HadronInelasticProcess* theInelasticProc << 692     G4KaonZeroSInelasticProcess* theInelasticProcess = 
630       new G4HadronInelasticProcess( "inelastic << 693       new G4KaonZeroSInelasticProcess("inelastic");
631     theInelasticProcess->AddDataSet( theGGHNIn << 694     theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->
                                                   >> 695              GetCrossSectionDataSet(G4ChipsKaonZeroInelasticXS::Default_Name()));
632     theInelasticProcess->RegisterMe( theFTFMod    696     theInelasticProcess->RegisterMe( theFTFModel1 );
633           theInelasticProcess->RegisterMe( the    697           theInelasticProcess->RegisterMe( theBERTModel0 );
634     pmanager->AddDiscreteProcess( theInelastic    698     pmanager->AddDiscreteProcess( theInelasticProcess );    
635   }                                               699   }
636                                                   700 
637       else if (particleName == "kaon0L")          701       else if (particleName == "kaon0L") 
638   {                                               702   {
639     // Elastic scattering                         703     // Elastic scattering
640           G4HadronElasticProcess* theElasticPr    704           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
641     theElasticProcess->AddDataSet( theGGHNEl ) << 
642           theElasticProcess->RegisterMe( elast    705           theElasticProcess->RegisterMe( elastic_lhep0 );
643     pmanager->AddDiscreteProcess( theElasticPr    706     pmanager->AddDiscreteProcess( theElasticProcess );
644     // Inelastic scattering                       707     // Inelastic scattering
645     G4HadronInelasticProcess* theInelasticProc << 708     G4KaonZeroLInelasticProcess* theInelasticProcess = 
646       new G4HadronInelasticProcess( "inelastic << 709       new G4KaonZeroLInelasticProcess("inelastic");
647     theInelasticProcess->AddDataSet( theGGHNIn << 710     theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->
                                                   >> 711              GetCrossSectionDataSet(G4ChipsKaonZeroInelasticXS::Default_Name()));
648     theInelasticProcess->RegisterMe( theFTFMod    712     theInelasticProcess->RegisterMe( theFTFModel1 );
649           theInelasticProcess->RegisterMe( the    713           theInelasticProcess->RegisterMe( theBERTModel0 ); 
650     pmanager->AddDiscreteProcess( theInelastic    714     pmanager->AddDiscreteProcess( theInelasticProcess );    
651   }                                               715   }
652                                                   716 
653       else if (particleName == "kaon-")           717       else if (particleName == "kaon-") 
654   {                                               718   {
655     // Elastic scattering                         719     // Elastic scattering
656           G4HadronElasticProcess* theElasticPr    720           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
657     theElasticProcess->AddDataSet( theGGHNEl ) << 
658           theElasticProcess->RegisterMe( elast    721           theElasticProcess->RegisterMe( elastic_lhep0 );
659     pmanager->AddDiscreteProcess( theElasticPr    722     pmanager->AddDiscreteProcess( theElasticProcess );
660           // Inelastic scattering                 723           // Inelastic scattering
661     G4HadronInelasticProcess* theInelasticProc << 724     G4KaonMinusInelasticProcess* theInelasticProcess = 
662       new G4HadronInelasticProcess( "inelastic << 725       new G4KaonMinusInelasticProcess("inelastic"); 
663           theInelasticProcess->AddDataSet( the << 726           theInelasticProcess->AddDataSet( G4CrossSectionDataSetRegistry::Instance()->
                                                   >> 727              GetCrossSectionDataSet(G4ChipsKaonMinusInelasticXS::Default_Name()));
664     theInelasticProcess->RegisterMe( theFTFMod    728     theInelasticProcess->RegisterMe( theFTFModel1 );
665           theInelasticProcess->RegisterMe( the    729           theInelasticProcess->RegisterMe( theBERTModel0 );
666     pmanager->AddDiscreteProcess( theInelastic    730     pmanager->AddDiscreteProcess( theInelasticProcess );
667     pmanager->AddRestProcess(new G4HadronicAbs << 731     pmanager->AddRestProcess(new G4KaonMinusAbsorptionBertini, ordDefault);
668   }                                               732   }
669                                                   733 
670       else if (particleName == "proton")          734       else if (particleName == "proton") 
671   {                                               735   {
672     // Elastic scattering                         736     // Elastic scattering
673           G4HadronElasticProcess* theElasticPr    737           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
674           theElasticProcess->AddDataSet( new G << 738           theElasticProcess->AddDataSet(G4CrossSectionDataSetRegistry::Instance()->
                                                   >> 739           GetCrossSectionDataSet(G4ChipsProtonElasticXS::Default_Name()));
675           theElasticProcess->RegisterMe( elast    740           theElasticProcess->RegisterMe( elastic_chip );
676     pmanager->AddDiscreteProcess( theElasticPr    741     pmanager->AddDiscreteProcess( theElasticProcess );
677     // Inelastic scattering                       742     // Inelastic scattering
678     G4HadronInelasticProcess* theInelasticProc << 743     G4ProtonInelasticProcess* theInelasticProcess = 
679       new G4HadronInelasticProcess( "inelastic << 744       new G4ProtonInelasticProcess("inelastic");
680     theInelasticProcess->AddDataSet( new G4BGG    745     theInelasticProcess->AddDataSet( new G4BGGNucleonInelasticXS( G4Proton::Proton() ) );
681     theInelasticProcess->RegisterMe( theFTFMod    746     theInelasticProcess->RegisterMe( theFTFModel1 );
682           theInelasticProcess->RegisterMe( the    747           theInelasticProcess->RegisterMe( theBERTModel0 );
683     pmanager->AddDiscreteProcess( theInelastic    748     pmanager->AddDiscreteProcess( theInelasticProcess );
684   }                                               749   }
685       else if (particleName == "anti_proton")     750       else if (particleName == "anti_proton") 
686   {                                               751   {
687     // Elastic scattering                         752     // Elastic scattering
688           const G4double elastic_elimitAntiNuc    753           const G4double elastic_elimitAntiNuc = 100.0*MeV;
689           G4AntiNuclElastic* elastic_anuc = ne    754           G4AntiNuclElastic* elastic_anuc = new G4AntiNuclElastic();
690           elastic_anuc->SetMinEnergy( elastic_    755           elastic_anuc->SetMinEnergy( elastic_elimitAntiNuc );
691           G4CrossSectionElastic* elastic_anucx    756           G4CrossSectionElastic* elastic_anucxs = new G4CrossSectionElastic( elastic_anuc->GetComponentCrossSection() );
692           G4HadronElastic* elastic_lhep2 = new    757           G4HadronElastic* elastic_lhep2 = new G4HadronElastic();
693           elastic_lhep2->SetMaxEnergy( elastic    758           elastic_lhep2->SetMaxEnergy( elastic_elimitAntiNuc );
694           G4HadronElasticProcess* theElasticPr    759           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
695           theElasticProcess->AddDataSet( elast    760           theElasticProcess->AddDataSet( elastic_anucxs );
696           theElasticProcess->RegisterMe( elast    761           theElasticProcess->RegisterMe( elastic_lhep2 );
697           theElasticProcess->RegisterMe( elast    762           theElasticProcess->RegisterMe( elastic_anuc );
698     pmanager->AddDiscreteProcess( theElasticPr    763     pmanager->AddDiscreteProcess( theElasticProcess );
699     // Inelastic scattering                       764     // Inelastic scattering
700     G4HadronInelasticProcess* theInelasticProc << 765     G4AntiProtonInelasticProcess* theInelasticProcess = 
701       new G4HadronInelasticProcess( "inelastic << 766       new G4AntiProtonInelasticProcess("inelastic");
702     theInelasticProcess->AddDataSet( theAntiNu    767     theInelasticProcess->AddDataSet( theAntiNucleonData );
703     theInelasticProcess->RegisterMe( theFTFMod    768     theInelasticProcess->RegisterMe( theFTFModel0 );
704     pmanager->AddDiscreteProcess( theInelastic    769     pmanager->AddDiscreteProcess( theInelasticProcess );
705     // Absorption                                 770     // Absorption
706     pmanager->AddRestProcess(new G4HadronicAbs << 771     pmanager->AddRestProcess(new G4AntiProtonAbsorptionFritiof, ordDefault);
707   }                                               772   }
                                                   >> 773 
708       else if (particleName == "neutron") {       774       else if (particleName == "neutron") {
709   // elastic scattering                           775   // elastic scattering
710   G4HadronElasticProcess* theElasticProcess =     776   G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
711         theElasticProcess->AddDataSet(new G4Ne << 777         theElasticProcess->AddDataSet(G4CrossSectionDataSetRegistry::Instance()->GetCrossSectionDataSet(G4ChipsNeutronElasticXS::Default_Name()));
712         G4HadronElastic* elastic_neutronChipsM    778         G4HadronElastic* elastic_neutronChipsModel = new G4ChipsElasticModel();
713   elastic_neutronChipsModel->SetMinEnergy( 19.    779   elastic_neutronChipsModel->SetMinEnergy( 19.0*MeV );
714         theElasticProcess->RegisterMe( elastic    780         theElasticProcess->RegisterMe( elastic_neutronChipsModel );
715   G4ParticleHPElastic * theElasticNeutronHP =     781   G4ParticleHPElastic * theElasticNeutronHP = new G4ParticleHPElastic;
716         theElasticNeutronHP->SetMinEnergy( the    782         theElasticNeutronHP->SetMinEnergy( theHPMin );
717         theElasticNeutronHP->SetMaxEnergy( the    783         theElasticNeutronHP->SetMaxEnergy( theHPMax );
718   theElasticProcess->RegisterMe( theElasticNeu    784   theElasticProcess->RegisterMe( theElasticNeutronHP );
719   theElasticProcess->AddDataSet( new G4Particl    785   theElasticProcess->AddDataSet( new G4ParticleHPElasticData );
720   pmanager->AddDiscreteProcess( theElasticProc    786   pmanager->AddDiscreteProcess( theElasticProcess );
721   // inelastic scattering                         787   // inelastic scattering   
722   G4HadronInelasticProcess* theInelasticProces << 788   G4NeutronInelasticProcess* theInelasticProcess =
723     new G4HadronInelasticProcess( "inelastic", << 789     new G4NeutronInelasticProcess("inelastic");
724   theInelasticProcess->AddDataSet( new G4Neutr << 790   theInelasticProcess->AddDataSet( new G4BGGNucleonInelasticXS( G4Neutron::Neutron() ) );
725   theInelasticProcess->RegisterMe( theFTFModel    791   theInelasticProcess->RegisterMe( theFTFModel1 );
726         theInelasticProcess->RegisterMe( theBE    792         theInelasticProcess->RegisterMe( theBERTModel1 );
727   G4ParticleHPInelastic * theNeutronInelasticH    793   G4ParticleHPInelastic * theNeutronInelasticHPModel = new G4ParticleHPInelastic;
728         theNeutronInelasticHPModel->SetMinEner    794         theNeutronInelasticHPModel->SetMinEnergy( theHPMin );
729         theNeutronInelasticHPModel->SetMaxEner    795         theNeutronInelasticHPModel->SetMaxEnergy( theHPMax );
730   theInelasticProcess->RegisterMe( theNeutronI    796   theInelasticProcess->RegisterMe( theNeutronInelasticHPModel );
731   theInelasticProcess->AddDataSet( new G4Parti    797   theInelasticProcess->AddDataSet( new G4ParticleHPInelasticData );
732   pmanager->AddDiscreteProcess(theInelasticPro    798   pmanager->AddDiscreteProcess(theInelasticProcess);
733   // capture                                      799   // capture
734   G4NeutronCaptureProcess* theCaptureProcess = << 800   G4HadronCaptureProcess* theCaptureProcess =
735     new G4NeutronCaptureProcess;               << 801     new G4HadronCaptureProcess;
736   G4ParticleHPCapture * theLENeutronCaptureMod    802   G4ParticleHPCapture * theLENeutronCaptureModel = new G4ParticleHPCapture;
737   theLENeutronCaptureModel->SetMinEnergy(theHP    803   theLENeutronCaptureModel->SetMinEnergy(theHPMin);
738   theLENeutronCaptureModel->SetMaxEnergy(theHP    804   theLENeutronCaptureModel->SetMaxEnergy(theHPMax);
739   theCaptureProcess->RegisterMe(theLENeutronCa    805   theCaptureProcess->RegisterMe(theLENeutronCaptureModel);
740   theCaptureProcess->AddDataSet( new G4Particl    806   theCaptureProcess->AddDataSet( new G4ParticleHPCaptureData);
741   pmanager->AddDiscreteProcess(theCaptureProce    807   pmanager->AddDiscreteProcess(theCaptureProcess);
                                                   >> 808 
742       }                                           809       }
743       else if (particleName == "anti_neutron")    810       else if (particleName == "anti_neutron") 
744   {                                               811   {
745     // Elastic scattering                         812     // Elastic scattering
746           G4HadronElasticProcess* theElasticPr    813           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
747     theElasticProcess->AddDataSet( theGGHNEl ) << 
748           theElasticProcess->RegisterMe( elast    814           theElasticProcess->RegisterMe( elastic_lhep0 );
749     pmanager->AddDiscreteProcess( theElasticPr    815     pmanager->AddDiscreteProcess( theElasticProcess );
750           // Inelastic scattering (include ann    816           // Inelastic scattering (include annihilation on-fly)
751     G4HadronInelasticProcess* theInelasticProc << 817     G4AntiNeutronInelasticProcess* theInelasticProcess = 
752       new G4HadronInelasticProcess( "inelastic << 818       new G4AntiNeutronInelasticProcess("inelastic");
753     theInelasticProcess->AddDataSet( theAntiNu    819     theInelasticProcess->AddDataSet( theAntiNucleonData );
754     theInelasticProcess->RegisterMe( theFTFMod    820     theInelasticProcess->RegisterMe( theFTFModel0 );
755     pmanager->AddDiscreteProcess( theInelastic    821     pmanager->AddDiscreteProcess( theInelasticProcess );    
756   }                                               822   }
                                                   >> 823 
757       else if (particleName == "deuteron")        824       else if (particleName == "deuteron") 
758   {                                               825   {
759     // Elastic scattering                         826     // Elastic scattering
760           G4HadronElasticProcess* theElasticPr    827           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
761     theElasticProcess->AddDataSet( theGGNNEl ) << 
762           theElasticProcess->RegisterMe( elast    828           theElasticProcess->RegisterMe( elastic_lhep0 );
763     pmanager->AddDiscreteProcess( theElasticPr    829     pmanager->AddDiscreteProcess( theElasticProcess );
764           // Inelastic scattering                 830           // Inelastic scattering
765     G4HadronInelasticProcess* theInelasticProc << 831     G4DeuteronInelasticProcess* theInelasticProcess = 
766       new G4HadronInelasticProcess( "inelastic << 832       new G4DeuteronInelasticProcess("inelastic");
767     theInelasticProcess->AddDataSet( theGGNucl    833     theInelasticProcess->AddDataSet( theGGNuclNuclData );
768     theInelasticProcess->RegisterMe( theFTFMod    834     theInelasticProcess->RegisterMe( theFTFModel1 );
769           theInelasticProcess->RegisterMe( the    835           theInelasticProcess->RegisterMe( theBERTModel0 );
770     pmanager->AddDiscreteProcess( theInelastic    836     pmanager->AddDiscreteProcess( theInelasticProcess );
771   }                                               837   }
                                                   >> 838       
772       else if (particleName == "triton")          839       else if (particleName == "triton") 
773   {                                               840   {
774     // Elastic scattering                         841     // Elastic scattering
775           G4HadronElasticProcess* theElasticPr    842           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
776     theElasticProcess->AddDataSet( theGGNNEl ) << 
777           theElasticProcess->RegisterMe( elast    843           theElasticProcess->RegisterMe( elastic_lhep0 );
778     pmanager->AddDiscreteProcess( theElasticPr    844     pmanager->AddDiscreteProcess( theElasticProcess );
779           // Inelastic scattering                 845           // Inelastic scattering
780     G4HadronInelasticProcess* theInelasticProc << 846     G4TritonInelasticProcess* theInelasticProcess = 
781       new G4HadronInelasticProcess( "inelastic << 847       new G4TritonInelasticProcess("inelastic");
782     theInelasticProcess->AddDataSet( theGGNucl    848     theInelasticProcess->AddDataSet( theGGNuclNuclData );
783     theInelasticProcess->RegisterMe( theFTFMod    849     theInelasticProcess->RegisterMe( theFTFModel1 );
784           theInelasticProcess->RegisterMe( the    850           theInelasticProcess->RegisterMe( theBERTModel0 );
785     pmanager->AddDiscreteProcess( theInelastic    851     pmanager->AddDiscreteProcess( theInelasticProcess );
786   }                                               852   }
787       else if (particleName == "alpha")           853       else if (particleName == "alpha") 
788   {                                               854   {
789     // Elastic scattering                         855     // Elastic scattering
790           G4HadronElasticProcess* theElasticPr    856           G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess;
791     theElasticProcess->AddDataSet( theGGNNEl ) << 
792           theElasticProcess->RegisterMe( elast    857           theElasticProcess->RegisterMe( elastic_lhep0 );
793     pmanager->AddDiscreteProcess( theElasticPr    858     pmanager->AddDiscreteProcess( theElasticProcess );
794           // Inelastic scattering                 859           // Inelastic scattering
795     G4HadronInelasticProcess* theInelasticProc << 860     G4AlphaInelasticProcess* theInelasticProcess = 
796       new G4HadronInelasticProcess( "inelastic << 861       new G4AlphaInelasticProcess("inelastic");  
797           theInelasticProcess->AddDataSet( the    862           theInelasticProcess->AddDataSet( theGGNuclNuclData );
798     theInelasticProcess->RegisterMe( theFTFMod    863     theInelasticProcess->RegisterMe( theFTFModel1 );
799           theInelasticProcess->RegisterMe( the    864           theInelasticProcess->RegisterMe( theBERTModel0 );
800     pmanager->AddDiscreteProcess( theInelastic    865     pmanager->AddDiscreteProcess( theInelasticProcess );
801   }                                               866   }
                                                   >> 867 
802     }                                             868     }
803 }                                                 869 }
804                                                   870 
                                                   >> 871 
805 // Decays ////////////////////////////////////    872 // Decays ///////////////////////////////////////////////////////////////////
                                                   >> 873 #include "G4Decay.hh"
                                                   >> 874 #include "G4RadioactiveDecay.hh"
                                                   >> 875 #include "G4IonTable.hh"
                                                   >> 876 #include "G4Ions.hh"
                                                   >> 877 
806 void DMXPhysicsList::ConstructGeneral() {         878 void DMXPhysicsList::ConstructGeneral() {
807                                                   879 
808   // Add Decay Process                            880   // Add Decay Process
809   G4Decay* theDecayProcess = new G4Decay();       881   G4Decay* theDecayProcess = new G4Decay();
810   auto particleIterator=GetParticleIterator();    882   auto particleIterator=GetParticleIterator();
811   particleIterator->reset();                      883   particleIterator->reset();
812   while( (*particleIterator)() )                  884   while( (*particleIterator)() )
813     {                                             885     {
814       G4ParticleDefinition* particle = particl    886       G4ParticleDefinition* particle = particleIterator->value();
815       G4ProcessManager* pmanager = particle->G    887       G4ProcessManager* pmanager = particle->GetProcessManager();
816                                                   888       
817       if (theDecayProcess->IsApplicable(*parti    889       if (theDecayProcess->IsApplicable(*particle) && !particle->IsShortLived()) 
818   {                                               890   { 
819     pmanager ->AddProcess(theDecayProcess);       891     pmanager ->AddProcess(theDecayProcess);
820     // set ordering for PostStepDoIt and AtRes    892     // set ordering for PostStepDoIt and AtRestDoIt
821     pmanager ->SetProcessOrdering(theDecayProc    893     pmanager ->SetProcessOrdering(theDecayProcess, idxPostStep);
822     pmanager ->SetProcessOrdering(theDecayProc    894     pmanager ->SetProcessOrdering(theDecayProcess, idxAtRest);
823   }                                               895   }
824     }                                             896     }
825                                                   897 
826   // Declare radioactive decay to the GenericI    898   // Declare radioactive decay to the GenericIon in the IonTable.
827   G4LossTableManager* man = G4LossTableManager << 899   const G4IonTable *theIonTable = 
828   G4VAtomDeexcitation* ad = man->AtomDeexcitat << 900     G4ParticleTable::GetParticleTable()->GetIonTable();
829   if(!ad) {                                    << 901   G4RadioactiveDecay *theRadioactiveDecay = new G4RadioactiveDecay();
830     G4EmParameters::Instance()->SetAugerCascad << 
831     ad = new G4UAtomicDeexcitation();          << 
832     man->SetAtomDeexcitation(ad);              << 
833     ad->InitialiseAtomicDeexcitation();        << 
834   }                                            << 
835                                                   902 
836   G4PhysicsListHelper::GetPhysicsListHelper()- << 903   for (G4int i=0; i<theIonTable->Entries(); i++) 
837     RegisterProcess(new G4RadioactiveDecay(),  << 904     {
                                                   >> 905       G4String particleName = theIonTable->GetParticle(i)->GetParticleName();
                                                   >> 906       G4String particleType = theIonTable->GetParticle(i)->GetParticleType();
                                                   >> 907       
                                                   >> 908       if (particleName == "GenericIon") 
                                                   >> 909   {
                                                   >> 910     G4ProcessManager* pmanager = 
                                                   >> 911       theIonTable->GetParticle(i)->GetProcessManager();
                                                   >> 912     pmanager->SetVerboseLevel(VerboseLevel);
                                                   >> 913     pmanager ->AddProcess(theRadioactiveDecay);
                                                   >> 914     pmanager ->SetProcessOrdering(theRadioactiveDecay, idxPostStep);
                                                   >> 915     pmanager ->SetProcessOrdering(theRadioactiveDecay, idxAtRest);
                                                   >> 916   } 
                                                   >> 917     }
838 }                                                 918 }
839                                                   919 
840 // Cuts //////////////////////////////////////    920 // Cuts /////////////////////////////////////////////////////////////////////
841 void DMXPhysicsList::SetCuts()                    921 void DMXPhysicsList::SetCuts() 
842 {                                                 922 {
843                                                   923   
844   if (verboseLevel >1)                            924   if (verboseLevel >1)
845     G4cout << "DMXPhysicsList::SetCuts:";         925     G4cout << "DMXPhysicsList::SetCuts:";
846                                                   926   
847   if (verboseLevel>0){                            927   if (verboseLevel>0){
848     G4cout << "DMXPhysicsList::SetCuts:";         928     G4cout << "DMXPhysicsList::SetCuts:";
849     G4cout << "CutLength : "                      929     G4cout << "CutLength : " 
850      << G4BestUnit(defaultCutValue,"Length") <    930      << G4BestUnit(defaultCutValue,"Length") << G4endl;
851   }                                               931   }
852                                                   932 
853   //special for low energy physics                933   //special for low energy physics
854   G4double lowlimit=250*eV;                       934   G4double lowlimit=250*eV;  
855   G4ProductionCutsTable::GetProductionCutsTabl    935   G4ProductionCutsTable::GetProductionCutsTable()->SetEnergyRange(lowlimit,100.*GeV);
856                                                   936 
857   // set cut values for gamma at first and for    937   // set cut values for gamma at first and for e- second and next for e+,
858   // because some processes for e+/e- need cut    938   // because some processes for e+/e- need cut values for gamma 
859   SetCutValue(cutForGamma, "gamma");              939   SetCutValue(cutForGamma, "gamma");
860   SetCutValue(cutForElectron, "e-");              940   SetCutValue(cutForElectron, "e-");
861   SetCutValue(cutForPositron, "e+");              941   SetCutValue(cutForPositron, "e+");
862                                                   942   
863   if (verboseLevel>0) DumpCutValuesTable();       943   if (verboseLevel>0) DumpCutValuesTable();
864 }                                                 944 }
865                                                   945 
866                                                   946