bmtool 0.8.0__tar.gz → 0.8.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bmtool
-Version: 0.8.0
+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.0 → 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.0 → bmtool-0.8.2}/bmtool/stimulus/core.py

@@ -140,16 +140,129 @@ class StimulusBuilder:
             raise ValueError(f"Unknown distribution: {distribution}. Must be 'lognormal' or 'normal'.")
         
         return rates
+    
+    def generate_background(self, output_path, network_name, population_params,
+                           groupby='pop_name', t_start=0.0, t_stop=10.0, 
+                           verbose=False, seed=None):
+        """Generate background (spontaneous) activity for network nodes grouped by property.
+        
+        This function generates baseline spiking activity, grouped by a specified node property.
+        Each group can use either a constant firing rate or a distribution-based rate.
+        
+        Args:
+            output_path (str): Path to save the resulting .h5 file.
+            network_name (str): BMTK network name.
+            population_params (dict): Parameters for each population/group.
+                Keys should match values in the node property specified by groupby.
+                Each value is a dict with:
+                    - 'mean_firing_rate' (float): Mean firing rate in Hz (required)
+                    - 'stdev' (float, optional): Standard deviation. If provided, uses lognormal distribution.
+                                                If omitted, uses constant firing rate.
+                Example:
+                    {
+                        'PN': {'mean_firing_rate': 20.0, 'stdev': 2.0},
+                        'PV': {'mean_firing_rate': 30.0},  # constant rate
+                        'SST': {'mean_firing_rate': 15.0, 'stdev': 1.5}
+                    }
+            groupby (str): Node property to group by (default: 'pop_name').
+                          Will match against keys in population_params.
+            t_start, t_stop (float): Time range for activity (seconds).
+            verbose (bool): If True, print detailed information (default: False).
+            seed (int, optional): Random seed for distribution sampling. Overrides instance psg_seed.
+            
+        Examples:
+            # Population-specific rates with mixed distributions
+            params = {
+                'PN': {'mean_firing_rate': 20.0, 'stdev': 2.0},
+                'PV': {'mean_firing_rate': 30.0},  # constant rate
+                'SST': {'mean_firing_rate': 15.0, 'stdev': 1.5}
+            }
+            sb.generate_background(
+                output_path='background.h5',
+                network_name='input',
+                population_params=params,
+                t_start=0.0, t_stop=15.0
+            )
+            
+            # Group by custom property (e.g., layer)
+            layer_params = {
+                'L1': {'mean_firing_rate': 10.0, 'stdev': 1.0},
+                'L2/3': {'mean_firing_rate': 15.0, 'stdev': 2.0}
+            }
+            sb.generate_background(
+                output_path='layer_background.h5',
+                network_name='input',
+                population_params=layer_params,
+                groupby='layer'
+            )
+        """
+        if population_params is None or not isinstance(population_params, dict):
+            raise ValueError("population_params must be a non-empty dict")
+        
+        nodes_df = self.get_nodes(network_name)
+        
+        # Verify groupby column exists
+        if groupby not in nodes_df.columns:
+            raise ValueError(f"Node property '{groupby}' not found in network '{network_name}'")
+        
+        # Use provided seed or default to instance psg_seed
+        psg_seed = seed if seed is not None else self.psg_seed
+        
+        population = network_name  # Default population name in PSG
+        psg = PoissonSpikeGenerator(population=population, seed=psg_seed)
+        
+        times = (t_start, t_stop)
+        total_nodes = 0
+        
+        for group_key, params in population_params.items():
+            # Find nodes matching this group
+            nodes_in_group = nodes_df[nodes_df[groupby] == group_key].index.values
+            
+            if len(nodes_in_group) == 0:
+                if verbose:
+                    print(f"  Warning: No nodes found with {groupby}='{group_key}'")
+                continue
+            
+            total_nodes += len(nodes_in_group)
+            
+            if not isinstance(params, dict) or 'mean_firing_rate' not in params:
+                raise ValueError(f"params['{group_key}'] must be a dict with 'mean_firing_rate' key")
+            
+            mean_rate = params['mean_firing_rate']
+            stdev = params.get('stdev', None)
+            
+            # Determine: constant vs distribution-based
+            if stdev is not None:
+                # Use distribution (lognormal)
+                firing_rates = self._generate_firing_rates(len(nodes_in_group), mean_rate, stdev, 'lognormal')
+                for node_id, rate in zip(nodes_in_group, firing_rates):
+                    psg.add(node_ids=node_id, firing_rate=rate, times=times)
+                if verbose:
+                    print(f"  {group_key}: {len(nodes_in_group)} nodes, {mean_rate:.1f}±{stdev:.1f} Hz (lognormal)")
+            else:
+                # Use constant firing rate
+                psg.add(node_ids=nodes_in_group.tolist(), firing_rate=mean_rate, times=times)
+                if verbose:
+                    print(f"  {group_key}: {len(nodes_in_group)} nodes, {mean_rate:.1f} Hz (constant)")
+        
+        # Write to file
+        os.makedirs(os.path.dirname(output_path), exist_ok=True)
+        psg.to_sonata(output_path)
+        if verbose:
+            print(f"Generated background activity: {total_nodes} nodes to {output_path}")
             
     def generate_stimulus(self, output_path, pattern_type, assembly_name, verbose=False, seed=None, **kwargs):
         """Generate a BMTK Poisson spike file (SONATA) for a specific assembly group.
         
+        Use create_assemblies() first to define your stimulus assemblies, then call this
+        function to generate time-varying firing patterns for those assemblies.
+        
         Args:
             output_path (str): Path to save the resulting .h5 file.
             pattern_type (str): Firing rate template ('short', 'long', 'ramp', etc).
             assembly_name (str): Name of the assembly group created via create_assemblies.
             verbose (bool): If True, print detailed information (default: False).
-            seed (int, optional): Random seed for Poisson spike generation. Overrides instance psg_seed for this call.
+            seed (int, optional): Random seed for Poisson spike generation. Overrides instance psg_seed.
             **kwargs: Arguments passed to the generator function and PoissonSpikeGenerator.
                 - population (str): Name of the spike population (for BMTK).
                 - firing_rate (3-tuple): (off_rate, burst_rate, silent_rate).
@@ -157,9 +270,20 @@ class StimulusBuilder:
                 - off_time (float): Duration of silent period.
                 - t_start (float): Start time of cycles.
                 - t_stop (float): End time of cycles.
+                
+        Example:
+            # First create assemblies
+            sb.create_assemblies(name='stim_groups', network_name='thalamus', 
+                                method='property', property_name='pulse_group_id')
+            
+            # Then generate stimulus
+            sb.generate_stimulus(output_path='stim.h5', pattern_type='long', 
+                                assembly_name='stim_groups', population='thalamus',
+                                firing_rate=(0.0, 50.0, 0.0), t_start=1.0, t_stop=15.0,
+                                on_time=1.0, off_time=0.5)
         """
         if assembly_name not in self.assemblies:
-            raise ValueError(f"Assembly '{assembly_name}' not defined.")
+            raise ValueError(f"Assembly '{assembly_name}' not defined. Use create_assemblies() first.")
             
         assembly_list = self.assemblies[assembly_name]
         n_assemblies = len(assembly_list)
@@ -192,99 +316,3 @@ class StimulusBuilder:
         psg.to_sonata(output_path)
         if verbose:
             print(f"Written stimulus to {output_path}")
-
-    def generate_baseline(self, output_path, network_name, pop_name=None, distribution='constant', 
-                         mean=None, stdev=None, firing_rate=None, t_start=0.0, t_stop=10.0, verbose=False, seed=None):
-        """Generate baseline activity for a selection of nodes.
-        
-        Args:
-            output_path (str): Path to save the resulting .h5 file.
-            network_name (str): BMTK network name.
-            pop_name (str, optional): Filter nodes by population name.
-            distribution (str): 'constant', 'lognormal', or 'normal'.
-            mean (float): Mean for lognormal/normal or constant rate (if firing_rate omitted).
-            stdev (float): Standard deviation for lognormal/normal.
-            firing_rate (float, optional): Constant firing rate.
-            t_start, t_stop (float): Time range for activity.
-            verbose (bool): If True, print detailed information (default: False).
-            seed (int, optional): Random seed for distribution sampling. Overrides instance psg_seed for this call.
-        """
-        nodes_df = self.get_nodes(network_name, pop_name)
-        node_ids = nodes_df.index.values.tolist()
-        
-        # Use provided seed or default to instance psg_seed
-        psg_seed = seed if seed is not None else self.psg_seed
-        
-        population = network_name # Default population name in PSG
-        psg = PoissonSpikeGenerator(population=population, seed=psg_seed)
-        
-        times = (t_start, t_stop)
-        
-        if distribution == 'constant':
-            if firing_rate is None:
-                if mean is not None: 
-                    firing_rate = mean
-                else:
-                    raise ValueError("Must provide firing_rate for constant distribution")
-            
-            psg.add(node_ids=node_ids, firing_rate=firing_rate, times=times)
-            
-        elif distribution in ['lognormal', 'normal']:
-            if mean is None or stdev is None:
-                raise ValueError(f"Must provide mean and stdev for {distribution} distribution")
-            
-            firing_rates = self._generate_firing_rates(len(node_ids), mean, stdev, distribution)
-            
-            for node_id, fr in zip(node_ids, firing_rates):
-                psg.add(node_ids=node_id, firing_rate=fr, times=times)
-                
-        else:
-             raise ValueError(f"Unknown distribution: {distribution}")
-             
-        # Write to file
-        os.makedirs(os.path.dirname(output_path), exist_ok=True)
-        psg.to_sonata(output_path)
-        if verbose:
-            print(f"Written baseline to {output_path}")
-
-    def generate_shell_input(self, output_path, network_name, shell_params, 
-                            distribution='lognormal', t_start=0.0, t_stop=15.0, verbose=False, seed=None):
-        """Generate shell (background) stimulus with population-specific rates.
-        
-        Args:
-            output_path (str): Path to save the resulting .h5 file.
-            network_name (str): BMTK network name.
-            shell_params (dict): Population-specific (mean, stdev) tuples.
-                Example: {'ET': (1.9, 1.8), 'IT': (1.3, 1.4), 'PV': (7.5, 6.4), 'SST': (5.0, 6.0)}
-            distribution (str): 'lognormal' or 'normal' (default: 'lognormal').
-            t_start, t_stop (float): Time range for activity.
-            verbose (bool): If True, print detailed information (default: False).
-            seed (int, optional): Random seed for distribution sampling. Overrides instance psg_seed for this call.
-        """
-        nodes_df = self.get_nodes(network_name)
-        
-        # Use provided seed or default to instance psg_seed
-        psg_seed = seed if seed is not None else self.psg_seed
-        
-        psg = PoissonSpikeGenerator(population=network_name, seed=psg_seed)
-        
-        total_nodes = 0
-        for pop_name, (mean, stdev) in shell_params.items():
-            nodes_in_pop = nodes_df[nodes_df['pop_name'] == pop_name].index.values
-            if len(nodes_in_pop) == 0:
-                continue
-            
-            total_nodes += len(nodes_in_pop)
-            
-            # Generate rates using helper function
-            rates = self._generate_firing_rates(len(nodes_in_pop), mean, stdev, distribution)
-            
-            # Add to PSG
-            for node_id, rate in zip(nodes_in_pop, rates):
-                psg.add(node_ids=node_id, firing_rate=rate, times=(t_start, t_stop))
-        
-        # Write to file
-        os.makedirs(os.path.dirname(output_path), exist_ok=True)
-        psg.to_sonata(output_path)
-        if verbose:
-            print(f"Generated shell stimulus ({distribution}): {total_nodes} nodes to {output_path}")

{bmtool-0.8.0 → 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.0 → bmtool-0.8.2}/bmtool.egg-info/PKG-INFO

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

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

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

bmtool-0.8.0/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