Geant4  10.03.p02
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Public Member Functions | List of all members
ExExChPhysListEmStandardSS Class Reference

#include <ExExChPhysListEmStandardSS.hh>

Inheritance diagram for ExExChPhysListEmStandardSS:
Inheritance graph
[legend]
Collaboration diagram for ExExChPhysListEmStandardSS:
Collaboration graph
[legend]

Public Member Functions

 ExExChPhysListEmStandardSS (const G4String &name="standardSS")
 
 ~ExExChPhysListEmStandardSS ()
 
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 G4String & GetPhysicsName () 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 G4VPCManager & GetSubInstanceManager ()
 
- Protected Member Functions inherited from G4VPhysicsConstructor
G4bool RegisterProcess (G4VProcess *process, G4ParticleDefinition *particle)
 
G4ParticleTable::G4PTblDicIterator * GetParticleIterator () const
 
- Protected Attributes inherited from G4VPhysicsConstructor
G4int verboseLevel
 
G4String namePhysics
 
G4int typePhysics
 
G4ParticleTable * theParticleTable
 
G4int g4vpcInstanceID
 
- Static Protected Attributes inherited from G4VPhysicsConstructor
static G4RUN_DLL G4VPCManager subInstanceManager
 

Detailed Description

Definition at line 38 of file ExExChPhysListEmStandardSS.hh.

Constructor & Destructor Documentation

ExExChPhysListEmStandardSS::ExExChPhysListEmStandardSS ( const G4String &  name = "standardSS")

Definition at line 84 of file ExExChPhysListEmStandardSS.cc.

86 :G4VPhysicsConstructor(name){
87 }
G4VPhysicsConstructor::G4VPhysicsConstructor
G4VPhysicsConstructor(const G4String &="")
Definition: G4VPhysicsConstructor.cc:48
ExExChPhysListEmStandardSS::~ExExChPhysListEmStandardSS ( )

Definition at line 91 of file ExExChPhysListEmStandardSS.cc.

92 {}

Member Function Documentation

virtual void ExExChPhysListEmStandardSS::ConstructParticle ( void  )
inlinevirtual

Implements G4VPhysicsConstructor.

Definition at line 46 of file ExExChPhysListEmStandardSS.hh.

46 {};
void ExExChPhysListEmStandardSS::ConstructProcess ( void  )
virtual

Implements G4VPhysicsConstructor.

Definition at line 96 of file ExExChPhysListEmStandardSS.cc.

97 {
98  G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
99 
100  // Add standard EM Processes
101  //
102  auto particleIterator=GetParticleIterator();
103  particleIterator->reset();
104  while( (*particleIterator)() ){
105  G4ParticleDefinition* particle = particleIterator->value();
106  G4String particleName = particle->GetParticleName();
107 
108  if (particleName == "gamma") {
109  //G4cout << particleName << G4endl;
110  // Compton scattering
111  G4ComptonScattering* cs = new G4ComptonScattering;
112  cs->SetEmModel(new G4KleinNishinaModel(),1);
113  G4VEmModel* theLowEPComptonModel = new G4LowEPComptonModel();
114  theLowEPComptonModel->SetHighEnergyLimit(20*MeV);
115  cs->AddEmModel(0, theLowEPComptonModel);
116  ph->RegisterProcess(cs, particle);
117 
118  // Photoelectric
119  G4PhotoElectricEffect* pe = new G4PhotoElectricEffect();
120  G4VEmModel* theLivermorePEModel =
121  new G4LivermorePhotoElectricModel();
122  theLivermorePEModel->SetHighEnergyLimit(10*GeV);
123  pe->SetEmModel(theLivermorePEModel,1);
124  ph->RegisterProcess(pe, particle);
125 
126  // Gamma conversion
127  G4GammaConversion* gc = new G4GammaConversion();
128  G4VEmModel* thePenelopeGCModel =
129  new G4PenelopeGammaConversionModel();
130  thePenelopeGCModel->SetHighEnergyLimit(1*GeV);
131  gc->SetEmModel(thePenelopeGCModel,1);
132  ph->RegisterProcess(gc, particle);
133 
134  // Rayleigh scattering
135  ph->RegisterProcess(new G4RayleighScattering(), particle);
136  } else if (particleName == "e-") {
137 
138  //G4cout << particleName << G4endl;
139  // ionisation
140  G4eIonisation* eIoni = new G4eIonisation();
141  eIoni->SetStepFunction(0.1, 100*um);
142  G4VEmModel* theIoniPenelope = new G4PenelopeIonisationModel();
143  theIoniPenelope->SetHighEnergyLimit(0.1*MeV);
144  eIoni->AddEmModel(0, theIoniPenelope, new G4UniversalFluctuation());
145 
146  XWrapperContinuousDiscreteProcess *eIoni_wrapper =
147  new XWrapperContinuousDiscreteProcess();
148  eIoni_wrapper->RegisterProcess(eIoni,-1);
149  ph->RegisterProcess(eIoni_wrapper, particle);
150 
151  // bremsstrahlung
152  G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();
153  XWrapperContinuousDiscreteProcess *eBrem_wrapper =
154  new XWrapperContinuousDiscreteProcess();
155  eBrem_wrapper->RegisterProcess(eBrem,-1);
156  ph->RegisterProcess(eBrem_wrapper, particle);
157 
158  // coulomb scattering
159  G4CoulombScattering* ecs = new G4CoulombScattering();
160  ecs->SetBuildTableFlag(false);
161  G4eSingleCoulombScatteringModel* ecsmodel =
162  new G4eSingleCoulombScatteringModel();
163  ecsmodel->SetPolarAngleLimit(0.0);
164  ecs->AddEmModel(0, ecsmodel);
165  XWrapperDiscreteProcess *ecs_wrapper =
166  new XWrapperDiscreteProcess();
167  ecs_wrapper->RegisterProcess(ecs,1,1);
168  ph->RegisterProcess(ecs_wrapper, particle);
169 
170 
171  // multiple scattering
172  G4eMultipleScattering* ems = new G4eMultipleScattering();
173  XWrapperContinuousDiscreteProcess *ems_wrapper =
174  new XWrapperContinuousDiscreteProcess();
175  ems_wrapper->RegisterProcess(ems,0,2);
176  ph->RegisterProcess(ems_wrapper, particle);
177 
178  } else if (particleName == "e+") {
179  //G4cout << particleName << G4endl;
180  // ionisation
181  G4eIonisation* eIoni = new G4eIonisation();
182  eIoni->SetStepFunction(0.2, 100*um);
183  G4VEmModel* theIoniPenelope = new G4PenelopeIonisationModel();
184  theIoniPenelope->SetHighEnergyLimit(0.1*MeV);
185  eIoni->AddEmModel(0, theIoniPenelope, new G4UniversalFluctuation());
186 
187  XWrapperContinuousDiscreteProcess *eIoni_wrapper =
188  new XWrapperContinuousDiscreteProcess();
189  eIoni_wrapper->RegisterProcess(eIoni,-1);
190  ph->RegisterProcess(eIoni_wrapper, particle);
191 
192  // bremsstrahlung
193  G4eBremsstrahlung* eBrem = new G4eBremsstrahlung();
194  XWrapperContinuousDiscreteProcess *eBrem_wrapper =
195  new XWrapperContinuousDiscreteProcess();
196  eBrem_wrapper->RegisterProcess(eBrem,-1);
197  ph->RegisterProcess(eBrem_wrapper, particle);
198 
199  // annihilation at rest and in flight
200  G4eplusAnnihilation* eplusAnn = new G4eplusAnnihilation();
201  XWrapperDiscreteProcess *eplusAnn_wrapper =
202  new XWrapperDiscreteProcess();
203  eplusAnn_wrapper->RegisterProcess(eplusAnn,-1);
204  ph->RegisterProcess(eplusAnn_wrapper, particle);
205 
206  // coulomb scattering
207  G4CoulombScattering* ecs = new G4CoulombScattering();
208  ecs->SetBuildTableFlag(false);
209  G4eSingleCoulombScatteringModel* ecsmodel =
210  new G4eSingleCoulombScatteringModel();
211  ecsmodel->SetPolarAngleLimit(0.0);
212  ecs->AddEmModel(0, ecsmodel);
213  XWrapperDiscreteProcess *ecs_wrapper =
214  new XWrapperDiscreteProcess();
215  ecs_wrapper->RegisterProcess(ecs,1,1);
216  ph->RegisterProcess(ecs_wrapper, particle);
217 
218  // multiple scattering
219  G4eMultipleScattering* ems = new G4eMultipleScattering();
220  XWrapperContinuousDiscreteProcess *ems_wrapper =
221  new XWrapperContinuousDiscreteProcess();
222  ems_wrapper->RegisterProcess(ems,0,2);
223  ph->RegisterProcess(ems_wrapper, particle);
224 
225  } else if ((particleName == "mu+" ||
226  particleName == "mu-")) {
227  //G4cout << particleName << G4endl;
228  // ionisation
229  G4MuIonisation* muIoni = new G4MuIonisation();
230  muIoni->SetStepFunction(0.2, 50*um);
231  XWrapperContinuousDiscreteProcess *muIoni_wrapper =
232  new XWrapperContinuousDiscreteProcess();
233  muIoni_wrapper->RegisterProcess(muIoni,-1);
234  ph->RegisterProcess(muIoni_wrapper, particle);
235 
236  // bremsstrahlung
237  G4MuBremsstrahlung* muBrem = new G4MuBremsstrahlung();
238  XWrapperContinuousDiscreteProcess *muBrem_wrapper =
239  new XWrapperContinuousDiscreteProcess();
240  muBrem_wrapper->RegisterProcess(muBrem,-1);
241  ph->RegisterProcess(muBrem_wrapper, particle);
242 
243  // pair production
244  G4MuPairProduction* muPair = new G4MuPairProduction();
245  XWrapperContinuousDiscreteProcess* muPair_wrapper =
246  new XWrapperContinuousDiscreteProcess();
247  muPair_wrapper->RegisterProcess(muPair,-1);
248  ph->RegisterProcess(muPair_wrapper, particle);
249 
250  // coulomb scattering
251  G4CoulombScattering* ecs = new G4CoulombScattering();
252  ecs->SetBuildTableFlag(false);
253  G4eCoulombScatteringModel* ecsmodel =
254  new G4eCoulombScatteringModel();
255  ecsmodel->SetPolarAngleLimit(0.0);
256  ecs->AddEmModel(0, ecsmodel);
257  XWrapperDiscreteProcess *ecs_wrapper =
258  new XWrapperDiscreteProcess();
259  ecs_wrapper->RegisterProcess(ecs,1,1);
260  ph->RegisterProcess(ecs_wrapper, particle);
261 
262  // multiple scattering
263  XWrapperContinuousDiscreteProcess *mums_wrapper =
264  new XWrapperContinuousDiscreteProcess();
265  mums_wrapper->RegisterProcess(new G4MuMultipleScattering(),0,2);
266  ph->RegisterProcess(mums_wrapper, particle);
267 
268  } else if ((particleName == "alpha" || particleName == "He3") ) {
269  //G4cout << particleName << G4endl;
270  // ionisation
271  G4ionIonisation* ionIoni = new G4ionIonisation();
272  ionIoni->SetStepFunction(0.1, 10*um);
273  XWrapperContinuousDiscreteProcess *ionIoni_wrapper =
274  new XWrapperContinuousDiscreteProcess();
275  ionIoni_wrapper->RegisterProcess(ionIoni,-1);
276  ph->RegisterProcess(ionIoni_wrapper, particle);
277 
278  // coulomb scattering
279  G4CoulombScattering* ecs = new G4CoulombScattering();
280  ecs->SetBuildTableFlag(false);
281  XWrapperDiscreteProcess *ecs_wrapper =
282  new XWrapperDiscreteProcess();
283  ecs_wrapper->RegisterProcess(ecs,1,1);
284  ph->RegisterProcess(ecs_wrapper, particle);
285 
286 
287  // multiple scattering
288  XWrapperContinuousDiscreteProcess *hms_wrapper =
289  new XWrapperContinuousDiscreteProcess();
290  hms_wrapper->RegisterProcess(new G4hMultipleScattering(),0,2);
291  ph->RegisterProcess(hms_wrapper, particle);
292 
293  } else if( particleName == "proton" ||
294  particleName == "pi-" ||
295  particleName == "pi+" ) {
296 
297  //G4cout << particleName << G4endl;
298  // ionisation
299  G4hIonisation* hIoni = new G4hIonisation();
300  hIoni->SetStepFunction(0.1, 20*um);
301  XWrapperContinuousDiscreteProcess *hIoni_wrapper =
302  new XWrapperContinuousDiscreteProcess();
303  hIoni_wrapper->RegisterProcess(hIoni,-1);
304  ph->RegisterProcess(hIoni_wrapper, particle);
305 
306  // bremsstrahlung
307  G4hBremsstrahlung* hBrem = new G4hBremsstrahlung();
308  XWrapperContinuousDiscreteProcess *hBrem_wrapper =
309  new XWrapperContinuousDiscreteProcess();
310  hBrem_wrapper->RegisterProcess(hBrem,-1);
311  ph->RegisterProcess(hBrem_wrapper, particle);
312 
313  // pair production
314  G4hPairProduction* hPair = new G4hPairProduction();
315  XWrapperContinuousDiscreteProcess* hPair_wrapper =
316  new XWrapperContinuousDiscreteProcess();
317  hPair_wrapper->RegisterProcess(hPair,-1);
318  ph->RegisterProcess(hPair_wrapper, particle);
319 
320  // coulomb scattering
321  G4CoulombScattering* ecs = new G4CoulombScattering();
322  ecs->SetBuildTableFlag(false);
323  XWrapperDiscreteProcess *ecs_wrapper =
324  new XWrapperDiscreteProcess();
325  ecs_wrapper->RegisterProcess(ecs,1,1);
326  ph->RegisterProcess(ecs_wrapper, particle);
327 
328  // multiple scattering
329  XWrapperContinuousDiscreteProcess *hms_wrapper =
330  new XWrapperContinuousDiscreteProcess();
331  hms_wrapper->RegisterProcess(new G4hMultipleScattering(),0,2);
332  ph->RegisterProcess(hms_wrapper, particle);
333 
334  } else if (particleName == "GenericIon" ) {
335  //G4cout << particleName << G4endl;
336  // ionisation
337  G4ionIonisation* ionIoni = new G4ionIonisation();
338  ionIoni->SetStepFunction(0.1, 1*um);
339  XWrapperContinuousDiscreteProcess *ionIoni_wrapper =
340  new XWrapperContinuousDiscreteProcess();
341  ionIoni_wrapper->RegisterProcess(ionIoni,-1);
342  ph->RegisterProcess(ionIoni_wrapper, particle);
343 
344  // coulomb scattering
345  G4CoulombScattering* ecs = new G4CoulombScattering();
346  ecs->SetBuildTableFlag(false);
347  XWrapperDiscreteProcess *ecs_wrapper =
348  new XWrapperDiscreteProcess();
349  ecs_wrapper->RegisterProcess(ecs,1,1);
350  ph->RegisterProcess(ecs_wrapper, particle);
351 
352  // multiple scattering
353  XWrapperContinuousDiscreteProcess *hms_wrapper =
354  new XWrapperContinuousDiscreteProcess();
355  hms_wrapper->RegisterProcess(new G4hMultipleScattering(),0,2);
356  ph->RegisterProcess(hms_wrapper, particle);
357 
358  } else if ((!particle->IsShortLived()) &&
359  (particle->GetPDGCharge() != 0.0) &&
360  (particle->GetParticleName() != "chargedgeantino") ) {
361  //G4cout << particleName << G4endl;
362  //all others charged particles except geantino
363 
364  // ionisation
365  G4hIonisation* hIoni = new G4hIonisation();
366  XWrapperContinuousDiscreteProcess *hIoni_wrapper =
367  new XWrapperContinuousDiscreteProcess();
368  hIoni_wrapper->RegisterProcess(hIoni,-1);
369  ph->RegisterProcess(hIoni_wrapper, particle);
370 
371  // coulomb scattering
372  G4CoulombScattering* ecs = new G4CoulombScattering();
373  ecs->SetBuildTableFlag(false);
374  XWrapperDiscreteProcess *ecs_wrapper =
375  new XWrapperDiscreteProcess();
376  ecs_wrapper->RegisterProcess(ecs,1,1);
377  ph->RegisterProcess(ecs_wrapper, particle);
378 
379  // multiple scattering
380  XWrapperContinuousDiscreteProcess *hms_wrapper =
381  new XWrapperContinuousDiscreteProcess();
382  hms_wrapper->RegisterProcess(new G4hMultipleScattering(),0,2);
383  ph->RegisterProcess(hms_wrapper, particle);
384 
385  }
386  }
387 
388  // Em options
389  //
390  // Main options and setting parameters are shown here.
391  // Several of them have default values.
392  //
393  G4EmProcessOptions emOptions;
394 
395  //physics tables
396  //
397  emOptions.SetMinEnergy(10*eV);
398  emOptions.SetMaxEnergy(10*TeV);
399  emOptions.SetDEDXBinning(12*20);
400  emOptions.SetLambdaBinning(12*20);
401 
402  // scattering
403  emOptions.SetPolarAngleLimit(0.0);
404 
405  // Deexcitation
406  G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
407  G4LossTableManager::Instance()->SetAtomDeexcitation(de);
408  de->SetFluo(true);
409 }
XWrapperContinuousDiscreteProcess::RegisterProcess
void RegisterProcess(G4VContinuousDiscreteProcess *)
Definition: XWrapperContinousDiscreteProcess.cc:109
G4LossTableManager::Instance
static G4LossTableManager * Instance()
Definition: G4LossTableManager.cc:112
G4VEmProcess::SetBuildTableFlag
void SetBuildTableFlag(G4bool val)
Definition: G4VEmProcess.hh:641
G4EmProcessOptions::SetMinEnergy
void SetMinEnergy(G4double val)
Definition: G4EmProcessOptions.cc:182
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
G4VEmModel::SetHighEnergyLimit
void SetHighEnergyLimit(G4double)
Definition: G4VEmModel.hh:732
TeV
static constexpr double TeV
Definition: G4SIunits.hh:218
G4EmProcessOptions::SetDEDXBinning
void SetDEDXBinning(G4int val)
Definition: G4EmProcessOptions.cc:266
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
G4VEmProcess::SetEmModel
void SetEmModel(G4VEmModel *, G4int index=1)
Definition: G4VEmProcess.cc:213
um
static constexpr double um
Definition: G4SIunits.hh:113
G4EmProcessOptions::SetLambdaBinning
void SetLambdaBinning(G4int val)
Definition: G4EmProcessOptions.cc:278
G4PhysicsListHelper::RegisterProcess
G4bool RegisterProcess(G4VProcess *process, G4ParticleDefinition *particle)
Definition: G4PhysicsListHelper.cc:413
eV
static constexpr double eV
Definition: G4SIunits.hh:215
G4EmProcessOptions::SetMaxEnergy
void SetMaxEnergy(G4double val)
Definition: G4EmProcessOptions.cc:189
G4VEmProcess::AddEmModel
void AddEmModel(G4int, G4VEmModel *, const G4Region *region=nullptr)
Definition: G4VEmProcess.cc:203
G4PhysicsListHelper::GetPhysicsListHelper
static G4PhysicsListHelper * GetPhysicsListHelper()
Definition: G4PhysicsListHelper.cc:89
GeV
static constexpr double GeV
Definition: G4SIunits.hh:217
particleIterator
std::vector< G4InuclElementaryParticle >::iterator particleIterator
Definition: G4BigBanger.cc:65
MeV
static constexpr double MeV
Definition: G4SIunits.hh:214
XWrapperDiscreteProcess::RegisterProcess
void RegisterProcess(G4VDiscreteProcess *)
Definition: XWrapperDiscreteProcess.cc:88
G4ParticleDefinition::GetPDGCharge
G4double GetPDGCharge() const
Definition: G4ParticleDefinition.hh:124
G4LossTableManager::SetAtomDeexcitation
void SetAtomDeexcitation(G4VAtomDeexcitation *)
Definition: G4LossTableManager.cc:990
G4VEmModel::SetPolarAngleLimit
void SetPolarAngleLimit(G4double)
Definition: G4VEmModel.hh:767
G4EmProcessOptions::SetPolarAngleLimit
void SetPolarAngleLimit(G4double val)
Definition: G4EmProcessOptions.cc:238

Here is the call graph for this function:

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