kandellab 1.0.0__tar.gz

kandellab-1.0.0/KandelLab/__init__.py

@@ -0,0 +1,7 @@
+"""KandelLab — 神经科学原理仿真系统。
+
+细胞 → 回路 → 系统 → 认知，四层递进，12 个核心概念的 Python 从零实现。
+"""
+
+__version__ = "1.0.0"
+__all__ = ["__version__"]

kandellab-1.0.0/KandelLab/__main__.py

@@ -0,0 +1,8 @@
+"""支持 `python -m KandelLab` 运行 CLI。"""
+
+import sys
+
+from .main import main
+
+if __name__ == "__main__":
+    sys.exit(main())

kandellab-1.0.0/KandelLab/cells/__init__.py

@@ -0,0 +1,8 @@
+"""cells — 细胞层：单神经元的电生理模型。
+
+nernst          离子平衡电位
+goldman         GHK 方程静息电位
+hodgkin_huxley  动作电位
+lif             漏电积分发放模型
+synapse         突触 PSP 与时空总和
+"""

kandellab-1.0.0/KandelLab/cells/goldman.py

@@ -0,0 +1,109 @@
+"""Goldman–Hodgkin–Katz（GHK）方程：通透性加权的静息电位。
+
+核心概念 #2：静息电位由多种离子的相对通透性共同决定。
+
+模型
+----
+    V = (RT/F) · ln((P_K[K]_o + P_Na[Na]_o + P_Cl[Cl]_i)
+                  / (P_K[K]_i + P_Na[Na]_i + P_Cl[Cl]_o))
+
+P_X 为相对通透性；Cl⁻ 因价态为 −1 而取内外翻转。
+
+验证锚点：
+    单离子极限（其余 P=0）→ 还原为 Nernst 方程；
+    生理通透性下静息电位 ≈ −70 mV。
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from .. import config
+
+
+def goldman_voltage(permeabilities, c_out, c_in, T=None, z=None):
+    """GHK 方程计算静息电位（mV）。
+
+    Parameters
+    ----------
+    permeabilities : dict[str, float]
+        {"K": P_K, "Na": P_Na, "Cl": P_Cl, ...}，值为相对通透性。
+    c_out, c_in : dict[str, float]
+        {"K": …, "Na": …, "Cl": …} 膜外/膜内浓度（mM）。
+    T : float | None
+        绝对温度（K）。
+    z : dict[str, int] | None
+        各离子价态；None 时使用 config.ION_CONCENTRATIONS 的价态。
+
+    Returns
+    -------
+    float : 静息电位（mV）。
+    """
+    T = config.T_KELVIN if T is None else T
+    rt_f = config.R * T / config.F * 1000.0   # mV
+
+    if z is None:
+        z = {ion: config.ION_CONCENTRATIONS[ion]["z"] for ion in permeabilities}
+
+    numer = 0.0
+    denom = 0.0
+    for ion, P in permeabilities.items():
+        zi = z[ion]
+        co = c_out[ion]
+        ci = c_in[ion]
+        if zi > 0:
+            numer += P * co
+            denom += P * ci
+        else:
+            numer += P * ci
+            denom += P * co
+
+    if numer <= 0 or denom <= 0:
+        raise ValueError("GHK 分子/分母必须为正（所有 P 均为 0 时无定义）")
+    return rt_f * np.log(numer / denom)
+
+
+def resting_potential(T=None):
+    """使用 config 生理浓度与默认通透性计算静息电位（mV）。"""
+    perm = dict(config.PERMEABILITIES)
+    conc = config.ION_CONCENTRATIONS
+    c_out = {ion: conc[ion]["o"] for ion in perm}
+    c_in = {ion: conc[ion]["i"] for ion in perm}
+    return goldman_voltage(perm, c_out, c_in, T)
+
+
+def single_ion_limit(ion, T=None):
+    """计算"仅某离子通透"时的极限电位，应等于该离子 Nernst 电位。"""
+    conc = config.ION_CONCENTRATIONS
+    perm = {ion: 1.0}
+    c_out = {ion: conc[ion]["o"]}
+    c_in = {ion: conc[ion]["i"]}
+    return goldman_voltage(perm, c_out, c_in, T)
+
+
+def permeability_scan(na_frac, T=None, cl_perm=None):
+    """扫描 Na⁺ 相对通透性（PK=1）对静息电位的影响。
+
+    Parameters
+    ----------
+    na_frac : array_like
+        P_Na 取值序列。
+    T : float | None
+    cl_perm : float | None
+        P_Cl 固定值；None 使用 config 默认 0.45。
+
+    Returns
+    -------
+    (na_frac, V) : 通透性序列与对应电位。
+    """
+    conc = config.ION_CONCENTRATIONS
+    c_out = {ion: conc[ion]["o"] for ion in ("K", "Na", "Cl")}
+    c_in = {ion: conc[ion]["i"] for ion in ("K", "Na", "Cl")}
+    if cl_perm is None:
+        cl_perm = config.PERMEABILITIES["Cl"]
+    na_frac = np.asarray(na_frac, dtype=float)
+    V = np.array([
+        goldman_voltage({"K": 1.0, "Na": p, "Cl": cl_perm}, c_out, c_in, T)
+        for p in na_frac
+    ])
+    return na_frac, V

kandellab-1.0.0/KandelLab/cells/hodgkin_huxley.py

@@ -0,0 +1,212 @@
+"""Hodgkin–Huxley（HH）模型：动作电位的电压门控离子通道动力学。
+
+核心概念 #3：动作电位是电压门控 Na⁺/K⁺ 通道的协同动力学产物。
+
+模型（经典 4 变量 ODE，HH 1952，单位 mV / ms / µA/cm²）
+------------------------------------------------------
+    C_m · dV/dt = −(g_Na·m³·h·(V−E_Na) + g_K·n⁴·(V−E_K) + g_L·(V−E_L)) + I_ext
+    dm/dt = α_m(V)(1−m) − β_m(V)·m          （Na 激活）
+    dh/dt = α_h(V)(1−h) − β_h(V)·h          （Na 失活）
+    dn/dt = α_n(V)(1−n) − β_n(V)·n          （K 激活）
+
+门控速率函数（V 以 mV 计，经典取值）：
+    α_m = 0.1(V+40)/(1−exp(−(V+40)/10))      β_m = 4·exp(−(V+65)/18)
+    α_h = 0.07·exp(−(V+65)/20)               β_h = 1/(1+exp(−(V+35)/10))
+    α_n = 0.01(V+55)/(1−exp(−(V+55)/10))     β_n = 0.125·exp(−(V+65)/80)
+
+验证锚点：静息 ≈ −65 mV、峰 ≈ +35 mV、阈值 ≈ −55 mV、绝对不应期 ≈ 2 ms。
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from .. import config
+from ..utils.neuro import integrate_ode, detect_spikes
+
+
+# ---------------------------------------------------------------------------
+# 门控速率函数
+# ---------------------------------------------------------------------------
+def alpha_m(v):
+    v = np.asarray(v, dtype=float)
+    z = (v + 40.0) / 10.0
+    with np.errstate(over="ignore", invalid="ignore"):
+        denom = 1.0 - np.exp(-z)
+    zz = np.where(np.abs(z) < 1e-8, 1e-8, z)   # z→0 极限 = 1
+    out = zz / denom
+    return np.where(np.isfinite(out), out, 0.0)
+
+
+def beta_m(v):
+    return 4.0 * np.exp(-(np.asarray(v, dtype=float) + 65.0) / 18.0)
+
+
+def alpha_h(v):
+    return 0.07 * np.exp(-(np.asarray(v, dtype=float) + 65.0) / 20.0)
+
+
+def beta_h(v):
+    v = np.asarray(v, dtype=float)
+    return 1.0 / (1.0 + np.exp(-(v + 35.0) / 10.0))
+
+
+def alpha_n(v):
+    v = np.asarray(v, dtype=float)
+    z = (v + 55.0) / 10.0
+    with np.errstate(over="ignore", invalid="ignore"):
+        denom = 1.0 - np.exp(-z)
+    zz = np.where(np.abs(z) < 1e-8, 1e-8, z)   # z→0 极限 = 0.1
+    out = 0.1 * zz / denom
+    return np.where(np.isfinite(out), out, 0.0)
+
+
+def beta_n(v):
+    return 0.125 * np.exp(-(np.asarray(v, dtype=float) + 65.0) / 80.0)
+
+
+def gate_steady_state(v):
+    """各门控的稳态值（m∞, h∞, n∞）与时间常数。"""
+    v = np.asarray(v, dtype=float)
+    a_m, b_m = alpha_m(v), beta_m(v)
+    a_h, b_h = alpha_h(v), beta_h(v)
+    a_n, b_n = alpha_n(v), beta_n(v)
+    return {
+        "m_inf": a_m / (a_m + b_m),
+        "h_inf": a_h / (a_h + b_h),
+        "n_inf": a_n / (a_n + b_n),
+        "tau_m": 1.0 / (a_m + b_m),
+        "tau_h": 1.0 / (a_h + b_h),
+        "tau_n": 1.0 / (a_n + b_n),
+    }
+
+
+# ---------------------------------------------------------------------------
+# HH 动力学
+# ---------------------------------------------------------------------------
+class HodgkinHuxley:
+    """HH 模型封装。默认参数来自 config.HH_DEFAULTS。"""
+
+    def __init__(self, **kwargs):
+        p = dict(config.HH_DEFAULTS)
+        p.update(kwargs)
+        self.C_m = p["C_m"]
+        self.g_Na = p["g_Na"]
+        self.g_K = p["g_K"]
+        self.g_L = p["g_L"]
+        self.E_Na = p["E_Na"]
+        self.E_K = p["E_K"]
+        self.E_L = p["E_L"]
+        self.V_rest = p["V_rest"]
+
+    # -- 门控动力学（供 integrate_ode 使用的向量场） -------------------
+    def dvdt(self, v, m, h, n, i_ext):
+        i_na = self.g_Na * m ** 3 * h * (v - self.E_Na)
+        i_k = self.g_K * n ** 4 * (v - self.E_K)
+        i_l = self.g_L * (v - self.E_L)
+        return (-(i_na + i_k + i_l) + i_ext) / self.C_m
+
+    def vector_field(self, y, t, i_ext_fn=None):
+        v, m, h, n = y
+        i_ext = 0.0 if i_ext_fn is None else i_ext_fn(t)
+        dm = alpha_m(v) * (1.0 - m) - beta_m(v) * m
+        dh = alpha_h(v) * (1.0 - h) - beta_h(v) * h
+        dn = alpha_n(v) * (1.0 - n) - beta_n(v) * n
+        return np.array([self.dvdt(v, m, h, n, i_ext), dm, dh, dn])
+
+    def initial_state(self):
+        g = gate_steady_state(self.V_rest)
+        return np.array([self.V_rest, g["m_inf"], g["h_inf"], g["n_inf"]])
+
+    def simulate(self, t_max, dt=None, i_ext_fn=None, v0=None, method="rk4"):
+        """模拟 HH 模型。
+
+        Parameters
+        ----------
+        t_max : float
+            仿真时长（ms）。
+        dt : float | None
+            时间步长。
+        i_ext_fn : callable | None
+            i_ext(t) 返回注入电流密度（µA/cm²）。
+        v0 : array_like | None
+            初值 [V, m, h, n]；None 用静息稳态。
+        method : str
+            "rk4" / "euler"。
+
+        Returns
+        -------
+        t : np.ndarray
+        y : np.ndarray (N, 4)，列为 V, m, h, n
+        """
+        y0 = self.initial_state() if v0 is None else np.asarray(v0, dtype=float)
+        t, y = integrate_ode(self.vector_field, y0, t_max, dt, method,
+                             i_ext_fn=i_ext_fn)
+        return t, y
+
+    def spikes(self, t, y, v_thresh=None, refractory_ms=1.0):
+        v = y[:, 0]
+        dt = t[1] - t[0]
+        return detect_spikes(v, v_thresh, dt, refractory_ms)
+
+    def fI_curve(self, currents, t_max=120.0, dt=0.01, t_stim=(10.0, 110.0),
+                 method="rk4"):
+        """不同注入电流下的发放率（Hz）。电流为恒定阶跃。
+
+        Returns
+        -------
+        (I, f) : 电流序列与发放率序列。
+        """
+        I = np.asarray(currents, dtype=float)
+        f = np.empty_like(I)
+        for i, cur in enumerate(I):
+            def i_ext_fn(tt):
+                return cur if t_stim[0] <= tt <= t_stim[1] else 0.0
+            t, y = self.simulate(t_max, dt, i_ext_fn=i_ext_fn, method=method)
+            spikes = self.spikes(t, y)
+            duration = t_stim[1] - t_stim[0]
+            spikes = spikes[(spikes >= t_stim[0]) & (spikes <= t_stim[1])]
+            f[i] = spikes.size / (duration / 1000.0)
+        return I, f
+
+
+def threshold_finder(hh, t_max=60.0, dt=0.01, amp_scan=(0.0, 12.0, 40),
+                     pulse_ms=1.0, t_on=5.0, amp_tol=0.01):
+    """用脉冲电流扫描确定发放阈值（mV）。
+
+    做法：在静息电位基础上给一个短促电流脉冲，二分搜索临界电流幅度
+    （恰好触发动作电位的注入电流），返回临界电流下亚阈值响应的
+    峰值膜电位，作为阈值电压估计。对经典 HH 参数应 ≈ −55 mV。
+
+    amp_tol : float
+        二分搜索的电流精度（mV）；防止过度逼近临界点导致
+        亚阈值峰值被 RK4 数值误差放大。
+    """
+    lo, hi = amp_scan[0], amp_scan[1]
+    v_peak_sub = None
+    for _ in range(amp_scan[2]):
+        mid = 0.5 * (lo + hi)
+
+        def i_ext_fn(tt):
+            return mid if t_on <= tt <= t_on + pulse_ms else 0.0
+
+        t, y = hh.simulate(t_max, dt, i_ext_fn=i_ext_fn, method="rk4")
+        sp = hh.spikes(t, y, refractory_ms=0.5)
+        has_spike = sp.size > 0
+        if has_spike:
+            hi = mid
+        else:
+            v_peak_sub = float(y[:, 0].max())
+            lo = mid
+        if hi - lo < amp_tol:
+            break
+    return v_peak_sub if v_peak_sub is not None else 0.5 * (lo + hi)
+
+
+def step_current(amp, t_on=5.0, t_off=np.inf):
+    """构造阶跃电流函数 i_ext(t)，在 [t_on, t_off) 注入恒定 amp。"""
+
+    def fn(t):
+        return amp if t_on <= t < t_off else 0.0
+
+    return fn

kandellab-1.0.0/KandelLab/cells/lif.py

@@ -0,0 +1,131 @@
+"""漏电积分发放（Leaky Integrate-and-Fire, LIF）模型。
+
+核心概念 #4：神经元以脉冲序列（频率编码）传递信息。
+
+模型
+----
+    τ_m · dV/dt = −(V − E_L) + R_m · I(t)
+
+V ≥ V_th 时发放一次并复位到 V_reset（含绝对不应期 τ_ref）。
+
+解析发放率（恒定电流 I，V∞ = E_L + R·I）：
+    f = 1 / (τ_ref + τ_m · ln((V∞ − V_reset) / (V∞ − V_th)))
+
+验证锚点：数值模拟的 f-I 曲线与解析公式逐点吻合。
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from .. import config
+from ..utils.neuro import detect_spikes
+
+
+class LIF:
+    """LIF 神经元。默认参数来自 config.LIF_DEFAULTS。"""
+
+    def __init__(self, **kwargs):
+        p = dict(config.LIF_DEFAULTS)
+        p.update(kwargs)
+        self.tau_m = p["tau_m"]
+        self.R_m = p["R_m"]
+        self.E_L = p["E_L"]
+        self.V_th = p["V_th"]
+        self.V_reset = p["V_reset"]
+        self.V_peak = p["V_peak"]
+        self.tau_ref = p["tau_ref"]
+
+    # -- 数值模拟 -------------------------------------------------------
+    def simulate(self, I, t_max, dt=0.01, v0=None):
+        """恒定/时变电流下的仿真。
+
+        Parameters
+        ----------
+        I : float | np.ndarray
+            恒定电流（nA）或与 t 对齐的电流序列。
+        t_max : float
+            时长（ms）。
+        dt : float
+            步长（ms）。
+        v0 : float | None
+            初始电位；None 用 E_L。
+
+        Returns
+        -------
+        t : np.ndarray
+        v : np.ndarray
+        spike_times : np.ndarray
+        """
+        n = int(np.ceil(t_max / dt)) + 1
+        t = np.arange(n) * dt
+        v = np.empty(n)
+        if np.isscalar(I):
+            I = np.full(n, float(I))
+        I = np.asarray(I, dtype=float)
+        if I.ndim == 0:
+            I = np.full(n, float(I))
+
+        v[0] = self.E_L if v0 is None else v0
+        spike_times = []
+        ref_end = -1.0
+        for i in range(n - 1):
+            tt = t[i]
+            if i < ref_end:
+                v[i] = self.V_reset
+                v[i + 1] = self.V_reset
+                continue
+            v_inf = self.E_L + self.R_m * I[i]
+            dv = (-(v[i] - self.E_L) + self.R_m * I[i]) / self.tau_m
+            v[i + 1] = v[i] + dt * dv
+            if v[i + 1] >= self.V_th:
+                v[i + 1] = self.V_peak
+                spike_times.append(tt + dt)
+                ref_end = i + 1 + int(np.ceil(self.tau_ref / dt))
+        return t, v, np.array(spike_times)
+
+    # -- 解析 -----------------------------------------------------------
+    def analytical_rate(self, I):
+        """恒定电流下的解析发放率（Hz）。I 低于阈时返回 0。"""
+        v_inf = self.E_L + self.R_m * float(I)
+        if v_inf <= self.V_th:
+            return 0.0
+        t_s = self.tau_m * np.log((v_inf - self.V_reset) / (v_inf - self.V_th))
+        if t_s < 0:
+            return 0.0
+        return 1.0 / ((self.tau_ref + t_s) / 1000.0)
+
+    def rheobase(self):
+        """基强度电流（nA）：恰好使 V∞ = V_th。"""
+        return (self.V_th - self.E_L) / self.R_m
+
+    def fI_curve(self, currents, t_max=1000.0, dt=0.01, burn_ms=100.0):
+        """数值 f-I 曲线（Hz），burn_ms 用于丢弃起始瞬态。"""
+        I = np.asarray(currents, dtype=float)
+        f_num = np.empty_like(I)
+        for k, cur in enumerate(I):
+            t, v, sp = self.simulate(float(cur), t_max, dt)
+            sp = sp[sp >= burn_ms]
+            f_num[k] = sp.size / ((t_max - burn_ms) / 1000.0)
+        f_ana = np.array([self.analytical_rate(float(c)) for c in I])
+        return I, f_num, f_ana
+
+
+def raster_simulation(currents, n_trials=20, t_max=300.0, dt=0.01, seed=None,
+                      **lif_kwargs):
+    """多次试验的栅栏图模拟：返回 {电流: spike_times 列表}。
+
+    通过在每个 trial 添加微小高斯噪声模拟响应变异性。
+    """
+    from ..utils.neuro import rng
+    r = rng(seed)
+    lif = LIF(**lif_kwargs)
+    out = {}
+    for cur in currents:
+        trial_spikes = []
+        for _ in range(n_trials):
+            noisy = cur + r.normal(0.0, abs(cur) * 0.05 + 0.1)
+            t, v, sp = lif.simulate(noisy, t_max, dt)
+            trial_spikes.append(sp)
+        out[float(cur)] = trial_spikes
+    return out

kandellab-1.0.0/KandelLab/cells/nernst.py

@@ -0,0 +1,82 @@
+"""Nernst 方程：离子浓度差决定平衡电位。
+
+核心概念 #1：细胞膜两侧离子浓度差 + 选择性通透 → 膜电位。
+
+模型
+----
+    E = (RT / zF) · ln([X]_o / [X]_i)
+
+其中 R 为气体常数、T 为绝对温度、z 为离子价态、F 为法拉第常数、
+[X]_o / [X]_i 为膜外/膜内浓度。
+
+教科书锚点（37 °C，Kandel 标准浓度）：
+    K⁺  ≈ −90 mV，Na⁺ ≈ +60 mV，Cl⁻ ≈ −90 mV，Ca²⁺ ≈ +132 mV
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from .. import config
+
+
+def nernst_potential(z, c_out, c_in, T=None):
+    """计算单个离子的 Nernst 平衡电位（mV）。
+
+    Parameters
+    ----------
+    z : int | float
+        离子价态（K⁺/Na⁺ 取 +1，Ca²⁺ 取 +2，Cl⁻ 取 −1）。
+    c_out, c_in : float
+        膜外 / 膜内浓度（mM，同单位即可）。
+    T : float | None
+        绝对温度（K）；None 使用 config 生理温度 37 °C。
+
+    Returns
+    -------
+    float : 平衡电位（mV）。
+    """
+    if z == 0:
+        raise ValueError("z 不能为 0")
+    if c_in <= 0 or c_out <= 0:
+        raise ValueError("浓度必须为正数")
+    T = config.T_KELVIN if T is None else T
+    rt_f = config.R * T / config.F   # 单位 V
+    return rt_f * 1000.0 / z * np.log(c_out / c_in)
+
+
+def ion_equilibrium(ion, T=None):
+    """使用 config 默认浓度计算某离子的平衡电位（mV）。
+
+    Parameters
+    ----------
+    ion : str
+        "K" / "Na" / "Ca" / "Cl"。
+    """
+    if ion not in config.ION_CONCENTRATIONS:
+        raise KeyError(f"未知离子: {ion}")
+    spec = config.ION_CONCENTRATIONS[ion]
+    return nernst_potential(spec["z"], spec["o"], spec["i"], T)
+
+
+def all_equilibria(T=None):
+    """返回全部离子的平衡电位 dict。"""
+    return {ion: ion_equilibrium(ion, T) for ion in config.ION_CONCENTRATIONS}
+
+
+def concentration_scan(ion, c_out_range, T=None):
+    """扫描膜外浓度并返回 (浓度数组, 电位数组)。
+
+    用于实验 #1：改变 [K⁺]_o → 观察静息电位（Nernst 预测）。
+    """
+    spec = config.ION_CONCENTRATIONS[ion]
+    c_out = np.asarray(c_out_range, dtype=float)
+    E = np.array([nernst_potential(spec["z"], co, spec["i"], T) for co in c_out])
+    return c_out, E
+
+
+def temperature_scan(c_out, c_in, z=1, T_range=(280.0, 320.0, 41)):
+    """温度扫描：返回 (温度数组, 电位数组)。"""
+    T = np.linspace(T_range[0], T_range[1], T_range[2])
+    E = np.array([nernst_potential(z, c_out, c_in, Ti) for Ti in T])
+    return T, E

kandellab-1.0.0/KandelLab/cells/synapse.py

@@ -0,0 +1,139 @@
+"""突触模型：EPSP / IPSP 与时间、空间总和。
+
+核心概念 #5：突触输入在时间与空间上整合，决定神经元是否发放。
+
+模型
+----
+    PSP(t) = w · (t/τ) · exp(−t/τ)          （α 函数，t ≥ 0）
+
+多突触事件的响应线性叠加（在亚阈值范围内近似成立）：
+    V(t) = Σ_i  w_i · PSP(t − t_i)
+
+验证锚点：
+    时间总和：ISI 短 → 双脉冲峰值 > 单脉冲峰值；
+    空间总和：多输入同刻 → 幅度随输入数近似线性增长。
+"""
+
+from __future__ import annotations
+
+import numpy as np
+
+from .. import config
+
+
+def psp_alpha(t, w=1.0, tau=None):
+    """α 函数型突触后电位。
+
+    Parameters
+    ----------
+    t : array_like
+        时间（ms）。
+    w : float
+        突触权重（幅度；IPSP 传负值）。
+    tau : float | None
+        时间常数（ms）；None 用 config.SYNAPSE_DEFAULTS["tau_decay"]。
+
+    Returns
+    -------
+    np.ndarray
+    """
+    tau = config.SYNAPSE_DEFAULTS["tau_decay"] if tau is None else tau
+    t = np.asarray(t, dtype=float)
+    out = np.zeros_like(t)
+    pos = t >= 0
+    out[pos] = w * (t[pos] / tau) * np.exp(-t[pos] / tau)
+    return out
+
+
+def psp_alpha_peak(w, tau):
+    """α 函数峰值幅度（归一化到 w）。"""
+    return w * np.exp(-1.0)
+
+
+def psp_peak_time(tau):
+    """α 函数到达峰值的时间（ms）。"""
+    return tau
+
+
+def simulate_psp(spike_times, t, w=1.0, tau=None):
+    """对单一输入的多次发放做时间总和（线性叠加）。
+
+    Parameters
+    ----------
+    spike_times : array_like
+        发放时刻（ms）。
+    t : array_like
+        观测时间网格（ms）。
+    w, tau : float
+        权重与时间常数。
+
+    Returns
+    -------
+    np.ndarray : V(t)
+    """
+    t = np.asarray(t, dtype=float)
+    v = np.zeros_like(t)
+    for st in np.atleast_1d(spike_times):
+        v = v + psp_alpha(t - st, w, tau)
+    return v
+
+
+def temporal_sum_peak(isi, w=1.0, tau=None, dt=0.01):
+    """双脉冲（间隔 ISI）时间总和后的峰值电位。
+
+    Returns
+    -------
+    float : 叠加后峰值（mV）。
+    """
+    tau = config.SYNAPSE_DEFAULTS["tau_decay"] if tau is None else tau
+    t = np.arange(0.0, max(8 * tau, isi + 6 * tau), dt)
+    v = simulate_psp([0.0, isi], t, w, tau)
+    return float(v.max())
+
+
+def temporal_sum_scan(isis, w=1.0, tau=None, dt=0.01):
+    """扫描双脉冲间隔：返回 (ISI 序列, 峰值序列, 单脉冲峰值)。"""
+    isis = np.asarray(isis, dtype=float)
+    single = psp_alpha_peak(w, config.SYNAPSE_DEFAULTS["tau_decay"] if tau is None else tau)
+    peaks = np.array([temporal_sum_peak(isi, w, tau, dt) for isi in isis])
+    return isis, peaks, single
+
+
+def spatial_sum(spike_times_list, t, weights=None, taus=None):
+    """多输入（每条输入一个发放时刻序列）的空间总和。
+
+    Parameters
+    ----------
+    spike_times_list : list[array_like]
+        每条输入对应的发放时刻。
+    t : array_like
+        时间网格。
+    weights : list[float] | None
+        各输入权重；None 全为 1。
+    taus : list[float] | None
+        各输入时间常数；None 全用默认。
+
+    Returns
+    -------
+    np.ndarray : V(t)
+    """
+    n_in = len(spike_times_list)
+    if weights is None:
+        weights = [1.0] * n_in
+    if taus is None:
+        taus = [None] * n_in
+    t = np.asarray(t, dtype=float)
+    v = np.zeros_like(t)
+    for spikes, w, tau in zip(spike_times_list, weights, taus):
+        v = v + simulate_psp(spikes, t, w, tau)
+    return v
+
+
+def spatial_sum_peak(spike_times_list, t, weights=None, taus=None):
+    """多输入空间总和后的峰值。"""
+    return float(spatial_sum(spike_times_list, t, weights, taus).max())
+
+
+def isi_to_firing(isi):
+    """由发放间隔（ms）换算发放率（Hz）。"""
+    return 1000.0 / float(isi) if isi > 0 else np.inf