emerge 0.6.8__tar.gz → 0.6.9__tar.gz

{emerge-0.6.8 → emerge-0.6.9}/.bumpversion.toml

@@ -1,5 +1,5 @@
 [tool.bumpversion]
-current_version = "0.6.8"
+current_version = "0.6.9"
 parse = "(?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)"
 serialize = ["{major}.{minor}.{patch}"]
 search = "{current_version}"

{emerge-0.6.8 → emerge-0.6.9}/.gitignore

@@ -42,7 +42,7 @@ manual_scripts/
 tests/
 trial_scripts/
 wheelhouse/
-
+benchmarks/
 .pytest_cache/
 
 .vscode/

{emerge-0.6.8 → emerge-0.6.9}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.4
 Name: emerge
-Version: 0.6.8
+Version: 0.6.9
 Summary: An open source EM FEM simulator in Python
 Project-URL: Homepage, https://github.com/FennisRobert/EMerge
 Project-URL: Issues, https://github.com/FennisRobert/EMerge/issues
 License-File: LICENSE
 Requires-Python: <4.0,>=3.10
+Requires-Dist: cloudpickle>=3.1.1
 Requires-Dist: gmsh<4.14.0,>=4.13.0
 Requires-Dist: joblib>=1.5.1
 Requires-Dist: loguru>=0.7.3

{emerge-0.6.8 → emerge-0.6.9}/emerge/__init__.py

@@ -18,7 +18,7 @@ along with this program; if not, see
 """
 import os
 
-__version__ = "0.6.8"
+__version__ = "0.6.9"
 
 ############################################################
 #               HANDLE ENVIRONMENT VARIABLES              #

{emerge-0.6.8 → emerge-0.6.9}/emerge/_emerge/geometry.py

@@ -61,8 +61,11 @@ class _GeometryManager:
         self.geometry_list[model].append(geo)
 
     def sign_in(self, modelname: str) -> None:
-        if modelname not in self.geometry_list:
-            self.geometry_list[modelname] = []
+        # if modelname not in self.geometry_list:
+        #     self.geometry_list[modelname] = []
+        if modelname is self.geometry_list:
+            logger.warning(f'{modelname} already exist, Geometries will be reset.')
+        self.geometry_list[modelname] = []
         self.active = modelname
 
     def reset(self, modelname: str) -> None:
@@ -242,6 +245,10 @@ class GeoObject:
     def opacity(self) -> float:
         return self.material.opacity
     
+    @property
+    def _metal(self) -> bool:
+        return self.material._metal
+    
     @property
     def select(self) -> Selection:
         '''Returns a corresponding Face/Domain or Edge Selection object'''

{emerge-0.6.8 → emerge-0.6.9}/emerge/_emerge/material.py

@@ -289,7 +289,9 @@ class Material:
                  cond: float | MatProperty = 0.0,
                  _neff: float | None = None,
                  color: str ="#BEBEBE",
-                 opacity: float = 1.0):
+                 opacity: float = 1.0,
+                 _metal: bool = False,
+                 name: str = 'unnamed'):
         
         if not isinstance(er, MatProperty):
             er = MatProperty(er)
@@ -300,6 +302,7 @@ class Material:
         if not isinstance(cond, MatProperty):
             cond = MatProperty(cond)
         
+        self.name: str = name
         self.er: MatProperty = er
         self.ur: MatProperty = ur
         self.tand: MatProperty = tand
@@ -313,6 +316,10 @@ class Material:
             self._neff: Callable = lambda f: _neff
         hex_str = self.color.lstrip('#')
         self._color_rgb = tuple(int(hex_str[i:i+2], 16)/255.0 for i in (0, 2, 4))
+        self._metal: bool = _metal
+
+    def __str__(self) -> str:
+        return f'Material({self.name})'
     
     def initialize(self, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray, ids: np.ndarray):
         """Initializes the Material properties to be evaluated at xyz-coordinates for
@@ -364,5 +371,5 @@ class Material:
     def color_rgb(self) -> tuple[float,float,float]:
         return self._color_rgb
      
-AIR = Material(color="#4496f3", opacity=0.05)
-COPPER = Material(cond=5.8e7, color="#62290c")
+AIR = Material(color="#4496f3", opacity=0.05, name='Air')
+COPPER = Material(cond=5.8e7, color="#62290c", _metal=True, name='Copper')

{emerge-0.6.8 → emerge-0.6.9}/emerge/_emerge/physics/microwave/microwave_bc.py

@@ -354,7 +354,7 @@ class FloquetPort(PortBC):
         if cs is None:
             cs = GCS
         self.port_number: int= port_number
-        self.active: bool = True
+        self.active: bool = False
         self.power: float = power
         self.type: str = 'TEM'
         self.mode: tuple[int,int] = (1,0)
@@ -439,7 +439,6 @@ class ModalPort(PortBC):
     def __init__(self,
                  face: FaceSelection | GeoSurface,
                  port_number: int, 
-                 active: bool = False,
                  cs: CoordinateSystem | None = None,
                  power: float = 1,
                  TEM: bool = False,
@@ -457,7 +456,6 @@ class ModalPort(PortBC):
         Args:
             face (FaceSelection, GeoSurface): The port mode face
             port_number (int): The port number as an integer
-            active (bool, optional): Whether the port is set active. Defaults to False.
             cs (CoordinateSystem, optional): The local coordinate system of the port face. Defaults to None.
             power (float, optional): The radiated power. Defaults to 1.
             TEM (bool, optional): Wether the mode should be considered as a TEM mode. Defaults to False
@@ -467,7 +465,7 @@ class ModalPort(PortBC):
         super().__init__(face)
 
         self.port_number: int= port_number
-        self.active: bool = active
+        self.active: bool = False
         self.power: float = power
         self.alignment_vectors: list[Axis] = []
 
@@ -666,7 +664,7 @@ class RectangularWaveguide(PortBC):
     def __init__(self, 
                  face: FaceSelection | GeoSurface,
                  port_number: int, 
-                 active: bool = False,
+                 mode: tuple[int, int] = (1,0),
                  cs: CoordinateSystem | None = None,
                  dims: tuple[float, float] | None = None,
                  power: float = 1):
@@ -681,7 +679,7 @@ class RectangularWaveguide(PortBC):
         Args:
             face (FaceSelection, GeoSurface): The port boundary face selection
             port_number (int): The port number
-            active (bool, optional): Ther the port is active. Defaults to False.
+            mode: (tuple[int, int], optional): The TE mode number. Defaults to (1,0).
             cs (CoordinateSystem, optional): The local coordinate system. Defaults to None.
             dims (tuple[float, float], optional): The port face. Defaults to None.
             power (float): The port power. Default to 1.
@@ -689,10 +687,10 @@ class RectangularWaveguide(PortBC):
         super().__init__(face)
 
         self.port_number: int= port_number
-        self.active: bool = active
+        self.active: bool = False
         self.power: float = power
         self.type: str = 'TE'
-        self.mode: tuple[int,int] = (1,0)
+        self.mode: tuple[int,int] = mode
 
         if dims is None:
             logger.info("Determining port face based on selection")
@@ -701,13 +699,12 @@ class RectangularWaveguide(PortBC):
             self.dims = (width, height)
             logger.debug(f'Port CS: {self.cs}')
             logger.debug(f'Detected port {self.port_number} size = {width*1000:.1f} mm x {height*1000:.1f} mm')
-        
+        else:
+            self.dims = dims
+            self.cs = cs
         if self.cs is None:
             logger.info('Constructing coordinate system from normal port')
             self.cs = Axis(self.selection.normal).construct_cs()
-        else:
-            self.cs: CoordinateSystem = cs # type: ignore
-
     def get_basis(self) -> np.ndarray:
         return self.cs._basis
         
@@ -755,11 +752,12 @@ class RectangularWaveguide(PortBC):
 
         width = self.dims[0]
         height = self.dims[1]
-
-        E = self.get_amplitude(k0)*np.cos(np.pi*self.mode[0]*(x_local)/width)*np.cos(np.pi*self.mode[1]*(y_local)/height)
-        Ex = 0*E
-        Ey = E
-        Ez = 0*E
+        m, n= self.mode
+        Ev = self.get_amplitude(k0)*np.cos(np.pi*m*(x_local)/width)*np.cos(np.pi*n*(y_local)/height)
+        Eh = self.get_amplitude(k0)*np.sin(np.pi*m*(x_local)/width)*np.sin(np.pi*n*(y_local)/height)
+        Ex = Eh
+        Ey = Ev
+        Ez = 0*Eh
         Exyz =  self._qmode(k0) * np.array([Ex, Ey, Ez])
         return Exyz
 
@@ -787,7 +785,6 @@ class LumpedPort(PortBC):
                  width: float | None = None,
                  height: float | None = None,
                  direction: Axis | None = None,
-                 active: bool = False,
                  power: float = 1,
                  Z0: float = 50):
         """Generates a lumped power boundary condition.
@@ -804,7 +801,6 @@ class LumpedPort(PortBC):
             width (float): The port width (meters).
             height (float): The port height (meters).
             direction (Axis): The port direction as an Axis object (em.Axis(..) or em.ZAX)
-            active (bool, optional): Whether the port is active. Defaults to False.
             power (float, optional): The port output power. Defaults to 1.
             Z0 (float, optional): The port impedance. Defaults to 50.
         """
@@ -819,7 +815,7 @@ class LumpedPort(PortBC):
         
         logger.debug(f'Lumped port: width={1000*width:.1f}mm, height={1000*height:.1f}mm, direction={direction}') # type: ignore
         self.port_number: int= port_number
-        self.active: bool = active
+        self.active: bool = False
 
         self.power: float = power
         self.Z0: float = Z0

{emerge-0.6.8 → emerge-0.6.9}/emerge/_emerge/physics/microwave/microwave_data.py

@@ -20,7 +20,7 @@ from ...simulation_data import BaseDataset, DataContainer
 from ...elements.femdata import FEMBasis
 from dataclasses import dataclass
 import numpy as np
-from typing import Literal
+from typing import Literal, Callable
 from loguru import logger
 from .adaptive_freq import SparamModel
 from ...cs import Axis, _parse_axis
@@ -1018,7 +1018,8 @@ class MWField:
         k0 = self.k0
         return vertices, triangles, E, H, origin, k0
     
-    def optycal_antenna(self, faces: FaceSelection | GeoSurface | None = None,
+    def optycal_antenna(self, 
+                        faces: FaceSelection | GeoSurface | None = None,
                         origin: tuple[float, float, float] | None = None,
                         syms: list[Literal['Ex','Ey','Ez', 'Hx','Hy','Hz']] | None = None) -> dict:
         """Export this models exterior to an Optical acceptable dataset
@@ -1036,6 +1037,32 @@ class MWField:
     
         return dict(freq=freq, ff_function=function)
 
+    # def surface_integral(self, faces: FaceSelection | GeoSurface, fieldfunction: Callable) -> float | complex:
+    #     """Computes a surface integral on the selected faces. 
+    
+    #     The fieldfunction argument must be a callable of a single argument x, which will
+    #     be of type EHField which is restuned by the field.interpolate(x,y,z) function. It has
+    #     fields like Ez, Ey, Sx etc that can be called. 
+
+    #     Args:
+    #         faces (FaceSelection | GeoSurface): _description_
+    #         fieldfunction (Callable): _description_
+
+    #     Returns:
+    #         float | complex: _description_
+    #     """
+    #     from ...mth.integrals import surface_integral
+        
+    #     def ff(x, y, z):
+    #         fieldobj = self.interpolate(x,y,z)
+    #         return fieldfunction(fieldobj)
+        
+    #     nodes = self.mesh.get_nodes(faces.tags)
+    #     triangles = self.mesh.get_triangles(faces.tags)
+        
+    #     return surface_integral(nodes, triangles, ff)
+        
+        
 class MWScalar:
     """The MWDataSet class stores solution data of FEM Time Harmonic simulations.
     """

{emerge-0.6.8 → emerge-0.6.9}/emerge/_emerge/plot/pyvista/display.py

@@ -284,15 +284,16 @@ class PVDisplay(BaseDisplay):
         self._ruler.min_length = max(1e-3, min(self._mesh.edge_lengths))
         self._update_camera()
         self._add_aux_items()
+        # self._plot.renderer.enable_depth_peeling(20, 0.8)
+        # self._plot.enable_anti_aliasing(self.set.anti_aliassing)
         if self._do_animate:
             self._wire_close_events()
             self.add_text('Press Q to close!',color='red', position='upper_left')
             self._plot.show(auto_close=False, interactive_update=True, before_close_callback=self._close_callback)
             self._animate()
-            
-            
         else:
             self._plot.show()
+        
         self._reset()
     
     def set_mesh(self, mesh: Mesh3D):
@@ -440,8 +441,20 @@ class PVDisplay(BaseDisplay):
         opacity = obj.opacity
         line_width = 0.5
         color = obj.color_rgb
+        metal = obj._metal
         style='surface'
         
+        # Default render settings
+        metallic = 0.05
+        roughness = 0.5
+        pbr = False
+        
+        if metal:
+            pbr = True
+            metallic = 0.8
+            roughness = 0.3
+        
+        # Default keyword arguments when plotting Mesh mode.
         if mesh is True:
             show_edges = True
             opacity = 0.7
@@ -449,13 +462,28 @@ class PVDisplay(BaseDisplay):
             style='wireframe'
             color=next(C_CYCLE)
         
-        kwargs = setdefault(kwargs, color=color, opacity=opacity, line_width=line_width, show_edges=show_edges, pickable=True, style=style)
+        # Defining the default keyword arguments for PyVista
+        kwargs = setdefault(kwargs, color=color, 
+                            opacity=opacity, 
+                            metallic=metallic, 
+                            pbr=pbr,
+                            roughness=roughness,
+                            line_width=line_width, 
+                            show_edges=show_edges, 
+                            pickable=True, 
+                            style=style)
         mesh_obj = self.mesh(obj)
         
         if mesh is True and volume_mesh is True:
             mesh_obj = mesh_obj.extract_all_edges()
-        
         actor = self._plot.add_mesh(mesh_obj, *args, **kwargs)
+        
+        # Push 3D Geometries back to avoid Z-fighting with 2D geometries.
+        if obj.dim==3:
+            mapper = actor.GetMapper()
+            mapper.SetResolveCoincidentTopology(1)
+            mapper.SetRelativeCoincidentTopologyPolygonOffsetParameters(1,1)
+        
         self._plot.add_mesh(self._volume_edges(_select(obj)), color='#000000', line_width=2, show_edges=True)
 
     def add_scatter(self, xs: np.ndarray, ys: np.ndarray, zs: np.ndarray):

{emerge-0.6.8 → emerge-0.6.9}/emerge/_emerge/plot/pyvista/display_settings.py

@@ -1,3 +1,4 @@
+from typing import Literal
 
 class PVDisplaySettings:
 
@@ -22,4 +23,6 @@ class PVDisplaySettings:
         self.background_bottom: str = "#c0d2e8"
         self.background_top: str = "#ffffff"
         self.grid_line_color: str = "#8e8e8e"
-        self.z_boost: float = 1e-6
+        self.z_boost: float = 0#1e-9
+        self.depth_peeling: bool = True
+        self.anti_aliassing: Literal["msaa","ssaa",'fxaa'] = "msaa"

{emerge-0.6.8 → emerge-0.6.9}/emerge/_emerge/plot/simple_plots.py

@@ -406,21 +406,21 @@ and sparse frequency annotations (e.g., labeled by frequency).
     plt.tight_layout()
     plt.show()
 
-def plot_sp(f: np.ndarray, S: list[np.ndarray] | np.ndarray, 
-                      dblim=[-40, 5], 
-                    xunit="GHz", 
-                    levelindicator: int | float | None = None, 
-                    noise_floor=-150, 
-                    fill_areas: list[tuple] | None = None, 
-                    spec_area: list[tuple[float,...]] | None = None,
-                    unwrap_phase=False, 
-                    logx: bool = False,
-                    labels: list[str] | None = None,
-                    linestyles: list[str] | None = None,
-                    colorcycle: list[int] | None = None,
-                    filename: str | None = None,
-                    show_plot: bool = True,
-                    figdata: tuple | None = None) -> tuple[plt.Figure, plt.Axes, plt.Axes]:
+def plot_sp(f: np.ndarray | list[np.ndarray], S: list[np.ndarray] | np.ndarray, 
+            dblim=[-40, 5], 
+            xunit="GHz", 
+            levelindicator: int | float | None = None, 
+            noise_floor=-150, 
+            fill_areas: list[tuple] | None = None, 
+            spec_area: list[tuple[float,...]] | None = None,
+            unwrap_phase=False, 
+            logx: bool = False,
+            labels: list[str] | None = None,
+            linestyles: list[str] | None = None,
+            colorcycle: list[int] | None = None,
+            filename: str | None = None,
+            show_plot: bool = True,
+            figdata: tuple | None = None) -> tuple[plt.Figure, plt.Axes, plt.Axes]:
     """Plot S-parameters in dB and phase
 
     Args:
@@ -444,7 +444,12 @@ def plot_sp(f: np.ndarray, S: list[np.ndarray] | np.ndarray,
         Ss = [S]
     else:
         Ss = S
-
+        
+    if not isinstance(f, list):
+        fs = [f for _ in Ss]
+    else:
+        fs = f
+    
     if linestyles is None:
         linestyles = ['-' for _ in S]
 
@@ -452,7 +457,8 @@ def plot_sp(f: np.ndarray, S: list[np.ndarray] | np.ndarray,
         colorcycle = [i for i, S in enumerate(S)]
 
     unitdivider: dict[str, float] = {"MHz": 1e6, "GHz": 1e9, "kHz": 1e3}
-    fnew = f / unitdivider[xunit]
+    
+    fs = [f / unitdivider[xunit] for f in fs]
 
     if figdata is None:
         # Create two subplots: one for magnitude and one for phase
@@ -463,10 +469,10 @@ def plot_sp(f: np.ndarray, S: list[np.ndarray] | np.ndarray,
     minphase, maxphase = -180, 180
 
     maxy = 0
-    for s, ls, cid in zip(Ss, linestyles, colorcycle):
+    for f, s, ls, cid in zip(fs, Ss, linestyles, colorcycle):
         # Calculate and plot magnitude in dB
         SdB = 20 * np.log10(np.abs(s) + 10**(noise_floor/20) * np.random.rand(*s.shape) + 10**((noise_floor-30)/20))
-        ax_mag.plot(fnew, SdB, label="Magnitude (dB)", linestyle=ls, color=EMERGE_COLORS[cid % len(EMERGE_COLORS)])
+        ax_mag.plot(f, SdB, label="Magnitude (dB)", linestyle=ls, color=EMERGE_COLORS[cid % len(EMERGE_COLORS)])
         if np.max(SdB) > maxy:
             maxy = np.max(SdB)
         # Calculate and plot phase in degrees
@@ -475,12 +481,12 @@ def plot_sp(f: np.ndarray, S: list[np.ndarray] | np.ndarray,
             phase = np.unwrap(phase, period=360)
             minphase = min(np.min(phase), minphase)
             maxphase = max(np.max(phase), maxphase)
-        ax_phase.plot(fnew, phase, label="Phase (degrees)", linestyle=ls, color=EMERGE_COLORS[cid % len(EMERGE_COLORS)])
+        ax_phase.plot(f, phase, label="Phase (degrees)", linestyle=ls, color=EMERGE_COLORS[cid % len(EMERGE_COLORS)])
 
         # Annotate level indicators if specified
         if isinstance(levelindicator, (int, float)) and levelindicator is not None:
             lvl = levelindicator
-            fcross = hintersections(fnew, SdB, lvl)
+            fcross = hintersections(f, SdB, lvl)
             for fs in fcross:
                 ax_mag.annotate(
                     f"{str(fs)[:4]}{xunit}",
@@ -500,16 +506,18 @@ def plot_sp(f: np.ndarray, S: list[np.ndarray] | np.ndarray,
             f2 = fmax / unitdivider[xunit]
             ax_mag.fill_between([f1, f2], vmin,vmax, color='red', alpha=0.2)
     # Configure magnitude plot (ax_mag)
+    fmin = min([min(f) for f in fs])
+    fmax = max([max(f) for f in fs])
     ax_mag.set_ylabel("Magnitude (dB)")
     ax_mag.set_xlabel(f"Frequency ({xunit})")
-    ax_mag.axis([min(fnew), max(fnew), dblim[0], max(maxy*1.1,dblim[1])]) # type: ignore
+    ax_mag.axis([fmin, fmax, dblim[0], max(maxy*1.1,dblim[1])]) # type: ignore
     ax_mag.axhline(y=0, color="k", linewidth=1)
     ax_mag.xaxis.set_minor_locator(tck.AutoMinorLocator(2))
     ax_mag.yaxis.set_minor_locator(tck.AutoMinorLocator(2))
     # Configure phase plot (ax_phase)
     ax_phase.set_ylabel("Phase (degrees)")
     ax_phase.set_xlabel(f"Frequency ({xunit})")
-    ax_phase.axis([min(fnew), max(fnew), minphase, maxphase]) # type: ignore
+    ax_phase.axis([fmin, fmax, minphase, maxphase]) # type: ignore
     ax_phase.xaxis.set_minor_locator(tck.AutoMinorLocator(2))
     ax_phase.yaxis.set_minor_locator(tck.AutoMinorLocator(2))
     if logx:
@@ -612,6 +620,8 @@ def plot_ff(
 def plot_ff_polar(
     theta: np.ndarray,
     E: Union[np.ndarray, Sequence[np.ndarray]],
+    dB: bool = False,
+    dBfloor: float = -30,
     labels: Optional[List[str]] = None,
     linestyles: Union[str, List[str]] = "-",
     linewidth: float = 2.0,
@@ -649,6 +659,8 @@ def plot_ff_polar(
         E_list = list(E)
     n_series = len(E_list)
 
+    if dB:
+        E_list = [20*np.log10(np.clip(np.abs(e), a_min=10**(dBfloor/20), a_max = 1e9)) for e in E_list]
     # Style broadcasting
     def _broadcast(param, default):
         if isinstance(param, list):
@@ -665,11 +677,15 @@ def plot_ff_polar(
     ax.set_theta_zero_location(zero_location) # type: ignore
     ax.set_theta_direction(-1 if clockwise else 1) # type: ignore
     ax.set_rlabel_position(rlabel_angle) # type: ignore
+    ymin = min([min(E) for E in E_list])
+    ymax = max([max(E) for E in E_list])
+    yrange = ymax-ymin
 
+    ax.set_ylim(ymin-0.05*yrange, ymax+0.05*yrange)
     for i, Ei in enumerate(E_list):
-        mag = np.abs(Ei)
+        
         ax.plot(
-            theta, mag,
+            theta, Ei,
             linestyle=linestyles[i],
             linewidth=linewidth,
             marker=markers[i],

{emerge-0.6.8 → emerge-0.6.9}/emerge/_emerge/projects/_load_base.txt

@@ -17,8 +17,7 @@ with em.Simulation("myfile", load_file=True) as m:
     S11 = data.S(1,1)
     S21 = data.S(2,1)
     plt.plot_sp(f/1e9, [S11, S21])
-
-    m.set_mesh(m.data.mw.field[0].mesh)
+    
     m.display.add_object(m['box'])
     m.display.add_surf(*m.data.mw.field[0].cutplane(1*mm, z=5*mm).scalar('Ez','real'))
     m.display.show()

{emerge-0.6.8 → emerge-0.6.9}/emerge/_emerge/selection.py

@@ -205,6 +205,10 @@ class Selection:
     def centers(self) -> list[tuple[float, float, float],]:
         return [gmsh.model.occ.get_center_of_mass(self.dim, tag) for tag in self.tags]
     
+    @property
+    def _metal(self) -> bool:
+        return False
+    
     @property
     def opacity(self) -> float:
         return 0.6

{emerge-0.6.8 → emerge-0.6.9}/emerge/_emerge/simmodel.py

@@ -31,7 +31,7 @@ from typing import Literal, Generator, Any
 from loguru import logger
 import numpy as np
 import gmsh # type: ignore
-import joblib # type: ignore
+import cloudpickle
 import os
 import inspect
 from pathlib import Path
@@ -181,7 +181,10 @@ class Simulation:
 
             # Restier the Exit GMSH function on proper program abortion
             register(self._exit_gmsh)
-
+        else:
+            gmsh.finalize()
+            gmsh.initialize()
+            
         # Create a new GMSH model or load it
         if not self.load_file:
             gmsh.model.add(self.modelname)
@@ -283,7 +286,8 @@ class Simulation:
         # Pack and save data
         dataset = dict(simdata=self.data, mesh=self.mesh)
         data_path = self.modelpath / 'simdata.emerge'
-        joblib.dump(dataset, str(data_path))
+        with open(str(data_path), "wb") as f_out:
+            cloudpickle.dump(dataset, f_out)
         logger.info(f"Saved simulation data to: {data_path}")
 
     def load(self) -> None:
@@ -304,7 +308,8 @@ class Simulation:
         #self.mesh.update([])
 
         # Load data
-        datapack = joblib.load(str(data_path))
+        with open(str(data_path), "rb") as f_in:
+            datapack= cloudpickle.load(f_in)
         self.data = datapack['simdata']
         self._set_mesh(datapack['mesh'])
         logger.info(f"Loaded simulation data from: {data_path}")