pyNIBS 0.2024.8__py3-none-any.whl

pynibs/models/_TMS.py

@@ -0,0 +1,211 @@
+import os
+import glob
+import copy
+import shutil
+import pynibs
+import simnibs
+import datetime
+import numpy as np
+try:
+    from pygpc.AbstractModel import AbstractModel
+except ImportError:
+    pass
+
+
+class _TMS(AbstractModel):
+    """
+    TMS field calculation using Simnibs
+    """
+
+    def __init__(self):
+        """
+        Parameters
+        ----------
+        p : dict
+            parameters dictionary
+        p["fn_subject"] : str
+            Filename of subject object
+            (e.g. /data/pt_01756/probands/15484.08/15484.08.pkl)
+        p["mesh_idx"] : int
+            MESH index the simulations are conducted with
+        p["fn_coil"] : str
+            Filename of coil .ccd file
+        p["coil_position_mean"]: ndarray of float [3 x 4]
+            Mean coil position and orientation [x_ori, y_ori, z_ori, loc]
+        p["anisotropy_type"]: str or None
+            Type of anisotropy ("vn" (volume normalized) or None)
+        p["sigma_WM"] : float
+            Electrical conductivity of white matter (default: 0.126 S/m)
+        p["sigma_GM"] : float
+            Electrical conductivity of gray matter (default: 0.275 S/m)
+        p["sigma_CSF"] : float
+            Electrical conductivity of CSF (default: 1.654 S/m)
+        p["sigma_Skull"] : float
+            Electrical conductivity of skull (default: 0.010 S/m)
+        p["sigma_Scalp"] : float
+            Electrical conductivity of scalp (default: 0.465 S/m)
+        p["aniso"] : float
+            Anisotropy scaling factor (default: 0.5)
+        p["x"] : float
+            Displacement of TMS coil along first principal axis
+        p["y"] : float
+            Displacement of TMS coil along second principal axis
+        p["z"] : float
+            Displacement of TMS coil along third principal axis
+        p["psi"] : float
+            Rotation of TMS coil around first principal axis in deg
+        p["theta"] : float
+            Rotation of TMS coil around second principal axis in deg
+        p["phi"] : float
+            Rotation of TMS coil around third principal axis in deg
+        p["fn_results"] : str
+            Results folder
+            (e.g. /home/raid1/kweise/data/probands/15484.08/results/gpc/20_cond_coil_corrected/electric_field/I_0)
+        """
+        pass
+
+    def validate(self):
+        pass
+
+    def simulate(self, process_id=None, matlab_engine=None):
+        """
+        Calculates the scalar electric potential
+
+        Returns
+        -------
+        potential : ndarray of float [n_points]
+            Scalar electric potential in nodes of FEM mesh
+        additional_data : dict of ndarray
+            Additional output data
+            - dA/dt [3*n_points] ... magnetic vector potential in nodes of mesh
+            - coil_dipoles [3*n_dipoles] ... coil dipole positions
+            - coil_mag [n_dipoles] ... coil dipole magnitude
+        """
+
+        # load subject
+        subject = pynibs.load_subject(self.p["fn_subject"])
+
+        # Setting up SimNIBS SESSION
+        #######################################################################
+        S = simnibs.sim_struct.SESSION()
+        S.fnamehead = subject.mesh[self.p["mesh_idx"]]["fn_mesh_msh"]
+        S.pathfem = os.path.join(os.path.split(self.p["fn_results"])[0], "tmp", str(process_id))
+        S.fields = "veED"
+        S.open_in_gmsh = False
+
+        if os.path.isdir(S.pathfem):
+            shutil.rmtree(S.pathfem)
+        os.makedirs(S.pathfem)
+
+        # Setting up coil position
+        #######################################################################
+        matsimnibs = pynibs.calc_coil_transformation_matrix(
+            LOC_mean=self.p["coil_position_mean"][0:3, 3],
+            ORI_mean=self.p["coil_position_mean"][0:3, 0:3],
+            LOC_var=np.array([self.p["x"], self.p["y"], self.p["z"]]),
+            ORI_var=np.array([self.p["psi"], self.p["theta"], self.p["phi"]]),
+            V=self.p["coil_position_mean"][0:3, 0:3])
+
+        # Define the TMS simulation and setting up conductivities
+        #######################################################################
+        tms = S.add_tmslist()
+        tms.fnamecoil = self.p["fn_coil"]
+        tms.cond[0].value = self.p["sigma_WM"]      # WM
+        tms.cond[1].value = self.p["sigma_GM"]      # GM
+        tms.cond[2].value = self.p["sigma_CSF"]     # CSF
+        tms.cond[3].value = self.p["sigma_Skull"]   # Skull
+        tms.cond[4].value = self.p["sigma_Scalp"]   # Scalp
+
+        if not (self.p['anisotropy_type'] in ['iso', 'vn']):
+            raise NotImplementedError
+
+        if self.p['anisotropy_type'] == 'vn':
+            S.fname_tensor = subject.mesh[self.p['mesh_idx']]['fn_tensor_vn']
+            tms.fn_tensor_nifti = subject.mesh[self.p['mesh_idx']]['fn_tensor_vn']
+            tms.anisotropy_type = self.p['anisotropy_type']
+
+        tms.excentricity_scale = self.p["aniso"]
+
+        # Define the coil positions
+        #######################################################################
+        pos = tms.add_position()
+        pos.matsimnibs = copy.deepcopy(matsimnibs)
+        pos.distance = 0.1  # distance from coil surface to head surface
+        pos.didt = 1e6      # in A/s (1e6 A/s = 1 A/us)
+        pos.postprocess = S.fields
+
+        # Running simulation
+        #######################################################################
+        print("Running computation of TMS induced electric fields.")
+        filenames = simnibs.run_simnibs(S, cpus=1)
+
+        # Reading results from .msh file
+        #######################################################################
+        print("Reading results from: {}".format(filenames[0]))
+
+        msh = simnibs.msh.mesh_io.read_msh(filenames[0])
+        msh_pyfempp = pynibs.load_mesh_msh(filenames[0])
+
+        # potential
+        for i in range(len(msh.nodedata)):
+            if msh.nodedata[i].field_name == "v":
+                print("Reading potential")
+                v = msh.nodedata[i].value.flatten()
+
+        # fields
+        for i in range(len(msh.elmdata)):
+            # save dadt also in nodes
+            if msh.elmdata[i].field_name == "D":
+                print("Reading dAdt and transforming from elements2nodes")
+                D = pynibs.mesh.data_elements2nodes(msh.elmdata[i].value[msh.elm.elm_type == 4,])
+                D = D.flatten()[:, np.newaxis]
+
+            # if msh.elmdata[i].field_name == "E":
+            #     E_tets = msh.elmdata[i].value[msh.elm.elm_type == 4, ]
+            #     E_tets = E_tets.flatten()[:, np.newaxis]
+            #
+            # if msh.elmdata[i].field_name == "normE":
+            #     normE_tets = msh.elmdata[i].value[msh.elm.elm_type == 4, ]
+            #     normE_tets = normE_tets.flatten()[:, np.newaxis]
+            #
+            # if msh.elmdata[i].field_name == "E":
+            #     E_tris = msh.elmdata[i].value[msh.elm.elm_type == 2, ]
+            #     E_tris = E_tris.flatten()[:, np.newaxis]
+            #
+            # if msh.elmdata[i].field_name == "normE":
+            #     normE_tris = msh.elmdata[i].value[msh.elm.elm_type == 2, ]
+            #     normE_tris = normE_tris.flatten()[:, np.newaxis]
+
+        # 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)
+
+        # Additional information
+        #######################################################################
+        print("Collecting simulation information")
+        additional_data = dict()
+        additional_data['info/date'] = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        additional_data['info/sigma_WM'] = S.poslists[0].cond[0].value      # WM
+        additional_data['info/sigma_GM'] = S.poslists[0].cond[1].value      # GM
+        additional_data['info/sigma_CSF'] = S.poslists[0].cond[2].value     # CSF
+        additional_data['info/sigma_Skull'] = S.poslists[0].cond[3].value   # Skull
+        additional_data['info/sigma_Scalp'] = S.poslists[0].cond[4].value   # Scalp
+        additional_data['info/fn_coil'] = S.poslists[0].fnamecoil           # TMS coil
+        additional_data['info/matsimnibs'] = matsimnibs.flatten()  # coil location and orientation
+        additional_data['info/dIdt'] = S.poslists[0].pos[0].didt  # rate of change of coil current
+        additional_data['info/anisotropy_type'] = S.poslists[0].anisotropy_type  # type of anisotropy model
+        additional_data['info/fn_mesh_msh'] = S.fnamehead  # mesh
+        additional_data["coil/dipole_position"] = dipole_position.flatten()
+        additional_data["coil/dipole_moment_mag"] = dipole_moment_mag.flatten()
+        additional_data["data/nodes/D"] = D.flatten()
+        # additional_data["data/tets/E"] = E_tets.flatten()
+        # additional_data["data/tets/normE"] = normE_tets.flatten()
+        # additional_data["data/tris/E"] = E_tris.flatten()
+        # additional_data["data/tris/normE"] = normE_tris.flatten()
+
+        # Deleting temporary files
+        print("Removing temporary files: {}".format(S.pathfem))
+        shutil.rmtree(S.pathfem)
+
+        return v, additional_data

pynibs/muap.py

@@ -0,0 +1,392 @@
+import numpy as np
+from scipy import interpolate
+
+
+def sfap_dip(z):
+    dist = 1
+
+    i = np.zeros(len(z))
+    i[np.isclose(z, 0, atol=0.01)] = 1
+    i[np.isclose(z, dist, atol=0.01)] = -1
+    return i
+
+
+def sfap(z, sigma_i=1.01, d=55*1e-6, alpha=0.5):
+    """
+    Single fibre propagating transmembrane current (second spatial derivative of transmembrane potential).
+
+    S. D. Nandedkar and E. V. Stalberg,“Simulation of single musclefiber action potentials”
+    Med. Biol. Eng. Comput., vol. 21, pp. 158–165, Mar.1983.
+
+    J.  Duchene  and  J.-Y.  Hogrel,“A  model  of  EMG  generation,”
+    IEEETrans. Biomed. Eng., vol. 47, no. 2, pp. 192–200, Feb. 2000
+
+    Hamilton-Wright, A., & Stashuk, D. W. (2005).
+    Physiologically based simulation of clinical EMG signals.
+    IEEE Transactions on biomedical engineering, 52(2), 171-183.
+
+    Parameters
+    ----------
+    t : ndarray of float [n_t]
+        Time in (ms)
+    sigma_i : float, optional, default: 1.01
+        Intracellular conductivity in (S/m)
+    d : float, optional, default: 55*1e-6
+        Diameter of muscle fibre in (m)
+    v : float, optional, default: 1
+        Conduction velocity in (m/s)
+    alpha : float, optional, default: 0.5
+        Scaling factor to adjust length of AP
+
+    Returns
+    -------
+    i : ndarray of float [n_t]
+        Transmembrane current of muscle fibre
+    """
+    # z = v * t
+    z[z<0] = 0
+    i = (sigma_i * np.pi * d**2) * 96 * alpha**3 * z * np.exp(-alpha*z) * (alpha**2*z**2 - 6*alpha*z + 6)
+    # i = (sigma_i * np.pi * d**2) * 96 * (z) * (6-6*(z) + (z)**2)*np.exp(-z)
+    # i = (sigma_i * np.pi * d**2)/4 * 3072 * z * (z**2 - 3*z + 1.5) * np.exp(-2*z)
+
+    return i
+
+
+def dipole_potential(z, loc, response):
+    """
+    Returns dipole potential at given coordinates z (interpolates given dipole potential)
+    """
+    res = np.zeros(len(z))
+    mask = np.logical_and(z > loc[0], z < loc[-1])
+    f = interpolate.interp1d(loc, response)
+    res[mask] = f(z[mask])
+
+    return res
+
+
+def create_electrode(l_x, l_z, n_x, n_z):
+    """
+    Creates electrode coordinates
+
+    Parameters
+    ----------
+    l_x : float
+        X-extension of electrode in mm
+    l_z : float
+        Z-extension of electrode in mm
+    n_x : int
+        Number of point electrode in x-direction
+    n_z : int
+        Number of point electrodes in z-direction
+
+    Returns
+    -------
+    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
+    dx = l_x/(n_x-1)
+    dz = l_z/(n_z-1)
+
+    for i_x in range(n_x):
+        for i_z in range(n_z):
+            electrode_coords[i, :] = np.array([-l_x/2 + i_x*dx, 0, -l_z/2 + i_z*dz])
+            i += 1
+
+    return electrode_coords
+
+
+def create_muscle_coords(l_x, l_y, n_x, n_y, h):
+    """
+    Create x and y coordinates of muscle fibres in muscle
+
+    Parameters
+    ----------
+    l_x : float
+        X-extension of muscle in mm
+    l_y : float
+        Y-extension of muscle in mm
+    n_x : int
+        Number of muscle fibres in x-direction
+    n_y : int
+        Number of muscle fibres in y-direction
+    h : float
+        Offset of muscle from electrode plane in mm
+
+    Returns
+    -------
+    muscle_coords : ndarray of float [n_muscle x 3]
+        Coordinates of muscle fibres in x-y plane (x, y, z)
+    """
+
+    muscle_coords = np.zeros((n_x*n_y, 3))
+
+    i = 0
+
+    if n_x == 1:
+        dx = 0
+    else:
+        dx = l_x/(n_x-1)
+
+    if n_y == 1:
+        dy = 0
+    else:
+        dy = l_y/(n_y-1)
+
+    for i_x in range(n_x):
+        for i_y in range(n_y):
+            muscle_coords[i, :] = np.array([-l_x/2 + i_x*dx, h + i_y*dy, 0])
+            i += 1
+
+    return muscle_coords
+
+
+def create_muscle_fibre(x0, y0, L, n_fibre):
+    """
+    Creates muscle fibre coordinates (in z-direction)
+
+    Parameters
+    ----------
+    x0 : float
+        X-location of muscle fibre
+    y0 : float
+        Y-location of muscle fibre
+    L : float
+        Length of muscle fibre
+    n_fibre : float
+        Number of discrete fibre elements
+
+    Returns
+    -------
+    fibre_coords : ndarray of float [n_fibre x 3]
+        Coordinates of muscle fibre in z-direction (x, y, z)
+    """
+    dz_fibre = L/(n_fibre-1)
+    fibre_coords = np.hstack((np.ones((n_fibre, 1))*x0,
+                              np.ones((n_fibre, 1))*y0,
+                              (-L/2 + np.arange(n_fibre) * dz_fibre)[:, np.newaxis]))
+
+    return fibre_coords
+
+
+def create_signal_matrix(T, dt, fibre_coords, z_e, v):
+    """
+    Create signal matrix containing the travelling action potential on the fibre
+
+    Parameters
+    ----------
+    T : float
+        Total time
+    dt : float
+        Time step
+    fibre_coords : ndarray of float [n_fibre x 3]
+        Coordinates of muscle fibre in z-direction (x, y, z)
+    z_e : float
+        Location of action potential generation
+    v : float
+        Velocity of action potential
+
+    Returns
+    -------
+    signal_matrix : ndarray of float [n_time x n_fibre]
+        Signal matrix containing the action potential values for each time step in the rows
+    """
+    N_t = int(T/dt + 1)  # number of time-steps
+    t = np.linspace(0, T, N_t)
+    n_fibre = fibre_coords.shape[0]
+    dz_fibre = np.abs(fibre_coords[0, 2] - fibre_coords[1, 2])
+    signal_matrix = np.zeros((N_t, n_fibre))
+    z_e_idx = np.argmin(np.abs(fibre_coords[:, 2] - z_e))
+    z_r = fibre_coords[z_e_idx:, 2] - fibre_coords[-1, 2]
+    z_l = fibre_coords[:z_e_idx, 2] - fibre_coords[z_e_idx, 2]  # np.arange(-(L/2 + z_e), 0, dz_fibre)
+
+    for i in range(N_t):
+        z_l += v*dt
+        z_r += v*dt
+
+#         ap_r = sfap_dip(z=z_r)
+#         ap_l = sfap_dip(z=z_l)
+
+        ap_r = sfap(t=z_r, v=1)
+        ap_l = sfap(t=z_l, v=1)
+
+        signal_matrix[i, :z_e_idx] = ap_l
+        signal_matrix[i, z_e_idx:] = np.flip(ap_r)
+
+    return signal_matrix, t, fibre_coords[:, 2]
+
+
+def hermite_rodriguez_1st(t, tau0=0, tau=0, lam=0.002):
+    """
+    First order Hermite Rodriguez function to model surface MUAPs
+
+    Parameters
+    ----------
+    t : ndarray of float [n_t]
+        Time axis in s
+    tau0 : float, optional, default: 0
+        initial shift to ensure causality in s
+    tau : float, optional, default: 0
+        shift (firing time) in s
+    lam : float, optional, default: 2
+        Timescale in s
+
+    Returns
+    -------
+    y : ndarray of float [n_t]
+        Surface MUAP
+    """
+
+    return -(t-tau0-tau) * np.exp(-((t-tau0-tau)/lam)**2)
+
+
+def weight_signal_matrix(signal_matrix, fn_imp, t, z):
+    """
+    Weight signal matrix with impulse response from single dipole at every location
+    """
+    imp = np.loadtxt(fn_imp)
+    imp[:, 0:3] = imp[:, 0:3]*1000
+    imp[:, 3] = imp[:, 3]/np.max(imp[:, 3])
+    signal_matrix_weighted = np.zeros((signal_matrix.shape[0], signal_matrix.shape[1], signal_matrix.shape[1]))
+
+    for i_t in range(signal_matrix.shape[0]):
+        print(f"{i_t}/{signal_matrix.shape[0]}")
+        for i_z, z_w in enumerate(z):
+            ir_interp = dipole_potential(z=z-z_w, loc=imp[:, 2], response=imp[:, 3])
+            signal_matrix_weighted[i_t, i_z, :] = signal_matrix[i_t, i_z] * ir_interp
+
+    signal_matrix_weighted = np.sum(signal_matrix_weighted, axis=1)
+
+    return signal_matrix_weighted
+
+
+def create_sensor_matrix(electrode_coords, fibre_coords, sigma_r=1, sigma_z=1):
+    """
+    Create sensor matrix containing the inverse distances from the point electrodes to the fibre elements
+    weighted by the anisotropy factor of the muscle tissue.
+
+    Parameters
+    ----------
+    electrode_coords : ndarray of float [n_ele x 3]
+        Coordinates of point electrodes (x, y, z)
+    fibre_coords : ndarray of float [n_fibre x 3]
+        Coordinates of muscle fibre in z-direction (x, y, z)
+    sigma_r : float, optional, default: 1
+        Radial conductivity of muscle
+    sigma_z : float, optional, default: 1
+        Axial conductivity of muscle along fibre
+
+    Returns
+    -------
+    sensor_matrix : ndarray of float [n_fibre x n_ele]
+        Sensor matrix containing the inverse distances weighted with the anisotropy of muscle tissue
+    """
+    sigma_factor = sigma_z/sigma_r
+
+    sensor_matrix = np.zeros((fibre_coords.shape[0], electrode_coords.shape[0]))
+
+    for i in range(electrode_coords.shape[0]):
+        r_f = np.linalg.norm(electrode_coords[i, :2] - fibre_coords[:, :2], axis=1)
+
+        # sensor_matrix[:, i] = 1/np.linalg.norm(fibre_coords-electrode_coords[i, :], axis=1)
+        sensor_matrix[:, i] = 1/np.sqrt(sigma_factor*r_f**2 + (fibre_coords[:, 2]-electrode_coords[i, 2])**2)
+
+    return sensor_matrix
+
+
+def compute_signal(signal_matrix, sensor_matrix):
+    """
+    Determine average signal from one single muscle fibre on all point electrodes
+
+    Parameters
+    ----------
+    signal_matrix : ndarray of float [n_time x n_fibre]
+        Signal matrix containing the action potential values for each time step in the rows
+    sensor_matrix : ndarray of float [n_fibre x n_ele]
+        Sensor matrix containing the inverse distances weighted with the anisotropy of muscle tissue
+
+    Returns
+    -------
+    signal : ndarray of float [n_time]
+        Average signal detected all point electrodes
+    """
+    signal = np.mean(np.matmul(signal_matrix, sensor_matrix), axis=1)
+
+    return signal
+
+
+def calc_mep_wilson(firing_rate_in, t, Qvmax=900, Qmmax=300, q=8, Tmin=14, N=100, M0=42, lam=0.002, tau0=0.006):
+    """
+    Determine motor evoked potential from incoming firing rate
+
+    Parameters
+    ----------
+    firing_rate_in : ndarray of float [n_t]
+        Input firing rate from alpha motor neurons
+    t : ndarray of float [n_t]
+        Time axis in s
+    Qvmax : float, optional, default: 900
+        Max of incoming firing rate [1/s]
+    Qmmax : float, optional, default: 300
+        Max of MU firing rate [1/s]
+    q : float, optional, default: 8
+        Min firing rate of MU [1/s]
+    Tmin : float, optional, default: 14
+        Min MU threshold [1/s]
+    N : float, optional, default: 100
+        Number of MU
+    M0 : float, optional, default: 42
+        Scaling constant of MU amplitude [mV/s]
+    lam : float, optional, default: 0.002
+        MUAP timescale of first order Hermite Rodriguez function [s]
+    tau0 : float, optional, default: 0.006
+        Standard shift of MUAP to ensure causality [s]
+
+    Returns
+    -------
+    mep : ndarray of float [n_t]
+        Motor evoked potential at surface electrode
+    """
+    dt = t[1] - t[0]            # time step
+    k = np.arange(N)+1          # MU index
+    firing_rate_in_mat = np.repeat(firing_rate_in[np.newaxis, :], N, axis=0)
+
+    # determine MU thresholds
+    alpha = 1/N*np.log(Qvmax/Tmin)
+    Tk = Tmin * np.exp(alpha*k)
+
+    # determine MU amplitude
+    Mk = M0 * np.exp(alpha*k)
+
+    # determine spike rate of MUs from incoming spike rate
+    kappak = (Qmmax - q) / (Qvmax - Tk)
+    Qk = q + kappak[:, np.newaxis] * (firing_rate_in_mat - Tk[:, np.newaxis])
+    Qk[firing_rate_in_mat < Tk[:, np.newaxis]] = 0
+
+    # determine spike times of MUs by integrating the spike rates
+    Qk_int = np.cumsum(Qk, axis=1) * dt
+
+    spike_times = []
+    for k in range(N):
+        Qk_int_max = int(np.floor(Qk_int[k, -1]))
+
+        if Qk_int_max > 0:
+            spike_times.append(np.zeros(Qk_int_max))
+
+            for j in range(Qk_int_max):
+                spike_times[k][j] = t[np.where(Qk_int[k, :] > (j+1))[0][0]]
+        else:
+            spike_times.append([])
+
+    # determine EMG signal by summing up all MUAPS at determined firing times
+    mep = np.zeros(len(t))
+
+    for k in range(N):
+        if len(spike_times[k]) > 0:
+            for tau in spike_times[k]:
+                mep += Mk[k] * hermite_rodriguez_1st(t=t, tau0=tau0, tau=tau, lam=lam)
+
+    return mep

pynibs/neuron/__init__.py

@@ -0,0 +1,2 @@
+from .neuron_regression import *
+from .util import *