Classes
class	AqueousSolution

class	Component

class	EquilibriumReactants

class	InitialAqueousSolution

class	KineticReactant

class	Kinetics

class	PhaseComponent

class	PhreeqcKernel

class	ReactionRate

Functions
static bool	isHydrogen (std::string_view const element)

AqueousSolution	createAqueousSolution (BaseLib::ConfigTree const &config, std::vector< std::pair< int, std::string > > const &process_id_to_component_name_map)

std::unique_ptr< EquilibriumReactants >	createEquilibriumReactants (std::optional< BaseLib::ConfigTree > const &config, MeshLib::Mesh const &mesh)

InitialAqueousSolution	createInitialAqueousSolution (BaseLib::ConfigTree const &config, std::vector< std::pair< int, std::string > > const &process_id_to_component_name_map)

std::unique_ptr< Kinetics >	createKineticReactants (std::optional< BaseLib::ConfigTree > const &config, MeshLib::Mesh const &mesh)

Function Documentation

◆ createAqueousSolution()

AqueousSolution ChemistryLib::PhreeqcKernelData::createAqueousSolution	(	BaseLib::ConfigTree const &	config,
		std::vector< std::pair< int, std::string > > const &	process_id_to_component_name_map )

Input File Parameter: prj__chemical_system__solution__temperature

Input File Parameter: prj__chemical_system__solution__pressure

Input File Parameter: prj__chemical_system__solution__pe

Definition at line 20 of file CreateAqueousSolution.cpp.

{
    auto const temperature = config.getConfigParameter<double>("temperature");
 
    auto const pressure = config.getConfigParameter<double>("pressure");
 
    auto const pe = config.getConfigParameter<double>("pe");
 
    auto const initial_aqueous_solution =
        createInitialAqueousSolution(config, process_id_to_component_name_map);
 
    return {temperature, pressure, pe, initial_aqueous_solution};
}

References createInitialAqueousSolution(), BaseLib::ConfigTree::getConfigParameter(), and ChemistryLib::pe.

◆ createEquilibriumReactants()

std::unique_ptr< EquilibriumReactants > ChemistryLib::PhreeqcKernelData::createEquilibriumReactants	(	std::optional< BaseLib::ConfigTree > const &	config,
		MeshLib::Mesh const &	mesh )

Input File Parameter: prj__chemical_system__equilibrium_reactants__phase_component

Input File Parameter: prj__chemical_system__equilibrium_reactants__phase_component__name

Input File Parameter: prj__chemical_system__equilibrium_reactants__phase_component__initial_amount

Input File Parameter: prj__chemical_system__equilibrium_reactants__phase_component__saturation_index

Definition at line 25 of file CreateEquilibriumReactants.cpp.

{
    if (!config)
    {
        return nullptr;
    }
 
    std::vector<PhaseComponent> phase_components;
    for (
        auto const& phase_component_config :
        config->getConfigSubtreeList("phase_component"))
    {
        auto name =
            phase_component_config.getConfigParameter<std::string>("name");
 
        double const initial_amount =
            phase_component_config.getConfigParameter<double>("initial_amount");
 
        double const saturation_index =
            phase_component_config.getConfigParameter<double>(
                "saturation_index");
 
        auto amount = MeshLib::getOrCreateMeshProperty<double>(
            const_cast<MeshLib::Mesh&>(mesh),
            name,
            MeshLib::MeshItemType::Node,
            1);
        std::fill(amount->begin(), amount->end(), initial_amount);
 
        phase_components.emplace_back(
            std::move(name), initial_amount, saturation_index);
    }
 
    return std::make_unique<EquilibriumReactants>(phase_components);
}

References MeshLib::Node.

◆ createInitialAqueousSolution()

InitialAqueousSolution ChemistryLib::PhreeqcKernelData::createInitialAqueousSolution	(	BaseLib::ConfigTree const &	config,
		std::vector< std::pair< int, std::string > > const &	process_id_to_component_name_map )

Input File Parameter: prj__chemical_system__solution__components

Input File Parameter: prj__chemical_system__solution__components__component

Definition at line 23 of file CreateInitialAqueousSolution.cpp.

{
    std::map<std::string, cxxISolutionComp> components;
    auto comp_config = config.getConfigSubtree("components");
    for (
        auto const& component_config :
        comp_config.getConfigSubtreeList("component"))
    {
        auto const component_name = component_config.getValue<std::string>();
        Component component(component_name);
        components.emplace(component_name, component);
    }
 
    for (auto const& component : components)
    {
        auto process_id_to_component_name_pair =
            std::find_if(process_id_to_component_name_map.begin(),
                         process_id_to_component_name_map.end(),
                         [&component](auto const& pair)
                         { return pair.second == component.first; });
 
        if (process_id_to_component_name_pair ==
            process_id_to_component_name_map.end())
        {
            OGS_FATAL(
                "Component {:s} given in <solution>/<components> is not found "
                "in specified coupled processes (see "
                "<process>/<process_variables>/<concentration>).",
                component.first);
        }
    }
 
    if (components.size() + 1 != process_id_to_component_name_map.size())
    {
        OGS_FATAL(
            "The number of components given in <solution>/<components> is not "
            "in line with the number of transport processes - 1 which stands "
            "for the transport process of hydrogen.");
    }
 
    auto const charge_balance = createChargeBalance(config);
    if (charge_balance == ChargeBalance::pH)
    {
        Component component("H(1)");
        component.Set_equation_name("charge");
        components.emplace("H(1)", component);
    }
    if (charge_balance == ChargeBalance::pe)
    {
        OGS_FATAL(
            "Adjusting pe value for charge balance is unsupported yet with the "
            "chemical solver 'PhreeqcKernel'. Please use the chemical solver "
            "'Phreeqc' for this functionality.");
    }
 
    return InitialAqueousSolution(components);
}

References ChemistryLib::createChargeBalance(), BaseLib::ConfigTree::getConfigSubtree(), BaseLib::ConfigTree::getValue(), OGS_FATAL, ChemistryLib::pe, and ChemistryLib::pH.

Referenced by createAqueousSolution().

◆ createKineticReactants()

std::unique_ptr< Kinetics > ChemistryLib::PhreeqcKernelData::createKineticReactants	(	std::optional< BaseLib::ConfigTree > const &	config,
		MeshLib::Mesh const &	mesh )

Input File Parameter: prj__chemical_system__kinetic_reactants__kinetic_reactant

Input File Parameter: prj__chemical_system__kinetic_reactants__kinetic_reactant__name

Input File Parameter: prj__chemical_system__kinetic_reactants__kinetic_reactant__initial_amount

Definition at line 25 of file CreateKineticReactant.cpp.

{
    if (!config)
    {
        return nullptr;
    }
 
    std::vector<KineticReactant> kinetic_reactants;
    for (
        auto const& reactant_config :
        config->getConfigSubtreeList("kinetic_reactant"))
    {
        auto name = reactant_config.getConfigParameter<std::string>("name");
 
        double const initial_amount =
            reactant_config.getConfigParameter<double>("initial_amount");
 
        auto* const amount = MeshLib::getOrCreateMeshProperty<double>(
            const_cast<MeshLib::Mesh&>(mesh),
            name,
            MeshLib::MeshItemType::Node,
            1);
        std::fill(std::begin(*amount), std::end(*amount), initial_amount);
 
        kinetic_reactants.emplace_back(std::move(name), initial_amount);
    }
 
    return std::make_unique<Kinetics>(kinetic_reactants);
}

References MeshLib::Node.

◆ isHydrogen()

static bool ChemistryLib::PhreeqcKernelData::isHydrogen ( std::string_view const element )

static

Definition at line 185 of file PhreeqcKernel.cpp.

{
    return element == "H";
}

Referenced by ChemistryLib::PhreeqcKernelData::PhreeqcKernel::setAqueousSolutions(), and ChemistryLib::PhreeqcKernelData::PhreeqcKernel::updateNodalProcessSolutions().