LightWave2D 0.0.3__tar.gz

lightwave2d-0.0.3/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020 Martin de Sivry
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

lightwave2d-0.0.3/LightWave2D/VERSION

@@ -0,0 +1 @@
+0.0.3

lightwave2d-0.0.3/LightWave2D/components/__init__.py

@@ -0,0 +1,4 @@
+from .scatterers import Waveguide, Circle, Square, Ellipse  # noqa: F401
+
+
+# -

lightwave2d-0.0.3/LightWave2D/components/base_class.py

@@ -0,0 +1,100 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from typing import NoReturn
+
+import numpy
+from LightWave2D.physics import Physics
+import matplotlib.pyplot as plt
+from matplotlib.patches import PathPatch
+
+
+class BaseComponent():
+    def __post_init__(self):
+        self.build_object()
+
+    def build_object(self) -> NoReturn:
+        """
+        Build the permittivity mesh for the square scatterer.
+        """
+        self.epsilon_r_mesh = numpy.ones(self.grid.shape)  # Background permittivity
+
+        self.compute_path()
+
+        x_mesh, y_mesh = numpy.meshgrid(self.grid.x_stamp, self.grid.y_stamp)
+
+        coordinates = numpy.c_[x_mesh.T.flatten(), y_mesh.T.flatten()]
+
+        self.idx = self.path.contains_points(coordinates).astype(bool).reshape(self.epsilon_r_mesh.shape)
+
+        self.epsilon_r_mesh[self.idx] = self.epsilon_r
+
+    def add_to_ax(self, ax: plt.axis) -> NoReturn:
+        """
+        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)
+
+    def plot(self) -> NoReturn:
+        figure, ax = plt.subplots(1, 1, figsize=(6, 6))
+        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')
+
+        self.add_to_ax(ax)
+        ax.autoscale_view()
+
+        plt.show()
+
+    def interpret_position_to_index(self) -> tuple:
+        """
+        Interprets and returns the value of positions x and y of the waveguide
+
+        :returns:   The index of width and height
+        :rtype:     int
+        """
+        x, y = self.position
+
+        if isinstance(x, str):
+            x_index = self.grid.string_to_index(x, axis='x')
+        else:
+            x_index = self.grid.position_to_index(x, axis='x')
+
+        if isinstance(y, str):
+            y_index = self.grid.string_to_index(y, axis='y')
+        else:
+            y_index = self.grid.position_to_index(y, axis='y')
+
+        return x_index, y_index
+
+    def interpret_position_to_position(self) -> tuple:
+        """
+        Interprets and returns the value of positions x and y of the waveguide
+
+        :returns:   The index of width and height
+        :rtype:     int
+        """
+        x, y = self.position
+
+        coordinate = self.grid.get_coordinate(x=x, y=y)
+
+        return coordinate.x, coordinate.y
+
+    def add_to_mesh(self, epsilon_r_mesh: numpy.ndarray) -> None:
+        epsilon_r_mesh += self.epsilon_r_mesh
+
+    def add_non_linear_effect_to_field(self, field: numpy.ndarray) -> None:
+        chi_2 = 1e10
+
+        field += self.idx * self.grid.dt**2 / (self.epsilon_r_mesh * Physics.epsilon_0 * Physics.mu_0) * chi_2 * field ** 2

lightwave2d-0.0.3/LightWave2D/components/scatterers.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from typing import Tuple, Union, NoReturn
+from pydantic.dataclasses import dataclass
+import numpy
+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
+
+
+config_dict = dict(
+    kw_only=True,
+    extra='forbid',
+    slots=True,
+    arbitrary_types_allowed=True
+)
+
+
+@dataclass(config=config_dict)
+class Waveguide(BaseComponent):
+    """
+    Represents a waveguide in a simulation grid.
+
+    Attributes:
+        grid (Grid): The grid of the simulation mesh.
+        width (int | str): Width of the waveguide in grid cells or 'full' for full width.
+        height (int | str): Height of the waveguide in grid cells or 'full' for full height.
+        position (tuple): Starting position of the waveguide.
+        epsilon_r (float): Relative permittivity inside the waveguide.
+    """
+    grid: Grid
+    width: Union[int | str]
+    height: Union[int | str]
+    position: Tuple[float | str, float | str]
+    epsilon_r: float
+    facecolor: str = 'lightblue'
+    edgecolor: str = 'blue'
+
+    def build_mesh(self) -> NoReturn:
+        """
+        Build the permittivity mesh for the waveguide.
+        """
+        width_index, height_index = self._interpret_width_height()
+        x_index, y_index = self._interpret_position_to_index()
+
+        x_start, x_end = x_index, x_index + width_index
+        y_start, y_end = y_index, y_index + height_index
+
+        self.epsilon_r_mesh[x_start:x_end, y_start:y_end] = self.epsilon_r
+
+    def _interpret_width_height(self) -> Tuple[float, float]:
+        """
+        Interpret and return the width and height of the waveguide in grid indices.
+
+        Returns:
+            tuple: The indices of the width and height.
+        """
+        if isinstance(self.width, str) and self.width.lower() == 'full':
+            width_index = self.grid.n_x
+        else:
+            width_index = self.grid.position_to_index(self.width, axis='x')
+
+        if isinstance(self.height, str) and self.height.lower() == 'full':
+            height_index = self.grid.n_y
+        else:
+            height_index = self.grid.position_to_index(self.height, axis='y')
+
+        return int(width_index), int(height_index)
+
+    def _interpret_position_to_index(self) -> Tuple[int, int]:
+        """
+        Interpret and return the indices for the positions x and y of the waveguide.
+
+        Returns:
+            tuple: The indices of the x and y positions.
+        """
+        x, y = self.position
+        x_index = self.grid.string_to_position_x(x) if isinstance(x, str) else self.grid.position_to_index(x, axis='x')
+        y_index = self.grid.string_to_position_y(y) if isinstance(y, str) else self.grid.position_to_index(y, axis='y')
+        return x_index, y_index
+
+
+@dataclass(config=config_dict)
+class Square(BaseComponent):
+    """
+    Represents a square scatterer in a simulation grid.
+
+    Attributes:
+        grid (Grid): The grid of the simulation mesh.
+        position (Tuple[float | str, 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.
+    """
+    grid: Grid
+    position: Tuple[float | str, float | str]
+    epsilon_r: float
+    side_length: float
+    facecolor: str = 'lightblue'
+    edgecolor: str = 'blue'
+
+    def compute_path(self) -> NoReturn:
+        x0, y0 = self.position
+        self.coordinate = self.grid.get_coordinate(x=x0, y=y0)
+
+        half_side = self.side_length / 2
+        self.x_start = (self.coordinate.x - half_side)
+        self.x_end = (self.coordinate.x + half_side)
+        self.y_start = (self.coordinate.y - half_side)
+        self.y_end = (self.coordinate.y + half_side)
+
+        p0 = geo.Point(self.x_start, self.y_start)
+        p1 = geo.Point(self.x_start, self.y_end)
+        p2 = geo.Point(self.x_end, self.y_start)
+        p3 = geo.Point(self.x_end, self.y_end)
+
+        self.polygon = geo.Polygon([p0, p1, p3, p2])
+
+        self.path = Path(numpy.array(self.polygon.exterior.coords))
+
+
+@dataclass(config=config_dict)
+class Circle(BaseComponent):
+    """
+    Represents a scatterer in a simulation grid.
+
+    Attributes:
+        grid (Grid): The grid of the simulation mesh.
+        position (Tuple[float | str, float | str]): Starting position of the scatterer.
+        epsilon_r (float): Relative permittivity inside the scatterer.
+        radius (float): Radius of the scatterer.
+    """
+    grid: Grid
+    position: Tuple[float | str, float | str]
+    epsilon_r: float
+    radius: float
+    facecolor: str = 'lightblue'
+
+    def compute_path(self) -> NoReturn:
+        x0, y0 = self.position
+        self.coordinate = self.grid.get_coordinate(x=x0, y=y0)
+        self.polygon = geo.Point(self.coordinate.x, self.coordinate.y).buffer(self.radius)
+        self.path = Path(numpy.array(self.polygon.exterior.coords))
+
+
+@dataclass(config=config_dict)
+class Ellipse(BaseComponent):
+    """
+    Represents a scatterer in a simulation grid.
+
+    Attributes:
+        grid (Grid): The grid of the simulation mesh.
+        position (Tuple[float | str, float | str]): Starting position of the scatterer.
+        epsilon_r (float): Relative permittivity inside the scatterer.
+        width (float):
+        height (float):
+        angle (float):
+    """
+    grid: Grid
+    position: Tuple[float | str, float | str]
+    width: float
+    height: float
+    epsilon_r: float
+    angle: float = 0
+    facecolor: str = 'lightblue'
+    edgecolor: str = 'blue'
+
+    def compute_path(self) -> NoReturn:
+        x0, y0 = self.position
+        self.coordinate = self.grid.get_coordinate(x=x0, y=y0)
+
+        polygon = patches.Ellipse(
+            (self.coordinate.x, self.coordinate.y),
+            width=self.width,
+            height=self.height,
+            angle=self.angle
+        )
+
+        vertices = polygon.get_verts()
+        self.polygon = geo.Polygon(vertices)
+        self.path = Path(numpy.array(self.polygon.exterior.coords))
+
+# -

lightwave2d-0.0.3/LightWave2D/detector.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from typing import Tuple, Union, NoReturn
+from dataclasses import field
+import numpy
+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
+
+config_dict = dict(
+    kw_only=True,
+    slots=True,
+    extra='forbid',
+    arbitrary_types_allowed=True
+)
+
+
+@dataclass(config=config_dict)
+class PointDetector(BaseComponent):
+    """
+    Represents a point detector within a simulation grid.
+
+    Attributes:
+        grid (Grid): The simulation mesh grid.
+        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):
+        """
+        Initialize the PointDetector by converting the given position into
+        grid coordinates and initializing the data array.
+        """
+        x, y = self.position
+
+        self.p0 = self.grid.get_coordinate(x=x, y=y)
+
+        self.polygon = geo.Point(self.p0.x, self.p0.y)
+
+        self.path = Path(self.polygon.coords)
+
+        self.data = numpy.zeros(self.grid.n_steps)
+
+    def update_data(self, field: numpy.ndarray) -> NoReturn:
+        """
+        Update the detector data based on the provided field values.
+
+        Parameters:
+            field (numpy.ndarray): The field values to update the detector data.
+        """
+        self.data = field[:, self.p0.x_index, self.p0.y_index]
+
+    def plot_data(self) -> SceneList:
+        """
+        Plot the detector data over time.
+
+        Returns:
+            SceneList: A scene list containing the plot.
+        """
+        scene = SceneList()
+        ax = scene.append_ax()
+        ax.add_line(x=self.grid.time_stamp, y=self.data)
+        return scene
+
+    def add_to_ax(self, ax: plt.axis) -> NoReturn:
+        """
+        Add the scatterer to the provided axis as a circle.
+
+        Args:
+            ax (Axis): The axis to which the scatterer will be added.
+        """
+        ax.scatter(
+            self.p0.x,
+            self.p0.y,
+            color=self.facecolor
+        )
+
+

lightwave2d-0.0.3/LightWave2D/directories.py

@@ -0,0 +1,33 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+
+from pathlib import Path
+import LightWave2D
+
+
+__all__ = [
+    'root_path',
+    'project_path',
+    'doc_path',
+    'doc_css_path',
+    'version_path',
+]
+
+root_path = Path(LightWave2D.__path__[0])
+
+project_path = root_path.parents[0]
+
+doc_path = project_path.joinpath('docs')
+
+doc_css_path = doc_path.joinpath('source/_static/default.css')
+
+version_path = root_path.joinpath('VERSION')
+
+
+if __name__ == '__main__':
+    for path_name in __all__:
+        path = locals()[path_name]
+        print(path)
+        assert path.exists(), f"Path {path_name} do not exists"
+
+# -