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


  1 //                                                  1 
  2 // *******************************************    
  3 // * License and Disclaimer                       
  4 // *                                              
  5 // * The  Geant4 software  is  copyright of th    
  6 // * the Geant4 Collaboration.  It is provided    
  7 // * conditions of the Geant4 Software License    
  8 // * LICENSE and available at  http://cern.ch/    
  9 // * include a list of copyright holders.         
 10 // *                                              
 11 // * Neither the authors of this software syst    
 12 // * institutes,nor the agencies providing fin    
 13 // * work  make  any representation or  warran    
 14 // * regarding  this  software system or assum    
 15 // * use.  Please see the license in the file     
 16 // * for the full disclaimer and the limitatio    
 17 // *                                              
 18 // * This  code  implementation is the result     
 19 // * technical work of the GEANT4 collaboratio    
 20 // * By using,  copying,  modifying or  distri    
 21 // * any work based  on the software)  you  ag    
 22 // * use  in  resulting  scientific  publicati    
 23 // * acceptance of all terms of the Geant4 Sof    
 24 // *******************************************    
 25 //                                                
 26 //                                                
 27 // -------------------------------------------    
 28 //   GEANT 4 - Underground Dark Matter Detecto    
 29 //                                                
 30 //      For information related to this code c    
 31 //      e-mail: alexander.howard@cern.ch          
 32 // -------------------------------------------    
 33 // Comments                                       
 34 //                                                
 35 //                  Underground Advanced          
 36 //               by A. Howard and H. Araujo       
 37 //                    (27th November 2001)        
 38 //                                                
 39 // PhysicsList program                            
 40 //                                                
 41 // Modified:                                      
 42 //                                                
 43 // 14-02-03 Fix bugs in msc and hIon instancia    
 44 //                                                
 45 // 05-02-05 AH - changes to G4Decay - added is    
 46 //          and redefined particles to allow n    
 47 //          i.e. changed construction to G4Mes    
 48 //                                                
 49 // 23-10-09 LP - migrated EM physics from the     
 50 //          the new G4Livermore model implemen    
 51 //                                                
 52 // -------------------------------------------    
 53                                                   
 54 #include <iomanip>                                
 55                                                   
 56 #include "DMXPhysicsList.hh"                      
 57                                                   
 58 #include "globals.hh"                             
 59 #include "G4SystemOfUnits.hh"                     
 60 #include "G4ProcessManager.hh"                    
 61 #include "G4ProcessVector.hh"                     
 62                                                   
 63 #include "G4ParticleDefinition.hh"                
 64 #include "G4ParticleWithCuts.hh"                  
 65 #include "G4ParticleTypes.hh"                     
 66 #include "G4ParticleTable.hh"                     
 67                                                   
 68 #include "G4ios.hh"                               
 69 #include "G4UserLimits.hh"                        
 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 ///////////////////////////////    
195 DMXPhysicsList::DMXPhysicsList() : G4VUserPhys    
196 {                                                 
197                                                   
198   defaultCutValue     = 1.0*micrometer; //        
199   cutForGamma         = defaultCutValue;          
200   cutForElectron      = 1.0*nanometer;            
201   cutForPositron      = defaultCutValue;          
202                                                   
203   VerboseLevel = 1;                               
204   OpVerbLevel = 0;                                
205                                                   
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);                  
222 }                                                 
223                                                   
224 // Destructor ////////////////////////////////    
225 DMXPhysicsList::~DMXPhysicsList()                 
226 {;}                                               
227                                                   
228 // Construct Particles ///////////////////////    
229 void DMXPhysicsList::ConstructParticle()          
230 {                                                 
231   // In this method, static member functions s    
232   // for all particles which you want to use.     
233   // This ensures that objects of these partic    
234   // created in the program.                      
235                                                   
236   ConstructMyBosons();                            
237   ConstructMyLeptons();                           
238   ConstructMyHadrons();                           
239   ConstructMyShortLiveds();                       
240 }                                                 
241                                                   
242 // construct Bosons://////////////////////////    
243 void DMXPhysicsList::ConstructMyBosons()          
244 {                                                 
245   // pseudo-particles                             
246   G4Geantino::GeantinoDefinition();               
247   G4ChargedGeantino::ChargedGeantinoDefinition    
248                                                   
249   // gamma                                        
250   G4Gamma::GammaDefinition();                     
251                                                   
252   //OpticalPhotons                                
253   G4OpticalPhoton::OpticalPhotonDefinition();     
254                                                   
255 }                                                 
256                                                   
257 // construct Leptons://///////////////////////    
258 void DMXPhysicsList::ConstructMyLeptons()         
259 {                                                 
260   // leptons                                      
261   G4Electron::ElectronDefinition();               
262   G4Positron::PositronDefinition();               
263   G4MuonPlus::MuonPlusDefinition();               
264   G4MuonMinus::MuonMinusDefinition();             
265                                                   
266   G4NeutrinoE::NeutrinoEDefinition();             
267   G4AntiNeutrinoE::AntiNeutrinoEDefinition();     
268   G4NeutrinoMu::NeutrinoMuDefinition();           
269   G4AntiNeutrinoMu::AntiNeutrinoMuDefinition()    
270 }                                                 
271                                                   
272 // construct Hadrons://///////////////////////    
273 void DMXPhysicsList::ConstructMyHadrons()         
274 {                                                 
275  //  mesons                                       
276   G4MesonConstructor mConstructor;                
277   mConstructor.ConstructParticle();               
278                                                   
279  //  baryons                                      
280   G4BaryonConstructor bConstructor;               
281   bConstructor.ConstructParticle();               
282                                                   
283  //  ions                                         
284   G4IonConstructor iConstructor;                  
285   iConstructor.ConstructParticle();               
286 }                                                 
287                                                   
288 // construct Shortliveds://///////////////////    
289 void DMXPhysicsList::ConstructMyShortLiveds()     
290 {                                                 
291   G4ShortLivedConstructor slConstructor;          
292   slConstructor.ConstructParticle();              
293 }                                                 
294                                                   
295 // Construct Processes ///////////////////////    
296 void DMXPhysicsList::ConstructProcess()           
297 {                                                 
298   AddTransportation();                            
299                                                   
300   ConstructEM();                                  
301                                                   
302   ConstructOp();                                  
303                                                   
304   ConstructHad();                                 
305                                                   
306   ConstructGeneral();                             
307 }                                                 
308                                                   
309 // Transportation ////////////////////////////    
310 void DMXPhysicsList::AddTransportation() {        
311                                                   
312   G4VUserPhysicsList::AddTransportation();        
313                                                   
314   auto particleIterator=GetParticleIterator();    
315   particleIterator->reset();                      
316   while( (*particleIterator)() ){                 
317     G4ParticleDefinition* particle = particleI    
318     G4ProcessManager* pmanager = particle->Get    
319     G4String particleName = particle->GetParti    
320     // time cuts for ONLY neutrons:               
321     if(particleName == "neutron")                 
322       pmanager->AddDiscreteProcess(new DMXMaxT    
323     // Energy cuts to kill charged (embedded i    
324     pmanager->AddDiscreteProcess(new DMXMinEki    
325                                                   
326     // Step limit applied to all particles:       
327     pmanager->AddDiscreteProcess(new G4StepLim    
328   }                                               
329 }                                                 
330                                                   
331 // Electromagnetic Processes /////////////////    
332 // all charged particles                          
333 void DMXPhysicsList::ConstructEM() {              
334                                                   
335   G4LossTableManager* man = G4LossTableManager    
336   man->SetAtomDeexcitation(new G4UAtomicDeexci    
337                                                   
338   G4EmParameters* em_params = G4EmParameters::    
339                                                   
340   auto particleIterator=GetParticleIterator();    
341   particleIterator->reset();                      
342   while( (*particleIterator)() ){                 
343     G4ParticleDefinition* particle = particleI    
344     G4ProcessManager* pmanager = particle->Get    
345     G4String particleName = particle->GetParti    
346     G4String particleType = particle->GetParti    
347     G4double charge = particle->GetPDGCharge()    
348                                                   
349     if (particleName == "gamma")                  
350       {                                           
351   //gamma                                         
352   G4RayleighScattering* theRayleigh = new G4Ra    
353   pmanager->AddDiscreteProcess(theRayleigh);      
354                                                   
355   G4PhotoElectricEffect* thePhotoElectricEffec    
356   thePhotoElectricEffect->SetEmModel(new G4Liv    
357   pmanager->AddDiscreteProcess(thePhotoElectri    
358                                                   
359   G4ComptonScattering* theComptonScattering =     
360   theComptonScattering->SetEmModel(new G4Liver    
361   pmanager->AddDiscreteProcess(theComptonScatt    
362                                                   
363   G4GammaConversion* theGammaConversion = new     
364   theGammaConversion->SetEmModel(new G4BetheHe    
365   pmanager->AddDiscreteProcess(theGammaConvers    
366                                                   
367       }                                           
368     else if (particleName == "e-")                
369       {                                           
370   //electron                                      
371   // process ordering: AddProcess(name, at res    
372   // Multiple scattering                          
373   G4eMultipleScattering* msc = new G4eMultiple    
374   em_params->SetMscStepLimitType(fUseDistanceT    
375   pmanager->AddProcess(msc,-1, 1, -1);            
376                                                   
377   // Ionisation                                   
378   G4eIonisation* eIonisation = new G4eIonisati    
379         G4VEmModel* theIoniLiv = new G4Livermo    
380         theIoniLiv->SetHighEnergyLimit(0.1*MeV    
381         eIonisation->AddEmModel(0, theIoniLiv,    
382   em_params->SetStepFunction(0.2, 100*um); //i    
383   pmanager->AddProcess(eIonisation,-1, 2, 1);     
384                                                   
385   // Bremsstrahlung                               
386   G4eBremsstrahlung* eBremsstrahlung = new G4e    
387   pmanager->AddProcess(eBremsstrahlung, -1,-3,    
388       }                                           
389     else if (particleName == "e+")                
390       {                                           
391   //positron                                      
392   G4eMultipleScattering* msc = new G4eMultiple    
393   msc->SetStepLimitType(fUseDistanceToBoundary    
394   pmanager->AddProcess(msc,-1, 1, -1);            
395                                                   
396   // Ionisation                                   
397   G4eIonisation* eIonisation = new G4eIonisati    
398   // eIonisation->SetStepFunction(0.2, 100*um)    
399   pmanager->AddProcess(eIonisation,               
400                                                   
401   //Bremsstrahlung (use default, no low-energy    
402   pmanager->AddProcess(new G4eBremsstrahlung()    
403                                                   
404   //Annihilation                                  
405   pmanager->AddProcess(new G4eplusAnnihilation    
406       }                                           
407     else if( particleName == "mu+" ||             
408        particleName == "mu-"    )                 
409       {                                           
410   //muon                                          
411   pmanager->AddProcess(new G4MuMultipleScatter    
412   pmanager->AddProcess(new G4MuIonisation(),      
413   pmanager->AddProcess(new G4MuBremsstrahlung(    
414   pmanager->AddProcess(new G4MuPairProduction(    
415   if( particleName == "mu-" )                     
416     pmanager->AddProcess(new G4MuonMinusCaptur    
417       }                                           
418     else if (particleName == "proton" ||          
419        particleName == "pi+" ||                   
420        particleName == "pi-")                     
421       {                                           
422   //multiple scattering                           
423   pmanager->AddProcess(new G4hMultipleScatteri    
424                                                   
425   //ionisation                                    
426   G4hIonisation* hIonisation = new G4hIonisati    
427   em_params->SetStepFunctionMuHad(0.2, 50*um);    
428   pmanager->AddProcess(hIonisation,               
429                                                   
430   //bremmstrahlung                                
431   pmanager->AddProcess(new G4hBremsstrahlung,     
432       }                                           
433     else if(particleName == "alpha"      ||       
434        particleName == "deuteron"   ||            
435        particleName == "triton"     ||            
436        particleName == "He3")                     
437       {                                           
438   //multiple scattering                           
439   pmanager->AddProcess(new G4hMultipleScatteri    
440                                                   
441   //ionisation                                    
442   G4ionIonisation* ionIoni = new G4ionIonisati    
443   em_params->SetStepFunctionLightIons(0.1, 1*C    
444   pmanager->AddProcess(ionIoni,                   
445   pmanager->AddProcess(new G4NuclearStopping()    
446       }                                           
447     else if (particleName == "GenericIon")        
448       {                                           
449   // OBJECT may be dynamically created as eith    
450   // G4Nucleus exists and therefore has partic    
451   // genericIon:                                  
452                                                   
453   //multiple scattering                           
454   pmanager->AddProcess(new G4hMultipleScatteri    
455                                                   
456   //ionisation                                    
457   G4ionIonisation* ionIoni = new G4ionIonisati    
458   em_params->SetStepFunctionIons(0.1, 1*CLHEP:    
459   pmanager->AddProcess(ionIoni,                   
460   pmanager->AddProcess(new G4NuclearStopping()    
461       }                                           
462                                                   
463     else if ((!particle->IsShortLived()) &&       
464        (charge != 0.0) &&                         
465        (particle->GetParticleName() != "charge    
466       {                                           
467   //all others charged particles except geanti    
468         G4hMultipleScattering* aMultipleScatte    
469         G4hIonisation* ahadronIon = new G4hIon    
470                                                   
471   //multiple scattering                           
472   pmanager->AddProcess(aMultipleScattering,-1,    
473                                                   
474   //ionisation                                    
475   pmanager->AddProcess(ahadronIon,       -1,2,    
476       }                                           
477   }                                               
478 }                                                 
479                                                   
480 // Optical Processes /////////////////////////    
481 void DMXPhysicsList::ConstructOp()                
482 {                                                 
483   G4OpticalParameters* opParams = G4OpticalPar    
484   G4Scintillation* theScintProcessDef = new G4    
485   opParams->SetScintTrackSecondariesFirst(true    
486   opParams->SetScintByParticleType(true);         
487                                                   
488   // optical processes                            
489   G4OpAbsorption* theAbsorptionProcess = new G    
490   G4OpBoundaryProcess* theBoundaryProcess = ne    
491                                                   
492   auto particleIterator=GetParticleIterator();    
493   particleIterator->reset();                      
494   while( (*particleIterator)() )                  
495     {                                             
496       G4ParticleDefinition* particle = particl    
497       G4ProcessManager* pmanager = particle->G    
498       G4String particleName = particle->GetPar    
499       if (theScintProcessDef->IsApplicable(*pa    
500         pmanager->AddProcess(theScintProcessDe    
501         pmanager->SetProcessOrderingToLast(the    
502         pmanager->SetProcessOrderingToLast(the    
503       }                                           
504                                                   
505       if (particleName == "opticalphoton") {      
506   pmanager->AddDiscreteProcess(theAbsorptionPr    
507   pmanager->AddDiscreteProcess(theBoundaryProc    
508       }                                           
509     }                                             
510 }                                                 
511                                                   
512 // Hadronic processes ////////////////////////    
513                                                   
514 void DMXPhysicsList::ConstructHad()               
515 {                                                 
516   //Elastic models                                
517   G4HadronElastic* elastic_lhep0 = new G4Hadro    
518   G4ChipsElasticModel* elastic_chip = new G4Ch    
519   G4ElasticHadrNucleusHE* elastic_he = new G4E    
520                                                   
521   // Inelastic scattering                         
522   const G4double theFTFMin0 =    0.0*GeV;         
523   const G4double theFTFMin1 =    3.0*GeV;         
524   const G4double theFTFMax = G4HadronicParamet    
525   const G4double theBERTMin0 =   0.0*GeV;         
526   const G4double theBERTMin1 =  19.0*MeV;         
527   const G4double theBERTMax =    6.0*GeV;         
528   const G4double theHPMin =      0.0*GeV;         
529   const G4double theHPMax =     20.0*MeV;         
530                                                   
531   G4FTFModel * theStringModel = new G4FTFModel    
532   G4ExcitedStringDecay * theStringDecay = new     
533   theStringModel->SetFragmentationModel( theSt    
534   G4PreCompoundModel * thePreEquilib = new G4P    
535   G4GeneratorPrecompoundInterface * theCascade    
536                                                   
537   G4TheoFSGenerator * theFTFModel0 = new G4The    
538   theFTFModel0->SetHighEnergyGenerator( theStr    
539   theFTFModel0->SetTransport( theCascade );       
540   theFTFModel0->SetMinEnergy( theFTFMin0 );       
541   theFTFModel0->SetMaxEnergy( theFTFMax );        
542                                                   
543   G4TheoFSGenerator * theFTFModel1 = new G4The    
544   theFTFModel1->SetHighEnergyGenerator( theStr    
545   theFTFModel1->SetTransport( theCascade );       
546   theFTFModel1->SetMinEnergy( theFTFMin1 );       
547   theFTFModel1->SetMaxEnergy( theFTFMax );        
548                                                   
549   G4CascadeInterface * theBERTModel0 = new G4C    
550   theBERTModel0->SetMinEnergy( theBERTMin0 );     
551   theBERTModel0->SetMaxEnergy( theBERTMax );      
552                                                   
553   G4CascadeInterface * theBERTModel1 = new G4C    
554   theBERTModel1->SetMinEnergy( theBERTMin1 );     
555   theBERTModel1->SetMaxEnergy( theBERTMax );      
556                                                   
557   G4VCrossSectionDataSet * theAntiNucleonData     
558   G4ComponentGGNuclNuclXsc * ggNuclNuclXsec =     
559   G4VCrossSectionDataSet * theGGNuclNuclData =    
560   G4VCrossSectionDataSet * theGGNNEl = new G4C    
561   G4ComponentGGHadronNucleusXsc * ggHNXsec = n    
562   G4VCrossSectionDataSet * theGGHNEl = new G4C    
563   G4VCrossSectionDataSet * theGGHNInel = new G    
564                                                   
565   auto particleIterator=GetParticleIterator();    
566   particleIterator->reset();                      
567   while ((*particleIterator)())                   
568     {                                             
569       G4ParticleDefinition* particle = particl    
570       G4ProcessManager* pmanager = particle->G    
571       G4String particleName = particle->GetPar    
572                                                   
573       if (particleName == "pi+")                  
574   {                                               
575     // Elastic scattering                         
576           G4HadronElasticProcess* theElasticPr    
577           theElasticProcess->AddDataSet( new G    
578           theElasticProcess->RegisterMe( elast    
579     pmanager->AddDiscreteProcess( theElasticPr    
580     //Inelastic scattering                        
581     G4HadronInelasticProcess* theInelasticProc    
582       new G4HadronInelasticProcess( "inelastic    
583     theInelasticProcess->AddDataSet( new G4BGG    
584     theInelasticProcess->RegisterMe( theFTFMod    
585           theInelasticProcess->RegisterMe( the    
586     pmanager->AddDiscreteProcess( theInelastic    
587   }                                               
588                                                   
589       else if (particleName == "pi-")             
590   {                                               
591     // Elastic scattering                         
592           G4HadronElasticProcess* theElasticPr    
593           theElasticProcess->AddDataSet( new G    
594           theElasticProcess->RegisterMe( elast    
595     pmanager->AddDiscreteProcess( theElasticPr    
596     //Inelastic scattering                        
597     G4HadronInelasticProcess* theInelasticProc    
598       new G4HadronInelasticProcess( "inelastic    
599     theInelasticProcess->AddDataSet( new G4BGG    
600     theInelasticProcess->RegisterMe( theFTFMod    
601           theInelasticProcess->RegisterMe( the    
602     pmanager->AddDiscreteProcess( theInelastic    
603     //Absorption                                  
604     pmanager->AddRestProcess(new G4HadronicAbs    
605   }                                               
606       else if (particleName == "kaon+")           
607   {                                               
608     // Elastic scattering                         
609           G4HadronElasticProcess* theElasticPr    
610     theElasticProcess->AddDataSet( theGGHNEl )    
611           theElasticProcess->RegisterMe( elast    
612     pmanager->AddDiscreteProcess( theElasticPr    
613           // Inelastic scattering                 
614     G4HadronInelasticProcess* theInelasticProc    
615       new G4HadronInelasticProcess( "inelastic    
616     theInelasticProcess->AddDataSet( theGGHNIn    
617     theInelasticProcess->RegisterMe( theFTFMod    
618           theInelasticProcess->RegisterMe( the    
619     pmanager->AddDiscreteProcess( theInelastic    
620   }                                               
621       else if (particleName == "kaon0S")          
622   {                                               
623     // Elastic scattering                         
624           G4HadronElasticProcess* theElasticPr    
625     theElasticProcess->AddDataSet( theGGHNEl )    
626           theElasticProcess->RegisterMe( elast    
627     pmanager->AddDiscreteProcess( theElasticPr    
628           // Inelastic scattering                 
629     G4HadronInelasticProcess* theInelasticProc    
630       new G4HadronInelasticProcess( "inelastic    
631     theInelasticProcess->AddDataSet( theGGHNIn    
632     theInelasticProcess->RegisterMe( theFTFMod    
633           theInelasticProcess->RegisterMe( the    
634     pmanager->AddDiscreteProcess( theInelastic    
635   }                                               
636                                                   
637       else if (particleName == "kaon0L")          
638   {                                               
639     // Elastic scattering                         
640           G4HadronElasticProcess* theElasticPr    
641     theElasticProcess->AddDataSet( theGGHNEl )    
642           theElasticProcess->RegisterMe( elast    
643     pmanager->AddDiscreteProcess( theElasticPr    
644     // Inelastic scattering                       
645     G4HadronInelasticProcess* theInelasticProc    
646       new G4HadronInelasticProcess( "inelastic    
647     theInelasticProcess->AddDataSet( theGGHNIn    
648     theInelasticProcess->RegisterMe( theFTFMod    
649           theInelasticProcess->RegisterMe( the    
650     pmanager->AddDiscreteProcess( theInelastic    
651   }                                               
652                                                   
653       else if (particleName == "kaon-")           
654   {                                               
655     // Elastic scattering                         
656           G4HadronElasticProcess* theElasticPr    
657     theElasticProcess->AddDataSet( theGGHNEl )    
658           theElasticProcess->RegisterMe( elast    
659     pmanager->AddDiscreteProcess( theElasticPr    
660           // Inelastic scattering                 
661     G4HadronInelasticProcess* theInelasticProc    
662       new G4HadronInelasticProcess( "inelastic    
663           theInelasticProcess->AddDataSet( the    
664     theInelasticProcess->RegisterMe( theFTFMod    
665           theInelasticProcess->RegisterMe( the    
666     pmanager->AddDiscreteProcess( theInelastic    
667     pmanager->AddRestProcess(new G4HadronicAbs    
668   }                                               
669                                                   
670       else if (particleName == "proton")          
671   {                                               
672     // Elastic scattering                         
673           G4HadronElasticProcess* theElasticPr    
674           theElasticProcess->AddDataSet( new G    
675           theElasticProcess->RegisterMe( elast    
676     pmanager->AddDiscreteProcess( theElasticPr    
677     // Inelastic scattering                       
678     G4HadronInelasticProcess* theInelasticProc    
679       new G4HadronInelasticProcess( "inelastic    
680     theInelasticProcess->AddDataSet( new G4BGG    
681     theInelasticProcess->RegisterMe( theFTFMod    
682           theInelasticProcess->RegisterMe( the    
683     pmanager->AddDiscreteProcess( theInelastic    
684   }                                               
685       else if (particleName == "anti_proton")     
686   {                                               
687     // Elastic scattering                         
688           const G4double elastic_elimitAntiNuc    
689           G4AntiNuclElastic* elastic_anuc = ne    
690           elastic_anuc->SetMinEnergy( elastic_    
691           G4CrossSectionElastic* elastic_anucx    
692           G4HadronElastic* elastic_lhep2 = new    
693           elastic_lhep2->SetMaxEnergy( elastic    
694           G4HadronElasticProcess* theElasticPr    
695           theElasticProcess->AddDataSet( elast    
696           theElasticProcess->RegisterMe( elast    
697           theElasticProcess->RegisterMe( elast    
698     pmanager->AddDiscreteProcess( theElasticPr    
699     // Inelastic scattering                       
700     G4HadronInelasticProcess* theInelasticProc    
701       new G4HadronInelasticProcess( "inelastic    
702     theInelasticProcess->AddDataSet( theAntiNu    
703     theInelasticProcess->RegisterMe( theFTFMod    
704     pmanager->AddDiscreteProcess( theInelastic    
705     // Absorption                                 
706     pmanager->AddRestProcess(new G4HadronicAbs    
707   }                                               
708       else if (particleName == "neutron") {       
709   // elastic scattering                           
710   G4HadronElasticProcess* theElasticProcess =     
711         theElasticProcess->AddDataSet(new G4Ne    
712         G4HadronElastic* elastic_neutronChipsM    
713   elastic_neutronChipsModel->SetMinEnergy( 19.    
714         theElasticProcess->RegisterMe( elastic    
715   G4ParticleHPElastic * theElasticNeutronHP =     
716         theElasticNeutronHP->SetMinEnergy( the    
717         theElasticNeutronHP->SetMaxEnergy( the    
718   theElasticProcess->RegisterMe( theElasticNeu    
719   theElasticProcess->AddDataSet( new G4Particl    
720   pmanager->AddDiscreteProcess( theElasticProc    
721   // inelastic scattering                         
722   G4HadronInelasticProcess* theInelasticProces    
723     new G4HadronInelasticProcess( "inelastic",    
724   theInelasticProcess->AddDataSet( new G4Neutr    
725   theInelasticProcess->RegisterMe( theFTFModel    
726         theInelasticProcess->RegisterMe( theBE    
727   G4ParticleHPInelastic * theNeutronInelasticH    
728         theNeutronInelasticHPModel->SetMinEner    
729         theNeutronInelasticHPModel->SetMaxEner    
730   theInelasticProcess->RegisterMe( theNeutronI    
731   theInelasticProcess->AddDataSet( new G4Parti    
732   pmanager->AddDiscreteProcess(theInelasticPro    
733   // capture                                      
734   G4NeutronCaptureProcess* theCaptureProcess =    
735     new G4NeutronCaptureProcess;                  
736   G4ParticleHPCapture * theLENeutronCaptureMod    
737   theLENeutronCaptureModel->SetMinEnergy(theHP    
738   theLENeutronCaptureModel->SetMaxEnergy(theHP    
739   theCaptureProcess->RegisterMe(theLENeutronCa    
740   theCaptureProcess->AddDataSet( new G4Particl    
741   pmanager->AddDiscreteProcess(theCaptureProce    
742       }                                           
743       else if (particleName == "anti_neutron")    
744   {                                               
745     // Elastic scattering                         
746           G4HadronElasticProcess* theElasticPr    
747     theElasticProcess->AddDataSet( theGGHNEl )    
748           theElasticProcess->RegisterMe( elast    
749     pmanager->AddDiscreteProcess( theElasticPr    
750           // Inelastic scattering (include ann    
751     G4HadronInelasticProcess* theInelasticProc    
752       new G4HadronInelasticProcess( "inelastic    
753     theInelasticProcess->AddDataSet( theAntiNu    
754     theInelasticProcess->RegisterMe( theFTFMod    
755     pmanager->AddDiscreteProcess( theInelastic    
756   }                                               
757       else if (particleName == "deuteron")        
758   {                                               
759     // Elastic scattering                         
760           G4HadronElasticProcess* theElasticPr    
761     theElasticProcess->AddDataSet( theGGNNEl )    
762           theElasticProcess->RegisterMe( elast    
763     pmanager->AddDiscreteProcess( theElasticPr    
764           // Inelastic scattering                 
765     G4HadronInelasticProcess* theInelasticProc    
766       new G4HadronInelasticProcess( "inelastic    
767     theInelasticProcess->AddDataSet( theGGNucl    
768     theInelasticProcess->RegisterMe( theFTFMod    
769           theInelasticProcess->RegisterMe( the    
770     pmanager->AddDiscreteProcess( theInelastic    
771   }                                               
772       else if (particleName == "triton")          
773   {                                               
774     // Elastic scattering                         
775           G4HadronElasticProcess* theElasticPr    
776     theElasticProcess->AddDataSet( theGGNNEl )    
777           theElasticProcess->RegisterMe( elast    
778     pmanager->AddDiscreteProcess( theElasticPr    
779           // Inelastic scattering                 
780     G4HadronInelasticProcess* theInelasticProc    
781       new G4HadronInelasticProcess( "inelastic    
782     theInelasticProcess->AddDataSet( theGGNucl    
783     theInelasticProcess->RegisterMe( theFTFMod    
784           theInelasticProcess->RegisterMe( the    
785     pmanager->AddDiscreteProcess( theInelastic    
786   }                                               
787       else if (particleName == "alpha")           
788   {                                               
789     // Elastic scattering                         
790           G4HadronElasticProcess* theElasticPr    
791     theElasticProcess->AddDataSet( theGGNNEl )    
792           theElasticProcess->RegisterMe( elast    
793     pmanager->AddDiscreteProcess( theElasticPr    
794           // Inelastic scattering                 
795     G4HadronInelasticProcess* theInelasticProc    
796       new G4HadronInelasticProcess( "inelastic    
797           theInelasticProcess->AddDataSet( the    
798     theInelasticProcess->RegisterMe( theFTFMod    
799           theInelasticProcess->RegisterMe( the    
800     pmanager->AddDiscreteProcess( theInelastic    
801   }                                               
802     }                                             
803 }                                                 
804                                                   
805 // Decays ////////////////////////////////////    
806 void DMXPhysicsList::ConstructGeneral() {         
807                                                   
808   // Add Decay Process                            
809   G4Decay* theDecayProcess = new G4Decay();       
810   auto particleIterator=GetParticleIterator();    
811   particleIterator->reset();                      
812   while( (*particleIterator)() )                  
813     {                                             
814       G4ParticleDefinition* particle = particl    
815       G4ProcessManager* pmanager = particle->G    
816                                                   
817       if (theDecayProcess->IsApplicable(*parti    
818   {                                               
819     pmanager ->AddProcess(theDecayProcess);       
820     // set ordering for PostStepDoIt and AtRes    
821     pmanager ->SetProcessOrdering(theDecayProc    
822     pmanager ->SetProcessOrdering(theDecayProc    
823   }                                               
824     }                                             
825                                                   
826   // Declare radioactive decay to the GenericI    
827   G4LossTableManager* man = G4LossTableManager    
828   G4VAtomDeexcitation* ad = man->AtomDeexcitat    
829   if(!ad) {                                       
830     G4EmParameters::Instance()->SetAugerCascad    
831     ad = new G4UAtomicDeexcitation();             
832     man->SetAtomDeexcitation(ad);                 
833     ad->InitialiseAtomicDeexcitation();           
834   }                                               
835                                                   
836   G4PhysicsListHelper::GetPhysicsListHelper()-    
837     RegisterProcess(new G4RadioactiveDecay(),     
838 }                                                 
839                                                   
840 // Cuts //////////////////////////////////////    
841 void DMXPhysicsList::SetCuts()                    
842 {                                                 
843                                                   
844   if (verboseLevel >1)                            
845     G4cout << "DMXPhysicsList::SetCuts:";         
846                                                   
847   if (verboseLevel>0){                            
848     G4cout << "DMXPhysicsList::SetCuts:";         
849     G4cout << "CutLength : "                      
850      << G4BestUnit(defaultCutValue,"Length") <    
851   }                                               
852                                                   
853   //special for low energy physics                
854   G4double lowlimit=250*eV;                       
855   G4ProductionCutsTable::GetProductionCutsTabl    
856                                                   
857   // set cut values for gamma at first and for    
858   // because some processes for e+/e- need cut    
859   SetCutValue(cutForGamma, "gamma");              
860   SetCutValue(cutForElectron, "e-");              
861   SetCutValue(cutForPositron, "e+");              
862                                                   
863   if (verboseLevel>0) DumpCutValuesTable();       
864 }                                                 
865                                                   
866