Geant4 10.7.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4EmDNAPhysicsActivator.cc
Go to the documentation of this file.
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26
27#include "G4EmDNAPhysicsActivator.hh"
28
29#include "G4EmParameters.hh"
30#include "G4ParticleDefinition.hh"
31#include "G4ParticleTable.hh"
32#include "G4RegionStore.hh"
33#include "G4Region.hh"
34#include "G4VEnergyLossProcess.hh"
35#include "G4LossTableManager.hh"
36#include "G4EmConfigurator.hh"
37
38#include "G4Gamma.hh"
39#include "G4Electron.hh"
40#include "G4Positron.hh"
41#include "G4MuonPlus.hh"
42#include "G4MuonMinus.hh"
43#include "G4Proton.hh"
44#include "G4GenericIon.hh"
45#include "G4Alpha.hh"
46
47#include "G4ProcessManager.hh"
48#include "G4DummyModel.hh"
49#include "G4EmProcessSubType.hh"
50#include "G4PhysicsListHelper.hh"
51
52#include "G4BraggModel.hh"
53#include "G4BraggIonModel.hh"
54#include "G4BetheBlochModel.hh"
55#include "G4UrbanMscModel.hh"
56#include "G4WentzelVIModel.hh"
57#include "G4MollerBhabhaModel.hh"
58#include "G4IonFluctuations.hh"
59#include "G4UniversalFluctuation.hh"
60#include "G4LowECapture.hh"
61#include "G4hMultipleScattering.hh"
62#include "G4eCoulombScatteringModel.hh"
63#include "G4IonCoulombScatteringModel.hh"
64#include "G4hIonisation.hh"
65#include "G4ICRU49NuclearStoppingModel.hh"
66
67// Processes and models for Geant4-DNA
68#include "G4DNAGenericIonsManager.hh"
69
70#include "G4DNAElastic.hh"
71#include "G4DNAChampionElasticModel.hh"
72//#include "G4DNAScreenedRutherfordElasticModel.hh"
73#include "G4DNAUeharaScreenedRutherfordElasticModel.hh"
74#include "G4DNAIonElasticModel.hh"
75
76#include "G4DNAExcitation.hh"
77#include "G4DNAAttachment.hh"
78#include "G4DNAVibExcitation.hh"
79#include "G4DNAIonisation.hh"
80#include "G4DNAChargeDecrease.hh"
81#include "G4DNAChargeIncrease.hh"
82
83#include "G4SystemOfUnits.hh"
84#include <vector>
85
86#include "G4DNAChemistryManager.hh"
87#include "G4DNAElectronSolvation.hh"
88#include "G4DNAEmfietzoglouIonisationModel.hh"
89#include "G4DNAEmfietzoglouExcitationModel.hh"
90
91#include <G4DNACPA100ElasticModel.hh>
92#include "G4DNACPA100IonisationModel.hh"
93#include "G4DNACPA100ExcitationModel.hh"
94
95#include "G4Threading.hh"
96
97#include "G4UAtomicDeexcitation.hh" // added by MJPietrzak
98
99//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
100
101G4EmDNAPhysicsActivator::G4EmDNAPhysicsActivator(G4int ver)
102 : G4VPhysicsConstructor("G4EmDNAPhysicsActivator"), verbose(ver)
103{
104 theParameters = G4EmParameters::Instance();
105 theParameters->ActivateDNA();
106}
107
108//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
109
110G4EmDNAPhysicsActivator::~G4EmDNAPhysicsActivator()
111{}
112
113G4bool G4EmDNAPhysicsActivator::IsVerbose() const
114{
115 return (0 < verbose && G4Threading::IsMasterThread());
116}
117
118//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
119
120void G4EmDNAPhysicsActivator::ConstructParticle()
121{
122 // bosons
123 G4Gamma::Gamma();
124
125 // leptons
126 G4Electron::Electron();
127 G4Positron::Positron();
128
129 // baryons
130 G4Proton::Proton();
131
132 G4GenericIon::GenericIonDefinition();
133 G4Alpha::Alpha();
134
135 G4DNAGenericIonsManager * genericIonsManager;
136 genericIonsManager=G4DNAGenericIonsManager::Instance();
137 genericIonsManager->GetIon("alpha+");
138 genericIonsManager->GetIon("helium");
139 genericIonsManager->GetIon("hydrogen");
140 //genericIonsManager->GetIon("carbon");
141 //genericIonsManager->GetIon("nitrogen");
142 //genericIonsManager->GetIon("oxygen");
143 //genericIonsManager->GetIon("iron");
144
145}
146
147//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
148
149void G4EmDNAPhysicsActivator::ConstructProcess()
150{
151 const std::vector<G4String>& regnamesDNA = theParameters->RegionsDNA();
152 G4int nreg = regnamesDNA.size();
153 if(0 == nreg)
154 {
155 return;
156 }
157 const std::vector<G4String>& typesDNA = theParameters->TypesDNA();
158
159 if(IsVerbose()) {
160 G4cout << "### G4EmDNAPhysicsActivator::ConstructProcess for " << nreg
161 << " regions; DNA physics type " << typesDNA[0] << G4endl;
162 }
163
164 // list of particles
165 const G4ParticleDefinition* elec = G4Electron::Electron();
166 const G4ParticleDefinition* prot = G4Proton::Proton();
167 const G4ParticleDefinition* gion = G4GenericIon::GenericIon();
168
169 G4DNAGenericIonsManager * genericIonsManager =
170 G4DNAGenericIonsManager::Instance();
171 const G4ParticleDefinition* alpha2 = G4Alpha::Alpha();
172 const G4ParticleDefinition* alpha1 = genericIonsManager->GetIon("alpha+");
173 const G4ParticleDefinition* alpha0 = genericIonsManager->GetIon("helium");
174 const G4ParticleDefinition* h0 = genericIonsManager->GetIon("hydrogen");
175
176 G4ProcessManager* eman = elec->GetProcessManager();
177 G4ProcessManager* pman = prot->GetProcessManager();
178 G4ProcessManager* iman = gion->GetProcessManager();
179 G4ProcessManager* a2man = alpha2->GetProcessManager();
180 G4ProcessManager* a1man = alpha1->GetProcessManager();
181 G4ProcessManager* a0man = alpha0->GetProcessManager();
182 G4ProcessManager* h0man = h0->GetProcessManager();
183
184 // alpha+ standard processes
185 G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
186 G4ParticleDefinition* alpha11 = const_cast<G4ParticleDefinition*>(alpha1);
187 ph->RegisterProcess(new G4hMultipleScattering(), alpha11);
188 ph->RegisterProcess(new G4hIonisation(), alpha11);
189
190 G4bool emsc = HasMsc(eman);
191 G4bool pmsc = HasMsc(pman);
192 G4bool a2msc = HasMsc(a2man);
193 G4bool a1msc = HasMsc(a1man);
194 // G4bool imsc = HasMsc(iman);
195
196 // processes are defined with dummy models for the world
197 // elastic scatetring
198 G4DNAElastic* theDNAeElasticProcess = new G4DNAElastic("e-_G4DNAElastic");
199 theDNAeElasticProcess->SetEmModel(new G4DummyModel());
200 eman->AddDiscreteProcess(theDNAeElasticProcess);
201
202 G4DNAElastic* theDNApElasticProcess =
203 new G4DNAElastic("proton_G4DNAElastic");
204 theDNApElasticProcess->SetEmModel(new G4DummyModel());
205 pman->AddDiscreteProcess(theDNApElasticProcess);
206
207 G4DNAElastic* theDNAa2ElasticProcess =
208 new G4DNAElastic("alpha_G4DNAElastic");
209 theDNAa2ElasticProcess->SetEmModel(new G4DummyModel());
210 a2man->AddDiscreteProcess(theDNAa2ElasticProcess);
211
212 G4DNAElastic* theDNAa1ElasticProcess =
213 new G4DNAElastic("alpha+_G4DNAElastic");
214 theDNAa1ElasticProcess->SetEmModel(new G4DummyModel());
215 a1man->AddDiscreteProcess(theDNAa1ElasticProcess);
216
217 G4DNAElastic* theDNAa0ElasticProcess =
218 new G4DNAElastic("helium_G4DNAElastic");
219 theDNAa0ElasticProcess->SetEmModel(new G4DummyModel());
220 a0man->AddDiscreteProcess(theDNAa0ElasticProcess);
221
222 G4DNAElastic* theDNAh0ElasticProcess =
223 new G4DNAElastic("hydrogen_G4DNAElastic");
224 theDNAh0ElasticProcess->SetEmModel(new G4DummyModel());
225 h0man->AddDiscreteProcess(theDNAh0ElasticProcess);
226
227 // excitation
228 G4DNAExcitation* theDNAeExcProcess =
229 new G4DNAExcitation("e-_G4DNAExcitation");
230 theDNAeExcProcess->SetEmModel(new G4DummyModel());
231 eman->AddDiscreteProcess(theDNAeExcProcess);
232
233 G4DNAExcitation* theDNApExcProcess =
234 new G4DNAExcitation("proton_G4DNAExcitation");
235 theDNApExcProcess->SetEmModel(new G4DummyModel());
236 pman->AddDiscreteProcess(theDNApExcProcess);
237
238 G4DNAExcitation* theDNAa2ExcProcess =
239 new G4DNAExcitation("alpha_G4DNAExcitation");
240 theDNAa2ExcProcess->SetEmModel(new G4DummyModel());
241 a2man->AddDiscreteProcess(theDNAa2ExcProcess);
242
243 G4DNAExcitation* theDNAa1ExcProcess =
244 new G4DNAExcitation("alpha+_G4DNAExcitation");
245 theDNAa1ExcProcess->SetEmModel(new G4DummyModel());
246 a1man->AddDiscreteProcess(theDNAa1ExcProcess);
247
248 G4DNAExcitation* theDNAa0ExcProcess =
249 new G4DNAExcitation("helium_G4DNAExcitation");
250 theDNAa0ExcProcess->SetEmModel(new G4DummyModel());
251 a0man->AddDiscreteProcess(theDNAa0ExcProcess);
252
253 G4DNAExcitation* theDNAh0ExcProcess =
254 new G4DNAExcitation("hydrogen_G4DNAExcitation");
255 theDNAh0ExcProcess->SetEmModel(new G4DummyModel());
256 h0man->AddDiscreteProcess(theDNAh0ExcProcess);
257
258 // vibration excitation
259 G4DNAVibExcitation* theDNAeVibExcProcess =
260 new G4DNAVibExcitation("e-_G4DNAVibExcitation");
261 theDNAeVibExcProcess->SetEmModel(new G4DummyModel());
262 eman->AddDiscreteProcess(theDNAeVibExcProcess);
263
264 // ionisation
265 G4DNAIonisation* theDNAeIoniProcess =
266 new G4DNAIonisation("e-_G4DNAIonisation");
267 theDNAeIoniProcess->SetEmModel(new G4DummyModel());
268 eman->AddDiscreteProcess(theDNAeIoniProcess);
269
270 G4DNAIonisation* theDNApIoniProcess =
271 new G4DNAIonisation("proton_G4DNAIonisation");
272 theDNApIoniProcess->SetEmModel(new G4DummyModel());
273 pman->AddDiscreteProcess(theDNApIoniProcess);
274
275 G4DNAIonisation* theDNAa2IoniProcess =
276 new G4DNAIonisation("alpha_G4DNAIonisation");
277 theDNAa2IoniProcess->SetEmModel(new G4DummyModel());
278 a2man->AddDiscreteProcess(theDNAa2IoniProcess);
279
280 G4DNAIonisation* theDNAa1IoniProcess =
281 new G4DNAIonisation("alpha+_G4DNAIonisation");
282 theDNAa1IoniProcess->SetEmModel(new G4DummyModel());
283 a1man->AddDiscreteProcess(theDNAa1IoniProcess);
284
285 G4DNAIonisation* theDNAa0IoniProcess =
286 new G4DNAIonisation("helium_G4DNAIonisation");
287 theDNAa0IoniProcess->SetEmModel(new G4DummyModel());
288 a0man->AddDiscreteProcess(theDNAa0IoniProcess);
289
290 G4DNAIonisation* theDNAh0IoniProcess =
291 new G4DNAIonisation("hydrogen_G4DNAIonisation");
292 theDNAh0IoniProcess->SetEmModel(new G4DummyModel());
293 h0man->AddDiscreteProcess(theDNAh0IoniProcess);
294
295 G4DNAIonisation* theDNAiIoniProcess =
296 new G4DNAIonisation("GenericIon_G4DNAIonisation");
297 theDNAiIoniProcess->SetEmModel(new G4DummyModel());
298 iman->AddDiscreteProcess(theDNAiIoniProcess);
299
300 // attachment
301 G4DNAAttachment* theDNAAttachProcess =
302 new G4DNAAttachment("e-_G4DNAAttachment");
303 theDNAAttachProcess->SetEmModel(new G4DummyModel());
304 eman->AddDiscreteProcess(theDNAAttachProcess);
305
306 // charge exchange
307 G4DNAChargeDecrease* theDNApChargeDecreaseProcess =
308 new G4DNAChargeDecrease("proton_G4DNAChargeDecrease");
309 theDNApChargeDecreaseProcess->SetEmModel(new G4DummyModel());
310 pman->AddDiscreteProcess(theDNApChargeDecreaseProcess);
311
312 G4DNAChargeDecrease* theDNAa2ChargeDecreaseProcess =
313 new G4DNAChargeDecrease("alpha_G4DNAChargeDecrease");
314 theDNAa2ChargeDecreaseProcess->SetEmModel(new G4DummyModel());
315 a2man->AddDiscreteProcess(theDNAa2ChargeDecreaseProcess);
316
317 G4DNAChargeDecrease* theDNAa1ChargeDecreaseProcess =
318 new G4DNAChargeDecrease("alpha+_G4DNAChargeDecrease");
319 theDNAa1ChargeDecreaseProcess->SetEmModel(new G4DummyModel());
320 a1man->AddDiscreteProcess(theDNAa1ChargeDecreaseProcess);
321
322 G4DNAChargeIncrease* theDNAa1ChargeIncreaseProcess =
323 new G4DNAChargeIncrease("alpha+_G4DNAChargeIncrease");
324 theDNAa1ChargeIncreaseProcess->SetEmModel(new G4DummyModel());
325 a1man->AddDiscreteProcess(theDNAa1ChargeIncreaseProcess);
326
327 G4DNAChargeIncrease* theDNAa0ChargeIncreaseProcess =
328 new G4DNAChargeIncrease("helium_G4DNAChargeIncrease");
329 theDNAa0ChargeIncreaseProcess->SetEmModel(new G4DummyModel());
330 a0man->AddDiscreteProcess(theDNAa0ChargeIncreaseProcess);
331
332 G4DNAChargeIncrease* theDNAh0ChargeIncreaseProcess =
333 new G4DNAChargeIncrease("hydrogen_G4DNAChargeIncrease");
334 theDNAh0ChargeIncreaseProcess->SetEmModel(new G4DummyModel());
335 h0man->AddDiscreteProcess(theDNAh0ChargeIncreaseProcess);
336
337 // limits for DNA model applicability
338 // static const G4double elowest= 7.4 * eV; // seems to be option dependent - MJPietrzak
339 static const G4double elimel = 1 * MeV;
340 static const G4double pminbb = 2 * MeV;
341 static const G4double pmin = 0.1 * keV;
342 static const G4double pmax = 100 * MeV;
343 static const G4double hemin = 1 * keV;
344 static const G4double ionmin = 0.5 * MeV;
345
346
347 // G4DNAElectronSolvation used instead of G4LowECapture (always for simplicity) - MJPietrzak
348
349 // When chemistry is activated: G4DNAElectronSolvation turns the electron
350 // to a solvated electron, otherwise it kills the electron at the
351 // corresponding high energy limit of the model
352 auto pSolvatation = new G4DNAElectronSolvation("e-_G4DNAElectronSolvation");
353 pSolvatation->SetEmModel(G4DNASolvationModelFactory::GetMacroDefinedModel());
354 eman->AddDiscreteProcess(pSolvatation);
355
356 G4LowECapture* pcap = new G4LowECapture(pmin);
357 pman->AddDiscreteProcess(pcap);
358 G4LowECapture* icap = new G4LowECapture(ionmin);
359 iman->AddDiscreteProcess(icap);
360 G4LowECapture* a2cap = new G4LowECapture(hemin);
361 a2man->AddDiscreteProcess(a2cap);
362 G4LowECapture* a1cap = new G4LowECapture(hemin);
363 a1man->AddDiscreteProcess(a1cap);
364 G4LowECapture* a0cap = new G4LowECapture(hemin);
365 a0man->AddDiscreteProcess(a0cap);
366 G4LowECapture* h0cap = new G4LowECapture(ionmin);
367 h0man->AddDiscreteProcess(h0cap);
368
369 // loop over regions
370 for(G4int i = 0; i < nreg; ++i)
371 {
372 G4String reg = regnamesDNA[i];
373 if(IsVerbose())
374 {
375 G4cout << "### DNA models type " << typesDNA[i]
376 << " are activated for G4Region " << reg << G4endl;
377 }
378
379 if(typesDNA[i] == "DNA_Opt0") {
380 AddElectronModels0(reg, emsc, elimel);
381 }
382 else if(typesDNA[i] == "DNA_Opt2"){
383 AddElectronModels2(reg, emsc, elimel);
384 }
385 else if(typesDNA[i] == "DNA_Opt4"){
386 AddElectronModels4(reg, emsc, elimel);
387 }
388 else if(typesDNA[i] == "DNA_Opt4a"){
389 AddElectronModels4a(reg, emsc, elimel);
390 }
391 else if(typesDNA[i] == "DNA_Opt6"){
392 AddElectronModels6(reg, emsc, elimel);
393 }
394 else if(typesDNA[i] == "DNA_Opt6a"){
395 AddElectronModels6a(reg, emsc, elimel);
396 }
397 else if(typesDNA[i] == "DNA_Opt7") {
398 AddElectronModels7(reg, emsc, elimel);
399 }
400
401 // models for for other particles seems to be option independent so I moved them here - MJPietrzak
402 AddProtonModels0(reg, pmsc, elimel, pminbb, pmax);
403 AddHeliumModels0(reg, a1msc, a2msc, elimel, pminbb, pmax);
404 AddGenericIonModels0(reg, pminbb);
405 DeactivateNuclearStopping(pman, elimel);
406 DeactivateNuclearStopping(a1man, elimel);
407 DeactivateNuclearStopping(a2man, elimel);
408 }
409
410 auto ltman = G4LossTableManager::Instance();
411 ltman->EmConfigurator()->AddModels();
412}
413
414//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
415
416void G4EmDNAPhysicsActivator::AddElectronModels0(const G4String& reg,
417 G4bool emsc,
418 G4double elimel)
419{
420 G4EmConfigurator* em_config =
421 G4LossTableManager::Instance()->EmConfigurator();
422 G4VEmModel* mod;
423
424 static const G4double elowest = 7.4 * eV; // seems to be option dependent, so I moved it here - MJPietrzak
425 static const G4double elimin = 1 * MeV;
426 static const G4double elimvb = 100 * eV;
427 static const G4double elimat = 13 * eV;
428 static const G4double elim1 = 10 * keV;
429
430 // for e- 100 MeV is a limit between different msc models
431 G4double emax = theParameters->MaxKinEnergy();
432
433 if(emsc) {
434 G4UrbanMscModel* msc = new G4UrbanMscModel();
435 msc->SetActivationLowEnergyLimit(elimel);
436 G4double emaxmsc = std::min(100*MeV, emax);
437 em_config->SetExtraEmModel("e-", "msc", msc, reg, 0.0, emaxmsc);
438 } else {
439 mod = new G4eCoulombScatteringModel();
440 mod->SetActivationLowEnergyLimit(elimel);
441 em_config->SetExtraEmModel("e-", "CoulombScat", mod, reg, 0.0, emax);
442 }
443
444 // cuts and solvation
445 mod = new G4DNAOneStepThermalizationModel();
446 em_config->SetExtraEmModel("e-", "e-_G4DNAElectronSolvation",
447 mod, reg, 0., elowest);
448
449 // elastic
450 mod = new G4DNAChampionElasticModel();
451 em_config->SetExtraEmModel("e-", "e-_G4DNAElastic",
452 mod, reg, 0.0, elimel);
453 // ionisation
454 mod = new G4MollerBhabhaModel();
455 mod->SetActivationLowEnergyLimit(elimin);
456 em_config->SetExtraEmModel("e-", "eIoni",
457 mod, reg, 0.0, emax,
458 new G4UniversalFluctuation());
459
460 mod = new G4DNABornIonisationModel();
461 em_config->SetExtraEmModel("e-", "e-_G4DNAIonisation",
462 mod, reg, elim1, elimin);
463
464 mod = new G4DNAEmfietzoglouIonisationModel();
465 em_config->SetExtraEmModel("e-", "e-_G4DNAIonisation",
466 mod, reg, 0.0, elim1);
467
468 // exc
469 mod = new G4DNAEmfietzoglouExcitationModel();
470 em_config->SetExtraEmModel("e-", "e-_G4DNAExcitation",
471 mod, reg, 0.0, elim1);
472
473 mod = new G4DNABornExcitationModel();
474 em_config->SetExtraEmModel("e-", "e-_G4DNAExcitation",
475 mod, reg, elim1, elimin);
476
477 mod = new G4DNASancheExcitationModel();
478 em_config->SetExtraEmModel("e-", "e-_G4DNAVibExcitation",
479 mod, reg, 0.0, elimvb);
480
481 mod = new G4DNAMeltonAttachmentModel();
482 em_config->SetExtraEmModel("e-", "e-_G4DNAAttachment",
483 mod, reg, 0.0, elimat);
484
485}
486
487//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
488
489void G4EmDNAPhysicsActivator::AddElectronModels2(const G4String &reg,
490 G4bool emsc,
491 G4double elimel)
492{
493 G4EmConfigurator *em_config =
494 G4LossTableManager::Instance()->EmConfigurator();
495 G4VEmModel *mod;
496
497 static const G4double elowest = 7.4 * eV; // seems to be option dependent, so I moved it here - MJPietrzak
498 static const G4double elimin = 1 * MeV;
499 static const G4double elimvb = 100 * eV;
500 static const G4double elimat = 13 * eV;
501
502
503 // for e- 100 MeV is a limit between different msc models
504 G4double emax = theParameters->MaxKinEnergy();
505
506 if (emsc) {
507 G4UrbanMscModel *msc = new G4UrbanMscModel();
508 msc->SetActivationLowEnergyLimit(elimel);
509 G4double emaxmsc = std::min(100 * MeV, emax);
510 em_config->SetExtraEmModel("e-", "msc", msc, reg, 0.0, emaxmsc);
511 } else {
512 mod = new G4eCoulombScatteringModel();
513 mod->SetActivationLowEnergyLimit(elimel);
514 em_config->SetExtraEmModel("e-", "CoulombScat", mod, reg, 0.0, emax);
515 }
516
517 // cuts and solvation
518 mod = new G4DNAOneStepThermalizationModel();
519 em_config->SetExtraEmModel("e-", "e-_G4DNAElectronSolvation",
520 mod, reg, 0., elowest);
521
522 // elastic
523 mod = new G4DNAChampionElasticModel();
524 em_config->SetExtraEmModel("e-", "e-_G4DNAElastic",
525 mod, reg, 0.0, elimel);
526
527
528 // ionisation
529 mod = new G4MollerBhabhaModel();
530 mod->SetActivationLowEnergyLimit(elimin);
531 em_config->SetExtraEmModel("e-", "eIoni",
532 mod, reg, 0.0, emax,
533 new G4UniversalFluctuation());
534
535 mod = new G4DNABornIonisationModel();
536 em_config->SetExtraEmModel("e-", "e-_G4DNAIonisation",
537 mod, reg, elowest, elimin);
538
539 // excitation
540 mod = new G4DNABornExcitationModel();
541 em_config->SetExtraEmModel("e-", "e-_G4DNAExcitation",
542 mod, reg, 0., elimin);
543
544 // vib excitation
545 mod = new G4DNASancheExcitationModel();
546 em_config->SetExtraEmModel("e-", "e-_G4DNAVibExcitation",
547 mod, reg, 0.0, elimvb);
548
549 // attachment
550 mod = new G4DNAMeltonAttachmentModel();
551 em_config->SetExtraEmModel("e-", "e-_G4DNAAttachment",
552 mod, reg, 0.0, elimat);
553
554}
555
556
557//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
558
559void G4EmDNAPhysicsActivator::AddElectronModels4(const G4String& reg,
560 G4bool emsc,
561 G4double elimel)
562{
563 G4EmConfigurator *em_config =
564 G4LossTableManager::Instance()->EmConfigurator();
565 G4VEmModel *mod;
566
567 static const G4double elowest = 10 * eV; // seems to be option dependent, so I moved it here - MJPietrzak
568 static const G4double elimin = 1 * MeV;
569// static const G4double elimvb = 100 * eV;
570// static const G4double elimat = 13 * eV;
571
572
573 // for e- 100 MeV is a limit between different msc models
574 G4double emax = theParameters->MaxKinEnergy();
575
576 if (emsc) {
577 G4UrbanMscModel *msc = new G4UrbanMscModel();
578 msc->SetActivationLowEnergyLimit(elimel);
579 G4double emaxmsc = std::min(100 * MeV, emax);
580 em_config->SetExtraEmModel("e-", "msc", msc, reg, 0.0, emaxmsc);
581 } else {
582 mod = new G4eCoulombScatteringModel();
583 mod->SetActivationLowEnergyLimit(elimel);
584 em_config->SetExtraEmModel("e-", "CoulombScat", mod, reg, 0.0, emax);
585 }
586
587 // cuts and solvation
588 mod = new G4DNAOneStepThermalizationModel();
589 em_config->SetExtraEmModel("e-", "e-_G4DNAElectronSolvation",
590 mod, reg, 0., elowest);
591
592 // elastic
593 mod = new G4DNAUeharaScreenedRutherfordElasticModel();
594 em_config->SetExtraEmModel("e-", "e-_G4DNAElastic",
595 mod, reg, 0.0, elimel);
596
597 // ionisation
598 mod = new G4MollerBhabhaModel();
599 mod->SetActivationLowEnergyLimit(elimin);
600 em_config->SetExtraEmModel("e-", "eIoni",
601 mod, reg, 0.0, emax,
602 new G4UniversalFluctuation());
603
604 mod = new G4DNAEmfietzoglouIonisationModel();
605 em_config->SetExtraEmModel("e-", "e-_G4DNAIonisation",
606 mod, reg, elowest, elimin);
607
608 // excitation
609 mod = new G4DNAEmfietzoglouExcitationModel();
610 em_config->SetExtraEmModel("e-", "e-_G4DNAExcitation",
611 mod, reg, 0., elimin);
612
613
614// todo - MJPietrzak
615// I don't understand why vib excit. and attachment models are turned off in option 4 (and 6)
616// therefore I have created option 4a (and 6a), which has these models turned on
617//
618// // vib excitation
619// mod = new G4DNASancheExcitationModel();
620// em_config->SetExtraEmModel("e-", "e-_G4DNAVibExcitation",
621// mod, reg, 0.0, elimvb);
622//
623// // attachment
624// mod = new G4DNAMeltonAttachmentModel();
625// em_config->SetExtraEmModel("e-", "e-_G4DNAAttachment",
626// mod, reg, 0.0, elimat);
627
628}
629
630//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
631
632void G4EmDNAPhysicsActivator::AddElectronModels4a(const G4String& reg,
633 G4bool emsc,
634 G4double elimel)
635{
636 G4EmConfigurator *em_config =
637 G4LossTableManager::Instance()->EmConfigurator();
638 G4VEmModel *mod;
639
640 static const G4double elowest = 10 * eV; // seems to be option dependent, so I moved it here - MJPietrzak
641 static const G4double elimin = 1 * MeV;
642 static const G4double elimvb = 100 * eV;
643 static const G4double elimat = 13 * eV;
644
645
646 // for e- 100 MeV is a limit between different msc models
647 G4double emax = theParameters->MaxKinEnergy();
648
649 if (emsc) {
650 G4UrbanMscModel *msc = new G4UrbanMscModel();
651 msc->SetActivationLowEnergyLimit(elimel);
652 G4double emaxmsc = std::min(100 * MeV, emax);
653 em_config->SetExtraEmModel("e-", "msc", msc, reg, 0.0, emaxmsc);
654 } else {
655 mod = new G4eCoulombScatteringModel();
656 mod->SetActivationLowEnergyLimit(elimel);
657 em_config->SetExtraEmModel("e-", "CoulombScat", mod, reg, 0.0, emax);
658 }
659
660 // cuts and solvation
661 mod = new G4DNAOneStepThermalizationModel();
662 em_config->SetExtraEmModel("e-", "e-_G4DNAElectronSolvation",
663 mod, reg, 0., elowest);
664
665 // elastic
666 mod = new G4DNAUeharaScreenedRutherfordElasticModel();
667 em_config->SetExtraEmModel("e-", "e-_G4DNAElastic",
668 mod, reg, 0.0, elimel);
669
670 // ionisation
671 mod = new G4MollerBhabhaModel();
672 mod->SetActivationLowEnergyLimit(elimin);
673 em_config->SetExtraEmModel("e-", "eIoni",
674 mod, reg, 0.0, emax,
675 new G4UniversalFluctuation());
676
677 mod = new G4DNAEmfietzoglouIonisationModel();
678 em_config->SetExtraEmModel("e-", "e-_G4DNAIonisation",
679 mod, reg, elowest, elimin);
680
681 // excitation
682 mod = new G4DNAEmfietzoglouExcitationModel();
683 em_config->SetExtraEmModel("e-", "e-_G4DNAExcitation",
684 mod, reg, 0., elimin);
685
686
687 // I don't understand why vib excit. and attachment models are turned off in option 4
688 // therefore I have created option 4a, which has these models turned on
689 // and here it is - MJPietrzak
690
691 // vib excitation
692 mod = new G4DNASancheExcitationModel();
693 em_config->SetExtraEmModel("e-", "e-_G4DNAVibExcitation",
694 mod, reg, 0.0, elimvb);
695
696 // attachment
697 mod = new G4DNAMeltonAttachmentModel();
698 em_config->SetExtraEmModel("e-", "e-_G4DNAAttachment",
699 mod, reg, 0.0, elimat);
700
701}
702
703//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
704
705void G4EmDNAPhysicsActivator::AddElectronModels6(const G4String& reg,
706 G4bool emsc,
707 G4double elimel)
708{
709 G4EmConfigurator *em_config =
710 G4LossTableManager::Instance()->EmConfigurator();
711 G4VEmModel *mod;
712
713 static const G4double elowest = 11 * eV; // seems to be option dependent, so I moved it here - MJPietrzak
714 static const G4double elimin = 1 * MeV;
715 // static const G4double elimvb = 100 * eV;
716 // static const G4double elimat = 13 * eV;
717
718 // for e- 100 MeV is a limit between different msc models
719 G4double emax = theParameters->MaxKinEnergy();
720
721 if (emsc) {
722 G4UrbanMscModel *msc = new G4UrbanMscModel();
723 msc->SetActivationLowEnergyLimit(elimel);
724 G4double emaxmsc = std::min(100 * MeV, emax);
725 em_config->SetExtraEmModel("e-", "msc", msc, reg, 0.0, emaxmsc);
726 } else {
727 mod = new G4eCoulombScatteringModel();
728 mod->SetActivationLowEnergyLimit(elimel);
729 em_config->SetExtraEmModel("e-", "CoulombScat", mod, reg, 0.0, emax);
730 }
731
732 // cuts and solvation
733 mod = new G4DNAOneStepThermalizationModel();
734 em_config->SetExtraEmModel("e-", "e-_G4DNAElectronSolvation",
735 mod, reg, 0., elowest);
736
737 // elastic
738 mod = new G4DNACPA100ElasticModel();
739 em_config->SetExtraEmModel("e-", "e-_G4DNAElastic",
740 mod, reg, 0.0, elimel);
741
742 // ionisation
743 mod = new G4MollerBhabhaModel();
744 mod->SetActivationLowEnergyLimit(elimin);
745 em_config->SetExtraEmModel("e-", "eIoni",
746 mod, reg, 0.0, emax,
747 new G4UniversalFluctuation());
748
749 mod = new G4DNACPA100IonisationModel();
750 em_config->SetExtraEmModel("e-", "e-_G4DNAIonisation",
751 mod, reg, elowest, elimin);
752
753 // excitation
754 mod = new G4DNACPA100ExcitationModel();
755 em_config->SetExtraEmModel("e-", "e-_G4DNAExcitation",
756 mod, reg, 0., elimin);
757
758
759// I don't understand why vib excit. and attachment models are turned off in option 6 (and 4)
760// therefore I have created option 6a (and 4a), which has these models turned on
761// and here it is - MJPietrzak
762
763// // vib excitation
764// mod = new G4DNASancheExcitationModel();
765// em_config->SetExtraEmModel("e-", "e-_G4DNAVibExcitation",
766// mod, reg, 0.0, elimvb);
767//
768// // attachment
769// mod = new G4DNAMeltonAttachmentModel();
770// em_config->SetExtraEmModel("e-", "e-_G4DNAAttachment",
771// mod, reg, 0.0, elimat);
772
773}
774//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
775
776void G4EmDNAPhysicsActivator::AddElectronModels6a(const G4String& reg,
777 G4bool emsc,
778 G4double elimel)
779{
780 G4EmConfigurator *em_config =
781 G4LossTableManager::Instance()->EmConfigurator();
782 G4VEmModel *mod;
783
784 static const G4double elowest = 11 * eV; // seems to be option dependent, so I moved it here - MJPietrzak
785 static const G4double elimin = 1 * MeV;
786 static const G4double elimvb = 100 * eV;
787 static const G4double elimat = 13 * eV;
788
789
790 // for e- 100 MeV is a limit between different msc models
791 G4double emax = theParameters->MaxKinEnergy();
792
793 if (emsc) {
794 G4UrbanMscModel *msc = new G4UrbanMscModel();
795 msc->SetActivationLowEnergyLimit(elimel);
796 G4double emaxmsc = std::min(100 * MeV, emax);
797 em_config->SetExtraEmModel("e-", "msc", msc, reg, 0.0, emaxmsc);
798 } else {
799 mod = new G4eCoulombScatteringModel();
800 mod->SetActivationLowEnergyLimit(elimel);
801 em_config->SetExtraEmModel("e-", "CoulombScat", mod, reg, 0.0, emax);
802 }
803
804 // cuts and solvation
805 mod = new G4DNAOneStepThermalizationModel();
806 em_config->SetExtraEmModel("e-", "e-_G4DNAElectronSolvation",
807 mod, reg, 0., elowest);
808
809 // elastic
810 mod = new G4DNACPA100ElasticModel();
811 em_config->SetExtraEmModel("e-", "e-_G4DNAElastic",
812 mod, reg, 0.0, elimel);
813
814 // ionisation
815 mod = new G4MollerBhabhaModel();
816 mod->SetActivationLowEnergyLimit(elimin);
817 em_config->SetExtraEmModel("e-", "eIoni",
818 mod, reg, 0.0, emax,
819 new G4UniversalFluctuation());
820
821 mod = new G4DNACPA100IonisationModel();
822 em_config->SetExtraEmModel("e-", "e-_G4DNAIonisation",
823 mod, reg, elowest, elimin);
824
825 // excitation
826 mod = new G4DNACPA100ExcitationModel();
827 em_config->SetExtraEmModel("e-", "e-_G4DNAExcitation",
828 mod, reg, 0., elimin);
829
830 // I don't understand why vib excit. and attachment models are turned off in option 6 (and 4)
831 // therefore I have created option 6a (and 4a), which has these models turned on
832 // and here it is - MJPietrzak
833
834 // vib excitation
835 mod = new G4DNASancheExcitationModel();
836 em_config->SetExtraEmModel("e-", "e-_G4DNAVibExcitation",
837 mod, reg, 0.0, elimvb);
838
839 // attachment
840 mod = new G4DNAMeltonAttachmentModel();
841 em_config->SetExtraEmModel("e-", "e-_G4DNAAttachment",
842 mod, reg, 0.0, elimat);
843
844}
845
846//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
847
848void G4EmDNAPhysicsActivator::AddElectronModels7(const G4String &reg,
849 G4bool emsc,
850 G4double elimel)
851{
852 G4EmConfigurator *em_config =
853 G4LossTableManager::Instance()->EmConfigurator();
854 G4VEmModel *mod;
855
856 static const G4double elowest = 10 * eV; // seems to be option dependent, so I moved it here - MJPietrzak
857 static const G4double elimin = 1 * MeV;
858 static const G4double elimvb = 100 * eV;
859 static const G4double elimat = 13 * eV;
860 static const G4double elim1 = 10 * keV;
861
862 // for e- 100 MeV is a limit between different msc models
863 G4double emax = theParameters->MaxKinEnergy();
864
865 if (emsc) {
866 G4UrbanMscModel *msc = new G4UrbanMscModel();
867 msc->SetActivationLowEnergyLimit(elimel);
868 G4double emaxmsc = std::min(100 * MeV, emax);
869 em_config->SetExtraEmModel("e-", "msc", msc, reg, 0.0, emaxmsc);
870 } else {
871 mod = new G4eCoulombScatteringModel();
872 mod->SetActivationLowEnergyLimit(elimel);
873 em_config->SetExtraEmModel("e-", "CoulombScat", mod, reg, 0.0, emax);
874 }
875
876 // cuts and solvation
877 mod = new G4DNAOneStepThermalizationModel();
878 em_config->SetExtraEmModel("e-", "e-_G4DNAElectronSolvation",
879 mod, reg, 0., elowest);
880
881 // elastic
882 mod = new G4DNAUeharaScreenedRutherfordElasticModel(); // G4DNAChampionElasticModel(); in Opt_0 - the main difference between Opt0 and Opt7
883 em_config->SetExtraEmModel("e-", "e-_G4DNAElastic",
884 mod, reg, 0.0, elimel);
885
886
887 // ionisation
888 mod = new G4MollerBhabhaModel();
889 mod->SetActivationLowEnergyLimit(elimin);
890 em_config->SetExtraEmModel("e-", "eIoni",
891 mod, reg, 0.0, emax,
892 new G4UniversalFluctuation());
893 // todo - MJPietrzak
894 // I don't understand why the MollerBhabhaModel is here, as there is no sign of this model in regular DNA lists.
895 // However, it seems that it is necessary for all the options.
896
897 mod = new G4DNABornIonisationModel();
898 em_config->SetExtraEmModel("e-", "e-_G4DNAIonisation",
899 mod, reg, elim1, elimin);
900
901 mod = new G4DNAEmfietzoglouIonisationModel();
902 em_config->SetExtraEmModel("e-", "e-_G4DNAIonisation",
903 mod, reg, elowest, elim1); // mod, reg, 0.0, elim1);
904
905
906 // excitation
907 mod = new G4DNAEmfietzoglouExcitationModel();
908 em_config->SetExtraEmModel("e-", "e-_G4DNAExcitation",
909 mod, reg, 8 * eV, elim1);
910
911 mod = new G4DNABornExcitationModel();
912 em_config->SetExtraEmModel("e-", "e-_G4DNAExcitation",
913 mod, reg, elim1, elimin);
914
915 // vib excitation
916 mod = new G4DNASancheExcitationModel();
917 em_config->SetExtraEmModel("e-", "e-_G4DNAVibExcitation",
918 mod, reg, 0.0, elimvb);
919
920 // attachment
921 mod = new G4DNAMeltonAttachmentModel();
922 em_config->SetExtraEmModel("e-", "e-_G4DNAAttachment",
923 mod, reg, 0.0, elimat);
924
925}
926
927//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
928
929// OTHER PARTICLES (hadrons) MODELS BELOW
930
931//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
932
933void G4EmDNAPhysicsActivator::AddProtonModels0(const G4String& reg,
934 G4bool pmsc, G4double elimel,
935 G4double pminbb, G4double pmax)
936{
937 G4EmConfigurator* em_config =
938 G4LossTableManager::Instance()->EmConfigurator();
939 G4VEmModel* mod;
940
941 static const G4double gmmax = 500 * keV;
942
943 G4double emax = theParameters->MaxKinEnergy();
944
945 // proton
946
947 // if SS physics list msc process does not exist
948 if(pmsc) {
949 G4WentzelVIModel* msc = new G4WentzelVIModel();
950 msc->SetActivationLowEnergyLimit(elimel);
951 em_config->SetExtraEmModel("proton", "msc", msc, reg, 0.0, emax);
952 }
953 // single scattering always applied
954 mod = new G4eCoulombScatteringModel();
955 mod->SetActivationLowEnergyLimit(elimel);
956 em_config->SetExtraEmModel("proton", "CoulombScat", mod, reg, 0.0, emax);
957
958 mod = new G4BraggModel();
959 mod->SetActivationLowEnergyLimit(std::min(pminbb, pmax));
960 em_config->SetExtraEmModel("proton", "hIoni",
961 mod, reg, 0.0, pminbb,
962 new G4UniversalFluctuation());
963
964 mod = new G4BetheBlochModel();
965 mod->SetActivationLowEnergyLimit(pmax);
966 em_config->SetExtraEmModel("proton", "hIoni",
967 mod, reg, pminbb, emax,
968 new G4UniversalFluctuation());
969
970 mod = new G4DNARuddIonisationModel();
971 em_config->SetExtraEmModel("proton", "proton_G4DNAIonisation",
972 mod, reg, 0.0, gmmax);
973
974 mod = new G4DNABornIonisationModel();
975 em_config->SetExtraEmModel("proton", "proton_G4DNAIonisation",
976 mod, reg, gmmax, pmax);
977
978 mod = new G4DNAMillerGreenExcitationModel();
979 em_config->SetExtraEmModel("proton", "proton_G4DNAExcitation",
980 mod, reg, 0.0, gmmax);
981
982 mod = new G4DNABornExcitationModel();
983 em_config->SetExtraEmModel("proton", "proton_G4DNAExcitation",
984 mod, reg, gmmax, pmax);
985
986 mod = new G4DNADingfelderChargeDecreaseModel();
987 em_config->SetExtraEmModel("proton", "proton_G4DNAChargeDecrease",
988 mod, reg, 0.0, pmax);
989
990 mod = new G4DNAIonElasticModel();
991 em_config->SetExtraEmModel("proton", "proton_G4DNAElastic",
992 mod, reg, 0.0, elimel);
993
994 // hydrogen
995 mod = new G4DNARuddIonisationModel();
996 em_config->SetExtraEmModel("hydrogen", "hydrogen_G4DNAIonisation",
997 mod, reg, 0.0, pmax);
998
999 mod = new G4DNAMillerGreenExcitationModel();
1000 em_config->SetExtraEmModel("hydrogen", "hydrogen_G4DNAExcitation",
1001 mod, reg, 0.0, gmmax);
1002
1003 mod = new G4DNADingfelderChargeIncreaseModel();
1004 em_config->SetExtraEmModel("hydrogen", "hydrogen_G4DNAChargeIncrease",
1005 mod, reg, 0.0, pmax);
1006
1007 mod = new G4DNAIonElasticModel();
1008 em_config->SetExtraEmModel("hydrogen", "hydrogen_G4DNAElastic",
1009 mod, reg, 0.0, elimel);
1010
1011}
1012
1013//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
1014
1015void G4EmDNAPhysicsActivator::AddGenericIonModels0(const G4String& reg,
1016 G4double pminbb)
1017{
1018 G4EmConfigurator* em_config =
1019 G4LossTableManager::Instance()->EmConfigurator();
1020 G4VEmModel* mod;
1021
1022 G4double emax = theParameters->MaxKinEnergy();
1023 G4double iemax = std::min(10*MeV, emax);
1024 //G4double iemin = 100*eV;
1025
1026 mod = new G4BraggIonModel();
1027 mod->SetActivationLowEnergyLimit(iemax);
1028 em_config->SetExtraEmModel("GenericIon", "ionIoni",
1029 mod, reg, 0.0, pminbb,
1030 new G4IonFluctuations());
1031
1032 mod = new G4BetheBlochModel();
1033 mod->SetActivationLowEnergyLimit(iemax);
1034 em_config->SetExtraEmModel("GenericIon", "ionIoni",
1035 mod, reg, pminbb, emax,
1036 new G4IonFluctuations());
1037
1038 mod = new G4DNARuddIonisationExtendedModel();
1039 em_config->SetExtraEmModel("GenericIon", "GenericIon_G4DNAIonisation",
1040 mod, reg, 0.0, iemax);
1041
1042}
1043
1044//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
1045
1046void G4EmDNAPhysicsActivator::AddHeliumModels0(const G4String& reg,
1047 G4bool a1msc,
1048 G4bool a2msc, G4double elimel,
1049 G4double pminbb, G4double)
1050{
1051 G4EmConfigurator* em_config =
1052 G4LossTableManager::Instance()->EmConfigurator();
1053 G4VEmModel* mod;
1054
1055 static const G4double hemax = 400 * MeV;
1056 static const G4double massRatio = G4Alpha::Alpha()->GetPDGMass()/CLHEP::proton_mass_c2;
1057
1058 G4double emax = theParameters->MaxKinEnergy();
1059 G4double pminbba = massRatio*pminbb;
1060 if(IsVerbose()) {
1061 G4cout << "AddHeliumModels0 for <" << reg << "> a1msc: " << a1msc <<" a2msc: " << a2msc
1062 << " elimel= " << elimel << " pminbba= " << pminbba << G4endl;
1063 }
1064 // alpha++
1065 if(elimel < emax) {
1066 if(a2msc) {
1067 G4UrbanMscModel* msc = new G4UrbanMscModel();
1068 msc->SetActivationLowEnergyLimit(elimel);
1069 em_config->SetExtraEmModel("alpha", "msc", msc, reg, 0.0, emax);
1070 } else {
1071 mod = new G4IonCoulombScatteringModel();
1072 mod->SetActivationLowEnergyLimit(elimel);
1073 em_config->SetExtraEmModel("alpha", "CoulombScat", mod, reg, 0.0, emax);
1074 }
1075 }
1076
1077 mod = new G4BraggIonModel();
1078 mod->SetActivationLowEnergyLimit(hemax/massRatio);
1079 em_config->SetExtraEmModel("alpha", "ionIoni",
1080 mod, reg, 0.0, pminbba,
1081 new G4IonFluctuations());
1082
1083 mod = new G4BetheBlochModel();
1084 mod->SetActivationLowEnergyLimit(hemax/massRatio);
1085 em_config->SetExtraEmModel("alpha", "ionIoni",
1086 mod, reg, pminbba, emax,
1087 new G4IonFluctuations());
1088
1089 mod = new G4DNARuddIonisationModel();
1090 em_config->SetExtraEmModel("alpha", "alpha_G4DNAIonisation",
1091 mod, reg, 0.0, hemax);
1092
1093 mod = new G4DNAMillerGreenExcitationModel();
1094 em_config->SetExtraEmModel("alpha", "alpha_G4DNAExcitation",
1095 mod, reg, 0.0, hemax);
1096
1097 mod = new G4DNADingfelderChargeDecreaseModel();
1098 em_config->SetExtraEmModel("alpha", "alpha_G4DNAChargeDecrease",
1099 mod, reg, 0.0, hemax);
1100
1101 mod = new G4DNAIonElasticModel();
1102 em_config->SetExtraEmModel("alpha", "alpha_G4DNAElastic",
1103 mod, reg, 0.0, elimel);
1104
1105 // ---
1106 // alpha+
1107 if(elimel < emax) {
1108 if(a1msc) {
1109 G4UrbanMscModel* msc = new G4UrbanMscModel();
1110 msc->SetActivationLowEnergyLimit(elimel);
1111 em_config->SetExtraEmModel("alpha+", "msc", msc, reg, 0.0, emax);
1112 } else {
1113 mod = new G4IonCoulombScatteringModel();
1114 mod->SetActivationLowEnergyLimit(elimel);
1115 em_config->SetExtraEmModel("alpha+", "CoulombScat", mod, reg, 0.0, emax);
1116 }
1117 }
1118
1119 mod = new G4BraggIonModel();
1120 mod->SetActivationLowEnergyLimit(hemax/massRatio);
1121 em_config->SetExtraEmModel("alpha+", "hIoni",
1122 mod, reg, 0.0, pminbba,
1123 new G4IonFluctuations());
1124
1125 mod = new G4BetheBlochModel();
1126 mod->SetActivationLowEnergyLimit(hemax/massRatio);
1127 em_config->SetExtraEmModel("alpha+", "hIoni",
1128 mod, reg, pminbba, emax,
1129 new G4IonFluctuations());
1130
1131 mod = new G4DNARuddIonisationModel();
1132 em_config->SetExtraEmModel("alpha+", "alpha+_G4DNAIonisation",
1133 mod, reg, 0.0, hemax);
1134
1135 mod = new G4DNAMillerGreenExcitationModel();
1136 em_config->SetExtraEmModel("alpha+", "alpha+_G4DNAExcitation",
1137 mod, reg, 0.0, hemax);
1138
1139 mod = new G4DNADingfelderChargeDecreaseModel();
1140 em_config->SetExtraEmModel("alpha+", "alpha+_G4DNAChargeDecrease",
1141 mod, reg, 0.0, hemax);
1142
1143 mod = new G4DNADingfelderChargeIncreaseModel();
1144 em_config->SetExtraEmModel("alpha+", "alpha+_G4DNAChargeIncrease",
1145 mod, reg, 0.0, hemax);
1146
1147 mod = new G4DNAIonElasticModel();
1148 em_config->SetExtraEmModel("alpha+", "alpha+_G4DNAElastic",
1149 mod, reg, 0.0, elimel);
1150
1151 // ---
1152 // helium
1153 mod = new G4DNARuddIonisationModel();
1154 em_config->SetExtraEmModel("helium", "helium_G4DNAIonisation",
1155 mod, reg, 0.0, hemax);
1156
1157 mod = new G4DNAMillerGreenExcitationModel();
1158 em_config->SetExtraEmModel("helium", "helium_G4DNAExcitation",
1159 mod, reg, 0.0, hemax);
1160
1161 mod = new G4DNADingfelderChargeIncreaseModel();
1162 em_config->SetExtraEmModel("helium", "helium_G4DNAChargeIncrease",
1163 mod, reg, 0.0, hemax);
1164
1165 mod = new G4DNAIonElasticModel();
1166 em_config->SetExtraEmModel("helium", "helium_G4DNAElastic",
1167 mod, reg, 0.0, elimel);
1168}
1169
1170//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
1171
1172void G4EmDNAPhysicsActivator::DeactivateNuclearStopping(G4ProcessManager* pman,
1173 G4double elimel)
1174{
1175 G4ProcessVector* pv = pman->GetProcessList();
1176 G4int nproc = pman->GetProcessListLength();
1177 for(G4int i = 0; i < nproc; ++i) {
1178 if(((*pv)[i])->GetProcessSubType() == fNuclearStopping) {
1179 G4VEmProcess* proc = static_cast<G4VEmProcess*>((*pv)[i]);
1180 if(proc) {
1181 G4VEmModel* mod = new G4ICRU49NuclearStoppingModel();
1182 mod->SetActivationLowEnergyLimit(elimel);
1183 proc->SetEmModel(mod);
1184 }
1185 break;
1186 }
1187 }
1188}
1189
1190//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
1191
1192G4bool G4EmDNAPhysicsActivator::HasMsc(G4ProcessManager* pman) const
1193{
1194 G4bool res = false;
1195 G4ProcessVector* pv = pman->GetProcessList();
1196 G4int nproc = pman->GetProcessListLength();
1197 for(G4int i = 0; i < nproc; ++i)
1198 {
1199 if(((*pv)[i])->GetProcessSubType() == fMultipleScattering)
1200 {
1201 res = true;
1202 break;
1203 }
1204 }
1205 return res;
1206}
1207
1208//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
G4DNABornExcitationModel
G4DNABornExcitationModel1 G4DNABornExcitationModel
Definition: G4DNABornExcitationModel.hh:40
G4DNABornIonisationModel
#define G4DNABornIonisationModel
Definition: G4DNABornIonisationModel.hh:40
G4DNAOneStepThermalizationModel
G4TDNAOneStepThermalizationModel< DNA::Penetration::Meesungnoen2002 > G4DNAOneStepThermalizationModel
Definition: G4DNAOneStepThermalizationModel.hh:185
fNuclearStopping
@ fNuclearStopping
Definition: G4EmProcessSubType.hh:52
fMultipleScattering
@ fMultipleScattering
Definition: G4EmProcessSubType.hh:55
G4double
double G4double
Definition: G4Types.hh:83
G4bool
bool G4bool
Definition: G4Types.hh:86
G4int
int G4int
Definition: G4Types.hh:85
G4endl
#define G4endl
Definition: G4ios.hh:57
G4cout
G4GLOB_DLL std::ostream G4cout
G4Alpha::Alpha
static G4Alpha * Alpha()
Definition: G4Alpha.cc:88
G4DNAGenericIonsManager::Instance
static G4DNAGenericIonsManager * Instance(void)
Definition: G4DNAGenericIonsManager.cc:35
G4DNAGenericIonsManager::GetIon
G4ParticleDefinition * GetIon(const G4String &name)
Definition: G4DNAGenericIonsManager.cc:45
G4DNASolvationModelFactory::GetMacroDefinedModel
static G4VEmModel * GetMacroDefinedModel()
One step thermalization model can be chosen via macro using /process/dna/e-SolvationSubType Ritchie19...
Definition: G4DNAOneStepThermalizationModel.cc:294
G4Electron::Electron
static G4Electron * Electron()
Definition: G4Electron.cc:93
G4EmConfigurator::SetExtraEmModel
void SetExtraEmModel(const G4String &particleName, const G4String &processName, G4VEmModel *, const G4String &regionName="", G4double emin=0.0, G4double emax=DBL_MAX, G4VEmFluctuationModel *fm=nullptr)
Definition: G4EmConfigurator.cc:76
G4EmParameters::Instance
static G4EmParameters * Instance()
Definition: G4EmParameters.cc:67
G4EmParameters::TypesDNA
const std::vector< G4String > & TypesDNA() const
Definition: G4EmParameters.cc:1143
G4EmParameters::RegionsDNA
const std::vector< G4String > & RegionsDNA() const
Definition: G4EmParameters.cc:1138
G4EmParameters::MaxKinEnergy
G4double MaxKinEnergy() const
Definition: G4EmParameters.cc:570
G4Gamma::Gamma
static G4Gamma * Gamma()
Definition: G4Gamma.cc:85
G4GenericIon::GenericIonDefinition
static G4GenericIon * GenericIonDefinition()
Definition: G4GenericIon.cc:87
G4GenericIon::GenericIon
static G4GenericIon * GenericIon()
Definition: G4GenericIon.cc:92
G4LossTableManager::Instance
static G4LossTableManager * Instance()
Definition: G4LossTableManager.cc:87
G4LossTableManager::EmConfigurator
G4EmConfigurator * EmConfigurator()
Definition: G4LossTableManager.cc:1016
G4ParticleDefinition::GetProcessManager
G4ProcessManager * GetProcessManager() const
Definition: G4ParticleDefinition.cc:237
G4PhysicsListHelper::RegisterProcess
G4bool RegisterProcess(G4VProcess *process, G4ParticleDefinition *particle)
Definition: G4PhysicsListHelper.cc:471
G4PhysicsListHelper::GetPhysicsListHelper
static G4PhysicsListHelper * GetPhysicsListHelper()
Definition: G4PhysicsListHelper.cc:92
G4Positron::Positron
static G4Positron * Positron()
Definition: G4Positron.cc:93
G4ProcessManager::AddDiscreteProcess
G4int AddDiscreteProcess(G4VProcess *aProcess, G4int ord=ordDefault)
G4ProcessManager::GetProcessListLength
G4int GetProcessListLength() const
G4ProcessManager::GetProcessList
G4ProcessVector * GetProcessList() const
G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:92
G4VEmModel::SetActivationLowEnergyLimit
void SetActivationLowEnergyLimit(G4double)
Definition: G4VEmModel.hh:778
G4VEmProcess::SetEmModel
void SetEmModel(G4VEmModel *, G4int index=0)
Definition: G4VEmProcess.cc:203
G4Threading::IsMasterThread
G4bool IsMasterThread()
Definition: G4Threading.cc:124