Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,5 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+README.pdf filter=lfs diff=lfs merge=lfs -text
+src/networks_graphs/Con100_Cleft50/graph.graphml filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,3 +1,71 @@
 ---
 license: agpl-3.0
+tags:
+- reservoir-computing
+- echo-state-networks
+- connectomics
+- drone-control
+- robotics
+- pybullet
+- neuroscience
+metrics:
+- rmse
 ---
+
+# Fly Connectome Echo State Network for Drone Control
+
+This repository contains research and simulation code that utilizes biological neural connectivity data (the connectome of the *Drosophila melanogaster* fruit fly) as the reservoir inside an **Echo State Network (ESN)** to perform autonomous drone flight control.
+
+## Project Overview
+
+* **Biological Reservoir**: The network reservoir is built from the synaptic connectivity graph of the fly brain. We scale the spectral radius of the graph below `1.0` to guarantee the Echo State Property and stabilize neural dynamics.
+* **Drone Control Task**: The network is trained using Ridge Regression to output 4D control signals (target velocities: $v_x$, $v_y$, $v_z$, and yaw rate) from a 12D drone state vector.
+* **Simulation Environment**: Real-time evaluation is conducted using `gym-pybullet-drones`, a physics engine simulating ground effect, aerodynamic drag, and rotor downwash.
+
+## Directory Structure
+
+```text
+flydrone-esn/
+│
+├── README.md                     # English documentation (with HF YAML front matter)
+├── README.txt                    # Detailed Turkish documentation
+├── requirements.txt              # Project dependencies
+│
+└── src/                          # Code files
+    ├── utils.py                  # Core mathematics and ESN reservoir helpers
+    ├── database_interaction.ipynb # CAVE API client for retrieving connectome synapses
+    ├── drone_data_collection.py  # Script to collect training trajectories in PyBullet
+    ├── drone_esn_training.py     # Script to train Wout using Ridge Regression
+    ├── drone_realtime_simulation.py # Script to run the trained model in PyBullet and log video
+    ├── classes_by_cell_type.csv  # Neuron cell classifications
+    └── networks_graphs/          # Connectome .graphml data files
+```
+
+## Setup and Quick Start
+
+### 1. Install Dependencies
+Make sure you have python 3.10 installed, then run:
+```bash
+pip install -r requirements.txt
+```
+
+### 2. Collect Training Data
+To collect drone state-action flight datasets (circular trajectories with sinusoidal height variation) in a headless PyBullet simulator, run:
+```bash
+python src/drone_data_collection.py
+```
+This generates the `src/drone_dataset.npz` data file.
+
+### 3. Train the Model
+To scale the connectome matrix and train output weights using Ridge Regression ($\beta = 10^{-6}$), run:
+```bash
+python src/drone_esn_training.py
+```
+This saves the trained ESN components inside `src/W_drone_components.pkl`.
+
+### 4. Run the Real-time Simulation
+To run the ESN-controlled drone in the PyBullet simulator with a graphical interface, run:
+```bash
+python src/drone_realtime_simulation.py
+```
+This runs the simulation and logs third-person and first-person camera flight recordings to `drone_third_person.mp4` and `drone_first_person.mp4` in your directory.

README.pdf

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:694d8bbd3a2c0b57c5529c5ee8bcca5f9af5e8995de85726102fd0168ec6eaf9
+size 83207257

requirements.txt

@@ -0,0 +1,11 @@
+numpy
+scipy
+pandas
+networkx
+scikit-learn
+matplotlib
+seaborn
+pybullet
+gym-pybullet-drones
+caveclient
+torch

src/W.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:636a1d86b4845c126da018f08407a29e8cb6be54de33af9353972b99409f986d
+size 14372683

src/W_drone_components.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:54d676045913356123f551a6c9611bbb8f9972dd0c0dc272039e9ba6f7b84ab7
+size 46624271

src/W_in.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f528b1d2e6b9103882df1463722426f7283f27ba955d21e3a9173e6bda61b489
+size 200162

src/W_out.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3ef54d3e8586776abfbb6a529b0d4053f24bb402fe447c1e6a3773d3eb1a8b7c
+size 200162

src/bias.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:34abd868c6bddd92b077cc86cddc2c953b1f5157ca587a43cdedc992bfa12397
+size 200160

src/database_interaction.ipynb

@@ -0,0 +1,471 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 0 Set up your version of cave-client "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# only run this one the first time to set up the token, then save your token in a file called token.txt\n",
+    "\n",
+    "import caveclient\n",
+    "import pandas as pd\n",
+    "import seaborn as sns\n",
+    "from matplotlib import pyplot as plt\n",
+    "import numpy as np\n",
+    "import time\n",
+    "import csv\n",
+    "import os\n",
+    "\n",
+    "\n",
+    "client = caveclient.CAVEclient()\n",
+    "client.auth.setup_token(make_new=True)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "with open('token.txt', 'r') as file:\n",
+    "    my_token = file.read().strip()\n",
+    "\n",
+    "datastack_name = \"flywire_fafb_public\"\n",
+    "client = caveclient.CAVEclient(datastack_name, auth_token=my_token)\n",
+    "\n",
+    "# Print all the available versions and relative timestamps\n",
+    "for version in client.materialize.get_versions():\n",
+    "    print(f\"Version {version}: {client.materialize.get_timestamp(version)}\")\n",
+    "\n",
+    "# Print all the available tables for queries\n",
+    "client.materialize.get_tables()\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 1 Fetch neurons from database\n",
+    "## 1.1 By neuron"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#this is to fetch neurons from the database\n",
+    "\n",
+    "cell_class_type_annos_df = client.materialize.query_table(\"hierarchical_neuron_annotations\", filter_in_dict={\"classification_system\": [\"cell_class\"]}) #cell type is another good one to look at\n",
+    "cell_class_type_annos_df\n",
+    "root_ids_cell_types = cell_class_type_annos_df[['pt_root_id', 'cell_type']]\n",
+    "root_ids_cell_types.to_csv('classes_by_cell_type.csv', index=False)\n",
+    "unique_cell_types = cell_class_type_annos_df['cell_type'].unique()\n",
+    "print(unique_cell_types)\n",
+    "\n",
+    "def read_csv_data(csv_file, cell_types=None):\n",
+    "    # FIX: column name was 'pt_root_id' instead of 'id', which was causing ValueError\n",
+    "    data = []\n",
+    "    with open(csv_file, 'r') as file:\n",
+    "        csv_reader = csv.reader(file)\n",
+    "        header = next(csv_reader)  # Skip the header row\n",
+    "        id_index = header.index('pt_root_id')\n",
+    "        cell_type_index = header.index('cell_type')\n",
+    "        for row in csv_reader:\n",
+    "            cell_id = int(row[id_index])\n",
+    "            cell_type = row[cell_type_index]\n",
+    "            if cell_types is None or cell_type in cell_types:\n",
+    "                data.append((cell_id, cell_type))\n",
+    "    return data\n",
+    "\n",
+    "csv_file = 'classes_by_cell_type.csv'\n",
+    "cell_types = ['CX', 'Kenyon_Cell']  # Example list of cell types\n",
+    "data = read_csv_data(csv_file, cell_types)\n",
+    "print(data)\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1.2 and by synapse"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This is to search from the database synapses\n",
+    "\n",
+    "\n",
+    "#  Fetch the list of neurons\n",
+    "neurons = client.materialize.query_table('proofread_neurons')\n",
+    "\n",
+    "# Extract unique neuron IDs\n",
+    "neuron_ids = neurons['pt_root_id'].unique()\n",
+    "\n",
+    "# Create a mapping from neuron ID to matrix index\n",
+    "neuron_id_to_index = {neuron_id: index for index, neuron_id in enumerate(neuron_ids)}\n",
+    "\n",
+    "if os.path.isfile('synapses.csv'):\n",
+    "    already_logged = set(pd.read_csv('synapses.csv')['pre_pt_root_id'])\n",
+    "else:\n",
+    "    already_logged = set()\n",
+    "\n",
+    "# Open the CSV file in write mode\n",
+    "with open('synapses.csv', 'a', newline='') as csvfile:\n",
+    "    csv_writer = csv.writer(csvfile)\n",
+    "    # Check if the file is empty\n",
+    "    if csvfile.tell() == 0:\n",
+    "        # Write the header row\n",
+    "        csv_writer.writerow(['id', 'pre_pt_root_id', 'post_pt_root_id', 'connection_score', 'cleft_score', 'gaba', 'ach', 'glut', 'oct', 'ser', 'da', 'valid_nt', 'pre_pt_supervoxel_id', 'post_pt_supervoxel_id', 'neuropil', 'pre_pt_position', 'post_pt_position'])\n",
+    "        \n",
+    "    # Iterate through each neuron to fetch its synapses\n",
+    "    for i, neuron_id in enumerate(neuron_ids):\n",
+    "        # Check if the neuron ID is already in the first column of the CSV file\n",
+    "        if neuron_id not in already_logged:\n",
+    "            # Fetch the synapses for the neuron\n",
+    "            neuron_start_time = time.time()\n",
+    "            flag = 0\n",
+    "            retries = 0\n",
+    "            max_retries = 5\n",
+    "            while flag == 0:\n",
+    "                try:\n",
+    "                    synapses = client.materialize.query_view(\"valid_synapses_nt_np_v6\", filter_in_dict={'pre_pt_root_id': [neuron_id]})\n",
+    "                    flag = 1\n",
+    "                except Exception as e:\n",
+    "                    # FIX: bare except was swallowing all exceptions (including KeyboardInterrupt)\n",
+    "                    # and never printing the cause. Now it logs the error and retries with a limit.\n",
+    "                    retries += 1\n",
+    "                    print(f\"Lost connection on neuron {i} ({e}), retrying ({retries}/{max_retries})...\")\n",
+    "                    if retries >= max_retries:\n",
+    "                        print(f\"Giving up on neuron {i} after {max_retries} retries.\")\n",
+    "                        break\n",
+    "                    time.sleep(10)\n",
+    "                    with open('token.txt', 'r') as file:\n",
+    "                        my_token = file.read().strip()\n",
+    "\n",
+    "                    datastack_name = \"flywire_fafb_public\"\n",
+    "                    client = caveclient.CAVEclient(datastack_name, auth_token=my_token)\n",
+    "\n",
+    "            if flag == 0:\n",
+    "                continue\n",
+    "\n",
+    "            for _, synapse in synapses.iterrows():\n",
+    "                list_to_write = []\n",
+    "                for elem in ['id', 'pre_pt_root_id', 'post_pt_root_id', 'connection_score', 'cleft_score', 'gaba', 'ach', 'glut', 'oct', 'ser', 'da', 'valid_nt', 'pre_pt_supervoxel_id', 'post_pt_supervoxel_id', 'neuropil', 'pre_pt_position', 'post_pt_position']:\n",
+    "                    list_to_write += [synapse[elem]]    \n",
+    "                \n",
+    "                # Write the synapse details to the CSV file\n",
+    "                csv_writer.writerow(list_to_write)\n",
+    "            \n",
+    "            # Calculate elapsed time and estimate remaining time\n",
+    "            elapsed_time = time.time() - neuron_start_time\n",
+    "            print(f\"Processed neuron {i+1}/{len(neuron_ids)} in {elapsed_time:.2f} seconds\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 1.3 This is just to check the presence of specific cells inside a .csv file\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#this it too check stuff from a specific .csv file\n",
+    "import csv\n",
+    "\n",
+    "csv_file = 'classes_by_cell_type.csv'\n",
+    "cell_types = ['olfactory', 'visual', 'mechanosensory', 'hygrosensory', 'unknown_sensory', 'ocellar', 'gustatory', 'thermosensory']  # Example list of cell types\n",
+    "\n",
+    "data = []\n",
+    "with open(csv_file, 'r') as file:\n",
+    "    csv_reader = csv.reader(file)\n",
+    "    header = next(csv_reader)  # Skip the header row\n",
+    "    id_index = header.index('pt_root_id')\n",
+    "    cell_type_index = header.index('cell_type')\n",
+    "    for row in csv_reader:\n",
+    "        cell_id = int(row[id_index])\n",
+    "        cell_type = row[cell_type_index]\n",
+    "        if cell_types is None or cell_type in cell_types:\n",
+    "            data.append((cell_id, cell_type))\n",
+    "\n",
+    "data_dict = {cell_id: cell_type for cell_id, cell_type in data}\n",
+    "\n",
+    "\n",
+    "\n",
+    "print(data)\n",
+    "len(data)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 2 This creates a graph from the .csv (make sure you have the .csv in the right place). IMPORTANT: threshold_connection and threshold_cleft are your quality selection parameters"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "\n",
+    "import csv\n",
+    "import networkx as nx\n",
+    "import torch\n",
+    "import random\n",
+    "import numpy as np\n",
+    "import pickle\n",
+    "import os\n",
+    "\n",
+    "threshold_connection = 100 # at the moment this is fully arbitrary and should be changed\n",
+    "threshold_cleft = 50\n",
+    "\n",
+    "# here is the function that will determine the sign of the neurotransmitter\n",
+    "\n",
+    "def synapse_characteristics(cell_type, neurotransmitter):\n",
+    "    # General neurotransmitter effects for excitatory/inhibitory/modulatory\n",
+    "    neurotransmitter_effects = {\n",
+    "        \"gaba\": \"inhibitory\",\n",
+    "        \"ach\": \"excitatory\",\n",
+    "        \"glut\": \"excitatory\",\n",
+    "        \"oct\": \"modulatory\",\n",
+    "        \"ser\": \"modulatory\",\n",
+    "        \"da\": \"modulatory\"\n",
+    "    }\n",
+    "\n",
+    "    # Cell type-specific effects and threshold modulation patterns\n",
+    "    cell_type_effects = {\n",
+    "        \"kenyon_cell\": {\"ach\": (\"excitatory\", \"lower\")},\n",
+    "        \"alpn\": {\"glut\": (\"excitatory\", None)},\n",
+    "        \"alln\": {\"gaba\": (\"inhibitory\", None), \"ach\": (\"mixed\", None)},\n",
+    "        \"dan\": {\"da\": (\"modulatory\", \"lower\")},\n",
+    "        \"mbon\": {\"da\": (\"modulatory\", \"lower\"), \"ach\": (\"excitatory\", None), \"gaba\": (\"inhibitory\", None)},\n",
+    "        \"lo\": {\"glut\": (\"excitatory\", None), \"ach\": (\"excitatory\", None)},\n",
+    "        \"me\": {\"glut\": (\"excitatory\", None), \"ach\": (\"excitatory\", None)},\n",
+    "        \"visual\": {\"glut\": (\"excitatory\", None)},\n",
+    "        \"olfactory\": {\"glut\": (\"excitatory\", None)},\n",
+    "        \"mechanosensory\": {\"glut\": (\"excitatory\", \"lower\"), \"oct\": (\"modulatory\", \"lower\")},\n",
+    "        \"clock\": {\"da\": (\"modulatory\", \"lower\"), \"ser\": (\"modulatory\", \"raise\")},\n",
+    "        \"lhcent\": {\"gaba\": (\"inhibitory\", None), \"glut\": (\"excitatory\", None), \"ser\": (\"modulatory\", \"raise\")},\n",
+    "        \"alin\": {\"gaba\": (\"inhibitory\", None)},\n",
+    "        \"lhln\": {\"gaba\": (\"inhibitory\", None)},\n",
+    "        \"tpn\": {\"oct\": (\"modulatory\", \"lower\")}\n",
+    "    }\n",
+    "\n",
+    "    # Standardize inputs to lowercase for matching\n",
+    "    neurotransmitter = neurotransmitter.lower()\n",
+    "    cell_type = cell_type.lower()\n",
+    "\n",
+    "    # Check if the cell type has specific rules for the neurotransmitter\n",
+    "    if cell_type in cell_type_effects:\n",
+    "        cell_rules = cell_type_effects[cell_type]\n",
+    "        if neurotransmitter in cell_rules:\n",
+    "            effect, threshold_modulation = cell_rules[neurotransmitter]\n",
+    "            return effect, threshold_modulation\n",
+    "\n",
+    "    # Default to general neurotransmitter effects if no cell-specific rule found\n",
+    "    effect = neurotransmitter_effects.get(neurotransmitter, \"unknown\")\n",
+    "    threshold_modulation = None  # Default to None if no specific modulation information\n",
+    "    return effect, threshold_modulation\n",
+    "\n",
+    "# Step 0: get the class of every cell\n",
+    "\n",
+    "csv_file = 'classes_by_cell_type.csv'\n",
+    "cell_classes = {}\n",
+    "biases = {}\n",
+    "with open(csv_file, 'r') as file:\n",
+    "    csv_reader = csv.reader(file)\n",
+    "    header = next(csv_reader)  # Skip the header row\n",
+    "    id_index = header.index('pt_root_id')\n",
+    "    cell_type_index = header.index('cell_type')\n",
+    "    for row in csv_reader:\n",
+    "        cell_id = row[id_index]\n",
+    "        cell_type = row[cell_type_index]\n",
+    "        if cell_id not in cell_classes.keys():\n",
+    "            cell_classes.update({cell_id: cell_type})\n",
+    "            biases.update({cell_id: 0})\n",
+    "\n",
+    "neuro_transmitters = [\"gaba\",\"ach\",\"glut\",\"oct\",\"ser\",\"da\"]\n",
+    "\n",
+    "# Step 1: Read the CSV file\n",
+    "# FIX: file name was 'synapses_complete.csv' but it was never created anywhere.\n",
+    "# Since the file written in 1.2 is 'synapses.csv', it should be used here as well.\n",
+    "with open('synapses.csv', 'r') as file:\n",
+    "    print('initializing reader')\n",
+    "    csv_reader = csv.reader(file)\n",
+    "    print('reader done')\n",
+    "    header = next(csv_reader)  # Skip the header row\n",
+    "\n",
+    "    # Step 2: Initialize a NetworkX graph\n",
+    "    print('initializing graph')\n",
+    "    G = nx.DiGraph()\n",
+    "    print('graph done')\n",
+    "\n",
+    "    # Step 3: Add edges to the graph\n",
+    "    current_row = 0\n",
+    "\n",
+    "    # FIX: file was already opened and header skipped; file.seek(0) + next()\n",
+    "    # was doing the same thing redundantly. Removed.\n",
+    "\n",
+    "    # Iterate through each row in the CSV file\n",
+    "    unique_neurons = 0\n",
+    "    for row in csv_reader:\n",
+    "        if float(row[3]) > threshold_connection and float(row[4]) > threshold_cleft and row[1] in cell_classes.keys() and row[2] in cell_classes.keys():\n",
+    "            source = row[1]  # Assuming the source column is at index 1\n",
+    "            target = row[2]  # Assuming the target column is at index 2\n",
+    "            weight = float(row[3])  # Assuming the weight column is at index 3\n",
+    "            neuro_trs = neuro_transmitters[np.argmax([float(row[5]), float(row[6]), float(row[7]), float(row[8]), float(row[9]), float(row[10])])]\n",
+    "\n",
+    "            if target in cell_classes.keys():\n",
+    "                tmp_cell_class = cell_classes[target]\n",
+    "            else:\n",
+    "                tmp_cell_class = \"unknown\"\n",
+    "            effect, threshold_modulation = synapse_characteristics(tmp_cell_class, neuro_trs)\n",
+    "\n",
+    "            if effect == \"mixed\":\n",
+    "                effect = random.choice([\"excitatory\", \"inhibitory\"])\n",
+    "\n",
+    "            # FIX: target was already added to G as string, but the comparison checked 'int(target) not in G.nodes()'\n",
+    "            # -> due to type mismatch the condition was always True.\n",
+    "            is_new_node = target not in G.nodes()\n",
+    "\n",
+    "            if effect == \"excitatory\":\n",
+    "                G.add_edge(source, target, weight=weight)\n",
+    "            elif effect == \"inhibitory\":\n",
+    "                G.add_edge(source, target, weight=-weight)\n",
+    "            elif effect == \"modulatory\":\n",
+    "                if threshold_modulation == \"lower\": # there will probably be the need of modulation for these\n",
+    "                    biases[target] -= weight\n",
+    "                elif threshold_modulation == \"raise\":\n",
+    "                    biases[target] += weight\n",
+    "\n",
+    "            if effect in (\"excitatory\", \"inhibitory\") and is_new_node:\n",
+    "                unique_neurons += 1\n",
+    "\n",
+    "        # Update loading bar\n",
+    "        current_row += 1\n",
+    "        if current_row % 100000 == 0:\n",
+    "            print(f\"\\rRows processed: {current_row}     Unique neurons found: {unique_neurons} \", end='', flush=True)\n",
+    "    print(\"\\nProcessing complete.\")\n",
+    "\n",
+    "    directory = f\"networks_graphs/Con{threshold_connection}_Cleft{threshold_cleft}\"\n",
+    "    # FIX: added exist_ok=True to prevent FileExistsError if the directory already exists\n",
+    "    os.makedirs(directory, exist_ok=True)\n",
+    "\n",
+    "# Save the graph\n",
+    "is_directed = nx.is_directed(G)\n",
+    "print(f\"Is the graph directed? {is_directed}\")\n",
+    "nx.write_graphml(G, f\"{directory}/graph.graphml\")\n",
+    "# Save biases to a .pkl file\n",
+    "with open(f\"{directory}/biases.pkl\", 'wb') as file:\n",
+    "    pickle.dump(biases, file)\n",
+    "\n",
+    "if False:\n",
+    "\n",
+    "    #Step 4: Extract edge list\n",
+    "    edge_index = torch.tensor([(int(u), int(v)) for u, v in G.edges]).t().contiguous()\n",
+    "    edge_weight = torch.tensor([G[u][v]['weight'] for u, v in G.edges])\n",
+    "\n",
+    "    # Step 5: Create a PyTorch sparse matrix\n",
+    "    sparse_matrix = torch.sparse_coo_tensor(edge_index, edge_weight, (G.number_of_nodes(), G.number_of_nodes()))\n",
+    "\n",
+    "    print(sparse_matrix)\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import networkx as nx\n",
+    "\n",
+    "# Define the directory and file path\n",
+    "directory = f\"networks_graphs/Con{threshold_connection}_Cleft{threshold_cleft}\"\n",
+    "graph_path = f\"{directory}/graph.graphml\"\n",
+    "\n",
+    "# Load the graph\n",
+    "G = nx.read_graphml(graph_path)\n",
+    "if nx.is_directed(G):\n",
+    "    print(\"The graph is directed.\")\n",
+    "else:\n",
+    "    print(\"The graph is undirected.\")\n",
+    "\n",
+    "print(f\"Graph loaded with {G.number_of_nodes()} nodes and {G.number_of_edges()} edges.\")\n",
+    "\n",
+    "# Keep only the largest connected component\n",
+    "largest_cc = max(nx.weakly_connected_components(G), key=len)\n",
+    "G = G.subgraph(largest_cc).copy()\n",
+    "\n",
+    "print(f\"Graph reduced to largest connected component with {G.number_of_nodes()} nodes and {G.number_of_edges()} edges.\")"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from scipy.sparse import csr_matrix\n",
+    "\n",
+    "# Convert the graph G to a scipy sparse matrix\n",
+    "sparse_matrix = nx.to_scipy_sparse_array(G, weight='weight', format='csr')\n",
+    "\n",
+    "# Compute the sparsity of the matrix\n",
+    "total_elements = sparse_matrix.shape[0] * sparse_matrix.shape[1]\n",
+    "nonzero_elements = sparse_matrix.nnz\n",
+    "sparsity = 1 - (nonzero_elements / total_elements)\n",
+    "print(f\"Sparsity of the matrix: {sparsity:.4f}\")\n",
+    "\n",
+    "# Check if the matrix is symmetrical\n",
+    "is_symmetric = (sparse_matrix != sparse_matrix.T).nnz == 0\n",
+    "print(f\"Is the matrix symmetrical? {'Yes' if is_symmetric else 'No'}\")\n",
+    "\n",
+    "# Save the sparse matrix to a pickle file\n",
+    "with open('W_whole_world.pkl', 'wb') as f:\n",
+    "    pickle.dump(sparse_matrix, f)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "fly_connectome_2",
+   "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.10.15"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

src/drone_data_collection.py

@@ -0,0 +1,68 @@
+import numpy as np
+import os
+import time
+
+try:
+    from gym_pybullet_drones.envs.VelocityAviary import VelocityAviary
+    from gym_pybullet_drones.utils.Logger import Logger
+    from gym_pybullet_drones.utils.utils import sync, str2bool
+except ImportError:
+    print("gym_pybullet_drones is not installed or available.")
+    print("Please make sure the environment is set up correctly.")
+    exit(1)
+
+def collect_data(num_steps=8000, save_path="drone_dataset.npz"):
+    """
+    Collects flight data for ESN training.
+    We will fly in a circle with varying height to generate dynamic states.
+    Inputs: 12D state (x,y,z, r,p,y, vx,vy,vz, wx,wy,wz)
+    Targets: 4D velocity ref (vx_ref, vy_ref, vz_ref, yaw_rate_ref)
+    """
+    BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+    if not os.path.isabs(save_path):
+        save_path = os.path.join(BASE_DIR, save_path)
+    INIT_XYZS = np.array([[0, 0, .5]])
+    INIT_RPYS = np.array([[0, 0, 0]])
+    
+    env = VelocityAviary(
+        gui=False,
+        record=False,
+        initial_xyzs=INIT_XYZS,
+        initial_rpys=INIT_RPYS
+    )
+    
+    states = []
+    targets = []
+    
+    obs, info = env.reset()
+    state = obs[0]
+    
+    for i in range(num_steps):
+        # Generate some target velocities for a figure-8 or circle
+        t = i / 100.0
+        vx_ref = 0.5 * np.cos(t)
+        vy_ref = 0.5 * np.sin(t)
+        vz_ref = 0.1 * np.sin(t/2.0)
+        yaw_rate_ref = 0.2 * np.cos(t)
+        
+        target_action = np.array([vx_ref, vy_ref, vz_ref, yaw_rate_ref])
+        
+        # Save state and target
+        states.append(state)
+        targets.append(target_action)
+        
+        # Step env (action is the target velocity)
+        obs, reward, terminated, truncated, info = env.step(np.array([target_action]))
+        state = obs[0]
+        
+    env.close()
+    
+    states = np.array(states)
+    targets = np.array(targets)
+    
+    # Save the data
+    np.savez(save_path, states=states, targets=targets)
+    print(f"Data saved to {save_path}. Collected {len(states)} steps.")
+
+if __name__ == "__main__":
+    collect_data(8000, "drone_dataset.npz")

src/drone_dataset.npz

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f3fd9e63f820321cf15bab6e5b02e38f11a9fb198af14d9d7893a17023f4e159
+size 1536512

src/drone_esn_training.py

@@ -0,0 +1,138 @@
+import numpy as np
+import pickle
+import scipy.sparse
+import os
+from utils import simulate
+
+def train_drone_esn(data_path="drone_dataset.npz"):
+    BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+    if not os.path.isabs(data_path):
+        data_path = os.path.join(BASE_DIR, data_path)
+
+    print("Loading data...")
+    if not os.path.exists(data_path):
+        print(f"{data_path} not found. Run drone_data_collection.py first.")
+        return
+        
+    data = np.load(data_path)
+    states = data['states']     # shape (T, 12) or (T, 20)
+    targets = data['targets']   # shape (T, 4)
+    
+    Nu = states.shape[1]
+    Ny = targets.shape[1]
+    
+    # Let's use 80% for training and 20% for testing
+    split = int(0.8 * len(states))
+    train_u = states[:split]
+    train_label = targets[:split]
+    test_u = states[split:]
+    test_label = targets[split:]
+    
+    print("Loading biological matrices...")
+    try:
+        with open(os.path.join(BASE_DIR, 'W.pkl'), 'rb') as f:
+            W = pickle.load(f)
+        Nx = W.shape[0]
+
+        with open(os.path.join(BASE_DIR, 'W_in.pkl'), 'rb') as f:
+            Win_loaded = pickle.load(f)
+
+        with open(os.path.join(BASE_DIR, 'W_out.pkl'), 'rb') as f:
+            Wout_loaded = pickle.load(f)
+
+        with open(os.path.join(BASE_DIR, 'bias.pkl'), 'rb') as f:
+            bias_loaded = pickle.load(f)
+            
+        print("Creating 50K Bi-Hemispheric Brain...")
+        W = scipy.sparse.block_diag((W, W))
+        Win_loaded = np.concatenate((Win_loaded, Win_loaded))
+        Wout_loaded = np.vstack((Wout_loaded, Wout_loaded))
+        bias_loaded = np.concatenate((bias_loaded, bias_loaded))
+        Nx = W.shape[0] # Update Nx to 50,000
+        
+    except FileNotFoundError:
+        print("Biological matrices (W.pkl, etc.) not found! Falling back to a standard random ESN (Nx=500)...")
+        Nx = 500
+        W = scipy.sparse.random(Nx, Nx, density=0.1, format='csr')
+        Win_loaded = np.random.randn(Nx)
+        Wout_loaded = np.ones((Nx, 1)) # Select all neurons
+        bias_loaded = np.random.randn(Nx, 1) * 0.1
+        
+    # Scale spectral radius to 0.99 (Bypass for 50k as W.pkl is already scaled)
+    if Nx < 25000:
+        try:
+            radius, _ = scipy.sparse.linalg.eigs(W, k=1, which='LM', maxiter=10000, tol=1e-2)
+            radius = abs(np.linalg.norm(radius))
+        except:
+            radius = max(abs(np.linalg.eigvals(W.toarray())))
+        W = W * (0.99 / radius)
+
+    # Ensure Win_loaded and bias_loaded are 1D arrays to prevent sequence assignment error
+    Win_loaded = np.asarray(Win_loaded).flatten()
+    bias_loaded = np.asarray(bias_loaded).flatten()
+
+    # Reshape Win as done in main.ipynb
+    Win_loaded_reshaped = np.zeros((Nu, Nx))
+    for i in range(Nx):
+        row = np.random.choice(Nu)
+        Win_loaded_reshaped[row, i] = Win_loaded[i]
+
+    Win = Win_loaded_reshaped
+    Win = np.vstack((Win, bias_loaded.T)).transpose()
+
+    input_scaling = 0.7
+    Win[:, :-1] = Win[:, :-1] * input_scaling
+
+    Wout_mask = Wout_loaded[:, 0]
+    mask = (Wout_mask == 1)
+
+    print("Simulating reservoir on training data...")
+    step = 0.9  # 1 - leakage rate
+    
+    # Need to simulate washout. Just use initial state (e.g. 100 steps)
+    wash_u = train_u[:100]
+    x0 = np.random.random((Nx, 1))
+    reservoir_wash = simulate(x0, W, Win, np.hstack((wash_u, np.ones((len(wash_u), 1)))), step)
+    
+    x0 = reservoir_wash[:, -1].reshape((Nx, 1))
+    
+    # Train
+    train_u_sim = train_u[100:]
+    train_label_sim = train_label[100:]
+    train_size = len(train_u_sim)
+    
+    # High RAM limit (64GB) allows using maximum precision (Float64)
+    XX = np.zeros((len(np.where(mask)[0]) + 1, len(np.where(mask)[0]) + 1))
+    XY = np.zeros((Ny, len(np.where(mask)[0]) + 1))
+    Yhat = train_label_sim.T
+    
+    XX, XY, reservoir = simulate(x0, W, Win, np.hstack((train_u_sim, np.ones((train_size, 1)))), step, 
+                                 XX, XY, Yhat, building_matrices=True, mask=mask)
+                                 
+    beta = 1e-6
+    print("Performing Ridge Regression (using np.linalg.solve in Float64)...")
+    # np.linalg.solve avoids explicit matrix inversion, making it faster and more stable
+    Wout = np.linalg.solve(XX + beta * np.identity(XX.shape[0]), XY.T).T
+    
+    # Test error
+    X = np.vstack((np.ones((1, train_size)), reservoir.reshape((Nx, train_size))[mask, :]))
+    Y_train = Wout @ X
+    err_train = np.sqrt(np.mean((Y_train - Yhat)**2))
+    print(f"Training RMSE: {err_train}")
+    
+    # Save the trained components
+    print("Saving trained network parameters to W_drone_components.pkl...")
+    components = {
+        'W': W,
+        'Win': Win,
+        'Wout': Wout,
+        'mask': mask,
+        'alpha': step
+    }
+    components_path = os.path.join(BASE_DIR, "W_drone_components.pkl")
+    with open(components_path, "wb") as f:
+        pickle.dump(components, f)
+    print("Training complete!")
+
+if __name__ == "__main__":
+    train_drone_esn()

src/drone_realtime_simulation.py

@@ -0,0 +1,131 @@
+import numpy as np
+import pybullet as p
+import time
+import pickle
+import os
+from gym_pybullet_drones.envs.VelocityAviary import VelocityAviary
+from gym_pybullet_drones.utils.enums import Physics
+from utils import step_compute
+
+def run_realtime_simulation():
+    BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+    components_path = os.path.join(BASE_DIR, "W_drone_components.pkl")
+    if not os.path.exists(components_path):
+        print(f"{components_path} not found!")
+        return
+        
+    with open(components_path, "rb") as f:
+        components = pickle.load(f)
+    W, Win, Wout, mask, alpha, Nx = components['W'], components['Win'], components['Wout'], components['mask'], components['alpha'], components['W'].shape[0]
+
+    # Realistic physics engine features: Ground Effect, Drag, and Downwash
+    env = VelocityAviary(
+        gui=True, 
+        initial_xyzs=np.array([[0, 0, .5]]), 
+        initial_rpys=np.array([[0, 0, 0]]),
+        physics=Physics.PYB_GND_DRAG_DW
+    )
+    
+    # Close PyBullet GUI side panels and enable shadows for realistic visuals
+    p.configureDebugVisualizer(p.COV_ENABLE_GUI, 0, physicsClientId=env.CLIENT)
+    p.configureDebugVisualizer(p.COV_ENABLE_SHADOWS, 1, physicsClientId=env.CLIENT)
+
+    obs, info = env.reset()
+    state = obs[0] # VelocityAviary state is size 20
+    x = np.random.random((Nx, 1))
+
+    # --- VIDEO RECORDING SETTINGS ---
+    # 1. Third Person camera tracking the drone
+    log_id_tp = p.startStateLogging(p.STATE_LOGGING_VIDEO_MP4, "drone_third_person.mp4")
+    
+    # 2. First Person camera (ego-view)
+    log_id_fp = p.startStateLogging(p.STATE_LOGGING_VIDEO_MP4, "drone_first_person.mp4")
+
+    print("Simulation starting, recording video...")
+    
+    try:
+        for i in range(43200): # Match simulation length
+            # Generate the live CPG clock signal exactly as in training
+            clock_signal = np.sin(i * 2 * np.pi / 43200.0)
+            
+            # Blind Flight: Hide global X and Y positions from the network
+            state[0] = 0
+            state[1] = 0
+            
+            # Append clock signal to make the state vector length 21
+            state_with_clock = np.append(state, clock_signal)
+            
+            x, y = step_compute(x, W, Win, Wout, state_with_clock, alpha, mask)
+            
+            # Velocity references are directly generated by ESN (Autonomous flight)
+            obs, reward, terminated, truncated, info = env.step(np.array([y.flatten()]))
+            state = obs[0]
+
+            # --- SPECTATOR CAMERA (FREECAM) CONTROL ---
+            cam_info = p.getDebugVisualizerCamera(physicsClientId=env.CLIENT)
+            cam_yaw = cam_info[8]
+            cam_pitch = cam_info[9]
+            cam_dist = cam_info[10]
+            cam_target = list(cam_info[11])
+            
+            forward = np.array(cam_info[5]) # Camera forward direction
+            right = np.array(cam_info[6])   # Camera right direction
+            
+            # Reset Z axis for flat movement in X/Y plane
+            forward[2] = 0
+            if np.linalg.norm(forward) > 0: forward = forward / np.linalg.norm(forward)
+            right[2] = 0
+            if np.linalg.norm(right) > 0: right = right / np.linalg.norm(right)
+
+            keys = p.getKeyboardEvents()
+            cam_speed = 0.05
+            moved = False
+            
+            # Arrow Keys (Forward-Backward, Left-Right based on camera direction)
+            if p.B3G_UP_ARROW in keys and keys[p.B3G_UP_ARROW] & p.KEY_IS_DOWN:
+                cam_target[0] += forward[0] * cam_speed
+                cam_target[1] += forward[1] * cam_speed
+                moved = True
+            if p.B3G_DOWN_ARROW in keys and keys[p.B3G_DOWN_ARROW] & p.KEY_IS_DOWN:
+                cam_target[0] -= forward[0] * cam_speed
+                cam_target[1] -= forward[1] * cam_speed
+                moved = True
+            if p.B3G_RIGHT_ARROW in keys and keys[p.B3G_RIGHT_ARROW] & p.KEY_IS_DOWN:
+                cam_target[0] += right[0] * cam_speed
+                cam_target[1] += right[1] * cam_speed
+                moved = True
+            if p.B3G_LEFT_ARROW in keys and keys[p.B3G_LEFT_ARROW] & p.KEY_IS_DOWN:
+                cam_target[0] -= right[0] * cam_speed
+                cam_target[1] -= right[1] * cam_speed
+                moved = True
+                
+            # Move Up (Space) / Move Down (Shift)
+            if 32 in keys and keys[32] & p.KEY_IS_DOWN:
+                cam_target[2] += cam_speed
+                moved = True
+            if p.B3G_SHIFT in keys and keys[p.B3G_SHIFT] & p.KEY_IS_DOWN:
+                cam_target[2] -= cam_speed
+                moved = True
+                
+            if moved:
+                p.resetDebugVisualizerCamera(
+                    cameraDistance=cam_dist, 
+                    cameraYaw=cam_yaw, 
+                    cameraPitch=cam_pitch, 
+                    cameraTargetPosition=cam_target,
+                    physicsClientId=env.CLIENT
+                )
+            
+            time.sleep(env.CTRL_TIMESTEP)
+            
+    except KeyboardInterrupt:
+        print("Stopped by user.")
+    finally:
+        # --- CLOSE VIDEO RECORDING ---
+        p.stopStateLogging(log_id_tp)
+        p.stopStateLogging(log_id_fp)
+        env.close()
+        print("Videos saved: drone_third_person.mp4 and drone_first_person.mp4")
+
+if __name__ == "__main__":
+    run_realtime_simulation()

src/lib/bindings/utils.js

@@ -0,0 +1,189 @@
+function neighbourhoodHighlight(params) {
+  // console.log("in nieghbourhoodhighlight");
+  allNodes = nodes.get({ returnType: "Object" });
+  // originalNodes = JSON.parse(JSON.stringify(allNodes));
+  // if something is selected:
+  if (params.nodes.length > 0) {
+    highlightActive = true;
+    var i, j;
+    var selectedNode = params.nodes[0];
+    var degrees = 2;
+
+    // mark all nodes as hard to read.
+    for (let nodeId in allNodes) {
+      // nodeColors[nodeId] = allNodes[nodeId].color;
+      allNodes[nodeId].color = "rgba(200,200,200,0.5)";
+      if (allNodes[nodeId].hiddenLabel === undefined) {
+        allNodes[nodeId].hiddenLabel = allNodes[nodeId].label;
+        allNodes[nodeId].label = undefined;
+      }
+    }
+    var connectedNodes = network.getConnectedNodes(selectedNode);
+    var allConnectedNodes = [];
+
+    // get the second degree nodes
+    for (i = 1; i < degrees; i++) {
+      for (j = 0; j < connectedNodes.length; j++) {
+        allConnectedNodes = allConnectedNodes.concat(
+          network.getConnectedNodes(connectedNodes[j])
+        );
+      }
+    }
+
+    // all second degree nodes get a different color and their label back
+    for (i = 0; i < allConnectedNodes.length; i++) {
+      // allNodes[allConnectedNodes[i]].color = "pink";
+      allNodes[allConnectedNodes[i]].color = "rgba(150,150,150,0.75)";
+      if (allNodes[allConnectedNodes[i]].hiddenLabel !== undefined) {
+        allNodes[allConnectedNodes[i]].label =
+          allNodes[allConnectedNodes[i]].hiddenLabel;
+        allNodes[allConnectedNodes[i]].hiddenLabel = undefined;
+      }
+    }
+
+    // all first degree nodes get their own color and their label back
+    for (i = 0; i < connectedNodes.length; i++) {
+      // allNodes[connectedNodes[i]].color = undefined;
+      allNodes[connectedNodes[i]].color = nodeColors[connectedNodes[i]];
+      if (allNodes[connectedNodes[i]].hiddenLabel !== undefined) {
+        allNodes[connectedNodes[i]].label =
+          allNodes[connectedNodes[i]].hiddenLabel;
+        allNodes[connectedNodes[i]].hiddenLabel = undefined;
+      }
+    }
+
+    // the main node gets its own color and its label back.
+    // allNodes[selectedNode].color = undefined;
+    allNodes[selectedNode].color = nodeColors[selectedNode];
+    if (allNodes[selectedNode].hiddenLabel !== undefined) {
+      allNodes[selectedNode].label = allNodes[selectedNode].hiddenLabel;
+      allNodes[selectedNode].hiddenLabel = undefined;
+    }
+  } else if (highlightActive === true) {
+    // console.log("highlightActive was true");
+    // reset all nodes
+    for (let nodeId in allNodes) {
+      // allNodes[nodeId].color = "purple";
+      allNodes[nodeId].color = nodeColors[nodeId];
+      // delete allNodes[nodeId].color;
+      if (allNodes[nodeId].hiddenLabel !== undefined) {
+        allNodes[nodeId].label = allNodes[nodeId].hiddenLabel;
+        allNodes[nodeId].hiddenLabel = undefined;
+      }
+    }
+    highlightActive = false;
+  }
+
+  // transform the object into an array
+  var updateArray = [];
+  if (params.nodes.length > 0) {
+    for (let nodeId in allNodes) {
+      if (allNodes.hasOwnProperty(nodeId)) {
+        // console.log(allNodes[nodeId]);
+        updateArray.push(allNodes[nodeId]);
+      }
+    }
+    nodes.update(updateArray);
+  } else {
+    // console.log("Nothing was selected");
+    for (let nodeId in allNodes) {
+      if (allNodes.hasOwnProperty(nodeId)) {
+        // console.log(allNodes[nodeId]);
+        // allNodes[nodeId].color = {};
+        updateArray.push(allNodes[nodeId]);
+      }
+    }
+    nodes.update(updateArray);
+  }
+}
+
+function filterHighlight(params) {
+  allNodes = nodes.get({ returnType: "Object" });
+  // if something is selected:
+  if (params.nodes.length > 0) {
+    filterActive = true;
+    let selectedNodes = params.nodes;
+
+    // hiding all nodes and saving the label
+    for (let nodeId in allNodes) {
+      allNodes[nodeId].hidden = true;
+      if (allNodes[nodeId].savedLabel === undefined) {
+        allNodes[nodeId].savedLabel = allNodes[nodeId].label;
+        allNodes[nodeId].label = undefined;
+      }
+    }
+
+    for (let i=0; i < selectedNodes.length; i++) {
+      allNodes[selectedNodes[i]].hidden = false;
+      if (allNodes[selectedNodes[i]].savedLabel !== undefined) {
+        allNodes[selectedNodes[i]].label = allNodes[selectedNodes[i]].savedLabel;
+        allNodes[selectedNodes[i]].savedLabel = undefined;
+      }
+    }
+
+  } else if (filterActive === true) {
+    // reset all nodes
+    for (let nodeId in allNodes) {
+      allNodes[nodeId].hidden = false;
+      if (allNodes[nodeId].savedLabel !== undefined) {
+        allNodes[nodeId].label = allNodes[nodeId].savedLabel;
+        allNodes[nodeId].savedLabel = undefined;
+      }
+    }
+    filterActive = false;
+  }
+
+  // transform the object into an array
+  var updateArray = [];
+  if (params.nodes.length > 0) {
+    for (let nodeId in allNodes) {
+      if (allNodes.hasOwnProperty(nodeId)) {
+        updateArray.push(allNodes[nodeId]);
+      }
+    }
+    nodes.update(updateArray);
+  } else {
+    for (let nodeId in allNodes) {
+      if (allNodes.hasOwnProperty(nodeId)) {
+        updateArray.push(allNodes[nodeId]);
+      }
+    }
+    nodes.update(updateArray);
+  }
+}
+
+function selectNode(nodes) {
+  network.selectNodes(nodes);
+  neighbourhoodHighlight({ nodes: nodes });
+  return nodes;
+}
+
+function selectNodes(nodes) {
+  network.selectNodes(nodes);
+  filterHighlight({nodes: nodes});
+  return nodes;
+}
+
+function highlightFilter(filter) {
+  let selectedNodes = []
+  let selectedProp = filter['property']
+  if (filter['item'] === 'node') {
+    let allNodes = nodes.get({ returnType: "Object" });
+    for (let nodeId in allNodes) {
+      if (allNodes[nodeId][selectedProp] && filter['value'].includes((allNodes[nodeId][selectedProp]).toString())) {
+        selectedNodes.push(nodeId)
+      }
+    }
+  }
+  else if (filter['item'] === 'edge'){
+    let allEdges = edges.get({returnType: 'object'});
+    // check if the selected property exists for selected edge and select the nodes connected to the edge
+    for (let edge in allEdges) {
+      if (allEdges[edge][selectedProp] && filter['value'].includes((allEdges[edge][selectedProp]).toString())) {
+        selectedNodes.push(allEdges[edge]['from'])
+        selectedNodes.push(allEdges[edge]['to'])
+      }
+    }
+  }
+  selectNodes(selectedNodes)
+}

src/lib/tom-select/tom-select.complete.min.js

@@ -0,0 +1,356 @@
+/**
+* Tom Select v2.0.0-rc.4
+* Licensed under the Apache License, Version 2.0 (the "License");
+*/
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e||self).TomSelect=t()}(this,(function(){"use strict"
+function e(e,t){e.split(/\s+/).forEach((e=>{t(e)}))}class t{constructor(){this._events={}}on(t,i){e(t,(e=>{this._events[e]=this._events[e]||[],this._events[e].push(i)}))}off(t,i){var s=arguments.length
+0!==s?e(t,(e=>{if(1===s)return delete this._events[e]
+e in this._events!=!1&&this._events[e].splice(this._events[e].indexOf(i),1)})):this._events={}}trigger(t,...i){var s=this
+e(t,(e=>{if(e in s._events!=!1)for(let t of s._events[e])t.apply(s,i)}))}}var i
+const s="[̀-ͯ·ʾ]",n=new RegExp(s,"g")
+var o
+const r={"æ":"ae","ⱥ":"a","ø":"o"},l=new RegExp(Object.keys(r).join("|"),"g"),a=[[67,67],[160,160],[192,438],[452,652],[961,961],[1019,1019],[1083,1083],[1281,1289],[1984,1984],[5095,5095],[7429,7441],[7545,7549],[7680,7935],[8580,8580],[9398,9449],[11360,11391],[42792,42793],[42802,42851],[42873,42897],[42912,42922],[64256,64260],[65313,65338],[65345,65370]],c=e=>e.normalize("NFKD").replace(n,"").toLowerCase().replace(l,(function(e){return r[e]})),d=(e,t="|")=>{if(1==e.length)return e[0]
+var i=1
+return e.forEach((e=>{i=Math.max(i,e.length)})),1==i?"["+e.join("")+"]":"(?:"+e.join(t)+")"},p=e=>{if(1===e.length)return[[e]]
+var t=[]
+return p(e.substring(1)).forEach((function(i){var s=i.slice(0)
+s[0]=e.charAt(0)+s[0],t.push(s),(s=i.slice(0)).unshift(e.charAt(0)),t.push(s)})),t},u=e=>{void 0===o&&(o=(()=>{var e={}
+a.forEach((t=>{for(let s=t[0];s<=t[1];s++){let t=String.fromCharCode(s),n=c(t)
+if(n!=t.toLowerCase()){n in e||(e[n]=[n])
+var i=new RegExp(d(e[n]),"iu")
+t.match(i)||e[n].push(t)}}}))
+var t=Object.keys(e)
+t=t.sort(((e,t)=>t.length-e.length)),i=new RegExp("("+d(t)+"[̀-ͯ·ʾ]*)","g")
+var s={}
+return t.sort(((e,t)=>e.length-t.length)).forEach((t=>{var i=p(t).map((t=>(t=t.map((t=>e.hasOwnProperty(t)?d(e[t]):t)),d(t,""))))
+s[t]=d(i)})),s})())
+return e.normalize("NFKD").toLowerCase().split(i).map((e=>{if(""==e)return""
+const t=c(e)
+if(o.hasOwnProperty(t))return o[t]
+const i=e.normalize("NFC")
+return i!=e?d([e,i]):e})).join("")},h=(e,t)=>{if(e)return e[t]},g=(e,t)=>{if(e){for(var i,s=t.split(".");(i=s.shift())&&(e=e[i]););return e}},f=(e,t,i)=>{var s,n
+return e?-1===(n=(e+="").search(t.regex))?0:(s=t.string.length/e.length,0===n&&(s+=.5),s*i):0},v=e=>(e+"").replace(/([\$\(-\+\.\?\[-\^\{-\}])/g,"\\$1"),m=(e,t)=>{var i=e[t]
+if("function"==typeof i)return i
+i&&!Array.isArray(i)&&(e[t]=[i])},y=(e,t)=>{if(Array.isArray(e))e.forEach(t)
+else for(var i in e)e.hasOwnProperty(i)&&t(e[i],i)},O=(e,t)=>"number"==typeof e&&"number"==typeof t?e>t?1:e<t?-1:0:(e=c(e+"").toLowerCase())>(t=c(t+"").toLowerCase())?1:t>e?-1:0
+class b{constructor(e,t){this.items=e,this.settings=t||{diacritics:!0}}tokenize(e,t,i){if(!e||!e.length)return[]
+const s=[],n=e.split(/\s+/)
+var o
+return i&&(o=new RegExp("^("+Object.keys(i).map(v).join("|")+"):(.*)$")),n.forEach((e=>{let i,n=null,r=null
+o&&(i=e.match(o))&&(n=i[1],e=i[2]),e.length>0&&(r=v(e),this.settings.diacritics&&(r=u(r)),t&&(r="\\b"+r)),s.push({string:e,regex:r?new RegExp(r,"iu"):null,field:n})})),s}getScoreFunction(e,t){var i=this.prepareSearch(e,t)
+return this._getScoreFunction(i)}_getScoreFunction(e){const t=e.tokens,i=t.length
+if(!i)return function(){return 0}
+const s=e.options.fields,n=e.weights,o=s.length,r=e.getAttrFn
+if(!o)return function(){return 1}
+const l=1===o?function(e,t){const i=s[0].field
+return f(r(t,i),e,n[i])}:function(e,t){var i=0
+if(e.field){const s=r(t,e.field)
+!e.regex&&s?i+=1/o:i+=f(s,e,1)}else y(n,((s,n)=>{i+=f(r(t,n),e,s)}))
+return i/o}
+return 1===i?function(e){return l(t[0],e)}:"and"===e.options.conjunction?function(e){for(var s,n=0,o=0;n<i;n++){if((s=l(t[n],e))<=0)return 0
+o+=s}return o/i}:function(e){var s=0
+return y(t,(t=>{s+=l(t,e)})),s/i}}getSortFunction(e,t){var i=this.prepareSearch(e,t)
+return this._getSortFunction(i)}_getSortFunction(e){var t,i,s
+const n=this,o=e.options,r=!e.query&&o.sort_empty?o.sort_empty:o.sort,l=[],a=[]
+if("function"==typeof r)return r.bind(this)
+const c=function(t,i){return"$score"===t?i.score:e.getAttrFn(n.items[i.id],t)}
+if(r)for(t=0,i=r.length;t<i;t++)(e.query||"$score"!==r[t].field)&&l.push(r[t])
+if(e.query){for(s=!0,t=0,i=l.length;t<i;t++)if("$score"===l[t].field){s=!1
+break}s&&l.unshift({field:"$score",direction:"desc"})}else for(t=0,i=l.length;t<i;t++)if("$score"===l[t].field){l.splice(t,1)
+break}for(t=0,i=l.length;t<i;t++)a.push("desc"===l[t].direction?-1:1)
+const d=l.length
+if(d){if(1===d){const e=l[0].field,t=a[0]
+return function(i,s){return t*O(c(e,i),c(e,s))}}return function(e,t){var i,s,n
+for(i=0;i<d;i++)if(n=l[i].field,s=a[i]*O(c(n,e),c(n,t)))return s
+return 0}}return null}prepareSearch(e,t){const i={}
+var s=Object.assign({},t)
+if(m(s,"sort"),m(s,"sort_empty"),s.fields){m(s,"fields")
+const e=[]
+s.fields.forEach((t=>{"string"==typeof t&&(t={field:t,weight:1}),e.push(t),i[t.field]="weight"in t?t.weight:1})),s.fields=e}return{options:s,query:e.toLowerCase().trim(),tokens:this.tokenize(e,s.respect_word_boundaries,i),total:0,items:[],weights:i,getAttrFn:s.nesting?g:h}}search(e,t){var i,s,n=this
+s=this.prepareSearch(e,t),t=s.options,e=s.query
+const o=t.score||n._getScoreFunction(s)
+e.length?y(n.items,((e,n)=>{i=o(e),(!1===t.filter||i>0)&&s.items.push({score:i,id:n})})):y(n.items,((e,t)=>{s.items.push({score:1,id:t})}))
+const r=n._getSortFunction(s)
+return r&&s.items.sort(r),s.total=s.items.length,"number"==typeof t.limit&&(s.items=s.items.slice(0,t.limit)),s}}const w=e=>{if(e.jquery)return e[0]
+if(e instanceof HTMLElement)return e
+if(e.indexOf("<")>-1){let t=document.createElement("div")
+return t.innerHTML=e.trim(),t.firstChild}return document.querySelector(e)},_=(e,t)=>{var i=document.createEvent("HTMLEvents")
+i.initEvent(t,!0,!1),e.dispatchEvent(i)},I=(e,t)=>{Object.assign(e.style,t)},C=(e,...t)=>{var i=A(t);(e=x(e)).map((e=>{i.map((t=>{e.classList.add(t)}))}))},S=(e,...t)=>{var i=A(t);(e=x(e)).map((e=>{i.map((t=>{e.classList.remove(t)}))}))},A=e=>{var t=[]
+return y(e,(e=>{"string"==typeof e&&(e=e.trim().split(/[\11\12\14\15\40]/)),Array.isArray(e)&&(t=t.concat(e))})),t.filter(Boolean)},x=e=>(Array.isArray(e)||(e=[e]),e),k=(e,t,i)=>{if(!i||i.contains(e))for(;e&&e.matches;){if(e.matches(t))return e
+e=e.parentNode}},F=(e,t=0)=>t>0?e[e.length-1]:e[0],L=(e,t)=>{if(!e)return-1
+t=t||e.nodeName
+for(var i=0;e=e.previousElementSibling;)e.matches(t)&&i++
+return i},P=(e,t)=>{y(t,((t,i)=>{null==t?e.removeAttribute(i):e.setAttribute(i,""+t)}))},E=(e,t)=>{e.parentNode&&e.parentNode.replaceChild(t,e)},T=(e,t)=>{if(null===t)return
+if("string"==typeof t){if(!t.length)return
+t=new RegExp(t,"i")}const i=e=>3===e.nodeType?(e=>{var i=e.data.match(t)
+if(i&&e.data.length>0){var s=document.createElement("span")
+s.className="highlight"
+var n=e.splitText(i.index)
+n.splitText(i[0].length)
+var o=n.cloneNode(!0)
+return s.appendChild(o),E(n,s),1}return 0})(e):((e=>{if(1===e.nodeType&&e.childNodes&&!/(script|style)/i.test(e.tagName)&&("highlight"!==e.className||"SPAN"!==e.tagName))for(var t=0;t<e.childNodes.length;++t)t+=i(e.childNodes[t])})(e),0)
+i(e)},V="undefined"!=typeof navigator&&/Mac/.test(navigator.userAgent)?"metaKey":"ctrlKey"
+var j={options:[],optgroups:[],plugins:[],delimiter:",",splitOn:null,persist:!0,diacritics:!0,create:null,createOnBlur:!1,createFilter:null,highlight:!0,openOnFocus:!0,shouldOpen:null,maxOptions:50,maxItems:null,hideSelected:null,duplicates:!1,addPrecedence:!1,selectOnTab:!1,preload:null,allowEmptyOption:!1,loadThrottle:300,loadingClass:"loading",dataAttr:null,optgroupField:"optgroup",valueField:"value",labelField:"text",disabledField:"disabled",optgroupLabelField:"label",optgroupValueField:"value",lockOptgroupOrder:!1,sortField:"$order",searchField:["text"],searchConjunction:"and",mode:null,wrapperClass:"ts-wrapper",controlClass:"ts-control",dropdownClass:"ts-dropdown",dropdownContentClass:"ts-dropdown-content",itemClass:"item",optionClass:"option",dropdownParent:null,copyClassesToDropdown:!1,placeholder:null,hidePlaceholder:null,shouldLoad:function(e){return e.length>0},render:{}}
+const q=e=>null==e?null:D(e),D=e=>"boolean"==typeof e?e?"1":"0":e+"",N=e=>(e+"").replace(/&/g,"&amp;").replace(/</g,"&lt;").replace(/>/g,"&gt;").replace(/"/g,"&quot;"),z=(e,t)=>{var i
+return function(s,n){var o=this
+i&&(o.loading=Math.max(o.loading-1,0),clearTimeout(i)),i=setTimeout((function(){i=null,o.loadedSearches[s]=!0,e.call(o,s,n)}),t)}},R=(e,t,i)=>{var s,n=e.trigger,o={}
+for(s in e.trigger=function(){var i=arguments[0]
+if(-1===t.indexOf(i))return n.apply(e,arguments)
+o[i]=arguments},i.apply(e,[]),e.trigger=n,o)n.apply(e,o[s])},H=(e,t=!1)=>{e&&(e.preventDefault(),t&&e.stopPropagation())},B=(e,t,i,s)=>{e.addEventListener(t,i,s)},K=(e,t)=>!!t&&(!!t[e]&&1===(t.altKey?1:0)+(t.ctrlKey?1:0)+(t.shiftKey?1:0)+(t.metaKey?1:0)),M=(e,t)=>{const i=e.getAttribute("id")
+return i||(e.setAttribute("id",t),t)},Q=e=>e.replace(/[\\"']/g,"\\$&"),G=(e,t)=>{t&&e.append(t)}
+function U(e,t){var i=Object.assign({},j,t),s=i.dataAttr,n=i.labelField,o=i.valueField,r=i.disabledField,l=i.optgroupField,a=i.optgroupLabelField,c=i.optgroupValueField,d=e.tagName.toLowerCase(),p=e.getAttribute("placeholder")||e.getAttribute("data-placeholder")
+if(!p&&!i.allowEmptyOption){let t=e.querySelector('option[value=""]')
+t&&(p=t.textContent)}var u,h,g,f,v,m,O={placeholder:p,options:[],optgroups:[],items:[],maxItems:null}
+return"select"===d?(h=O.options,g={},f=1,v=e=>{var t=Object.assign({},e.dataset),i=s&&t[s]
+return"string"==typeof i&&i.length&&(t=Object.assign(t,JSON.parse(i))),t},m=(e,t)=>{var s=q(e.value)
+if(null!=s&&(s||i.allowEmptyOption)){if(g.hasOwnProperty(s)){if(t){var a=g[s][l]
+a?Array.isArray(a)?a.push(t):g[s][l]=[a,t]:g[s][l]=t}}else{var c=v(e)
+c[n]=c[n]||e.textContent,c[o]=c[o]||s,c[r]=c[r]||e.disabled,c[l]=c[l]||t,c.$option=e,g[s]=c,h.push(c)}e.selected&&O.items.push(s)}},O.maxItems=e.hasAttribute("multiple")?null:1,y(e.children,(e=>{var t,i,s
+"optgroup"===(u=e.tagName.toLowerCase())?((s=v(t=e))[a]=s[a]||t.getAttribute("label")||"",s[c]=s[c]||f++,s[r]=s[r]||t.disabled,O.optgroups.push(s),i=s[c],y(t.children,(e=>{m(e,i)}))):"option"===u&&m(e)}))):(()=>{const t=e.getAttribute(s)
+if(t)O.options=JSON.parse(t),y(O.options,(e=>{O.items.push(e[o])}))
+else{var r=e.value.trim()||""
+if(!i.allowEmptyOption&&!r.length)return
+const t=r.split(i.delimiter)
+y(t,(e=>{const t={}
+t[n]=e,t[o]=e,O.options.push(t)})),O.items=t}})(),Object.assign({},j,O,t)}var W=0
+class J extends(function(e){return e.plugins={},class extends e{constructor(...e){super(...e),this.plugins={names:[],settings:{},requested:{},loaded:{}}}static define(t,i){e.plugins[t]={name:t,fn:i}}initializePlugins(e){var t,i
+const s=this,n=[]
+if(Array.isArray(e))e.forEach((e=>{"string"==typeof e?n.push(e):(s.plugins.settings[e.name]=e.options,n.push(e.name))}))
+else if(e)for(t in e)e.hasOwnProperty(t)&&(s.plugins.settings[t]=e[t],n.push(t))
+for(;i=n.shift();)s.require(i)}loadPlugin(t){var i=this,s=i.plugins,n=e.plugins[t]
+if(!e.plugins.hasOwnProperty(t))throw new Error('Unable to find "'+t+'" plugin')
+s.requested[t]=!0,s.loaded[t]=n.fn.apply(i,[i.plugins.settings[t]||{}]),s.names.push(t)}require(e){var t=this,i=t.plugins
+if(!t.plugins.loaded.hasOwnProperty(e)){if(i.requested[e])throw new Error('Plugin has circular dependency ("'+e+'")')
+t.loadPlugin(e)}return i.loaded[e]}}}(t)){constructor(e,t){var i
+super(),this.order=0,this.isOpen=!1,this.isDisabled=!1,this.isInvalid=!1,this.isValid=!0,this.isLocked=!1,this.isFocused=!1,this.isInputHidden=!1,this.isSetup=!1,this.ignoreFocus=!1,this.hasOptions=!1,this.lastValue="",this.caretPos=0,this.loading=0,this.loadedSearches={},this.activeOption=null,this.activeItems=[],this.optgroups={},this.options={},this.userOptions={},this.items=[],W++
+var s=w(e)
+if(s.tomselect)throw new Error("Tom Select already initialized on this element")
+s.tomselect=this,i=(window.getComputedStyle&&window.getComputedStyle(s,null)).getPropertyValue("direction")
+const n=U(s,t)
+this.settings=n,this.input=s,this.tabIndex=s.tabIndex||0,this.is_select_tag="select"===s.tagName.toLowerCase(),this.rtl=/rtl/i.test(i),this.inputId=M(s,"tomselect-"+W),this.isRequired=s.required,this.sifter=new b(this.options,{diacritics:n.diacritics}),n.mode=n.mode||(1===n.maxItems?"single":"multi"),"boolean"!=typeof n.hideSelected&&(n.hideSelected="multi"===n.mode),"boolean"!=typeof n.hidePlaceholder&&(n.hidePlaceholder="multi"!==n.mode)
+var o=n.createFilter
+"function"!=typeof o&&("string"==typeof o&&(o=new RegExp(o)),o instanceof RegExp?n.createFilter=e=>o.test(e):n.createFilter=()=>!0),this.initializePlugins(n.plugins),this.setupCallbacks(),this.setupTemplates()
+const r=w("<div>"),l=w("<div>"),a=this._render("dropdown"),c=w('<div role="listbox" tabindex="-1">'),d=this.input.getAttribute("class")||"",p=n.mode
+var u
+if(C(r,n.wrapperClass,d,p),C(l,n.controlClass),G(r,l),C(a,n.dropdownClass,p),n.copyClassesToDropdown&&C(a,d),C(c,n.dropdownContentClass),G(a,c),w(n.dropdownParent||r).appendChild(a),n.hasOwnProperty("controlInput"))n.controlInput?(u=w(n.controlInput),this.focus_node=u):(u=w("<input/>"),this.focus_node=l)
+else{u=w('<input type="text" autocomplete="off" size="1" />')
+y(["autocorrect","autocapitalize","autocomplete"],(e=>{s.getAttribute(e)&&P(u,{[e]:s.getAttribute(e)})})),u.tabIndex=-1,l.appendChild(u),this.focus_node=u}this.wrapper=r,this.dropdown=a,this.dropdown_content=c,this.control=l,this.control_input=u,this.setup()}setup(){const e=this,t=e.settings,i=e.control_input,s=e.dropdown,n=e.dropdown_content,o=e.wrapper,r=e.control,l=e.input,a=e.focus_node,c={passive:!0},d=e.inputId+"-ts-dropdown"
+P(n,{id:d}),P(a,{role:"combobox","aria-haspopup":"listbox","aria-expanded":"false","aria-controls":d})
+const p=M(a,e.inputId+"-ts-control"),u="label[for='"+(e=>e.replace(/['"\\]/g,"\\$&"))(e.inputId)+"']",h=document.querySelector(u),g=e.focus.bind(e)
+if(h){B(h,"click",g),P(h,{for:p})
+const t=M(h,e.inputId+"-ts-label")
+P(a,{"aria-labelledby":t}),P(n,{"aria-labelledby":t})}if(o.style.width=l.style.width,e.plugins.names.length){const t="plugin-"+e.plugins.names.join(" plugin-")
+C([o,s],t)}(null===t.maxItems||t.maxItems>1)&&e.is_select_tag&&P(l,{multiple:"multiple"}),e.settings.placeholder&&P(i,{placeholder:t.placeholder}),!e.settings.splitOn&&e.settings.delimiter&&(e.settings.splitOn=new RegExp("\\s*"+v(e.settings.delimiter)+"+\\s*")),t.load&&t.loadThrottle&&(t.load=z(t.load,t.loadThrottle)),e.control_input.type=l.type,B(s,"click",(t=>{const i=k(t.target,"[data-selectable]")
+i&&(e.onOptionSelect(t,i),H(t,!0))})),B(r,"click",(t=>{var s=k(t.target,"[data-ts-item]",r)
+s&&e.onItemSelect(t,s)?H(t,!0):""==i.value&&(e.onClick(),H(t,!0))})),B(i,"mousedown",(e=>{""!==i.value&&e.stopPropagation()})),B(a,"keydown",(t=>e.onKeyDown(t))),B(i,"keypress",(t=>e.onKeyPress(t))),B(i,"input",(t=>e.onInput(t))),B(a,"resize",(()=>e.positionDropdown()),c),B(a,"blur",(t=>e.onBlur(t))),B(a,"focus",(t=>e.onFocus(t))),B(a,"paste",(t=>e.onPaste(t)))
+const f=t=>{const i=t.composedPath()[0]
+if(!o.contains(i)&&!s.contains(i))return e.isFocused&&e.blur(),void e.inputState()
+H(t,!0)}
+var m=()=>{e.isOpen&&e.positionDropdown()}
+B(document,"mousedown",f),B(window,"scroll",m,c),B(window,"resize",m,c),this._destroy=()=>{document.removeEventListener("mousedown",f),window.removeEventListener("sroll",m),window.removeEventListener("resize",m),h&&h.removeEventListener("click",g)},this.revertSettings={innerHTML:l.innerHTML,tabIndex:l.tabIndex},l.tabIndex=-1,l.insertAdjacentElement("afterend",e.wrapper),e.sync(!1),t.items=[],delete t.optgroups,delete t.options,B(l,"invalid",(t=>{e.isValid&&(e.isValid=!1,e.isInvalid=!0,e.refreshState())})),e.updateOriginalInput(),e.refreshItems(),e.close(!1),e.inputState(),e.isSetup=!0,l.disabled?e.disable():e.enable(),e.on("change",this.onChange),C(l,"tomselected","ts-hidden-accessible"),e.trigger("initialize"),!0===t.preload&&e.preload()}setupOptions(e=[],t=[]){this.addOptions(e),y(t,(e=>{this.registerOptionGroup(e)}))}setupTemplates(){var e=this,t=e.settings.labelField,i=e.settings.optgroupLabelField,s={optgroup:e=>{let t=document.createElement("div")
+return t.className="optgroup",t.appendChild(e.options),t},optgroup_header:(e,t)=>'<div class="optgroup-header">'+t(e[i])+"</div>",option:(e,i)=>"<div>"+i(e[t])+"</div>",item:(e,i)=>"<div>"+i(e[t])+"</div>",option_create:(e,t)=>'<div class="create">Add <strong>'+t(e.input)+"</strong>&hellip;</div>",no_results:()=>'<div class="no-results">No results found</div>',loading:()=>'<div class="spinner"></div>',not_loading:()=>{},dropdown:()=>"<div></div>"}
+e.settings.render=Object.assign({},s,e.settings.render)}setupCallbacks(){var e,t,i={initialize:"onInitialize",change:"onChange",item_add:"onItemAdd",item_remove:"onItemRemove",item_select:"onItemSelect",clear:"onClear",option_add:"onOptionAdd",option_remove:"onOptionRemove",option_clear:"onOptionClear",optgroup_add:"onOptionGroupAdd",optgroup_remove:"onOptionGroupRemove",optgroup_clear:"onOptionGroupClear",dropdown_open:"onDropdownOpen",dropdown_close:"onDropdownClose",type:"onType",load:"onLoad",focus:"onFocus",blur:"onBlur"}
+for(e in i)(t=this.settings[i[e]])&&this.on(e,t)}sync(e=!0){const t=this,i=e?U(t.input,{delimiter:t.settings.delimiter}):t.settings
+t.setupOptions(i.options,i.optgroups),t.setValue(i.items,!0),t.lastQuery=null}onClick(){var e=this
+if(e.activeItems.length>0)return e.clearActiveItems(),void e.focus()
+e.isFocused&&e.isOpen?e.blur():e.focus()}onMouseDown(){}onChange(){_(this.input,"input"),_(this.input,"change")}onPaste(e){var t=this
+t.isFull()||t.isInputHidden||t.isLocked?H(e):t.settings.splitOn&&setTimeout((()=>{var e=t.inputValue()
+if(e.match(t.settings.splitOn)){var i=e.trim().split(t.settings.splitOn)
+y(i,(e=>{t.createItem(e)}))}}),0)}onKeyPress(e){var t=this
+if(!t.isLocked){var i=String.fromCharCode(e.keyCode||e.which)
+return t.settings.create&&"multi"===t.settings.mode&&i===t.settings.delimiter?(t.createItem(),void H(e)):void 0}H(e)}onKeyDown(e){var t=this
+if(t.isLocked)9!==e.keyCode&&H(e)
+else{switch(e.keyCode){case 65:if(K(V,e))return H(e),void t.selectAll()
+break
+case 27:return t.isOpen&&(H(e,!0),t.close()),void t.clearActiveItems()
+case 40:if(!t.isOpen&&t.hasOptions)t.open()
+else if(t.activeOption){let e=t.getAdjacent(t.activeOption,1)
+e&&t.setActiveOption(e)}return void H(e)
+case 38:if(t.activeOption){let e=t.getAdjacent(t.activeOption,-1)
+e&&t.setActiveOption(e)}return void H(e)
+case 13:return void(t.isOpen&&t.activeOption?(t.onOptionSelect(e,t.activeOption),H(e)):t.settings.create&&t.createItem()&&H(e))
+case 37:return void t.advanceSelection(-1,e)
+case 39:return void t.advanceSelection(1,e)
+case 9:return void(t.settings.selectOnTab&&(t.isOpen&&t.activeOption&&(t.onOptionSelect(e,t.activeOption),H(e)),t.settings.create&&t.createItem()&&H(e)))
+case 8:case 46:return void t.deleteSelection(e)}t.isInputHidden&&!K(V,e)&&H(e)}}onInput(e){var t=this
+if(!t.isLocked){var i=t.inputValue()
+t.lastValue!==i&&(t.lastValue=i,t.settings.shouldLoad.call(t,i)&&t.load(i),t.refreshOptions(),t.trigger("type",i))}}onFocus(e){var t=this,i=t.isFocused
+if(t.isDisabled)return t.blur(),void H(e)
+t.ignoreFocus||(t.isFocused=!0,"focus"===t.settings.preload&&t.preload(),i||t.trigger("focus"),t.activeItems.length||(t.showInput(),t.refreshOptions(!!t.settings.openOnFocus)),t.refreshState())}onBlur(e){if(!1!==document.hasFocus()){var t=this
+if(t.isFocused){t.isFocused=!1,t.ignoreFocus=!1
+var i=()=>{t.close(),t.setActiveItem(),t.setCaret(t.items.length),t.trigger("blur")}
+t.settings.create&&t.settings.createOnBlur?t.createItem(null,!1,i):i()}}}onOptionSelect(e,t){var i,s=this
+t&&(t.parentElement&&t.parentElement.matches("[data-disabled]")||(t.classList.contains("create")?s.createItem(null,!0,(()=>{s.settings.closeAfterSelect&&s.close()})):void 0!==(i=t.dataset.value)&&(s.lastQuery=null,s.addItem(i),s.settings.closeAfterSelect&&s.close(),!s.settings.hideSelected&&e.type&&/click/.test(e.type)&&s.setActiveOption(t))))}onItemSelect(e,t){var i=this
+return!i.isLocked&&"multi"===i.settings.mode&&(H(e),i.setActiveItem(t,e),!0)}canLoad(e){return!!this.settings.load&&!this.loadedSearches.hasOwnProperty(e)}load(e){const t=this
+if(!t.canLoad(e))return
+C(t.wrapper,t.settings.loadingClass),t.loading++
+const i=t.loadCallback.bind(t)
+t.settings.load.call(t,e,i)}loadCallback(e,t){const i=this
+i.loading=Math.max(i.loading-1,0),i.lastQuery=null,i.clearActiveOption(),i.setupOptions(e,t),i.refreshOptions(i.isFocused&&!i.isInputHidden),i.loading||S(i.wrapper,i.settings.loadingClass),i.trigger("load",e,t)}preload(){var e=this.wrapper.classList
+e.contains("preloaded")||(e.add("preloaded"),this.load(""))}setTextboxValue(e=""){var t=this.control_input
+t.value!==e&&(t.value=e,_(t,"update"),this.lastValue=e)}getValue(){return this.is_select_tag&&this.input.hasAttribute("multiple")?this.items:this.items.join(this.settings.delimiter)}setValue(e,t){R(this,t?[]:["change"],(()=>{this.clear(t),this.addItems(e,t)}))}setMaxItems(e){0===e&&(e=null),this.settings.maxItems=e,this.refreshState()}setActiveItem(e,t){var i,s,n,o,r,l,a=this
+if("single"!==a.settings.mode){if(!e)return a.clearActiveItems(),void(a.isFocused&&a.showInput())
+if("click"===(i=t&&t.type.toLowerCase())&&K("shiftKey",t)&&a.activeItems.length){for(l=a.getLastActive(),(n=Array.prototype.indexOf.call(a.control.children,l))>(o=Array.prototype.indexOf.call(a.control.children,e))&&(r=n,n=o,o=r),s=n;s<=o;s++)e=a.control.children[s],-1===a.activeItems.indexOf(e)&&a.setActiveItemClass(e)
+H(t)}else"click"===i&&K(V,t)||"keydown"===i&&K("shiftKey",t)?e.classList.contains("active")?a.removeActiveItem(e):a.setActiveItemClass(e):(a.clearActiveItems(),a.setActiveItemClass(e))
+a.hideInput(),a.isFocused||a.focus()}}setActiveItemClass(e){const t=this,i=t.control.querySelector(".last-active")
+i&&S(i,"last-active"),C(e,"active last-active"),t.trigger("item_select",e),-1==t.activeItems.indexOf(e)&&t.activeItems.push(e)}removeActiveItem(e){var t=this.activeItems.indexOf(e)
+this.activeItems.splice(t,1),S(e,"active")}clearActiveItems(){S(this.activeItems,"active"),this.activeItems=[]}setActiveOption(e){e!==this.activeOption&&(this.clearActiveOption(),e&&(this.activeOption=e,P(this.focus_node,{"aria-activedescendant":e.getAttribute("id")}),P(e,{"aria-selected":"true"}),C(e,"active"),this.scrollToOption(e)))}scrollToOption(e,t){if(!e)return
+const i=this.dropdown_content,s=i.clientHeight,n=i.scrollTop||0,o=e.offsetHeight,r=e.getBoundingClientRect().top-i.getBoundingClientRect().top+n
+r+o>s+n?this.scroll(r-s+o,t):r<n&&this.scroll(r,t)}scroll(e,t){const i=this.dropdown_content
+t&&(i.style.scrollBehavior=t),i.scrollTop=e,i.style.scrollBehavior=""}clearActiveOption(){this.activeOption&&(S(this.activeOption,"active"),P(this.activeOption,{"aria-selected":null})),this.activeOption=null,P(this.focus_node,{"aria-activedescendant":null})}selectAll(){if("single"===this.settings.mode)return
+const e=this.controlChildren()
+e.length&&(this.hideInput(),this.close(),this.activeItems=e,C(e,"active"))}inputState(){var e=this
+e.control.contains(e.control_input)&&(P(e.control_input,{placeholder:e.settings.placeholder}),e.activeItems.length>0||!e.isFocused&&e.settings.hidePlaceholder&&e.items.length>0?(e.setTextboxValue(),e.isInputHidden=!0):(e.settings.hidePlaceholder&&e.items.length>0&&P(e.control_input,{placeholder:""}),e.isInputHidden=!1),e.wrapper.classList.toggle("input-hidden",e.isInputHidden))}hideInput(){this.inputState()}showInput(){this.inputState()}inputValue(){return this.control_input.value.trim()}focus(){var e=this
+e.isDisabled||(e.ignoreFocus=!0,e.control_input.offsetWidth?e.control_input.focus():e.focus_node.focus(),setTimeout((()=>{e.ignoreFocus=!1,e.onFocus()}),0))}blur(){this.focus_node.blur(),this.onBlur()}getScoreFunction(e){return this.sifter.getScoreFunction(e,this.getSearchOptions())}getSearchOptions(){var e=this.settings,t=e.sortField
+return"string"==typeof e.sortField&&(t=[{field:e.sortField}]),{fields:e.searchField,conjunction:e.searchConjunction,sort:t,nesting:e.nesting}}search(e){var t,i,s,n=this,o=this.getSearchOptions()
+if(n.settings.score&&"function"!=typeof(s=n.settings.score.call(n,e)))throw new Error('Tom Select "score" setting must be a function that returns a function')
+if(e!==n.lastQuery?(n.lastQuery=e,i=n.sifter.search(e,Object.assign(o,{score:s})),n.currentResults=i):i=Object.assign({},n.currentResults),n.settings.hideSelected)for(t=i.items.length-1;t>=0;t--){let e=q(i.items[t].id)
+e&&-1!==n.items.indexOf(e)&&i.items.splice(t,1)}return i}refreshOptions(e=!0){var t,i,s,n,o,r,l,a,c,d,p
+const u={},h=[]
+var g,f=this,v=f.inputValue(),m=f.search(v),O=f.activeOption,b=f.settings.shouldOpen||!1,w=f.dropdown_content
+for(O&&(c=O.dataset.value,d=O.closest("[data-group]")),n=m.items.length,"number"==typeof f.settings.maxOptions&&(n=Math.min(n,f.settings.maxOptions)),n>0&&(b=!0),t=0;t<n;t++){let e=m.items[t].id,n=f.options[e],l=f.getOption(e,!0)
+for(f.settings.hideSelected||l.classList.toggle("selected",f.items.includes(e)),o=n[f.settings.optgroupField]||"",i=0,s=(r=Array.isArray(o)?o:[o])&&r.length;i<s;i++)o=r[i],f.optgroups.hasOwnProperty(o)||(o=""),u.hasOwnProperty(o)||(u[o]=document.createDocumentFragment(),h.push(o)),i>0&&(l=l.cloneNode(!0),P(l,{id:n.$id+"-clone-"+i,"aria-selected":null}),l.classList.add("ts-cloned"),S(l,"active")),c==e&&d&&d.dataset.group===o&&(O=l),u[o].appendChild(l)}this.settings.lockOptgroupOrder&&h.sort(((e,t)=>(f.optgroups[e]&&f.optgroups[e].$order||0)-(f.optgroups[t]&&f.optgroups[t].$order||0))),l=document.createDocumentFragment(),y(h,(e=>{if(f.optgroups.hasOwnProperty(e)&&u[e].children.length){let t=document.createDocumentFragment(),i=f.render("optgroup_header",f.optgroups[e])
+G(t,i),G(t,u[e])
+let s=f.render("optgroup",{group:f.optgroups[e],options:t})
+G(l,s)}else G(l,u[e])})),w.innerHTML="",G(w,l),f.settings.highlight&&(g=w.querySelectorAll("span.highlight"),Array.prototype.forEach.call(g,(function(e){var t=e.parentNode
+t.replaceChild(e.firstChild,e),t.normalize()})),m.query.length&&m.tokens.length&&y(m.tokens,(e=>{T(w,e.regex)})))
+var _=e=>{let t=f.render(e,{input:v})
+return t&&(b=!0,w.insertBefore(t,w.firstChild)),t}
+if(f.loading?_("loading"):f.settings.shouldLoad.call(f,v)?0===m.items.length&&_("no_results"):_("not_loading"),(a=f.canCreate(v))&&(p=_("option_create")),f.hasOptions=m.items.length>0||a,b){if(m.items.length>0){if(!w.contains(O)&&"single"===f.settings.mode&&f.items.length&&(O=f.getOption(f.items[0])),!w.contains(O)){let e=0
+p&&!f.settings.addPrecedence&&(e=1),O=f.selectable()[e]}}else p&&(O=p)
+e&&!f.isOpen&&(f.open(),f.scrollToOption(O,"auto")),f.setActiveOption(O)}else f.clearActiveOption(),e&&f.isOpen&&f.close(!1)}selectable(){return this.dropdown_content.querySelectorAll("[data-selectable]")}addOption(e,t=!1){const i=this
+if(Array.isArray(e))return i.addOptions(e,t),!1
+const s=q(e[i.settings.valueField])
+return null!==s&&!i.options.hasOwnProperty(s)&&(e.$order=e.$order||++i.order,e.$id=i.inputId+"-opt-"+e.$order,i.options[s]=e,i.lastQuery=null,t&&(i.userOptions[s]=t,i.trigger("option_add",s,e)),s)}addOptions(e,t=!1){y(e,(e=>{this.addOption(e,t)}))}registerOption(e){return this.addOption(e)}registerOptionGroup(e){var t=q(e[this.settings.optgroupValueField])
+return null!==t&&(e.$order=e.$order||++this.order,this.optgroups[t]=e,t)}addOptionGroup(e,t){var i
+t[this.settings.optgroupValueField]=e,(i=this.registerOptionGroup(t))&&this.trigger("optgroup_add",i,t)}removeOptionGroup(e){this.optgroups.hasOwnProperty(e)&&(delete this.optgroups[e],this.clearCache(),this.trigger("optgroup_remove",e))}clearOptionGroups(){this.optgroups={},this.clearCache(),this.trigger("optgroup_clear")}updateOption(e,t){const i=this
+var s,n
+const o=q(e),r=q(t[i.settings.valueField])
+if(null===o)return
+if(!i.options.hasOwnProperty(o))return
+if("string"!=typeof r)throw new Error("Value must be set in option data")
+const l=i.getOption(o),a=i.getItem(o)
+if(t.$order=t.$order||i.options[o].$order,delete i.options[o],i.uncacheValue(r),i.options[r]=t,l){if(i.dropdown_content.contains(l)){const e=i._render("option",t)
+E(l,e),i.activeOption===l&&i.setActiveOption(e)}l.remove()}a&&(-1!==(n=i.items.indexOf(o))&&i.items.splice(n,1,r),s=i._render("item",t),a.classList.contains("active")&&C(s,"active"),E(a,s)),i.lastQuery=null}removeOption(e,t){const i=this
+e=D(e),i.uncacheValue(e),delete i.userOptions[e],delete i.options[e],i.lastQuery=null,i.trigger("option_remove",e),i.removeItem(e,t)}clearOptions(){this.loadedSearches={},this.userOptions={},this.clearCache()
+var e={}
+y(this.options,((t,i)=>{this.items.indexOf(i)>=0&&(e[i]=this.options[i])})),this.options=this.sifter.items=e,this.lastQuery=null,this.trigger("option_clear")}getOption(e,t=!1){const i=q(e)
+if(null!==i&&this.options.hasOwnProperty(i)){const e=this.options[i]
+if(e.$div)return e.$div
+if(t)return this._render("option",e)}return null}getAdjacent(e,t,i="option"){var s
+if(!e)return null
+s="item"==i?this.controlChildren():this.dropdown_content.querySelectorAll("[data-selectable]")
+for(let i=0;i<s.length;i++)if(s[i]==e)return t>0?s[i+1]:s[i-1]
+return null}getItem(e){if("object"==typeof e)return e
+var t=q(e)
+return null!==t?this.control.querySelector(`[data-value="${Q(t)}"]`):null}addItems(e,t){var i=this,s=Array.isArray(e)?e:[e]
+for(let e=0,n=(s=s.filter((e=>-1===i.items.indexOf(e)))).length;e<n;e++)i.isPending=e<n-1,i.addItem(s[e],t)}addItem(e,t){R(this,t?[]:["change"],(()=>{var i,s
+const n=this,o=n.settings.mode,r=q(e)
+if((!r||-1===n.items.indexOf(r)||("single"===o&&n.close(),"single"!==o&&n.settings.duplicates))&&null!==r&&n.options.hasOwnProperty(r)&&("single"===o&&n.clear(t),"multi"!==o||!n.isFull())){if(i=n._render("item",n.options[r]),n.control.contains(i)&&(i=i.cloneNode(!0)),s=n.isFull(),n.items.splice(n.caretPos,0,r),n.insertAtCaret(i),n.isSetup){if(!n.isPending&&n.settings.hideSelected){let e=n.getOption(r),t=n.getAdjacent(e,1)
+t&&n.setActiveOption(t)}n.isPending||n.refreshOptions(n.isFocused&&"single"!==o),0!=n.settings.closeAfterSelect&&n.isFull()?n.close():n.isPending||n.positionDropdown(),n.trigger("item_add",r,i),n.isPending||n.updateOriginalInput({silent:t})}(!n.isPending||!s&&n.isFull())&&(n.inputState(),n.refreshState())}}))}removeItem(e=null,t){const i=this
+if(!(e=i.getItem(e)))return
+var s,n
+const o=e.dataset.value
+s=L(e),e.remove(),e.classList.contains("active")&&(n=i.activeItems.indexOf(e),i.activeItems.splice(n,1),S(e,"active")),i.items.splice(s,1),i.lastQuery=null,!i.settings.persist&&i.userOptions.hasOwnProperty(o)&&i.removeOption(o,t),s<i.caretPos&&i.setCaret(i.caretPos-1),i.updateOriginalInput({silent:t}),i.refreshState(),i.positionDropdown(),i.trigger("item_remove",o,e)}createItem(e=null,t=!0,i=(()=>{})){var s,n=this,o=n.caretPos
+if(e=e||n.inputValue(),!n.canCreate(e))return i(),!1
+n.lock()
+var r=!1,l=e=>{if(n.unlock(),!e||"object"!=typeof e)return i()
+var s=q(e[n.settings.valueField])
+if("string"!=typeof s)return i()
+n.setTextboxValue(),n.addOption(e,!0),n.setCaret(o),n.addItem(s),n.refreshOptions(t&&"single"!==n.settings.mode),i(e),r=!0}
+return s="function"==typeof n.settings.create?n.settings.create.call(this,e,l):{[n.settings.labelField]:e,[n.settings.valueField]:e},r||l(s),!0}refreshItems(){var e=this
+e.lastQuery=null,e.isSetup&&e.addItems(e.items),e.updateOriginalInput(),e.refreshState()}refreshState(){const e=this
+e.refreshValidityState()
+const t=e.isFull(),i=e.isLocked
+e.wrapper.classList.toggle("rtl",e.rtl)
+const s=e.wrapper.classList
+var n
+s.toggle("focus",e.isFocused),s.toggle("disabled",e.isDisabled),s.toggle("required",e.isRequired),s.toggle("invalid",!e.isValid),s.toggle("locked",i),s.toggle("full",t),s.toggle("input-active",e.isFocused&&!e.isInputHidden),s.toggle("dropdown-active",e.isOpen),s.toggle("has-options",(n=e.options,0===Object.keys(n).length)),s.toggle("has-items",e.items.length>0)}refreshValidityState(){var e=this
+e.input.checkValidity&&(e.isValid=e.input.checkValidity(),e.isInvalid=!e.isValid)}isFull(){return null!==this.settings.maxItems&&this.items.length>=this.settings.maxItems}updateOriginalInput(e={}){const t=this
+var i,s
+const n=t.input.querySelector('option[value=""]')
+if(t.is_select_tag){const e=[]
+function o(i,s,o){return i||(i=w('<option value="'+N(s)+'">'+N(o)+"</option>")),i!=n&&t.input.append(i),e.push(i),i.selected=!0,i}t.input.querySelectorAll("option:checked").forEach((e=>{e.selected=!1})),0==t.items.length&&"single"==t.settings.mode?o(n,"",""):t.items.forEach((n=>{if(i=t.options[n],s=i[t.settings.labelField]||"",e.includes(i.$option)){o(t.input.querySelector(`option[value="${Q(n)}"]:not(:checked)`),n,s)}else i.$option=o(i.$option,n,s)}))}else t.input.value=t.getValue()
+t.isSetup&&(e.silent||t.trigger("change",t.getValue()))}open(){var e=this
+e.isLocked||e.isOpen||"multi"===e.settings.mode&&e.isFull()||(e.isOpen=!0,P(e.focus_node,{"aria-expanded":"true"}),e.refreshState(),I(e.dropdown,{visibility:"hidden",display:"block"}),e.positionDropdown(),I(e.dropdown,{visibility:"visible",display:"block"}),e.focus(),e.trigger("dropdown_open",e.dropdown))}close(e=!0){var t=this,i=t.isOpen
+e&&(t.setTextboxValue(),"single"===t.settings.mode&&t.items.length&&t.hideInput()),t.isOpen=!1,P(t.focus_node,{"aria-expanded":"false"}),I(t.dropdown,{display:"none"}),t.settings.hideSelected&&t.clearActiveOption(),t.refreshState(),i&&t.trigger("dropdown_close",t.dropdown)}positionDropdown(){if("body"===this.settings.dropdownParent){var e=this.control,t=e.getBoundingClientRect(),i=e.offsetHeight+t.top+window.scrollY,s=t.left+window.scrollX
+I(this.dropdown,{width:t.width+"px",top:i+"px",left:s+"px"})}}clear(e){var t=this
+if(t.items.length){var i=t.controlChildren()
+y(i,(e=>{t.removeItem(e,!0)})),t.showInput(),e||t.updateOriginalInput(),t.trigger("clear")}}insertAtCaret(e){const t=this,i=t.caretPos,s=t.control
+s.insertBefore(e,s.children[i]),t.setCaret(i+1)}deleteSelection(e){var t,i,s,n,o,r=this
+t=e&&8===e.keyCode?-1:1,i={start:(o=r.control_input).selectionStart||0,length:(o.selectionEnd||0)-(o.selectionStart||0)}
+const l=[]
+if(r.activeItems.length)n=F(r.activeItems,t),s=L(n),t>0&&s++,y(r.activeItems,(e=>l.push(e)))
+else if((r.isFocused||"single"===r.settings.mode)&&r.items.length){const e=r.controlChildren()
+t<0&&0===i.start&&0===i.length?l.push(e[r.caretPos-1]):t>0&&i.start===r.inputValue().length&&l.push(e[r.caretPos])}const a=l.map((e=>e.dataset.value))
+if(!a.length||"function"==typeof r.settings.onDelete&&!1===r.settings.onDelete.call(r,a,e))return!1
+for(H(e,!0),void 0!==s&&r.setCaret(s);l.length;)r.removeItem(l.pop())
+return r.showInput(),r.positionDropdown(),r.refreshOptions(!1),!0}advanceSelection(e,t){var i,s,n=this
+n.rtl&&(e*=-1),n.inputValue().length||(K(V,t)||K("shiftKey",t)?(s=(i=n.getLastActive(e))?i.classList.contains("active")?n.getAdjacent(i,e,"item"):i:e>0?n.control_input.nextElementSibling:n.control_input.previousElementSibling)&&(s.classList.contains("active")&&n.removeActiveItem(i),n.setActiveItemClass(s)):n.moveCaret(e))}moveCaret(e){}getLastActive(e){let t=this.control.querySelector(".last-active")
+if(t)return t
+var i=this.control.querySelectorAll(".active")
+return i?F(i,e):void 0}setCaret(e){this.caretPos=this.items.length}controlChildren(){return Array.from(this.control.querySelectorAll("[data-ts-item]"))}lock(){this.close(),this.isLocked=!0,this.refreshState()}unlock(){this.isLocked=!1,this.refreshState()}disable(){var e=this
+e.input.disabled=!0,e.control_input.disabled=!0,e.focus_node.tabIndex=-1,e.isDisabled=!0,e.lock()}enable(){var e=this
+e.input.disabled=!1,e.control_input.disabled=!1,e.focus_node.tabIndex=e.tabIndex,e.isDisabled=!1,e.unlock()}destroy(){var e=this,t=e.revertSettings
+e.trigger("destroy"),e.off(),e.wrapper.remove(),e.dropdown.remove(),e.input.innerHTML=t.innerHTML,e.input.tabIndex=t.tabIndex,S(e.input,"tomselected","ts-hidden-accessible"),e._destroy(),delete e.input.tomselect}render(e,t){return"function"!=typeof this.settings.render[e]?null:this._render(e,t)}_render(e,t){var i,s,n=""
+const o=this
+return"option"!==e&&"item"!=e||(n=D(t[o.settings.valueField])),null==(s=o.settings.render[e].call(this,t,N))||(s=w(s),"option"===e||"option_create"===e?t[o.settings.disabledField]?P(s,{"aria-disabled":"true"}):P(s,{"data-selectable":""}):"optgroup"===e&&(i=t.group[o.settings.optgroupValueField],P(s,{"data-group":i}),t.group[o.settings.disabledField]&&P(s,{"data-disabled":""})),"option"!==e&&"item"!==e||(P(s,{"data-value":n}),"item"===e?(C(s,o.settings.itemClass),P(s,{"data-ts-item":""})):(C(s,o.settings.optionClass),P(s,{role:"option",id:t.$id}),o.options[n].$div=s))),s}clearCache(){y(this.options,((e,t)=>{e.$div&&(e.$div.remove(),delete e.$div)}))}uncacheValue(e){const t=this.getOption(e)
+t&&t.remove()}canCreate(e){return this.settings.create&&e.length>0&&this.settings.createFilter.call(this,e)}hook(e,t,i){var s=this,n=s[t]
+s[t]=function(){var t,o
+return"after"===e&&(t=n.apply(s,arguments)),o=i.apply(s,arguments),"instead"===e?o:("before"===e&&(t=n.apply(s,arguments)),t)}}}return J.define("change_listener",(function(){B(this.input,"change",(()=>{this.sync()}))})),J.define("checkbox_options",(function(){var e=this,t=e.onOptionSelect
+e.settings.hideSelected=!1
+var i=function(e){setTimeout((()=>{var t=e.querySelector("input")
+e.classList.contains("selected")?t.checked=!0:t.checked=!1}),1)}
+e.hook("after","setupTemplates",(()=>{var t=e.settings.render.option
+e.settings.render.option=(i,s)=>{var n=w(t.call(e,i,s)),o=document.createElement("input")
+o.addEventListener("click",(function(e){H(e)})),o.type="checkbox"
+const r=q(i[e.settings.valueField])
+return r&&e.items.indexOf(r)>-1&&(o.checked=!0),n.prepend(o),n}})),e.on("item_remove",(t=>{var s=e.getOption(t)
+s&&(s.classList.remove("selected"),i(s))})),e.hook("instead","onOptionSelect",((s,n)=>{if(n.classList.contains("selected"))return n.classList.remove("selected"),e.removeItem(n.dataset.value),e.refreshOptions(),void H(s,!0)
+t.call(e,s,n),i(n)}))})),J.define("clear_button",(function(e){const t=this,i=Object.assign({className:"clear-button",title:"Clear All",html:e=>`<div class="${e.className}" title="${e.title}">&times;</div>`},e)
+t.on("initialize",(()=>{var e=w(i.html(i))
+e.addEventListener("click",(e=>{t.clear(),"single"===t.settings.mode&&t.settings.allowEmptyOption&&t.addItem(""),e.preventDefault(),e.stopPropagation()})),t.control.appendChild(e)}))})),J.define("drag_drop",(function(){var e=this
+if(!$.fn.sortable)throw new Error('The "drag_drop" plugin requires jQuery UI "sortable".')
+if("multi"===e.settings.mode){var t=e.lock,i=e.unlock
+e.hook("instead","lock",(()=>{var i=$(e.control).data("sortable")
+return i&&i.disable(),t.call(e)})),e.hook("instead","unlock",(()=>{var t=$(e.control).data("sortable")
+return t&&t.enable(),i.call(e)})),e.on("initialize",(()=>{var t=$(e.control).sortable({items:"[data-value]",forcePlaceholderSize:!0,disabled:e.isLocked,start:(e,i)=>{i.placeholder.css("width",i.helper.css("width")),t.css({overflow:"visible"})},stop:()=>{t.css({overflow:"hidden"})
+var i=[]
+t.children("[data-value]").each((function(){this.dataset.value&&i.push(this.dataset.value)})),e.setValue(i)}})}))}})),J.define("dropdown_header",(function(e){const t=this,i=Object.assign({title:"Untitled",headerClass:"dropdown-header",titleRowClass:"dropdown-header-title",labelClass:"dropdown-header-label",closeClass:"dropdown-header-close",html:e=>'<div class="'+e.headerClass+'"><div class="'+e.titleRowClass+'"><span class="'+e.labelClass+'">'+e.title+'</span><a class="'+e.closeClass+'">&times;</a></div></div>'},e)
+t.on("initialize",(()=>{var e=w(i.html(i)),s=e.querySelector("."+i.closeClass)
+s&&s.addEventListener("click",(e=>{H(e,!0),t.close()})),t.dropdown.insertBefore(e,t.dropdown.firstChild)}))})),J.define("caret_position",(function(){var e=this
+e.hook("instead","setCaret",(t=>{"single"!==e.settings.mode&&e.control.contains(e.control_input)?(t=Math.max(0,Math.min(e.items.length,t)))==e.caretPos||e.isPending||e.controlChildren().forEach(((i,s)=>{s<t?e.control_input.insertAdjacentElement("beforebegin",i):e.control.appendChild(i)})):t=e.items.length,e.caretPos=t})),e.hook("instead","moveCaret",(t=>{if(!e.isFocused)return
+const i=e.getLastActive(t)
+if(i){const s=L(i)
+e.setCaret(t>0?s+1:s),e.setActiveItem()}else e.setCaret(e.caretPos+t)}))})),J.define("dropdown_input",(function(){var e=this
+e.settings.shouldOpen=!0,e.hook("before","setup",(()=>{e.focus_node=e.control,C(e.control_input,"dropdown-input")
+const t=w('<div class="dropdown-input-wrap">')
+t.append(e.control_input),e.dropdown.insertBefore(t,e.dropdown.firstChild)})),e.on("initialize",(()=>{e.control_input.addEventListener("keydown",(t=>{switch(t.keyCode){case 27:return e.isOpen&&(H(t,!0),e.close()),void e.clearActiveItems()
+case 9:e.focus_node.tabIndex=-1}return e.onKeyDown.call(e,t)})),e.on("blur",(()=>{e.focus_node.tabIndex=e.isDisabled?-1:e.tabIndex})),e.on("dropdown_open",(()=>{e.control_input.focus()}))
+const t=e.onBlur
+e.hook("instead","onBlur",(i=>{if(!i||i.relatedTarget!=e.control_input)return t.call(e)})),B(e.control_input,"blur",(()=>e.onBlur())),e.hook("before","close",(()=>{e.isOpen&&e.focus_node.focus()}))}))})),J.define("input_autogrow",(function(){var e=this
+e.on("initialize",(()=>{var t=document.createElement("span"),i=e.control_input
+t.style.cssText="position:absolute; top:-99999px; left:-99999px; width:auto; padding:0; white-space:pre; ",e.wrapper.appendChild(t)
+for(const e of["letterSpacing","fontSize","fontFamily","fontWeight","textTransform"])t.style[e]=i.style[e]
+var s=()=>{e.items.length>0?(t.textContent=i.value,i.style.width=t.clientWidth+"px"):i.style.width=""}
+s(),e.on("update item_add item_remove",s),B(i,"input",s),B(i,"keyup",s),B(i,"blur",s),B(i,"update",s)}))})),J.define("no_backspace_delete",(function(){var e=this,t=e.deleteSelection
+this.hook("instead","deleteSelection",(i=>!!e.activeItems.length&&t.call(e,i)))})),J.define("no_active_items",(function(){this.hook("instead","setActiveItem",(()=>{})),this.hook("instead","selectAll",(()=>{}))})),J.define("optgroup_columns",(function(){var e=this,t=e.onKeyDown
+e.hook("instead","onKeyDown",(i=>{var s,n,o,r
+if(!e.isOpen||37!==i.keyCode&&39!==i.keyCode)return t.call(e,i)
+r=k(e.activeOption,"[data-group]"),s=L(e.activeOption,"[data-selectable]"),r&&(r=37===i.keyCode?r.previousSibling:r.nextSibling)&&(n=(o=r.querySelectorAll("[data-selectable]"))[Math.min(o.length-1,s)])&&e.setActiveOption(n)}))})),J.define("remove_button",(function(e){const t=Object.assign({label:"&times;",title:"Remove",className:"remove",append:!0},e)
+var i=this
+if(t.append){var s='<a href="javascript:void(0)" class="'+t.className+'" tabindex="-1" title="'+N(t.title)+'">'+t.label+"</a>"
+i.hook("after","setupTemplates",(()=>{var e=i.settings.render.item
+i.settings.render.item=(t,n)=>{var o=w(e.call(i,t,n)),r=w(s)
+return o.appendChild(r),B(r,"mousedown",(e=>{H(e,!0)})),B(r,"click",(e=>{if(H(e,!0),!i.isLocked){var t=o.dataset.value
+i.removeItem(t),i.refreshOptions(!1)}})),o}}))}})),J.define("restore_on_backspace",(function(e){const t=this,i=Object.assign({text:e=>e[t.settings.labelField]},e)
+t.on("item_remove",(function(e){if(""===t.control_input.value.trim()){var s=t.options[e]
+s&&t.setTextboxValue(i.text.call(t,s))}}))})),J.define("virtual_scroll",(function(){const e=this,t=e.canLoad,i=e.clearActiveOption,s=e.loadCallback
+var n,o={},r=!1
+if(!e.settings.firstUrl)throw"virtual_scroll plugin requires a firstUrl() method"
+function l(t){return!("number"==typeof e.settings.maxOptions&&n.children.length>=e.settings.maxOptions)&&!(!(t in o)||!o[t])}e.settings.sortField=[{field:"$order"},{field:"$score"}],e.setNextUrl=function(e,t){o[e]=t},e.getUrl=function(t){if(t in o){const e=o[t]
+return o[t]=!1,e}return o={},e.settings.firstUrl(t)},e.hook("instead","clearActiveOption",(()=>{if(!r)return i.call(e)})),e.hook("instead","canLoad",(i=>i in o?l(i):t.call(e,i))),e.hook("instead","loadCallback",((t,i)=>{r||e.clearOptions(),s.call(e,t,i),r=!1})),e.hook("after","refreshOptions",(()=>{const t=e.lastValue
+var i
+l(t)?(i=e.render("loading_more",{query:t}))&&i.setAttribute("data-selectable",""):t in o&&!n.querySelector(".no-results")&&(i=e.render("no_more_results",{query:t})),i&&(C(i,e.settings.optionClass),n.append(i))})),e.on("initialize",(()=>{n=e.dropdown_content,e.settings.render=Object.assign({},{loading_more:function(){return'<div class="loading-more-results">Loading more results ... </div>'},no_more_results:function(){return'<div class="no-more-results">No more results</div>'}},e.settings.render),n.addEventListener("scroll",(function(){n.clientHeight/(n.scrollHeight-n.scrollTop)<.95||l(e.lastValue)&&(r||(r=!0,e.load.call(e,e.lastValue)))}))}))})),J}))
+var tomSelect=function(e,t){return new TomSelect(e,t)}
+//# sourceMappingURL=tom-select.complete.min.js.map

src/lib/tom-select/tom-select.css

@@ -0,0 +1,334 @@
+/**
+ * tom-select.css (v2.0.0-rc.4)
+ * Copyright (c) contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
+ * file except in compliance with the License. You may obtain a copy of the License at:
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
+ * ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ *
+ */
+.ts-wrapper.plugin-drag_drop.multi > .ts-control > div.ui-sortable-placeholder {
+  visibility: visible !important;
+  background: #f2f2f2 !important;
+  background: rgba(0, 0, 0, 0.06) !important;
+  border: 0 none !important;
+  box-shadow: inset 0 0 12px 4px #fff; }
+
+.ts-wrapper.plugin-drag_drop .ui-sortable-placeholder::after {
+  content: '!';
+  visibility: hidden; }
+
+.ts-wrapper.plugin-drag_drop .ui-sortable-helper {
+  box-shadow: 0 2px 5px rgba(0, 0, 0, 0.2); }
+
+.plugin-checkbox_options .option input {
+  margin-right: 0.5rem; }
+
+.plugin-clear_button .ts-control {
+  padding-right: calc( 1em + (3 * 6px)) !important; }
+
+.plugin-clear_button .clear-button {
+  opacity: 0;
+  position: absolute;
+  top: 8px;
+  right: calc(8px - 6px);
+  margin-right: 0 !important;
+  background: transparent !important;
+  transition: opacity 0.5s;
+  cursor: pointer; }
+
+.plugin-clear_button.single .clear-button {
+  right: calc(8px - 6px +  2rem); }
+
+.plugin-clear_button.focus.has-items .clear-button,
+.plugin-clear_button:hover.has-items .clear-button {
+  opacity: 1; }
+
+.ts-wrapper .dropdown-header {
+  position: relative;
+  padding: 10px 8px;
+  border-bottom: 1px solid #d0d0d0;
+  background: #f8f8f8;
+  border-radius: 3px 3px 0 0; }
+
+.ts-wrapper .dropdown-header-close {
+  position: absolute;
+  right: 8px;
+  top: 50%;
+  color: #303030;
+  opacity: 0.4;
+  margin-top: -12px;
+  line-height: 20px;
+  font-size: 20px !important; }
+
+.ts-wrapper .dropdown-header-close:hover {
+  color: black; }
+
+.plugin-dropdown_input.focus.dropdown-active .ts-control {
+  box-shadow: none;
+  border: 1px solid #d0d0d0; }
+
+.plugin-dropdown_input .dropdown-input {
+  border: 1px solid #d0d0d0;
+  border-width: 0 0 1px 0;
+  display: block;
+  padding: 8px 8px;
+  box-shadow: none;
+  width: 100%;
+  background: transparent; }
+
+.ts-wrapper.plugin-input_autogrow.has-items .ts-control > input {
+  min-width: 0; }
+
+.ts-wrapper.plugin-input_autogrow.has-items.focus .ts-control > input {
+  flex: none;
+  min-width: 4px; }
+  .ts-wrapper.plugin-input_autogrow.has-items.focus .ts-control > input::-webkit-input-placeholder {
+    color: transparent; }
+  .ts-wrapper.plugin-input_autogrow.has-items.focus .ts-control > input::-ms-input-placeholder {
+    color: transparent; }
+  .ts-wrapper.plugin-input_autogrow.has-items.focus .ts-control > input::placeholder {
+    color: transparent; }
+
+.ts-dropdown.plugin-optgroup_columns .ts-dropdown-content {
+  display: flex; }
+
+.ts-dropdown.plugin-optgroup_columns .optgroup {
+  border-right: 1px solid #f2f2f2;
+  border-top: 0 none;
+  flex-grow: 1;
+  flex-basis: 0;
+  min-width: 0; }
+
+.ts-dropdown.plugin-optgroup_columns .optgroup:last-child {
+  border-right: 0 none; }
+
+.ts-dropdown.plugin-optgroup_columns .optgroup:before {
+  display: none; }
+
+.ts-dropdown.plugin-optgroup_columns .optgroup-header {
+  border-top: 0 none; }
+
+.ts-wrapper.plugin-remove_button .item {
+  display: inline-flex;
+  align-items: center;
+  padding-right: 0 !important; }
+
+.ts-wrapper.plugin-remove_button .item .remove {
+  color: inherit;
+  text-decoration: none;
+  vertical-align: middle;
+  display: inline-block;
+  padding: 2px 6px;
+  border-left: 1px solid #d0d0d0;
+  border-radius: 0 2px 2px 0;
+  box-sizing: border-box;
+  margin-left: 6px; }
+
+.ts-wrapper.plugin-remove_button .item .remove:hover {
+  background: rgba(0, 0, 0, 0.05); }
+
+.ts-wrapper.plugin-remove_button .item.active .remove {
+  border-left-color: #cacaca; }
+
+.ts-wrapper.plugin-remove_button.disabled .item .remove:hover {
+  background: none; }
+
+.ts-wrapper.plugin-remove_button.disabled .item .remove {
+  border-left-color: white; }
+
+.ts-wrapper.plugin-remove_button .remove-single {
+  position: absolute;
+  right: 0;
+  top: 0;
+  font-size: 23px; }
+
+.ts-wrapper {
+  position: relative; }
+
+.ts-dropdown,
+.ts-control,
+.ts-control input {
+  color: #303030;
+  font-family: inherit;
+  font-size: 13px;
+  line-height: 18px;
+  font-smoothing: inherit; }
+
+.ts-control,
+.ts-wrapper.single.input-active .ts-control {
+  background: #fff;
+  cursor: text; }
+
+.ts-control {
+  border: 1px solid #d0d0d0;
+  padding: 8px 8px;
+  width: 100%;
+  overflow: hidden;
+  position: relative;
+  z-index: 1;
+  box-sizing: border-box;
+  box-shadow: none;
+  border-radius: 3px;
+  display: flex;
+  flex-wrap: wrap; }
+  .ts-wrapper.multi.has-items .ts-control {
+    padding: calc( 8px - 2px - 0) 8px calc( 8px - 2px - 3px - 0); }
+  .full .ts-control {
+    background-color: #fff; }
+  .disabled .ts-control,
+  .disabled .ts-control * {
+    cursor: default !important; }
+  .focus .ts-control {
+    box-shadow: none; }
+  .ts-control > * {
+    vertical-align: baseline;
+    display: inline-block; }
+  .ts-wrapper.multi .ts-control > div {
+    cursor: pointer;
+    margin: 0 3px 3px 0;
+    padding: 2px 6px;
+    background: #f2f2f2;
+    color: #303030;
+    border: 0 solid #d0d0d0; }
+    .ts-wrapper.multi .ts-control > div.active {
+      background: #e8e8e8;
+      color: #303030;
+      border: 0 solid #cacaca; }
+  .ts-wrapper.multi.disabled .ts-control > div, .ts-wrapper.multi.disabled .ts-control > div.active {
+    color: #7d7c7c;
+    background: white;
+    border: 0 solid white; }
+  .ts-control > input {
+    flex: 1 1 auto;
+    min-width: 7rem;
+    display: inline-block !important;
+    padding: 0 !important;
+    min-height: 0 !important;
+    max-height: none !important;
+    max-width: 100% !important;
+    margin: 0 !important;
+    text-indent: 0 !important;
+    border: 0 none !important;
+    background: none !important;
+    line-height: inherit !important;
+    -webkit-user-select: auto !important;
+       -moz-user-select: auto !important;
+        -ms-user-select: auto !important;
+            user-select: auto !important;
+    box-shadow: none !important; }
+    .ts-control > input::-ms-clear {
+      display: none; }
+    .ts-control > input:focus {
+      outline: none !important; }
+  .has-items .ts-control > input {
+    margin: 0 4px !important; }
+  .ts-control.rtl {
+    text-align: right; }
+    .ts-control.rtl.single .ts-control:after {
+      left: 15px;
+      right: auto; }
+    .ts-control.rtl .ts-control > input {
+      margin: 0 4px 0 -2px !important; }
+  .disabled .ts-control {
+    opacity: 0.5;
+    background-color: #fafafa; }
+  .input-hidden .ts-control > input {
+    opacity: 0;
+    position: absolute;
+    left: -10000px; }
+
+.ts-dropdown {
+  position: absolute;
+  top: 100%;
+  left: 0;
+  width: 100%;
+  z-index: 10;
+  border: 1px solid #d0d0d0;
+  background: #fff;
+  margin: 0.25rem 0 0 0;
+  border-top: 0 none;
+  box-sizing: border-box;
+  box-shadow: 0 1px 3px rgba(0, 0, 0, 0.1);
+  border-radius: 0 0 3px 3px; }
+  .ts-dropdown [data-selectable] {
+    cursor: pointer;
+    overflow: hidden; }
+    .ts-dropdown [data-selectable] .highlight {
+      background: rgba(125, 168, 208, 0.2);
+      border-radius: 1px; }
+  .ts-dropdown .option,
+  .ts-dropdown .optgroup-header,
+  .ts-dropdown .no-results,
+  .ts-dropdown .create {
+    padding: 5px 8px; }
+  .ts-dropdown .option, .ts-dropdown [data-disabled], .ts-dropdown [data-disabled] [data-selectable].option {
+    cursor: inherit;
+    opacity: 0.5; }
+  .ts-dropdown [data-selectable].option {
+    opacity: 1;
+    cursor: pointer; }
+  .ts-dropdown .optgroup:first-child .optgroup-header {
+    border-top: 0 none; }
+  .ts-dropdown .optgroup-header {
+    color: #303030;
+    background: #fff;
+    cursor: default; }
+  .ts-dropdown .create:hover,
+  .ts-dropdown .option:hover,
+  .ts-dropdown .active {
+    background-color: #f5fafd;
+    color: #495c68; }
+    .ts-dropdown .create:hover.create,
+    .ts-dropdown .option:hover.create,
+    .ts-dropdown .active.create {
+      color: #495c68; }
+  .ts-dropdown .create {
+    color: rgba(48, 48, 48, 0.5); }
+  .ts-dropdown .spinner {
+    display: inline-block;
+    width: 30px;
+    height: 30px;
+    margin: 5px 8px; }
+    .ts-dropdown .spinner:after {
+      content: " ";
+      display: block;
+      width: 24px;
+      height: 24px;
+      margin: 3px;
+      border-radius: 50%;
+      border: 5px solid #d0d0d0;
+      border-color: #d0d0d0 transparent #d0d0d0 transparent;
+      animation: lds-dual-ring 1.2s linear infinite; }
+
+@keyframes lds-dual-ring {
+  0% {
+    transform: rotate(0deg); }
+  100% {
+    transform: rotate(360deg); } }
+
+.ts-dropdown-content {
+  overflow-y: auto;
+  overflow-x: hidden;
+  max-height: 200px;
+  overflow-scrolling: touch;
+  scroll-behavior: smooth; }
+
+.ts-hidden-accessible {
+  border: 0 !important;
+  clip: rect(0 0 0 0) !important;
+  -webkit-clip-path: inset(50%) !important;
+          clip-path: inset(50%) !important;
+  height: 1px !important;
+  overflow: hidden !important;
+  padding: 0 !important;
+  position: absolute !important;
+  width: 1px !important;
+  white-space: nowrap !important; }
+
+/*# sourceMappingURL=tom-select.css.map */

src/networks_graphs/Con100_Cleft50/biases.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d655d2708c365e4804b6f63faaf7c82224bc299e34ed806a948e1e62e9ca2c54
+size 2471401

src/networks_graphs/Con100_Cleft50/graph.graphml

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ba1a4b908deff9fdf12d9caa3d215fabb0cc8f38e395ee5f86327343ce0bd85
+size 681118580

src/utils.py

@@ -0,0 +1,691 @@
+# This file contains functions that could be used in different parts of the project
+
+import numpy as np
+import networkx as nx
+import os
+import pickle
+import sys
+import matplotlib.pyplot as plt
+import csv
+import scipy
+from scipy.sparse import csr_matrix
+import copy
+import seaborn as sns
+import pandas as pd
+import random
+from collections import Counter
+import time
+from heapq import heappop, heappush
+import itertools
+from collections import deque
+
+BASE_DIR = os.path.dirname(os.path.abspath(__file__))
+
+# These functions are used to handle the reservoir during computation
+
+def compute(x, W, Win, u, alpha):
+    """
+    Computes a single step of the neuron activity
+    """
+    W_spr = W
+    x_spr = csr_matrix(x)
+    Win_spr = csr_matrix(Win)
+    u_spr = csr_matrix(u)
+    newx_spr = np.tanh(W_spr @ x_spr + Win_spr @ u_spr)
+    newx = newx_spr.toarray()
+    newx = (1-alpha)*x + newx*alpha
+    return newx
+
+def step_compute(x, W, Win, Wout, u_in, alpha, mask):
+    """
+    Computes a single step of the neuron activity and returns the output y
+    u_in should be the raw input vector WITHOUT the bias term.
+    """
+    # Reshape u_in to make sure it's a column vector (Nu, 1)
+    u_in = np.array(u_in).reshape(-1, 1)
+    
+    # Append bias 1 for the reservoir compute
+    u_in_with_bias = np.vstack((u_in, [[1]]))
+    
+    # Calculate new reservoir state
+    newx = compute(x, W, Win, u_in_with_bias, alpha)
+    
+    # Calculate output y = Wout @ [1; x[mask]] (Skip connection u_in removed)
+    X_col = np.vstack((np.ones((1,1)), newx[mask].reshape(-1, 1)))
+    y = Wout @ X_col
+    
+    return newx, y
+
+def simulate(x, W, Win, u, alpha, XX = None, XY = None, Yhat = None, building_matrices = False, mask=None):
+    """
+    Sumulates the neural response to the entire input
+    """
+    #time0 = time.time()
+    # Simulates the Echo State Network over the input u (L x (1+Nu))
+    if building_matrices: # this makes the time scale linearly with respect to the number of samples
+        if mask is None:
+            raise("Need to provide a mask for this step")
+        if XX is None or XY is None or Yhat is None:
+            raise("You need to provide the the basic matrices to build them incremetally")
+        retval = []
+        newx = copy.deepcopy(x)
+        for u_idx, u_in in enumerate(u):
+            #print(time.time())
+            newx = compute(newx, W, Win, u_in.reshape((u.shape[1],-1)), alpha)
+            retval.append(newx)
+            #print(time.time())
+            # Skip connection removed
+            newx_reshaped = np.hstack((np.ones((1,1)), newx[mask].reshape(1,-1)))
+            # Assuming newx_reshaped and Yhat are numpy arrays
+            newx_reshaped_col = newx_reshaped.reshape(-1, 1)
+            newx_reshaped_row = newx_reshaped.reshape(1, -1)
+            Yhat_col = Yhat[:, u_idx].reshape(-1, 1)
+
+            #print(time.time())
+            XX += np.dot(newx_reshaped_col, newx_reshaped_row)
+            XY += np.dot(Yhat_col, newx_reshaped_row)
+            #print(time.time())
+        retval = np.array(retval).reshape((-1,len(x))).transpose()
+        #print(f"computation in {time.time() - time0} :  {time.time()} - {time0}")
+        return XX, XY, retval
+    else:
+        retval = []
+        newx = copy.deepcopy(x)
+        for u_in in u: 
+            newx = compute(newx, W, Win, u_in.reshape((u.shape[1],-1)), alpha)
+            retval.append(newx)
+        retval = np.array(retval).reshape((-1,len(x))).transpose()
+        #print(f"computation in {time.time() - time0} :  {time.time()} - {time0}")
+        return retval
+
+# These functions are used to handle the complete graph of the brain and cut it down into smaller subgraphs
+
+def create_connectivity_matrix(num_neu, graph_folder_name, sel_crit, biologically_accurate=False, showing_figure = False, make_comparison = True): # Creates the connectivity matrix ad W, and also W_in, W_out and biases. Saves them in the current directory, ready to be used by main.ipynb
+
+    # get cells classes, that will be useful for the input definition
+
+    csv_file = os.path.join(BASE_DIR, 'classes_by_cell_type.csv')
+    input_cell_types = ['olfactory', 'visual', 'mechanosensory', 'hygrosensory', 'unknown_sensory', 'ocellar', 'gustatory', 'thermosensory']
+    output_cell_types = [
+        "MBON", "DAN", "LHCENT", "clock", "pars_intercerebralis",
+        "pars_lateralis", "Kenyon_Cell", "ALON", "LOP>ME", 
+        "LOP>LO.ME", "LOP>LO", "LOP", "TuBu"
+    ]
+
+    data = []
+    with open(csv_file, 'r') as file:
+        csv_reader = csv.reader(file)
+        header = next(csv_reader)  # Skip the header row
+        id_index = header.index('pt_root_id')
+        cell_type_index = header.index('cell_type')
+        for row in csv_reader:
+            cell_id = row[id_index]
+            cell_type = row[cell_type_index]
+            data += [(cell_id, cell_type)]
+
+    data_dict = {str(cell_id): cell_type for cell_id, cell_type in data}
+
+    # Load the network from a file
+
+    file_path = os.path.join(BASE_DIR ,'networks_graphs', graph_folder_name)
+
+    G = nx.read_graphml(os.path.join( file_path,'graph.graphml'))
+
+    unique_neurons = set(G.nodes())
+
+    # Load the biases from a file
+    with open(os.path.join( file_path,'biases.pkl'), 'rb') as file:
+        biases = pickle.load(file)
+
+
+    F, theta = selection_criterion(G=G, num_neu=num_neu, unique_neurons=unique_neurons, biases=biases, data_dict=data_dict, mode=sel_crit)
+
+    first_elements = {int(u) for u, v in F.edges}
+    second_elements = {int(v) for u, v in F.edges}
+
+    only_first = first_elements - second_elements
+    only_second = second_elements - first_elements
+    both = first_elements & second_elements
+
+    if showing_figure:
+
+        # Create a figure with 4 subplots
+        fig, axs = plt.subplots(2, 2, figsize=(12, 8))
+
+        # Degree distribution
+        degrees = [F.degree(n) for n in F.nodes()]
+        axs[0, 0].hist(degrees, bins=range(min(degrees), max(degrees) + 1), edgecolor='black')
+        axs[0, 0].set_title('Degree Distribution')
+        axs[0, 0].set_xlabel('Degree')
+        axs[0, 0].set_ylabel('Frequency')
+
+        # Clustering coefficient distribution
+        clustering_coeffs = nx.clustering(F).values()
+        axs[0, 1].hist(clustering_coeffs, bins=10, edgecolor='black')
+        axs[0, 1].set_title('Clustering Coefficient Distribution')
+        axs[0, 1].set_xlabel('Clustering Coefficient')
+        axs[0, 1].set_ylabel('Frequency')
+
+        # Shortest path length distribution
+        if nx.is_connected(F):
+            path_lengths = dict(nx.all_pairs_shortest_path_length(F))
+            lengths = []
+            for source in path_lengths:
+                for target in path_lengths[source]:
+                    if source != target:
+                        lengths.append(path_lengths[source][target])
+            axs[1, 0].hist(lengths, bins=range(min(lengths), max(lengths) + 1), edgecolor='black', align='left')
+            axs[1, 0].set_title('Shortest Path Length Distribution')
+            axs[1, 0].set_xlabel('Path Length')
+            axs[1, 0].set_ylabel('Frequency')
+        else:
+            axs[1, 0].text(0.5, 0.5, "The graph is not connected,\nso shortest path lengths cannot be computed for all pairs of nodes.",
+                        horizontalalignment='center', verticalalignment='center', transform=axs[1, 0].transAxes)
+
+        # Connectivity of Unique IDs
+        labels = ['Only as Pre-syn', 'Only as Post-syn', 'Both']
+        sizes = [len(only_first), len(only_second), len(both)]
+        axs[1, 1].bar(labels, sizes, color=['blue', 'orange', 'green'])
+        axs[1, 1].set_title('Connectivity of Unique Neurons')
+        axs[1, 1].set_xlabel('Category')
+        axs[1, 1].set_ylabel('Number of Unique Neurons')
+
+        # Adjust the spacing between subplots
+        plt.tight_layout()
+
+        # Show the figure
+        plt.show()
+
+        # Save the figure in the /graph_stats/ folder
+        if not os.path.exists('graph_stats'):
+            os.makedirs('graph_stats')
+
+        graph_size = len(F.nodes())
+        figure_path = os.path.join('graph_stats', f'graph_stats_size_{graph_size}.png')
+        fig.savefig(figure_path)
+        print(f"Figure saved to {figure_path}")
+
+        if make_comparison:
+
+            # Create a graph D with the same sparsity as G but with randomly placed edges
+            num_nodes = len(F.nodes())
+            num_edges = len(F.edges())
+
+            # Generate a random graph with the same number of nodes and edges
+            D = nx.gnm_random_graph(num_nodes, num_edges)
+
+            while not nx.is_connected(D):
+                D = nx.gnm_random_graph(num_nodes, num_edges)
+
+            # Relabel the nodes of D to match the node labels of F
+            mapping = {i: node for i, node in enumerate(F.nodes())}
+            D = nx.relabel_nodes(D, mapping)
+
+            # Create a figure with 4 subplots
+            fig, axs = plt.subplots(2, 2, figsize=(12, 8))
+
+            # Degree distribution
+            degrees = [D.degree(n) for n in D.nodes()]
+            axs[0, 0].hist(degrees, bins=range(min(degrees), max(degrees) + 1), edgecolor='black')
+            axs[0, 0].set_title('Degree Distribution')
+            axs[0, 0].set_xlabel('Degree')
+            axs[0, 0].set_ylabel('Frequency')
+
+            # Clustering coefficient distribution
+            clustering_coeffs = nx.clustering(D).values()
+            axs[0, 1].hist(clustering_coeffs, bins=10, edgecolor='black')
+            axs[0, 1].set_title('Clustering Coefficient Distribution')
+            axs[0, 1].set_xlabel('Clustering Coefficient')
+            axs[0, 1].set_ylabel('Frequency')
+
+            # Shortest path length distribution
+            if nx.is_connected(D):
+                path_lengths = dict(nx.all_pairs_shortest_path_length(D))
+                lengths = []
+                for source in path_lengths:
+                    for target in path_lengths[source]:
+                        if source != target:
+                            lengths.append(path_lengths[source][target])
+                axs[1, 0].hist(lengths, bins=range(min(lengths), max(lengths) + 1), edgecolor='black', align='left')
+                axs[1, 0].set_title('Shortest Path Length Distribution')
+                axs[1, 0].set_xlabel('Path Length')
+                axs[1, 0].set_ylabel('Frequency')
+            else:
+                axs[1, 0].text(0.5, 0.5, "The graph is not connected,\nso shortest path lengths cannot be computed for all pairs of nodes.",
+                            horizontalalignment='center', verticalalignment='center', transform=axs[1, 0].transAxes)
+                
+            first_elements_D = {int(u) for u, v in D.edges}
+            second_elements_D  = {int(v) for u, v in D.edges}
+
+            only_first_D  = first_elements_D  - second_elements_D 
+            only_second_D  = second_elements_D  - first_elements_D 
+            both_D  = first_elements_D  & second_elements_D 
+
+            # Connectivity of Unique IDs
+            labels = ['Only as Pre-syn', 'Only as Post-syn', 'Both']
+            sizes = [len(only_first_D ), len(only_second_D ), len(both_D )]
+            axs[1, 1].bar(labels, sizes, color=['blue', 'orange', 'green'])
+            axs[1, 1].set_title('Connectivity of Unique Neurons')
+            axs[1, 1].set_xlabel('Category')
+            axs[1, 1].set_ylabel('Number of Unique Neurons')
+
+            # Adjust the spacing between subplots
+            plt.tight_layout()
+
+            # Show the figure
+            plt.show()
+
+            
+            # Save the figure in the /graph_stats/ folder
+            if not os.path.exists('graph_stats'):
+                os.makedirs('graph_stats')
+
+            graph_size = len(F.nodes())
+            figure_path = os.path.join('graph_stats', f'graph_stats_size_{graph_size}_random_perm.png')
+            fig.savefig(figure_path)
+            print(f"Figure saved to {figure_path}")
+            
+
+
+
+    # Convert the connectivity matrix to a sparse matrix
+    connectivity_matrix = scipy.sparse.csr_matrix(nx.to_scipy_sparse_array(F, weight='weight'))
+
+    target_radius = 1
+    spectral_radius, _ = scipy.sparse.linalg.eigs(connectivity_matrix, k=1, which='LM')
+
+    # Rescale the connectivity matrix
+    theta = theta.astype('float')
+    rescaled_matrix = connectivity_matrix * target_radius/np.linalg.norm(spectral_radius)
+    theta *= target_radius/abs(float(np.linalg.norm(spectral_radius)))
+
+
+
+    print("Initial Spectral Radius:", spectral_radius)
+
+    # Keep scaling the matrix down until the spectral radius is below 1
+    scaling_factor = .99
+
+    while True:
+        spectral_radius, _ = scipy.sparse.linalg.eigs(rescaled_matrix, k=1, which='LM')
+        print(f"\rSpectral Radius: {np.linalg.norm(spectral_radius)}", end='', flush=True)
+        if np.linalg.norm(spectral_radius) < 1:
+            break
+        rescaled_matrix *= scaling_factor
+        theta *= scaling_factor
+    print(f"\n")
+
+
+    # Create W_in array
+    W_in = np.zeros((len(F.nodes()) , 1))
+
+    # Update W_in based on input_cell_types
+    for i, neuron_id in enumerate(F.nodes()):
+        if int(neuron_id) in [int(x) for x in list(data_dict.keys())] and data_dict[neuron_id] in input_cell_types:
+            W_in[i] = 1
+
+    if not biologically_accurate or np.max(W_in) == 0:
+        print("No input neurons found in the selected neurons, switching to first element only neurons.")
+        for i, neuron_id in enumerate(F.nodes()):
+            if int(neuron_id) in only_first:
+                W_in[i] = 1
+
+    if np.max(W_in) == 0:
+        print("no first element only neurons found")
+        W_in = None
+
+    W_out = np.zeros((len(F.nodes()), 1))
+
+    # Update W_out based on output_cell_types
+    for i, neuron_id in enumerate(F.nodes()):
+        if int(neuron_id) in [int(x) for x in list(data_dict.keys())] and data_dict[neuron_id] in output_cell_types:
+            W_out[i] = 1
+
+    if not biologically_accurate or np.max(W_out) == 0:
+        print("No output neurons found in the selected neurons, switching to second element only neurons.")
+        for i, neuron_id in enumerate(F.nodes()):
+            if int(neuron_id) in only_second:
+                W_out[i] = 1
+
+    if np.max(W_out) == 0:
+        print("no second element only neurons found")
+        W_out = None
+
+    # Save W_out to a file called W_out
+    with open(os.path.join(BASE_DIR, 'W_out.pkl'), 'wb') as file:
+        pickle.dump(W_out, file)
+
+    # Save connectivity_matrix to a file called W
+    with open(os.path.join(BASE_DIR, 'W.pkl'), 'wb') as file:
+        pickle.dump(rescaled_matrix, file)
+
+    # Save W_in to a file called W_in
+    with open(os.path.join(BASE_DIR, 'W_in.pkl'), 'wb') as file:
+        pickle.dump(W_in, file)
+
+    # Save theta to a file called theta.pkl
+    with open(os.path.join(BASE_DIR, 'bias.pkl'), 'wb') as file:
+        pickle.dump(theta, file)
+
+# This function is similar to the one above, but it does not save the matrices in src/** and only returns the neurons IDs and the unique cell types
+
+def get_neurons_id(num_neu, mode, graph_folder_name):
+
+    # get cells classes, that will be useful for the input definition
+
+    csv_file = os.path.join(BASE_DIR, 'classes_by_cell_type.csv')
+
+    data = []
+    with open(csv_file, 'r') as file:
+        csv_reader = csv.reader(file)
+        header = next(csv_reader)  # Skip the header row
+        id_index = header.index('pt_root_id')
+        cell_type_index = header.index('cell_type')
+        for row in csv_reader:
+            cell_id = row[id_index]
+            cell_type = row[cell_type_index]
+            data += [(cell_id, cell_type)]
+
+    data_dict = {str(cell_id): cell_type for cell_id, cell_type in data}
+
+    # Load the network from a file
+
+    file_path = os.path.join(BASE_DIR, 'networks_graphs', graph_folder_name)
+
+    G = nx.read_graphml(os.path.join( file_path,'graph.graphml'))
+
+    unique_neurons = set(G.nodes())
+
+    # Calculate the total number of edges for each neuron
+    edge_counts = {neuron: G.degree(neuron) for neuron in unique_neurons}
+
+    # Sort the neuron IDs based on the edge counts in descending order
+    sorted_neurons = sorted(unique_neurons, key=lambda neuron: edge_counts[neuron], reverse=True)
+
+    # Create a sorted list of neuron IDs
+    neuron_id_list = list(sorted_neurons)
+
+    F, _ = selection_criterion(G=G, num_neu=num_neu, unique_neurons=unique_neurons, mode=mode, biases=None, data_dict=data_dict)
+
+    neuron_ids_in_F = list(F.nodes)
+    unique_cell_types_in_F = set(data_dict[neuron_id] for neuron_id in neuron_ids_in_F if neuron_id in data_dict)
+    return neuron_ids_in_F, unique_cell_types_in_F
+
+
+def selection_criterion(G, num_neu, unique_neurons, data_dict,  biases = None, mode='connectivity_first', params=None): #This function selects a smaller subset of N neurons from the full NetworkX graph G, and returns the NetworkX graph F, containing N nodes
+
+    if 'connectivity_first' in mode:
+
+        # Calculate the total number of edges for each neuron
+        edge_counts = {neuron: G.degree(neuron) for neuron in unique_neurons}
+
+        # Sort the neuron IDs based on the edge counts in descending order
+        sorted_neurons = sorted(unique_neurons, key=lambda neuron: edge_counts[neuron], reverse=True)
+        
+        if biases is not None:
+            sorted_biases = np.array([biases[nrn] for nrn in sorted_neurons])
+
+        # Create a sorted list of neuron IDs
+        neuron_id_list = list(sorted_neurons)
+
+        num_neuron = num_neu
+
+        # Create a subgraph of G with the first num_neurons neurons
+        F = G.subgraph(neuron_id_list[:num_neuron])
+
+        # Create a copy of the subgraph
+        F = F.copy()
+
+        if '2' in mode:
+
+            if not nx.is_connected(F):
+                print("Graph not fully connected, connecting the components")
+                components = list(nx.connected_components(F))
+                meta_graph = nx.Graph()
+                for i, comp in enumerate(components):
+                    meta_graph.add_node(i)
+
+                candidate_nodes = set(G.nodes()) - set(F.nodes())
+                best_addition = set()
+
+                F = min_node_connected_subgraph(G, components)
+
+            print("Pruning components")
+
+            # Check the number of nodes in F
+            while len(F.nodes()) > num_neuron:
+                # Find the least connected node
+                sorted_nodes = sorted(F.nodes, key=lambda node: F.degree(node))
+                for node in sorted_nodes:
+                    F_tentative = F.copy()
+                    F_tentative.remove_node(node)
+                    if nx.is_connected(F_tentative):
+                        F = F_tentative
+                        break
+                    print(f"\rCurrent number of nodes: {len(F.nodes())}", end='', flush=True)
+
+            print("Adding components")
+
+            while len(F.nodes()) < num_neuron:
+                # Find the node in G that is most connected to nodes already in F
+                candidate_nodes = set(G.nodes()) - set(F.nodes())
+                best_node = max(candidate_nodes, key=lambda node: len(set(G.neighbors(node)) & set(F.nodes())))
+                F.add_node(best_node)
+                for neighbor in G.neighbors(best_node):
+                    if neighbor in F.nodes:
+                        F.add_edge(best_node, neighbor, weight=G[best_node][neighbor]['weight'])
+        else:
+
+            # Check if the graph is connected
+            if not nx.is_connected(F):
+                # Find the largest connected component
+                largest_component = max(nx.connected_components(F), key=len)
+                # Create a new graph with only the largest connected component
+                F = F.subgraph(largest_component)
+                # Print the number of unique neurons in the new graph
+                print("The graph is not fully connected. Only the largest connected component is considered.")
+            print("Number of unique neurons in the biggest element:", len(F))
+
+        if biases is not None:
+            theta = sorted_biases[:len(F)]
+
+        F = F.copy()
+
+        if not '2' in mode:
+
+            # Add neurons connected to F from G according to the order in sorted_neurons until num_neurons is reached
+            for neuron_id in sorted_neurons:
+                if len(F.nodes) >= num_neuron:
+                    break
+                if neuron_id not in F.nodes:
+                    for neighbor in G.neighbors(neuron_id):
+                        if neighbor in F.nodes:
+                            F.add_node(neuron_id)
+                            F.add_edge(neuron_id, neighbor, weight=G[neuron_id][neighbor]['weight'])
+                            if biases is not None:
+                                theta += [biases[neuron_id]]
+                            break
+            print("Number of unique neurons after adding neighbors:", len(F))
+
+    elif 'proportional_selection' in mode:
+
+        # Find the largest connected component
+        if G.is_directed():
+            largest_component = max(nx.weakly_connected_components(G), key=len)
+        else:
+            largest_component = max(nx.connected_components(G), key=len)
+        # Create a new graph with only the largest connected component
+        G = G.subgraph(largest_component)
+
+        # Remove keys from data_dict that are no longer in G
+        data_dict = {k: v for k, v in data_dict.items() if k in G.nodes()}
+
+        if num_neu > len(G.nodes()):
+            print(f"Number of neurons requested is greater than the number of neurons in the graph, setting number of neuron to {G.nodes()}")
+            return None
+
+        class_count = Counter(data_dict.values())
+        D = []
+        nodes_to_keep = set()
+        for key_idx, key in enumerate(class_count.keys()):
+            fraction = class_count[key] / len(data_dict)
+            target_class_ids = [k for k, v in data_dict.items() if v == key]
+
+            edge_counts = {neuron: G.degree(neuron) for neuron in target_class_ids}
+            try:
+                sorted_target_class_ids = sorted(target_class_ids, key=lambda neuron: edge_counts[neuron], reverse=True)
+            except:
+                print(f"Class {key} has no neurons in the graph")
+            num_neuron = num_neu
+            D_temp = G.subgraph(sorted_target_class_ids[:int(np.ceil(fraction*num_neuron))]).copy()
+            D += [D_temp]
+            for node in D_temp.nodes():
+                nodes_to_keep.add(node)
+
+        F = G.subgraph(list(nodes_to_keep)).copy()
+
+        is_conn = nx.is_weakly_connected(F) if F.is_directed() else nx.is_connected(F)
+        if not is_conn:
+            print("Graph not fully connected, quickly connecting the components with synthetic edges")
+            components = list(nx.weakly_connected_components(F) if F.is_directed() else nx.connected_components(F))
+            
+            # Sort components by size descending
+            components.sort(key=len, reverse=True)
+            
+            # Connect all smaller components to the largest one with a random weak edge
+            largest_comp = list(components[0])
+            for i in range(1, len(components)):
+                u = np.random.choice(largest_comp)
+                v = np.random.choice(list(components[i]))
+                # Add a weak directed edge
+                F.add_edge(u, v, weight=0.01)
+
+        print("Pruning components")
+
+        # Check the number of nodes in F
+        while len(F.nodes()) > num_neuron:
+            # Find the least connected node
+            sorted_nodes = sorted(F.nodes, key=lambda node: F.degree(node))
+            for node in sorted_nodes:
+                F_tentative = F.copy()
+                F_tentative.remove_node(node)
+                is_conn_tentative = nx.is_weakly_connected(F_tentative) if F_tentative.is_directed() else nx.is_connected(F_tentative)
+                if is_conn_tentative:
+                    F = F_tentative
+                    break
+                print(f"\rCurrent number of nodes: {len(F.nodes())}", end='', flush=True)
+
+        print("Adding components")
+
+        while len(F.nodes()) < num_neuron:
+            # Find the node in G that is most connected to nodes already in F
+            candidate_nodes = set(G.nodes()) - set(F.nodes())
+            best_node = max(candidate_nodes, key=lambda node: len(set(G.neighbors(node)) & set(F.nodes())))
+            F.add_node(best_node)
+            for neighbor in G.neighbors(best_node):
+                if neighbor in F.nodes:
+                    F.add_edge(best_node, neighbor, weight=G[best_node][neighbor]['weight'])
+
+        node_ids = list(F.nodes())
+        
+
+        if biases is not None:
+            theta = np.array([biases[nrn] for nrn in node_ids])
+
+
+    else:
+        raise ValueError(f"Invalid selection criterion mode: {mode}")
+    
+    if biases is None:
+        theta = None
+
+    return F, theta
+
+def min_node_connected_subgraph(G, components):
+    """
+    Finds the minimal set of additional nodes needed to connect all given components in G.
+    
+    Parameters:
+        G (networkx.Graph): The input graph.
+        components (list of sets): Each set contains nodes forming a component.
+    
+    Returns:
+        networkx.Graph: The minimal connected subgraph with the fewest extra nodes.
+    """
+    # Step 1: Identify component representative nodes
+    component_representatives = [next(iter(comp)) for comp in components]
+    
+    # Step 2: Build a shortest-path metric graph based on node count
+    metric_graph = nx.Graph()
+    shortest_paths = {}
+
+    undirected_G = G.to_undirected(as_view=True) if G.is_directed() else G
+
+    for u, v in itertools.combinations(component_representatives, 2):
+        try:
+            # First try directed path
+            path = nx.shortest_path(G, source=u, target=v)
+        except nx.NetworkXNoPath:
+            try:
+                # Try the reverse directed path
+                path = nx.shortest_path(G, source=v, target=u)
+            except nx.NetworkXNoPath:
+                # Fallback to undirected path
+                try:
+                    path = nx.shortest_path(undirected_G, source=u, target=v)
+                except nx.NetworkXNoPath:
+                    continue # No path at all
+        metric_graph.add_edge(u, v, weight=len(path) - 1)
+        shortest_paths[(u, v)] = path
+
+    # Step 3: Compute MST on the metric graph to ensure minimal connectivity
+    mst = nx.minimum_spanning_tree(metric_graph, weight="weight")
+
+    # Step 4: Extract corresponding paths from the original graph
+    added_nodes = set()
+    subgraph_edges = set()
+
+    for u, v in mst.edges:
+        path = shortest_paths[(u, v)]
+        for i in range(len(path) - 1):
+            n1 = path[i]
+            n2 = path[i+1]
+            added_nodes.update([n1, n2])
+            if G.has_edge(n1, n2):
+                subgraph_edges.add((n1, n2))
+            elif G.has_edge(n2, n1):
+                subgraph_edges.add((n2, n1))
+
+    # Step 5: Construct the minimal connected subgraph
+    H = G.edge_subgraph(subgraph_edges).copy()
+    
+    return H
+
+
+
+def create_csr_matrix(size, target_sparsity, data_rvs):
+    density = 1 - target_sparsity
+    num_nonzero_elements = int(size * size * density)
+    
+    # Generate random row and column indices for the non-zero elements
+    row_indices = np.random.randint(0, size, num_nonzero_elements)
+    col_indices = np.random.randint(0, size, num_nonzero_elements)
+    
+    # Generate random values using the provided data_rvs function
+    data = data_rvs(num_nonzero_elements)
+    
+    # Create the CSR matrix
+    csr_matrix = scipy.sparse.csr_matrix((data, (row_indices, col_indices)), shape=(size, size))
+    
+    return csr_matrix
+
+
+def is_fully_connected(W):
+    # Convert the sparse matrix to a NetworkX graph
+    graph = nx.from_scipy_sparse_array(W, create_using=nx.DiGraph if scipy.sparse.isspmatrix_csr(W) else nx.Graph)
+    
+    # Check if the graph is strongly connected (for directed graphs) or connected (for undirected graphs)
+    if isinstance(graph, nx.DiGraph):
+        return nx.is_strongly_connected(graph)
+    else:
+        return nx.is_connected(graph)