Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/examples/extended/biasing/B03/src/B03PhysicsList.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/extended/biasing/B03/src/B03PhysicsList.cc (Version 11.3.0) and /examples/extended/biasing/B03/src/B03PhysicsList.cc (Version 8.3.p2)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 /// \file biasing/B03/src/B03PhysicsList.cc    << 
 27 /// \brief Implementation of the B03PhysicsLis << 
 28 //                                             << 
 29 //                                                 26 //
                                                   >>  27 // $Id: B03PhysicsList.cc,v 1.5 2006/06/29 16:35:21 gunter Exp $
                                                   >>  28 // GEANT4 tag $Name: geant4-08-03-patch-02 $
 30 //                                                 29 //
 31                                                    30 
                                                   >>  31 #include "globals.hh"
                                                   >>  32 #include <iomanip>                
                                                   >>  33 
 32 #include "B03PhysicsList.hh"                       34 #include "B03PhysicsList.hh"
 33                                                    35 
 34 #include "G4BaryonConstructor.hh"              << 
 35 #include "G4BosonConstructor.hh"               << 
 36 #include "G4HadronicParameters.hh"             << 
 37 #include "G4IonConstructor.hh"                 << 
 38 #include "G4LeptonConstructor.hh"              << 
 39 #include "G4Material.hh"                       << 
 40 #include "G4MaterialTable.hh"                  << 
 41 #include "G4MesonConstructor.hh"               << 
 42 #include "G4ParticleDefinition.hh"                 36 #include "G4ParticleDefinition.hh"
 43 #include "G4ParticleTable.hh"                  << 
 44 #include "G4ParticleTypes.hh"                  << 
 45 #include "G4ParticleWithCuts.hh"                   37 #include "G4ParticleWithCuts.hh"
 46 #include "G4ProcessManager.hh"                     38 #include "G4ProcessManager.hh"
 47 #include "G4ProcessVector.hh"                      39 #include "G4ProcessVector.hh"
                                                   >>  40 #include "G4ParticleTypes.hh"
                                                   >>  41 #include "G4ParticleTable.hh"
                                                   >>  42 #include "G4BosonConstructor.hh"
                                                   >>  43 #include "G4LeptonConstructor.hh"
                                                   >>  44 #include "G4MesonConstructor.hh"
                                                   >>  45 #include "G4BaryonConstructor.hh"
                                                   >>  46 #include "G4IonConstructor.hh"
 48 #include "G4ShortLivedConstructor.hh"              47 #include "G4ShortLivedConstructor.hh"
 49 #include "G4SystemOfUnits.hh"                  <<  48 #include "G4Material.hh"
 50 #include "globals.hh"                          <<  49 #include "G4MaterialTable.hh"
 51                                                << 
 52 #include <iomanip>                             << 
 53                                                << 
 54 //....oooOO0OOooo........oooOO0OOooo........oo << 
 55                                                    50 
 56 B03PhysicsList::B03PhysicsList(G4String parall <<  51 B03PhysicsList::B03PhysicsList() :  G4VUserPhysicsList()
 57   : G4VUserPhysicsList(), fBiasWorldName(paral << 
 58 {                                                  52 {
 59   fParaWorldName.clear();                      << 
 60   SetVerboseLevel(1);                              53   SetVerboseLevel(1);
 61 }                                                  54 }
 62                                                    55 
 63 //....oooOO0OOooo........oooOO0OOooo........oo << 
 64                                                << 
 65 B03PhysicsList::~B03PhysicsList()                  56 B03PhysicsList::~B03PhysicsList()
 66 {                                                  57 {
 67   fParaWorldName.clear();                      << 
 68 }                                                  58 }
 69                                                    59 
 70 //....oooOO0OOooo........oooOO0OOooo........oo << 
 71                                                << 
 72 void B03PhysicsList::ConstructParticle()           60 void B03PhysicsList::ConstructParticle()
 73 {                                                  61 {
 74   // In this method, static member functions s     62   // In this method, static member functions should be called
 75   // for all particles which you want to use.      63   // for all particles which you want to use.
 76   // This ensures that objects of these partic     64   // This ensures that objects of these particle types will be
 77   // created in the program.                   <<  65   // created in the program. 
 78                                                    66 
 79   ConstructAllBosons();                            67   ConstructAllBosons();
 80   ConstructAllLeptons();                           68   ConstructAllLeptons();
 81   ConstructAllMesons();                            69   ConstructAllMesons();
 82   ConstructAllBaryons();                           70   ConstructAllBaryons();
 83   ConstructAllIons();                              71   ConstructAllIons();
 84   ConstructAllShortLiveds();                       72   ConstructAllShortLiveds();
 85 }                                                  73 }
 86                                                    74 
 87 //....oooOO0OOooo........oooOO0OOooo........oo << 
 88                                                << 
 89 void B03PhysicsList::ConstructAllBosons()          75 void B03PhysicsList::ConstructAllBosons()
 90 {                                                  76 {
 91   // Construct all bosons                          77   // Construct all bosons
 92   G4BosonConstructor pConstructor;                 78   G4BosonConstructor pConstructor;
 93   pConstructor.ConstructParticle();                79   pConstructor.ConstructParticle();
 94 }                                                  80 }
 95                                                    81 
 96 //....oooOO0OOooo........oooOO0OOooo........oo << 
 97                                                << 
 98 void B03PhysicsList::ConstructAllLeptons()         82 void B03PhysicsList::ConstructAllLeptons()
 99 {                                                  83 {
100   // Construct all leptons                         84   // Construct all leptons
101   G4LeptonConstructor pConstructor;                85   G4LeptonConstructor pConstructor;
102   pConstructor.ConstructParticle();                86   pConstructor.ConstructParticle();
103 }                                                  87 }
104                                                    88 
105 //....oooOO0OOooo........oooOO0OOooo........oo << 
106                                                << 
107 void B03PhysicsList::ConstructAllMesons()          89 void B03PhysicsList::ConstructAllMesons()
108 {                                                  90 {
109   //  Construct all mesons                         91   //  Construct all mesons
110   G4MesonConstructor pConstructor;                 92   G4MesonConstructor pConstructor;
111   pConstructor.ConstructParticle();                93   pConstructor.ConstructParticle();
112 }                                                  94 }
113                                                    95 
114 //....oooOO0OOooo........oooOO0OOooo........oo << 
115                                                << 
116 void B03PhysicsList::ConstructAllBaryons()         96 void B03PhysicsList::ConstructAllBaryons()
117 {                                                  97 {
118   //  Construct all barions                        98   //  Construct all barions
119   G4BaryonConstructor pConstructor;                99   G4BaryonConstructor pConstructor;
120   pConstructor.ConstructParticle();               100   pConstructor.ConstructParticle();
121 }                                                 101 }
122                                                   102 
123 //....oooOO0OOooo........oooOO0OOooo........oo << 
124                                                << 
125 void B03PhysicsList::ConstructAllIons()           103 void B03PhysicsList::ConstructAllIons()
126 {                                                 104 {
127   //  Construct light ions                        105   //  Construct light ions
128   G4IonConstructor pConstructor;                  106   G4IonConstructor pConstructor;
129   pConstructor.ConstructParticle();            << 107   pConstructor.ConstructParticle();  
130 }                                                 108 }
131                                                   109 
132 //....oooOO0OOooo........oooOO0OOooo........oo << 
133                                                << 
134 void B03PhysicsList::ConstructAllShortLiveds()    110 void B03PhysicsList::ConstructAllShortLiveds()
135 {                                                 111 {
136   //  Construct  resonaces and quarks             112   //  Construct  resonaces and quarks
137   G4ShortLivedConstructor pConstructor;           113   G4ShortLivedConstructor pConstructor;
138   pConstructor.ConstructParticle();            << 114   pConstructor.ConstructParticle();  
139 }                                                 115 }
140                                                   116 
141 //....oooOO0OOooo........oooOO0OOooo........oo << 
142                                                << 
143 void B03PhysicsList::ConstructProcess()           117 void B03PhysicsList::ConstructProcess()
144 {                                                 118 {
145   AddTransportation();                            119   AddTransportation();
146   AddScoringProcess();                         << 
147   AddBiasingProcess();                         << 
148   ConstructEM();                                  120   ConstructEM();
149   ConstructLeptHad();                             121   ConstructLeptHad();
150   ConstructHad();                                 122   ConstructHad();
151   ConstructGeneral();                             123   ConstructGeneral();
152 }                                                 124 }
153                                                   125 
154 //....oooOO0OOooo........oooOO0OOooo........oo << 
155                                                << 
156 #include "G4ComptonScattering.hh"                 126 #include "G4ComptonScattering.hh"
157 #include "G4GammaConversion.hh"                   127 #include "G4GammaConversion.hh"
158 #include "G4MuBremsstrahlung.hh"               << 
159 #include "G4MuIonisation.hh"                   << 
160 #include "G4MuMultipleScattering.hh"           << 
161 #include "G4MuPairProduction.hh"               << 
162 #include "G4PhotoElectricEffect.hh"               128 #include "G4PhotoElectricEffect.hh"
163 #include "G4eBremsstrahlung.hh"                << 129 
                                                   >> 130 #include "G4MultipleScattering.hh"
                                                   >> 131 
164 #include "G4eIonisation.hh"                       132 #include "G4eIonisation.hh"
165 #include "G4eMultipleScattering.hh"            << 133 #include "G4eBremsstrahlung.hh"
166 #include "G4eplusAnnihilation.hh"                 134 #include "G4eplusAnnihilation.hh"
                                                   >> 135 
                                                   >> 136 #include "G4MuIonisation.hh"
                                                   >> 137 #include "G4MuBremsstrahlung.hh"
                                                   >> 138 #include "G4MuPairProduction.hh"
                                                   >> 139 
167 #include "G4hIonisation.hh"                       140 #include "G4hIonisation.hh"
168 #include "G4hMultipleScattering.hh"            << 
169                                                   141 
170 void B03PhysicsList::ConstructEM()                142 void B03PhysicsList::ConstructEM()
171 {                                                 143 {
172   auto particleIterator = GetParticleIterator( << 144   theParticleIterator->reset();
173   particleIterator->reset();                   << 145   while( (*theParticleIterator)() ){
174   while ((*particleIterator)()) {              << 146     G4ParticleDefinition* particle = theParticleIterator->value();
175     G4ParticleDefinition* particle = particleI << 
176     G4ProcessManager* pmanager = particle->Get    147     G4ProcessManager* pmanager = particle->GetProcessManager();
177     G4String particleName = particle->GetParti    148     G4String particleName = particle->GetParticleName();
178                                                << 149      
179     if (particleName == "gamma") {                150     if (particleName == "gamma") {
180       // gamma                                 << 151     // gamma
181       // Construct processes for gamma            152       // Construct processes for gamma
182       pmanager->AddDiscreteProcess(new G4Gamma    153       pmanager->AddDiscreteProcess(new G4GammaConversion());
183       pmanager->AddDiscreteProcess(new G4Compt << 154       pmanager->AddDiscreteProcess(new G4ComptonScattering());      
184       pmanager->AddDiscreteProcess(new G4Photo    155       pmanager->AddDiscreteProcess(new G4PhotoElectricEffect());
185     }                                          << 156 
186     else if (particleName == "e-") {           << 157     } else if (particleName == "e-") {
187       // electron                              << 158     //electron
188       //  Construct processes for electron     << 159       // Construct processes for electron
189       pmanager->AddProcess(new G4eMultipleScat << 160       pmanager->AddProcess(new G4MultipleScattering(),-1,1,1);
190       pmanager->AddProcess(new G4eIonisation() << 161       pmanager->AddProcess(new G4eIonisation(),-1,2,2);
191       pmanager->AddProcess(new G4eBremsstrahlu << 162       pmanager->AddProcess(new G4eBremsstrahlung(),-1,-1,3);
192     }                                          << 163   
193     else if (particleName == "e+") {           << 164     } else if (particleName == "e+") {
194       // positron                              << 165     //positron
195       //  Construct processes for positron     << 166       // Construct processes for positron
196       pmanager->AddProcess(new G4eMultipleScat << 167      pmanager->AddProcess(new G4MultipleScattering(),-1,1,1);
197                                                << 168      
198       pmanager->AddProcess(new G4eIonisation() << 169      pmanager->AddProcess(new G4eIonisation(),-1,2,2);
199       pmanager->AddProcess(new G4eBremsstrahlu << 170      pmanager->AddProcess(new G4eBremsstrahlung(),-1,-1,3);      
200       pmanager->AddProcess(new G4eplusAnnihila << 171      pmanager->AddProcess(new G4eplusAnnihilation(),0,-1,4);
201     }                                          << 172   
202     else if (particleName == "mu+" || particle << 173     } else if( particleName == "mu+" || 
203       // muon                                  << 174                particleName == "mu-"    ) {
204       //  Construct processes for muon+        << 175     //muon  
205       pmanager->AddProcess(new G4MuMultipleSca << 176      // Construct processes for muon+
206       pmanager->AddProcess(new G4MuIonisation( << 177      pmanager->AddProcess(new G4MultipleScattering(),-1,1,1);
207       pmanager->AddProcess(new G4MuBremsstrahl << 178      pmanager->AddProcess(new G4MuIonisation(),-1,2,2);
208       pmanager->AddProcess(new G4MuPairProduct << 179      pmanager->AddProcess(new G4MuBremsstrahlung(),-1,-1,3);
209     }                                          << 180      pmanager->AddProcess(new G4MuPairProduction(),-1,-1,4);       
210     else if (particleName == "GenericIon") {   << 181      
211       pmanager->AddProcess(new G4hMultipleScat << 182     } else if( particleName == "GenericIon" ) {
212       pmanager->AddProcess(new G4hIonisation() << 183       pmanager->AddProcess(new G4MultipleScattering(),-1,1,1);
213     }                                          << 184       pmanager->AddProcess(new G4hIonisation(),-1,2,2); 
214     else {                                     << 185     } else { 
215       if ((particle->GetPDGCharge() != 0.0) && << 186       if ((particle->GetPDGCharge() != 0.0) && 
216           && (!particle->IsShortLived()))      << 187           (particle->GetParticleName() != "chargedgeantino")&&
217       {                                        << 188           (!particle->IsShortLived()) ) {
218         // all others charged particles except << 189      // all others charged particles except geantino
219         pmanager->AddProcess(new G4hMultipleSc << 190        pmanager->AddProcess(new G4MultipleScattering(),-1,1,1);
220         pmanager->AddProcess(new G4hIonisation << 191        pmanager->AddProcess(new G4hIonisation(),-1,2,2);       
221       }                                        << 192      }
222     }                                             193     }
223   }                                               194   }
224 }                                                 195 }
225                                                   196 
226 //....oooOO0OOooo........oooOO0OOooo........oo << 
227                                                << 
228 // Hadron Processes                               197 // Hadron Processes
229                                                   198 
230 #include "G4HadronElasticProcess.hh"              199 #include "G4HadronElasticProcess.hh"
231 #include "G4HadronInelasticProcess.hh"         << 200 #include "G4HadronFissionProcess.hh"
232 #include "G4NeutronCaptureProcess.hh"          << 201 #include "G4HadronCaptureProcess.hh"
233 #include "G4NeutronFissionProcess.hh"          << 202 
                                                   >> 203 #include "G4PionPlusInelasticProcess.hh"
                                                   >> 204 #include "G4PionMinusInelasticProcess.hh"
                                                   >> 205 #include "G4KaonPlusInelasticProcess.hh"
                                                   >> 206 #include "G4KaonZeroSInelasticProcess.hh"
                                                   >> 207 #include "G4KaonZeroLInelasticProcess.hh"
                                                   >> 208 #include "G4KaonMinusInelasticProcess.hh"
                                                   >> 209 #include "G4ProtonInelasticProcess.hh"
                                                   >> 210 #include "G4AntiProtonInelasticProcess.hh"
                                                   >> 211 #include "G4NeutronInelasticProcess.hh"
                                                   >> 212 #include "G4AntiNeutronInelasticProcess.hh"
                                                   >> 213 #include "G4LambdaInelasticProcess.hh"
                                                   >> 214 #include "G4AntiLambdaInelasticProcess.hh"
                                                   >> 215 #include "G4SigmaPlusInelasticProcess.hh"
                                                   >> 216 #include "G4SigmaMinusInelasticProcess.hh"
                                                   >> 217 #include "G4AntiSigmaPlusInelasticProcess.hh"
                                                   >> 218 #include "G4AntiSigmaMinusInelasticProcess.hh"
                                                   >> 219 #include "G4XiZeroInelasticProcess.hh"
                                                   >> 220 #include "G4XiMinusInelasticProcess.hh"
                                                   >> 221 #include "G4AntiXiZeroInelasticProcess.hh"
                                                   >> 222 #include "G4AntiXiMinusInelasticProcess.hh"
                                                   >> 223 #include "G4DeuteronInelasticProcess.hh"
                                                   >> 224 #include "G4TritonInelasticProcess.hh"
                                                   >> 225 #include "G4AlphaInelasticProcess.hh"
                                                   >> 226 #include "G4OmegaMinusInelasticProcess.hh"
                                                   >> 227 #include "G4AntiOmegaMinusInelasticProcess.hh"
234                                                   228 
235 // Low-energy Models                              229 // Low-energy Models
236                                                   230 
237 #include "G4HadronElastic.hh"                  << 231 #include "G4LElastic.hh"
238 #include "G4LFission.hh"                          232 #include "G4LFission.hh"
239 #include "G4NeutronRadCapture.hh"              << 233 #include "G4LCapture.hh"
                                                   >> 234 
                                                   >> 235 #include "G4LEPionPlusInelastic.hh"
                                                   >> 236 #include "G4LEPionMinusInelastic.hh"
                                                   >> 237 #include "G4LEKaonPlusInelastic.hh"
                                                   >> 238 #include "G4LEKaonZeroSInelastic.hh"
                                                   >> 239 #include "G4LEKaonZeroLInelastic.hh"
                                                   >> 240 #include "G4LEKaonMinusInelastic.hh"
                                                   >> 241 #include "G4LEProtonInelastic.hh"
                                                   >> 242 #include "G4LEAntiProtonInelastic.hh"
                                                   >> 243 #include "G4LENeutronInelastic.hh"
                                                   >> 244 #include "G4LEAntiNeutronInelastic.hh"
                                                   >> 245 #include "G4LELambdaInelastic.hh"
                                                   >> 246 #include "G4LEAntiLambdaInelastic.hh"
                                                   >> 247 #include "G4LESigmaPlusInelastic.hh"
                                                   >> 248 #include "G4LESigmaMinusInelastic.hh"
                                                   >> 249 #include "G4LEAntiSigmaPlusInelastic.hh"
                                                   >> 250 #include "G4LEAntiSigmaMinusInelastic.hh"
                                                   >> 251 #include "G4LEXiZeroInelastic.hh"
                                                   >> 252 #include "G4LEXiMinusInelastic.hh"
                                                   >> 253 #include "G4LEAntiXiZeroInelastic.hh"
                                                   >> 254 #include "G4LEAntiXiMinusInelastic.hh"
                                                   >> 255 #include "G4LEDeuteronInelastic.hh"
                                                   >> 256 #include "G4LETritonInelastic.hh"
                                                   >> 257 #include "G4LEAlphaInelastic.hh"
                                                   >> 258 #include "G4LEOmegaMinusInelastic.hh"
                                                   >> 259 #include "G4LEAntiOmegaMinusInelastic.hh"
240                                                   260 
241 // -- generator models                            261 // -- generator models
242 #include "G4BinaryLightIonReaction.hh"         << 262 #include "G4TheoFSGenerator.hh"
243 #include "G4CascadeInterface.hh"               << 
244 #include "G4CompetitiveFission.hh"             << 
245 #include "G4ExcitationHandler.hh"                 263 #include "G4ExcitationHandler.hh"
246 #include "G4ExcitedStringDecay.hh"             << 264 #include "G4Evaporation.hh"
247 #include "G4FTFModel.hh"                       << 265 #include "G4CompetitiveFission.hh"
248 #include "G4Fancy3DNucleus.hh"                 << 266 #include "G4FermiBreakUp.hh"
                                                   >> 267 #include "G4StatMF.hh"
249 #include "G4GeneratorPrecompoundInterface.hh"     268 #include "G4GeneratorPrecompoundInterface.hh"
250 #include "G4LundStringFragmentation.hh"        << 269 #include "G4Fancy3DNucleus.hh"
                                                   >> 270 #include "G4LEProtonInelastic.hh"
                                                   >> 271 #include "G4StringModel.hh"
251 #include "G4PreCompoundModel.hh"                  272 #include "G4PreCompoundModel.hh"
                                                   >> 273 #include "G4FTFModel.hh"
252 #include "G4QGSMFragmentation.hh"                 274 #include "G4QGSMFragmentation.hh"
253 #include "G4QMDReaction.hh"                    << 275 #include "G4ExcitedStringDecay.hh"
254 #include "G4StringModel.hh"                    << 
255 #include "G4TheoFSGenerator.hh"                << 
256                                                << 
257 // Cross sections                              << 
258 #include "G4ComponentGGHadronNucleusXsc.hh"    << 
259 #include "G4ComponentGGNuclNuclXsc.hh"         << 
260 #include "G4CrossSectionElastic.hh"            << 
261 #include "G4CrossSectionInelastic.hh"          << 
262 #include "G4NeutronInelasticXS.hh"             << 
263                                                   276 
264 //                                                277 //
265 // ConstructHad()                                 278 // ConstructHad()
266 //                                                279 //
267 // Makes discrete physics processes for the ha << 280 // Makes discrete physics processes for the hadrons, at present limited
                                                   >> 281 // to those particles with GHEISHA interactions (INTRC > 0).
268 // The processes are: Elastic scattering, Inel    282 // The processes are: Elastic scattering, Inelastic scattering,
269 // Fission (for neutron only), and Capture (ne    283 // Fission (for neutron only), and Capture (neutron).
270 //                                                284 //
                                                   >> 285 // F.W.Jones  06-JUL-1998
                                                   >> 286 //
271                                                   287 
272 void B03PhysicsList::ConstructHad()               288 void B03PhysicsList::ConstructHad()
273 {                                                 289 {
274   // this will be the model class for high ene << 290     // this will be the model class for high energies
275   G4TheoFSGenerator* theTheoModel = new G4Theo << 291     G4TheoFSGenerator * theTheoModel = new G4TheoFSGenerator;
276   G4TheoFSGenerator* antiBHighEnergyModel = ne << 292        
277                                                << 293     // all models for treatment of thermal nucleus 
278   // Evaporation logic                         << 294     G4Evaporation * theEvaporation = new G4Evaporation;
279   G4ExcitationHandler* theHandler = new G4Exci << 295     G4FermiBreakUp * theFermiBreakUp = new G4FermiBreakUp;
280   theHandler->SetMinEForMultiFrag(3 * MeV);    << 296     G4StatMF * theMF = new G4StatMF;
281                                                << 297 
282   // Pre equilibrium stage                     << 298     // Evaporation logic
283   G4PreCompoundModel* thePreEquilib = new G4Pr << 299     G4ExcitationHandler * theHandler = new G4ExcitationHandler;
284                                                << 300         theHandler->SetEvaporation(theEvaporation);
285   // a no-cascade generator-precompound intera << 301         theHandler->SetFermiModel(theFermiBreakUp);
286   G4GeneratorPrecompoundInterface* theCascade  << 302         theHandler->SetMultiFragmentation(theMF);
287   theCascade->SetDeExcitation(thePreEquilib);  << 303         theHandler->SetMaxAandZForFermiBreakUp(12, 6);
288                                                << 304         theHandler->SetMinEForMultiFrag(3*MeV);
289   // Bertini cascade                           << 305   
290   G4CascadeInterface* bertini = new G4CascadeI << 306     // Pre equilibrium stage 
291   bertini->SetMaxEnergy(22 * MeV);             << 307     G4PreCompoundModel * thePreEquilib = new G4PreCompoundModel(theHandler);
292                                                << 308 
293   // here come the high energy parts           << 309     
294   G4VPartonStringModel* theStringModel;        << 310     // a no-cascade generator-precompound interaface
295   theStringModel = new G4FTFModel;             << 311     G4GeneratorPrecompoundInterface * theCascade = new G4GeneratorPrecompoundInterface;
296   theTheoModel->SetTransport(theCascade);      << 312             theCascade->SetDeExcitation(thePreEquilib);  
297   theTheoModel->SetHighEnergyGenerator(theStri << 313   
298   theTheoModel->SetMinEnergy(19 * GeV);        << 314     // here come the high energy parts
299   theTheoModel->SetMaxEnergy(G4HadronicParamet << 315     // the string model; still not quite according to design - Explicite use of the forseen interfaces 
300                                                << 316     // will be tested and documented in this program by beta-02 at latest.
301   G4VLongitudinalStringDecay* theFragmentation << 317     G4VPartonStringModel * theStringModel;
302   G4ExcitedStringDecay* theStringDecay = new G << 318     theStringModel = new G4FTFModel;
303   theStringModel->SetFragmentationModel(theStr << 319     theTheoModel->SetTransport(theCascade);
304                                                << 320     theTheoModel->SetHighEnergyGenerator(theStringModel);
305   // high energy model for anti-baryons        << 321     theTheoModel->SetMinEnergy(19*GeV);
306   antiBHighEnergyModel = new G4TheoFSGenerator << 322     theTheoModel->SetMaxEnergy(100*TeV);
307   G4FTFModel* antiBStringModel = new G4FTFMode << 323 
308   G4ExcitedStringDecay* stringDecay = new G4Ex << 324       G4VLongitudinalStringDecay * theFragmentation = new G4QGSMFragmentation;
309   antiBStringModel->SetFragmentationModel(stri << 325       G4ExcitedStringDecay * theStringDecay = new G4ExcitedStringDecay(theFragmentation);
310                                                << 326       theStringModel->SetFragmentationModel(theStringDecay);
311   G4GeneratorPrecompoundInterface* antiBCascad << 327 
312   G4PreCompoundModel* preEquilib = new G4PreCo << 328 // done with the generator model (most of the above is also available as default)
313   antiBCascade->SetDeExcitation(preEquilib);   << 329    G4HadronElasticProcess* theElasticProcess = 
314                                                << 330                                     new G4HadronElasticProcess;
315   antiBHighEnergyModel->SetTransport(antiBCasc << 331    G4LElastic* theElasticModel = new G4LElastic;
316   antiBHighEnergyModel->SetHighEnergyGenerator << 332    theElasticProcess->RegisterMe(theElasticModel);
317   antiBHighEnergyModel->SetMinEnergy(0.0);     << 333    G4HadronElasticProcess* theElasticProcess1 = 
318   antiBHighEnergyModel->SetMaxEnergy(20 * TeV) << 334                                     new G4HadronElasticProcess;
319                                                << 335    theParticleIterator->reset();
320   // Light ion models                          << 336    while ((*theParticleIterator)()) {
321   G4BinaryLightIonReaction* binaryCascade = ne << 337       G4ParticleDefinition* particle = theParticleIterator->value();
322   binaryCascade->SetMinEnergy(0.0);            << 338       G4ProcessManager* pmanager = particle->GetProcessManager();
323   binaryCascade->SetMaxEnergy(110 * MeV);      << 339       G4String particleName = particle->GetParticleName();
324                                                << 340      
325   G4QMDReaction* qmd = new G4QMDReaction;      << 341       if (particleName == "pi+") {
326   qmd->SetMinEnergy(100 * MeV);                << 342          pmanager->AddDiscreteProcess(theElasticProcess);
327   qmd->SetMaxEnergy(10 * GeV);                 << 343          G4PionPlusInelasticProcess* theInelasticProcess = 
328                                                << 344                                 new G4PionPlusInelasticProcess("inelastic");
329   G4VCrossSectionDataSet* ionXS = new G4CrossS << 345          G4LEPionPlusInelastic* theInelasticModel = 
330                                                << 346                                 new G4LEPionPlusInelastic;
331   G4ComponentGGHadronNucleusXsc* ggHNXsec = ne << 347          theInelasticProcess->RegisterMe(theInelasticModel);
332   G4VCrossSectionDataSet* theGGHNEl = new G4Cr << 348          theInelasticProcess->RegisterMe(theTheoModel);
333   G4VCrossSectionDataSet* theGGHNInel = new G4 << 349          pmanager->AddDiscreteProcess(theInelasticProcess);
334                                                << 350       }
335   // Elastic process                           << 351       else if (particleName == "pi-") {
336   G4HadronElasticProcess* theElasticProcess =  << 352          pmanager->AddDiscreteProcess(theElasticProcess);
337   theElasticProcess->AddDataSet(theGGHNEl);    << 353          G4PionMinusInelasticProcess* theInelasticProcess = 
338   G4HadronElastic* theElasticModel = new G4Had << 354                                 new G4PionMinusInelasticProcess("inelastic");
339   theElasticProcess->RegisterMe(theElasticMode << 355          G4LEPionMinusInelastic* theInelasticModel = 
340                                                << 356                                 new G4LEPionMinusInelastic;
341   auto particleIterator = GetParticleIterator( << 357          theInelasticProcess->RegisterMe(theInelasticModel);
342   particleIterator->reset();                   << 358          theInelasticProcess->RegisterMe(theTheoModel);
343   while ((*particleIterator)()) {              << 359          pmanager->AddDiscreteProcess(theInelasticProcess);
344     G4ParticleDefinition* particle = particleI << 360       }
345     G4ProcessManager* pmanager = particle->Get << 361       else if (particleName == "kaon+") {
346     G4String particleName = particle->GetParti << 362          pmanager->AddDiscreteProcess(theElasticProcess);
347                                                << 363          G4KaonPlusInelasticProcess* theInelasticProcess = 
348     if (particleName == "pi+") {               << 364                                   new G4KaonPlusInelasticProcess("inelastic");
349       pmanager->AddDiscreteProcess(theElasticP << 365          G4LEKaonPlusInelastic* theInelasticModel = new G4LEKaonPlusInelastic;
350       G4HadronInelasticProcess* theInelasticPr << 366          theInelasticProcess->RegisterMe(theInelasticModel);
351         new G4HadronInelasticProcess("inelasti << 367          theInelasticProcess->RegisterMe(theTheoModel);
352       theInelasticProcess->AddDataSet(theGGHNI << 368          pmanager->AddDiscreteProcess(theInelasticProcess);
353       theInelasticProcess->RegisterMe(bertini) << 369       }
354       theInelasticProcess->RegisterMe(theTheoM << 370       else if (particleName == "kaon0S") {
355       pmanager->AddDiscreteProcess(theInelasti << 371          pmanager->AddDiscreteProcess(theElasticProcess);
356     }                                          << 372          G4KaonZeroSInelasticProcess* theInelasticProcess = 
357     else if (particleName == "pi-") {          << 373                              new G4KaonZeroSInelasticProcess("inelastic");
358       pmanager->AddDiscreteProcess(theElasticP << 374          G4LEKaonZeroSInelastic* theInelasticModel = 
359       G4HadronInelasticProcess* theInelasticPr << 375                              new G4LEKaonZeroSInelastic;
360         new G4HadronInelasticProcess("inelasti << 376          theInelasticProcess->RegisterMe(theInelasticModel);
361       theInelasticProcess->AddDataSet(theGGHNI << 377          theInelasticProcess->RegisterMe(theTheoModel);
362       theInelasticProcess->RegisterMe(bertini) << 378          pmanager->AddDiscreteProcess(theInelasticProcess);
363       theInelasticProcess->RegisterMe(theTheoM << 379       }
364       pmanager->AddDiscreteProcess(theInelasti << 380       else if (particleName == "kaon0L") {
365     }                                          << 381          pmanager->AddDiscreteProcess(theElasticProcess);
366     else if (particleName == "kaon+") {        << 382          G4KaonZeroLInelasticProcess* theInelasticProcess = 
367       pmanager->AddDiscreteProcess(theElasticP << 383                              new G4KaonZeroLInelasticProcess("inelastic");
368       G4HadronInelasticProcess* theInelasticPr << 384          G4LEKaonZeroLInelastic* theInelasticModel = 
369         new G4HadronInelasticProcess("inelasti << 385                              new G4LEKaonZeroLInelastic;
370       theInelasticProcess->AddDataSet(theGGHNI << 386          theInelasticProcess->RegisterMe(theInelasticModel);
371       theInelasticProcess->RegisterMe(bertini) << 387          theInelasticProcess->RegisterMe(theTheoModel);
372       theInelasticProcess->RegisterMe(theTheoM << 388          pmanager->AddDiscreteProcess(theInelasticProcess);
373       pmanager->AddDiscreteProcess(theInelasti << 389       }
374     }                                          << 390       else if (particleName == "kaon-") {
375     else if (particleName == "kaon0S") {       << 391          pmanager->AddDiscreteProcess(theElasticProcess);
376       pmanager->AddDiscreteProcess(theElasticP << 392          G4KaonMinusInelasticProcess* theInelasticProcess = 
377       G4HadronInelasticProcess* theInelasticPr << 393                                  new G4KaonMinusInelasticProcess("inelastic");
378         new G4HadronInelasticProcess("inelasti << 394          G4LEKaonMinusInelastic* theInelasticModel = 
379       theInelasticProcess->AddDataSet(theGGHNI << 395                                  new G4LEKaonMinusInelastic;
380       theInelasticProcess->RegisterMe(bertini) << 396          theInelasticProcess->RegisterMe(theInelasticModel);
381       theInelasticProcess->RegisterMe(theTheoM << 397          theInelasticProcess->RegisterMe(theTheoModel);
382       pmanager->AddDiscreteProcess(theInelasti << 398          pmanager->AddDiscreteProcess(theInelasticProcess);
383     }                                          << 399       }
384     else if (particleName == "kaon0L") {       << 400       else if (particleName == "proton") {
385       pmanager->AddDiscreteProcess(theElasticP << 401          pmanager->AddDiscreteProcess(theElasticProcess);
386       G4HadronInelasticProcess* theInelasticPr << 402          G4ProtonInelasticProcess* theInelasticProcess = 
387         new G4HadronInelasticProcess("inelasti << 403                                     new G4ProtonInelasticProcess("inelastic");
388       theInelasticProcess->AddDataSet(theGGHNI << 404          G4LEProtonInelastic* theInelasticModel = new G4LEProtonInelastic;
389       theInelasticProcess->RegisterMe(bertini) << 405          theInelasticProcess->RegisterMe(theInelasticModel);
390       theInelasticProcess->RegisterMe(theTheoM << 406          theInelasticProcess->RegisterMe(theTheoModel);
391       pmanager->AddDiscreteProcess(theInelasti << 407          pmanager->AddDiscreteProcess(theInelasticProcess);
392     }                                          << 408       }
393     else if (particleName == "kaon-") {        << 409       else if (particleName == "anti_proton") {
394       pmanager->AddDiscreteProcess(theElasticP << 410          pmanager->AddDiscreteProcess(theElasticProcess);
395       G4HadronInelasticProcess* theInelasticPr << 411          G4AntiProtonInelasticProcess* theInelasticProcess = 
396         new G4HadronInelasticProcess("inelasti << 412                                 new G4AntiProtonInelasticProcess("inelastic");
397       theInelasticProcess->AddDataSet(theGGHNI << 413          G4LEAntiProtonInelastic* theInelasticModel = 
398       theInelasticProcess->RegisterMe(bertini) << 414                                 new G4LEAntiProtonInelastic;
399       theInelasticProcess->RegisterMe(theTheoM << 415          theInelasticProcess->RegisterMe(theInelasticModel);
400       pmanager->AddDiscreteProcess(theInelasti << 416          theInelasticProcess->RegisterMe(theTheoModel);
401     }                                          << 417          pmanager->AddDiscreteProcess(theInelasticProcess);
402     else if (particleName == "proton") {       << 418       }
403       pmanager->AddDiscreteProcess(theElasticP << 419       else if (particleName == "neutron") {
404       G4HadronInelasticProcess* theInelasticPr << 420          
405         new G4HadronInelasticProcess("inelasti << 421           // elastic scattering
406       theInelasticProcess->AddDataSet(theGGHNI << 422          G4LElastic* theElasticModel1 = new G4LElastic;
407       theInelasticProcess->RegisterMe(bertini) << 423          theElasticProcess1->RegisterMe(theElasticModel1);
408       theInelasticProcess->RegisterMe(theTheoM << 424          pmanager->AddDiscreteProcess(theElasticProcess1);
409       pmanager->AddDiscreteProcess(theInelasti << 425           // inelastic scattering
410     }                                          << 426          G4NeutronInelasticProcess* theInelasticProcess = 
411     else if (particleName == "anti_proton") {  << 427                                     new G4NeutronInelasticProcess("inelastic");
412       pmanager->AddDiscreteProcess(theElasticP << 428          G4LENeutronInelastic* theInelasticModel = new G4LENeutronInelastic;
413       G4HadronInelasticProcess* theInelasticPr << 429          theInelasticProcess->RegisterMe(theInelasticModel);
414         new G4HadronInelasticProcess("inelasti << 430          theInelasticProcess->RegisterMe(theTheoModel);
415       theInelasticProcess->AddDataSet(theGGHNI << 431          pmanager->AddDiscreteProcess(theInelasticProcess);
416       theInelasticProcess->RegisterMe(antiBHig << 432           // fission
417       pmanager->AddDiscreteProcess(theInelasti << 433          G4HadronFissionProcess* theFissionProcess =
418     }                                          << 434                                     new G4HadronFissionProcess;
419     else if (particleName == "neutron") {      << 435          G4LFission* theFissionModel = new G4LFission;
420       // elastic scattering                    << 436          theFissionProcess->RegisterMe(theFissionModel);
421       pmanager->AddDiscreteProcess(theElasticP << 437          pmanager->AddDiscreteProcess(theFissionProcess);
422                                                << 438          // capture
423       // inelastic scattering                  << 439          G4HadronCaptureProcess* theCaptureProcess =
424       G4HadronInelasticProcess* theInelasticPr << 440                                     new G4HadronCaptureProcess;
425         new G4HadronInelasticProcess("inelasti << 441          G4LCapture* theCaptureModel = new G4LCapture;
426       theInelasticProcess->AddDataSet(new G4Ne << 442          theCaptureProcess->RegisterMe(theCaptureModel);
427       theInelasticProcess->RegisterMe(bertini) << 443          pmanager->AddDiscreteProcess(theCaptureProcess);
428       theInelasticProcess->RegisterMe(theTheoM << 444       }  
429       pmanager->AddDiscreteProcess(theInelasti << 445       else if (particleName == "anti_neutron") {
430                                                << 446          pmanager->AddDiscreteProcess(theElasticProcess);
431       // fission                               << 447          G4AntiNeutronInelasticProcess* theInelasticProcess = 
432       G4NeutronFissionProcess* theFissionProce << 448                                new G4AntiNeutronInelasticProcess("inelastic");
433       G4LFission* theFissionModel = new G4LFis << 449          G4LEAntiNeutronInelastic* theInelasticModel = 
434       theFissionProcess->RegisterMe(theFission << 450                                new G4LEAntiNeutronInelastic;
435       pmanager->AddDiscreteProcess(theFissionP << 451          theInelasticProcess->RegisterMe(theInelasticModel);
436                                                << 452    theInelasticProcess->RegisterMe(theTheoModel);
437       // capture                               << 453          pmanager->AddDiscreteProcess(theInelasticProcess);
438       G4NeutronCaptureProcess* theCaptureProce << 454       }
439       G4NeutronRadCapture* theCaptureModel = n << 455       else if (particleName == "lambda") {
440       theCaptureProcess->RegisterMe(theCapture << 456          pmanager->AddDiscreteProcess(theElasticProcess);
441       pmanager->AddDiscreteProcess(theCaptureP << 457          G4LambdaInelasticProcess* theInelasticProcess = 
442     }                                          << 458                                     new G4LambdaInelasticProcess("inelastic");
443     else if (particleName == "anti_neutron") { << 459          G4LELambdaInelastic* theInelasticModel = new G4LELambdaInelastic;
444       pmanager->AddDiscreteProcess(theElasticP << 460          theInelasticProcess->RegisterMe(theInelasticModel);
445       G4HadronInelasticProcess* theInelasticPr << 461          theInelasticProcess->RegisterMe(theTheoModel);
446         new G4HadronInelasticProcess("inelasti << 462          pmanager->AddDiscreteProcess(theInelasticProcess);
447       theInelasticProcess->AddDataSet(theGGHNI << 463       }
448       theInelasticProcess->RegisterMe(antiBHig << 464       else if (particleName == "anti_lambda") {
449       pmanager->AddDiscreteProcess(theInelasti << 465          pmanager->AddDiscreteProcess(theElasticProcess);
450     }                                          << 466          G4AntiLambdaInelasticProcess* theInelasticProcess = 
451     else if (particleName == "lambda") {       << 467                                 new G4AntiLambdaInelasticProcess("inelastic");
452       pmanager->AddDiscreteProcess(theElasticP << 468          G4LEAntiLambdaInelastic* theInelasticModel = 
453       G4HadronInelasticProcess* theInelasticPr << 469                                 new G4LEAntiLambdaInelastic;
454         new G4HadronInelasticProcess("inelasti << 470          theInelasticProcess->RegisterMe(theInelasticModel);
455       theInelasticProcess->AddDataSet(theGGHNI << 471          theInelasticProcess->RegisterMe(theTheoModel);
456       theInelasticProcess->RegisterMe(bertini) << 472          pmanager->AddDiscreteProcess(theInelasticProcess);
457       theInelasticProcess->RegisterMe(theTheoM << 473       }
458       pmanager->AddDiscreteProcess(theInelasti << 474       else if (particleName == "sigma+") {
459     }                                          << 475          pmanager->AddDiscreteProcess(theElasticProcess);
460     else if (particleName == "anti_lambda") {  << 476          G4SigmaPlusInelasticProcess* theInelasticProcess = 
461       pmanager->AddDiscreteProcess(theElasticP << 477                                  new G4SigmaPlusInelasticProcess("inelastic");
462       G4HadronInelasticProcess* theInelasticPr << 478          G4LESigmaPlusInelastic* theInelasticModel = 
463         new G4HadronInelasticProcess("inelasti << 479                                  new G4LESigmaPlusInelastic;
464       theInelasticProcess->AddDataSet(theGGHNI << 480          theInelasticProcess->RegisterMe(theInelasticModel);
465       theInelasticProcess->RegisterMe(antiBHig << 481          theInelasticProcess->RegisterMe(theTheoModel);
466       pmanager->AddDiscreteProcess(theInelasti << 482          pmanager->AddDiscreteProcess(theInelasticProcess);
467     }                                          << 483       }
468     else if (particleName == "sigma+") {       << 484       else if (particleName == "sigma-") {
469       pmanager->AddDiscreteProcess(theElasticP << 485          pmanager->AddDiscreteProcess(theElasticProcess);
470       G4HadronInelasticProcess* theInelasticPr << 486          G4SigmaMinusInelasticProcess* theInelasticProcess = 
471         new G4HadronInelasticProcess("inelasti << 487                                  new G4SigmaMinusInelasticProcess("inelastic");
472       theInelasticProcess->AddDataSet(theGGHNI << 488          G4LESigmaMinusInelastic* theInelasticModel = 
473       theInelasticProcess->RegisterMe(bertini) << 489                                  new G4LESigmaMinusInelastic;
474       theInelasticProcess->RegisterMe(theTheoM << 490          theInelasticProcess->RegisterMe(theInelasticModel);
475       pmanager->AddDiscreteProcess(theInelasti << 491          theInelasticProcess->RegisterMe(theTheoModel);
476     }                                          << 492          pmanager->AddDiscreteProcess(theInelasticProcess);
477     else if (particleName == "sigma-") {       << 493       }
478       pmanager->AddDiscreteProcess(theElasticP << 494       else if (particleName == "anti_sigma+") {
479       G4HadronInelasticProcess* theInelasticPr << 495          pmanager->AddDiscreteProcess(theElasticProcess);
480         new G4HadronInelasticProcess("inelasti << 496          G4AntiSigmaPlusInelasticProcess* theInelasticProcess = 
481       theInelasticProcess->AddDataSet(theGGHNI << 497                              new G4AntiSigmaPlusInelasticProcess("inelastic");
482       theInelasticProcess->RegisterMe(bertini) << 498          G4LEAntiSigmaPlusInelastic* theInelasticModel = 
483       theInelasticProcess->RegisterMe(theTheoM << 499                                  new G4LEAntiSigmaPlusInelastic;
484       pmanager->AddDiscreteProcess(theInelasti << 500          theInelasticProcess->RegisterMe(theInelasticModel);
485     }                                          << 501          theInelasticProcess->RegisterMe(theTheoModel);
486     else if (particleName == "anti_sigma+") {  << 502          pmanager->AddDiscreteProcess(theInelasticProcess);
487       pmanager->AddDiscreteProcess(theElasticP << 503       }
488       G4HadronInelasticProcess* theInelasticPr << 504       else if (particleName == "anti_sigma-") {
489         new G4HadronInelasticProcess("inelasti << 505          pmanager->AddDiscreteProcess(theElasticProcess);
490       theInelasticProcess->AddDataSet(theGGHNI << 506          G4AntiSigmaMinusInelasticProcess* theInelasticProcess = 
491       theInelasticProcess->RegisterMe(antiBHig << 507                             new G4AntiSigmaMinusInelasticProcess("inelastic");
492       pmanager->AddDiscreteProcess(theInelasti << 508          G4LEAntiSigmaMinusInelastic* theInelasticModel = 
493     }                                          << 509                                  new G4LEAntiSigmaMinusInelastic;
494     else if (particleName == "anti_sigma-") {  << 510          theInelasticProcess->RegisterMe(theInelasticModel);
495       pmanager->AddDiscreteProcess(theElasticP << 511          theInelasticProcess->RegisterMe(theTheoModel);
496       G4HadronInelasticProcess* theInelasticPr << 512          pmanager->AddDiscreteProcess(theInelasticProcess);
497         new G4HadronInelasticProcess("inelasti << 513       }
498       theInelasticProcess->AddDataSet(theGGHNI << 514       else if (particleName == "xi0") {
499       theInelasticProcess->RegisterMe(antiBHig << 515          pmanager->AddDiscreteProcess(theElasticProcess);
500       pmanager->AddDiscreteProcess(theInelasti << 516          G4XiZeroInelasticProcess* theInelasticProcess = 
501     }                                          << 517                             new G4XiZeroInelasticProcess("inelastic");
502     else if (particleName == "xi0") {          << 518          G4LEXiZeroInelastic* theInelasticModel = 
503       pmanager->AddDiscreteProcess(theElasticP << 519                                  new G4LEXiZeroInelastic;
504       G4HadronInelasticProcess* theInelasticPr << 520          theInelasticProcess->RegisterMe(theInelasticModel);
505         new G4HadronInelasticProcess("inelasti << 521          theInelasticProcess->RegisterMe(theTheoModel);
506       theInelasticProcess->AddDataSet(theGGHNI << 522          pmanager->AddDiscreteProcess(theInelasticProcess);
507       theInelasticProcess->RegisterMe(bertini) << 523       }
508       theInelasticProcess->RegisterMe(theTheoM << 524       else if (particleName == "xi-") {
509       pmanager->AddDiscreteProcess(theInelasti << 525          pmanager->AddDiscreteProcess(theElasticProcess);
510     }                                          << 526          G4XiMinusInelasticProcess* theInelasticProcess = 
511     else if (particleName == "xi-") {          << 527                             new G4XiMinusInelasticProcess("inelastic");
512       pmanager->AddDiscreteProcess(theElasticP << 528          G4LEXiMinusInelastic* theInelasticModel = 
513       G4HadronInelasticProcess* theInelasticPr << 529                                  new G4LEXiMinusInelastic;
514         new G4HadronInelasticProcess("inelasti << 530          theInelasticProcess->RegisterMe(theInelasticModel);
515       theInelasticProcess->AddDataSet(theGGHNI << 531          theInelasticProcess->RegisterMe(theTheoModel);
516       theInelasticProcess->RegisterMe(bertini) << 532          pmanager->AddDiscreteProcess(theInelasticProcess);
517       theInelasticProcess->RegisterMe(theTheoM << 533       }
518       pmanager->AddDiscreteProcess(theInelasti << 534       else if (particleName == "anti_xi0") {
519     }                                          << 535          pmanager->AddDiscreteProcess(theElasticProcess);
520     else if (particleName == "anti_xi0") {     << 536          G4AntiXiZeroInelasticProcess* theInelasticProcess = 
521       pmanager->AddDiscreteProcess(theElasticP << 537                             new G4AntiXiZeroInelasticProcess("inelastic");
522       G4HadronInelasticProcess* theInelasticPr << 538          G4LEAntiXiZeroInelastic* theInelasticModel = 
523         new G4HadronInelasticProcess("inelasti << 539                                  new G4LEAntiXiZeroInelastic;
524       theInelasticProcess->AddDataSet(theGGHNI << 540          theInelasticProcess->RegisterMe(theInelasticModel);
525       theInelasticProcess->RegisterMe(antiBHig << 541          theInelasticProcess->RegisterMe(theTheoModel);
526       pmanager->AddDiscreteProcess(theInelasti << 542          pmanager->AddDiscreteProcess(theInelasticProcess);
527     }                                          << 543       }
528     else if (particleName == "anti_xi-") {     << 544       else if (particleName == "anti_xi-") {
529       pmanager->AddDiscreteProcess(theElasticP << 545          pmanager->AddDiscreteProcess(theElasticProcess);
530       G4HadronInelasticProcess* theInelasticPr << 546          G4AntiXiMinusInelasticProcess* theInelasticProcess = 
531         new G4HadronInelasticProcess("inelasti << 547                             new G4AntiXiMinusInelasticProcess("inelastic");
532       theInelasticProcess->AddDataSet(theGGHNI << 548          G4LEAntiXiMinusInelastic* theInelasticModel = 
533       theInelasticProcess->RegisterMe(antiBHig << 549                                  new G4LEAntiXiMinusInelastic;
534       pmanager->AddDiscreteProcess(theInelasti << 550          theInelasticProcess->RegisterMe(theInelasticModel);
535     }                                          << 551          theInelasticProcess->RegisterMe(theTheoModel);
536     else if (particleName == "deuteron") {     << 552          pmanager->AddDiscreteProcess(theInelasticProcess);
537       pmanager->AddDiscreteProcess(theElasticP << 553       }
538       G4HadronInelasticProcess* theInelasticPr << 554       else if (particleName == "deuteron") {
539         new G4HadronInelasticProcess("inelasti << 555          pmanager->AddDiscreteProcess(theElasticProcess);
540       theInelasticProcess->RegisterMe(binaryCa << 556          G4DeuteronInelasticProcess* theInelasticProcess = 
541       theInelasticProcess->RegisterMe(qmd);    << 557                             new G4DeuteronInelasticProcess("inelastic");
542       theInelasticProcess->AddDataSet(ionXS);  << 558          G4LEDeuteronInelastic* theInelasticModel = 
543       pmanager->AddDiscreteProcess(theInelasti << 559                                  new G4LEDeuteronInelastic;
544     }                                          << 560          theInelasticProcess->RegisterMe(theInelasticModel);
545     else if (particleName == "triton") {       << 561          theInelasticProcess->RegisterMe(theTheoModel);
546       pmanager->AddDiscreteProcess(theElasticP << 562          pmanager->AddDiscreteProcess(theInelasticProcess);
547       G4HadronInelasticProcess* theInelasticPr << 563       }
548         new G4HadronInelasticProcess("inelasti << 564       else if (particleName == "triton") {
549       theInelasticProcess->RegisterMe(binaryCa << 565          pmanager->AddDiscreteProcess(theElasticProcess);
550       theInelasticProcess->RegisterMe(qmd);    << 566          G4TritonInelasticProcess* theInelasticProcess = 
551       theInelasticProcess->AddDataSet(ionXS);  << 567                             new G4TritonInelasticProcess("inelastic");
552       pmanager->AddDiscreteProcess(theInelasti << 568          G4LETritonInelastic* theInelasticModel = 
553     }                                          << 569                                  new G4LETritonInelastic;
554     else if (particleName == "alpha") {        << 570          theInelasticProcess->RegisterMe(theInelasticModel);
555       pmanager->AddDiscreteProcess(theElasticP << 571          theInelasticProcess->RegisterMe(theTheoModel);
556       G4HadronInelasticProcess* theInelasticPr << 572          pmanager->AddDiscreteProcess(theInelasticProcess);
557         new G4HadronInelasticProcess("inelasti << 573       }
558       theInelasticProcess->RegisterMe(binaryCa << 574       else if (particleName == "alpha") {
559       theInelasticProcess->RegisterMe(qmd);    << 575          pmanager->AddDiscreteProcess(theElasticProcess);
560       theInelasticProcess->AddDataSet(ionXS);  << 576          G4AlphaInelasticProcess* theInelasticProcess = 
561       pmanager->AddDiscreteProcess(theInelasti << 577                             new G4AlphaInelasticProcess("inelastic");
562     }                                          << 578          G4LEAlphaInelastic* theInelasticModel = 
563     else if (particleName == "omega-") {       << 579                                  new G4LEAlphaInelastic;
564       pmanager->AddDiscreteProcess(theElasticP << 580          theInelasticProcess->RegisterMe(theInelasticModel);
565       G4HadronInelasticProcess* theInelasticPr << 581          theInelasticProcess->RegisterMe(theTheoModel);
566         new G4HadronInelasticProcess("inelasti << 582          pmanager->AddDiscreteProcess(theInelasticProcess);
567       theInelasticProcess->AddDataSet(theGGHNI << 583       }
568       theInelasticProcess->RegisterMe(bertini) << 584       else if (particleName == "omega-") {
569       theInelasticProcess->RegisterMe(theTheoM << 585          pmanager->AddDiscreteProcess(theElasticProcess);
570       pmanager->AddDiscreteProcess(theInelasti << 586          G4OmegaMinusInelasticProcess* theInelasticProcess = 
571     }                                          << 587                             new G4OmegaMinusInelasticProcess("inelastic");
572     else if (particleName == "anti_omega-") {  << 588          G4LEOmegaMinusInelastic* theInelasticModel = 
573       pmanager->AddDiscreteProcess(theElasticP << 589                                  new G4LEOmegaMinusInelastic;
574       G4HadronInelasticProcess* theInelasticPr << 590          theInelasticProcess->RegisterMe(theInelasticModel);
575         new G4HadronInelasticProcess("inelasti << 591          theInelasticProcess->RegisterMe(theTheoModel);
576       theInelasticProcess->AddDataSet(theGGHNI << 592          pmanager->AddDiscreteProcess(theInelasticProcess);
577       theInelasticProcess->RegisterMe(antiBHig << 593       }
578       pmanager->AddDiscreteProcess(theInelasti << 594       else if (particleName == "anti_omega-") {
579     }                                          << 595          pmanager->AddDiscreteProcess(theElasticProcess);
580   }                                            << 596          G4AntiOmegaMinusInelasticProcess* theInelasticProcess = 
                                                   >> 597                             new G4AntiOmegaMinusInelasticProcess("inelastic");
                                                   >> 598          G4LEAntiOmegaMinusInelastic* theInelasticModel = 
                                                   >> 599                                  new G4LEAntiOmegaMinusInelastic;
                                                   >> 600          theInelasticProcess->RegisterMe(theInelasticModel);
                                                   >> 601          theInelasticProcess->RegisterMe(theTheoModel);
                                                   >> 602          pmanager->AddDiscreteProcess(theInelasticProcess);
                                                   >> 603       }
                                                   >> 604    }
581 }                                                 605 }
582                                                   606 
583 //....oooOO0OOooo........oooOO0OOooo........oo << 
584                                                << 
585 void B03PhysicsList::ConstructLeptHad()           607 void B03PhysicsList::ConstructLeptHad()
586 {                                              << 608 {;}
587   ;                                            << 
588 }                                              << 
589                                                << 
590 //....oooOO0OOooo........oooOO0OOooo........oo << 
591                                                   609 
592 #include "G4Decay.hh"                             610 #include "G4Decay.hh"
593 void B03PhysicsList::ConstructGeneral()           611 void B03PhysicsList::ConstructGeneral()
594 {                                                 612 {
595   G4Decay* theDecayProcess = new G4Decay();       613   G4Decay* theDecayProcess = new G4Decay();
596   auto particleIterator = GetParticleIterator( << 614   theParticleIterator->reset();
597   particleIterator->reset();                   << 615   while( (*theParticleIterator)() ){
598   while ((*particleIterator)()) {              << 616     G4ParticleDefinition* particle = theParticleIterator->value();
599     G4ParticleDefinition* particle = particleI << 
600     G4ProcessManager* pmanager = particle->Get    617     G4ProcessManager* pmanager = particle->GetProcessManager();
601     if (theDecayProcess->IsApplicable(*particl << 618     if (theDecayProcess->IsApplicable(*particle)) { 
602       pmanager->AddProcess(theDecayProcess);   << 619       pmanager ->AddProcess(theDecayProcess);
603       pmanager->SetProcessOrdering(theDecayPro << 620       pmanager ->SetProcessOrdering(theDecayProcess, idxPostStep);
604       pmanager->SetProcessOrdering(theDecayPro << 621       pmanager ->SetProcessOrdering(theDecayProcess, idxAtRest);
605     }                                             622     }
606   }                                               623   }
607 }                                                 624 }
608                                                   625 
609 //....oooOO0OOooo........oooOO0OOooo........oo << 
610                                                << 
611 void B03PhysicsList::SetCuts()                    626 void B03PhysicsList::SetCuts()
612 {                                                 627 {
613   if (verboseLevel > 0) {                      << 628   if (verboseLevel >0)
                                                   >> 629   {
614     G4cout << "B03PhysicsList::SetCuts:";         630     G4cout << "B03PhysicsList::SetCuts:";
615     G4cout << "CutLength : " << defaultCutValu << 631     G4cout << "CutLength : " << defaultCutValue/mm << " (mm)" << G4endl;
616   }                                            << 632   }  
617   //   "G4VUserPhysicsList::SetCutsWithDefault << 633   //   "G4VUserPhysicsList::SetCutsWithDefault" method sets 
618   //   the default cut value for all particle  << 634   //   the default cut value for all particle types 
619   SetCutsWithDefault();                        << 635   SetCutsWithDefault();   
620 }                                              << 
621                                                << 
622 //....oooOO0OOooo........oooOO0OOooo........oo << 
623                                                << 
624 #include "G4ParallelWorldProcess.hh"           << 
625 void B03PhysicsList::AddScoringProcess()       << 
626 {                                              << 
627   G4int npw = fParaWorldName.size();           << 
628   for (G4int i = 0; i < npw; i++) {            << 
629     G4String procName = "ParaWorldProc_" + fPa << 
630     G4ParallelWorldProcess* theParallelWorldPr << 
631     theParallelWorldProcess->SetParallelWorld( << 
632                                                << 
633     auto particleIterator = GetParticleIterato << 
634     particleIterator->reset();                 << 
635     while ((*particleIterator)()) {            << 
636       G4ParticleDefinition* particle = particl << 
637       G4ProcessManager* pmanager = particle->G << 
638       pmanager->AddProcess(theParallelWorldPro << 
639       if (theParallelWorldProcess->IsAtRestReq << 
640         pmanager->SetProcessOrdering(theParall << 
641       }                                        << 
642       pmanager->SetProcessOrderingToSecond(the << 
643       pmanager->SetProcessOrdering(theParallel << 
644     }                                          << 
645   }                                            << 
646 }                                              << 
647                                                << 
648 //....oooOO0OOooo........oooOO0OOooo........oo << 
649                                                << 
650 #include "G4IStore.hh"                         << 
651 #include "G4ImportanceProcess.hh"              << 
652 void B03PhysicsList::AddBiasingProcess()       << 
653 {                                              << 
654   G4cout << " Preparing Importance Sampling wi << 
655                                                << 
656   G4IStore* iStore = G4IStore::GetInstance(fBi << 
657   G4GeometrySampler fGeomSampler(fBiasWorldNam << 
658   fGeomSampler.SetParallel(true);  // parallel << 
659   // fGeomSampler.SetWorld(iStore->GetParallel << 
660   //  fGeomSampler->PrepareImportanceSampling( << 
661   //                              GetInstance( << 
662   static G4bool first = true;                  << 
663   if (first) {                                 << 
664     fGeomSampler.PrepareImportanceSampling(iSt << 
665                                                << 
666     fGeomSampler.Configure();                  << 
667     G4cout << " GeomSampler Configured!!! " << << 
668     first = false;                             << 
669   }                                            << 
670                                                << 
671 #ifdef G4MULTITHREADED                         << 
672   if (!G4Threading::IsMasterThread()) fGeomSam << 
673 #else                                          << 
674   G4cout << " Running in singlethreaded mode!! << 
675 #endif                                         << 
676 }                                                 636 }
677                                                << 
678 //....oooOO0OOooo........oooOO0OOooo........oo << 
679                                                   637