pyEQL 1.4.0rc9__cp311-cp311-macosx_10_9_x86_64.whl

pyEQL/equilibrium.py

@@ -0,0 +1,227 @@
+"""
+pyEQL methods for chemical equilibrium calculations (e.g. acid/base, reactions,
+redox, complexation, etc.).
+
+NOTE: these methods are not currently used but are here for the future.
+
+:copyright: 2013-2024 by Ryan S. Kingsbury
+:license: LGPL, see LICENSE for more details.
+
+"""
+
+# import libraries for scientific functions
+import logging
+
+import numpy as np
+
+from pyEQL import ureg
+
+logger = logging.getLogger(__name__)
+
+# TODO - not used. Remove?
+SPECIES_ALIAISES = {
+    "Sodium": "Na+",
+    "Potassium": "K+",
+    "Calcium": "Ca+2",
+    "Barium": "Ba+2",
+    "Strontium": "Sr+2",
+    "Magnesium": "Mg+2",
+    "Chloride": "Cl-",
+    "Fluoride": "F-",
+    "Nitrate": "NO3-",
+    "Ammonium": "NH4+",
+    "Sulfate": "SO4-2",
+    "Phosphate": "PO4-3",
+    "Carbonate": "CO3-2",
+    "Bicarbonate": "HCO3-",
+}
+
+
+def adjust_temp_pitzer(c1, c2, c3, c4, c5, temp, temp_ref=ureg.Quantity("298.15 K")):
+    """
+    Calculate a parameter for the Pitzer model based on temperature-dependent coefficients c1,c2,c3,c4,and c5.
+
+    Args:
+        c1, c2, c3, c4, c5 (float): Temperature-dependent coefficients for the pitzer parameter of interest.
+        temp (Quantity): The temperature at which the Pitzer parameter is to be calculated.
+        temp_ref (Quantity, optional): The reference temperature on which the parameters are based. Defaults to 298.15 K if omitted.
+
+    Note:
+        As described in the PHREEQC documentation.
+    """
+    return (
+        c1
+        + c2 * (1 / temp + 1 / temp_ref)
+        + c2 * np.log(temp / temp_ref)
+        + c3 * (temp - temp_ref)
+        + c4 * (temp**2 - temp_ref**2)
+        + c5 * (temp**-2 - temp_ref**-2)
+    )
+
+
+def adjust_temp_vanthoff(equilibrium_constant, enthalpy, temperature, reference_temperature=ureg.Quantity(25, "degC")):
+    r"""
+    Adjust a reaction equilibrium constant from one temperature to another.
+
+    Args:
+        equilibrium_constant (float): The reaction equilibrium constant for the reaction.
+        enthalpy (Quantity): The enthalpy change (delta H) for the reaction in kJ/mol. Assumed independent of temperature (see Notes).
+        temperature (Quantity): The desired reaction temperature in degrees Celsius.
+        reference_temperature (Quantity, optional): The temperature at which equilibrium_constant is valid. Defaults to 25 degrees C if omitted.
+
+    Returns:
+        float: The adjusted reaction equilibrium constant.
+
+    Note:
+        This function implements the Van't Hoff equation to adjust measured equilibrium constants to other temperatures.
+
+        .. math::
+            ln(K2 / K1) = {\delta H \over R} ( {1 \over T_1} - {1 \over T_2} )
+
+        This implementation assumes that the enthalpy is independent of temperature over the range of interest.
+
+    References:
+        Stumm, Werner and Morgan, James J. Aquatic Chemistry, 3rd ed, pp 53. Wiley Interscience, 1996.
+
+    Examples:
+        >>> adjust_temp_vanthoff(0.15,ureg.Quantity('-197.6 kJ/mol'),ureg.Quantity('42 degC'),ureg.Quantity(' 25degC')) #doctest: +ELLIPSIS
+        0.00203566...
+
+        If the 'ref_temperature' parameter is omitted, a default of 25 C is used.
+
+        >>> adjust_temp_vanthoff(0.15,ureg.Quantity('-197.6 kJ/mol'),ureg.Quantity('42 degC')) #doctest: +ELLIPSIS
+        0.00203566...
+    """
+    output = equilibrium_constant * np.exp(
+        enthalpy / ureg.R * (1 / reference_temperature.to("K") - 1 / temperature.to("K"))
+    )
+
+    logger.debug(
+        "Adjusted equilibrium constant K=%s from %s to %s degrees Celsius with Delta H = %s. Adjusted K = %s % equilibrium_constant,reference_temperature,temperature,enthalpy,output"
+    )
+
+    logger.info(
+        "Note that the Van't Hoff equation assumes enthalpy is independent of temperature over the range of interest"
+    )
+    return output
+
+
+def adjust_temp_arrhenius(
+    rate_constant,
+    activation_energy,
+    temperature,
+    reference_temperature=ureg.Quantity(25, "degC"),
+):
+    r"""
+    Adjust a reaction equilibrium constant from one temperature to another.
+
+    Args:
+        rate_constant (Quantity): The parameter value (usually a rate constant) being adjusted.
+        activation_energy (Quantity): The activation energy of the process, in kJ/mol.
+        temperature (Quantity): The desired reaction temperature.
+        reference_temperature (Quantity, optional): The temperature at which equilibrium_constant is valid. Defaults to 25 degrees C if omitted.
+
+    Returns:
+        Quantity: The adjusted reaction equilibrium constant.
+
+    Notes:
+        This function implements the Arrhenius equation to adjust measured rate constants to other temperatures.
+        TODO - add better reference
+
+        .. math::
+            \ln\left((\frac{K_2}{K_1}\right) = \frac{E_a}{R} \left( \frac{1}{T_{1}} - {\frac{1}{T_2}} \right)
+
+    References:
+        https://chem.libretexts.org/Bookshelves/Physical_and_Theoretical_Chemistry_Textbook_Maps/Physical_Chemistry_(LibreTexts)/28%3A_Chemical_Kinetics_I_-_Rate_Laws/28.07%3A_Rate_Constants_Are_Usually_Strongly_Temperature_Dependent
+
+    Examples:
+        >>> adjust_temp_arrhenius(7,900*ureg.Quantity('kJ/mol'),37*ureg.Quantity('degC'),97*ureg.Quantity('degC')) #doctest: +ELLIPSIS
+        1.8867225...e-24
+    """
+    output = rate_constant * np.exp(
+        activation_energy / ureg.R * (1 / reference_temperature.to("K") - 1 / temperature.to("K"))
+    )
+
+    logger.debug(
+        f"Adjusted parameter {rate_constant} from {reference_temperature} to {temperature} degrees Celsius with"
+        f"Activation Energy = {activation_energy}s kJ/mol. Adjusted value = {output}"
+    )
+
+    return output
+
+
+def alpha(n, pH, pKa_list):
+    r"""
+    Returns the acid-base distribution coefficient (alpha) of an acid in the n-deprotonated form at a given pH.
+
+    Args:
+        n (int): The number of protons that have been lost by the desired form of the acid. Also the subscript on the
+            alpha value. E.g. for bicarbonate (HCO3-), n=1 because 1 proton has been lost from the fully-protonated
+            carbonic acid (H2CO3) form.
+        pH (float or int): The pH of the solution.
+        pKa_list (list of floats or ints): The pKa values (negative log of equilibrium constants) for the acid of
+            interest. There must be a minimum of n pKa values in the list.
+
+    Returns:
+        float: The fraction of total acid present in the specified form.
+
+    Notes:
+        The acid-base coefficient is calculated as follows: [stm]_
+
+        .. math::
+
+            \alpha_n = \frac{term_n}{[H+]^n + k_{a1}[H+]^{n-1} + k_{a1}k_{a2}[H+]^{n-2} ... k_{a1}k_{a2}...k_{an} }
+
+        Where :math: '\term_n' refers to the nth term in the denominator, starting from 0
+
+    References:
+        Stumm, Werner and Morgan, James J. Aquatic Chemistry, 3rd ed, pp 127-130. Wiley Interscience, 1996.
+
+    Examples:
+        >>> alpha(1,8,[4.7]) #doctest: +ELLIPSIS
+        0.999...
+
+        The sum of all alpha values should equal 1
+
+        >>> alpha(0,8,[6.35,10.33]) #doctest: +ELLIPSIS
+        0.021...
+        >>> alpha(1,8,[6.35,10.33]) #doctest: +ELLIPSIS
+        0.979...
+        >>> alpha(2,8,[6.35,10.33]) #doctest: +ELLIPSIS
+        2.043...e-09
+
+        If pH is equal to one of the pKa values the function should return 0.5.
+
+        >>> alpha(1,6.35,[6.35,10.33])
+        0.5
+    """
+    # generate an error if no pKa values are specified
+    if len(pKa_list) == 0:
+        raise ValueError("No pKa values given. Cannot calculate distribution coefficient.")
+
+    # generate an error if n > number of pKa values
+    if len(pKa_list) < n:
+        raise ValueError("Insufficient number of pKa values given. Cannot calculate distribution coefficient.")
+
+    # sort the pKa list
+    pKa_list = sorted(pKa_list)
+
+    # determine how many protons the acid has
+    num_protons = len(pKa_list)
+
+    # build a list of terms where the term subscript corresponds to the list index
+    terms_list = [10 ** (-pH * num_protons)]
+    for i in range(len(pKa_list)):
+        # multiply together all K values with
+        k_term = 1
+        for pK in pKa_list[0 : i + 1]:
+            k_term *= 10**-pK
+        terms_list.append(k_term * 10 ** (-pH * (num_protons - (i + 1))))
+    print(terms_list)
+
+    # return the desired distribution factor
+    alpha = terms_list[n] / sum(terms_list)
+    logger.debug(
+        "Calculated %s-deprotonated acid distribution coefficient of %s for pKa=%s at pH %s % n,alpha,pKa_list,pH"
+    )
+    return alpha

pyEQL/functions.py

@@ -0,0 +1,281 @@
+"""
+pyEQL functions that take Solution objects as inputs or return Solution objects.
+
+:copyright: 2013-2024 by Ryan S. Kingsbury
+:license: LGPL, see LICENSE for more details.
+
+"""
+
+import logging
+
+import numpy as np
+
+from pyEQL import Solution, ureg
+
+logger = logging.getLogger(__name__)
+
+
+def gibbs_mix(solution1: Solution, solution2: Solution, activity_correction: bool = True):
+    r"""
+    Return the Gibbs energy change associated with mixing two solutions.
+
+    Args:
+        solution1: a solution to be mixed.
+        solution2: a solution to be mixed.
+        activity_correction : bool, optional
+            If True, activities will be used to calculate the true energy of
+            mixing. If False, mole fraction will be used, resulting in a
+            calculation of the ideal energy of mixing (i.e., :math:`\Delta_{mix} S \times T` )
+
+    Returns:
+        The change in Gibbs energy associated with complete mixing of the
+        Solutions, in Joules.
+
+    Notes:
+        The Gibbs energy of mixing is calculated as follows
+
+        .. math::
+
+            \Delta_{mix} G_{true} = \sum_i {(n_c + n_d) R T \ln a_b} - \sum_i {n_c R T \ln a_c} - \sum_i {n_d R T \ln a_d}
+
+        or
+
+        .. math::
+
+            \Delta_{mix} G_{ideal} = \sum_i {(n_c + n_d) R T \ln x_b} - \sum_i {n_c R T \ln x_c} - \sum_i {n_d R T \ln x_d}
+
+
+        Where :math:`n` is the number of moles of substance, :math:`T` is the temperature in kelvin, :math:`a` is the activity of solute :math:`i`,
+        :math:`x` is the mole fraction of solute :math:`i`, and  subscripts :math:`b`, :math:`c`, and :math:`d` refer to the concentrated, dilute, and blended
+        Solutions, respectively.
+
+        Note that dissociated ions must be counted as separate components,
+        so a simple salt dissolved in water is a three component solution (cation,
+        anion, and water).
+
+    References:
+        Koga, Yoshikata, 2007. Solution Thermodynamics and its Application to Aqueous Solutions:
+            A differential approach. Elsevier, 2007, pp. 23-37.
+
+    """
+    concentrate = solution1
+    dilute = solution2
+    blend = solution1 + solution2
+    term_list = {concentrate: 0, dilute: 0, blend: 0}
+
+    # calculate the entropy change and number of moles solute for each solution
+    for solution in term_list:
+        for solute in solution.components:
+            if solution.get_amount(solute, "fraction") != 0:
+                if activity_correction is True:
+                    term_list[solution] += solution.get_amount(solute, "mol") * np.log(solution.get_activity(solute))
+                else:
+                    term_list[solution] += solution.get_amount(solute, "mol") * np.log(
+                        solution.get_amount(solute, "fraction")
+                    )
+
+    return (ureg.R * blend.temperature.to("K") * (term_list[blend] - term_list[concentrate] - term_list[dilute])).to(
+        "J"
+    )
+
+
+def entropy_mix(solution1: Solution, solution2: Solution):
+    r"""
+    Return the ideal mixing entropy associated with mixing two solutions.
+
+    Parameters:
+        solution1, solution2: The two solutions to be mixed.
+
+    Returns:
+        The ideal mixing entropy associated with complete mixing of the
+        Solutions, in Joules per Kelvin.
+
+    Notes:
+        The ideal entropy of mixing is calculated as follows
+
+        .. math::
+
+            \Delta_{mix} S = \sum_i {(n_c + n_d) R \ln x_b} - \sum_i {n_c R \ln x_c} - \sum_i {n_d R \ln x_d}
+
+        Where :math:`n` is the number of moles of substance, :math:`T` is the temperature in kelvin, :math:`x` is the
+        mole fraction of solute :math:`i`, and  subscripts :math:`b`, :math:`c`, and :math:`d` refer to the
+        concentrated, dilute, and blended Solutions, respectively.
+
+        Note that dissociated ions must be counted as separate components,
+        so a simple salt dissolved in water is a three component solution (cation,
+        anion, and water).
+
+    References:
+        Koga, Yoshikata, 2007. *Solution Thermodynamics and its Application to Aqueous Solutions: *
+        *A differential approach.* Elsevier, 2007, pp. 23-37.
+
+    """
+    concentrate = solution1
+    dilute = solution2
+    blend = solution1 + solution2
+    term_list = {concentrate: 0, dilute: 0, blend: 0}
+
+    # calculate the entropy change and number of moles solute for each solution
+    for solution in term_list:
+        for solute in solution.components:
+            if solution.get_amount(solute, "fraction") != 0:
+                term_list[solution] += solution.get_amount(solute, "mol") * np.log(
+                    solution.get_amount(solute, "fraction")
+                )
+
+    return (ureg.R * (term_list[blend] - term_list[concentrate] - term_list[dilute])).to("J/K")
+
+
+def donnan_eql(solution: Solution, fixed_charge: str):
+    r"""
+    Return a solution object in equilibrium with fixed_charge.
+
+    Args:
+        solution : Solution object
+            The external solution to be brought into equilibrium with the fixed
+            charges
+        fixed_charge : str quantity
+            String representing the concentration of fixed charges, including sign.
+            May be specified in mol/L or mol/kg units. e.g. '1 mol/kg'
+
+    Returns:
+        A Solution that has established Donnan equilibrium with the external
+        (input) Solution
+
+    Notes:
+        The general equation representing the equilibrium between an external
+        electrolyte solution and an ion-exchange medium containing fixed charges
+        is
+
+        .. math::
+
+            \big(\frac{a_{-}}{\bar a_{-}} \big)^{(\frac{1}{z_{-}})}
+            \big(\frac{\bar a_{+}}{a_{+}}\big)^{(\frac{1}{z_{+}})}
+            =\exp \big(\frac{\Delta \pi \bar V}{RT z_{+} \nu_{+}}\big)
+
+        Where subscripts :math:`+` and :math:`-` indicate the cation and anion, respectively,
+        the overbar indicates the membrane phase,
+        :math:`a` represents activity, :math:`z` represents charge, :math:`\nu` represents the stoichiometric
+        coefficient, :math:`V` represents the partial molar volume of the salt, and
+        :math:`\Delta \pi` is the difference in osmotic pressure between the membrane and the
+        solution phase.
+
+        In addition, electroneutrality must prevail within the membrane phase:
+
+        .. math:: \bar C_{+} z_{+} + \bar X + \bar C_{-} z_{-} = 0
+
+        Where :math:`C` represents concentration and :math:`X` is the fixed charge concentration
+        in the membrane or ion exchange phase.
+
+        This function solves these two equations simultaneously to arrive at the
+        concentrations of the cation and anion in the membrane phase. It returns
+        a solution equal to the input solution except that the concentrations of
+        the predominant cation and anion have been adjusted according to this
+        equilibrium.
+
+        NOTE that this treatment is only capable of equilibrating a single salt.
+        This salt is identified by the get_salt() method.
+
+    References:
+        Strathmann, Heiner, ed. *Membrane Science and Technology* vol. 9, 2004. Chapter 2, p. 51.
+           http://dx.doi.org/10.1016/S0927-5193(04)80033-0
+
+    See Also:
+        get_salt()
+
+    """
+    # identify the salt
+    salt = solution.get_salt()
+
+    # convert fixed_charge in to a quantity
+    fixed_charge = ureg.Quantity(fixed_charge)
+
+    # identify variables from the external solution
+    conc_cation_soln = solution.get_amount(salt.cation, str(fixed_charge.units))
+    conc_anion_soln = solution.get_amount(salt.anion, str(fixed_charge.units))
+    act_cation_soln = solution.get_activity(salt.cation)
+    act_anion_soln = solution.get_activity(salt.anion)
+    z_cation = salt.z_cation
+    z_anion = salt.z_anion
+    nu_cation = salt.nu_cation
+
+    # get the partial molar volume for the salt, or calculate it from the ions
+    # TODO - consider how to incorporate pitzer parameters
+    molar_volume = solution.get_property(salt.formula, "size.molar_volume")
+    if molar_volume is None:
+        cation_vol = solution.get_property(salt.cation, "size.molar_volume")
+        anion_vol = solution.get_property(salt.anion, "size.molar_volume")
+        if cation_vol is not None and anion_vol is not None:
+            molar_volume = cation_vol + anion_vol
+        else:
+            logger.error("Required partial molar volume information not available. Aborting.")
+            return None
+
+    # initialize the equilibrated solution - start with a direct copy of the
+    # input / external solution
+    donnan_soln = solution.copy()
+
+    # do nothing if either of the ion concentrations is zero
+    if conc_cation_soln.magnitude == 0 or conc_anion_soln.magnitude == 0:
+        return donnan_soln
+
+    # define a function representing the donnan equilibrium as a function
+    # of the two unknown activities to feed to the nonlinear solver
+
+    # the stuff in the term below doesn't change on iteration, so calculate it up-front
+    # assign it the correct units and extract the magnitude for a performance gain
+    exp_term = (molar_volume / (ureg.R * solution.temperature * z_cation * nu_cation)).to("1/Pa").magnitude
+
+    def donnan_solve(x):
+        """Where x is the magnitude of co-ion concentration."""
+        # solve for the counter-ion concentration by enforcing electroneutrality
+        # using only floats / ints here instead of quantities helps performance
+        if fixed_charge.magnitude >= 0:
+            # counter-ion is the anion
+            conc_cation_mem = x / abs(z_cation)
+            conc_anion_mem = -(conc_cation_mem * z_cation + fixed_charge.magnitude) / z_anion
+        elif fixed_charge.magnitude < 0:
+            # counter-ion is the cation
+            conc_anion_mem = x / abs(z_anion)
+            conc_cation_mem = -(conc_anion_mem * z_anion + fixed_charge.magnitude) / z_cation
+
+        # match the units given for fixed_charge
+        units = str(fixed_charge.units)
+
+        # set the cation and anion concentrations in the membrane phase equal
+        # to the current guess
+        donnan_soln.set_amount(salt.cation, str(conc_cation_mem) + units)
+        donnan_soln.set_amount(salt.anion, str(conc_anion_mem) + units)
+
+        # get the new concentrations and activities
+        act_cation_mem = donnan_soln.get_activity(salt.cation)
+        act_anion_mem = donnan_soln.get_activity(salt.anion)
+
+        # compute the difference in osmotic pressure
+        # using the magnitudes here helps performance
+        delta_pi = donnan_soln.osmotic_pressure.magnitude - solution.osmotic_pressure.magnitude
+
+        return (act_cation_mem / act_cation_soln) ** (1 / z_cation) * (act_anion_soln / act_anion_mem) ** (
+            1 / z_anion
+        ) - np.exp(delta_pi * exp_term)
+
+    # solve the function above using one of scipy's nonlinear solvers
+
+    from scipy.optimize import brentq  # noqa: PLC0415
+
+    # determine which ion concentration represents the co-ion
+    # call a nonlinear solver to adjust the concentrations per the donnan
+    # equilibrium, unless the membrane is uncharged
+    # the initial guess is to set the co-ion concentration in the membrane
+    # equal to that in the solution
+    if fixed_charge.magnitude > 0:
+        x = conc_cation_soln.magnitude
+        brentq(donnan_solve, 1e-10, x, xtol=0.001)
+    elif fixed_charge.magnitude < 0:
+        x = conc_anion_soln.magnitude
+        brentq(donnan_solve, 1e-10, x, xtol=0.001)
+    else:
+        pass
+
+    # return the equilibrated solution
+    return donnan_soln

pyEQL/phreeqc/__init__.py

@@ -0,0 +1,5 @@
+from .core import IS_AVAILABLE, Phreeqc
+from .solution import PHRQSol
+
+__all__ = ["IS_AVAILABLE", "PHRQSol", "Phreeqc"]
+__version__ = "3.8.6-17100.r1"

pyEQL/phreeqc/bindings.cpp

@@ -0,0 +1,84 @@
+#include <pybind11/pybind11.h>
+#include "iphreeqc_wrapper.cpp"
+
+#define STRINGIFY(x) #x
+#define MACRO_STRINGIFY(x) STRINGIFY(x)
+
+namespace py = pybind11;
+
+// managed Var that doesn't leak memory
+class PyVar {
+    public: VAR var;
+public:
+    PyVar() {
+        VarInit(&this->var);
+    }
+
+    ~PyVar() {
+        VarClear(&this->var);
+    }
+};
+
+
+PYBIND11_MODULE(_phreeqc, m) {
+
+    py::enum_<VAR_TYPE>(m, "PY_VAR_TYPE", py::module_local())
+        .value("TT_EMPTY", TT_EMPTY)
+        .value("TT_ERROR", TT_ERROR)
+        .value("TT_LONG", TT_LONG)
+        .value("TT_DOUBLE", TT_DOUBLE)
+        .value("TT_STRING", TT_STRING);
+
+    py::enum_<VRESULT>(m, "PY_VRESULT", py::module_local())
+        .value("VR_OK", VR_OK)
+        .value("VR_OUTOFMEMORY", VR_OUTOFMEMORY)
+        .value("VR_BADVARTYPE", VR_BADVARTYPE)
+        .value("VR_INVALIDARG", VR_INVALIDARG)
+        .value("VR_INVALIDROW", VR_INVALIDROW)
+        .value("VR_INVALIDCOL", VR_INVALIDCOL);
+
+    // The VAR type is exposed to Python, but only indirectly through an
+    // attribute of the PyVar class, which is why we name the class
+    // "_VAR".
+    py::class_<VAR>(m, "_VAR")
+        .def_readwrite("type", &VAR::type)
+        .def_readwrite("lVal", &VAR::lVal)
+        .def_readwrite("dVal", &VAR::dVal)
+        .def_property("sVal",   // property since str needs to be on the heap
+            [](const VAR& v) {  // getter
+                return std::string(v.sVal ? v.sVal : "");
+            },
+            [](VAR& v, const std::string& val) {  // setter
+                v.sVal = strdup(val.c_str());  // needs to be freed, which is done in VarClear
+            })
+        .def_readwrite("vresult", &VAR::vresult);
+
+    py::class_<PyVar>(m, "PyVar")
+        .def(py::init<>())
+        // For the following readwrite attribute to work, pybind11 needs to
+        // know how to expose VAR as a Python object, which is why we defined
+        // the class above.
+        .def_readwrite("var", &PyVar::var);
+
+    py::class_<IPhreeqcWrapper>(m, "PyIPhreeqc")
+        .def(py::init<>())
+        .def("load_database", &IPhreeqcWrapper::load_database)
+        .def("run_string", &IPhreeqcWrapper::run_string)
+        .def("get_error_string", &IPhreeqcWrapper::get_error_string)
+        .def("get_selected_output_row_count", &IPhreeqcWrapper::get_selected_output_row_count)
+        .def("get_selected_output_column_count", &IPhreeqcWrapper::get_selected_output_column_count)
+        .def("get_value", &IPhreeqcWrapper::get_value)
+        .def("get_component_count", &IPhreeqcWrapper::get_component_count)
+        .def("get_component", &IPhreeqcWrapper::get_component)
+        .def("set_dump_string_on", &IPhreeqcWrapper::set_dump_string_on)
+        .def("get_dump_string", &IPhreeqcWrapper::get_dump_string)
+        .def("set_log_string_on", &IPhreeqcWrapper::set_log_string_on)
+        .def("get_log_string", &IPhreeqcWrapper::get_log_string);
+
+
+#ifdef VERSION_INFO
+    m.attr("__version__") = MACRO_STRINGIFY(VERSION_INFO);
+#else
+    m.attr("__version__") = "dev";
+#endif
+}