emerge 1.0.3__py3-none-any.whl → 1.0.5__py3-none-any.whl

emerge/_emerge/plot/pyvista/cmap_maker.py

@@ -0,0 +1,70 @@
+from typing import Iterable, Sequence, Optional
+import numpy as np
+from matplotlib.colors import LinearSegmentedColormap, to_rgba
+
+def make_colormap(
+    hex_colors: Sequence[str],
+    positions: Optional[Iterable[float]] = None,
+    name: str = "custom",
+    N: int = 256,
+) -> LinearSegmentedColormap:
+    """
+    Create a Matplotlib colormap from hex colors with optional positions.
+
+    Parameters
+    ----------
+    hex_colors : sequence of str
+        Hex color strings like '#RRGGBB' (or 'RRGGBB'). At least 2 required.
+    positions : iterable of float in [0, 1], optional
+        Locations of each color along the gradient. If not provided,
+        they are evenly spaced via linspace(0, 1, len(hex_colors)).
+        If provided, they do not have to be sorted; they will be sorted
+        together with the colors. If the first/last position do not
+        hit 0 or 1, they’ll be extended by duplicating the end colors.
+    name : str
+        Name for the colormap.
+    N : int
+        Resolution (number of lookup entries) of the colormap.
+
+    Returns
+    -------
+    matplotlib.colors.LinearSegmentedColormap
+    """
+    # Normalize hex strings and basic validation
+    colors = []
+    for c in hex_colors:
+        if not isinstance(c, str):
+            raise TypeError("All colors must be hex strings.")
+        colors.append(c if c.startswith("#") else f"#{c}")
+
+    if len(colors) < 2:
+        raise ValueError("Provide at least two hex colors.")
+
+    # Build/validate positions
+    if positions is None:
+        pos = np.linspace(0.0, 1.0, len(colors), dtype=float)
+    else:
+        pos = np.asarray(list(positions), dtype=float)
+        if pos.size != len(colors):
+            raise ValueError("`positions` must have the same length as `hex_colors`.")
+        if np.any((pos < 0.0) | (pos > 1.0)):
+            raise ValueError("All positions must be within [0, 1].")
+
+        # Sort positions and carry colors along
+        order = np.argsort(pos)
+        pos = pos[order]
+        colors = [colors[i] for i in order]
+
+        # Ensure coverage of [0, 1] by extending ends if needed
+        if pos[0] > 0.0:
+            pos = np.r_[0.0, pos]
+            colors = [colors[0]] + colors
+        if pos[-1] < 1.0:
+            pos = np.r_[pos, 1.0]
+            colors = colors + [colors[-1]]
+
+    # Pair positions with RGBA
+    segment = list(zip(pos.tolist(), (to_rgba(c) for c in colors)))
+
+    # Create the colormap
+    return LinearSegmentedColormap.from_list(name, segment, N=N)

emerge/_emerge/plot/pyvista/display.py

@@ -26,6 +26,8 @@ from typing import Iterable, Literal, Callable, Any
 from ..display import BaseDisplay
 from .display_settings import PVDisplaySettings
 from matplotlib.colors import ListedColormap
+from .cmap_maker import make_colormap
+
 from itertools import cycle
 ### Color scale
 
@@ -40,6 +42,8 @@ cmap_names = Literal['bgy','bgyw','kbc','blues','bmw','bmy','kgy','gray','dimgra
                      'bkr','bky','coolwarm','gwv','bjy','bwy','cwr','colorwheel','isolum','rainbow','fire',
                      'cet_fire','gouldian','kbgyw','cwr','CET_CBL1','CET_CBL3','CET_D1A']
 
+EMERGE_AMP =  make_colormap(["#1F0061","#35188e","#1531ab", "#ff007b", "#ff7c51"], (0.0, 0.2, 0.4, 0.7, 0.9))
+EMERGE_WAVE = make_colormap(["#4ab9ff","#0510B2B8","#3A37466E","#CC0954B9","#ff9036"], (0.0, 0.3, 0.5, 0.7, 1.0))
 
 def _gen_c_cycle():
     colors = [
@@ -74,24 +78,24 @@ class _RunState:
     
 ANIM_STATE = _RunState()
 
-def gen_cmap(mesh, N: int = 256):
-    # build a linear grid of data‐values (not strictly needed for pure colormap)
-    vmin, vmax = mesh['values'].min(), mesh['values'].max()
-    mapping = np.linspace(vmin, vmax, N)
+# def gen_cmap(mesh, N: int = 256):
+#     # build a linear grid of data‐values (not strictly needed for pure colormap)
+#     vmin, vmax = mesh['values'].min(), mesh['values'].max()
+#     mapping = np.linspace(vmin, vmax, N)
     
-    # prepare output
-    newcolors = np.empty((N, 4))
+#     # prepare output
+#     newcolors = np.empty((N, 4))
     
-    # normalized positions of control points: start, middle, end
-    control_pos = np.array([0.0, 0.25, 0.5, 0.75, 1]) * (vmax - vmin) + vmin
-    # stack control colors
-    controls = np.vstack([col1, col2, col3, col4, col5])
+#     # normalized positions of control points: start, middle, end
+#     control_pos = np.array([0.0, 0.25, 0.5, 0.75, 1]) * (vmax - vmin) + vmin
+#     # stack control colors
+#     controls = np.vstack([col1, col2, col3, col4, col5])
     
-    # interp each RGBA channel independently
-    for chan in range(4):
-        newcolors[:, chan] = np.interp(mapping, control_pos, controls[:, chan])
+#     # interp each RGBA channel independently
+#     for chan in range(4):
+#         newcolors[:, chan] = np.interp(mapping, control_pos, controls[:, chan])
     
-    return ListedColormap(newcolors)
+#     return ListedColormap(newcolors)
 
 def setdefault(options: dict, **kwargs) -> dict:
     """Shorthand for overwriting non-existent keyword arguments with defaults
@@ -252,8 +256,20 @@ class PVDisplay(BaseDisplay):
 
         self._ctr: int = 0 
         
+        self._cbar_args: dict = {}
+        self._cbar_lim: tuple[float, float] | None = None
         self.camera_position = (1, -1, 1)     # +X, +Z, -Y
     
+    
+    def cbar(self, name: str, n_labels: int = 5, interactive: bool = False, clim: tuple[float, float] | None = None ) -> PVDisplay:
+        self._cbar_args = dict(title=name, n_labels=n_labels, interactive=interactive)
+        self._cbar_lim = clim
+        return self
+    
+    def _reset_cbar(self) -> None:
+        self._cbar_args: dict = {}
+        self._cbar_lim: tuple[float, float] | None = None
+        
     def _wire_close_events(self):
         self._closed = False
 
@@ -378,6 +394,7 @@ class PVDisplay(BaseDisplay):
         >>> display.animate().surf(...)
         >>> display.show()
         """
+        print('If you closed the animation without using (Q) press Ctrl+C to kill the process.')
         self._Nsteps = Nsteps
         self._fps = fps
         self._do_animate = True
@@ -573,7 +590,6 @@ class PVDisplay(BaseDisplay):
         else:
             F = np.real(F.T)
             Fnorm = np.sqrt(Fx.real**2 + Fy.real**2 + Fz.real**2).T
-
         if XYZ is not None:
             grid = pv.StructuredGrid(X,Y,Z)
             self.add_surf(X,Y,Z,Fnorm, _fieldname = 'portfield')
@@ -588,7 +604,7 @@ class PVDisplay(BaseDisplay):
                  z: np.ndarray,
                  field: np.ndarray,
                  scale: Literal['lin','log','symlog'] = 'lin',
-                 cmap: cmap_names = 'viridis',
+                 cmap: cmap_names | None = None,
                  clim: tuple[float, float] | None = None,
                  opacity: float = 1.0,
                  symmetrize: bool = False,
@@ -614,8 +630,6 @@ class PVDisplay(BaseDisplay):
         grid = pv.StructuredGrid(x,y,z)
         field_flat = field.flatten(order='F')
         
-        
-
         if scale=='log':
             T = lambda x: np.log10(np.abs(x+1e-12))
         elif scale=='symlog':
@@ -624,6 +638,7 @@ class PVDisplay(BaseDisplay):
             T = lambda x: x
         
         static_field = T(np.real(field_flat))
+        
         if _fieldname is None:
             name = 'anim'+str(self._ctr)
         else:
@@ -634,18 +649,26 @@ class PVDisplay(BaseDisplay):
 
         grid_no_nan = grid.threshold(scalars=name)
         
-        
+        default_cmap = EMERGE_AMP
         # Determine color limits
         if clim is None:
-            fmin = np.nanmin(static_field)
-            fmax = np.nanmax(static_field)
-            clim = (fmin, fmax)
+            if self._cbar_lim is not None:
+                clim = self._cbar_lim
+            else:
+                fmin = np.nanmin(static_field)
+                fmax = np.nanmax(static_field)
+                clim = (fmin, fmax)
+        
         if symmetrize:
             lim = max(abs(clim[0]), abs(clim[1]))
             clim = (-lim, lim)
-
+            default_cmap = EMERGE_WAVE
+        
+        if cmap is None:
+            cmap = default_cmap
+        
         kwargs = setdefault(kwargs, cmap=cmap, clim=clim, opacity=opacity, pickable=False, multi_colors=True)
-        actor = self._plot.add_mesh(grid_no_nan, scalars=name, **kwargs)
+        actor = self._plot.add_mesh(grid_no_nan, scalars=name, scalar_bar_args=self._cbar_args, **kwargs)
 
 
         if self._do_animate:
@@ -655,8 +678,9 @@ class PVDisplay(BaseDisplay):
                 obj.fgrid[name] = obj.grid.threshold(scalars=name)[name]
                 #obj.fgrid replace with thresholded scalar data.
             self._objs.append(_AnimObject(field_flat, T, grid, grid_no_nan, actor, on_update))
-
-
+        
+        self._reset_cbar()
+        
     def add_title(self, title: str) -> None:
         """Adds a title
 
@@ -689,6 +713,7 @@ class PVDisplay(BaseDisplay):
               dx: np.ndarray, dy: np.ndarray, dz: np.ndarray,
               scale: float = 1,
               color: tuple[float, float, float] | None = None,
+              cmap: cmap_names | None = None,
               scalemode: Literal['lin','log'] = 'lin'):
         """Add a quiver plot to the display
 
@@ -711,6 +736,8 @@ class PVDisplay(BaseDisplay):
         
         ids = np.invert(np.isnan(dx))
         
+        if cmap is None:
+            cmap = EMERGE_AMP
         x, y, z, dx, dy, dz = x[ids], y[ids], z[ids], dx[ids], dy[ids], dz[ids]
         
         dmin = _min_distance(x,y,z)
@@ -729,8 +756,8 @@ class PVDisplay(BaseDisplay):
         if color is not None:
             kwargs['color'] = color
             
-        pl = self._plot.add_arrows(Coo, Vec, scalars=None, clim=None, cmap=None, **kwargs)
-
+        pl = self._plot.add_arrows(Coo, Vec, scalars=None, clim=None, cmap=cmap, **kwargs)
+        self._reset_cbar()
         
     def add_contour(self,
                      X: np.ndarray,
@@ -738,8 +765,11 @@ class PVDisplay(BaseDisplay):
                      Z: np.ndarray,
                      V: np.ndarray,
                      Nlevels: int = 5,
+                     scale: Literal['lin','log','symlog'] = 'lin',
                      symmetrize: bool = True,
-                     cmap: str = 'viridis'):
+                     clim: tuple[float, float] | None = None,
+                     cmap: cmap_names | None = None,
+                     opacity: float = 0.25):
         """Adds a 3D volumetric contourplot based on a 3D grid of X,Y,Z and field values
 
 
@@ -753,27 +783,54 @@ class PVDisplay(BaseDisplay):
             cmap (str, optional): The color map. Defaults to 'viridis'.
         """
         Vf = V.flatten()
+        Vf = np.nan_to_num(Vf)
         vmin = np.min(np.real(Vf))
         vmax = np.max(np.real(Vf))
+        
+        default_cmap = EMERGE_AMP
+        
+        if scale=='log':
+            T = lambda x: np.log10(np.abs(x+1e-12))
+        elif scale=='symlog':
+            T = lambda x: np.sign(x) * np.log10(1 + np.abs(x*np.log(10)))
+        else:
+            T = lambda x: x
+        
         if symmetrize:
-            level = max(np.abs(vmin),np.abs(vmax))
+            level = np.max(np.abs(Vf))
             vmin, vmax = (-level, level)
+            default_cmap = EMERGE_WAVE
+        
+        if clim is None:
+            if self._cbar_lim is not None:
+                clim = self._cbar_lim
+                vmin, vmax = clim
+            else:
+                clim = (vmin, vmax)
+        
+        if cmap is None:
+            cmap = default_cmap
+            
         grid = pv.StructuredGrid(X,Y,Z)
         field = V.flatten(order='F')
-        grid['anim'] = np.real(field)
+        grid['anim'] = T(np.real(field))
+        
         levels = list(np.linspace(vmin, vmax, Nlevels))
         contour = grid.contour(isosurfaces=levels)
-        actor = self._plot.add_mesh(contour, opacity=0.25, cmap=cmap, pickable=False)
-
+        
+        actor = self._plot.add_mesh(contour, opacity=opacity, cmap=cmap, clim=clim, pickable=False, scalar_bar_args=self._cbar_args)
+        
         if self._do_animate:
             def on_update(obj: _AnimObject, phi: complex):
-                new_vals = np.real(obj.field * phi)
+                new_vals = obj.T(np.real(obj.field * phi))
                 obj.grid['anim'] = new_vals
                 new_contour = obj.grid.contour(isosurfaces=levels)
                 obj.actor.GetMapper().SetInputData(new_contour) # type: ignore
+                
+            self._objs.append(_AnimObject(field, T, grid, None, actor, on_update)) # type: ignore
             
-            self._objs.append(_AnimObject(field, lambda x: x, grid, actor, on_update)) # type: ignore
-
+        self._reset_cbar()
+        
     def _add_aux_items(self) -> None:
         saved_camera = {
             "position": self._plot.camera.position,

emerge/_emerge/simmodel.py

@@ -33,10 +33,10 @@ from typing import Literal, Generator, Any
 from loguru import logger
 import numpy as np
 import gmsh # type: ignore
-import cloudpickle
 import os
 import inspect
 from pathlib import Path
+import joblib
 from atexit import register
 import signal
 from .. import __version__
@@ -120,10 +120,14 @@ class Simulation:
         self._initialize_simulation()
 
         self.set_loglevel(loglevel)
+        
         if write_log:
             self.set_write_log()
 
         LOG_CONTROLLER._flush_log_buffer()
+        
+        LOG_CONTROLLER._sys_info()
+        
         self._update_data()
     
 
@@ -226,10 +230,18 @@ class Simulation:
     
     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                  #
     ############################################################
@@ -393,9 +405,9 @@ class Simulation:
         # Pack and save data
         dataset = dict(simdata=self.data, mesh=self.mesh)
         data_path = self.modelpath / 'simdata.emerge'
-        with open(str(data_path), "wb") as f_out:
-            cloudpickle.dump(dataset, f_out)
-            
+        
+        joblib.dump(dataset, str(data_path))
+        
         if self._cache_run:
             cachepath = self.modelpath / 'pylines.txt'
             with open(str(cachepath), 'w') as f_out:
@@ -418,13 +430,12 @@ class Simulation:
         gmsh.model.geo.synchronize()
         gmsh.model.occ.synchronize()
         logger.info(f"Loaded mesh from: {mesh_path}")
-        #self.mesh.update([])
-
-        # Load data
-        with open(str(data_path), "rb") as f_in:
-            datapack= cloudpickle.load(f_in)
+        
+        datapack = joblib.load(str(data_path))
+        
         self.data = datapack['simdata']
-        self._set_mesh(datapack['mesh'])
+        self.activate(0)
+        
         logger.info(f"Loaded simulation data from: {data_path}")
     
     def set_loglevel(self, loglevel: Literal['DEBUG','INFO','WARNING','ERROR']) -> None:
@@ -433,12 +444,14 @@ class Simulation:
         Args:
             loglevel ('DEBUG','INFO','WARNING','ERROR'): The loglevel
         """
+        logger.trace(f'Setting loglevel to {loglevel}')
         LOG_CONTROLLER.set_std_loglevel(loglevel)
         if loglevel not in ('TRACE','DEBUG'):
             gmsh.option.setNumber("General.Terminal", 0)
 
     def set_write_log(self) -> None:
         """Adds a file output for the logger."""
+        logger.trace(f'Writing log to path = {self.modelpath}')
         LOG_CONTROLLER.set_write_file(self.modelpath)
         
     def view(self, 
@@ -471,17 +484,28 @@ class Simulation:
 
         return None
         
-    def set_periodic_cell(self, cell: PeriodicCell, included_faces: FaceSelection | None = None):
+    def set_periodic_cell(self, cell: PeriodicCell):
         """Set the given periodic cell object as the simulations peridicity.
 
         Args:
             cell (PeriodicCell): The PeriodicCell class
-            excluded_faces (list[FaceSelection], optional): Faces to exclude from the periodic boundary condition. Defaults to None.
         """
+        logger.trace(f'Setting {cell} as periodic cell object')
         self.mw.bc._cell = cell
         self._cell = cell
-        self._cell.included_faces = included_faces
 
+    def set_resolution(self, resolution: float) -> Simulation:
+        """Sets the discretization resolution in the various physics interfaces.
+        
+
+        Args:
+            resolution (float): The resolution as a float. Lower resolution is a finer mesh 
+
+        Returns:
+            Simulation: _description_
+        """
+        self.mw.set_resolution(resolution)
+        
     def commit_geometry(self, *geometries: GeoObject | list[GeoObject]) -> None:
         """Finalizes and locks the current geometry state of the simulation.
 
@@ -489,12 +513,15 @@ class Simulation:
         
         """
         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._save_geometries()
         
-        self.data.sim['geos'] = {geo.name: geo for geo in geometries_parsed}
         self.mesher.submit_objects(geometries_parsed)
         self._defined_geometries = True
         self.display._facetags = [dt[1] for dt in gmsh.model.get_entities(2)]
@@ -507,6 +534,19 @@ class Simulation:
         """
         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
+        
     def generate_mesh(self) -> None:
         """Generate the mesh. 
         This can only be done after commit_geometry(...) is called and if frequencies are defined.
@@ -517,13 +557,15 @@ class Simulation:
         Raises:
             ValueError: ValueError if no frequencies are defined.
         """
+        logger.trace('Starting mesh generation phase.')
         if not self._defined_geometries:
             self.commit_geometry()
         
+        logger.trace(' (1) Installing periodic boundaries in mesher.')
         # Set the cell periodicity in GMSH
         if self._cell is not None:
             self.mesher.set_periodic_cell(self._cell)
-            
+        
         self.mw._initialize_bcs(_GEOMANAGER.get_surfaces())
 
         # Check if frequencies are defined: TODO: Replace with a more generic check
@@ -533,25 +575,26 @@ class Simulation:
         gmsh.model.occ.synchronize()
 
         # Set the mesh size
-        self.mesher.set_mesh_size(self.mw.get_discretizer(), self.mw.resolution)
+        self.mesher._configure_mesh_size(self.mw.get_discretizer(), self.mw.resolution)
         
+        logger.trace(' (2) Calling GMSH mesher')
         try:
             gmsh.logger.start()
             gmsh.model.mesh.generate(3)
             logs = gmsh.logger.get()
             gmsh.logger.stop()
             for log in logs:
-                logger.trace('[GMSH] '+log)
+                logger.trace('[GMSH] ' + log)
         except Exception:
             logger.error('GMSH Mesh error detected.')
             print(_GMSH_ERROR_TEXT)
             raise
-        
+        logger.info('GMSH Meshing complete!')
         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 parameter_sweep(self, clear_mesh: bool = True, **parameters: np.ndarray) -> Generator[tuple[float,...], None, None]:
         """Executes a parameteric sweep iteration.
@@ -579,9 +622,13 @@ class Simulation:
         paramlist = sorted(list(parameters.keys()))
         dims = np.meshgrid(*[parameters[key] for key in paramlist], indexing='ij')
         dims_flat = [dim.flatten() for dim in dims]
+        
         self.mw.cache_matrices = False
+        logger.trace('Starting parameter sweep.')
+        
         for i_iter in range(dims_flat[0].shape[0]):
-            if clear_mesh:
+            
+            if clear_mesh and i_iter > 0:
                 logger.info('Cleaning up mesh.')
                 gmsh.clear()
                 mesh = Mesh3D(self.mesher)
@@ -592,12 +639,19 @@ class Simulation:
             params = {key: dim[i_iter] for key,dim in zip(paramlist, dims_flat)}
             self.mw._params = params
             self.data.sim.new(**params)
-
+            
             logger.info(f'Iterating: {params}')
             if len(dims_flat)==1:
                 yield dims_flat[0][i_iter]
             else:
                 yield (dim[i_iter] for dim in dims_flat) # type: ignore
+            
+            if not clear_mesh:
+                self._save_geometries()
+        
+        if not clear_mesh:
+                self._save_geometries()
+        
         self.mw.cache_matrices = True
     
     def export(self, filename: str):
@@ -613,6 +667,7 @@ class Simulation:
         Args:
             filename (str): The filename
         """
+        logger.trace(f'Writing geometry to {filename}')
         gmsh.write(filename)
         
     def set_solver(self, solver: EMSolver | Solver):
@@ -622,6 +677,7 @@ class Simulation:
         Args:
             solver (EMSolver | Solver): The solver objects
         """
+        logger.trace(f'Setting solver to {solver}')
         self.mw.solveroutine.set_solver(solver)
         
     ############################################################

emerge/_emerge/simulation_data.py

@@ -159,7 +159,7 @@ class DataEntry:
         return all(self.vars[key]==other[key] for key in allkeys)
     
     def _dist(self, other: dict[str, float]) -> float:
-        return sum([(abs(self.vars.get(key,1e20)-other[key])/other[key]) for key in other.keys()])
+        return sum([(abs(self.vars.get(key,1e20)-other[key])/(other[key]+1e-12)) for key in other.keys()])
     
     def __getitem__(self, key) -> Any:
         return self.data[key]
@@ -191,6 +191,11 @@ class DataContainer:
         for entry in self.entries:
             yield entry.vars, entry.data
 
+    @property
+    def first(self) -> DataEntry:
+        """Returns the first added entry"""
+        return self.entries[0]
+    
     @property
     def last(self) -> DataEntry:
         """Returns the last added entry"""
@@ -203,7 +208,11 @@ class DataContainer:
             return self.stock
         else:
             return self.last
-        
+    
+    def index(self, index: int) -> DataEntry:
+        """Returns the last added entry"""
+        return self.entries[index]
+    
     def select(self, **vars: float) -> DataEntry | None:
         """Returns the data entry corresponding to the provided parametric sweep set"""
         for entry in self.entries:
@@ -318,7 +327,11 @@ class BaseDataset(Generic[T,M]):
         for i, var_map in enumerate(self._variables):
             error = sum([abs(var_map.get(k, 1e30) - v) for k, v in variables.items()])
             output.append((i,error))
-        return self.get_entry(sorted(output, key=lambda x:x[1])[0][0])
+        selection_id = sorted(output, key=lambda x:x[1])[0][0]
+        entry = self.get_entry(selection_id)
+        variables = ', '.join([f'{key}={value}' for key,value in self._variables[selection_id].items()])
+        logger.info(f'Selected entry: {variables}')
+        return entry
 
     def axis(self, name: str) -> np.ndarray:
         """Returns a sorted list of all variables for the given name
@@ -343,7 +356,8 @@ class BaseDataset(Generic[T,M]):
         return new_entry
     
     def _grid_axes(self) -> bool:
-        """This method attepmts to create a gritted version of the scalar dataset
+        """This method attepmts to create a gritted version of the scalar dataset. It may fail
+        if the data in the dataset cannot be cast into a gridded structure.
 
         Returns:
             None
@@ -353,9 +367,11 @@ class BaseDataset(Generic[T,M]):
         for var in self._variables:
             for key, value in var.items():
                 variables[key].add(value)
+                
         N_entries = len(self._variables)
         N_prod = 1
         N_dim = len(variables)
+        
         for key, val_list in variables.items():
             N_prod *= len(val_list)
         
@@ -369,8 +385,10 @@ class BaseDataset(Generic[T,M]):
         
         self._axes = dict()
         self._ax_ids = dict()
+        
         revax = dict()
         i = 0
+        
         for key, val_set in variables.items():
             self._axes[key] = np.sort(np.array(list(val_set)))
             self._ax_ids[key] = i