zoomy-core 0.1.2__tar.gz → 0.1.3__tar.gz

{zoomy_core-0.1.2 → zoomy_core-0.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: zoomy_core
-Version: 0.1.2
+Version: 0.1.3
 Summary: A simulation software for dimensionally-reduced free surface flows.
 Author-email: Ingo Steldermann <steldermann@mbd.rwth-aachen.de>
 License: GNU
@@ -20,6 +20,7 @@ Requires-Dist: attrs
 Requires-Dist: sympy>=1.13.3
 Requires-Dist: numpy
 Requires-Dist: scipy
+Requires-Dist: loguru
 Provides-Extra: gui
 Requires-Dist: pyvista; extra == "gui"
 Requires-Dist: trame; extra == "gui"

{zoomy_core-0.1.2 → zoomy_core-0.1.3}/library/zoomy_core/mesh/mesh.py

@@ -2,6 +2,7 @@ import os
 
 try:
     import h5py
+
     _HAVE_H5PY = True
 except ImportError:
     _HAVE_H5PY = False
@@ -9,15 +10,22 @@ except ImportError:
 
 try:
     from petsc4py import PETSc
+
     _HAVE_PETSC = True
 except ImportError:
     _HAVE_PETSC = False
-    
+
+
+try:
+    import meshio
+
+    _HAVE_MESHIO = True
+except:
+    _HAVE_MESHIO = False
 from copy import deepcopy
 from itertools import product
 from typing import Union
 
-import meshio
 import numpy as np
 from attr import define
 
@@ -62,7 +70,6 @@ def scale_lsq_derivative(mon_indices):
     return scale_factors
 
 
-
 def find_derivative_indices(full_monomials_arr, requested_derivs_arr):
     """
     Args:
@@ -91,7 +98,6 @@ def find_derivative_indices(full_monomials_arr, requested_derivs_arr):
     return indices
 
 
-
 def compute_derivatives(u, mesh, derivatives_multi_index=None):
     A_glob = mesh.lsq_gradQ  # shape (n_cells, n_monomials, n_neighbors)
     neighbors = mesh.lsq_neighbors  # list of neighbors per cell
@@ -108,7 +114,8 @@ def compute_derivatives(u, mesh, derivatives_multi_index=None):
         delta_u = u_neighbors - u_i
         return (scale_factors * (A_loc.T @ delta_u)).T  # shape (n_monomials,)
 
-    out = np.zeros((A_glob.shape[0], len(derivatives_multi_index)), dtype=float)
+    out = np.zeros((A_glob.shape[0], len(
+        derivatives_multi_index)), dtype=float)
     for i in range(A_glob.shape[0]):
         A_loc = A_glob[i]
         neighbor_idx = neighbors[i]
@@ -193,8 +200,10 @@ def least_squares_reconstruction_local(
 
         # Expand further if still under-resolved
         while n_nbr < max_neighbors:
-            extended_neighbors = expand_neighbors(neighbors_list, current_neighbors)
-            extended_neighbors = list(set(extended_neighbors) - {i_c})  # Remove self
+            extended_neighbors = expand_neighbors(
+                neighbors_list, current_neighbors)
+            extended_neighbors = list(
+                set(extended_neighbors) - {i_c})  # Remove self
             # Keep only new neighbors not already present
             new_neighbors = [
                 n for n in extended_neighbors if n not in current_neighbors
@@ -220,7 +229,8 @@ def least_squares_reconstruction_local(
         for j, neighbor in enumerate(trimmed_neighbors):
             dX[j, :] = cell_centers[neighbor] - cell_centers[i_c]
 
-        V = build_vandermonde(dX, mon_indices)  # shape (max_neighbors, n_monomials)
+        # shape (max_neighbors, n_monomials)
+        V = build_vandermonde(dX, mon_indices)
 
         # Compute weights
         weights = compute_gaussian_weights(dX)  # shape (n_neighbors,)
@@ -238,6 +248,10 @@ def least_squares_reconstruction_local(
 
 
 def get_physical_boundary_labels(filepath):
+    if not _HAVE_MESHIO:
+        raise RuntimeError(
+            "_write_to_vtk_from_vertices_edges requires meshio, which is not available."
+        )
     mesh = meshio.read(filepath)
     boundary_dict = {key: value[0] for key, value in mesh.field_data.items()}
     return boundary_dict
@@ -327,7 +341,8 @@ def _boundary_dict_indices(d):
 def _get_neighberhood(dm, cell, cStart=0):
     neighbors = (
         np.array(
-            [dm.getSupport(f)[dm.getSupport(f) != cell][0] for f in dm.getCone(cell)],
+            [dm.getSupport(f)[dm.getSupport(f) != cell][0]
+             for f in dm.getCone(cell)],
             dtype=int,
         )
         - cStart
@@ -338,7 +353,8 @@ def _get_neighberhood(dm, cell, cStart=0):
 def _fill_neighborhood(dm, neighbors, max_neighbors, cStart=0):
     new_potential_neighbors = []
     for cell in neighbors:
-        new_potential_neighbors += list(_get_neighberhood(dm, cell, cStart=cStart))
+        new_potential_neighbors += list(_get_neighberhood(dm,
+                                        cell, cStart=cStart))
     new_potential_neighbors = np.array(new_potential_neighbors)
     new_neighbors = np.setdiff1d(new_potential_neighbors, neighbors)
     neighbors = np.concatenate((neighbors, new_neighbors))[:max_neighbors]
@@ -435,7 +451,8 @@ class Mesh:
                     for d in range(self.dimension)
                 ]
                 # reverse the order of lexsort such that the most important is first IS NOT NEEDED, since lexsort starts sorting by the last entry in the list
-                sort_order_significance = np.lexsort([significance_per_dimension])
+                sort_order_significance = np.lexsort(
+                    [significance_per_dimension])
 
                 from_cells_sort_order = np.lexsort(
                     [from_coords[d, :] for d in sort_order_significance]
@@ -485,7 +502,8 @@ class Mesh:
         cell_centers[:n_inner_cells, 0] = np.arange(xL + dx / 2, xR, dx)
         cell_centers[n_inner_cells, 0] = xL - dx / 2
         cell_centers[n_inner_cells + 1, 0] = xR + dx / 2
-        cell_neighbors = (n_cells + 1) * np.ones((n_cells, n_faces_per_cell), dtype=int)
+        cell_neighbors = (n_cells + 1) * \
+            np.ones((n_cells, n_faces_per_cell), dtype=int)
 
         cell_faces = np.empty((n_inner_cells, n_faces_per_cell), dtype=int)
         cell_faces[:, 0] = list(range(0, n_faces - 1))
@@ -511,8 +529,10 @@ class Mesh:
             face_normals[i_face, 0] = 1.0
 
         boundary_face_cells = np.array([0, n_inner_cells - 1], dtype=int)
-        boundary_face_ghosts = np.array([n_inner_cells, n_inner_cells + 1], dtype=int)
-        boundary_face_function_numbers = np.empty((n_boundary_faces), dtype=int)
+        boundary_face_ghosts = np.array(
+            [n_inner_cells, n_inner_cells + 1], dtype=int)
+        boundary_face_function_numbers = np.empty(
+            (n_boundary_faces), dtype=int)
         boundary_face_function_numbers[0] = 0
         boundary_face_function_numbers[1] = 1
         boundary_face_physical_tags = np.array([0, 1], dtype=int)
@@ -520,8 +540,8 @@ class Mesh:
 
         face_cells = np.empty((n_faces, 2), dtype=int)
         # face_cell_face_index = (n_faces + 1)*np.ones((n_faces, 2), dtype=int)
-        face_cells[1 : n_faces - 1, 0] = list(range(0, n_inner_cells - 1))
-        face_cells[1 : n_faces - 1, 1] = list(range(1, n_inner_cells))
+        face_cells[1: n_faces - 1, 0] = list(range(0, n_inner_cells - 1))
+        face_cells[1: n_faces - 1, 1] = list(range(1, n_inner_cells))
         # face_cell_face_index[1:n_faces-1, 0] = 1
         # face_cell_face_index[1:n_faces-1, 1] = 0
         face_cells[0, 0] = n_inner_cells
@@ -558,12 +578,12 @@ class Mesh:
         lsq_scale_factors = scale_lsq_derivative(lsq_monomial_multi_index)
 
         n_face_neighbors = 2
-        face_neighbors = (n_cells + 1) * np.ones((n_faces, n_face_neighbors), dtype=int)
+        face_neighbors = (n_cells + 1) * \
+            np.ones((n_faces, n_face_neighbors), dtype=int)
 
         for i_f, neighbors in enumerate(face_cells):
             face_neighbors[i_f] = neighbors
 
-
         z_ordering = np.array([-1], dtype=float)
 
         # return cls(dimension, 'line', n_cells, n_cells + 1, 2, n_faces_per_element, vertex_coordinates, element_vertices, element_face_areas, element_centers, element_volume, element_inradius, element_face_normals, element_n_neighbors, element_neighbors, element_neighbors_face_index, boundary_face_vertices, boundary_face_corresponding_element, boundary_face_element_face_index, boundary_face_tag, boundary_tag_names)
@@ -679,14 +699,16 @@ class Mesh:
         n_inner_cells = cEnd - cStart
         n_faces = egEnd - egStart
         n_vertices = vEnd - vStart
-        cell_vertices = np.zeros((n_inner_cells, n_vertices_per_cell), dtype=int)
+        cell_vertices = np.zeros(
+            (n_inner_cells, n_vertices_per_cell), dtype=int)
         cell_faces = np.zeros((n_inner_cells, n_faces_per_cell), dtype=int)
         cell_centers = np.zeros((n_cells, 3), dtype=float)
         # I create cell_volumes of size n_cells because then I can avoid an if clause in the numerical flux computation. The values will be delted after using apply_boundary_conditions anyways
         cell_volumes = np.ones((n_cells), dtype=float)
         cell_inradius = compute_cell_inradius(dm)
         for i_c, c in enumerate(range(cStart, cEnd)):
-            cell_volume, cell_center, cell_normal = dm.computeCellGeometryFVM(c)
+            cell_volume, cell_center, cell_normal = dm.computeCellGeometryFVM(
+                c)
             transitive_closure_points, transitive_closure_orientation = (
                 dm.getTransitiveClosure(c, useCone=True)
             )
@@ -731,7 +753,8 @@ class Mesh:
 
         for e in range(egStart, egEnd):
             label = gdm.getLabelValue("Face Sets", e)
-            face_volume, face_center, face_normal = gdm.computeCellGeometryFVM(e)
+            face_volume, face_center, face_normal = gdm.computeCellGeometryFVM(
+                e)
             face_vertices = get_face_vertices(dim, gdm, vgStart, e)
             face_vertices_coords = vertex_coordinates[face_vertices]
             _face_cells = gdm.getSupport(e)
@@ -801,7 +824,8 @@ class Mesh:
         # NON_VECTORIZED CASE
         polynomial_degree = 1
         n_neighbors = n_faces_per_cell * polynomial_degree
-        cell_neighbors = (n_cells + 1) * np.ones((n_cells, n_neighbors), dtype=int)
+        cell_neighbors = (n_cells + 1) * \
+            np.ones((n_cells, n_neighbors), dtype=int)
 
         for i_c, c in enumerate(range(cgStart, cgEnd)):
             # GET NEIGHBORHOOD
@@ -826,7 +850,8 @@ class Mesh:
         lsq_scale_factors = scale_lsq_derivative(lsq_monomial_multi_index)
 
         n_face_neighbors = (2 * (n_faces_per_cell + 1) - 2) * polynomial_degree
-        face_neighbors = (n_cells + 1) * np.ones((n_faces, n_face_neighbors), dtype=int)
+        face_neighbors = (n_cells + 1) * \
+            np.ones((n_faces, n_face_neighbors), dtype=int)
 
         for i_f, f in enumerate(range(egStart, egEnd)):
             # GET NEIGHBORHOOD
@@ -835,7 +860,6 @@ class Mesh:
             )
             face_neighbors[i_f, :] = neighbors
 
-
         face_volumes = np.array(face_volumes, dtype=float)
         _face_centers = np.array(face_centers, dtype=float)
         face_centers = np.zeros((n_faces, 3), dtype=float)
@@ -845,18 +869,21 @@ class Mesh:
 
         face_cells = np.array(face_cells, dtype=int)
         # face_cell_face_index = np.array(face_cell_face_index, dtype=int)
-        boundary_face_function_numbers = _boundary_dict_indices(boundary_face_cells)
+        boundary_face_function_numbers = _boundary_dict_indices(
+            boundary_face_cells)
 
         # get rid of empty keys in the boundary_dict (e.g. no surface values in 2d)
         boundary_dict_inverted = {v: k for k, v in boundary_dict.items()}
-        boundary_dict_reduced = {k: boundary_dict_inverted[k] for k in allowed_keys}
+        boundary_dict_reduced = {
+            k: boundary_dict_inverted[k] for k in allowed_keys}
 
         # sort the dict by the values
         sorted_keys = np.array(list(boundary_dict_reduced.keys()), dtype=int)
         sorted_keys.sort()
         boundary_dict = {k: boundary_dict_reduced[k] for k in sorted_keys}
         boundary_face_cells = {k: boundary_face_cells[k] for k in sorted_keys}
-        boundary_face_ghosts = {k: boundary_face_ghosts[k] for k in sorted_keys}
+        boundary_face_ghosts = {
+            k: boundary_face_ghosts[k] for k in sorted_keys}
         boundary_face_face_indices = {
             k: boundary_face_face_indices[k] for k in sorted_keys
         }
@@ -937,7 +964,8 @@ class Mesh:
         n_boundary_faces = msh.n_boundary_faces * n_layers + 2 * msh.n_cells
         n_faces_per_cell = mesh_util._get_faces_per_element(mesh_type)
         n_faces = n_inner_cells * n_faces_per_cell
-        vertex_coordinates = extrude.extrude_points(msh.vertex_coordinates.T, Z).T
+        vertex_coordinates = extrude.extrude_points(
+            msh.vertex_coordinates.T, Z).T
         cell_vertices = extrude.extrude_element_vertices(
             msh.cell_vertices.T, msh.n_vertices, n_layers
         ).T
@@ -946,16 +974,16 @@ class Mesh:
         cell_volumes = np.empty((n_cells), dtype=float)
         cell_inradius = np.empty((n_cells), dtype=float)
         cell_face_areas = np.empty((n_cells, n_faces_per_cell), dtype=float)
-        cell_face_normals = np.zeros((n_cells, n_faces_per_cell, 3), dtype=float)
+        cell_face_normals = np.zeros(
+            (n_cells, n_faces_per_cell, 3), dtype=float)
         cell_n_neighbors = np.empty((n_cells), dtype=int)
         cell_neighbors = np.empty((n_cells, n_faces_per_cell), dtype=int)
-        cell_neighbors_face_index = np.empty((n_cells, n_faces_per_cell), dtype=int)
+        cell_neighbors_face_index = np.empty(
+            (n_cells, n_faces_per_cell), dtype=int)
         for i_elem, elem in enumerate(cell_vertices.T):
-
             cell_centers[i_elem, :dimension] = mesh_util.center(
                 vertex_coordinates.T, elem
             )
-        
 
         # truncate normals and positions from 3d to dimendion-d
         vertex_coordinates = vertex_coordinates.T[:, :dimension].T
@@ -966,8 +994,10 @@ class Mesh:
         # empty fields
         cell_faces = np.empty((n_inner_cells, n_faces_per_cell), dtype=int)
         boundary_face_cells = np.array([0, n_inner_cells - 1], dtype=int)
-        boundary_face_ghosts = np.array([n_inner_cells, n_inner_cells + 1], dtype=int)
-        boundary_face_function_numbers = np.empty((n_boundary_faces), dtype=int)
+        boundary_face_ghosts = np.array(
+            [n_inner_cells, n_inner_cells + 1], dtype=int)
+        boundary_face_function_numbers = np.empty(
+            (n_boundary_faces), dtype=int)
         boundary_face_physical_tags = np.array([0, 1], dtype=int)
         boundary_face_face_indices = np.array([0, n_faces - 1], dtype=int)
         face_cells = np.empty((n_faces, 2), dtype=int)
@@ -980,7 +1010,8 @@ class Mesh:
 
         # hard coded guess
         n_face_neighbors = 0
-        face_neighbors = (n_cells + 1) * np.ones((n_faces, n_face_neighbors), dtype=int)
+        face_neighbors = (n_cells + 1) * \
+            np.ones((n_faces, n_face_neighbors), dtype=int)
         lsq_gradQ = np.zeros((n_cells, dimension, 0), dtype=float)
         lsq_neighbors = np.zeros(1)
         lsq_monomial_multi_index = np.zeros(1)
@@ -1024,7 +1055,7 @@ class Mesh:
         )
 
     def write_to_hdf5(self, filepath: str):
-        if  not _HAVE_H5PY:
+        if not _HAVE_H5PY:
             raise RuntimeError(
                 "Mesh.write_to_hdf5() requires h5py, which is not available."
             )
@@ -1039,15 +1070,18 @@ class Mesh:
             mesh.create_dataset("n_vertices", data=self.n_vertices)
             mesh.create_dataset("n_boundary_faces", data=self.n_boundary_faces)
             mesh.create_dataset("n_faces_per_cell", data=self.n_faces_per_cell)
-            mesh.create_dataset("vertex_coordinates", data=self.vertex_coordinates)
+            mesh.create_dataset("vertex_coordinates",
+                                data=self.vertex_coordinates)
             mesh.create_dataset("cell_vertices", data=self.cell_vertices)
             mesh.create_dataset("cell_faces", data=self.cell_faces)
             mesh.create_dataset("cell_volumes", data=self.cell_volumes)
             mesh.create_dataset("cell_centers", data=self.cell_centers)
             mesh.create_dataset("cell_inradius", data=self.cell_inradius)
             mesh.create_dataset("cell_neighbors", data=self.cell_neighbors)
-            mesh.create_dataset("boundary_face_cells", data=self.boundary_face_cells)
-            mesh.create_dataset("boundary_face_ghosts", data=self.boundary_face_ghosts)
+            mesh.create_dataset("boundary_face_cells",
+                                data=self.boundary_face_cells)
+            mesh.create_dataset("boundary_face_ghosts",
+                                data=self.boundary_face_ghosts)
             mesh.create_dataset(
                 "boundary_face_function_numbers",
                 data=self.boundary_face_function_numbers,
@@ -1071,14 +1105,17 @@ class Mesh:
             )
             mesh.create_dataset(
                 "boundary_conditions_sorted_names",
-                data=np.array(self.boundary_conditions_sorted_names, dtype="S"),
+                data=np.array(
+                    self.boundary_conditions_sorted_names, dtype="S"),
             )
             mesh.create_dataset("lsq_gradQ", data=np.array(self.lsq_gradQ))
-            mesh.create_dataset("lsq_neighbors", data=np.array(self.lsq_neighbors))
+            mesh.create_dataset(
+                "lsq_neighbors", data=np.array(self.lsq_neighbors))
             mesh.create_dataset(
                 "lsq_monomial_multi_index", data=(self.lsq_monomial_multi_index)
             )
-            mesh.create_dataset("lsq_scale_factors", data=(self.lsq_scale_factors))
+            mesh.create_dataset("lsq_scale_factors",
+                                data=(self.lsq_scale_factors))
             mesh.create_dataset("z_ordering", data=np.array(self.z_ordering))
 
     @classmethod
@@ -1119,7 +1156,8 @@ class Mesh:
                 file["mesh"]["face_neighbors"][()],
                 file["mesh"]["boundary_conditions_sorted_physical_tags"][()],
                 np.array(
-                    file["mesh"]["boundary_conditions_sorted_names"][()], dtype="str"
+                    file["mesh"]["boundary_conditions_sorted_names"][()
+                                                                     ], dtype="str"
                 ),
                 file["mesh"]["lsq_gradQ"][()],
                 file["mesh"]["lsq_neighbors"][()],
@@ -1136,6 +1174,10 @@ class Mesh:
         field_names: Union[list[str], None] = None,
         point_data: dict = {},
     ):
+        if not _HAVE_MESHIO:
+            raise RuntimeError(
+                "_write_to_vtk_from_vertices_edges requires meshio, which is not available."
+            )
         d_fields = {}
         vertex_coords_3d = np.zeros((3, self.vertex_coordinates.shape[1]))
         vertex_coords_3d[: self.vertex_coordinates.shape[0], :] = (

{zoomy_core-0.1.2 → zoomy_core-0.1.3}/library/zoomy_core/misc/io.py

@@ -1,11 +1,18 @@
 import os
 import numpy as np
-import meshio
 import json
 import shutil
 
+try:
+    import meshio
+
+    _HAVE_MESHIO = True
+except:
+    _HAVE_MESHIO = False
+
 try:
     import h5py
+
     _HAVE_H5PY = True
 except ImportError:
     _HAVE_H5PY = False
@@ -17,7 +24,6 @@ from library.zoomy_core.misc.misc import Zstruct, Settings
 from library.zoomy_core.misc.logger_config import logger
 
 
-
 def init_output_directory(path, clean):
     main_dir = os.getenv("ZOOMY_DIR")
     path = os.path.join(main_dir, path)
@@ -30,12 +36,14 @@ def init_output_directory(path, clean):
             else:
                 os.remove(os.path.join(path, f))
 
+
 def get_hdf5_type(value):
     out = type(value)
     if isinstance(value, str):
         out = h5py.string_dtype()
     return out
 
+
 def write_dict_to_hdf5(group, d):
     for key, value in d.items():
         if isinstance(value, dict):
@@ -47,12 +55,14 @@ def write_dict_to_hdf5(group, d):
             group.create_dataset(key, data=value)
         elif isinstance(value, type(np.ndarray)):
             group.create_dataset(key, data=value)
-        elif hasattr(value, "as_dict"): 
+        elif hasattr(value, "as_dict"):
             subgroup = group.create_group(key)
             write_dict_to_hdf5(subgroup, value.as_dict())
         else:
-            logger.warning(f"Skipping unsupported type for key: {key} -> {type(value)}")
-            
+            logger.warning(f"Skipping unsupported type for key: {
+                           key} -> {type(value)}")
+
+
 def load_hdf5_to_dict(group):
     d = {}
     for key, value in group.items():
@@ -60,11 +70,12 @@ def load_hdf5_to_dict(group):
             d[key] = load_hdf5_to_dict(value)
         elif isinstance(value, h5py.Dataset):
             if value.dtype == h5py.string_dtype():
-                d[key] = value[()].decode('utf-8')
-            else:  
+                d[key] = value[()].decode("utf-8")
+            else:
                 d[key] = value[()]
         else:
-            logger.warning(f"Skipping unsupported type for key: {key} -> {type(value)}")
+            logger.warning(f"Skipping unsupported type for key: {
+                           key} -> {type(value)}")
 
     return d
 
@@ -74,16 +85,18 @@ def save_settings(settings):
     filepath = os.path.join(main_dir, settings.output.directory)
     with h5py.File(os.path.join(filepath, "settings.h5"), "w") as f:
         write_dict_to_hdf5(f, settings.as_dict(recursive=True))
-        
+
+
 def load_settings(filepath):
     main_dir = os.getenv("ZOOMY_DIR")
     filepath = os.path.join(main_dir, filepath)
     with h5py.File(os.path.join(filepath, "settings.h5"), "r") as f:
         d = load_hdf5_to_dict(f)
-        
-    settings = Settings.from_dict(d)                
+
+    settings = Settings.from_dict(d)
     return settings
-        
+
+
 def load_settings2(filepath):
     main_dir = os.getenv("ZOOMY_DIR")
     filepath = os.path.join(main_dir, filepath)
@@ -91,19 +104,21 @@ def load_settings2(filepath):
         model = f["model"]
         solver = f["solver"]
         output = f["output"]
-        
+
         d_model = {}
-        if 'parameters' in model:
+        if "parameters" in model:
             parameters = {k: v[()] for k, v in model["parameters"].items()}
             parameters = Zstruct(**parameters)
         for k in model.keys():
-            if k != 'parameters':
+            if k != "parameters":
                 v = model[k][()]
                 if isinstance(v, (str, int, float, bool)):
                     d_model[k] = v
                 else:
-                    raise ValueError(f"Unsupported type for model attribute {k}: {type(v)}")
-        d_model['parameters'] = parameters
+                    raise ValueError(
+                        f"Unsupported type for model attribute {k}: {type(v)}"
+                    )
+        d_model["parameters"] = parameters
         model = Zstruct(**d_model)
         d_solver = {}
         for k in solver.keys():
@@ -111,21 +126,24 @@ def load_settings2(filepath):
             if isinstance(v, (str, int, float, bool)):
                 d_solver[k] = v
             else:
-                raise ValueError(f"Unsupported type for solver attribute {k}: {type(v)}")
+                raise ValueError(
+                    f"Unsupported type for solver attribute {k}: {type(v)}"
+                )
         solver = Zstruct(**d_solver)
-        
+
         d_output = {}
         for k in output.keys():
             v = output[k][()]
             if isinstance(v, (str, int, float, bool)):
                 d_output[k] = v
             else:
-                raise ValueError(f"Unsupported type for output attribute {k}: {type(v)}")
+                raise ValueError(
+                    f"Unsupported type for output attribute {k}: {type(v)}"
+                )
         output = Zstruct(**d_output)
-        
+
         settings = Settings(model=model, solver=solver, output=output)
-                
-                
+
         # parameters = {k: v[()] for k, v in f["parameters"].items()}
         # name = f["name"][()]
         # output_dir = f["output_dir"][()]
@@ -160,7 +178,8 @@ def _save_fields_to_hdf5(filepath, i_snapshot, time, Q, Qaux=None, overwrite=Tru
             if overwrite:
                 del fields[group_name]
             else:
-                raise ValueError(f"Group {group_name} already exists in {filepath}")
+                raise ValueError(
+                    f"Group {group_name} already exists in {filepath}")
         attrs = fields.create_group(group_name)
         attrs.create_dataset("time", data=time, dtype=float)
         attrs.create_dataset("Q", data=Q)
@@ -168,6 +187,7 @@ def _save_fields_to_hdf5(filepath, i_snapshot, time, Q, Qaux=None, overwrite=Tru
             attrs.create_dataset("Qaux", data=Qaux)
     return i_snapshot + 1.0
 
+
 def get_save_fields_simple(_filepath, write_all, overwrite=True):
     def _save_hdf5(i_snapshot, time, Q, Qaux):
         i_snap = int(i_snapshot)
@@ -184,15 +204,18 @@ def get_save_fields_simple(_filepath, write_all, overwrite=True):
                 if overwrite:
                     del fields[group_name]
                 else:
-                    raise ValueError(f"Group {group_name} already exists in {filepath}")
+                    raise ValueError(
+                        f"Group {group_name} already exists in {filepath}")
             attrs = fields.create_group(group_name)
             attrs.create_dataset("time", data=time, dtype=float)
             attrs.create_dataset("Q", data=Q)
             if Qaux is not None:
                 attrs.create_dataset("Qaux", data=Qaux)
         return i_snapshot + 1.0
+
     return _save_hdf5
 
+
 def _save_hdf5(_filepath, i_snapshot, time, Q, Qaux, overwrite=True):
     i_snap = int(i_snapshot)
     main_dir = os.getenv("ZOOMY_DIR")
@@ -208,7 +231,8 @@ def _save_hdf5(_filepath, i_snapshot, time, Q, Qaux, overwrite=True):
             if overwrite:
                 del fields[group_name]
             else:
-                raise ValueError(f"Group {group_name} already exists in {filepath}")
+                raise ValueError(
+                    f"Group {group_name} already exists in {filepath}")
         attrs = fields.create_group(group_name)
         attrs.create_dataset("time", data=time, dtype=float)
         attrs.create_dataset("Q", data=Q)
@@ -216,19 +240,25 @@ def _save_hdf5(_filepath, i_snapshot, time, Q, Qaux, overwrite=True):
             attrs.create_dataset("Qaux", data=Qaux)
     return i_snapshot + 1.0
 
+
 def get_save_fields(_filepath, write_all=False, overwrite=True):
     if _HAVE_H5PY:
-        def save(time, next_write_at, i_snapshot, Q, Qaux):   
+
+        def save(time, next_write_at, i_snapshot, Q, Qaux):
             if write_all or time >= next_write_at:
-                return _save_hdf5(_filepath, i_snapshot, time, Q, Qaux, overwrite=overwrite)
+                return _save_hdf5(
+                    _filepath, i_snapshot, time, Q, Qaux, overwrite=overwrite
+                )
             else:
                 return i_snapshot
     else:
-        def save(time, next_write_at, i_snapshot, Q, Qaux):   
+
+        def save(time, next_write_at, i_snapshot, Q, Qaux):
             if write_all or time >= next_write_at:
                 return i_snapshot + 1
             else:
                 return i_snapshot
+
     return save
 
 
@@ -240,6 +270,7 @@ def save_fields_test(a):
     _save_fields_to_hdf5(filepath, i_snapshot, time, Q, Qaux)
     return i_snapshot + 1
 
+
 def load_mesh_from_hdf5(filepath):
     mesh = Mesh.from_hdf5(filepath)
     return mesh
@@ -292,6 +323,10 @@ def _write_to_vtk_from_vertices_edges(
     point_fields=None,
     point_field_names=None,
 ):
+    if not _HAVE_MESHIO:
+        raise RuntimeError(
+            "_write_to_vtk_from_vertices_edges requires meshio, which is not available."
+        )
     assert (
         mesh_type == "triangle"
         or mesh_type == "quad"
@@ -306,13 +341,15 @@ def _write_to_vtk_from_vertices_edges(
         if field_names is None:
             field_names = [str(i) for i in range(fields.shape[0])]
         for i_fields, _ in enumerate(fields):
-            d_fields[field_names[i_fields]] = [fields[i_fields, :n_inner_elements]]
+            d_fields[field_names[i_fields]] = [
+                fields[i_fields, :n_inner_elements]]
     point_d_fields = {}
     if point_fields is not None:
         if point_field_names is None:
             point_field_names = [str(i) for i in range(point_fields.shape[0])]
         for i_fields, _ in enumerate(point_fields):
-            point_d_fields[point_field_names[i_fields]] = point_fields[i_fields]
+            point_d_fields[point_field_names[i_fields]
+                           ] = point_fields[i_fields]
     meshout = meshio.Mesh(
         vertex_coordinates,
         [(mesh_util.convert_mesh_type_to_meshio_mesh_type(mesh_type), cell_vertices)],
@@ -331,7 +368,7 @@ def generate_vtk(
     aux_field_names=None,
     skip_aux=False,
     filename="out",
-    warp=False
+    warp=False,
 ):
     main_dir = os.getenv("ZOOMY_DIR")
     abs_filepath = os.path.join(main_dir, filepath)
@@ -367,7 +404,8 @@ def generate_vtk(
         if field_names is None:
             field_names = [str(i) for i in range(Q.shape[0])]
         if aux_field_names is None:
-            aux_field_names = ["aux_{}".format(str(i)) for i in range(Qaux.shape[0])]
+            aux_field_names = ["aux_{}".format(
+                str(i)) for i in range(Qaux.shape[0])]
 
         fields = np.concatenate((Q, Qaux), axis=0)
         field_names = field_names + aux_field_names
@@ -375,7 +413,6 @@ def generate_vtk(
         vertex_coordinates_3d = np.zeros((mesh.vertex_coordinates.shape[1], 3))
         vertex_coordinates_3d[:, : mesh.dimension] = mesh.vertex_coordinates.T
 
-
         _write_to_vtk_from_vertices_edges(
             os.path.join(path, output_vtk),
             mesh.type,
@@ -397,5 +434,5 @@ def generate_vtk(
     # finalize vtk
     with open(os.path.join(path, f"{full_filepath_out}.vtk.series"), "w") as f:
         json.dump(vtk_timestamp_file, f)
-        
+
     file.close()