G4EmDNAPhysicsChemistry Class Reference

#include <G4EmDNAPhysicsChemistry.hh>

Inheritance diagram for G4EmDNAPhysicsChemistry:

Public Member Functions
	G4EmDNAPhysicsChemistry (G4int ver=1)
virtual	~G4EmDNAPhysicsChemistry ()
virtual void	ConstructParticle ()
virtual void	ConstructProcess ()
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

Protected Member Functions
void	ConstructMolecules ()
void	ConstructDecayChannels ()
void	ConstructReactionTable ()
Protected Member Functions inherited from G4VPhysicsConstructor
G4bool	RegisterProcess (G4VProcess *process, G4ParticleDefinition *particle)

Additional Inherited Members
Protected Attributes inherited from G4VPhysicsConstructor
G4int	verboseLevel
G4String	namePhysics
G4int	typePhysics
G4ParticleTable *	theParticleTable
G4ParticleTable::G4PTblDicIterator *	theParticleIterator
G4PhysicsListHelper *	thePLHelper

Detailed Description

Definition at line 34 of file G4EmDNAPhysicsChemistry.hh.

Constructor & Destructor Documentation

G4EmDNAPhysicsChemistry()

G4EmDNAPhysicsChemistry::G4EmDNAPhysicsChemistry

(

G4int

ver = 1

)

Definition at line 104 of file G4EmDNAPhysicsChemistry.cc.

    : G4VPhysicsConstructor("G4EmDNAPhysicsChemistry"), verbose(ver)
{
    SetPhysicsType(bElectromagnetic);
}

~G4EmDNAPhysicsChemistry()

G4EmDNAPhysicsChemistry::~G4EmDNAPhysicsChemistry ( )

virtual

It should not be useful to delete those singletons since they are based on auto_ptr. But to make sure that it won't cause any trouble, we explicitly call the following methods responsible for the destruction of the singletons.

Definition at line 110 of file G4EmDNAPhysicsChemistry.cc.

{
    /** It should not be useful to delete those singletons
      * since they are based on auto_ptr. But to make sure
      * that it won't cause any trouble, we explicitly call
      * the following methods responsible for the destruction
      * of the singletons.
      */
    G4DNAChemistryManager::DeleteInstance();
}

Member Function Documentation

ConstructDecayChannels()

void G4EmDNAPhysicsChemistry::ConstructDecayChannels ( )

protected

Definition at line 159 of file G4EmDNAPhysicsChemistry.cc.

{
    //-----------------------------------
    //Create the dynamic objects
    G4Molecule * H3O = new G4Molecule(G4H3O::Definition());
    H3O -> RemoveElectron(4,1);
 
    G4Molecule * OH = new G4Molecule(G4OH::Definition());
    G4Molecule * e_aq = new G4Molecule(G4Electron_aq::Definition());
 
    G4Molecule * H = new G4Molecule(G4Hydrogen::Definition());
    G4Molecule * H2 = new G4Molecule(G4H2::Definition());
 
    G4Molecule* OHm = new G4Molecule(G4OH::Definition());
    OHm->AddElectron(3);
    OHm->SetMass(17.0079*g/Avogadro * c_squared);
    OHm->SetDiffusionCoefficient(5.0e-9*(m2/s));
 
    //-------------------------------------
    //Define the decay channels
    G4MoleculeDefinition* water = G4H2O::Definition();
    G4MolecularDecayChannel* decCh1;
    G4MolecularDecayChannel* decCh2;
 
    G4ElectronOccupancy* occ = new G4ElectronOccupancy(*(water->GetGroundStateElectronOccupancy()));
 
    //////////////////////////////////////////////////////////
    //            EXCITATIONS                               //
    //////////////////////////////////////////////////////////
    G4DNAWaterExcitationStructure waterExcitation;
    //--------------------------------------------------------
    //---------------Excitation on the fifth layer------------
 
    decCh1 = new G4MolecularDecayChannel("A^1B_1_Relaxation");
    decCh2 = new G4MolecularDecayChannel("A^1B_1_DissociativeDecay");
    //Decay 1 : OH + H
    decCh1->SetEnergy(waterExcitation.ExcitationEnergy(0));
    decCh1->SetProbability(0.35);
    decCh1 -> SetDisplacementType(G4DNAMolecularDecayDisplacer::NoDisplacement);
 
    decCh2->AddProduct(OH);
    decCh2->AddProduct(H);
    decCh2->SetProbability(0.65);
    decCh2 -> SetDisplacementType(G4DNAMolecularDecayDisplacer::A1B1_DissociationDecay);
 
    water->AddExcitedState("A^1B_1");
    water->AddDecayChannel("A^1B_1",decCh1);
    water->AddDecayChannel("A^1B_1",decCh2);
 
    occ->RemoveElectron(4,1); // this is the transition form ground state to
    occ->AddElectron(5,1);  // the first unoccupied orbital: A^1B_1
 
    water->AddeConfToExcitedState("A^1B_1", *occ);
 
    //--------------------------------------------------------
    //---------------Excitation on the fourth layer-----------
    decCh1 = new G4MolecularDecayChannel("B^1A_1_Relaxation_Channel");
    decCh2 = new G4MolecularDecayChannel("B^1A_1_DissociativeDecay");
    G4MolecularDecayChannel* decCh3 = new G4MolecularDecayChannel("B^1A_1_AutoIonisation_Channel");
 
    water->AddExcitedState("B^1A_1");
 
    //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(G4DNAMolecularDecayDisplacer::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(G4DNAMolecularDecayDisplacer::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->AddeConfToExcitedState("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 G4MolecularDecayChannel("Excitation3rdLayer_AutoIonisation_Channel");
    decCh2 = new G4MolecularDecayChannel("Excitation3rdLayer_Relaxation_Channel");
 
    water->AddExcitedState("Excitation3rdLayer");
 
    //Decay channel 1 : : OH + H_3Op + e_aq
    decCh1->AddProduct(OH);
    decCh1->AddProduct(H3O);
    decCh1->AddProduct(e_aq);
 
    decCh1->SetProbability(0.5);
    decCh1->SetDisplacementType(G4DNAMolecularDecayDisplacer::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->AddeConfToExcitedState("Excitation3rdLayer", *occ);
    water->AddDecayChannel("Excitation3rdLayer",decCh1);
    water->AddDecayChannel("Excitation3rdLayer",decCh2);
 
    //-------------------------------------------------------
    //-------------------Excitation of 2nd layer-----------------
    decCh1 = new G4MolecularDecayChannel("Excitation2ndLayer_AutoIonisation_Channel");
    decCh2 = new G4MolecularDecayChannel("Excitation2ndLayer_Relaxation_Channel");
 
    water->AddExcitedState("Excitation2ndLayer");
 
    //Decay Channel 1 : : OH + H_3Op + e_aq
    decCh1->AddProduct(OH);
    decCh1->AddProduct(H3O);
    decCh1->AddProduct(e_aq);
 
    decCh1->SetProbability(0.5);
    decCh1->SetDisplacementType(G4DNAMolecularDecayDisplacer::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->AddeConfToExcitedState("Excitation2ndLayer", *occ);
    water->AddDecayChannel("Excitation2ndLayer",decCh1);
    water->AddDecayChannel("Excitation2ndLayer",decCh2);
 
    //-------------------------------------------------------
    //-------------------Excitation of 1st layer-----------------
    decCh1 = new G4MolecularDecayChannel("Excitation1stLayer_AutoIonisation_Channel");
    decCh2 = new G4MolecularDecayChannel("Excitation1stLayer_Relaxation_Channel");
 
    *occ = *(water->GetGroundStateElectronOccupancy());
    occ->RemoveElectron(0,1);
    occ->AddElectron(5,1);
 
    water->AddExcitedState("Excitation1stLayer");
    water->AddeConfToExcitedState("Excitation1stLayer", *occ);
 
    //Decay Channel 1 : : OH + H_3Op + e_aq
    decCh1->AddProduct(OH);
    decCh1->AddProduct(H3O);
    decCh1->AddProduct(e_aq);
    decCh1->SetProbability(0.5);
    decCh1->SetDisplacementType(G4DNAMolecularDecayDisplacer::AutoIonisation);
 
    //Decay channel 2 : energy
    decCh2->SetEnergy(waterExcitation.ExcitationEnergy(4));
    decCh2->SetProbability(0.5);
    water->AddDecayChannel("Excitation1stLayer",decCh1);
    water->AddDecayChannel("Excitation1stLayer",decCh2);
 
    /////////////////////////////////////////////////////////
    //                  IONISATION                         //
    /////////////////////////////////////////////////////////
    //--------------------------------------------------------
    //------------------- Ionisation -------------------------
    water->AddExcitedState("Ionisation");
 
    decCh1 = new G4MolecularDecayChannel("Ionisation_Channel");
 
    //Decay Channel 1 : : OH + H_3Op
    decCh1->AddProduct(H3O);
    decCh1->AddProduct(OH);
    decCh1->SetProbability(1);
    decCh1->SetDisplacementType(G4DNAMolecularDecayDisplacer::Ionisation_DissociationDecay);
 
    *occ = *(water->GetGroundStateElectronOccupancy());
    occ->RemoveElectron(4,1); // this is a ionized h2O with a hole in its last orbital
    water->AddeConfToExcitedState("Ionisation", *occ);
 
    *occ = *(water->GetGroundStateElectronOccupancy());
    occ->RemoveElectron(3,1);
    water->AddeConfToExcitedState("Ionisation", *occ);
 
    *occ = *(water->GetGroundStateElectronOccupancy());
    occ->RemoveElectron(2,1);
    water->AddeConfToExcitedState("Ionisation", *occ);
 
    *occ = *(water->GetGroundStateElectronOccupancy());
    occ->RemoveElectron(1,1);
    water->AddeConfToExcitedState("Ionisation", *occ);
 
    *occ = *(water->GetGroundStateElectronOccupancy());
    occ->RemoveElectron(0,1);
    water->AddeConfToExcitedState("Ionisation", *occ);
    water->AddDecayChannel("Ionisation",decCh1);
    // to this electronic configuration should be associated a decay time of 10e-15 s should the process do it on the dynamic object? the dyn object.
 
    //////////////////////////////////////////////////////////
    //            Dissociative Attachment                   //
    //////////////////////////////////////////////////////////
    decCh1 = new G4MolecularDecayChannel("DissociativeAttachment");
 
    //Decay 1 : 2OH + H_2
    decCh1->AddProduct(H2);
    decCh1->AddProduct(OHm);
    decCh1->AddProduct(OH);
    decCh1->SetProbability(1);
    //decCh1->SetDisplacementType(G4DNAMolecularDecayDisplacer::DissociativeAttachment);
 
    *occ = *(water->GetGroundStateElectronOccupancy());
    occ->AddElectron(5,1); // H_2O^-
    water->AddExcitedState("DissociativeAttachment");
    water->AddeConfToExcitedState("DissociativeAttachment", *occ);
    water->AddDecayChannel("DissociativeAttachment",decCh1);
 
    delete occ;
}

Referenced by ConstructMolecules().

ConstructMolecules()

void G4EmDNAPhysicsChemistry::ConstructMolecules ( )

protected

Definition at line 144 of file G4EmDNAPhysicsChemistry.cc.

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

Referenced by ConstructProcess().

ConstructParticle()

void G4EmDNAPhysicsChemistry::ConstructParticle ( )

virtual

Implements G4VPhysicsConstructor.

Definition at line 123 of file G4EmDNAPhysicsChemistry.cc.

{
    // bosons
    G4Gamma::Gamma();
 
    // leptons
    G4Electron::Electron();
    G4Positron::Positron();
 
    // baryons
    G4Proton::Proton();
 
    G4GenericIon::GenericIonDefinition();
 
    G4DNAGenericIonsManager * genericIonsManager;
    genericIonsManager=G4DNAGenericIonsManager::Instance();
    genericIonsManager->GetIon("alpha++");
    genericIonsManager->GetIon("alpha+");
    genericIonsManager->GetIon("helium");
    genericIonsManager->GetIon("hydrogen");
}

ConstructProcess()

void G4EmDNAPhysicsChemistry::ConstructProcess ( )

virtual

Tells to the chemistry manager whether the chemistry needs to be activated. WARNING : if you don't use the chemistry do not activate it otherwise it might generate memory leaks with tracks created but not destroyed.

Implements G4VPhysicsConstructor.

Definition at line 457 of file G4EmDNAPhysicsChemistry.cc.

{
 
    ConstructMolecules();
    // Is placed outside ConstructParticles to avoid
    // the transportation process to be added to the molecules
 
    G4PhysicsListHelper* ph = G4PhysicsListHelper::GetPhysicsListHelper();
 
    theParticleIterator->reset();
    while( (*theParticleIterator)() )
    {
        G4ParticleDefinition* particle = theParticleIterator->value();
        G4String particleName = particle->GetParticleName();
        G4String particleType = particle->GetParticleType();
        G4ProcessManager* pmanager = particle->GetProcessManager();
 
        if (particleName == "e-") {
 
            // *** Elastic scattering (two alternative models available) ***
 
            G4DNAElastic* theDNAElasticProcess = new G4DNAElastic("e-_G4DNAElastic");
            G4DNAChampionElasticModel * championElasticModel = new G4DNAChampionElasticModel();
            championElasticModel->SetKillBelowThreshold(0.*eV);
            theDNAElasticProcess->SetModel(championElasticModel);
 
            // or alternative model
            //theDNAElasticProcess->SetModel(new G4DNAScreenedRutherfordElasticModel());
 
            ph->RegisterProcess(theDNAElasticProcess, particle);
 
            // *** Excitation ***
            ph->RegisterProcess(new G4DNAExcitation("e-_G4DNAExcitation"), particle);
 
            // *** Ionisation ***
            ph->RegisterProcess(new G4DNAIonisation("e-_G4DNAIonisation"), particle);
 
            // *** Vibrational excitation ***
            G4DNAVibExcitation* vibExcitation = new G4DNAVibExcitation("e-_G4DNAVibExcitation");
            G4DNASancheExcitationModel* sancheExcitationMod = new G4DNASancheExcitationModel;
            vibExcitation -> SetModel(sancheExcitationMod);
            sancheExcitationMod->ExtendLowEnergyLimit(0.025*eV);
            ph->RegisterProcess(vibExcitation, particle);
 
            // *** Attachment ***
            ph->RegisterProcess(new G4DNAAttachment("e-_G4DNAAttachment"), particle);
 
            // *** Electron Solvatation ***
            ph->RegisterProcess(new G4DNAElectronSolvatation("e-_G4DNAElectronSolvatation"), particle);
        } else if ( particleName == "proton" ) {
            ph->RegisterProcess(new G4DNAExcitation("proton_G4DNAExcitation"), particle);
            ph->RegisterProcess(new G4DNAIonisation("proton_G4DNAIonisation"), particle);
            ph->RegisterProcess(new G4DNAChargeDecrease("proton_G4DNAChargeDecrease"), particle);
 
        } else if ( particleName == "hydrogen" ) {
            ph->RegisterProcess(new G4DNAExcitation("hydrogen_G4DNAExcitation"), particle);
            ph->RegisterProcess(new G4DNAIonisation("hydrogen_G4DNAIonisation"), particle);
            ph->RegisterProcess(new G4DNAChargeIncrease("hydrogen_G4DNAChargeIncrease"), particle);
 
        } else if ( particleName == "alpha" ) {
            ph->RegisterProcess(new G4DNAExcitation("alpha_G4DNAExcitation"), particle);
            ph->RegisterProcess(new G4DNAIonisation("alpha_G4DNAIonisation"), particle);
            ph->RegisterProcess(new G4DNAChargeDecrease("alpha_G4DNAChargeDecrease"), particle);
 
        } else if ( particleName == "alpha+" ) {
            ph->RegisterProcess(new G4DNAExcitation("alpha+_G4DNAExcitation"), particle);
            ph->RegisterProcess(new G4DNAIonisation("alpha+_G4DNAIonisation"), particle);
            ph->RegisterProcess(new G4DNAChargeDecrease("alpha+_G4DNAChargeDecrease"), particle);
            ph->RegisterProcess(new G4DNAChargeIncrease("alpha+_G4DNAChargeIncrease"), particle);
 
        } else if ( particleName == "helium" ) {
            ph->RegisterProcess(new G4DNAExcitation("helium_G4DNAExcitation"), particle);
            ph->RegisterProcess(new G4DNAIonisation("helium_G4DNAIonisation"), particle);
            ph->RegisterProcess(new G4DNAChargeIncrease("helium_G4DNAChargeIncrease"), particle);
 
        }
            // Extension to HZE proposed by Z. Francis
 
        else if ( particleName == "carbon" ) {
          ph->RegisterProcess(new G4DNAIonisation("carbon_G4DNAIonisation"), particle);
 
        } else if ( particleName == "nitrogen" ) {
          ph->RegisterProcess(new G4DNAIonisation("nitrogen_G4DNAIonisation"), particle);
 
        } else if ( particleName == "oxygen" ) {
          ph->RegisterProcess(new G4DNAIonisation("oxygen_G4DNAIonisation"), particle);
 
        } else if ( particleName == "iron" ) {
          ph->RegisterProcess(new G4DNAIonisation("iron_G4DNAIonisation"), particle);
 
        }
 
        // Warning : the following particles and processes are needed by EM Physics builders
        // They are taken from the default Livermore Physics list
        // These particles are currently not handled by Geant4-DNA
 
        // e+
 
        else if (particleName == "e+") {
 
            // Identical to G4EmStandardPhysics_option3
 
            G4eMultipleScattering* msc = new G4eMultipleScattering();
            msc->AddEmModel(0, new G4UrbanMscModel95());
            msc->SetStepLimitType(fUseDistanceToBoundary);
            G4eIonisation* eIoni = new G4eIonisation();
            eIoni->SetStepFunction(0.2, 100*um);
 
            ph->RegisterProcess(msc, particle);
            ph->RegisterProcess(eIoni, particle);
            ph->RegisterProcess(new G4eBremsstrahlung(), particle);
            ph->RegisterProcess(new G4eplusAnnihilation(), particle);
 
        }else if (particleName == "gamma") {
            G4double LivermoreHighEnergyLimit = GeV;
 
            G4PhotoElectricEffect* thePhotoElectricEffect = new G4PhotoElectricEffect();
            G4LivermorePhotoElectricModel* theLivermorePhotoElectricModel =
                    new G4LivermorePhotoElectricModel();
            theLivermorePhotoElectricModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
            thePhotoElectricEffect->AddEmModel(0, theLivermorePhotoElectricModel);
            ph->RegisterProcess(thePhotoElectricEffect, particle);
 
            G4ComptonScattering* theComptonScattering = new G4ComptonScattering();
            G4LivermoreComptonModel* theLivermoreComptonModel =
                    new G4LivermoreComptonModel();
            theLivermoreComptonModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
            theComptonScattering->AddEmModel(0, theLivermoreComptonModel);
            ph->RegisterProcess(theComptonScattering, particle);
 
            G4GammaConversion* theGammaConversion = new G4GammaConversion();
            G4LivermoreGammaConversionModel* theLivermoreGammaConversionModel =
                    new G4LivermoreGammaConversionModel();
            theLivermoreGammaConversionModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
            theGammaConversion->AddEmModel(0, theLivermoreGammaConversionModel);
            ph->RegisterProcess(theGammaConversion, particle);
 
            G4RayleighScattering* theRayleigh = new G4RayleighScattering();
            G4LivermoreRayleighModel* theRayleighModel = new G4LivermoreRayleighModel();
            theRayleighModel->SetHighEnergyLimit(LivermoreHighEnergyLimit);
            theRayleigh->AddEmModel(0, theRayleighModel);
            ph->RegisterProcess(theRayleigh, particle);
 
        }
        else if(particleType == "Molecule" && particleName != "H_{2}O")
        {
            if  (pmanager==0)
            {
                particle->SetProcessManager(new G4ProcessManager(particle));
            }
 
            G4DNABrownianTransportation* brown = new G4DNABrownianTransportation();
            ph->RegisterProcess(brown, particle);
        }
        else if (particleName == "H_{2}O")
        {
            if  (pmanager==0)
            {
                particle->SetProcessManager(new G4ProcessManager(particle));
            }
 
            G4DNAMolecularDecay* decayProcess = new G4DNAMolecularDecay("H2O_DNAMolecularDecay");
            decayProcess -> SetDecayDisplacer(particle, new G4DNAMolecularDecayDisplacer);
            decayProcess -> SetVerboseLevel(1);
            ph->RegisterProcess(decayProcess, particle);
 
        }
 
 
        // Warning : end of particles and processes are needed by EM Physics builders
 
    }
 
    // Deexcitation
    //
    G4VAtomDeexcitation* de = new G4UAtomicDeexcitation();
    G4LossTableManager::Instance()->SetAtomDeexcitation(de);
    de->SetFluo(true);
 
    // Chemistry
    ConstructReactionTable();
 
    /**
      * Tells to the chemistry manager whether the chemistry
      * needs to be activated.
      * WARNING : if you don't use the chemistry do not activate it
      * otherwise it might generate memory leaks with tracks created but
      * not destroyed.
      */
    G4DNAChemistryManager::Instance()->SetChemistryActivation(true);
}

ConstructReactionTable()

void G4EmDNAPhysicsChemistry::ConstructReactionTable ( )

protected

Definition at line 387 of file G4EmDNAPhysicsChemistry.cc.

{
    G4DNAMolecularReactionTable* theReactionTable = G4DNAMolecularReactionTable::GetReactionTable();
 
    G4Molecule* OHm = new G4Molecule(G4OH::Definition());
    OHm->AddElectron(3);
    OHm->SetMass(17.0079*g/Avogadro * c_squared);
    OHm->SetDiffusionCoefficient(5.0e-9*(m2/s));
    G4Molecule* OH = new G4Molecule(G4OH::Definition());
    G4Molecule* e_aq = new G4Molecule(G4Electron_aq::Definition());
    G4Molecule* H = new G4Molecule(G4Hydrogen::Definition());
    G4Molecule* H3Op = new G4Molecule(G4H3O::Definition());
    G4Molecule* H2O2 = new G4Molecule(G4H2O2::Definition());
    H3Op->RemoveElectron(4,1);
 
    G4Molecule* H2 = new G4Molecule(G4H2::Definition());
 
    //------------------------------------------------------------------
    //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);
    //------------------------------------------------------------------
    //OH + H2 -> H + H2O
    reactionData = new G4DNAMolecularReactionData(4.17e7*(1e-3*m3/(mole*s)), OH, H2);
    reactionData->AddProduct(H);
    theReactionTable -> SetReaction(reactionData);
    //------------------------------------------------------------------
}

Referenced by ConstructProcess().

---

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

• G4EmDNAPhysicsChemistry.hh
• G4EmDNAPhysicsChemistry.cc