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