xray_TESdetector/src/G4EmStandardPhysics_SpacePhysics.cc

0001 //
0002 // ********************************************************************
0003 // * License and Disclaimer                                           *
0004 // *                                                                  *
0005 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
0006 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
0007 // * conditions of the Geant4 Software License,  included in the file *
0008 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
0009 // * include a list of copyright holders.                             *
0010 // *                                                                  *
0011 // * Neither the authors of this software system, nor their employing *
0012 // * institutes,nor the agencies providing financial support for this *
0013 // * work  make  any representation or  warranty, express or implied, *
0014 // * regarding  this  software system or assume any liability for its *
0015 // * use.  Please see the license in the file  LICENSE  and URL above *
0016 // * for the full disclaimer and the limitation of liability.         *
0017 // *                                                                  *
0018 // * This  code  implementation is the result of  the  scientific and *
0019 // * technical work of the GEANT4 collaboration.                      *
0020 // * By using,  copying,  modifying or  distributing the software (or *
0021 // * any work based  on the software)  you  agree  to acknowledge its *
0022 // * use  in  resulting  scientific  publications,  and indicate your *
0023 // * acceptance of all terms of the Geant4 Software license.          *
0024 // ********************************************************************
0025 //
0026 //
0027 //---------------------------------------------------------------------------
0028 //
0029 // Author: P.Dondero (paolo.dondero@cern.ch)
0030 //
0031 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
0032 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
0033
0034
0035 #include "G4EmStandardPhysics_SpacePhysics.hh"
0036
0037 #include "G4SystemOfUnits.hh"
0038 #include "G4ParticleDefinition.hh"
0039 #include "G4LossTableManager.hh"
0040 #include "G4EmParameters.hh"
0041 #include "G4EmBuilder.hh"
0042
0043 #include "G4ComptonScattering.hh"
0044 #include "G4GammaConversion.hh"
0045 #include "G4PhotoElectricEffect.hh"
0046 #include "G4RayleighScattering.hh"
0047 #include "G4PEEffectFluoModel.hh"
0048 #include "G4KleinNishinaModel.hh"
0049 #include "G4BetheHeitler5DModel.hh"
0050 #include "G4LivermorePhotoElectricModel.hh"
0051 #include "G4LivermorePolarizedRayleighModel.hh"
0052 #include "G4PhotoElectricAngularGeneratorPolarized.hh"
0053 #include "G4LowEPComptonModel.hh"
0054 #include "G4LowEPPolarizedComptonModel.hh"
0055
0056 #include "G4eMultipleScattering.hh"
0057 #include "G4hMultipleScattering.hh"
0058 #include "G4MscStepLimitType.hh"
0059 #include "G4UrbanMscModel.hh"
0060 #include "G4GoudsmitSaundersonMscModel.hh"
0061 #include "G4DummyModel.hh"
0062 #include "G4WentzelVIModel.hh"
0063 #include "G4CoulombScattering.hh"
0064 #include "G4eCoulombScatteringModel.hh"
0065
0066 #include "G4eIonisation.hh"
0067 #include "G4eBremsstrahlung.hh"
0068 #include "G4Generator2BS.hh"
0069 #include "G4Generator2BN.hh"
0070 #include "G4SeltzerBergerModel.hh"
0071 #include "G4ePairProduction.hh"
0072 #include "G4LivermoreIonisationModel.hh"
0073 #include "G4PenelopeIonisationModel.hh"
0074 #include "G4UniversalFluctuation.hh"
0075 #include "G4UrbanFluctuation.hh"
0076
0077 #include "G4eplusAnnihilation.hh"
0078
0079 #include "G4hIonisation.hh"
0080 #include "G4ionIonisation.hh"
0081 #include "G4IonParametrisedLossModel.hh"
0082 #include "G4NuclearStopping.hh"
0083
0084 #include "G4Gamma.hh"
0085 #include "G4Electron.hh"
0086 #include "G4Positron.hh"
0087 #include "G4GenericIon.hh"
0088
0089 #include "G4PhysicsListHelper.hh"
0090 #include "G4BuilderType.hh"
0091 #include "G4EmModelActivator.hh"
0092 #include "G4GammaGeneralProcess.hh"
0093
0094 // factory
0095 #include "G4PhysicsConstructorFactory.hh"
0096 //
0097 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
0098
0099 G4EmStandardPhysics_SpacePhysics::G4EmStandardPhysics_SpacePhysics(G4int ver, const G4String&)
0100   : G4VPhysicsConstructor("G4EmStandard_SpacePhysics"), fVerbose(ver)
0101 {
0102   G4cout << "---> Using G4EmStandard_SpacePhysics v. 11.03 " << G4endl;
0103   G4EmParameters* param = G4EmParameters::Instance();
0104   param->SetDefaults();
0105   param->SetVerbose(ver);
0106   param->SetMinEnergy(100*CLHEP::eV);
0107   param->SetLowestElectronEnergy(50*CLHEP::eV);
0108   param->SetNumberOfBinsPerDecade(20);
0109   param->ActivateAngularGeneratorForIonisation(true);
0110   param->SetStepFunction(0.2, 10*CLHEP::um);
0111   param->SetStepFunctionMuHad(0.05, 0.01*CLHEP::um);
0112   param->SetStepFunctionLightIons(0.1, 20*CLHEP::um);
0113   param->SetStepFunctionIons(0.1, 1*CLHEP::um);
0114   param->SetUseMottCorrection(true); // use Mott-correction for e-/e+ msc gs
0115   param->SetMscStepLimitType(fUseSafetyPlus); // for e-/e+ msc gs
0116   param->SetMscSkin(3);              // error-free stepping for e-/e+ msc gs
0117   param->SetMscRangeFactor(0.08);    // error-free stepping for e-/e+ msc gs
0118   param->SetMuHadLateralDisplacement(true);
0119   param->SetFluo(true);
0120   param->SetUseICRU90Data(true);
0121   param->SetMaxNIELEnergy(1*CLHEP::MeV);
0122   SetPhysicsType(bElectromagnetic);
0123 }
0124
0125 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
0126
0127 void G4EmStandardPhysics_SpacePhysics::ConstructParticle()
0128 {
0129   // minimal set of particles for EM physics
0130   G4EmBuilder::ConstructMinimalEmSet();
0131 }
0132
0133 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
0134
0135 void G4EmStandardPhysics_SpacePhysics::ConstructProcess()
0136 {
0137   if(fVerbose > 1)
0138   {
0139     G4cout << "### " << GetPhysicsName() << " Construct Space Physics Processes " << G4endl;
0140   }
0141   G4EmBuilder::PrepareEMPhysics();
0142
0143   auto *ph = G4PhysicsListHelper::GetPhysicsListHelper();
0144   auto *param = G4EmParameters::Instance();
0145
0146   // processes used by several particles
0147   auto *hmsc = new G4hMultipleScattering("ionmsc");
0148
0149   // nuclear stopping is enabled if the energy limit above zero
0150   G4double nielEnergyLimit = param->MaxNIELEnergy();
0151   G4NuclearStopping* pnuc = nullptr;
0152   if(nielEnergyLimit > 0.0)
0153   {
0154     pnuc = new G4NuclearStopping();
0155     pnuc->SetMaxKinEnergy(nielEnergyLimit);
0156   }
0157
0158   // high energy limit for e+- scattering models and bremsstrahlung
0159   G4double highEnergyLimit = param->MscEnergyLimit();
0160
0161   // Add gamma EM Processes
0162   G4ParticleDefinition *particle = G4Gamma::Gamma();
0163   G4bool polar = param->EnablePolarisation();
0164
0165   // Photoelectric
0166   auto *pe = new G4PhotoElectricEffect();
0167   auto *peModel = new G4LivermorePhotoElectricModel();
0168   pe->SetEmModel(peModel);
0169   if(polar)
0170   {
0171     peModel->SetAngularDistribution(new G4PhotoElectricAngularGeneratorPolarized());
0172   }
0173
0174   // Compton scattering
0175   auto *cs = new G4ComptonScattering;
0176   cs->SetEmModel(new G4KleinNishinaModel());
0177   G4VEmModel* cModel = nullptr;
0178   if(polar)
0179   {
0180     cModel = new G4LowEPPolarizedComptonModel();
0181   }
0182   else
0183   {
0184     cModel = new G4LowEPComptonModel();
0185   }
0186   cModel->SetHighEnergyLimit(20*CLHEP::MeV);
0187   cs->AddEmModel(0, cModel);
0188
0189   // Gamma conversion
0190   auto *gc = new G4GammaConversion();
0191   auto *conv = new G4BetheHeitler5DModel();
0192   gc->SetEmModel(conv);
0193
0194   // default Rayleigh scattering is Livermore
0195   G4RayleighScattering* rl = new G4RayleighScattering();
0196   if(polar)
0197   {
0198     rl->SetEmModel(new G4LivermorePolarizedRayleighModel());
0199   }
0200
0201   if(param->GeneralProcessActive())
0202   {
0203     auto *sp = new G4GammaGeneralProcess();
0204     sp->AddEmProcess(pe);
0205     sp->AddEmProcess(cs);
0206     sp->AddEmProcess(gc);
0207     sp->AddEmProcess(rl);
0208     G4LossTableManager::Instance()->SetGammaGeneralProcess(sp);
0209     ph->RegisterProcess(sp, particle);
0210   }
0211   else
0212   {
0213     ph->RegisterProcess(pe, particle);
0214     ph->RegisterProcess(cs, particle);
0215     ph->RegisterProcess(gc, particle);
0216     ph->RegisterProcess(rl, particle);
0217   }
0218
0219   // e-
0220   particle = G4Electron::Electron();
0221
0222   // multiple scattering
0223   auto *msc = new G4eMultipleScattering();
0224   // e-/e+ msc gs with Mott-correction
0225   // (Mott-correction is set through G4EmParameters)
0226   auto *msc1 = new G4GoudsmitSaundersonMscModel();
0227   auto *msc2 = new G4WentzelVIModel();
0228   msc1->SetHighEnergyLimit(highEnergyLimit);
0229   msc2->SetLowEnergyLimit(highEnergyLimit);
0230   msc->SetEmModel(msc1);
0231   msc->SetEmModel(msc2);
0232
0233   auto *ssm = new G4eCoulombScatteringModel();
0234   G4CoulombScattering* ss = new G4CoulombScattering();
0235   ss->SetEmModel(ssm);
0236   ss->SetMinKinEnergy(highEnergyLimit);
0237   ssm->SetLowEnergyLimit(highEnergyLimit);
0238   ssm->SetActivationLowEnergyLimit(highEnergyLimit);
0239
0240   // ionisation
0241   auto *eioni = new G4eIonisation();
0242   G4VEmModel* theIoniLiv = new G4LivermoreIonisationModel();
0243   eioni->SetFluctModel(new G4UrbanFluctuation());
0244   theIoniLiv->SetHighEnergyLimit(0.1*CLHEP::MeV);
0245   eioni->AddEmModel(0, theIoniLiv, new G4UniversalFluctuation() );
0246
0247   // bremsstrahlung
0248   auto *brem = new G4eBremsstrahlung();
0249   auto *br1 = new G4SeltzerBergerModel();
0250   auto *br2 = new G4eBremsstrahlungRelModel();
0251   br1->SetAngularDistribution(new G4Generator2BS());
0252   br2->SetAngularDistribution(new G4Generator2BS());
0253   brem->SetEmModel(br1);
0254   brem->SetEmModel(br2);
0255   br1->SetHighEnergyLimit(CLHEP::GeV);
0256
0257   auto *ee = new G4ePairProduction();
0258
0259   // register processes
0260   ph->RegisterProcess(msc, particle);
0261   ph->RegisterProcess(eioni, particle);
0262   ph->RegisterProcess(brem, particle);
0263   ph->RegisterProcess(ee, particle);
0264   ph->RegisterProcess(ss, particle);
0265
0266   // e+
0267   particle = G4Positron::Positron();
0268
0269   // multiple scattering
0270   msc = new G4eMultipleScattering();
0271   // e-/e+ msc gs with Mott-correction
0272   // (Mott-correction is set through G4EmParameters)
0273   msc1 = new G4GoudsmitSaundersonMscModel();
0274   msc2 = new G4WentzelVIModel();
0275   msc1->SetHighEnergyLimit(highEnergyLimit);
0276   msc2->SetLowEnergyLimit(highEnergyLimit);
0277   msc->SetEmModel(msc1);
0278   msc->SetEmModel(msc2);
0279
0280   ssm = new G4eCoulombScatteringModel();
0281   ss = new G4CoulombScattering();
0282   ss->SetEmModel(ssm);
0283   ss->SetMinKinEnergy(highEnergyLimit);
0284   ssm->SetLowEnergyLimit(highEnergyLimit);
0285   ssm->SetActivationLowEnergyLimit(highEnergyLimit);
0286
0287   // ionisation
0288   eioni = new G4eIonisation();
0289   eioni->SetFluctModel(new G4UrbanFluctuation());
0290   auto *pen = new G4PenelopeIonisationModel();
0291   pen->SetHighEnergyLimit(0.1*CLHEP::MeV);
0292   eioni->AddEmModel(0, pen, new G4UniversalFluctuation());
0293
0294   // bremsstrahlung
0295   brem = new G4eBremsstrahlung();
0296   br1 = new G4SeltzerBergerModel();
0297   br2 = new G4eBremsstrahlungRelModel();
0298   br1->SetAngularDistribution(new G4Generator2BS());
0299   br2->SetAngularDistribution(new G4Generator2BS());
0300   brem->SetEmModel(br1);
0301   brem->SetEmModel(br2);
0302   br1->SetHighEnergyLimit(CLHEP::GeV);
0303
0304   // register processes
0305   ph->RegisterProcess(msc, particle);
0306   ph->RegisterProcess(eioni, particle);
0307   ph->RegisterProcess(brem, particle);
0308   ph->RegisterProcess(ee, particle);
0309   ph->RegisterProcess(new G4eplusAnnihilation(), particle);
0310   ph->RegisterProcess(ss, particle);
0311
0312   // generic ion
0313   particle = G4GenericIon::GenericIon();
0314   auto *ionIoni = new G4ionIonisation();
0315   ionIoni->SetEmModel(new G4IonParametrisedLossModel());
0316   ph->RegisterProcess(hmsc, particle);
0317   ph->RegisterProcess(ionIoni, particle);
0318   if(nullptr != pnuc) { ph->RegisterProcess(pnuc, particle); }
0319
0320   // muons, hadrons, ions
0321   G4EmBuilder::ConstructCharged(hmsc, pnuc);
0322
0323   // extra configuration
0324   G4EmModelActivator mact(GetPhysicsName());
0325 }
0326
0327 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......