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 // 26 // 27 // ------------------------------------------- 27 // -------------------------------------------------------------- 28 // GEANT 4 - Underground Dark Matter Detecto 28 // GEANT 4 - Underground Dark Matter Detector Advanced Example 29 // 29 // 30 // For information related to this code c 30 // For information related to this code contact: Alex Howard 31 // e-mail: alexander.howard@cern.ch 31 // e-mail: alexander.howard@cern.ch 32 // ------------------------------------------- 32 // -------------------------------------------------------------- 33 // Comments 33 // Comments 34 // 34 // 35 // Underground Advanced 35 // Underground Advanced 36 // by A. Howard and H. Araujo 36 // by A. Howard and H. Araujo 37 // (27th November 2001) 37 // (27th November 2001) 38 // 38 // 39 // PhysicsList program 39 // PhysicsList program 40 // 40 // 41 // Modified: 41 // Modified: 42 // 42 // 43 // 14-02-03 Fix bugs in msc and hIon instancia 43 // 14-02-03 Fix bugs in msc and hIon instanciation + cut per region 44 // 44 // 45 // 05-02-05 AH - changes to G4Decay - added is 45 // 05-02-05 AH - changes to G4Decay - added is not short lived protection 46 // and redefined particles to allow n 46 // and redefined particles to allow non-static creation 47 // i.e. changed construction to G4Mes 47 // i.e. changed construction to G4MesonConstructor, G4BaryonConstructor 48 // << 49 // 23-10-09 LP - migrated EM physics from the << 50 // the new G4Livermore model implemen << 51 // 48 // 52 // ------------------------------------------- 49 // -------------------------------------------------------------- 53 50 54 #include <iomanip> << 55 << 56 #include "DMXPhysicsList.hh" 51 #include "DMXPhysicsList.hh" 57 52 58 #include "globals.hh" 53 #include "globals.hh" 59 #include "G4SystemOfUnits.hh" << 60 #include "G4ProcessManager.hh" 54 #include "G4ProcessManager.hh" 61 #include "G4ProcessVector.hh" 55 #include "G4ProcessVector.hh" 62 56 63 #include "G4ParticleDefinition.hh" 57 #include "G4ParticleDefinition.hh" 64 #include "G4ParticleWithCuts.hh" 58 #include "G4ParticleWithCuts.hh" 65 #include "G4ParticleTypes.hh" 59 #include "G4ParticleTypes.hh" 66 #include "G4ParticleTable.hh" 60 #include "G4ParticleTable.hh" 67 61 68 #include "G4ios.hh" 62 #include "G4ios.hh" 69 #include "G4UserLimits.hh" << 63 #include <iomanip> 70 << 71 #include "G4MesonConstructor.hh" << 72 #include "G4BaryonConstructor.hh" << 73 #include "G4IonConstructor.hh" << 74 #include "G4ShortLivedConstructor.hh" << 75 << 76 #include "DMXMaxTimeCuts.hh" << 77 #include "DMXMinEkineCuts.hh" << 78 #include "G4StepLimiter.hh" << 79 << 80 // gamma << 81 #include "G4PhotoElectricEffect.hh" << 82 #include "G4LivermorePhotoElectricModel.hh" << 83 << 84 #include "G4ComptonScattering.hh" << 85 #include "G4LivermoreComptonModel.hh" << 86 << 87 #include "G4GammaConversion.hh" << 88 #include "G4BetheHeitler5DModel.hh" << 89 << 90 #include "G4RayleighScattering.hh" << 91 #include "G4LivermoreRayleighModel.hh" << 92 << 93 // e- << 94 #include "G4eMultipleScattering.hh" << 95 << 96 #include "G4eIonisation.hh" << 97 #include "G4LivermoreIonisationModel.hh" << 98 << 99 #include "G4eBremsstrahlung.hh" << 100 #include "G4UniversalFluctuation.hh" << 101 << 102 // e+ << 103 #include "G4eIonisation.hh" << 104 #include "G4eBremsstrahlung.hh" << 105 #include "G4eplusAnnihilation.hh" << 106 << 107 // alpha and GenericIon and deuterons, triton, << 108 //muon: << 109 #include "G4MuIonisation.hh" << 110 #include "G4MuBremsstrahlung.hh" << 111 #include "G4MuPairProduction.hh" << 112 #include "G4MuMultipleScattering.hh" << 113 #include "G4MuonMinusCapture.hh" << 114 << 115 //OTHERS: << 116 #include "G4hIonisation.hh" << 117 #include "G4hMultipleScattering.hh" << 118 #include "G4hBremsstrahlung.hh" << 119 #include "G4ionIonisation.hh" << 120 #include "G4IonParametrisedLossModel.hh" << 121 #include "G4NuclearStopping.hh" << 122 << 123 //em process options to allow msc step-limitat << 124 #include "G4EmParameters.hh" << 125 #include "G4VAtomDeexcitation.hh" << 126 #include "G4UAtomicDeexcitation.hh" << 127 #include "G4LossTableManager.hh" << 128 << 129 #include "G4Scintillation.hh" << 130 #include "G4OpAbsorption.hh" << 131 #include "G4OpBoundaryProcess.hh" << 132 #include "G4OpticalParameters.hh" << 133 << 134 // Elastic processes: << 135 #include "G4HadronElasticProcess.hh" << 136 #include "G4ChipsElasticModel.hh" << 137 #include "G4ElasticHadrNucleusHE.hh" << 138 << 139 // Inelastic processes: << 140 #include "G4HadronInelasticProcess.hh" << 141 << 142 // High energy FTFP model and Bertini cascade << 143 #include "G4FTFModel.hh" << 144 #include "G4LundStringFragmentation.hh" << 145 #include "G4ExcitedStringDecay.hh" << 146 #include "G4PreCompoundModel.hh" << 147 #include "G4GeneratorPrecompoundInterface.hh" << 148 #include "G4TheoFSGenerator.hh" << 149 #include "G4CascadeInterface.hh" << 150 << 151 // Cross sections << 152 #include "G4VCrossSectionDataSet.hh" << 153 #include "G4CrossSectionDataSetRegistry.hh" << 154 << 155 #include "G4CrossSectionElastic.hh" << 156 #include "G4CrossSectionInelastic.hh" << 157 #include "G4BGGPionElasticXS.hh" << 158 #include "G4BGGPionInelasticXS.hh" << 159 #include "G4AntiNuclElastic.hh" << 160 << 161 #include "G4CrossSectionInelastic.hh" << 162 #include "G4BGGNucleonInelasticXS.hh" << 163 #include "G4BGGNucleonElasticXS.hh" << 164 #include "G4NeutronInelasticXS.hh" << 165 #include "G4NeutronElasticXS.hh" << 166 #include "G4ComponentAntiNuclNuclearXS.hh" << 167 #include "G4ComponentGGNuclNuclXsc.hh" << 168 #include "G4ComponentGGHadronNucleusXsc.hh" << 169 << 170 #include "G4HadronElastic.hh" << 171 #include "G4NeutronCaptureProcess.hh" << 172 << 173 // Neutron high-precision models: <20 MeV << 174 #include "G4ParticleHPElastic.hh" << 175 #include "G4ParticleHPElasticData.hh" << 176 #include "G4ParticleHPCapture.hh" << 177 #include "G4ParticleHPCaptureData.hh" << 178 #include "G4ParticleHPInelastic.hh" << 179 #include "G4ParticleHPInelasticData.hh" << 180 << 181 // Stopping processes << 182 #include "G4HadronStoppingProcess.hh" << 183 #include "G4HadronicAbsorptionBertini.hh" << 184 #include "G4HadronicAbsorptionFritiof.hh" << 185 64 186 #include "G4HadronicParameters.hh" << 65 #include "G4UserLimits.hh" 187 66 188 #include "G4Decay.hh" << 189 #include "G4RadioactiveDecay.hh" << 190 #include "G4PhysicsListHelper.hh" << 191 #include "G4NuclideTable.hh" << 192 #include "G4NuclearLevelData.hh" << 193 67 194 // Constructor /////////////////////////////// 68 // Constructor ///////////////////////////////////////////////////////////// 195 DMXPhysicsList::DMXPhysicsList() : G4VUserPhys 69 DMXPhysicsList::DMXPhysicsList() : G4VUserPhysicsList() 196 { 70 { 197 71 198 defaultCutValue = 1.0*micrometer; // 72 defaultCutValue = 1.0*micrometer; // 199 cutForGamma = defaultCutValue; 73 cutForGamma = defaultCutValue; 200 cutForElectron = 1.0*nanometer; 74 cutForElectron = 1.0*nanometer; 201 cutForPositron = defaultCutValue; 75 cutForPositron = defaultCutValue; 202 76 203 VerboseLevel = 1; 77 VerboseLevel = 1; 204 OpVerbLevel = 0; 78 OpVerbLevel = 0; 205 79 206 //set a finer grid of the physic tables in o << 207 //former LowEnergy models have 200 bins up t << 208 G4EmParameters* param = G4EmParameters::Inst << 209 param->SetMaxEnergy(100*GeV); << 210 param->SetNumberOfBinsPerDecade(20); << 211 param->SetMscStepLimitType(fMinimal); << 212 param->SetFluo(true); << 213 param->SetPixe(true); << 214 param->SetAuger(true); << 215 << 216 G4EmParameters::Instance()->AddPhysics("Worl << 217 G4DeexPrecoParameters* deex = G4NuclearLevel << 218 deex->SetStoreICLevelData(true); << 219 deex->SetMaxLifeTime(G4NuclideTable::GetInst << 220 /std::log(2.)); << 221 SetVerboseLevel(VerboseLevel); 80 SetVerboseLevel(VerboseLevel); 222 } 81 } 223 82 >> 83 224 // Destructor //////////////////////////////// 84 // Destructor ////////////////////////////////////////////////////////////// 225 DMXPhysicsList::~DMXPhysicsList() 85 DMXPhysicsList::~DMXPhysicsList() 226 {;} 86 {;} 227 87 >> 88 228 // Construct Particles /////////////////////// 89 // Construct Particles ///////////////////////////////////////////////////// 229 void DMXPhysicsList::ConstructParticle() 90 void DMXPhysicsList::ConstructParticle() 230 { 91 { >> 92 231 // In this method, static member functions s 93 // In this method, static member functions should be called 232 // for all particles which you want to use. 94 // for all particles which you want to use. 233 // This ensures that objects of these partic 95 // This ensures that objects of these particle types will be 234 // created in the program. 96 // created in the program. 235 97 236 ConstructMyBosons(); 98 ConstructMyBosons(); 237 ConstructMyLeptons(); 99 ConstructMyLeptons(); 238 ConstructMyHadrons(); 100 ConstructMyHadrons(); 239 ConstructMyShortLiveds(); 101 ConstructMyShortLiveds(); >> 102 240 } 103 } 241 104 >> 105 242 // construct Bosons:////////////////////////// 106 // construct Bosons:///////////////////////////////////////////////////// 243 void DMXPhysicsList::ConstructMyBosons() 107 void DMXPhysicsList::ConstructMyBosons() 244 { 108 { 245 // pseudo-particles 109 // pseudo-particles 246 G4Geantino::GeantinoDefinition(); 110 G4Geantino::GeantinoDefinition(); 247 G4ChargedGeantino::ChargedGeantinoDefinition 111 G4ChargedGeantino::ChargedGeantinoDefinition(); 248 112 249 // gamma 113 // gamma 250 G4Gamma::GammaDefinition(); 114 G4Gamma::GammaDefinition(); 251 115 252 //OpticalPhotons 116 //OpticalPhotons 253 G4OpticalPhoton::OpticalPhotonDefinition(); 117 G4OpticalPhoton::OpticalPhotonDefinition(); 254 118 255 } 119 } 256 120 >> 121 257 // construct Leptons:///////////////////////// 122 // construct Leptons:///////////////////////////////////////////////////// 258 void DMXPhysicsList::ConstructMyLeptons() 123 void DMXPhysicsList::ConstructMyLeptons() 259 { 124 { 260 // leptons 125 // leptons 261 G4Electron::ElectronDefinition(); 126 G4Electron::ElectronDefinition(); 262 G4Positron::PositronDefinition(); 127 G4Positron::PositronDefinition(); 263 G4MuonPlus::MuonPlusDefinition(); 128 G4MuonPlus::MuonPlusDefinition(); 264 G4MuonMinus::MuonMinusDefinition(); 129 G4MuonMinus::MuonMinusDefinition(); 265 130 266 G4NeutrinoE::NeutrinoEDefinition(); 131 G4NeutrinoE::NeutrinoEDefinition(); 267 G4AntiNeutrinoE::AntiNeutrinoEDefinition(); 132 G4AntiNeutrinoE::AntiNeutrinoEDefinition(); 268 G4NeutrinoMu::NeutrinoMuDefinition(); 133 G4NeutrinoMu::NeutrinoMuDefinition(); 269 G4AntiNeutrinoMu::AntiNeutrinoMuDefinition() 134 G4AntiNeutrinoMu::AntiNeutrinoMuDefinition(); 270 } 135 } 271 136 >> 137 >> 138 #include "G4MesonConstructor.hh" >> 139 #include "G4BaryonConstructor.hh" >> 140 #include "G4IonConstructor.hh" >> 141 272 // construct Hadrons:///////////////////////// 142 // construct Hadrons:///////////////////////////////////////////////////// 273 void DMXPhysicsList::ConstructMyHadrons() 143 void DMXPhysicsList::ConstructMyHadrons() 274 { 144 { 275 // mesons 145 // mesons 276 G4MesonConstructor mConstructor; 146 G4MesonConstructor mConstructor; 277 mConstructor.ConstructParticle(); 147 mConstructor.ConstructParticle(); 278 148 279 // baryons 149 // baryons 280 G4BaryonConstructor bConstructor; 150 G4BaryonConstructor bConstructor; 281 bConstructor.ConstructParticle(); 151 bConstructor.ConstructParticle(); 282 152 283 // ions 153 // ions 284 G4IonConstructor iConstructor; 154 G4IonConstructor iConstructor; 285 iConstructor.ConstructParticle(); 155 iConstructor.ConstructParticle(); >> 156 286 } 157 } 287 158 >> 159 288 // construct Shortliveds:///////////////////// 160 // construct Shortliveds:///////////////////////////////////////////////////// 289 void DMXPhysicsList::ConstructMyShortLiveds() 161 void DMXPhysicsList::ConstructMyShortLiveds() 290 { 162 { 291 G4ShortLivedConstructor slConstructor; << 163 // ShortLiveds 292 slConstructor.ConstructParticle(); << 164 ; 293 } 165 } 294 166 >> 167 >> 168 >> 169 295 // Construct Processes /////////////////////// 170 // Construct Processes ////////////////////////////////////////////////////// 296 void DMXPhysicsList::ConstructProcess() 171 void DMXPhysicsList::ConstructProcess() 297 { 172 { >> 173 298 AddTransportation(); 174 AddTransportation(); 299 175 300 ConstructEM(); 176 ConstructEM(); 301 177 302 ConstructOp(); 178 ConstructOp(); 303 179 304 ConstructHad(); 180 ConstructHad(); 305 181 306 ConstructGeneral(); 182 ConstructGeneral(); >> 183 307 } 184 } 308 185 >> 186 309 // Transportation //////////////////////////// 187 // Transportation /////////////////////////////////////////////////////////// >> 188 #include "DMXMaxTimeCuts.hh" >> 189 #include "DMXMinEkineCuts.hh" >> 190 #include "G4StepLimiter.hh" >> 191 310 void DMXPhysicsList::AddTransportation() { 192 void DMXPhysicsList::AddTransportation() { 311 193 312 G4VUserPhysicsList::AddTransportation(); 194 G4VUserPhysicsList::AddTransportation(); 313 195 314 auto particleIterator=GetParticleIterator(); << 196 theParticleIterator->reset(); 315 particleIterator->reset(); << 197 while( (*theParticleIterator)() ){ 316 while( (*particleIterator)() ){ << 198 G4ParticleDefinition* particle = theParticleIterator->value(); 317 G4ParticleDefinition* particle = particleI << 318 G4ProcessManager* pmanager = particle->Get 199 G4ProcessManager* pmanager = particle->GetProcessManager(); 319 G4String particleName = particle->GetParti 200 G4String particleName = particle->GetParticleName(); 320 // time cuts for ONLY neutrons: 201 // time cuts for ONLY neutrons: 321 if(particleName == "neutron") 202 if(particleName == "neutron") 322 pmanager->AddDiscreteProcess(new DMXMaxT 203 pmanager->AddDiscreteProcess(new DMXMaxTimeCuts()); 323 // Energy cuts to kill charged (embedded i 204 // Energy cuts to kill charged (embedded in method) particles: 324 pmanager->AddDiscreteProcess(new DMXMinEki 205 pmanager->AddDiscreteProcess(new DMXMinEkineCuts()); 325 206 326 // Step limit applied to all particles: 207 // Step limit applied to all particles: 327 pmanager->AddDiscreteProcess(new G4StepLim << 208 pmanager->AddProcess(new G4StepLimiter, -1,-1,1); >> 209 328 } 210 } 329 } 211 } 330 212 >> 213 331 // Electromagnetic Processes ///////////////// 214 // Electromagnetic Processes //////////////////////////////////////////////// 332 // all charged particles 215 // all charged particles >> 216 #include "G4MultipleScattering.hh" >> 217 >> 218 // gamma >> 219 #include "G4LowEnergyRayleigh.hh" >> 220 #include "G4LowEnergyPhotoElectric.hh" >> 221 #include "G4LowEnergyCompton.hh" >> 222 #include "G4LowEnergyGammaConversion.hh" >> 223 >> 224 >> 225 // e- >> 226 #include "G4LowEnergyIonisation.hh" >> 227 #include "G4LowEnergyBremsstrahlung.hh" >> 228 >> 229 // e+ >> 230 #include "G4eIonisation.hh" >> 231 #include "G4eBremsstrahlung.hh" >> 232 #include "G4eplusAnnihilation.hh" >> 233 >> 234 >> 235 // alpha and GenericIon and deuterons, triton, He3: >> 236 //hIonisation #include "G4hLowEnergyIonisation.hh" -> moved to G4hIonisation >> 237 #include "G4EnergyLossTables.hh" >> 238 // hLowEnergyIonisation uses Ziegler 1988 as the default >> 239 >> 240 >> 241 //muon: >> 242 #include "G4MuIonisation.hh" >> 243 #include "G4MuBremsstrahlung.hh" >> 244 #include "G4MuPairProduction.hh" >> 245 #include "G4MuonMinusCaptureAtRest.hh" >> 246 >> 247 //OTHERS: >> 248 #include "G4hIonisation.hh" // standard hadron ionisation >> 249 >> 250 //em process options to allow msc step-limitation to be switched off >> 251 #include "G4EmProcessOptions.hh" >> 252 333 void DMXPhysicsList::ConstructEM() { 253 void DMXPhysicsList::ConstructEM() { 334 << 335 G4LossTableManager* man = G4LossTableManager << 336 man->SetAtomDeexcitation(new G4UAtomicDeexci << 337 254 338 G4EmParameters* em_params = G4EmParameters:: << 255 // processes: >> 256 >> 257 G4LowEnergyPhotoElectric* lowePhot = new G4LowEnergyPhotoElectric(); >> 258 G4LowEnergyIonisation* loweIon = new G4LowEnergyIonisation(); >> 259 G4LowEnergyBremsstrahlung* loweBrem = new G4LowEnergyBremsstrahlung(); >> 260 >> 261 // note LowEIon uses proton as basis for its data-base, therefore >> 262 // cannot specify different LowEnergyIonisation models for different >> 263 // particles, but can change model globally for Ion, Alpha and Proton. >> 264 >> 265 >> 266 //fluorescence apply specific cut for fluorescence from photons, electrons >> 267 //and bremsstrahlung photons: >> 268 G4double fluorcut = 250*eV; >> 269 lowePhot->SetCutForLowEnSecPhotons(fluorcut); >> 270 loweIon->SetCutForLowEnSecPhotons(fluorcut); >> 271 loweBrem->SetCutForLowEnSecPhotons(fluorcut); 339 272 340 auto particleIterator=GetParticleIterator(); << 273 // setting tables explicitly for electronic stopping power 341 particleIterator->reset(); << 274 // ahadronLowEIon->SetElectronicStoppingPowerModel 342 while( (*particleIterator)() ){ << 275 // (G4GenericIon::GenericIonDefinition(), "ICRU_R49p") ; 343 G4ParticleDefinition* particle = particleI << 276 // ahadronLowEIon->SetElectronicStoppingPowerModel >> 277 // (G4Proton::ProtonDefinition(), "ICRU_R49p") ; >> 278 >> 279 // Switch off the Barkas and Bloch corrections >> 280 // ahadronLowEIon->SetBarkasOff(); >> 281 >> 282 >> 283 theParticleIterator->reset(); >> 284 while( (*theParticleIterator)() ){ >> 285 G4ParticleDefinition* particle = theParticleIterator->value(); 344 G4ProcessManager* pmanager = particle->Get 286 G4ProcessManager* pmanager = particle->GetProcessManager(); 345 G4String particleName = particle->GetParti 287 G4String particleName = particle->GetParticleName(); 346 G4String particleType = particle->GetParti 288 G4String particleType = particle->GetParticleType(); 347 G4double charge = particle->GetPDGCharge() 289 G4double charge = particle->GetPDGCharge(); 348 290 349 if (particleName == "gamma") 291 if (particleName == "gamma") 350 { 292 { 351 //gamma 293 //gamma 352 G4RayleighScattering* theRayleigh = new G4Ra << 294 pmanager->AddDiscreteProcess(new G4LowEnergyRayleigh()); 353 pmanager->AddDiscreteProcess(theRayleigh); << 295 pmanager->AddDiscreteProcess(lowePhot); 354 << 296 pmanager->AddDiscreteProcess(new G4LowEnergyCompton()); 355 G4PhotoElectricEffect* thePhotoElectricEffec << 297 pmanager->AddDiscreteProcess(new G4LowEnergyGammaConversion()); 356 thePhotoElectricEffect->SetEmModel(new G4Liv << 357 pmanager->AddDiscreteProcess(thePhotoElectri << 358 << 359 G4ComptonScattering* theComptonScattering = << 360 theComptonScattering->SetEmModel(new G4Liver << 361 pmanager->AddDiscreteProcess(theComptonScatt << 362 << 363 G4GammaConversion* theGammaConversion = new << 364 theGammaConversion->SetEmModel(new G4BetheHe << 365 pmanager->AddDiscreteProcess(theGammaConvers << 366 << 367 } 298 } 368 else if (particleName == "e-") 299 else if (particleName == "e-") 369 { 300 { 370 //electron 301 //electron 371 // process ordering: AddProcess(name, at res 302 // process ordering: AddProcess(name, at rest, along step, post step) 372 // Multiple scattering << 303 // -1 = not implemented, then ordering 373 G4eMultipleScattering* msc = new G4eMultiple << 304 G4MultipleScattering* aMultipleScattering = new G4MultipleScattering(); 374 em_params->SetMscStepLimitType(fUseDistanceT << 305 pmanager->AddProcess(aMultipleScattering, -1, 1, 1); 375 pmanager->AddProcess(msc,-1, 1, -1); << 306 pmanager->AddProcess(loweIon, -1, 2, 2); 376 << 307 pmanager->AddProcess(loweBrem, -1,-1, 3); 377 // Ionisation << 378 G4eIonisation* eIonisation = new G4eIonisati << 379 G4VEmModel* theIoniLiv = new G4Livermo << 380 theIoniLiv->SetHighEnergyLimit(0.1*MeV << 381 eIonisation->AddEmModel(0, theIoniLiv, << 382 em_params->SetStepFunction(0.2, 100*um); //i << 383 pmanager->AddProcess(eIonisation,-1, 2, 1); << 384 << 385 // Bremsstrahlung << 386 G4eBremsstrahlung* eBremsstrahlung = new G4e << 387 pmanager->AddProcess(eBremsstrahlung, -1,-3, << 388 } 308 } 389 else if (particleName == "e+") 309 else if (particleName == "e+") 390 { 310 { 391 //positron << 311 //positron 392 G4eMultipleScattering* msc = new G4eMultiple << 312 G4MultipleScattering* aMultipleScattering = new G4MultipleScattering(); 393 msc->SetStepLimitType(fUseDistanceToBoundary << 313 pmanager->AddProcess(aMultipleScattering, -1, 1, 1); 394 pmanager->AddProcess(msc,-1, 1, -1); << 314 pmanager->AddProcess(new G4eIonisation(), -1, 2, 2); 395 << 315 pmanager->AddProcess(new G4eBremsstrahlung(), -1,-1, 3); 396 // Ionisation << 316 pmanager->AddProcess(new G4eplusAnnihilation(),0,-1, 4); 397 G4eIonisation* eIonisation = new G4eIonisati << 398 // eIonisation->SetStepFunction(0.2, 100*um) << 399 pmanager->AddProcess(eIonisation, << 400 << 401 //Bremsstrahlung (use default, no low-energy << 402 pmanager->AddProcess(new G4eBremsstrahlung() << 403 << 404 //Annihilation << 405 pmanager->AddProcess(new G4eplusAnnihilation << 406 } 317 } 407 else if( particleName == "mu+" || 318 else if( particleName == "mu+" || 408 particleName == "mu-" ) 319 particleName == "mu-" ) 409 { 320 { 410 //muon 321 //muon 411 pmanager->AddProcess(new G4MuMultipleScatter << 322 G4MultipleScattering* aMultipleScattering = new G4MultipleScattering(); 412 pmanager->AddProcess(new G4MuIonisation(), << 323 pmanager->AddProcess(aMultipleScattering, -1, 1, 1); 413 pmanager->AddProcess(new G4MuBremsstrahlung( << 324 pmanager->AddProcess(new G4MuIonisation(), -1, 2, 2); 414 pmanager->AddProcess(new G4MuPairProduction( << 325 pmanager->AddProcess(new G4MuBremsstrahlung(), -1,-1, 3); >> 326 pmanager->AddProcess(new G4MuPairProduction(), -1,-1, 4); 415 if( particleName == "mu-" ) 327 if( particleName == "mu-" ) 416 pmanager->AddProcess(new G4MuonMinusCaptur << 328 pmanager->AddProcess(new G4MuonMinusCaptureAtRest(), 0,-1,-1); 417 } 329 } 418 else if (particleName == "proton" || << 330 else if (particleName == "proton" || 419 particleName == "pi+" || << 331 particleName == "alpha" || 420 particleName == "pi-") << 421 { << 422 //multiple scattering << 423 pmanager->AddProcess(new G4hMultipleScatteri << 424 << 425 //ionisation << 426 G4hIonisation* hIonisation = new G4hIonisati << 427 em_params->SetStepFunctionMuHad(0.2, 50*um); << 428 pmanager->AddProcess(hIonisation, << 429 << 430 //bremmstrahlung << 431 pmanager->AddProcess(new G4hBremsstrahlung, << 432 } << 433 else if(particleName == "alpha" || << 434 particleName == "deuteron" || 332 particleName == "deuteron" || 435 particleName == "triton" || 333 particleName == "triton" || 436 particleName == "He3") << 334 particleName == "He3" || 437 { << 335 particleName == "GenericIon" || 438 //multiple scattering << 336 (particleType == "nucleus" && charge != 0)) 439 pmanager->AddProcess(new G4hMultipleScatteri << 440 << 441 //ionisation << 442 G4ionIonisation* ionIoni = new G4ionIonisati << 443 em_params->SetStepFunctionLightIons(0.1, 1*C << 444 pmanager->AddProcess(ionIoni, << 445 pmanager->AddProcess(new G4NuclearStopping() << 446 } << 447 else if (particleName == "GenericIon") << 448 { 337 { 449 // OBJECT may be dynamically created as eith 338 // OBJECT may be dynamically created as either a GenericIon or nucleus 450 // G4Nucleus exists and therefore has partic 339 // G4Nucleus exists and therefore has particle type nucleus 451 // genericIon: 340 // genericIon: 452 << 341 G4MultipleScattering* aMultipleScattering = new G4MultipleScattering(); 453 //multiple scattering << 342 //hIonisation G4hLowEnergyIonisation* ahadronLowEIon = new G4hLowEnergyIonisation(); 454 pmanager->AddProcess(new G4hMultipleScatteri << 343 G4hIonisation* ahadronIon = new G4hIonisation(); 455 << 344 pmanager->AddProcess(aMultipleScattering,-1,1,1); 456 //ionisation << 345 //hIonisation pmanager->AddProcess(ahadronLowEIon,-1,2,2); 457 G4ionIonisation* ionIoni = new G4ionIonisati << 346 pmanager->AddProcess(ahadronIon,-1,2,2); 458 em_params->SetStepFunctionIons(0.1, 1*CLHEP: << 347 // ahadronLowEIon->SetNuclearStoppingOff() ; 459 pmanager->AddProcess(ionIoni, << 348 // ahadronLowEIon->SetNuclearStoppingPowerModel("ICRU_R49") ; 460 pmanager->AddProcess(new G4NuclearStopping() << 349 // ahadronLowEIon->SetNuclearStoppingOn() ; >> 350 >> 351 //fluorescence switch off for hadrons (for now) PIXE: >> 352 //hIonisation ahadronLowEIon->SetFluorescence(false); 461 } 353 } 462 << 463 else if ((!particle->IsShortLived()) && 354 else if ((!particle->IsShortLived()) && 464 (charge != 0.0) && 355 (charge != 0.0) && 465 (particle->GetParticleName() != "charge 356 (particle->GetParticleName() != "chargedgeantino")) 466 { 357 { 467 //all others charged particles except geanti 358 //all others charged particles except geantino 468 G4hMultipleScattering* aMultipleScatte << 359 G4MultipleScattering* aMultipleScattering = new G4MultipleScattering(); >> 360 //hIonisation G4hLowEnergyIonisation* ahadronLowEIon = new G4hLowEnergyIonisation(); 469 G4hIonisation* ahadronIon = new G4hIon 361 G4hIonisation* ahadronIon = new G4hIonisation(); 470 << 362 pmanager->AddProcess(aMultipleScattering,-1,1,1); 471 //multiple scattering << 363 //hIonisation pmanager->AddProcess(ahadronLowEIon, -1,2,2); 472 pmanager->AddProcess(aMultipleScattering,-1, << 364 pmanager->AddProcess(ahadronIon, -1,2,2); 473 << 365 // pmanager->AddProcess(new G4hIonisation(), -1,2,2); 474 //ionisation << 475 pmanager->AddProcess(ahadronIon, -1,2, << 476 } 366 } >> 367 477 } 368 } >> 369 >> 370 // turn off msc step-limitation - especially as electron cut 1nm >> 371 G4EmProcessOptions opt; >> 372 // opt.SetMscStepLimitation(false); >> 373 opt.SetMscStepLimitation(fMinimal); >> 374 478 } 375 } 479 376 >> 377 480 // Optical Processes ///////////////////////// 378 // Optical Processes //////////////////////////////////////////////////////// >> 379 #include "G4Scintillation.hh" >> 380 #include "G4OpAbsorption.hh" >> 381 //#include "G4OpRayleigh.hh" >> 382 #include "G4OpBoundaryProcess.hh" >> 383 481 void DMXPhysicsList::ConstructOp() 384 void DMXPhysicsList::ConstructOp() 482 { 385 { 483 G4OpticalParameters* opParams = G4OpticalPar << 386 // default scintillation process 484 G4Scintillation* theScintProcessDef = new G4 387 G4Scintillation* theScintProcessDef = new G4Scintillation("Scintillation"); 485 opParams->SetScintTrackSecondariesFirst(true << 388 // theScintProcessDef->DumpPhysicsTable(); 486 opParams->SetScintByParticleType(true); << 389 theScintProcessDef->SetTrackSecondariesFirst(true); >> 390 theScintProcessDef->SetScintillationYieldFactor(1.0); // >> 391 theScintProcessDef->SetScintillationExcitationRatio(0.0); // >> 392 theScintProcessDef->SetVerboseLevel(OpVerbLevel); >> 393 >> 394 // scintillation process for alpha: >> 395 G4Scintillation* theScintProcessAlpha = new G4Scintillation("Scintillation"); >> 396 // theScintProcessNuc->DumpPhysicsTable(); >> 397 theScintProcessAlpha->SetTrackSecondariesFirst(true); >> 398 theScintProcessAlpha->SetScintillationYieldFactor(1.1); >> 399 theScintProcessAlpha->SetScintillationExcitationRatio(1.0); >> 400 theScintProcessAlpha->SetVerboseLevel(OpVerbLevel); >> 401 >> 402 // scintillation process for heavy nuclei >> 403 G4Scintillation* theScintProcessNuc = new G4Scintillation("Scintillation"); >> 404 // theScintProcessNuc->DumpPhysicsTable(); >> 405 theScintProcessNuc->SetTrackSecondariesFirst(true); >> 406 theScintProcessNuc->SetScintillationYieldFactor(0.2); >> 407 theScintProcessNuc->SetScintillationExcitationRatio(1.0); >> 408 theScintProcessNuc->SetVerboseLevel(OpVerbLevel); 487 409 488 // optical processes 410 // optical processes 489 G4OpAbsorption* theAbsorptionProcess = new G 411 G4OpAbsorption* theAbsorptionProcess = new G4OpAbsorption(); >> 412 // G4OpRayleigh* theRayleighScatteringProcess = new G4OpRayleigh(); 490 G4OpBoundaryProcess* theBoundaryProcess = ne 413 G4OpBoundaryProcess* theBoundaryProcess = new G4OpBoundaryProcess(); >> 414 // theAbsorptionProcess->DumpPhysicsTable(); >> 415 // theRayleighScatteringProcess->DumpPhysicsTable(); >> 416 theAbsorptionProcess->SetVerboseLevel(OpVerbLevel); >> 417 // theRayleighScatteringProcess->SetVerboseLevel(OpVerbLevel); >> 418 theBoundaryProcess->SetVerboseLevel(OpVerbLevel); >> 419 G4OpticalSurfaceModel themodel = unified; >> 420 theBoundaryProcess->SetModel(themodel); 491 421 492 auto particleIterator=GetParticleIterator(); << 422 theParticleIterator->reset(); 493 particleIterator->reset(); << 423 while( (*theParticleIterator)() ) 494 while( (*particleIterator)() ) << 495 { 424 { 496 G4ParticleDefinition* particle = particl << 425 G4ParticleDefinition* particle = theParticleIterator->value(); 497 G4ProcessManager* pmanager = particle->G 426 G4ProcessManager* pmanager = particle->GetProcessManager(); 498 G4String particleName = particle->GetPar 427 G4String particleName = particle->GetParticleName(); 499 if (theScintProcessDef->IsApplicable(*pa 428 if (theScintProcessDef->IsApplicable(*particle)) { 500 pmanager->AddProcess(theScintProcessDe << 429 // if(particle->GetPDGMass() > 5.0*GeV) 501 pmanager->SetProcessOrderingToLast(the << 430 if(particle->GetParticleName() == "GenericIon") { 502 pmanager->SetProcessOrderingToLast(the << 431 pmanager->AddProcess(theScintProcessNuc); // AtRestDiscrete >> 432 pmanager->SetProcessOrderingToLast(theScintProcessNuc,idxAtRest); >> 433 pmanager->SetProcessOrderingToLast(theScintProcessNuc,idxPostStep); >> 434 } >> 435 else if(particle->GetParticleName() == "alpha") { >> 436 pmanager->AddProcess(theScintProcessAlpha); >> 437 pmanager->SetProcessOrderingToLast(theScintProcessAlpha,idxAtRest); >> 438 pmanager->SetProcessOrderingToLast(theScintProcessAlpha,idxPostStep); >> 439 } >> 440 else { >> 441 pmanager->AddProcess(theScintProcessDef); >> 442 pmanager->SetProcessOrderingToLast(theScintProcessDef,idxAtRest); >> 443 pmanager->SetProcessOrderingToLast(theScintProcessDef,idxPostStep); >> 444 } 503 } 445 } 504 446 505 if (particleName == "opticalphoton") { 447 if (particleName == "opticalphoton") { 506 pmanager->AddDiscreteProcess(theAbsorptionPr 448 pmanager->AddDiscreteProcess(theAbsorptionProcess); >> 449 // pmanager->AddDiscreteProcess(theRayleighScatteringProcess); 507 pmanager->AddDiscreteProcess(theBoundaryProc 450 pmanager->AddDiscreteProcess(theBoundaryProcess); 508 } 451 } 509 } 452 } 510 } 453 } 511 454 >> 455 512 // Hadronic processes //////////////////////// 456 // Hadronic processes //////////////////////////////////////////////////////// 513 457 >> 458 // Elastic processes: >> 459 #include "G4HadronElasticProcess.hh" >> 460 >> 461 // Inelastic processes: >> 462 #include "G4PionPlusInelasticProcess.hh" >> 463 #include "G4PionMinusInelasticProcess.hh" >> 464 #include "G4KaonPlusInelasticProcess.hh" >> 465 #include "G4KaonZeroSInelasticProcess.hh" >> 466 #include "G4KaonZeroLInelasticProcess.hh" >> 467 #include "G4KaonMinusInelasticProcess.hh" >> 468 #include "G4ProtonInelasticProcess.hh" >> 469 #include "G4AntiProtonInelasticProcess.hh" >> 470 #include "G4NeutronInelasticProcess.hh" >> 471 #include "G4AntiNeutronInelasticProcess.hh" >> 472 #include "G4DeuteronInelasticProcess.hh" >> 473 #include "G4TritonInelasticProcess.hh" >> 474 #include "G4AlphaInelasticProcess.hh" >> 475 >> 476 // Low-energy Models: < 20GeV >> 477 #include "G4LElastic.hh" >> 478 #include "G4LEPionPlusInelastic.hh" >> 479 #include "G4LEPionMinusInelastic.hh" >> 480 #include "G4LEKaonPlusInelastic.hh" >> 481 #include "G4LEKaonZeroSInelastic.hh" >> 482 #include "G4LEKaonZeroLInelastic.hh" >> 483 #include "G4LEKaonMinusInelastic.hh" >> 484 #include "G4LEProtonInelastic.hh" >> 485 #include "G4LEAntiProtonInelastic.hh" >> 486 #include "G4LENeutronInelastic.hh" >> 487 #include "G4LEAntiNeutronInelastic.hh" >> 488 #include "G4LEDeuteronInelastic.hh" >> 489 #include "G4LETritonInelastic.hh" >> 490 #include "G4LEAlphaInelastic.hh" >> 491 #include "G4HadronCaptureProcess.hh" >> 492 // High-energy Models: >20 GeV >> 493 #include "G4HEPionPlusInelastic.hh" >> 494 #include "G4HEPionMinusInelastic.hh" >> 495 #include "G4HEKaonPlusInelastic.hh" >> 496 #include "G4HEKaonZeroInelastic.hh" >> 497 #include "G4HEKaonZeroInelastic.hh" >> 498 #include "G4HEKaonMinusInelastic.hh" >> 499 #include "G4HEProtonInelastic.hh" >> 500 #include "G4HEAntiProtonInelastic.hh" >> 501 #include "G4HENeutronInelastic.hh" >> 502 #include "G4HEAntiNeutronInelastic.hh" >> 503 >> 504 // Neutron high-precision models: <20 MeV >> 505 #include "G4NeutronHPElastic.hh" >> 506 #include "G4NeutronHPElasticData.hh" >> 507 #include "G4NeutronHPCapture.hh" >> 508 #include "G4NeutronHPCaptureData.hh" >> 509 #include "G4NeutronHPInelastic.hh" >> 510 #include "G4NeutronHPInelasticData.hh" >> 511 #include "G4LCapture.hh" >> 512 >> 513 // Stopping processes >> 514 #include "G4PiMinusAbsorptionAtRest.hh" >> 515 #include "G4KaonMinusAbsorptionAtRest.hh" >> 516 #include "G4AntiProtonAnnihilationAtRest.hh" >> 517 #include "G4AntiNeutronAnnihilationAtRest.hh" >> 518 >> 519 >> 520 // ConstructHad() >> 521 // Makes discrete physics processes for the hadrons, at present limited >> 522 // to those particles with GHEISHA interactions (INTRC > 0). >> 523 // The processes are: Elastic scattering and Inelastic scattering. >> 524 // F.W.Jones 09-JUL-1998 514 void DMXPhysicsList::ConstructHad() 525 void DMXPhysicsList::ConstructHad() 515 { 526 { 516 //Elastic models << 527 G4HadronElasticProcess* theElasticProcess = new G4HadronElasticProcess; 517 G4HadronElastic* elastic_lhep0 = new G4Hadro << 528 G4LElastic* theElasticModel = new G4LElastic; 518 G4ChipsElasticModel* elastic_chip = new G4Ch << 529 theElasticProcess->RegisterMe(theElasticModel); 519 G4ElasticHadrNucleusHE* elastic_he = new G4E << 520 530 521 // Inelastic scattering << 531 theParticleIterator->reset(); 522 const G4double theFTFMin0 = 0.0*GeV; << 532 while ((*theParticleIterator)()) 523 const G4double theFTFMin1 = 3.0*GeV; << 524 const G4double theFTFMax = G4HadronicParamet << 525 const G4double theBERTMin0 = 0.0*GeV; << 526 const G4double theBERTMin1 = 19.0*MeV; << 527 const G4double theBERTMax = 6.0*GeV; << 528 const G4double theHPMin = 0.0*GeV; << 529 const G4double theHPMax = 20.0*MeV; << 530 << 531 G4FTFModel * theStringModel = new G4FTFModel << 532 G4ExcitedStringDecay * theStringDecay = new << 533 theStringModel->SetFragmentationModel( theSt << 534 G4PreCompoundModel * thePreEquilib = new G4P << 535 G4GeneratorPrecompoundInterface * theCascade << 536 << 537 G4TheoFSGenerator * theFTFModel0 = new G4The << 538 theFTFModel0->SetHighEnergyGenerator( theStr << 539 theFTFModel0->SetTransport( theCascade ); << 540 theFTFModel0->SetMinEnergy( theFTFMin0 ); << 541 theFTFModel0->SetMaxEnergy( theFTFMax ); << 542 << 543 G4TheoFSGenerator * theFTFModel1 = new G4The << 544 theFTFModel1->SetHighEnergyGenerator( theStr << 545 theFTFModel1->SetTransport( theCascade ); << 546 theFTFModel1->SetMinEnergy( theFTFMin1 ); << 547 theFTFModel1->SetMaxEnergy( theFTFMax ); << 548 << 549 G4CascadeInterface * theBERTModel0 = new G4C << 550 theBERTModel0->SetMinEnergy( theBERTMin0 ); << 551 theBERTModel0->SetMaxEnergy( theBERTMax ); << 552 << 553 G4CascadeInterface * theBERTModel1 = new G4C << 554 theBERTModel1->SetMinEnergy( theBERTMin1 ); << 555 theBERTModel1->SetMaxEnergy( theBERTMax ); << 556 << 557 G4VCrossSectionDataSet * theAntiNucleonData << 558 G4ComponentGGNuclNuclXsc * ggNuclNuclXsec = << 559 G4VCrossSectionDataSet * theGGNuclNuclData = << 560 G4VCrossSectionDataSet * theGGNNEl = new G4C << 561 G4ComponentGGHadronNucleusXsc * ggHNXsec = n << 562 G4VCrossSectionDataSet * theGGHNEl = new G4C << 563 G4VCrossSectionDataSet * theGGHNInel = new G << 564 << 565 auto particleIterator=GetParticleIterator(); << 566 particleIterator->reset(); << 567 while ((*particleIterator)()) << 568 { 533 { 569 G4ParticleDefinition* particle = particl << 534 G4ParticleDefinition* particle = theParticleIterator->value(); 570 G4ProcessManager* pmanager = particle->G 535 G4ProcessManager* pmanager = particle->GetProcessManager(); 571 G4String particleName = particle->GetPar 536 G4String particleName = particle->GetParticleName(); 572 537 573 if (particleName == "pi+") 538 if (particleName == "pi+") 574 { 539 { 575 // Elastic scattering << 540 pmanager->AddDiscreteProcess(theElasticProcess); 576 G4HadronElasticProcess* theElasticPr << 541 G4PionPlusInelasticProcess* theInelasticProcess = 577 theElasticProcess->AddDataSet( new G << 542 new G4PionPlusInelasticProcess("inelastic"); 578 theElasticProcess->RegisterMe( elast << 543 G4LEPionPlusInelastic* theLEInelasticModel = 579 pmanager->AddDiscreteProcess( theElasticPr << 544 new G4LEPionPlusInelastic; 580 //Inelastic scattering << 545 theInelasticProcess->RegisterMe(theLEInelasticModel); 581 G4HadronInelasticProcess* theInelasticProc << 546 G4HEPionPlusInelastic* theHEInelasticModel = 582 new G4HadronInelasticProcess( "inelastic << 547 new G4HEPionPlusInelastic; 583 theInelasticProcess->AddDataSet( new G4BGG << 548 theInelasticProcess->RegisterMe(theHEInelasticModel); 584 theInelasticProcess->RegisterMe( theFTFMod << 549 pmanager->AddDiscreteProcess(theInelasticProcess); 585 theInelasticProcess->RegisterMe( the << 586 pmanager->AddDiscreteProcess( theInelastic << 587 } 550 } 588 551 589 else if (particleName == "pi-") 552 else if (particleName == "pi-") 590 { 553 { 591 // Elastic scattering << 554 pmanager->AddDiscreteProcess(theElasticProcess); 592 G4HadronElasticProcess* theElasticPr << 555 G4PionMinusInelasticProcess* theInelasticProcess = 593 theElasticProcess->AddDataSet( new G << 556 new G4PionMinusInelasticProcess("inelastic"); 594 theElasticProcess->RegisterMe( elast << 557 G4LEPionMinusInelastic* theLEInelasticModel = 595 pmanager->AddDiscreteProcess( theElasticPr << 558 new G4LEPionMinusInelastic; 596 //Inelastic scattering << 559 theInelasticProcess->RegisterMe(theLEInelasticModel); 597 G4HadronInelasticProcess* theInelasticProc << 560 G4HEPionMinusInelastic* theHEInelasticModel = 598 new G4HadronInelasticProcess( "inelastic << 561 new G4HEPionMinusInelastic; 599 theInelasticProcess->AddDataSet( new G4BGG << 562 theInelasticProcess->RegisterMe(theHEInelasticModel); 600 theInelasticProcess->RegisterMe( theFTFMod << 563 pmanager->AddDiscreteProcess(theInelasticProcess); 601 theInelasticProcess->RegisterMe( the << 564 G4String prcNam; 602 pmanager->AddDiscreteProcess( theInelastic << 565 pmanager->AddRestProcess(new G4PiMinusAbsorptionAtRest, ordDefault); 603 //Absorption << 604 pmanager->AddRestProcess(new G4HadronicAbs << 605 } 566 } >> 567 606 else if (particleName == "kaon+") 568 else if (particleName == "kaon+") 607 { 569 { 608 // Elastic scattering << 570 pmanager->AddDiscreteProcess(theElasticProcess); 609 G4HadronElasticProcess* theElasticPr << 571 G4KaonPlusInelasticProcess* theInelasticProcess = 610 theElasticProcess->AddDataSet( theGGHNEl ) << 572 new G4KaonPlusInelasticProcess("inelastic"); 611 theElasticProcess->RegisterMe( elast << 573 G4LEKaonPlusInelastic* theLEInelasticModel = 612 pmanager->AddDiscreteProcess( theElasticPr << 574 new G4LEKaonPlusInelastic; 613 // Inelastic scattering << 575 theInelasticProcess->RegisterMe(theLEInelasticModel); 614 G4HadronInelasticProcess* theInelasticProc << 576 G4HEKaonPlusInelastic* theHEInelasticModel = 615 new G4HadronInelasticProcess( "inelastic << 577 new G4HEKaonPlusInelastic; 616 theInelasticProcess->AddDataSet( theGGHNIn << 578 theInelasticProcess->RegisterMe(theHEInelasticModel); 617 theInelasticProcess->RegisterMe( theFTFMod << 579 pmanager->AddDiscreteProcess(theInelasticProcess); 618 theInelasticProcess->RegisterMe( the << 580 } 619 pmanager->AddDiscreteProcess( theInelastic << 581 620 } << 621 else if (particleName == "kaon0S") 582 else if (particleName == "kaon0S") 622 { 583 { 623 // Elastic scattering << 584 pmanager->AddDiscreteProcess(theElasticProcess); 624 G4HadronElasticProcess* theElasticPr << 585 G4KaonZeroSInelasticProcess* theInelasticProcess = 625 theElasticProcess->AddDataSet( theGGHNEl ) << 586 new G4KaonZeroSInelasticProcess("inelastic"); 626 theElasticProcess->RegisterMe( elast << 587 G4LEKaonZeroSInelastic* theLEInelasticModel = 627 pmanager->AddDiscreteProcess( theElasticPr << 588 new G4LEKaonZeroSInelastic; 628 // Inelastic scattering << 589 theInelasticProcess->RegisterMe(theLEInelasticModel); 629 G4HadronInelasticProcess* theInelasticProc << 590 G4HEKaonZeroInelastic* theHEInelasticModel = 630 new G4HadronInelasticProcess( "inelastic << 591 new G4HEKaonZeroInelastic; 631 theInelasticProcess->AddDataSet( theGGHNIn << 592 theInelasticProcess->RegisterMe(theHEInelasticModel); 632 theInelasticProcess->RegisterMe( theFTFMod << 593 pmanager->AddDiscreteProcess(theInelasticProcess); 633 theInelasticProcess->RegisterMe( the << 634 pmanager->AddDiscreteProcess( theInelastic << 635 } 594 } 636 595 637 else if (particleName == "kaon0L") 596 else if (particleName == "kaon0L") 638 { 597 { 639 // Elastic scattering << 598 pmanager->AddDiscreteProcess(theElasticProcess); 640 G4HadronElasticProcess* theElasticPr << 599 G4KaonZeroLInelasticProcess* theInelasticProcess = 641 theElasticProcess->AddDataSet( theGGHNEl ) << 600 new G4KaonZeroLInelasticProcess("inelastic"); 642 theElasticProcess->RegisterMe( elast << 601 G4LEKaonZeroLInelastic* theLEInelasticModel = 643 pmanager->AddDiscreteProcess( theElasticPr << 602 new G4LEKaonZeroLInelastic; 644 // Inelastic scattering << 603 theInelasticProcess->RegisterMe(theLEInelasticModel); 645 G4HadronInelasticProcess* theInelasticProc << 604 G4HEKaonZeroInelastic* theHEInelasticModel = 646 new G4HadronInelasticProcess( "inelastic << 605 new G4HEKaonZeroInelastic; 647 theInelasticProcess->AddDataSet( theGGHNIn << 606 theInelasticProcess->RegisterMe(theHEInelasticModel); 648 theInelasticProcess->RegisterMe( theFTFMod << 607 pmanager->AddDiscreteProcess(theInelasticProcess); 649 theInelasticProcess->RegisterMe( the << 650 pmanager->AddDiscreteProcess( theInelastic << 651 } 608 } 652 609 653 else if (particleName == "kaon-") 610 else if (particleName == "kaon-") 654 { 611 { 655 // Elastic scattering << 612 pmanager->AddDiscreteProcess(theElasticProcess); 656 G4HadronElasticProcess* theElasticPr << 613 G4KaonMinusInelasticProcess* theInelasticProcess = 657 theElasticProcess->AddDataSet( theGGHNEl ) << 614 new G4KaonMinusInelasticProcess("inelastic"); 658 theElasticProcess->RegisterMe( elast << 615 G4LEKaonMinusInelastic* theLEInelasticModel = 659 pmanager->AddDiscreteProcess( theElasticPr << 616 new G4LEKaonMinusInelastic; 660 // Inelastic scattering << 617 theInelasticProcess->RegisterMe(theLEInelasticModel); 661 G4HadronInelasticProcess* theInelasticProc << 618 G4HEKaonMinusInelastic* theHEInelasticModel = 662 new G4HadronInelasticProcess( "inelastic << 619 new G4HEKaonMinusInelastic; 663 theInelasticProcess->AddDataSet( the << 620 theInelasticProcess->RegisterMe(theHEInelasticModel); 664 theInelasticProcess->RegisterMe( theFTFMod << 621 pmanager->AddDiscreteProcess(theInelasticProcess); 665 theInelasticProcess->RegisterMe( the << 622 pmanager->AddRestProcess(new G4KaonMinusAbsorptionAtRest, ordDefault); 666 pmanager->AddDiscreteProcess( theInelastic << 667 pmanager->AddRestProcess(new G4HadronicAbs << 668 } 623 } 669 624 670 else if (particleName == "proton") 625 else if (particleName == "proton") 671 { 626 { 672 // Elastic scattering << 627 pmanager->AddDiscreteProcess(theElasticProcess); 673 G4HadronElasticProcess* theElasticPr << 628 G4ProtonInelasticProcess* theInelasticProcess = 674 theElasticProcess->AddDataSet( new G << 629 new G4ProtonInelasticProcess("inelastic"); 675 theElasticProcess->RegisterMe( elast << 630 G4LEProtonInelastic* theLEInelasticModel = new G4LEProtonInelastic; 676 pmanager->AddDiscreteProcess( theElasticPr << 631 theInelasticProcess->RegisterMe(theLEInelasticModel); 677 // Inelastic scattering << 632 G4HEProtonInelastic* theHEInelasticModel = new G4HEProtonInelastic; 678 G4HadronInelasticProcess* theInelasticProc << 633 theInelasticProcess->RegisterMe(theHEInelasticModel); 679 new G4HadronInelasticProcess( "inelastic << 634 pmanager->AddDiscreteProcess(theInelasticProcess); 680 theInelasticProcess->AddDataSet( new G4BGG << 681 theInelasticProcess->RegisterMe( theFTFMod << 682 theInelasticProcess->RegisterMe( the << 683 pmanager->AddDiscreteProcess( theInelastic << 684 } 635 } >> 636 685 else if (particleName == "anti_proton") 637 else if (particleName == "anti_proton") 686 { 638 { 687 // Elastic scattering << 639 pmanager->AddDiscreteProcess(theElasticProcess); 688 const G4double elastic_elimitAntiNuc << 640 G4AntiProtonInelasticProcess* theInelasticProcess = 689 G4AntiNuclElastic* elastic_anuc = ne << 641 new G4AntiProtonInelasticProcess("inelastic"); 690 elastic_anuc->SetMinEnergy( elastic_ << 642 G4LEAntiProtonInelastic* theLEInelasticModel = 691 G4CrossSectionElastic* elastic_anucx << 643 new G4LEAntiProtonInelastic; 692 G4HadronElastic* elastic_lhep2 = new << 644 theInelasticProcess->RegisterMe(theLEInelasticModel); 693 elastic_lhep2->SetMaxEnergy( elastic << 645 G4HEAntiProtonInelastic* theHEInelasticModel = 694 G4HadronElasticProcess* theElasticPr << 646 new G4HEAntiProtonInelastic; 695 theElasticProcess->AddDataSet( elast << 647 theInelasticProcess->RegisterMe(theHEInelasticModel); 696 theElasticProcess->RegisterMe( elast << 648 pmanager->AddDiscreteProcess(theInelasticProcess); 697 theElasticProcess->RegisterMe( elast << 698 pmanager->AddDiscreteProcess( theElasticPr << 699 // Inelastic scattering << 700 G4HadronInelasticProcess* theInelasticProc << 701 new G4HadronInelasticProcess( "inelastic << 702 theInelasticProcess->AddDataSet( theAntiNu << 703 theInelasticProcess->RegisterMe( theFTFMod << 704 pmanager->AddDiscreteProcess( theInelastic << 705 // Absorption << 706 pmanager->AddRestProcess(new G4HadronicAbs << 707 } 649 } >> 650 708 else if (particleName == "neutron") { 651 else if (particleName == "neutron") { 709 // elastic scattering 652 // elastic scattering 710 G4HadronElasticProcess* theElasticProcess = << 653 G4HadronElasticProcess* theNeutronElasticProcess = 711 theElasticProcess->AddDataSet(new G4Ne << 654 new G4HadronElasticProcess; 712 G4HadronElastic* elastic_neutronChipsM << 655 G4LElastic* theElasticModel1 = new G4LElastic; 713 elastic_neutronChipsModel->SetMinEnergy( 19. << 656 G4NeutronHPElastic * theElasticNeutron = new G4NeutronHPElastic; 714 theElasticProcess->RegisterMe( elastic << 657 theNeutronElasticProcess->RegisterMe(theElasticModel1); 715 G4ParticleHPElastic * theElasticNeutronHP = << 658 theElasticModel1->SetMinEnergy(19*MeV); 716 theElasticNeutronHP->SetMinEnergy( the << 659 theNeutronElasticProcess->RegisterMe(theElasticNeutron); 717 theElasticNeutronHP->SetMaxEnergy( the << 660 G4NeutronHPElasticData * theNeutronData = new G4NeutronHPElasticData; 718 theElasticProcess->RegisterMe( theElasticNeu << 661 theNeutronElasticProcess->AddDataSet(theNeutronData); 719 theElasticProcess->AddDataSet( new G4Particl << 662 pmanager->AddDiscreteProcess(theNeutronElasticProcess); 720 pmanager->AddDiscreteProcess( theElasticProc << 663 // inelastic scattering 721 // inelastic scattering << 664 G4NeutronInelasticProcess* theInelasticProcess = 722 G4HadronInelasticProcess* theInelasticProces << 665 new G4NeutronInelasticProcess("inelastic"); 723 new G4HadronInelasticProcess( "inelastic", << 666 G4LENeutronInelastic* theInelasticModel = new G4LENeutronInelastic; 724 theInelasticProcess->AddDataSet( new G4Neutr << 667 theInelasticModel->SetMinEnergy(19*MeV); 725 theInelasticProcess->RegisterMe( theFTFModel << 668 theInelasticProcess->RegisterMe(theInelasticModel); 726 theInelasticProcess->RegisterMe( theBE << 669 G4NeutronHPInelastic * theLENeutronInelasticModel = 727 G4ParticleHPInelastic * theNeutronInelasticH << 670 new G4NeutronHPInelastic; 728 theNeutronInelasticHPModel->SetMinEner << 671 theInelasticProcess->RegisterMe(theLENeutronInelasticModel); 729 theNeutronInelasticHPModel->SetMaxEner << 672 G4NeutronHPInelasticData * theNeutronData1 = 730 theInelasticProcess->RegisterMe( theNeutronI << 673 new G4NeutronHPInelasticData; 731 theInelasticProcess->AddDataSet( new G4Parti << 674 theInelasticProcess->AddDataSet(theNeutronData1); 732 pmanager->AddDiscreteProcess(theInelasticPro 675 pmanager->AddDiscreteProcess(theInelasticProcess); 733 // capture 676 // capture 734 G4NeutronCaptureProcess* theCaptureProcess = << 677 G4HadronCaptureProcess* theCaptureProcess = 735 new G4NeutronCaptureProcess; << 678 new G4HadronCaptureProcess; 736 G4ParticleHPCapture * theLENeutronCaptureMod << 679 G4LCapture* theCaptureModel = new G4LCapture; 737 theLENeutronCaptureModel->SetMinEnergy(theHP << 680 theCaptureModel->SetMinEnergy(19*MeV); 738 theLENeutronCaptureModel->SetMaxEnergy(theHP << 681 theCaptureProcess->RegisterMe(theCaptureModel); >> 682 G4NeutronHPCapture * theLENeutronCaptureModel = new G4NeutronHPCapture; 739 theCaptureProcess->RegisterMe(theLENeutronCa 683 theCaptureProcess->RegisterMe(theLENeutronCaptureModel); 740 theCaptureProcess->AddDataSet( new G4Particl << 684 G4NeutronHPCaptureData * theNeutronData3 = new G4NeutronHPCaptureData; >> 685 theCaptureProcess->AddDataSet(theNeutronData3); 741 pmanager->AddDiscreteProcess(theCaptureProce 686 pmanager->AddDiscreteProcess(theCaptureProcess); >> 687 // G4ProcessManager* pmanager = G4Neutron::Neutron->GetProcessManager(); >> 688 // pmanager->AddProcess(new G4UserSpecialCuts(),-1,-1,1); 742 } 689 } 743 else if (particleName == "anti_neutron") 690 else if (particleName == "anti_neutron") 744 { 691 { 745 // Elastic scattering << 692 pmanager->AddDiscreteProcess(theElasticProcess); 746 G4HadronElasticProcess* theElasticPr << 693 G4AntiNeutronInelasticProcess* theInelasticProcess = 747 theElasticProcess->AddDataSet( theGGHNEl ) << 694 new G4AntiNeutronInelasticProcess("inelastic"); 748 theElasticProcess->RegisterMe( elast << 695 G4LEAntiNeutronInelastic* theLEInelasticModel = 749 pmanager->AddDiscreteProcess( theElasticPr << 696 new G4LEAntiNeutronInelastic; 750 // Inelastic scattering (include ann << 697 theInelasticProcess->RegisterMe(theLEInelasticModel); 751 G4HadronInelasticProcess* theInelasticProc << 698 G4HEAntiNeutronInelastic* theHEInelasticModel = 752 new G4HadronInelasticProcess( "inelastic << 699 new G4HEAntiNeutronInelastic; 753 theInelasticProcess->AddDataSet( theAntiNu << 700 theInelasticProcess->RegisterMe(theHEInelasticModel); 754 theInelasticProcess->RegisterMe( theFTFMod << 701 pmanager->AddDiscreteProcess(theInelasticProcess); 755 pmanager->AddDiscreteProcess( theInelastic << 756 } 702 } >> 703 757 else if (particleName == "deuteron") 704 else if (particleName == "deuteron") 758 { 705 { 759 // Elastic scattering << 706 pmanager->AddDiscreteProcess(theElasticProcess); 760 G4HadronElasticProcess* theElasticPr << 707 G4DeuteronInelasticProcess* theInelasticProcess = 761 theElasticProcess->AddDataSet( theGGNNEl ) << 708 new G4DeuteronInelasticProcess("inelastic"); 762 theElasticProcess->RegisterMe( elast << 709 G4LEDeuteronInelastic* theLEInelasticModel = 763 pmanager->AddDiscreteProcess( theElasticPr << 710 new G4LEDeuteronInelastic; 764 // Inelastic scattering << 711 theInelasticProcess->RegisterMe(theLEInelasticModel); 765 G4HadronInelasticProcess* theInelasticProc << 712 pmanager->AddDiscreteProcess(theInelasticProcess); 766 new G4HadronInelasticProcess( "inelastic << 767 theInelasticProcess->AddDataSet( theGGNucl << 768 theInelasticProcess->RegisterMe( theFTFMod << 769 theInelasticProcess->RegisterMe( the << 770 pmanager->AddDiscreteProcess( theInelastic << 771 } 713 } >> 714 772 else if (particleName == "triton") 715 else if (particleName == "triton") 773 { 716 { 774 // Elastic scattering << 717 pmanager->AddDiscreteProcess(theElasticProcess); 775 G4HadronElasticProcess* theElasticPr << 718 G4TritonInelasticProcess* theInelasticProcess = 776 theElasticProcess->AddDataSet( theGGNNEl ) << 719 new G4TritonInelasticProcess("inelastic"); 777 theElasticProcess->RegisterMe( elast << 720 G4LETritonInelastic* theLEInelasticModel = 778 pmanager->AddDiscreteProcess( theElasticPr << 721 new G4LETritonInelastic; 779 // Inelastic scattering << 722 theInelasticProcess->RegisterMe(theLEInelasticModel); 780 G4HadronInelasticProcess* theInelasticProc << 723 pmanager->AddDiscreteProcess(theInelasticProcess); 781 new G4HadronInelasticProcess( "inelastic << 782 theInelasticProcess->AddDataSet( theGGNucl << 783 theInelasticProcess->RegisterMe( theFTFMod << 784 theInelasticProcess->RegisterMe( the << 785 pmanager->AddDiscreteProcess( theInelastic << 786 } 724 } >> 725 787 else if (particleName == "alpha") 726 else if (particleName == "alpha") 788 { 727 { 789 // Elastic scattering << 728 pmanager->AddDiscreteProcess(theElasticProcess); 790 G4HadronElasticProcess* theElasticPr << 729 G4AlphaInelasticProcess* theInelasticProcess = 791 theElasticProcess->AddDataSet( theGGNNEl ) << 730 new G4AlphaInelasticProcess("inelastic"); 792 theElasticProcess->RegisterMe( elast << 731 G4LEAlphaInelastic* theLEInelasticModel = 793 pmanager->AddDiscreteProcess( theElasticPr << 732 new G4LEAlphaInelastic; 794 // Inelastic scattering << 733 theInelasticProcess->RegisterMe(theLEInelasticModel); 795 G4HadronInelasticProcess* theInelasticProc << 734 pmanager->AddDiscreteProcess(theInelasticProcess); 796 new G4HadronInelasticProcess( "inelastic << 797 theInelasticProcess->AddDataSet( the << 798 theInelasticProcess->RegisterMe( theFTFMod << 799 theInelasticProcess->RegisterMe( the << 800 pmanager->AddDiscreteProcess( theInelastic << 801 } 735 } >> 736 802 } 737 } 803 } 738 } 804 739 >> 740 805 // Decays //////////////////////////////////// 741 // Decays /////////////////////////////////////////////////////////////////// >> 742 #include "G4Decay.hh" >> 743 #include "G4RadioactiveDecay.hh" >> 744 #include "G4IonTable.hh" >> 745 #include "G4Ions.hh" >> 746 806 void DMXPhysicsList::ConstructGeneral() { 747 void DMXPhysicsList::ConstructGeneral() { 807 748 808 // Add Decay Process 749 // Add Decay Process 809 G4Decay* theDecayProcess = new G4Decay(); 750 G4Decay* theDecayProcess = new G4Decay(); 810 auto particleIterator=GetParticleIterator(); << 751 theParticleIterator->reset(); 811 particleIterator->reset(); << 752 while( (*theParticleIterator)() ) 812 while( (*particleIterator)() ) << 813 { 753 { 814 G4ParticleDefinition* particle = particl << 754 G4ParticleDefinition* particle = theParticleIterator->value(); 815 G4ProcessManager* pmanager = particle->G 755 G4ProcessManager* pmanager = particle->GetProcessManager(); 816 756 817 if (theDecayProcess->IsApplicable(*parti 757 if (theDecayProcess->IsApplicable(*particle) && !particle->IsShortLived()) 818 { 758 { 819 pmanager ->AddProcess(theDecayProcess); 759 pmanager ->AddProcess(theDecayProcess); 820 // set ordering for PostStepDoIt and AtRes 760 // set ordering for PostStepDoIt and AtRestDoIt 821 pmanager ->SetProcessOrdering(theDecayProc 761 pmanager ->SetProcessOrdering(theDecayProcess, idxPostStep); 822 pmanager ->SetProcessOrdering(theDecayProc 762 pmanager ->SetProcessOrdering(theDecayProcess, idxAtRest); 823 } 763 } 824 } 764 } 825 765 826 // Declare radioactive decay to the GenericI 766 // Declare radioactive decay to the GenericIon in the IonTable. 827 G4LossTableManager* man = G4LossTableManager << 767 const G4IonTable *theIonTable = 828 G4VAtomDeexcitation* ad = man->AtomDeexcitat << 768 G4ParticleTable::GetParticleTable()->GetIonTable(); 829 if(!ad) { << 769 G4RadioactiveDecay *theRadioactiveDecay = new G4RadioactiveDecay(); 830 G4EmParameters::Instance()->SetAugerCascad << 831 ad = new G4UAtomicDeexcitation(); << 832 man->SetAtomDeexcitation(ad); << 833 ad->InitialiseAtomicDeexcitation(); << 834 } << 835 770 836 G4PhysicsListHelper::GetPhysicsListHelper()- << 771 for (G4int i=0; i<theIonTable->Entries(); i++) 837 RegisterProcess(new G4RadioactiveDecay(), << 772 { >> 773 G4String particleName = theIonTable->GetParticle(i)->GetParticleName(); >> 774 G4String particleType = theIonTable->GetParticle(i)->GetParticleType(); >> 775 >> 776 if (particleName == "GenericIon") >> 777 { >> 778 G4ProcessManager* pmanager = >> 779 theIonTable->GetParticle(i)->GetProcessManager(); >> 780 pmanager->SetVerboseLevel(VerboseLevel); >> 781 pmanager ->AddProcess(theRadioactiveDecay); >> 782 pmanager ->SetProcessOrdering(theRadioactiveDecay, idxPostStep); >> 783 pmanager ->SetProcessOrdering(theRadioactiveDecay, idxAtRest); >> 784 } >> 785 } 838 } 786 } 839 787 840 // Cuts ////////////////////////////////////// 788 // Cuts ///////////////////////////////////////////////////////////////////// 841 void DMXPhysicsList::SetCuts() 789 void DMXPhysicsList::SetCuts() 842 { 790 { 843 791 844 if (verboseLevel >1) 792 if (verboseLevel >1) 845 G4cout << "DMXPhysicsList::SetCuts:"; 793 G4cout << "DMXPhysicsList::SetCuts:"; 846 794 847 if (verboseLevel>0){ 795 if (verboseLevel>0){ 848 G4cout << "DMXPhysicsList::SetCuts:"; 796 G4cout << "DMXPhysicsList::SetCuts:"; 849 G4cout << "CutLength : " 797 G4cout << "CutLength : " 850 << G4BestUnit(defaultCutValue,"Length") < 798 << G4BestUnit(defaultCutValue,"Length") << G4endl; 851 } 799 } 852 800 853 //special for low energy physics 801 //special for low energy physics 854 G4double lowlimit=250*eV; 802 G4double lowlimit=250*eV; 855 G4ProductionCutsTable::GetProductionCutsTabl 803 G4ProductionCutsTable::GetProductionCutsTable()->SetEnergyRange(lowlimit,100.*GeV); 856 804 857 // set cut values for gamma at first and for 805 // set cut values for gamma at first and for e- second and next for e+, 858 // because some processes for e+/e- need cut 806 // because some processes for e+/e- need cut values for gamma 859 SetCutValue(cutForGamma, "gamma"); 807 SetCutValue(cutForGamma, "gamma"); 860 SetCutValue(cutForElectron, "e-"); 808 SetCutValue(cutForElectron, "e-"); 861 SetCutValue(cutForPositron, "e+"); 809 SetCutValue(cutForPositron, "e+"); 862 810 863 if (verboseLevel>0) DumpCutValuesTable(); 811 if (verboseLevel>0) DumpCutValuesTable(); 864 } 812 } 865 813 866 814