morpho.py 0.0.3__tar.gz → 0.1.0__tar.gz

morpho_py-0.1.0/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: morpho.py
+Version: 0.1.0
+Summary: PWE framework for photonic crystal analysis
+License-Expression: MIT
+License-File: LICENSE
+Author: Tiago Vilela
+Author-email: tiagovla@gmail.com
+Requires-Python: >=3.9,<3.16
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
+Provides-Extra: docs
+Requires-Dist: matplotlib (>=3.4.3,<4.0.0)
+Requires-Dist: mkdocs (>=1.6.1,<2) ; extra == "docs"
+Requires-Dist: mkdocs-material (>=9.7.7) ; extra == "docs"
+Requires-Dist: mkdocstrings[python] (>=0.24.0) ; extra == "docs"
+Requires-Dist: numpy (>=1.20.1,<3.0.0)
+Requires-Dist: scipy (>=1.6.2,<2.0.0)

morpho_py-0.1.0/morpho/__init__.py

@@ -0,0 +1,28 @@
+__version__ = "0.1.0"
+
+from morpho.brillouinzone import (
+    BrillouinZonePath,
+    BrillouinZonePath1D,
+    BrillouinZonePath2D,
+    BrillouinZonePath3D,
+    SymmetryPoint,
+)
+from morpho.geometry import Geometry, Geometry1D, Geometry2D, Geometry3D
+from morpho.solver import Solver, Solver1D, Solver2D, Solver3D
+
+__all__ = [
+    "__version__",
+    "BrillouinZonePath",
+    "BrillouinZonePath1D",
+    "BrillouinZonePath2D",
+    "BrillouinZonePath3D",
+    "SymmetryPoint",
+    "Geometry",
+    "Geometry1D",
+    "Geometry2D",
+    "Geometry3D",
+    "Solver",
+    "Solver1D",
+    "Solver2D",
+    "Solver3D",
+]

morpho_py-0.1.0/morpho/brillouinzone.py

@@ -0,0 +1,339 @@
+"""This module implements classes related to the brillouinzone."""
+
+from abc import ABC, abstractproperty
+from dataclasses import dataclass
+from numbers import Integral
+from typing import List, Optional, Tuple, Union
+
+import numpy as np
+from numpy.linalg import norm
+
+
+@dataclass
+class BlochVectors:
+    """Represents a data structure of Bloch wave vectors."""
+
+    values: np.ndarray
+    cumsum: np.ndarray
+
+
+class SymmetryPoint:
+    """Model of a symmetry point at the brillouinzone.
+
+    Parameters
+    ----------
+    point : Tuple[float, ...]
+        A point in the reciprocal domain.
+    name : str
+        A label to describe the point.
+    """
+
+    def __init__(self, point: Tuple[float, ...], name: str):
+        """Initialize a SymmetryPoint."""
+        self.point = np.array(point)
+        self.name = name
+
+
+class BrillouinZonePathBase(ABC):
+    """BrillouinZoneBase class."""
+
+    def __init__(
+        self,
+        path: List[SymmetryPoint],
+        n_points: int = 50,
+        strategy: str = "linear",
+        points_per_segment: Optional[int] = None,
+    ):
+        self.path_points = path
+        self.n_points = n_points
+        self.strat = strategy
+        if points_per_segment is not None:
+            if (
+                not isinstance(points_per_segment, Integral)
+                or isinstance(points_per_segment, bool)
+                or points_per_segment < 1
+            ):
+                raise ValueError("points_per_segment must be a positive integer.")
+            if len(path) < 2:
+                raise ValueError(
+                    "At least two symmetry points are needed for segment sampling."
+                )
+            points_per_segment = int(points_per_segment)
+        self.points_per_segment = points_per_segment
+        self._path: np.ndarray
+
+    @abstractproperty
+    def betas(self) -> BlochVectors:
+        """Return bloch wave vectors."""
+
+    @staticmethod
+    def _interpolate_beta(beta_cs, path, n_points, points_per_segment=None):
+        """Interpolate a path globally or by segment."""
+        if points_per_segment is not None:
+            beta_values = []
+            beta_distances = []
+            for index in range(path.shape[1] - 1):
+                fractions = np.linspace(0.0, 1.0, points_per_segment + 1)
+                start = path[:, index, None]
+                delta = (path[:, index + 1] - path[:, index])[:, None]
+                segment_values = start + delta * fractions[None, :]
+
+                start_distance = beta_cs[index]
+                segment_length = beta_cs[index + 1] - start_distance
+                segment_distances = start_distance + segment_length * fractions
+
+                if index:
+                    segment_values = segment_values[:, 1:]
+                    segment_distances = segment_distances[1:]
+                beta_values.append(segment_values)
+                beta_distances.append(segment_distances)
+
+            return BlochVectors(
+                np.concatenate(beta_values, axis=1),
+                np.concatenate(beta_distances),
+            )
+
+        beta_csi = np.linspace(0, beta_cs[-1], n_points)
+        beta_vi = np.vstack(
+            [
+                np.interp(beta_csi, beta_cs, path[i, :]).flatten()
+                for i in range(path.shape[0])
+            ]
+        )
+        return BlochVectors(beta_vi, beta_csi)
+
+    @property
+    def point_locations(self):
+        """Return cumulative sum of vectors' length."""
+        return np.concatenate(
+            (np.zeros(1), np.cumsum(norm(np.diff(self._path, axis=1), axis=0)))
+        )
+
+    @property
+    def point_names(self):
+        """Return list of symmetry point names."""
+        return [p.name for p in self.path_points]
+
+
+class BrillouinZonePath1D(BrillouinZonePathBase):
+    """BrillouinZonePath1D.
+
+    Parameters
+    ----------
+    a1 : Tuple[float]
+        Direct lattice vector a1.
+    path : List[SymmetryPoint]
+        List of symmetry points.
+    n_points : int
+        Total number of vectors sampled along the full path. Used when
+        ``points_per_segment`` is not set.
+    strategy : str = 'linear'
+        Strategy to interpolate.
+    points_per_segment : int, optional
+        Number of intervals on each segment. Every symmetry point is sampled;
+        the total is one plus this value times the number of segments. This
+        takes precedence over ``n_points``.
+    """
+
+    def __init__(
+        self,
+        a1: Tuple[float],
+        path: List[SymmetryPoint],
+        n_points: int = 50,
+        strategy: str = "linear",
+        points_per_segment: Optional[int] = None,
+    ):
+        """Initialize a BrillouinZonePath."""
+        super().__init__(path, n_points, strategy, points_per_segment)
+        self.a1 = np.array(a1)
+        self.dim = 1
+
+    @property
+    def _path(self) -> np.ndarray:
+        """Return the path matrix."""
+        path = np.stack([p.point for p in self.path_points], axis=1)
+        return path[0, :] * self.b1[:, None]
+
+    @property
+    def betas(self) -> BlochVectors:
+        """Return beta vector values and cumsum."""
+        beta_cs = np.cumsum(norm(np.diff(self._path, axis=1), axis=0))
+        beta_cs = np.pad(beta_cs, (1, 0), "constant")
+        if self.strat == "linear":
+            return self._interpolate_beta(
+                beta_cs, self._path, self.n_points, self.points_per_segment
+            )
+        raise NotImplementedError
+
+    @property
+    def b1(self) -> np.ndarray:
+        """Return reciprocal lattice vector b1."""
+        return 2 * np.pi / self.a1
+
+
+class BrillouinZonePath2D(BrillouinZonePathBase):
+    """BrillouinZonePath2D.
+
+    Parameters
+    ----------
+    a1 : Tuple[float, float]
+        Direct lattice vector a1.
+    a2 : Tuple[float, float]
+        Direct lattice vector a2.
+    path : List[SymmetryPoint]
+        List of symmetry points.
+    n_points : int
+        Total number of vectors sampled along the full path. Used when
+        ``points_per_segment`` is not set.
+    strategy : str = 'linear'
+        Strategy to interpolate.
+    points_per_segment : int, optional
+        Number of intervals on each segment. Every symmetry point is sampled;
+        the total is one plus this value times the number of segments. This
+        takes precedence over ``n_points``.
+    """
+
+    def __init__(
+        self,
+        a1: Tuple[float, float],
+        a2: Tuple[float, float],
+        path: List[SymmetryPoint],
+        n_points: int = 50,
+        strategy: str = "linear",
+        points_per_segment: Optional[int] = None,
+    ):
+        """Initialize a BrillouinZonePath."""
+        super().__init__(path, n_points, strategy, points_per_segment)
+        self.a1 = np.array(a1)
+        self.a2 = np.array(a2)
+        self.dim = 2
+
+    @property
+    def _path(self) -> np.ndarray:
+        """Return the path matrix."""
+        path = np.stack([p.point for p in self.path_points], axis=1)
+        return path[0, :] * self.b1[:, None] + path[1, :] * self.b2[:, None]
+
+    @property
+    def betas(self) -> BlochVectors:
+        """Return beta vector values and cumsum."""
+        beta_cs = np.cumsum(norm(np.diff(self._path, axis=1), axis=0))
+        beta_cs = np.pad(beta_cs, (1, 0), "constant")
+        if self.strat == "linear":
+            return self._interpolate_beta(
+                beta_cs, self._path, self.n_points, self.points_per_segment
+            )
+        raise NotImplementedError
+
+    @property
+    def b1(self) -> np.ndarray:
+        """Return reciprocal lattice vector b1."""
+        Q = np.array([[0, -1], [1, 0]])
+        return 2 * np.pi * Q @ self.a2 / np.dot(self.a1, Q @ self.a2)
+
+    @property
+    def b2(self) -> np.ndarray:
+        """Return reciprocal lattice vector b2."""
+        Q = np.array([[0, -1], [1, 0]])
+        return 2 * np.pi * Q @ self.a1 / np.dot(self.a2, Q @ self.a1)
+
+
+class BrillouinZonePath3D(BrillouinZonePathBase):
+    """BrillouinZonePath3D.
+
+    Parameters
+    ----------
+    a1 : Tuple[float, float, float]
+        Direct lattice vector a1.
+    a2 : Tuple[float, float, float]
+        Direct lattice vector a2.
+    a3 : Tuple[float, float, float]
+        Direct lattice vector a3.
+    path : List[SymmetryPoint]
+        List of symmetry points.
+    n_points : int
+        Total number of vectors sampled along the full path. Used when
+        ``points_per_segment`` is not set.
+    strategy : str = 'linear'
+        Strategy to interpolate.
+    points_per_segment : int, optional
+        Number of intervals on each segment. Every symmetry point is sampled;
+        the total is one plus this value times the number of segments. This
+        takes precedence over ``n_points``.
+    """
+
+    def __init__(
+        self,
+        a1: Tuple[float, float, float],
+        a2: Tuple[float, float, float],
+        a3: Tuple[float, float, float],
+        path: List[SymmetryPoint],
+        n_points: int = 50,
+        strategy: str = "interpolate",
+        points_per_segment: Optional[int] = None,
+    ):
+        """Initialize a BrillouinZonePath."""
+        super().__init__(path, n_points, strategy, points_per_segment)
+        self.a1 = np.array(a1)
+        self.a2 = np.array(a2)
+        self.a3 = np.array(a3)
+        self.dim = 3
+
+    @property
+    def _path(self) -> np.ndarray:
+        """Return the path matrix."""
+        path = np.stack([p.point for p in self.path_points], axis=1)
+        return (
+            path[0, :] * self.b1[:, None]
+            + path[1, :] * self.b2[:, None]
+            + path[2, :] * self.b3[:, None]
+        )
+
+    @property
+    def betas(self) -> BlochVectors:
+        """Return beta vector values and cumsum."""
+        beta_cs = np.cumsum(norm(np.diff(self._path, axis=1), axis=0))
+        beta_cs = np.pad(beta_cs, (1, 0), "constant")
+        if self.strat == "interpolate":
+            return self._interpolate_beta(
+                beta_cs, self._path, self.n_points, self.points_per_segment
+            )
+        raise NotImplementedError
+
+    @property
+    def b1(self) -> np.ndarray:
+        """Return reciprocal lattice vector b1."""
+        return (
+            2
+            * np.pi
+            * np.cross(self.a2, self.a3)
+            / np.dot(self.a1, np.cross(self.a2, self.a3))
+        )
+
+    @property
+    def b2(self) -> np.ndarray:
+        """Return reciprocal lattice vector b2."""
+        return (
+            2
+            * np.pi
+            * np.cross(self.a3, self.a1)
+            / np.dot(self.a1, np.cross(self.a2, self.a3))
+        )
+
+    @property
+    def b3(self) -> np.ndarray:
+        """Return reciprocal lattice vector b3."""
+        return (
+            2
+            * np.pi
+            * np.cross(self.a1, self.a2)
+            / np.dot(self.a1, np.cross(self.a2, self.a3))
+        )
+
+
+def BrillouinZonePath(
+    a1, *args, **kwargs
+) -> Union[BrillouinZonePath1D, BrillouinZonePath2D, BrillouinZonePath3D]:
+    """BrillouinZonePath factory."""
+    dim_obj = {1: BrillouinZonePath1D, 2: BrillouinZonePath2D, 3: BrillouinZonePath3D}
+    return dim_obj[len(a1)](a1, *args, **kwargs)

morpho_py-0.1.0/morpho/geometry.py

@@ -0,0 +1,265 @@
+"""Implement photonic crystal geometries."""
+
+from __future__ import annotations
+
+from abc import ABC
+from dataclasses import dataclass
+from typing import Callable, Optional, Tuple, Union
+
+import numpy as np
+
+
+class GeometryBase(ABC):
+    """Base Geometry class."""
+
+    def __init__(self, eps_rf: Optional[Callable], mu_rf: Optional[Callable]):
+        self.eps_rf: Optional[Callable] = eps_rf or None
+        self.mu_rf: Optional[Callable] = mu_rf or None
+        self._eps_r: np.ndarray
+        self._mu_r: np.ndarray
+
+    def overwrite(self, func: Callable):
+        """Overwrite decorator.
+
+        Parameters
+        ----------
+        func : Callable
+            func
+        """
+        if func.__name__ in ["eps_rf", "mu_rf"]:
+            setattr(self, func.__name__, func)
+        else:
+            raise Exception("Can only overwrite eps_rf or mu_rf.")
+
+
+class Geometry1D(GeometryBase):
+    """Geometry class.
+
+    Parameters
+    ----------
+    a1 : Tuple[float, ...]
+        Direct a1 vector.
+    n1 : int
+        Number of divisions in the a1 vector direction.
+    eps_rf : Optional[Callable]
+        Permittivity matrix eps_r if directly supplied.
+    mu_rf : Optional[Callable]
+        Permeabillity matrix mu_r if directly supplied.
+    """
+
+    def __init__(
+        self,
+        a1: Tuple[float],
+        n1: int = 64,
+        eps_rf: Optional[Callable] = None,
+        mu_rf: Optional[Callable] = None,
+    ):
+        super().__init__(eps_rf, mu_rf)
+        self.a1: np.ndarray = np.array(a1)
+        self.n1: int = n1
+        self._eps_r: np.ndarray = np.ones((n1,), dtype=complex)
+        self._mu_r: np.ndarray = np.ones((n1,), dtype=complex)
+
+    @property
+    def X(self) -> CartesianVectors1D:
+        """Return cartesian positions."""
+        P0 = np.arange(self.n1) / self.n1 - 0.5
+        x = P0 * self.a1[0]
+        return CartesianVectors1D(x)
+
+    @property
+    def eps_r(self) -> np.ndarray:
+        """Return the relative permittivity profile."""
+        if self.eps_rf:
+            self.eps_rf(eps_r=self._eps_r, x=self.X.x)
+        return self._eps_r
+
+    @property
+    def mu_r(self) -> np.ndarray:
+        """Return the relative permeability profile."""
+        if self.mu_rf:
+            self.mu_rf(self._mu_r, x=self.X.x)
+        return self._mu_r
+
+
+class Geometry2D(GeometryBase):
+    """Geometry class.
+
+    Parameters
+    ----------
+    a1 : Tuple[float, ...]
+        Direct a1 vector.
+    a2 : Optional[Tuple[float, ...]]
+        Direct a2 vector.
+    n1 : int
+        Number of divisions in the a1 vector direction.
+    n2 : int
+        Number of divisions in the a2 vector direction.
+    eps_rf : Optional[Callable]
+        Permittivity matrix eps_r if directly supplied.
+    mu_rf : Optional[Callable]
+        Permeabillity matrix mu_r if directly supplied.
+    """
+
+    def __init__(
+        self,
+        a1: Tuple[float, float],
+        a2: Tuple[float, float],
+        n1: int = 64,
+        n2: int = 64,
+        eps_rf: Optional[Callable] = None,
+        mu_rf: Optional[Callable] = None,
+    ):
+        super().__init__(eps_rf, mu_rf)
+        self.a1: np.ndarray = np.array(a1)
+        self.a2: np.ndarray = np.array(a2)
+        self.n1: int = n1
+        self.n2: int = n2
+        self._eps_r: np.ndarray = np.ones((n1, n2), dtype=complex)
+        self._mu_r: np.ndarray = np.ones((n1, n2), dtype=complex)
+
+    @property
+    def X(self) -> CartesianVectors2D:
+        """Return cartesian positions."""
+        P0, Q0 = np.meshgrid(
+            np.arange(self.n1) / self.n1 - 0.5,
+            np.arange(self.n2) / self.n2 - 0.5,
+            indexing="ij",
+        )
+
+        x = P0 * self.a1[0] + Q0 * self.a2[0]
+        y = P0 * self.a1[1] + Q0 * self.a2[1]
+
+        return CartesianVectors2D(x, y)
+
+    @property
+    def eps_r(self) -> np.ndarray:
+        """Return the relative permittivity matrice."""
+        if self.eps_rf:
+            self.eps_rf(eps_r=self._eps_r, x=self.X.x, y=self.X.y)
+        return self._eps_r
+
+    @property
+    def mu_r(self) -> np.ndarray:
+        """Return the relative permeabillity matrice."""
+        if self.mu_rf:
+            self.mu_rf(self._mu_r, x=self.X.x, y=self.X.y)
+        return self._mu_r
+
+
+class Geometry3D(GeometryBase):
+    """Geometry class.
+
+    Parameters
+    ----------
+    a1 : Tuple[float, float, float]
+        Direct a1 vector.
+    a2 : Optional[Tuple[float, float, float]]
+        Direct a2 vector.
+    a3 : Optional[Tuple[float, float, float]]
+        Direct a3 vector.
+    n1 : int
+        Number of divisions in the a1 vector direction.
+    n2 : int
+        Number of divisions in the a2 vector direction.
+    n3 : int
+        Number of divisions in the a3 vector direction.
+    eps_rf : Optional[Callable]
+        Permittivity matrix function eps_rf if directly supplied.
+    mu_rf : Optional[Callable]
+        Permeabillity matrix function mu_rf if directly supplied.
+    """
+
+    def __init__(
+        self,
+        a1: Tuple[float, float, float],
+        a2: Tuple[float, float, float],
+        a3: Tuple[float, float, float],
+        n1: int = 64,
+        n2: int = 64,
+        n3: int = 64,
+        eps_rf: Optional[Callable] = None,
+        mu_rf: Optional[Callable] = None,
+    ):
+        super().__init__(eps_rf, mu_rf)
+        self.a1: np.ndarray = np.array(a1)
+        self.a2: np.ndarray = np.array(a2)
+        self.a3: np.ndarray = np.array(a3)
+        self.n1: int = n1
+        self.n2: int = n2
+        self.n3: int = n3
+        self._eps_r: np.ndarray = np.ones((n1, n2, n3), dtype=complex)
+        self._mu_r: np.ndarray = np.ones((n1, n2, n3), dtype=complex)
+
+    @property
+    def X(self) -> CartesianVectors3D:
+        """Return cartesian positions."""
+        P0, Q0, R0 = np.meshgrid(
+            np.arange(self.n1) / self.n1 - 0.5,
+            np.arange(self.n2) / self.n2 - 0.5,
+            np.arange(self.n3) / self.n3 - 0.5,
+            indexing="ij",
+        )
+
+        x = P0 * self.a1[0] + Q0 * self.a2[0] + R0 * self.a3[0]
+        y = P0 * self.a1[1] + Q0 * self.a2[1] + R0 * self.a3[1]
+        z = P0 * self.a1[2] + Q0 * self.a2[2] + R0 * self.a3[2]
+
+        return CartesianVectors3D(x, y, z)
+
+    @property
+    def eps_r(self) -> np.ndarray:
+        """Return the relative permittivity matrice."""
+        if self.eps_rf:
+            self.eps_rf(eps_r=self._eps_r, x=self.X.x, y=self.X.y, z=self.X.z)
+        return self._eps_r
+
+    @property
+    def mu_r(self) -> np.ndarray:
+        """Return the relative permeabillity matrice."""
+        if self.mu_rf:
+            self.mu_rf(self._mu_r, x=self.X.x, y=self.X.y, z=self.X.z)
+        return self._mu_r
+
+
+def Geometry(*args, **kwargs) -> Union[Geometry1D, Geometry2D, Geometry3D]:
+    """Geometry factory.
+
+    Parameters
+    ----------
+    args :
+        args
+    kwargs :
+        kwargs
+
+    Returns
+    -------
+    Union[Geometry1D, Geometry2D, Geometry3D]
+
+    """
+    dim_obj = {1: Geometry1D, 2: Geometry2D, 3: Geometry3D}
+    return dim_obj[len(args[0])](*args, **kwargs)
+
+
+@dataclass
+class CartesianVectors1D:
+    """Represent a data structure of cartesian coordinates."""
+
+    x: np.ndarray
+
+
+@dataclass
+class CartesianVectors2D:
+    """Represent a data structure of cartesian coordinates."""
+
+    x: np.ndarray
+    y: np.ndarray
+
+
+@dataclass
+class CartesianVectors3D:
+    """Represent a data structure of cartesian coordinates."""
+
+    x: np.ndarray
+    y: np.ndarray
+    z: np.ndarray

morpho_py-0.1.0/morpho/solver.py

@@ -0,0 +1,230 @@
+"""Implement 3D/2D solvers."""
+
+from typing import List, Union
+
+import numpy as np
+from scipy.linalg import eigh
+
+from .brillouinzone import BrillouinZonePath1D as BZPath1D
+from .brillouinzone import BrillouinZonePath2D as BZPath2D
+from .brillouinzone import BrillouinZonePath3D as BZPath3D
+from .geometry import Geometry1D, Geometry2D, Geometry3D
+from .utils import convmat, harmonic_indices
+
+
+class Solver1D:
+    """Implement a 1D PWE Solver.
+
+    Parameters
+    ----------
+    geometry : Geometry
+        geometry
+    path : BrillouinZonePath
+        A BrillouinZonePath object.
+    P : int
+        Number of terms in the direction of the reciprocal vector b1.
+    """
+
+    def __init__(
+        self, geometry: Geometry1D, path: BZPath1D, P: int = 1, pol: str = "TM"
+    ):
+        """Initialize the PWE Solver."""
+        self.geo = geometry
+        self.path = path
+        self.P = P
+        self.pol = pol
+
+        self.eps_rc: np.ndarray
+        self.mu_rc: np.ndarray
+        self.wn: List[np.ndarray] = []
+        self.modes: List[np.ndarray] = []
+
+    def run(self):
+        """Calculate the eigen-wavenumbers and modes."""
+        self.eps_rc = convmat(self.geo.eps_r, self.P)
+        self.mu_rc = convmat(self.geo.mu_r, self.P)
+        mu_rci = convmat(1 / self.geo.mu_r, self.P)
+        eps_rci = convmat(1 / self.geo.eps_r, self.P)
+
+        p = harmonic_indices(self.P)
+        G_k = p * self.path.b1[0]
+        beta = self.path.betas.values
+
+        for col in range(beta.shape[1]):
+            k = beta[0, col] - G_k
+            KX = np.diag(k)
+
+            if self.pol == "TM":
+                A = KX @ mu_rci @ KX
+                B = self.eps_rc
+            else:
+                A = KX @ eps_rci @ KX
+                B = self.mu_rc
+
+            D, V = eigh(A, B)
+            self.wn.append(np.sqrt(np.maximum(D, 0)))
+            self.modes.append(V)
+
+
+class Solver2D:
+    """Implement a 2D PWE Solver.
+
+    Parameters
+    ----------
+    geometry : Geometry
+        geometry
+    path : BrillouinZonePath
+        A BrillouinZonePath object.
+    P : int
+        Number of terms in the direction of the reciprocal vector b1.
+    Q : int
+        Number of terms in the direction of the reciprocal vector b2.
+    """
+
+    def __init__(
+        self,
+        geometry: Geometry2D,
+        path: BZPath2D,
+        P: int = 1,
+        Q: int = 1,
+        pol: str = "TM",
+    ):
+        """Initialize the PWE Solver."""
+        self.geo = geometry
+        self.path = path
+        self.P, self.Q = P, Q
+        self.pol = pol
+
+        self.eps_rc: np.ndarray
+        self.mu_rc: np.ndarray
+        self.wn: List[np.ndarray] = []
+        self.modes: List[np.ndarray] = []
+
+    def run(self):
+        """Calculate the eigen-wavenumbers and modes."""
+        self.eps_rc = convmat(self.geo.eps_r, self.P, self.Q)
+        self.mu_rc = convmat(self.geo.mu_r, self.P, self.Q)
+
+        mu_rci = convmat(1 / self.geo.mu_r, self.P, self.Q)
+        if self.pol != "TM":
+            # Factorize epsilon before truncating its reciprocal. This
+            # inverse rule converges much faster for TE modes at sharp
+            # dielectric interfaces than Fourier coefficients of 1/eps.
+            eps_rci = np.linalg.inv(self.eps_rc)
+
+        p = harmonic_indices(self.P)
+        q = harmonic_indices(self.Q)
+
+        P0, Q0 = np.meshgrid(p, q, indexing="ij")
+        b1, b2 = self.path.b1, self.path.b2
+
+        G_k = P0.ravel(order="F") * b1[:, None] + Q0.ravel(order="F") * b2[:, None]
+        beta = self.path.betas.values
+
+        for col in range(beta.shape[1]):
+            k = beta[:, col, None] - G_k
+
+            KX = np.diag(k[0, :])
+            KY = np.diag(k[1, :])
+
+            if self.pol == "TM":
+                A = KX @ mu_rci @ KX + KY @ mu_rci @ KY
+                B = self.eps_rc
+            else:
+                A = KX @ eps_rci @ KX + KY @ eps_rci @ KY
+                B = self.mu_rc
+
+            D, V = eigh(A, B)
+
+            self.wn.append(np.sqrt(np.maximum(D, 0)))
+            self.modes.append(V)
+
+
+class Solver3D:
+    """Implement a 3D PWE Solver.
+
+    Parameters
+    ----------
+    geometry : Geometry
+        geometry
+    path : BrillouinZonePath
+        A BrillouinZonePath object.
+    P : int
+        Number of terms in the direction of the reciprocal vector b1.
+    Q : int
+        Number of terms in the direction of the reciprocal vector b2.
+    R : int
+        Number of terms in the direction of the reciprocal vector b3.
+    """
+
+    def __init__(
+        self, geometry: Geometry3D, path: BZPath3D, P: int = 1, Q: int = 1, R: int = 1
+    ):
+        """Initialize the PWE Solver."""
+        self.geo = geometry
+        self.path = path
+        self.P, self.Q, self.R = P, Q, R
+
+        self.eps_rc: np.ndarray
+        self.mu_rc: np.ndarray
+        self.wn: List[np.ndarray] = []
+        self.modes: List[np.ndarray] = []
+
+    def run(self):
+        """Calculate the eigen-wavenumbers and modes."""
+        self.eps_rc = convmat(self.geo.eps_r, self.P, self.Q, self.R)
+        self.mu_rc = convmat(self.geo.mu_r, self.P, self.Q, self.R)
+
+        eps_rk = np.kron(np.eye(3), self.eps_rc)
+        mu_ri = convmat(1 / self.geo.mu_r, self.P, self.Q, self.R)
+        mu_rki = np.kron(np.eye(3), mu_ri)
+
+        p = harmonic_indices(self.P)
+        q = harmonic_indices(self.Q)
+        r = harmonic_indices(self.R)
+
+        P0, Q0, R0 = np.meshgrid(p, q, r, indexing="ij")
+        b1, b2, b3 = self.path.b1, self.path.b2, self.path.b3
+
+        G_k = (
+            b1[:, None] * P0.ravel(order="F")
+            + b2[:, None] * Q0.ravel(order="F")
+            + b3[:, None] * R0.ravel(order="F")
+        )
+
+        beta = self.path.betas.values
+        for col in range(beta.shape[1]):
+            k = beta[:, col, None] - G_k
+
+            KX = np.diag(k[0, :])
+            KY = np.diag(k[1, :])
+            KZ = np.diag(k[2, :])
+            K_V = np.vstack(
+                (
+                    np.hstack((0 * KX, -KZ, KY)),
+                    np.hstack((KZ, 0 * KY, -KX)),
+                    np.hstack((-KY, KX, 0 * KZ)),
+                )
+            )
+            A = K_V @ mu_rki @ K_V
+            B = eps_rk
+
+            D, V = eigh(A, B)
+
+            # The curl-curl operator has one longitudinal null mode per
+            # retained reciprocal vector. Drop those N zero eigenvalues;
+            # at Gamma the two physical zero-frequency modes remain.
+            n_harmonics = KX.shape[0]
+            D = D[:-n_harmonics]
+            V = V[:, :-n_harmonics]
+
+            # eigh returns the negative eigenvalues from most negative to
+            # least negative, so reverse to report frequencies low to high.
+            self.wn.append(np.sqrt(np.maximum(-D, 0))[::-1])
+            self.modes.append(V[:, ::-1])
+
+
+def Solver(geometry, path, *args, **kwargs) -> Union[Solver1D, Solver2D, Solver3D]:
+    """Solver factory."""
+    dim_obj = {1: Solver1D, 2: Solver2D, 3: Solver3D}
+    return dim_obj[path.dim](geometry, path, *args, **kwargs)

morpho_py-0.1.0/morpho/utils.py

@@ -0,0 +1,58 @@
+"""This module implements utilities."""
+
+import numpy as np
+
+
+def harmonic_indices(count: int) -> np.ndarray:
+    """Return ``count`` integer harmonics centered as closely as possible at 0.
+
+    For an even count, the integer range is necessarily asymmetric; this
+    convention keeps zero and the negative Nyquist-side harmonic.
+    """
+    if count < 1:
+        raise ValueError("The number of harmonics must be positive.")
+    return np.arange(-(count // 2), (count + 1) // 2)
+
+
+def convmat(A: np.ndarray, P: int = 1, Q: int = 1, R: int = 1):
+    """Return a permittivity/permeability convolution matrix.
+
+    Parameters
+    ----------
+    A : np.ndarray
+        A 3D/2D/1D permittivity or permeability matrix.
+    P : int
+        Number of terms in the direction of the reciprocal vector T1.
+    Q : int
+        Number of terms in the direction of the reciprocal vector T2.
+    R : int
+        Number of terms in the direction of the reciprocal vector T3.
+    """
+    NH = P * Q * R
+    A = np.asarray(A)
+    if A.ndim == 1:
+        A = A[:, None, None]
+    elif A.ndim == 2:
+        A = A[:, :, None]
+    elif A.ndim != 3:
+        raise ValueError("A must have one, two, or three dimensions.")
+    N1, N2, N3 = A.shape
+
+    p = harmonic_indices(P)
+    q = harmonic_indices(Q)
+    r = harmonic_indices(R)
+
+    A = np.fft.fftshift(np.fft.fftn(A) / A.size)
+
+    p_0, q_0, r_0 = N1 // 2, N2 // 2, N3 // 2
+
+    p_, q_, r_ = np.meshgrid(p, q, r, indexing="ij")
+    rr_, cc_ = np.mgrid[0:NH, 0:NH]
+    rr_i = np.unravel_index(rr_, p_.shape, order="F")
+    cc_i = np.unravel_index(cc_, p_.shape, order="F")
+
+    p_fft_ = p_[rr_i] - p_[cc_i] + p_0
+    q_fft_ = q_[rr_i] - q_[cc_i] + q_0
+    r_fft_ = r_[rr_i] - r_[cc_i] + r_0
+
+    return A[p_fft_, q_fft_, r_fft_]

morpho_py-0.1.0/pyproject.toml

@@ -0,0 +1,64 @@
+[project]
+name = "morpho.py"
+version = "0.1.0"
+description = "PWE framework for photonic crystal analysis"
+license = "MIT"
+authors = [{name = "Tiago Vilela", email = "tiagovla@gmail.com"}]
+requires-python = ">=3.9,<3.16"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
+]
+dependencies = [
+    "numpy>=1.20.1,<3.0.0",
+    "scipy>=1.6.2,<2.0.0",
+    "matplotlib>=3.4.3,<4.0.0",
+]
+
+[project.optional-dependencies]
+docs = [
+    "mkdocs>=1.6.1,<2",
+    "mkdocs-material>=9.7.7",
+    "mkdocstrings[python]>=0.24.0",
+]
+
+[tool.poetry]
+packages = [
+    {include = "morpho", from = "."}
+]
+
+[dependency-groups]
+dev = [
+    "black==24.8.0",
+    "pre-commit>=3.8.0,<4.0.0",
+    "pytest>=5.2",
+    "ruff==0.16.10",
+    "mkdocs>=1.6.1,<2",
+    "mkdocs-material>=9.7.7",
+    "mkdocstrings[python]>=0.24.0",
+]
+
+[tool.uv]
+package = true
+
+[build-system]
+requires = ["poetry-core>=2.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.black]
+line-length = 88
+target-version = ["py39"]
+
+[tool.ruff]
+line-length = 88
+target-version = "py39"
+
+[tool.ruff.lint]
+select = ["E4", "E7", "E9", "F"]
+

morpho.py-0.0.3/PKG-INFO

@@ -1,13 +0,0 @@
-Metadata-Version: 2.1
-Name: morpho.py
-Version: 0.0.3
-Summary: 
-Author: Tiago Vilela
-Author-email: tiagovla@gmail.com
-Requires-Python: >=3.8,<4.0
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
-Requires-Dist: matplotlib (>=3.3.4,<4.0.0)
-Requires-Dist: numpy (>=1.20.1,<2.0.0)
-Requires-Dist: scipy (>=1.6.1,<2.0.0)

morpho.py-0.0.3/morpho/__init__.py

@@ -1,5 +0,0 @@
-__version__ = "0.0.3"
-
-from morpho.brillouinzone import BrillouinZonePath, SymmetryPoint
-from morpho.geometry import Geometry
-from morpho.solver import Solver

morpho.py-0.0.3/morpho/brillouinzone.py

@@ -1,80 +0,0 @@
-"""This module implements classes related to the brillouinzone."""
-
-from typing import List, Optional, Tuple
-
-import numpy as np
-from numpy.linalg import norm
-
-
-class SymmetryPoint:
-    """Model of a symmetry point at the brillouinzone."""
-
-    def __init__(self, point: Tuple[float, ...], name: str):
-        """Initialize a SymmetryPoint."""
-        self.point = np.array(point)
-        self.name = name
-
-
-class BrillouinZonePath:
-    """Model of a path at the brillouinzone."""
-
-    def __init__(
-        self,
-        path: List[SymmetryPoint],
-        t1: Tuple[float, ...],
-        t2: Optional[Tuple[float, ...]] = None,
-        t3: Optional[Tuple[float, ...]] = None,
-        n_points: int = 5,
-    ):
-        """Initialize a BrillouinZonePath."""
-        self.path_points = path
-        self.n_points = n_points
-
-        self.dim = len(t1)
-
-        self._t1 = np.pad(np.array(t1), (0, 3 - len(t1)), "constant")
-        self._t2 = (np.pad(np.array(t2), (0, 3 - len(t2)), "constant")
-                    if t2 else np.array([0, 1, 0]))
-        self._t3 = (np.pad(np.array(t3), (0, 3 - len(t1)), "constant")
-                    if t3 else np.array([0, 0, 1]))
-
-        self._T1 = (2 * np.pi * np.cross(self._t2, self._t3) /
-                    np.dot(self._t1, np.cross(self._t2, self._t3)))
-        self._T2 = (2 * np.pi * np.cross(self._t3, self._t1) /
-                    np.dot(self._t1, np.cross(self._t2, self._t3)))
-        self._T3 = (2 * np.pi * np.cross(self._t1, self._t2) /
-                    np.dot(self._t1, np.cross(self._t2, self._t3)))
-
-        self.beta_vec = None
-        self.beta_vec_len = None
-        self.symmetry_names = None
-        self.symmetry_locations = None
-        self._calculate_beta()
-
-    def _calculate_beta(self):
-        beta_path = np.stack(
-            [
-                np.pad(p.point, (0, 3 - len(p.point)), "constant")
-                for p in self.path_points
-            ],
-            axis=1,
-        )
-        beta_path = (beta_path[0, :] * self._T1[:, None] +
-                     beta_path[1, :] * self._T2[:, None] +
-                     beta_path[2, :] * self._T3[:, None])
-
-        beta_len = np.cumsum(
-            norm(np.diff(beta_path, axis=1)[:self.dim], axis=0))
-        beta_len = np.pad(beta_len, (1, 0), "constant")
-        beta_len_interp = np.linspace(0, beta_len[-1], self.n_points)
-        beta_ix = np.interp(beta_len_interp, beta_len,
-                            beta_path[0, :].flatten())
-        beta_iy = np.interp(beta_len_interp, beta_len,
-                            beta_path[1, :].flatten())
-        beta_iz = np.interp(beta_len_interp, beta_len,
-                            beta_path[2, :].flatten())
-
-        self.beta_vec = np.vstack((beta_ix, beta_iy, beta_iz))[:self.dim, :]
-        self.beta_vec_len = beta_len_interp
-        self.symmetry_names = [p.name for p in self.path_points]
-        self.symmetry_locations = beta_len

morpho.py-0.0.3/morpho/geometry.py

@@ -1,69 +0,0 @@
-"""Implement photonic crystal geometries."""
-
-from typing import Callable, Optional, Tuple
-
-import matplotlib.pyplot as plt
-import numpy as np
-
-
-class Geometry:
-    """Geometry class."""
-
-    def __init__(
-        self,
-        t1: Tuple[float, float, float],
-        t2: Tuple[float, float, float],
-        t3: Tuple[float, float, float],
-        Nx: int = 32,
-        Ny: int = 32,
-        Nz: int = 32,
-        eps_r: Optional[np.ndarray] = None,
-        mu_r: Optional[np.ndarray] = None,
-    ):
-        """Initialize the geometry obj."""
-        self.t1 = np.array(t1).reshape(-1, 1)
-        self.t2 = np.array(t2).reshape(-1, 1)
-        self.t3 = np.array(t3).reshape(-1, 1)
-
-        self.T1 = (2 * np.pi * np.cross(self.t2, self.t3, axis=0) /
-                   np.dot(t1, np.cross(self.t2, self.t3, axis=0)))
-        self.T2 = (2 * np.pi * np.cross(self.t3, self.t1, axis=0) /
-                   np.dot(t1, np.cross(self.t2, self.t3, axis=0)))
-        self.T3 = (2 * np.pi * np.cross(self.t1, self.t2, axis=0) /
-                   np.dot(t1, np.cross(self.t2, self.t3, axis=0)))
-
-        self.eps_r = eps_r or np.ones((Nx, Ny, Nz), dtype=complex)
-        self.mu_r = mu_r or np.ones((Nx, Ny, Nz), dtype=complex)
-
-        P0, Q0, R0 = np.meshgrid(
-            np.linspace(-0.5, 0.5, Nx),
-            np.linspace(-0.5, 0.5, Ny),
-            np.linspace(-0.5, 0.5, Nz),
-        )
-        self.x = P0 * self.t1[0] + Q0 * self.t2[0] + R0 * self.t3[0]
-        self.y = P0 * self.t1[1] + Q0 * self.t2[1] + R0 * self.t3[1]
-        self.z = P0 * self.t1[2] + Q0 * self.t2[2] + R0 * self.t3[2]
-
-        self.epsr_f: Optional[Callable] = None
-        self.mur_f: Optional[Callable] = None
-
-    def setup(self):
-        """Set the material properties."""
-        if self.epsr_f:
-            self.epsr_f()
-        if self.mur_f:
-            self.mur_f()
-
-    def plot(self):
-        """Plot ep_s and mu_r."""
-        raise NotImplementedError
-
-    def set_epsr_f(self, func: Callable):
-        """Set decorator to set a eps_r profile."""
-        self.epsr_f = func
-        return func
-
-    def set_mur_f(self, func: Callable):
-        """Set decorator to set a mu_r profile."""
-        self.mur_f = func
-        return func

morpho.py-0.0.3/morpho/solver.py

@@ -1,86 +0,0 @@
-
-"""Implement the solver."""
-
-from typing import List
-
-import matplotlib.pyplot as plt
-import numpy as np
-from scipy.linalg import eigh
-
-from .brillouinzone import BrillouinZonePath as BZPath
-from .geometry import Geometry
-from .utils import convmat
-
-
-class Solver:
-    """Implement the PWE solver."""
-
-    def __init__(self,
-                 geometry: Geometry,
-                 path: BZPath,
-                 P: int = 1,
-                 Q: int = 1,
-                 R: int = 1):
-        """Initialize the PWE Solver."""
-        self.geo = geometry
-        self.path = path
-        self.P, self.Q, self.R = P, Q, R
-        self.eps_rc: np.ndarray
-        self.mu_rc: np.ndarray
-
-        self.wn: List[np.ndarray] = []
-        self.modes: List[np.ndarray] = []
-
-    def run(self):
-        """Run the simulation."""
-        self.geo.setup()
-        self.eps_rc = convmat(self.geo.eps_r, self.P, self.Q, self.R)
-        self.mu_rc = convmat(self.geo.mu_r, self.P, self.Q, self.R)
-
-        eps_rk = np.kron(np.eye(3), self.eps_rc)
-        # mu_rk = np.kron(np.eye(3), self.eps_rc)
-        # epsr_ki = np.kron(np.eye(3), np.linalg.inv(self.eps_rc))
-        mu_rki = np.kron(np.eye(3), np.linalg.inv(self.mu_rc))
-
-        p = np.arange(-(self.P // 2), self.P // 2 + 1)
-        q = np.arange(-(self.Q // 2), self.Q // 2 + 1)
-        r = np.arange(-(self.R // 2), self.R // 2 + 1)
-
-        P0, Q0, R0 = np.meshgrid(p, q, r)
-        T1, T2, T3 = self.geo.T1, self.geo.T2, self.geo.T3
-
-        G_k = T1 * P0.flatten() + T2 * Q0.flatten() + T3 * R0.flatten()
-        beta = self.path.beta_vec
-        for col in range(beta.shape[1]):
-            k = beta[:, col, None] - G_k
-
-            KX = np.diag(k[0, :])
-            KY = np.diag(k[1, :])
-            KZ = np.diag(k[2, :])
-            K_V = np.vstack((
-                np.hstack((0 * KX, -KZ, KY)),
-                np.hstack((KZ, 0 * KY, -KX)),
-                np.hstack((-KY, KX, 0 * KZ)),
-            ))
-            A = K_V @ mu_rki @ K_V
-            B = eps_rk
-
-            D, V = eigh(A, B)
-
-            self.wn.append(np.sqrt(-np.minimum(D, 0)))
-            self.modes.append(V)
-
-    def plot_bands(self):
-        """Plot a bandgap diagram."""
-        beta_len = self.path.beta_vec_len
-        wn = np.vstack([d for d in self.wn])
-        fig, ax = plt.subplots()
-        ax.plot(beta_len, wn / (2 * np.pi), "k-")
-        ax.set_xticklabels(self.path.symmetry_names)
-        ax.set_xticks(self.path.symmetry_locations)
-        ax.set_xlim(0, self.path.symmetry_locations[-1])
-        ax.set_ylim(0, 2)
-        ax.set_xlabel("Bloch Wave Vector $\\beta$")
-        ax.set_ylabel("Frequency [$\\frac{a \\omega}{2\\pi c}$]")
-        ax.grid(True)
-        plt.show()

morpho.py-0.0.3/morpho/utils.py

@@ -1,39 +0,0 @@
-"""This module implements utilities."""
-import matplotlib.pyplot as plt
-import numpy as np
-
-
-def convmat(A: np.ndarray, P: int = 1, Q: int = 1, R: int = 1):
-    """Create a convolution matrix."""
-    NH = P * Q * R
-    Nx, Ny, Nz = A.shape
-
-    p = np.arange(-(P // 2), P//2 + 1)
-    q = np.arange(-(Q // 2), Q//2 + 1)
-    r = np.arange(-(R // 2), R//2 + 1)
-
-    A = np.fft.fftshift(np.fft.fftn(A) / (Nx*Ny*Nz))
-
-    p_0 = Nx // 2
-    q_0 = Ny // 2
-    r_0 = Nz // 2
-
-    C = np.zeros((NH, NH), dtype=complex)
-
-    for r_row in range(R):
-        for q_row in range(Q):
-            for p_row in range(P):
-                row = r_row*Q*P + q_row*P + p_row
-
-                for r_col in range(R):
-                    for q_col in range(Q):
-                        for p_col in range(P):
-                            col = r_col*Q*P + q_col*P + p_col
-
-                            p_fft = p[p_row] - p[p_col]
-                            q_fft = q[q_row] - q[q_col]
-                            r_fft = r[r_row] - r[r_col]
-
-                            C[row, col] = A[p_0 + p_fft, q_0 + q_fft,
-                                            r_0 + r_fft]
-    return C

morpho.py-0.0.3/pyproject.toml

@@ -1,25 +0,0 @@
-[tool.poetry]
-name = "morpho.py"
-version = "0.0.3"
-description = ""
-authors = ["Tiago Vilela <tiagovla@gmail.com>"]
-
-packages = [
-    {include = "morpho", from="."}
-]
-
-[tool.poetry.dependencies]
-python = "^3.8"
-numpy = "^1.20.1"
-matplotlib = "^3.3.4"
-scipy = "^1.6.1"
-
-[tool.poetry.dev-dependencies]
-pytest = "^5.2"
-Sphinx = "^3.5.1"
-sphinx-rtd-theme = "^0.5.1"
-sphinx-autodoc-typehints = "^1.11.1"
-
-[build-system]
-requires = ["poetry-core>=1.0.0"]
-build-backend = "poetry.core.masonry.api"

morpho.py-0.0.3/setup.py

@@ -1,34 +0,0 @@
-# -*- coding: utf-8 -*-
-from setuptools import setup
-
-package_dir = \
-{'': '.'}
-
-packages = \
-['morpho']
-
-package_data = \
-{'': ['*']}
-
-install_requires = \
-['matplotlib>=3.3.4,<4.0.0', 'numpy>=1.20.1,<2.0.0', 'scipy>=1.6.1,<2.0.0']
-
-setup_kwargs = {
-    'name': 'morpho.py',
-    'version': '0.0.3',
-    'description': '',
-    'long_description': None,
-    'author': 'Tiago Vilela',
-    'author_email': 'tiagovla@gmail.com',
-    'maintainer': None,
-    'maintainer_email': None,
-    'url': None,
-    'package_dir': package_dir,
-    'packages': packages,
-    'package_data': package_data,
-    'install_requires': install_requires,
-    'python_requires': '>=3.8,<4.0',
-}
-
-
-setup(**setup_kwargs)