Geant4 Cross Reference |
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-01 $ 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