LightWave2D 0.0.6__tar.gz → 0.0.8__tar.gz

lightwave2d-0.0.8/LightWave2D/VERSION

@@ -0,0 +1 @@
+0.0.8

{lightwave2d-0.0.6 → lightwave2d-0.0.8}/LightWave2D/components.py

@@ -4,12 +4,10 @@
 from typing import NoReturn, Union, Tuple
 from pydantic.dataclasses import dataclass
 import numpy
-from LightWave2D.physics import Physics
 import matplotlib.pyplot as plt
 import shapely.geometry as geo
 from matplotlib.patches import PathPatch
 from matplotlib import patches
-import numpy as np
 from matplotlib.path import Path
 from matplotlib.collections import PatchCollection
 from LightWave2D.grid import Grid
@@ -36,12 +34,14 @@ class BaseComponent():
         edgecolor (str): The color of the component's edge.
         alpha (float): Transparency level of the component.
         rotation (float): Rotation angle of the component.
+        sigma (float): Conductivity of the component.
     """
     grid: Grid
     facecolor: str = 'lightblue'
     edgecolor: str = 'blue'
     alpha: float = 0.3
     rotation: float = 0
+    sigma: float = 0
 
     def __post_init__(self):
         x0, y0 = self.position
@@ -63,14 +63,10 @@ class BaseComponent():
 
         self.path = Path(self.polygon.exterior.coords)
 
-        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()]
+        coordinates = numpy.c_[self.grid.x_mesh.T.flatten(), self.grid.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) -> PatchCollection:
         """
         Add the component to the provided axis.
@@ -82,8 +78,8 @@ class BaseComponent():
             PatchCollection: The collection of patches added to the axis.
         """
         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])
+            Path(numpy.asarray(self.polygon.exterior.coords)[:, :2]),
+            *[Path(numpy.asarray(ring.coords)[:, :2]) for ring in self.polygon.interiors])
 
         patch = PathPatch(path, facecolor=self.facecolor, edgecolor=self.edgecolor, alpha=0.4)
         collection = PatchCollection([patch], facecolor=self.facecolor, edgecolor=self.edgecolor, alpha=self.alpha)
@@ -107,25 +103,36 @@ class BaseComponent():
 
         plt.show()
 
-    def add_to_mesh(self, epsilon_r_mesh: numpy.ndarray) -> NoReturn:
+    def add_to_epsilon_r_mesh(self, epsilon_r_mesh: numpy.ndarray) -> NoReturn:
         """
         Add the component's permittivity to the provided mesh.
 
         Args:
-            epsilon_r_mesh (np.ndarray): The permittivity mesh to be updated.
+            epsilon_r_mesh (numpy.ndarray): The permittivity mesh to be updated.
+        """
+        epsilon_r_mesh[self.idx] = self.epsilon_r
+
+    def add_to_sigma_mesh(self, sigma_mesh: numpy.ndarray) -> NoReturn:
+        """
+        Add the component's sigma to the provided mesh.
+
+        Args:
+            sigma_mesh (numpy.ndarray): The permittivity mesh to be updated.
         """
-        epsilon_r_mesh += self.epsilon_r_mesh
+        sigma_mesh[self.idx] = self.sigma
 
     def add_non_linear_effect_to_field(self, field: numpy.ndarray) -> NoReturn:
         """
         Add non-linear effects to the field.
 
         Args:
-            field (np.ndarray): The field to which non-linear effects will be added.
+            field (numpy.ndarray): The field to which non-linear effects will be added.
         """
-        chi_2 = 1e10
-
-        field += self.idx * self.grid.dt**2 / (self.epsilon_r_mesh * Physics.epsilon_0 * Physics.mu_0) * chi_2 * field ** 2
+        return field
+        chi_3 = 1e-8  # Third-order non-linear susceptibility (example value)
+        intensity = numpy.abs(field) ** 2
+        nonlinear_term = chi_3 * intensity * field
+        return field + self.grid.dt * nonlinear_term
 
 
 @dataclass(config=config_dict)
@@ -231,7 +238,7 @@ class Triangle(BaseComponent):
         """
         Compute the polygon of the triangular scatterer.
         """
-        height = (np.sqrt(3) / 2) * self.side_length
+        height = (numpy.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)

{lightwave2d-0.0.6 → lightwave2d-0.0.8}/LightWave2D/experiment.py

@@ -6,8 +6,8 @@ from typing import Tuple, NoReturn, Optional, Union, List
 import numpy
 from LightWave2D.physics import Physics
 from LightWave2D.grid import Grid
-from LightWave2D.components import Circle, Square, Ellipse, Triangle, Lense, Grating, RingResonator, Waveguide
-from LightWave2D.source import PointSource, LineSource, PointImpulsion
+from LightWave2D import components
+from LightWave2D import source
 from LightWave2D.detector import PointDetector
 from LightWave2D.pml import PML
 from MPSPlots import colormaps
@@ -116,82 +116,89 @@ class Experiment:
         return self.pml
 
     @add_to_component
-    def add_circle(self, **kwargs) -> Circle:
+    def add_circle(self, **kwargs) -> components.Circle:
         """
-        Method to add a Circle to the simulation.
+        Method to add a components.Circle to the simulation.
         """
-        return Circle(grid=self.grid, **kwargs)
+        return components.Circle(grid=self.grid, **kwargs)
 
     @add_to_component
-    def add_ellipse(self, **kwargs) -> Ellipse:
+    def add_ellipse(self, **kwargs) -> components.Ellipse:
         """
-        Method to add a Ellipse to the simulation.
+        Method to add a components.Ellipse to the simulation.
         """
-        return Ellipse(grid=self.grid, **kwargs)
+        return components.Ellipse(grid=self.grid, **kwargs)
 
     @add_to_component
-    def add_square(self, **kwargs) -> Square:
+    def add_square(self, **kwargs) -> components.Square:
         """
         open()
-        Method to add a Square to the simulation.
+        Method to add a components.Square to the simulation.
         """
-        return Square(grid=self.grid, **kwargs)
+        return components.Square(grid=self.grid, **kwargs)
 
     @add_to_component
-    def add_triangle(self, **kwargs) -> Square:
+    def add_triangle(self, **kwargs) -> components.Triangle:
         """
-        Method to add a Triangle to the simulation.
+        Method to add a components.Triangle to the simulation.
         """
-        return Triangle(grid=self.grid, **kwargs)
+        return components.Triangle(grid=self.grid, **kwargs)
 
     @add_to_component
-    def add_lense(self, **kwargs) -> Square:
+    def add_lense(self, **kwargs) -> components.Lense:
         """
-        Method to add a Lense to the simulation.
+        Method to add a components.Lense to the simulation.
         """
-        return Lense(grid=self.grid, **kwargs)
+        return components.Lense(grid=self.grid, **kwargs)
 
     @add_to_component
-    def add_grating(self, **kwargs) -> Square:
+    def add_grating(self, **kwargs) -> components.Grating:
         """
-        Method to add a Grating to the simulation.
+        Method to add a components.Grating to the simulation.
         """
-        return Grating(grid=self.grid, **kwargs)
+        return components.Grating(grid=self.grid, **kwargs)
 
     @add_to_component
-    def add_ring_resonator(self, **kwargs) -> Square:
+    def add_ring_resonator(self, **kwargs) -> components.RingResonator:
         """
-        Method to add a RingResonator to the simulation.
+        Method to add a components.RingResonator to the simulation.
         """
-        return RingResonator(grid=self.grid, **kwargs)
+        return components.RingResonator(grid=self.grid, **kwargs)
 
     @add_to_component
-    def add_waveguide(self, **kwargs) -> Waveguide:
+    def add_waveguide(self, **kwargs) -> components.Waveguide:
         """
-        Method to add a Waveguide to the simulation.
+        Method to add a components.Waveguide to the simulation.
         """
-        return Waveguide(grid=self.grid, **kwargs)
+        return components.Waveguide(grid=self.grid, **kwargs)
 
     @add_to_source
-    def add_point_source(self, **kwargs) -> PointSource:
+    def add_point_source(self, **kwargs) -> source.PointSource:
         """
-        Method to add a PointSource to the simulation.
+        Method to add a source.PointSource to the simulation.
         """
-        return PointSource(grid=self.grid, **kwargs)
+        return source.PointSource(grid=self.grid, **kwargs)
 
     @add_to_source
-    def add_point_impulsion(self, **kwargs) -> PointImpulsion:
+    def add_point_impulsion(self, **kwargs) -> source.PointImpulsion:
         """
-        Method to add a Impulsion to the simulation.
+        Method to add a source.Impulsion to the simulation.
         """
-        return PointImpulsion(grid=self.grid, **kwargs)
+        return source.PointImpulsion(grid=self.grid, **kwargs)
 
     @add_to_source
-    def add_line_source(self, **kwargs) -> LineSource:
+    def add_line_source(self, **kwargs) -> source.LineSource:
         """
-        Method to add a LineSource to the simulation.
+        Method to add a source.LineSource to the simulation.
         """
-        return LineSource(grid=self.grid, **kwargs)
+        return source.LineSource(grid=self.grid, **kwargs)
+
+    @add_to_source
+    def add_line_impulsion(self, **kwargs) -> source.LineImpulsion:
+        """
+        Method to add a source.LineSource to the simulation.
+        """
+        return source.LineImpulsion(grid=self.grid, **kwargs)
 
     @add_to_detector
     def add_point_detector(self, **kwargs) -> PointDetector:
@@ -211,6 +218,11 @@ class Experiment:
             sigma_x, sigma_y = self.pml.sigma_x, self.pml.sigma_y
         else:
             sigma_x = sigma_y = numpy.zeros(self.grid.shape)
+
+        for component in self.components:
+            component.add_to_sigma_mesh(sigma_x)
+            component.add_to_sigma_mesh(sigma_y)
+
         return sigma_x, sigma_y
 
     def get_epsilon(self) -> numpy.ndarray:
@@ -222,7 +234,7 @@ class Experiment:
         """
         epsilon_r_mesh = numpy.ones(self.grid.shape)
         for component in self.components:
-            component.add_to_mesh(epsilon_r_mesh)
+            component.add_to_epsilon_r_mesh(epsilon_r_mesh)
 
         return epsilon_r_mesh * Physics.epsilon_0
 
@@ -264,13 +276,17 @@ class Experiment:
 
             Ez[1:-1, 1:-1] += eps_factor[1:-1, 1:-1] * (dHy_dx - dHx_dy)
 
-            for component in self.components:
-                component.add_non_linear_effect_to_field(Ez)
+            # Apply absorption (losses) to the electric field Ez
+            absorption_factor = 1 - (sigma_x + sigma_y) * eps_factor / 2
+            absorption_factor = numpy.clip(absorption_factor, 0, 1)  # Absorption cliped to [0, 1] to ensure stability
+
+            Ez *= absorption_factor
 
-            Ez *= (1 - (sigma_x + sigma_y) * eps_factor / 2)
+            for component in self.components:
+                Ez = component.add_non_linear_effect_to_field(Ez)
 
-            for source in self.sources:
-                source.add_source_to_field(Ez, time=t)
+            for element in self.sources:
+                element.add_source_to_field(Ez, time=t)
 
             self.Ez_t[iteration] = Ez
 
@@ -342,6 +358,7 @@ class Experiment:
             frame_number (int): The index of the frame to be saved.
             filename (str): The file path where the image will be saved.
             dpi (int): The resolution of the saved image in dots per inch.
+            show_intensity (bool): If True, the intensity is shown instead of amplitude
             colormap (Optional[Union[str, object]]): The colormap used for visualizing the data. Defaults to a predefined blue-black-red colormap.
 
         Returns:
@@ -394,6 +411,7 @@ class Experiment:
             skip_frame: int = 10,
             scale_max: float = 5,
             unit_size: int = 6,
+            auto_adjust_clim: bool = False,
             colormap: Optional[Union[str, object]] = colormaps.blue_black_red) -> animation.FuncAnimation:
         """
         Renders the propagation of a field as an animation using matplotlib.
@@ -403,6 +421,7 @@ class Experiment:
 
         Args:
             skip_frame (int): The number of time steps to skip between frames in the animation.
+            auto_adjust_clim (bool): TODO
             colormap (Optional[Union[str, object]]): The colormap used for visualizing the data. Defaults to a predefined blue-black-red colormap.
             unit_size (float): The base unit size for scaling the plot elements.
 
@@ -437,6 +456,11 @@ class Experiment:
             """
             field_t = self.Ez_t[frame].T
             field_artist.set_array(field_t)
+
+            if auto_adjust_clim:
+                max_amplitude = abs(field_t).max() / scale_max
+                field_artist.set_clim(vmin=-max_amplitude, vmax=max_amplitude)
+
             return [artist for artist in artist_list]
 
         def init_func():

{lightwave2d-0.0.6 → lightwave2d-0.0.8}/LightWave2D/grid.py

@@ -52,6 +52,8 @@ class Grid:
         self.x_stamp = numpy.arange(self.n_x) * self.dx
         self.y_stamp = numpy.arange(self.n_y) * self.dy
 
+        self.x_mesh, self.y_mesh = numpy.meshgrid(self.x_stamp, self.y_stamp)
+
         self.polygon = geo.Polygon([
             (self.x_stamp[0], self.y_stamp[0]),
             (self.x_stamp[0], self.y_stamp[-1]),

{lightwave2d-0.0.6 → lightwave2d-0.0.8}/LightWave2D/pml.py

@@ -47,7 +47,6 @@ class PML:
         opposite_width = f"{100 - opposite_width}%"
         self.width_start = self.grid.get_coordinate(x=self.width, y=self.width)
         self.width_stop = self.grid.get_coordinate(x=opposite_width, y=opposite_width)
-        self.width_stop_ = self.grid.get_coordinate(x="100%", y="100%")
 
         bottom_boundary = y_mesh < self.width_start.y
         left_boundary = x_mesh < self.width_start.x

{lightwave2d-0.0.6 → lightwave2d-0.0.8}/LightWave2D/source.py

@@ -25,15 +25,16 @@ config_dict = {
 
 
 @dataclass(kw_only=True, config=config_dict)
-class BaseSource():
+class BaseSource:
     """
-    Represents an elliptical scatterer in a simulation grid.
+    Base class for sources in a 2D light wave simulation.
 
     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.
+        facecolor (str): Color of the source face.
+        edgecolor (str): Color of the source edge.
+        alpha (float): Transparency level of the source.
+        rotation (float): Rotation angle of the source.
     """
     grid: Grid
     facecolor: str = 'red'
@@ -42,73 +43,63 @@ class BaseSource():
     rotation: float = 0
 
     def __post_init__(self):
-        x0, y0 = self.position
-        self.coordinate = self.grid.get_coordinate(x=x0, y=y0)
-
+        self.coordinate = self.grid.get_coordinate(x=self.position[0], y=self.position[1])
         self.build_object()
 
     def build_object(self) -> NoReturn:
         """
-        Build the permittivity mesh for the square scatterer.
+        Build the source object and initialize its properties.
         """
         self.compute_polygon()
-
         self.path = Path(self.polygon.exterior.coords)
-
         self.path = self.path.transformed(matplotlib.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)
-
         coordinates = numpy.c_[x_mesh.T.flatten(), y_mesh.T.flatten()]
+        self.idx = self.path.contains_points(coordinates).astype(bool).reshape(self.grid.shape)
 
-        self.idx = self.path.contains_points(coordinates).astype(bool).reshape(self.epsilon_r_mesh.shape)
-
-    def add_to_ax(self, ax: plt.axis) -> PatchCollection:
+    def add_to_ax(self, ax: plt.Axes) -> PatchCollection:
         """
-        Add the scatterer to the provided axis as a circle.
+        Add the source to the provided axis as a scatter point or patch.
 
         Args:
-            ax (Axis): The axis to which the scatterer will be added.
+            ax (plt.Axes): The axis to which the source will be added.
         """
         path = Path.make_compound_path(
             Path(numpy.asarray(self.polygon.exterior.coords)[:, :2]),
-            *[Path(numpy.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)
-
+            *[Path(numpy.asarray(ring.coords)[:, :2]) for ring in self.polygon.interiors]
+        )
+        patch = PathPatch(path, facecolor=self.facecolor, edgecolor=self.edgecolor, alpha=self.alpha)
+        collection = PatchCollection([patch], facecolor=self.facecolor, edgecolor=self.edgecolor, alpha=self.alpha)
         ax.add_collection(collection, autolim=True)
         ax.autoscale_view()
         return collection
 
     def plot(self) -> NoReturn:
+        """
+        Plot the source on a 2D grid.
+        """
         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_ylabel(r'y position [$\mu$m]')
         ax.set_aspect('equal')
-
         self.add_to_ax(ax)
-        ax.autoscale_view()
-
         plt.show()
 
 
-@dataclass(kw_only=True, config=config_dict)
+@dataclass(config=config_dict)
 class PointSource(BaseSource):
     """
     Represents a point source in a 2D light wave simulation.
 
     Attributes:
-        wavelength (float): Wavelength of the source.
-        position (tuple): Position (x, y) of the source.
-        amplitude (float): Amplitude of the electric field, default is 1.0.
+        wavelength (Union[float, List[float], numpy.ndarray]): Wavelength of the source.
+        position (Tuple[Union[float, str], Union[float, str]]): Position (x, y) of the source.
+        amplitude (float): Amplitude of the electric field.
     """
     wavelength: Union[float | List[float] | numpy.ndarray]
     position: Tuple[float | str, float | str]
-    amplitude: float = 1.0
-    facecolor: str = 'red'
-    edgecolor: str = 'red'
+    amplitude: float
 
     def __post_init__(self):
         self.wavelength = numpy.atleast_1d(self.wavelength)
@@ -144,22 +135,21 @@ class PointSource(BaseSource):
         field[self.p0.x_index, self.p0.y_index] = self.amplitude / len(self.omega) * numpy.sin(self.omega * time).sum()
 
 
-@dataclass(kw_only=True, config=config_dict)
+@dataclass(config=config_dict)
 class PointImpulsion(BaseSource):
     """
-    Represents a point source in a 2D light wave simulation.
+    Represents a point impulsion source in a 2D light wave simulation.
 
     Attributes:
-        wavelength (float): Wavelength of the source.
-        position (tuple): Position (x, y) of the source.
-        amplitude (float): Amplitude of the electric field, default is 1.0.
+        amplitude (float): Amplitude of the electric field.
+        duration (float): Duration of the impulsion.
+        position (Tuple[Union[float, str], Union[float, str]]): Position (x, y) of the source.
+        delay (float): Delay before the impulsion starts.
     """
+    amplitude: float
     duration: float
     position: Tuple[float | str, float | str]
     delay: float = 0
-    amplitude: float = 1.0
-    facecolor: str = 'red'
-    edgecolor: str = 'red'
 
     def __post_init__(self):
         x, y = self.position
@@ -183,10 +173,10 @@ class PointImpulsion(BaseSource):
 
     def add_source_to_field(self, field: numpy.ndarray, time: float) -> NoReturn:
         """
-        Add the source's effect to the simulation field.
+        Add the impulsion source's effect to the simulation field.
 
         Args:
-            field (numpy.ndarray): The simulation field to which the source's effect will be added.
+            field (np.ndarray): The simulation field to which the source's effect will be added.
             time (float): The current simulation time.
         """
         source_field = numpy.exp(-((time - self.delay) / self.duration) ** 2)
@@ -194,21 +184,21 @@ class PointImpulsion(BaseSource):
         field[self.p0.x_index, self.p0.y_index] = self.amplitude * source_field
 
 
-@dataclass(kw_only=True, config=config_dict)
+@dataclass(config=config_dict)
 class LineSource(BaseSource):
     """
     Represents a line source in a 2D light wave simulation.
 
     Attributes:
+        amplitude (float): Amplitude of the electric field.
         wavelength (float): Wavelength of the source.
-        point_0 (Tuple[float, float]): Starting position (x, y) of the source.
-        point_1 (Tuple[float, float]): Ending position (x, y) of the source.
-        amplitude (float): Amplitude of the electric field, default is 1.0.
+        position_0 (Tuple[Union[float, str], Union[float, str]]): Starting position (x, y) of the source.
+        position_1 (Tuple[Union[float, str], Union[float, str]]): Ending position (x, y) of the source.
     """
+    amplitude: float
     wavelength: float
     position_0: Tuple[float | str, float | str]
     position_1: Tuple[float | str, float | str]
-    amplitude: float = 1.0
 
     def __post_init__(self):
         self.frequency = Physics.c / self.wavelength
@@ -252,11 +242,85 @@ class LineSource(BaseSource):
 
     def add_source_to_field(self, field: numpy.ndarray, time: float) -> NoReturn:
         """
-        Add the source's effect to the simulation field.
+        Add the line source's effect to the simulation field.
 
         Args:
-            field (numpy.ndarray): The simulation field to which the source's effect will be added.
+            field (np.ndarray): The simulation field to which the source's effect will be added.
             time (float): The current simulation time.
         """
         rows, cols = self.slice_indexes
         field[rows, cols] = self.amplitude * numpy.sin(self.omega * time)
+
+
+@dataclass(config=config_dict)
+class LineImpulsion(BaseSource):
+    """
+    Represents a line impulsion source in a 2D light wave simulation.
+
+    Attributes:
+        duration (float): Duration of the impulsion.
+        amplitude (float): Amplitude of the electric field.
+        position_0 (Tuple[Union[float, str], Union[float, str]]): Starting position (x, y) of the source.
+        position_1 (Tuple[Union[float, str], Union[float, str]]): Ending position (x, y) of the source.
+        delay (float): Delay before the impulsion starts.
+    """
+    duration: float
+    amplitude: float
+    position_0: Tuple[float | str, float | str]
+    position_1: Tuple[float | str, float | str]
+    delay: float = 0
+
+    def __post_init__(self):
+        self.build_object()
+
+    def build_object(self) -> NoReturn:
+        """
+        Build the line source object and calculate the line's coordinates.
+        """
+        self.p0 = self.grid.get_coordinate(x=self.position_0[0], y=self.position_0[1])
+        self.p1 = self.grid.get_coordinate(x=self.position_1[0], y=self.position_1[1])
+
+        position = bresenham_line(
+            x0=self.p0.x_index,
+            y0=self.p0.y_index,
+            x1=self.p1.x_index,
+            y1=self.p1.y_index
+        )
+
+        rows, cols = zip(*position.T)
+        self.slice_indexes = rows, cols
+
+        p0 = geo.Point(self.p0.x, self.p0.y)
+        p1 = geo.Point(self.p1.x, self.p1.y)
+        self.polygon = geo.LineString((p0, p1))
+
+    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.plot(
+            self.polygon.xy[0],
+            self.polygon.xy[1],
+            color=self.facecolor,
+            label='source'
+        )
+
+    def add_source_to_field(self, field: numpy.ndarray, time: float) -> NoReturn:
+        """
+        Add the line impulsion source's effect to the simulation field.
+
+        Args:
+            field (np.ndarray): The simulation field to which the source's effect will be added.
+            time (float): The current simulation time.
+        """
+        rows, cols = self.slice_indexes
+
+        source_field = numpy.exp(-((time - self.delay) / self.duration) ** 2)
+
+        field[rows, cols] = self.amplitude * source_field
+
+
+# -

{lightwave2d-0.0.6 → lightwave2d-0.0.8}/LightWave2D.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: LightWave2D
-Version: 0.0.6
+Version: 0.0.8
 Summary: A package for finite-difference time domain computation for light propagation.
 Home-page: https://github.com/MartinPdeS/LightWave2D
 Author: Martin Poinsinet de Sivry

{lightwave2d-0.0.6 → lightwave2d-0.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: LightWave2D
-Version: 0.0.6
+Version: 0.0.8
 Summary: A package for finite-difference time domain computation for light propagation.
 Home-page: https://github.com/MartinPdeS/LightWave2D
 Author: Martin Poinsinet de Sivry

lightwave2d-0.0.8/developments/testings_0.py

@@ -0,0 +1,80 @@
+"""
+Experiment: Circular Scatterer
+==============================
+
+This example demonstrates the setup and execution of a circular scatterer experiment using LightWave2D.
+We will define the simulation grid, add a circular scatterer and a line source, apply a perfectly matched layer (PML), run the simulation, and visualize the results.
+"""
+
+# %%
+# Importing the necessary packages
+from LightWave2D.grid import Grid
+from LightWave2D.experiment import Experiment
+from MPSPlots import colormaps
+
+# %%
+# Define the simulation grid
+grid = Grid(
+    resolution=0.1e-6,  # Grid resolution in meters
+    size_x=32e-6,       # Grid size in the x direction in meters
+    size_y=20e-6,       # Grid size in the y direction in meters
+    n_steps=300         # Number of time steps for the simulation
+)
+
+# Initialize the experiment with the defined grid
+experiment = Experiment(grid=grid)
+
+# %%
+# Add a circular scatterer to the experiment
+scatterer = experiment.add_circle(
+    position=('30%', '50%'),  # Center position of the scatterer
+    epsilon_r=1.5,            # Relative permittivity of the scatterer
+    radius=3e-6,              # Radius of the circular scatterer in meters
+    # sigma=1e6
+)
+
+# %%
+# Add a line source to the experiment
+source = experiment.add_line_source(
+    wavelength=1550e-9,         # Wavelength of the source in meters
+    position_0=('10%', '80%'),  # Starting position of the source
+    position_1=('10%', '20%'),  # Ending position of the source
+    amplitude=10                # Amplitude of the source
+)
+
+# %%
+# Add a perfectly matched layer (PML) to absorb boundary reflections
+experiment.add_pml(
+    order=1,          # Order of the PML polynomial profile
+    width='10%',      # Width of the PML region as a percentage of grid size
+    sigma_max=5000    # Maximum conductivity for the PML
+)
+
+# %%
+# Plot the entire experiment setup
+experiment.plot()
+
+# Run the FDTD simulation
+experiment.run_fdtd()
+
+# %%
+# Plot the last time frame of the computed fields
+experiment.plot_frame(
+    frame_number=-1,  # Plot the last frame
+    scale_max=1,      # Maximum scale for the field visualization
+    colormap=colormaps.polytechnique.red_black_blue,  # Colormap for the plot
+    # show_intensity=True
+)
+
+# %%
+# Render an animation of the field propagation over time
+animation = experiment.render_propagation(
+    skip_frame=5,                            # Number of frames to skip in the animation
+    unit_size=5,                             # Size of each unit in the animation
+    colormap=colormaps.polytechnique.red_black_blue,  # Colormap for the animation
+    scale_max=1,
+    auto_adjust_clim=True
+)
+
+# Save the animation as a GIF file
+animation.save('./circular_scatterer_propagation.gif', writer='Pillow', fps=10)

lightwave2d-0.0.6/LightWave2D/VERSION

@@ -1 +0,0 @@
-0.0.6

lightwave2d-0.0.6/developments/testings_0.py

@@ -1,82 +0,0 @@
-"""
-Experiment: elliptic scatterer
-==============================
-
-"""
-
-
-# %%
-# Importing the package
-from LightWave2D.grid import Grid
-from LightWave2D.experiment import Experiment
-from MPSPlots import colormaps
-
-# %%
-# We define here the grid on which to build the experiemnt
-grid = Grid(
-    resolution=0.05e-6,
-    size_x=50e-6,
-    size_y=15e-6,
-    n_steps=1200
-)
-
-experiment = Experiment(grid=grid)
-
-# scatterer = experiment.add_ellipse(
-#     position=('30%', '40%'),
-#     width=4e-6,
-#     height=4e-6,
-#     epsilon_r=1,
-# )
-
-
-scatterer = experiment.add_waveguide(
-    position_0=('0%', '50%'),
-    position_1=('100%', '50%'),
-    width=2e-6,
-    epsilon_r=2,
-)
-
-source = experiment.add_line_source(
-    wavelength=1550e-9,
-    position_0=('20%', '45%'),
-    position_1=('20%', '55%'),
-    amplitude=10,
-)
-
-
-# source = experiment.add_impulsion(
-#     duration=1e-15,
-#     delay=0,
-#     position=('50%', '50%'),
-#     amplitude=1000,
-# )
-
-
-# %%
-# We add a perfectly matched layer to avoid reflection at the boundary of the mesh
-experiment.add_pml(order=1, width='10%', sigma_max=5000)
-
-experiment.run_fdtd()
-
-experiment.plot()
-
-# %%
-# Plotting the last time frame of the computed fields
-# experiment.plot_frame(
-#     frame_number=-1,
-#     colormap=colormaps.polytechnique.red_black_blue,
-#     scale_max=1
-# )
-
-
-animation = experiment.render_propagation(
-    skip_frame=10,
-    colormap=colormaps.polytechnique.red_black_blue,
-    scale_max=2
-)
-
-_ = animation.save('./resonator.gif', writer='Pillow', fps=20)
-
-
-# -