emerge 1.0.7__py3-none-any.whl → 1.1.0__py3-none-any.whl

emerge/_emerge/simmodel.py

@@ -16,19 +16,20 @@
 # <https://www.gnu.org/licenses/>.
 
 from __future__ import annotations
-from .mesher import Mesher, unpack_lists
-from .geometry import GeoObject, _GEOMANAGER
+from .mesher import Mesher
+from .geometry import GeoObject
 from .geo.modeler import Modeler
 from .physics.microwave.microwave_3d import Microwave3D
 from .mesh3d import Mesh3D
-from .selection import Selector, FaceSelection, Selection
-from .logsettings import LOG_CONTROLLER
-from .plot.pyvista import PVDisplay
+from .selection import Selector, Selection
 from .dataset import SimulationDataset
+from .logsettings import LOG_CONTROLLER, DEBUG_COLLECTOR
+from .plot.pyvista import PVDisplay
 from .periodic import PeriodicCell
 from .cacherun import get_build_section, get_run_section
 from .settings import DEFAULT_SETTINGS, Settings
 from .solver import EMSolver, Solver
+from .simstate import SimState
 from typing import Literal, Generator, Any
 from loguru import logger
 import numpy as np
@@ -40,7 +41,7 @@ import joblib
 from atexit import register
 import signal
 from .. import __version__
-
+from .mesher import Algorithm3D
 ############################################################
 #                   EXCEPTION DEFINITIONS                  #
 ############################################################
@@ -63,6 +64,7 @@ class VersionError(Exception):
 #                 BASE 3D SIMULATION MODEL                 #
 ############################################################
 
+
 class Simulation:
 
     def __init__(self, 
@@ -94,16 +96,12 @@ class Simulation:
         self.mesher: Mesher = Mesher()
         self.modeler: Modeler = Modeler()
         
-        self.mesh: Mesh3D = Mesh3D(self.mesher)
+        self.state: SimState = SimState()
         self.select: Selector = Selector()
-        
         self.settings: Settings = DEFAULT_SETTINGS
 
         ## Display
-        self.display: PVDisplay = PVDisplay(self.mesh)
-        
-        ## Dataset
-        self.data: SimulationDataset = SimulationDataset()
+        self.display: PVDisplay = PVDisplay(self.state)
         
         ## STATES
         self.__active: bool = False
@@ -115,7 +113,7 @@ class Simulation:
         self._file_lines: str = ''
         
         ## Physics
-        self.mw: Microwave3D = Microwave3D(self.mesher, self.settings, self.data.mw)
+        self.mw: Microwave3D = Microwave3D(self.state, self.mesher, self.settings)
 
         self._initialize_simulation()
 
@@ -125,16 +123,25 @@ class Simulation:
             self.set_write_log()
 
         LOG_CONTROLLER._flush_log_buffer()
-        
         LOG_CONTROLLER._sys_info()
-        
-        self._update_data()
-    
+
+        self.__post_init__()
 
     ############################################################
     #                       PRIVATE FUNCTIONS                  #
     ############################################################
 
+    @property
+    def data(self) -> SimulationDataset:
+        return self.state.data
+    
+    @property
+    def mesh(self) -> Mesh3D:
+        return self.state.mesh
+    
+    def __post_init__(self):
+        pass
+
     def __setitem__(self, name: str, value: Any) -> None:
         """Store data in the current data container"""
         self.data.sim[name] = value
@@ -181,13 +188,13 @@ class Simulation:
     def _initialize_simulation(self):
         """Initializes the Simulation data and GMSH API with proper shutdown routines.
         """
-        _GEOMANAGER.sign_in(self.modelname)
+        self.state.init(self.modelname)
         
         # If GMSH is not yet initialized (Two simulation in a file)
         if gmsh.isInitialized() == 0:
             logger.debug('Initializing GMSH')
-            gmsh.initialize()
             
+            gmsh.initialize()
             # Set an exit handler for Ctrl+C cases
             self._install_signal_handlers()
 
@@ -200,7 +207,6 @@ class Simulation:
         # Create a new GMSH model or load it
         if not self.load_file:
             gmsh.model.add(self.modelname)
-            self.data: SimulationDataset = SimulationDataset()
         else:
             self.load()
 
@@ -213,6 +219,11 @@ class Simulation:
         if not self.__active:
             return
         logger.debug('Exiting program')
+        
+        if DEBUG_COLLECTOR.any_warnings:
+            logger.warning('EMerge simulation warnings:')
+        for i, report in DEBUG_COLLECTOR.all_reports():
+            logger.warning(f'{i}: {report}')
         # Save the file first
         if self.save_file:
             self.save()
@@ -223,25 +234,8 @@ class Simulation:
         logger.debug('GMSH Shut down successful')
         # set the state to active
         self.__active = False
-
-    def _update_data(self) -> None:
-        """Writes the stored physics data to each phyics class insatnce"""
-        self.mw.data = self.data.mw
-    
-    def _set_mesh(self, mesh: Mesh3D) -> None:
-        """Set the current model mesh to a given mesh."""
-        logger.trace(f'Setting {mesh} as model mesh')
-        self.mesh = mesh
-        self.mw.mesh = mesh
-        self.display._mesh = mesh
+        
     
-    def _save_geometries(self) -> None:
-        """Saves the current geometry state to the simulatin dataset
-        """
-        logger.trace('Storing geometries in data.sim')
-        self.data.sim['geos'] = {geo.name: geo for geo in _GEOMANAGER.all_geometries()}
-        self.data.sim['mesh'] = self.mesh
-        self.data.sim.entries.append(self.data.sim.stock)
     ############################################################
     #                       PUBLIC FUNCTIONS                  #
     ############################################################
@@ -382,6 +376,11 @@ class Simulation:
 
         raise VersionError(msg)
 
+    def activate(self, _indx: int | None = None, **variables) -> Simulation:
+        """Searches for the permutaions of parameter sweep variables and sets the current geometry to the provided set."""
+        self.state.activate(_indx, **variables)
+        return self
+    
     def save(self) -> None:
         """Saves the current model in the provided project directory."""
         # Ensure directory exists
@@ -403,7 +402,7 @@ class Simulation:
         logger.info(f"Saved mesh to: {mesh_path}")
 
         # Pack and save data
-        dataset = dict(simdata=self.data, mesh=self.mesh)
+        dataset = self.state.get_dataset()
         data_path = self.modelpath / 'simdata.emerge'
         
         joblib.dump(dataset, str(data_path))
@@ -424,17 +423,16 @@ class Simulation:
         if not mesh_path.exists() or not data_path.exists():
             raise FileNotFoundError("Missing required mesh or data file.")
 
-        # Load mesh
+        # Load GMSH Mesh (Ideally Id remove)
         gmsh.open(str(brep_path))
         gmsh.merge(str(mesh_path))
         gmsh.model.geo.synchronize()
         gmsh.model.occ.synchronize()
-        logger.info(f"Loaded mesh from: {mesh_path}")
         
+        logger.info(f"Loaded mesh from: {mesh_path}")
         datapack = joblib.load(str(data_path))
-        
-        self.data = datapack['simdata']
-        self.activate(0)
+        self.state.load_dataset(datapack)
+        self.state.activate(0)
         
         logger.info(f"Loaded simulation data from: {data_path}")
     
@@ -446,7 +444,7 @@ class Simulation:
         """
         logger.trace(f'Setting loglevel to {loglevel}')
         LOG_CONTROLLER.set_std_loglevel(loglevel)
-        if loglevel not in ('TRACE','DEBUG'):
+        if loglevel not in ('TRACE'):
             gmsh.option.setNumber("General.Terminal", 0)
 
     def set_write_log(self) -> None:
@@ -476,7 +474,7 @@ class Simulation:
             gmsh.model.occ.synchronize()
             gmsh.fltk.run()
             return
-        for geo in _GEOMANAGER.all_geometries():
+        for geo in self.state.current_geo_state:
             self.display.add_object(geo, mesh=plot_mesh, opacity=opacity, volume_mesh=volume_mesh, label=labels)
         if selections:
             [self.display.add_object(sel, color='red', opacity=0.6, label=labels) for sel in selections]
@@ -512,17 +510,13 @@ class Simulation:
         The geometries may be provided (legacy behavior) but are automatically managed in the background.
         
         """
-        geometries_parsed: Any = None
         logger.trace('Committing final geometry.')
-        if not geometries:
-            geometries_parsed = _GEOMANAGER.all_geometries()
-        else:
-            geometries_parsed = unpack_lists(geometries + tuple([item for item in self.data.sim.default.values() if isinstance(item, GeoObject)]))
-        logger.trace(f'Parsed geometries = {geometries_parsed}')
+        self.state.store_geometry_data()
         
-        self._save_geometries()
+        logger.trace(f'Parsed geometries = {self.state.geos}')
+        
+        self.mesher.submit_objects(self.state.geos)
         
-        self.mesher.submit_objects(geometries_parsed)
         self._defined_geometries = True
         self.display._facetags = [dt[1] for dt in gmsh.model.get_entities(2)]
     
@@ -532,20 +526,7 @@ class Simulation:
         Returns:
             list[GeoObject]: A list of all GeoObjects
         """
-        return _GEOMANAGER.all_geometries()  
-    
-    def activate(self, _indx: int | None = None, **variables) -> Simulation:
-        """Searches for the permutaions of parameter sweep variables and sets the current geometry to the provided set."""
-        if _indx is not None:
-            dataset = self.data.sim.index(_indx)
-        else:
-            dataset = self.data.sim.find(**variables)
-        
-        variables = ', '.join([f'{key}={value}' for key,value in dataset.vars.items()])
-        logger.info(f'Activated entry with variables: {variables}')
-        _GEOMANAGER.set_geometries(dataset['geos'])
-        self._set_mesh(dataset['mesh'])
-        return self
+        return self.state.current_geo_state
         
     def generate_mesh(self, regenerate: bool = False) -> None:
         """Generate the mesh. 
@@ -557,8 +538,9 @@ class Simulation:
         Raises:
             ValueError: ValueError if no frequencies are defined.
         """
+        logger.info('Starting mesh generation phase.')
         if not regenerate:
-            logger.trace('Starting mesh generation phase.')
+            
             if not self._defined_geometries:
                 self.commit_geometry()
             
@@ -567,7 +549,7 @@ class Simulation:
             if self._cell is not None:
                 self.mesher.set_periodic_cell(self._cell)
             
-            self.mw._initialize_bcs(_GEOMANAGER.get_surfaces())
+            self.mw._initialize_bcs(self.state.manager.get_surfaces())
 
             # Check if frequencies are defined: TODO: Replace with a more generic check
             if self.mw.frequencies is None:
@@ -576,8 +558,18 @@ class Simulation:
         gmsh.model.occ.synchronize()
 
         # Set the mesh size
-        self.mesher._configure_mesh_size(self.mw.get_discretizer(), self.mw.resolution)
+        self.mesher._configure_mesh_size(self.mw.get_discretizer(), self.mw.resolution) # This makes no sense to do this here
             
+        # Validity check
+        x1, y1, z1, x2, y2, z2 = gmsh.model.getBoundingBox(-1, -1)
+        bb_volume = (x2-x1)*(y2-y1)*(z2-z1)
+        wl = 299792458/self.mw.frequencies[-1]
+        Nelem = int(5 * bb_volume / (wl**3))
+        if Nelem > 100_000 and DEFAULT_SETTINGS.size_check:
+            DEBUG_COLLECTOR.add_report(f'An estimated {Nelem} tetrahedra are required for the bounding box of the geometry. This may imply a simulation domain that is very large.' + 
+                                       'To disable this message. Set the .size_check parameter in model.settings to False.')
+            
+            raise SimulationError('Simulation requires too many elements.')
         logger.trace(' (2) Calling GMSH mesher')
         try:
             gmsh.logger.start()
@@ -595,16 +587,7 @@ class Simulation:
         self.mesh._pre_update(self.mesher._get_periodic_bcs())
         self.mesh.exterior_face_tags = self.mesher.domain_boundary_face_tags
         gmsh.model.occ.synchronize()
-        self._set_mesh(self.mesh)
         logger.trace(' (3) Mesh routine complete')
-
-    def _reset_mesh(self):
-        #gmsh.clear()
-        gmsh.model.mesh.clear()
-        mesh = Mesh3D(self.mesher)
-        
-        self.mw.reset(False)
-        self._set_mesh(mesh)
         
     def parameter_sweep(self, clear_mesh: bool = True, **parameters: np.ndarray) -> Generator[tuple[float,...], None, None]:
         """Executes a parameteric sweep iteration.
@@ -641,14 +624,13 @@ class Simulation:
             if clear_mesh and i_iter > 0:
                 logger.info('Cleaning up mesh.')
                 gmsh.clear()
-                mesh = Mesh3D(self.mesher)
-                _GEOMANAGER.reset(self.modelname)
-                self._set_mesh(mesh)
+                self.state.reset_geostate(self.modelname)
                 self.mw.reset()
+                
             
             params = {key: dim[i_iter] for key,dim in zip(paramlist, dims_flat)}
-            self.mw._params = params
-            self.data.sim.new(**params)
+            
+            self.state.set_parameters(params)
             
             logger.info(f'Iterating: {params}')
             if len(dims_flat)==1:
@@ -656,75 +638,16 @@ class Simulation:
             else:
                 yield (dim[i_iter] for dim in dims_flat) # type: ignore
             
+            
             if not clear_mesh:
-                self._save_geometries()
+                self.state.store_geometry_data()
         
         if not clear_mesh:
-                self._save_geometries()
+            self.state.store_geometry_data()
         
         self.mw.cache_matrices = True
-    
-    
-    def _beta_adaptive_mesh_refinement(self, 
-                                 max_steps: int = 6,
-                                 convergence: float = 0.02,
-                                 refinement_percentage: float = 0.1,
-                                 refinement_ratio: float = 0.3,
-                                 growth_rate: float = 3) -> None:
-        """Beta implementation of Adaptive Mesh Refinement
-
-        Args:
-            max_steps (int, optional): _description_. Defaults to 6.
-            convergence (float, optional): _description_. Defaults to 0.02.
-            refinement_percentage (float, optional): _description_. Defaults to 0.1.
-            refinement_ratio (float, optional): _description_. Defaults to 0.3.
-            growth_rate (float, optional): _description_. Defaults to 3.
-        """
-        from .physics.microwave.adaptive_mesh import select_refinement_indices, reduce_point_set, compute_convergence
-   
-        max_freq = np.max(self.mw.frequencies)
         
-        regenerate = False
         
-        Smats = []
-
-        for step in range(max_steps):
-            amr_params = dict(iter_step=step)
-            self.mw._params = amr_params
-            self.data.sim.new(**amr_params)
-            
-            
-            data = self.mw._run_adaptive_mesh(step, max_freq)
-            
-            field = data.field[-1]
-            
-            Smat_new = data.scalar[-1].Sp
-            Smats.append(Smat_new)
-            if step > 0:
-                S0 = Smats[-2]
-                S1 = Smats[-1]
-                conv = compute_convergence(S0, S1)
-                logger.info(f'Convergence = {conv}')
-                if conv < convergence:
-                    logger.info('Mesh refinement passed!')
-                    break
-            error, lengths = field._solution_quality()
-                
-            idx = select_refinement_indices(error, refinement_percentage)
-            
-            idx = idx[reduce_point_set(self.mw.mesh.centers[:,idx], growth_rate, lengths[idx], refinement_ratio)]
-            centers = self.mw.mesh.centers
-            
-            self.mesher._reset_amr_points()
-            self._reset_mesh()
-            logger.debug(f'Adding {len(idx)} refinement points.')
-            for i in idx:
-                coord = centers[:,i]
-                size = lengths[i]
-                self.mesher.add_refinement_point(coord, refinement_ratio, size, growth_rate)
-            
-            self.generate_mesh(True)            
-            self.view(plot_mesh=True)
     def export(self, filename: str):
         """Exports the model or mesh depending on the extension. 
         
@@ -760,4 +683,153 @@ class Simulation:
         """
         logger.warning('define_geometry() will be derpicated. Use commit_geometry() instead.')
         self.commit_geometry(*args)
-        
+        
+class SimulationBeta(Simulation):
+    
+    
+    def __post_init__(self):
+        
+        self.mesher.set_algorithm(Algorithm3D.HXT)
+        logger.debug('Setting mesh algorithm to HXT')
+        
+        
+    def _reset_mesh(self):
+        #gmsh.clear()
+        gmsh.model.mesh.clear()
+        
+        self.mw.reset(_reset_bc = False)
+        self.state.reset_mesh()
+        
+    def adaptive_mesh_refinement(self, 
+                                 max_steps: int = 6,
+                                 min_refined_passes: int = 1,
+                                 convergence: float = 0.02,
+                                 magnitude_convergence: float = 2.0,
+                                 phase_convergence: float = 180,
+                                 refinement_ratio: float = 0.9,
+                                 growth_rate: float = 3,
+                                 minimum_refinement_percentage: float = 20.0, 
+                                 error_field_inclusion_percentage: float = 5.0,
+                                 frequency: float = None,
+                                 show_mesh: bool = False) -> SimulationDataset:
+        """ A beta-version of adaptive mesh refinement.
+
+        Convergence Criteria:
+            (1): max(abs(S[n]-S[n-1]))
+            (2): max(abs(abs(S[n]) - abs(S[n-1])))
+            (3): max(angle(S[n]/S[n-1])) * 180/π
+        
+        Args:
+            max_steps (int, optional): The maximum number of refinement steps. Defaults to 6.
+            min_refined_passes (int, optional): The minimum number of refined passes. Defaults to 1.
+            convergence (float, optional): The S-paramerter convergence (1). Defaults to 0.02.
+            magnitude_convergence (float, optional): The S-parameter magnitude convergence (2). Defaults to 2.0.
+            phase_convergence (float, optional): The S-parameter Phase convergence (3). Defaults to 180.
+            refinement_ratio (float, optional): The size reduction of mesh elements by original length. Defaults to 0.75.
+            growth_rate (float, optional): The mesh size growth rate. Defaults to 3.0.
+            minimum_refinement_percentage (float, optional): The minimum mesh size increase . Defaults to 15.0.
+            error_field_inclusion_percentage (float, optional): A percentage of tet elements to be included for refinement. Defaults to 5.0.
+            frequency (float, optional): The refinement frequency. Defaults to None.
+            show_mesh (bool, optional): If the intermediate meshes should be shown (freezes simulation). Defaults to False
+
+        Returns:
+            SimulationDataset: _description_
+        """
+        from .physics.microwave.adaptive_mesh import select_refinement_indices, reduce_point_set, compute_convergence
+        
+        
+        max_freq = np.max(self.mw.frequencies)
+        
+        if frequency is not None:
+            max_freq = frequency
+        
+        S_matrices: list[np.ndarray] = []
+
+        last_n_tets: int = self.mesh.n_tets
+        logger.info(f'Initial mesh has {last_n_tets} tetrahedra')  
+        
+        passed = 0
+        
+        self.state.stash()
+        
+        for step in range(1,max_steps+1):
+            
+            self.data.sim.new(iter_step=step)
+            
+            data = self.mw._run_adaptive_mesh(step, max_freq)
+            
+            field = data.field[-1]
+            
+            Smat_new = data.scalar[-1].Sp
+            S_matrices.append(Smat_new)
+            
+            if step > 1:
+                S0 = S_matrices[-2]
+                S1 = S_matrices[-1]
+                conv_complex, conv_mag, conv_phase = compute_convergence(S0, S1)
+                logger.info(f'Pass {step}: Convergence = {conv_complex:.3f}, Mag = {conv_mag:.3f}, Phase = {conv_phase:.1f} deg')
+                if conv_complex <= convergence and conv_phase < phase_convergence and conv_mag < magnitude_convergence:
+                    logger.info(f'Pass {step}: Mesh refinement passed!')
+                    passed += 1
+                else:
+                    passed = 0
+            
+            if passed >= min_refined_passes:
+                logger.info('Adaptive mesh refinement successfull')
+                break
+            
+            error, lengths = field._solution_quality()
+                
+            idx = select_refinement_indices(error, error_field_inclusion_percentage/100)
+            idx = idx[::-1]
+            
+            self.mesher.add_refinement_points(self.mw.mesh.centers[:,idx], lengths[idx])
+            
+            logger.debug(f'Pass {step}: Adding {len(idx)} new refinement points.')
+                
+            new_ids = reduce_point_set(self.mesher._amr_coords, growth_rate, self.mesher._amr_sizes, refinement_ratio, 0.20)
+            
+            logger.debug(f'Pass {step}: Removing {self.mesher._amr_coords.shape[1] - len(new_ids)} points from {self.mesher._amr_coords.shape[1]} to {len(new_ids)}')
+            
+            self.mesher._amr_coords = self.mesher._amr_coords[:,new_ids]
+            self.mesher._amr_sizes = self.mesher._amr_sizes[new_ids]
+            
+            
+            while True:
+                
+                self._reset_mesh()
+                
+                logger.debug(f'Pass {step}: Adding {len(idx)} refinement points.')
+                
+                self.mesher.set_refinement_function(refinement_ratio, growth_rate, 1.0)
+                
+                self.generate_mesh(True)
+                
+                percentage = (self.mesh.n_tets/last_n_tets - 1) * 100
+                logger.info(f'Pass {step}: New mesh has {self.mesh.n_tets} (+{percentage:.1f}%) tetrahedra.')  
+                
+                if percentage < minimum_refinement_percentage:
+                    logger.debug('Not enough mesh refinement, decreasing mesh size constraint.')
+                    refinement_ratio = refinement_ratio * 0.9
+                    logger.debug(f'New refinement ratio: {refinement_ratio}')
+                    continue
+                
+                if percentage > 2*minimum_refinement_percentage and refinement_ratio < 0.99:
+                    logger.debug('Too much mesh refinement, decreasing mesh size constraint.')
+                    refinement_ratio = refinement_ratio ** (1-np.log(percentage/minimum_refinement_percentage)/4)
+                    logger.debug(f'New refinement ratio: {refinement_ratio}')
+                    
+
+                last_n_tets = self.mesh.n_tets
+                break
+            
+            if show_mesh:
+                self.view(plot_mesh=True, volume_mesh=True)
+        
+        if passed < min_refined_passes:
+            logger.warning('Adaptive mesh refinement did not converge!')
+        
+        old = self.state.reload()
+        return old
+    
+    

emerge/_emerge/simstate.py

@@ -0,0 +1,106 @@
+# EMerge is an open source Python based FEM EM simulation module.
+# Copyright (C) 2025  Robert Fennis.
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 2
+# of the License, or (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, see
+# <https://www.gnu.org/licenses/>.
+
+
+from .mesh3d import Mesh3D
+from .geometry import GeoObject, _GeometryManager, _GEOMANAGER
+from .dataset import SimulationDataset
+from loguru import logger
+
+from typing import Any
+
+
+class SimState:
+    
+    def __init__(self):
+        self.mesh: Mesh3D = Mesh3D()
+        self.geos: list[GeoObject] = []
+        self.data: SimulationDataset = SimulationDataset()
+        self.params: dict[str, float] = dict()
+        self._stashed: SimulationDataset | None = None
+        self.manager: _GeometryManager = _GEOMANAGER
+    
+    @property
+    def current_geo_state(self) -> list[GeoObject]:
+        return self.manager.all_geometries()
+    
+    def reset_geostate(self, modelname: str) -> None:
+        _GEOMANAGER.reset(modelname)
+        self.clear_mesh()
+        
+    def init(self, modelname: str) -> None:
+        self.mesh = Mesh3D()
+        self.geos = []
+        self.reset_geostate(modelname)
+        self.init_data()
+        
+    def stash(self) -> None:
+        self._stashed = self.data
+        self.data = SimulationDataset()
+    
+    def set_parameters(self, parameters: dict[str, float]) -> None:
+        self.params = parameters
+        
+    def init_data(self) -> None:
+        self.data.sim.new(**self.params)
+        
+    def reload(self) -> SimulationDataset:
+        old = self._stashed
+        self.data = self._stashed
+        self._stashed = None
+        return old
+    
+    def reset_mesh(self) -> None:
+        self.mesh = Mesh3D()
+        
+    def set_mesh(self, mesh: Mesh3D) -> None:
+        self.mesh = mesh
+        
+    def set_geos(self, geos: list[GeoObject]) -> None:
+        self.geos = geos
+        _GEOMANAGER.set_geometries(geos)
+
+    def clear_mesh(self) -> None:
+        self.mesh = Mesh3D()
+        
+    def store_geometry_data(self) -> None:
+        """Saves the current geometry state to the simulatin dataset
+        """
+        logger.trace('Storing geometries in data.sim')
+        self.geos = self.current_geo_state
+        self.data.sim['geos'] = self.geos
+        self.data.sim['mesh'] = self.mesh
+        
+    def get_dataset(self) -> dict[str, Any]:
+        return dict(simdata=self.data, mesh=self.mesh)
+    
+    def load_dataset(self, dataset: dict[str, Any]):
+        self.data = dataset['simdata']
+        self.mesh = dataset['mesh']
+        
+    def activate(self, _indx: int | None = None, **variables):
+        """Searches for the permutaions of parameter sweep variables and sets the current geometry to the provided set."""
+        if _indx is not None:
+            dataset = self.data.sim.index(_indx)
+        else:
+            dataset = self.data.sim.find(**variables)
+        
+        variables = ', '.join([f'{key}={value}' for key,value in dataset.vars.items()])
+        logger.info(f'Activated entry with variables: {variables}')
+        self.set_mesh(dataset['mesh'])
+        self.set_geos(dataset['geos'])
+        return self