G4EmLivermorePolarizedPhysics Class Reference

#include <G4EmLivermorePolarizedPhysics.hh>

Inheritance diagram for G4EmLivermorePolarizedPhysics:

G4VPhysicsConstructor

Public Member Functions

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

Detailed Description

Definition at line 36 of file G4EmLivermorePolarizedPhysics.hh.

Constructor & Destructor Documentation

G4EmLivermorePolarizedPhysics::G4EmLivermorePolarizedPhysics ( G4int  ver = 1  ) 

Definition at line 126 of file G4EmLivermorePolarizedPhysics.cc.

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

00127   : G4VPhysicsConstructor("G4EmLivermorePolarizedPhysics"), verbose(ver)
00128 {
00129   G4LossTableManager::Instance();
00130   SetPhysicsType(bElectromagnetic);
00131 }

G4EmLivermorePolarizedPhysics::G4EmLivermorePolarizedPhysics ( G4int  ver,
const G4String &   
)

Definition at line 135 of file G4EmLivermorePolarizedPhysics.cc.

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

00136   : G4VPhysicsConstructor("G4EmLivermorePolarizedPhysics"), verbose(ver)
00137 {
00138   G4LossTableManager::Instance();
00139   SetPhysicsType(bElectromagnetic);
00140 }

G4EmLivermorePolarizedPhysics::~G4EmLivermorePolarizedPhysics (  )  [virtual]

Definition at line 144 of file G4EmLivermorePolarizedPhysics.cc.

00145 {}

Member Function Documentation

void G4EmLivermorePolarizedPhysics::ConstructParticle (  )  [virtual]

Implements G4VPhysicsConstructor.

Definition at line 149 of file G4EmLivermorePolarizedPhysics.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().

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

void G4EmLivermorePolarizedPhysics::ConstructProcess (  )  [virtual]

Implements G4VPhysicsConstructor.

Definition at line 180 of file G4EmLivermorePolarizedPhysics.cc.

References G4VEnergyLossProcess::AddEmModel(), G4VEmProcess::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().

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

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