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

#include <G4EmDNAChemistry.hh>

+ Inheritance diagram for G4EmDNAChemistry:

Public Member Functions

 G4EmDNAChemistry ()
 
virtual ~G4EmDNAChemistry ()
 
virtual void ConstructParticle ()
 
virtual void ConstructMolecule ()
 
virtual void ConstructProcess ()
 
virtual void ConstructDissociationChannels ()
 
virtual void ConstructReactionTable (G4DNAMolecularReactionTable *reactionTable)
 
virtual void ConstructTimeStepModel (G4DNAMolecularReactionTable *reactionTable)
 
- Public Member Functions inherited from G4VUserChemistryList
 G4VUserChemistryList (G4bool flag=true)
 
virtual ~G4VUserChemistryList ()
 
bool IsPhysicsConstructor ()
 
void ThisIsAPhysicsConstructor (G4bool flag=true)
 
virtual void ConstructMolecule ()
 
virtual void ConstructProcess ()
 
virtual void ConstructDissociationChannels ()
 
virtual void ConstructReactionTable (G4DNAMolecularReactionTable *reactionTable)=0
 
virtual void ConstructTimeStepModel (G4DNAMolecularReactionTable *reactionTable)=0
 
void BuildPhysicsTable ()
 
- 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
 
G4int GetInstanceID () const
 
virtual void TerminateWorker ()
 
void SetVerboseLevel (G4int value)
 
G4int GetVerboseLevel () const
 

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 G4VUserChemistryList
void BuildPhysicsTable (G4MoleculeDefinition *)
 
void RegisterTimeStepModel (G4VITStepModel *timeStepModel, G4double startingTime=0)
 
- 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 G4VUserChemistryList
G4int verboseLevel
 
G4bool fIsPhysicsConstructor
 
- Protected Attributes inherited from G4VPhysicsConstructor
G4int verboseLevel = 0
 
G4String namePhysics = ""
 
G4int typePhysics = 0
 
G4ParticleTable * theParticleTable = nullptr
 
G4int g4vpcInstanceID = 0
 
- Static Protected Attributes inherited from G4VPhysicsConstructor
static G4RUN_DLL G4VPCManager subInstanceManager
 

Detailed Description

Definition at line 35 of file G4EmDNAChemistry.hh.

Constructor & Destructor Documentation

◆ G4EmDNAChemistry()

G4EmDNAChemistry::G4EmDNAChemistry ( )
explicit

Definition at line 93 of file G4EmDNAChemistry.cc.

93 :
94 G4VUserChemistryList(true)
95{
96 G4DNAChemistryManager::Instance()->SetChemistryList(this);
97}
G4DNAChemistryManager::Instance
static G4DNAChemistryManager * Instance()
Definition: G4DNAChemistryManager.cc:132
G4DNAChemistryManager::SetChemistryList
void SetChemistryList(G4VUserChemistryList &)
Definition: G4DNAChemistryManager.cc:715

◆ ~G4EmDNAChemistry()

G4EmDNAChemistry::~G4EmDNAChemistry ( )
virtual

Definition at line 101 of file G4EmDNAChemistry.cc.

102{
103}

Member Function Documentation

◆ ConstructDissociationChannels()

void G4EmDNAChemistry::ConstructDissociationChannels ( )
virtual

Reimplemented from G4VUserChemistryList.

Definition at line 143 of file G4EmDNAChemistry.cc.

144{
145 //-----------------------------------
146 //Get the molecular configuration
147 G4MolecularConfiguration* OH =
148 G4MoleculeTable::Instance()->GetConfiguration("OH");
149 G4MolecularConfiguration* OHm =
150 G4MoleculeTable::Instance()->GetConfiguration("OHm");
151 G4MolecularConfiguration* e_aq =
152 G4MoleculeTable::Instance()->GetConfiguration("e_aq");
153 G4MolecularConfiguration* H2 =
154 G4MoleculeTable::Instance()->GetConfiguration("H2");
155 G4MolecularConfiguration* H3O =
156 G4MoleculeTable::Instance()->GetConfiguration("H3Op");
157 G4MolecularConfiguration* H =
158 G4MoleculeTable::Instance()->GetConfiguration("H");
159
160 //-------------------------------------
161 //Define the decay channels
162 G4MoleculeDefinition* water = G4H2O::Definition();
163 G4MolecularDissociationChannel* decCh1;
164 G4MolecularDissociationChannel* decCh2;
165
166 G4ElectronOccupancy* occ = new G4ElectronOccupancy(
167 *(water->GetGroundStateElectronOccupancy()));
168
169 //////////////////////////////////////////////////////////
170 // EXCITATIONS //
171 //////////////////////////////////////////////////////////
172 G4DNAWaterExcitationStructure waterExcitation;
173 //--------------------------------------------------------
174 //---------------Excitation on the fifth layer------------
175
176 decCh1 = new G4MolecularDissociationChannel("A^1B_1_Relaxation");
177 decCh2 = new G4MolecularDissociationChannel("A^1B_1_DissociativeDecay");
178 //Decay 1 : OH + H
179 decCh1->SetEnergy(waterExcitation.ExcitationEnergy(0));
180 decCh1->SetProbability(0.35);
181 decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::NoDisplacement);
182
183 decCh2->AddProduct(OH);
184 decCh2->AddProduct(H);
185 decCh2->SetProbability(0.65);
186 decCh2->SetDisplacementType(
187 G4DNAWaterDissociationDisplacer::A1B1_DissociationDecay);
188
189// water->AddExcitedState("A^1B_1");
190 occ->RemoveElectron(4, 1); // this is the transition form ground state to
191 occ->AddElectron(5, 1); // the first unoccupied orbital: A^1B_1
192
193 water->NewConfigurationWithElectronOccupancy("A^1B_1", *occ);
194 water->AddDecayChannel("A^1B_1", decCh1);
195 water->AddDecayChannel("A^1B_1", decCh2);
196
197 //--------------------------------------------------------
198 //---------------Excitation on the fourth layer-----------
199 decCh1 = new G4MolecularDissociationChannel("B^1A_1_Relaxation_Channel");
200 decCh2 = new G4MolecularDissociationChannel("B^1A_1_DissociativeDecay");
201 G4MolecularDissociationChannel* decCh3 = new G4MolecularDissociationChannel(
202 "B^1A_1_AutoIonisation_Channel");
203
204 //Decay 1 : energy
205 decCh1->SetEnergy(waterExcitation.ExcitationEnergy(1));
206 decCh1->SetProbability(0.3);
207
208 //Decay 2 : 2OH + H_2
209 decCh2->AddProduct(H2);
210 decCh2->AddProduct(OH);
211 decCh2->AddProduct(OH);
212 decCh2->SetProbability(0.15);
213 decCh2->SetDisplacementType(
214 G4DNAWaterDissociationDisplacer::B1A1_DissociationDecay);
215
216 //Decay 3 : OH + H_3Op + e_aq
217 decCh3->AddProduct(OH);
218 decCh3->AddProduct(H3O);
219 decCh3->AddProduct(e_aq);
220 decCh3->SetProbability(0.55);
221 decCh3->SetDisplacementType(G4DNAWaterDissociationDisplacer::AutoIonisation);
222
223 *occ = *(water->GetGroundStateElectronOccupancy());
224 occ->RemoveElectron(3); // this is the transition form ground state to
225 occ->AddElectron(5, 1); // the first unoccupied orbital: B^1A_1
226
227 water->NewConfigurationWithElectronOccupancy("B^1A_1", *occ);
228 water->AddDecayChannel("B^1A_1", decCh1);
229 water->AddDecayChannel("B^1A_1", decCh2);
230 water->AddDecayChannel("B^1A_1", decCh3);
231
232 //-------------------------------------------------------
233 //-------------------Excitation of 3rd layer-----------------
234 decCh1 = new G4MolecularDissociationChannel(
235 "Excitation3rdLayer_AutoIonisation_Channel");
236 decCh2 = new G4MolecularDissociationChannel(
237 "Excitation3rdLayer_Relaxation_Channel");
238
239 //Decay channel 1 : : OH + H_3Op + e_aq
240 decCh1->AddProduct(OH);
241 decCh1->AddProduct(H3O);
242 decCh1->AddProduct(e_aq);
243
244 decCh1->SetProbability(0.5);
245 decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::AutoIonisation);
246
247 //Decay channel 2 : energy
248 decCh2->SetEnergy(waterExcitation.ExcitationEnergy(2));
249 decCh2->SetProbability(0.5);
250
251 //Electronic configuration of this decay
252 *occ = *(water->GetGroundStateElectronOccupancy());
253 occ->RemoveElectron(2, 1);
254 occ->AddElectron(5, 1);
255
256 //Configure the water molecule
257 water->NewConfigurationWithElectronOccupancy("Excitation3rdLayer", *occ);
258 water->AddDecayChannel("Excitation3rdLayer", decCh1);
259 water->AddDecayChannel("Excitation3rdLayer", decCh2);
260
261 //-------------------------------------------------------
262 //-------------------Excitation of 2nd layer-----------------
263 decCh1 = new G4MolecularDissociationChannel(
264 "Excitation2ndLayer_AutoIonisation_Channel");
265 decCh2 = new G4MolecularDissociationChannel(
266 "Excitation2ndLayer_Relaxation_Channel");
267
268 //Decay Channel 1 : : OH + H_3Op + e_aq
269 decCh1->AddProduct(OH);
270 decCh1->AddProduct(H3O);
271 decCh1->AddProduct(e_aq);
272
273 decCh1->SetProbability(0.5);
274 decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::AutoIonisation);
275
276 //Decay channel 2 : energy
277 decCh2->SetEnergy(waterExcitation.ExcitationEnergy(3));
278 decCh2->SetProbability(0.5);
279
280 *occ = *(water->GetGroundStateElectronOccupancy());
281 occ->RemoveElectron(1, 1);
282 occ->AddElectron(5, 1);
283
284 water->NewConfigurationWithElectronOccupancy("Excitation2ndLayer", *occ);
285 water->AddDecayChannel("Excitation2ndLayer", decCh1);
286 water->AddDecayChannel("Excitation2ndLayer", decCh2);
287
288 //-------------------------------------------------------
289 //-------------------Excitation of 1st layer-----------------
290 decCh1 = new G4MolecularDissociationChannel(
291 "Excitation1stLayer_AutoIonisation_Channel");
292 decCh2 = new G4MolecularDissociationChannel(
293 "Excitation1stLayer_Relaxation_Channel");
294
295 *occ = *(water->GetGroundStateElectronOccupancy());
296 occ->RemoveElectron(0, 1);
297 occ->AddElectron(5, 1);
298
299 //Decay Channel 1 : : OH + H_3Op + e_aq
300 decCh1->AddProduct(OH);
301 decCh1->AddProduct(H3O);
302 decCh1->AddProduct(e_aq);
303 decCh1->SetProbability(0.5);
304 decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::AutoIonisation);
305
306 //Decay channel 2 : energy
307 decCh2->SetEnergy(waterExcitation.ExcitationEnergy(4));
308 decCh2->SetProbability(0.5);
309
310 water->NewConfigurationWithElectronOccupancy("Excitation1stLayer", *occ);
311 water->AddDecayChannel("Excitation1stLayer", decCh1);
312 water->AddDecayChannel("Excitation1stLayer", decCh2);
313
314 /////////////////////////////////////////////////////////
315 // IONISATION //
316 /////////////////////////////////////////////////////////
317 //--------------------------------------------------------
318 //------------------- Ionisation -------------------------
319
320 decCh1 = new G4MolecularDissociationChannel("Ionisation_Channel");
321
322 //Decay Channel 1 : : OH + H_3Op
323 decCh1->AddProduct(H3O);
324 decCh1->AddProduct(OH);
325 decCh1->SetProbability(1);
326 decCh1->SetDisplacementType(
327 G4DNAWaterDissociationDisplacer::Ionisation_DissociationDecay);
328
329 *occ = *(water->GetGroundStateElectronOccupancy());
330 occ->RemoveElectron(4, 1);
331 // this is a ionized h2O with a hole in its last orbital
332 water->NewConfigurationWithElectronOccupancy("Ionisation5", *occ);
333 water->AddDecayChannel("Ionisation5",
334 decCh1);
335
336 *occ = *(water->GetGroundStateElectronOccupancy());
337 occ->RemoveElectron(3, 1);
338 water->NewConfigurationWithElectronOccupancy("Ionisation4", *occ);
339 water->AddDecayChannel("Ionisation4",
340 new G4MolecularDissociationChannel(*decCh1));
341
342 *occ = *(water->GetGroundStateElectronOccupancy());
343 occ->RemoveElectron(2, 1);
344 water->NewConfigurationWithElectronOccupancy("Ionisation3", *occ);
345 water->AddDecayChannel("Ionisation3",
346 new G4MolecularDissociationChannel(*decCh1));
347
348 *occ = *(water->GetGroundStateElectronOccupancy());
349 occ->RemoveElectron(1, 1);
350 water->NewConfigurationWithElectronOccupancy("Ionisation2", *occ);
351 water->AddDecayChannel("Ionisation2",
352 new G4MolecularDissociationChannel(*decCh1));
353
354 *occ = *(water->GetGroundStateElectronOccupancy());
355 occ->RemoveElectron(0, 1);
356 water->NewConfigurationWithElectronOccupancy("Ionisation1", *occ);
357 water->AddDecayChannel("Ionisation1",
358 new G4MolecularDissociationChannel(*decCh1));
359
360 //////////////////////////////////////////////////////////
361 // Dissociative Attachment //
362 //////////////////////////////////////////////////////////
363 decCh1 = new G4MolecularDissociationChannel("DissociativeAttachment");
364
365 //Decay 1 : 2OH + H_2
366 decCh1->AddProduct(H2);
367 decCh1->AddProduct(OHm);
368 decCh1->AddProduct(OH);
369 decCh1->SetProbability(1);
370 decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::
371 DissociativeAttachment);
372
373 *occ = *(water->GetGroundStateElectronOccupancy());
374 occ->AddElectron(5, 1); // H_2O^-
375 water->NewConfigurationWithElectronOccupancy("DissociativeAttachment", *occ);
376 water->AddDecayChannel("DissociativeAttachment", decCh1);
377
378 //////////////////////////////////////////////////////////
379 // Electron-hole recombination //
380 //////////////////////////////////////////////////////////
381 decCh1 = new G4MolecularDissociationChannel("H2Ovib_DissociationDecay1");
382 decCh2 = new G4MolecularDissociationChannel("H2Ovib_DissociationDecay2");
383 decCh3 = new G4MolecularDissociationChannel("H2Ovib_DissociationDecay3");
384
385 //Decay 1 : 2OH + H_2
386 decCh1->AddProduct(H2);
387 decCh1->AddProduct(OH);
388 decCh1->AddProduct(OH);
389 decCh1->SetProbability(0.15);
390 decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::
391 B1A1_DissociationDecay);
392
393 //Decay 2 : OH + H
394 decCh2->AddProduct(OH);
395 decCh2->AddProduct(H);
396 decCh2->SetProbability(0.55);
397 decCh2->SetDisplacementType(G4DNAWaterDissociationDisplacer::
398 A1B1_DissociationDecay);
399
400 //Decay 3 : relaxation
401 decCh3->SetProbability(0.30);
402
403 const auto pH2Ovib = G4H2O::Definition()->NewConfiguration("H2Ovib");
404 assert(pH2Ovib != nullptr);
405
406 water->AddDecayChannel(pH2Ovib, decCh1);
407 water->AddDecayChannel(pH2Ovib, decCh2);
408 water->AddDecayChannel(pH2Ovib, decCh3);
409
410 delete occ;
411}
G4ElectronOccupancy::AddElectron
G4int AddElectron(G4int orbit, G4int number=1)
Definition: G4ElectronOccupancy.cc:139
G4ElectronOccupancy::RemoveElectron
G4int RemoveElectron(G4int orbit, G4int number=1)
Definition: G4ElectronOccupancy.cc:161
G4H2O::Definition
static G4H2O * Definition()
Definition: G4H2O.cc:42
G4MolecularDissociationChannel::AddProduct
void AddProduct(Product *, G4double displacement=0.)
Definition: G4MolecularDissociationChannel.cc:60
G4MoleculeDefinition::GetGroundStateElectronOccupancy
const G4ElectronOccupancy * GetGroundStateElectronOccupancy() const
Definition: G4MoleculeDefinition.hh:240
G4MoleculeDefinition::AddDecayChannel
void AddDecayChannel(const G4MolecularConfiguration *molConf, const G4MolecularDissociationChannel *channel)
Definition: G4MoleculeDefinition.cc:223
G4MoleculeDefinition::NewConfiguration
G4MolecularConfiguration * NewConfiguration(const G4String &excitedStateLabel)
Definition: G4MoleculeDefinition.cc:147
G4MoleculeDefinition::NewConfigurationWithElectronOccupancy
G4MolecularConfiguration * NewConfigurationWithElectronOccupancy(const G4String &excitedStateLabel, const G4ElectronOccupancy &, double decayTime=0.)
Definition: G4MoleculeDefinition.cc:170
G4MoleculeTable::GetConfiguration
G4MolecularConfiguration * GetConfiguration(const G4String &, bool mustExist=true)
Definition: G4MoleculeTable.cc:107
G4MoleculeTable::Instance
static G4MoleculeTable * Instance()
Definition: G4MoleculeTable.cc:55

◆ ConstructMolecule()

void G4EmDNAChemistry::ConstructMolecule ( )
virtual

Reimplemented from G4VUserChemistryList.

Definition at line 107 of file G4EmDNAChemistry.cc.

108{
109 //-----------------------------------
110 G4Electron::Definition(); // safety
111
112 //-----------------------------------
113 // Create the definition
114 G4H2O::Definition();
115 G4Hydrogen::Definition();
116 G4H3O::Definition();
117 G4OH::Definition();
118 G4Electron_aq::Definition();
119 G4H2O2::Definition();
120 G4H2::Definition();
121
122 //____________________________________________________________________________
123
124 G4MoleculeTable::Instance()->CreateConfiguration("H3Op", G4H3O::Definition());
125 G4MolecularConfiguration* OHm = G4MoleculeTable::Instance()->
126 CreateConfiguration("OHm", // just a tag to store and retrieve from
127 // G4MoleculeTable
128 G4OH::Definition(),
129 -1, // charge
130 5.0e-9 * (m2 / s));
131 OHm->SetMass(17.0079 * g / Avogadro * c_squared);
132 G4MoleculeTable::Instance()->CreateConfiguration("OH", G4OH::Definition());
133 G4MoleculeTable::Instance()->CreateConfiguration("e_aq",
134 G4Electron_aq::Definition());
135 G4MoleculeTable::Instance()->CreateConfiguration("H",
136 G4Hydrogen::Definition());
137 G4MoleculeTable::Instance()->CreateConfiguration("H2", G4H2::Definition());
138 G4MoleculeTable::Instance()->CreateConfiguration("H2O2", G4H2O2::Definition());
139}
G4Electron_aq::Definition
static G4Electron_aq * Definition()
Definition: G4Electron_aq.cc:45
G4Electron::Definition
static G4Electron * Definition()
Definition: G4Electron.cc:48
G4H2O2::Definition
static G4H2O2 * Definition()
Definition: G4H2O2.cc:45
G4H2::Definition
static G4H2 * Definition()
Definition: G4H2.cc:45
G4H3O::Definition
static G4H3O * Definition()
Definition: G4H3O.cc:46
G4Hydrogen::Definition
static G4Hydrogen * Definition()
Definition: G4Hydrogen.cc:45
G4MoleculeTable::CreateConfiguration
G4MolecularConfiguration * CreateConfiguration(const G4String &userIdentifier, const G4MoleculeDefinition *molDef, const G4String &configurationLabel, const G4ElectronOccupancy &eOcc)
Definition: G4MoleculeTable.cc:235
G4OH::Definition
static G4OH * Definition()
Definition: G4OH.cc:45

Referenced by ConstructParticle().

◆ ConstructParticle()

virtual void G4EmDNAChemistry::ConstructParticle ( )
inlinevirtual

Implements G4VPhysicsConstructor.

Definition at line 44 of file G4EmDNAChemistry.hh.

45 {
46 ConstructMolecule();
47 }
G4EmDNAChemistry::ConstructMolecule
virtual void ConstructMolecule()
Definition: G4EmDNAChemistry.cc:107

◆ ConstructProcess()

void G4EmDNAChemistry::ConstructProcess ( )
virtual

Reimplemented from G4VUserChemistryList.

Definition at line 492 of file G4EmDNAChemistry.cc.

493{
494 auto pPhysicsListHelper = G4PhysicsListHelper::GetPhysicsListHelper();
495
496 //===============================================================
497 // Extend vibrational to low energy
498 // Anyway, solvation of electrons is taken into account from 7.4 eV
499 // So below this threshold, for now, no accurate modeling is done
500 //
501 G4VProcess* pProcess = G4ProcessTable::GetProcessTable()->
502 FindProcess("e-_G4DNAVibExcitation", "e-");
503
504 if (pProcess != nullptr)
505 {
506 G4DNAVibExcitation* pVibExcitation = (G4DNAVibExcitation*) pProcess;
507 G4VEmModel* pModel = pVibExcitation->EmModel();
508 G4DNASancheExcitationModel* pSancheExcitationMod =
509 dynamic_cast<G4DNASancheExcitationModel*>(pModel);
510 if(pSancheExcitationMod != nullptr)
511 {
512 pSancheExcitationMod->ExtendLowEnergyLimit(0.025 * eV);
513 }
514 }
515
516 //===============================================================
517 // Electron Solvatation
518 //
519 pProcess = G4ProcessTable::GetProcessTable()->FindProcess("e-_G4DNAElectronSolvation", "e-");
520
521 if (pProcess == nullptr)
522 {
523 pPhysicsListHelper->RegisterProcess(new G4DNAElectronSolvation("e-_G4DNAElectronSolvation"),
524 G4Electron::Definition());
525 }
526
527 //===============================================================
528 // Define processes for molecules
529 //
530 G4MoleculeTable* pMoleculeTable = G4MoleculeTable::Instance();
531 G4MoleculeDefinitionIterator iterator = pMoleculeTable->GetDefintionIterator();
532 iterator.reset();
533 while (iterator())
534 {
535 G4MoleculeDefinition* pMoleculeDef = iterator.value();
536
537 if (pMoleculeDef != G4H2O::Definition())
538 {
539 G4DNABrownianTransportation* pBrownianTransport = new G4DNABrownianTransportation();
540 pPhysicsListHelper->RegisterProcess(pBrownianTransport, pMoleculeDef);
541 }
542 else
543 {
544 pMoleculeDef->GetProcessManager()->AddRestProcess(new G4DNAElectronHoleRecombination(), 2);
545 G4DNAMolecularDissociation* pDissociationProcess = new G4DNAMolecularDissociation("H2O_DNAMolecularDecay");
546 pDissociationProcess->SetDisplacer(pMoleculeDef, new G4DNAWaterDissociationDisplacer);
547 pDissociationProcess->SetVerboseLevel(1);
548
549 pMoleculeDef->GetProcessManager()->AddRestProcess(pDissociationProcess, 1);
550 }
551 }
552
553 G4DNAChemistryManager::Instance()->Initialize();
554}
G4DNAMolecularDissociation::SetDisplacer
void SetDisplacer(Species *, Displacer *)
Definition: G4DNAMolecularDissociation.cc:306
G4MoleculeTable::GetDefintionIterator
G4MoleculeDefinitionIterator GetDefintionIterator()
Definition: G4MoleculeTable.hh:119
G4ParticleDefinition::GetProcessManager
G4ProcessManager * GetProcessManager() const
Definition: G4ParticleDefinition.cc:238
G4PhysicsListHelper::GetPhysicsListHelper
static G4PhysicsListHelper * GetPhysicsListHelper()
Definition: G4PhysicsListHelper.cc:89
G4ProcessManager::AddRestProcess
G4int AddRestProcess(G4VProcess *aProcess, G4int ord=ordDefault)
G4ProcessTable::GetProcessTable
static G4ProcessTable * GetProcessTable()
Definition: G4ProcessTable.cc:108
G4ProcessTable::FindProcess
G4VProcess * FindProcess(const G4String &processName, const G4String &particleName) const
Definition: G4ProcessTable.cc:285
G4VEmProcess::EmModel
G4VEmModel * EmModel(size_t index=0) const
Definition: G4VEmProcess.hh:798
G4VProcess::SetVerboseLevel
void SetVerboseLevel(G4int value)
Definition: G4VProcess.hh:416

◆ ConstructReactionTable()

void G4EmDNAChemistry::ConstructReactionTable ( G4DNAMolecularReactionTable *  reactionTable)
virtual

Implements G4VUserChemistryList.

Definition at line 415 of file G4EmDNAChemistry.cc.

417{
418 //-----------------------------------
419 //Get the molecular configuration
420 G4MolecularConfiguration* OH =
421 G4MoleculeTable::Instance()->GetConfiguration("OH");
422 G4MolecularConfiguration* OHm =
423 G4MoleculeTable::Instance()->GetConfiguration("OHm");
424 G4MolecularConfiguration* e_aq =
425 G4MoleculeTable::Instance()->GetConfiguration("e_aq");
426 G4MolecularConfiguration* H2 =
427 G4MoleculeTable::Instance()->GetConfiguration("H2");
428 G4MolecularConfiguration* H3Op =
429 G4MoleculeTable::Instance()->GetConfiguration("H3Op");
430 G4MolecularConfiguration* H =
431 G4MoleculeTable::Instance()->GetConfiguration("H");
432 G4MolecularConfiguration* H2O2 =
433 G4MoleculeTable::Instance()->GetConfiguration("H2O2");
434
435 //------------------------------------------------------------------
436 // e_aq + e_aq + 2H2O -> H2 + 2OH-
437 G4DNAMolecularReactionData* reactionData =
438 new G4DNAMolecularReactionData(0.5e10 * (1e-3 * m3 / (mole * s)), e_aq, e_aq);
439 reactionData->AddProduct(OHm);
440 reactionData->AddProduct(OHm);
441 reactionData->AddProduct(H2);
442 theReactionTable->SetReaction(reactionData);
443 //------------------------------------------------------------------
444 // e_aq + *OH -> OH-
445 reactionData = new G4DNAMolecularReactionData(
446 2.95e10 * (1e-3 * m3 / (mole * s)), e_aq, OH);
447 reactionData->AddProduct(OHm);
448 theReactionTable->SetReaction(reactionData);
449 //------------------------------------------------------------------
450 // e_aq + H* + H2O -> H2 + OH-
451 reactionData = new G4DNAMolecularReactionData(
452 2.65e10 * (1e-3 * m3 / (mole * s)), e_aq, H);
453 reactionData->AddProduct(OHm);
454 reactionData->AddProduct(H2);
455 theReactionTable->SetReaction(reactionData);
456 //------------------------------------------------------------------
457 // e_aq + H3O+ -> H* + H2O
458 reactionData = new G4DNAMolecularReactionData(
459 2.11e10 * (1e-3 * m3 / (mole * s)), e_aq, H3Op);
460 reactionData->AddProduct(H);
461 theReactionTable->SetReaction(reactionData);
462 //------------------------------------------------------------------
463 // e_aq + H2O2 -> OH- + *OH
464 reactionData = new G4DNAMolecularReactionData(
465 1.41e10 * (1e-3 * m3 / (mole * s)), e_aq, H2O2);
466 reactionData->AddProduct(OHm);
467 reactionData->AddProduct(OH);
468 theReactionTable->SetReaction(reactionData);
469 //------------------------------------------------------------------
470 // *OH + *OH -> H2O2
471 reactionData = new G4DNAMolecularReactionData(
472 0.44e10 * (1e-3 * m3 / (mole * s)), OH, OH);
473 reactionData->AddProduct(H2O2);
474 theReactionTable->SetReaction(reactionData);
475 //------------------------------------------------------------------
476 // *OH + *H -> H2O
477 theReactionTable->SetReaction(1.44e10 * (1e-3 * m3 / (mole * s)), OH, H);
478 //------------------------------------------------------------------
479 // *H + *H -> H2
480 reactionData = new G4DNAMolecularReactionData(
481 1.20e10 * (1e-3 * m3 / (mole * s)), H, H);
482 reactionData->AddProduct(H2);
483 theReactionTable->SetReaction(reactionData);
484 //------------------------------------------------------------------
485 // H3O+ + OH- -> 2H2O
486 theReactionTable->SetReaction(1.43e11 * (1e-3 * m3 / (mole * s)), H3Op, OHm);
487 //------------------------------------------------------------------
488}

◆ ConstructTimeStepModel()

void G4EmDNAChemistry::ConstructTimeStepModel ( G4DNAMolecularReactionTable *  reactionTable)
virtual

Implements G4VUserChemistryList.

Definition at line 558 of file G4EmDNAChemistry.cc.

560{
561 G4VDNAReactionModel* reactionRadiusComputer = new G4DNASmoluchowskiReactionModel();
562 reactionTable->PrintTable(reactionRadiusComputer);
563
564 G4DNAMolecularStepByStepModel* stepByStep = new G4DNAMolecularStepByStepModel();
565 stepByStep->SetReactionModel(reactionRadiusComputer);
566// ((G4DNAMoleculeEncounterStepper*) stepByStep->GetTimeStepper())->
567// SetVerbose(5);
568
569 RegisterTimeStepModel(stepByStep, 0);
570}
G4DNAMolecularReactionTable::PrintTable
void PrintTable(G4VDNAReactionModel *=0)
Definition: G4DNAMolecularReactionTable.cc:424
G4DNAMolecularStepByStepModel::SetReactionModel
void SetReactionModel(G4VDNAReactionModel *)
Definition: G4DNAMolecularStepByStepModel.cc:87
G4VUserChemistryList::RegisterTimeStepModel
void RegisterTimeStepModel(G4VITStepModel *timeStepModel, G4double startingTime=0)
Definition: G4VUserChemistryList.cc:56
The documentation for this class was generated from the following files: