Repository: Hjorthmedh/Snudda (language: python)

Issue:
Fixed axon_density



Discussion / hints:

Fix patch:
diff --git a/examples/notebooks/optimise_prune/OptimisePrune.ipynb b/examples/notebooks/optimise_prune/OptimisePrune.ipynb
new file mode 100644
index 000000000..761b95b25
--- /dev/null
+++ b/examples/notebooks/optimise_prune/OptimisePrune.ipynb
@@ -0,0 +1,412 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "df4b2bd1-8690-4fc1-91e6-ae9fbd69925b",
+   "metadata": {},
+   "source": [
+    "This Notebook shows how to optimise the pruning parameters of your network based on pairwise connectivity data.\n",
+    "\n",
+    "First we need to create a small network that we can use for the optimisation of the pruning parameters.\n",
+    "\n",
+    "In this example we do not need to have realistic neuron densities, so we will place the neurons in a cube of diameter 100 micrometers."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "id": "2eaf4585-4517-4f28-bd0e-82063619d95b",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "network_path = os.path.join(\"networks\",\"dspn_to_dspn\")\n",
+    "n_neurons = 100\n",
+    "pop_size = 10\n",
+    "epochs = 10\n",
+    "\n",
+    "pre_type = \"dSPN\"\n",
+    "post_type = \"dSPN\"\n",
+    "con_type = \"GABA\"\n",
+    "\n",
+    "SPN2SPNdistDepPruning = \"1-exp(-(0.4*d/60e-6)**2)\"\n",
+    "extra_pruning_parameters = { 'distPruning': SPN2SPNdistDepPruning }\n",
+    "\n",
+    "experimental_data = [(0, 50e-6, 3/47.0), (0, 100e-6, 3/66.0)]\n",
+    "avg_num_synapses_per_pair = [3, 0.05]  # Expected mean, error weight"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "id": "b9f27530-a938-4799-b50b-75e94375f323",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Adding neurons: dSPN from dir /home/hjorth/HBP/BasalGangliaData/data/neurons/striatum/dspn\n",
+      "Writing networks/dspn_to_dspn/network-config.json\n"
+     ]
+    }
+   ],
+   "source": [
+    "from snudda.place.create_cube_mesh import create_cube_mesh\n",
+    "\n",
+    "mesh_file = os.path.join(network_path, \"cube-mesh.obj\")\n",
+    "create_cube_mesh(mesh_file, [0,0,0], 100e-6)\n",
+    "\n",
+    "from snudda.init import SnuddaInit\n",
+    "si = SnuddaInit(network_path=network_path, random_seed=123, snudda_data=\"../../../../BasalGangliaData/data/\")\n",
+    "\n",
+    "si.define_structure(struct_name=\"Cube\", struct_mesh=mesh_file, d_min=12e-6, mesh_bin_width=25e-6)\n",
+    "\n",
+    "if pre_type == post_type:\n",
+    "    si.add_neurons(name=pre_type, num_neurons=n_neurons, volume_id=\"Cube\",\n",
+    "                    neuron_dir=os.path.join(\"$DATA\",\"neurons\",\"striatum\",\"dspn\"))\n",
+    "else:\n",
+    "    si.add_neurons(name=pre_type, num_neurons=int(n_neurons/2), volume_id=\"Cube\",\n",
+    "                    neuron_dir=os.path.join(\"$DATA\",\"neurons\",\"striatum\",\"dspn\"))\n",
+    "    si.add_neurons(name=post_type, num_neurons=int(n_neurons/2), volume_id=\"Cube\",\n",
+    "                    neuron_dir=os.path.join(\"$DATA\",\"neurons\",\"striatum\",\"dspn\"))\n",
+    "    \n",
+    "\n",
+    "# The parameters here does not matter, they will be set during optimisation\n",
+    "si.add_neuron_target(neuron_name=pre_type,\n",
+    "                     target_name=post_type,\n",
+    "                     connection_type=con_type,\n",
+    "                     dist_pruning=SPN2SPNdistDepPruning,\n",
+    "                     f1=None, soft_max=None, mu2=None,\n",
+    "                     a3=None,\n",
+    "                     conductance=[0.24e-9, 0.1e-9],\n",
+    "                     mod_file=\"tmGabaA\")\n",
+    "\n",
+    "si.write_json()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "id": "e4a95e3a-9b43-4023-a338-84e2abc0d95d",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Reading SNUDDA_DATA=../../../../BasalGangliaData/data/ from networks/dspn_to_dspn/network-config.json\n"
+     ]
+    }
+   ],
+   "source": [
+    "from snudda import SnuddaPlace\n",
+    "sp = SnuddaPlace(network_path=network_path, verbose=False)\n",
+    "sp.place()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "id": "bb715388-152b-4f8e-862a-5b38df1e631e",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Reading SNUDDA_DATA=../../../../BasalGangliaData/data/ from networks/dspn_to_dspn/network-config.json\n"
+     ]
+    },
+    {
+     "data": {
+      "image/png": "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\n",
+      "text/plain": [
+       "<Figure size 600x650 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "from snudda.plotting import PlotNetwork\n",
+    "network_file = os.path.join(network_path, \"network-neuron-positions.hdf5\")\n",
+    "pn = PlotNetwork(network_file)\n",
+    "pn.plot(plot_axon=False, plot_dendrite=False, plot_synapses=False)\n",
+    "pn.close() "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 5,
+   "id": "87956186-ebc7-4d42-967e-28e4737e0a71",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Reading SNUDDA_DATA=../../../../BasalGangliaData/data/ from networks/dspn_to_dspn/network-config.json\n",
+      "No d_view specified, running distribute neurons in serial\n",
+      "Processing hyper voxel : 56/125 (100 neurons)\n",
+      "Processing hyper voxel : 31/125 (100 neurons)\n",
+      "Processing hyper voxel : 30/125 (85 neurons)\n",
+      "Processing hyper voxel : 32/125 (84 neurons)\n",
+      "Processing hyper voxel : 36/125 (83 neurons)\n",
+      "Processing hyper voxel : 26/125 (78 neurons)\n",
+      "Processing hyper voxel : 61/125 (71 neurons)\n",
+      "Processing hyper voxel : 51/125 (65 neurons)\n",
+      "Processing hyper voxel : 55/125 (61 neurons)\n",
+      "Processing hyper voxel : 57/125 (58 neurons)\n",
+      "Processing hyper voxel : 35/125 (37 neurons)\n",
+      "Processing hyper voxel : 6/125 (32 neurons)\n",
+      "Processing hyper voxel : 25/125 (31 neurons)\n",
+      "Processing hyper voxel : 27/125 (29 neurons)\n",
+      "Processing hyper voxel : 37/125 (29 neurons)\n",
+      "Processing hyper voxel : 52/125 (21 neurons)\n",
+      "Processing hyper voxel : 62/125 (20 neurons)\n",
+      "Processing hyper voxel : 50/125 (19 neurons)\n",
+      "Processing hyper voxel : 60/125 (18 neurons)\n",
+      "Processing hyper voxel : 5/125 (15 neurons)\n",
+      "Processing hyper voxel : 1/125 (14 neurons)\n",
+      "Processing hyper voxel : 81/125 (12 neurons)\n",
+      "Processing hyper voxel : 11/125 (10 neurons)\n",
+      "Processing hyper voxel : 7/125 (8 neurons)\n",
+      "Processing hyper voxel : 0/125 (5 neurons)\n",
+      "Processing hyper voxel : 12/125 (3 neurons)\n",
+      "Processing hyper voxel : 2/125 (3 neurons)\n",
+      "Processing hyper voxel : 76/125 (3 neurons)\n",
+      "Processing hyper voxel : 58/125 (2 neurons)\n",
+      "Processing hyper voxel : 80/125 (2 neurons)\n",
+      "Processing hyper voxel : 33/125 (2 neurons)\n",
+      "Processing hyper voxel : 82/125 (2 neurons)\n",
+      "Processing hyper voxel : 10/125 (1 neurons)\n",
+      "Processing hyper voxel : 66/125 (1 neurons)\n",
+      "Processing hyper voxel : 75/125 (1 neurons)\n"
+     ]
+    }
+   ],
+   "source": [
+    "from snudda import SnuddaDetect\n",
+    "\n",
+    "sd = SnuddaDetect(network_path=network_path, hyper_voxel_size=100)\n",
+    "sd.detect()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "e413fb86-c3ff-431d-b502-670445309063",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from snudda.optimise.optimise_pruning import OptimisePruning\n",
+    "op = OptimisePruning(network_path=network_path, pop_size=pop_size, epochs=epochs)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 7,
+   "id": "37667d52-30e2-427f-9f40-2edf25b0b504",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Read 168329 out of total 168329 synapses\n"
+     ]
+    }
+   ],
+   "source": [
+    "op.merge_putative_synapses()"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "268e3825-1642-404d-81ab-156866aa0bfa",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{(1,\n",
+       "  1,\n",
+       "  10): (OrderedDict([('f1', 1.0),\n",
+       "               ('softMax', None),\n",
+       "               ('mu2', None),\n",
+       "               ('a3', None),\n",
+       "               ('distPruning', '1-exp(-(0.4*d/60e-6)**2)'),\n",
+       "               ('cluster', False)]), None)}"
+      ]
+     },
+     "execution_count": 8,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "op.prune.connectivity_distributions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "54d6f86e-4be8-40ae-95b2-eb1f82936071",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "{'dSPN': 1}"
+      ]
+     },
+     "execution_count": 9,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "op.prune.type_id_lookup"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "fc43c7ba-a750-41b9-8ef8-87f5333a91f0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "b'{\"dSPN$$dSPN\": {\"GABA\": {\"conductance\": [2.4e-10, 1e-10], \"channelParameters\": {\"modFile\": \"tmGabaA\"}, \"clusterSize\": 1, \"clusterSpread\": null, \"pruning\": {\"f1\": null, \"softMax\": null, \"mu2\": null, \"a3\": null, \"distPruning\": \"1-exp(-(0.4*d/60e-6)**2)\", \"cluster\": false}, \"channelModelID\": 10, \"lognormal_mu_sigma\": [-22.230424900260093, 0.40010675493807013]}}}'"
+      ]
+     },
+     "execution_count": 10,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "source": [
+    "op.prune.hist_file[\"meta/connectivityDistributions\"][()]"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "521b4339-15e7-4d28-8c08-10c9b345d52c",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/hjorth/HBP/Snudda/venv/lib/python3.9/site-packages/scipy/optimize/_differentialevolution.py:377: UserWarning: differential_evolution: the 'workers' keyword has overridden updating='immediate' to updating='deferred'\n",
+      "  with DifferentialEvolutionSolver(func, bounds, args=args,\n"
+     ]
+    },
+    {
+     "ename": "RuntimeError",
+     "evalue": "The map-like callable must be of the form f(func, iterable), returning a sequence of numbers the same length as 'iterable'",
+     "output_type": "error",
+     "traceback": [
+      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
+      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "File \u001b[0;32m~/HBP/Snudda/venv/lib/python3.9/site-packages/scipy/_lib/_util.py:477\u001b[0m, in \u001b[0;36mMapWrapper.__call__\u001b[0;34m(self, func, iterable)\u001b[0m\n\u001b[1;32m    476\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 477\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_mapfunc\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43miterable\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    478\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m    479\u001b[0m     \u001b[38;5;66;03m# wrong number of arguments\u001b[39;00m\n",
+      "File \u001b[0;32m/usr/lib/python3.9/multiprocessing/pool.py:364\u001b[0m, in \u001b[0;36mPool.map\u001b[0;34m(self, func, iterable, chunksize)\u001b[0m\n\u001b[1;32m    360\u001b[0m \u001b[38;5;124;03m'''\u001b[39;00m\n\u001b[1;32m    361\u001b[0m \u001b[38;5;124;03mApply `func` to each element in `iterable`, collecting the results\u001b[39;00m\n\u001b[1;32m    362\u001b[0m \u001b[38;5;124;03min a list that is returned.\u001b[39;00m\n\u001b[1;32m    363\u001b[0m \u001b[38;5;124;03m'''\u001b[39;00m\n\u001b[0;32m--> 364\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_map_async\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43miterable\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mmapstar\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mchunksize\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mget\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m/usr/lib/python3.9/multiprocessing/pool.py:771\u001b[0m, in \u001b[0;36mApplyResult.get\u001b[0;34m(self, timeout)\u001b[0m\n\u001b[1;32m    770\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n\u001b[0;32m--> 771\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_value\n",
+      "File \u001b[0;32m/usr/lib/python3.9/multiprocessing/pool.py:537\u001b[0m, in \u001b[0;36mPool._handle_tasks\u001b[0;34m(taskqueue, put, outqueue, pool, cache)\u001b[0m\n\u001b[1;32m    536\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[0;32m--> 537\u001b[0m     \u001b[43mput\u001b[49m\u001b[43m(\u001b[49m\u001b[43mtask\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    538\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mException\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n",
+      "File \u001b[0;32m/usr/lib/python3.9/multiprocessing/connection.py:211\u001b[0m, in \u001b[0;36m_ConnectionBase.send\u001b[0;34m(self, obj)\u001b[0m\n\u001b[1;32m    210\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_check_writable()\n\u001b[0;32m--> 211\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_send_bytes(\u001b[43m_ForkingPickler\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdumps\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobj\u001b[49m\u001b[43m)\u001b[49m)\n",
+      "File \u001b[0;32m/usr/lib/python3.9/multiprocessing/reduction.py:51\u001b[0m, in \u001b[0;36mForkingPickler.dumps\u001b[0;34m(cls, obj, protocol)\u001b[0m\n\u001b[1;32m     50\u001b[0m buf \u001b[38;5;241m=\u001b[39m io\u001b[38;5;241m.\u001b[39mBytesIO()\n\u001b[0;32m---> 51\u001b[0m \u001b[38;5;28;43mcls\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mbuf\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mprotocol\u001b[49m\u001b[43m)\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdump\u001b[49m\u001b[43m(\u001b[49m\u001b[43mobj\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m     52\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m buf\u001b[38;5;241m.\u001b[39mgetbuffer()\n",
+      "\u001b[0;31mTypeError\u001b[0m: cannot pickle '_io.TextIOWrapper' object",
+      "\nThe above exception was the direct cause of the following exception:\n",
+      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
+      "File \u001b[0;32m~/HBP/Snudda/venv/lib/python3.9/site-packages/scipy/optimize/_differentialevolution.py:1117\u001b[0m, in \u001b[0;36mDifferentialEvolutionSolver._calculate_population_energies\u001b[0;34m(self, population)\u001b[0m\n\u001b[1;32m   1115\u001b[0m \u001b[38;5;28;01mtry\u001b[39;00m:\n\u001b[1;32m   1116\u001b[0m     calc_energies \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mlist\u001b[39m(\n\u001b[0;32m-> 1117\u001b[0m         \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_mapwrapper\u001b[49m\u001b[43m(\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfunc\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mparameters_pop\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;241;43m0\u001b[39;49m\u001b[43m:\u001b[49m\u001b[43mS\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m   1118\u001b[0m     )\n\u001b[1;32m   1119\u001b[0m     calc_energies \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39msqueeze(calc_energies)\n",
+      "File \u001b[0;32m~/HBP/Snudda/venv/lib/python3.9/site-packages/scipy/_lib/_util.py:480\u001b[0m, in \u001b[0;36mMapWrapper.__call__\u001b[0;34m(self, func, iterable)\u001b[0m\n\u001b[1;32m    478\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m    479\u001b[0m     \u001b[38;5;66;03m# wrong number of arguments\u001b[39;00m\n\u001b[0;32m--> 480\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mTypeError\u001b[39;00m(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThe map-like callable must be of the\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m    481\u001b[0m                     \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124m form f(func, iterable)\u001b[39m\u001b[38;5;124m\"\u001b[39m) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n",
+      "\u001b[0;31mTypeError\u001b[0m: The map-like callable must be of the form f(func, iterable)",
+      "\nThe above exception was the direct cause of the following exception:\n",
+      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
+      "Input \u001b[0;32mIn [11]\u001b[0m, in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[43mop\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43moptimize\u001b[49m\u001b[43m(\u001b[49m\u001b[43mpre_type\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpre_type\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mpost_type\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mpost_type\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mcon_type\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mcon_type\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mexperimental_data\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mexperimental_data\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mextra_pruning_parameters\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mextra_pruning_parameters\u001b[49m\u001b[43m)\u001b[49m\n",
+      "File \u001b[0;32m~/HBP/Snudda/snudda/optimise/optimise_pruning.py:227\u001b[0m, in \u001b[0;36mOptimisePruning.optimize\u001b[0;34m(self, pre_type, post_type, con_type, experimental_data, extra_pruning_parameters, workers)\u001b[0m\n\u001b[1;32m    223\u001b[0m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39moptimisation_info[\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mctr\u001b[39m\u001b[38;5;124m\"\u001b[39m] \u001b[38;5;241m=\u001b[39m \u001b[38;5;241m0\u001b[39m\n\u001b[1;32m    225\u001b[0m bounds \u001b[38;5;241m=\u001b[39m [(\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m1\u001b[39m), (\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m20\u001b[39m), (\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m5\u001b[39m), (\u001b[38;5;241m0\u001b[39m, \u001b[38;5;241m1\u001b[39m)]\n\u001b[0;32m--> 227\u001b[0m res \u001b[38;5;241m=\u001b[39m \u001b[43mdifferential_evolution\u001b[49m\u001b[43m(\u001b[49m\u001b[43mfunc\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mhelper_func\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mbounds\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mbounds\u001b[49m\u001b[43m,\u001b[49m\u001b[43m \u001b[49m\u001b[43mworkers\u001b[49m\u001b[38;5;241;43m=\u001b[39;49m\u001b[43mworkers\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    229\u001b[0m \u001b[38;5;66;03m# self.log_file.close()\u001b[39;00m\n\u001b[1;32m    231\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m res\n",
+      "File \u001b[0;32m~/HBP/Snudda/venv/lib/python3.9/site-packages/scipy/optimize/_differentialevolution.py:392\u001b[0m, in \u001b[0;36mdifferential_evolution\u001b[0;34m(func, bounds, args, strategy, maxiter, popsize, tol, mutation, recombination, seed, callback, disp, polish, init, atol, updating, workers, constraints, x0, integrality, vectorized)\u001b[0m\n\u001b[1;32m    375\u001b[0m \u001b[38;5;66;03m# using a context manager means that any created Pool objects are\u001b[39;00m\n\u001b[1;32m    376\u001b[0m \u001b[38;5;66;03m# cleared up.\u001b[39;00m\n\u001b[1;32m    377\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m DifferentialEvolutionSolver(func, bounds, args\u001b[38;5;241m=\u001b[39margs,\n\u001b[1;32m    378\u001b[0m                                  strategy\u001b[38;5;241m=\u001b[39mstrategy,\n\u001b[1;32m    379\u001b[0m                                  maxiter\u001b[38;5;241m=\u001b[39mmaxiter,\n\u001b[0;32m   (...)\u001b[0m\n\u001b[1;32m    390\u001b[0m                                  integrality\u001b[38;5;241m=\u001b[39mintegrality,\n\u001b[1;32m    391\u001b[0m                                  vectorized\u001b[38;5;241m=\u001b[39mvectorized) \u001b[38;5;28;01mas\u001b[39;00m solver:\n\u001b[0;32m--> 392\u001b[0m     ret \u001b[38;5;241m=\u001b[39m \u001b[43msolver\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43msolve\u001b[49m\u001b[43m(\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m    394\u001b[0m \u001b[38;5;28;01mreturn\u001b[39;00m ret\n",
+      "File \u001b[0;32m~/HBP/Snudda/venv/lib/python3.9/site-packages/scipy/optimize/_differentialevolution.py:984\u001b[0m, in \u001b[0;36mDifferentialEvolutionSolver.solve\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m    979\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfeasible, \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mconstraint_violation \u001b[38;5;241m=\u001b[39m (\n\u001b[1;32m    980\u001b[0m         \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_calculate_population_feasibilities(\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpopulation))\n\u001b[1;32m    982\u001b[0m     \u001b[38;5;66;03m# only work out population energies for feasible solutions\u001b[39;00m\n\u001b[1;32m    983\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mpopulation_energies[\u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mfeasible] \u001b[38;5;241m=\u001b[39m (\n\u001b[0;32m--> 984\u001b[0m         \u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43m_calculate_population_energies\u001b[49m\u001b[43m(\u001b[49m\n\u001b[1;32m    985\u001b[0m \u001b[43m            \u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mpopulation\u001b[49m\u001b[43m[\u001b[49m\u001b[38;5;28;43mself\u001b[39;49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mfeasible\u001b[49m\u001b[43m]\u001b[49m\u001b[43m)\u001b[49m)\n\u001b[1;32m    987\u001b[0m     \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39m_promote_lowest_energy()\n\u001b[1;32m    989\u001b[0m \u001b[38;5;66;03m# do the optimization.\u001b[39;00m\n",
+      "File \u001b[0;32m~/HBP/Snudda/venv/lib/python3.9/site-packages/scipy/optimize/_differentialevolution.py:1123\u001b[0m, in \u001b[0;36mDifferentialEvolutionSolver._calculate_population_energies\u001b[0;34m(self, population)\u001b[0m\n\u001b[1;32m   1119\u001b[0m     calc_energies \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39msqueeze(calc_energies)\n\u001b[1;32m   1120\u001b[0m \u001b[38;5;28;01mexcept\u001b[39;00m (\u001b[38;5;167;01mTypeError\u001b[39;00m, \u001b[38;5;167;01mValueError\u001b[39;00m) \u001b[38;5;28;01mas\u001b[39;00m e:\n\u001b[1;32m   1121\u001b[0m     \u001b[38;5;66;03m# wrong number of arguments for _mapwrapper\u001b[39;00m\n\u001b[1;32m   1122\u001b[0m     \u001b[38;5;66;03m# or wrong length returned from the mapper\u001b[39;00m\n\u001b[0;32m-> 1123\u001b[0m     \u001b[38;5;28;01mraise\u001b[39;00m \u001b[38;5;167;01mRuntimeError\u001b[39;00m(\n\u001b[1;32m   1124\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mThe map-like callable must be of the form f(func, iterable), \u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m   1125\u001b[0m         \u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mreturning a sequence of numbers the same length as \u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124miterable\u001b[39m\u001b[38;5;124m'\u001b[39m\u001b[38;5;124m\"\u001b[39m\n\u001b[1;32m   1126\u001b[0m     ) \u001b[38;5;28;01mfrom\u001b[39;00m \u001b[38;5;21;01me\u001b[39;00m\n\u001b[1;32m   1128\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m calc_energies\u001b[38;5;241m.\u001b[39msize \u001b[38;5;241m!=\u001b[39m S:\n\u001b[1;32m   1129\u001b[0m     \u001b[38;5;28;01mif\u001b[39;00m \u001b[38;5;28mself\u001b[39m\u001b[38;5;241m.\u001b[39mvectorized:\n",
+      "\u001b[0;31mRuntimeError\u001b[0m: The map-like callable must be of the form f(func, iterable), returning a sequence of numbers the same length as 'iterable'"
+     ]
+    }
+   ],
+   "source": [
+    "res = op.optimize(pre_type=pre_type, post_type=post_type, con_type=con_type, experimental_data=experimental_data, extra_pruning_parameters=extra_pruning_parameters)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "9669aa41-9e2b-4b20-bdf6-8c9fe77136ea",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "res"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "19853b8d-0c78-4c9e-835d-73fc7c673ddf",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import os\n",
+    "from snudda.analyse.analyse import SnuddaAnalyse\n",
+    "\n",
+    "network_file = os.path.join(network_path, \"network-synapses-e1758f28-37e3-4405-b3af-b3fd1f0a8c19.hdf5\")\n",
+    "dist3D = False\n",
+    "y_max_H = None\n",
+    "\n",
+    "sa = SnuddaAnalyse(network_file)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "b31c8259-ac6a-45a6-9088-1a49b1985b1a",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "sa.plot_connection_probability(\"dSPN\", \"dSPN\", dist_3d=True, exp_max_dist=[50e-6, 100e-6], exp_data=[5 / 19.0, 3 / 43.0],\n",
+    "                               exp_data_detailed=[(5, 19), (3, 43)])"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "c697fc6f-f88c-4e4a-962c-5cc6afa650fc",
+   "metadata": {},
+   "outputs": [],
+   "source": []
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3 (ipykernel)",
+   "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.9.2"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/requirements.txt b/requirements.txt
index 3c21bddcc..a26f7d0b6 100644
--- a/requirements.txt
+++ b/requirements.txt
@@ -3,17 +3,18 @@ h5py >=3.2.1
 ipyparallel>=6.3.0
 matplotlib>=3.3.4
 mpi4py>=3.0.3
-numpy>=1.20.2
+numba>=0.56.4  # Optimisation
+numpy==1.23.5   # -- numpy requirement satisfied through numba's numpy dependence
 scipy>=1.6.3
 sonata>=0.0.2
 pyzmq>=22.0.3
 numexpr>=2.7.3
 # allensdk  # Optional, only needed for downloading meshes from Allen Institute
-snudda
 NEURON>=7.8.2
 pyswarms>=1.3.0
 setuptools
 psutil >= 5.8.0
 cython  # Needed for compiling NEURON
-numba>=0.55.1  # Optimisation
+
 # igraph
+# snudda
diff --git a/setup.py b/setup.py
index e853a165b..a2c773599 100644
--- a/setup.py
+++ b/setup.py
@@ -25,14 +25,14 @@
         "ipyparallel>=6.3.0",
         "matplotlib>=3.3.4",
         "mpi4py>=3.0.3",
-        "numpy>=1.20.2",
+        "numpy==1.23.5",  # Numba depends on specific numpy version, so removing this line for now as numba will install its requirements
         "scipy>=1.6.3",
         "sonata>=0.0.2",
         "pyzmq>=22.0.3",
         "setuptools",
         "psutil",
         "numexpr>=2.7.3",
-        "numba>=0.53.1",
+        "numba>=0.56.4",
         # "igraph"
     ]
     
diff --git a/snudda/TODO.txt b/snudda/TODO.txt
deleted file mode 100644
index b5dbccc70..000000000
--- a/snudda/TODO.txt
+++ /dev/null
@@ -1,33 +0,0 @@
-
-2020-10-02 (JH+IC)
-
-- All the synapses on the same neuron from the same source (external),
-  need to have the same overall behaviour. Ie, they need to be picked from
-  the same pool: facilitating, depressing, high nmda/ampa ratio,
-  start ficiliating then depressing (this is for cortical and thalamic input)
-
-  Current status: We randomly pick parameters for each synapse on the neuron,
-  ie the soma sees an averaging of these different behaviours - not good.
-  
-
-- We want to be able to do pruning such that synapses are clustered afterwards.
-  This is important for cortical and thalamic input when using virtual axons,
-  and possibly also for intrastriatal synapses.
-
-  Current status: Synapses are pruned independtly of each other.
-  
-
-- We want to be able to place clustered synapses for external input.
-  This is needed for cortical and thalamic input.
-
-  Current status: Synapses are placed indepedently of each other.
-
-2020-10-04 (IC)
-
-- Include the possibility to optimize for two traces at the same time (same input region, same cell but different frequencies). For example:
-  M1-RH-ipsi 161_FS10_GBZ_CC_H10 and 161_FS10_GBZ_CC_H20
-
-  Current status: One trace at the time is optimized.
-
-
-
diff --git a/snudda/__init__.py b/snudda/__init__.py
index 61561b99b..70bd667ea 100644
--- a/snudda/__init__.py
+++ b/snudda/__init__.py
@@ -1,6 +1,6 @@
 from .core import Snudda
 
-__version__ = "1.4.0"
+__version__ = "1.4.1"
 
 from .init import SnuddaInit
 from .place import SnuddaPlace
diff --git a/snudda/analyse/analyse_spike_trains.py b/snudda/analyse/analyse_spike_trains.py
index 43d32367d..1f53cde7a 100644
--- a/snudda/analyse/analyse_spike_trains.py
+++ b/snudda/analyse/analyse_spike_trains.py
@@ -1,10 +1,13 @@
 import os
 import numpy as np
+from numba import jit
+import matplotlib.pyplot as plt
 
 import h5py
-from elephant.spike_train_correlation import spike_time_tiling_coefficient
-from neo import SpikeTrain as NeoSpikeTrain
-import quantities as pq
+# from elephant.spike_train_correlation import spike_time_tiling_coefficient
+from snudda.analyse.spike_time_tiling_coefficient import spike_time_tiling_coefficient
+# from neo import SpikeTrain as NeoSpikeTrain
+# import quantities as pq
 
 from snudda.utils.load_network_simulation import SnuddaLoadNetworkSimulation
 from snudda.utils.load import SnuddaLoad
@@ -57,51 +60,64 @@ def __init__(self, network_file=None, output_file=None, input_file=None, network
         if self.input_file is not None:
             self.input_data = h5py.File(self.input_file, "r")
 
-    def calculate_sttc(self, spike_train_a, spike_train_b, dt):
-        t_end = self.get_end_time() * pq.s
-        sa = NeoSpikeTrain(spike_train_a.flatten(), t_stop=t_end, units="s")
-        sb = NeoSpikeTrain(spike_train_b.flatten(), t_stop=t_end, units="s")
+    def calculate_sttc(self, spike_train_a, spike_train_b, dt, start_time=0, end_time=None):
 
-        return spike_time_tiling_coefficient(spiketrain_i=sa, spiketrain_j=sb, dt=dt)
+        if end_time is None:
+            end_time = self.get_end_time()
+
+        idx_a = np.where(np.logical_and(start_time <= spike_train_a, spike_train_a <= end_time))[0]
+        idx_b = np.where(np.logical_and(start_time <= spike_train_b, spike_train_b <= end_time))[0]
+
+        return spike_time_tiling_coefficient(spiketrain_i=spike_train_a[idx_a], spiketrain_j=spike_train_b[idx_b],
+                                             dt=dt, end_time=end_time, start_time=start_time)
 
     def get_end_time(self):
-        return np.max(self.output_data.get_time()) * pq.s
+        return np.max(self.output_data.get_time())
 
-    def calculate_sttc_all_to_all(self, spike_trains, n_spikes, dt):
+    def calculate_sttc_all_to_all(self, spike_trains, n_spikes, dt, start_time=0, end_time=None):
         n_spike_trains = len(n_spikes)
         assert spike_trains.shape[0] == n_spike_trains
 
         corr = []
-        t_end = self.get_end_time()
 
-        neo_spike_trains = []
-        for i in range(0, n_spike_trains):
-            neo_spike_trains.append(NeoSpikeTrain(spike_trains[i, :n_spikes[i]].flatten(), t_stop=t_end, units="s"))
+        if end_time is None:
+            end_time = self.get_end_time()
+
+        pruned_spike_trains = []
+        for st in spike_trains:
+            idx = np.where(np.logical_and(start_time <= st, st <= end_time))[0]
+            pruned_spike_trains.append(st[idx].flatten())
 
         for i in range(0, n_spike_trains):
             if i % 50 == 0:
                 print(f'{i} / {n_spike_trains}')
             for j in range(i+1, n_spike_trains):
-                corr.append(spike_time_tiling_coefficient(spiketrain_i=neo_spike_trains[i],
-                                                          spiketrain_j=neo_spike_trains[j],
-                                                          dt=dt))
+                corr.append(spike_time_tiling_coefficient(spiketrain_a=pruned_spike_trains[i],
+                                                          spiketrain_b=pruned_spike_trains[j],
+                                                          dt=dt, start_time=start_time, end_time=end_time))
         print(f'{i} / {n_spike_trains}')
 
         return np.array(corr)
 
-    def calculate_sttc_one_to_all(self, spike_train, spike_trains, n_spikes, dt):
+    def calculate_sttc_one_to_all(self, spike_train, spike_trains, n_spikes, dt, start_time=0, end_time=None):
         n_spike_trains = len(n_spikes)
         assert spike_trains.shape[0] == n_spike_trains
         corr = []
-        t_end = self.get_end_time()
 
-        spike_train_b = NeoSpikeTrain(spike_train.flatten(), t_stop=t_end, units="s")
+        if end_time is None:
+            end_time = self.get_end_time()
+
+        st = spike_train.flatten()
+        idx = np.where(np.logical_and(start_time <= st, st <= end_time))[0]
+        spike_train_b = st[idx]
 
         for i in range(1, n_spike_trains):
-            spike_train_a = NeoSpikeTrain(spike_trains[i, :n_spikes[i]].flatten(), t_stop=t_end, units="s")
-            corr.append(spike_time_tiling_coefficient(spiketrain_i=spike_train_a,
-                                                      spiketrain_j=spike_train_b,
-                                                      dt=dt))
+            idx_i = np.where(np.logical_and(start_time <= spike_trains[i, :], spike_trains[i, :] <= end_time))[0]
+            spike_train_i = spike_trains[i, idx_i].flatten()
+
+            corr.append(spike_time_tiling_coefficient(spiketrain_a=spike_train_i,
+                                                      spiketrain_b=spike_train_b,
+                                                      dt=dt, end_time=end_time))
 
         return np.array(corr)
 
@@ -112,7 +128,7 @@ def input_correlation(self, neuron_id, input_type, dt):
         corr = self.calculate_sttc_all_to_all(spike_trains=input_spikes, n_spikes=n_spikes, dt=dt)
         return corr
 
-    def input_output_correlation(self, neuron_id, dt):
+    def input_output_correlation(self, neuron_id, dt, start_time=0, end_time=None):
 
         input_data = dict()
         corr = dict()
@@ -127,6 +143,63 @@ def input_output_correlation(self, neuron_id, dt):
             corr[input_type] = self.calculate_sttc_one_to_all(spike_train=output_data,
                                                               spike_trains=input_spikes,
                                                               n_spikes=n_spikes,
-                                                              dt=dt)
+                                                              dt=dt, start_time=start_time, end_time=end_time)
         return corr
 
+    def plot_spike_multiplicity(self, neuron_id, input_type, jitter=0, start_time=None, end_time=None):
+
+        mult_list, mult = self.calculate_spike_multiplicity(neuron_id=neuron_id, input_type=input_type, jitter=jitter,
+                                                            start_time=None, end_time=None)
+
+        plt.figure()
+        plt.title(f"{self.network_path} {neuron_id} {input_type}")
+        # plt.stairs(edges=np.arange(0, len(mult)+1), values=mult)
+        plt.hist(mult_list, bins=50)
+        plt.yscale('log')
+
+    def calculate_spike_multiplicity(self, neuron_id, input_type, jitter=0, start_time=None, end_time=None):
+
+        input_spikes = self.input_data[f"input/{neuron_id}/{input_type}/spikes"][()].flatten()
+        return self.calculate_multiplicity_helper(input_spikes=input_spikes, jitter=jitter,
+                                                  start_time=start_time, end_time=end_time)
+
+    @staticmethod
+    # @jit(nopython=True, fastmath=True, cache=True)
+    def calculate_multiplicity_helper(input_spikes, jitter=0, start_time=None, end_time=None):
+
+        assert (start_time is None) ^ (end_time is None) == False, "Either both start_time and end_time is set, or None"
+
+        max_mult = input_spikes.shape[0]
+        multiplicity = np.zeros((max_mult+1, ), dtype=int)
+
+        input_spikes = input_spikes.flatten()
+        if end_time is None:
+            input_spikes = np.sort(input_spikes[np.where(input_spikes >= 0)[0]])
+        else:
+            input_spikes = np.sort(input_spikes[np.where(np.logical_and(start_time <= input_spikes,
+                                                                        input_spikes <= end_time))[0]])
+
+        mul_ctr = 1
+        first_spike = input_spikes[0]
+        max_mult = 1
+
+        mult_list = []
+
+        for idx in range(1, len(input_spikes)):
+            if input_spikes[idx] <= first_spike + jitter:
+                mul_ctr += 1
+            else:
+                mult_list.append(mul_ctr)
+                multiplicity[mul_ctr] += 1
+                max_mult = max(max_mult, mul_ctr)
+                mul_ctr = 1
+                first_spike = input_spikes[idx]
+
+        # Need to add the last spike also
+        mult_list.append(mul_ctr)
+        multiplicity[mul_ctr] += 1
+        max_mult = max(max_mult, mul_ctr)
+
+        return mult_list, multiplicity[:max_mult+1]
+
+
diff --git a/snudda/analyse/analyse_synapse_location.py b/snudda/analyse/analyse_synapse_location.py
index 695e25352..5b291c400 100644
--- a/snudda/analyse/analyse_synapse_location.py
+++ b/snudda/analyse/analyse_synapse_location.py
@@ -47,7 +47,7 @@ def plot_synapse_distance_to_soma(self, pre_type=None, post_type=None, fig_path=
             post_text = post_type
 
         if fig_path is None:
-            fig_path = os.path.join(self.figure_path, f"Distance-to-soma-{pre_text}-to-{post_text}.png")
+            fig_path = os.path.join(self.figure_path, f"Distance-to-soma-{pre_text}-to-{post_text}.pdf")
 
         dist = self.synapse_distance_to_soma(pre_type=pre_type, post_type=post_type)
 
diff --git a/snudda/analyse/spike_time_tiling_coefficient.py b/snudda/analyse/spike_time_tiling_coefficient.py
new file mode 100644
index 000000000..5c703a159
--- /dev/null
+++ b/snudda/analyse/spike_time_tiling_coefficient.py
@@ -0,0 +1,153 @@
+# This code is taken from https://github.com/NeuralEnsemble/elephant/blob/master/elephant/spike_train_correlation.py
+# and modified to use numba for faster run time.
+
+import numpy as np
+from numba import jit
+
+
+@jit(nopython=True, fastmath=True, cache=True)
+def spike_time_tiling_coefficient(spiketrain_a, spiketrain_b, end_time, start_time=0, dt=0.005):
+    """
+    Calculates the Spike Time Tiling Coefficient (STTC) as described in
+    :cite:`correlation-Cutts2014_14288` following their implementation in C.
+    The STTC is a pair wise measure of correlation between spike trains.
+    It has been proposed as a replacement for the correlation index as it
+    presents several advantages (e.g. it's not confounded by firing rate,
+    appropriately distinguishes lack of correlation from anti-correlation,
+    periods of silence don't add to the correlation and it's sensitive to
+    firing patterns).
+    The STTC is calculated as follows:
+    .. math::
+        STTC = 1/2((PA - TB)/(1 - PA*TB) + (PB - TA)/(1 - PB*TA))
+    Where `PA` is the proportion of spikes from train 1 that lie within
+    `[-dt, +dt]` of any spike of train 2 divided by the total number of spikes
+    in train 1, `PB` is the same proportion for the spikes in train 2;
+    `TA` is the proportion of total recording time within `[-dt, +dt]` of any
+    spike in train 1, TB is the same proportion for train 2.
+    For :math:`TA = PB = 1`and for :math:`TB = PA = 1`
+    the resulting :math:`0/0` is replaced with :math:`1`,
+    since every spike from the train with :math:`T = 1` is within
+    `[-dt, +dt]` of a spike of the other train.
+    This is a Python implementation compatible with the elephant library of
+    the original code by C. Cutts written in C and available `here
+    <https://github.com/CCutts/Detecting_pairwise_correlations_in_spike_trains/
+    blob/master/spike_time_tiling_coefficient.c>`_:
+    """
+
+    N1 = len(spiketrain_a)
+    N2 = len(spiketrain_b)
+
+    if N1 == 0 or N2 == 0:
+        index = np.nan
+    else:
+        TA = run_t(spiketrain_a, end_time=end_time, start_time=start_time, dt=dt)
+        TB = run_t(spiketrain_b, end_time=end_time, start_time=start_time, dt=dt)
+        PA = run_p(spiketrain_a, spiketrain_b, dt=dt)
+        PA = PA / N1
+        PB = run_p(spiketrain_b, spiketrain_a, dt=dt)
+        PB = PB / N2
+        # check if the P and T values are 1 to avoid division by zero
+        # This only happens for TA = PB = 1 and/or TB = PA = 1,
+        # which leads to 0/0 in the calculation of the index.
+        # In those cases, every spike in the train with P = 1
+        # is within dt of a spike in the other train,
+        # so we set the respective (partial) index to 1.
+        if PA * TB == 1:
+            if PB * TA == 1:
+                index = 1.
+            else:
+                index = 0.5 + 0.5 * (PB - TA) / (1 - PB * TA)
+        elif PB * TA == 1:
+            index = 0.5 + 0.5 * (PA - TB) / (1 - PA * TB)
+        else:
+            index = 0.5 * (PA - TB) / (1 - PA * TB) + 0.5 * (PB - TA) / (1 - PB * TA)
+
+    return index
+
+
+@jit(nopython=True, fastmath=True, cache=True)
+def run_p(spiketrain_a, spiketrain_b, dt=0.005):
+    """
+    Check every spike in train 1 to see if there's a spike in train 2
+    within dt
+    """
+    N2 = len(spiketrain_b)
+
+    # Search spikes of spiketrain_i in spiketrain_j
+    # ind will contain index of
+    ind = np.searchsorted(spiketrain_b, spiketrain_a)
+
+    # To prevent IndexErrors
+    # If a spike of spiketrain_i is after the last spike of spiketrain_j,
+    # the index is N2, however spiketrain_j[N2] raises an IndexError.
+    # By shifting this index, the spike of spiketrain_i will be compared
+    # to the last 2 spikes of spiketrain_j (negligible overhead).
+    # Note: Not necessary for index 0 that will be shifted to -1,
+    # because spiketrain_j[-1] is valid (additional negligible comparison)
+    ind[ind == N2] = N2 - 1
+
+    # Compare to nearest spike in spiketrain_j BEFORE spike in spiketrain_i
+    close_left = np.abs(spiketrain_b[ind - 1] - spiketrain_a) <= dt
+    # Compare to nearest spike in spiketrain_j AFTER (or simultaneous)
+    # spike in spiketrain_j
+    close_right = np.abs(spiketrain_b[ind] - spiketrain_a) <= dt
+
+    # spiketrain_j spikes that are in [-dt, dt] range of spiketrain_i
+    # spikes are counted only ONCE (as per original implementation)
+    close = close_left + close_right
+
+    # Count how many spikes in spiketrain_i have a "partner" in
+    # spiketrain_j
+    return np.count_nonzero(close)
+
+
+@jit(nopython=True, fastmath=True, cache=True)
+def run_t(spiketrain, end_time, start_time=0, dt=0.005):
+    """
+    Calculate the proportion of the total recording time 'tiled' by spikes.
+    """
+    N = len(spiketrain)
+    time_A = 2 * N * dt  # maximum possible time
+
+    if N == 1:  # for only a single spike in the train
+
+        # Check difference between start of recording and single spike
+        if spiketrain[0] - start_time < dt:
+            time_A += - dt + spiketrain[0] - start_time
+
+        # Check difference between single spike and end of recording
+        elif spiketrain[0] + dt > end_time:
+            time_A += - dt - spiketrain[0] + end_time
+
+    else:  # if more than a single spike in the train
+
+        # Calculate difference between consecutive spikes
+        diff = np.diff(spiketrain)
+
+        # Find spikes whose tiles overlap
+        idx = np.where(diff < 2 * dt)[0]
+        # Subtract overlapping "2*dt" tiles and add differences instead
+        time_A += - 2 * dt * len(idx) + diff[idx].sum()
+
+        # Check if spikes are within +/-dt of the start and/or end
+        # if so, subtract overlap of first and/or last spike
+        if spiketrain[0] - start_time < dt:
+            time_A += spiketrain[0] - start_time - dt
+        if (end_time - spiketrain[N - 1]) < dt:
+            time_A += - spiketrain[-1] - dt + end_time
+
+    # Calculate the proportion of total recorded time to "tiled" time
+    T = time_A / end_time
+    return T
+
+
+if __name__ == "__main__":
+
+    time_a = np.sort(np.random.uniform(low=0, high=10, size=10))
+    time_b = np.sort(np.random.uniform(low=0, high=10, size=10))
+
+    run_p(time_a, time_b, dt=0.005)
+    run_t(time_a, end_time=10, dt=0.005)
+
+    spike_time_tiling_coefficient(time_a, time_b, end_time=10)
+
diff --git a/snudda/detect/detect.py b/snudda/detect/detect.py
index 12fec2f57..aa1552d88 100644
--- a/snudda/detect/detect.py
+++ b/snudda/detect/detect.py
@@ -705,7 +705,7 @@ def get_density_location(self, neuron, seed):
             axon_loc = np.floor((axon_cloud[:, :3] - self.simulation_origo) / self.hyper_voxel_width).astype(int)
 
         if axon_loc is not None:
-            inside_idx = np.logical_and(0 <= axon_loc, axon_loc < self.hyper_voxel_id_lookup.shape[None, :])
+            inside_idx = np.sum(np.logical_and(0 <= axon_loc, axon_loc < self.hyper_voxel_id_lookup.shape), axis=1) == 3
             hyper_voxel_id = np.unique(self.hyper_voxel_id_lookup[tuple(axon_loc[inside_idx, :].T)])
 
         return hyper_voxel_id
@@ -1355,12 +1355,14 @@ def place_synapses_no_axon(self, hyper_id, voxel_space, voxel_space_ctr,
             # No neurons without axons
             return
 
-        for na_neuron in no_axon_neurons:
+        for na_neuron_id in no_axon_neurons:
 
             # There are two types of axon density specified
             # - Spherically symmetric
             # - f(x,y,z) in SWC coordinates
 
+            na_neuron = self.neurons[na_neuron_id]
+
             if na_neuron["axonDensityType"] == "r":
 
                 # 2. Check that we have cumulative probability distribution for
@@ -2380,6 +2382,11 @@ def distribute_neurons_parallel(self, d_view=None):
 
                     self.hyper_voxels[hid]["neurons"][neuron_id] = hv[hid]["neurons"][neuron_id]
 
+                for neuron_id in hv[hid]["axon_density"]:
+                    assert neuron_id not in self.hyper_voxels[hid]["axon_density"], \
+                        f"Internal error, neuron_id {neuron_id} already exists hyper_voxel {hid} (axon_density)"
+                    self.hyper_voxels[hid]["axon_density"].append(neuron_id)
+
         # Sort for reproducibility
         self.count_and_sort_neurons_in_hypervoxels()
         self.generate_hyper_voxel_random_seeds()
@@ -3145,10 +3152,6 @@ def process_hyper_voxel(self, hyper_id):
                                               section_id=section_id,
                                               subtree=subtree)
 
-            # if hyper_id == 813:   #56:
-            #     import pdb
-            #     pdb.set_trace()
-
             # This should be outside the neuron loop
             # This places axon voxels for neurons without axon morphologies
             self.place_synapses_no_axon(hyper_id,
diff --git a/snudda/detect/prune.py b/snudda/detect/prune.py
index c0ee7b2e3..3291de4a1 100644
--- a/snudda/detect/prune.py
+++ b/snudda/detect/prune.py
@@ -687,7 +687,7 @@ def load_pruning_information(self, config_file=None):
         with open(config_file, "r") as f:
             self.config = json.load(f, object_pairs_hook=collections.OrderedDict)
 
-        self.population_unit_id = self.hist_file["network/neurons/populationUnitID"][()]
+        self.population_unit_id = self.hist_file["network/neurons/populationUnitID"][()].copy()
 
         # Normally we use type names as lookups, but since we will do this
         # many millions of times, we create an temporary typeID number
diff --git a/snudda/init/init.py b/snudda/init/init.py
index e3bd92c2e..c64e72c47 100644
--- a/snudda/init/init.py
+++ b/snudda/init/init.py
@@ -919,7 +919,7 @@ def define_striatum(self,
             print("Using cube for striatum")
             # 1.73 million neurons, volume of allen striatal mesh is 21.5mm3
             striatum_volume = 1e-9 * num_neurons / neuron_density  # 80.5e3
-            striatum_side_len = striatum_volume ** (1. / 3)
+            striatum_side_len = np.maximum(striatum_volume ** (1. / 3), 50e-6)  # We do a minimum of 10 micrometer cube
             striatum_centre = np.array([4750e-6, 4000e-6, 7750e-6])
 
             if num_neurons < 500:
diff --git a/snudda/input/input.py b/snudda/input/input.py
index 002faa402..e9f024de1 100644
--- a/snudda/input/input.py
+++ b/snudda/input/input.py
@@ -543,8 +543,14 @@ def read_input_config_file(self):
         with open(snudda_parse_path(self.input_config_file, self.snudda_data), 'rt') as f:
             self.input_info = json.load(f, object_pairs_hook=OrderedDict)
 
+        max_time = self.time
+
         for neuron_type in self.input_info:
             for input_type in self.input_info[neuron_type]:
+
+                if "end" in self.input_info[neuron_type][input_type]:
+                    max_time = max(max_time, np.max(self.input_info[neuron_type][input_type]["end"]))
+
                 if "parameterFile" in self.input_info[neuron_type][input_type]:
                     # Allow user to use $DATA to refer to snudda data directory
                     par_file = snudda_parse_path(self.input_info[neuron_type][input_type]["parameterFile"],
@@ -577,6 +583,11 @@ def read_input_config_file(self):
                     self.write_log(f"Did you forget to specify the name of the input to {neuron_type}?")
                     sys.exit(-1)
 
+        if max_time > self.time:
+            self.write_log(f"Found input that ends at {max_time}, "
+                           f"increasing input generation from {self.time} to {max_time}", force_print=True)
+            self.time = max_time
+
     ############################################################################
 
     # Each synaptic input will contain a fraction of population unit spikes, which are
@@ -618,8 +629,13 @@ def make_population_unit_spike_trains(self, rng):
                     if type(pop_unit_list) != list:
                         pop_unit_list = [pop_unit_list]
                 else:
+                    # We do not want to generate "global" mother spikes for population unit 0
+                    # For population unit 0, mother spikes are unique to each neuron
                     pop_unit_list = self.all_population_units
 
+                # This makes sure that we do not give population unit wide mother spikes to population unit 0
+                pop_unit_list = set(pop_unit_list) - {0}
+
                 if input_type == "VirtualNeuron":
                     # No population unit spike trains needed for virtual neurons, reads input from file
                     pass
@@ -1678,10 +1694,10 @@ def read_network_config_file(self):
                 if "unitID" in self.network_config["PopulationUnits"][volume]:
                     all_id += self.network_config["PopulationUnits"][volume]["unitID"]
 
-            all_id = sorted(all_id)
+            all_id = set(all_id) - {0}
 
             if "AllUnitID" in self.network_config["PopulationUnits"]:
-                self.all_population_units = sorted(self.network_config["PopulationUnits"]["AllUnitID"])
+                self.all_population_units = set(self.network_config["PopulationUnits"]["AllUnitID"])
                 assert all_id == self.all_population_units, \
                     (f"Inconsistency: AllUnitID = {self.all_population_units}, "
                      f"but all units in unitID blocks = {all_id}")
@@ -1690,7 +1706,7 @@ def read_network_config_file(self):
                 self.all_population_units = all_id
 
         else:
-            self.all_population_units = [0]
+            self.all_population_units = {}
 
     def generate_seeds(self, num_states):
 
@@ -2089,7 +2105,7 @@ def make_input_helper_serial(self,
             input_loc = None
 
             num_inputs = 1
-            p_keep = np.divide(1, (num_inputs - np.sqrt(correlation) * (num_inputs - 1)))
+            p_keep = np.sqrt(correlation)
 
             # !!! Pass the input_generator
             spikes = self.make_correlated_spikes(freq=freq,
diff --git a/snudda/neurons/neuron_morphology_extended.py b/snudda/neurons/neuron_morphology_extended.py
index 2e6750dcc..f7904dc04 100644
--- a/snudda/neurons/neuron_morphology_extended.py
+++ b/snudda/neurons/neuron_morphology_extended.py
@@ -60,7 +60,7 @@ def __init__(self,
 
         # Can we remove these:
         self.axon_density_type = None
-        self.dend_density = None
+        # self.dend_density = None
         self.axon_density = None
         self.max_axon_radius = None
         self.axon_density_bounds_xyz = None
@@ -220,6 +220,19 @@ def clone(self,
 
         new_neuron.load_morphology = self.load_morphology
 
+        new_neuron.max_axon_radius = self.max_axon_radius
+
+        if self.axon_density is not None:
+            new_neuron.axon_density = self.axon_density
+
+        new_neuron.voxel_size = self.voxel_size
+
+        if self.axon_density_type is not None:
+            new_neuron.axon_density_type = self.axon_density_type
+
+        if self.axon_density_bounds_xyz is not None:
+            new_neuron.axon_density_bounds_xyz = self.axon_density_bounds_xyz
+
         return new_neuron
 
     def get_section_coordinates(self, section_id, section_x):
diff --git a/snudda/optimise/optimise_pruning.py b/snudda/optimise/optimise_pruning.py
new file mode 100644
index 000000000..e23109497
--- /dev/null
+++ b/snudda/optimise/optimise_pruning.py
@@ -0,0 +1,231 @@
+import os
+import json
+import collections
+import numpy as np
+import h5py
+
+from snudda.utils import SnuddaLoad
+from snudda.detect import SnuddaPrune
+
+from scipy.stats import binomtest
+from scipy.spatial import distance_matrix
+from scipy.optimize import differential_evolution
+
+import uuid
+
+
+class OptimisePruning:
+
+    """ Optimises pruning parameters. First it creates a relatively small network and does touch detection on it.
+        After that it does multiple pruning attempts (while keeping the files original detection files). """
+
+    def __init__(self, network_path, pop_size=10, epochs=10):
+
+        self.network_path = network_path
+        self.pop_size = pop_size
+        self.epochs = epochs
+
+        self.prune = SnuddaPrune(network_path=network_path, keep_files=True)
+
+        self.merge_files_syn = None
+        self.merge_neuron_range_syn = None
+        self.merge_syn_ctr = None
+        self.merge_files_gj = None
+        self.merge_neuron_range_gj = None
+        self.merge_gj_ctr = None
+
+        self.optimisation_info = dict()
+
+        self.log_file = None
+
+    def merge_putative_synapses(self):
+
+        merge_info = self.prune.get_merge_info()
+
+        if merge_info:
+            merge_files_syn, merge_neuron_range_syn, merge_syn_ctr, \
+            merge_files_gj, merge_neuron_range_gj, merge_gj_ctr = merge_info
+        else:
+            # From the hyper voxels gather all synapses (and gap junctions) belonging to specific neurons
+            merge_files_syn, merge_neuron_range_syn, merge_syn_ctr, \
+            merge_files_gj, merge_neuron_range_gj, merge_gj_ctr = self.prune.gather_neuron_synapses()
+
+            self.prune.save_merge_info(merge_files_syn=merge_files_syn,
+                                       merge_neuron_range_syn=merge_neuron_range_syn,
+                                       merge_syn_ctr=merge_syn_ctr,
+                                       merge_files_gj=merge_files_gj,
+                                       merge_neuron_range_gj=merge_neuron_range_gj,
+                                       merge_gj_ctr=merge_gj_ctr)
+
+        self.merge_files_syn = merge_files_syn
+        self.merge_neuron_range_syn = merge_neuron_range_syn
+        self.merge_syn_ctr = merge_syn_ctr
+        self.merge_files_gj = merge_files_gj
+        self.merge_neuron_range_gj = merge_neuron_range_gj
+        self.merge_gj_ctr = merge_gj_ctr
+
+    def prune_synapses(self, pre_type, post_type, con_type, pruning_parameters, output_file):
+
+        """ Prunes the network keeping only synapses between pre_type and post_type, using pruning_parameters
+
+        Args:
+            pre_type (str) : presynaptic neuron type (e.g. "FS")
+            post_type (str) : postsynaptic neuron type (e.g. "dSPN")
+            con_type (str) : type of connection (e.g. "GABA")
+            pruning_parameters (dict) :
+        """
+
+        self.prune.load_pruning_information()
+
+        orig_connectivity_distributions = json.loads(self.prune.hist_file["meta/connectivityDistributions"][()],
+                                                     object_pairs_hook=collections.OrderedDict)
+
+        # Next overwrite the pruning parameters
+        pre_type_id = self.prune.type_id_lookup[pre_type]
+        post_type_id = self.prune.type_id_lookup[post_type]
+        orig_key = f"{pre_type}$${post_type}"
+        synapse_type_id = orig_connectivity_distributions[orig_key][con_type]["channelModelID"]
+
+        pruning = self.prune.complete_pruning_info(pruning_parameters)
+        pruning_other = None
+
+        self.prune.connectivity_distributions = dict([])
+        self.prune.connectivity_distributions[pre_type_id, post_type_id, synapse_type_id] = (pruning, pruning_other)
+
+        assert len(self.merge_files_syn) == 1, f"merge_Files_syn should be a list with one file only"
+
+        with h5py.File(self.merge_files_syn[0], "r") as f_syn:
+            print(f"Writing file {output_file}")
+            # We need to make sure that we keep the pruned data files separate
+            self.prune.prune_synapses(synapse_file=f_syn,
+                                      output_filename=output_file,
+                                      row_range=None,
+                                      close_out_file=True,
+                                      close_input_file=True,
+                                      merge_data_type="synapses")
+
+            if not os.path.exists(output_file):
+                print(f"Output file missing {output_file}")
+                import pdb
+                pdb.set_trace()
+
+    def evaluate_fitness(self, pre_type, post_type, output_file, experimental_data, avg_num_synapses_per_pair=None):
+
+        """
+
+            Args:
+                pre_type
+                post_type
+                output_file: path to output file from prune
+                experiment_data: [(bin start, bin end, P)]
+                avg_num_synapses_per_pair: (avg_num, error_weight)
+
+        """
+
+        print(f"Opening {output_file}")
+        snudda_load = SnuddaLoad(network_file=output_file)
+        snudda_data = snudda_load.data
+
+        connection_matrix = np.zeros((snudda_data["nNeurons"], snudda_data["nNeurons"]))
+
+        pre_id = snudda_load.get_neuron_id_of_type(neuron_type=pre_type)
+        post_id = snudda_load.get_neuron_id_of_type(neuron_type=post_type)
+
+        pre_mask = np.zeros((snudda_data["nNeurons"],), dtype=bool)
+        post_mask = np.zeros((snudda_data["nNeurons"],), dtype=bool)
+
+        pre_mask[pre_id] = True
+        post_mask[post_id] = True
+
+        for row in snudda_data["synapses"]:
+            if pre_mask[row[0]] and post_mask[row[1]]:
+                # Only include connections between the right pre and post types
+                connection_matrix[row[0], row[1]] += 1
+
+        pos = snudda_data["neuronPositions"]
+        dist_matrix = distance_matrix(pos, pos)
+
+        n_connected = np.zeros((len(experimental_data),), dtype=int)
+        n_total = np.zeros((len(experimental_data),), dtype=int)
+        n_syn = 0
+        n_pairs = 0
+
+        for dist, con in zip(dist_matrix.flatten(), connection_matrix.flatten()):
+
+            if con > 0:
+                n_syn += con
+                n_pairs += 1
+
+            for idx, (bin_start, bin_end, _) in enumerate(experimental_data):
+                if bin_start <= dist <= bin_end:
+                    n_total[idx] += 1
+                    if con > 0:
+                        n_connected[idx] += 1
+
+        p_hyp = np.zeros((len(experimental_data), ))
+
+        for idx, (n_con, n_tot, p_exp) in enumerate(zip(n_connected, n_total, [x[2] for x in experimental_data])):
+            # test = binomtest(n_con, n_tot, p_exp)
+            # p_hyp[idx] = test.pvalue  # gave 0 when p values are too far apart, not informative
+            p_hyp[idx] = abs(n_con/n_tot - p_exp)
+
+        if avg_num_synapses_per_pair is not None:
+            per_pair_error = abs(avg_num_synapses_per_pair[0] - n_syn/n_pairs)
+            error = np.sum(p_hyp) + per_pair_error * avg_num_synapses_per_pair[1]  # * Weight of error
+        else:
+            error = np.sum(p_hyp)
+
+        return error
+
+    def helper_func(self, x):
+
+        pruning_parameters = dict()
+        pruning_parameters |= self.optimisation_info["extra_pruning_parameters"]
+
+        pruning_parameters["f1"] = x[0]
+        pruning_parameters["softMax"] = x[1]
+        pruning_parameters["mu2"] = x[2]
+        pruning_parameters["a3"] = x[3]
+
+        output_file = os.path.join(self.network_path, "temp", f"network-synapses-{uuid.uuid4()}.hdf5")
+        print(f"Output file {output_file}")
+
+        self.prune_synapses(pre_type=self.optimisation_info["pre_type"],
+                            post_type=self.optimisation_info["post_type"],
+                            con_type=self.optimisation_info["con_type"],
+                            pruning_parameters=pruning_parameters,
+                            output_file=output_file)
+
+        fitness = self.evaluate_fitness(pre_type=self.optimisation_info["pre_type"],
+                                        post_type=self.optimisation_info["post_type"],
+                                        output_file=output_file,
+                                        experimental_data=self.optimisation_info["exp_data"])
+
+        self.optimisation_info["ctr"] += 1
+
+        print(f"({self.optimisation_info['ctr'] }) Evaluating f1 = {x[0]}, SM = {x[1]}, mu2 = {x[2]}, a3 = {x[3]}, fitness: {fitness}")
+
+        self.log_file.write(f"{self.optimisation_info['ctr']}, {pruning_parameters['f1']}, "
+                            f"{pruning_parameters['softMax']}, {pruning_parameters['mu2']}, "
+                            f"{pruning_parameters['a3']}, {fitness}, {output_file}\n")
+
+        return fitness
+
+    def optimize(self, pre_type, post_type, con_type, experimental_data, extra_pruning_parameters, workers=1):
+
+        self.log_file = open(os.path.join(self.network_path, f"{pre_type}-{post_type}-{con_type}-optimisation-log.txt"), "wt")
+
+        self.optimisation_info["pre_type"] = pre_type
+        self.optimisation_info["post_type"] = post_type
+        self.optimisation_info["con_type"] = con_type
+        self.optimisation_info["exp_data"] = experimental_data
+        self.optimisation_info["extra_pruning_parameters"] = extra_pruning_parameters
+        self.optimisation_info["ctr"] = 0
+
+        bounds = [(0, 1), (0, 20), (0, 5), (0, 1)]
+
+        res = differential_evolution(func=self.helper_func, bounds=bounds, workers=workers)
+
+        self.log_file.close()
+
+        return res
\ No newline at end of file
diff --git a/snudda/todo-2020-12-18.txt b/snudda/todo-2020-12-18.txt
deleted file mode 100644
index 01af9ae7d..000000000
--- a/snudda/todo-2020-12-18.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-
-* Ability to set random seed for cell placement.
-* Ability to set random seed for pruning.
-
-* Double check that no randomness is used in detection, should not be...
-
-
-* Benchmarking
-* Proof of correctness (verification)
-* Simpler examples, step by step.
-
-* Clearer explanation of how pruning is setup and tuned
-
-
-* Synaptic input, opaque -- clearer examples
--- better documentation
-
-
-
-We are open source.
-We allow distance dependent pruning.


Test patch:
diff --git a/tests/networks/network_testing_input/input-test-1.json b/tests/networks/network_testing_input/input-test-1.json
index 981832a9e..64d4de886 100644
--- a/tests/networks/network_testing_input/input-test-1.json
+++ b/tests/networks/network_testing_input/input-test-1.json
@@ -88,7 +88,7 @@
 	    "type" : "AMPA_NMDA",
 	    "synapseDensity": "50*0.092*(1-exp(-d/200e-6))",	    
 	    "frequency" : 1,
-	    "populationUnitCorrelation" : 0.2,
+	    "populationUnitCorrelation" : 0,
 	    "jitter" : 0.00,
 	    "conductance" : 1.5e-9,	    
 	    "modFile": "tmGlut",
diff --git a/tests/networks/network_testing_input/network-config.json b/tests/networks/network_testing_input/network-config.json
index 5c0ac6bcd..750b6926e 100644
--- a/tests/networks/network_testing_input/network-config.json
+++ b/tests/networks/network_testing_input/network-config.json
@@ -13,8 +13,8 @@
         "Striatum": {
             "type": "mesh",
             "dMin": 1.5e-05,
-            "meshFile": "networks/network_testing_input/mesh/Striatum-cube-mesh-4.989626526218353e-05.obj",
-            "meshBinWidth": 4.989626526218353e-05
+            "meshFile": "networks/network_testing_input/mesh/Striatum-cube-mesh-5e-05.obj",
+            "meshBinWidth": 5e-05
         }
     },
     "Connectivity": {