FiberFusing 1.9.4__tar.gz → 1.9.7__tar.gz

fiberfusing-1.9.7/FiberFusing/_version.py

@@ -0,0 +1,5 @@
+"""Release version maintained by martinpdes-maintenance."""
+
+__version__ = version = "1.9.7"
+__version_tuple__ = version_tuple = tuple(int(part) for part in version.split("."))
+__commit_id__ = commit_id = None

{fiberfusing-1.9.4 → fiberfusing-1.9.7}/FiberFusing/background.py

@@ -3,15 +3,14 @@
 
 from typing import Tuple, Optional
 from pydantic.dataclasses import dataclass
-from pydantic import ConfigDict
 import numpy as np
 
 from FiberFusing.coordinate_system import CoordinateSystem
 from FiberFusing.helper import OverlayStructureBaseClass
-from FiberFusing.utils import NameSpace
+from FiberFusing.utils import NameSpace, config_dict
 
 
-@dataclass(config=ConfigDict(extra='forbid', kw_only=True))
+@dataclass(config=config_dict)
 class BackGround(OverlayStructureBaseClass):
     """
     Represents a background structure overlayed on a mesh, characterized by a circular shape.

{fiberfusing-1.9.4 → fiberfusing-1.9.7}/FiberFusing/connection/connection.py

@@ -380,14 +380,15 @@ class Connection:
             options={'xatol': tolerance}
         )
 
-        if result.success:
+        if result.success and np.isfinite(result.x) and np.isfinite(result.fun):
+            self._compute_area_mismatch_cost(result.x)
             logging.info(f"Optimization successful: cost={result.fun:.2e}")
             # Apply optimized shifts
             if self.core_shift:
                 self.fiber0.shifted_core += self.core_shift[0]
                 self.fiber1.shifted_core += self.core_shift[1]
         else:
-            logging.warning(f"Optimization failed: {result.message}")
+            raise RuntimeError(f"Core optimization failed: {result.message}")
 
     def _compute_area_mismatch_cost(self, x: float) -> float:
         """

{fiberfusing-1.9.4 → fiberfusing-1.9.7}/FiberFusing/connection/connection_optimization.py

@@ -1,4 +1,5 @@
 import logging
+import numpy as np
 from scipy.optimize import minimize_scalar
 from itertools import combinations
 from FiberFusing.connection.connection import Connection
@@ -92,6 +93,7 @@ class ConnectionOptimization:
         virtual_shift : float
             The shift value for the virtual circles.
         """
+        self._added_section = self._removed_section = None
         self.virtual_shift = virtual_shift
         topology = self.get_overall_topology()
         for connection in self.connected_fibers:
@@ -132,7 +134,7 @@ class ConnectionOptimization:
         float
             The total removed area.
         """
-        disconnected_area = len(self.fiber_list) * self.fiber_list[0].area
+        disconnected_area = sum(fiber.area for fiber in self.fiber_list)
         connected_area = utils.union_geometries(*self.fiber_list).area
         return disconnected_area - connected_area
 
@@ -140,6 +142,7 @@ class ConnectionOptimization:
         """
         Initializes the connections between pairs of fibers in the structure.
         """
+        self._added_section = self._removed_section = None
         self.connected_fibers = [Connection(f0, f1) for f0, f1 in self.iterate_over_connected_fibers()]
 
     def get_overall_topology(self) -> str:
@@ -206,12 +209,18 @@ class ConnectionOptimization:
         core_distance = self.connected_fibers[0].distance_between_cores
         bounds = (0, core_distance * 1e3) if bounds is None else bounds
 
+        if np.shape(bounds) != (2,) or not np.all(np.isfinite(bounds)) or not 0 <= bounds[0] < bounds[1]:
+            raise ValueError("bounds must be finite, nonnegative, and strictly increasing.")
+
         result = minimize_scalar(
             self.get_cost_value,
             bounds=bounds,
             method='bounded',
             options={'xatol': core_distance * self.tolerance_factor}
         )
+        if not result.success or not np.isfinite(result.x) or not np.isfinite(result.fun):
+            raise RuntimeError(f"Fusion optimization failed: {result.message}")
+        self.shift_connections(result.x)
         return result.x
 
     def compute_optimal_structure(self, bounds: tuple = None) -> None:
@@ -224,8 +233,14 @@ class ConnectionOptimization:
             The boundaries for the virtual shift.
         """
         logging.info("Computing the optimal structure geometry")
-        self.find_optimal_virtual_shift(bounds)
+        shift = self.find_optimal_virtual_shift(bounds)
+        self.shift_connections(shift)
         self._clad_structure = self.compute_shifted_geometry()
+        if not self._clad_structure._shapely_object.is_valid or not np.isfinite(self._clad_structure.area):
+            raise RuntimeError("Fusion optimization produced invalid geometry.")
+        target_area = sum(fiber.area for fiber in self.fiber_list)
+        self.area_residual = abs(self._clad_structure.area - target_area)
+        self.relative_area_residual = self.area_residual / target_area
         self.optimize_core_positions()
 
     def compute_shifted_geometry(self) -> Polygon:

{fiberfusing-1.9.4 → fiberfusing-1.9.7}/FiberFusing/coordinate_system.py

@@ -4,11 +4,13 @@
 import numpy as np
 from typing import Tuple, Optional
 from pydantic.dataclasses import dataclass
-from pydantic import ConfigDict, field_validator
+from pydantic import field_validator
 from dataclasses import field
 
+from FiberFusing.utils import config_dict
 
-@dataclass(config=ConfigDict(extra='forbid', strict=True, kw_only=True, arbitrary_types_allowed=True, frozen=False))
+
+@dataclass(config=config_dict)
 class CoordinateSystem:
     """
     A 2D Cartesian coordinate system for fiber optics simulations.

{fiberfusing-1.9.4 → fiberfusing-1.9.7}/FiberFusing/fiber/generic_fiber.py

@@ -6,12 +6,12 @@ import numpy
 import pprint
 from copy import deepcopy
 import matplotlib.pyplot as plt
+from FiberFusing.plottings import plotting
 
 from FiberFusing import Circle, CircleOpticalStructure
 from FiberFusing.geometries.point import Point
 from FiberFusing.coordinate_system import CoordinateSystem
 from FiberFusing.plottings import plot_polygon
-from FiberFusing.helper import _plot_helper
 from FiberFusing.graded_index import GradedIndex
 
 pp = pprint.PrettyPrinter(indent=4, sort_dicts=False, compact=True, width=1)
@@ -508,8 +508,8 @@ class GenericFiber():
             coordinate_system=coordinate_system
         )
 
-    @_plot_helper
-    def plot(self, ax: plt.Axes = None) -> None:
+    @plotting(nrows=1, ncols=1)
+    def plot(self, axes: plt.Axes = None) -> None:
         """
         Plot the fiber geometry representation including patch and raster-mesh.
 
@@ -519,7 +519,7 @@ class GenericFiber():
             Resolution for rasterizing structures. Default is 300.
         """
         for structure in self.fiber_structure:
-            plot_polygon(ax=ax, polygon=structure.polygon._shapely_object)
+            plot_polygon(ax=axes, polygon=structure.polygon._shapely_object)
 
     def get_structures_boundaries(self) -> numpy.ndarray:
         """
@@ -565,8 +565,8 @@ class GenericFiber():
         """
         return self.get_structure_max_min_boundaries()
 
-    @_plot_helper
-    def plot_raster(self, coordinate_system, ax: plt.Axes = None) -> None:
+    @plotting(nrows=1, ncols=1)
+    def plot_raster(self, axes: plt.Axes, coordinate_system) -> None:
         """
         Render the rasterized representation of the geometry onto a given matplotlib axis.
 
@@ -582,7 +582,16 @@ class GenericFiber():
         None
         """
         mesh = self.get_raster_mesh(coordinate_system=coordinate_system)
-        ax.pcolormesh(coordinate_system.x_vector, coordinate_system.y_vector, mesh, cmap='Blues')
+        axes.pcolormesh(
+            coordinate_system.x_vector,
+            coordinate_system.y_vector,
+            mesh,
+            cmap='Blues'
+        )
+
+        axes.set(
+            title='Fiber structure',
+            xlabel=r'x-distance',
+            ylabel=r'y-distance'
+        )
 
-        ax.set(title='Fiber structure', xlabel=r'x-distance [m]', ylabel=r'y-distance [m]')
-        ax.ticklabel_format(axis='both', style='sci', scilimits=(-6, -6), useOffset=False)

{fiberfusing-1.9.4 → fiberfusing-1.9.7}/FiberFusing/geometries/__init__.py

@@ -1,11 +1,3 @@
-from pydantic import ConfigDict
-
-config_dict = ConfigDict(
-    extra='forbid',
-    arbitrary_types_allowed=True,
-    kw_only=True
-)
-
 from .base_class import Alteration  # noqa: F401
 from .point import Point  # noqa: F401
 from .linestring import LineString  # noqa: F401

{fiberfusing-1.9.4 → fiberfusing-1.9.7}/FiberFusing/geometries/base_class.py

@@ -1,7 +1,8 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-from typing import Tuple, Callable, Self
+from typing import Tuple, Callable
+from typing_extensions import Self
 import copy
 from shapely import affinity
 

{fiberfusing-1.9.4 → fiberfusing-1.9.7}/FiberFusing/geometries/linestring.py

@@ -1,7 +1,8 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-from typing import Optional, Tuple, Self
+from typing import Optional, Tuple
+from typing_extensions import Self
 import numpy as np
 from pydantic.dataclasses import dataclass
 from dataclasses import field
@@ -9,9 +10,10 @@ from shapely.affinity import scale
 import shapely.geometry as geo
 
 from FiberFusing.geometries.base_class import Alteration
+from FiberFusing.utils import config_dict
 from FiberFusing import geometries
 
-@dataclass(config=geometries.config_dict)
+@dataclass(config=config_dict)
 class LineString(Alteration):
     coordinates: Optional[Tuple] = field(default=None, repr=False)
     instance: Optional[geo.LineString] = field(default=None, repr=False)

{fiberfusing-1.9.4 → fiberfusing-1.9.7}/FiberFusing/geometries/point.py

@@ -2,18 +2,20 @@
 # -*- coding: utf-8 -*-
 
 # Built-in imports
-from typing import Optional, Tuple, Self
+from typing import Optional, Tuple, List
+from typing_extensions import Self
 import numpy
 from pydantic.dataclasses import dataclass
 import shapely.geometry as geo
 import matplotlib.pyplot as plt
+from FiberFusing.plottings import plotting
 
-from FiberFusing.helper import _plot_helper
 from FiberFusing import geometries
+from FiberFusing.utils import config_dict
 
-@dataclass(config=geometries.config_dict)
+@dataclass(config=config_dict)
 class Point(geometries.base_class.Alteration):
-    position: Optional[Tuple[float, float]] = None
+    position: Tuple[float, float] | List[float] | None = None
     instance: Optional[geo.Point] = None
     index: Optional[float] = None
 
@@ -106,8 +108,8 @@ class Point(geometries.base_class.Alteration):
         """
         return numpy.sqrt((self.x - other.x)**2 + (self.y - other.y)**2)
 
-    @_plot_helper
-    def plot(self, ax: plt.Axes = None, marker: str = 'x', size: int = 20, label: str = None) -> None:
+    @plotting(nrows=1, ncols=1)
+    def plot(self, axes: plt.Axes, marker: str = 'x', size: int = 20, label: str = None) -> None:
         """
         Renders this point on the given axis, optionally with text.
 
@@ -122,4 +124,4 @@ class Point(geometries.base_class.Alteration):
         label : str
             The label for the point, if any.
         """
-        ax.scatter(self.x, self.y, label=label, marker=marker, s=size)
+        axes.scatter(self.x, self.y, label=label, marker=marker, s=size)

{fiberfusing-1.9.4 → fiberfusing-1.9.7}/FiberFusing/geometries/polygon.py

@@ -1,7 +1,8 @@
 #!/usr/bin/env python
 # -*- coding: utf-8 -*-
 
-from typing import Iterable, List, Optional, Union, Tuple, Self
+from typing import Iterable, List, Optional, Union, Tuple
+from typing_extensions import Self
 import numpy as np
 from matplotlib.path import Path
 import shapely.geometry as geo
@@ -10,8 +11,7 @@ from shapely.ops import split
 from shapely import affinity
 
 from FiberFusing.coordinate_system import CoordinateSystem
-from FiberFusing.plottings import plot_polygon
-from FiberFusing.helper import _plot_helper
+from FiberFusing.plottings import plot_polygon, plotting
 from FiberFusing import geometries
 
 class Polygon(geometries.base_class.Alteration):
@@ -142,8 +142,8 @@ class Polygon(geometries.base_class.Alteration):
         # Points are inside if they are in the exterior but not in any hole
         return exterior_mask & ~hole_mask
 
-    @_plot_helper
-    def plot(self, ax: plt.Axes, **kwargs) -> None:
+    @plotting(nrows=1, ncols=1)
+    def plot(self, axes: plt.Axes, **kwargs) -> None:
         """
         Plots the polygon on the given Matplotlib axis.
 
@@ -154,7 +154,7 @@ class Polygon(geometries.base_class.Alteration):
         **kwargs
             Additional keyword arguments passed to the plotting function.
         """
-        plot_polygon(ax=ax, polygon=self._shapely_object, **kwargs)
+        plot_polygon(ax=axes, polygon=self._shapely_object, **kwargs)
 
     def rasterize(self, coordinate_system: CoordinateSystem) -> np.ndarray:
         """

{fiberfusing-1.9.4 → fiberfusing-1.9.7}/FiberFusing/geometry.py

@@ -7,16 +7,20 @@ import numpy
 from scipy.ndimage import gaussian_filter
 import FiberFusing
 import matplotlib.pyplot as plt
-from FiberFusing.coordinate_system import CoordinateSystem
-from mpl_toolkits.axes_grid1 import make_axes_locatable
 import matplotlib.colors as colors
-from MPSPlots.styles import mps
-from FiberFusing.helper import _plot_helper
-from pydantic import field_validator, ConfigDict
+from mpl_toolkits.axes_grid1 import make_axes_locatable
+from pydantic import field_validator
 from pydantic.dataclasses import dataclass
+from FiberFusing.plottings import plotting
+
+
+from FiberFusing.coordinate_system import CoordinateSystem
+from FiberFusing.utils import config_dict
+
 
 class DomainAlignment(Enum):
     """Boundary positioning modes."""
+
     AUTO = "auto"
     LEFT = "left"
     RIGHT = "right"
@@ -25,8 +29,8 @@ class DomainAlignment(Enum):
     CENTERING = "centering"
 
 
-@dataclass(config=ConfigDict(extra='forbid', kw_only=True, arbitrary_types_allowed=True))
-class Geometry():
+@dataclass(config=config_dict)
+class Geometry:
     """
     Represents the refractive index (RI) geometric profile including background and fiber structures.
 
@@ -73,28 +77,28 @@ class Geometry():
         """
         self.structure_list.extend(structure)
 
-    @field_validator('resolution')
+    @field_validator("resolution")
     @classmethod
     def validate_resolution(cls, v: int) -> int:
         """Validate resolution is positive."""
         if v <= 0:
-            raise ValueError('Resolution must be positive')
+            raise ValueError("Resolution must be positive")
         return v
 
-    @field_validator('boundary_pad_factor')
+    @field_validator("boundary_pad_factor")
     @classmethod
     def validate_boundary_pad_factor(cls, v: float) -> float:
         """Validate boundary pad factor is positive."""
         if v <= 0:
-            raise ValueError('Boundary pad factor must be positive')
+            raise ValueError("Boundary pad factor must be positive")
         return v
 
-    @field_validator('index_scrambling')
+    @field_validator("index_scrambling")
     @classmethod
     def validate_index_scrambling(cls, v: float) -> float:
         """Validate index scrambling is non-negative."""
         if v < 0:
-            raise ValueError('Index scrambling must be non-negative')
+            raise ValueError("Index scrambling must be non-negative")
         return v
 
     def initialize(self):
@@ -105,7 +109,12 @@ class Geometry():
         x_min, y_min, x_max, y_max = self.get_boundaries()
 
         self.coordinate_system = CoordinateSystem(
-            x_min=x_min, x_max=x_max, y_min=y_min, y_max=y_max, nx=self.resolution, ny=self.resolution
+            x_min=x_min,
+            x_max=x_max,
+            y_min=y_min,
+            y_max=y_max,
+            nx=self.resolution,
+            ny=self.resolution,
         )
 
         self.coordinate_system.center(factor=self.boundary_pad_factor)
@@ -124,14 +133,21 @@ class Geometry():
         x_min, y_min, x_max, y_max = self.get_boundaries()
 
         self.coordinate_system = CoordinateSystem(
-            x_min=x_min, x_max=x_max, y_min=y_min, y_max=y_max, nx=self.resolution, ny=self.resolution
+            x_min=x_min,
+            x_max=x_max,
+            y_min=y_min,
+            y_max=y_max,
+            nx=self.resolution,
+            ny=self.resolution,
         )
         self.coordinate_system.center(factor=self.boundary_pad_factor)
         self.apply_boundary_settings()
 
-    @field_validator('x_bounds')
+    @field_validator("x_bounds")
     @classmethod
-    def validate_x_bounds(cls, v: Union[DomainAlignment, Tuple[float, float]]) -> Union[DomainAlignment, Tuple[float, float]]:
+    def validate_x_bounds(
+        cls, v: Union[DomainAlignment, Tuple[float, float]]
+    ) -> Union[DomainAlignment, Tuple[float, float]]:
         """Validate x_bounds parameter."""
         if isinstance(v, (list, tuple)):
             if len(v) != 2:
@@ -142,9 +158,11 @@ class Geometry():
             raise ValueError("x_bounds must be a tuple or DomainAlignment")
         return v
 
-    @field_validator('y_bounds')
+    @field_validator("y_bounds")
     @classmethod
-    def validate_y_bounds(cls, v: Union[DomainAlignment, Tuple[float, float]]) -> Union[DomainAlignment, Tuple[float, float]]:
+    def validate_y_bounds(
+        cls, v: Union[DomainAlignment, Tuple[float, float]]
+    ) -> Union[DomainAlignment, Tuple[float, float]]:
         """Validate y_bounds parameter."""
         if isinstance(v, (list, tuple)):
             if len(v) != 2:
@@ -157,14 +175,18 @@ class Geometry():
 
     def apply_boundary_settings(self) -> None:
         """Apply boundary settings to coordinate system."""
-        if hasattr(self, 'coordinate_system') and self.coordinate_system is not None:
+        if hasattr(self, "coordinate_system") and self.coordinate_system is not None:
             if isinstance(self.x_bounds, (list, tuple)):
-                self.coordinate_system.x_min, self.coordinate_system.x_max = self.x_bounds
+                self.coordinate_system.x_min, self.coordinate_system.x_max = (
+                    self.x_bounds
+                )
             elif isinstance(self.x_bounds, DomainAlignment):
                 self._apply_x_boundary_mode(self.x_bounds)
 
             if isinstance(self.y_bounds, (list, tuple)):
-                self.coordinate_system.y_min, self.coordinate_system.y_max = self.y_bounds
+                self.coordinate_system.y_min, self.coordinate_system.y_max = (
+                    self.y_bounds
+                )
             elif isinstance(self.y_bounds, DomainAlignment):
                 self._apply_y_boundary_mode(self.y_bounds)
 
@@ -206,10 +228,16 @@ class Geometry():
             The boundaries as (x_min, y_min, x_max, y_max).
 
         """
-        filtered_structures = [obj for obj in self.structure_list if not isinstance(obj, FiberFusing.background.BackGround)]
+        filtered_structures = [
+            obj
+            for obj in self.structure_list
+            if not isinstance(obj, FiberFusing.background.BackGround)
+        ]
 
         if len(filtered_structures) == 0:
-            raise ValueError('No structures provided (other than background) for computing the mesh.')
+            raise ValueError(
+                "No structures provided (other than background) for computing the mesh."
+            )
 
         x_min, y_min, x_max, y_max = zip(
             *(obj.get_structure_max_min_boundaries() for obj in filtered_structures)
@@ -226,7 +254,11 @@ class Geometry():
         float
             Maximum refractive index.
         """
-        return max(refractive_index for obj in self.structure_list for refractive_index in obj.refractive_index_list)
+        return max(
+            refractive_index
+            for obj in self.structure_list
+            for refractive_index in obj.refractive_index_list
+        )
 
     @property
     def refractive_index_minimum(self) -> float:
@@ -238,7 +270,12 @@ class Geometry():
         float
             Minimum refractive index.
         """
-        return min(refractive_index for obj in self.structure_list if not isinstance(obj, FiberFusing.background.BackGround) for refractive_index in obj.refractive_index_list)
+        return min(
+            refractive_index
+            for obj in self.structure_list
+            if not isinstance(obj, FiberFusing.background.BackGround)
+            for refractive_index in obj.refractive_index_list
+        )
 
     def get_index_range(self) -> List[float]:
         """
@@ -276,7 +313,12 @@ class Geometry():
         """
         for fiber in self.fiber_list:
             for structure in fiber.inner_structure:
-                adjustment = structure.refractive_index * self.refractive_index_scrambling * numpy.random.rand() * random_factor
+                adjustment = (
+                    structure.refractive_index
+                    * self.refractive_index_scrambling
+                    * numpy.random.rand()
+                    * random_factor
+                )
                 structure.refractive_index += adjustment
 
         self.mesh = self.generate_mesh()
@@ -298,7 +340,9 @@ class Geometry():
         mesh = numpy.zeros(self.coordinate_system.shape)
 
         for structure in self.structure_list:
-            structure.overlay_structures_on_mesh(mesh=mesh, coordinate_system=self.coordinate_system)
+            structure.overlay_structures_on_mesh(
+                mesh=mesh, coordinate_system=self.coordinate_system
+            )
 
         return mesh
 
@@ -316,8 +360,10 @@ class Geometry():
         AttributeError
             If the coordinate system has not been generated before calling this method.
         """
-        if not hasattr(self, 'coordinate_system'):
-            raise AttributeError("Coordinate system has not been generated. Call generate_coordinate_system() first.")
+        if not hasattr(self, "coordinate_system"):
+            raise AttributeError(
+                "Coordinate system has not been generated. Call generate_coordinate_system() first."
+            )
 
         mesh = self.rasterize_polygons()
 
@@ -326,8 +372,8 @@ class Geometry():
 
         return mesh
 
-    @_plot_helper
-    def plot_patch(self, ax: plt.Axes = None, show: bool = True) -> None:
+    @plotting(nrows=1, ncols=1)
+    def plot_patch(self, axes: plt.Axes) -> None:
         """
         Render the patch representation of the geometry onto a given matplotlib axis.
 
@@ -347,16 +393,24 @@ class Geometry():
                 continue
 
             if isinstance(structure, FiberFusing.profile.Profile):
-                structure.plot(ax=ax, show=False, show_added=False, show_removed=False, show_centers=False, show_fibers=True)
+                structure.plot(
+                    axes=axes,
+                    show=False,
+                    show_added=False,
+                    show_removed=False,
+                    show_centers=False,
+                    show_fibers=True,
+                )
                 continue
 
-            structure.plot(ax=ax, show=False)
+            structure.plot(axes=axes, show=False)
 
-        ax.set(title='Fiber structure', xlabel=r'x-distance [m]', ylabel=r'y-distance [m]')
-        ax.ticklabel_format(axis='both', style='sci', scilimits=(-6, -6), useOffset=False)
+        axes.set(
+            title="Fiber structure", xlabel=r"x-distance [m]", ylabel=r"y-distance [m]"
+        )
 
-    @_plot_helper
-    def plot_raster(self, ax: plt.Axes = None, gamma: float = 5) -> None:
+    @plotting(nrows=1, ncols=1)
+    def plot_raster(self, axes: plt.Axes, gamma: float = 5) -> None:
         """
         Render the rasterized representation of the geometry onto a given matplotlib axis.
 
@@ -373,31 +427,35 @@ class Geometry():
         -------
         None
         """
-        image = ax.pcolormesh(
+        image = axes.pcolormesh(
             self.coordinate_system.x_vector,
             self.coordinate_system.y_vector,
             self.mesh,
-            cmap='Blues',
-            norm=colors.PowerNorm(gamma=gamma)
+            cmap="Blues",
+            norm=colors.PowerNorm(gamma=gamma),
         )
 
-        divider = make_axes_locatable(ax)
-        cax = divider.append_axes('right', size='5%', pad=0.05)
-        ax.get_figure().colorbar(image, cax=cax, orientation='vertical')
+        divider = make_axes_locatable(axes)
+        cax = divider.append_axes("right", size="5%", pad=0.05)
+        axes.get_figure().colorbar(image, cax=cax, orientation="vertical")
 
-        ax.set(title='Fiber structure', xlabel=r'x-distance [m]', ylabel=r'y-distance [m]')
-        ax.ticklabel_format(axis='both', style='sci', scilimits=(-6, -6), useOffset=False)
+        axes.set(
+            title="Fiber structure", xlabel=r"x-distance [m]", ylabel=r"y-distance [m]"
+        )
 
-    def plot(self, show_patch: bool = True, show_mesh: bool = True, show: bool = True, gamma: float = 5) -> plt.Figure:
+    @plotting(
+        nrows=1,
+        ncols=2,
+        subplot_kw=dict(
+            aspect="equal", xlabel="x-distance [m]", ylabel="y-distance [m]"
+        ),
+    )
+    def plot(self, axes, gamma: float = 5) -> plt.Figure:
         """
         Plot the different representations (patch and mesh) of the geometry.
 
         Parameters
         ----------
-        show_patch : bool, optional
-            Whether to display the patch representation of the geometry. Default is True.
-        show_mesh : bool, optional
-            Whether to display the mesh (rasterized) representation of the geometry. Default is True.
         show : bool, optional
             Whether to immediately show the plot. Default is True.
         gamma : float, optional
@@ -408,29 +466,9 @@ class Geometry():
         plt.Figure
             The matplotlib figure encompassing all the axes used in the plot.
         """
-        n_ax = bool(show_patch) + bool(show_mesh)
-        unit_size = numpy.array([1, n_ax])
-
-        with plt.style.context(mps):
-            figure, axes = plt.subplots(
-                *unit_size,
-                figsize=5 * numpy.flip(unit_size),
-                sharex=True,
-                sharey=True,
-                subplot_kw=dict(aspect='equal', xlabel='x-distance [m]', ylabel='y-distance [m]'),
-            )
-
-        axes_iter = iter(axes.flatten())
-
-        if show_patch:
-            ax = next(axes_iter)
-            self.plot_patch(ax, show=False)
-
-        if show_mesh:
-            ax = next(axes_iter)
-            self.plot_raster(ax, show=False, gamma=gamma)
+        axes[0].sharex(axes[1])
+        axes[0].sharey(axes[1])
 
-        if show:
-            plt.show()
+        self.plot_patch(axes=axes[0], show=False)
 
-        return figure
+        self.plot_raster(axes=axes[1], show=False, gamma=gamma)