From 26432b5c3e7510b05b5f5f4b7a295881dcbba508 Mon Sep 17 00:00:00 2001 From: jnsbck-uni Date: Thu, 15 Aug 2024 11:58:41 +0200 Subject: [PATCH] wip: save wip. --- jaxley/io/graph.py | 2 +- tutorials/graphIO.ipynb | 646 +++++++++++++++++++++++++++++++++++++--- 2 files changed, 611 insertions(+), 37 deletions(-) diff --git a/jaxley/io/graph.py b/jaxley/io/graph.py index 3e0d6fbfb..849ef7dab 100644 --- a/jaxley/io/graph.py +++ b/jaxley/io/graph.py @@ -180,7 +180,7 @@ def to_graph(module: jx.Module) -> nx.DiGraph: is_leaf = lambda graph, n: graph.out_degree(n) == 0 and graph.in_degree(n) == 1 is_branching = lambda graph, n: graph.out_degree(n) > 1 has_same_id = lambda graph, i, j: graph.nodes[i]["id"] == graph.nodes[j]["id"] -path_e2n = lambda path: [path[0][0]] + [e[1] for e in path] +path_e2n = lambda path: [path[0][0]] + [e[1] for e in path] if path.shape[0] > 1 else [path[0,0], path[0,1]] path_n2e = lambda path: [e for e in zip(path[:-1], path[1:])] unpack = lambda d, keys: [d[k] for k in keys] has_node_attr = lambda graph, attr: all(attr in graph.nodes[n] for n in graph.nodes) diff --git a/tutorials/graphIO.ipynb b/tutorials/graphIO.ipynb index 7c99bcb65..7c403a5dc 100644 --- a/tutorials/graphIO.ipynb +++ b/tutorials/graphIO.ipynb @@ -26,7 +26,7 @@ }, { "cell_type": "code", - "execution_count": 65, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -53,7 +53,7 @@ }, { "cell_type": "code", - "execution_count": 231, + "execution_count": 2480, "metadata": {}, "outputs": [], "source": [ @@ -142,7 +142,7 @@ "_ = h.load_file(\"stdlib.hoc\")\n", "_ = h.load_file(\"import3d.hoc\")\n", "\n", - "def test_swc_voltages(use_graph=False):\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", @@ -174,34 +174,27 @@ " sec.nseg = nseg_per_branch\n", "\n", " ####################### jaxley ##################\n", - " if use_graph:\n", - " graph = swc_to_graph(fname)\n", - " # graph = make_jaxley_compatible(graph, max_branch_len=2000.0, nseg=8, source_node=\"leaf\")\n", - " cell = from_graph(graph, nseg=8, max_branch_len=2000.0)\n", - " else:\n", - " cell = jx.read_swc(fname, 8, max_branch_len=2000.0, assign_groups=True)\n", - " cell._update_nodes_with_xyz()\n", - "\n", - " cell.insert(HH())\n", + " jx_cell.insert(HH())\n", "\n", - " branch_loc = 0.05 \n", - " neuron_inds, jaxley_inds = match_branch_inds_by_type(cell, branch_loc)\n", + " comp_len = 1/nseg_per_branch\n", + " branch_loc = comp_len/2 + 0*comp_len\n", + " neuron_inds, jaxley_inds = match_branch_inds_by_type(jx_cell, branch_loc)\n", " trunk_inds, tuft_inds, basal_inds, stim_idx = [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", - " cell.set(\"axial_resistivity\", 1_000.0)\n", - " cell.set(\"v\", -62.0)\n", - " cell.set(\"HH_m\", 0.074901)\n", - " cell.set(\"HH_h\", 0.4889)\n", - " cell.set(\"HH_n\", 0.3644787)\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", - " cell.branch.comp(stim_idx).stimulate(\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", - " cell.branch(i).loc(branch_loc).record()\n", + " jx_cell.branch(i).loc(branch_loc).record()\n", "\n", - " voltages_jaxley = jx.integrate(cell, delta_t=dt)\n", + " voltages_jaxley = jx.integrate(jx_cell, delta_t=dt)\n", "\n", " ################### NEURON #################\n", " stim = h.IClamp(h.soma[0](0.1))\n", @@ -272,7 +265,542 @@ }, { "cell_type": "code", - "execution_count": 227, + "execution_count": 3738, + "metadata": {}, + "outputs": [], + "source": [ + "fname = os.path.join(\"../tests/\", \"morph.swc\") # n120\n", + "\n", + "graph = swc_to_graph(fname)\n", + "\n", + "unpack = lambda d, keys: [d[k] for k in keys]\n", + "path_e2n = lambda path: [path[0][0]] + [e[1] for e in path] if path.shape[0] > 1 else [path[0,0], path[0,1]]\n", + "v_interp = vmap(jnp.interp, in_axes=(None, None, 1))\n", + "\n", + "is_leaf = lambda graph, n: graph.out_degree(n) == 0 and graph.in_degree(n) == 1\n", + "is_branching = lambda graph, n: graph.out_degree(n) > 1\n", + "has_same_id = lambda graph, i, j: graph.nodes[i][\"id\"] == graph.nodes[j][\"id\"]\n", + "\n", + "def get_paths(graph, source_node = 0):\n", + " \"\"\"Get all linear paths in a graph.\n", + "\n", + " The graph is traversed depth-first starting from the root node.\n", + "\n", + " Args:\n", + " graph: A networkx graph.\n", + " source_node: node at which to start graph traversal. If \"leaf\", the traversal\n", + " starts at the first identified leaf node.\n", + "\n", + " Returns:\n", + " A list of linear paths in the graph. Each path is represented as an array of\n", + " edges.\"\"\"\n", + " paths, current_path = [], []\n", + " leaf_idx = next(x for x in graph.nodes() if graph.out_degree(x)==0 and graph.in_degree(x)==1)\n", + " # initiate traversal from leaf node, this avoids having to reconnect the\n", + " # source node to the rest of the graph later on\n", + " source = leaf_idx if source_node == \"leaf\" else source_node\n", + " for i, j in nx.dfs_edges(graph.to_undirected(), source):\n", + " if is_leaf(graph, j) or is_branching(graph, j):\n", + " paths.append(np.array(current_path + [(i, j)]))\n", + " current_path = []\n", + " elif not has_same_id(graph, i, j): # start new path if ids differ\n", + " paths.append(np.array(current_path))\n", + " current_path = [(i, j)]\n", + " # current_path = [] if i == 0 else [(i, j)]\n", + " else:\n", + " current_path.append((i, j))\n", + " return [p for p in paths if p.shape[0] > 0]\n", + "\n", + "def add_edge_lens(graph):\n", + " for i,j in graph.edges:\n", + " xyz_i = np.array(unpack(graph.nodes[i], [\"x\", \"y\", \"z\"]))\n", + " xyz_j = np.array(unpack(graph.nodes[j], [\"x\", \"y\", \"z\"]))\n", + " d_ij = np.sqrt(((xyz_i - xyz_j)**2).sum())\n", + " graph.edges[i,j][\"l\"] = d_ij\n", + " return graph\n", + "\n", + "def split_paths(paths, max_len=100):\n", + " #TODO: split paths into equally long sections\n", + " edge_lens = nx.get_edge_attributes(graph, \"l\")\n", + " edge_lens.update({(j,i): l for (i,j),l in edge_lens.items()})\n", + " new_paths = []\n", + " for path in paths:\n", + " cum_path_len = np.cumsum([edge_lens[*e] for e in path])\n", + " k = cum_path_len // max_len\n", + " split_path = [path[np.where(np.array(k) == kk)[0]] for kk in np.unique(k)]\n", + " new_paths += split_path\n", + " return new_paths\n", + "\n", + "def split_edge(graph, i,j, loc=0.5):\n", + " k = len(graph.nodes)\n", + " i_xyzr = np.array(unpack(graph.nodes[i], \"xyzr\"))\n", + " j_xyzr = np.array(unpack(graph.nodes[j], \"xyzr\"))\n", + " xyzr_k = i_xyzr + loc*(j_xyzr - i_xyzr)\n", + " l = graph.edges[i,j][\"l\"]\n", + " graph.add_node(k, id=graph.nodes[i][\"id\"], **dict(zip(\"xyzr\", (xyzr_k))))\n", + " graph.add_edge(i,k, l=loc*l)\n", + " graph.add_edge(k,j, l=(1-loc)*l)\n", + " graph.remove_edge(i, j)\n", + "\n", + "def split_node(graph, k, eps=0):\n", + " kk = len(graph.nodes)\n", + " children = list(graph.successors(k))\n", + " graph.add_node(kk, **graph.nodes[k])\n", + " graph.add_edge(k,kk, l=0+eps)\n", + "\n", + " for s in children:\n", + " graph.add_edge(kk,s, **graph.edges[k,s])\n", + " graph.remove_edge(k,s)\n", + "\n", + "def make_jaxley_compatible_v2(graph, nseg = 8, max_branch_len = 2000, source_node = 0):\n", + " graph = add_edge_lens(graph)\n", + "\n", + " # for i in range(100):\n", + " # edges = pd.DataFrame([d for *i,d in graph.edges(data=True)], index=graph.edges)\n", + " # longest_edges = edges.sort_values(\"l\", ascending=False).index.to_list()\n", + " # split_edge(graph, *longest_edges[0])\n", + "\n", + " # ids = nx.get_node_attributes(graph, \"id\")\n", + " # inter_group_edges = [e for e in graph.edges if ids[e[0]] != ids[e[1]]]\n", + " # for i,j in inter_group_edges:\n", + " # split_edge(graph,i,j)\n", + "\n", + " paths = get_paths(graph, source_node=source_node)\n", + "\n", + " idx = 113\n", + " paths = paths[:idx] + [paths[idx][:18],paths[idx][18:]] + paths[idx+1:]\n", + " \n", + " # add source compartment with length = 0\n", + " # if source_node != \"leaf\":\n", + " # paths = [np.array([[source_node,source_node]])] + paths\n", + " # graph.add_edge(source_node,source_node)\n", + " # graph.edges[source_node,source_node][\"l\"] = 0.01 #graph.nodes[source_node][\"r\"]\n", + "\n", + " branch_edges = split_paths(paths, max_branch_len)\n", + " branch_nodes = [path_e2n(b) for b in branch_edges]\n", + "\n", + " jaxley_branches = pd.DataFrame(sum([[{**graph.nodes[n], \"branch_index\":i} for n in nodes] for i, nodes in enumerate(branch_nodes)], []))\n", + " for idx, group in jaxley_branches.groupby(\"branch_index\"):\n", + " if jaxley_branches.loc[group.index[0], \"id\"] != jaxley_branches.loc[group.index[1], \"id\"]:\n", + " jaxley_branches.loc[group.index[0], [\"id\", \"r\"]] = jaxley_branches.loc[group.index[-1], [\"id\", \"r\"]]\n", + "\n", + " edge_lens = nx.get_edge_attributes(graph,\"l\")\n", + " edge_lens.update({(j,i): l for (i,j),l in edge_lens.items()})\n", + " jaxley_branches[\"l\"] = np.hstack([np.cumsum([0]+[edge_lens[*e] for e in branch]) for branch in branch_edges])\n", + "\n", + " # compartmentalize branches\n", + " jaxley_comps = []\n", + " keys = [\"x\", \"y\", \"z\", \"r\", \"id\"]\n", + " for idx, nodes in jaxley_branches.groupby(\"branch_index\"):\n", + " branch_len = nodes[\"l\"].max()\n", + " comp_len = branch_len / nseg\n", + " locs = np.linspace(comp_len/2, branch_len-comp_len/2, nseg)\n", + " comp_attrs = v_interp(locs, nodes[\"l\"].values, nodes[keys].values)\n", + "\n", + " comp_attrs = pd.DataFrame(comp_attrs.T, columns=keys)\n", + " comp_attrs[\"id\"] = comp_attrs[\"id\"].astype(int)\n", + " comp_attrs[\"length\"] = comp_len\n", + " comp_attrs[\"branch_index\"] = idx\n", + " \n", + " jaxley_comps.append(comp_attrs)\n", + " jaxley_comps = pd.concat(jaxley_comps, ignore_index=True)\n", + "\n", + " jaxley_comps.rename(columns={\"r\": \"radius\"}, inplace=True)\n", + " jaxley_comps[\"comp_index\"] = np.arange(jaxley_comps.shape[0])\n", + " jaxley_comps[\"cell_index\"] = 0\n", + "\n", + " # comp_locs = np.linspace(0, comp_len, 10)\n", + " # locs = np.hstack([comp_locs+i*comp_len for i in range(nseg)])\n", + " # rads = v_interp(locs, nodes[\"l\"].values, nodes[[\"r\"]].values)\n", + " # comp_attrs[\"r\"] = rads.reshape(-1,10).mean(axis=1)\n", + "\n", + " group_ids = {0: \"undefined\", 1: \"soma\", 2: \"axon\", 3: \"basal\", 4: \"apical\"}\n", + " id2group = lambda x: [group_ids[x] if x < 5 else f\"custom{x}\"]\n", + " jaxley_comps[\"groups\"] = jaxley_comps[\"id\"].apply(id2group)\n", + "\n", + " branch_roots_and_leafs = np.stack([np.array(branch)[[0, -1]] for branch in branch_nodes])\n", + " parent_equal_child = np.equal(*np.meshgrid(*(branch_roots_and_leafs.T)))\n", + " # edges_between_branches = np.stack(list(zip(*np.where(parent_equal_child))))[1:]\n", + " edges_between_branches = np.stack(list(zip(*np.where(parent_equal_child))))\n", + " \n", + " comps_in_branches = jaxley_comps.groupby(\"branch_index\")[\"comp_index\"]\n", + " intra_branch_edges = sum([path_n2e(c) for i, c in comps_in_branches], [])\n", + "\n", + " branch_roots = comps_in_branches.first().values\n", + " branch_leafs = comps_in_branches.last().values\n", + " \n", + " inter_branch_children = branch_roots[edges_between_branches[:,1]]\n", + " inter_branch_parents = branch_leafs[edges_between_branches[:,0]]\n", + " inter_branch_edges = np.stack([inter_branch_parents, inter_branch_children]).T\n", + "\n", + " source_branches = np.where(branch_roots_and_leafs[:,0] == source_node)[0][1:]\n", + " source_branch_edges = np.stack([source_node*np.ones_like(source_branches), source_branches]).T\n", + " inter_source_children = branch_roots[source_branch_edges[:, 1]]\n", + " inter_source_parents = branch_leafs[source_branch_edges[:, 0]]\n", + " inter_source_edges = np.stack([inter_source_parents, inter_source_children]).T\n", + "\n", + " comp_graph = nx.DiGraph()\n", + " comp_graph.add_edges_from(inter_branch_edges, type=\"inter_branch\")\n", + " comp_graph.add_edges_from(intra_branch_edges, type=\"intra_branch\")\n", + " comp_graph.add_edges_from(inter_source_edges, type=\"inter_branch\")\n", + "\n", + " keys = [\"radius\", \"length\", \"x\", \"y\", \"z\", \"comp_index\", \"branch_index\", \"cell_index\", \"groups\"]\n", + " comp_graph.add_nodes_from(((n, {k:v for k,v in zip(keys, vals)}) for i, (n,*vals) in jaxley_comps[[\"comp_index\"]+keys].iterrows())) \n", + " comp_graph.graph[\"nseg\"] = nseg\n", + " comp_graph.graph[\"xyzr\"] = [n[[\"x\",\"y\",\"z\",\"r\"]].values for i,n in jaxley_branches.groupby(\"branch_index\")]\n", + " # comp_graph.graph[\"type\"] = infer_module_type_from_inds(jaxley_comps[[\"cell_index\", \"branch_index\", \"comp_index\"]])\n", + " comp_graph.graph[\"type\"] = \"cell\"\n", + " return comp_graph" + ] + }, + { + "cell_type": "code", + "execution_count": 3726, + "metadata": {}, + "outputs": [], + "source": [ + "def get_segment_xyzrL(section, loc=None, nseg=8):\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", + "def match_index_by_coords(cell, branch_loc=0.05):\n", + " neuron_coords = {i: np.vstack(get_segment_coordinates(sec, branch_loc)).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" + ] + }, + { + "cell_type": "code", + "execution_count": 3703, + "metadata": {}, + "outputs": [], + "source": [ + "def add_edge_lens(graph):\n", + " for i,j in graph.edges:\n", + " xyz_i = np.array(unpack(graph.nodes[i], [\"x\", \"y\", \"z\"]))\n", + " xyz_j = np.array(unpack(graph.nodes[j], [\"x\", \"y\", \"z\"]))\n", + " d_ij = np.sqrt(((xyz_i - xyz_j)**2).sum())\n", + " graph.edges[i,j][\"l\"] = d_ij\n", + " return graph\n", + "\n", + "# def split_paths(paths, max_len=100):\n", + "# #TODO: split paths into equally long sections\n", + "# edge_lens = nx.get_edge_attributes(graph, \"l\")\n", + "# edge_lens.update({(j,i): l for (i,j),l in edge_lens.items()})\n", + "# new_paths = []\n", + "# for path in paths:\n", + "# cum_path_len = np.cumsum([edge_lens[*e] for e in path])\n", + "# k = cum_path_len // max_len\n", + "# split_path = [path[np.where(np.array(k) == kk)[0]] for kk in np.unique(k)]\n", + "# new_paths += split_path\n", + "# return new_paths" + ] + }, + { + "cell_type": "code", + "execution_count": 3745, + "metadata": {}, + "outputs": [], + "source": [ + "fname = os.path.join(\"../tests/\", \"morph.swc\") # n120\n", + "graph = swc_to_graph(fname)\n", + "\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)" + ] + }, + { + "cell_type": "code", + "execution_count": 3746, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3746, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "fname = os.path.join(\"../tests/\", \"morph.swc\") # n120\n", + "graph = swc_to_graph(fname)\n", + "graph = add_edge_lens(graph)\n", + "paths = get_paths(graph, 0)\n", + "\n", + "idx = 113\n", + "paths = paths[:idx] + [paths[idx][:18],paths[idx][18:]] + paths[idx+1:]\n", + "\n", + "jx_xyzr = [np.array([unpack(n, \"xyzr\") for i,n in graph.nodes(data=True) if i in path_e2n(path)]) for path in paths]\n", + "neuron_xyzr = [d2r(np.array(s.psection()[\"morphology\"][\"pts3d\"])) for s in h.allsec()]\n", + "\n", + "neuron_lens = np.array([np.sqrt((np.diff(n[:,:3], axis=0)**2).sum(axis=1)).sum() for n in neuron_xyzr])\n", + "neuron_idxs = np.argsort(neuron_lens)\n", + "neuron_sorted_lens = neuron_lens[neuron_idxs]\n", + "\n", + "jx_lens = np.array([np.sqrt((np.diff(n[:,:3], axis=0)**2).sum(axis=1)).sum() for n in jx_xyzr])\n", + "jx_idxs = np.argsort(jx_lens)\n", + "jx_sorted_lens = jx_lens[jx_idxs]\n", + "\n", + "xs = np.arange(156).tolist()\n", + "plt.plot(xs, neuron_sorted_lens, label=\"neuron\")\n", + "plt.plot(xs, jx_sorted_lens, label=\"jx\")\n", + "plt.axhline(155)\n", + "plt.legend()" + ] + }, + { + "cell_type": "code", + "execution_count": 3740, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "113 20.347926491087385 30.91125797060176\n", + "\n", + "55 1.1460000276565552 0.7699611588728849\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "113 20.347926491087385 30.91125797060176\n", + "\n", + "55 1.1460000276565552 0.8898834766186545\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "113 3.981673514114541 30.91125797060176\n", + "\n", + "55 1.1460000276565552 1.009805794364424\n", + "113 0.5644372552965549 0.4\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "113 1.743264350702068 30.91125797060176\n", + "\n", + "113 0.550000011920929 0.4\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "113 9.62087884983413 30.91125797060176\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "113 9.62087884983413 30.91125797060176\n", + "\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "113 0.31471076567772016 30.91125797060176\n", + "\n", + "113 0.8700000047683716 0.609051338985402\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "113 7.155161477194158 30.91125797060176\n", + "\n", + "113 0.7099999785423279 0.87\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "nseg=8\n", + "comp_len = 1/nseg\n", + "for n in range(nseg):\n", + " loc = comp_len/2 + n*comp_len\n", + " jaxley2neuron_inds = match_index_by_coords(cell4, branch_loc=loc)\n", + " jx2N = pd.DataFrame(np.array([(k,v) for k,v in jaxley2neuron_inds.items()]), columns=[\"jx\", \"N\"])\n", + " # jx2N[\"counts\"] = jx2N[\"N\"].value_counts()\n", + " # arg = np.where(jx2N[\"counts\"] > 1)[0]\n", + " # print(jx2N.set_index(\"N\").loc[arg])\n", + " # jx2N = jx2N[jx2N[\"jx\"] != 113]\n", + "\n", + " # jx2N = jx2N.sort_values(\"N\")\n", + " xyzrl_nx = cell4.branch(\"all\").loc(loc).show().set_index(\"branch_index\")[[\"x\", \"y\", \"z\", \"radius\", \"length\"]].to_numpy()\n", + " xyzrl_neuron = np.vstack([np.vstack(get_segment_xyzrL(sec, loc)).T for i, sec in enumerate(h.allsec())])\n", + "\n", + " fig, ax = plt.subplots(2,2, figsize=(5,3), layout=\"constrained\")\n", + " ax[0,0].scatter(xyzrl_neuron[:, 0], xyzrl_neuron[:, 1], s=2)\n", + " ax[0,0].scatter(xyzrl_nx[:, 0], xyzrl_nx[:, 1], s=2)\n", + "\n", + " ax[0,1].scatter(xyzrl_neuron[:, 0], xyzrl_neuron[:, 2], s=2)\n", + " ax[0,1].scatter(xyzrl_nx[:, 0], xyzrl_nx[:, 2], s=2)\n", + "\n", + " # ax[2,0].plot(xyzrl_neuron[jx2N[\"N\"], 3])\n", + " # ax[2,0].plot(xyzrl_nx[jx2N[\"jx\"], 3])\n", + " # ax[2,1].plot(xyzrl_neuron[jx2N[\"N\"], 4])\n", + " # ax[2,1].plot(xyzrl_nx[jx2N[\"jx\"], 4])\n", + "\n", + " ax[1,0].plot(xyzrl_neuron[jx2N[\"N\"], 3]-xyzrl_nx[jx2N[\"jx\"], 3])\n", + " ax[1,1].plot(xyzrl_neuron[jx2N[\"N\"], 4]-xyzrl_nx[jx2N[\"jx\"], 4])\n", + "\n", + " ax[1,0].set_title(\"radius\")\n", + " ax[1,1].set_title(\"length\")\n", + "\n", + " rad_diff_idx = jx2N[\"jx\"].loc[np.where(abs(xyzrl_neuron[jx2N[\"N\"], 3]-xyzrl_nx[jx2N[\"jx\"], 3]) > 0.1)[0]].values\n", + " len_diff_idx = jx2N[\"jx\"].loc[np.where(abs(xyzrl_neuron[jx2N[\"N\"], 4]-xyzrl_nx[jx2N[\"jx\"], 4]) > 1)[0]].values\n", + " for idx in len_diff_idx:\n", + " print(idx, xyzrl_neuron[jx2N[\"N\"], 4][idx], xyzrl_nx[jx2N[\"jx\"], 4][idx])\n", + " print()\n", + " for idx in rad_diff_idx:\n", + " print(idx, xyzrl_neuron[jx2N[\"N\"], 3][idx], xyzrl_nx[jx2N[\"jx\"], 3][idx])\n", + " plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -370,28 +898,74 @@ }, { "cell_type": "code", - "execution_count": 234, + "execution_count": 3741, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Added 1 stimuli. See `.currents` 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": [ - "v_nx, v_nx_neuron = test_swc_voltages(use_graph=True)\n", - "v_swc, v_swc_neuron = test_swc_voltages(use_graph=False)" + "# 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, max_branch_len=2000)\n", + "\n", + "# cell_swc = jx.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": null, + "execution_count": 3742, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "MSEs between networkX and NEURON voltages [10.14612018 10.35377231 10.84316607 11.17640196 11.06866644 11.1941421\n", - " 10.72721014 10.44691712 10.55542459 9.83932744 9.47578905 10.63712368\n", - " 13.2997599 9.5394632 10.3148209 10.06744197 10.11404793 9.99624842\n", - " 11.15663607 11.10845196 10.55436891 10.17346833 10.95011269 11.09521677\n", - " 11.24092038 10.65548104 11.36646986]\n", + "MSEs between networkX and NEURON voltages [2.63343624 2.80071704 2.79569691 3.01349224 2.79546085 2.92622472\n", + " 3.40968077 3.13264066 3.07261978 2.97657172 3.04170358 3.15846694\n", + " 3.16016155 4.69451618 2.06187881 2.05651176 1.75327168 1.75567393\n", + " 2.35193769 2.4517987 2.50208306 2.85954521 3.19612681 3.3670398\n", + " 2.87255653 3.14574168 3.50882296]\n", "MSEs between jaxley_swc_reader and NEURON voltages [0.72412308 0.7978693 0.81918308 0.84724678 0.80464105 1.43258348\n", " 1.47786316 0.73113843 1.14953477 1.12154859 1.18076938 1.30564702\n", " 1.56853646 2.9105652 0.38078612 1.00738273 0.79437486 0.81636714\n", @@ -401,7 +975,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -418,8 +992,8 @@ "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", + "# 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",