Geant4 10.7.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
Public Member Functions | List of all members
G4EmDNAPhysicsActivator Class Reference

#include <G4EmDNAPhysicsActivator.hh>

+ Inheritance diagram for G4EmDNAPhysicsActivator:

Public Member Functions

 G4EmDNAPhysicsActivator (G4int ver=1)
 
 ~G4EmDNAPhysicsActivator () override
 
void ConstructParticle () override
 
void ConstructProcess () override
 
- Public Member Functions inherited from G4VPhysicsConstructor
 G4VPhysicsConstructor (const G4String &="")
 
 G4VPhysicsConstructor (const G4String &name, G4int physics_type)
 
virtual ~G4VPhysicsConstructor ()
 
virtual void ConstructParticle ()=0
 
virtual void ConstructProcess ()=0
 
void SetPhysicsName (const G4String &="")
 
const G4String & GetPhysicsName () const
 
void SetPhysicsType (G4int)
 
G4int GetPhysicsType () const
 
void SetVerboseLevel (G4int value)
 
G4int GetVerboseLevel () const
 
G4int GetInstanceID () const
 
virtual void TerminateWorker ()
 

Additional Inherited Members

- Static Public Member Functions inherited from G4VPhysicsConstructor
static const G4VPCManager & GetSubInstanceManager ()
 
- Protected Types inherited from G4VPhysicsConstructor
using PhysicsBuilder_V = G4VPCData::PhysicsBuilders_V
 
- Protected Member Functions inherited from G4VPhysicsConstructor
G4bool RegisterProcess (G4VProcess *process, G4ParticleDefinition *particle)
 
G4ParticleTable::G4PTblDicIterator * GetParticleIterator () const
 
PhysicsBuilder_V GetBuilders () const
 
void AddBuilder (G4PhysicsBuilderInterface *bld)
 
- 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 39 of file G4EmDNAPhysicsActivator.hh.

Constructor & Destructor Documentation

◆ G4EmDNAPhysicsActivator()

G4EmDNAPhysicsActivator::G4EmDNAPhysicsActivator ( G4int  ver = 1)
explicit

Definition at line 101 of file G4EmDNAPhysicsActivator.cc.

102 : G4VPhysicsConstructor("G4EmDNAPhysicsActivator"), verbose(ver)
103{
104 theParameters = G4EmParameters::Instance();
105 theParameters->ActivateDNA();
106}
G4EmParameters::Instance
static G4EmParameters * Instance()
Definition: G4EmParameters.cc:67

◆ ~G4EmDNAPhysicsActivator()

G4EmDNAPhysicsActivator::~G4EmDNAPhysicsActivator ( )
override

Definition at line 110 of file G4EmDNAPhysicsActivator.cc.

111{}

Member Function Documentation

◆ ConstructParticle()

void G4EmDNAPhysicsActivator::ConstructParticle ( )
overridevirtual

Implements G4VPhysicsConstructor.

Definition at line 120 of file G4EmDNAPhysicsActivator.cc.

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}
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
G4Electron::Electron
static G4Electron * Electron()
Definition: G4Electron.cc:93
G4Gamma::Gamma
static G4Gamma * Gamma()
Definition: G4Gamma.cc:85
G4GenericIon::GenericIonDefinition
static G4GenericIon * GenericIonDefinition()
Definition: G4GenericIon.cc:87
G4Positron::Positron
static G4Positron * Positron()
Definition: G4Positron.cc:93
G4Proton::Proton
static G4Proton * Proton()
Definition: G4Proton.cc:92

◆ ConstructProcess()

void G4EmDNAPhysicsActivator::ConstructProcess ( )
overridevirtual

Implements G4VPhysicsConstructor.

Definition at line 149 of file G4EmDNAPhysicsActivator.cc.

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}
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
G4DNASolvationModelFactory::GetMacroDefinedModel
static G4VEmModel * GetMacroDefinedModel()
One step thermalization model can be chosen via macro using /process/dna/e-SolvationSubType Ritchie19...
Definition: G4DNAOneStepThermalizationModel.cc:294
G4EmParameters::TypesDNA
const std::vector< G4String > & TypesDNA() const
Definition: G4EmParameters.cc:1143
G4EmParameters::RegionsDNA
const std::vector< G4String > & RegionsDNA() const
Definition: G4EmParameters.cc:1138
G4GenericIon::GenericIon
static G4GenericIon * GenericIon()
Definition: G4GenericIon.cc:92
G4LossTableManager::Instance
static G4LossTableManager * Instance()
Definition: G4LossTableManager.cc:87
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
G4ProcessManager::AddDiscreteProcess
G4int AddDiscreteProcess(G4VProcess *aProcess, G4int ord=ordDefault)
G4VEmProcess::SetEmModel
void SetEmModel(G4VEmModel *, G4int index=0)
Definition: G4VEmProcess.cc:203
The documentation for this class was generated from the following files: