10.03.p03/html/_g4_em_standard_physics__option4_8cc_source.html

 //

 // ********************************************************************

 // * License and Disclaimer                                           *

 // *                                                                  *

 // * The  Geant4 software  is  copyright of the Copyright Holders  of *

 // * the Geant4 Collaboration.  It is provided  under  the terms  and *

 // * conditions of the Geant4 Software License,  included in the file *

 // * LICENSE and available at  http://cern.ch/geant4/license .  These *

 // * include a list of copyright holders.                             *

 // *                                                                  *

 // * Neither the authors of this software system, nor their employing *

 // * institutes,nor the agencies providing financial support for this *

 // * work  make  any representation or  warranty, express or implied, *

 // * regarding  this  software system or assume any liability for its *

 // * use.  Please see the license in the file  LICENSE  and URL above *

 // * for the full disclaimer and the limitation of liability.         *

 // *                                                                  *

 // * This  code  implementation is the result of  the  scientific and *

 // * technical work of the GEANT4 collaboration.                      *

 // * By using,  copying,  modifying or  distributing the software (or *

 // * any work based  on the software)  you  agree  to acknowledge its *

 // * use  in  resulting  scientific  publications,  and indicate your *

 // * acceptance of all terms of the Geant4 Software license.          *

 // ********************************************************************

 //

 // $Id: G4EmStandardPhysics_option4.cc 99938 2016-10-12 08:06:52Z gcosmo $

 //

 //---------------------------------------------------------------------------

 //

 // ClassName:   G4EmStandardPhysics_option4

 //

 // Author:      V.Ivanchenko 28.09.2012 from Option3 physics constructor

 //

 // Modified:

 //

 //----------------------------------------------------------------------------

 //


 #include "G4EmStandardPhysics_option4.hh"


 #include "G4SystemOfUnits.hh"

 #include "G4ParticleDefinition.hh"

 #include "G4LossTableManager.hh"

 #include "G4EmParameters.hh"


 #include "G4ComptonScattering.hh"

 #include "G4GammaConversion.hh"

 #include "G4PhotoElectricEffect.hh"

 #include "G4RayleighScattering.hh"

 #include "G4PEEffectFluoModel.hh"

 #include "G4KleinNishinaModel.hh"

 #include "G4LowEPComptonModel.hh"

 #include "G4PenelopeGammaConversionModel.hh"

 #include "G4LivermorePhotoElectricModel.hh"


 #include "G4eMultipleScattering.hh"

 #include "G4MuMultipleScattering.hh"

 #include "G4hMultipleScattering.hh"

 #include "G4MscStepLimitType.hh"

 #include "G4UrbanMscModel.hh"

 #include "G4DummyModel.hh"

 #include "G4WentzelVIModel.hh"

 #include "G4CoulombScattering.hh"

 #include "G4eCoulombScatteringModel.hh"


 #include "G4eIonisation.hh"

 #include "G4eBremsstrahlung.hh"

 #include "G4Generator2BS.hh"

 #include "G4Generator2BN.hh"

 #include "G4SeltzerBergerModel.hh"

 #include "G4PenelopeIonisationModel.hh"

 #include "G4UniversalFluctuation.hh"


 #include "G4eplusAnnihilation.hh"

 #include "G4UAtomicDeexcitation.hh"


 #include "G4MuIonisation.hh"

 #include "G4MuBremsstrahlung.hh"

 #include "G4MuPairProduction.hh"

 #include "G4hBremsstrahlung.hh"

 #include "G4hPairProduction.hh"

 #include "G4ePairProduction.hh"


 #include "G4MuBremsstrahlungModel.hh"

 #include "G4MuPairProductionModel.hh"

 #include "G4hBremsstrahlungModel.hh"

 #include "G4hPairProductionModel.hh"


 #include "G4hIonisation.hh"

 #include "G4ionIonisation.hh"

 #include "G4IonParametrisedLossModel.hh"

 #include "G4NuclearStopping.hh"


 #include "G4Gamma.hh"

 #include "G4Electron.hh"

 #include "G4Positron.hh"

 #include "G4MuonPlus.hh"

 #include "G4MuonMinus.hh"

 #include "G4PionPlus.hh"

 #include "G4PionMinus.hh"

 #include "G4KaonPlus.hh"

 #include "G4KaonMinus.hh"

 #include "G4Proton.hh"

 #include "G4AntiProton.hh"

 #include "G4Deuteron.hh"

 #include "G4Triton.hh"

 #include "G4He3.hh"

 #include "G4Alpha.hh"

 #include "G4GenericIon.hh"


 #include "G4PhysicsListHelper.hh"

 #include "G4BuilderType.hh"

 #include "G4EmModelActivator.hh"


 // factory

 #include "G4PhysicsConstructorFactory.hh"

 //

 G4_DECLARE_PHYSCONSTR_FACTORY(G4EmStandardPhysics_option4);


 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......


 G4EmStandardPhysics_option4::G4EmStandardPhysics_option4(G4int ver,

                              const G4String&)

   : G4VPhysicsConstructor("G4EmStandard_opt4"), verbose(ver)

 {

   G4EmParameters* param = G4EmParameters::Instance();

   param->SetDefaults();

   param->SetVerbose(verbose);

   param->SetMinEnergy(100*eV);

   param->SetMaxEnergy(10*TeV);

   param->SetLowestElectronEnergy(100*eV);

   param->SetNumberOfBinsPerDecade(20);

   param->ActivateAngularGeneratorForIonisation(true);

   param->SetMscRangeFactor(0.02);

   param->SetMscStepLimitType(fUseDistanceToBoundary);

   param->SetMuHadLateralDisplacement(true);

   //  param->SetLatDisplacementBeyondSafety(true);

   param->SetFluo(true);

   SetPhysicsType(bElectromagnetic);

 }


 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......


 G4EmStandardPhysics_option4::~G4EmStandardPhysics_option4()

 {}


 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......


 void G4EmStandardPhysics_option4::ConstructParticle()

 {

   // gamma

   G4Gamma::Gamma();


   // leptons

   G4Electron::Electron();

   G4Positron::Positron();

   G4MuonPlus::MuonPlus();

   G4MuonMinus::MuonMinus();


   // mesons

   G4PionPlus::PionPlusDefinition();

   G4PionMinus::PionMinusDefinition();

   G4KaonPlus::KaonPlusDefinition();

   G4KaonMinus::KaonMinusDefinition();


   // barions

   G4Proton::Proton();

   G4AntiProton::AntiProton();


   // ions

   G4Deuteron::Deuteron();

   G4Triton::Triton();

   G4He3::He3();

   G4Alpha::Alpha();

   G4GenericIon::GenericIonDefinition();

 }


 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......


 void G4EmStandardPhysics_option4::ConstructProcess()

 {

   if(verbose > 1) {

     G4cout << "### " << GetPhysicsName() << " Construct Processes " << G4endl;

   }

   G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();


   // muon & hadron bremsstrahlung and pair production

   G4MuBremsstrahlung* mub = new G4MuBremsstrahlung();

   G4MuPairProduction* mup = new G4MuPairProduction();

   G4hBremsstrahlung* pib = new G4hBremsstrahlung();

   G4hPairProduction* pip = new G4hPairProduction();

   G4hBremsstrahlung* kb = new G4hBremsstrahlung();

   G4hPairProduction* kp = new G4hPairProduction();

   G4hBremsstrahlung* pb = new G4hBremsstrahlung();

   G4hPairProduction* pp = new G4hPairProduction();

   G4ePairProduction* ee = new G4ePairProduction();


   // muon & hadron multiple scattering

   G4MuMultipleScattering* mumsc = new G4MuMultipleScattering();

   mumsc->AddEmModel(0, new G4WentzelVIModel());

   G4CoulombScattering* muss = new G4CoulombScattering();


   G4MuMultipleScattering* pimsc = new G4MuMultipleScattering();

   pimsc->AddEmModel(0, new G4WentzelVIModel());

   G4CoulombScattering* piss = new G4CoulombScattering();


   G4MuMultipleScattering* kmsc = new G4MuMultipleScattering();

   kmsc->AddEmModel(0, new G4WentzelVIModel());

   G4CoulombScattering* kss = new G4CoulombScattering();


   G4MuMultipleScattering* pmsc = new G4MuMultipleScattering();

   pmsc->AddEmModel(0, new G4WentzelVIModel());

   G4CoulombScattering* pss = new G4CoulombScattering();


   G4hMultipleScattering* hmsc = new G4hMultipleScattering("ionmsc");


   // energy limits for e+- scattering models

   G4double highEnergyLimit = 100*MeV;

   // energy limits for e+- ionisation models

   G4double penEnergyLimit = 1*MeV;


   // nuclear stopping

   G4NuclearStopping* pnuc = new G4NuclearStopping();


   // Add standard EM Processes

   auto myParticleIterator=GetParticleIterator();

   myParticleIterator->reset();

   while( (*myParticleIterator)() ){

     G4ParticleDefinition* particle = myParticleIterator->value();

     G4String particleName = particle->GetParticleName();


     if (particleName == "gamma") {


       // Photoelectric

       G4PhotoElectricEffect* pe = new G4PhotoElectricEffect();

       G4VEmModel* theLivermorePEModel = new G4LivermorePhotoElectricModel();

       pe->SetEmModel(theLivermorePEModel,1);

       ph->RegisterProcess(pe, particle);


       // Compton scattering

       G4ComptonScattering* cs = new G4ComptonScattering;

       cs->SetEmModel(new G4KleinNishinaModel(),1);

       G4VEmModel* theLowEPComptonModel = new G4LowEPComptonModel();

       theLowEPComptonModel->SetHighEnergyLimit(20*MeV);

       cs->AddEmModel(0, theLowEPComptonModel);

       ph->RegisterProcess(cs, particle);


       // Gamma conversion

       G4GammaConversion* gc = new G4GammaConversion();

       G4VEmModel* thePenelopeGCModel = new G4PenelopeGammaConversionModel();

       thePenelopeGCModel->SetHighEnergyLimit(1*GeV);

       gc->SetEmModel(thePenelopeGCModel,1);

       ph->RegisterProcess(gc, particle);


       // Rayleigh scattering

       ph->RegisterProcess(new G4RayleighScattering(), particle);


     } else if (particleName == "e-") {


       // multiple scattering

       G4eMultipleScattering* msc = new G4eMultipleScattering;

       G4UrbanMscModel* msc1 = new G4UrbanMscModel();

       G4WentzelVIModel* msc2 = new G4WentzelVIModel();

       msc1->SetHighEnergyLimit(highEnergyLimit);

       msc2->SetLowEnergyLimit(highEnergyLimit);

       msc->AddEmModel(0, msc1);

       msc->AddEmModel(0, msc2);


       G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();

       G4CoulombScattering* ss = new G4CoulombScattering();

       ss->SetEmModel(ssm, 1);

       ss->SetMinKinEnergy(highEnergyLimit);

       ssm->SetLowEnergyLimit(highEnergyLimit);

       ssm->SetActivationLowEnergyLimit(highEnergyLimit);


       // ionisation

       G4eIonisation* eIoni = new G4eIonisation();

       eIoni->SetStepFunction(0.2, 100*um);

       G4PenelopeIonisationModel* pen = new G4PenelopeIonisationModel();

       pen->SetHighEnergyLimit(penEnergyLimit);

       eIoni->AddEmModel(0, pen, new G4UniversalFluctuation());


       // bremsstrahlung

       G4eBremsstrahlung* brem = new G4eBremsstrahlung();

       G4SeltzerBergerModel* br1 = new G4SeltzerBergerModel();

       G4eBremsstrahlungRelModel* br2 = new G4eBremsstrahlungRelModel();

       br1->SetAngularDistribution(new G4Generator2BS());

       br2->SetAngularDistribution(new G4Generator2BS());

       brem->SetEmModel(br1,1);

       brem->SetEmModel(br2,2);

       br2->SetLowEnergyLimit(GeV);


       // register processes

       ph->RegisterProcess(msc, particle);

       ph->RegisterProcess(eIoni, particle);

       ph->RegisterProcess(brem, particle);

       ph->RegisterProcess(ee, particle);

       ph->RegisterProcess(ss, particle);


     } else if (particleName == "e+") {


       // multiple scattering

       G4eMultipleScattering* msc = new G4eMultipleScattering;

       G4UrbanMscModel* msc1 = new G4UrbanMscModel();

       G4WentzelVIModel* msc2 = new G4WentzelVIModel();

       msc1->SetHighEnergyLimit(highEnergyLimit);

       msc2->SetLowEnergyLimit(highEnergyLimit);

       msc->AddEmModel(0, msc1);

       msc->AddEmModel(0, msc2);


       G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel();

       G4CoulombScattering* ss = new G4CoulombScattering();

       ss->SetEmModel(ssm, 1);

       ss->SetMinKinEnergy(highEnergyLimit);

       ssm->SetLowEnergyLimit(highEnergyLimit);

       ssm->SetActivationLowEnergyLimit(highEnergyLimit);


       // ionisation

       G4eIonisation* eIoni = new G4eIonisation();

       eIoni->SetStepFunction(0.2, 100*um);

       G4PenelopeIonisationModel* pen = new G4PenelopeIonisationModel();

       pen->SetHighEnergyLimit(penEnergyLimit);

       eIoni->AddEmModel(0, pen, new G4UniversalFluctuation());


       // bremsstrahlung

       G4eBremsstrahlung* brem = new G4eBremsstrahlung();

       G4SeltzerBergerModel* br1 = new G4SeltzerBergerModel();

       G4eBremsstrahlungRelModel* br2 = new G4eBremsstrahlungRelModel();

       br1->SetAngularDistribution(new G4Generator2BS());

       br2->SetAngularDistribution(new G4Generator2BS());

       brem->SetEmModel(br1,1);

       brem->SetEmModel(br2,2);

       br2->SetLowEnergyLimit(GeV);


       // register processes

       ph->RegisterProcess(msc, particle);

       ph->RegisterProcess(eIoni, particle);

       ph->RegisterProcess(brem, particle);

       ph->RegisterProcess(ee, particle);

       ph->RegisterProcess(new G4eplusAnnihilation(), particle);

       ph->RegisterProcess(ss, particle);


     } else if (particleName == "mu+" ||

                particleName == "mu-"    ) {


       G4MuIonisation* muIoni = new G4MuIonisation();

       muIoni->SetStepFunction(0.2, 50*um);


       ph->RegisterProcess(mumsc, particle);

       ph->RegisterProcess(muIoni, particle);

       ph->RegisterProcess(mub, particle);

       ph->RegisterProcess(mup, particle);

       ph->RegisterProcess(muss, particle);


     } else if (particleName == "alpha" ||

                particleName == "He3") {


       G4hMultipleScattering* msc = new G4hMultipleScattering();

       G4ionIonisation* ionIoni = new G4ionIonisation();

       ionIoni->SetStepFunction(0.1, 10*um);


       ph->RegisterProcess(msc, particle);

       ph->RegisterProcess(ionIoni, particle);

       ph->RegisterProcess(pnuc, particle);


     } else if (particleName == "GenericIon") {


       G4ionIonisation* ionIoni = new G4ionIonisation();

       ionIoni->SetEmModel(new G4IonParametrisedLossModel());

       ionIoni->SetStepFunction(0.1, 1*um);


       ph->RegisterProcess(hmsc, particle);

       ph->RegisterProcess(ionIoni, particle);

       ph->RegisterProcess(pnuc, particle);


     } else if (particleName == "pi+" ||

                particleName == "pi-" ) {


       //G4hMultipleScattering* pimsc = new G4hMultipleScattering();

       G4hIonisation* hIoni = new G4hIonisation();

       hIoni->SetStepFunction(0.2, 50*um);


       ph->RegisterProcess(pimsc, particle);

       ph->RegisterProcess(hIoni, particle);

       ph->RegisterProcess(pib, particle);

       ph->RegisterProcess(pip, particle);

       ph->RegisterProcess(piss, particle);


     } else if (particleName == "kaon+" ||

                particleName == "kaon-" ) {


       //G4hMultipleScattering* kmsc = new G4hMultipleScattering();

       G4hIonisation* hIoni = new G4hIonisation();

       hIoni->SetStepFunction(0.2, 50*um);


       ph->RegisterProcess(kmsc, particle);

       ph->RegisterProcess(hIoni, particle);

       ph->RegisterProcess(kb, particle);

       ph->RegisterProcess(kp, particle);

       ph->RegisterProcess(kss, particle);


     } else if (particleName == "proton" ||

            particleName == "anti_proton") {


       //G4hMultipleScattering* pmsc = new G4hMultipleScattering();

       G4hIonisation* hIoni = new G4hIonisation();

       hIoni->SetStepFunction(0.1, 20*um);


       ph->RegisterProcess(pmsc, particle);

       ph->RegisterProcess(hIoni, particle);

       ph->RegisterProcess(pb, particle);

       ph->RegisterProcess(pp, particle);

       ph->RegisterProcess(pss, particle);

       ph->RegisterProcess(pnuc, particle);


     } else if (particleName == "B+" ||

            particleName == "B-" ||

            particleName == "D+" ||

            particleName == "D-" ||

            particleName == "Ds+" ||

            particleName == "Ds-" ||

                particleName == "anti_He3" ||

                particleName == "anti_alpha" ||

                particleName == "anti_deuteron" ||

                particleName == "anti_lambda_c+" ||

                particleName == "anti_omega-" ||

                particleName == "anti_sigma_c+" ||

                particleName == "anti_sigma_c++" ||

                particleName == "anti_sigma+" ||

                particleName == "anti_sigma-" ||

                particleName == "anti_triton" ||

                particleName == "anti_xi_c+" ||

                particleName == "anti_xi-" ||

                particleName == "deuteron" ||

            particleName == "lambda_c+" ||

                particleName == "omega-" ||

                particleName == "sigma_c+" ||

                particleName == "sigma_c++" ||

                particleName == "sigma+" ||

                particleName == "sigma-" ||

                particleName == "tau+" ||

                particleName == "tau-" ||

                particleName == "triton" ||

                particleName == "xi_c+" ||

                particleName == "xi-" ) {


       ph->RegisterProcess(hmsc, particle);

       ph->RegisterProcess(new G4hIonisation(), particle);

       ph->RegisterProcess(pnuc, particle);

     }

   }


   // Nuclear stopping

   pnuc->SetMaxKinEnergy(MeV);


   // Deexcitation

   G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();

   G4LossTableManager::Instance()->SetAtomDeexcitation(de);


   G4EmModelActivator mact(GetPhysicsName());

 }


 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......

G4hMultipleScattering.hh

G4VEmModel
Definition: G4VEmModel.hh:104

G4InuclParticleNames::pip
Definition: G4InuclParticleNames.hh:61

G4EmStandardPhysics_option4.hh

G4eCoulombScatteringModel
Definition: G4eCoulombScatteringModel.hh:78

G4eCoulombScatteringModel.hh

G4KaonPlus::KaonPlusDefinition
static G4KaonPlus * KaonPlusDefinition()
Definition: G4KaonPlus.cc:108

G4KleinNishinaModel
Definition: G4KleinNishinaModel.hh:59

G4eIonisation.hh

G4GenericIon::GenericIonDefinition
static G4GenericIon * GenericIonDefinition()
Definition: G4GenericIon.cc:88

G4Generator2BN.hh

G4MuonPlus::MuonPlus
static G4MuonPlus * MuonPlus()
Definition: G4MuonPlus.cc:99

G4PionPlus.hh

G4GenericIon.hh

G4MuPairProductionModel.hh

G4IonParametrisedLossModel.hh

G4EmParameters::SetVerbose
void SetVerbose(G4int val)
Definition: G4EmParameters.cc:724

G4LossTableManager::Instance
static G4LossTableManager * Instance()
Definition: G4LossTableManager.cc:112

G4hPairProductionModel.hh

G4UniversalFluctuation.hh

G4MscStepLimitType.hh

G4PhotoElectricEffect
Definition: G4PhotoElectricEffect.hh:79

G4Triton.hh

G4EmParameters::SetLowestElectronEnergy
void SetLowestElectronEnergy(G4double val)
Definition: G4EmParameters.cc:460

G4ePairProduction
Definition: G4ePairProduction.hh:58

G4ComptonScattering.hh

G4EmParameters::SetMscStepLimitType
void SetMscStepLimitType(G4MscStepLimitType val)
Definition: G4EmParameters.cc:747

G4PEEffectFluoModel.hh

G4hBremsstrahlung.hh

G4PenelopeGammaConversionModel
Definition: G4PenelopeGammaConversionModel.hh:57

G4KaonPlus.hh

G4InuclParticleNames::mup
Definition: G4InuclParticleNames.hh:72

G4hIonisation.hh

G4KaonMinus::KaonMinusDefinition
static G4KaonMinus * KaonMinusDefinition()
Definition: G4KaonMinus.cc:108

G4EmModelActivator
Definition: G4EmModelActivator.hh:58

G4hPairProduction
Definition: G4hPairProduction.hh:59

G4NuclearStopping.hh

G4ePairProduction.hh

G4MuPairProduction.hh

G4hPairProduction.hh

G4eMultipleScattering.hh

G4LowEPComptonModel
Definition: G4LowEPComptonModel.hh:81

G4UAtomicDeexcitation
Definition: G4UAtomicDeexcitation.hh:61

G4ComptonScattering
Definition: G4ComptonScattering.hh:71

G4LossTableManager.hh

G4SeltzerBergerModel.hh

fUseDistanceToBoundary
Definition: G4MscStepLimitType.hh:52

G4PenelopeIonisationModel
Definition: G4PenelopeIonisationModel.hh:66

G4MuIonisation.hh

G4PhysicsListHelper.hh

G4BuilderType.hh

G4ParticleDefinition
Definition: G4ParticleDefinition.hh:72

G4EmStandardPhysics_option4::~G4EmStandardPhysics_option4
virtual ~G4EmStandardPhysics_option4()
Definition: G4EmStandardPhysics_option4.cc:144

G4MuBremsstrahlung.hh

G4KaonMinus.hh

G4int
int G4int
Definition: G4Types.hh:78

G4EmParameters::SetMaxEnergy
void SetMaxEnergy(G4double val)
Definition: G4EmParameters.cc:423

G4VEnergyLossProcess::SetStepFunction
void SetStepFunction(G4double v1, G4double v2, G4bool lock=true)
Definition: G4VEnergyLossProcess.cc:2353

G4ParticleDefinition::GetParticleName
const G4String & GetParticleName() const
Definition: G4ParticleDefinition.hh:120

G4CoulombScattering
Definition: G4CoulombScattering.hh:55

G4LowEPComptonModel.hh

G4VEmModel::SetHighEnergyLimit
void SetHighEnergyLimit(G4double)
Definition: G4VEmModel.hh:732

G4hBremsstrahlungModel.hh

G4ionIonisation.hh

TeV
static constexpr double TeV
Definition: G4SIunits.hh:218

G4CoulombScattering.hh

G4eBremsstrahlungRelModel
Definition: G4eBremsstrahlungRelModel.hh:62

G4UrbanMscModel.hh

G4VEnergyLossProcess::AddEmModel
void AddEmModel(G4int, G4VEmModel *, G4VEmFluctuationModel *fluc=0, const G4Region *region=nullptr)
Definition: G4VEnergyLossProcess.cc:391

G4VPhysicsConstructor::GetParticleIterator
G4ParticleTable::G4PTblDicIterator * GetParticleIterator() const
Definition: G4VPhysicsConstructor.cc:78

G4EmStandardPhysics_option4
Definition: G4EmStandardPhysics_option4.hh:53

G4VEmProcess::SetEmModel
void SetEmModel(G4VEmModel *, G4int index=1)
Definition: G4VEmProcess.cc:213

G4cout
G4GLOB_DLL std::ostream G4cout

um
static constexpr double um
Definition: G4SIunits.hh:113

G4EmModelActivator.hh

G4GammaConversion
Definition: G4GammaConversion.hh:75

G4hBremsstrahlung
Definition: G4hBremsstrahlung.hh:61

G4GammaConversion.hh

G4AntiProton::AntiProton
static G4AntiProton * AntiProton()
Definition: G4AntiProton.cc:93

G4EmParameters
Definition: G4EmParameters.hh:72

G4MuMultipleScattering
Definition: G4MuMultipleScattering.hh:61

G4PionMinus::PionMinusDefinition
static G4PionMinus * PionMinusDefinition()
Definition: G4PionMinus.cc:93

G4EmParameters::SetMscRangeFactor
void SetMscRangeFactor(G4double val)
Definition: G4EmParameters.cc:586

G4MuBremsstrahlungModel.hh

G4PhysicsListHelper::RegisterProcess
G4bool RegisterProcess(G4VProcess *process, G4ParticleDefinition *particle)
Definition: G4PhysicsListHelper.cc:413

G4VAtomDeexcitation
Definition: G4VAtomDeexcitation.hh:64

G4Proton.hh

G4IonParametrisedLossModel
Definition: G4IonParametrisedLossModel.hh:93

G4Alpha.hh

G4DummyModel.hh

G4EmParameters::SetNumberOfBinsPerDecade
void SetNumberOfBinsPerDecade(G4int val)
Definition: G4EmParameters.cc:705

G4Triton::Triton
static G4Triton * Triton()
Definition: G4Triton.cc:95

G4PionPlus::PionPlusDefinition
static G4PionPlus * PionPlusDefinition()
Definition: G4PionPlus.cc:93

G4Positron.hh

G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:93

G4EmStandardPhysics_option4::ConstructProcess
virtual void ConstructProcess()
Definition: G4EmStandardPhysics_option4.cc:180

eV
static constexpr double eV
Definition: G4SIunits.hh:215

G4Generator2BS.hh

G4EmParameters::SetDefaults
void SetDefaults()
Definition: G4EmParameters.cc:96

G4NuclearStopping
Definition: G4NuclearStopping.hh:64

G4ParticleDefinition.hh

G4EmParameters.hh

G4VPhysicsConstructor::GetPhysicsName
const G4String & GetPhysicsName() const
Definition: G4VPhysicsConstructor.hh:195

G4PhotoElectricEffect.hh

G4Gamma::Gamma
static G4Gamma * Gamma()
Definition: G4Gamma.cc:86

G4PenelopeGammaConversionModel.hh

G4ionIonisation
Definition: G4ionIonisation.hh:78

G4MuBremsstrahlung
Definition: G4MuBremsstrahlung.hh:78

G4Deuteron::Deuteron
static G4Deuteron * Deuteron()
Definition: G4Deuteron.cc:94

G4Deuteron.hh

G4VEmModel::SetActivationLowEnergyLimit
void SetActivationLowEnergyLimit(G4double)
Definition: G4VEmModel.hh:753

G4UAtomicDeexcitation.hh

G4MuIonisation
Definition: G4MuIonisation.hh:85

G4PenelopeIonisationModel.hh

bElectromagnetic
Definition: G4BuilderType.hh:48

G4SeltzerBergerModel
Definition: G4SeltzerBergerModel.hh:61

G4VEmProcess::AddEmModel
void AddEmModel(G4int, G4VEmModel *, const G4Region *region=nullptr)
Definition: G4VEmProcess.cc:203

G4RayleighScattering.hh

G4eBremsstrahlung
Definition: G4eBremsstrahlung.hh:81

G4MuMultipleScattering.hh

G4Positron::Positron
static G4Positron * Positron()
Definition: G4Positron.cc:94

G4Electron.hh

G4VEmProcess::SetMaxKinEnergy
void SetMaxKinEnergy(G4double e)
Definition: G4VEmProcess.cc:1219

G4WentzelVIModel.hh

G4PionMinus.hh

G4EmParameters::SetMuHadLateralDisplacement
void SetMuHadLateralDisplacement(G4bool val)
Definition: G4EmParameters.cc:302

G4eIonisation
Definition: G4eIonisation.hh:80

G4eplusAnnihilation.hh

G4InuclParticleNames::pp
Definition: G4InuclParticleNames.hh:67

G4LivermorePhotoElectricModel
Definition: G4LivermorePhotoElectricModel.hh:50

G4He3.hh

G4EmParameters::SetMinEnergy
void SetMinEnergy(G4double val)
Definition: G4EmParameters.cc:404

G4PhysicsConstructorFactory.hh

G4AntiProton.hh

G4MuonMinus.hh

G4VEmModel::SetAngularDistribution
void SetAngularDistribution(G4VEmAngularDistribution *)
Definition: G4VEmModel.hh:626

G4PhysicsListHelper::GetPhysicsListHelper
static G4PhysicsListHelper * GetPhysicsListHelper()
Definition: G4PhysicsListHelper.cc:89

G4EmParameters::Instance
static G4EmParameters * Instance()
Definition: G4EmParameters.cc:67

G4Generator2BS
Definition: G4Generator2BS.hh:64

G4EmStandardPhysics_option4::G4EmStandardPhysics_option4
G4EmStandardPhysics_option4(G4int ver=1, const G4String &name="")
Definition: G4EmStandardPhysics_option4.cc:122

G4VEnergyLossProcess::SetEmModel
void SetEmModel(G4VEmModel *, G4int index=1)
Definition: G4VEnergyLossProcess.cc:409

G4MuPairProduction
Definition: G4MuPairProduction.hh:74

GeV
static constexpr double GeV
Definition: G4SIunits.hh:217

G4VMultipleScattering::AddEmModel
void AddEmModel(G4int order, G4VEmModel *, const G4Region *region=nullptr)
Definition: G4VMultipleScattering.cc:144

G4EmParameters::ActivateAngularGeneratorForIonisation
void ActivateAngularGeneratorForIonisation(G4bool val)
Definition: G4EmParameters.cc:324

G4UniversalFluctuation
Definition: G4UniversalFluctuation.hh:64

G4MuonMinus::MuonMinus
static G4MuonMinus * MuonMinus()
Definition: G4MuonMinus.cc:100

G4Electron::Electron
static G4Electron * Electron()
Definition: G4Electron.cc:94

G4eBremsstrahlung.hh

G4endl
#define G4endl
Definition: G4ios.hh:61

MeV
static constexpr double MeV
Definition: G4SIunits.hh:214

G4eplusAnnihilation
Definition: G4eplusAnnihilation.hh:65

G4eMultipleScattering
Definition: G4eMultipleScattering.hh:60

G4RayleighScattering
Definition: G4RayleighScattering.hh:51

G4hMultipleScattering
Definition: G4hMultipleScattering.hh:62

G4MuonPlus.hh

G4Alpha::Alpha
static G4Alpha * Alpha()
Definition: G4Alpha.cc:89

G4VEmProcess::SetMinKinEnergy
void SetMinKinEnergy(G4double e)
Definition: G4VEmProcess.cc:1207

G4PhysicsListHelper
Definition: G4PhysicsListHelper.hh:50

G4double
double G4double
Definition: G4Types.hh:76

G4SystemOfUnits.hh

G4VEmModel::SetLowEnergyLimit
void SetLowEnergyLimit(G4double)
Definition: G4VEmModel.hh:739

G4EmStandardPhysics_option4::ConstructParticle
virtual void ConstructParticle()
Definition: G4EmStandardPhysics_option4.cc:149

G4He3::He3
static G4He3 * He3()
Definition: G4He3.cc:94

G4UrbanMscModel
Definition: G4UrbanMscModel.hh:72

G4LossTableManager::SetAtomDeexcitation
void SetAtomDeexcitation(G4VAtomDeexcitation *)
Definition: G4LossTableManager.cc:990

G4VPhysicsConstructor::SetPhysicsType
void SetPhysicsType(G4int)
Definition: G4VPhysicsConstructor.hh:200

G4VPhysicsConstructor
Definition: G4VPhysicsConstructor.hh:121

G4WentzelVIModel
Definition: G4WentzelVIModel.hh:66

G4hIonisation
Definition: G4hIonisation.hh:85

G4KleinNishinaModel.hh

G4EmParameters::SetFluo
void SetFluo(G4bool val)
Definition: G4EmParameters.cc:222

G4Gamma.hh

G4LivermorePhotoElectricModel.hh

G4_DECLARE_PHYSCONSTR_FACTORY
#define G4_DECLARE_PHYSCONSTR_FACTORY(physics_constructor)
Definition: G4PhysicsConstructorFactory.hh:60

G4String
Definition: G4String.hh:45