LightWave2D 0.0.3__tar.gz → 0.0.4__tar.gz

lightwave2d-0.0.4/LightWave2D/VERSION

@@ -0,0 +1 @@
+0.0.4

lightwave2d-0.0.4/LightWave2D/components/__init__.py

@@ -0,0 +1,5 @@
+from .complex import Lense, Grating, RingResonator  # noqa: F401
+
+from .basic import Circle, Square, Ellipse, Triangle  # noqa: F401
+
+# -

{lightwave2d-0.0.3 → lightwave2d-0.0.4}/LightWave2D/components/base_class.py

@@ -2,15 +2,48 @@
 # -*- coding: utf-8 -*-
 
 from typing import NoReturn
-
+from pydantic.dataclasses import dataclass
 import numpy
 from LightWave2D.physics import Physics
 import matplotlib.pyplot as plt
 from matplotlib.patches import PathPatch
+import matplotlib as mpl
+import numpy as np
+from matplotlib.path import Path
+from matplotlib.collections import PatchCollection
+from LightWave2D.grid import Grid
+
+
+# Configuration dictionary for dataclasses
+config_dict = {
+    'kw_only': True,
+    'extra': 'forbid',
+    'slots': True,
+    'arbitrary_types_allowed': True
+}
 
 
+@dataclass(kw_only=True, config=config_dict)
 class BaseComponent():
+    """
+    Represents an elliptical scatterer in a simulation grid.
+
+    Attributes:
+        grid (Grid): The grid of the simulation mesh.
+        angle (float): Rotation angle of the ellipse.
+        facecolor (str): Color of the scatterer face.
+        edgecolor (str): Color of the scatterer edge.
+    """
+    grid: Grid
+    facecolor: str = 'lightblue'
+    edgecolor: str = 'blue'
+    alpha: float = 0.3
+    rotation: float = 0
+
     def __post_init__(self):
+        x0, y0 = self.position
+        self.coordinate = self.grid.get_coordinate(x=x0, y=y0)
+
         self.build_object()
 
     def build_object(self) -> NoReturn:
@@ -19,7 +52,11 @@ class BaseComponent():
         """
         self.epsilon_r_mesh = numpy.ones(self.grid.shape)  # Background permittivity
 
-        self.compute_path()
+        self.compute_polygon()
+
+        self.path = Path(self.polygon.exterior.coords)
+
+        self.path = self.path.transformed(mpl.transforms.Affine2D().rotate_around(self.coordinate.x, self.coordinate.y, self.rotation))
 
         x_mesh, y_mesh = numpy.meshgrid(self.grid.x_stamp, self.grid.y_stamp)
 
@@ -29,21 +66,23 @@ class BaseComponent():
 
         self.epsilon_r_mesh[self.idx] = self.epsilon_r
 
-    def add_to_ax(self, ax: plt.axis) -> NoReturn:
+    def add_to_ax(self, ax: plt.axis) -> PatchCollection:
         """
         Add the scatterer to the provided axis as a circle.
 
         Args:
             ax (Axis): The axis to which the scatterer will be added.
         """
-        patch = PathPatch(
-            self.path,
-            alpha=0.7,
-            color=self.facecolor,
-            label=str(self.__class__.__name__),
-        )
-
-        return ax.add_patch(patch)
+        path = Path.make_compound_path(
+            Path(np.asarray(self.polygon.exterior.coords)[:, :2]),
+            *[Path(np.asarray(ring.coords)[:, :2]) for ring in self.polygon.interiors])
+
+        patch = PathPatch(path, color=self.facecolor, edgecolor=self.edgecolor, alpha=0.4)
+        collection = PatchCollection([patch], color=self.facecolor, edgecolor=self.edgecolor, alpha=self.alpha)
+
+        ax.add_collection(collection, autolim=True)
+        ax.autoscale_view()
+        return collection
 
     def plot(self) -> NoReturn:
         figure, ax = plt.subplots(1, 1, figsize=(6, 6))

lightwave2d-0.0.4/LightWave2D/components/basic.py

@@ -0,0 +1,133 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from typing import Tuple, Union, NoReturn
+from pydantic.dataclasses import dataclass
+import numpy as np
+from LightWave2D.grid import Grid
+from LightWave2D.components.base_class import BaseComponent
+from matplotlib.path import Path
+import shapely.geometry as geo
+from matplotlib import patches
+from shapely.affinity import scale
+
+# Configuration dictionary for dataclasses
+config_dict = {
+    'kw_only': True,
+    'extra': 'forbid',
+    'slots': True,
+    'arbitrary_types_allowed': True
+}
+
+
+@dataclass(config=config_dict)
+class Square(BaseComponent):
+    """
+    Represents a square scatterer in a simulation grid.
+
+    Attributes:
+        position (Tuple[Union[float, str], Union[float, str]]): Starting position of the scatterer (center of the square).
+        epsilon_r (float): Relative permittivity inside the scatterer.
+        side_length (float): Side length of the square scatterer.
+    """
+    position: Tuple[Union[float, str], Union[float, str]]
+    epsilon_r: float
+    side_length: float
+
+    def compute_polygon(self) -> Path:
+        """
+        Compute the path of the square scatterer.
+        """
+        half_side = self.side_length / 2
+        x_start, x_end = self.coordinate.x - half_side, self.coordinate.x + half_side
+        y_start, y_end = self.coordinate.y - half_side, self.coordinate.y + half_side
+
+        self.polygon = geo.Polygon([
+            (x_start, y_start),
+            (x_start, y_end),
+            (x_end, y_end),
+            (x_end, y_start)
+        ])
+
+
+@dataclass(config=config_dict)
+class Circle(BaseComponent):
+    """
+    Represents a circular scatterer in a simulation grid.
+
+    Attributes:
+        position (Tuple[Union[float, str], Union[float, str]]): Starting position of the scatterer.
+        epsilon_r (float): Relative permittivity inside the scatterer.
+        radius (float): Radius of the scatterer.
+    """
+    position: Tuple[Union[float, str], Union[float, str]]
+    epsilon_r: float
+    radius: float
+
+    def compute_polygon(self) -> Path:
+        """
+        Compute the path of the circular scatterer.
+        """
+        self.polygon = geo.Point(self.coordinate.x, self.coordinate.y).buffer(self.radius)
+
+
+@dataclass(config=config_dict)
+class Triangle(BaseComponent):
+    """
+    Represents a triangular scatterer in a simulation grid.
+
+    Attributes:
+        position (Tuple[Union[float, str], Union[float, str]]): Starting position of the scatterer (center of the triangle).
+        epsilon_r (float): Relative permittivity inside the scatterer.
+        side_length (float): Side length of the triangle.
+    """
+    position: Tuple[Union[float, str], Union[float, str]]
+    epsilon_r: float
+    side_length: float
+
+    def compute_polygon(self) -> NoReturn:
+        """
+        Compute the path of the triangular scatterer.
+        """
+        height = (np.sqrt(3) / 2) * self.side_length
+
+        # Vertices of an equilateral triangle centered at (coordinate.x, coordinate.y)
+        p0 = (self.coordinate.x - self.side_length / 2, self.coordinate.y - height / 3)
+        p1 = (self.coordinate.x + self.side_length / 2, self.coordinate.y - height / 3)
+        p2 = (self.coordinate.x, self.coordinate.y + 2 * height / 3)
+
+        self.polygon = geo.Polygon([p0, p1, p2])
+
+
+@dataclass(config=config_dict)
+class Ellipse(BaseComponent):
+    """
+    Represents an elliptical scatterer in a simulation grid.
+
+    Attributes:
+        position (Tuple[Union[float, str], Union[float, str]]): Starting position of the scatterer.
+        width (float): Width of the ellipse.
+        height (float): Height of the ellipse.
+        epsilon_r (float): Relative permittivity inside the scatterer.
+        resolution (float): Resolution of the ellipse.
+    """
+    position: Tuple[Union[float, str], Union[float, str]]
+    width: float
+    height: float
+    epsilon_r: float
+    resolution: float = 100
+
+    def compute_polygon(self) -> Path:
+        """
+        Compute the path of the elliptical scatterer.
+        """
+        ellipse_patch = patches.Ellipse(
+            (self.coordinate.x, self.coordinate.y),
+            width=self.resolution,
+            height=self.resolution * self.height / self.width,
+        )
+
+        vertices = ellipse_patch.get_verts()
+        polygon = geo.Polygon(vertices)
+
+        self.polygon = scale(polygon, xfact=self.width / self.resolution, yfact=self.width / self.resolution)

lightwave2d-0.0.4/LightWave2D/components/complex.py

@@ -0,0 +1,105 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from typing import Tuple, Union, NoReturn
+from pydantic.dataclasses import dataclass
+from LightWave2D.grid import Grid
+from LightWave2D.components.base_class import BaseComponent
+from matplotlib.path import Path
+import shapely.geometry as geo
+
+# Configuration dictionary for dataclasses
+config_dict = {
+    'kw_only': True,
+    'extra': 'forbid',
+    'slots': True,
+    'arbitrary_types_allowed': True
+}
+
+
+@dataclass(config=config_dict)
+class Grating(BaseComponent):
+    """
+    Represents a grating in a simulation grid.
+
+    Attributes:
+        position (Tuple[Union[float, str], Union[float, str]]): Starting position of the grating.
+        epsilon_r (float): Relative permittivity inside the grating.
+        period (float): Period of the grating.
+        duty_cycle (float): Duty cycle of the grating (fraction of period occupied by the grating material).
+        num_periods (int): Number of grating periods.
+    """
+    position: Tuple[Union[float, str], Union[float, str]]
+    epsilon_r: float
+    period: float
+    duty_cycle: float
+    num_periods: int
+
+    def compute_polygon(self) -> NoReturn:
+        """
+        Compute the path of the grating.
+        """
+        bars = []
+        for i in range(self.num_periods):
+            x_start = self.coordinate.x + i * self.period
+            x_end = x_start + self.duty_cycle * self.period
+            bar = geo.box(x_start, self.coordinate.y - 0.5, x_end, self.coordinate.y + 0.5)
+            bars.append(bar)
+
+        self.polygon = geo.MultiPolygon(bars)
+
+
+@dataclass(config=config_dict)
+class RingResonator(BaseComponent):
+    """
+    Represents a ring resonator in a simulation grid.
+
+    Attributes:
+        position (Tuple[Union[float, str], Union[float, str]]): Starting position of the resonator (center of the ring).
+        epsilon_r (float): Relative permittivity inside the resonator.
+        inner_radius (float): Inner radius of the ring.
+        width (float): Outer radius of the ring.
+    """
+    grid: Grid
+    position: Tuple[Union[float, str], Union[float, str]]
+    epsilon_r: float
+    inner_radius: float
+    width: float
+
+    def compute_polygon(self) -> Path:
+        """
+        Compute the path of the ring resonator.
+        """
+        inner_circle = geo.Point(self.coordinate.x, self.coordinate.y).buffer(self.inner_radius)
+        outer_circle = geo.Point(self.coordinate.x, self.coordinate.y).buffer(self.inner_radius + self.width)
+        self.polygon = outer_circle.difference(inner_circle)
+
+
+@dataclass(config=config_dict)
+class Lense(BaseComponent):
+    """
+    Represents a lens in a simulation grid.
+
+    Attributes:
+        position (Tuple[Union[float, str], Union[float, str]]): Starting position of the lens (center of the lens).
+        epsilon_r (float): Relative permittivity inside the lens.
+        radius (float): Radius of the lens.
+        curvature (float): Curvature of the lens (positive for convex, negative for concave).
+    """
+    position: Tuple[Union[float, str], Union[float, str]]
+    epsilon_r: float
+    width: float
+    curvature: float
+
+    def compute_polygon(self) -> Path:
+        """
+        Compute the path of the lens.
+        """
+        # Create two arcs for the lens shape
+        x0 = self.coordinate.x + self.curvature - self.width / 2
+        x1 = self.coordinate.x - self.curvature + self.width / 2
+
+        arc3 = geo.Point(x0, self.coordinate.y).buffer(self.curvature, resolution=100)
+        arc4 = geo.Point(x1, self.coordinate.y).buffer(self.curvature, resolution=100)
+
+        self.polygon = arc3.intersection(arc4)

{lightwave2d-0.0.3 → lightwave2d-0.0.4}/LightWave2D/detector.py

@@ -8,7 +8,6 @@ from LightWave2D.grid import Grid
 from MPSPlots.render2D import SceneList
 import shapely.geometry as geo
 from matplotlib.path import Path
-import cv2
 from pydantic.dataclasses import dataclass
 from LightWave2D.components.base_class import BaseComponent
 import matplotlib.pyplot as plt
@@ -21,7 +20,7 @@ config_dict = dict(
 )
 
 
-@dataclass(config=config_dict)
+@dataclass(kw_only=True, config=config_dict)
 class PointDetector(BaseComponent):
     """
     Represents a point detector within a simulation grid.
@@ -31,10 +30,8 @@ class PointDetector(BaseComponent):
         position (Tuple[float | str, float | str]): The (x, y) coordinates of the point detector on the grid.
         data (numpy.ndarray): The data collected by the detector over time.
     """
-    grid: Grid
     position: Union[Tuple[float | str, float | str]]
     data: numpy.ndarray = field(init=False)
-    facecolor: str = 'blue'
 
     def __post_init__(self):
         """
@@ -85,4 +82,4 @@ class PointDetector(BaseComponent):
             color=self.facecolor
         )
 
-
+# -

{lightwave2d-0.0.3 → lightwave2d-0.0.4}/LightWave2D/experiment.py

@@ -6,7 +6,8 @@ from typing import Tuple, NoReturn, Optional, Union
 import numpy
 from LightWave2D.physics import Physics
 from LightWave2D.grid import Grid
-from LightWave2D.components import Waveguide, Circle, Square, Ellipse
+from LightWave2D.components.basic import Circle, Square, Ellipse, Triangle
+from LightWave2D.components.complex import Lense, Grating, RingResonator
 from LightWave2D.source import PointSource, LineSource
 from LightWave2D.detector import PointDetector
 from LightWave2D.pml import PML
@@ -58,7 +59,7 @@ class Experiment:
             raise ValueError("Axis must be 'x' or 'y'.")
         return gradient
 
-    def plot(self, unit_size: int = 4, colormap: Optional[Union[str, object]] = 'Blues') -> NoReturn:
+    def plot(self, unit_size: int = 6, colormap: Optional[Union[str, object]] = 'Blues') -> NoReturn:
         """
         Generates a plot of the FDTD simulation setup using a specified colormap.
 
@@ -72,13 +73,7 @@ class Experiment:
         Returns:
             SceneList: A SceneList object that contains the constructed plot.
         """
-        figsize = int(unit_size), int(unit_size * self.grid.size_y / self.grid.size_x)
-        figure, ax = plt.subplots(1, 1, figsize=figsize)
-
-        ax.set_title('FDTD Simulation')
-        ax.set_xlabel(r'x position [$\mu$m]')
-        ax.set_xlabel(r'y position [$\mu$m]')
-        ax.set_aspect('equal')
+        figure, ax = self.get_figure_ax(unit_size=unit_size)
 
         # Add PML layers to the plot if present
         if self.pml:
@@ -134,9 +129,24 @@ class Experiment:
         return Square(grid=self.grid, **kwargs)
 
     @add_to_component
-    def add_waveguide(self, **kwargs) -> Waveguide:
+    def add_triangle(self, **kwargs) -> Square:
         """General method to add a component to the simulation."""
-        return Waveguide(grid=self.grid, **kwargs)
+        return Triangle(grid=self.grid, **kwargs)
+
+    @add_to_component
+    def add_lense(self, **kwargs) -> Square:
+        """General method to add a component to the simulation."""
+        return Lense(grid=self.grid, **kwargs)
+
+    @add_to_component
+    def add_grating(self, **kwargs) -> Square:
+        """General method to add a component to the simulation."""
+        return Grating(grid=self.grid, **kwargs)
+
+    @add_to_component
+    def add_ring_resonator(self, **kwargs) -> Square:
+        """General method to add a component to the simulation."""
+        return RingResonator(grid=self.grid, **kwargs)
 
     @add_to_source
     def add_point_source(self, **kwargs) -> PointSource:
@@ -227,7 +237,7 @@ class Experiment:
         for detector in self.detectors:
             detector.update_data(field=self.Ez_t)
 
-    def plot_frame(self, frame_number: int, unit_size: int = 4, colormap: Optional[Union[str, object]] = colormaps.polytechnique.blue_black_red) -> SceneList:
+    def plot_frame(self, frame_number: int, scale_max: float = 5, unit_size: int = 6, colormap: Optional[Union[str, object]] = colormaps.polytechnique.blue_black_red) -> SceneList:
         """
         Creates a plot of a specific frame from the FDTD simulation.
 
@@ -242,13 +252,7 @@ class Experiment:
         Returns:
             SceneList: A SceneList object that contains the constructed plot.
         """
-        figsize = int(unit_size), int(unit_size * self.grid.size_y / self.grid.size_x)
-        figure, ax = plt.subplots(1, 1, figsize=figsize)
-
-        ax.set_title('FDTD Simulation')
-        ax.set_xlabel(r'x position [$\mu$m]')
-        ax.set_xlabel(r'y position [$\mu$m]')
-        ax.set_aspect('equal')
+        figure, ax = self.get_figure_ax(unit_size=unit_size)
 
         image = ax.pcolormesh(
             self.grid.x_stamp,
@@ -262,13 +266,13 @@ class Experiment:
 
         vmin, vmax = image.get_clim()
 
-        max_diff = max(abs(vmin), abs(vmax))
+        max_diff = max(abs(vmin), abs(vmax)) / scale_max
 
         image.set_clim([-max_diff, max_diff])
 
         plt.show()
 
-    def save_frame_as_image(self, frame_number: int, filename: str, unit_size: int = 4, dpi: int = 200, colormap: Optional[Union[str, object]] = colormaps.polytechnique.blue_black_red) -> None:
+    def save_frame_as_image(self, frame_number: int, filename: str, scale_max: float = 5, unit_size: int = 6, dpi: int = 200, colormap: Optional[Union[str, object]] = colormaps.polytechnique.blue_black_red) -> None:
         """
         Saves a specific frame from the FDTD simulation as an image file at the specified resolution.
 
@@ -285,13 +289,7 @@ class Experiment:
         Returns:
             None: This method does not return any value, but saves an image file.
         """
-        figsize = int(unit_size), int(unit_size * self.grid.size_y / self.grid.size_x)
-        figure, ax = plt.subplots(1, 1, figsize=figsize)
-
-        ax.set_title('FDTD Simulation')
-        ax.set_xlabel(r'x position [$\mu$m]')
-        ax.set_xlabel(r'y position [$\mu$m]')
-        ax.set_aspect('equal')
+        figure, ax = self.get_figure_ax(unit_size=unit_size)
 
         image = ax.pcolormesh(
             self.grid.x_stamp,
@@ -305,13 +303,24 @@ class Experiment:
 
         vmin, vmax = image.get_clim()
 
-        max_diff = max(abs(vmin), abs(vmax))
+        max_diff = max(abs(vmin), abs(vmax)) / scale_max
 
         image.set_clim([-max_diff, max_diff])
 
         plt.savefig(filename, dpi=dpi)
 
-    def render_propagation(self, skip_frame: int = 10, unit_size: int = 4, colormap: Optional[Union[str, object]] = colormaps.blue_black_red) -> animation.FuncAnimation:
+    def get_figure_ax(self, unit_size: int = 6) -> Tuple:
+        figsize = int(unit_size), int(unit_size * self.grid.size_y / self.grid.size_x)
+        figure, ax = plt.subplots(1, 1, figsize=figsize)
+
+        ax.set_title('FDTD Simulation')
+        ax.set_xlabel(r'x position [$\mu$m]')
+        ax.set_ylabel(r'y position [$\mu$m]')
+        ax.set_aspect('equal')
+
+        return figure, ax
+
+    def render_propagation(self, skip_frame: int = 10, scale_max: float = 5, unit_size: int = 6, colormap: Optional[Union[str, object]] = colormaps.blue_black_red) -> animation.FuncAnimation:
         """
         Renders the propagation of a field as an animation using matplotlib.
 
@@ -326,13 +335,7 @@ class Experiment:
         Returns:
             animation.FuncAnimation: The animation object that can be displayed or saved.
         """
-        figsize = int(unit_size), int(unit_size * self.grid.size_y / self.grid.size_x)
-        figure, ax = plt.subplots(1, 1, figsize=figsize)
-
-        ax.set_title('FDTD Simulation')
-        ax.set_xlabel(r'x position [$\mu$m]')
-        ax.set_xlabel(r'y position [$\mu$m]')
-        ax.set_aspect('equal')
+        figure, ax = self.get_figure_ax(unit_size=unit_size)
 
         # Initialize the field display
         initial_field = numpy.zeros(self.Ez_t[0].shape).T
@@ -351,7 +354,7 @@ class Experiment:
             artist_list.append(component.add_to_ax(ax))
 
         # Set color limits based on the maximum field amplitude
-        max_amplitude = abs(self.Ez_t).max() / 2
+        max_amplitude = abs(self.Ez_t).max() / scale_max
         field_artist.set_clim(vmin=-max_amplitude, vmax=max_amplitude)
 
         def update(frame) -> list:

{lightwave2d-0.0.3 → lightwave2d-0.0.4}/LightWave2D/pml.py

@@ -58,7 +58,7 @@ class PML():
             label='PML'
         )
 
-    def plot(self, unit_size: int = 4) -> NoReturn:
+    def plot(self, unit_size: int = 6) -> NoReturn:
         figsize = int(unit_size), int(unit_size * self.grid.size_y / self.grid.size_x)
         figure, ax = plt.subplots(1, 1, figsize=figsize)