diff --git a/jaxley/io/graph.py b/jaxley/io/graph.py index 8441b223..508dd511 100644 --- a/jaxley/io/graph.py +++ b/jaxley/io/graph.py @@ -564,6 +564,7 @@ def from_graph( nseg: int = 4, max_branch_len: float = 2000.0, assign_groups: bool = True, + ignore_swc_trace_errors: bool = True, ) -> Union[jx.Network, jx.Cell, jx.Branch, jx.Compartment]: """Build a module from a networkx graph. @@ -633,6 +634,8 @@ def from_graph( assigned yet. assign_groups: Wether to assign groups to nodes based on the the id or groups attribute. + ignore_swc_trace_errors: Whether to ignore discontinuities in the swc tracing + order. If False, this will result in split branches at these points. Returns: A module instance that is populated with the node and egde attributes of @@ -645,12 +648,20 @@ def from_graph( if "type" not in graph.graph: try: graph = make_jaxley_compatible( - graph, nseg=nseg, max_branch_len=max_branch_len + graph, + nseg=nseg, + max_branch_len=max_branch_len, + ignore_swc_trace_errors=ignore_swc_trace_errors, ) except: raise Exception("Graph appears to be incompatible with jaxley.") elif graph.graph["type"] == "swc": - graph = make_jaxley_compatible(graph, nseg=nseg, max_branch_len=max_branch_len) + graph = make_jaxley_compatible( + graph, + nseg=nseg, + max_branch_len=max_branch_len, + ignore_swc_trace_errors=ignore_swc_trace_errors, + ) ################################# ### Import graph as jx.Module ### @@ -692,7 +703,8 @@ def from_graph( acc_parents.append([-1] + parents.tolist()) # drop special attrs from nodes and ignore error if col does not exist - optional_attrs = ["recordings", "externals", "groups", "trainable"] + # x,y,z can be re-computed from xyzr if needed + optional_attrs = ["recordings", "externals", "groups", "trainable", "x", "y", "z"] nodes.drop(columns=optional_attrs, inplace=True, errors="ignore") # build module @@ -700,11 +712,12 @@ def from_graph( module = build_module_scaffold(idxs, graph.graph["type"], acc_parents) # set global attributes of module + graph.graph.pop("type") for k, v in graph.graph.items(): setattr(module, k, v) module.nodes[nodes.columns] = nodes # set column-wise. preserves cols not in nodes. - module.edges = synapse_edges.T + module.edges = synapse_edges.T if not synapse_edges.empty else module.edges module.membrane_current_names = [c.current_name for c in module.channels] module.synapse_names = [s._name for s in module.synapses] @@ -727,8 +740,12 @@ def from_graph( cached_external_inds = {} cached_externals = {} for key, data in externals.items(): - cached_externals[key] = np.stack(data[~data.isna()].explode().values) - cached_external_inds[key] = data[~data.isna()].explode().index.to_numpy() + cached_externals[key] = jnp.array( + np.stack(data[~data.isna()].explode().values) + ) + cached_external_inds[key] = jnp.array( + data[~data.isna()].explode().index.to_numpy() + ) module.externals = cached_externals module.external_inds = cached_external_inds @@ -773,10 +790,10 @@ def from_graph( if not groups.empty and assign_groups: groups = groups.explode(1).rename(columns={0: "index", 1: "group"}) groups = groups[groups["group"] != "undefined"] # skip undefined comps - group_nodes = {k: nodes.loc[v["index"]] for k, v in groups.groupby("group")} + # module[:] ensure group nodes in module reflect what is shown in view + group_nodes = { + k: module[:].view.loc[v["index"]] for k, v in groups.groupby("group") + } module.group_nodes = group_nodes - # update group nodes in module to reflect what is shown in view - for group, nodes in module.group_nodes.items(): - module.group_nodes[group] = module.__getattr__(group).view return module diff --git a/jaxley/modules/base.py b/jaxley/modules/base.py index 30303dda..a33b87c6 100644 --- a/jaxley/modules/base.py +++ b/jaxley/modules/base.py @@ -114,9 +114,8 @@ def __init__(self): def _update_nodes_with_xyz(self): """Add xyz coordinates to nodes.""" loc = np.linspace(0.5 / self.nseg, 1 - 0.5 / self.nseg, self.nseg) - jit_interp = jit(interpolate_xyz) xyz = ( - [jit_interp(loc, xyzr).T for xyzr in self.xyzr] + [interpolate_xyz(loc, xyzr).T for xyzr in self.xyzr] if len(loc) > 0 else [self.xyzr] ) diff --git a/jaxley/utils/cell_utils.py b/jaxley/utils/cell_utils.py index f19b3632..ee6ff2af 100644 --- a/jaxley/utils/cell_utils.py +++ b/jaxley/utils/cell_utils.py @@ -278,6 +278,9 @@ def remap_to_consecutive(arr): return inverse_indices +v_interp = vmap(jnp.interp, in_axes=(None, None, 1)) + + def interpolate_xyz(loc: float, coords: np.ndarray): """Perform a linear interpolation between xyz-coordinates. @@ -288,9 +291,9 @@ def interpolate_xyz(loc: float, coords: np.ndarray): Return: Interpolated xyz coordinate at `loc`, shape `(3,). """ - return vmap(lambda x: jnp.interp(loc, jnp.linspace(0, 1, len(x)), x), in_axes=(1,))( - coords[:, :3] - ) + lens = np.cumsum(np.sqrt(np.sum(np.diff(coords[:, :3], axis=0) ** 2, axis=1))) + lens = np.insert(lens, 0, 0) + return v_interp(loc * lens[-1], lens, coords[:, :3]) def params_to_pstate( @@ -388,6 +391,3 @@ def group_and_sum( group_sums = group_sums.at[inds_to_group_by].add(values_to_sum) return group_sums - - -v_interp = vmap(jnp.interp, in_axes=(None, None, 1)) diff --git a/jaxley/utils/misc_utils.py b/jaxley/utils/misc_utils.py index 3ced3326..578a20be 100644 --- a/jaxley/utils/misc_utils.py +++ b/jaxley/utils/misc_utils.py @@ -33,41 +33,61 @@ def childview( raise AttributeError("Compartment does not support indexing") -def recursive_compare(a, b): - if isinstance(a, (int, float)): +def recursive_compare(a, b, verbose=False): + def verbose_comp(a, b, type): + if verbose: + print(f"{type} {a} and {b} are not equal.") + return False + + if type(a) != type(b): + return verbose_comp(a, b, "Types") + + if isinstance(a, (float, int)): if abs(a - b) > 1e-5 and not (np.isnan(a) and np.isnan(b)): - return False + return verbose_comp(a, b, "Floats/Ints") + elif isinstance(a, str): if a != b: - return False + return verbose_comp(a, b, "Strings") + elif isinstance(a, (np.ndarray, jnp.ndarray)): - if a.size > 1: - for i in range(len(a)): - if not recursive_compare(a[i], b[i]): - return False - else: - if not recursive_compare(a.item(), b.item()): - return False + if a.dtype.kind in "biufc": # is numeric + if not np.allclose(a, b, equal_nan=True): + return verbose_comp(a, b, "Arrays") + elif not np.all(a == b): + return verbose_comp(a, b, "Arrays") + elif isinstance(a, (list, tuple)): if len(a) != len(b): - return False + return verbose_comp(a, b, "Lists/Tuples") + for i in range(len(a)): if not recursive_compare(a[i], b[i]): - return False + return verbose_comp(a[i], b[i], "Lists/Tuples") + elif isinstance(a, dict): if len(a) != len(b) and len(a) != 0: - return False + return verbose_comp(a, b, "Dicts") + if set(a.keys()) != set(b.keys()): - return False + return verbose_comp(a, b, "Dicts") + for k in a.keys(): if not recursive_compare(a[k], b[k]): - return False + return verbose_comp(a[k], b[k], "Dicts") + elif isinstance(a, pd.DataFrame): if not recursive_compare(a.to_dict(), b.to_dict()): - return False + return verbose_comp(a, b, "DataFrames") + elif a is None or b is None: if not (a is None and b is None): - return False + return verbose_comp(a, b, "None") else: - raise ValueError(f"Type {type(a)} not supported") + try: + if not a == b: + return verbose_comp(a, b, "Other") + + except AttributeError: + raise ValueError(f"Type {type(a)} not supported") return True diff --git a/tests/helpers.py b/tests/helpers.py index 30404c3a..da1fe93c 100644 --- a/tests/helpers.py +++ b/tests/helpers.py @@ -1,4 +1,3 @@ -from neuron import h import numpy as np import pandas as pd @@ -38,14 +37,14 @@ def get_segment_xyzrL(section, comp_idx=None, loc=None, nseg=8): return x, y, z, r, L[-1]/nseg -def jaxley2neuron_by_coords(jx_cell, neuron_secs, branch_loc=0.05, nseg=8): - neuron_coords = {i: np.vstack(get_segment_xyzrL(sec, branch_loc, nseg=nseg))[:,:3].T for i, sec in enumerate(neuron_secs)} +def jaxley2neuron_by_coords(jx_cell, neuron_secs, comp_idx=None, loc=None, nseg=8): + neuron_coords = {i: np.vstack(get_segment_xyzrL(sec, comp_idx=comp_idx, loc=loc, nseg=nseg))[:3].T for i, sec in enumerate(neuron_secs)} neuron_coords = np.vstack([np.hstack([k*np.ones((v.shape[0], 1)), v]) for k,v in neuron_coords.items()]) neuron_coords = pd.DataFrame(neuron_coords, columns=["branch_index", "x", "y", "z"]) neuron_coords["branch_index"] = neuron_coords["branch_index"].astype(int) neuron_loc_xyz = neuron_coords.groupby("branch_index").mean() - jaxley_loc_xyz = jx_cell.branch("all").loc(branch_loc).show().set_index("branch_index")[["x", "y", "z"]] + jaxley_loc_xyz = jx_cell.branch("all").loc(loc).show().set_index("branch_index")[["x", "y", "z"]] jaxley2neuron_inds = {} for i,xyz in enumerate(jaxley_loc_xyz.to_numpy()): @@ -54,13 +53,13 @@ def jaxley2neuron_by_coords(jx_cell, neuron_secs, branch_loc=0.05, nseg=8): return jaxley2neuron_inds -def jaxley2neuron_by_group(cell, neuron_secs, branch_loc=0.05, nseg=8, num_apical=20, num_tuft=20, num_basal=10): - y_apical = cell.apical.show().groupby("branch_index").mean()["y"].abs().sort_values() +def jaxley2neuron_by_group(jx_cell, neuron_secs, comp_idx=None, loc=None, nseg=8, num_apical=20, num_tuft=20, num_basal=10): + y_apical = jx_cell.apical.show().groupby("branch_index").mean()["y"].abs().sort_values() trunk_inds = y_apical.index[:num_apical].tolist() tuft_inds = y_apical.index[-num_tuft:].tolist() - basal_inds = cell.basal.show()["branch_index"].unique()[:num_basal].tolist() + basal_inds = jx_cell.basal.show()["branch_index"].unique()[:num_basal].tolist() - jaxley2neuron = jaxley2neuron_by_coords(cell, neuron_secs, loc=branch_loc, nseg=nseg) + jaxley2neuron = jaxley2neuron_by_coords(jx_cell, neuron_secs, comp_idx=comp_idx, loc=loc, nseg=nseg) neuron_trunk_inds = [jaxley2neuron[i] for i in trunk_inds] neuron_tuft_inds = [jaxley2neuron[i] for i in tuft_inds] @@ -70,12 +69,13 @@ def jaxley2neuron_by_group(cell, neuron_secs, branch_loc=0.05, nseg=8, num_apica jaxley_inds = {"trunk": trunk_inds, "tuft": tuft_inds, "basal": basal_inds} return neuron_inds, jaxley_inds -def match_stim_loc(jx_cell, neuron_sec, loc=0.05, nseg=8): - stim_coords = get_segment_xyzrL(neuron_sec, loc=loc, nseg=nseg)[:,:3] +def match_stim_loc(jx_cell, neuron_sec, comp_idx=None, loc=None, nseg=8): + stim_coords = get_segment_xyzrL(neuron_sec, comp_idx=comp_idx, loc=loc, nseg=nseg)[:3] stim_idx = ((jx_cell.nodes[["x", "y", "z"]]-stim_coords)**2).sum(axis=1).argmin() return stim_idx def import_neuron_morph(fname, nseg=8): + from neuron import h _ = h.load_file("stdlib.hoc") _ = h.load_file("import3d.hoc") nseg = 8 @@ -91,4 +91,4 @@ def import_neuron_morph(fname, nseg=8): for sec in h.allsec(): sec.nseg = nseg - return cell \ No newline at end of file + return h, cell \ No newline at end of file diff --git a/tests/test_graph.py b/tests/test_graph.py index 934c5c78..16cf84f9 100644 --- a/tests/test_graph.py +++ b/tests/test_graph.py @@ -8,11 +8,18 @@ import jaxley as jx from jaxley import connect +from jaxley.channels import HH from jaxley.channels.pospischil import K, Leak, Na from jaxley.io.graph import from_graph, make_jaxley_compatible, to_graph from jaxley.io.swc import swc_to_graph from jaxley.synapses import IonotropicSynapse, TestSynapse from jaxley.utils.misc_utils import recursive_compare +from tests.helpers import ( + get_segment_xyzrL, + import_neuron_morph, + jaxley2neuron_by_group, + match_stim_loc, +) def get_unique_trainables(indices_set_by_trainables, trainable_params): @@ -51,8 +58,30 @@ def compare_modules(m1, m2): m2_trainables = get_unique_trainables(m2_trainable_inds, m2_trainables) equal_trainables = np.all(m1_trainables == m2_trainables) - assert equal_trainables + m1_synapses = d1.pop("synapses") + m2_synapses = d2.pop("synapses") + for syn1, syn2 in zip(m1_synapses, m2_synapses): + assert recursive_compare(syn1.__dict__, syn2.__dict__) + + m1_channels = d1.pop("channels") + m2_channels = d2.pop("channels") + for ch1, ch2 in zip(m1_channels, m2_channels): + assert recursive_compare(ch1.__dict__, ch2.__dict__) + + # assumes only group inds matter for viewing, otherwise no comparison is possible + # since i.e. + # 1) cell.branch(0).add_to_group("soma"); cell.insert(Na()) + # 2) cell.insert(Na()); cell.branch(0).add_to_group("soma") + # will result in different group_nodes, while cell.nodes are the same + m1_groups = d1.pop("group_nodes") + m2_groups = d2.pop("group_nodes") + assert m1_groups.keys() == m2_groups.keys() + + for g in m1_groups: + assert np.all(m1_groups[g].index == m1_groups[g].index) + assert equal_edges + assert equal_trainables assert recursive_compare(d1, d2) @@ -119,40 +148,59 @@ def test_graph_import_export_cycle(): jx.integrate(re_module) -# def test_graph_swc_tracer(): -# nseg = 8 -# fname = os.path.join("../tests/swc_files/", "morph.swc") # n120 - -# graph = swc_to_graph(fname) -# graph = make_jaxley_compatible(graph, nseg=nseg, max_branch_len=2000, ignore_swc_trace_errors=False) -# cell = from_graph(graph, nseg=nseg, max_branch_len=2000) -# neuron_cell = import_neuron_morph(fname, nseg=nseg) - -# # remove root branch -# jaxley_comps = cell.nodes[cell.nodes["branch_index"] != 0].reset_index(drop=True) -# jaxley_comps["branch_index"] -= 1 - -# jx_branch_lens = jaxley_comps.groupby("branch_index")["length"].sum().to_numpy() - -# # match by branch lengths -# neuron_xyzd = [np.array(s.psection()["morphology"]["pts3d"]) for s in h.allsec()] -# neuron_branch_lens = np.array([np.sqrt((np.diff(n[:,:3], axis=0)**2).sum(axis=1)).sum() for n in neuron_xyzd]) -# neuron_inds = np.argsort(neuron_branch_lens) -# jx_inds = np.argsort(jx_branch_lens) - -# errors = pd.DataFrame(columns=["idx_NEURON", "idx_Jaxley", "dxyz", "dl", "dr"]) -# for k in range(len(neuron_inds)): -# neuron_comp_k = np.array([get_segment_xyzrL(list(h.allsec())[neuron_inds[k]], comp_idx=i) for i in range(nseg)]) -# jx_comp_k = jaxley_comps[jaxley_comps["branch_index"] == jx_inds[k]][["x", "y", "z", "radius", "length"]].to_numpy() -# dxyz = (((neuron_comp_k[:,:3] - jx_comp_k[:,:3])**2).sum(axis=1)**0.5).max() -# dl = abs(neuron_comp_k[:,4] - jx_comp_k[:,4]).max() -# dr = abs(neuron_comp_k[:,3] - jx_comp_k[:,3]).max() -# errors.loc[k] = [neuron_inds[k], jx_inds[k], dxyz, dl, dr] +def test_graph_swc_tracer(): + nseg = 8 + dirname = os.path.dirname(__file__) + fname = os.path.join(dirname, "swc_files/morph.swc") -# # allow one error, see https://github.com/jaxleyverse/jaxley/issues/140 -# assert len(errors['dxyz'][errors['dxyz'] > 0.001]) <= 1, "traced coords do not match." -# assert len(errors['dl'][errors['dl'] > 0.001]) <= 1, "traced lengths do not match." -# assert len(errors['dr'][errors['dr'] > 0.001]) <= 1, "traced radii do not match." + graph = swc_to_graph(fname) + cell = from_graph( + graph, nseg=nseg, max_branch_len=2000, ignore_swc_trace_errors=False + ) + cell._update_nodes_with_xyz() + h, neuron_cell = import_neuron_morph(fname, nseg=nseg) + + # remove root branch + jaxley_comps = cell.nodes[cell.nodes["branch_index"] != 0].reset_index(drop=True) + jaxley_comps["branch_index"] -= 1 + + jx_branch_lens = jaxley_comps.groupby("branch_index")["length"].sum().to_numpy() + + # match by branch lengths + neuron_xyzd = [np.array(s.psection()["morphology"]["pts3d"]) for s in h.allsec()] + neuron_branch_lens = np.array( + [ + np.sqrt((np.diff(n[:, :3], axis=0) ** 2).sum(axis=1)).sum() + for n in neuron_xyzd + ] + ) + neuron_inds = np.argsort(neuron_branch_lens) + jx_inds = np.argsort(jx_branch_lens) + + errors = pd.DataFrame(columns=["idx_NEURON", "idx_Jaxley", "dxyz", "dl", "dr"]) + for k in range(len(neuron_inds)): + neuron_comp_k = np.array( + [ + get_segment_xyzrL(list(h.allsec())[neuron_inds[k]], comp_idx=i) + for i in range(nseg) + ] + ) + jx_comp_k = jaxley_comps[jaxley_comps["branch_index"] == jx_inds[k]][ + ["x", "y", "z", "radius", "length"] + ].to_numpy() + dxyz = ( + ((neuron_comp_k[:, :3] - jx_comp_k[:, :3]) ** 2).sum(axis=1) ** 0.5 + ).max() + dl = abs(neuron_comp_k[:, 4] - jx_comp_k[:, 4]).max() + dr = abs(neuron_comp_k[:, 3] - jx_comp_k[:, 3]).max() + errors.loc[k] = [neuron_inds[k], jx_inds[k], dxyz, dl, dr] + + # allow one error, see https://github.com/jaxleyverse/jaxley/issues/140 + assert ( + len(errors["dxyz"][errors["dxyz"] > 0.001]) <= 1 + ), "traced coords do not match." + assert len(errors["dl"][errors["dl"] > 0.001]) <= 1, "traced lengths do not match." + assert len(errors["dr"][errors["dr"] > 0.001]) <= 1, "traced radii do not match." def test_graph_to_jaxley(): @@ -186,3 +234,128 @@ def test_graph_to_jaxley(): module_imported_after_preprocessing = from_graph(graph) compare_modules(module_imported_directly, module_imported_after_preprocessing) + + +def test_swc2graph_voltages(): + """Check if voltages of SWC recording match. + + To match the branch indices between NEURON and jaxley, we rely on comparing the + length of the branches. + + It tests whether, on average over time and recordings, the voltage is off by less + than 1.5 mV. + """ + dirname = os.path.dirname(__file__) + fname = os.path.join(dirname, "swc_files/morph.swc") + + nseg = 8 + + i_delay = 2.0 + i_dur = 5.0 + i_amp = 0.25 + t_max = 20.0 + dt = 0.025 + + ##################### NEURON ################## + h, neuron_cell = import_neuron_morph(fname, nseg=nseg) + + ####################### jaxley ################## + graph = swc_to_graph(fname) + jx_cell = from_graph( + graph, nseg=nseg, max_branch_len=2000, ignore_swc_trace_errors=False + ) + jx_cell._update_nodes_with_xyz() + jx_cell.insert(HH()) + + branch_loc = 0.05 + neuron_inds, jaxley_inds = jaxley2neuron_by_group( + jx_cell, h.allsec(), loc=branch_loc + ) + trunk_inds, tuft_inds, basal_inds = [ + jaxley_inds[key] for key in ["trunk", "tuft", "basal"] + ] + neuron_trunk_inds, neuron_tuft_inds, neuron_basal_inds = [ + neuron_inds[key] for key in ["trunk", "tuft", "basal"] + ] + + stim_loc = 0.1 + stim_idx = match_stim_loc(jx_cell, h.soma[0], loc=stim_loc) + + jx_cell.set("axial_resistivity", 1_000.0) + jx_cell.set("v", -62.0) + jx_cell.set("HH_m", 0.074901) + jx_cell.set("HH_h", 0.4889) + jx_cell.set("HH_n", 0.3644787) + + jx_cell.branch.comp(stim_idx).stimulate( + jx.step_current(i_delay, i_dur, i_amp, dt, t_max) + ) + for i in trunk_inds + tuft_inds + basal_inds: + jx_cell.branch(i).loc(branch_loc).record() + + voltages_jaxley = jx.integrate(jx_cell, delta_t=dt) + + ################### NEURON ################# + stim = h.IClamp(h.soma[0](stim_loc)) + stim.delay = i_delay + stim.dur = i_dur + stim.amp = i_amp + + counter = 0 + voltage_recs = {} + + for r in neuron_trunk_inds: + for i, sec in enumerate(h.allsec()): + if i == r: + v = h.Vector() + v.record(sec(branch_loc)._ref_v) + voltage_recs[f"v{counter}"] = v + counter += 1 + + for r in neuron_tuft_inds: + for i, sec in enumerate(h.allsec()): + if i == r: + v = h.Vector() + v.record(sec(branch_loc)._ref_v) + voltage_recs[f"v{counter}"] = v + counter += 1 + + for r in neuron_basal_inds: + for i, sec in enumerate(h.allsec()): + if i == r: + v = h.Vector() + v.record(sec(branch_loc)._ref_v) + voltage_recs[f"v{counter}"] = v + counter += 1 + + for sec in h.allsec(): + sec.insert("hh") + sec.Ra = 1_000.0 + + sec.gnabar_hh = 0.120 # S/cm2 + sec.gkbar_hh = 0.036 # S/cm2 + sec.gl_hh = 0.0003 # S/cm2 + sec.ena = 50 # mV + sec.ek = -77.0 # mV + sec.el_hh = -54.3 # mV + + h.dt = dt + tstop = t_max + v_init = -62.0 + + def initialize(): + h.finitialize(v_init) + h.fcurrent() + + def integrate(): + while h.t < tstop: + h.fadvance() + + initialize() + integrate() + voltages_neuron = np.asarray([voltage_recs[key] for key in voltage_recs]) + + ####################### check ################ + errors = np.mean(np.abs(voltages_jaxley - voltages_neuron), axis=1) + + assert all(errors < 1.5), "voltages do not match." diff --git a/tutorials/graphIO.ipynb b/tutorials/graphIO.ipynb deleted file mode 100644 index 1c251397..00000000 --- a/tutorials/graphIO.ipynb +++ /dev/null @@ -1,764 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "The autoreload extension is already loaded. To reload it, use:\n", - " %reload_ext autoreload\n" - ] - } - ], - "source": [ - "%load_ext autoreload\n", - "%autoreload 2" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "from jax import config\n", - "config.update(\"jax_enable_x64\", True)\n", - "config.update(\"jax_platform_name\", \"cpu\")\n", - "\n", - "import os\n", - "os.environ[\"XLA_PYTHON_CLIENT_MEM_FRACTION\"]=\".8\"" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [], - "source": [ - "import matplotlib.pyplot as plt\n", - "import numpy as np\n", - "import jax.numpy as jnp\n", - "from jax import jit, vmap, value_and_grad\n", - "\n", - "import jaxley as jx\n", - "\n", - "import networkx as nx\n", - "import pandas as pd\n", - "import jax\n", - "from jax import vmap, jit\n", - "\n", - "from jaxley.io.graph import to_graph, from_graph, make_jaxley_compatible\n", - "from jaxley.io.swc import swc_to_graph, swc_to_jaxley, read_swc\n", - "from jaxley.io.swc import swc_to_graph\n", - "from jaxley.io.graph import trace_branches, branch_e2n, branch_n2e, build_module_scaffold, make_jaxley_compatible\n", - "\n", - "from neuron import h\n", - "from jaxley.channels import HH\n", - "import os" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [], - "source": [ - "from neuron import h\n", - "\n", - "def get_segment_xyzrL(section, comp_idx=None, loc=None, nseg=8):\n", - " assert comp_idx is not None or loc is not None, \"Either comp_idx or loc must be provided.\"\n", - " assert not (comp_idx is not None and loc is not None), \"Only one of comp_idx or loc can be provided.\"\n", - "\n", - " comp_len = 1/nseg\n", - " loc = comp_len/2 + comp_idx*comp_len if loc is None else loc\n", - "\n", - " n3d = section.n3d()\n", - " x3d = np.array([section.x3d(i) for i in range(n3d)])\n", - " y3d = np.array([section.y3d(i) for i in range(n3d)])\n", - " z3d = np.array([section.z3d(i) for i in range(n3d)])\n", - " L = np.array([section.arc3d(i) for i in range(n3d)]) # Cumulative arc lengths\n", - " r3d = np.array([section.diam3d(i)/2 for i in range(n3d)])\n", - " if loc is None:\n", - " return x3d, y3d, z3d, r3d\n", - " else:\n", - " total_length = L[-1]\n", - " target_length = loc * total_length\n", - "\n", - " # Find segment containing target_length\n", - " for i in range(1, n3d):\n", - " if L[i] >= target_length:\n", - " break\n", - " else:\n", - " i = n3d - 1\n", - "\n", - " # Interpolate between points i-1 and i\n", - " L0, L1 = L[i-1], L[i]\n", - " t = (target_length - L0) / (L1 - L0)\n", - " x = x3d[i-1] + t * (x3d[i] - x3d[i-1])\n", - " y = y3d[i-1] + t * (y3d[i] - y3d[i-1])\n", - " z = z3d[i-1] + t * (z3d[i] - z3d[i-1])\n", - " r = r3d[i-1] + t * (r3d[i] - r3d[i-1])\n", - " return x, y, z, r, L[-1]/nseg\n", - "\n", - "\n", - "def jaxley2neuron_by_coords(cell, branch_loc=0.05, nseg=8):\n", - " neuron_coords = {i: np.vstack(get_segment_xyzrL(sec, branch_loc, nseg=nseg))[:,:3].T for i, sec in enumerate(h.allsec())}\n", - " neuron_coords = np.vstack([np.hstack([k*np.ones((v.shape[0], 1)), v]) for k,v in neuron_coords.items()])\n", - " neuron_coords = pd.DataFrame(neuron_coords, columns=[\"branch_index\", \"x\", \"y\", \"z\"])\n", - " neuron_coords[\"branch_index\"] = neuron_coords[\"branch_index\"].astype(int)\n", - "\n", - " neuron_loc_xyz = neuron_coords.groupby(\"branch_index\").mean()\n", - " jaxley_loc_xyz = cell.branch(\"all\").loc(branch_loc).show().set_index(\"branch_index\")[[\"x\", \"y\", \"z\"]]\n", - "\n", - " jaxley2neuron_inds = {}\n", - " for i,xyz in enumerate(jaxley_loc_xyz.to_numpy()):\n", - " d = np.sqrt(((neuron_loc_xyz - xyz)**2)).sum(axis=1)\n", - " jaxley2neuron_inds[i] = d.argmin()\n", - " return jaxley2neuron_inds\n", - "\n", - "\n", - "def jaxley2neuron_by_group(cell, branch_loc=0.05, nseg=8, num_apical=20, num_tuft=20, num_basal=10):\n", - " y_apical = cell.apical.show().groupby(\"branch_index\").mean()[\"y\"].abs().sort_values()\n", - " trunk_inds = y_apical.index[:num_apical].tolist()\n", - " tuft_inds = y_apical.index[-num_tuft:].tolist()\n", - " basal_inds = cell.basal.show()[\"branch_index\"].unique()[:num_basal].tolist()\n", - "\n", - " jaxley2neuron = jaxley2neuron_by_coords(cell, loc=branch_loc, nseg=nseg)\n", - "\n", - " neuron_trunk_inds = [jaxley2neuron[i] for i in trunk_inds]\n", - " neuron_tuft_inds = [jaxley2neuron[i] for i in tuft_inds]\n", - " neuron_basal_inds = [jaxley2neuron[i] for i in basal_inds]\n", - "\n", - " neuron_inds = {\"trunk\": neuron_trunk_inds, \"tuft\": neuron_tuft_inds, \"basal\": neuron_basal_inds}\n", - " jaxley_inds = {\"trunk\": trunk_inds, \"tuft\": tuft_inds, \"basal\": basal_inds}\n", - " return neuron_inds, jaxley_inds\n", - "\n", - "def match_stim_loc(jx_cell, neuron_sec, loc=0.05, nseg=8):\n", - " stim_coords = get_segment_xyzrL(neuron_sec, loc=loc, nseg=nseg)[:,:3]\n", - " stim_idx = ((jx_cell.nodes[[\"x\", \"y\", \"z\"]]-stim_coords)**2).sum(axis=1).argmin()\n", - " return stim_idx\n", - "\n", - "def import_neuron_morph(fname, nseg=8):\n", - " _ = h.load_file(\"stdlib.hoc\")\n", - " _ = h.load_file(\"import3d.hoc\")\n", - " nseg = 8\n", - "\n", - " ##################### NEURON ##################\n", - " for sec in h.allsec():\n", - " h.delete_section(sec=sec)\n", - "\n", - " cell = h.Import3d_SWC_read()\n", - " cell.input(fname)\n", - " i3d = h.Import3d_GUI(cell, False)\n", - " i3d.instantiate(None)\n", - "\n", - " for sec in h.allsec():\n", - " sec.nseg = nseg\n", - " return cell\n", - "\n", - "_ = h.load_file(\"stdlib.hoc\")\n", - "_ = h.load_file(\"import3d.hoc\")\n", - "\n", - "def test_swc_voltages(jx_cell):\n", - " \"\"\"Check if voltages of SWC recording match.\n", - "\n", - " To match the branch indices between NEURON and jaxley, we rely on comparing the\n", - " length of the branches.\n", - "\n", - " It tests whether, on average over time and recordings, the voltage is off by less\n", - " than 1.5 mV.\n", - " \"\"\"\n", - " fname = os.path.join(\"../tests/swc_files/\", \"morph.swc\") # n120\n", - "\n", - " i_delay = 2.0\n", - " i_dur = 5.0\n", - " i_amp = 0.25\n", - " t_max = 20.0\n", - " dt = 0.025\n", - "\n", - " nseg_per_branch = 8\n", - "\n", - " ##################### NEURON ##################\n", - " for sec in h.allsec():\n", - " h.delete_section(sec=sec)\n", - "\n", - " cell = h.Import3d_SWC_read()\n", - " cell.input(fname)\n", - " i3d = h.Import3d_GUI(cell, False)\n", - " i3d.instantiate(None)\n", - "\n", - " for sec in h.allsec():\n", - " sec.nseg = nseg_per_branch\n", - "\n", - " ####################### jaxley ##################\n", - " jx_cell.insert(HH())\n", - "\n", - " branch_loc = 0.05\n", - " neuron_inds, jaxley_inds = jaxley2neuron_by_group(jx_cell, loc=branch_loc)\n", - " trunk_inds, tuft_inds, basal_inds = [jaxley_inds[key] for key in [\"trunk\", \"tuft\", \"basal\", \"stim\"]]\n", - " neuron_trunk_inds, neuron_tuft_inds, neuron_basal_inds = [neuron_inds[key] for key in [\"trunk\", \"tuft\", \"basal\"]]\n", - " \n", - " stim_loc = 0.1\n", - " stim_idx = match_stim_loc(jx_cell, h.soma[0], loc=stim_loc)\n", - "\n", - " jx_cell.set(\"axial_resistivity\", 1_000.0)\n", - " jx_cell.set(\"v\", -62.0)\n", - " jx_cell.set(\"HH_m\", 0.074901)\n", - " jx_cell.set(\"HH_h\", 0.4889)\n", - " jx_cell.set(\"HH_n\", 0.3644787)\n", - "\n", - " jx_cell.branch.comp(stim_idx).stimulate(\n", - " jx.step_current(i_delay, i_dur, i_amp, dt, t_max)\n", - " )\n", - " for i in trunk_inds + tuft_inds + basal_inds:\n", - " jx_cell.branch(i).loc(branch_loc).record()\n", - "\n", - " voltages_jaxley = jx.integrate(jx_cell, delta_t=dt)\n", - "\n", - " ################### NEURON #################\n", - " stim = h.IClamp(h.soma[0](stim_loc))\n", - " stim.delay = i_delay\n", - " stim.dur = i_dur\n", - " stim.amp = i_amp\n", - "\n", - " counter = 0\n", - " voltage_recs = {}\n", - "\n", - " for r in neuron_trunk_inds:\n", - " for i, sec in enumerate(h.allsec()):\n", - " if i == r:\n", - " v = h.Vector()\n", - " v.record(sec(branch_loc)._ref_v)\n", - " voltage_recs[f\"v{counter}\"] = v\n", - " counter += 1\n", - "\n", - " for r in neuron_tuft_inds:\n", - " for i, sec in enumerate(h.allsec()):\n", - " if i == r:\n", - " v = h.Vector()\n", - " v.record(sec(branch_loc)._ref_v)\n", - " voltage_recs[f\"v{counter}\"] = v\n", - " counter += 1\n", - "\n", - " for r in neuron_basal_inds:\n", - " for i, sec in enumerate(h.allsec()):\n", - " if i == r:\n", - " v = h.Vector()\n", - " v.record(sec(branch_loc)._ref_v)\n", - " voltage_recs[f\"v{counter}\"] = v\n", - " counter += 1\n", - "\n", - " for sec in h.allsec():\n", - " sec.insert(\"hh\")\n", - " sec.Ra = 1_000.0\n", - "\n", - " sec.gnabar_hh = 0.120 # S/cm2\n", - " sec.gkbar_hh = 0.036 # S/cm2\n", - " sec.gl_hh = 0.0003 # S/cm2\n", - " sec.ena = 50 # mV\n", - " sec.ek = -77.0 # mV\n", - " sec.el_hh = -54.3 # mV\n", - "\n", - " h.dt = dt\n", - " tstop = t_max\n", - " v_init = -62.0\n", - "\n", - " def initialize():\n", - " h.finitialize(v_init)\n", - " h.fcurrent()\n", - "\n", - " def integrate():\n", - " while h.t < tstop:\n", - " h.fadvance()\n", - "\n", - " initialize()\n", - " integrate()\n", - " voltages_neuron = np.asarray([voltage_recs[key] for key in voltage_recs])\n", - "\n", - " ####################### check ################\n", - " errors = np.mean(np.abs(voltages_jaxley - voltages_neuron), axis=1)\n", - "\n", - " assert all(errors < 1.5), \"voltages do not match.\"\n", - " return voltages_jaxley, voltages_neuron" - ] - }, - { - "cell_type": "code", - "execution_count": 128, - "metadata": {}, - "outputs": [], - "source": [ - "def test_graph_swc_tracer():\n", - " nseg = 8\n", - " fname = os.path.join(\"../tests/swc_files/\", \"morph.swc\") # n120\n", - " \n", - " graph = swc_to_graph(fname)\n", - " graph = make_jaxley_compatible(graph, nseg=nseg, max_branch_len=2000, ignore_swc_trace_errors=False)\n", - " cell = from_graph(graph, nseg=nseg, max_branch_len=2000)\n", - " neuron_cell = import_neuron_morph(fname, nseg=nseg)\n", - " \n", - " # remove root branch\n", - " jaxley_comps = cell.nodes[cell.nodes[\"branch_index\"] != 0].reset_index(drop=True)\n", - " jaxley_comps[\"branch_index\"] -= 1\n", - "\n", - " jx_branch_lens = jaxley_comps.groupby(\"branch_index\")[\"length\"].sum().to_numpy()\n", - "\n", - " # match by branch lengths\n", - " neuron_xyzd = [np.array(s.psection()[\"morphology\"][\"pts3d\"]) for s in h.allsec()]\n", - " neuron_branch_lens = np.array([np.sqrt((np.diff(n[:,:3], axis=0)**2).sum(axis=1)).sum() for n in neuron_xyzd])\n", - " neuron_inds = np.argsort(neuron_branch_lens)\n", - " jx_inds = np.argsort(jx_branch_lens)\n", - "\n", - " errors = pd.DataFrame(columns=[\"idx_NEURON\", \"idx_Jaxley\", \"dxyz\", \"dl\", \"dr\"])\n", - " for k in range(len(neuron_inds)):\n", - " neuron_comp_k = np.array([get_segment_xyzrL(list(h.allsec())[neuron_inds[k]], comp_idx=i) for i in range(nseg)])\n", - " jx_comp_k = jaxley_comps[jaxley_comps[\"branch_index\"] == jx_inds[k]][[\"x\", \"y\", \"z\", \"radius\", \"length\"]].to_numpy()\n", - " dxyz = (((neuron_comp_k[:,:3] - jx_comp_k[:,:3])**2).sum(axis=1)**0.5).max()\n", - " dl = abs(neuron_comp_k[:,4] - jx_comp_k[:,4]).max()\n", - " dr = abs(neuron_comp_k[:,3] - jx_comp_k[:,3]).max()\n", - " errors.loc[k] = [neuron_inds[k], jx_inds[k], dxyz, dl, dr]\n", - " error_exceeds_thresh = errors[['dxyz', 'dl', 'dr']] > 0.001\n", - "\n", - " # allow one error, see https://github.com/jaxleyverse/jaxley/issues/140\n", - " assert len(errors['dxyz'][error_exceeds_thresh['dxyz']]) <= 1, \"SWC tracers do not match.\"\n", - "\n", - "test_graph_swc_tracer()" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/tmp/ipykernel_1519238/1312587570.py:35: DeprecationWarning: DataFrameGroupBy.apply operated on the grouping columns. This behavior is deprecated, and in a future version of pandas the grouping columns will be excluded from the operation. Either pass `include_groups=False` to exclude the groupings or explicitly select the grouping columns after groupby to silence this warning.\n", - " jx_xyzrl = jaxley_comps.groupby(\"branch_index\").apply(lambda x: x.iloc[comp_idx])[[\"x\", \"y\", \"z\", \"radius\", \"length\"]].to_numpy()\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from jaxley.io.graph import add_edge_lens, split_branches, find_swc_trace_errors, simulate_swc_trace_errors, soma_idxs, branch_e2n, v_interp\n", - "\n", - "nseg = 8\n", - "fname = os.path.join(\"../tests/swc_files/\", \"morph.swc\") # n120\n", - "graph = swc_to_graph(fname)\n", - "graph = make_jaxley_compatible(graph, nseg=nseg, max_branch_len=2000, ignore_swc_trace_errors=False)\n", - "cell = from_graph(graph, nseg=nseg, max_branch_len=2000)\n", - "\n", - "# graph = add_edge_lens(graph) # add edge lengths to graph just in case\n", - "# branches = trace_branches(graph, source_node=source_node)\n", - "\n", - "# breaks = find_swc_trace_errors(graph)\n", - "# branches = simulate_swc_trace_errors(branches, breaks)\n", - "\n", - "comp_idx = 2\n", - "comp_len = 1/nseg\n", - "branch_loc = comp_len/2 + comp_idx*comp_len\n", - "\n", - "jaxley_comps = cell.nodes[cell.nodes[\"branch_index\"] != 0].reset_index(drop=True)\n", - "jaxley_comps[\"branch_index\"] -= 1\n", - "jx_branch_lens = jaxley_comps.groupby(\"branch_index\")[\"length\"].sum().to_numpy()\n", - "\n", - "neuron_cell = import_neuron_morph(fname)\n", - "neuron_xyzd = [np.array(s.psection()[\"morphology\"][\"pts3d\"]) for s in h.allsec()]\n", - "neuron_branch_lens = np.array([np.sqrt((np.diff(n[:,:3], axis=0)**2).sum(axis=1)).sum() for n in neuron_xyzd])\n", - "\n", - "neuron_inds = np.argsort(neuron_branch_lens)\n", - "jx_inds = np.argsort(jx_branch_lens)\n", - "wo_error = np.where(abs(neuron_branch_lens[neuron_inds] - jx_branch_lens[jx_inds]) < 1)[0]\n", - "neuron_inds = neuron_inds[wo_error]\n", - "jx_inds = jx_inds[wo_error]\n", - "\n", - "neuron_xyzrl = np.array([get_segment_xyzrL(s, loc=branch_loc, nseg=nseg) for s in h.allsec()])\n", - "jx_xyzrl = jaxley_comps.groupby(\"branch_index\").apply(lambda x: x.iloc[comp_idx])[[\"x\", \"y\", \"z\", \"radius\", \"length\"]].to_numpy()\n", - "\n", - "fname = os.path.join(\"../tests/swc_files/\", \"morph.swc\") # n120\n", - "\n", - "fig, ax = plt.subplots(4, 2, figsize=(10, 10), layout=\"constrained\")\n", - "\n", - "ax[0,0].plot(neuron_branch_lens[neuron_inds], label=\"neuron\")\n", - "ax[0,0].plot(jx_branch_lens[jx_inds], label=\"graph\")\n", - "ax[0,1].plot(abs(neuron_branch_lens[neuron_inds] - jx_branch_lens[jx_inds]), label=\"diff\")\n", - "ax[0,0].set_title(\"sorted branch lengths\")\n", - "ax[0,0].legend()\n", - "\n", - "k = 4\n", - "ax[1,0].plot(neuron_xyzrl[neuron_inds][:,k], label=\"neuron\")\n", - "ax[1,0].plot(jx_xyzrl[jx_inds][:,k], label=\"graph\")\n", - "ax[1,1].plot(abs(neuron_xyzrl[neuron_inds][:,k] - jx_xyzrl[jx_inds][:,k]), label=\"diff\")\n", - "ax[1,0].set_title(\"sorted comp lengths\")\n", - "ax[1,0].legend()\n", - "\n", - "k = 3\n", - "ax[2,0].plot(neuron_xyzrl[neuron_inds][:,k], label=\"neuron\")\n", - "ax[2,0].plot(jx_xyzrl[jx_inds][:,k], label=\"graph\")\n", - "ax[2,1].plot(abs(neuron_xyzrl[neuron_inds][:,k] - jx_xyzrl[jx_inds][:,k]), label=\"diff\")\n", - "ax[2,0].set_title(\"sorted comp radii\")\n", - "ax[2,0].legend()\n", - "\n", - "ax[3,0].scatter(neuron_xyzrl[neuron_inds][:,0], neuron_xyzrl[neuron_inds][:,1], alpha=0.5, s=2, label=\"neuron\")\n", - "ax[3,0].scatter(jx_xyzrl[jx_inds][:,0], jx_xyzrl[jx_inds][:,1], alpha=0.5, s=2, label=\"graph\")\n", - "dx = ((neuron_xyzrl[neuron_inds][:,:3] - jx_xyzrl[jx_inds][:,:3])**2).sum(axis=1)**0.5\n", - "ax[3,1].hist(dx, label=\"diff\")\n", - "ax[3,0].set_title(\"xy-locations\")\n", - "ax[3,0].legend()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 727, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "compartment 0: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 1: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 2: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 3: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 4: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 5: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 6: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 7: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 8: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 9: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 10: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 11: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 12: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 13: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 14: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 15: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 16: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 17: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 18: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 19: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 20: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 21: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 22: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 23: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 24: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 25: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 26: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 27: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 28: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 29: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 30: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 31: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 32: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 33: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 34: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 35: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 36: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 37: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 38: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 39: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 40: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 41: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 42: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 43: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 44: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 45: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 46: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 47: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 48: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 49: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 50: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 51: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 52: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 53: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 54: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 55: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 56: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 57: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 58: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 59: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 60: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 61: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 62: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 63: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 64: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 65: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 66: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 67: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 68: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 69: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 70: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 71: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 72: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 73: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 74: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 75: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 76: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 77: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 78: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 79: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 80: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 81: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 82: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 83: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 84: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 85: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 86: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 87: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 88: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 89: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 90: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 91: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 92: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 93: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 94: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 95: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 96: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 97: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 98: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 99: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 100: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 101: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 102: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 103: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 104: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 105: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 106: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 107: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 108: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 109: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 110: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 111: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 112: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 113: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 114: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 115: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 116: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 117: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 118: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 119: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 120: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 121: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 122: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 123: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 124: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 125: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 126: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 127: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 128: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 129: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 130: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 131: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 132: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 133: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 134: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 135: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 136: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 137: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 138: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 139: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 140: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 141: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 142: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 143: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 144: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 145: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 146: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 147: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 148: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 149: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 150: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 151: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 152: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 153: dx = 0.00, dl = 0.00, dr = 0.00\n", - "compartment 154: dx = 0.00, dl = 0.00, dr = 0.00\n" - ] - } - ], - "source": [ - "for k in range(len(neuron_inds)):\n", - " neuron_comp_k = np.array([get_segment_xyzrL(list(h.allsec())[neuron_inds[k]], (1/nseg)/2 + i/nseg) for i in range(nseg)])\n", - " jx_comp_k = jaxley_comps[jaxley_comps[\"branch_index\"] == jx_inds[k]][[\"x\", \"y\", \"z\", \"radius\", \"length\"]].to_numpy()\n", - " dx = (((neuron_comp_k[:,:3] - jx_comp_k[:,:3])**2).sum(axis=1)**0.5).mean()\n", - " dl = abs(neuron_comp_k[:,4] - jx_comp_k[:,4]).mean()\n", - " dr = abs(neuron_comp_k[:,3] - jx_comp_k[:,3]).mean()\n", - " print(f\"compartment {k}: dx = {dx:.2f}, dl = {dl:.2f}, dr = {dr:.2f}\")" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [], - "source": [ - "fname = os.path.join(\"../tests/swc_files/\", \"morph.swc\") # n120\n", - "graph = swc_to_graph(fname)\n", - "nx_cell = from_graph(graph, nseg=8, max_branch_len=2000.0)" - ] - }, - { - "cell_type": "code", - "execution_count": 630, - "metadata": {}, - "outputs": [], - "source": [ - "fname = os.path.join(\"../tests/swc_files/\", \"morph.swc\") # n120\n", - "\n", - "graph = swc_to_graph(fname)\n", - "graph = make_jaxley_compatible_v2(graph, max_branch_len=2000.0, nseg=8, source_node=0)\n", - "nx_cell = from_graph(graph, nseg=8, max_branch_len=2000.0)\n", - "# nx_cell.compute_xyz(); nx_cell._update_nodes_with_xyz() #-> changes xyzs and makes less similar to NEURON and more similar to current jaxley!\n", - "\n", - "# swc_cell = jx.read_swc(fname, 8, max_branch_len=2000.0, assign_groups=True)\n", - "# swc_cell._update_nodes_with_xyz()\n", - "\n", - "neuron_cell = import_neuron_morph(fname)" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Added 1 external_states. See `.externals` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n", - "Added 1 recordings. See `.recordings` for details.\n" - ] - } - ], - "source": [ - "# graph = swc_to_graph(fname)\n", - "# cell_v1 = from_graph(graph, nseg=8, max_branch_len=2000.0)\n", - "\n", - "graph = swc_to_graph(fname)\n", - "graph = make_jaxley_compatible_v2(graph, max_branch_len=2000)\n", - "cell_v2 = from_graph(graph, nseg=8, max_branch_len=2000)\n", - "\n", - "# cell_swc = read_swc(fname, 8, max_branch_len=2000.0, assign_groups=True)\n", - "# cell_swc._update_nodes_with_xyz()\n", - "\n", - "\n", - "# v_swc, v_swc_neuron = test_swc_voltages(cell_swc)\n", - "v_nx, v_nx_neuron = test_swc_voltages(cell_v2)" - ] - }, - { - "cell_type": "code", - "execution_count": 636, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "MSEs between networkX and NEURON voltages [1.04713083 1.05762205 1.12190617 1.12256981 1.10002585 1.11516644\n", - " 1.14133652 1.06901444 1.07062674 1.23506127 1.2488945 1.05729204\n", - " 1.31578322 1.10680595 0.84590106 1.02711285 0.96237384 1.0017698\n", - " 0.82199011 0.76980736 0.826342 0.86485781 0.80588585 0.97928768\n", - " 0.77268776 0.96853645 0.77838237]\n", - "MSEs between jaxley_swc_reader and NEURON voltages [0.99074595 0.99798788 1.06303194 1.06644151 1.04075219 1.08479116\n", - " 1.08351713 0.949176 1.20691056 1.17982389 1.19336607 1.00193021\n", - " 1.06711586 1.05206764 0.63350792 0.96918593 0.90271575 0.9424342\n", - " 0.76555555 0.71062625 0.77389985 0.81035832 0.75040486 0.92461516\n", - " 0.72069685 0.91403832 0.7240964 ]\n" - ] - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "print(\"MSEs between networkX and NEURON voltages\", np.mean(np.abs(v_nx - v_nx_neuron), axis=1)) \n", - "# print(\"MSEs between jaxley_swc_reader and NEURON voltages\", np.mean(np.abs(v_swc - v_swc_neuron), axis=1)) \n", - "\n", - "# plot the different voltages\n", - "fig, ax = plt.subplots(2, 2, figsize=(10, 5), sharex=True, sharey=True, layout=\"constrained\")\n", - "ax[0,0].plot(v_nx.T)\n", - "ax[0,1].plot(v_nx_neuron.T)\n", - "# ax[1,0].plot(v_swc.T)\n", - "# ax[1,1].plot(v_swc_neuron.T)\n", - "\n", - "\n", - "ax[0,0].set_title(\"networkX\")\n", - "ax[0,1].set_title(\"NEURON\")\n", - "ax[0,0].set_ylabel(\"voltage (mV)\")\n", - "ax[1,0].set_ylabel(\"voltage (mV)\")\n", - "ax[1,1].set_xlabel(\"time (ms)\")\n", - "ax[1,0].set_xlabel(\"time (ms)\")\n", - "\n", - "plt.show()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "jaxley", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.12.1" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -}