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
G4EmDNAChemistry_option1 Class Reference

#include <G4EmDNAChemistry_option1.hh>

+ Inheritance diagram for G4EmDNAChemistry_option1:

Public Member Functions

 G4EmDNAChemistry_option1 ()
 
virtual ~G4EmDNAChemistry_option1 ()
 
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 (bool flag=true)
 
virtual ~G4VUserChemistryList ()
 
bool IsPhysicsConstructor ()
 
void ThisIsAPhysicsConstructor (bool 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
 
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 G4VUserChemistryList
void RegisterTimeStepModel (G4VITStepModel *timeStepModel, double startingTime=0)
 
void BuildPhysicsTable (G4MoleculeDefinition *)
 
- 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
int verboseLevel
 
bool fIsPhysicsConstructor
 
- 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 35 of file G4EmDNAChemistry_option1.hh.

Constructor & Destructor Documentation

◆ G4EmDNAChemistry_option1()

G4EmDNAChemistry_option1::G4EmDNAChemistry_option1 ( )
explicit

Definition at line 92 of file G4EmDNAChemistry_option1.cc.

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

◆ ~G4EmDNAChemistry_option1()

G4EmDNAChemistry_option1::~G4EmDNAChemistry_option1 ( )
virtual

Definition at line 100 of file G4EmDNAChemistry_option1.cc.

101{
102}

Member Function Documentation

◆ ConstructDissociationChannels()

void G4EmDNAChemistry_option1::ConstructDissociationChannels ( )
virtual

Reimplemented from G4VUserChemistryList.

Definition at line 150 of file G4EmDNAChemistry_option1.cc.

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

◆ ConstructMolecule()

void G4EmDNAChemistry_option1::ConstructMolecule ( )
virtual

Reimplemented from G4VUserChemistryList.

Definition at line 106 of file G4EmDNAChemistry_option1.cc.

107{
108 //-----------------------------------
109 G4Electron::Definition(); // safety
110
111 //-----------------------------------
112 // Create the definition
113 G4H2O::Definition();
114 G4Hydrogen::Definition();
115 G4H3O::Definition();
116 G4OH::Definition();
117 G4Electron_aq::Definition();
118 G4H2O2::Definition();
119 G4H2::Definition();
120
121 //____________________________________________________________________________
122
123 G4MoleculeTable::Instance()->CreateConfiguration("H3Op", G4H3O::Definition());
124 G4MoleculeTable::Instance()->GetConfiguration("H3Op")->SetDiffusionCoefficient(
125 9.46e-9 * (m2/s));
126 G4MolecularConfiguration* OHm = G4MoleculeTable::Instance()->
127 CreateConfiguration("OHm", // just a tag to store and retrieve from
128 // G4MoleculeTable
129 G4OH::Definition(),
130 -1, // charge
131 5.3e-9 * (m2 / s));
132 OHm->SetMass(17.0079 * g / Avogadro * c_squared);
133 G4MoleculeTable::Instance()->CreateConfiguration("OH", G4OH::Definition());
134 G4MoleculeTable::Instance()->GetConfiguration("OH")->SetDiffusionCoefficient(
135 2.2e-9 * (m2/s));
136 G4MoleculeTable::Instance()->CreateConfiguration("e_aq",
137 G4Electron_aq::Definition());
138 G4MoleculeTable::Instance()->CreateConfiguration("H",
139 G4Hydrogen::Definition());
140 G4MoleculeTable::Instance()->CreateConfiguration("H2", G4H2::Definition());
141 G4MoleculeTable::Instance()->GetConfiguration("H2")->SetDiffusionCoefficient(
142 4.8e-9 * (m2/s));
143 G4MoleculeTable::Instance()->CreateConfiguration("H2O2", G4H2O2::Definition());
144 G4MoleculeTable::Instance()->GetConfiguration("H2O2")->SetDiffusionCoefficient(
145 2.3e-9 * (m2/s));
146}
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:233
G4OH::Definition
static G4OH * Definition()
Definition: G4OH.cc:45

Referenced by ConstructParticle().

◆ ConstructParticle()

virtual void G4EmDNAChemistry_option1::ConstructParticle ( )
inlinevirtual

Implements G4VPhysicsConstructor.

Definition at line 44 of file G4EmDNAChemistry_option1.hh.

45 {
46 ConstructMolecule();
47 }
G4EmDNAChemistry_option1::ConstructMolecule
virtual void ConstructMolecule()
Definition: G4EmDNAChemistry_option1.cc:106

◆ ConstructProcess()

void G4EmDNAChemistry_option1::ConstructProcess ( )
virtual

Reimplemented from G4VUserChemistryList.

Definition at line 467 of file G4EmDNAChemistry_option1.cc.

468{
469 G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
470
471 //===============================================================
472 // Extend vibrational to low energy
473 // Anyway, solvation of electrons is taken into account from 7.4 eV
474 // So below this threshold, for now, no accurate modeling is done
475 //
476 G4VProcess* process =
477 G4ProcessTable::GetProcessTable()->
478 FindProcess("e-_G4DNAVibExcitation", "e-");
479
480 if (process)
481 {
482 G4DNAVibExcitation* vibExcitation = (G4DNAVibExcitation*) process;
483 G4VEmModel* model = vibExcitation->EmModel();
484 G4DNASancheExcitationModel* sancheExcitationMod =
485 dynamic_cast<G4DNASancheExcitationModel*>(model);
486 if(sancheExcitationMod)
487 {
488 sancheExcitationMod->ExtendLowEnergyLimit(0.025 * eV);
489 }
490 }
491
492 //===============================================================
493 // *** Electron Solvatation ***
494 //
495 process =
496 G4ProcessTable::GetProcessTable()->
497 FindProcess("e-_G4DNAElectronSolvation", "e-");
498
499 if (process == 0)
500 {
501 ph->RegisterProcess(
502 new G4DNAElectronSolvation("e-_G4DNAElectronSolvation"),
503 G4Electron::Definition());
504 }
505
506 //===============================================================
507 // Define processes for molecules
508 //
509 G4MoleculeTable* theMoleculeTable = G4MoleculeTable::Instance();
510 G4MoleculeDefinitionIterator iterator =
511 theMoleculeTable->GetDefintionIterator();
512 iterator.reset();
513 while (iterator())
514 {
515 G4MoleculeDefinition* moleculeDef = iterator.value();
516
517 if (moleculeDef != G4H2O::Definition())
518 {
519 // G4cout << "Brownian motion added for : "
520 // << moleculeDef->GetName() << G4endl;
521 G4DNABrownianTransportation* brown = new G4DNABrownianTransportation();
522 // brown->SetVerboseLevel(4);
523 ph->RegisterProcess(brown, moleculeDef);
524 }
525 else
526 {
527 moleculeDef->GetProcessManager()
528 ->AddRestProcess(new G4DNAElectronHoleRecombination(), 2);
529 G4DNAMolecularDissociation* dissociationProcess =
530 new G4DNAMolecularDissociation("H2O_DNAMolecularDecay");
531 dissociationProcess->SetDisplacer(
532 moleculeDef, new G4DNAWaterDissociationDisplacer);
533 dissociationProcess->SetVerboseLevel(1);
534// ph->RegisterProcess(dissociationProcess, moleculeDef);
535
536 moleculeDef->GetProcessManager()
537 ->AddRestProcess(dissociationProcess, 1);
538 }
539 /*
540 * Warning : end of particles and processes are needed by
541 * EM Physics builders
542 */
543 }
544
545 G4DNAChemistryManager::Instance()->Initialize();
546}
G4DNAMolecularDissociation::SetDisplacer
void SetDisplacer(Species *, Displacer *)
Definition: G4DNAMolecularDissociation.cc:284
G4MoleculeTable::GetDefintionIterator
G4MoleculeDefinitionIterator GetDefintionIterator()
Definition: G4MoleculeTable.hh:116
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::AddRestProcess
G4int AddRestProcess(G4VProcess *aProcess, G4int ord=ordDefault)
G4ProcessTable::GetProcessTable
static G4ProcessTable * GetProcessTable()
Definition: G4ProcessTable.cc:108
G4VEmProcess::EmModel
G4VEmModel * EmModel(size_t index=0) const
Definition: G4VEmProcess.cc:211
G4VProcess::SetVerboseLevel
void SetVerboseLevel(G4int value)
Definition: G4VProcess.hh:412

◆ ConstructReactionTable()

void G4EmDNAChemistry_option1::ConstructReactionTable ( G4DNAMolecularReactionTable *  reactionTable)
virtual

Implements G4VUserChemistryList.

Definition at line 390 of file G4EmDNAChemistry_option1.cc.

392{
393 //-----------------------------------
394 //Get the molecular configuration
395 G4MolecularConfiguration* OH =
396 G4MoleculeTable::Instance()->GetConfiguration("OH");
397 G4MolecularConfiguration* OHm =
398 G4MoleculeTable::Instance()->GetConfiguration("OHm");
399 G4MolecularConfiguration* e_aq =
400 G4MoleculeTable::Instance()->GetConfiguration("e_aq");
401 G4MolecularConfiguration* H2 =
402 G4MoleculeTable::Instance()->GetConfiguration("H2");
403 G4MolecularConfiguration* H3Op =
404 G4MoleculeTable::Instance()->GetConfiguration("H3Op");
405 G4MolecularConfiguration* H =
406 G4MoleculeTable::Instance()->GetConfiguration("H");
407 G4MolecularConfiguration* H2O2 =
408 G4MoleculeTable::Instance()->GetConfiguration("H2O2");
409
410 //------------------------------------------------------------------
411 // e_aq + e_aq + 2H2O -> H2 + 2OH-
412 G4DNAMolecularReactionData* reactionData =
413 new G4DNAMolecularReactionData(0.636e10 * (1e-3 * m3 / (mole * s)), e_aq, e_aq);
414 reactionData->AddProduct(OHm);
415 reactionData->AddProduct(OHm);
416 reactionData->AddProduct(H2);
417 theReactionTable->SetReaction(reactionData);
418 //------------------------------------------------------------------
419 // e_aq + *OH -> OH-
420 reactionData = new G4DNAMolecularReactionData(
421 2.95e10 * (1e-3 * m3 / (mole * s)), e_aq, OH);
422 reactionData->AddProduct(OHm);
423 theReactionTable->SetReaction(reactionData);
424 //------------------------------------------------------------------
425 // e_aq + H* + H2O -> H2 + OH-
426 reactionData = new G4DNAMolecularReactionData(
427 2.50e10 * (1e-3 * m3 / (mole * s)), e_aq, H);
428 reactionData->AddProduct(OHm);
429 reactionData->AddProduct(H2);
430 theReactionTable->SetReaction(reactionData);
431 //------------------------------------------------------------------
432 // e_aq + H3O+ -> H* + H2O
433 reactionData = new G4DNAMolecularReactionData(
434 2.11e10 * (1e-3 * m3 / (mole * s)), e_aq, H3Op);
435 reactionData->AddProduct(H);
436 theReactionTable->SetReaction(reactionData);
437 //------------------------------------------------------------------
438 // e_aq + H2O2 -> OH- + *OH
439 reactionData = new G4DNAMolecularReactionData(
440 1.10e10 * (1e-3 * m3 / (mole * s)), e_aq, H2O2);
441 reactionData->AddProduct(OHm);
442 reactionData->AddProduct(OH);
443 theReactionTable->SetReaction(reactionData);
444 //------------------------------------------------------------------
445 // *OH + *OH -> H2O2
446 reactionData = new G4DNAMolecularReactionData(
447 0.55e10 * (1e-3 * m3 / (mole * s)), OH, OH);
448 reactionData->AddProduct(H2O2);
449 theReactionTable->SetReaction(reactionData);
450 //------------------------------------------------------------------
451 // *OH + *H -> H2O
452 theReactionTable->SetReaction(1.55e10 * (1e-3 * m3 / (mole * s)), OH, H);
453 //------------------------------------------------------------------
454 // *H + *H -> H2
455 reactionData = new G4DNAMolecularReactionData(
456 0.503e10 * (1e-3 * m3 / (mole * s)), H, H);
457 reactionData->AddProduct(H2);
458 theReactionTable->SetReaction(reactionData);
459 //------------------------------------------------------------------
460 // H3O+ + OH- -> 2H2O
461 theReactionTable->SetReaction(1.13e11 * (1e-3 * m3 / (mole * s)), H3Op, OHm);
462 //------------------------------------------------------------------
463}

◆ ConstructTimeStepModel()

void G4EmDNAChemistry_option1::ConstructTimeStepModel ( G4DNAMolecularReactionTable *  reactionTable)
virtual

The reaction model defines how to compute the reaction range between molecules

The StepByStep model tells the step manager how to behave before and after each step, how to compute the time steps.

Implements G4VUserChemistryList.

Definition at line 550 of file G4EmDNAChemistry_option1.cc.

552{
553
554 //=========================================
555 // Diffusion controlled reaction model
556 //=========================================
557 /**
558 * The reaction model defines how to compute the reaction range between
559 * molecules
560 */
561
562 G4VDNAReactionModel* reactionRadiusComputer =
563 new G4DNASmoluchowskiReactionModel();
564 reactionTable->PrintTable(reactionRadiusComputer);
565
566 /**
567 * The StepByStep model tells the step manager how to behave before and
568 * after each step, how to compute the time steps.
569 */
570
571 G4DNAMolecularStepByStepModel* stepByStep =
572 new G4DNAMolecularStepByStepModel();
573 stepByStep->SetReactionModel(reactionRadiusComputer);
574// ((G4DNAMoleculeEncounterStepper*) stepByStep->GetTimeStepper())->
575// SetVerbose(5);
576
577 RegisterTimeStepModel(stepByStep, 0);
578}
G4DNAMolecularReactionTable::PrintTable
void PrintTable(G4VDNAReactionModel *=0)
Definition: G4DNAMolecularReactionTable.cc:423
G4DNAMolecularStepByStepModel::SetReactionModel
void SetReactionModel(G4VDNAReactionModel *)
Definition: G4DNAMolecularStepByStepModel.cc:87
G4VUserChemistryList::RegisterTimeStepModel
void RegisterTimeStepModel(G4VITStepModel *timeStepModel, double startingTime=0)
Definition: G4VUserChemistryList.cc:56
The documentation for this class was generated from the following files: