G4EmLivermorePhysics Class Reference

#include <G4EmLivermorePhysics.hh>

Inheritance diagram for G4EmLivermorePhysics:

G4VPhysicsConstructor

Public Member Functions

 G4EmLivermorePhysics (G4int ver=1)
 G4EmLivermorePhysics (G4int ver, const G4String &name)
virtual ~G4EmLivermorePhysics ()
virtual void ConstructParticle ()
virtual void ConstructProcess ()

Detailed Description

Definition at line 36 of file G4EmLivermorePhysics.hh.

Constructor & Destructor Documentation

G4EmLivermorePhysics::G4EmLivermorePhysics ( G4int  ver = 1  ) 

Definition at line 128 of file G4EmLivermorePhysics.cc.

References bElectromagnetic, G4LossTableManager::Instance(), and G4VPhysicsConstructor::SetPhysicsType().

00129   : G4VPhysicsConstructor("G4EmLivermorePhysics"), verbose(ver)
00130 {
00131   G4LossTableManager::Instance();
00132   SetPhysicsType(bElectromagnetic);
00133 }

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

Definition at line 137 of file G4EmLivermorePhysics.cc.

References bElectromagnetic, G4LossTableManager::Instance(), and G4VPhysicsConstructor::SetPhysicsType().

00138   : G4VPhysicsConstructor("G4EmLivermorePhysics"), verbose(ver)
00139 {
00140   G4LossTableManager::Instance();
00141   SetPhysicsType(bElectromagnetic);
00142 }

G4EmLivermorePhysics::~G4EmLivermorePhysics (  )  [virtual]

Definition at line 146 of file G4EmLivermorePhysics.cc.

00147 {}

Member Function Documentation

void G4EmLivermorePhysics::ConstructParticle (  )  [virtual]

Implements G4VPhysicsConstructor.

Definition at line 151 of file G4EmLivermorePhysics.cc.

References G4Alpha::Alpha(), G4AntiProton::AntiProton(), G4Deuteron::Deuteron(), G4Electron::Electron(), G4Gamma::Gamma(), G4GenericIon::GenericIonDefinition(), G4He3::He3(), G4KaonMinus::KaonMinusDefinition(), G4KaonPlus::KaonPlusDefinition(), G4MuonMinus::MuonMinus(), G4MuonPlus::MuonPlus(), G4PionMinus::PionMinusDefinition(), G4PionPlus::PionPlusDefinition(), G4Positron::Positron(), G4Proton::Proton(), and G4Triton::Triton().

00152 {
00153 // gamma
00154   G4Gamma::Gamma();
00155 
00156 // leptons
00157   G4Electron::Electron();
00158   G4Positron::Positron();
00159   G4MuonPlus::MuonPlus();
00160   G4MuonMinus::MuonMinus();
00161 
00162 // mesons
00163   G4PionPlus::PionPlusDefinition();
00164   G4PionMinus::PionMinusDefinition();
00165   G4KaonPlus::KaonPlusDefinition();
00166   G4KaonMinus::KaonMinusDefinition();
00167 
00168 // baryons
00169   G4Proton::Proton();
00170   G4AntiProton::AntiProton();
00171 
00172 // ions
00173   G4Deuteron::Deuteron();
00174   G4Triton::Triton();
00175   G4He3::He3();
00176   G4Alpha::Alpha();
00177   G4GenericIon::GenericIonDefinition();
00178 }

void G4EmLivermorePhysics::ConstructProcess (  )  [virtual]

Implements G4VPhysicsConstructor.

Definition at line 182 of file G4EmLivermorePhysics.cc.

References G4VEnergyLossProcess::AddEmModel(), G4VMultipleScattering::AddEmModel(), fUseDistanceToBoundary, G4cout, G4endl, G4ParticleDefinition::GetParticleName(), G4PhysicsListHelper::GetPhysicsListHelper(), G4VPhysicsConstructor::GetPhysicsName(), G4LossTableManager::Instance(), G4INCL::Math::pi, G4InuclParticleNames::pip, G4InuclParticleNames::pp, G4PhysicsListHelper::RegisterProcess(), G4ParticleTableIterator< K, V >::reset(), G4VEmModel::SetActivationLowEnergyLimit(), G4LossTableManager::SetAtomDeexcitation(), G4EmProcessOptions::SetDEDXBinning(), G4VEnergyLossProcess::SetEmModel(), G4VEmProcess::SetEmModel(), G4VAtomDeexcitation::SetFluo(), G4VEmModel::SetHighEnergyLimit(), G4EmProcessOptions::SetLambdaBinning(), G4VEmModel::SetLowEnergyLimit(), G4EmProcessOptions::SetMaxEnergy(), G4VEmProcess::SetMaxKinEnergy(), G4EmProcessOptions::SetMinEnergy(), G4VEmProcess::SetMinKinEnergy(), G4EmProcessOptions::SetPolarAngleLimit(), G4VEnergyLossProcess::SetStepFunction(), G4VMultipleScattering::SetStepLimitType(), G4EmProcessOptions::SetVerbose(), G4VPhysicsConstructor::theParticleIterator, and G4ParticleTableIterator< K, V >::value().

00183 {
00184   G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
00185 
00186   // muon & hadron bremsstrahlung and pair production
00187   G4MuBremsstrahlung* mub = new G4MuBremsstrahlung();
00188   G4MuPairProduction* mup = new G4MuPairProduction();
00189   G4hBremsstrahlung* pib = new G4hBremsstrahlung();
00190   G4hPairProduction* pip = new G4hPairProduction();
00191   G4hBremsstrahlung* kb = new G4hBremsstrahlung();
00192   G4hPairProduction* kp = new G4hPairProduction();
00193   G4hBremsstrahlung* pb = new G4hBremsstrahlung();
00194   G4hPairProduction* pp = new G4hPairProduction();
00195 
00196   // muon & hadron multiple scattering
00197   G4MuMultipleScattering* mumsc = new G4MuMultipleScattering();
00198   mumsc->AddEmModel(0, new G4WentzelVIModel());
00199   G4hMultipleScattering* pimsc = new G4hMultipleScattering();
00200   pimsc->AddEmModel(0, new G4WentzelVIModel());
00201   G4hMultipleScattering* kmsc = new G4hMultipleScattering();
00202   kmsc->AddEmModel(0, new G4WentzelVIModel());
00203   G4hMultipleScattering* pmsc = new G4hMultipleScattering();
00204   pmsc->AddEmModel(0, new G4WentzelVIModel());
00205   G4hMultipleScattering* hmsc = new G4hMultipleScattering("ionmsc");
00206 
00207   // high energy limit for e+- scattering models
00208   G4double highEnergyLimit = 100*MeV;
00209 
00210   // nuclear stopping
00211   G4NuclearStopping* ionnuc = new G4NuclearStopping();
00212   G4NuclearStopping* pnuc = new G4NuclearStopping();
00213 
00214   // Add Livermore EM Processes
00215   theParticleIterator->reset();
00216 
00217   while( (*theParticleIterator)() ){
00218   
00219     G4ParticleDefinition* particle = theParticleIterator->value();
00220     G4String particleName = particle->GetParticleName();
00221     
00222     if(verbose > 1)
00223       G4cout << "### " << GetPhysicsName() << " instantiates for " 
00224              << particleName << G4endl;
00225 
00226     //Applicability range for Livermore models
00227     //for higher energies, the Standard models are used   
00228     G4double LivermoreHighEnergyLimit = GeV;
00229 
00230     if (particleName == "gamma") {
00231 
00232       // Photoelectric effect - define low-energy model
00233       G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
00234       G4LivermorePhotoElectricModel* theLivermorePhotoElectricModel = 
00235         new G4LivermorePhotoElectricModel();
00236       thePhotoElectricEffect->SetEmModel(theLivermorePhotoElectricModel);
00237       ph->RegisterProcess(thePhotoElectricEffect, particle);
00238 
00239       // Compton scattering - define low-energy model
00240       G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
00241       G4LivermoreComptonModel* theLivermoreComptonModel = 
00242         new G4LivermoreComptonModel();
00243       theLivermoreComptonModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
00244       theComptonScattering->SetEmModel(theLivermoreComptonModel, 1);
00245       ph->RegisterProcess(theComptonScattering, particle);
00246 
00247       // gamma conversion - define low-energy model
00248       G4GammaConversion* theGammaConversion = new G4GammaConversion();
00249       G4VEmModel* theLivermoreGammaConversionModel = 
00250         new G4LivermoreGammaConversionModel();
00251       theGammaConversion->SetEmModel(theLivermoreGammaConversionModel, 1);
00252       ph->RegisterProcess(theGammaConversion, particle);
00253 
00254       // default Rayleigh scattering is Livermore
00255       G4RayleighScattering* theRayleigh = new G4RayleighScattering();
00256       ph->RegisterProcess(theRayleigh, particle);
00257 
00258     } else if (particleName == "e-") {
00259 
00260       // multiple scattering
00261       G4eMultipleScattering* msc = new G4eMultipleScattering;
00262       msc->SetStepLimitType(fUseDistanceToBoundary);
00263       G4UrbanMscModel95* msc1 = new G4UrbanMscModel95();
00264       G4WentzelVIModel* msc2 = new G4WentzelVIModel();
00265       msc1->SetHighEnergyLimit(highEnergyLimit);
00266       msc2->SetLowEnergyLimit(highEnergyLimit);
00267       msc->AddEmModel(0, msc1);
00268       msc->AddEmModel(0, msc2);
00269 
00270       G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel(); 
00271       G4CoulombScattering* ss = new G4CoulombScattering();
00272       ss->SetEmModel(ssm, 1); 
00273       ss->SetMinKinEnergy(highEnergyLimit);
00274       ssm->SetLowEnergyLimit(highEnergyLimit);
00275       ssm->SetActivationLowEnergyLimit(highEnergyLimit);
00276       ph->RegisterProcess(msc, particle);
00277       ph->RegisterProcess(ss, particle);
00278       
00279       // Ionisation - Livermore should be used only for low energies
00280       G4eIonisation* eIoni = new G4eIonisation();
00281       G4LivermoreIonisationModel* theIoniLivermore = new
00282         G4LivermoreIonisationModel();
00283       theIoniLivermore->SetHighEnergyLimit(0.1*MeV); 
00284       eIoni->AddEmModel(0, theIoniLivermore, new G4UniversalFluctuation() );
00285       eIoni->SetStepFunction(0.2, 100*um); //     
00286       ph->RegisterProcess(eIoni, particle);
00287       
00288       // Bremsstrahlung
00289       G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();
00290       G4VEmModel* theBremLivermore = new G4LivermoreBremsstrahlungModel();
00291       theBremLivermore->SetHighEnergyLimit(1*GeV);
00292       //theBremLivermore->SetAngularDistribution(new G4Generator2BS());
00293       eBrem->SetEmModel(theBremLivermore,1);
00294      
00295       ph->RegisterProcess(eBrem, particle);
00296 
00297     } else if (particleName == "e+") {
00298 
00299       // Identical to G4EmStandardPhysics_option3
00300       
00301       // multiple scattering
00302       G4eMultipleScattering* msc = new G4eMultipleScattering;
00303       msc->SetStepLimitType(fUseDistanceToBoundary);
00304       G4UrbanMscModel95* msc1 = new G4UrbanMscModel95();
00305       G4WentzelVIModel* msc2 = new G4WentzelVIModel();
00306       msc1->SetHighEnergyLimit(highEnergyLimit);
00307       msc2->SetLowEnergyLimit(highEnergyLimit);
00308       msc->AddEmModel(0, msc1);
00309       msc->AddEmModel(0, msc2);
00310 
00311       G4eCoulombScatteringModel* ssm = new G4eCoulombScatteringModel(); 
00312       G4CoulombScattering* ss = new G4CoulombScattering();
00313       ss->SetEmModel(ssm, 1); 
00314       ss->SetMinKinEnergy(highEnergyLimit);
00315       ssm->SetLowEnergyLimit(highEnergyLimit);
00316       ssm->SetActivationLowEnergyLimit(highEnergyLimit);
00317 
00318       G4eIonisation* eIoni = new G4eIonisation();
00319       eIoni->SetStepFunction(0.2, 100*um);      
00320 
00321       ph->RegisterProcess(msc, particle);
00322       ph->RegisterProcess(eIoni, particle);
00323       ph->RegisterProcess(new G4eBremsstrahlung(), particle);
00324       ph->RegisterProcess(new G4eplusAnnihilation(), particle);
00325       ph->RegisterProcess(ss, particle);
00326 
00327     } else if (particleName == "mu+" ||
00328                particleName == "mu-"    ) {
00329 
00330       G4MuIonisation* muIoni = new G4MuIonisation();
00331       muIoni->SetStepFunction(0.2, 50*um);          
00332 
00333       ph->RegisterProcess(mumsc, particle);
00334       ph->RegisterProcess(muIoni, particle);
00335       ph->RegisterProcess(mub, particle);
00336       ph->RegisterProcess(mup, particle);
00337       ph->RegisterProcess(new G4CoulombScattering(), particle);
00338 
00339     } else if (particleName == "alpha" ||
00340                particleName == "He3" ) {
00341 
00342       // Identical to G4EmStandardPhysics_option3
00343       
00344       G4hMultipleScattering* msc = new G4hMultipleScattering();
00345       G4ionIonisation* ionIoni = new G4ionIonisation();
00346       ionIoni->SetStepFunction(0.1, 10*um);
00347 
00348       ph->RegisterProcess(msc, particle);
00349       ph->RegisterProcess(ionIoni, particle);
00350       ph->RegisterProcess(ionnuc, particle);
00351 
00352     } else if (particleName == "GenericIon") {
00353 
00354       // Identical to G4EmStandardPhysics_option3
00355       
00356       G4ionIonisation* ionIoni = new G4ionIonisation();
00357       ionIoni->SetEmModel(new G4IonParametrisedLossModel());
00358       ionIoni->SetStepFunction(0.1, 1*um);
00359 
00360       ph->RegisterProcess(hmsc, particle);
00361       ph->RegisterProcess(ionIoni, particle);
00362       ph->RegisterProcess(ionnuc, particle);
00363 
00364     } else if (particleName == "pi+" ||
00365                particleName == "pi-" ) {
00366 
00367       //G4hMultipleScattering* pimsc = new G4hMultipleScattering();
00368       G4hIonisation* hIoni = new G4hIonisation();
00369       hIoni->SetStepFunction(0.2, 50*um);
00370 
00371       ph->RegisterProcess(pimsc, particle);
00372       ph->RegisterProcess(hIoni, particle);
00373       ph->RegisterProcess(pib, particle);
00374       ph->RegisterProcess(pip, particle);
00375 
00376     } else if (particleName == "kaon+" ||
00377                particleName == "kaon-" ) {
00378 
00379       //G4hMultipleScattering* kmsc = new G4hMultipleScattering();
00380       G4hIonisation* hIoni = new G4hIonisation();
00381       hIoni->SetStepFunction(0.2, 50*um);
00382 
00383       ph->RegisterProcess(kmsc, particle);
00384       ph->RegisterProcess(hIoni, particle);
00385       ph->RegisterProcess(kb, particle);
00386       ph->RegisterProcess(kp, particle);
00387 
00388     } else if (particleName == "proton" ||
00389                particleName == "anti_proton") {
00390 
00391       //G4hMultipleScattering* pmsc = new G4hMultipleScattering();
00392       G4hIonisation* hIoni = new G4hIonisation();
00393       hIoni->SetStepFunction(0.2, 50*um);
00394 
00395       ph->RegisterProcess(pmsc, particle);
00396       ph->RegisterProcess(hIoni, particle);
00397       ph->RegisterProcess(pb, particle);
00398       ph->RegisterProcess(pp, particle);
00399       ph->RegisterProcess(pnuc, particle);
00400 
00401     } else if (particleName == "B+" ||
00402                particleName == "B-" ||
00403                particleName == "D+" ||
00404                particleName == "D-" ||
00405                particleName == "Ds+" ||
00406                particleName == "Ds-" ||
00407                particleName == "anti_He3" ||
00408                particleName == "anti_alpha" ||
00409                particleName == "anti_deuteron" ||
00410                particleName == "anti_lambda_c+" ||
00411                particleName == "anti_omega-" ||
00412                particleName == "anti_sigma_c+" ||
00413                particleName == "anti_sigma_c++" ||
00414                particleName == "anti_sigma+" ||
00415                particleName == "anti_sigma-" ||
00416                particleName == "anti_triton" ||
00417                particleName == "anti_xi_c+" ||
00418                particleName == "anti_xi-" ||
00419                particleName == "deuteron" ||
00420                particleName == "lambda_c+" ||
00421                particleName == "omega-" ||
00422                particleName == "sigma_c+" ||
00423                particleName == "sigma_c++" ||
00424                particleName == "sigma+" ||
00425                particleName == "sigma-" ||
00426                particleName == "tau+" ||
00427                particleName == "tau-" ||
00428                particleName == "triton" ||
00429                particleName == "xi_c+" ||
00430                particleName == "xi-" ) {
00431 
00432       // Identical to G4EmStandardPhysics_option3
00433       
00434       ph->RegisterProcess(hmsc, particle);
00435       ph->RegisterProcess(new G4hIonisation(), particle);
00436       ph->RegisterProcess(pnuc, particle);
00437     }
00438   }
00439     
00440   // Em options
00441   //      
00442   G4EmProcessOptions opt;
00443   opt.SetVerbose(verbose);
00444   
00445   // Multiple Coulomb scattering
00446   //
00447   opt.SetPolarAngleLimit(CLHEP::pi);
00448     
00449   // Physics tables
00450   //
00451 
00452   opt.SetMinEnergy(100*eV);
00453   opt.SetMaxEnergy(10*TeV);
00454   opt.SetDEDXBinning(220);
00455   opt.SetLambdaBinning(220);
00456 
00457   // Nuclear stopping
00458   pnuc->SetMaxKinEnergy(MeV);
00459 
00460   // Ionization
00461   //
00462   //opt.SetSubCutoff(true);    
00463 
00464   // Deexcitation
00465   //
00466   G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
00467   G4LossTableManager::Instance()->SetAtomDeexcitation(de);
00468   de->SetFluo(true);
00469 }

The documentation for this class was generated from the following files:
Generated on Mon May 27 17:51:53 2013 for Geant4 by  doxygen 1.4.7