photosurfactant 1.0.0__py3-none-any.whl

photosurfactant/semi_analytic/leading_order.py

@@ -0,0 +1,237 @@
+"""Leading order solution to the photosurfactant model."""
+
+from functools import cached_property
+
+import numpy as np
+
+from photosurfactant.parameters import Parameters
+from photosurfactant.semi_analytic.utils import Y, cosh, polyder
+
+
+class LeadingOrder(object):
+    """Leading order solution to the photosurfactant model."""
+
+    def __init__(self, params: Parameters, root_index: int = -1):
+        """Initialize solution to the leading order model.
+
+        :param params: :class:`~.parameters.Parameters` object containing the
+            model parameters.
+        :param root_index: Index of the solution branch to use. If set to -1,
+            the branch is selected automatically.
+        """
+        self.params = params
+        self._initialize()
+
+        if root_index == -1:
+            self._trim_roots()
+            if len(self.roots) > 1:
+                raise ValueError(
+                    "Multiple valid solution branches detected. You can override this "
+                    "message by explicitly setting a solution branch using root_index."
+                )
+
+        (self.A, self.B) = self.roots[root_index]
+
+    def _initialize(self):
+        """Initialize the leading order solution."""
+        params = self.params
+
+        # Define determinant coefficients
+        a_0 = (params.Da_tr + params.Da_ci) * (
+            params.alpha * params.Bi_tr * params.k_tr + params.Bi_ci * params.k_ci
+        ) + params.Bi_tr * params.Bi_ci * (params.alpha * params.k_tr + params.k_ci)
+        b_0 = (params.Da_tr + params.Da_ci) * (
+            params.eta * params.Bi_tr * params.k_tr - params.Bi_ci * params.k_ci
+        ) + params.Bi_tr * params.Bi_ci * (params.eta * params.k_tr - params.k_ci)
+        c_0 = (
+            params.Da_tr * params.Bi_ci
+            + params.Da_ci * params.Bi_tr
+            + params.Bi_tr * params.Bi_ci
+        )
+
+        # Quadratic coefficients
+        a = a_0 * (params.alpha + 1)
+        b = a_0 * (params.eta - 1) / np.sqrt(params.zeta) * np.sinh(
+            np.sqrt(params.zeta)
+        ) + b_0 * (params.alpha + 1) * np.cosh(np.sqrt(params.zeta))
+        c = (
+            b_0
+            * (params.eta - 1)
+            / np.sqrt(params.zeta)
+            * np.sinh(np.sqrt(params.zeta))
+            * np.cosh(np.sqrt(params.zeta))
+        )
+        d = a_0 * (1 / (params.k_tr * params.chi_tr) - 1) + c_0 * (params.alpha + 1)
+        e = b_0 * (1 / (params.k_tr * params.chi_tr) - 1) * np.cosh(
+            np.sqrt(params.zeta)
+        ) + c_0 * (params.eta - 1) / np.sqrt(params.zeta) * np.sinh(
+            np.sqrt(params.zeta)
+        )
+        f = -c_0
+
+        # Second Quadratic
+        p = (
+            b_0
+            * params.k_tr
+            * params.chi_tr
+            * (params.alpha + params.eta)
+            / np.sqrt(params.zeta)
+            * np.sinh(np.sqrt(params.zeta))
+            * np.cosh(np.sqrt(params.zeta))
+        )
+        q = (
+            a_0
+            * params.k_tr
+            * params.chi_tr
+            * (params.alpha + params.eta)
+            / np.sqrt(params.zeta)
+            * np.sinh(np.sqrt(params.zeta))
+        )
+        r = params.alpha * params.Bi_tr * params.Bi_ci * (params.k_tr - params.k_ci)
+        s = c_0 * params.k_tr * params.chi_tr * (params.alpha + params.eta) / np.sqrt(
+            params.zeta
+        ) * np.sinh(np.sqrt(params.zeta)) + params.Bi_tr * params.Bi_ci * (
+            params.eta * params.k_tr + params.alpha * params.k_ci
+        ) * np.cosh(np.sqrt(params.zeta))
+
+        # Solve for B
+        poly = np.poly1d(
+            [
+                (0.0 if params.eta == 1 else (a * p**2 - b * p * q + c * q**2)),
+                (
+                    2 * a * p * s
+                    - b * p * r
+                    - b * q * s
+                    + 2 * c * q * r
+                    - d * p * q
+                    + e * q**2
+                ),
+                (
+                    a * s**2
+                    - b * r * s
+                    + c * r**2
+                    - d * p * r
+                    - d * q * s
+                    + 2 * e * q * r
+                    + f * q**2
+                ),
+                (-d * r * s + e * r**2 + 2 * f * q * r),
+                f * r**2,
+            ]
+        )
+        B = poly.roots  # noqa: N806
+
+        # Solve for A
+        A = -(p * B + s) / (q * B + r) * B  # noqa: N806
+
+        self.roots = [(a, b) for a, b in zip(A, B)]
+
+    def _trim_roots(self):
+        """Trim any invalid roots."""
+        verified_roots = []
+        for A_0, B_0 in self.roots:
+            if np.isclose(A_0.imag, 0):
+                self.A, self.B = A_0.real, B_0.real
+            else:
+                continue
+
+            # Check if any of the concentrations are negative
+            # (it is sufficient to check the endpoints)
+            if self.c_ci(0) < 0 or self.c_ci(1) < 0:
+                continue
+            elif self.c_tr(0) < 0 or self.c_tr(1) < 0:
+                continue
+
+            verified_roots.append([self.A, self.B])
+
+        self.roots = verified_roots
+
+    def c_tr(self, z, z_order=0):
+        """Concentration of trans surfactant at leading order."""
+        params = self.params
+        return params.alpha * self.A * polyder(Y**0, z_order)(
+            z
+        ) + params.eta * self.B * np.sqrt(params.zeta) ** z_order * cosh(
+            z * np.sqrt(params.zeta), z_order
+        )
+
+    def c_ci(self, z, z_order=0):
+        """Concentration of cis surfactant at leading order."""
+        params = self.params
+        return self.A * polyder(Y**0, z_order)(z) - self.B * np.sqrt(
+            params.zeta
+        ) ** z_order * cosh(z * np.sqrt(params.zeta), z_order)
+
+    def c(self, z, z_order=0):
+        """Concentration of surfactant at leading order."""
+        return np.array([self.c_tr(z, z_order), self.c_ci(z, z_order)])
+
+    def i_c_tr(self, z, z_s=0):
+        """Integral of the trans concentration at leading order."""
+        return self.c_tr(z, z_order=-1) - self.c_tr(z_s, z_order=-1)
+
+    def i_c_ci(self, z, z_s=0):
+        """Integral of the cis concentration at leading order."""
+        return self.c_ci(z, z_order=-1) - self.c_ci(z_s, z_order=-1)
+
+    def i_c(self, z, z_s):
+        """Integral of the surfactant concentration at leading order."""
+        return np.array([self.i_c_tr(z, z_s), self.i_c_ci(z, z_s)])
+
+    @property
+    def Gamma_ci(self):
+        """Surface excess of cis surfactant at leading order."""
+        return self.Gamma[1]
+
+    @property
+    def Gamma_tr(self):
+        """Surface excess of trans surfactant at leading order."""
+        return self.Gamma[0]
+
+    @cached_property
+    def Gamma(self):
+        """Surface excess of surfactant at leading order."""
+        params = self.params
+        return np.linalg.solve(self.M, params.P @ params.B @ params.K @ self.c(1))
+
+    @cached_property
+    def J_ci(self):
+        """Kinetic flux of the cis surfactant at leading order."""
+        return self.params.Bi_ci * (
+            self.params.k_ci * self.c_ci(1) * (1 - self.Gamma_tr - self.Gamma_ci)
+            - self.Gamma_ci
+        )
+
+    @cached_property
+    def J_tr(self):
+        """Kinetic flux of the trans surfactant at leading order."""
+        return self.params.Bi_tr * (
+            self.params.k_tr * self.c_tr(1) * (1 - self.Gamma_tr - self.Gamma_ci)
+            - self.Gamma_tr
+        )
+
+    @property
+    def J(self):
+        """Kinetic flux of the surfactant at leading order."""
+        return np.array([self.J_tr, self.J_ci])
+
+    @cached_property
+    def gamma(self):
+        """Surface tension at leading order."""
+        return 1 + self.params.Ma * np.log(1 - self.Gamma_tr - self.Gamma_ci)
+
+    @cached_property
+    def M(self):
+        params = self.params
+        return params.A + params.P @ params.B @ np.array(
+            [
+                [
+                    params.k_tr * self.c_tr(1) + 1,
+                    params.k_tr * self.c_tr(1),
+                ],
+                [
+                    params.k_ci * self.c_ci(1),
+                    params.k_ci * self.c_ci(1) + 1,
+                ],
+            ]
+        )

photosurfactant/semi_analytic/limits.py

@@ -0,0 +1,240 @@
+"""Limiting solutions for large and small Damkohler numbers."""
+
+import numpy as np
+
+from photosurfactant.parameters import Parameters
+
+
+class LowIntensity:
+    """Leading order solution for a uniform intensity at small Damkohler number."""
+
+    def __init__(self, params: Parameters, root_index: int = -1):
+        """Initialise solution to the small Damkohler model.
+
+        :param params: :class:`~.parameters.Parameters` object containing the
+            model parameters.
+        :param root_index: Index of the solution branch to use. If set to -1,
+            the branch is selected automatically.
+        """
+        self.params = params
+        self._initialize()
+
+        if root_index == -1:
+            self._trim_roots()
+            if len(self.roots) > 1:
+                raise ValueError(
+                    "Multiple valid solution branches detected. You can override this "
+                    "message by explicitly setting a solution branch using root_index."
+                )
+
+        (self._c_tr, self._c_ci) = self.roots[root_index]
+
+    def _initialize(self):
+        """Initialize the solution."""
+        params = self.params
+
+        # Solve for c_tr
+        poly = np.poly1d(
+            [
+                (params.k_tr * (params.k_ci - params.k_tr)),
+                (
+                    -params.k_tr * params.k_ci
+                    + (
+                        1
+                        + (1 + params.alpha * (1 - params.k_tr * params.chi_tr))
+                        / ((1 + params.alpha) * params.k_tr * params.chi_tr)
+                    )
+                    * (params.k_ci - params.k_tr)
+                ),
+                (
+                    params.alpha
+                    / (1 + params.alpha)
+                    * (
+                        params.k_tr
+                        - (
+                            2
+                            + (1 - params.k_tr * params.chi_tr)
+                            / (params.k_tr * params.chi_tr)
+                            * params.k_tr
+                        )
+                        * params.k_ci
+                    )
+                ),
+                ((params.alpha / (1 + params.alpha)) ** 2 * params.k_ci),
+            ]
+        )
+        c_tr = poly.roots
+
+        # Solve for c_ci
+        c_ci = -(
+            (1 + params.alpha) * params.chi_tr * params.k_tr * c_tr**2
+            + (
+                (1 + params.alpha) * (1 + params.chi_tr)
+                - params.alpha * params.chi_tr * params.k_tr
+            )
+            * c_tr
+            - params.alpha * params.chi_tr
+        ) / (params.chi_tr * params.k_ci * (1 + (1 + params.alpha) * (c_tr - 1)))
+
+        self.roots = [(a, b) for a, b in zip(c_tr, c_ci)]
+
+    def _trim_roots(self):
+        """Trim any invalid roots."""
+        verified_roots = []
+        for c_tr, c_ci in self.roots:
+            if np.isclose(c_tr.imag, 0):
+                self._c_tr, self._c_ci = c_tr.real, c_ci.real
+            else:
+                continue
+
+            # Check if any of the concentrations are negative
+            if self.c_tr < 0 or self.c_ci < 0:
+                continue
+            elif self.gamma_tr < 0 or self.gamma_ci < 0:
+                continue
+
+            verified_roots.append([self._c_tr, self._c_ci])
+
+        self.roots = verified_roots
+
+    @property
+    def c_tr(self):
+        """Concentration of trans surfactant at small Damkohler number."""
+        return self._c_tr
+
+    @property
+    def c_ci(self):
+        """Concentration of cis surfactant at small Damkohler number."""
+        return self._c_ci
+
+    @property
+    def gamma_tr(self):
+        """Surface excess of trans surfactant at small Damkohler number."""
+        params = self.params
+        return (
+            params.k_tr
+            * self.c_tr
+            / (1 + params.k_tr * self.c_tr + params.k_ci * self.c_ci)
+        )
+
+    @property
+    def gamma_ci(self):
+        """Surface excess of cis surfactant at small Damkohler number."""
+        params = self.params
+        return (
+            params.k_ci
+            * self.c_ci
+            / (1 + params.k_tr * self.c_tr + params.k_ci * self.c_ci)
+        )
+
+    @property
+    def tension(self):
+        """Surface tension at small Damkohler number."""
+        return 1 + self.params.Ma * np.log(1 - self.gamma_tr - self.gamma_ci)
+
+
+class HighIntensity:
+    """Leading order solution for a uniform intensity at large Damkohler number."""
+
+    def __init__(self, params: Parameters, root_index: int = -1):
+        """Initialise solution to the large Damkohler model.
+
+        :param params: :class:`~.parameters.Parameters` object containing the
+            model parameters.
+        :param root_index: Index of the solution branch to use. If set to -1,
+            the branch is selected automatically.
+        """
+        self.params = params
+        self._initialize()
+
+        if root_index == -1:
+            self._trim_roots()
+            if len(self.roots) > 1:
+                raise ValueError(
+                    "Multiple valid solution branches detected. You can override this "
+                    "message by explicitly setting a solution branch using root_index."
+                )
+
+        self._gamma_ci = self.roots[root_index]
+
+    def _initialize(self):
+        """Initialize the solution."""
+        params = self.params
+
+        # Define additional parameters
+        a = params.alpha * params.Bi_tr * params.k_tr + params.Bi_ci * params.k_ci
+        b = params.alpha * params.Bi_tr * (1 + params.k_tr + 1 / params.chi_tr)
+        c = params.Bi_ci * (1 + params.k_ci + 1 / params.chi_ci)
+
+        # Solve for Gamma_ci
+        poly = np.poly1d(
+            [
+                (1 + params.alpha) / (params.k_tr * params.chi_tr) * a,
+                -(b + c),
+                a / (1 + params.alpha),
+            ]
+        )
+        self.roots = poly.roots
+
+    def _trim_roots(self):
+        """Trim any invalid roots."""
+        verified_roots = []
+        for root in self.roots:
+            if np.isclose(root.imag, 0):
+                self._gamma_ci = root.real
+            else:
+                continue
+
+            # Check if any of the concentrations are negative
+            if self.c_ci < 0 or self.c_tr < 0:
+                continue
+            elif self.gamma_ci < 0:
+                continue
+
+            verified_roots.append(self._gamma_ci)
+
+        self.roots = verified_roots
+
+    @property
+    def c_tr(self):
+        """Concentration of trans surfactant at large Damkohler number."""
+        return self.params.alpha * self.c_ci
+
+    @property
+    def c_ci(self):
+        """Concentration of cis surfactant at large Damkohler number."""
+        params = self.params
+        return (
+            1 / (1 + params.alpha) - 1 / (params.k_tr * params.chi_tr) * self.gamma_ci
+        )
+
+    @property
+    def gamma_tr(self):
+        """Surface excess of trans surfactant at large Damkohler number."""
+        return self.params.alpha * self.gamma_ci
+
+    @property
+    def gamma_ci(self):
+        """Surface excess of cis surfactant at large Damkohler number."""
+        return self._gamma_ci
+
+    @property
+    def J_tr(self):
+        """Kinetic flux of the trans surfactant at large Damkohler number."""
+        return self.params.Bi_tr * (
+            self.params.k_tr * self.c_tr * (1 - self.gamma_tr - self.gamma_ci)
+            - self.gamma_tr
+        )
+
+    @property
+    def J_ci(self):
+        """Kinetic flux of the cis surfactant at large Damkohler number."""
+        return self.params.Bi_ci * (
+            self.params.k_ci * self.c_ci * (1 - self.gamma_tr - self.gamma_ci)
+            - self.gamma_ci
+        )
+
+    @property
+    def tension(self):
+        """Surface tension at large Damkohler number."""
+        return 1 + self.params.Ma * np.log(1 - self.gamma_tr - self.gamma_ci)

photosurfactant/semi_analytic/utils.py

@@ -0,0 +1,43 @@
+"""Utility functions for the semi-analytic model."""
+
+from enum import Enum
+from typing import Callable
+
+import numpy as np
+import numpy.typing as npt
+
+Y = np.poly1d([1, 0])  # Polynomial for differentiation
+
+
+def hyperder(n: int) -> Callable[[float], float]:
+    """Return the n-th derivative of cosh."""
+    return np.sinh if n % 2 else np.cosh
+
+
+def cosh(x: float, x_order: int = 0) -> float:
+    return hyperder(x_order)(x)
+
+
+def sinh(x: float, x_order: int = 0) -> float:
+    return hyperder(x_order + 1)(x)
+
+
+def polyder(p: np.poly1d, n: int) -> np.poly1d:
+    """Wrap np.polyder and np.polyint."""
+    return p.deriv(n) if n > 0 else p.integ(-n)
+
+
+def to_arr(vals: dict, unknowns: Enum) -> npt.NDArray:
+    """Convert a dictionary of values to an array."""
+    arr = np.zeros(len(unknowns), dtype=complex)
+    for key in vals.keys():
+        if key not in unknowns:
+            raise ValueError(f"Unknown key: {key}")
+
+    for i, key in enumerate(unknowns):
+        try:
+            arr[i] = vals[key]
+        except KeyError:
+            pass
+
+    return arr

photosurfactant/utils/arg_parser.py

@@ -0,0 +1,162 @@
+from argparse import ArgumentParser
+
+
+def parameter_parser(parser: ArgumentParser):
+    """Add model parameters to the parser."""
+    parser.add_argument(
+        "--L",
+        type=float,
+        default=10.0,
+        help="The aspect ratio of the domain.",
+    )
+    parser.add_argument(
+        "--Da_tr",
+        type=float,
+        default=1.0,
+        help="The Damkohler number for the trans surfactant.",
+    )
+    parser.add_argument(
+        "--Da_ci",
+        type=float,
+        default=2.0,
+        help="The Damkohler number for the cis surfactant.",
+    )
+    parser.add_argument(
+        "--Pe_tr",
+        type=float,
+        default=10.0,
+        help="The Peclet number for the trans surfactant.",
+    )
+    parser.add_argument(
+        "--Pe_ci",
+        type=float,
+        default=10.0,
+        help="The Peclet number for the cis surfactant.",
+    )
+    parser.add_argument(
+        "--Pe_tr_s",
+        type=float,
+        default=10.0,
+        help="The Peclet number for the trans surfactant on the interface.",
+    )
+    parser.add_argument(
+        "--Pe_ci_s",
+        type=float,
+        default=10.0,
+        help="The Peclet number for the cis surfactant on the interface.",
+    )
+    parser.add_argument(
+        "--Bi_tr",
+        type=float,
+        default=1 / 300,
+        help="The Biot number for the trans surfactant.",
+    )
+    parser.add_argument(
+        "--Bi_ci",
+        type=float,
+        default=1.0,
+        help="The Biot number for the cis surfactant.",
+    )
+    parser.add_argument("--Ma", type=float, default=2.0, help="The Marangoni number.")
+    parser.add_argument(
+        "--k_tr",
+        type=float,
+        default=1.0,
+        help="The adsorption rate for the trans surfactant.",
+    )
+    parser.add_argument(
+        "--k_ci",
+        type=float,
+        default=1 / 30,
+        help="The adsorption rate for the cis surfactant.",
+    )
+    parser.add_argument(
+        "--chi_tr",
+        type=float,
+        default=100 / 30,
+        help="The desorption rate for the trans surfactant.",
+    )
+    parser.add_argument(
+        "--chi_ci",
+        type=float,
+        default=100.0,
+        help="The desorption rate for the cis surfactant.",
+    )
+
+
+def plot_parser(parser: ArgumentParser):
+    """Add plotting parameters to the parser."""
+    parser.add_argument(
+        "--wave_count", type=int, default=100, help="Number of wavenumbers to use."
+    )
+    parser.add_argument(
+        "--grid_size",
+        type=int,
+        default=1000,
+        help="Number of grid points to evaluate the solution on.",
+    )
+    parser.add_argument(
+        "-s", "--save", action="store_true", help="Save the figures to disk."
+    )
+    parser.add_argument(
+        "--path", type=str, default="./", help="Path to save the figures to."
+    )
+    parser.add_argument(
+        "--label", type=str, help="Label to append to the figure filenames."
+    )
+    parser.add_argument(
+        "--usetex", action="store_true", help="Use LaTeX for rendering text."
+    )
+    parser.add_argument(
+        "--format",
+        type=str,
+        default="png",
+        help="Format to save the figures in.",
+    )
+
+
+def leading_order_parser(parser: ArgumentParser):
+    """Add leading order parameters to the parser."""
+    parser.add_argument(
+        "--root_index",
+        type=int,
+        default=-1,
+        help="The index of solution branch for the leading order problem. If set to "
+        "-1, the branch is selected automatically.",
+    )
+
+
+def first_order_parser(parser: ArgumentParser):
+    """Add first order parameters to the parser."""
+    parser.add_argument(
+        "--func",
+        type=str,
+        default="super_gaussian(x, 4.0, 1.0)",
+        help="An expression in the coordinate x for the light intensity/interface "
+        'perturbation. The function should be a quoted string. E.g. "sin(x)". The '
+        "function must be 2L-periodic and always return a float.",
+    )
+    parser.add_argument(
+        "--problem",
+        choices=["forward", "inverse"],
+        default="forward",
+        help="The type of problem to solve.",
+    )
+    parser.add_argument(
+        "--mollify",
+        action="store_true",
+        help="Apply mollification to the light intensity/interface perturbation.",
+    )
+    parser.add_argument(
+        "--delta",
+        type=float,
+        default=0.5,
+        help="The mollification parameter for the light intensity/interface "
+        "perturbation.",
+    )
+    parser.add_argument(
+        "--norm_scale",
+        choices=["linear", "log"],
+        default="linear",
+        help="The normalization type.",
+    )

photosurfactant/utils/func_parser.py

@@ -0,0 +1,10 @@
+from typing import Callable
+
+import numpy as np  # noqa: F401
+
+from photosurfactant.intensity_functions import *  # noqa: F403
+from photosurfactant.parameters import Parameters
+
+
+def parse_func(func_str: str) -> Callable[[float, Parameters], float]:
+    return eval("lambda x, params: " + func_str)