rock-physics-open 0.3.2__py3-none-any.whl

rock_physics_open/span_wagner/co2_properties.py

@@ -0,0 +1,444 @@
+import importlib
+
+import numpy as np
+import scipy.optimize
+from scipy.interpolate import RegularGridInterpolator
+
+from rock_physics_open.equinor_utilities.conversions import celsius_to_kelvin
+from rock_physics_open.span_wagner import equations
+from rock_physics_open.span_wagner.coefficients import (
+    a0,
+    theta0,
+)
+from rock_physics_open.span_wagner.tables.lookup_table import (
+    load_lookup_table_interpolator,
+)
+
+# Constants
+CO2_GAS_CONSTANT = 0.1889241 * 1e3  # J / kg K
+CO2_CRITICAL_TEMPERATURE = 304.1282  # K
+CO2_CRITICAL_DENSITY = 467.6  # kg / m^3
+CO2_CRITICAL_PRESSURE = 7.3773  # MPa
+CO2_TRIPLE_TEMPERATURE = 216.592  # K
+CO2_TRIPLE_PRESSURE = 0.51795  # MPa
+
+
+def co2_properties(temp, pres):
+    """
+    CO2 properties are estimated according to Span & Wagner's equation of state model.
+    References
+    ----------
+    R. Span and W. Wagner: A new equation of state for carbon dioxide covering the
+    fluid region from the triple point temperature to 1100K at pressures up to
+    800 MPa.
+    J. Phys. Chem. Ref. Data, Vol. 25, No. 6, 1996, pp 1509 - 1596
+
+    Parameters
+    ----------
+    temp: np.ndarray
+        Temperature [°C]
+    pres: np.ndarray
+        Pressure [Pa]
+
+    Returns
+    -------
+    tuple
+        vel_co2, den_co2, k_co2 : (np.ndarray, np.ndarray, np.ndarray).
+        vel_co2: velocity [m/s], den_co2: density [kg/m^3], k_co2: bulk modulus [Pa].
+    """
+    abs_temp = celsius_to_kelvin(temp)
+    pres_mpa = pres * 1.0e-6
+    den_co2 = carbon_dioxide_density(abs_temp, pres_mpa)
+    k_co2 = carbon_dioxide_bulk_modulus(abs_temp, den_co2)
+    vel_co2 = (k_co2 / den_co2) ** 0.5
+
+    return vel_co2, den_co2, k_co2
+
+
+def co2_helmholtz_energy(delta, tau, dd, dt):
+    """
+    Helmholtz energy as defined by equation 6.1 in Span & Wagner [2]
+
+    :param delta: Reduced density, unit-less. That is, density / CO2_CRITICAL_DENSITY.
+    :param tau: Inverse reduced temperature, unit-less. That is, CO2_CRITICAL_TEMPERATURE / (absolute) temperature
+    :param dd: Degree of derivation wrt. delta. Integer between 0 and 2.
+    :param dt: Degree of derivation wrt. tau. Integer between 0 and 2, as long as (dt + dd < 3)
+    """
+    return ideal_gas_helmholtz_energy(
+        delta, tau, dd, dt
+    ) + co2_residual_helmholtz_energy(delta, tau, dd, dt)
+
+
+def ideal_gas_helmholtz_energy(delta, tau, dd, dt):
+    """
+    Helmholtz energy from ideal gas behavior as defined by equation 2.3 in Span & Wagner [2]. See function
+    co2_helmholtz_energy for argument documentation.
+    """
+    # Adjust array shapes
+    tau = np.asarray(tau)
+    delta = np.asarray(delta)
+    return_scalar = tau.ndim == 0
+    tau2 = tau.reshape(-1, 1)  # Needed for array-based sums
+
+    if dt == dd == 0:
+        _sum = np.sum(a0[0, 3:] * np.log(1 - np.exp(-theta0 * tau2)), axis=-1)
+        result = (
+            np.log(delta) + a0[0, 0] + a0[0, 1] * tau + a0[0, 2] * np.log(tau) + _sum
+        )
+    elif dt == 1 and dd == 0:
+        _sum = np.sum(
+            a0[0, 3:] * theta0 * ((1 - np.exp(-theta0 * tau2)) ** -1 - 1), axis=-1
+        )
+        result = a0[0, 1] + a0[0, 2] / tau + _sum
+    elif dt == 0 and dd == 1:
+        return 1 / delta
+    elif dt == 2 and dd == 0:
+        _sum = np.sum(
+            a0[0, 3:]
+            * theta0**2
+            * np.exp(-theta0 * tau2)
+            * (1 - np.exp(-theta0 * tau2)) ** -2,
+            axis=-1,
+        )
+        result = -a0[0, 2] / tau**2 - _sum
+    elif dt == 0 and dd == 2:
+        return -1 / delta**2
+    elif dt == 1 and dd == 1:
+        return 0
+    else:
+        raise ValueError
+    if return_scalar:
+        return result[0]
+    return result
+
+
+def co2_residual_helmholtz_energy(delta, tau, dd, dt):
+    """
+    Residual part of Helmholtz energy as defined by the equation in Table 32 of Span & Wagner [2]. See
+    co2_helmholtz_energy for argument documentation.
+    """
+    tau = np.asarray(tau)
+    delta = np.asarray(delta)
+    return_scalar = (tau.ndim == 0) & (delta.ndim == 0)
+    tau = tau.reshape(-1, 1)
+    delta = delta.reshape(-1, 1)
+    # tau == 1.0 or delta == 1.0 leads to numerically invalid results. The values are nudged to avoid nan output.
+    tau[tau == 1.0] -= 1e-15
+    delta[delta == 1.0] -= 1e-15
+
+    res = equations.residual_helmholtz_energy(delta, tau, dd, dt)
+
+    if return_scalar:
+        return res[0]
+    return res
+
+
+def carbon_dioxide_pressure(
+    absolute_temperature, density, d_density=0, d_temperature=0, isentropic=False
+):
+    """
+    CO2 pressure (MPa) as given by Table 3 of Span & Wagner [2]
+
+    :param absolute_temperature: Temperature in K.
+    :param density: CO2 density (kg / m^3).
+    :param d_density: Degree of derivation wrt. density.
+    :param d_temperature: Degree of derivation wrt. temperature.
+    :param isentropic: Correction for isentropic conditions. Relevant primarily for isentropic bulk modulus
+    """
+    tau = CO2_CRITICAL_TEMPERATURE / absolute_temperature
+    delta = density / CO2_CRITICAL_DENSITY
+    if d_temperature != 0:
+        raise ValueError(f"d_temperature must be 0, but was {d_temperature}")
+    if d_density == 0:
+        return (
+            density
+            * CO2_GAS_CONSTANT
+            * absolute_temperature
+            * (1 + delta * co2_residual_helmholtz_energy(delta, tau, 1, 0))
+            / 1e6
+        )
+    if d_density == 1:
+        first = 2 * delta * co2_residual_helmholtz_energy(delta, tau, 1, 0)
+        second = delta**2 * co2_residual_helmholtz_energy(delta, tau, 2, 0)
+        if isentropic is False:
+            third = 0
+        else:
+            # See Table 3 of Span & Wagner (speed of sound)
+            nom = (
+                1
+                + delta * co2_residual_helmholtz_energy(delta, tau, 1, 0)
+                - delta * tau * co2_residual_helmholtz_energy(delta, tau, 1, 1)
+            ) ** 2
+            den = tau**2 * (co2_helmholtz_energy(delta, tau, 0, 2))
+            third = -nom / den
+        return (
+            absolute_temperature * CO2_GAS_CONSTANT * (1 + first + second + third) / 1e6
+        )
+    return None
+
+
+def saturated_liquid_density(absolute_temperature):
+    """
+    Saturated liquid density as defined by equation 3.14 of Span & Wagner [2]
+
+    :param absolute_temperature: Absolute temperature in K. Should satisfy:
+        CO2_TRIPLE_TEMPERATURE < absolute_temperature < CO2_CRITICAL_TEMPERATURE
+    """
+    _a1 = 1.9245108
+    _a2 = -0.62385555
+    _a3 = -0.32731127
+    _a4 = 0.39245142
+    _t = 1 - absolute_temperature / CO2_CRITICAL_TEMPERATURE
+    inner = _a1 * _t**0.34 + _a2 * _t**0.5 + _a3 * _t ** (10 / 6) + _a4 * _t ** (11 / 6)
+    return CO2_CRITICAL_DENSITY * np.exp(inner)
+
+
+def saturated_vapor_density(absolute_temperature):
+    """
+    Saturated vapor density as defined by equation 3.15 of Span & Wagner
+
+    :param absolute_temperature: Absolute temperature in K. Should satisfy:
+        CO2_TRIPLE_TEMPERATURE < absolute_temperature < CO2_CRITICAL_TEMPERATURE
+    """
+    # Assert temp < critical
+    _a1 = -1.7074879
+    _a2 = -0.82274670
+    _a3 = -4.6008549
+    _a4 = -10.111178
+    _a5 = -29.742252
+    _t = 1 - absolute_temperature / CO2_CRITICAL_TEMPERATURE
+    inner = (
+        _a1 * _t**0.34
+        + _a2 * _t**0.5
+        + _a3 * _t
+        + _a4 * _t ** (7 / 3)
+        + _a5 * _t ** (14 / 3)
+    )
+    return CO2_CRITICAL_DENSITY * np.exp(inner)
+
+
+def sublimation_pressure(absolute_temperature):
+    """
+    Sublimation pressure as defined by equation 3.12 of Span & Wagner [2]
+
+    :param absolute_temperature: Absolute temperature in K. Should satisfy absolute_temperature < CO2_TRIPLE_TEMPERATURE
+    """
+    _a1 = -14.740846
+    _a2 = 2.4327015
+    _a3 = -5.3061778
+    _t = 1 - absolute_temperature / CO2_TRIPLE_TEMPERATURE
+    inner = _a1 * _t + _a2 * _t**1.9 + _a3 * _t**2.9
+    return CO2_TRIPLE_PRESSURE * np.exp(inner / (1 - _t))
+
+
+def vapor_pressure(absolute_temperature):
+    """
+    Vapor pressure as defined by equation 3.13 of Span & Wagner [2]
+
+    :param absolute_temperature: Absolute temperature in K. Should satisfy:
+        CO2_TRIPLE_TEMPERATURE < absolute_temperature < CO2_CRITICAL_TEMPERATURE
+    """
+    _a1 = -7.0602087
+    _a2 = 1.9391218
+    _a3 = -1.6463597
+    _a4 = -3.2995634
+    _t = 1 - absolute_temperature / CO2_CRITICAL_TEMPERATURE
+    inner = _a1 * _t**1.0 + _a2 * _t**1.5 + _a3 * _t**2.0 + _a4 * _t**4.0
+    return CO2_CRITICAL_PRESSURE * np.exp(inner / (1 - _t))
+
+
+def melting_pressure(absolute_temperature):
+    """
+    Melting pressure as defined by equation 3.10 of Span & Wagner [2]
+
+    :param absolute_temperature: Absolute temperature in K. Should satisfy CO2_TRIPLE_TEMPERATURE < absolute_temperature
+    """
+    _a1 = 1955.5390
+    _a2 = 2055.4593
+    _t = absolute_temperature / CO2_TRIPLE_TEMPERATURE - 1
+    return CO2_TRIPLE_PRESSURE * (1 + _a1 * _t + _a2 * _t**2)
+
+
+def _determine_density_bounds(absolute_temperature, pressure, force_vapor):
+    """
+    Calculate the upper and lower bound on density
+    """
+    bounds = np.zeros((absolute_temperature.size, 2))
+    bounds[:, 0] = 0.1
+    bounds[:, 1] = 1500.0
+
+    below_triple = absolute_temperature < CO2_TRIPLE_TEMPERATURE
+    below_critical = ~below_triple & (absolute_temperature < CO2_CRITICAL_TEMPERATURE)
+
+    bounds[below_triple, 1] = saturated_vapor_density(
+        absolute_temperature[below_triple]
+    )
+    if force_vapor is True:
+        bounds[below_critical, 1] = saturated_vapor_density(
+            absolute_temperature[below_critical]
+        )
+    elif force_vapor is False:
+        bounds[below_critical, 0] = saturated_liquid_density(
+            absolute_temperature[below_critical]
+        )
+    else:  # force_vapor == 'auto'
+        below_vapor_pressure = pressure < vapor_pressure(absolute_temperature)
+        is_vapor = below_critical & below_vapor_pressure
+        bounds[is_vapor, 1] = saturated_vapor_density(absolute_temperature[is_vapor])
+        is_liquid = below_critical & ~below_vapor_pressure
+        bounds[is_liquid, 0] = saturated_liquid_density(absolute_temperature[is_liquid])
+    return bounds
+
+
+def _find_initial_density_values(bounds, absolute_temperature, pressure):
+    """
+    Finds approximate density values for the provided temperature(s) and pressure(s). The result is only intended to be
+    used by array_carbon_dioxide_density.
+    """
+
+    temps = np.geomspace(
+        np.min(absolute_temperature) * 0.99, np.max(absolute_temperature) * 1.01, 41
+    )
+    press = np.geomspace(
+        np.min(pressure) * 0.99, np.max(absolute_temperature) * 1.01, 41
+    )
+    tt, pp = np.meshgrid(temps, press, indexing="ij")
+    densi = carbon_dioxide_density(
+        tt.flatten(), pp.flatten(), force_vapor="auto", raise_error=False
+    ).reshape(temps.size, press.size)
+    rgi = RegularGridInterpolator(np.array((temps, press)), densi, method="linear")
+    iv = rgi(np.array((absolute_temperature, pressure)).T)
+    oob = (iv < bounds[:, 0]) | (iv > bounds[:, 1]) | np.isnan(iv)
+    iv[oob] = np.mean(bounds[oob], axis=1)
+    return iv
+
+
+def array_carbon_dioxide_density(absolute_temperature, pressure, force_vapor):
+    """
+    Alternative implementation of a vectorized carbon dioxide density function. Implemented primarily for demonstration
+    purposes. For large arrays, a look-up-table approach should be preferred.
+
+    Utilizes scipy.optimize.newton, which is the only root-finding method of scipy that supports a vectorized functions.
+
+    For argument documentation, see carbon_dioxide_density.
+    """
+    absolute_temperature = np.asarray(absolute_temperature)
+    pressure = np.asarray(pressure)
+    bounds = _determine_density_bounds(absolute_temperature, pressure, force_vapor)
+    iv = _find_initial_density_values(bounds, absolute_temperature, pressure)
+    opt = scipy.optimize.newton(
+        lambda x: carbon_dioxide_pressure(absolute_temperature, x) - pressure,
+        x0=iv,
+        maxiter=10,
+        full_output=True,
+    )
+    # scipy.optimize.newton may not always converge. We need to determine which of the elements of the solution are
+    #  invalid. The opt.converged variable does not seem to suffice, so we perform separate checks. First, check that
+    #  the solution is a valid root
+    invalid = ~np.isclose(
+        carbon_dioxide_pressure(absolute_temperature, opt.root),
+        pressure,
+        atol=1e-5,
+        rtol=0.0,
+    )
+
+    # Next, check if the solution is anywhere out of bounds (since newton does not support brackets), and check for nan
+    # values.
+    invalid |= (
+        (opt.root < bounds[:, 0]) | (opt.root > bounds[:, 1]) | np.isnan(opt.root)
+    )
+
+    # Finally, use the robust density method to determine the invalid results
+    sol = opt.root
+    sol[invalid] = carbon_dioxide_density(
+        absolute_temperature[invalid], pressure[invalid], force_vapor=force_vapor
+    )
+    return sol
+
+
+def float_vectorize(f):
+    # TODO:
+    # Should test if execution time is longer when using the float_vectorize instead of using numpy arrays directly.
+    # It may not be possible to use numpy arrays directly in span-wagner, but that should be tested
+    return np.vectorize(f, otypes=[float])
+
+
+@float_vectorize
+def _calculate_carbon_dioxide_density(
+    absolute_temperature, pressure, force_vapor="auto", raise_error=True
+):
+    """
+    Density of carbon dioxide. Found solving the Pressure equation of Table 3 in Span & Wagner [2] numerically for
+    density. To ensure a single solution, the phase of the liquid must first be determined.
+
+    :param absolute_temperature: Absolute temperature (K).
+    :param pressure: Pressure (MPa).
+    :param force_vapor: Boolean or 'auto'. If 'auto', the phase of the fluid is automatically determined. However, along
+        the vaporization line (assuming T_triple < absolute_temperature < T_critical), the fluid is in two-phase
+        equilibrium and the phase cannot be uniquely determined. If force_vapor is set to True, vapor phase is always
+        selected, if False, liquid phase is selected. Outide the temperature bounds, this argument has no effect. This
+        argument should only be used close to the vaporization boundary, otherwise the behavior might not be as
+        expected.
+    :param raise_error: Boolean. If True, raises an error if density cannot be determined. Otherwise, returns np.nan.
+
+    :return: Density (kg / m^3)
+    """
+    bounds = _determine_density_bounds(
+        np.array([absolute_temperature]), np.array([pressure]), force_vapor
+    )[0, :]
+
+    # Extend bounds slightly to ensure toms748 can converge
+    bounds = [bounds[0] * 0.95, bounds[1] * 1.05]
+
+    try:
+        opt = scipy.optimize.root_scalar(
+            lambda x: carbon_dioxide_pressure(absolute_temperature, x) - pressure,
+            method="toms748",
+            bracket=bounds,
+            x0=np.sum(bounds) / 2,
+        )
+    except ValueError:
+        if raise_error:
+            raise
+        return np.nan
+    return opt.root
+
+
+def carbon_dioxide_density(absolute_temperature, pressure, interpolate=False, **kwargs):
+    """
+    Density of carbon dioxide. Found either by direct calculation or interpolation. Any additional arguments are passed
+    to _calculate_carbon_dioxide_density.
+
+    :param absolute_temperature: Absolute temperature (K).
+    :param pressure: Pressure (MPa).
+    :param interpolate: Flag whether to interpolate data or not. If not, data is calculated directly. This is more
+        accurate, but also more time-consuming. Data outside the bounds of the interpolator will be set to np.nan.
+
+    :return: Density (kg / m^3)
+    """
+    if interpolate is False:
+        return _calculate_carbon_dioxide_density(
+            absolute_temperature, pressure, **kwargs
+        )
+    assert interpolate is True
+
+    ref = (
+        importlib.resources.files(
+            "rock_physics.fluid_models.gas_model.span_wagner.tables"
+        )
+        / "carbon_dioxide_density.npz"
+    )
+    with importlib.resources.as_file(ref) as fp:
+        interpolator = load_lookup_table_interpolator(fp)
+
+    return interpolator(absolute_temperature, pressure)
+
+
+def carbon_dioxide_bulk_modulus(absolute_temperature, density):
+    """
+    Isentropic bulk modulus, derived from the expression for speed of sound in Table 3 of Span & Wagner
+    """
+    d_pressure = carbon_dioxide_pressure(
+        absolute_temperature, density, d_density=1, isentropic=True
+    )
+    return density * d_pressure * 1e6

rock_physics_open/span_wagner/coefficients.py

@@ -0,0 +1,165 @@
+"""
+Span-Wagner Coefficients
+
+Coefficients defined in tables of Span & Wagner. Coefficients are divided into groups according to horizontal lines in
+the table. This is also convenient when evaluating the Helmholtz energy expressions (phi functions).
+"""
+
+from numpy import array
+
+""" Ideal gas part (table 27) """
+a0 = array(
+    [
+        [
+            8.37304456,
+            -3.70454304,
+            2.50000000,
+            1.99427042,
+            0.62105248,
+            0.41195293,
+            1.04028922,
+            0.08327678,
+        ]
+    ]
+)
+theta0 = array(
+    [
+        [
+            3.15163,
+            6.11190,
+            6.77708,
+            11.32384,
+            27.08792,
+        ]
+    ]
+)
+
+""" Residual part (table 31) """
+
+# First group
+n1 = array(
+    [
+        [
+            0.38856823203161 * 1e0,
+            0.29385475942740 * 1e1,
+            -0.55867188534934 * 1e1,
+            -0.76753199592477 * 1e0,
+            0.31729005580416 * 1e0,
+            0.54803315897767 * 1e0,
+            0.12279411220335 * 1e0,
+        ]
+    ]
+)
+d1 = array([[1, 1, 1, 1, 2, 2, 3]])
+t1 = array([[0.00, 0.75, 1.00, 2.00, 0.75, 2.00, 0.75]])
+
+# Second group
+n2 = array(
+    [
+        [
+            0.21658961543220 * 1e1,
+            0.15841735109724 * 1e1,
+            -0.23132705405503 * 1e0,
+            0.58116916431436 * 1e-1,
+            -0.55369137205382 * 1e0,
+            0.48946615909422 * 1e0,
+            -0.24275739843501 * 1e-1,
+            0.62494790501678 * 1e-1,
+            -0.12175860225246 * 1e0,
+            -0.37055685270086 * 1e0,
+            -0.16775879700426 * 1e-1,
+            -0.11960736637987 * 1e0,
+            -0.45619362508778 * 1e-1,
+            0.35612789270346 * 1e-1,
+            -0.74427727132052 * 1e-2,
+            -0.17395704902432 * 1e-2,
+            -0.21810121289527 * 1e-1,
+            0.24332166559236 * 1e-1,
+            -0.37440133423463 * 1e-1,
+            0.143387157568781 * 1e0,
+            -0.13491969083286 * 1e0,
+            -0.23151225053480 * 1e-1,
+            0.12363125492901 * 1e-1,
+            0.21058321972940 * 1e-2,
+            -0.33958519026368 * 1e-3,
+            0.55993651771592 * 1e-2,
+            -0.30335118055646 * 1e-3,
+        ]
+    ]
+)
+d2 = array(
+    [[1, 2, 4, 5, 5, 5, 6, 6, 6, 1, 1, 4, 4, 4, 7, 8, 2, 3, 3, 5, 5, 6, 7, 8, 10, 4, 8]]
+)
+t2 = array(
+    [
+        [
+            1.50,
+            1.50,
+            2.50,
+            0.00,
+            1.50,
+            2.00,
+            0.00,
+            1.00,
+            2.00,
+            3.00,
+            6.00,
+            3.00,
+            6.00,
+            8.00,
+            6.00,
+            0.00,
+            7.00,
+            12.00,
+            16.00,
+            22.00,
+            24.00,
+            16.00,
+            24.00,
+            8.00,
+            2.00,
+            28.00,
+            14.00,
+        ]
+    ]
+)
+c2 = array(
+    [[1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 6]]
+)
+
+# Third group
+n3 = array(
+    [
+        [
+            -0.21365488688320 * 1e3,
+            0.26641569149272 * 1e5,
+            -0.24027212204557 * 1e5,
+            -0.28341603423999 * 1e3,
+            0.21247284400179 * 1e3,
+        ]
+    ]
+)
+d3 = array([[2, 2, 2, 3, 3]])
+t3 = array([[1.00, 0.00, 1.00, 3.00, 3.00]])
+alpha3 = array([[25, 25, 25, 15, 20]])
+beta3 = array([[325, 300, 300, 275, 275]])
+gamma3 = array([[1.16, 1.19, 1.19, 1.25, 1.22]])
+epsilon3 = array([[1.00, 1.00, 1.00, 1.00, 1.00]])
+
+# Fourth group
+n4 = array(
+    [
+        [
+            -0.66642276540751 * 1e0,
+            0.72608632349897 * 1e0,
+            0.55068668612842 * 1e-1,
+        ]
+    ]
+)
+a4 = array([[3.500, 3.500, 3.000]])
+b4 = array([[0.875, 0.925, 0.875]])
+beta4 = array([[0.300, 0.300, 0.300]])
+A4 = array([[0.700, 0.700, 0.700]])
+B4 = array([[0.3, 0.3, 1.0]])
+C4 = array([[10.0, 10.0, 12.5]])
+D4 = array([[275, 275, 275]])

rock_physics_open/span_wagner/equations.py

@@ -0,0 +1,104 @@
+"""
+Package for calculating the residual helmholtz energy for CO2. The module uses sympy to evaluate the functions defined
+in Span & Wagner [2], as well as its derivatives.
+"""
+
+import numpy as np
+import sympy as sp
+
+from . import coefficients
+
+
+def residual_helmholtz_energy(delta_, tau_, diff_delta, diff_tau):
+    """
+    Equation 6.1 from Span & Wagner [2]. Calculates the residual helmholtz energy of co2 or its derivatives. tau_ and
+    delta_ must have be numpy arrays of shape (N, 1). This allows for vectorization.
+
+    :param delta_: Reduced density. Unit-less. numpy.ndarray with shape (N, 1)
+    :param tau_: Inverse reduced temperature. Unit-less. numpy.ndarray with shape (N, 1)
+    :param diff_delta: Degree of derivation wrt. delta. Integer.
+    :param diff_tau: Degree of derivation wrt. tau. Integer.
+
+    :return: Helmholtz free energy. Unit-less. numpy.ndarray with shape (N,)
+    """
+    _s1 = np.sum(
+        _LAMBDIFIED_EXPRESSIONS[(s1, diff_delta, diff_tau)](tau_, delta_), axis=-1
+    )
+    _s2 = np.sum(
+        _LAMBDIFIED_EXPRESSIONS[(s2, diff_delta, diff_tau)](tau_, delta_), axis=-1
+    )
+    _s3 = np.sum(
+        _LAMBDIFIED_EXPRESSIONS[(s3, diff_delta, diff_tau)](tau_, delta_), axis=-1
+    )
+    _s4 = np.sum(
+        _LAMBDIFIED_EXPRESSIONS[(s4, diff_delta, diff_tau)](tau_, delta_), axis=-1
+    )
+
+    return _s1 + _s2 + _s3 + _s4
+
+
+# Define coefficients symbols. These should correspond one-to-one with variable names in the coefficient module
+coeff_symbols = (
+    n1,
+    t1,
+    d1,
+    n2,
+    d2,
+    t2,
+    c2,
+    n3,
+    d3,
+    t3,
+    alpha3,
+    epsilon3,
+    beta3,
+    gamma3,
+    n4,
+    b4,
+    a4,
+    beta4,
+    A4,
+    B4,
+    C4,
+    D4,
+) = sp.symbols(
+    "n1 t1 d1 n2 d2 t2 c2 n3 d3 t3 alpha3 epsilon3 beta3 gamma3 n4 b4 a4 beta4 A4 B4 C4 D4"
+)
+tau, delta = sp.symbols("tau delta", real=True)
+i = sp.symbols("i", integer=True)
+s1 = n1 * delta**d1 * tau**t1
+s2 = n2 * delta**d2 * tau**t2 * sp.exp(-(delta**c2))
+s3 = (
+    n3
+    * delta**d3
+    * tau**t3
+    * sp.exp(-alpha3 * (delta - epsilon3) ** 2 - beta3 * (tau - gamma3) ** 2)
+)
+
+theta_expr = (1 - tau) + A4 * ((delta - 1) ** 2) ** (1 / (2 * beta4))
+bigdelta_expr = theta_expr**2 + B4 * ((delta - 1) ** 2) ** a4
+bigphi_expr = sp.exp(-C4 * (delta - 1) ** 2 - D4 * (tau - 1) ** 2)
+s4 = n4 * bigdelta_expr**b4 * delta * bigphi_expr
+
+
+def _lambdify(expr, diff_delta, diff_tau):
+    diff = [delta] * diff_delta + [tau] * diff_tau
+    if len(diff) > 0:
+        expr = expr.diff(*diff)
+    expr = expr.powsimp()
+    coeff_vars = [getattr(coefficients, s.name) for s in coeff_symbols]
+    _sympy_lambda = sp.utilities.lambdify(
+        list(coeff_symbols) + [tau, delta],
+        expr,
+        modules=["numpy", {"DiracDelta": lambda x: x == 0}],
+    )
+    return lambda _tau, _delta: _sympy_lambda(*coeff_vars, _tau, _delta)
+
+
+_LAMBDIFIED_EXPRESSIONS = {
+    (e, dd, dt): _lambdify(e, dd, dt)
+    for e in (s1, s2, s3, s4)
+    for dd in (0, 1, 2)
+    for dt in (0, 1, 2)
+    if dd + dt <= 2
+}