bmtool 0.6.0__tar.gz → 0.6.2__tar.gz

{bmtool-0.6.0 → bmtool-0.6.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bmtool
-Version: 0.6.0
+Version: 0.6.2
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 

{bmtool-0.6.0 → bmtool-0.6.2}/bmtool/SLURM.py

@@ -3,6 +3,7 @@ import os
 import subprocess
 import json
 import requests
+import shutil
 
 
 def check_job_status(job_id):
@@ -106,7 +107,6 @@ class seedSweep:
         
         print(f"JSON file '{self.json_file_path}' modified successfully with {self.param_name}={new_value}.", flush=True)
         
-    
     def change_json_file_path(self,new_json_file_path):
         self.json_file_path = new_json_file_path
 
@@ -156,8 +156,7 @@ class multiSeedSweep(seedSweep):
 
 
 class SimulationBlock:
-    def __init__(self, block_name, time, partition, nodes, ntasks, mem, simulation_cases, output_base_dir,account=None,additional_commands=None,
-                 status_list = ['COMPLETED', 'FAILED', 'CANCELLED']):
+    def __init__(self, block_name, time, partition, nodes, ntasks, mem, simulation_cases, output_base_dir,account=None,additional_commands=None,status_list = ['COMPLETED', 'FAILED', 'CANCELLED'],component_path=None):
         """
         Initializes the SimulationBlock instance.
 
@@ -187,6 +186,7 @@ class SimulationBlock:
         self.additional_commands = additional_commands if additional_commands is not None else []
         self.status_list = status_list
         self.job_ids = []
+        self.component_path = component_path
 
     def create_batch_script(self, case_name, command):
         """
@@ -207,6 +207,8 @@ class SimulationBlock:
         additional_commands_str = "\n".join(self.additional_commands)
         # Conditional account linegit
         account_line = f"#SBATCH --account={self.account}\n" if self.account else ""
+        env_var_component_path = f"export COMPONENT_PATH={self.component_path}" if self.component_path else ""
+        
 
         # Write the batch script to the file
         with open(batch_script_path, 'w') as script_file:
@@ -224,6 +226,9 @@ class SimulationBlock:
 # Additional user-defined commands
 {additional_commands_str}
 
+#enviroment vars
+{env_var_component_path}
+
 export OUTPUT_DIR={case_output_dir}
 
 {command}
@@ -272,7 +277,6 @@ export OUTPUT_DIR={case_output_dir}
                 return False
         return True
 
-
     def check_block_running(self):
         """checks if a job is running
 
@@ -284,9 +288,21 @@ export OUTPUT_DIR={case_output_dir}
             if status != 'RUNNING': # 
                 return False
         return True
+    
+    def check_block_submited(self):
+        """checks if a job is running
 
+        Returns:
+            bool: True if jobs are RUNNING false if anything else
+        """
+        for job_id in self.job_ids:
+            status = check_job_status(job_id)
+            if status != 'PENDING': # 
+                return False
+        return True
 
-class SequentialBlockRunner:
+
+class BlockRunner:
     """
     Class to handle submitting multiple blocks sequentially.
 
@@ -297,17 +313,23 @@ class SequentialBlockRunner:
         webhook (str): a microsoft webhook for teams. When used will send teams messages to the hook!
     """
 
-    def __init__(self, blocks, json_editor=None, param_values=None, check_interval=200,webhook=None):
+    def __init__(self, blocks, json_editor=None,json_file_path=None, param_name=None, 
+                 param_values=None, check_interval=60,syn_dict_list = None,
+                 webhook=None):
         self.blocks = blocks
         self.json_editor = json_editor
         self.param_values = param_values
         self.check_interval = check_interval
         self.webhook = webhook
+        self.param_name = param_name
+        self.json_file_path = json_file_path
+        self.syn_dict_list = syn_dict_list
 
     def submit_blocks_sequentially(self):
         """
-        Submits all blocks sequentially, ensuring each block starts only after the previous block has completed.
+        Submits all blocks sequentially, ensuring each block starts only after the previous block has completed or is running.
         Updates the JSON file with new parameters before each block run.
+        json file path should be the path WITH the components folder 
         """
         for i, block in enumerate(self.blocks):
             # Update JSON file with new parameter value
@@ -317,15 +339,14 @@ class SequentialBlockRunner:
                 if len(self.blocks) != len(self.param_values):
                     raise Exception("Number of blocks needs to each number of params given")
                 new_value = self.param_values[i]
-                # NGL didnt test the multi but should work
-                if isinstance(self.json_editor, multiSeedSweep):
-                    self.json_editor.edit_all_jsons(new_value)
-                elif isinstance(self.json_editor,seedSweep):
-                    print(f"Updating JSON file with parameter value for block: {block.block_name}", flush=True)
-                    self.json_editor.edit_json(new_value)
-                else:
-                    raise Exception("json editor provided but not a seedSweep class not sure what your doing?!?")
                 
+                if self.syn_dict_list == None:
+                    json_editor = seedSweep(self.json_file_path, self.param_name)
+                    json_editor.edit_json(new_value)
+                else:
+                    json_editor = multiSeedSweep(self.json_file_path,self.param_name,
+                                                self.syn_dict_list,base_ratio=1)
+                    json_editor.edit_all_jsons(new_value) 
 
             # Submit the block
             print(f"Submitting block: {block.block_name}", flush=True)
@@ -335,7 +356,7 @@ class SequentialBlockRunner:
                 send_teams_message(self.webhook,message)
 
             # Wait for the block to complete
-            if i == len(self.blocks) - 1:  # Corrected index to check the last block
+            if i == len(self.blocks) - 1:  
                 while not block.check_block_completed():
                     print(f"Waiting for the last block {i} to complete...")
                     time.sleep(self.check_interval)
@@ -350,3 +371,43 @@ class SequentialBlockRunner:
             message = "SIMULATION UPDATE: Simulation are Done!"
             send_teams_message(self.webhook,message)
 
+    def submit_blocks_parallel(self):
+        """
+        submits all the blocks at once onto the queue. To do this the components dir will be cloned and each block will have its own.
+        Also the json_file_path should be the path after the components dir
+        """
+        if self.webhook:
+            message = "SIMULATION UPDATE: Simulations have been submited in parallel!"
+            send_teams_message(self.webhook,message)
+        for i, block in enumerate(self.blocks):
+            if block.component_path == None:
+                raise Exception("Unable to use parallel submitter without defining the component path")
+            new_value = self.param_values[i]
+            
+            source_dir = block.component_path
+            destination_dir = f"{source_dir}{i+1}"
+            block.component_path = destination_dir
+
+            shutil.copytree(source_dir, destination_dir) # create new components folder 
+            json_file_path = os.path.join(destination_dir,self.json_file_path)
+            if self.syn_dict_list == None:
+                json_editor = seedSweep(json_file_path, self.param_name)
+                json_editor.edit_json(new_value)
+            else:
+                json_editor = multiSeedSweep(json_file_path,self.param_name,
+                                             self.syn_dict_list,base_ratio=1)
+                json_editor.edit_all_jsons(new_value)  
+            
+            # submit block with new component path 
+            print(f"Submitting block: {block.block_name}", flush=True)
+            block.submit_block()
+            if i == len(self.blocks) - 1:  
+                while not block.check_block_completed():
+                    print(f"Waiting for the last block {i} to complete...")
+                    time.sleep(self.check_interval)
+                
+        if self.webhook:
+            message = "SIMULATION UPDATE: Simulations are Done!"
+            send_teams_message(self.webhook,message)
+            
+            

{bmtool-0.6.0 → bmtool-0.6.2}/bmtool/bmplot.py

@@ -21,7 +21,6 @@ import os
 import sys
 import re
 from typing import Optional, Dict
-from .analysis.spikes import load_spikes_to_df
 
 from .util.util import CellVarsFile,load_nodes_from_config #, missing_units
 from bmtk.analyzer.utils import listify
@@ -306,46 +305,47 @@ def gap_junction_matrix(config=None,title=None,sources=None, targets=None, sids=
     
     
     def filter_rows(syn_info, data, source_labels, target_labels):
-        new_syn_info = syn_info
-        new_data = data
-        new_source_labels = source_labels
-        new_target_labels = target_labels
-        for row in new_data:
-            row_index = -1
-            try:
-                if((np.isnan(row).all())): #checks if all of a row is nan
-                    row_index = np.where(np.isnan(new_data)==np.isnan(row))[0][0]  
-            except:
-                row_index = -1
-            finally:          
-                if(all(x==0 for x in row)): #checks if all of a row is zeroes
-                    row_index = np.where(new_data==row)[0][0] 
-                if row_index!=-1:   #deletes corresponding row accordingly in all relevant variables.
-                    new_syn_info = np.delete(new_syn_info,row_index,0) 
-                    new_data = np.delete(new_data,row_index,0)
-                    new_source_labels = np.delete(new_source_labels,row_index)
-        return new_syn_info, new_data,new_source_labels,new_target_labels
-
-    def filter_rows_and_columns(syn_info,data,source_labels,target_labels):
+        # Identify rows with all NaN or all zeros
+        valid_rows = ~np.all(np.isnan(data), axis=1) & ~np.all(data == 0, axis=1)
+
+        # Filter rows based on valid_rows mask
+        new_syn_info = syn_info[valid_rows]
+        new_data = data[valid_rows]
+        new_source_labels = np.array(source_labels)[valid_rows]
+
+        return new_syn_info, new_data, new_source_labels, target_labels
+
+    def filter_rows_and_columns(syn_info, data, source_labels, target_labels):
+        # Filter rows first
         syn_info, data, source_labels, target_labels = filter_rows(syn_info, data, source_labels, target_labels)
-        transposed_syn_info = np.transpose(syn_info) #transpose everything and put it in to make sure columns get filtered
+
+        # Transpose data to filter columns
+        transposed_syn_info = np.transpose(syn_info)
         transposed_data = np.transpose(data)
         transposed_source_labels = target_labels
         transposed_target_labels = source_labels
-        syn_info, data, source_labels, target_labels = filter_rows(transposed_syn_info, transposed_data, transposed_source_labels, transposed_target_labels)
-        filtered_syn_info = np.transpose(syn_info) #transpose everything back to original order after filtering.
-        filtered_data = np.transpose(data)
-        filtered_source_labels = target_labels
-        filtered_target_labels = source_labels
-        return filtered_syn_info,filtered_data,filtered_source_labels,filtered_target_labels
+
+        # Filter columns (by treating them as rows in transposed data)
+        transposed_syn_info, transposed_data, transposed_source_labels, transposed_target_labels = filter_rows(
+            transposed_syn_info, transposed_data, transposed_source_labels, transposed_target_labels
+        )
+
+        # Transpose back to original orientation
+        filtered_syn_info = np.transpose(transposed_syn_info)
+        filtered_data = np.transpose(transposed_data)
+        filtered_source_labels = transposed_target_labels  # Back to original source_labels
+        filtered_target_labels = transposed_source_labels  # Back to original target_labels
+
+        return filtered_syn_info, filtered_data, filtered_source_labels, filtered_target_labels
+
     
     syn_info, data, source_labels, target_labels = filter_rows_and_columns(syn_info, data, source_labels, target_labels)
 
     if title == None or title=="":
         title = 'Gap Junction'
-        if type == 'convergence':
+        if method == 'convergence':
             title+=' Syn Convergence'
-        elif type == 'percent':
+        elif method == 'percent':
             title+=' Percent Connectivity'
     plot_connection_info(syn_info,data,source_labels,target_labels,title, save_file=save_file)
     return
@@ -535,35 +535,42 @@ def edge_histogram_matrix(config=None,sources = None,targets=None,sids=None,tids
     fig.text(0.04, 0.5, 'Source', va='center', rotation='vertical')
     plt.draw()
 
-def plot_connection_info(text, num, source_labels,target_labels, title, syn_info='0', save_file=None,return_dict=None):
+def plot_connection_info(text, num, source_labels, target_labels, title, syn_info='0', save_file=None, return_dict=None):
     """
-    write about function here
+    Function to plot connection information as a heatmap, including handling missing source and target values.
+    If there is no source or target, set the value to 0.
     """
     
-    #num = pd.DataFrame(num).fillna('nc').to_numpy() # replace nan with nc * does not work with imshow
+    # Ensure text dimensions match num dimensions
+    num_source = len(source_labels)
+    num_target = len(target_labels)
     
-    num_source=len(source_labels)
-    num_target=len(target_labels)
+    # Set color map
     matplotlib.rc('image', cmap='viridis')
     
-    fig1, ax1 = plt.subplots(figsize=(num_source,num_target))
+    # Create figure and axis for the plot
+    fig1, ax1 = plt.subplots(figsize=(num_source, num_target))
+    num = np.nan_to_num(num, nan=0) # replace NaN with 0
     im1 = ax1.imshow(num)
-    #fig.colorbar(im, ax=ax,shrink=0.4)
-    # We want to show all ticks...
+    
+    # Set ticks and labels for source and target
     ax1.set_xticks(list(np.arange(len(target_labels))))
     ax1.set_yticks(list(np.arange(len(source_labels))))
-    # ... and label them with the respective list entries
     ax1.set_xticklabels(target_labels)
-    ax1.set_yticklabels(source_labels,size=12, weight = 'semibold')
-    # Rotate the tick labels and set their alignment.
+    ax1.set_yticklabels(source_labels, size=12, weight='semibold')
+    
+    # Rotate the tick labels for better visibility
     plt.setp(ax1.get_xticklabels(), rotation=45, ha="right",
-            rotation_mode="anchor", size=12, weight = 'semibold')
+             rotation_mode="anchor", size=12, weight='semibold')
     
+    # Dictionary to store connection information
     graph_dict = {}
-    # Loop over data dimensions and create text annotations.
+    
+    # Loop over data dimensions and create text annotations
     for i in range(num_source):
         for j in range(num_target):
-            edge_info = text[i, j]
+            # Get the edge info, or set it to '0' if it's missing
+            edge_info = text[i, j] if text[i, j] is not None else 0
             
             # Initialize the dictionary for the source node if not already done
             if source_labels[i] not in graph_dict:
@@ -571,35 +578,41 @@ def plot_connection_info(text, num, source_labels,target_labels, title, syn_info
             
             # Add edge info for the target node
             graph_dict[source_labels[i]][target_labels[j]] = edge_info
-            if syn_info =='2' or syn_info =='3':
-                if num_source > 8 and num_source <20:
+            
+            # Set text annotations based on syn_info type
+            if syn_info == '2' or syn_info == '3':
+                if num_source > 8 and num_source < 20:
                     fig_text = ax1.text(j, i, edge_info,
-                            ha="center", va="center", color="w",rotation=37.5, size=8, weight = 'semi\bold')
+                                        ha="center", va="center", color="w", rotation=37.5, size=8, weight='semibold')
                 elif num_source > 20:
                     fig_text = ax1.text(j, i, edge_info,
-                            ha="center", va="center", color="w",rotation=37.5, size=7, weight = 'semibold')
+                                        ha="center", va="center", color="w", rotation=37.5, size=7, weight='semibold')
                 else:
                     fig_text = ax1.text(j, i, edge_info,
-                            ha="center", va="center", color="w",rotation=37.5, size=11, weight = 'semibold')
+                                        ha="center", va="center", color="w", rotation=37.5, size=11, weight='semibold')
             else:
                 fig_text = ax1.text(j, i, edge_info,
-                            ha="center", va="center", color="w", size=11, weight = 'semibold')
-
-    ax1.set_ylabel('Source', size=11, weight = 'semibold')
-    ax1.set_xlabel('Target', size=11, weight = 'semibold')
-    ax1.set_title(title,size=20, weight = 'semibold')
-    #plt.tight_layout()
-    notebook = is_notebook()
+                                    ha="center", va="center", color="w", size=11, weight='semibold')
+    
+    # Set labels and title for the plot
+    ax1.set_ylabel('Source', size=11, weight='semibold')
+    ax1.set_xlabel('Target', size=11, weight='semibold')
+    ax1.set_title(title, size=20, weight='semibold')
+    
+    # Display the plot or save it based on the environment and arguments
+    notebook = is_notebook()  # Check if running in a Jupyter notebook
     if notebook == False:
         fig1.show()
+    
     if save_file:
         plt.savefig(save_file)
+    
     if return_dict:
         return graph_dict
     else:
         return
 
-def connector_percent_matrix(csv_path: str = None, exclude_strings=None, title: str = 'Percent connection matrix', pop_order=None) -> None:
+def connector_percent_matrix(csv_path: str = None, exclude_strings=None, assemb_key=None, title: str = 'Percent connection matrix', pop_order=None) -> None:
     """
     Generates and plots a connection matrix based on connection probabilities from a CSV file produced by bmtool.connector.
 
@@ -633,6 +646,7 @@ def connector_percent_matrix(csv_path: str = None, exclude_strings=None, title:
     # Filter the DataFrame based on exclude_strings
     def filter_dataframe(df, column_name, exclude_strings):
         def process_string(string):
+            
             match = re.search(r"\[\'(.*?)\'\]", string)
             if exclude_strings and any(ex_string in string for ex_string in exclude_strings):
                 return None
@@ -640,17 +654,55 @@ def connector_percent_matrix(csv_path: str = None, exclude_strings=None, title:
                 filtered_string = match.group(1)
                 if 'Gap' in string:
                         filtered_string = filtered_string + "-Gap"
+                if assemb_key in string:
+                    filtered_string = filtered_string + assemb_key
                 return filtered_string  # Return matched string
 
             return string  # If no match, return the original string
-
+        
         df[column_name] = df[column_name].apply(process_string)
         df = df.dropna(subset=[column_name])
+        
         return df
 
     df = filter_dataframe(df, 'Source', exclude_strings)
     df = filter_dataframe(df, 'Target', exclude_strings)
+    
+    #process assem rows and combine them into one prob per assem type
+    assems = df[df['Source'].str.contains(assemb_key)]
+    unique_sources = assems['Source'].unique()
 
+    for source in unique_sources:
+        source_assems = assems[assems['Source'] == source]
+        unique_targets = source_assems['Target'].unique()  # Filter targets for the current source
+
+        for target in unique_targets:
+            # Filter the assemblies with the current source and target
+            unique_assems = source_assems[source_assems['Target'] == target]
+            
+            # find the prob of a conn
+            forward_probs = []
+            for _,row in unique_assems.iterrows():
+                selected_percentage = row[selected_column]
+                selected_percentage = [float(p) for p in selected_percentage.strip('[]').split()]
+                if len(selected_percentage) == 1 or len(selected_percentage) == 2:
+                    forward_probs.append(selected_percentage[0])
+                if len(selected_percentage) == 3:
+                    forward_probs.append(selected_percentage[0])
+                    forward_probs.append(selected_percentage[1])
+                    
+            mean_probs = np.mean(forward_probs)
+            source = source.replace(assemb_key, "")
+            target = target.replace(assemb_key, "")
+            new_row = pd.DataFrame({
+                'Source': [source],
+                'Target': [target],
+                'Percent connectionivity within possible connections': [mean_probs],
+                'Percent connectionivity within all connections': [0]
+            })
+
+            df = pd.concat([df, new_row], ignore_index=False)
+            
     # Prepare connection data
     connection_data = {}
     for _, row in df.iterrows():
@@ -671,14 +723,18 @@ def connector_percent_matrix(csv_path: str = None, exclude_strings=None, title:
         if source in populations and target in populations:
             source_idx = populations.index(source)
             target_idx = populations.index(target)
-            connection_matrix[source_idx][target_idx] = probabilities[0]
-            if len(probabilities) == 1:
+
+            if type(probabilities) == float:
+                connection_matrix[source_idx][target_idx] = probabilities
+            elif len(probabilities) == 1:
                 connection_matrix[source_idx][target_idx] = probabilities[0]
-            if len(probabilities) == 2:
+            elif len(probabilities) == 2:
                 connection_matrix[source_idx][target_idx] = probabilities[0]
-            if len(probabilities) == 3:
+            elif len(probabilities) == 3:
                 connection_matrix[source_idx][target_idx] = probabilities[0] 
                 connection_matrix[target_idx][source_idx] = probabilities[1]
+            else:
+                raise Exception("unsupported format")
 
     # Plotting
     fig, ax = plt.subplots(figsize=(10, 8))

{bmtool-0.6.0 → bmtool-0.6.2}/bmtool/synapses.py

@@ -46,13 +46,14 @@ class SynapseTuner:
         self.conn_type_settings = conn_type_settings
         if json_folder_path:
             print(f"updating settings from json path {json_folder_path}")
-            self.update_spec_syn_param(json_folder_path)
+            self._update_spec_syn_param(json_folder_path)
         self.general_settings = general_settings
         self.conn = self.conn_type_settings[connection]
         self.synaptic_props = self.conn['spec_syn_param']
         self.vclamp = general_settings['vclamp']
         self.current_name = current_name
         self.other_vars_to_record = other_vars_to_record
+        self.ispk = None
 
         if slider_vars:
             # Start by filtering based on keys in slider_vars
@@ -63,10 +64,10 @@ class SynapseTuner:
                 if key not in self.synaptic_props:
                     try:
                         # Get the alternative value from getattr dynamically
-                        self.set_up_cell()
-                        self.set_up_synapse()
+                        self._set_up_cell()
+                        self._set_up_synapse()
                         value = getattr(self.syn,key)
-                        print(value)
+                        #print(value)
                         self.slider_vars[key] = value
                     except AttributeError as e:
                         print(f"Error accessing '{key}' in syn {self.syn}: {e}")
@@ -80,7 +81,7 @@ class SynapseTuner:
         h.steps_per_ms = 1 / h.dt
         h.celsius = general_settings['celsius']
 
-    def update_spec_syn_param(self, json_folder_path):
+    def _update_spec_syn_param(self, json_folder_path):
         """
         Update specific synaptic parameters using JSON files located in the specified folder.
         
@@ -99,20 +100,20 @@ class SynapseTuner:
                 print(f"JSON file for {conn_type} not found.")
 
 
-    def set_up_cell(self):
+    def _set_up_cell(self):
         """
         Set up the neuron cell based on the specified connection settings.
         """
         self.cell = getattr(h, self.conn['spec_settings']['post_cell'])()
 
 
-    def set_up_synapse(self):
+    def _set_up_synapse(self):
         """
         Set up the synapse on the target cell according to the synaptic parameters in `conn_type_settings`.
         
         Notes:
         ------
-        - `set_up_cell()` should be called before setting up the synapse.
+        - `_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']))
@@ -124,7 +125,7 @@ class SynapseTuner:
                     print(f"Warning: {key} cannot be assigned as it does not exist in the synapse. Check your mod file or spec_syn_param.")
 
 
-    def set_up_recorders(self):
+    def _set_up_recorders(self):
         """
         Set up recording vectors to capture simulation data.
         
@@ -171,8 +172,8 @@ class SynapseTuner:
         and then runs the NEURON simulation for a single event. The single synaptic event will occur at general_settings['tstart']
         Will display graphs and synaptic properies works best with a jupyter notebook
         """
-        self.set_up_cell()
-        self.set_up_synapse()
+        self._set_up_cell()
+        self._set_up_synapse()
 
         # Set up the stimulus
         self.nstim = h.NetStim()
@@ -191,7 +192,7 @@ class SynapseTuner:
             self.vcl.amp[i] = self.conn['spec_settings']['vclamp_amp']
             self.vcl.dur[i] = vcldur[1][i]
 
-        self.set_up_recorders()
+        self._set_up_recorders()
 
         # Run simulation
         h.tstop = self.general_settings['tstart'] + self.general_settings['tdur']
@@ -199,13 +200,13 @@ class SynapseTuner:
         self.nstim.number = 1
         self.nstim2.start = h.tstop
         h.run()
-        self.plot_model([self.general_settings['tstart'] - 5, self.general_settings['tstart'] + self.general_settings['tdur']])
-        syn_props = self.get_syn_prop(rise_interval=self.general_settings['rise_interval'])     
+        self._plot_model([self.general_settings['tstart'] - 5, self.general_settings['tstart'] + self.general_settings['tdur']])
+        syn_props = self._get_syn_prop(rise_interval=self.general_settings['rise_interval'])     
         for prop in syn_props.items():
             print(prop)
 
 
-    def find_first(self, x):
+    def _find_first(self, x):
         """
         Find the index of the first non-zero element in a given array.
         
@@ -224,7 +225,7 @@ class SynapseTuner:
         return idx[0] if idx.size else None
 
 
-    def get_syn_prop(self, rise_interval=(0.2, 0.8), dt=h.dt, short=False):
+    def _get_syn_prop(self, rise_interval=(0.2, 0.8), dt=h.dt, short=False):
         """
         Calculate synaptic properties such as peak amplitude, latency, rise time, decay time, and half-width.
         
@@ -269,22 +270,22 @@ class SynapseTuner:
         ipk = ipk[0]
         peak = isyn[ipk]
         # latency
-        istart = self.find_first(np.diff(isyn[:ipk + 1]) > 0)
+        istart = self._find_first(np.diff(isyn[:ipk + 1]) > 0)
         latency = dt * (istart + 1)
         # rise time
-        rt1 = self.find_first(isyn[istart:ipk + 1] > rise_interval[0] * peak)
-        rt2 = self.find_first(isyn[istart:ipk + 1] > rise_interval[1] * peak)
+        rt1 = self._find_first(isyn[istart:ipk + 1] > rise_interval[0] * peak)
+        rt2 = self._find_first(isyn[istart:ipk + 1] > rise_interval[1] * peak)
         rise_time = (rt2 - rt1) * dt
         # decay time
-        iend = self.find_first(np.diff(isyn[ipk:]) > 0)
+        iend = self._find_first(np.diff(isyn[ipk:]) > 0)
         iend = isyn.size - 1 if iend is None else iend + ipk
         decay_len = iend - ipk + 1
         popt, _ = curve_fit(lambda t, a, tau: a * np.exp(-t / tau), dt * np.arange(decay_len),
                             isyn[ipk:iend + 1], p0=(peak, dt * decay_len / 2))
         decay_time = popt[1]
         # half-width
-        hw1 = self.find_first(isyn[istart:ipk + 1] > 0.5 * peak)
-        hw2 = self.find_first(isyn[ipk:] < 0.5 * peak)
+        hw1 = self._find_first(isyn[istart:ipk + 1] > 0.5 * peak)
+        hw2 = self._find_first(isyn[ipk:] < 0.5 * peak)
         hw2 = isyn.size if hw2 is None else hw2 + ipk
         half_width = dt * (hw2 - hw1)
         output = {'baseline': baseline, 'sign': sign, 'latency': latency,
@@ -292,7 +293,7 @@ class SynapseTuner:
         return output
 
 
-    def plot_model(self, xlim):
+    def _plot_model(self, xlim):
         """
         Plots the results of the simulation, including synaptic current, soma voltage,
         and any additional recorded variables.
@@ -319,6 +320,11 @@ class SynapseTuner:
         
         # Plot synaptic current (always included)
         axs[0].plot(self.t, 1000 * self.rec_vectors[self.current_name])
+        if self.ispk !=None:
+            for num in range(len(self.ispk)):
+                current = 1000 * np.array(self.rec_vectors[self.current_name].to_python())
+                axs[0].text(self.t[self.ispk[num]],current[self.ispk[num]],f"{str(num+1)}")
+
         axs[0].set_ylabel('Synaptic Current (pA)')
         
         # Plot voltage clamp or soma voltage (always included)
@@ -332,6 +338,7 @@ class SynapseTuner:
         else:
             soma_v_plt = np.array(self.soma_v)
             soma_v_plt[:ispk] = soma_v_plt[ispk]
+
             axs[1].plot(self.t, soma_v_plt)
             axs[1].set_ylabel('Soma Voltage (mV)')
         
@@ -353,11 +360,11 @@ class SynapseTuner:
             for j in range(num_vars_to_plot, len(axs)):
                 fig.delaxes(axs[j])
 
-        plt.tight_layout()
+        #plt.tight_layout()
         plt.show()
 
 
-    def set_drive_train(self,freq=50., delay=250.):
+    def _set_drive_train(self,freq=50., delay=250.):
         """
         Configures trains of 12 action potentials at a specified frequency and delay period
         between pulses 8 and 9.
@@ -390,7 +397,7 @@ class SynapseTuner:
         return tstop
  
 
-    def response_amplitude(self):
+    def _response_amplitude(self):
         """
         Calculates the amplitude of the synaptic response by analyzing the recorded synaptic current.
 
@@ -402,17 +409,25 @@ class SynapseTuner:
         """
         isyn = np.asarray(self.rec_vectors['i'])
         tspk = np.append(np.asarray(self.tspk), h.tstop)
-        syn_prop = self.get_syn_prop(short=True)
+        syn_prop = self._get_syn_prop(short=True)
         # print("syn_prp[sign] = " + str(syn_prop['sign']))
         isyn = (isyn - syn_prop['baseline']) 
         isyn *= syn_prop['sign']
-        # print(isyn)
         ispk = np.floor((tspk + self.general_settings['delay']) / h.dt).astype(int)
-        amp = [isyn[ispk[i]:ispk[i + 1]].max() for i in range(ispk.size - 1)]
+
+        try:        
+            amp = [isyn[ispk[i]:ispk[i + 1]].max() for i in range(ispk.size - 1)]
+            # indexs of where the max of the synaptic current is at. This is then plotted     
+            self.ispk = [np.argmax(isyn[ispk[i]:ispk[i + 1]]) + ispk[i] for i in range(ispk.size - 1)]
+        # Sometimes the sim can cutoff at the peak of synaptic activity. So we just reduce the range by 1 and ingore that point
+        except:
+            amp = [isyn[ispk[i]:ispk[i + 1]].max() for i in range(ispk.size - 2)]  
+            self.ispk = [np.argmax(isyn[ispk[i]:ispk[i + 1]]) + ispk[i] for i in range(ispk.size - 2)]
+            
         return amp
 
 
-    def find_max_amp(self, amp, normalize_by_trial=True):
+    def _find_max_amp(self, amp, normalize_by_trial=True):
         """
         Determines the maximum amplitude from the response data.
 
@@ -435,7 +450,7 @@ class SynapseTuner:
         return max_amp
 
 
-    def induction_recovery(self,amp, normalize_by_trial=True):
+    def _print_ppr_induction_recovery(self,amp, normalize_by_trial=True):
         """
         Calculates induction and recovery metrics from the synaptic response amplitudes.
 
@@ -457,54 +472,48 @@ class SynapseTuner:
         """
         amp = np.array(amp)
         amp = amp.reshape(-1, amp.shape[-1])
+        maxamp = amp.max(axis=1 if normalize_by_trial else None)
+
+        # functions used to round array to 2 sig figs
+        def format_value(x):
+            return f"{x:.2g}"
+
+        # Function to apply format_value to an entire array
+        def format_array(arr):
+            # Flatten the array and format each element
+            return ' '.join([format_value(x) for x in arr.flatten()])
         
+        print("Short Term Plasticity")
+        print("PPR: above 1 is facilitating below 1 is depressing")
+        print("Induction: above 0 is facilitating below 0 is depressing")
+        print("Recovery: measure of how fast STP decays")
+        print("")
         
-        maxamp = amp.max(axis=1 if normalize_by_trial else None)
+        ppr = amp[:,1:2] / amp[:,0:1]
+        print(f"Paired Pulse Response Calculation: 2nd pulse / 1st pulse ")
+        print(f"{format_array(amp[:,1:2])} - {format_array(amp[:,0:1])} = {format_array(ppr)}")
+        print("")
+
         induction = np.mean((amp[:, 5:8].mean(axis=1) - amp[:, :1].mean(axis=1)) / maxamp)
+        print(f"Induction Calculation: (avg(6,7,8 pulses) - 1 pulse) / max amps")
+        # Format and print arrays with 2 significant figures
+        print(f"{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)} = {format_array(induction)}")
+        print("")
+
         recovery = np.mean((amp[:, 8:12].mean(axis=1) - amp[:, :4].mean(axis=1)) / maxamp)
+        print("Recovery Calculation: avg(9,10,11,12 pulses) - avg(1,2,3,4 pulses) / max amps")
+        print(f"{format_array(amp[:, 8:12])} - {format_array(amp[:, :4])} / {format_array(maxamp)}")
+        print(f"{format_array(amp[:, 8:12].mean(axis=1))} - {format_array(amp[:, :4].mean(axis=1))} / {format_array(maxamp)} = {format_array(recovery)}")
+        print("")
 
+        
         # maxamp = max(amp, key=lambda x: abs(x[0]))
         maxamp = maxamp.max()
-        return induction, recovery, maxamp
-
-
-    def paired_pulse_ratio(self, dt=h.dt):
-        """
-        Computes the paired-pulse ratio (PPR) based on the recorded synaptic current or voltage.
-
-        Parameters:
-        -----------
-        dt : float, optional
-            Time step in milliseconds. Default is the NEURON simulation time step.
+        #return induction, recovery, maxamp
 
-        Returns:
-        --------
-        ppr : float
-            The ratio between the second and first pulse amplitudes.
 
-        Notes:
-        ------
-        - The function handles both voltage-clamp and current-clamp conditions.
-        - A minimum of two spikes is required to calculate PPR.
-        """
-        if self.vclamp:
-            isyn = self.ivcl
-        else:
-            isyn = self.rec_vectors['i']
-        isyn = np.asarray(isyn)
-        tspk = np.asarray(self.tspk)
-        if tspk.size < 2:
-            raise ValueError("Need at least two spikes.")
-        syn_prop = self.get_syn_prop()
-        isyn = (isyn - syn_prop['baseline']) * syn_prop['sign']
-        ispk2 = int(np.floor(tspk[1] / dt))
-        ipk, _ = find_peaks(isyn[ispk2:])
-        ipk2 = ipk[0] + ispk2
-        peak2 = isyn[ipk2]
-        return peak2 / syn_prop['amp']
-
-
-    def set_syn_prop(self, **kwargs):
+    def _set_syn_prop(self, **kwargs):
         """
         Sets the synaptic parameters based on user inputs from sliders.
         
@@ -517,7 +526,7 @@ class SynapseTuner:
             setattr(self.syn, key, value)
 
 
-    def simulate_model(self,input_frequency, delay, vclamp=None):
+    def _simulate_model(self,input_frequency, delay, vclamp=None):
         """
         Runs the simulation with the specified input frequency, delay, and voltage clamp settings.
 
@@ -532,7 +541,7 @@ class SynapseTuner:
 
         """
         if self.input_mode == False:
-            self.tstop = self.set_drive_train(input_frequency, delay)
+            self.tstop = self._set_drive_train(input_frequency, delay)
             h.tstop = self.tstop
 
             vcldur = [[0, 0, 0], [self.general_settings['tstart'], self.tstop, 1e9]]
@@ -556,13 +565,9 @@ class SynapseTuner:
         """
         Sets up interactive sliders for short-term plasticity (STP) experiments in a Jupyter Notebook.
         
-        Notes:
-        ------
-        - The sliders allow control over synaptic properties dynamically based on slider_vars.
-        - Additional buttons allow running the simulation and configuring voltage clamp settings.
         """
         # Widgets setup (Sliders)
-        freqs = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 20, 50, 100, 200]
+        freqs = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 35, 50, 100, 200]
         delays = [125, 250, 500, 1000, 2000, 4000]
         durations = [300, 500, 1000, 2000, 5000, 10000]
         freq0 = 50
@@ -602,19 +607,17 @@ class SynapseTuner:
             self.input_mode = w_input_mode.value
             # Update synaptic properties based on slider values
             syn_props = {var: slider.value for var, slider in dynamic_sliders.items()}
-            self.set_syn_prop(**syn_props)
+            self._set_syn_prop(**syn_props)
             if self.input_mode == False:
-                self.simulate_model(w_input_freq.value, self.w_delay.value, w_vclamp.value)
+                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)
-            self.plot_model([self.general_settings['tstart'] - self.nstim.interval / 3, self.tstop])
-            amp = self.response_amplitude()
-            induction_single, recovery, maxamp = self.induction_recovery(amp)
-            ppr = self.paired_pulse_ratio()
-            print('Paired Pulse Ratio using ' + ('PSC' if self.vclamp else 'PSP') + f': {ppr:.3f}')
-            print('Single trial ' + ('PSC' if self.vclamp else 'PSP'))
-            print(f'Induction: {induction_single:.2f}; Recovery: {recovery:.2f}')
-            print(f'Rest Amp: {amp[0]:.2f}; Maximum Amp: {maxamp:.2f}')
+                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._print_ppr_induction_recovery(amp)
+            # print('Single trial ' + ('PSC' if self.vclamp else 'PSP'))
+            # print(f'Induction: {induction_single:.2f}; Recovery: {recovery:.2f}')
+            #print(f'Rest Amp: {amp[0]:.2f}; Maximum Amp: {maxamp:.2f}')
 
         # Function to switch between delay and duration sliders
         def switch_slider(*args):
@@ -628,7 +631,7 @@ class SynapseTuner:
         # Link input mode to slider switch
         w_input_mode.observe(switch_slider, names='value')
 
-        # Hide the duration slider initially
+        # Hide the duration slider initially until the user selects it
         self.w_duration.layout.display = 'none'  # Hide duration slider
 
         w_run.on_click(update_ui)
@@ -647,6 +650,8 @@ class SynapseTuner:
         ui = VBox([HBox([w_run, w_vclamp, w_input_mode]), HBox([w_input_freq, self.w_delay, self.w_duration]), slider_columns])
 
         display(ui)
+        # run model with default parameters 
+        update_ui()
 
 
     

{bmtool-0.6.0 → bmtool-0.6.2}/bmtool.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: bmtool
-Version: 0.6.0
+Version: 0.6.2
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 

{bmtool-0.6.0 → bmtool-0.6.2}/setup.py

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