SuPyMode 2.4.3__cp314-cp314-win_amd64.whl

SuPyMode/__init__.py

@@ -0,0 +1,9 @@
+from .utils import load_superset  # noqa: F401, W292
+
+try:
+    from ._version import version as __version__  # noqa: F401
+
+except ImportError:
+    __version__ = "0.0.0"
+
+# -

SuPyMode/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = "2.4.3"
+__version_tuple__ = version_tuple = (2, 4, 3)
+
+__commit_id__ = commit_id = None

SuPyMode/directories.py

@@ -0,0 +1,51 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from pathlib import Path
+import SuPyMode
+
+
+__all__ = [
+    "root_path",
+    "project_path",
+    "test_path",
+    "version_path",
+    "validation_data_path",
+    "doc_path",
+    "static_doc_path",
+    "logo_path",
+    "doc_css_path",
+]
+
+root_path = Path(SuPyMode.__path__[0])
+
+project_path = root_path.parents[0]
+
+test_path = project_path.joinpath("tests")
+
+user_data_directory = root_path.joinpath("user_data")
+
+reports_path = root_path.joinpath("reports")
+
+version_path = root_path.joinpath("VERSION")
+
+validation_data_path = root_path.joinpath("validation_data")
+
+doc_path = root_path.parents[0].joinpath("docs")
+
+static_doc_path = doc_path.joinpath("images")
+
+logo_path = static_doc_path.joinpath("logo.png")
+
+doc_css_path = doc_path.joinpath("source/_static/default.css")
+
+rtd_example = "https://supymode.readthedocs.io/en/latest/examples.html"
+
+
+if __name__ == "__main__":
+    for path_name in __all__:
+        path = locals()[path_name]
+        print(path)
+        assert path.exists(), f"Path {path_name} do not exists"
+
+# -

SuPyMode/plotter.py

@@ -0,0 +1,325 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+from dataclasses import dataclass
+from typing import Optional, Sequence, Tuple
+from MPSPlots import colormaps
+import matplotlib.pyplot as plt
+from matplotlib.animation import FuncAnimation, PillowWriter
+
+from SuPyMode.taper import AlphaProfile
+
+
+def generate_propagation_gif(
+    profile: AlphaProfile,
+    output_directory: str = "./new_gif.gif",
+    dpi: int = 100,
+    fps: int = 20,
+    number_of_frames: int = 200,
+    dark_background: bool = True,
+) -> None:
+    """
+    Generates an animated GIF of light propagation in a taper structure.
+
+    Parameters:
+        output_directory (str): Path where the GIF will be saved.
+        dpi (int): Dots per inch for the output GIF.
+        fps (int): Frames per second for the animation.
+        number_of_frames (int): Total number of frames in the animation.
+        dark_background (bool): If True, use a dark background for the GIF.
+
+    Returns:
+        None
+    """
+    figure, ax = plt.subplots(1, 1, figsize=(12, 6))
+    ax.set_xlabel(
+        "Propagation axis [mm]", color="white" if dark_background else "black"
+    )
+    style_context = "dark_background" if dark_background else "default"
+
+    sub_sampling_factor = int(profile.distance.size / number_of_frames)
+
+    sub_distance = profile.distance[::sub_sampling_factor] * 1e3
+    sub_radius = profile.radius[::sub_sampling_factor]
+    sub_itr_list = profile.itr_list[::sub_sampling_factor]
+    with plt.style.context(style_context):
+
+        def init_func() -> tuple:
+            line_0 = ax.plot(sub_distance, sub_radius, color="black")
+            line_1 = ax.plot(sub_distance, -sub_radius, color="black")
+
+            line_2 = ax.fill_between(
+                sub_distance, +sub_radius, -sub_radius, color="lightblue", alpha=0.8
+            )
+
+            return [*line_0, *line_1, line_2]
+
+        def animate(slice_number: int) -> tuple:
+            position = sub_distance[slice_number]
+            itr = sub_itr_list[slice_number]
+            title = f"[slice: {slice_number} - ITR: {itr:.3f}]"
+
+            if slice_number > 0:
+                ax.lines[-1].remove()
+
+            line_0 = ax.set_title(title, color="white")
+
+            line_1 = ax.axvline(position, linestyle="--", linewidth=2, color="red")
+
+            return line_0, line_1
+
+    animation = FuncAnimation(
+        fig=figure,
+        func=animate,
+        init_func=init_func,
+        blit=True,
+        repeat=True,
+        frames=sub_itr_list.size,
+    )
+
+    animation.save(output_directory, dpi=dpi, writer=PillowWriter(fps=fps))
+
+
+def get_3_figures(
+    *,
+    figure_size: Tuple[float, float] = (8, 6),
+    left: float = 0.1,
+    right: float = 0.9,
+    bottom: float = 0.1,
+    top: float = 0.9,
+    wspace: float = 1.0,
+    hspace: float = 0.15,
+):
+    """
+    Create a 3-axes figure layout:
+    - top row: one axis spanning both columns
+    - bottom row: two square axes (images)
+
+    Returns
+    -------
+    fig : matplotlib.figure.Figure
+    ax0 : matplotlib.axes.Axes
+        Top axis spanning full width.
+    ax1 : matplotlib.axes.Axes
+        Bottom-left image axis.
+    ax2 : matplotlib.axes.Axes
+        Bottom-right image axis.
+    """
+    fig = plt.figure(figsize=figure_size)
+
+    gs = fig.add_gridspec(
+        2,
+        2,
+        width_ratios=(1, 1),
+        height_ratios=(1, 1),
+        left=left,
+        right=right,
+        bottom=bottom,
+        top=top,
+        wspace=wspace,
+        hspace=hspace,
+    )
+
+    ax0 = fig.add_subplot(gs[0, :])
+    ax1 = fig.add_subplot(gs[1, 0])
+    ax2 = fig.add_subplot(gs[1, 1])
+
+    for ax in (ax1, ax2):
+        ax.set_aspect("equal")
+        ax.set_xticks([])
+        ax.set_yticks([])
+        ax.tick_params(
+            axis="both",
+            which="both",
+            top=False,
+            bottom=False,
+            right=False,
+            left=False,
+            labelleft=False,
+            labelbottom=False,
+            grid_alpha=0,
+        )
+
+    return fig, ax0, ax1, ax2
+
+
+@dataclass(frozen=True)
+class _AnimationSettings:
+    n_step: int = 20
+    dpi: float = 100.0
+    fps: int = 50
+    interval_ms: int = 40
+    outfile: str = "propagation.gif"
+
+
+class ModePropagationGifCreator:
+    """
+    Create an animated GIF of mode fields along a taper profile.
+
+    The API is intentionally close to your original implementation:
+    - constructor takes (superset, profile, max_number_of_mode, dark_background)
+    - make_animation(n_step, dpi, fps) writes "propagation.gif" by default
+
+    Improvements
+    ------------
+    - Stable artists: uses persistent QuadMesh objects and updates their data,
+      avoiding ax.clear() which is slow and breaks blitting.
+    - Robust figure layout: fields are created from a single method and stored.
+    - Profile marker: uses one Line2D updated each frame.
+    - Optional progress printing without spamming by default.
+
+    Notes
+    -----
+    This expects:
+    - profile.distance, profile.radius, profile.length
+    - profile.master_interpolation_z_to_itr(z) -> float
+    - superset.get_slice_structure(itr=..., add_symmetries=True) -> object with .fields
+    - superset[mode].stylized_name
+    """
+
+    def __init__(
+        self,
+        superset,
+        profile,
+        max_number_of_mode: Optional[int] = None,
+        dark_background: bool = True,
+    ):
+        self.superset = superset
+        self.profile = profile
+        self.dark_background = dark_background
+
+        self.number_of_mode = (
+            len(superset.supermodes)
+            if max_number_of_mode is None
+            else int(max_number_of_mode)
+        )
+
+        self.figure = None
+        self.grid_spec = None
+        self.ax_profile = None
+        self.field_axes: list = []
+        self._field_meshes: list = []
+        self._profile_line = None
+
+        self.generate_figure()
+
+    # -------------------------
+    # Figure construction
+    # -------------------------
+    def generate_figure(self, unit_size: Tuple[float, float] = (3, 6)) -> None:
+        figure_size = (unit_size[0] * self.number_of_mode, unit_size[1])
+        self.figure = plt.figure(figsize=figure_size)
+
+        self.grid_spec = self.figure.add_gridspec(
+            2,
+            self.number_of_mode,
+            left=0.1,
+            right=0.95,
+            bottom=0.1,
+            top=0.9,
+            wspace=0.5,
+            hspace=0.35,
+        )
+
+        self._generate_profile_ax()
+        self._generate_field_axes()
+
+    def _generate_profile_ax(self) -> None:
+        self.ax_profile = self.figure.add_subplot(self.grid_spec[0, :])
+        self.ax_profile.set_xlabel("Propagation distance z")
+        self.ax_profile.set_ylabel("Coupler profile")
+
+        top = self.profile.radius
+        bottom = -self.profile.radius
+
+        self.ax_profile.plot(self.profile.distance, top, color="black")
+        self.ax_profile.plot(self.profile.distance, bottom, color="black")
+        self.ax_profile.fill_between(
+            self.profile.distance, top, bottom, color="lightblue", alpha=0.8
+        )
+
+        self._profile_line = self.ax_profile.axvline(0.0, linestyle="--", color="red")
+
+    def _generate_field_axes(self) -> None:
+        self.field_axes = []
+        self._field_meshes = []
+
+        for mode_index in range(self.number_of_mode):
+            ax = self.figure.add_subplot(self.grid_spec[1, mode_index])
+            ax.set_aspect("equal")
+            ax.set_xticks([])
+            ax.set_yticks([])
+            ax.set_title(self.superset[mode_index].stylized_name)
+
+            # Placeholder mesh. We will replace data on first populate.
+            mesh = ax.pcolormesh(
+                [[0.0, 0.0], [0.0, 0.0]], cmap=colormaps.blue_black_red, shading="auto"
+            )
+
+            self.field_axes.append(ax)
+            self._field_meshes.append(mesh)
+
+    # -------------------------
+    # Frame evaluation
+    # -------------------------
+    def _get_fields_at_z(self, z: float):
+        itr = self.profile.master_interpolation_z_to_itr(z)
+        slice_structure = self.superset.get_slice_structure(
+            itr=itr, add_symmetries=True
+        )
+        return itr, slice_structure.fields
+
+    def populate_axes(self, z: float) -> None:
+        itr, fields = self._get_fields_at_z(z)
+
+        self._profile_line.set_xdata([z, z])
+        self.ax_profile.set_title(f"Z-distance: {z:>5.3e}    ITR: {itr:>5.3f}")
+
+        for mesh, field in zip(self._field_meshes, fields):
+            # QuadMesh stores a flattened array; set_array expects 1D.
+            mesh.set_array(field.ravel())
+
+        self.figure.canvas.draw_idle()
+
+    def update_axes(self, z: float) -> Sequence:
+        itr, fields = self._get_fields_at_z(z)
+
+        self._profile_line.set_xdata([z, z])
+        self.ax_profile.set_title(f"Z-distance: {z:>5.3e}    ITR: {itr:>5.3f}")
+
+        updated_artists = [self._profile_line]
+
+        for mesh, field in zip(self._field_meshes, fields):
+            mesh.set_array(field.ravel())
+            updated_artists.append(mesh)
+
+        return updated_artists
+
+    # -------------------------
+    # Animation
+    # -------------------------
+    def make_animation(self, n_step: int = 20, dpi: float = 100, fps: int = 50):
+        settings = _AnimationSettings(n_step=n_step, dpi=float(dpi), fps=int(fps))
+
+        self.populate_axes(z=0.0)
+
+        z_max = float(self.profile.length)
+        step = z_max / float(settings.n_step)
+
+        def animate(frame_index: int):
+            z = frame_index * step
+            return self.update_axes(z)
+
+        animation = FuncAnimation(
+            self.figure,
+            animate,
+            interval=settings.interval_ms,
+            blit=True,
+            repeat=True,
+            frames=settings.n_step,
+        )
+
+        animation.save(
+            settings.outfile,
+            dpi=settings.dpi,
+            writer=PillowWriter(fps=settings.fps),
+        )

SuPyMode/propagation.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+import numpy
+import pyvista
+import matplotlib.pyplot as plt
+
+from SuPyMode.taper import AlphaProfile
+
+
+class Propagation:
+    def __init__(
+        self,
+        superset: object,
+        distance: numpy.ndarray,
+        profile: AlphaProfile,
+        amplitudes: numpy.ndarray,
+        z_to_itr: object,
+    ):
+        """
+        Parameters
+        ----------
+        profile : AlphaProfile
+            The profile to propagate.
+        amplitude : numpy.ndarray
+            The modes amplitudes.
+        """
+        self.superset = superset
+        self.supermodes = superset.supermodes
+        self.z_to_itr = z_to_itr
+        self.distance = distance
+        self.profile = profile
+        self.amplitudes = amplitudes
+        self.z_to_itr = self.profile.get_itr_vs_distance_interpolation()
+
+    def plot(
+        self,
+        sub_sampling: int = 5,
+        show_energy: bool = True,
+        show_amplitudes: bool = True,
+        **kwargs: dict,
+    ) -> None:
+        """
+        Plots the propagation of amplitudes over a given profile, optionally showing energy and amplitude plots.
+
+        Parameters
+        ----------
+        sub_sampling : int
+            The factor for sub-sampling data for plotting. Defaults to 5.
+        show_energy : bool
+            Whether to plot the energy of the modes. Defaults to True.
+        show_amplitudes : bool
+            Whether to plot the real part of the amplitudes. Defaults to True.
+        **kwargs : dict
+            Additional keyword arguments for solver.
+
+        """
+        fig, ax = plt.subplots()
+        ax.set(xlabel="Propagation distance (z)", ylabel="Inverse taper ratio (ITR)")
+
+        x_values = self.distance[::sub_sampling]
+
+        for idx, mode in enumerate(self.supermodes):
+            color = f"C{idx}"
+            y_energy = numpy.abs(self.amplitudes[idx, ::sub_sampling]) ** 2
+            y_amplitude = self.amplitudes[idx, ::sub_sampling].real
+
+            if show_energy:
+                ax.plot(
+                    x_values,
+                    y_energy,
+                    label=f"{mode.stylized_label} Energy",
+                    linewidth=2.0,
+                    linestyle="-",
+                    color=color,
+                )
+            if show_amplitudes:
+                ax.plot(
+                    x_values,
+                    y_amplitude,
+                    label=f"{mode.stylized_label} Amplitude",
+                    linewidth=2.0,
+                    linestyle="--",
+                    color=color,
+                )
+
+        if show_energy:
+            total_energy = numpy.sqrt(
+                numpy.sum(numpy.abs(self.amplitudes) ** 2, axis=0)
+            )[::sub_sampling]
+            ax.plot(
+                x_values,
+                total_energy,
+                label="Total Energy",
+                linewidth=3.0,
+                linestyle="--",
+                color="black",
+            )
+
+        ax.legend()
+        plt.show()
+
+    def get_field_combination(
+        self, amplitudes: numpy.ndarray, itr: int
+    ) -> numpy.ndarray:
+
+        shape = self.superset.supermodes[0].field.data[0].shape
+        total_field = numpy.zeros(shape).astype(complex)
+        slice_number = 0
+
+        for mode, amplitude in zip(self.superset.supermodes, amplitudes):
+            total_field += amplitude * mode.field.data[slice_number]
+
+        return total_field
+
+    def generate_gif(
+        self,
+        *,
+        sub_sampling: int = 5,
+        mutliplicative_factor: float = -100,
+        delta_azimuth: float = 0,
+        save_directory: str = "new_figure.gif",
+        colormap: str = "bwr",
+        **kwargs,
+    ) -> None:
+        """
+        Generates a gif video of the mode propagation.
+
+        Parameters
+        ----------
+        sub_sampling : int
+            Propagation undersampling factor for the video production.
+        mutliplicative_factor : float
+            Multiplicative factor for scaling.
+        save_directory : str
+            Directory to save the generated GIF.
+        delta_azimuth : float
+            Azimuthal change per frame.
+        **kwargs : dict
+            Additional keyword arguments for solver.
+
+        Returns
+        -------
+        Tuple: Propagation distances, amplitudes, and ITR list.
+        """
+        sub_amplitudes = self.amplitudes[:, ::sub_sampling]
+        initial_amplitudes = self.amplitudes[:, 0]
+
+        sub_distance = self.distance[::sub_sampling]
+        sub_itr = self.z_to_itr(sub_distance)
+
+        total_field = self.get_field_combination(amplitudes=initial_amplitudes, itr=1.0)
+
+        x, y = numpy.mgrid[0 : total_field.shape[0], 0 : total_field.shape[1]]
+        grid = pyvista.StructuredGrid(x, y, total_field)
+
+        plotter = pyvista.Plotter(notebook=False, off_screen=True)
+        plotter.open_gif(save_directory, fps=20)
+        plotter.view_isometric()
+        # plotter.set_background('black', top='white')
+
+        plotter.add_mesh(
+            grid,
+            scalars=total_field,
+            style="surface",
+            show_edges=True,
+            edge_color="k",
+            colormap=colormap,
+            show_scalar_bar=False,
+            clim=[-100, 100],
+        )
+
+        pts = grid.points.copy()
+        azimuth = 0
+        for z, amplitudes, itr in zip(sub_distance, sub_amplitudes.T, sub_itr):
+            print(f"itr: {itr}")
+            plotter.camera.elevation = -20
+            plotter.camera.azimuth = azimuth
+            azimuth += delta_azimuth
+
+            structure = self.superset.get_slice_structure(itr=itr, add_symmetries=True)
+            total_field = (
+                structure.get_field_combination(amplitudes, Linf_normalization=True)
+                * mutliplicative_factor
+            )
+
+            pts[:, -1] = total_field.T.ravel()
+            plotter.update_coordinates(pts, render=True)
+            plotter.update_scalars(total_field.T.ravel(), render=False)
+            plotter.add_title(
+                f"ITR: {itr: .3f}\t  z: {z: .3e}",
+                font="courier",
+                color="w",
+                font_size=20,
+            )
+
+            plotter.write_frame()
+
+        plotter.close()
+
+
+# -

SuPyMode/representation/__init__.py

@@ -0,0 +1,23 @@
+from .adiabatic import Adiabatic
+
+from .index import Index
+
+from .beating_length import BeatingLength
+
+from .eigen_value import EigenValue
+
+from .field import Field
+
+from .beta import Beta
+
+from .normalized_coupling import NormalizedCoupling
+
+__all__ = [
+    "Adiabatic",
+    "Beta",
+    "BeatingLength",
+    "EigenValue",
+    "Field",
+    "Index",
+    "NormalizedCoupling",
+]