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

pynibs/mesh/utils.py

@@ -1,5 +1,8 @@
+import os
 import h5py
 import math
+import meshio
+import trimesh
 import warnings
 import numpy as np
 import pandas as pd
@@ -8,7 +11,6 @@ import multiprocessing
 from functools import partial
 from numpy import cross as cycross
 from scipy.spatial import Delaunay
-
 import pynibs
 
 
@@ -38,12 +40,12 @@ def calc_tet_volume(points, abs=True):
     Returns
     -------
     volume: np.ndarray
-        shape: ``(n_tets)``
+        shape: ``(n_tets)``-
 
     Other Parameters
     ----------------
     abs : bool, default: true
-        Return magnitude
+        Return magnitude-
     """
     if points.ndim == 2:
         points = np.atleast_3d(points).reshape(1, 4, 3)
@@ -107,7 +109,7 @@ def get_sphere(mesh=None, mesh_fn=None, target=None, radius=None, roi_idx=None,
     Returns
     -------
     elms_in_sphere : np.ndarray
-        (n_elements): Indices of elements found in ROI
+        (n_elements): Indices of elements found in ROI-
     """
     # let's handle the input parameter combinations
     assert target is not None
@@ -121,9 +123,9 @@ def get_sphere(mesh=None, mesh_fn=None, target=None, radius=None, roi_idx=None,
         if mesh is not None:
             raise ValueError("Either provide mesh or mesh_fn")
         if mesh_fn.endswith('.hdf5'):
-            mesh = pynibs.load_mesh_hdf5(mesh_fn)
+            mesh = pynibs.hdf5_io.load_mesh_hdf5(mesh_fn)
         elif mesh_fn.endswith('.msh'):
-            mesh = pynibs.load_mesh_msh(mesh_fn)
+            mesh = pynibs.hdf5_io.load_mesh_msh(mesh_fn)
 
     if roi is None and roi_idx is not None:
         if mesh_fn is None:
@@ -153,17 +155,16 @@ def tets_in_sphere(mesh, target, radius, roi, domain=None):
     ----------
     mesh : pynibs.TetrahedraLinear, optional
     target : np.ndarray of float, optional
-        (3,) X, Y, Z coordinates of target
+        (3,) X, Y, Z coordinates of target-
     radius : float, optional
-        Sphere radius im mm
+        Sphere radius im mm-
     roi : pynibs.mesh.ROI, optional
-        Region of interest
+        Region of interest-
 
     Returns
     -------
     tets_in_sphere : np.ndarray
-        (n_tets): Indices of elements found in ROI
-
+        (n_tets): Indices of elements found in ROI-
     """
     if roi is None:
         if radius is None or radius == 0:
@@ -201,16 +202,16 @@ def tris_in_sphere(mesh, target, radius, roi):
     ----------
     mesh : pynibs.mesh.TetrahedraLinear, optional
     target : np.ndarray of float or list of float
-        (3,) X, Y, Z coordinates of target
+        (3,) X, Y, Z coordinates of target-
     radius : float
         Sphere radius im mm
     roi : pynibs.mesh.mesh_struct.ROI, optional
-        ROI
+        ROI-
 
     Returns
     -------
     tris_in_sphere : np.ndarray
-        (n_triangles): Indices of elements found in sphere
+        (n_triangles): Indices of elements found in sphere.
     """
     if roi is None:
         if radius is None or radius == 0:
@@ -244,7 +245,6 @@ def sample_sphere(n_points, r):
     points: np.ndarray of float
         (N x 3), Evenly spread points in a unit sphere.
     """
-
     assert n_points % 2 == 1, "The number of points must be odd"
     points = []
 
@@ -268,35 +268,34 @@ def sample_sphere(n_points, r):
 def get_indices_discontinuous_data(data, con, neighbor=False, deviation_factor=2,
                                    min_val=None, not_fitted_elms=None, crit='median', neigh_style='point'):
     """
-    Get element indices (and the best neighbor index), where the data is discontinuous
+    Get element indices (and the best neighbor index), where the data is discontinuous.
 
     Parameters
     ----------
     data : np.ndarray of float [n_data]
-        Data array to analyze given in the element center
+        Data array to analyze given in the element center.
     con : np.ndarray of float [n_data, 3 or 4]
-        Connectivity matrix
+        Connectivity matrix.
     neighbor : bool, default: False
-        Return also the element index of the "best" neighbor (w.r.t. median of data)
+        Return also the element index of the "best" neighbor (w.r.t. median of data).
     deviation_factor : float
-        Allows data deviation from 1/deviation_factor < data[i]/median < deviation_factor
+        Allows data deviation from 1/deviation_factor < data[i]/median < deviation_factor.
     min_val : float, optional
         If given, only return elements which have a neighbor with data higher than min_val.
     not_fitted_elms : np.ndarray
-        If given, these elements are not used as neighbors
+        If given, these elements are not used as neighbors.
     crit: str, default: median
-        Criterium for best neighbor. Either median or max value
+        Criterium for best neighbor. Either median or max value.
     neigh_style : str, default: 'point'
-        Should neighbors share point or 'edge'
+        Should neighbors share point or 'edge'.
 
     Returns
     -------
     idx_disc : list of int [n_disc]
-        Index list containing the indices of the discontinuous elements
+        Index list containing the indices of the discontinuous elements.
     idx_neighbor : list of int [n_disc]
-        Index list containing the indices of the "best" neighbors of the discontinuous elements
+        Index list containing the indices of the "best" neighbors of the discontinuous elements.
     """
-
     n_ele = con.shape[0]
     idx_disc, idx_neighbor = [], []
 
@@ -409,7 +408,6 @@ def find_nearest(array, value):
     -------
     idx : int
         Index j such that "value" is between array[j] and array[j+1].
-
     """
     n = len(array)
     if value < array[0]:
@@ -451,10 +449,9 @@ def in_hull(points, hull):
     Returns
     -------
     inside : np.ndarray of bool
-        TRUE: point inside the hull
-        FALSE: point outside the hull
+        TRUE: point inside the hull.
+        FALSE: point outside the hull.
     """
-
     if not isinstance(hull, Delaunay):
         hull = Delaunay(hull)
     return hull.find_simplex(points) >= 0
@@ -477,20 +474,19 @@ def calc_tetrahedra_volume_cross(P1, P2, P3, P4):
     Parameters
     ----------
     P1 : np.ndarray of float [N_tet x 3]
-        Coordinates of first point of tetrahedra
+        Coordinates of first point of tetrahedra.
     P2 : np.ndarray of float [N_tet x 3]
-        Coordinates of second point of tetrahedra
+        Coordinates of second point of tetrahedra.
     P3 : np.ndarray of float [N_tet x 3]
-        Coordinates of third point of tetrahedra
+        Coordinates of third point of tetrahedra.
     P4 : np.ndarray of float [N_tet x 3]
-        Coordinates of fourth point of tetrahedra
+        Coordinates of fourth point of tetrahedra.
 
     Returns
     -------
     tetrahedra_volume: np.ndarray of float [N_tet x 1]
-        Volumes of tetrahedra
+        Volumes of tetrahedra.
     """
-
     tetrahedra_volume = 1.0 / 6 * \
                         np.sum(np.multiply(cycross(P2 - P1, P3 - P1), P4 - P1), 1)
     tetrahedra_volume = tetrahedra_volume[:, np.newaxis]
@@ -500,7 +496,7 @@ def calc_tetrahedra_volume_cross(P1, P2, P3, P4):
 def calc_tetrahedra_volume_det(P1, P2, P3, P4):
     """
     Calculate volume of tetrahedron specified by 4 points P1...P4
-    multiple tetrahedra can be defined by P1...P4 as 2-D np.arrays
+    multiple tetrahedra can be defined by P1...P4 as 2-D np.ndarray
     using the determinant.
 
 
@@ -515,20 +511,19 @@ def calc_tetrahedra_volume_det(P1, P2, P3, P4):
     Parameters
     ----------
     P1 : np.ndarray of float [N_tet x 3]
-        Coordinates of first point of tetrahedra
+        Coordinates of first point of tetrahedra.
     P2 : np.ndarray of float [N_tet x 3]
-        Coordinates of second point of tetrahedra
+        Coordinates of second point of tetrahedra.
     P3 : np.ndarray of float [N_tet x 3]
-        Coordinates of third point of tetrahedra
+        Coordinates of third point of tetrahedra.
     P4 : np.ndarray of float [N_tet x 3]
-        Coordinates of fourth point of tetrahedra
+        Coordinates of fourth point of tetrahedra.
 
     Returns
     -------
     tetrahedra_volume : np.ndarray of float [N_tet x 1]
-        Volumes of tetrahedra
+        Volumes of tetrahedra.
     """
-
     N_tets = P1.shape[0] if P1.ndim > 1 else 1
 
     # add ones
@@ -557,18 +552,17 @@ def calc_gradient_surface(phi, points, triangles):
     Parameters
     ----------
     phi : np.ndarray of float [N_points x 1]
-        Potential in nodes
+        Potential in nodes.
     points : np.ndarray of float [N_points x 3]
-        Coordinates of nodes (x,y,z)
+        Coordinates of nodes (x,y,z).
     triangles : np.ndarray of int32 [N_tri x 3]
-        Connectivity of triangular mesh
+        Connectivity of triangular mesh.
 
     Returns
     -------
     grad_phi : np.ndarray of float [N_tri x 3]
-        Gradient of potential phi on surface
+        Gradient of potential phi on surface.
     """
-
     grad_phi = np.zeros((triangles.shape[0], 3))
 
     for i in range(triangles.shape[0]):
@@ -594,11 +588,10 @@ def determine_e_midlayer_workhorse(fn_e_results, subject, mesh_idx, midlayer_fun
         simnibs < 3.0  : 1000.
         simnibs >= 3.0 :    1. (Default)
     """
-
     if verbose:
         print(f"Loading Mesh and ROI {roi_idx} from {fn_mesh_hdf5}")
 
-    msh = pynibs.load_mesh_hdf5(fn_mesh_hdf5)
+    msh = pynibs.hdf5_io.load_mesh_hdf5(fn_mesh_hdf5)
     roi = pynibs.load_roi_surface_obj_from_hdf5(fn_mesh_hdf5)
 
     for fn_e in fn_e_results:
@@ -666,28 +659,27 @@ def determine_e_midlayer(fn_e_results, fn_mesh_hdf5, subject, mesh_idx, roi_idx,
     Parameters
     ----------
     fn_e_results : list of str
-        List of results filenames (.hdf5 format)
+        List of results filenames (.hdf5 format).
     fn_mesh_hdf5 : str
-        Filename of corresponding mesh file
+        Filename of corresponding mesh file.
     subject : pynibs.Subject
-        Subject object
+        Subject object.
     mesh_idx : int
-        Mesh index
+        Mesh index.
     roi_idx : int
-        ROI index
+        ROI index.
     n_cpu : int, default: 4
-        Number of parallel computations
+        Number of parallel computations.
     midlayer_fun : str, default: "simnibs"
-        Method to determine the midlayer e-fields ("pynibs" or "simnibs")
+        Method to determine the midlayer e-fields ("pynibs" or "simnibs").
     phi_scaling : float, default: 1.0
-        Scaling factor of scalar potential to change between "m" and "mm"
+        Scaling factor of scalar potential to change between "m" and "mm".
 
     Returns
     -------
     <File> .hdf5 file
-        Adds midlayer e-field results to ROI
+        Adds midlayer e-field results to ROI.
     """
-
     # msh = pynibs.load_mesh_msh(subject.mesh[mesh_idx]['fn_mesh_msh'])
 
     n_cpu_available = multiprocessing.cpu_count()
@@ -702,7 +694,7 @@ def determine_e_midlayer(fn_e_results, fn_mesh_hdf5, subject, mesh_idx, roi_idx,
                                 phi_scaling=phi_scaling,
                                 verbose=verbose)
 
-    fn_e_results_chunks = pynibs.compute_chunks(fn_e_results, n_cpu)
+    fn_e_results_chunks = pynibs.util.utils.compute_chunks(fn_e_results, n_cpu)
     pool = multiprocessing.Pool(n_cpu)
     pool.map(workhorse_partial, fn_e_results_chunks)
     pool.close()
@@ -716,18 +708,17 @@ def find_element_idx_by_points(nodes, con, points):
     Parameters
     ----------
     nodes : np.ndarray [N_nodes x 3]
-        Coordinates (x, y, z) of the nodes
+        Coordinates (x, y, z) of the nodes.
     con : np.ndarray [N_tet x 4]
-        Connectivity matrix
+        Connectivity matrix.
     points : np.ndarray [N_points x 3]
         Points for which the element indices are found.
 
     Returns
     -------
     ele_idx : np.ndarray [N_points]
-        Element indices of tetrahedra where corresponding 'points' are lying in
+        Element indices of tetrahedra where corresponding 'points' are lying in.
     """
-
     node_idx = []
     for i in range(points.shape[0]):
         node_idx.append(np.where(np.linalg.norm(nodes - points[i, :], axis=1) < 1e-2)[0])
@@ -748,6 +739,7 @@ def check_islands_for_single_elm(source_elm, connectivity=None, adjacency=None,
     3. Continue recursively with all 2-node-neighbors and visit their 2-node-neighbors
     4. See if any 1-node-neighbors have not been visited with this strategy. If so, an island has been found
 
+
     Parameters
     ----------
     source_elm : int
@@ -852,15 +844,16 @@ def find_islands(connectivity=None, adjacency=None, island_crit='any', verbose=F
     largest : book, default: False
         Only return largest island, speeds up computation quite a bit if only one large, and many small islands exist.
     verbose : bool, optional
-        Print some verbosity information. Default: False
+        Print some verbosity information. Default: False.
+
     Returns
     -------
-        elms_with_island : list
-            Elements with neighboring islands
-        counter_visited : np.ndarray
-            shape = (n_elms). How often as each element been visited.
-        counter_not_visited : np.ndarray
-            shape = (n_elms). How often as each element not been visited.
+    elms_with_island : list
+        Elements with neighboring islands.
+    counter_visited : np.ndarray
+        shape = (n_elms). How often as each element been visited.
+    counter_not_visited : np.ndarray
+        shape = (n_elms). How often as each element not been visited.
     """
     elms_with_island = []
     if adjacency is not None and connectivity is not None:
@@ -914,7 +907,7 @@ def find_islands(connectivity=None, adjacency=None, island_crit='any', verbose=F
 def find_island_elms(connectivity=None, adjacency=None, verbose=False, island_crit='edge', decision='cumulative'):
     """
     Searches for islands in a mesh and returns element indices of the smallest island.
-    Island is defines as a set of elements, which share a single node and/or single edge with the rest of the mesh.
+    Island is defind as a set of elements, which share a single node and/or single edge with the rest of the mesh.
 
     Parameters
     ----------
@@ -936,7 +929,7 @@ def find_island_elms(connectivity=None, adjacency=None, verbose=False, island_cr
 
     Returns
     -------
-        island : list of island-elms
+        island : list of island-elms.
     """
     if adjacency is not None and connectivity is not None:
         raise ValueError(f"Provide either neighbors or connectivity, not both.")
@@ -978,9 +971,12 @@ def find_island_elms(connectivity=None, adjacency=None, verbose=False, island_cr
 
     elif decision == 'cumulative':
         return np.argwhere(counter_not_visited > 0)
+    else:
+        raise ValueError
 
 
-def cortical_depth(mesh_fn, geo_fn=None, write_xdmf=True, skin_surface_id=1005, verbose=False):
+def cortical_depth(mesh_fn, geo_fn=None, skin_surface_id=1005, mesh_fn_out=None,
+                   tissue_type=None, only_tri=False, verbose=False):
     """
     Compute skin-cortex-distance (SCD) for surface and volume data in ``mesh_fn``.
 
@@ -997,15 +993,23 @@ def cortical_depth(mesh_fn, geo_fn=None, write_xdmf=True, skin_surface_id=1005,
     geo_fn : str, optional
         :py:class:`~pynibs.mesh.mesh_struct.TetrahedraLinear` mesh file with geometric data. If provided, geometric
         information is read from here.
-    write_xdmf : bool, default: True
-        Write .xdmf or not.
     skin_surface_id : int, default: 1005
         Which tissue type nr to compute distance against.
+    mesh_fn_out : str, optional
+        If provided, SCD information is written to this file.
+    tissue_type : list of int, optional
+        For which tissue types to compute SCD. If None, all tissue types are computed.
+    only_tri : bool, default: False
+        If True, only triangles are computed.
     verbose : bool, default: False
         Print some verbosity information.
 
     Returns
     -------
+    distances_tri : np.ndarray
+        Distances of triangles to skin surface.
+    distances_tets : np.ndarray
+        Distances of tetrahedra to skin surface.
     <file> : .hdf5
         ``mesh_fn`` or ``geo_fn`` with SCD information in ``/data/tris/Cortex_dist`` and ``/data/tets/Cortex_dist``.
     <file> : .xdmf
@@ -1017,11 +1021,11 @@ def cortical_depth(mesh_fn, geo_fn=None, write_xdmf=True, skin_surface_id=1005,
         skin_tri_idx = f['/mesh/elm/tri_tissue_type'][:] == skin_surface_id
         tri_nodes = f['/mesh/elm/triangle_number_list'][:][skin_tri_idx]
 
-    elms_with_island, counter_visited, counter_not_visited = pynibs.find_islands(connectivity=tri_nodes,
-                                                                                 verbose=True,
-                                                                                 island_crit='edge',
-                                                                                 largest=True)
-    hdf5 = pynibs.load_mesh_hdf5(mesh_fn)
+    elms_with_island, counter_visited, counter_not_visited = find_islands(connectivity=tri_nodes,
+                                                                          verbose=True,
+                                                                          island_crit='edge',
+                                                                          largest=True)
+    hdf5 = pynibs.hdf5_io.load_mesh_hdf5(mesh_fn)
 
     with h5py.File(geo_fn, 'r') as geo:
         # get indices for skin elements
@@ -1031,25 +1035,37 @@ def cortical_depth(mesh_fn, geo_fn=None, write_xdmf=True, skin_surface_id=1005,
     def fun(row):
         return np.min(np.linalg.norm(row - skin_positions, axis=1))
 
+    if tissue_type is not None:
+        arr_tri = hdf5.triangles_center[np.isin(hdf5.triangles_regions, tissue_type)]
+        arr_tet = hdf5.tetrahedra_center[np.isin(hdf5.tetrahedra_regions, tissue_type)]
+    else:
+        arr_tri = hdf5.triangles_center
+        arr_tet = hdf5.tetrahedra_center
+
     if verbose:
         print("Computing triangles")
-    distances_tri = np.apply_along_axis(fun, axis=1, arr=hdf5.triangles_center)
-    if verbose:
-        print("Computing tetrahedra")
-
-    distances_tets = np.apply_along_axis(fun, axis=1, arr=hdf5.tetrahedra_center)
-    with h5py.File(mesh_fn, 'a') as f:
-        try:
-            del f['data/tris/Cortex_dist']
-            del f['data/tets/Cortex_dist']
-        except KeyError:
-            pass
-        f.create_dataset(name='data/tris/Cortex_dist', data=distances_tri)
-        f.create_dataset(name='data/tets/Cortex_dist', data=distances_tets)
-
-    if write_xdmf:
+    distances_tri = np.apply_along_axis(fun, axis=1, arr=arr_tri)
+
+    if not only_tri:
+        if verbose:
+            print("Computing tetrahedra")
+        distances_tets = np.apply_along_axis(fun, axis=1, arr=arr_tet)
+    else:
+        distances_tets = None
+    if mesh_fn_out is not None:
+        with h5py.File(mesh_fn_out, 'a') as f:
+            try:
+                del f['data/tris/Cortex_dist']
+                del f['data/tets/Cortex_dist']
+            except KeyError:
+                pass
+            f.create_dataset(name='data/tris/Cortex_dist', data=distances_tri)
+            if not only_tri:
+                f.create_dataset(name='data/tets/Cortex_dist', data=distances_tets)
+
         pynibs.write_xdmf(overwrite_xdmf=True, hdf5_geo_fn=geo_fn, hdf5_fn=mesh_fn)
 
+    return distances_tri, distances_tets
 
 def calc_distances(coords, mesh_fn, tissues=None):
     """
@@ -1067,8 +1083,7 @@ def calc_distances(coords, mesh_fn, tissues=None):
     Returns
     -------
     distances : pd.Dataframe()
-        colunms: coorrd, tissue_type, distance
-
+        colunms: coorrd, tissue_type, distance.
     """
     coords = np.atleast_2d(coords)
     print("Coordinate  |  tissue type  | Distance")
@@ -1101,3 +1116,80 @@ def calc_distances(coords, mesh_fn, tissues=None):
                 print(f"{coord} |     {tissue: >4} |  {distances.round(2): >6} mm")
             print("-" * 40)
     return pd.DataFrame().from_dict(res)
+
+
+def head_circumference(fn_hdf5, z_center=None, result_folder=None):
+    """
+    Computes the head circumference of a mesh.
+
+    .. figure:: ../../doc/images/head_circum.png
+       :scale: 50 %
+       :alt: Head circumference
+
+       For each point on the circumference, the closest point on the skin surface is determined.
+       Distances from point to point are summed up to get the head circumference.
+
+    Parameters
+    ----------
+    fn_hdf5 : str
+        Filename of the mesh in hdf5 format.
+    z_center : float, optional
+        Z-coordinate of the center of the head. If not provided, it is computed from the mesh.
+    result_folder : str, optional
+        Folder to save the results. If not provided, the results are not saved.
+
+    Returns
+    -------
+    circ : float
+        Head circumference in mm.
+    """
+    with h5py.File(fn_hdf5, 'r') as f:
+        nodes = f['mesh/nodes/node_coord'][:]
+        # tris = f['mesh/elm/node_number_list'][:]
+        tri_tissue_type = f['/mesh/elm/tri_tissue_type'][:]
+        tr_con = f['/mesh/elm/triangle_number_list'][:]
+
+    if z_center is None:
+        # find the highest point of eyes
+        eye_surface_id = 1006
+        eye_positions = nodes[tr_con[tri_tissue_type == 1006]]
+        eye_top = eye_positions[:, :, 2].max()
+        dist = 40
+        z_center = eye_top + dist
+
+    n = 100
+    r = 200
+    origins = np.array(
+        [(math.cos(2 * np.pi / n * x) * r, math.sin(2 * np.pi / n * x) * r, z_center) for x in range(0, n + 1)])
+    directions = -origins.copy()
+    directions[:, 2] = 0
+    skin_mesh = trimesh.Trimesh(vertices=nodes, faces=tr_con[tri_tissue_type == 1005])
+    hits, idx_ray, idx_tri = skin_mesh.ray.intersects_location(
+        ray_origins=origins, ray_directions=directions, multiple_hits=True)
+
+    closest_hits = []
+    for idx in range(origins.shape[0]):
+        ray_idx = np.squeeze(np.argwhere(idx_ray == idx))
+        min_idx = np.argmin(np.linalg.norm(origins[idx] - hits[ray_idx], axis=1))
+        closest_hits.append(hits[ray_idx][min_idx])
+    closest_hits = np.array(closest_hits)
+
+    if result_folder is not None:
+        os.makedirs(result_folder, exist_ok=True)
+
+        meshio.Mesh(
+            points=closest_hits,
+            cells=[('vertex', np.array([[i, ] for i in range(closest_hits.shape[0])])), ],
+            point_data={'hits': list(range(closest_hits.shape[0]))}).write(
+            f"{result_folder}/hits.vtk")
+
+        meshio.Mesh(
+            points=origins,
+            cells=[('vertex', np.array([[i, ] for i in range(len(hits[0]))])), ],
+            point_data={'hits': list(range(len(hits[0])))}).write(
+            f"{result_folder}/origins.vtk")
+
+    dist = np.linalg.norm(closest_hits[-1] - closest_hits[0])
+    for idx in range(closest_hits.shape[0] - 1):
+        dist += np.linalg.norm(closest_hits[idx] - closest_hits[idx + 1])
+    return np.round(dist, 2)

pynibs/models/_TMS.py

@@ -6,6 +6,7 @@ import pynibs
 import simnibs
 import datetime
 import numpy as np
+
 try:
     from pygpc.AbstractModel import AbstractModel
 except ImportError:
@@ -179,7 +180,7 @@ class _TMS(AbstractModel):
         # dipole position and magnitude
         fn_coil_geo = glob.glob(os.path.join(S.pathfem, "*.geo"))[0]
         print("Reading coil dipole information from {}".format(fn_coil_geo))
-        dipole_position, dipole_moment_mag = pynibs.simnibs.read_coil_geo(fn_coil_geo)
+        dipole_position, dipole_moment_mag = pynibs.util.simnibs_io.read_coil_geo(fn_coil_geo)
 
         # Additional information
         #######################################################################

pynibs/muap.py

@@ -84,7 +84,6 @@ def create_electrode(l_x, l_z, n_x, n_z):
     electrode_coords : ndarray of float [n_ele x 3]
         Coordinates of point electrodes (x, y, z)
     """
-
     electrode_coords = np.zeros((n_x*n_z, 3))
 
     i = 0
@@ -389,4 +388,4 @@ def calc_mep_wilson(firing_rate_in, t, Qvmax=900, Qmmax=300, q=8, Tmin=14, N=100
             for tau in spike_times[k]:
                 mep += Mk[k] * hermite_rodriguez_1st(t=t, tau0=tau0, tau=tau, lam=lam)
 
-    return mep
+    return mep

pynibs/neuron/__init__.py

@@ -1,2 +1,12 @@
+"""
+Functions to compute directional-sensitivity-informed [1]_ neuronal activation thresholds [2]_.
+
+.. [1] Jing, Y., Numssen, O., Hartwigsen, G., Knösche, T. R., & Weise, K. (2024). Effects of Electric Field Direction
+   on TMS-based Motor Cortex Mapping. *bioRxiv*
+   `10.1101/2024.12.10.627753 <https://doi.org/10.1101/2024.12.10.627753>`_
+.. [2] Weise, K., Makaroff, S. N., Numssen, O., Bikson, M., & Knösche, T. R. (2025). Statistical method accounts for
+   microscopic electric field distortions around neurons when simulating activation thresholds. *Brain Stimulation,
+   18*(2), 280–286. `10.1016/j.brs.2025.02.007 <https://doi.org/10.1016/j.brs.2025.02.007>`_
+"""
 from .neuron_regression import *
 from .util import *