G4EmDNAChemistry Class Reference

#include <G4EmDNAChemistry.hh>

Inheritance diagram for G4EmDNAChemistry:

Collaboration 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 (bool flag=true)
virtual	~G4VUserChemistryList ()
bool	IsPhysicsConstructor ()
void	ThisIsAPhysicsConstructor (bool flag=true)
void	BuildPhysicsTable ()
Public Member Functions inherited from G4VPhysicsConstructor
	G4VPhysicsConstructor (const G4String &="")
	G4VPhysicsConstructor (const G4String &name, G4int physics_type)
virtual	~G4VPhysicsConstructor ()
void	SetPhysicsName (const G4String &="")
const G4String &	GetPhysicsName () const
void	SetPhysicsType (G4int)
G4int	GetPhysicsType () const
void	SetVerboseLevel (G4int value)
G4int	GetVerboseLevel () const
G4int	GetInstanceID () const

Additional Inherited Members
Static Public Member Functions inherited from G4VPhysicsConstructor
static const G4VPCManager &	GetSubInstanceManager ()
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
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.hh.

Constructor & Destructor Documentation

G4EmDNAChemistry()

G4EmDNAChemistry::G4EmDNAChemistry

(

)

Definition at line 92 of file G4EmDNAChemistry.cc.

                                   :
    G4VUserChemistryList()
{
  G4DNAChemistryManager::Instance()->SetChemistryList(this);
}

Here is the call graph for this function:

~G4EmDNAChemistry()

G4EmDNAChemistry::~G4EmDNAChemistry ( )

virtual

Definition at line 100 of file G4EmDNAChemistry.cc.

{
}

Member Function Documentation

ConstructDissociationChannels()

void G4EmDNAChemistry::ConstructDissociationChannels ( )

virtual

Reimplemented from G4VUserChemistryList.

Definition at line 156 of file G4EmDNAChemistry.cc.

{
//  //-----------------------------------
//  //Create the dynamic objects
//  G4Molecule* OH = G4MoleculeTable::Instance()->GetMoleculeModel("OH");
//  G4Molecule* OHm = G4MoleculeTable::Instance()->GetMoleculeModel("OHm");
//  G4Molecule* e_aq = G4MoleculeTable::Instance()->GetMoleculeModel("e_aq");
//  G4Molecule* H2 = G4MoleculeTable::Instance()->GetMoleculeModel("H2");
//  G4Molecule* H3O = G4MoleculeTable::Instance()->GetMoleculeModel("H3Op");
//  G4Molecule* H = G4MoleculeTable::Instance()->GetMoleculeModel("H");
  //-----------------------------------
  //Get the molecular configuration
  G4MolecularConfiguration* OH =
      G4MoleculeTable::Instance()->GetConfiguration("OH");
  G4MolecularConfiguration* OHm =
      G4MoleculeTable::Instance()->GetConfiguration("OHm");
  G4MolecularConfiguration* e_aq =
      G4MoleculeTable::Instance()->GetConfiguration("e_aq");
  G4MolecularConfiguration* H2 =
      G4MoleculeTable::Instance()->GetConfiguration("H2");
  G4MolecularConfiguration* H3O =
      G4MoleculeTable::Instance()->GetConfiguration("H3Op");
  G4MolecularConfiguration* H =
      G4MoleculeTable::Instance()->GetConfiguration("H");

  //-------------------------------------
  //Define the decay channels
  G4MoleculeDefinition* water = G4H2O::Definition();
  G4MolecularDissociationChannel* decCh1;
  G4MolecularDissociationChannel* decCh2;

  G4ElectronOccupancy* occ = new G4ElectronOccupancy(
      *(water->GetGroundStateElectronOccupancy()));

  //            EXCITATIONS                               //
  G4DNAWaterExcitationStructure waterExcitation;
  //--------------------------------------------------------
  //---------------Excitation on the fifth layer------------

  decCh1 = new G4MolecularDissociationChannel("A^1B_1_Relaxation");
  decCh2 = new G4MolecularDissociationChannel("A^1B_1_DissociativeDecay");
  //Decay 1 : OH + H
  decCh1->SetEnergy(waterExcitation.ExcitationEnergy(0));
  decCh1->SetProbability(0.35);
  decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::NoDisplacement);

  decCh2->AddProduct(OH);
  decCh2->AddProduct(H);
  decCh2->SetProbability(0.65);
  decCh2->SetDisplacementType(
      G4DNAWaterDissociationDisplacer::A1B1_DissociationDecay);

//  water->AddExcitedState("A^1B_1");
  occ->RemoveElectron(4, 1); // this is the transition form ground state to
  occ->AddElectron(5, 1); // the first unoccupied orbital: A^1B_1

  water->NewConfigurationWithElectronOccupancy("A^1B_1", *occ);
  water->AddDecayChannel("A^1B_1", decCh1);
  water->AddDecayChannel("A^1B_1", decCh2);

  //--------------------------------------------------------
  //---------------Excitation on the fourth layer-----------
  decCh1 = new G4MolecularDissociationChannel("B^1A_1_Relaxation_Channel");
  decCh2 = new G4MolecularDissociationChannel("B^1A_1_DissociativeDecay");
  G4MolecularDissociationChannel* decCh3 = new G4MolecularDissociationChannel(
      "B^1A_1_AutoIonisation_Channel");

  //Decay 1 : energy
  decCh1->SetEnergy(waterExcitation.ExcitationEnergy(1));
  decCh1->SetProbability(0.3);

  //Decay 2 : 2OH + H_2
  decCh2->AddProduct(H2);
  decCh2->AddProduct(OH);
  decCh2->AddProduct(OH);
  decCh2->SetProbability(0.15);
  decCh2->SetDisplacementType(
      G4DNAWaterDissociationDisplacer::B1A1_DissociationDecay);

  //Decay 3 : OH + H_3Op + e_aq
  decCh3->AddProduct(OH);
  decCh3->AddProduct(H3O);
  decCh3->AddProduct(e_aq);
  decCh3->SetProbability(0.55);
  decCh3->SetDisplacementType(G4DNAWaterDissociationDisplacer::AutoIonisation);

  *occ = *(water->GetGroundStateElectronOccupancy());
  occ->RemoveElectron(3); // this is the transition form ground state to
  occ->AddElectron(5, 1); // the first unoccupied orbital: B^1A_1

  water->NewConfigurationWithElectronOccupancy("B^1A_1", *occ);
  water->AddDecayChannel("B^1A_1", decCh1);
  water->AddDecayChannel("B^1A_1", decCh2);
  water->AddDecayChannel("B^1A_1", decCh3);

  //-------------------------------------------------------
  //-------------------Excitation of 3rd layer-----------------
  decCh1 = new G4MolecularDissociationChannel(
      "Excitation3rdLayer_AutoIonisation_Channel");
  decCh2 = new G4MolecularDissociationChannel(
      "Excitation3rdLayer_Relaxation_Channel");

  //Decay channel 1 : : OH + H_3Op + e_aq
  decCh1->AddProduct(OH);
  decCh1->AddProduct(H3O);
  decCh1->AddProduct(e_aq);

  decCh1->SetProbability(0.5);
  decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::AutoIonisation);

  //Decay channel 2 : energy
  decCh2->SetEnergy(waterExcitation.ExcitationEnergy(2));
  decCh2->SetProbability(0.5);

  //Electronic configuration of this decay
  *occ = *(water->GetGroundStateElectronOccupancy());
  occ->RemoveElectron(2, 1);
  occ->AddElectron(5, 1);

  //Configure the water molecule
  water->NewConfigurationWithElectronOccupancy("Excitation3rdLayer", *occ);
  water->AddDecayChannel("Excitation3rdLayer", decCh1);
  water->AddDecayChannel("Excitation3rdLayer", decCh2);

  //-------------------------------------------------------
  //-------------------Excitation of 2nd layer-----------------
  decCh1 = new G4MolecularDissociationChannel(
      "Excitation2ndLayer_AutoIonisation_Channel");
  decCh2 = new G4MolecularDissociationChannel(
      "Excitation2ndLayer_Relaxation_Channel");

  //Decay Channel 1 : : OH + H_3Op + e_aq
  decCh1->AddProduct(OH);
  decCh1->AddProduct(H3O);
  decCh1->AddProduct(e_aq);

  decCh1->SetProbability(0.5);
  decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::AutoIonisation);

  //Decay channel 2 : energy
  decCh2->SetEnergy(waterExcitation.ExcitationEnergy(3));
  decCh2->SetProbability(0.5);

  *occ = *(water->GetGroundStateElectronOccupancy());
  occ->RemoveElectron(1, 1);
  occ->AddElectron(5, 1);

  water->NewConfigurationWithElectronOccupancy("Excitation2ndLayer", *occ);
  water->AddDecayChannel("Excitation2ndLayer", decCh1);
  water->AddDecayChannel("Excitation2ndLayer", decCh2);

  //-------------------------------------------------------
  //-------------------Excitation of 1st layer-----------------
  decCh1 = new G4MolecularDissociationChannel(
      "Excitation1stLayer_AutoIonisation_Channel");
  decCh2 = new G4MolecularDissociationChannel(
      "Excitation1stLayer_Relaxation_Channel");

  *occ = *(water->GetGroundStateElectronOccupancy());
  occ->RemoveElectron(0, 1);
  occ->AddElectron(5, 1);

  //Decay Channel 1 : : OH + H_3Op + e_aq
  decCh1->AddProduct(OH);
  decCh1->AddProduct(H3O);
  decCh1->AddProduct(e_aq);
  decCh1->SetProbability(0.5);
  decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::AutoIonisation);

  //Decay channel 2 : energy
  decCh2->SetEnergy(waterExcitation.ExcitationEnergy(4));
  decCh2->SetProbability(0.5);

  water->NewConfigurationWithElectronOccupancy("Excitation1stLayer", *occ);
  water->AddDecayChannel("Excitation1stLayer", decCh1);
  water->AddDecayChannel("Excitation1stLayer", decCh2);

  //                  IONISATION                         //
  //--------------------------------------------------------
  //------------------- Ionisation -------------------------

  decCh1 = new G4MolecularDissociationChannel("Ionisation_Channel");

  //Decay Channel 1 : : OH + H_3Op
  decCh1->AddProduct(H3O);
  decCh1->AddProduct(OH);
  decCh1->SetProbability(1);
  decCh1->SetDisplacementType(
      G4DNAWaterDissociationDisplacer::Ionisation_DissociationDecay);

  *occ = *(water->GetGroundStateElectronOccupancy());
  occ->RemoveElectron(4, 1);
  // this is a ionized h2O with a hole in its last orbital
  water->NewConfigurationWithElectronOccupancy("Ionisation5", *occ);
  water->AddDecayChannel("Ionisation5",
                         decCh1);

  *occ = *(water->GetGroundStateElectronOccupancy());
  occ->RemoveElectron(3, 1);
  water->NewConfigurationWithElectronOccupancy("Ionisation4", *occ);
  water->AddDecayChannel("Ionisation4",
                         new G4MolecularDissociationChannel(*decCh1));

  *occ = *(water->GetGroundStateElectronOccupancy());
  occ->RemoveElectron(2, 1);
  water->NewConfigurationWithElectronOccupancy("Ionisation3", *occ);
  water->AddDecayChannel("Ionisation3",
                         new G4MolecularDissociationChannel(*decCh1));

  *occ = *(water->GetGroundStateElectronOccupancy());
  occ->RemoveElectron(1, 1);
  water->NewConfigurationWithElectronOccupancy("Ionisation2", *occ);
  water->AddDecayChannel("Ionisation2",
                         new G4MolecularDissociationChannel(*decCh1));

  *occ = *(water->GetGroundStateElectronOccupancy());
  occ->RemoveElectron(0, 1);
  water->NewConfigurationWithElectronOccupancy("Ionisation1", *occ);
  water->AddDecayChannel("Ionisation1",
                         new G4MolecularDissociationChannel(*decCh1));

  //            Dissociative Attachment                   //
  decCh1 = new G4MolecularDissociationChannel("DissociativeAttachment");

  //Decay 1 : 2OH + H_2
  decCh1->AddProduct(H2);
  decCh1->AddProduct(OHm);
  decCh1->AddProduct(OH);
  decCh1->SetProbability(1);
  decCh1->SetDisplacementType(G4DNAWaterDissociationDisplacer::
                              DissociativeAttachment);

  *occ = *(water->GetGroundStateElectronOccupancy());
  occ->AddElectron(5, 1); // H_2O^-
  water->NewConfigurationWithElectronOccupancy("DissociativeAttachment", *occ);
  water->AddDecayChannel("DissociativeAttachment", decCh1);

  delete occ;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ConstructMolecule()

void G4EmDNAChemistry::ConstructMolecule ( )

virtual

Reimplemented from G4VUserChemistryList.

Definition at line 106 of file G4EmDNAChemistry.cc.

{
  //-----------------------------------
  G4Electron::Definition(); // safety

  //-----------------------------------
  // Create the definition
  G4H2O::Definition();
  G4Hydrogen::Definition();
  G4H3O::Definition();
  G4OH::Definition();
  G4Electron_aq::Definition();
  G4H2O2::Definition();
  G4H2::Definition();

//  G4MoleculeTable::Instance()->CreateMoleculeModel("H3Op", G4H3O::Definition());
//  G4Molecule* OHm = G4MoleculeTable::Instance()->
//      CreateMoleculeModel("OHm", // just a tag to store and retrieve from
//                                 // G4MoleculeTable
//      G4OH::Definition(), -1, 5.0e-9 * (m2 / s));
//  OHm->SetMass(17.0079 * g / Avogadro * c_squared);
//  G4MoleculeTable::Instance()->CreateMoleculeModel("OH", G4OH::Definition());
//  G4MoleculeTable::Instance()->CreateMoleculeModel("e_aq",
//                                                   G4Electron_aq::Definition());
//  G4MoleculeTable::Instance()->CreateMoleculeModel("H",
//                                                   G4Hydrogen::Definition());
//  G4MoleculeTable::Instance()->CreateMoleculeModel("H2", G4H2::Definition());
//  G4MoleculeTable::Instance()->CreateMoleculeModel("H2O2", G4H2O2::Definition());

  //____________________________________________________________________________

  G4MoleculeTable::Instance()->CreateConfiguration("H3Op", G4H3O::Definition());
  G4MolecularConfiguration* OHm = G4MoleculeTable::Instance()->
      CreateConfiguration("OHm", // just a tag to store and retrieve from
                                 // G4MoleculeTable
                          G4OH::Definition(),
                          -1, // charge
                          5.0e-9 * (m2 / s));
  OHm->SetMass(17.0079 * g / Avogadro * c_squared);
  G4MoleculeTable::Instance()->CreateConfiguration("OH", G4OH::Definition());
  G4MoleculeTable::Instance()->CreateConfiguration("e_aq",
                                                   G4Electron_aq::Definition());
  G4MoleculeTable::Instance()->CreateConfiguration("H",
                                                   G4Hydrogen::Definition());
  G4MoleculeTable::Instance()->CreateConfiguration("H2", G4H2::Definition());
  G4MoleculeTable::Instance()->CreateConfiguration("H2O2", G4H2O2::Definition());
}

Here is the call graph for this function:

Here is the caller graph for this function:

ConstructParticle()

virtual void G4EmDNAChemistry::ConstructParticle ( void  )

inlinevirtual

Implements G4VPhysicsConstructor.

Definition at line 43 of file G4EmDNAChemistry.hh.

  {
    ConstructMolecule();
  }

Here is the call graph for this function:

ConstructProcess()

void G4EmDNAChemistry::ConstructProcess ( void  )

virtual

Reimplemented from G4VUserChemistryList.

Definition at line 489 of file G4EmDNAChemistry.cc.

{
  G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();

  //===============================================================
  // Extend vibrational to low energy
  // Anyway, solvation of electrons is taken into account from 7.4 eV
  // So below this threshold, for now, no accurate modeling is done
  //
  G4VProcess* process =
      G4ProcessTable::GetProcessTable()->
        FindProcess("e-_G4DNAVibExcitation", "e-");

  if (process)
  {
    G4DNAVibExcitation* vibExcitation = (G4DNAVibExcitation*) process;
    G4VEmModel* model = vibExcitation->EmModel();
    G4DNASancheExcitationModel* sancheExcitationMod =
        dynamic_cast<G4DNASancheExcitationModel*>(model);
    if(sancheExcitationMod)
    {
      sancheExcitationMod->ExtendLowEnergyLimit(0.025 * eV);
    }
  }

  //===============================================================
  // Modify elastic scattering models to avoid killing electrons
  // at low energy
  //
  process =
      G4ProcessTable::GetProcessTable()->
        FindProcess("e-_G4DNAElastic", "e-");

  if (process)
  {
    G4DNAElastic* vibExcitation = (G4DNAElastic*) process;
    G4VEmModel* model = vibExcitation->EmModel();

    if(G4DNAChampionElasticModel* championMod =
        dynamic_cast<G4DNAChampionElasticModel*>(model))
    {
      championMod->SetKillBelowThreshold(-1);
    }
    else if(G4DNAScreenedRutherfordElasticModel* screenRutherfordMod =
            dynamic_cast<G4DNAScreenedRutherfordElasticModel*>(model))
    {
      screenRutherfordMod->SetKillBelowThreshold(-1);
    }
    else if (G4DNAUeharaScreenedRutherfordElasticModel* ueharaScreenRutherfordMod =
        dynamic_cast<G4DNAUeharaScreenedRutherfordElasticModel*>(model))
    {
      ueharaScreenRutherfordMod->SetKillBelowThreshold(-1);
    }
  }

  //===============================================================
  // *** Electron Solvatation ***
  //
  ph->RegisterProcess(
      new G4DNAElectronSolvatation("e-_G4DNAElectronSolvatation"),
      G4Electron::Definition());

  //===============================================================
  // Define processes for molecules
  //
  G4MoleculeTable* theMoleculeTable = G4MoleculeTable::Instance();
  G4MoleculeDefinitionIterator iterator =
      theMoleculeTable->GetDefintionIterator();
  iterator.reset();
  while (iterator())
  {
    G4MoleculeDefinition* moleculeDef = iterator.value();

    if (moleculeDef != G4H2O::Definition())
    {
      // G4cout << "Brownian motion added for : "
      //        << moleculeDef->GetName() << G4endl;
      G4DNABrownianTransportation* brown = new G4DNABrownianTransportation();
      //   brown->SetVerboseLevel(4);
      ph->RegisterProcess(brown, moleculeDef);
    }
    else
    {
      moleculeDef->GetProcessManager()
                      ->AddRestProcess(new G4DNAElectronHoleRecombination(), 2);
      G4DNAMolecularDissociation* dissociationProcess =
          new G4DNAMolecularDissociation("H2O_DNAMolecularDecay");
      dissociationProcess->SetDecayDisplacer(
          moleculeDef, new G4DNAWaterDissociationDisplacer);
      dissociationProcess->SetVerboseLevel(1);
//      ph->RegisterProcess(dissociationProcess, moleculeDef);

      moleculeDef->GetProcessManager()
                ->AddRestProcess(dissociationProcess, 1);
    }
    /*
     * Warning : end of particles and processes are needed by
     * EM Physics builders
     */
  }

  G4DNAChemistryManager::Instance()->Initialize();
}

Here is the call graph for this function:

Here is the caller graph for this function:

ConstructReactionTable()

void G4EmDNAChemistry::ConstructReactionTable ( G4DNAMolecularReactionTable *  reactionTable )

virtual

Implements G4VUserChemistryList.

Definition at line 404 of file G4EmDNAChemistry.cc.

{
  //  //-----------------------------------
//  G4Molecule* OH = G4MoleculeTable::Instance()->GetMoleculeModel("OH");
//  G4Molecule* e_aq = G4MoleculeTable::Instance()->GetMoleculeModel("e_aq");
//  G4Molecule* H2 = G4MoleculeTable::Instance()->GetMoleculeModel("H2");
//  G4Molecule* H3Op = G4MoleculeTable::Instance()->GetMoleculeModel("H3Op");
//  G4Molecule* OHm = G4MoleculeTable::Instance()->GetMoleculeModel("OHm");
//  G4Molecule* H2O2 =  G4MoleculeTable::Instance()->GetMoleculeModel("H2O2");
//  G4Molecule* H = G4MoleculeTable::Instance()->GetMoleculeModel("H");
    //-----------------------------------
    //Get the molecular configuration
    G4MolecularConfiguration* OH =
        G4MoleculeTable::Instance()->GetConfiguration("OH");
    G4MolecularConfiguration* OHm =
        G4MoleculeTable::Instance()->GetConfiguration("OHm");
    G4MolecularConfiguration* e_aq =
        G4MoleculeTable::Instance()->GetConfiguration("e_aq");
    G4MolecularConfiguration* H2 =
        G4MoleculeTable::Instance()->GetConfiguration("H2");
    G4MolecularConfiguration* H3Op =
        G4MoleculeTable::Instance()->GetConfiguration("H3Op");
    G4MolecularConfiguration* H =
        G4MoleculeTable::Instance()->GetConfiguration("H");
    G4MolecularConfiguration* H2O2 =
        G4MoleculeTable::Instance()->GetConfiguration("H2O2");

  //------------------------------------------------------------------
  // e_aq + e_aq + 2H2O -> H2 + 2OH-
  G4DNAMolecularReactionData* reactionData = new G4DNAMolecularReactionData(
      0.5e10 * (1e-3 * m3 / (mole * s)), e_aq, e_aq);
  reactionData->AddProduct(OHm);
  reactionData->AddProduct(OHm);
  reactionData->AddProduct(H2);
  theReactionTable->SetReaction(reactionData);
  //------------------------------------------------------------------
  // e_aq + *OH -> OH-
  reactionData = new G4DNAMolecularReactionData(
      2.95e10 * (1e-3 * m3 / (mole * s)), e_aq, OH);
  reactionData->AddProduct(OHm);
  theReactionTable->SetReaction(reactionData);
  //------------------------------------------------------------------
  // e_aq + H* + H2O -> H2 + OH-
  reactionData = new G4DNAMolecularReactionData(
      2.65e10 * (1e-3 * m3 / (mole * s)), e_aq, H);
  reactionData->AddProduct(OHm);
  reactionData->AddProduct(H2);
  theReactionTable->SetReaction(reactionData);
  //------------------------------------------------------------------
  // e_aq + H3O+ -> H* + H2O
  reactionData = new G4DNAMolecularReactionData(
      2.11e10 * (1e-3 * m3 / (mole * s)), e_aq, H3Op);
  reactionData->AddProduct(H);
  theReactionTable->SetReaction(reactionData);
  //------------------------------------------------------------------
  // e_aq + H2O2 -> OH- + *OH
  reactionData = new G4DNAMolecularReactionData(
      1.41e10 * (1e-3 * m3 / (mole * s)), e_aq, H2O2);
  reactionData->AddProduct(OHm);
  reactionData->AddProduct(OH);
  theReactionTable->SetReaction(reactionData);
  //------------------------------------------------------------------
  // *OH + *OH -> H2O2
  reactionData = new G4DNAMolecularReactionData(
      0.44e10 * (1e-3 * m3 / (mole * s)), OH, OH);
  reactionData->AddProduct(H2O2);
  theReactionTable->SetReaction(reactionData);
  //------------------------------------------------------------------
  // *OH + *H -> H2O
  theReactionTable->SetReaction(1.44e10 * (1e-3 * m3 / (mole * s)), OH, H);
  //------------------------------------------------------------------
  // *H + *H -> H2
  reactionData = new G4DNAMolecularReactionData(
      1.20e10 * (1e-3 * m3 / (mole * s)), H, H);
  reactionData->AddProduct(H2);
  theReactionTable->SetReaction(reactionData);
  //------------------------------------------------------------------
  // H3O+ + OH- -> 2H2O
  theReactionTable->SetReaction(1.43e11 * (1e-3 * m3 / (mole * s)), H3Op, OHm);
  //------------------------------------------------------------------
}

Here is the call graph for this function:

Here is the caller graph for this function:

ConstructTimeStepModel()

void G4EmDNAChemistry::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 595 of file G4EmDNAChemistry.cc.

{

  //=========================================
  // Diffusion controlled reaction model
  //=========================================
  G4VDNAReactionModel* reactionRadiusComputer =
      new G4DNASmoluchowskiReactionModel();
  reactionTable->PrintTable(reactionRadiusComputer);

  G4DNAMolecularStepByStepModel* stepByStep =
      new G4DNAMolecularStepByStepModel();
  stepByStep->SetReactionModel(reactionRadiusComputer);
//  ((G4DNAMoleculeEncounterStepper*) stepByStep->GetTimeStepper())->
//  SetVerbose(5);

  RegisterTimeStepModel(stepByStep, 0);
}

Here is the call graph for this function:

Here is the caller graph for this function:

---

The documentation for this class was generated from the following files:

• G4EmDNAChemistry.hh
• G4EmDNAChemistry.cc