bmtool 0.8.1__tar.gz → 0.8.2__tar.gz

{bmtool-0.8.1 → bmtool-0.8.2}/PKG-INFO

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

bmtool-0.8.2/bmtool/analysis/netcon_reports.py

@@ -0,0 +1,228 @@
+import h5py
+import numpy as np
+import xarray as xr
+from typing import Union, List, Dict, Any
+
+from ..util.util import load_nodes_from_config
+
+
+def load_synapse_report(
+    h5_file_path: str,
+    config_path: str,
+    edge_name: str,
+    source_groupby: Union[str, List[str]],
+    target_groupby: Union[str, List[str]],
+) -> xr.Dataset:
+    """
+    Load and process a synapse report from a bmtk simulation into an xarray.
+
+    Parameters:
+    -----------
+    h5_file_path : str
+        Path to the h5 file containing the synapse report
+    config_path : str
+        Path to the simulation configuration file
+    edge_name : str
+        Edge name in format 'source_to_target' (e.g., 'thalamic_tone_to_LA')
+        This determines which source and target networks to load for population mapping
+    source_groupby : str or List[str]
+        Node property column name(s) to use for labeling source synapses.
+        Examples: 'pop_name', ['pop_name', 'model_type']
+    target_groupby : str or List[str]
+        Node property column name(s) to use for labeling target synapses.
+        Examples: 'pop_name', ['pop_name', 'model_type']
+
+    Returns:
+    --------
+    xarray.Dataset
+        An xarray containing the synapse report data with proper population labeling.
+        For each column in source_groupby/target_groupby, separate coordinates are created:
+        'source_{column}', 'target_{column}', etc.
+        A 'connection_label' coordinate is also created with pipe-delimited values
+        (e.g., 'Pyr|biophys->PV|biophys').
+
+    Examples:
+    ---------
+    # Group by single column (default behavior):
+    ds = load_synapse_report(
+        h5_file_path='output/synapse_report.h5',
+        config_path='simulation_config.json',
+        edge_name='LA_to_LA',
+        source_groupby='pop_name',
+        target_groupby='pop_name'
+    )
+
+    # Group by multiple columns:
+    ds = load_synapse_report(
+        h5_file_path='output/synapse_report.h5',
+        config_path='simulation_config.json',
+        edge_name='LA_to_LA',
+        source_groupby=['pop_name', 'model_type'],
+        target_groupby=['pop_name', 'model_type']
+    )
+    # Returns dataset with coordinates:
+    # source_pop_name, source_model_type, target_pop_name, target_model_type, connection_label
+    """
+    # Normalize groupby parameters to lists
+    if isinstance(source_groupby, str):
+        source_groupby = [source_groupby]
+    if isinstance(target_groupby, str):
+        target_groupby = [target_groupby]
+
+    # Parse edge_name to extract source and target networks
+    if "_to_" not in edge_name:
+        raise ValueError(
+            f"Invalid edge_name format: '{edge_name}'. Expected format: 'source_to_target' "
+            "(e.g., 'thalamic_tone_to_LA')"
+        )
+    
+    source_network, target_network = edge_name.split("_to_")
+    
+    # Load the h5 file to get synapse mapping data
+    with h5py.File(h5_file_path, "r") as file:
+        # Get the first (and typically only) network key in the report
+        report_networks = list(file["report"].keys())
+        if not report_networks:
+            raise ValueError(f"No report networks found in {h5_file_path}")
+        
+        # Use the first available network in the h5 file
+        report_network = report_networks[0]
+        report = file["report"][report_network]
+        mapping = report["mapping"]
+
+        # Get the data - shape is (n_timesteps, n_synapses)
+        data = report["data"][:]
+
+        # Get time information
+        time_info = mapping["time"][:]  # [start_time, end_time, dt]
+        start_time = time_info[0]
+        end_time = time_info[1]
+        dt = time_info[2]
+
+        # Create time array
+        n_steps = data.shape[0]
+        time = np.linspace(start_time, start_time + (n_steps - 1) * dt, n_steps)
+
+        # Get mapping information
+        src_ids = mapping["src_ids"][:]
+        trg_ids = mapping["trg_ids"][:]
+        sec_id = mapping["element_ids"][:]
+        sec_x = mapping["element_pos"][:]
+
+    # Load node information for both source and target networks
+    all_nodes = load_nodes_from_config(config_path)
+    
+    # Get the source and target node dataframes
+    if source_network not in all_nodes:
+        raise ValueError(
+            f"Source network '{source_network}' not found in config. "
+            f"Available networks: {list(all_nodes.keys())}"
+        )
+    if target_network not in all_nodes:
+        raise ValueError(
+            f"Target network '{target_network}' not found in config. "
+            f"Available networks: {list(all_nodes.keys())}"
+        )
+    
+    source_nodes = all_nodes[source_network]
+    target_nodes = all_nodes[target_network]
+
+    # Validate that requested groupby columns exist in node dataframes
+    missing_src_cols = [col for col in source_groupby if col not in source_nodes.columns]
+    if missing_src_cols:
+        raise KeyError(
+            f"Columns {missing_src_cols} not found in source network '{source_network}'. "
+            f"Available columns: {list(source_nodes.columns)}"
+        )
+    
+    missing_trg_cols = [col for col in target_groupby if col not in target_nodes.columns]
+    if missing_trg_cols:
+        raise KeyError(
+            f"Columns {missing_trg_cols} not found in target network '{target_network}'. "
+            f"Available columns: {list(target_nodes.columns)}"
+        )
+
+    # Create mappings from node IDs to groupby column values
+    # source_mappings[col] = {node_id: column_value}
+    source_mappings: Dict[str, Dict[int, Any]] = {}
+    for col in source_groupby:
+        source_mappings[col] = dict(zip(source_nodes.index, source_nodes[col]))
+    
+    target_mappings: Dict[str, Dict[int, Any]] = {}
+    for col in target_groupby:
+        target_mappings[col] = dict(zip(target_nodes.index, target_nodes[col]))
+
+    # Determine default values for external inputs (src_id = -1)
+    # Get the most common value or "unknown" if heterogeneous
+    src_external_values = {}
+    for col in source_groupby:
+        unique_vals = source_nodes[col].unique()
+        if len(unique_vals) == 1:
+            src_external_values[col] = unique_vals[0]
+        else:
+            src_external_values[col] = "unknown"
+
+    # Get the number of synapses
+    n_synapses = data.shape[1]
+
+    # Create arrays to hold the groupby values for each synapse
+    # synapse_values[col] = [val_for_synapse_0, val_for_synapse_1, ...]
+    source_values: Dict[str, List[Any]] = {col: [] for col in source_groupby}
+    target_values: Dict[str, List[Any]] = {col: [] for col in target_groupby}
+    connection_labels = []
+
+    # Process each synapse
+    for i in range(n_synapses):
+        src_id = src_ids[i]
+        trg_id = trg_ids[i]
+
+        # Get source groupby values
+        src_label_parts = []
+        for col in source_groupby:
+            if src_id == -1:
+                # External input: use default value for this column
+                val = src_external_values[col]
+            else:
+                val = source_mappings[col].get(src_id, f"unknown_{src_id}")
+            source_values[col].append(val)
+            src_label_parts.append(str(val))
+        
+        # Get target groupby values
+        trg_label_parts = []
+        for col in target_groupby:
+            val = target_mappings[col].get(trg_id, f"unknown_{trg_id}")
+            target_values[col].append(val)
+            trg_label_parts.append(str(val))
+        
+        # Create connection label with pipe-delimited format
+        src_label = "|".join(src_label_parts)
+        trg_label = "|".join(trg_label_parts)
+        connection_labels.append(f"{src_label}->{trg_label}")
+
+    # Create coordinates dictionary dynamically based on groupby columns
+    coords = {
+        "time": time,
+        "synapse": np.arange(n_synapses),
+        "source_id": ("synapse", src_ids),
+        "target_id": ("synapse", trg_ids),
+        "sec_id": ("synapse", sec_id),
+        "sec_x": ("synapse", sec_x),
+        "connection_label": ("synapse", connection_labels),
+    }
+    
+    # Add source groupby coordinates
+    for col in source_groupby:
+        coords[f"source_{col}"] = ("synapse", source_values[col])
+    
+    # Add target groupby coordinates
+    for col in target_groupby:
+        coords[f"target_{col}"] = ("synapse", target_values[col])
+
+    # Create xarray dataset
+    ds = xr.Dataset(
+        data_vars={"synapse_value": (["time", "synapse"], data)},
+        coords=coords,
+        attrs={"description": "Synapse report data from bmtk simulation"},
+    )
+
+    return ds

{bmtool-0.8.1 → bmtool-0.8.2}/bmtool/bmplot/connections.py

@@ -193,7 +193,11 @@ def percent_connection_matrix(
     no_prepend_pop : bool, optional
         If True, population name is not displayed before sid or tid in the plot. Default is False.
     method : str, optional
-        Method for calculating percent connectivity. Options: 'total', 'uni', 'bi'.
+        Method for calculating percent connectivity. Options:
+        - 'total': Pairwise connection probability (connections / (sources * targets) * 100)
+        - 'uni': Unidirectional connection probability
+        - 'bi': Bidirectional connection probability
+        - 'innervation': Percentage of target neurons receiving at least one connection
         Default is 'total'.
     include_gap : bool, optional
         If True, include gap junctions in analysis. If False, only include chemical synapses.
@@ -249,7 +253,16 @@ def percent_connection_matrix(
         include_gap=include_gap,
     )
     if title is None or title == "":
-        title = "Percent Connectivity"
+        if method == "uni":
+            title = "Unidirectional Percent Connectivity"
+        elif method == "bi":
+            title = "Bidirectional Percent Connectivity"
+        elif method == "total":
+            title = "Total Percent Connectivity"
+        elif method == "innervation":
+            title = "Percentage of target neurons receiving at least one connection"
+        else:
+            title = "Percent Connectivity"
 
     if return_dict:
         result_dict = plot_connection_info(

{bmtool-0.8.1 → bmtool-0.8.2}/bmtool/util/util.py

@@ -1240,12 +1240,18 @@ def percent_connections(
             uni = round(num_uni / (num_sources * num_targets) * 100, 2)
             bi = round(num_bi / (num_sources * num_targets) * 100, 2)
         
+        # Calculate innervation percentage (% of target neurons receiving at least one connection)
+        unique_target_nodes = cons['target_node_id'].nunique()
+        innervation = round(unique_target_nodes / num_targets * 100, 2)
+        
         if method == "total":
             return total
         if method == "uni":
             return uni
         if method == "bi":
             return bi
+        if method == "innervation":
+            return innervation
 
     return relation_matrix(
         config, nodes, edges, sources, targets, sids, tids, prepend_pop, relation_func=precent_func

{bmtool-0.8.1 → bmtool-0.8.2}/bmtool.egg-info/PKG-INFO

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

{bmtool-0.8.1 → bmtool-0.8.2}/setup.py

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

bmtool-0.8.1/bmtool/analysis/netcon_reports.py

@@ -1,94 +0,0 @@
-import h5py
-import numpy as np
-import xarray as xr
-
-from ..util.util import load_nodes_from_config
-
-
-def load_synapse_report(h5_file_path, config_path, network):
-    """
-    Load and process a synapse report from a bmtk simulation into an xarray.
-
-    Parameters:
-    -----------
-    h5_file_path : str
-        Path to the h5 file containing the synapse report
-    config_path : str
-        Path to the simulation configuration file
-
-    Returns:
-    --------
-    xarray.Dataset
-        An xarray containing the synapse report data with proper population labeling
-    """
-    # Load the h5 file
-    with h5py.File(h5_file_path, "r") as file:
-        # Get the report data
-        report = file["report"][network]
-        mapping = report["mapping"]
-
-        # Get the data - shape is (n_timesteps, n_synapses)
-        data = report["data"][:]
-
-        # Get time information
-        time_info = mapping["time"][:]  # [start_time, end_time, dt]
-        start_time = time_info[0]
-        end_time = time_info[1]
-        dt = time_info[2]
-
-        # Create time array
-        n_steps = data.shape[0]
-        time = np.linspace(start_time, start_time + (n_steps - 1) * dt, n_steps)
-
-        # Get mapping information
-        src_ids = mapping["src_ids"][:]
-        trg_ids = mapping["trg_ids"][:]
-        sec_id = mapping["element_ids"][:]
-        sec_x = mapping["element_pos"][:]
-
-    # Load node information
-    nodes = load_nodes_from_config(config_path)
-    nodes = nodes[network]
-
-    # Create a mapping from node IDs to population names
-    node_to_pop = dict(zip(nodes.index, nodes["pop_name"]))
-
-    # Get the number of synapses
-    n_synapses = data.shape[1]
-
-    # Create arrays to hold the source and target populations for each synapse
-    source_pops = []
-    target_pops = []
-    connection_labels = []
-
-    # Process each synapse
-    for i in range(n_synapses):
-        src_id = src_ids[i]
-        trg_id = trg_ids[i]
-
-        # Get population names (with fallback for unknown IDs)
-        src_pop = node_to_pop.get(src_id, f"unknown_{src_id}")
-        trg_pop = node_to_pop.get(trg_id, f"unknown_{trg_id}")
-
-        source_pops.append(src_pop)
-        target_pops.append(trg_pop)
-        connection_labels.append(f"{src_pop}->{trg_pop}")
-
-    # Create xarray dataset
-    ds = xr.Dataset(
-        data_vars={"synapse_value": (["time", "synapse"], data)},
-        coords={
-            "time": time,
-            "synapse": np.arange(n_synapses),
-            "source_pop": ("synapse", source_pops),
-            "target_pop": ("synapse", target_pops),
-            "source_id": ("synapse", src_ids),
-            "target_id": ("synapse", trg_ids),
-            "sec_id": ("synapse", sec_id),
-            "sec_x": ("synapse", sec_x),
-            "connection_label": ("synapse", connection_labels),
-        },
-        attrs={"description": "Synapse report data from bmtk simulation"},
-    )
-
-    return ds