scavenger/src/EmDNAChemistry.cc

0001 // ********************************************************************
0002 // * License and Disclaimer                                           *
0003 // *                                                                  *
0004 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
0005 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
0006 // * conditions of the Geant4 Software License,  included in the file *
0007 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
0008 // * include a list of copyright holders.                             *
0009 // *                                                                  *
0010 // * Neither the authors of this software system, nor their employing *
0011 // * institutes,nor the agencies providing financial support for this *
0012 // * work  make  any representation or  warranty, express or implied, *
0013 // * regarding  this  software system or assume any liability for its *
0014 // * use.  Please see the license in the file  LICENSE  and URL above *
0015 // * for the full disclaimer and the limitation of liability.         *
0016 // *                                                                  *
0017 // * This  code  implementation is the result of  the  scientific and *
0018 // * technical work of the GEANT4 collaboration.                      *
0019 // * By using,  copying,  modifying or  distributing the software (or *
0020 // * any work based  on the software)  you  agree  to acknowledge its *
0021 // * use  in  resulting  scientific  publications,  and indicate your *
0022 // * acceptance of all terms of the Geant4 Software license.          *
0023 // ********************************************************************
0024 //
0025 /// \file scavenger/src/EmDNAChemistry.cc
0026 /// \brief Implementation of the scavenger::EmDNAChemistry class
0027
0028 #include "EmDNAChemistry.hh"
0029
0030 #include "G4DNAChemistryManager.hh"
0031 #include "G4DNAElectronHoleRecombination.hh"
0032 #include "G4DNAElectronSolvation.hh"
0033 #include "G4DNAIRT.hh"
0034 #include "G4DNAMolecularDissociation.hh"
0035 #include "G4DNAMolecularIRTModel.hh"
0036 #include "G4DNAMolecularReactionTable.hh"
0037 #include "G4DNASancheExcitationModel.hh"
0038 #include "G4DNAUeharaScreenedRutherfordElasticModel.hh"
0039 #include "G4DNAVibExcitation.hh"
0040 #include "G4DNAWaterDissociationDisplacer.hh"
0041 #include "G4DNAWaterExcitationStructure.hh"
0042 #include "G4PhysicalConstants.hh"
0043 #include "G4ProcessManager.hh"
0044 #include "G4SystemOfUnits.hh"
0045 #include "G4VDNAReactionModel.hh"
0046 // particles
0047 #include "G4Electron.hh"
0048 #include "G4Electron_aq.hh"
0049 #include "G4FakeMolecule.hh"
0050 #include "G4H2.hh"
0051 #include "G4H2O.hh"
0052 #include "G4H2O2.hh"
0053 #include "G4H3O.hh"
0054 #include "G4HO2.hh"
0055 #include "G4Hydrogen.hh"
0056 #include "G4MoleculeTable.hh"
0057 #include "G4O2.hh"
0058 #include "G4O3.hh"
0059 #include "G4OH.hh"
0060 #include "G4Oxygen.hh"
0061 #include "G4PhysicsListHelper.hh"
0062 /****/
0063 #include "G4MolecularConfiguration.hh"
0064 #include "G4ProcessTable.hh"
0065 /****/
0066 // factory
0067 #include "G4PhysicsConstructorFactory.hh"
0068 namespace scavenger
0069 {
0070
0071 G4_DECLARE_PHYSCONSTR_FACTORY(EmDNAChemistry);
0072
0073 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
0074
0075 EmDNAChemistry::EmDNAChemistry()
0076   : G4VUserChemistryList(true),
0077     G4UImessenger(),
0078     fpParserDir(new G4UIdirectory("/chem/reactionTable/")),
0079     fpReactionTableNameCmd(new G4UIcmdWithAString("/chem/reactionTable/name", this))
0080 {
0081   G4DNAChemistryManager::Instance()->SetChemistryList(this);
0082   fpParserDir->SetGuidance("Chemistry control");
0083   fpReactionTableNameCmd->SetGuidance("Name of the chemical reaction table");
0084 }
0085
0086 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo.....
0087
0088 void EmDNAChemistry::SetNewValue(G4UIcommand* command, G4String newValue)
0089 {
0090   if (command == fpReactionTableNameCmd.get()) {
0091     fReactionTableName = newValue;
0092   }
0093 }
0094
0095 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
0096
0097 void EmDNAChemistry::ConstructMolecule()
0098 {
0099   // Create the definition
0100   G4H2O::Definition();
0101   G4Hydrogen::Definition();
0102   G4H3O::Definition();
0103   G4OH::Definition();
0104   G4Electron_aq::Definition();
0105   G4H2O2::Definition();
0106   G4H2::Definition();
0107   G4Oxygen::Definition();
0108   G4HO2::Definition();
0109   G4O2::Definition();
0110   G4O3::Definition();
0111
0112   auto G4NO2 = new G4MoleculeDefinition("NO_2",
0113                                         /*mass*/ 46.0055 * g / Avogadro * c_squared,
0114                                         /*D*/ 1.7e-9 * (m * m / s),
0115                                         /*charge*/ 0,
0116                                         /*electronL*/ 0,
0117                                         /*radius*/ 0.35 * nm);  // can be adjusted
0118
0119   auto G4NO3 = new G4MoleculeDefinition("NO_3",
0120                                         /*mass*/ 62.0049 * g / Avogadro * c_squared,
0121                                         /*D*/ 1.7e-9 * (m * m / s),
0122                                         /*charge*/ 0,
0123                                         /*electronL*/ 0,
0124                                         /*radius*/ 0.35 * nm);  // can be adjusted
0125   //____________________________________________________________________________
0126   // Note: Parameters Value changed according to Plante Paper
0127
0128   G4MoleculeTable::Instance()->CreateConfiguration("H3Op", G4H3O::Definition());
0129   G4MoleculeTable::Instance()->GetConfiguration("H3Op")->SetDiffusionCoefficient(9.46e-9
0130                                                                                  * (m2 / s));
0131   G4MoleculeTable::Instance()->GetConfiguration("H3Op")->SetVanDerVaalsRadius(0.25 * nm);
0132
0133   G4MoleculeTable::Instance()->CreateConfiguration("OH", G4OH::Definition());
0134   G4MoleculeTable::Instance()->GetConfiguration("OH")->SetDiffusionCoefficient(2.2e-9 * (m2 / s));
0135   G4MoleculeTable::Instance()->GetConfiguration("OH")->SetVanDerVaalsRadius(0.22 * nm);
0136
0137   G4MolecularConfiguration* OHm = G4MoleculeTable::Instance()->CreateConfiguration(
0138     "OHm",  // just a tag to store and retrieve from
0139     // G4MoleculeTable
0140     G4OH::Definition(),
0141     -1,  // charge
0142     5.3e-9 * (m2 / s));
0143   OHm->SetMass(17.0079 * g / Avogadro * c_squared);
0144   OHm->SetVanDerVaalsRadius(0.33 * nm);
0145
0146   G4MoleculeTable::Instance()->CreateConfiguration("e_aq", G4Electron_aq::Definition());
0147   G4MoleculeTable::Instance()->GetConfiguration("e_aq")->SetVanDerVaalsRadius(0.50 * nm);
0148
0149   G4MoleculeTable::Instance()->CreateConfiguration("H", G4Hydrogen::Definition());
0150   G4MoleculeTable::Instance()->GetConfiguration("H")->SetVanDerVaalsRadius(0.19 * nm);
0151
0152   G4MoleculeTable::Instance()->CreateConfiguration("H2", G4H2::Definition());
0153   G4MoleculeTable::Instance()->GetConfiguration("H2")->SetDiffusionCoefficient(4.8e-9 * (m2 / s));
0154   G4MoleculeTable::Instance()->GetConfiguration("H2")->SetVanDerVaalsRadius(0.14 * nm);
0155
0156   G4MoleculeTable::Instance()->CreateConfiguration("H2O2", G4H2O2::Definition());
0157   G4MoleculeTable::Instance()->GetConfiguration("H2O2")->SetDiffusionCoefficient(2.3e-9 * (m2 / s));
0158   G4MoleculeTable::Instance()->GetConfiguration("H2O2")->SetVanDerVaalsRadius(0.21 * nm);
0159
0160   // molecules extension (RITRACKS)
0161
0162   G4MoleculeTable::Instance()->CreateConfiguration("HO2", G4HO2::Definition());
0163   G4MoleculeTable::Instance()->GetConfiguration("HO2")->SetVanDerVaalsRadius(0.21 * nm);
0164
0165   auto HO2m = G4MoleculeTable::Instance()->CreateConfiguration(
0166     "HO2m",  // just a tag to store and retrieve from
0167     // G4MoleculeTable
0168     G4HO2::Definition(),
0169     -1,  // charge
0170     1.4e-9 * (m2 / s));
0171   HO2m->SetMass(33.00396 * g / Avogadro * c_squared);
0172   HO2m->SetVanDerVaalsRadius(0.25 * nm);
0173
0174   // Oxygen 3P
0175   G4MoleculeTable::Instance()->CreateConfiguration("Oxy", G4Oxygen::Definition());
0176   G4MoleculeTable::Instance()->GetConfiguration("Oxy")->SetVanDerVaalsRadius(0.20 * nm);
0177
0178   G4MolecularConfiguration* Om =
0179     G4MoleculeTable::Instance()->CreateConfiguration("Om",  // just a tag to store and retrieve from
0180                                                             // G4MoleculeTable
0181                                                      G4Oxygen::Definition(),
0182                                                      -1,  // charge
0183                                                      2.0e-9 * (m2 / s));
0184   Om->SetMass(15.99829 * g / Avogadro * c_squared);
0185   Om->SetVanDerVaalsRadius(0.25 * nm);
0186
0187   G4MoleculeTable::Instance()->CreateConfiguration("O2", G4O2::Definition());
0188   G4MoleculeTable::Instance()->GetConfiguration("O2")->SetVanDerVaalsRadius(0.17 * nm);
0189
0190   auto O2m = G4MoleculeTable::Instance()->CreateConfiguration(
0191     "O2m",  // just a tag to store and retrieve from
0192     // G4MoleculeTable
0193     G4O2::Definition(),
0194     -1,  // charge
0195     1.75e-9 * (m2 / s));
0196   O2m->SetMass(31.99602 * g / Avogadro * c_squared);
0197   O2m->SetVanDerVaalsRadius(0.22 * nm);
0198
0199   G4MoleculeTable::Instance()->CreateConfiguration("O3", G4O3::Definition());
0200   G4MoleculeTable::Instance()->GetConfiguration("O3")->SetVanDerVaalsRadius(0.20 * nm);
0201
0202   auto O3m = G4MoleculeTable::Instance()->CreateConfiguration(
0203     "O3m",  // just a tag to store and retrieve from
0204     // G4MoleculeTable
0205     G4O3::Definition(),
0206     -1,  // charge
0207     2.0e-9 * (m2 / s));
0208   O3m->SetMass(47.99375 * g / Avogadro * c_squared);
0209   O3m->SetVanDerVaalsRadius(0.20 * nm);
0210
0211   G4MoleculeTable::Instance()->CreateConfiguration("H2O(B)",  // just a tag to store and retrieve
0212                                                               // from G4MoleculeTable
0213                                                    G4H2O::Definition(),
0214                                                    0,  // charge
0215                                                    0 * (m2 / s));
0216
0217   G4MoleculeTable::Instance()->CreateConfiguration("H3Op(B)",  // just a tag to store and retrieve
0218                                                                // from G4MoleculeTable
0219                                                    G4H3O::Definition(),
0220                                                    1,  // charge
0221                                                    0 * (m2 / s));
0222
0223   G4MoleculeTable::Instance()->CreateConfiguration("OHm(B)",  // just a tag to store and retrieve
0224                                                               // from G4MoleculeTable
0225                                                    G4OH::Definition(),
0226                                                    -1,  // charge
0227                                                    0 * (m2 / s));
0228
0229   G4MoleculeTable::Instance()->CreateConfiguration("O2(B)",  // just a tag to store and retrieve
0230                                                              // from G4MoleculeTable
0231                                                    G4O2::Definition(),
0232                                                    0,  // charge
0233                                                    0 * (m2 / s));
0234
0235   G4MoleculeTable::Instance()->CreateConfiguration("NO2m(B)",  // just a tag to store and retrieve
0236                                                                // from G4MoleculeTable
0237                                                    G4NO2,
0238                                                    -1,  // charge
0239                                                    0 * (m2 / s));
0240
0241   G4MoleculeTable::Instance()->CreateConfiguration("NO3m(B)",  // just a tag to store and retrieve
0242                                                                // from G4MoleculeTable
0243                                                    G4NO3,
0244                                                    -1,  // charge
0245                                                    0 * (m2 / s));
0246
0247   // For first-order reactions
0248   G4MoleculeTable::Instance()->CreateConfiguration("NoneM", G4FakeMolecule::Definition());
0249 }
0250
0251 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
0252
0253 void EmDNAChemistry::ConstructDissociationChannels()
0254 {
0255   //-----------------------------------
0256   // Get the molecular configuration
0257   auto OH = G4MoleculeTable::Instance()->GetConfiguration("OH");
0258   auto OHm = G4MoleculeTable::Instance()->GetConfiguration("OHm");
0259   auto e_aq = G4MoleculeTable::Instance()->GetConfiguration("e_aq");
0260   auto H2 = G4MoleculeTable::Instance()->GetConfiguration("H2");
0261   auto H3O = G4MoleculeTable::Instance()->GetConfiguration("H3Op");
0262   auto H = G4MoleculeTable::Instance()->GetConfiguration("H");
0263
0264   //-------------------------------------
0265   // Define the decay channels
0266   auto* water = G4H2O::Definition();
0267   G4MolecularDissociationChannel* decCh1;
0268   G4MolecularDissociationChannel* decCh2;
0269
0270   auto occ = new G4ElectronOccupancy(*(water->GetGroundStateElectronOccupancy()));
0271
0272   //////////////////////////////////////////////////////////
0273   //            EXCITATIONS                               //
0274   //////////////////////////////////////////////////////////
0275   G4DNAWaterExcitationStructure waterExcitation;
0276   //--------------------------------------------------------
0277   //---------------Excitation on the fifth layer------------
0278
0279   decCh1 = new G4MolecularDissociationChannel("A^1B_1_Relaxation");
0280   decCh2 = new G4MolecularDissociationChannel("A^1B_1_DissociativeDecay");
0281   // Decay 1 : OH + H
0282   decCh1->SetEnergy(waterExcitation.ExcitationEnergy(0));
0283   decCh1->SetProbability(0.35);
0284   decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::NoDisplacement);
0285
0286   decCh2->AddProduct(OH);
0287   decCh2->AddProduct(H);
0288   decCh2->SetProbability(0.65);
0289   decCh2->SetDisplacementType(G4DNAWaterDissociationDisplacer::A1B1_DissociationDecay);
0290
0291   //  water->AddExcitedState("A^1B_1");
0292   occ->RemoveElectron(4, 1);  // this is the transition form ground state to
0293   occ->AddElectron(5, 1);  // the first unoccupied orbital: A^1B_1
0294
0295   water->NewConfigurationWithElectronOccupancy("A^1B_1", *occ);
0296   water->AddDecayChannel("A^1B_1", decCh1);
0297   water->AddDecayChannel("A^1B_1", decCh2);
0298
0299   //--------------------------------------------------------
0300   //---------------Excitation on the fourth layer-----------
0301   decCh1 = new G4MolecularDissociationChannel("B^1A_1_Relaxation_Channel");
0302   decCh2 = new G4MolecularDissociationChannel("B^1A_1_DissociativeDecay");
0303   auto decCh3 = new G4MolecularDissociationChannel("B^1A_1_AutoIonisation_Channel");
0304
0305   // Decay 1 : energy
0306   decCh1->SetEnergy(waterExcitation.ExcitationEnergy(1));
0307   decCh1->SetProbability(0.3);
0308
0309   // Decay 2 : 2OH + H_2
0310   decCh2->AddProduct(H2);
0311   decCh2->AddProduct(OH);
0312   decCh2->AddProduct(OH);
0313   decCh2->SetProbability(0.15);
0314   decCh2->SetDisplacementType(G4DNAWaterDissociationDisplacer::B1A1_DissociationDecay);
0315
0316   // Decay 3 : OH + H_3Op + e_aq
0317   decCh3->AddProduct(OH);
0318   decCh3->AddProduct(H3O);
0319   decCh3->AddProduct(e_aq);
0320   decCh3->SetProbability(0.55);
0321   decCh3->SetDisplacementType(G4DNAWaterDissociationDisplacer::AutoIonisation);
0322
0323   *occ = *(water->GetGroundStateElectronOccupancy());
0324   occ->RemoveElectron(3);  // this is the transition form ground state to
0325   occ->AddElectron(5, 1);  // the first unoccupied orbital: B^1A_1
0326
0327   water->NewConfigurationWithElectronOccupancy("B^1A_1", *occ);
0328   water->AddDecayChannel("B^1A_1", decCh1);
0329   water->AddDecayChannel("B^1A_1", decCh2);
0330   water->AddDecayChannel("B^1A_1", decCh3);
0331
0332   //-------------------------------------------------------
0333   //-------------------Excitation of 3rd layer-----------------
0334   decCh1 = new G4MolecularDissociationChannel("Excitation3rdLayer_AutoIonisation_Channel");
0335   decCh2 = new G4MolecularDissociationChannel("Excitation3rdLayer_Relaxation_Channel");
0336
0337   // Decay channel 1 : : OH + H_3Op + e_aq
0338   decCh1->AddProduct(OH);
0339   decCh1->AddProduct(H3O);
0340   decCh1->AddProduct(e_aq);
0341
0342   decCh1->SetProbability(0.5);
0343   decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::AutoIonisation);
0344
0345   // Decay channel 2 : energy
0346   decCh2->SetEnergy(waterExcitation.ExcitationEnergy(2));
0347   decCh2->SetProbability(0.5);
0348
0349   // Electronic configuration of this decay
0350   *occ = *(water->GetGroundStateElectronOccupancy());
0351   occ->RemoveElectron(2, 1);
0352   occ->AddElectron(5, 1);
0353
0354   // Configure the water molecule
0355   water->NewConfigurationWithElectronOccupancy("Excitation3rdLayer", *occ);
0356   water->AddDecayChannel("Excitation3rdLayer", decCh1);
0357   water->AddDecayChannel("Excitation3rdLayer", decCh2);
0358
0359   //-------------------------------------------------------
0360   //-------------------Excitation of 2nd layer-----------------
0361   decCh1 = new G4MolecularDissociationChannel("Excitation2ndLayer_AutoIonisation_Channel");
0362   decCh2 = new G4MolecularDissociationChannel("Excitation2ndLayer_Relaxation_Channel");
0363
0364   // Decay Channel 1 : : OH + H_3Op + e_aq
0365   decCh1->AddProduct(OH);
0366   decCh1->AddProduct(H3O);
0367   decCh1->AddProduct(e_aq);
0368
0369   decCh1->SetProbability(0.5);
0370   decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::AutoIonisation);
0371
0372   // Decay channel 2 : energy
0373   decCh2->SetEnergy(waterExcitation.ExcitationEnergy(3));
0374   decCh2->SetProbability(0.5);
0375
0376   *occ = *(water->GetGroundStateElectronOccupancy());
0377   occ->RemoveElectron(1, 1);
0378   occ->AddElectron(5, 1);
0379
0380   water->NewConfigurationWithElectronOccupancy("Excitation2ndLayer", *occ);
0381   water->AddDecayChannel("Excitation2ndLayer", decCh1);
0382   water->AddDecayChannel("Excitation2ndLayer", decCh2);
0383
0384   //-------------------------------------------------------
0385   //-------------------Excitation of 1st layer-----------------
0386   decCh1 = new G4MolecularDissociationChannel("Excitation1stLayer_AutoIonisation_Channel");
0387   decCh2 = new G4MolecularDissociationChannel("Excitation1stLayer_Relaxation_Channel");
0388
0389   *occ = *(water->GetGroundStateElectronOccupancy());
0390   occ->RemoveElectron(0, 1);
0391   occ->AddElectron(5, 1);
0392
0393   // Decay Channel 1 : : OH + H_3Op + e_aq
0394   decCh1->AddProduct(OH);
0395   decCh1->AddProduct(H3O);
0396   decCh1->AddProduct(e_aq);
0397   decCh1->SetProbability(0.5);
0398   decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::AutoIonisation);
0399
0400   // Decay channel 2 : energy
0401   decCh2->SetEnergy(waterExcitation.ExcitationEnergy(4));
0402   decCh2->SetProbability(0.5);
0403
0404   water->NewConfigurationWithElectronOccupancy("Excitation1stLayer", *occ);
0405   water->AddDecayChannel("Excitation1stLayer", decCh1);
0406   water->AddDecayChannel("Excitation1stLayer", decCh2);
0407
0408   /////////////////////////////////////////////////////////
0409   //                  IONISATION                         //
0410   /////////////////////////////////////////////////////////
0411   //--------------------------------------------------------
0412   //------------------- Ionisation -------------------------
0413
0414   decCh1 = new G4MolecularDissociationChannel("Ionisation_Channel");
0415
0416   // Decay Channel 1 : : OH + H_3Op
0417   decCh1->AddProduct(H3O);
0418   decCh1->AddProduct(OH);
0419   decCh1->SetProbability(1);
0420   decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::Ionisation_DissociationDecay);
0421
0422   *occ = *(water->GetGroundStateElectronOccupancy());
0423   occ->RemoveElectron(4, 1);
0424   // this is a ionized h2O with a hole in its last orbital
0425   water->NewConfigurationWithElectronOccupancy("Ionisation5", *occ);
0426   water->AddDecayChannel("Ionisation5", decCh1);
0427
0428   *occ = *(water->GetGroundStateElectronOccupancy());
0429   occ->RemoveElectron(3, 1);
0430   water->NewConfigurationWithElectronOccupancy("Ionisation4", *occ);
0431   water->AddDecayChannel("Ionisation4", new G4MolecularDissociationChannel(*decCh1));
0432
0433   *occ = *(water->GetGroundStateElectronOccupancy());
0434   occ->RemoveElectron(2, 1);
0435   water->NewConfigurationWithElectronOccupancy("Ionisation3", *occ);
0436   water->AddDecayChannel("Ionisation3", new G4MolecularDissociationChannel(*decCh1));
0437
0438   *occ = *(water->GetGroundStateElectronOccupancy());
0439   occ->RemoveElectron(1, 1);
0440   water->NewConfigurationWithElectronOccupancy("Ionisation2", *occ);
0441   water->AddDecayChannel("Ionisation2", new G4MolecularDissociationChannel(*decCh1));
0442
0443   *occ = *(water->GetGroundStateElectronOccupancy());
0444   occ->RemoveElectron(0, 1);
0445   water->NewConfigurationWithElectronOccupancy("Ionisation1", *occ);
0446   water->AddDecayChannel("Ionisation1", new G4MolecularDissociationChannel(*decCh1));
0447
0448   //////////////////////////////////////////////////////////
0449   //            Dissociative Attachment                   //
0450   //////////////////////////////////////////////////////////
0451   decCh1 = new G4MolecularDissociationChannel("DissociativeAttachment");
0452
0453   // Decay 1 : 2OH + H_2
0454   decCh1->AddProduct(H2);
0455   decCh1->AddProduct(OHm);
0456   decCh1->AddProduct(OH);
0457   decCh1->SetProbability(1);
0458   decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::DissociativeAttachment);
0459
0460   *occ = *(water->GetGroundStateElectronOccupancy());
0461   occ->AddElectron(5, 1);  // H_2O^-
0462   water->NewConfigurationWithElectronOccupancy("DissociativeAttachment", *occ);
0463   water->AddDecayChannel("DissociativeAttachment", decCh1);
0464
0465   //////////////////////////////////////////////////////////
0466   //            Electron-hole recombination               //
0467   //////////////////////////////////////////////////////////
0468   decCh1 = new G4MolecularDissociationChannel("H2Ovib_DissociationDecay1");
0469   decCh2 = new G4MolecularDissociationChannel("H2Ovib_DissociationDecay2");
0470   decCh3 = new G4MolecularDissociationChannel("H2Ovib_DissociationDecay3");
0471
0472   // Decay 1 : 2OH + H_2
0473   decCh1->AddProduct(H2);
0474   decCh1->AddProduct(OH);
0475   decCh1->AddProduct(OH);
0476   decCh1->SetProbability(0.15);
0477   decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::B1A1_DissociationDecay);
0478
0479   // Decay 2 : OH + H
0480   decCh2->AddProduct(OH);
0481   decCh2->AddProduct(H);
0482   decCh2->SetProbability(0.55);
0483   decCh2->SetDisplacementType(G4DNAWaterDissociationDisplacer::A1B1_DissociationDecay);
0484
0485   // Decay 3 : relaxation
0486   decCh3->SetProbability(0.30);
0487
0488   const auto pH2Ovib = G4H2O::Definition()->NewConfiguration("H2Ovib");
0489   assert(pH2Ovib != nullptr);
0490
0491   water->AddDecayChannel(pH2Ovib, decCh1);
0492   water->AddDecayChannel(pH2Ovib, decCh2);
0493   water->AddDecayChannel(pH2Ovib, decCh3);
0494
0495   delete occ;
0496 }
0497
0498 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
0499
0500 void EmDNAChemistry::ConstructReactionTable(G4DNAMolecularReactionTable* theReactionTable)
0501 {
0502   // Construct chemical reactions from user input file
0503   ParserChemReaction parser;
0504   parser.ReadReactionFile(fReactionTableName);
0505
0506   auto ListReactant1 = parser.GetListReactant1();
0507   auto ListReactant2 = parser.GetListReactant2();
0508   auto ListProduct = parser.GetListProduct();
0509   auto ListRate = parser.GetListRate();
0510
0511   const G4int Ntype = 5;
0512   for (size_t i = 0; i < Ntype; i++) {
0513     for (size_t j = 0; j < ListReactant1[i].size(); j++) {
0514       G4MolecularConfiguration* Reactant1 =
0515         G4MoleculeTable::Instance()->GetConfiguration(ListReactant1[i][j]);
0516       G4MolecularConfiguration* Reactant2 =
0517         G4MoleculeTable::Instance()->GetConfiguration(ListReactant2[i][j]);
0518
0519       auto pReactionData = new G4DNAMolecularReactionData(ListRate[i][j], Reactant1, Reactant2);
0520
0521       for (size_t k = 0; k < ListProduct[i][j].size(); k++) {
0522         G4MolecularConfiguration* Product =
0523           G4MoleculeTable::Instance()->GetConfiguration(ListProduct[i][j][k]);
0524         pReactionData->AddProduct(Product);
0525       }
0526       // Reaction type II and IV
0527       if (i == 1 || i == 3) {
0528         pReactionData->SetReactionType(1);
0529       }
0530
0531       theReactionTable->SetReaction(pReactionData);
0532     }
0533   }
0534 }
0535
0536 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
0537
0538 void EmDNAChemistry::ConstructProcess()
0539 {
0540   auto ph = G4PhysicsListHelper::GetPhysicsListHelper();
0541   G4VProcess* process =
0542     G4ProcessTable::GetProcessTable()->FindProcess("e-_G4DNAVibExcitation", "e-");
0543   if (process) {
0544     auto vibExcitation = (G4DNAVibExcitation*)process;
0545     G4VEmModel* model = vibExcitation->EmModel();
0546     auto sancheExcitationMod = dynamic_cast<G4DNASancheExcitationModel*>(model);
0547     if (sancheExcitationMod) {
0548       sancheExcitationMod->ExtendLowEnergyLimit(0.025 * eV);
0549     }
0550   }
0551   process = G4ProcessTable::GetProcessTable()->FindProcess("e-_G4DNAElectronSolvation", "e-");
0552
0553   if (process == nullptr) {
0554     ph->RegisterProcess(new G4DNAElectronSolvation("e-_G4DNAElectronSolvation"),
0555                         G4Electron::Definition());
0556   }
0557   auto* theMoleculeTable = G4MoleculeTable::Instance();
0558   G4MoleculeDefinitionIterator iterator = theMoleculeTable->GetDefintionIterator();
0559   iterator.reset();
0560   while (iterator()) {
0561     G4MoleculeDefinition* moleculeDef = iterator.value();
0562     if (moleculeDef == G4H2O::Definition()) {
0563       moleculeDef->GetProcessManager()->AddRestProcess(new G4DNAElectronHoleRecombination(), 2);
0564
0565       auto dissociationProcess = new G4DNAMolecularDissociation("H2O_DNAMolecularDecay");
0566       dissociationProcess->SetDisplacer(moleculeDef, new G4DNAWaterDissociationDisplacer);
0567       // dissociationProcess->SetVerboseLevel(3);
0568       moleculeDef->GetProcessManager()->AddRestProcess(dissociationProcess, 1);
0569     }
0570   }
0571   G4DNAChemistryManager::Instance()->Initialize();
0572 }
0573
0574 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
0575
0576 void EmDNAChemistry::ConstructTimeStepModel(G4DNAMolecularReactionTable*
0577                                             /*reactionTable*/)
0578 {
0579   auto irt = new G4DNAMolecularIRTModel();
0580   RegisterTimeStepModel(irt, 0);
0581 }
0582
0583 //....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
0584
0585 }  // namespace scavenger