G4EmLivermorePhysics Class Reference

#include <G4EmLivermorePhysics.hh>

Inheritance diagram for G4EmLivermorePhysics:

Public Member Functions
	G4EmLivermorePhysics (G4int ver=1)
	G4EmLivermorePhysics (G4int ver, const G4String &name)
virtual	~G4EmLivermorePhysics ()
virtual void	ConstructParticle ()
virtual void	ConstructProcess ()
Public Member Functions inherited from G4VPhysicsConstructor
	G4VPhysicsConstructor (const G4String &="")
	G4VPhysicsConstructor (const G4String &name, G4int physics_type)
virtual	~G4VPhysicsConstructor ()
virtual void	ConstructParticle ()=0
virtual void	ConstructProcess ()=0
void	SetPhysicsName (const G4String &="")
const G4String &	GetPhysicsName () const
void	SetPhysicsType (G4int)
G4int	GetPhysicsType () const
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel () const

Additional Inherited Members
Protected Member Functions inherited from G4VPhysicsConstructor
G4bool	RegisterProcess (G4VProcess *process, G4ParticleDefinition *particle)
Protected Attributes inherited from G4VPhysicsConstructor
G4int	verboseLevel
G4String	namePhysics
G4int	typePhysics
G4ParticleTable *	theParticleTable
G4ParticleTable::G4PTblDicIterator *	theParticleIterator
G4PhysicsListHelper *	thePLHelper

Detailed Description

Definition at line 36 of file G4EmLivermorePhysics.hh.

Constructor & Destructor Documentation

G4EmLivermorePhysics() [1/2]

G4EmLivermorePhysics::G4EmLivermorePhysics

(

G4int

ver = 1

)

Definition at line 128 of file G4EmLivermorePhysics.cc.

  : G4VPhysicsConstructor("G4EmLivermorePhysics"), verbose(ver)
{
  G4LossTableManager::Instance();
  SetPhysicsType(bElectromagnetic);
}

G4EmLivermorePhysics() [2/2]

G4EmLivermorePhysics::G4EmLivermorePhysics	(	G4int	ver,
		const G4String &	name
	)

Definition at line 137 of file G4EmLivermorePhysics.cc.

  : G4VPhysicsConstructor("G4EmLivermorePhysics"), verbose(ver)
{
  G4LossTableManager::Instance();
  SetPhysicsType(bElectromagnetic);
}

~G4EmLivermorePhysics()

G4EmLivermorePhysics::~G4EmLivermorePhysics ( )

virtual

Definition at line 146 of file G4EmLivermorePhysics.cc.

{}

Member Function Documentation

ConstructParticle()

void G4EmLivermorePhysics::ConstructParticle ( )

virtual

Implements G4VPhysicsConstructor.

Definition at line 151 of file G4EmLivermorePhysics.cc.

{
// gamma
  G4Gamma::Gamma();
 
// leptons
  G4Electron::Electron();
  G4Positron::Positron();
  G4MuonPlus::MuonPlus();
  G4MuonMinus::MuonMinus();
 
// mesons
  G4PionPlus::PionPlusDefinition();
  G4PionMinus::PionMinusDefinition();
  G4KaonPlus::KaonPlusDefinition();
  G4KaonMinus::KaonMinusDefinition();
 
// baryons
  G4Proton::Proton();
  G4AntiProton::AntiProton();
 
// ions
  G4Deuteron::Deuteron();
  G4Triton::Triton();
  G4He3::He3();
  G4Alpha::Alpha();
  G4GenericIon::GenericIonDefinition();
}

ConstructProcess()

void G4EmLivermorePhysics::ConstructProcess ( )

virtual

Implements G4VPhysicsConstructor.

Definition at line 182 of file G4EmLivermorePhysics.cc.

{
  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();
 
  // muon & hadron multiple scattering
  G4MuMultipleScattering* mumsc = new G4MuMultipleScattering();
  mumsc->AddEmModel(0, new G4WentzelVIModel());
  G4hMultipleScattering* pimsc = new G4hMultipleScattering();
  pimsc->AddEmModel(0, new G4WentzelVIModel());
  G4hMultipleScattering* kmsc = new G4hMultipleScattering();
  kmsc->AddEmModel(0, new G4WentzelVIModel());
  G4hMultipleScattering* pmsc = new G4hMultipleScattering();
  pmsc->AddEmModel(0, new G4WentzelVIModel());
  G4hMultipleScattering* hmsc = new G4hMultipleScattering("ionmsc");
 
  // high energy limit for e+- scattering models
  G4double highEnergyLimit = 100*MeV;
 
  // nuclear stopping
  G4NuclearStopping* ionnuc = new G4NuclearStopping();
  G4NuclearStopping* pnuc = new G4NuclearStopping();
 
  // Add Livermore EM Processes
  theParticleIterator->reset();
 
  while( (*theParticleIterator)() ){
  
    G4ParticleDefinition* particle = theParticleIterator->value();
    G4String particleName = particle->GetParticleName();
    
    if(verbose > 1)
      G4cout << "### " << GetPhysicsName() << " instantiates for " 
         << particleName << G4endl;
 
    //Applicability range for Livermore models
    //for higher energies, the Standard models are used   
    G4double LivermoreHighEnergyLimit = GeV;
 
    if (particleName == "gamma") {
 
      // Photoelectric effect - define low-energy model
      G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
      G4LivermorePhotoElectricModel* theLivermorePhotoElectricModel = 
    new G4LivermorePhotoElectricModel();
      thePhotoElectricEffect->SetEmModel(theLivermorePhotoElectricModel);
      ph->RegisterProcess(thePhotoElectricEffect, particle);
 
      // Compton scattering - define low-energy model
      G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
      G4LivermoreComptonModel* theLivermoreComptonModel = 
    new G4LivermoreComptonModel();
      theLivermoreComptonModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
      theComptonScattering->SetEmModel(theLivermoreComptonModel, 1);
      ph->RegisterProcess(theComptonScattering, particle);
 
      // gamma conversion - define low-energy model
      G4GammaConversion* theGammaConversion = new G4GammaConversion();
      G4VEmModel* theLivermoreGammaConversionModel = 
    new G4LivermoreGammaConversionModel();
      theGammaConversion->SetEmModel(theLivermoreGammaConversionModel, 1);
      ph->RegisterProcess(theGammaConversion, particle);
 
      // default Rayleigh scattering is Livermore
      G4RayleighScattering* theRayleigh = new G4RayleighScattering();
      ph->RegisterProcess(theRayleigh, particle);
 
    } else if (particleName == "e-") {
 
      // multiple scattering
      G4eMultipleScattering* msc = new G4eMultipleScattering;
      msc->SetStepLimitType(fUseDistanceToBoundary);
      G4UrbanMscModel95* msc1 = new G4UrbanMscModel95();
      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);
      ph->RegisterProcess(msc, particle);
      ph->RegisterProcess(ss, particle);
      
      // Ionisation - Livermore should be used only for low energies
      G4eIonisation* eIoni = new G4eIonisation();
      G4LivermoreIonisationModel* theIoniLivermore = new
        G4LivermoreIonisationModel();
      theIoniLivermore->SetHighEnergyLimit(0.1*MeV); 
      eIoni->AddEmModel(0, theIoniLivermore, new G4UniversalFluctuation() );
      eIoni->SetStepFunction(0.2, 100*um); //     
      ph->RegisterProcess(eIoni, particle);
      
      // Bremsstrahlung
      G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();
      G4VEmModel* theBremLivermore = new G4LivermoreBremsstrahlungModel();
      theBremLivermore->SetHighEnergyLimit(1*GeV);
      //theBremLivermore->SetAngularDistribution(new G4Generator2BS());
      eBrem->SetEmModel(theBremLivermore,1);
     
      ph->RegisterProcess(eBrem, particle);
 
    } else if (particleName == "e+") {
 
      // Identical to G4EmStandardPhysics_option3
      
      // multiple scattering
      G4eMultipleScattering* msc = new G4eMultipleScattering;
      msc->SetStepLimitType(fUseDistanceToBoundary);
      G4UrbanMscModel95* msc1 = new G4UrbanMscModel95();
      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);
 
      G4eIonisation* eIoni = new G4eIonisation();
      eIoni->SetStepFunction(0.2, 100*um);      
 
      ph->RegisterProcess(msc, particle);
      ph->RegisterProcess(eIoni, particle);
      ph->RegisterProcess(new G4eBremsstrahlung(), 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(new G4CoulombScattering(), particle);
 
    } else if (particleName == "alpha" ||
               particleName == "He3" ) {
 
      // Identical to G4EmStandardPhysics_option3
      
      G4hMultipleScattering* msc = new G4hMultipleScattering();
      G4ionIonisation* ionIoni = new G4ionIonisation();
      ionIoni->SetStepFunction(0.1, 10*um);
 
      ph->RegisterProcess(msc, particle);
      ph->RegisterProcess(ionIoni, particle);
      ph->RegisterProcess(ionnuc, particle);
 
    } else if (particleName == "GenericIon") {
 
      // Identical to G4EmStandardPhysics_option3
      
      G4ionIonisation* ionIoni = new G4ionIonisation();
      ionIoni->SetEmModel(new G4IonParametrisedLossModel());
      ionIoni->SetStepFunction(0.1, 1*um);
 
      ph->RegisterProcess(hmsc, particle);
      ph->RegisterProcess(ionIoni, particle);
      ph->RegisterProcess(ionnuc, 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);
 
    } 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);
 
    } else if (particleName == "proton" ||
           particleName == "anti_proton") {
 
      //G4hMultipleScattering* pmsc = new G4hMultipleScattering();
      G4hIonisation* hIoni = new G4hIonisation();
      hIoni->SetStepFunction(0.2, 50*um);
 
      ph->RegisterProcess(pmsc, particle);
      ph->RegisterProcess(hIoni, particle);
      ph->RegisterProcess(pb, particle);
      ph->RegisterProcess(pp, 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-" ) {
 
      // Identical to G4EmStandardPhysics_option3
      
      ph->RegisterProcess(hmsc, particle);
      ph->RegisterProcess(new G4hIonisation(), particle);
      ph->RegisterProcess(pnuc, particle);
    }
  }
    
  // Em options
  //      
  G4EmProcessOptions opt;
  opt.SetVerbose(verbose);
  
  // Multiple Coulomb scattering
  //
  opt.SetPolarAngleLimit(CLHEP::pi);
    
  // Physics tables
  //
 
  opt.SetMinEnergy(10*eV);
  opt.SetMaxEnergy(10*TeV);
  opt.SetDEDXBinning(240);
  opt.SetLambdaBinning(240);
 
  // Nuclear stopping
  pnuc->SetMaxKinEnergy(MeV);
 
  // Ionization
  //
  //opt.SetSubCutoff(true);    
 
  // Deexcitation
  //
  G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
  G4LossTableManager::Instance()->SetAtomDeexcitation(de);
  de->SetFluo(true);
}

---

The documentation for this class was generated from the following files:

• G4EmLivermorePhysics.hh
• G4EmLivermorePhysics.cc