bmtool 0.7.5__tar.gz → 0.7.6__tar.gz

{bmtool-0.7.5 → bmtool-0.7.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bmtool
-Version: 0.7.5
+Version: 0.7.6
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 

{bmtool-0.7.5 → bmtool-0.7.6}/bmtool/bmplot/connections.py

@@ -661,7 +661,8 @@ def connection_histogram(
                 (edges[source_id_type] == source_id) & (edges[target_id_type] == target_id)
             ]
             if not include_gap:
-                temp = temp[~temp["is_gap_junction"]]
+                gap_col = temp["is_gap_junction"].fillna(False).astype(bool)
+                temp = temp[~gap_col]
             node_pairs = temp.groupby("target_node_id")["source_node_id"].count()
             try:
                 conn_mean = statistics.mean(node_pairs.values)
@@ -1022,8 +1023,8 @@ def plot_synapse_location(config: str, source: str, target: str, sids: str, tids
         )
 
     # Fix the validation logic - it was using 'or' instead of 'and'
-    if syn_feature not in ["afferent_section_id", "afferent_section_pos"]:
-        raise ValueError("Currently only syn features supported are afferent_section_id or afferent_section_pos")
+    #if syn_feature not in ["afferent_section_id", "afferent_section_pos"]:
+    #    raise ValueError("Currently only syn features supported are afferent_section_id or afferent_section_pos")
 
     try:
         # Load mechanisms and template

{bmtool-0.7.5 → bmtool-0.7.6}/bmtool/singlecell.py

@@ -10,6 +10,8 @@ import pandas as pd
 from neuron import h
 from scipy.optimize import curve_fit
 
+from bmtool.util.util import load_templates_from_config, load_config
+
 
 def load_biophys1():
     """
@@ -1025,19 +1027,62 @@ class ZAP(CurrentClamp):
 
 
 class Profiler:
-    """All in one single cell profiler"""
+    """All in one single cell profiler
+
+    This Profiler now supports being initialized with either explicit
+    `template_dir` and `mechanism_dir` paths or with a BMTK `config` file
+    (which should contain `components.templates_dir` and
+    `components.mechanisms_dir`). When `config` is provided it will be used
+    to load mechanisms and templates via the utility helpers.
+    """
 
-    def __init__(self, template_dir: str = None, mechanism_dir: str = None, dt=None):
+    def __init__(self, template_dir: str = None, mechanism_dir: str = None, dt=None, config: str = None):
+        # initialize to None and then prefer config-derived paths if provided
         self.template_dir = None
         self.mechanism_dir = None
 
-        if not self.template_dir:
-            self.template_dir = template_dir
-        if not self.mechanism_dir:
-            self.mechanism_dir = mechanism_dir
-        self.templates = None
+        # If a BMTK config is provided, load mechanisms/templates from it
+        if config is not None:
+            try:
+                # load and apply the config values for directories
+                conf = load_config(config)
+                # conf behaves like a dict returned by bmtk Config.from_json
+                try:
+                    comps = conf["components"]
+                except Exception:
+                    comps = getattr(conf, "components", None)
+
+                if comps is not None:
+                    # support dict-like and object-like components
+                    try:
+                        self.template_dir = comps.get("templates_dir")
+                    except Exception:
+                        self.template_dir = getattr(comps, "templates_dir", None)
+                    try:
+                        self.mechanism_dir = comps.get("mechanisms_dir")
+                    except Exception:
+                        self.mechanism_dir = getattr(comps, "mechanisms_dir", None)
+
+                # actually load mechanisms and templates using the helper
+                load_templates_from_config(config)
+            except Exception:
+                # fall back to explicit dirs if config parsing/loading fails
+                pass
+
+        else:
+            # fall back to explicit args if not set by config
+            if not self.template_dir:
+                self.template_dir = template_dir
+            if not self.mechanism_dir:
+                self.mechanism_dir = mechanism_dir
+
+            # template_dir is required for loading templates later
+            if self.template_dir is None:
+                raise ValueError("Profiler requires either 'template_dir' or a 'config' containing components.templates_dir")
+
+            self.templates = None
 
-        self.load_templates()
+            self.load_templates()
 
         h.load_file("stdrun.hoc")
         if dt is not None:

{bmtool-0.7.5 → bmtool-0.7.6}/bmtool/synapses.py

@@ -8,6 +8,7 @@ import ipywidgets as widgets
 import matplotlib.pyplot as plt
 import neuron
 import numpy as np
+import pandas as pd
 from IPython.display import clear_output, display
 from ipywidgets import HBox, VBox
 from neuron import h
@@ -18,10 +19,10 @@ from scipy.optimize import curve_fit, minimize, minimize_scalar
 from scipy.signal import find_peaks
 from tqdm.notebook import tqdm
 
-from bmtool.util.util import load_templates_from_config
+from bmtool.util.util import load_templates_from_config, load_nodes_from_config, load_edges_from_config, load_config
 
 DEFAULT_GENERAL_SETTINGS = {
-    "vclamp": True,
+    "vclamp": False,
     "rise_interval": (0.1, 0.9),
     "tstart": 500.0,
     "tdur": 100.0,
@@ -43,17 +44,18 @@ DEFAULT_GAP_JUNCTION_GENERAL_SETTINGS = {
 class SynapseTuner:
     def __init__(
         self,
+        conn_type_settings: Optional[Dict[str, dict]] = None,
+        connection: Optional[str] = None,
+        current_name: str = "i",
         mechanisms_dir: Optional[str] = None,
         templates_dir: Optional[str] = None,
         config: Optional[str] = None,
-        conn_type_settings: Optional[dict] = None,
-        connection: Optional[str] = None,
         general_settings: Optional[dict] = None,
         json_folder_path: Optional[str] = None,
-        current_name: str = "i",
-        other_vars_to_record: Optional[list] = None,
-        slider_vars: Optional[list] = None,
+        other_vars_to_record: Optional[List[str]] = None,
+        slider_vars: Optional[List[str]] = None,
         hoc_cell: Optional[object] = None,
+        network: Optional[str] = None,
     ) -> None:
         """
         Initialize the SynapseTuner class with connection type settings, mechanisms, and template directories.
@@ -80,8 +82,28 @@ class SynapseTuner:
             List of synaptic variables you would like sliders set up for the STP sliders method by default will use all parameters in spec_syn_param.
         hoc_cell : Optional[object]
             An already loaded NEURON cell object. If provided, template loading and cell setup will be skipped.
+        network : Optional[str]
+            Name of the specific network dataset to access from the loaded edges data (e.g., 'network_to_network').
+            If not provided, will use all available networks. When a config file is provided, this enables
+            the network dropdown feature in InteractiveTuner for switching between different networks.
+
+        Network Dropdown Feature:
+        -------------------------
+        When initialized with a BMTK config file, the tuner automatically:
+        1. Loads all available network datasets from the config
+        2. Creates a network dropdown in InteractiveTuner (if multiple networks exist)
+        3. Allows dynamic switching between networks, which rebuilds connection types
+        4. Updates connection dropdown options when network is changed
+        5. Preserves current connection if it exists in the new network, otherwise selects the first available
         """
         self.hoc_cell = hoc_cell
+        # Store config and network information for network dropdown functionality
+        self.config = config  # Store config path for network dropdown functionality
+        self.available_networks = []  # Store available networks from config file
+        self.current_network = network  # Store current network selection
+        # Cache for loaded dynamics params JSON by filename to avoid repeated disk reads
+        self._syn_params_cache = {}
+        h.load_file('stdrun.hoc')
 
         if hoc_cell is None:
             if config is None and (mechanisms_dir is None or templates_dir is None):
@@ -95,11 +117,37 @@ class SynapseTuner:
             else:
                 # loads both mech and templates
                 load_templates_from_config(config)
+                # Load available networks from config for network dropdown feature
+                self._load_available_networks()
+                # Prebuild connection type settings for each available network to
+                # make network switching in the UI fast. This will make __init__ slower
+                # but dramatically speed up response when changing the network dropdown.
+                self._prebuilt_conn_type_settings = {}
+                try:
+                    for net in self.available_networks:
+                        self._prebuilt_conn_type_settings[net] = self._build_conn_type_settings_from_config(config, network=net)
+                except Exception as e:
+                    print(f"Warning: error prebuilding conn_type_settings for networks: {e}")
 
         if conn_type_settings is None:
-            raise ValueError("conn_type_settings must be provided.")
+            if config is not None:
+                print("Building conn_type_settings from BMTK config files...")
+                # If we prebuilt per-network settings, use the one for the requested network
+                if hasattr(self, '_prebuilt_conn_type_settings') and network in getattr(self, '_prebuilt_conn_type_settings', {}):
+                    conn_type_settings = self._prebuilt_conn_type_settings[network]
+                else:
+                    conn_type_settings = self._build_conn_type_settings_from_config(config, network=network)
+                print(f"Found {len(conn_type_settings)} connection types: {list(conn_type_settings.keys())}")
+                
+                # If connection is not specified, use the first available connection
+                if connection is None and conn_type_settings:
+                    connection = list(conn_type_settings.keys())[0]
+                    print(f"No connection specified, using first available: {connection}")
+            else:
+                raise ValueError("conn_type_settings must be provided if config is not specified.")
+                
         if connection is None:
-            raise ValueError("connection must be provided.")
+            raise ValueError("connection must be provided or inferable from conn_type_settings.")
         if connection not in conn_type_settings:
             raise ValueError(f"connection '{connection}' not found in conn_type_settings.")
 
@@ -182,6 +230,358 @@ class SynapseTuner:
 
         self._set_up_recorders()
 
+    def _build_conn_type_settings_from_config(self, config_path: str, node_set: Optional[str] = None, network: Optional[str] = None) -> Dict[str, dict]:
+        """
+        Build conn_type_settings from BMTK simulation and circuit config files using the method used by relation matrix function in util.
+        
+        Parameters:
+        -----------
+        config_path : str
+            Path to the simulation config JSON file.
+        node_set : Optional[str]
+            Specific node set to filter connections for. If None, processes all connections.
+        network : Optional[str]
+            Name of the specific network dataset to access (e.g., 'network_to_network').
+            If None, processes all available networks.
+            
+        Returns:
+        --------
+        Dict[str, dict]
+            Dictionary with connection names as keys and connection settings as values.
+
+        NOTE: a lot of this code could probs be made a bit more simple or just removed i kinda tried a bunch of things and it works now
+        but is kinda complex and some code is probs note needed 
+            
+        """
+        # Load configuration and get nodes and edges using util.py methods
+        config = load_config(config_path)
+        # Ensure the config dict knows its source path so path substitutions can be resolved
+        try:
+            # load_config may return a dict; store path used so callers can resolve $COMPONENTS_DIR
+            config['config_path'] = config_path
+        except Exception:
+            pass
+        nodes = load_nodes_from_config(config_path)
+        edges = load_edges_from_config(config_path)
+        
+        conn_type_settings = {}
+        
+        # If a specific network is requested, only process that one
+        if network:
+            if network not in edges:
+                print(f"Warning: Network '{network}' not found in edges. Available networks: {list(edges.keys())}")
+                return conn_type_settings
+            edge_datasets = {network: edges[network]}
+        else:
+            edge_datasets = edges
+        
+        # Process each edge dataset using the util.py approach
+        for edge_dataset_name, edge_df in edge_datasets.items():
+            if edge_df.empty:
+                continue
+            
+            # Create merged DataFrames with source and target node information like util.py does
+            source_node_df = None
+            target_node_df = None
+
+            # First, try to deterministically parse the edge_dataset_name for patterns like '<src>_to_<tgt>'
+            # e.g., 'network_to_network', 'extnet_to_network'
+            if '_to_' in edge_dataset_name:
+                parts = edge_dataset_name.split('_to_')
+                if len(parts) == 2:
+                    src_name, tgt_name = parts
+                    if src_name in nodes:
+                        source_node_df = nodes[src_name].add_prefix('source_')
+                    if tgt_name in nodes:
+                        target_node_df = nodes[tgt_name].add_prefix('target_')
+
+            # If not found by parsing name, fall back to inspecting a sample edge row which contains
+            # explicit 'source_population' and 'target_population' fields (this avoids reversing source/target)
+            if source_node_df is None or target_node_df is None:
+                sample_edge = edge_df.iloc[0] if len(edge_df) > 0 else None
+                if sample_edge is not None:
+                    # Use explicit population names from the edge entry
+                    source_pop_name = sample_edge.get('source_population', '')
+                    target_pop_name = sample_edge.get('target_population', '')
+                    if source_pop_name in nodes:
+                        source_node_df = nodes[source_pop_name].add_prefix('source_')
+                    if target_pop_name in nodes:
+                        target_node_df = nodes[target_pop_name].add_prefix('target_')
+
+            # As a last resort, attempt to heuristically match by prefix/suffix of the dataset name
+            if source_node_df is None or target_node_df is None:
+                for pop_name, node_df in nodes.items():
+                    if source_node_df is None and (edge_dataset_name.startswith(pop_name) or edge_dataset_name.endswith(pop_name)):
+                        source_node_df = node_df.add_prefix('source_')
+                    elif target_node_df is None and (edge_dataset_name.startswith(pop_name) or edge_dataset_name.endswith(pop_name)):
+                        target_node_df = node_df.add_prefix('target_')
+            
+            # If we still don't have the node data, skip this edge dataset
+            if source_node_df is None or target_node_df is None:
+                print(f"Warning: Could not find node data for edge dataset {edge_dataset_name}")
+                continue
+            
+            # Merge edge data with source node info
+            edges_with_source = pd.merge(
+                edge_df.reset_index(), 
+                source_node_df, 
+                how='left', 
+                left_on='source_node_id', 
+                right_index=True
+            )
+            
+            # Merge with target node info
+            edges_with_nodes = pd.merge(
+                edges_with_source, 
+                target_node_df, 
+                how='left', 
+                left_on='target_node_id', 
+                right_index=True
+            )
+            
+            # Get unique edge types from the merged dataset
+            if 'edge_type_id' in edges_with_nodes.columns:
+                edge_types = edges_with_nodes['edge_type_id'].unique()
+            else:
+                edge_types = [0]  # Single edge type
+            
+            # Process each edge type
+            for edge_type_id in edge_types:
+                # Filter edges for this type
+                if 'edge_type_id' in edges_with_nodes.columns:
+                    edge_type_data = edges_with_nodes[edges_with_nodes['edge_type_id'] == edge_type_id]
+                else:
+                    edge_type_data = edges_with_nodes
+                
+                if len(edge_type_data) == 0:
+                    continue
+                
+                # Get representative edge for this type
+                edge_info = edge_type_data.iloc[0]
+                
+                # Skip gap junctions
+                if 'is_gap_junction' in edge_info and pd.notna(edge_info['is_gap_junction']) and edge_info['is_gap_junction']:
+                    continue
+                
+                # Get population names from the merged data (this is the key improvement!)
+                source_pop = edge_info.get('source_pop_name', '')
+                target_pop = edge_info.get('target_pop_name', '')
+                
+                # Get target cell template from the merged data
+                target_model_template = edge_info.get('target_model_template', '')
+                if target_model_template.startswith('hoc:'):
+                    target_cell_type = target_model_template.replace('hoc:', '')
+                else:
+                    target_cell_type = target_model_template
+                
+                # Create connection name using the actual population names
+                if source_pop and target_pop:
+                    conn_name = f"{source_pop}2{target_pop}"
+                else:
+                    conn_name = f"{edge_dataset_name}_type_{edge_type_id}"
+                
+                # Get synaptic model template
+                model_template = edge_info.get('model_template', 'exp2syn')
+
+                # Build connection settings early so we can attach metadata like dynamics file name
+                conn_settings = {
+                    'spec_settings': {
+                        'post_cell': target_cell_type,
+                        'vclamp_amp': -70.0,  # Default voltage clamp amplitude
+                        'sec_x': 0.5,  # Default location on section
+                        'sec_id': 0,   # Default to soma
+                        # level_of_detail may be overridden by dynamics params below
+                        'level_of_detail': model_template,
+                    },
+                    'spec_syn_param': {}
+                }
+
+                # Load synaptic parameters from dynamics_params file if available.
+                # NOTE: the edge DataFrame produced by load_edges_from_config/load_sonata_edges_to_dataframe
+                # already contains the 'dynamics_params' column (from the CSV) or the
+                # flattened H5 dynamics_params attributes (prefixed with 'dynamics_params/').
+                # Prefer the direct 'dynamics_params' column value from the merged DataFrame
+                # rather than performing ad-hoc string parsing here.
+                syn_params = {}
+                dynamics_file_name = None
+                # Prefer a top-level 'dynamics_params' column if present
+                if 'dynamics_params' in edge_info and pd.notna(edge_info.get('dynamics_params')):
+                    val = edge_info.get('dynamics_params')
+                    # Some CSV loaders can produce bytes or numpy types; coerce to str
+                    try:
+                        dynamics_file_name = str(val).strip()
+                    except Exception:
+                        dynamics_file_name = None
+
+                # If we found a dynamics file name, use it directly (skip token parsing)
+                if dynamics_file_name and dynamics_file_name.upper() != 'NULL':
+                    try:
+                        conn_settings['spec_settings']['dynamics_params_file'] = dynamics_file_name
+                        # use a cache to avoid re-reading the same JSON multiple times
+                        if dynamics_file_name in self._syn_params_cache:
+                            syn_params = self._syn_params_cache[dynamics_file_name]
+                        else:
+                            syn_params = self._load_synaptic_params_from_config(config, dynamics_file_name)
+                            # cache result (even if empty dict) to avoid repeated lookups
+                            self._syn_params_cache[dynamics_file_name] = syn_params
+                    except Exception as e:
+                        print(f"Warning: could not load dynamics_params file '{dynamics_file_name}' for edge {edge_dataset_name}: {e}")
+
+                # If a dynamics params JSON filename was provided, prefer using its basename
+                # as the connection name so that the UI matches the JSON definitions.
+                if dynamics_file_name:
+                    try:
+                        json_base = os.path.splitext(os.path.basename(dynamics_file_name))[0]
+                        # Ensure uniqueness in conn_type_settings
+                        if json_base in conn_type_settings:
+                            # Append edge_type_id to disambiguate
+                            json_base = f"{json_base}_type_{edge_type_id}"
+                        conn_name = json_base
+                    except Exception:
+                        pass
+
+                # If the dynamics params defined a level_of_detail, override the default
+                if isinstance(syn_params, dict) and 'level_of_detail' in syn_params:
+                    conn_settings['spec_settings']['level_of_detail'] = syn_params.get('level_of_detail', model_template)
+
+                # Add synaptic parameters, excluding level_of_detail
+                for key, value in syn_params.items():
+                    if key != 'level_of_detail':
+                        conn_settings['spec_syn_param'][key] = value
+                else:
+                    # Fallback: some SONATA/H5 edge files expose dynamics params as flattened
+                    # columns named like 'dynamics_params/<param>'. If no filename was given,
+                    # gather any such columns from edge_info and use them as spec_syn_param.
+                    for col in edge_info.index:
+                        if isinstance(col, str) and col.startswith('dynamics_params/'):
+                            param_key = col.split('/', 1)[1]
+                            try:
+                                val = edge_info[col]
+                                if pd.notna(val):
+                                    conn_settings['spec_syn_param'][param_key] = val
+                            except Exception:
+                                # Ignore malformed entries
+                                pass
+                
+                # Add weight from edge info if available
+                if 'syn_weight' in edge_info and pd.notna(edge_info['syn_weight']):
+                    conn_settings['spec_syn_param']['initW'] = float(edge_info['syn_weight'])
+                
+                # Handle afferent section information
+                if 'afferent_section_id' in edge_info and pd.notna(edge_info['afferent_section_id']):
+                    conn_settings['spec_settings']['sec_id'] = int(edge_info['afferent_section_id'])
+                
+                if 'afferent_section_pos' in edge_info and pd.notna(edge_info['afferent_section_pos']):
+                    conn_settings['spec_settings']['sec_x'] = float(edge_info['afferent_section_pos'])
+                
+                # Store in connection settings
+                conn_type_settings[conn_name] = conn_settings
+
+        return conn_type_settings
+    
+    def _load_available_networks(self) -> None:
+        """
+        Load available network names from the config file for the network dropdown feature.
+        
+        This method is automatically called during initialization when a config file is provided.
+        It populates the available_networks list which enables the network dropdown in 
+        InteractiveTuner when multiple networks are available.
+        
+        Network Dropdown Behavior:
+        -------------------------
+        - If only one network exists: No network dropdown is shown
+        - If multiple networks exist: Network dropdown appears next to connection dropdown
+        - Networks are loaded from the edges data in the config file
+        - Current network defaults to the first available if not specified during init
+        """
+        if self.config is None:
+            self.available_networks = []
+            return
+            
+        try:
+            edges = load_edges_from_config(self.config)
+            self.available_networks = list(edges.keys())
+            
+            # Set current network to first available if not specified
+            if self.current_network is None and self.available_networks:
+                self.current_network = self.available_networks[0]
+        except Exception as e:
+            print(f"Warning: Could not load networks from config: {e}")
+            self.available_networks = []
+    
+    def _load_synaptic_params_from_config(self, config: dict, dynamics_params: str) -> dict:
+        """
+        Load synaptic parameters from dynamics params file using config information.
+        
+        Parameters:
+        -----------
+        config : dict
+            BMTK configuration dictionary
+        dynamics_params : str
+            Dynamics parameters filename
+            
+        Returns:
+        --------
+        dict
+            Synaptic parameters dictionary
+        """
+        try:
+            # Get the synaptic models directory from config
+            synaptic_models_dir = config.get('components', {}).get('synaptic_models_dir', '')
+            if synaptic_models_dir:
+                # Handle path variables
+                if synaptic_models_dir.startswith('$'):
+                    # This is a placeholder, try to resolve it
+                    config_dir = os.path.dirname(config.get('config_path', ''))
+                    synaptic_models_dir = synaptic_models_dir.replace('$COMPONENTS_DIR', 
+                                                                    os.path.join(config_dir, 'components'))
+                    synaptic_models_dir = synaptic_models_dir.replace('$BASE_DIR', config_dir)
+                
+                dynamics_file = os.path.join(synaptic_models_dir, dynamics_params)
+                
+                if os.path.exists(dynamics_file):
+                    with open(dynamics_file, 'r') as f:
+                        return json.load(f)
+                else:
+                    print(f"Warning: Dynamics params file not found: {dynamics_file}")
+        except Exception as e:
+            print(f"Warning: Error loading synaptic parameters: {e}")
+        
+        return {}
+    
+    @classmethod
+    def list_connections_from_config(cls, config_path: str, network: Optional[str] = None) -> Dict[str, dict]:
+        """
+        Class method to list all available connections from a BMTK config file without creating a tuner.
+        
+        Parameters:
+        -----------
+        config_path : str
+            Path to the simulation config JSON file.
+        network : Optional[str]
+            Name of the specific network dataset to access (e.g., 'network_to_network').
+            If None, processes all available networks.
+            
+        Returns:
+        --------
+        Dict[str, dict]
+            Dictionary with connection names as keys and connection info as values.
+        """
+        # Create a temporary instance just to use the parsing methods
+        temp_tuner = cls.__new__(cls)  # Create without calling __init__
+        conn_type_settings = temp_tuner._build_conn_type_settings_from_config(config_path, network=network)
+        
+        # Create a summary of connections with key info
+        connections_summary = {}
+        for conn_name, settings in conn_type_settings.items():
+            connections_summary[conn_name] = {
+                'post_cell': settings['spec_settings']['post_cell'],
+                'synapse_type': settings['spec_settings']['level_of_detail'],
+                'parameters': list(settings['spec_syn_param'].keys())
+            }
+        
+        return connections_summary
+
     def _switch_connection(self, new_connection: str) -> None:
         """
         Switch to a different connection type and update all related properties.
@@ -266,6 +666,61 @@ class SynapseTuner:
         
         print(f"Successfully switched to connection: {new_connection}")
 
+    def _switch_network(self, new_network: str) -> None:
+        """
+        Switch to a different network and rebuild conn_type_settings for the new network.
+        
+        This method is called when the user selects a different network from the network 
+        dropdown in InteractiveTuner. It performs a complete rebuild of the connection 
+        types available for the new network.
+        
+        Parameters:
+        -----------
+        new_network : str
+            Name of the new network to switch to.
+            
+        Network Switching Process:
+        -------------------------
+        1. Validates the new network exists in available_networks
+        2. Rebuilds conn_type_settings using the new network's edge data
+        3. Updates the connection dropdown with new network's available connections
+        4. Preserves current connection if it exists in new network
+        5. Falls back to first available connection if current doesn't exist
+        6. Recreates synapses and NEURON objects for the new connection
+        7. Updates UI components to reflect the changes
+        """
+        if new_network not in self.available_networks:
+            print(f"Warning: Network '{new_network}' not found in available networks: {self.available_networks}")
+            return
+        
+        if new_network == self.current_network:
+            return  # No change needed
+        
+        # Update current network
+        self.current_network = new_network
+        
+        # Switch conn_type_settings using prebuilt data if available, otherwise build on-demand
+        if self.config:
+            print(f"Switching connections for network: {new_network}")
+            if hasattr(self, '_prebuilt_conn_type_settings') and new_network in self._prebuilt_conn_type_settings:
+                self.conn_type_settings = self._prebuilt_conn_type_settings[new_network]
+            else:
+                # Fallback: build on-demand (slower)
+                self.conn_type_settings = self._build_conn_type_settings_from_config(self.config, network=new_network)
+            
+            # Update available connections and select first one if current doesn't exist
+            available_connections = list(self.conn_type_settings.keys())
+            if self.current_connection not in available_connections and available_connections:
+                self.current_connection = available_connections[0]
+                print(f"Connection '{self.current_connection}' not available in new network. Switched to: {available_connections[0]}")
+            
+            # Switch to the (potentially new) connection
+            if self.current_connection in self.conn_type_settings:
+                self._switch_connection(self.current_connection)
+            
+            print(f"Successfully switched to network: {new_network}")
+            print(f"Available connections: {available_connections}")
+
     def _update_spec_syn_param(self, json_folder_path: str) -> None:
         """
         Update specific synaptic parameters using JSON files located in the specified folder.
@@ -305,11 +760,14 @@ class SynapseTuner:
         - `_set_up_cell()` should be called before setting up the synapse.
         - Synapse location, type, and properties are specified within `spec_syn_param` and `spec_settings`.
         """
-        self.syn = getattr(h, self.conn["spec_settings"]["level_of_detail"])(
-            list(self.cell.all)[self.conn["spec_settings"]["sec_id"]](
-                self.conn["spec_settings"]["sec_x"]
+        try:
+            self.syn = getattr(h, self.conn["spec_settings"]["level_of_detail"])(
+                list(self.cell.all)[self.conn["spec_settings"]["sec_id"]](
+                    self.conn["spec_settings"]["sec_x"]
+                )
             )
-        )
+        except:
+            raise Exception("Make sure the mod file exist you are trying to load check spelling!")
         for key, value in self.conn["spec_syn_param"].items():
             if isinstance(value, (int, float)):
                 if hasattr(self.syn, key):
@@ -717,7 +1175,9 @@ class SynapseTuner:
         amp = np.array(amp)
         amp = amp * 1000  # scale up
         amp = amp.reshape(-1, amp.shape[-1])
-        maxamp = amp.max(axis=1 if normalize_by_trial else None)
+        
+        # Calculate 90th percentile amplitude for normalization
+        percentile_90 = np.percentile(amp, 90)
 
         def format_array(arr):
             """Format an array to 2 significant figures for cleaner output."""
@@ -729,49 +1189,42 @@ class SynapseTuner:
                 f"Short Term Plasticity Results for {self.train_freq}Hz with {self.train_delay} Delay"
             )
             print("=" * 40)
-            print("PPR: Above 1 is facilitating, below 1 is depressing.")
+            print("PPR: Above 0 is facilitating, below 0 is depressing.")
             print("Induction: Above 0 is facilitating, below 0 is depressing.")
             print("Recovery: A measure of how fast STP decays.\n")
 
-            # PPR Calculation
-            ppr = amp[:, 1:2] / amp[:, 0:1]
+            # PPR Calculation: (Avg 2nd pulse - Avg 1st pulse) / 90th percentile amplitude
+            ppr = (np.mean(amp[:, 1:2]) - np.mean(amp[:, 0:1])) / percentile_90
             print("Paired Pulse Response (PPR)")
-            print("Calculation: 2nd pulse / 1st pulse")
+            print("Calculation: (Avg 2nd pulse - Avg 1st pulse) / 90th percentile amplitude")
             print(
-                f"Values: ({format_array(amp[:, 1:2])}) / ({format_array(amp[:, 0:1])}) = {format_array(ppr)}\n"
+                f"Values: ({np.mean(amp[:, 1:2]):.3f} - {np.mean(amp[:, 0:1]):.3f}) / {percentile_90:.3f} = {ppr:.3f}\n"
             )
 
-            # Induction Calculation
-            induction = np.mean((amp[:, 5:8].mean(axis=1) - amp[:, :1].mean(axis=1)) / maxamp)
+            # Induction Calculation: (Avg (6th, 7th, 8th pulses) - Avg 1st pulse) / 90th percentile amplitude
+            induction = (np.mean(amp[:, 5:8]) - np.mean(amp[:, :1])) / percentile_90
             print("Induction")
-            print("Calculation: (avg(6th, 7th, 8th pulses) - 1st pulse) / max amps")
+            print("Calculation: (Avg(6th, 7th, 8th pulses) - Avg 1st pulse) / 90th percentile amplitude")
             print(
-                f"Values: avg({format_array(amp[:, 5:8])}) - {format_array(amp[:, :1])} / {format_array(maxamp)}"
-            )
-            print(
-                f"({format_array(amp[:, 5:8].mean(axis=1))}) - ({format_array(amp[:, :1].mean(axis=1))}) / {format_array(maxamp)} = {induction:.3f}\n"
+                f"Values: {np.mean(amp[:, 5:8]):.3f} - {np.mean(amp[:, :1]):.3f} / {percentile_90:.3f} = {induction:.3f}\n"
             )
 
-            # Recovery Calculation
-            recovery = np.mean((amp[:, 8:12].mean(axis=1) - amp[:, :4].mean(axis=1)) / maxamp)
+            # Recovery Calculation: (Avg (9th, 10th, 11th, 12th pulses) - Avg (1st, 2nd, 3rd, 4th pulses)) / 90th percentile amplitude
+            recovery = (np.mean(amp[:, 8:12]) - np.mean(amp[:, :4])) / percentile_90
             print("Recovery")
             print(
-                "Calculation: (avg(9th, 10th, 11th, 12th pulses) - avg(1st to 4th pulses)) / max amps"
-            )
-            print(
-                f"Values: avg({format_array(amp[:, 8:12])}) - avg({format_array(amp[:, :4])}) / {format_array(maxamp)}"
+                "Calculation: (Avg(9th, 10th, 11th, 12th pulses) - Avg(1st to 4th pulses)) / 90th percentile amplitude"
             )
             print(
-                f"({format_array(amp[:, 8:12].mean(axis=1))}) - ({format_array(amp[:, :4].mean(axis=1))}) / {format_array(maxamp)} = {recovery:.3f}\n"
+                f"Values: {np.mean(amp[:, 8:12]):.3f} - {np.mean(amp[:, :4]):.3f} / {percentile_90:.3f} = {recovery:.3f}\n"
             )
 
             print("=" * 40 + "\n")
 
-        recovery = np.mean((amp[:, 8:12].mean(axis=1) - amp[:, :4].mean(axis=1)) / maxamp)
-        induction = np.mean((amp[:, 5:8].mean(axis=1) - amp[:, :1].mean(axis=1)) / maxamp)
-        ppr = amp[:, 1:2] / amp[:, 0:1]
-        # maxamp = max(amp, key=lambda x: abs(x[0]))
-        maxamp = maxamp.max()
+        # Calculate final metrics
+        ppr = (np.mean(amp[:, 1:2]) - np.mean(amp[:, 0:1])) / percentile_90
+        induction = (np.mean(amp[:, 5:8]) - np.mean(amp[:, :1])) / percentile_90
+        recovery = (np.mean(amp[:, 8:12]) - np.mean(amp[:, :4])) / percentile_90
 
         return ppr, induction, recovery
 
@@ -833,6 +1286,7 @@ class SynapseTuner:
         Sets up interactive sliders for tuning short-term plasticity (STP) parameters in a Jupyter Notebook.
 
         This method creates an interactive UI with sliders for:
+        - Network selection dropdown (if multiple networks available and config provided)
         - Connection type selection dropdown
         - Input frequency
         - Delay between pulse trains
@@ -845,10 +1299,21 @@ class SynapseTuner:
         - Toggling voltage clamp mode
         - Switching between standard and continuous input modes
 
+        Network Dropdown Feature:
+        ------------------------
+        When the SynapseTuner is initialized with a BMTK config file containing multiple networks:
+        - A network dropdown appears next to the connection dropdown
+        - Users can dynamically switch between networks (e.g., 'network_to_network', 'external_to_network')
+        - Switching networks rebuilds available connections and updates the connection dropdown
+        - The current connection is preserved if it exists in the new network
+        - If multiple networks exist but only one is specified during init, that network is used as default
+
         Notes:
         ------
         Ideal for exploratory parameter tuning and interactive visualization of
         synapse behavior with different parameter values and stimulation protocols.
+        The network dropdown feature enables comprehensive exploration of multi-network
+        BMTK simulations without needing to reinitialize the tuner.
         """
         # Widgets setup (Sliders)
         freqs = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 35, 50, 100, 200]
@@ -868,6 +1333,17 @@ class SynapseTuner:
             style={'description_width': 'initial'}
         )
 
+        # Network dropdown - only shown if config was provided and multiple networks are available
+        # This enables users to switch between different network datasets dynamically
+        w_network = None
+        if self.config is not None and len(self.available_networks) > 1:
+            w_network = widgets.Dropdown(
+                options=self.available_networks,
+                value=self.current_network,
+                description="Network:",
+                style={'description_width': 'initial'}
+            )
+
         w_run = widgets.Button(description="Run Train", icon="history", button_style="primary")
         w_single = widgets.Button(description="Single Event", icon="check", button_style="success")
         w_vclamp = widgets.ToggleButton(
@@ -876,6 +1352,17 @@ class SynapseTuner:
             icon="fast-backward",
             button_style="warning",
         )
+        
+        # Voltage clamp amplitude input
+        default_vclamp_amp = getattr(self.conn['spec_settings'], 'vclamp_amp', -70.0)
+        w_vclamp_amp = widgets.FloatText(
+            value=default_vclamp_amp,
+            description="V_clamp (mV):",
+            step=5.0,
+            style={'description_width': 'initial'},
+            layout=widgets.Layout(width='150px')
+        )
+        
         w_input_mode = widgets.ToggleButton(
             value=False, description="Continuous input", icon="eject", button_style="info"
         )
@@ -915,13 +1402,29 @@ class SynapseTuner:
             "Setting up slider! The sliders ranges are set by their init value so try changing that if you dont like the slider range!"
         )
 
+        # Create output widget for displaying results
+        output_widget = widgets.Output()
+        
         def run_single_event(*args):
             clear_output()
             display(ui)
+            display(output_widget)
+            
             self.vclamp = w_vclamp.value
+            # Update voltage clamp amplitude if voltage clamp is enabled
+            if self.vclamp:
+                # Update the voltage clamp amplitude settings
+                self.conn['spec_settings']['vclamp_amp'] = w_vclamp_amp.value
+                # Update general settings if they exist
+                if hasattr(self, 'general_settings'):
+                    self.general_settings['vclamp_amp'] = w_vclamp_amp.value
             # Update synaptic properties based on slider values
             self.ispk = None
-            self.SingleEvent()
+            
+            # Clear previous results and run simulation
+            output_widget.clear_output()
+            with output_widget:
+                self.SingleEvent()
 
         def on_connection_change(*args):
             """Handle connection dropdown change"""
@@ -941,8 +1444,50 @@ class SynapseTuner:
             except Exception as e:
                 print(f"Error switching connection: {e}")
 
+        def on_network_change(*args):
+            """
+            Handle network dropdown change events.
+            
+            This callback is triggered when the user selects a different network from 
+            the network dropdown. It coordinates the complete switching process:
+            1. Calls _switch_network() to rebuild connections for the new network
+            2. Updates the connection dropdown options with new network's connections
+            3. Recreates dynamic sliders for the new connection parameters
+            4. Refreshes the entire UI to reflect all changes
+            """
+            if w_network is None:
+                return
+            try:
+                new_network = w_network.value
+                if new_network != self.current_network:
+                    # Switch to new network
+                    self._switch_network(new_network)
+                    
+                    # Update connection dropdown options with new network's connections
+                    connection_options = list(self.conn_type_settings.keys())
+                    w_connection.options = connection_options
+                    if connection_options:
+                        w_connection.value = self.current_connection
+                    
+                    # Recreate dynamic sliders for new connection
+                    self.dynamic_sliders = create_dynamic_sliders()
+                    
+                    # Update UI
+                    update_ui_layout()
+                    update_ui()
+                    
+            except Exception as e:
+                print(f"Error switching network: {e}")
+
         def update_ui_layout():
-            """Update the UI layout with new sliders"""
+            """
+            Update the UI layout with new sliders and network dropdown.
+            
+            This function reconstructs the entire UI layout including:
+            - Network dropdown (if available) and connection dropdown in the top row
+            - Button controls and input mode toggles
+            - Parameter sliders arranged in columns
+            """
             nonlocal ui, slider_columns
             
             # Add the dynamic sliders to the UI
@@ -956,9 +1501,18 @@ class SynapseTuner:
             else:
                 slider_columns = VBox([])
             
-            # Reconstruct the UI
-            connection_row = HBox([w_connection])
-            button_row = HBox([w_run, w_single, w_vclamp, w_input_mode])
+            # Create button row with voltage clamp controls
+            if w_vclamp.value:  # Show voltage clamp amplitude input when toggle is on
+                button_row = HBox([w_run, w_single, w_vclamp, w_vclamp_amp, w_input_mode])
+            else:  # Hide voltage clamp amplitude input when toggle is off
+                button_row = HBox([w_run, w_single, w_vclamp, w_input_mode])
+            
+            # Construct the top row - include network dropdown if available
+            # This creates a horizontal layout with network dropdown (if present) and connection dropdown
+            if w_network is not None:
+                connection_row = HBox([w_network, w_connection])
+            else:
+                connection_row = HBox([w_connection])
             slider_row = HBox([w_input_freq, self.w_delay, self.w_duration])
             
             ui = VBox([connection_row, button_row, slider_row, slider_columns])
@@ -967,19 +1521,31 @@ class SynapseTuner:
         def update_ui(*args):
             clear_output()
             display(ui)
+            display(output_widget)
+            
             self.vclamp = w_vclamp.value
+            # Update voltage clamp amplitude if voltage clamp is enabled
+            if self.vclamp:
+                self.conn['spec_settings']['vclamp_amp'] = w_vclamp_amp.value
+                if hasattr(self, 'general_settings'):
+                    self.general_settings['vclamp_amp'] = w_vclamp_amp.value
+            
             self.input_mode = w_input_mode.value
             syn_props = {var: slider.value for var, slider in self.dynamic_sliders.items()}
             self._set_syn_prop(**syn_props)
-            if not self.input_mode:
-                self._simulate_model(w_input_freq.value, self.w_delay.value, w_vclamp.value)
-            else:
-                self._simulate_model(w_input_freq.value, self.w_duration.value, w_vclamp.value)
-            amp = self._response_amplitude()
-            self._plot_model(
-                [self.general_settings["tstart"] - self.nstim.interval / 3, self.tstop]
-            )
-            _ = self._calc_ppr_induction_recovery(amp)
+            
+            # Clear previous results and run simulation
+            output_widget.clear_output()
+            with output_widget:
+                if not self.input_mode:
+                    self._simulate_model(w_input_freq.value, self.w_delay.value, w_vclamp.value)
+                else:
+                    self._simulate_model(w_input_freq.value, self.w_duration.value, w_vclamp.value)
+                amp = self._response_amplitude()
+                self._plot_model(
+                    [self.general_settings["tstart"] - self.nstim.interval / 3, self.tstop]
+                )
+                _ = self._calc_ppr_induction_recovery(amp)
 
         # Function to switch between delay and duration sliders
         def switch_slider(*args):
@@ -990,9 +1556,21 @@ class SynapseTuner:
                 self.w_delay.layout.display = ""  # Show delay slider
                 self.w_duration.layout.display = "none"  # Hide duration slider
 
+        # Function to handle voltage clamp toggle
+        def on_vclamp_toggle(*args):
+            """Handle voltage clamp toggle changes to show/hide amplitude input"""
+            update_ui_layout()
+            clear_output()
+            display(ui)
+            display(output_widget)
+
         # Link widgets to their callback functions
         w_connection.observe(on_connection_change, names="value")
+        # Link network dropdown callback only if network dropdown was created
+        if w_network is not None:
+            w_network.observe(on_network_change, names="value")
         w_input_mode.observe(switch_slider, names="value")
+        w_vclamp.observe(on_vclamp_toggle, names="value")
 
         # Hide the duration slider initially until the user selects it
         self.w_duration.layout.display = "none"  # Hide duration slider

{bmtool-0.7.5 → bmtool-0.7.6}/bmtool/util/util.py

@@ -1,4 +1,5 @@
 import argparse
+from logging import raiseExceptions
 import math
 import os
 import smtplib
@@ -1081,7 +1082,9 @@ def connection_totals(
         total = edges[(edges[source_id_type] == source_id) & (edges[target_id_type] == target_id)]
         if not include_gap:
             try:
-                total = total[~total["is_gap_junction"]]
+                # Handle mixed types and NaN values in is_gap_junction column
+                gap_col = total["is_gap_junction"].fillna(False).astype(bool)
+                total = total[~gap_col]
             except:
                 # If there are no gap junctions, just continue
                 pass
@@ -1129,7 +1132,8 @@ def percent_connections(
         cons = edges[(edges[source_id_type] == source_id) & (edges[target_id_type] == target_id)]
         if not include_gap:
             try:
-                gaps = cons["is_gap_junction"]==True
+                # Handle mixed types and NaN values in is_gap_junction column
+                gaps = cons["is_gap_junction"].fillna(False).astype(bool)
                 cons = cons[~gaps]
             except:
                 raise Exception("no gap junctions found to drop from connections")
@@ -1200,9 +1204,17 @@ def connection_divergence(
         cons = edges[(edges[source_id_type] == source_id) & (edges[target_id_type] == target_id)]
         if not include_gap:
             try:
-                cons = cons[~cons["is_gap_junction"]]
+                # Handle mixed types and NaN values in is_gap_junction column
+                gap_col = cons["is_gap_junction"].fillna(False).astype(bool)
+                cons = cons[~gap_col]
             except:
-                raise Exception("no gap junctions found to drop from connections")
+                raise Exception("error")
+        
+        if cons.empty:
+            if method == "mean+std":
+                return (0, 0)
+            else:
+                return 0
 
         if convergence:
             if method == "min":
@@ -1213,15 +1225,16 @@ def connection_divergence(
                 return round(count, 2)
             elif method == "std":
                 std = cons["target_node_id"].value_counts().std()
-                return round(std, 2)
+                return round(std, 2) if not np.isnan(std) else 0
             elif method == "mean":
                 mean = cons["target_node_id"].value_counts().mean()
-                return round(mean, 2)
+                return round(mean, 2) if not np.isnan(mean) else 0
             elif method == "mean+std":  # default is mean + std
                 mean = cons["target_node_id"].value_counts().mean()
                 std = cons["target_node_id"].value_counts().std()
-                # std = cons.apply(pd.Series.value_counts).target_node_id.dropna().std() no longer a valid way
-                return (round(mean, 2)), (round(std, 2))
+                mean = round(mean, 2) if not np.isnan(mean) else 0
+                std = round(std, 2) if not np.isnan(std) else 0
+                return (mean, std)
         else:  # divergence
             if method == "min":
                 count = cons["source_node_id"].value_counts().min()
@@ -1231,14 +1244,16 @@ def connection_divergence(
                 return round(count, 2)
             elif method == "std":
                 std = cons["source_node_id"].value_counts().std()
-                return round(std, 2)
+                return round(std, 2) if not np.isnan(std) else 0
             elif method == "mean":
                 mean = cons["source_node_id"].value_counts().mean()
-                return round(mean, 2)
+                return round(mean, 2) if not np.isnan(mean) else 0
             elif method == "mean+std":  # default is mean + std
                 mean = cons["source_node_id"].value_counts().mean()
                 std = cons["source_node_id"].value_counts().std()
-                return (round(mean, 2)), (round(std, 2))
+                mean = round(mean, 2) if not np.isnan(mean) else 0
+                std = round(std, 2) if not np.isnan(std) else 0
+                return (mean, std)
 
     return relation_matrix(
         config,
@@ -1442,7 +1457,9 @@ def connection_probabilities(
         ]
         if not include_gap:
             try:
-                relevant_edges = relevant_edges[~relevant_edges["is_gap_junction"]]
+                # Handle mixed types and NaN values in is_gap_junction column
+                gap_col = relevant_edges["is_gap_junction"].fillna(False).astype(bool)
+                relevant_edges = relevant_edges[~gap_col]
             except:
                 raise Exception("no gap junctions found to drop from connections")
         connected_distances = eudist(relevant_edges, dist_X, dist_Y, dist_Z).values.tolist()

{bmtool-0.7.5 → bmtool-0.7.6}/bmtool.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bmtool
-Version: 0.7.5
+Version: 0.7.6
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 

{bmtool-0.7.5 → bmtool-0.7.6}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setup(
     name="bmtool",
-    version="0.7.5",
+    version="0.7.6",
     author="Neural Engineering Laboratory at the University of Missouri",
     author_email="gregglickert@mail.missouri.edu",
     description="BMTool",