photosurfactant 1.0.0__py3-none-any.whl

photosurfactant/scripts/plot_leading_order.py

@@ -0,0 +1,288 @@
+#! /usr/bin/env python
+from argparse import ArgumentDefaultsHelpFormatter, ArgumentParser
+
+import numpy as np
+from matplotlib import colors
+
+from photosurfactant.parameters import Parameters, PlottingParameters
+from photosurfactant.semi_analytic.leading_order import LeadingOrder
+from photosurfactant.semi_analytic.limits import HighIntensity, LowIntensity
+from photosurfactant.utils.arg_parser import (
+    leading_order_parser,
+    parameter_parser,
+    plot_parser,
+)
+
+# TODO: Reduced figures at 3 magnitudes?
+
+
+def plot_bulk_concentration(
+    intensities, default_params, plot_params, root_index, log=False
+):
+    """Plot the bulk concentrations for varying intensity."""
+
+    default_intensity = default_params.Da_tr
+
+    # Figure setup
+    plt = plot_params.plt
+    fig, axs = plt.subplots(2, 1, figsize=(9, 6), constrained_layout=True)
+
+    cmap = plt.cm.get_cmap("coolwarm")
+
+    if log:
+        norm = colors.LogNorm(
+            vmin=intensities[0] / np.sqrt(10), vmax=intensities[-1] * np.sqrt(10)
+        )
+    else:
+        norm = plt.Normalize(vmin=intensities[0], vmax=intensities[-1])
+
+    yy = np.linspace(0, 1, plot_params.grid_size)
+
+    # Plot concentrations for varying intensity
+    for intensity in intensities:
+        params = default_params.update(
+            Da_tr=default_params.Da_tr * intensity / default_intensity,
+            Da_ci=default_params.Da_ci * intensity / default_intensity,
+        )
+
+        # Solve leading order problem
+        leading = LeadingOrder(params, root_index)
+
+        # Plot bulk concentrations
+        axs[0].plot(yy, leading.c_tr(yy), color=cmap(norm(intensity)))
+        axs[1].plot(yy, leading.c_ci(yy), color=cmap(norm(intensity)))
+
+    # Highlight curves for unit intensity
+    params = default_params.copy()
+    leading = LeadingOrder(params, root_index)
+    axs[0].plot(yy, leading.c_tr(yy), color="k", linestyle=(0, (5, 10)))
+    axs[1].plot(yy, leading.c_ci(yy), color="k", linestyle=(0, (5, 10)))
+
+    # Tidy up figure
+    axs[0].set_xticklabels([])
+    axs[0].set_ylabel(r"$c_{\mathrm{tr}, 0}$")
+    axs[0].ticklabel_format(style="sci", axis="y", scilimits=(0, 0))
+
+    axs[1].set_xlabel(r"$z$")
+    axs[1].set_ylabel(r"$c_{\mathrm{ci}, 0}$")
+    axs[1].ticklabel_format(style="sci", axis="y", scilimits=(0, 0))
+
+    sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
+    cbar = fig.colorbar(
+        sm, ax=axs.ravel().tolist(), label=r"Intensity ($Da_\mathrm{tr}$)"
+    )
+
+    # Annotate colorbar
+    cbar.ax.scatter(
+        np.mean(cbar.ax.set_xlim()) * np.ones_like(intensities),
+        intensities,
+        s=50,
+        facecolors="none",
+        edgecolors="k",
+    )
+
+    cbar.ax.scatter(
+        [np.mean(cbar.ax.set_xlim())],
+        [default_intensity],
+        s=60,
+        facecolors="k",
+        edgecolors="k",
+        marker="D",
+    )
+
+    if plot_params.save:
+        plt.savefig(
+            plot_params.path
+            + f"bulk_concentration{plot_params.label}.{plot_params.format}",
+            bbox_inches="tight",
+        )
+    else:
+        plt.show()
+
+
+def plot_interfacial_concentration(
+    intensities, default_params, plot_params, root_index, log=False, limits=False
+):
+    """Plot surface excess for varying intensity."""
+    # Collect interfacial values for varying intensity
+    gamma_tr, gamma_ci = [], []
+    tension = []
+    default_intensity = default_params.Da_tr
+
+    for intensity in intensities:
+        params = default_params.update(
+            Da_tr=default_params.Da_tr * intensity / default_intensity,
+            Da_ci=default_params.Da_ci * intensity / default_intensity,
+        )
+
+        # Solve leading order problem
+        leading = LeadingOrder(params, root_index)
+
+        # Store values
+        gamma_tr.append(leading.Gamma_tr)
+        gamma_ci.append(leading.Gamma_ci)
+
+        tension.append(leading.gamma)
+
+    gamma_tr, gamma_ci = np.array(gamma_tr), np.array(gamma_ci)
+    tension = np.array(tension)
+
+    plt = plot_params.plt
+    fig, ax1 = plt.subplots(figsize=(8, 6))
+
+    # Plot surface excess
+    gamma_tr_plt = ax1.plot(
+        intensities, gamma_tr, "r--", label=r"$\Gamma_{\mathrm{tr}, 0}$"
+    )
+    gamma_ci_plt = ax1.plot(
+        intensities, gamma_ci, "b-.", label=r"$\Gamma_{\mathrm{ci}, 0}$"
+    )
+
+    # Plot limiting cases
+    if limits:
+        tan_length = int((3 / 8) * len(intensities))
+
+        small_dam = LowIntensity(params)
+        ax1.plot(
+            intensities[:tan_length],
+            small_dam.gamma_tr * np.ones_like(intensities[:tan_length]),
+            "r:",
+        )
+        ax1.plot(
+            intensities[:tan_length],
+            small_dam.gamma_ci * np.ones_like(intensities[:tan_length]),
+            "b:",
+        )
+
+        large_dam = HighIntensity(params)
+        ax1.plot(
+            intensities[-tan_length:],
+            large_dam.gamma_tr * np.ones_like(intensities[-tan_length:]),
+            "r:",
+        )
+        ax1.plot(
+            intensities[-tan_length:],
+            large_dam.gamma_ci * np.ones_like(intensities[-tan_length:]),
+            "b:",
+        )
+
+    # Set xscale
+    if log:
+        ax1.set_xscale("log")
+
+    ax1.set_xlabel(r"Intensity ($Da_\mathrm{tr}$)")
+    ax1.set_ylabel(
+        r"Surface Excess ($\Gamma_{\mathrm{tr}, 0}, \Gamma_{\mathrm{ci}, 0}$)"
+    )
+    ax1.ticklabel_format(style="sci", axis="y", scilimits=(0, 0))
+    ax1.grid()
+
+    ax2 = ax1.twinx()
+
+    # Plot surface tension
+    tension_plt = ax2.plot(
+        intensities,
+        tension,
+        "k-",
+        label=r"$\gamma_0$",
+    )
+    ax2.set_ylabel(r"$\gamma_0$")
+    ax2.ticklabel_format(style="sci", axis="y", scilimits=(0, 0))
+
+    # Annotate points at unit intensity
+    leading = LeadingOrder(default_params, root_index)
+    ax1.plot([default_intensity], [leading.Gamma_tr], color="r", marker="D")
+    ax1.plot([default_intensity], [leading.Gamma_ci], color="b", marker="D")
+    ax2.plot([default_intensity], [leading.gamma], color="k", marker="D")
+
+    # Merge legends
+    plots = tension_plt + gamma_tr_plt + gamma_ci_plt
+    labels = [plot.get_label() for plot in plots]
+    ax2.legend(plots, labels, loc="upper right")
+
+    if plot_params.save:
+        plt.savefig(
+            plot_params.path
+            + f"interfacial_concentration{plot_params.label}.{plot_params.format}",
+            bbox_inches="tight",
+        )
+    else:
+        plt.show()
+
+
+def plot_leading_order():  # noqa: D103
+    parser = ArgumentParser(
+        description="Plot the leading order surfactant concentrations.",
+        formatter_class=ArgumentDefaultsHelpFormatter,
+    )
+    parameter_parser(parser)
+    plot_parser(parser)
+    leading_order_parser(parser)
+    parser.add_argument(
+        "--intensities",
+        type=float,
+        nargs="*",
+        default=[1.0],
+        help="Intensity factors to plot the concentration for. If count is greater "
+        "than one, plots for a range instead.",
+    )
+    parser.add_argument(
+        "--count",
+        type=int,
+        default=1,
+        help="The number of values to plot if using an intensity range.",
+    )
+    parser.add_argument(
+        "--interface",
+        action="store_true",
+        help="Plot the interfacial values.",
+    )
+    parser.add_argument(
+        "--limits",
+        action="store_true",
+        help="Plot the equilibrium states for small and large intensity.",
+    )
+    parser.add_argument(
+        "--log",
+        action="store_true",
+        help="Use a log scale.",
+    )
+    parser.add_argument(
+        "--gamma",
+        type=float,
+        default=1.0,
+        help="The stretching rate when using a range.",
+    )
+    args = parser.parse_args()
+
+    params = Parameters.from_dict(vars(args))
+    plot_params = PlottingParameters.from_dict(vars(args))
+    root_index = args.root_index
+    intensities = args.intensities
+
+    if args.count > 1:
+        if len(intensities) != 2:
+            raise ValueError("intensities must be of length 2 to plot a range.")
+
+        grid = abs(np.linspace(-1.0, 1.0, args.count)) ** args.gamma
+        grid[: args.count // 2] *= -1
+        intensities = grid * (intensities[1] - intensities[0]) / 2 + np.mean(
+            intensities
+        )
+
+    if args.log:
+        intensities = 10.0 ** np.array(intensities)
+
+    if args.interface:
+        plot_interfacial_concentration(
+            intensities,
+            params,
+            plot_params,
+            root_index,
+            log=args.log,
+            limits=args.limits,
+        )
+    else:
+        plot_bulk_concentration(
+            intensities, params, plot_params, root_index, log=args.log
+        )

photosurfactant/scripts/plot_spectrum.py

@@ -0,0 +1,146 @@
+#! /usr/bin/env python
+from argparse import ArgumentDefaultsHelpFormatter, ArgumentParser
+
+import numpy as np
+
+from photosurfactant.fourier import convolution_coeff, fourier_series_coeff
+from photosurfactant.intensity_functions import mollifier, square_wave
+from photosurfactant.parameters import Parameters, PlottingParameters
+from photosurfactant.semi_analytic.first_order import FirstOrder, Variables
+from photosurfactant.semi_analytic.leading_order import LeadingOrder
+from photosurfactant.utils.arg_parser import (
+    first_order_parser,
+    leading_order_parser,
+    parameter_parser,
+    plot_parser,
+)
+
+
+def plot_spectrum():  # noqa: D103
+    parser = ArgumentParser(
+        description="Plot the first order surfactant concentrations.",
+        formatter_class=ArgumentDefaultsHelpFormatter,
+    )
+    parameter_parser(parser)
+    plot_parser(parser)
+    leading_order_parser(parser)
+    first_order_parser(parser)
+    args = parser.parse_args()
+
+    root_index = args.root_index
+
+    params = Parameters.from_dict(vars(args))
+    plot_params = PlottingParameters.from_dict(vars(args))
+
+    wavenumbers, _ = fourier_series_coeff(
+        lambda x: 0.0, params.L, plot_params.wave_count
+    )
+
+    _, square_wave_coeffs = fourier_series_coeff(
+        lambda x: square_wave(x), params.L, plot_params.wave_count
+    )
+
+    _, mol_wave_coeffs = convolution_coeff(
+        lambda x: square_wave(x),
+        mollifier(plot_params.delta),
+        params.L,
+        plot_params.wave_count,
+    )
+
+    # Solve leading order problem
+    leading = LeadingOrder(params, root_index)
+
+    # Solve first order problem
+    first = FirstOrder(wavenumbers, params, leading)
+    first.solve(lambda n: (Variables.f, 1.0))
+
+    S_n = abs(first.solution @ Variables.S)
+
+    # Calculate the slope of the spectrum on a log plot
+    index = S_n > 1e-20
+    slope = np.polyfit(wavenumbers[index], np.log(S_n[index]), 1)
+
+    # Figure setup
+    plt = plot_params.plt
+
+    # Plot the spectrum
+    plt.figure()
+    plt.plot(wavenumbers[1:], S_n[1:], "k-")
+    plt.plot(
+        wavenumbers,
+        np.exp(slope[1] + slope[0] * wavenumbers),
+        "k--",
+        label=r"$e^{" f"{slope[0] * np.pi / params.L:.2f}" r"n}$",
+    )
+    plt.yscale("log")
+    plt.xlabel(r"$k_n$")
+    plt.ylabel(r"$|\tilde{S}^{(n)}|$")
+    plt.legend()
+    plt.tight_layout()
+
+    if plot_params.save:
+        plt.savefig(
+            plot_params.path
+            + f"interface_spectrum{plot_params.label}.{plot_params.format}",
+            bbox_inches="tight",
+        )
+    else:
+        plt.show()
+
+    # Plot the square wave spectrum
+    plt.figure()
+    plt.plot(
+        wavenumbers,
+        square_wave_coeffs.real,
+        "k-",
+        label="Square wave",
+    )
+    plt.plot(
+        wavenumbers,
+        mol_wave_coeffs.real,
+        "r--",
+        label="Mollified square wave",
+    )
+    plt.xlabel(r"$k_n$")
+    plt.ylabel(r"$S^{(n)}$")
+    plt.legend()
+    plt.tight_layout()
+
+    if plot_params.save:
+        plt.savefig(
+            plot_params.path
+            + f"square_wave_spectrum{plot_params.label}.{plot_params.format}",
+            bbox_inches="tight",
+        )
+    else:
+        plt.show()
+
+    # Plot the square wave
+    def invert(fourier_coeffs, x):
+        return (
+            fourier_coeffs[0].real
+            + 2
+            * np.sum(
+                fourier_coeffs[1:, np.newaxis]
+                * np.exp(1j * wavenumbers[1:, np.newaxis] * x[np.newaxis, :]),
+                axis=0,
+            ).real
+        )
+
+    x = np.linspace(-params.L, params.L, plot_params.grid_size)
+
+    plt.figure()
+    plt.plot(x, invert(square_wave_coeffs, x), "k-", label="Square wave")
+    plt.plot(x, invert(mol_wave_coeffs, x), "r--", label="Mollified square wave")
+    plt.xlabel(r"$x$")
+    plt.ylabel(r"$f_1(x)$")
+    plt.legend()
+    plt.tight_layout()
+
+    if plot_params.save:
+        plt.savefig(
+            plot_params.path + f"square_wave{plot_params.label}.{plot_params.format}",
+            bbox_inches="tight",
+        )
+    else:
+        plt.show()

photosurfactant/scripts/plot_sweep.py

@@ -0,0 +1,234 @@
+#! /usr/bin/env python
+from argparse import ArgumentDefaultsHelpFormatter, ArgumentParser
+from typing import Callable
+
+import numpy as np
+from alive_progress import alive_it
+from matplotlib import colors
+from scipy.optimize import minimize_scalar
+
+from photosurfactant.fourier import fourier_series_coeff
+from photosurfactant.parameters import Parameters, PlottingParameters
+from photosurfactant.semi_analytic.first_order import FirstOrder, Variables
+from photosurfactant.semi_analytic.leading_order import LeadingOrder
+from photosurfactant.utils.arg_parser import (
+    first_order_parser,
+    parameter_parser,
+    plot_parser,
+)
+from photosurfactant.utils.func_parser import parse_func
+
+
+def find_max(func: Callable[[float], float], bounds: list[float]) -> float:
+    """Find the maximum of a functional over a given range."""
+    res = minimize_scalar(lambda x: -func(x), bounds=bounds)
+    assert res.success, "maximum velocity not found"
+
+    return -res.fun
+
+
+def plot_multi_sweep(
+    intensity: Callable[[float], float],
+    x_func: Callable[[Parameters], float],
+    k_tr_vals: list[float],
+    params_list: list[Parameters],
+    plot_params: PlottingParameters,
+    xlabel: str,
+    tol: float = 1e-3,
+    label: str = "",
+):
+    """Sweep maximum velocity for set of k_tr values."""
+
+    if label:
+        label += "_"
+
+    # Figure setup
+    plt = plot_params.plt
+    fig, ax = plt.subplots(figsize=(6, 5), constrained_layout=True)  # (9, 6)
+
+    cmap = plt.get_cmap("viridis")
+
+    norm = colors.LogNorm(
+        vmin=min(k_tr_vals) / np.sqrt(10), vmax=max(k_tr_vals) * np.sqrt(10)
+    )
+
+    # Plot profiles over multile values of k_tr
+    for k_tr in k_tr_vals:
+        data = []
+        for params in alive_it(params_list, title=f"Sweeping at k_tr = {k_tr}"):
+            # Preserve the ratio in k parameters
+            params = params.update(k_tr=k_tr, k_ci=params.k_ci * (k_tr / params.k_tr))
+
+            # Find Fourier coeffients of the intensity function
+            wavenumbers, func_coeffs = fourier_series_coeff(
+                lambda x: intensity(x, params), params.L, plot_params.wave_count
+            )
+
+            # Solve leading order problem
+            leading = LeadingOrder(params)
+
+            if leading.gamma < tol:
+                # TODO: Temp fix for Marangoni sweep
+                if label == "ma_":
+                    data.pop()
+
+                break
+
+            # Solve first order problem
+            first = FirstOrder(wavenumbers, params, leading)
+            first.solve(lambda n: (Variables.f, func_coeffs[n]))
+
+            # Reduce using the functionals
+            data.append(
+                (
+                    x_func(params),
+                    find_max(lambda x: abs(first.u(x, y=1.0)), [-params.L, params.L]),
+                )
+            )
+
+        if data:
+            x_data, y_data = zip(*data)
+            ax.plot(x_data, y_data, color=cmap(norm(k_tr)))
+
+    # Tidy up figure
+    ax.set_xlabel(xlabel)
+    ax.set_ylabel(r"$\max_{x}\lvert{u_1}\rvert_{y=1}$")
+    ax.set_xscale("log")
+    # ax.set_yscale("log")
+    ax.ticklabel_format(style="sci", axis="y", scilimits=(0, 0))
+
+    sm = plt.cm.ScalarMappable(cmap=cmap, norm=norm)
+    cbar = plt.colorbar(sm, ax=ax, label=r"$k_\mathrm{tr}$")
+
+    # Annotate colorbar
+    cbar.ax.scatter(
+        np.mean(cbar.ax.set_xlim()) * np.ones_like(k_tr_vals),
+        k_tr_vals,
+        s=50,
+        facecolors="none",
+        edgecolors="k",
+    )
+
+    if plot_params.save:
+        plt.savefig(
+            plot_params.path + f"{label}sweep.{plot_params.format}",
+            bbox_inches="tight",
+        )
+    else:
+        plt.show()
+
+
+def bi_sweep(
+    intensity,
+    start: float,
+    stop: float,
+    k_tr_vals: list[float],
+    default_params: Parameters,
+    plot_params: PlottingParameters,
+):
+    """Sweep Biot number."""
+    biot_tr_vals = 10 ** np.linspace(start, stop, plot_params.grid_size)
+    params_list = [
+        default_params.update(
+            Bi_tr=Bi_tr,
+            Bi_ci=default_params.Bi_ci * (Bi_tr / default_params.Bi_tr),
+        )
+        for Bi_tr in biot_tr_vals
+    ]
+
+    print("Sweeping Biot number...")
+    plot_multi_sweep(
+        intensity,
+        lambda p: p.Bi_tr,
+        k_tr_vals,
+        params_list,
+        plot_params,
+        xlabel=r"$Bi_{\mathrm{tr}}$",
+        label="bi",
+    )
+
+
+def da_sweep(
+    intensity,
+    start: float,
+    stop: float,
+    k_tr_vals: list[float],
+    default_params: Parameters,
+    plot_params: PlottingParameters,
+):
+    """Sweep Damkohler number."""
+    damkohler_tr_vals = 10 ** np.linspace(start, stop, plot_params.grid_size)
+    params_list = [
+        default_params.update(
+            Da_tr=Da_tr,
+            Da_ci=default_params.Da_ci * (Da_tr / default_params.Da_tr),
+        )
+        for Da_tr in damkohler_tr_vals
+    ]
+
+    print("Sweeping Damkohler number...")
+    plot_multi_sweep(
+        intensity,
+        lambda p: p.Da_tr,
+        k_tr_vals,
+        params_list,
+        plot_params,
+        xlabel=r"$Da_{\mathrm{tr}}$",
+        label="da",
+    )
+
+
+def ma_sweep(
+    intensity,
+    start: float,
+    stop: float,
+    k_tr_vals: list[float],
+    default_params: Parameters,
+    plot_params: PlottingParameters,
+):
+    """Sweep Marangoni number."""
+    marangoni_vals = 10 ** np.linspace(start, stop, plot_params.grid_size)
+    params_list = [default_params.update(Ma=Ma) for Ma in marangoni_vals]
+
+    print("Sweeping Marangoni number...")
+    plot_multi_sweep(
+        intensity,
+        lambda p: p.Ma,
+        k_tr_vals,
+        params_list,
+        plot_params,
+        xlabel="$Ma$",
+        label="ma",
+    )
+
+
+def main():
+    # Parse parameters
+    parser = ArgumentParser(
+        description="Plot the maximum interfacial velocity.",
+        formatter_class=ArgumentDefaultsHelpFormatter,
+    )
+    parameter_parser(parser)
+    plot_parser(parser)
+    first_order_parser(parser)
+    args = parser.parse_args()
+
+    default_params = Parameters.from_dict(vars(args))
+    plot_params = PlottingParameters.from_dict(vars(args))
+    intensity = parse_func(args.func)
+
+    # Set k values
+    k_tr_vals = 10.0 ** np.arange(-4, 1)
+
+    # Sweep Biot number
+    bi_sweep(intensity, -4, 4, k_tr_vals, default_params, plot_params)
+
+    # Sweep Damkohler number
+    da_sweep(intensity, -6, 2, k_tr_vals, default_params, plot_params)
+
+    # Sweep Marangoni number
+    ma_sweep(intensity, -4, 6, k_tr_vals, default_params, plot_params)
+
+
+if __name__ == "__main__":
+    main()

photosurfactant/semi_analytic/__init__.py

@@ -0,0 +1,3 @@
+from .first_order import FirstOrder as FirstOrder
+from .first_order import Variables as Variables
+from .leading_order import LeadingOrder as LeadingOrder