morpho.py 0.0.4__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.0.4 → morpho_py-0.1.0}/morpho/geometry.py

@@ -26,7 +26,7 @@ class GeometryBase(ABC):
         func : Callable
             func
         """
-        if func.__name__ in ['eps_rf', 'mu_rf']:
+        if func.__name__ in ["eps_rf", "mu_rf"]:
             setattr(self, func.__name__, func)
         else:
             raise Exception("Can only overwrite eps_rf or mu_rf.")
@@ -47,24 +47,40 @@ class Geometry1D(GeometryBase):
         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):
+    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)
+        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.linspace(-0.5, 0.5, self.n1)
+        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.
@@ -85,13 +101,15 @@ class Geometry2D(GeometryBase):
         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):
+    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)
@@ -104,8 +122,9 @@ class Geometry2D(GeometryBase):
     def X(self) -> CartesianVectors2D:
         """Return cartesian positions."""
         P0, Q0 = np.meshgrid(
-            np.linspace(-0.5, 0.5, self.n1),
-            np.linspace(-0.5, 0.5, self.n2),
+            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]
@@ -124,7 +143,7 @@ class Geometry2D(GeometryBase):
     def mu_r(self) -> np.ndarray:
         """Return the relative permeabillity matrice."""
         if self.mu_rf:
-            self.mu_rf(eps_r=self._eps_r, x=self.X.x, y=self.X.y)
+            self.mu_rf(self._mu_r, x=self.X.x, y=self.X.y)
         return self._mu_r
 
 
@@ -151,15 +170,17 @@ class Geometry3D(GeometryBase):
         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):
+    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)
@@ -174,9 +195,10 @@ class Geometry3D(GeometryBase):
     def X(self) -> CartesianVectors3D:
         """Return cartesian positions."""
         P0, Q0, R0 = np.meshgrid(
-            np.linspace(-0.5, 0.5, self.n1),
-            np.linspace(-0.5, 0.5, self.n2),
-            np.linspace(-0.5, 0.5, self.n3),
+            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]
@@ -196,7 +218,7 @@ class Geometry3D(GeometryBase):
     def mu_r(self) -> np.ndarray:
         """Return the relative permeabillity matrice."""
         if self.mu_rf:
-            self.mu_rf(eps_r=self._eps_r, x=self.X.x, y=self.X.y, z=self.X.z)
+            self.mu_rf(self._mu_r, x=self.X.x, y=self.X.y, z=self.X.z)
         return self._mu_r
 
 

{morpho.py-0.0.4 → morpho_py-0.1.0}/morpho/solver.py

@@ -9,7 +9,7 @@ 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
+from .utils import convmat, harmonic_indices
 
 
 class Solver1D:
@@ -25,11 +25,9 @@ class Solver1D:
         Number of terms in the direction of the reciprocal vector b1.
     """
 
-    def __init__(self,
-                 geometry: Geometry1D,
-                 path: BZPath1D,
-                 P: int = 1,
-                 pol: str = "TM"):
+    def __init__(
+        self, geometry: Geometry1D, path: BZPath1D, P: int = 1, pol: str = "TM"
+    ):
         """Initialize the PWE Solver."""
         self.geo = geometry
         self.path = path
@@ -43,7 +41,29 @@ class Solver1D:
 
     def run(self):
         """Calculate the eigen-wavenumbers and modes."""
-        raise NotImplementedError
+        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:
@@ -61,12 +81,14 @@ class Solver2D:
         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"):
+    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
@@ -83,16 +105,20 @@ class Solver2D:
         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 = np.linalg.inv(self.mu_rc)
-        eps_rci = np.linalg.inv(self.eps_rc)
+        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 = np.arange(-(self.P // 2), self.P // 2 + 1)
-        q = np.arange(-(self.Q // 2), self.Q // 2 + 1)
+        p = harmonic_indices(self.P)
+        q = harmonic_indices(self.Q)
 
-        P0, Q0 = np.meshgrid(p, q)
+        P0, Q0 = np.meshgrid(p, q, indexing="ij")
         b1, b2 = self.path.b1, self.path.b2
 
-        G_k = P0.flatten() * b1[:, None] + Q0.flatten() * b2[:, None]
+        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]):
@@ -102,10 +128,10 @@ class Solver2D:
             KY = np.diag(k[1, :])
 
             if self.pol == "TM":
-                A = KX@mu_rci@KX + KY@mu_rci@KY
+                A = KX @ mu_rci @ KX + KY @ mu_rci @ KY
                 B = self.eps_rc
             else:
-                A = KX@eps_rci@KX + KY@eps_rci@KY
+                A = KX @ eps_rci @ KX + KY @ eps_rci @ KY
                 B = self.mu_rc
 
             D, V = eigh(A, B)
@@ -131,12 +157,9 @@ class Solver3D:
         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):
+    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
@@ -153,17 +176,21 @@ class Solver3D:
         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_rki = np.kron(np.eye(3), np.linalg.inv(self.mu_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 = 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)
+        p = harmonic_indices(self.P)
+        q = harmonic_indices(self.Q)
+        r = harmonic_indices(self.R)
 
-        P0, Q0, R0 = np.meshgrid(p, q, 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.flatten() + b2[:, None] * Q0.flatten() +
-               b3[:, None] * R0.flatten())
+        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]):
@@ -172,22 +199,32 @@ class Solver3D:
             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)),
-            ))
+            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)
+            # 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]:
+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.0.4 → morpho_py-0.1.0}/morpho/utils.py

@@ -1,7 +1,19 @@
 """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.
 
@@ -17,12 +29,18 @@ def convmat(A: np.ndarray, P: int = 1, Q: int = 1, R: int = 1):
         Number of terms in the direction of the reciprocal vector T3.
     """
     NH = P * Q * R
-    A = np.atleast_3d(A)
+    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 = np.arange(-(P // 2), P//2 + 1)
-    q = np.arange(-(Q // 2), Q//2 + 1)
-    r = np.arange(-(R // 2), R//2 + 1)
+    p = harmonic_indices(P)
+    q = harmonic_indices(Q)
+    r = harmonic_indices(R)
 
     A = np.fft.fftshift(np.fft.fftn(A) / A.size)
 

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.4/PKG-INFO

@@ -1,15 +0,0 @@
-Metadata-Version: 2.1
-Name: morpho.py
-Version: 0.0.4
-Summary: 
-License: MIT
-Author: Tiago Vilela
-Author-email: tiagovla@gmail.com
-Requires-Python: >=3.8,<4.0
-Classifier: License :: OSI Approved :: MIT License
-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.4/morpho/__init__.py

@@ -1,7 +0,0 @@
-__version__ = "0.0.4"
-
-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

morpho.py-0.0.4/morpho/brillouinzone.py

@@ -1,253 +0,0 @@
-"""This module implements classes related to the brillouinzone."""
-
-from abc import ABC, abstractproperty
-from dataclasses import dataclass
-from typing import List, 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'):
-        self.path_points = path
-        self.n_points = n_points
-        self.strat = strategy
-        self._path: np.ndarray
-
-    @abstractproperty
-    def betas(self) -> BlochVectors:
-        """Return bloch wave vectors."""
-
-    @staticmethod
-    def _interpolate_beta(beta_cs, path, n_points):
-        """Perform linear interpolation."""
-        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.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
-        Number of vectors.
-    strategy : str = 'linear'
-        Strategy to interpolate.
-    """
-
-    def __init__(self,
-                 a1: Tuple[float],
-                 path: List[SymmetryPoint],
-                 n_points: int = 50,
-                 strategy: str = 'linear'):
-        """Initialize a BrillouinZonePath."""
-        super().__init__(path, n_points, strategy)
-        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)
-        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
-        Number of vectors.
-    strategy : str = 'linear'
-        Strategy to interpolate.
-    """
-
-    def __init__(self,
-                 a1: Tuple[float, float],
-                 a2: Tuple[float, float],
-                 path: List[SymmetryPoint],
-                 n_points: int = 50,
-                 strategy: str = 'linear'):
-        """Initialize a BrillouinZonePath."""
-        super().__init__(path, n_points, strategy)
-        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)
-        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
-        Number of vectors.
-    strategy : str = 'linear'
-        Strategy to interpolate.
-    """
-
-    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'):
-        """Initialize a BrillouinZonePath."""
-        super().__init__(path, n_points, strategy)
-        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)
-        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.0.4/pyproject.toml

@@ -1,26 +0,0 @@
-[tool.poetry]
-name = "morpho.py"
-version = "0.0.4"
-description = ""
-license = "MIT"
-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.4/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.4',
-    '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)