photosurfactant 1.0.0__py3-none-any.whl

photosurfactant/__init__.py

@@ -0,0 +1 @@
+from .parameters import Parameters as Parameters

photosurfactant/fourier.py

@@ -0,0 +1,47 @@
+"""Module for Fourier series calculations."""
+
+import numpy as np
+import numpy.typing as npt
+
+
+def fourier_series_coeff(func, L: float, N: int) -> npt.NDArray[np.complex128]:
+    """Calculate the first N+1 Fourier series coeff. of a periodic function.
+
+    Given a periodic function f(x) with period 2L, this function returns the
+    coefficients {c0,c1,c2,...} such that:
+
+    f(x) ~= sum_{k=-N}^{N} c_k * exp(i*2*pi*k*x/L)
+
+    where we define c_{-n} = complex_conjugate(c_{n}).
+
+    :param func: The periodic function, a callable like f(x).
+    :param L: Half the period of the function f, so that f(-L)==f(L).
+    :param N: The function will return the first N + 1 Fourier coeff.
+    """
+    xx = np.linspace(-L, L, 2 * N, endpoint=False)
+    f_coeffs = np.fft.rfft(np.array([func(x) for x in xx])) / len(xx)
+    f_coeffs *= np.exp(1.0j * np.pi * np.arange(N + 1))  # Shift frequency domain
+
+    return np.arange(0, N + 1) * np.pi / L, f_coeffs
+
+
+def convolution_coeff(f, g, L: float, N: int):
+    """Calculate the first N+1 Fourier series coeff. of a convolution.
+
+    Given periodic functions f(x), g(x) with period 2L, this function returns the
+    coefficients {c0,c1,c2,...} such that:
+
+    f(x) * g(x) ~= sum_{k=-N}^{N} c_k * exp(i*2*pi*k*x/L)
+
+    where we define c_{-n} = complex_conjugate(c_{n}).
+
+    :param f: A periodic function, a callable like f(x).
+    :param g: A periodic function, a callable like f(x).
+    :param L: Half the period of the function f, so that f(-L)==f(L).
+    :param N: The function will return the first 2N + 1 Fourier coeff.
+    """
+    omega, f_full = fourier_series_coeff(f, L, N)
+    _, g_full = fourier_series_coeff(g, L, N)
+    f_conv_full = 2 * L * f_full * g_full
+
+    return omega, f_conv_full

photosurfactant/intensity_functions.py

@@ -0,0 +1,32 @@
+"""Example light intensity and surface perturbations."""
+
+from typing import Callable
+
+import numpy as np
+import scipy as sp
+
+
+def gaussian(x: float, d=1.0) -> float:
+    return super_gaussian(x, 2.0, d)
+
+
+def super_gaussian(x: float, k: float, d=1.0) -> float:
+    return np.exp(-(abs(x / d) ** k))
+
+
+def square_wave(x: float) -> float:
+    return float(abs(x) < 1)
+
+
+def smoothed_square(x: float, delta: float) -> float:
+    return 0.5 * (np.tanh((x + 1) / delta) - np.tanh((x - 1) / delta))
+
+
+def mollifier(delta: float) -> Callable[[float], float]:
+    def _(x):
+        if abs(x) < delta:
+            return np.exp(-(delta**2) / (delta**2 - x**2))
+        else:
+            return 0.0
+
+    return lambda x: _(x) / sp.integrate.quad(_, -1.0, 1.0)[0]

photosurfactant/parameters.py

@@ -0,0 +1,219 @@
+"""A module for the Parameters class."""
+
+import inspect
+from copy import copy
+from dataclasses import asdict, dataclass
+from typing import Any
+
+import numpy as np
+
+
+@dataclass(frozen=True)
+class Parameters:
+    """The Parameters for the model.
+
+    :param L: The aspect ratio of the domain.
+    :param Da_tr: The Damkohler number for the trans surfactant.
+    :param Da_ci: The Damkohler number for the cis surfactant.
+    :param Pe_tr: The Peclet number for the trans surfactant.
+    :param Pe_ci: The Peclet number for the cis surfactant.
+    :param Pe_tr_s: The Peclet number for the trans surfactant on the
+        interface.
+    :param Pe_ci_s: The Peclet number for the cis surfactant on the interface.
+    :param Bi_tr: The Biot number for the trans surfactant.
+    :param Bi_ci: The Biot number for the cis surfactant.
+    :param Ma: The Marangoni number.
+    :param k_tr: The adsorption rate for the trans surfactant.
+    :param k_ci: The adsorption rate for the cis surfactant.
+    :param chi_tr: The desorption rate for the trans surfactant.
+    :param chi_ci: The desorption rate for the cis surfactant.
+    """
+
+    # Aspect ratio
+    L: float = 10.0
+
+    # Reynolds numbers
+    Re: float = 0.0  # TODO: Deprecate this parameter
+
+    # Damkohler numbers
+    Da_tr: float = 1.0
+    Da_ci: float = 2.0
+
+    # Peclet numbers
+    Pe_tr: float = 10.0
+    Pe_ci: float = 10.0
+
+    # Interfacial Peclet numbers
+    Pe_tr_s: float = 10.0
+    Pe_ci_s: float = 10.0
+
+    # Biot numbers
+    Bi_tr: float = 1 / 300
+    Bi_ci: float = 1.0
+
+    # Marangoni number
+    Ma: float = 2.0
+
+    # Adsorption and desorption rates
+    k_tr: float = 1.0
+    k_ci: float = 1 / 30
+
+    chi_tr: float = 100 / 30
+    chi_ci: float = 100.0
+
+    def __post_init__(self):  # noqa: D105
+        if not np.isclose(self.k_tr * self.chi_tr, self.k_ci * self.chi_ci):
+            raise ValueError(
+                "Adsorption rates do not satisfy the condition k * chi = const."
+            )
+
+    def from_dict(kwargs: dict[str, float]) -> "Parameters":
+        """Load parameters from a dictionary."""
+        return Parameters(
+            **{
+                k: v
+                for k, v in kwargs.items()
+                if k in inspect.signature(Parameters).parameters
+            }
+        )
+
+    def copy(self) -> "Parameters":
+        """Return a copy of the `Parameters` object."""
+        return copy(self)
+
+    def update(self, **new_kwargs) -> "Parameters":
+        """Return a new `Parameter` object with missing values derived."""
+        derived_kwargs = asdict(self)
+        # new_kwargs overwrite derived_kwargs
+        return Parameters(**(derived_kwargs | new_kwargs))
+
+    @property
+    def alpha(self) -> float:
+        return self.Da_ci / self.Da_tr
+
+    @property
+    def eta(self) -> float:
+        return self.Pe_tr / self.Pe_ci
+
+    @property
+    def zeta(self) -> float:
+        return self.Pe_tr * self.Da_tr + self.Pe_ci * self.Da_ci
+
+    @property
+    def P(self):
+        return np.array([[self.Pe_tr, 0.0], [0.0, self.Pe_ci]])
+
+    @property
+    def P_s(self):
+        return np.array([[self.Pe_tr_s, 0.0], [0.0, self.Pe_ci_s]])
+
+    @property
+    def B(self):
+        return np.array([[self.Bi_tr, 0.0], [0.0, self.Bi_ci]])
+
+    @property
+    def K(self):
+        return np.array([[self.k_tr, 0.0], [0.0, self.k_ci]])
+
+    @property
+    def A(self):
+        return self.P @ self._D
+
+    @property
+    def A_s(self):
+        return self.P_s @ self._D
+
+    @property
+    def V(self):
+        return np.array([[self.alpha, self.eta], [1.0, -1.0]])
+
+    @property
+    def Lambda(self):
+        return np.array([[0.0, 0.0], [0.0, self.zeta]])
+
+    @property
+    def _D(self):
+        return np.array([[self.Da_tr, -self.Da_ci], [-self.Da_tr, self.Da_ci]])
+
+
+@dataclass
+class PlottingParameters:
+    """Additional parameters for plotting.
+
+    :param wave_count: The number of wave numbers to use.
+    :param grid_size: The number of grid points to evaluate the solution on.
+    :param mollify: A flag to mollify the input function.
+    :param delta: The mollification parameter.
+    :param norm_scale: Normalization type. Either "linear" or "log".
+    :param save: A flag to save the figures to disk.
+    :param path: The path to save the figures to.
+    :param label: A label to append to the figure filenames.
+    :param format: The format to save the figures in.
+    """
+
+    wave_count: int = 100
+    grid_size: int = 1000
+    mollify: bool = False
+    delta: float = 0.5
+    norm_scale: str = "linear"
+    save: bool = False
+    path: str = "./"
+    label: str = ""
+    usetex: bool = False
+    format: str = "png"
+
+    def __post_init__(self):  # noqa: D105
+        self.label = "_" + self.label if self.label else ""
+        self.plot_setup()
+
+    def from_dict(kwargs: dict[str, Any]) -> "PlottingParameters":
+        """Load parameters from a dictionary."""
+        return PlottingParameters(
+            **{
+                k: v
+                for k, v in kwargs.items()
+                if k in inspect.signature(PlottingParameters).parameters
+            }
+        )
+
+    def copy(self):
+        """Return a copy of the class."""
+        raise NotImplementedError
+        # TODO: Deprecate this method
+        return copy(self)
+
+    def plot_setup(self):
+        """Set up the matplotlib rcParams."""
+        import matplotlib.pyplot as plt
+
+        rcparams = {
+            "font.size": 18,
+            "axes.labelsize": 18,
+            "axes.titlesize": 18,
+            "axes.formatter.useoffset": True,
+            "xtick.labelsize": 16,
+            "ytick.labelsize": 16,
+            "legend.fontsize": 16,
+            "figure.figsize": [7, 6],
+            "figure.dpi": 100,
+            "figure.autolayout": True,
+            "savefig.dpi": 300,
+        }
+
+        if self.usetex:
+            plt.rcParams.update(
+                {
+                    "text.usetex": True,
+                    "font.family": "serif",
+                    "font.serif": ["Computer Modern Roman"],
+                    "axes.formatter.use_mathtext": True,
+                    "text.latex.preamble": r"\usepackage{amsmath}",
+                }
+                | rcparams
+            )
+
+        else:
+            plt.rcParams.update(rcparams)
+
+        plt.close("all")
+        self.plt = plt

photosurfactant/scripts/plot_all.sh

@@ -0,0 +1,19 @@
+#! /bin/bash
+echo "Plotting leading order..."
+plot_leading_order --intensities -6.0 2.0 --log --count 13 -s --path "./figures/leading/" --usetex --format "eps"
+plot_leading_order --interface --limits --intensities -6.0 2.0 --log --count 1000 -s --path "./figures/leading/" --usetex --format "eps"
+
+echo "Plotting first order: laser pointer..."
+plot_first_order -s --path "./figures/laser-point/" --usetex --format "eps"
+echo "Plotting first order: mixing..."
+plot_first_order --func "np.cos(2 * np.pi * x / params.L)" -s --path "./figures/mixing/" --usetex --format "eps"
+echo "Plotting first order: inverse problem..."
+plot_first_order --func "np.cos(np.pi * x / params.L) + np.cos(2 * np.pi * x / params.L) / 2 - np.cos(3 * np.pi * x / params.L) / 3" --problem inverse --wave_count 4 -s --path "./figures/inverse/" --usetex --format "eps"
+echo "Plotting first order: inverse problem..."
+plot_first_order --func "(np.sinh(1) / (np.cosh(1) - np.cos(np.pi * x / params.L)) - 1) / 2" --problem inverse --wave_count 30 -s --path "./figures/inverse-adv/" --usetex --format "eps"
+
+echo "Plotting first order: sweeping parameters..."
+plot_sweep -s --path "./figures/sweep/" --usetex --format "eps"
+
+echo "Plotting convergence...:"
+plot_error -s --path "" --usetex --format "eps"

photosurfactant/scripts/plot_error.py

@@ -0,0 +1,75 @@
+#! /usr/bin/env python
+from argparse import ArgumentDefaultsHelpFormatter, ArgumentParser
+
+import matplotlib.pyplot as plt
+import numpy as np
+
+from photosurfactant.fourier import fourier_series_coeff
+from photosurfactant.parameters import Parameters
+from photosurfactant.semi_analytic.first_order import FirstOrder, Variables
+from photosurfactant.semi_analytic.leading_order import LeadingOrder
+from photosurfactant.utils.arg_parser import parameter_parser
+
+WAVE_N = 5
+GRID_N = 100
+
+
+def plot_error():  # noqa: D103
+    parser = ArgumentParser(
+        description="Plot the first order surfactant concentrations.",
+        formatter_class=ArgumentDefaultsHelpFormatter,
+    )
+    parameter_parser(parser)
+    args = parser.parse_args()
+
+    # Extract parameters
+    kwargs = vars(args)
+    Da_tr = kwargs["Da_tr"]
+    Da_ci = kwargs["Da_ci"]
+
+    params = Parameters.from_dict(vars(args))
+
+    wavenumbers, func_coeffs = fourier_series_coeff(lambda x: 1.0, params.L, WAVE_N)
+
+    # Solve first order problem
+    leading = LeadingOrder(params)
+    first = FirstOrder(wavenumbers, params, leading)
+    first.solve(lambda n: (Variables.f, func_coeffs[n]))
+
+    # Solve the linearised system
+    yy = np.linspace(0, 1, GRID_N)
+    cc_tr_1 = np.array([first.c_tr(np.array([0]), y) for y in yy])[:, 0]
+    cc_tr_0 = leading.c_tr(yy)
+
+    # Set delta values
+    delta_values = 2.0 ** np.arange(0, -20, -1)
+    error = np.zeros((len(delta_values), 2))
+
+    for i, delta in enumerate(delta_values):
+        # Update parameters
+        kwargs["Da_tr"] = (1 + delta) * Da_tr
+        kwargs["Da_ci"] = (1 + delta) * Da_ci
+
+        params_delta = Parameters.from_dict(kwargs)
+        leading_delta = LeadingOrder(params_delta)
+        cc_tr_delta = leading_delta.c_tr(yy)
+
+        # Compute error
+        error[i, 0] = np.linalg.norm(cc_tr_delta - cc_tr_0)
+        error[i, 1] = np.linalg.norm(cc_tr_delta - (cc_tr_0 + delta * cc_tr_1))
+        print(
+            f"Error at delta = {delta:.2e}. Leading: {error[i, 0]:.2e}, "
+            f"first: {error[i, 1]:.2e}"
+        )
+
+    plt.loglog(delta_values, error[:, 0], "o-", label="Leading order")
+    plt.loglog(delta_values, error[:, 1], "o-", label="First order")
+    plt.loglog(delta_values, error[0, 0] * delta_values, "k:", label=r"O($\delta$)")
+    plt.loglog(
+        delta_values, error[0, 1] * delta_values**2, "k--", label=r"O($\delta^2$)"
+    )
+    plt.xlabel(r"$\delta$")
+    plt.ylabel("Error")
+
+    plt.legend()
+    plt.show()