Geant4  10.03.p03
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
PhysListEmStandardNR Class Reference

#include <PhysListEmStandardNR.hh>

Inheritance diagram for PhysListEmStandardNR:
Collaboration diagram for PhysListEmStandardNR:

Public Member Functions

 PhysListEmStandardNR (const G4String &name="standardNR")
 
 ~PhysListEmStandardNR ()
 
virtual void ConstructParticle ()
 
virtual void ConstructProcess ()
 
- Public Member Functions inherited from G4VPhysicsConstructor
 G4VPhysicsConstructor (const G4String &="")
 
 G4VPhysicsConstructor (const G4String &name, G4int physics_type)
 
virtual ~G4VPhysicsConstructor ()
 
void SetPhysicsName (const G4String &="")
 
const G4StringGetPhysicsName () const
 
void SetPhysicsType (G4int)
 
G4int GetPhysicsType () const
 
void SetVerboseLevel (G4int value)
 
G4int GetVerboseLevel () const
 
G4int GetInstanceID () const
 

Additional Inherited Members

- Static Public Member Functions inherited from G4VPhysicsConstructor
static const G4VPCManagerGetSubInstanceManager ()
 
- Protected Member Functions inherited from G4VPhysicsConstructor
G4bool RegisterProcess (G4VProcess *process, G4ParticleDefinition *particle)
 
G4ParticleTable::G4PTblDicIteratorGetParticleIterator () const
 
- Protected Attributes inherited from G4VPhysicsConstructor
G4int verboseLevel
 
G4String namePhysics
 
G4int typePhysics
 
G4ParticleTabletheParticleTable
 
G4int g4vpcInstanceID
 
- Static Protected Attributes inherited from G4VPhysicsConstructor
static G4RUN_DLL G4VPCManager subInstanceManager
 

Detailed Description

Definition at line 42 of file PhysListEmStandardNR.hh.

Constructor & Destructor Documentation

PhysListEmStandardNR::PhysListEmStandardNR ( const G4String name = "standardNR")

Definition at line 83 of file PhysListEmStandardNR.cc.

84  : G4VPhysicsConstructor(name)
85 {
88 }
static G4LossTableManager * Instance()
G4VPhysicsConstructor(const G4String &="")

Here is the call graph for this function:

PhysListEmStandardNR::~PhysListEmStandardNR ( )

Definition at line 92 of file PhysListEmStandardNR.cc.

93 {}

Member Function Documentation

virtual void PhysListEmStandardNR::ConstructParticle ( void  )
inlinevirtual

Implements G4VPhysicsConstructor.

Definition at line 50 of file PhysListEmStandardNR.hh.

50 {};
void PhysListEmStandardNR::ConstructProcess ( void  )
virtual

Implements G4VPhysicsConstructor.

Definition at line 97 of file PhysListEmStandardNR.cc.

98 {
100 
101  // muon & hadron bremsstrahlung and pair production
104 
106  G4double energyLimit = 100.*MeV;
107  nucr->SetMaxEnergyForScattering(energyLimit);
109  csm->SetActivationLowEnergyLimit(energyLimit);
110 
112  particleIterator->reset();
113  while( (*particleIterator)() ){
114  G4ParticleDefinition* particle = particleIterator->value();
115  G4String particleName = particle->GetParticleName();
116 
117  if (particleName == "gamma") {
118 
119  // Compton scattering
121  cs->SetEmModel(new G4KleinNishinaModel(),1);
122  ph->RegisterProcess(cs, particle);
123 
124  // Photoelectric
126  G4VEmModel* theLivermorePEModel = new G4LivermorePhotoElectricModel();
127  theLivermorePEModel->SetHighEnergyLimit(10*GeV);
128  pe->SetEmModel(theLivermorePEModel,1);
129  ph->RegisterProcess(pe, particle);
130 
131  // Gamma conversion
133  G4VEmModel* thePenelopeGCModel = new G4PenelopeGammaConversionModel();
134  thePenelopeGCModel->SetHighEnergyLimit(1*GeV);
135  gc->SetEmModel(thePenelopeGCModel,1);
136  ph->RegisterProcess(gc, particle);
137 
138  // Rayleigh scattering
139  ph->RegisterProcess(new G4RayleighScattering(), particle);
140 
141  } else if (particleName == "e-") {
142 
143  // ionisation
144  G4eIonisation* eIoni = new G4eIonisation();
145  eIoni->SetStepFunction(0.2, 100*um);
146 
147  // bremsstrahlung
148  G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();
149 
150  ph->RegisterProcess(new G4eMultipleScattering(), particle);
151  ph->RegisterProcess(eIoni, particle);
152  ph->RegisterProcess(eBrem, particle);
153 
154  } else if (particleName == "e+") {
155  // ionisation
156  G4eIonisation* eIoni = new G4eIonisation();
157  eIoni->SetStepFunction(0.2, 100*um);
158 
159  // bremsstrahlung
160  G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();
161 
162  ph->RegisterProcess(new G4eMultipleScattering(), particle);
163  ph->RegisterProcess(eIoni, particle);
164  ph->RegisterProcess(eBrem, particle);
165 
166  // annihilation at rest and in flight
167  ph->RegisterProcess(new G4eplusAnnihilation(), particle);
168 
169  } else if (particleName == "mu+" ||
170  particleName == "mu-" ) {
171 
172  G4MuIonisation* muIoni = new G4MuIonisation();
173  muIoni->SetStepFunction(0.2, 50*um);
174 
175  ph->RegisterProcess(muIoni, particle);
176  ph->RegisterProcess(mub, particle);
177  ph->RegisterProcess(mup, particle);
178  ph->RegisterProcess(new G4CoulombScattering(), particle);
179 
180  } else if (particleName == "alpha" || particleName == "He3") {
181 
184  model->SetActivationLowEnergyLimit(energyLimit);
185  msc->SetEmModel(model, 1);
186  ph->RegisterProcess(msc, particle);
187 
188  G4ionIonisation* ionIoni = new G4ionIonisation();
189  ionIoni->SetStepFunction(0.1, 10*um);
190  ph->RegisterProcess(ionIoni, particle);
191 
192  ph->RegisterProcess(nucr, particle);
193 
194  } else if (particleName == "GenericIon" ) {
195 
197  G4UrbanMscModel* model = new G4UrbanMscModel();
198  model->SetActivationLowEnergyLimit(energyLimit);
199  msc->SetEmModel(model, 1);
200  ph->RegisterProcess(msc, particle);
201 
202  G4ionIonisation* ionIoni = new G4ionIonisation();
203  ionIoni->SetEmModel(new G4IonParametrisedLossModel());
204  ionIoni->SetStepFunction(0.1, 1*um);
205  ph->RegisterProcess(ionIoni, particle);
206 
207  ph->RegisterProcess(nucr, particle);
208 
209  } else if (particleName == "proton" ||
210  particleName == "deuteron" ||
211  particleName == "triton") {
212 
214  G4UrbanMscModel* model = new G4UrbanMscModel();
215  model->SetActivationLowEnergyLimit(energyLimit);
216  msc->SetEmModel(model, 1);
217  ph->RegisterProcess(msc, particle);
218 
219  G4hIonisation* hIoni = new G4hIonisation();
220  hIoni->SetStepFunction(0.05, 1*um);
221  ph->RegisterProcess(hIoni, particle);
222 
223  ph->RegisterProcess(nucr, particle);
224 
225  } else if ((!particle->IsShortLived()) &&
226  (particle->GetPDGCharge() != 0.0) &&
227  (particle->GetParticleName() != "chargedgeantino")) {
228  //all others charged particles except geantino
229 
230  ph->RegisterProcess(new G4hMultipleScattering(), particle);
231  ph->RegisterProcess(new G4hIonisation(), particle);
232  }
233  }
234 
235  // Em options
236  //
237  // Main options and setting parameters are shown here.
238  // Several of them have default values.
239  //
240  G4EmProcessOptions emOptions;
241 
242  //physics tables
243  //
244  emOptions.SetMinEnergy(10*eV);
245  emOptions.SetMaxEnergy(10*TeV);
246  emOptions.SetDEDXBinning(12*20);
247  emOptions.SetLambdaBinning(12*20);
248 
249  // scattering
250  emOptions.SetPolarAngleLimit(0.0);
251 
252  // Deexcitation
255  de->SetFluo(true);
256 }
static G4LossTableManager * Instance()
void SetMinEnergy(G4double val)
void SetEmModel(G4VMscModel *, G4int index=1)
void SetStepFunction(G4double v1, G4double v2, G4bool lock=true)
const G4String & GetParticleName() const
void SetHighEnergyLimit(G4double)
Definition: G4VEmModel.hh:732
static constexpr double TeV
Definition: G4SIunits.hh:218
void SetDEDXBinning(G4int val)
G4ParticleTable::G4PTblDicIterator * GetParticleIterator() const
void SetEmModel(G4VEmModel *, G4int index=1)
static constexpr double um
Definition: G4SIunits.hh:113
void SetLambdaBinning(G4int val)
G4bool RegisterProcess(G4VProcess *process, G4ParticleDefinition *particle)
static constexpr double eV
Definition: G4SIunits.hh:215
void SetMaxEnergyForScattering(G4double energy)
set the upper energy beyond which this process has no cross section
void SetMaxEnergy(G4double val)
void SetActivationLowEnergyLimit(G4double)
Definition: G4VEmModel.hh:753
static G4PhysicsListHelper * GetPhysicsListHelper()
void SetEmModel(G4VEmModel *, G4int index=1)
static constexpr double GeV
Definition: G4SIunits.hh:217
std::vector< G4InuclElementaryParticle >::iterator particleIterator
Definition: G4BigBanger.cc:65
static constexpr double MeV
Definition: G4SIunits.hh:214
double G4double
Definition: G4Types.hh:76
G4double GetPDGCharge() const
A process which handles screened Coulomb collisions between nuclei.
const XML_Char XML_Content * model
Definition: expat.h:151
void SetAtomDeexcitation(G4VAtomDeexcitation *)
void SetPolarAngleLimit(G4double val)

Here is the call graph for this function:


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