Loading...
Searching...
No Matches
Public Member Functions | Private Attributes | List of all members
scavenger::EmDNAChemistry Class Reference
medical » dna » scavenger

Chemistry constructor with reading of the user file defining chemical reactions and scavengers (reaction with background) More...

#include <Doxymodules_medical.h>

Inheritance diagram for scavenger::EmDNAChemistry:
G4VUserChemistryList G4VPhysicsConstructor G4UImessenger

Public Member Functions

 EmDNAChemistry ()
 
 ~EmDNAChemistry () override=default
 
void SetNewValue (G4UIcommand *, G4String) override
 
void ConstructParticle () override
 
void ConstructMolecule () override
 
void ConstructProcess () override
 
void ConstructDissociationChannels () override
 
void ConstructReactionTable (G4DNAMolecularReactionTable *) override
 
void ConstructTimeStepModel (G4DNAMolecularReactionTable *) override
 

Private Attributes

std::unique_ptr< G4UIdirectory > fpParserDir
 
std::unique_ptr< G4UIcmdWithAString > fpReactionTableNameCmd
 
G4String fReactionTableName = ""
 

Detailed Description

Chemistry constructor with reading of the user file defining chemical reactions and scavengers (reaction with background)

Definition at line 346 of file Doxymodules_medical.h.

Constructor & Destructor Documentation

◆ EmDNAChemistry()

scavenger::EmDNAChemistry::EmDNAChemistry ( )

Definition at line 75 of file EmDNAChemistry.cc.

76 : G4VUserChemistryList(true),
77 G4UImessenger(),
78 fpParserDir(new G4UIdirectory("/chem/reactionTable/")),
79 fpReactionTableNameCmd(new G4UIcmdWithAString("/chem/reactionTable/name", this)){
80 G4DNAChemistryManager::Instance()->SetChemistryList(this);
81 fpParserDir->SetGuidance("Chemistry control");
82 fpReactionTableNameCmd->SetGuidance("Name of the chemical reaction table");
83}
scavenger::EmDNAChemistry::fpReactionTableNameCmd
std::unique_ptr< G4UIcmdWithAString > fpReactionTableNameCmd
Definition EmDNAChemistry.hh:78
scavenger::EmDNAChemistry::fpParserDir
std::unique_ptr< G4UIdirectory > fpParserDir
Definition EmDNAChemistry.hh:77

◆ ~EmDNAChemistry()

scavenger::EmDNAChemistry::~EmDNAChemistry ( )
overridedefault

Member Function Documentation

◆ SetNewValue()

void scavenger::EmDNAChemistry::SetNewValue ( G4UIcommand *  command,
G4String  newValue 
)
override

Definition at line 87 of file EmDNAChemistry.cc.

87 {
88 if (command == fpReactionTableNameCmd.get()) {
89 fReactionTableName = newValue;
90 }
91}

◆ ConstructParticle()

void scavenger::EmDNAChemistry::ConstructParticle ( )
inlineoverride

Definition at line 62 of file EmDNAChemistry.hh.

62 {
63 ConstructMolecule();
64 }
scavenger::EmDNAChemistry::ConstructMolecule
void ConstructMolecule() override
Definition EmDNAChemistry.cc:95

◆ ConstructMolecule()

void scavenger::EmDNAChemistry::ConstructMolecule ( )
override

Definition at line 95 of file EmDNAChemistry.cc.

95 {
96 // Create the definition
97 G4H2O::Definition();
98 G4Hydrogen::Definition();
99 G4H3O::Definition();
100 G4OH::Definition();
101 G4Electron_aq::Definition();
102 G4H2O2::Definition();
103 G4H2::Definition();
104 G4Oxygen::Definition();
105 G4HO2::Definition();
106 G4O2::Definition();
107 G4O3::Definition();
108
109 auto G4NO2 = new G4MoleculeDefinition("NO_2",
110 /*mass*/ 46.0055 * g / Avogadro * c_squared,
111 /*D*/ 1.7e-9 * (m * m / s),
112 /*charge*/ 0,
113 /*electronL*/ 0,
114 /*radius*/ 0.35 * nm); // can be adjusted
115
116 auto G4NO3 = new G4MoleculeDefinition("NO_3",
117 /*mass*/ 62.0049 * g / Avogadro * c_squared,
118 /*D*/ 1.7e-9 * (m * m / s),
119 /*charge*/ 0,
120 /*electronL*/ 0,
121 /*radius*/ 0.35 * nm); // can be adjusted
122 //____________________________________________________________________________
123 // Note: Parameters Value changed according to Plante Paper
124
125 G4MoleculeTable::Instance()->CreateConfiguration("H3Op", G4H3O::Definition());
126 G4MoleculeTable::Instance()->GetConfiguration("H3Op")->SetDiffusionCoefficient(9.46e-9 * (m2 / s));
127 G4MoleculeTable::Instance()->GetConfiguration("H3Op")->SetVanDerVaalsRadius(0.25 * nm);
128
129 G4MoleculeTable::Instance()->CreateConfiguration("OH", G4OH::Definition());
130 G4MoleculeTable::Instance()->GetConfiguration("OH")->SetDiffusionCoefficient(2.2e-9 * (m2 / s));
131 G4MoleculeTable::Instance()->GetConfiguration("OH")->SetVanDerVaalsRadius(0.22 * nm);
132
133 G4MolecularConfiguration *OHm = G4MoleculeTable::Instance()->
134 CreateConfiguration("OHm", // just a tag to store and retrieve from
135 // G4MoleculeTable
136 G4OH::Definition(),
137 -1, // charge
138 5.3e-9 * (m2 / s));
139 OHm->SetMass(17.0079 * g / Avogadro * c_squared);
140 OHm->SetVanDerVaalsRadius(0.33 * nm);
141
142 G4MoleculeTable::Instance()->CreateConfiguration("e_aq", G4Electron_aq::Definition());
143 G4MoleculeTable::Instance()->GetConfiguration("e_aq")->SetVanDerVaalsRadius(0.50 * nm);
144
145 G4MoleculeTable::Instance()->CreateConfiguration("H", G4Hydrogen::Definition());
146 G4MoleculeTable::Instance()->GetConfiguration("H")->SetVanDerVaalsRadius(0.19 * nm);
147
148 G4MoleculeTable::Instance()->CreateConfiguration("H2", G4H2::Definition());
149 G4MoleculeTable::Instance()->GetConfiguration("H2")->SetDiffusionCoefficient(4.8e-9 * (m2 / s));
150 G4MoleculeTable::Instance()->GetConfiguration("H2")->SetVanDerVaalsRadius(0.14 * nm);
151
152 G4MoleculeTable::Instance()->CreateConfiguration("H2O2", G4H2O2::Definition());
153 G4MoleculeTable::Instance()->GetConfiguration("H2O2")->SetDiffusionCoefficient(2.3e-9 * (m2 / s));
154 G4MoleculeTable::Instance()->GetConfiguration("H2O2")->SetVanDerVaalsRadius(0.21 * nm);
155
156 // molecules extension (RITRACKS)
157
158 G4MoleculeTable::Instance()->CreateConfiguration("HO2", G4HO2::Definition());
159 G4MoleculeTable::Instance()->GetConfiguration("HO2")->SetVanDerVaalsRadius(0.21 * nm);
160
161 auto HO2m = G4MoleculeTable::Instance()->
162 CreateConfiguration("HO2m", // just a tag to store and retrieve from
163 // G4MoleculeTable
164 G4HO2::Definition(),
165 -1, // charge
166 1.4e-9 * (m2 / s));
167 HO2m->SetMass(33.00396 * g / Avogadro * c_squared);
168 HO2m->SetVanDerVaalsRadius(0.25 * nm);
169
170 // Oxygen 3P
171 G4MoleculeTable::Instance()->CreateConfiguration("Oxy", G4Oxygen::Definition());
172 G4MoleculeTable::Instance()->GetConfiguration("Oxy")->SetVanDerVaalsRadius(0.20 * nm);
173
174 G4MolecularConfiguration *Om = G4MoleculeTable::Instance()->
175 CreateConfiguration("Om", // just a tag to store and retrieve from
176 // G4MoleculeTable
177 G4Oxygen::Definition(),
178 -1, // charge
179 2.0e-9 * (m2 / s));
180 Om->SetMass(15.99829 * g / Avogadro * c_squared);
181 Om->SetVanDerVaalsRadius(0.25 * nm);
182
183 G4MoleculeTable::Instance()->CreateConfiguration("O2", G4O2::Definition());
184 G4MoleculeTable::Instance()->GetConfiguration("O2")->SetVanDerVaalsRadius(0.17 * nm);
185
186 auto O2m = G4MoleculeTable::Instance()->
187 CreateConfiguration("O2m", // just a tag to store and retrieve from
188 // G4MoleculeTable
189 G4O2::Definition(),
190 -1, // charge
191 1.75e-9 * (m2 / s));
192 O2m->SetMass(31.99602 * g / Avogadro * c_squared);
193 O2m->SetVanDerVaalsRadius(0.22 * nm);
194
195 G4MoleculeTable::Instance()->CreateConfiguration("O3", G4O3::Definition());
196 G4MoleculeTable::Instance()->GetConfiguration("O3")->SetVanDerVaalsRadius(0.20 * nm);
197
198 auto O3m = G4MoleculeTable::Instance()->
199 CreateConfiguration("O3m", // just a tag to store and retrieve from
200 // G4MoleculeTable
201 G4O3::Definition(),
202 -1, // charge
203 2.0e-9 * (m2 / s));
204 O3m->SetMass(47.99375 * g / Avogadro * c_squared);
205 O3m->SetVanDerVaalsRadius(0.20 * nm);
206
207 G4MoleculeTable::Instance()->CreateConfiguration("H2O(B)", // just a tag to store and retrieve from
208 // G4MoleculeTable
209 G4H2O::Definition(),
210 0, // charge
211 0 * (m2 / s));
212
213 G4MoleculeTable::Instance()->CreateConfiguration("H3Op(B)", // just a tag to store and retrieve from
214 // G4MoleculeTable
215 G4H3O::Definition(),
216 1, // charge
217 0 * (m2 / s));
218
219 G4MoleculeTable::Instance()->CreateConfiguration("OHm(B)", // just a tag to store and retrieve from
220 // G4MoleculeTable
221 G4OH::Definition(),
222 -1, // charge
223 0 * (m2 / s));
224
225 G4MoleculeTable::Instance()->CreateConfiguration("O2(B)", // just a tag to store and retrieve from
226 // G4MoleculeTable
227 G4O2::Definition(),
228 0, // charge
229 0 * (m2 / s));
230
231 G4MoleculeTable::Instance()->CreateConfiguration("NO2m(B)", // just a tag to store and retrieve from
232 // G4MoleculeTable
233 G4NO2,
234 -1, // charge
235 0 * (m2 / s));
236
237 G4MoleculeTable::Instance()->CreateConfiguration("NO3m(B)", // just a tag to store and retrieve from
238 // G4MoleculeTable
239 G4NO3,
240 -1, // charge
241 0 * (m2 / s));
242
243 // For first-order reactions
244 G4MoleculeTable::Instance()->CreateConfiguration("NoneM", G4FakeMolecule::Definition());
245}
G4MolecularConfiguration::SetVanDerVaalsRadius
void SetVanDerVaalsRadius(G4double)
G4MolecularConfiguration::SetMass
void SetMass(G4double)

◆ ConstructProcess()

void scavenger::EmDNAChemistry::ConstructProcess ( )
override

Definition at line 551 of file EmDNAChemistry.cc.

551 {
552 auto ph = G4PhysicsListHelper::GetPhysicsListHelper();
553 G4VProcess *process = G4ProcessTable::GetProcessTable()->
554 FindProcess("e-_G4DNAVibExcitation", "e-");
555 if (process) {
556 auto vibExcitation = (G4DNAVibExcitation *) process;
557 G4VEmModel *model = vibExcitation->EmModel();
558 auto sancheExcitationMod = dynamic_cast<G4DNASancheExcitationModel *>(model);
559 if (sancheExcitationMod) {
560 sancheExcitationMod->ExtendLowEnergyLimit(0.025 * eV);
561 }
562 }
563 process =
564 G4ProcessTable::GetProcessTable()->
565 FindProcess("e-_G4DNAElectronSolvation", "e-");
566
567 if (process == nullptr) {
568 ph->RegisterProcess(
569 new G4DNAElectronSolvation("e-_G4DNAElectronSolvation"),
570 G4Electron::Definition());
571 }
572 auto *theMoleculeTable = G4MoleculeTable::Instance();
573 G4MoleculeDefinitionIterator iterator =
574 theMoleculeTable->GetDefintionIterator();
575 iterator.reset();
576 while (iterator()) {
577 G4MoleculeDefinition *moleculeDef = iterator.value();
578 if (moleculeDef == G4H2O::Definition()) {
579 moleculeDef->GetProcessManager()->AddRestProcess(new G4DNAElectronHoleRecombination(), 2);
580
581 auto dissociationProcess = new G4DNAMolecularDissociation("H2O_DNAMolecularDecay");
582 dissociationProcess->SetDisplacer(moleculeDef, new G4DNAWaterDissociationDisplacer);
583 //dissociationProcess->SetVerboseLevel(3);
584 moleculeDef->GetProcessManager()->AddRestProcess(dissociationProcess, 1);
585 }
586 }
587 G4DNAChemistryManager::Instance()->Initialize();
588}

◆ ConstructDissociationChannels()

void scavenger::EmDNAChemistry::ConstructDissociationChannels ( )
override

Definition at line 249 of file EmDNAChemistry.cc.

249 {
250 //-----------------------------------
251 //Get the molecular configuration
252 auto OH = G4MoleculeTable::Instance()->GetConfiguration("OH");
253 auto OHm = G4MoleculeTable::Instance()->GetConfiguration("OHm");
254 auto e_aq = G4MoleculeTable::Instance()->GetConfiguration("e_aq");
255 auto H2 = G4MoleculeTable::Instance()->GetConfiguration("H2");
256 auto H3O = G4MoleculeTable::Instance()->GetConfiguration("H3Op");
257 auto H = G4MoleculeTable::Instance()->GetConfiguration("H");
258
259 //-------------------------------------
260 //Define the decay channels
261 auto *water = G4H2O::Definition();
262 G4MolecularDissociationChannel *decCh1;
263 G4MolecularDissociationChannel *decCh2;
264
265 auto occ = new G4ElectronOccupancy(*(water->GetGroundStateElectronOccupancy()));
266
267 //////////////////////////////////////////////////////////
268 // EXCITATIONS //
269 //////////////////////////////////////////////////////////
270 G4DNAWaterExcitationStructure waterExcitation;
271 //--------------------------------------------------------
272 //---------------Excitation on the fifth layer------------
273
274 decCh1 = new G4MolecularDissociationChannel("A^1B_1_Relaxation");
275 decCh2 = new G4MolecularDissociationChannel("A^1B_1_DissociativeDecay");
276 //Decay 1 : OH + H
277 decCh1->SetEnergy(waterExcitation.ExcitationEnergy(0));
278 decCh1->SetProbability(0.35);
279 decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::NoDisplacement);
280
281 decCh2->AddProduct(OH);
282 decCh2->AddProduct(H);
283 decCh2->SetProbability(0.65);
284 decCh2->SetDisplacementType(
285 G4DNAWaterDissociationDisplacer::A1B1_DissociationDecay);
286
287// water->AddExcitedState("A^1B_1");
288 occ->RemoveElectron(4, 1); // this is the transition form ground state to
289 occ->AddElectron(5, 1); // the first unoccupied orbital: A^1B_1
290
291 water->NewConfigurationWithElectronOccupancy("A^1B_1", *occ);
292 water->AddDecayChannel("A^1B_1", decCh1);
293 water->AddDecayChannel("A^1B_1", decCh2);
294
295 //--------------------------------------------------------
296 //---------------Excitation on the fourth layer-----------
297 decCh1 = new G4MolecularDissociationChannel("B^1A_1_Relaxation_Channel");
298 decCh2 = new G4MolecularDissociationChannel("B^1A_1_DissociativeDecay");
299 auto decCh3 = new G4MolecularDissociationChannel("B^1A_1_AutoIonisation_Channel");
300
301 //Decay 1 : energy
302 decCh1->SetEnergy(waterExcitation.ExcitationEnergy(1));
303 decCh1->SetProbability(0.3);
304
305 //Decay 2 : 2OH + H_2
306 decCh2->AddProduct(H2);
307 decCh2->AddProduct(OH);
308 decCh2->AddProduct(OH);
309 decCh2->SetProbability(0.15);
310 decCh2->SetDisplacementType(
311 G4DNAWaterDissociationDisplacer::B1A1_DissociationDecay);
312
313 //Decay 3 : OH + H_3Op + e_aq
314 decCh3->AddProduct(OH);
315 decCh3->AddProduct(H3O);
316 decCh3->AddProduct(e_aq);
317 decCh3->SetProbability(0.55);
318 decCh3->SetDisplacementType(G4DNAWaterDissociationDisplacer::AutoIonisation);
319
320 *occ = *(water->GetGroundStateElectronOccupancy());
321 occ->RemoveElectron(3); // this is the transition form ground state to
322 occ->AddElectron(5, 1); // the first unoccupied orbital: B^1A_1
323
324 water->NewConfigurationWithElectronOccupancy("B^1A_1", *occ);
325 water->AddDecayChannel("B^1A_1", decCh1);
326 water->AddDecayChannel("B^1A_1", decCh2);
327 water->AddDecayChannel("B^1A_1", decCh3);
328
329 //-------------------------------------------------------
330 //-------------------Excitation of 3rd layer-----------------
331 decCh1 = new G4MolecularDissociationChannel(
332 "Excitation3rdLayer_AutoIonisation_Channel");
333 decCh2 = new G4MolecularDissociationChannel(
334 "Excitation3rdLayer_Relaxation_Channel");
335
336 //Decay channel 1 : : OH + H_3Op + e_aq
337 decCh1->AddProduct(OH);
338 decCh1->AddProduct(H3O);
339 decCh1->AddProduct(e_aq);
340
341 decCh1->SetProbability(0.5);
342 decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::AutoIonisation);
343
344 //Decay channel 2 : energy
345 decCh2->SetEnergy(waterExcitation.ExcitationEnergy(2));
346 decCh2->SetProbability(0.5);
347
348 //Electronic configuration of this decay
349 *occ = *(water->GetGroundStateElectronOccupancy());
350 occ->RemoveElectron(2, 1);
351 occ->AddElectron(5, 1);
352
353 //Configure the water molecule
354 water->NewConfigurationWithElectronOccupancy("Excitation3rdLayer", *occ);
355 water->AddDecayChannel("Excitation3rdLayer", decCh1);
356 water->AddDecayChannel("Excitation3rdLayer", decCh2);
357
358 //-------------------------------------------------------
359 //-------------------Excitation of 2nd layer-----------------
360 decCh1 = new G4MolecularDissociationChannel(
361 "Excitation2ndLayer_AutoIonisation_Channel");
362 decCh2 = new G4MolecularDissociationChannel(
363 "Excitation2ndLayer_Relaxation_Channel");
364
365 //Decay Channel 1 : : OH + H_3Op + e_aq
366 decCh1->AddProduct(OH);
367 decCh1->AddProduct(H3O);
368 decCh1->AddProduct(e_aq);
369
370 decCh1->SetProbability(0.5);
371 decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::AutoIonisation);
372
373 //Decay channel 2 : energy
374 decCh2->SetEnergy(waterExcitation.ExcitationEnergy(3));
375 decCh2->SetProbability(0.5);
376
377 *occ = *(water->GetGroundStateElectronOccupancy());
378 occ->RemoveElectron(1, 1);
379 occ->AddElectron(5, 1);
380
381 water->NewConfigurationWithElectronOccupancy("Excitation2ndLayer", *occ);
382 water->AddDecayChannel("Excitation2ndLayer", decCh1);
383 water->AddDecayChannel("Excitation2ndLayer", decCh2);
384
385 //-------------------------------------------------------
386 //-------------------Excitation of 1st layer-----------------
387 decCh1 = new G4MolecularDissociationChannel(
388 "Excitation1stLayer_AutoIonisation_Channel");
389 decCh2 = new G4MolecularDissociationChannel(
390 "Excitation1stLayer_Relaxation_Channel");
391
392 *occ = *(water->GetGroundStateElectronOccupancy());
393 occ->RemoveElectron(0, 1);
394 occ->AddElectron(5, 1);
395
396 //Decay Channel 1 : : OH + H_3Op + e_aq
397 decCh1->AddProduct(OH);
398 decCh1->AddProduct(H3O);
399 decCh1->AddProduct(e_aq);
400 decCh1->SetProbability(0.5);
401 decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::AutoIonisation);
402
403 //Decay channel 2 : energy
404 decCh2->SetEnergy(waterExcitation.ExcitationEnergy(4));
405 decCh2->SetProbability(0.5);
406
407 water->NewConfigurationWithElectronOccupancy("Excitation1stLayer", *occ);
408 water->AddDecayChannel("Excitation1stLayer", decCh1);
409 water->AddDecayChannel("Excitation1stLayer", decCh2);
410
411 /////////////////////////////////////////////////////////
412 // IONISATION //
413 /////////////////////////////////////////////////////////
414 //--------------------------------------------------------
415 //------------------- Ionisation -------------------------
416
417 decCh1 = new G4MolecularDissociationChannel("Ionisation_Channel");
418
419 //Decay Channel 1 : : OH + H_3Op
420 decCh1->AddProduct(H3O);
421 decCh1->AddProduct(OH);
422 decCh1->SetProbability(1);
423 decCh1->SetDisplacementType(
424 G4DNAWaterDissociationDisplacer::Ionisation_DissociationDecay);
425
426 *occ = *(water->GetGroundStateElectronOccupancy());
427 occ->RemoveElectron(4, 1);
428 // this is a ionized h2O with a hole in its last orbital
429 water->NewConfigurationWithElectronOccupancy("Ionisation5", *occ);
430 water->AddDecayChannel("Ionisation5",
431 decCh1);
432
433 *occ = *(water->GetGroundStateElectronOccupancy());
434 occ->RemoveElectron(3, 1);
435 water->NewConfigurationWithElectronOccupancy("Ionisation4", *occ);
436 water->AddDecayChannel("Ionisation4",
437 new G4MolecularDissociationChannel(*decCh1));
438
439 *occ = *(water->GetGroundStateElectronOccupancy());
440 occ->RemoveElectron(2, 1);
441 water->NewConfigurationWithElectronOccupancy("Ionisation3", *occ);
442 water->AddDecayChannel("Ionisation3",
443 new G4MolecularDissociationChannel(*decCh1));
444
445 *occ = *(water->GetGroundStateElectronOccupancy());
446 occ->RemoveElectron(1, 1);
447 water->NewConfigurationWithElectronOccupancy("Ionisation2", *occ);
448 water->AddDecayChannel("Ionisation2",
449 new G4MolecularDissociationChannel(*decCh1));
450
451 *occ = *(water->GetGroundStateElectronOccupancy());
452 occ->RemoveElectron(0, 1);
453 water->NewConfigurationWithElectronOccupancy("Ionisation1", *occ);
454 water->AddDecayChannel("Ionisation1",
455 new G4MolecularDissociationChannel(*decCh1));
456
457 //////////////////////////////////////////////////////////
458 // Dissociative Attachment //
459 //////////////////////////////////////////////////////////
460 decCh1 = new G4MolecularDissociationChannel("DissociativeAttachment");
461
462 //Decay 1 : 2OH + H_2
463 decCh1->AddProduct(H2);
464 decCh1->AddProduct(OHm);
465 decCh1->AddProduct(OH);
466 decCh1->SetProbability(1);
467 decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::
468 DissociativeAttachment);
469
470 *occ = *(water->GetGroundStateElectronOccupancy());
471 occ->AddElectron(5, 1); // H_2O^-
472 water->NewConfigurationWithElectronOccupancy("DissociativeAttachment", *occ);
473 water->AddDecayChannel("DissociativeAttachment", decCh1);
474
475 //////////////////////////////////////////////////////////
476 // Electron-hole recombination //
477 //////////////////////////////////////////////////////////
478 decCh1 = new G4MolecularDissociationChannel("H2Ovib_DissociationDecay1");
479 decCh2 = new G4MolecularDissociationChannel("H2Ovib_DissociationDecay2");
480 decCh3 = new G4MolecularDissociationChannel("H2Ovib_DissociationDecay3");
481
482 //Decay 1 : 2OH + H_2
483 decCh1->AddProduct(H2);
484 decCh1->AddProduct(OH);
485 decCh1->AddProduct(OH);
486 decCh1->SetProbability(0.15);
487 decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::
488 B1A1_DissociationDecay);
489
490 //Decay 2 : OH + H
491 decCh2->AddProduct(OH);
492 decCh2->AddProduct(H);
493 decCh2->SetProbability(0.55);
494 decCh2->SetDisplacementType(G4DNAWaterDissociationDisplacer::
495 A1B1_DissociationDecay);
496
497 //Decay 3 : relaxation
498 decCh3->SetProbability(0.30);
499
500 const auto pH2Ovib = G4H2O::Definition()->NewConfiguration("H2Ovib");
501 assert(pH2Ovib != nullptr);
502
503 water->AddDecayChannel(pH2Ovib, decCh1);
504 water->AddDecayChannel(pH2Ovib, decCh2);
505 water->AddDecayChannel(pH2Ovib, decCh3);
506
507 delete occ;
508}

◆ ConstructReactionTable()

void scavenger::EmDNAChemistry::ConstructReactionTable ( G4DNAMolecularReactionTable *  theReactionTable)
override

Definition at line 512 of file EmDNAChemistry.cc.

513 {
514 // Construct chemical reactions from user input file
515 ParserChemReaction parser;
516 parser.ReadReactionFile(fReactionTableName);
517
518 auto ListReactant1 = parser.GetListReactant1();
519 auto ListReactant2 = parser.GetListReactant2();
520 auto ListProduct = parser.GetListProduct();
521 auto ListRate = parser.GetListRate();
522
523 const G4int Ntype = 5;
524 for (size_t i = 0; i < Ntype; i++) {
525 for (size_t j = 0; j < ListReactant1[i].size(); j++) {
526 G4MolecularConfiguration *Reactant1 = G4MoleculeTable::Instance()
527 ->GetConfiguration(ListReactant1[i][j]);
528 G4MolecularConfiguration *Reactant2 = G4MoleculeTable::Instance()
529 ->GetConfiguration(ListReactant2[i][j]);
530
531 auto pReactionData
532 = new G4DNAMolecularReactionData(ListRate[i][j], Reactant1, Reactant2);
533
534 for (size_t k = 0; k < ListProduct[i][j].size(); k++) {
535 G4MolecularConfiguration *Product = G4MoleculeTable::Instance()
536 ->GetConfiguration(ListProduct[i][j][k]);
537 pReactionData->AddProduct(Product);
538 }
539 // Reaction type II and IV
540 if (i == 1 || i == 3) {
541 pReactionData->SetReactionType(1);
542 }
543
544 theReactionTable->SetReaction(pReactionData);
545 }
546 }
547}
G4DNAMolecularReactionTable::SetReaction
void SetReaction(G4double observedReactionRate, Reactant *reactive1, Reactant *reactive2)

◆ ConstructTimeStepModel()

void scavenger::EmDNAChemistry::ConstructTimeStepModel ( G4DNAMolecularReactionTable *  )
override

Definition at line 592 of file EmDNAChemistry.cc.

593 {
594 auto irt = new G4DNAMolecularIRTModel();
595 RegisterTimeStepModel(irt, 0);
596}

Member Data Documentation

◆ fpParserDir

std::unique_ptr<G4UIdirectory> scavenger::EmDNAChemistry::fpParserDir
private

Definition at line 77 of file EmDNAChemistry.hh.

◆ fpReactionTableNameCmd

std::unique_ptr<G4UIcmdWithAString> scavenger::EmDNAChemistry::fpReactionTableNameCmd
private

Definition at line 78 of file EmDNAChemistry.hh.

◆ fReactionTableName

G4String scavenger::EmDNAChemistry::fReactionTableName = ""
private

Definition at line 79 of file EmDNAChemistry.hh.

The documentation for this class was generated from the following files:
Generated on Tue Jan 30 2024 12:18:47 for Geant4 examples by   doxygen 1.9.8
Applications | User Support | Publications | Collaboration