pyNIBS 0.2024.8__py3-none-any.whl → 0.2026.1__py3-none-any.whl

pynibs/hdf5_io/hdf5_io.py

@@ -156,7 +156,7 @@ def load_mesh_msh(fname):
 
     triangles_regions = msh_msh.elm.tag2[msh_msh.elm.elm_type == 2]
 
-    obj = pynibs.mesh_struct.TetrahedraLinear(points, triangles, triangles_regions, tetrahedra, tetrahedra_regions)
+    obj = pynibs.mesh.TetrahedraLinear(points, triangles, triangles_regions, tetrahedra, tetrahedra_regions)
 
     return obj
 
@@ -229,7 +229,7 @@ def load_mesh_hdf5(fname):
             tetrahedra = np.array(f['elm/tetrahedra_number_list'])  # node_number_list[elm_type == 4, ]
             triangles_regions = np.array(f['elm/tri_tissue_type'])
             tetrahedra_regions = np.array(f['elm/tet_tissue_type'])
-    obj = pynibs.mesh_struct.TetrahedraLinear(points, triangles, triangles_regions, tetrahedra, tetrahedra_regions)
+    obj = pynibs.mesh.TetrahedraLinear(points, triangles, triangles_regions, tetrahedra, tetrahedra_regions)
     return obj
 
 
@@ -326,32 +326,30 @@ def write_geo_hdf5(out_fn, msh, roi_dict=None, hdf5_path='/mesh'):
         os.remove(out_fn)
 
     with h5py.File(out_fn, 'w') as f:
-        f.create_dataset(hdf5_path + '/elm/elm_number', data=np.arange(msh.N_tet + msh.N_tri) + 1)
-        f.create_dataset(hdf5_path + '/elm/elm_type', data=np.array([2] * msh.N_tri + [4] * msh.N_tet))
-        f.create_dataset(hdf5_path + '/elm/tag1',
-                         data=np.hstack((msh.triangles_regions + 1000, msh.tetrahedra_regions)).flatten())
-        f.create_dataset(hdf5_path + '/elm/tag2',
-                         data=np.hstack((msh.triangles_regions, msh.tetrahedra_regions)).flatten())
-        f.create_dataset(hdf5_path + '/elm/triangle_number_list', data=msh.triangles)
-        f.create_dataset(hdf5_path + '/elm/tri_tissue_type', data=msh.triangles_regions.flatten())
-        f.create_dataset(hdf5_path + '/elm/tetrahedra_number_list', data=msh.tetrahedra)
-        f.create_dataset(hdf5_path + '/elm/tet_tissue_type', data=msh.tetrahedra_regions.flatten())
+        f.create_dataset(f'{hdf5_path}/elm/elm_number', data=np.arange(msh.N_tet + msh.N_tri) + 1)
+        f.create_dataset(f'{hdf5_path}/elm/elm_type', data=np.array([2] * msh.N_tri + [4] * msh.N_tet))
+        f.create_dataset(f'{hdf5_path}/elm/tag1', data=np.hstack((msh.triangles_regions + 1000, msh.tetrahedra_regions)).flatten())
+        f.create_dataset(f'{hdf5_path}/elm/tag2', data=np.hstack((msh.triangles_regions, msh.tetrahedra_regions)).flatten())
+        f.create_dataset(f'{hdf5_path}/elm/triangle_number_list', data=msh.triangles)
+        f.create_dataset(f'{hdf5_path}/elm/tri_tissue_type', data=msh.triangles_regions.flatten())
+        f.create_dataset(f'{hdf5_path}/elm/tetrahedra_number_list', data=msh.tetrahedra)
+        f.create_dataset(f'{hdf5_path}/elm/tet_tissue_type', data=msh.tetrahedra_regions.flatten())
         if msh.tetrahedra.size != 0:
             if msh.triangles.size != 0:
-                f.create_dataset(hdf5_path + '/elm/node_number_list', data=np.vstack(
-                        (np.hstack((msh.triangles, np.zeros((msh.N_tri, 1)))),
-                         msh.tetrahedra)).astype(int))
+                f.create_dataset(f'{hdf5_path}/elm/node_number_list', data=np.vstack(
+                    (np.hstack((msh.triangles, np.zeros((msh.N_tri, 1)))),
+                     msh.tetrahedra)).astype(int))
             else:
-                f.create_dataset(hdf5_path + '/elm/node_number_list', data=msh.tetrahedra).astype(int)
+                f.create_dataset(f'{hdf5_path}/elm/node_number_list', data=msh.tetrahedra).astype(int)
         else:
-            f.create_dataset(hdf5_path + '/elm/node_number_list', data=np.vstack(
-                    (np.hstack((msh.triangles, np.zeros((msh.N_tri, 1)))),
-                     )).astype(int))
-        f.create_dataset(hdf5_path + '/nodes/node_coord', data=msh.points)
-        f.create_dataset(hdf5_path + '/nodes/node_number', data=np.arange(msh.N_points) + 1)
-        # f.create_dataset(hdf5_path + '/nodes/units', data=['mm'])
-        f.create_dataset(hdf5_path + '/elm/tet_elm_type', data=np.array([4] * msh.N_tet))
-        f.create_dataset(hdf5_path + '/elm/tri_elm_type', data=np.array([2] * msh.N_tri))
+            f.create_dataset(f'{hdf5_path}/elm/node_number_list', data=np.vstack(
+                (np.hstack((msh.triangles, np.zeros((msh.N_tri, 1)))),
+                 )).astype(int))
+        f.create_dataset(f'{hdf5_path}/nodes/node_coord', data=msh.points)
+        f.create_dataset(f'{hdf5_path}/nodes/node_number', data=np.arange(msh.N_points) + 1)
+        # f.create_datasef'{t}5_path + '/nodes/units', data=['mm'])
+        f.create_dataset(f'{hdf5_path}/elm/tet_elm_type', data=np.array([4] * msh.N_tet))
+        f.create_dataset(f'{hdf5_path}/elm/tri_elm_type', data=np.array([2] * msh.N_tri))
 
         if roi_dict is not None:
             for roi_key in roi_dict.keys():
@@ -644,21 +642,21 @@ def write_data_hdf5_surf(data, data_names, data_hdf_fn_out, geo_hdf_fn,
     except IndexError:
         data_hdf_fn_out += '.hdf5'
 
-    data_xdmf_fn = data_hdf_fn_out[:-4] + 'xdmf'
+    data_xdmf_fn = f'{data_hdf_fn_out[:-4]}xdmf'
     if os.path.exists(data_hdf_fn_out):
         if replace:
             os.remove(data_hdf_fn_out)
         elif not replace and replace_array_in_file:
             pass
         else:
-            raise FileExistsError(data_hdf_fn_out + " already exists")
+            raise FileExistsError(f"{data_hdf_fn_out} already exists")
     if os.path.exists(data_xdmf_fn):
         if replace:
             os.remove(data_xdmf_fn)
         elif not replace and replace_array_in_file:
             pass
         else:
-            raise FileExistsError(data_xdmf_fn + " already exists")
+            raise FileExistsError(f"{data_xdmf_fn} already exists")
 
     # Check for correct data and data_names
     if type(data) is np.ndarray:
@@ -666,7 +664,7 @@ def write_data_hdf5_surf(data, data_names, data_hdf_fn_out, geo_hdf_fn,
     elif type(data) is list:
         for dat in data:
             if type(dat) is not np.ndarray:
-                raise NotImplementedError
+                raise ValueError(f'Expected np.ndarray, got {type(dat)}')
     else:
         raise NotImplementedError
 
@@ -686,18 +684,19 @@ def write_data_hdf5_surf(data, data_names, data_hdf_fn_out, geo_hdf_fn,
         for idx, dat in enumerate(data):
             if replace_array_in_file:
                 try:
-                    del h5_data[f'/data/{datatype}/' + data_names[idx]]
+                    del h5_data[f'/data/{datatype}/{data_names[idx]}']
                 except KeyError:
                     only_data_replaced = False
 
             else:
                 only_data_replaced = False
 
-            h5_data.create_dataset(f'/data/{datatype}/' + data_names[idx], data=data[idx])
+            h5_data.create_dataset(f'/data/{datatype}/{data_names[idx]}', data=data[idx])
 
     if not only_data_replaced:
         data_dims = [dat.shape[1] if dat.ndim > 1 else 1 for dat in data]
-        pynibs.write_xdmf_surf(data_hdf_fn_out, data_names, data_xdmf_fn, geo_hdf_fn, data_dims)
+        pynibs.write_xdmf_surf(data_hdf=data_hdf_fn_out, data_names=data_names,
+                               data_xdmf_fn=data_xdmf_fn, geo_hdf_fn=geo_hdf_fn, data_dims=data_dims)
 
 
 def write_data_hdf5_vol(data, data_names, data_hdf_fn_out, geo_hdf_fn, replace=False, replace_array_in_file=True):
@@ -754,7 +753,7 @@ def write_data_hdf5_vol(data, data_names, data_hdf_fn_out, geo_hdf_fn, replace=F
         elif not replace and replace_array_in_file:
             pass
         else:
-            warnings.warn(data_hdf_fn_out + " already exists. Quitting")
+            warnings.warn(f"{data_hdf_fn_out} already exists. Quitting")
             return
     if os.path.exists(data_xdmf_fn):
         if replace:
@@ -762,7 +761,7 @@ def write_data_hdf5_vol(data, data_names, data_hdf_fn_out, geo_hdf_fn, replace=F
         elif not replace and replace_array_in_file:
             pass
         else:
-            warnings.warn(data_xdmf_fn + " already exists. Quitting")
+            warnings.warn(f"{data_xdmf_fn} already exists. Quitting")
             return
 
     # Check for correct data and data_names
@@ -843,16 +842,16 @@ def write_data_hdf5_vol(data, data_names, data_hdf_fn_out, geo_hdf_fn, replace=F
 
                 for vol in volume:
 
-                    n_tets = len(h5_geo['/mesh/elm/' + lookup_str + vol][:])
-                    n_nodes = len(h5_geo['/mesh/nodes/' + lookup_str_node + vol][:])
+                    n_tets = len(h5_geo[f'/mesh/elm/{lookup_str + vol}'][:])
+                    n_nodes = len(h5_geo[f'/mesh/nodes/{lookup_str_node + vol}'][:])
                     assert n_tets, n_nodes
 
                     # one grid for triangles...
                     ###########################
                     xdmf.write('<Grid Name="tris" GridType="Uniform">\n')
-                    xdmf.write('<Topology NumberOfElements="' + str(n_tets) +
-                               '" TopologyType="Tetrahedron" Name="' + vol + '_Tet">\n')
-                    xdmf.write('<DataItem Format="HDF" Dimensions="' + str(n_tets) + ' 4">\n')
+                    xdmf.write(f'<Topology NumberOfElements="{n_tets}' +
+                               f'" TopologyType="Tetrahedron" Name="{vol}_Tet">\n')
+                    xdmf.write(f'<DataItem Format="HDF" Dimensions="' + str(n_tets) + ' 4">\n')
                     xdmf.write(geo_hdf_fn + ':' + '/mesh/elm/' + lookup_str + vol + '\n')
                     xdmf.write('</DataItem>\n')
                     xdmf.write('</Topology>\n')
@@ -932,9 +931,9 @@ def hdf_2_ascii(hdf5_fn):
     h5.visititems(print_attrs)
 
 
-def simnibs_results_msh2hdf5_workhorse(fn_msh, fn_hdf5, session, pos_tms_idx, pos_local_idx, subject, mesh_idx,
+def simnibs_results_msh2hdf5_workhorse(fn_msh, fn_hdf5, session, pos_tms_idx, pos_local_idx, subject, mesh_id=None,
                                        mode_xdmf="r+",
-                                       verbose=False, overwrite=False, mid2roi=False):
+                                       verbose=False, overwrite=False, mid2roi=False, mesh_idx=None):
     """
     Converts simnibs .msh results file to .hdf5 (including midlayer data if desired)
 
@@ -954,7 +953,7 @@ def simnibs_results_msh2hdf5_workhorse(fn_msh, fn_hdf5, session, pos_tms_idx, po
         For every coil a separate TMSList exists, which contains multiple coil positions.
     subject : Subject object
         pynibs.Subject.
-    mesh_idx : int or str
+    mesh_id : int or str
         Mesh index or id.
     mode_xdmf : str, default: "r+"
         Mode to open hdf5_geo file to write xdmf. If hdf5_geo is already separated in tets and tris etc.,
@@ -967,6 +966,8 @@ def simnibs_results_msh2hdf5_workhorse(fn_msh, fn_hdf5, session, pos_tms_idx, po
         If the mesh contains ROIs and the e-field was calculated in the midlayer using SimNIBS
         (``S.map_to_surf = True``), the midlayer results will be mapped from the simnibs midlayer to the ROIs
         (takes some time for large ROIs).
+    mesh_idx : int or str, optional
+        Deprecated, use mesh_id instead.
 
     Returns
     -------
@@ -974,6 +975,10 @@ def simnibs_results_msh2hdf5_workhorse(fn_msh, fn_hdf5, session, pos_tms_idx, po
         .hdf5 file containing the results. An .xdmf file is also created to link the results with the mesh .hdf5 file
         of the subject.
     """
+    if mesh_idx is not None:
+        warnings.warn("simnibs_results_msh2hdf5_workhorse(): Use 'mesh_id' instead of 'mesh_idx'", DeprecationWarning)
+        mesh_id = mesh_idx
+
     import simnibs
     if type(fn_msh) is not list:
         fn_msh = [fn_msh]
@@ -1009,13 +1014,13 @@ def simnibs_results_msh2hdf5_workhorse(fn_msh, fn_hdf5, session, pos_tms_idx, po
                                    "_TMS_" +
                                    str(f_tms_idx + 1) + "-" + str(f_local_idx + 1).zfill(4) + "_" +
                                    os.path.splitext(
-                                           os.path.splitext(os.path.split(session.poslists[f_tms_idx].fnamecoil)[1])[
-                                               0])[0] +
+                                       os.path.splitext(os.path.split(session.poslists[f_tms_idx].fnamecoil)[1])[
+                                           0])[0] +
                                    "_nii_coil_pos.geo")
 
         # for some reason, the .geo file of the simulation was not saved ...
         try:
-            dipole_position, dipole_moment_mag = pynibs.read_coil_geo(fn_coil_geo)
+            dipole_position, dipole_moment_mag = pynibs.util.simnibs_io.read_coil_geo(fn_coil_geo)
         except FileNotFoundError:
             dipole_position = np.array([[0, 0, 0]])
             dipole_moment_mag = np.array([[0]])
@@ -1055,10 +1060,10 @@ def simnibs_results_msh2hdf5_workhorse(fn_msh, fn_hdf5, session, pos_tms_idx, po
 
         # write .xdmf markup file for paraview
         pynibs.write_xdmf(hdf5_fn=os.path.splitext(fn_hdf5[f_global_idx])[0] + ".hdf5",
-                   hdf5_geo_fn=subject.mesh[mesh_idx]["fn_mesh_hdf5"],
-                   overwrite_xdmf=True,
-                   verbose=False,
-                   mode=mode_xdmf)
+                          hdf5_geo_fn=subject.mesh[mesh_id]["fn_mesh_hdf5"],
+                          overwrite_xdmf=True,
+                          verbose=False,
+                          mode=mode_xdmf)
 
         # if calculated from Simnibs copy and crop midlayer results to ROIs
         if session.map_to_surf and mid2roi is not False:
@@ -1068,38 +1073,40 @@ def simnibs_results_msh2hdf5_workhorse(fn_msh, fn_hdf5, session, pos_tms_idx, po
                 if verbose:
                     print(f"Loading ROIs")
 
-                roi = pynibs.load_roi_surface_obj_from_hdf5(fname=subject.mesh[mesh_idx]["fn_mesh_hdf5"])
+                roi = pynibs.load_roi_surface_obj_from_hdf5(fname=subject.mesh[mesh_id]["fn_mesh_hdf5"])
                 mesh_folder = os.path.join(subject.subject_folder,
-                                           'mesh', str(mesh_idx),
-                                           subject.mesh[mesh_idx]["mesh_folder"])
+                                           'mesh', str(mesh_id),
+                                           subject.mesh[mesh_id]["mesh_folder"])
 
-                for roi_idx in roi.keys():
+                for roi_id in roi.keys():
                     # skip rois that are not wanted
-                    if isinstance(mid2roi, list) and roi_idx not in mid2roi:
+                    if isinstance(mid2roi, list) and roi_id not in mid2roi:
                         continue
                     # load freesurfer surface
-                    if type(roi[roi_idx].gm_surf_fname) is not list:
-                        roi[roi_idx].gm_surf_fname = [roi[roi_idx].gm_surf_fname]
+                    if type(roi[roi_id].gm_surf_fname) is not list:
+                        roi[roi_id].gm_surf_fname = [roi[roi_id].gm_surf_fname]
 
-                    points_gm = [None for _ in range(len(roi[roi_idx].gm_surf_fname))]
-                    con_gm = [None for _ in range(len(roi[roi_idx].gm_surf_fname))]
+                    points_gm = [None for _ in range(len(roi[roi_id].gm_surf_fname))]
+                    con_gm = [None for _ in range(len(roi[roi_id].gm_surf_fname))]
 
                     max_idx_gm = 0
 
-                    if (type(roi[roi_idx].gm_surf_fname) is list and roi[roi_idx].gm_surf_fname[0] is not None) or \
-                            (type(roi[roi_idx].gm_surf_fname) is str):
-                        if type(roi[roi_idx].gm_surf_fname) is str:
-                            fn_surface = [roi[roi_idx].gm_surf_fname]
+                    if (type(roi[roi_id].gm_surf_fname) is list and roi[roi_id].gm_surf_fname[0] is not None) or \
+                            (type(roi[roi_id].gm_surf_fname) is str):
+                        if type(roi[roi_id].gm_surf_fname) is str:
+                            fn_surface = [roi[roi_id].gm_surf_fname]
                         else:
-                            fn_surface = roi[roi_idx].gm_surf_fname
+                            fn_surface = roi[roi_id].gm_surf_fname
 
-                    elif (type(roi[roi_idx].midlayer_surf_fname) is list and
-                          roi[roi_idx].gm_surf_fname is not None) or \
-                            (type(roi[roi_idx].midlayer_surf_fname) is str):
-                        if type(roi[roi_idx].midlayer_surf_fname) is str:
-                            fn_surface = [roi[roi_idx].midlayer_surf_fname]
+                    elif (type(roi[roi_id].midlayer_surf_fname) is list and
+                          roi[roi_id].gm_surf_fname is not None) or \
+                            (type(roi[roi_id].midlayer_surf_fname) is str):
+                        if type(roi[roi_id].midlayer_surf_fname) is str:
+                            fn_surface = [roi[roi_id].midlayer_surf_fname]
                         else:
-                            fn_surface = roi[roi_idx].midlayer_surf_fname
+                            fn_surface = roi[roi_id].midlayer_surf_fname
+                    else:
+                        raise ValueError
 
                     for i in range(len(fn_surface)):
                         if fn_surface[i].endswith('.gii') or fn_surface[i].endswith('.gii.gz'):
@@ -1108,7 +1115,7 @@ def simnibs_results_msh2hdf5_workhorse(fn_msh, fn_hdf5, session, pos_tms_idx, po
                             con_gm[i] = gii_obj.darrays[1].data
                         else:
                             points_gm[i], con_gm[i] = nibabel.freesurfer.read_geometry(
-                                    os.path.join(mesh_folder, fn_surface[i]))
+                                os.path.join(mesh_folder, fn_surface[i]))
 
                         con_gm[i] = con_gm[i] + max_idx_gm
                         max_idx_gm = max_idx_gm + points_gm[i].shape[0]
@@ -1117,32 +1124,32 @@ def simnibs_results_msh2hdf5_workhorse(fn_msh, fn_hdf5, session, pos_tms_idx, po
                     con_gm = np.vstack(con_gm)
 
                     if verbose:
-                        print(f"Processing data to ROI #{roi_idx}")
-
-                    if roi[roi_idx].fn_mask is None or roi[roi_idx].fn_mask == []:
-                        if roi[roi_idx].X_ROI is None or roi[roi_idx].X_ROI == []:
-                            roi[roi_idx].X_ROI = [-np.inf, np.inf]
-                        if roi[roi_idx].Y_ROI is None or roi[roi_idx].Y_ROI == []:
-                            roi[roi_idx].Y_ROI = [-np.inf, np.inf]
-                        if roi[roi_idx].Z_ROI is None or roi[roi_idx].Z_ROI == []:
-                            roi[roi_idx].Z_ROI = [-np.inf, np.inf]
-
-                        roi_mask_bool = (roi[roi_idx].node_coord_mid[:, 0] > min(roi[roi_idx].X_ROI)) & (
-                                roi[roi_idx].node_coord_mid[:, 0] < max(roi[roi_idx].X_ROI)) & \
-                                        (roi[roi_idx].node_coord_mid[:, 1] > min(roi[roi_idx].Y_ROI)) & (
-                                                roi[roi_idx].node_coord_mid[:, 1] < max(roi[roi_idx].Y_ROI)) & \
-                                        (roi[roi_idx].node_coord_mid[:, 2] > min(roi[roi_idx].Z_ROI)) & (
-                                                roi[roi_idx].node_coord_mid[:, 2] < max(roi[roi_idx].Z_ROI))
+                        print(f"Processing data to ROI #{roi_id}")
+
+                    if roi[roi_id].fn_mask is None or roi[roi_id].fn_mask == []:
+                        if roi[roi_id].X_ROI is None or roi[roi_id].X_ROI == []:
+                            roi[roi_id].X_ROI = [-np.inf, np.inf]
+                        if roi[roi_id].Y_ROI is None or roi[roi_id].Y_ROI == []:
+                            roi[roi_id].Y_ROI = [-np.inf, np.inf]
+                        if roi[roi_id].Z_ROI is None or roi[roi_id].Z_ROI == []:
+                            roi[roi_id].Z_ROI = [-np.inf, np.inf]
+
+                        roi_mask_bool = (roi[roi_id].node_coord_mid[:, 0] > min(roi[roi_id].X_ROI)) & (
+                                roi[roi_id].node_coord_mid[:, 0] < max(roi[roi_id].X_ROI)) & \
+                                        (roi[roi_id].node_coord_mid[:, 1] > min(roi[roi_id].Y_ROI)) & (
+                                                roi[roi_id].node_coord_mid[:, 1] < max(roi[roi_id].Y_ROI)) & \
+                                        (roi[roi_id].node_coord_mid[:, 2] > min(roi[roi_id].Z_ROI)) & (
+                                                roi[roi_id].node_coord_mid[:, 2] < max(roi[roi_id].Z_ROI))
                         roi_mask_idx = np.where(roi_mask_bool)
 
                     else:
-                        if type(roi[roi_idx].fn_mask) is np.ndarray:
-                            if roi[roi_idx].fn_mask.ndim == 0:
-                                roi[roi_idx].fn_mask = roi[roi_idx].fn_mask.astype(str).tolist()
+                        if type(roi[roi_id].fn_mask) is np.ndarray:
+                            if roi[roi_id].fn_mask.ndim == 0:
+                                roi[roi_id].fn_mask = roi[roi_id].fn_mask.astype(str).tolist()
 
                         # read mask from freesurfer mask file
                         mask = nibabel.freesurfer.mghformat.MGHImage.from_filename(
-                                os.path.join(mesh_folder, roi[roi_idx].fn_mask)).dataobj[:]
+                            os.path.join(mesh_folder, roi[roi_id].fn_mask)).dataobj[:]
                         roi_mask_idx = np.where(mask > 0.5)
 
                     # read results data
@@ -1157,15 +1164,17 @@ def simnibs_results_msh2hdf5_workhorse(fn_msh, fn_hdf5, session, pos_tms_idx, po
                         if "lh" in os.path.split(fn_surf)[1]:
                             fname_base = os.path.join(os.path.split(f_msh)[0], "subject_overlays", "lh." + fn_msh_base)
 
-                        if "rh" in os.path.split(fn_surf)[1]:
+                        elif "rh" in os.path.split(fn_surf)[1]:
                             fname_base = os.path.join(os.path.split(f_msh)[0], "subject_overlays", "rh." + fn_msh_base)
+                        else:
+                            raise ValueError
 
                         e_normal.append(
-                                nibabel.freesurfer.read_morph_data(fname_base + ".central.E.normal").flatten()[:,
-                                np.newaxis])
+                            nibabel.freesurfer.read_morph_data(f"{fname_base}.central.E.normal").flatten()[:,
+                            np.newaxis])
                         e_tan.append(
-                                nibabel.freesurfer.read_morph_data(fname_base + ".central.E.tangent").flatten()[:,
-                                np.newaxis])
+                            nibabel.freesurfer.read_morph_data(f"{fname_base}.central.E.tangent").flatten()[:,
+                            np.newaxis])
 
                     e_normal = np.vstack(e_normal)
                     e_tan = np.vstack(e_tan)
@@ -1173,8 +1182,8 @@ def simnibs_results_msh2hdf5_workhorse(fn_msh, fn_hdf5, session, pos_tms_idx, po
                     # transform point data to element data
                     if verbose:
                         print("Transforming point data to element data")
-                    e_normal = pynibs.data_nodes2elements(data=e_normal, con=con_gm)
-                    e_tan = pynibs.data_nodes2elements(data=e_tan, con=con_gm)
+                    e_normal = pynibs.mesh.data_nodes2elements(data=e_normal, con=con_gm)
+                    e_tan = pynibs.mesh.data_nodes2elements(data=e_tan, con=con_gm)
 
                     # crop results data to ROI
                     # if not roi_mask_bool.all():
@@ -1196,15 +1205,15 @@ def simnibs_results_msh2hdf5_workhorse(fn_msh, fn_hdf5, session, pos_tms_idx, po
 
                     with h5py.File(os.path.splitext(fn_hdf5[f_global_idx])[0] + ".hdf5", 'a') as f:
                         try:
-                            del f['data/midlayer/roi_surface/{}/E_mag'.format(roi_idx)]
-                            del f['data/midlayer/roi_surface/{}/E_tan'.format(roi_idx)]
-                            del f['data/midlayer/roi_surface/{}/E_norm'.format(roi_idx)]
+                            del f[f'data/midlayer/roi_surface/{roi_id}/E_mag']
+                            del f[f'data/midlayer/roi_surface/{roi_id}/E_tan']
+                            del f[f'data/midlayer/roi_surface/{roi_id}/E_norm']
                         except KeyError:
                             pass
 
-                        f.create_dataset('data/midlayer/roi_surface/{}/E_mag'.format(roi_idx), data=e_mag)
-                        f.create_dataset('data/midlayer/roi_surface/{}/E_tan'.format(roi_idx), data=e_tan)
-                        f.create_dataset('data/midlayer/roi_surface/{}/E_norm'.format(roi_idx), data=e_normal)
+                        f.create_dataset(f'data/midlayer/roi_surface/{roi_id}/E_mag', data=e_mag)
+                        f.create_dataset(f'data/midlayer/roi_surface/{roi_id}/E_tan', data=e_tan)
+                        f.create_dataset(f'data/midlayer/roi_surface/{roi_id}/E_norm', data=e_normal)
 
                     del e_mag, e_normal, e_tan
             except KeyError as e:
@@ -1236,8 +1245,8 @@ def simnibs_results_msh2hdf5_workhorse(fn_msh, fn_hdf5, session, pos_tms_idx, po
         del f_global_idx
 
 
-def simnibs_results_msh2hdf5(fn_msh, fn_hdf5, S, pos_tms_idx, pos_local_idx, subject, mesh_idx, mode_xdmf="r+",
-                             n_cpu=4, verbose=False, overwrite=False, mid2roi=False):
+def simnibs_results_msh2hdf5(fn_msh, fn_hdf5, S, pos_tms_idx, pos_local_idx, subject, mesh_id=None, mode_xdmf="r+",
+                             n_cpu=4, verbose=False, overwrite=False, mid2roi=False, mesh_idx=None):
     """
     Converts simnibs .msh results file(s) to .hdf5 / .xdmf tuple.
 
@@ -1257,7 +1266,7 @@ def simnibs_results_msh2hdf5(fn_msh, fn_hdf5, S, pos_tms_idx, pos_local_idx, sub
         For every coil a separate TMSList exists, which contains multiple coil positions.
     subject : pynibs.subject.Subject
         Subject object.
-    mesh_idx : int or str
+    mesh_id : int or str
         Mesh id.
     mode_xdmf : str, default: "r+"
         Mode to open hdf5_geo file to write xdmf. If hdf5_geo is already separated in tets and tris etc.,
@@ -1272,6 +1281,8 @@ def simnibs_results_msh2hdf5(fn_msh, fn_hdf5, S, pos_tms_idx, pos_local_idx, sub
         If the mesh contains ROIs and the e-field was calculated in the midlayer using simnibs
         (``S.map_to_surf = True``),
         the midlayer results will be mapped from the simnibs midlayer to the ROIs (takes some time for large ROIs).
+    mesh_idx : int or str,
+        Deprecated, use mesh_id instead.
 
     Returns
     -------
@@ -1279,22 +1290,27 @@ def simnibs_results_msh2hdf5(fn_msh, fn_hdf5, S, pos_tms_idx, pos_local_idx, sub
         .hdf5 file containing the results. An .xdmf file is also created to link the results with the mesh .hdf5 file
         of the subject.
     """
+    if mesh_idx is not None:
+        warnings.warn("Use 'mesh_id' instead of 'mesh_idx'", DeprecationWarning)
+        mesh_id = mesh_idx
     n_cpu_available = multiprocessing.cpu_count()
     n_cpu = min(n_cpu, n_cpu_available, len(fn_msh))
     pool = multiprocessing.Pool(n_cpu)
+    if mid2roi and not S.map_to_surf:
+        warnings.warn("mid2roi is set to True, but S.map_to_surf is False. mid2roi will be ignored.")
     save_hdf5_partial = partial(simnibs_results_msh2hdf5_workhorse,
                                 fn_hdf5=fn_hdf5,
                                 session=S,
                                 pos_tms_idx=pos_tms_idx,
                                 pos_local_idx=pos_local_idx,
                                 subject=subject,
-                                mesh_idx=mesh_idx,
+                                mesh_id=mesh_id,
                                 mode_xdmf="r",
                                 verbose=verbose,
                                 overwrite=overwrite,
                                 mid2roi=mid2roi)
 
-    filenames_chunks = pynibs.compute_chunks(fn_msh, n_cpu)
+    filenames_chunks = pynibs.util.utils.compute_chunks(fn_msh, n_cpu)
     pool.map(save_hdf5_partial, filenames_chunks)
     pool.close()
     pool.join()
@@ -1377,17 +1393,17 @@ def msh2hdf5(fn_msh=None, skip_roi=False, skip_layer=True, include_data=False,
                     except KeyError:
                         pass
                     roi[mesh_idx][roi_idx].make_GM_WM_surface(
-                            gm_surf_fname=subject.roi[mesh_idx][roi_idx]['gm_surf_fname'],
-                            wm_surf_fname=subject.roi[mesh_idx][roi_idx]['wm_surf_fname'],
-                            midlayer_surf_fname=subject.roi[mesh_idx][roi_idx]['midlayer_surf_fname'],
-                            mesh_folder=mesh_folder,
-                            delta=subject.roi[mesh_idx][roi_idx]['delta'],
-                            x_roi=subject.roi[mesh_idx][roi_idx]['X_ROI'],
-                            y_roi=subject.roi[mesh_idx][roi_idx]['Y_ROI'],
-                            z_roi=subject.roi[mesh_idx][roi_idx]['Z_ROI'],
-                            layer=subject.roi[mesh_idx][roi_idx]['layer'],
-                            fn_mask=subject.roi[mesh_idx][roi_idx]['fn_mask'],
-                            refine=refine)
+                        gm_surf_fname=subject.roi[mesh_idx][roi_idx]['gm_surf_fname'],
+                        wm_surf_fname=subject.roi[mesh_idx][roi_idx]['wm_surf_fname'],
+                        midlayer_surf_fname=subject.roi[mesh_idx][roi_idx]['midlayer_surf_fname'],
+                        mesh_folder=mesh_folder,
+                        delta=subject.roi[mesh_idx][roi_idx]['delta'],
+                        x_roi=subject.roi[mesh_idx][roi_idx]['X_ROI'],
+                        y_roi=subject.roi[mesh_idx][roi_idx]['Y_ROI'],
+                        z_roi=subject.roi[mesh_idx][roi_idx]['Z_ROI'],
+                        layer=subject.roi[mesh_idx][roi_idx]['layer'],
+                        fn_mask=subject.roi[mesh_idx][roi_idx]['fn_mask'],
+                        refine=refine)
                     volmesh = simnibs.read_msh(subject.mesh[mesh_idx]['fn_mesh_msh'])
 
                     if not skip_layer:
@@ -1470,9 +1486,9 @@ def msh2hdf5(fn_msh=None, skip_roi=False, skip_layer=True, include_data=False,
         hdf5_geo_fn = out_fn
 
     pynibs.write_xdmf(hdf5_fn=out_fn,
-               hdf5_geo_fn=hdf5_geo_fn,
-               overwrite_xdmf=True,
-               verbose=False)
+                      hdf5_geo_fn=hdf5_geo_fn,
+                      overwrite_xdmf=True,
+                      verbose=False)
 
 
 def write_arr_to_hdf5(fn_hdf5, arr_name, data, overwrite_arr=True, verbose=False, check_file_exist=False):
@@ -1480,7 +1496,7 @@ def write_arr_to_hdf5(fn_hdf5, arr_name, data, overwrite_arr=True, verbose=False
     Takes an array and adds it to an hdf5 file.
 
     If data is list of dict, ``write_dict_to_hdf5()`` is called for each dict with adapted hdf5-folder name
-    Otherwise, data is casted to np.ndarray and dtype of unicode data casted to ``'|S'``.
+    Otherwise, data is cast to np.ndarray and dtype of unicode data cast to ``'|S'``.
 
     Parameters
     ----------
@@ -1573,7 +1589,6 @@ def write_dict_to_hdf5(fn_hdf5, data, folder, check_file_exist=False, verbose=Fa
     folder : str
     verbose : bool
     check_file_exist : bool
-
     """
     for key in data.keys():
         write_arr_to_hdf5(fn_hdf5=fn_hdf5,
@@ -1585,7 +1600,7 @@ def write_dict_to_hdf5(fn_hdf5, data, folder, check_file_exist=False, verbose=Fa
 
 def read_dict_from_hdf5(fn_hdf5, folder):
     """
-    Read all arrays from from hdf5 file and return them as dict
+    Read all arrays from hdf5 file and return them as dict
 
     Parameters
     ----------
@@ -1646,7 +1661,7 @@ def read_arr_from_hdf5(fn_hdf5, folder):
     Returns
     -------
     data_from_hdf5 : list
-        List containing data from .hdf5 file.
+        Contains data from .hdf5 file.
     """
     arr_1d = False
 
@@ -1715,7 +1730,7 @@ def create_fibre_geo_hdf5(fn_fibres_hdf5, overwrite=True):
 
     # create connectivity list
     fibre_con = np.hstack(
-            (np.arange(fibre_points.shape[0])[:, np.newaxis], np.arange(fibre_points.shape[0])[:, np.newaxis] + 1))
+        (np.arange(fibre_points.shape[0])[:, np.newaxis], np.arange(fibre_points.shape[0])[:, np.newaxis] + 1))
 
     # delete connectivities between fibres
     fibre_con = np.delete(fibre_con, np.cumsum([len(fib) for fib in fibres]) - 1, 0)
@@ -1735,7 +1750,7 @@ def write_coil_hdf5(tms_coil, fn):
 
     Can be visualized with ParaView (use Glyph plugin to view wires).
 
-    .. figure:: ../doc/images/two_stimulator_coil.png
+    .. figure:: ../../doc/images/two_stimulator_coil.png
        :scale: 80 %
        :alt: Example coil visualization
 
@@ -1795,21 +1810,23 @@ def write_coil_hdf5(tms_coil, fn):
                                         np.full((tms_coil.elements[idx].points.shape[0]),
                                                 tms_coil.elements[idx].stimulator.name)))
 
-
     else:
         wire_nodes = tms_coil.elements.points
         wire_data = tms_coil.elements.values
         coil_name = np.full((tms_coil.elements.points.shape[0]), tms_coil.elements.name)
         stim_name = np.full((tms_coil.elements.points.shape[0]), tms_coil.elements.stimulator.name)
 
+    coil_names_ordered = [i.name for i in tms_coil.elements]
+    stim_names_ordered = [i.stimulator.name for i in tms_coil.elements]
+
     # Convert strings to their corresponding float values
-    unique_strings = np.unique(coil_name)
-    string_to_float_map = {string: i for i, string in enumerate(unique_strings)}
+    # unique_strings = np.unique(coil_name)
+    string_to_float_map = {string: i for i, string in enumerate(coil_names_ordered)}
     coil_name = np.array([string_to_float_map[string] for string in coil_name])
 
     # Convert strings to their corresponding float values
-    unique_strings = np.unique(stim_name)
-    string_to_float_map = {string: i for i, string in enumerate(unique_strings)}
+    # unique_strings = np.unique(stim_name)
+    string_to_float_map = {string: i for i, string in enumerate(stim_names_ordered)}
     stim_name = np.array([string_to_float_map[string] for string in stim_name])
 
     n_nodes = wire_nodes.shape[0]