bmtool 0.6.3__py3-none-any.whl → 0.6.5__py3-none-any.whl

bmtool/connectors.py

@@ -1082,7 +1082,7 @@ class ReciprocalConnector(AbstractConnector):
 
 class UnidirectionConnector(AbstractConnector):
     """
-    Object for buiilding unidirectional connections in bmtk network model with
+    Object for building unidirectional connections in bmtk network model with
     given probability within a single population (or between two populations).
 
     Parameters:

bmtool/singlecell.py

@@ -7,6 +7,7 @@ import matplotlib.pyplot as plt
 from scipy.optimize import curve_fit
 import neuron
 from neuron import h
+import pandas as pd
 
 
 def load_biophys1():
@@ -356,8 +357,12 @@ class FI(object):
         self.nspks = [len(v) for v in self.tspk_vecs]
         print()
         print("Results")
-        print(f'Injection (nA): ' + ', '.join(f'{x:g}' for x in self.amps))
-        print(f'Number of spikes: ' + ', '.join(f'{x:d}' for x in self.nspks))
+        # lets make a df so the results line up nice
+        data = {'Injection (nA):':self.amps,'number of spikes':self.nspks}
+        df = pd.DataFrame(data)
+        print(df)
+        #print(f'Injection (nA): ' + ', '.join(f'{x:g}' for x in self.amps))
+        #print(f'Number of spikes: ' + ', '.join(f'{x:d}' for x in self.nspks))
         print()
 
         return self.amps, self.nspks

bmtool/synapses.py

@@ -1,13 +1,17 @@
 import os
 import json
-import numpy as np
 import neuron
+import numpy as np
 from neuron import h
-from neuron.units import ms, mV
+from typing import List, Dict, Callable, Optional,Tuple
+from tqdm.notebook import tqdm
 import matplotlib.pyplot as plt
+from neuron.units import ms, mV
+from dataclasses import dataclass
+# scipy
 from scipy.signal import find_peaks
-from scipy.optimize import curve_fit
-
+from scipy.optimize import curve_fit,minimize_scalar,minimize
+# widgets
 import ipywidgets as widgets
 from IPython.display import display, clear_output
 from ipywidgets import HBox, VBox
@@ -174,6 +178,11 @@ class SynapseTuner:
         """
         self._set_up_cell()
         self._set_up_synapse()
+        
+        # user slider values if the sliders are set up
+        if hasattr(self, 'dynamic_sliders'):
+            syn_props = {var: slider.value for var, slider in self.dynamic_sliders.items()}
+            self._set_syn_prop(**syn_props)
 
         # Set up the stimulus
         self.nstim = h.NetStim()
@@ -200,10 +209,17 @@ class SynapseTuner:
         self.nstim.number = 1
         self.nstim2.start = h.tstop
         h.run()
+        
+        current = np.array(self.rec_vectors[self.current_name])
+        syn_prop = self._get_syn_prop(short=True)
+        current = (current - syn_prop['baseline']) * 1000  # Convert to pA
+        current_integral = np.trapz(current, dx=h.dt)  # pA·ms
+        
         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)
+        print(f'Current Integral in pA: {current_integral:.2f}')
 
 
     def _find_first(self, x):
@@ -319,10 +335,14 @@ class SynapseTuner:
         axs = axs.ravel()
         
         # Plot synaptic current (always included)
-        axs[0].plot(self.t, 1000 * self.rec_vectors[self.current_name])
+        current = self.rec_vectors[self.current_name]
+        syn_prop = self._get_syn_prop(short=True)
+        current = (current - syn_prop['baseline']) 
+        current = current * 1000
+        
+        axs[0].plot(self.t, current)
         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)')
@@ -407,7 +427,7 @@ class SynapseTuner:
             A list containing the peak amplitudes for each segment of the recorded synaptic current.
         
         """
-        isyn = np.asarray(self.rec_vectors['i'])
+        isyn = np.array(self.rec_vectors[self.current_name].to_python())
         tspk = np.append(np.asarray(self.tspk), h.tstop)
         syn_prop = self._get_syn_prop(short=True)
         # print("syn_prp[sign] = " + str(syn_prop['sign']))
@@ -415,6 +435,7 @@ class SynapseTuner:
         isyn *= syn_prop['sign']
         ispk = np.floor((tspk + self.general_settings['delay']) / h.dt).astype(int)
 
+        
         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     
@@ -423,34 +444,32 @@ class SynapseTuner:
         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):
         """
-        Determines the maximum amplitude from the response data.
+        Determines the maximum amplitude from the response data and returns the max in pA
 
         Parameters:
         -----------
         amp : array-like
             Array containing the amplitudes of synaptic responses.
-        normalize_by_trial : bool, optional
-            If True, normalize the maximum amplitude within each trial. Default is True.
         
         Returns:
         --------
         max_amp : float
             The maximum or minimum amplitude based on the sign of the response.
         """
-        max_amp = amp.max(axis=1 if normalize_by_trial else None)
-        min_amp = amp.min(axis=1 if normalize_by_trial else None)
+        max_amp = max(amp)
+        min_amp = min(amp)
         if(abs(min_amp) > max_amp):
-            return min_amp
-        return max_amp
+            return min_amp * 1000 # scale unit
+        return max_amp * 1000 # scale unit
 
 
-    def _print_ppr_induction_recovery(self,amp, normalize_by_trial=True):
+    def _calc_ppr_induction_recovery(self,amp, normalize_by_trial=True,print_math=True):
         """
         Calculates induction and recovery metrics from the synaptic response amplitudes.
 
@@ -471,46 +490,51 @@ class SynapseTuner:
             The maximum amplitude in the response.
         """
         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)
 
-        # 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()])
+            """Format an array to 2 significant figures for cleaner output."""
+            return np.array2string(arr, precision=2, separator=', ', suppress_small=True)
         
-        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("")
-        
-        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("")
+        if print_math:
+            print("\n" + "="*40)
+            print("Short Term Plasticity Results")
+            print("="*40)
+            print("PPR: Above 1 is facilitating, below 1 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]
+            print("Paired Pulse Response (PPR)")
+            print("Calculation: 2nd pulse / 1st pulse")
+            print(f"Values: ({format_array(amp[:, 1:2])}) / ({format_array(amp[:, 0:1])}) = {format_array(ppr)}\n")
+
+            # Induction Calculation
+            induction = np.mean((amp[:, 5:8].mean(axis=1) - amp[:, :1].mean(axis=1)) / maxamp)
+            print("Induction")
+            print("Calculation: (avg(6th, 7th, 8th pulses) - 1st pulse) / max amps")
+            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")
+
+            # Recovery Calculation
+            recovery = np.mean((amp[:, 8:12].mean(axis=1) - amp[:, :4].mean(axis=1)) / maxamp)
+            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)}")
+            print(f"({format_array(amp[:, 8:12].mean(axis=1))}) - ({format_array(amp[:, :4].mean(axis=1))}) / {format_array(maxamp)} = {recovery:.3f}\n")
+
+            print("="*40 + "\n")
 
         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("")
-
-        
+        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()
-        #return induction, recovery, maxamp
+        
+        return ppr, induction, recovery
 
 
     def _set_syn_prop(self, **kwargs):
@@ -575,17 +599,19 @@ class SynapseTuner:
         duration0 = 300
         vlamp_status = self.vclamp
 
-        w_run = widgets.Button(description='Run', icon='history', button_style='primary')
+        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(value=vlamp_status, description='Voltage Clamp', icon='fast-backward', button_style='warning')
         w_input_mode = widgets.ToggleButton(value=False, description='Continuous input', icon='eject', button_style='info')
         w_input_freq = widgets.SelectionSlider(options=freqs, value=freq0, description='Input Freq')
 
+
         # Sliders for delay and duration
         self.w_delay = widgets.SelectionSlider(options=delays, value=delay0, description='Delay')
         self.w_duration = widgets.SelectionSlider(options=durations, value=duration0, description='Duration')
 
         # Generate sliders dynamically based on valid numeric entries in self.slider_vars
-        dynamic_sliders = {}
+        self.dynamic_sliders = {}
         print("Setting up slider! The sliders ranges are set by their init value so try changing that if you dont like the slider range!")
         for key, value in self.slider_vars.items():
             if isinstance(value, (int, float)):  # Only create sliders for numeric values
@@ -595,18 +621,25 @@ class SynapseTuner:
                         slider = widgets.FloatSlider(value=value, min=0, max=1000, step=1, description=key)
                     else:
                         slider = widgets.FloatSlider(value=value, min=0, max=value*20, step=value/5, description=key)
-                    dynamic_sliders[key] = slider
+                    self.dynamic_sliders[key] = slider
                 else:
                     print(f"skipping slider for {key} due to not being a synaptic variable")
 
+        def run_single_event(*args):
+            clear_output()
+            display(ui)
+            self.vclamp = w_vclamp.value
+            # Update synaptic properties based on slider values
+            self.ispk=None
+            self.SingleEvent()
+
         # Function to update UI based on input mode
         def update_ui(*args):
             clear_output()
             display(ui)
             self.vclamp = w_vclamp.value
             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()}
+            syn_props = {var: slider.value for var, slider in self.dynamic_sliders.items()}
             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)
@@ -614,10 +647,7 @@ class SynapseTuner:
                 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}')
+            _ = self._calc_ppr_induction_recovery(amp)
 
         # Function to switch between delay and duration sliders
         def switch_slider(*args):
@@ -634,23 +664,23 @@ class SynapseTuner:
         # Hide the duration slider initially until the user selects it
         self.w_duration.layout.display = 'none'  # Hide duration slider
 
+        w_single.on_click(run_single_event)
         w_run.on_click(update_ui)
 
         # Add the dynamic sliders to the UI
-        slider_widgets = [slider for slider in dynamic_sliders.values()]
+        slider_widgets = [slider for slider in self.dynamic_sliders.values()]
 
-        # Divide sliders into two columns
-        half = len(slider_widgets) // 2
-        col1 = VBox(slider_widgets[:half])  # First half of sliders
-        col2 = VBox(slider_widgets[half:])  # Second half of sliders
+        button_row = HBox([w_run, w_single, w_vclamp, w_input_mode])
+        slider_row = HBox([w_input_freq, self.w_delay, self.w_duration])
         
-        # Create a two-column layout with HBox
+        half = len(slider_widgets) // 2
+        col1 = VBox(slider_widgets[:half])
+        col2 = VBox(slider_widgets[half:])
         slider_columns = HBox([col1, col2])
 
-        ui = VBox([HBox([w_run, w_vclamp, w_input_mode]), HBox([w_input_freq, self.w_delay, self.w_duration]), slider_columns])
+        ui = VBox([button_row, slider_row, slider_columns])
 
         display(ui)
-        # run model with default parameters 
         update_ui()
 
 class GapJunctionTuner:
@@ -738,7 +768,7 @@ class GapJunctionTuner:
         return (v2[idx2] - v2[idx1]) / (v1[idx2] - v1[idx1])
 
     
-    def run_model(self):
+    def InteractiveTuner(self):
         w_run = widgets.Button(description='Run', icon='history', button_style='primary')
         values = [i * 10**-4 for i in range(1, 101)]  # From 1e-4 to 1e-2
 
@@ -762,4 +792,402 @@ class GapJunctionTuner:
             print(f"coupling_coefficient is {cc:0.4f}")
 
         on_button()    
-        w_run.on_click(on_button)
+        w_run.on_click(on_button)
+        
+        
+# optimizers!       
+        
+@dataclass
+class SynapseOptimizationResult:
+    """Container for synaptic parameter optimization results"""
+    optimal_params: Dict[str, float]
+    achieved_metrics: Dict[str, float]
+    target_metrics: Dict[str, float]
+    error: float
+    optimization_path: List[Dict[str, float]]
+
+class SynapseOptimizer:
+    def __init__(self, tuner):
+        """
+        Initialize the synapse optimizer with parameter scaling
+        
+        Parameters:
+        -----------
+        tuner : SynapseTuner
+            Instance of the SynapseTuner class
+        """
+        self.tuner = tuner
+        self.optimization_history = []
+        self.param_scales = {}
+        
+    def _normalize_params(self, params: np.ndarray, param_names: List[str]) -> np.ndarray:
+        """Normalize parameters to similar scales"""
+        return np.array([params[i] / self.param_scales[name] for i, name in enumerate(param_names)])
+        
+    def _denormalize_params(self, normalized_params: np.ndarray, param_names: List[str]) -> np.ndarray:
+        """Convert normalized parameters back to original scale"""
+        return np.array([normalized_params[i] * self.param_scales[name] for i, name in enumerate(param_names)])
+        
+    def _calculate_metrics(self) -> Dict[str, float]:
+        """Calculate standard metrics from the current simulation"""
+        self.tuner._simulate_model(50, 250) # 50 Hz with 250ms Delay
+        amp = self.tuner._response_amplitude()
+        ppr, induction, recovery = self.tuner._calc_ppr_induction_recovery(amp, print_math=False)
+        amp = self.tuner._find_max_amp(amp)
+        return {
+            'induction': float(induction),  # Ensure these are scalar values
+            'ppr': float(ppr),
+            'recovery': float(recovery),
+            'max_amplitude': float(amp)
+        }
+        
+    def _default_cost_function(self, metrics: Dict[str, float], target_metrics: Dict[str, float]) -> float:
+        """Default cost function that targets induction"""
+        return float((metrics['induction'] - target_metrics['induction']) ** 2)
+        
+    def _objective_function(self, 
+                          normalized_params: np.ndarray, 
+                          param_names: List[str], 
+                          cost_function: Callable,
+                          target_metrics: Dict[str, float]) -> float:
+        """
+        Calculate error using provided cost function
+        """
+        # Denormalize parameters
+        params = self._denormalize_params(normalized_params, param_names)
+        
+        # Set parameters
+        for name, value in zip(param_names, params):
+            setattr(self.tuner.syn, name, value)
+        
+        # Calculate metrics and error
+        metrics = self._calculate_metrics()
+        error = float(cost_function(metrics, target_metrics))  # Ensure error is scalar
+        
+        # Store history with denormalized values
+        history_entry = {
+            'params': dict(zip(param_names, params)),
+            'metrics': metrics,
+            'error': error
+        }
+        self.optimization_history.append(history_entry)
+        
+        return error
+    
+    def optimize_parameters(self, 
+                          target_metrics: Dict[str, float],
+                          param_bounds: Dict[str, Tuple[float, float]],
+                          cost_function: Optional[Callable] = None,
+                          method: str = 'SLSQP',init_guess='random') -> SynapseOptimizationResult:
+        """
+        Optimize synaptic parameters using custom cost function
+        """
+        self.optimization_history = []
+        param_names = list(param_bounds.keys())
+        bounds = [param_bounds[name] for name in param_names]
+        
+        if cost_function is None:
+            cost_function = self._default_cost_function
+        
+        # Calculate scaling factors
+        self.param_scales = {
+            name: max(abs(bounds[i][0]), abs(bounds[i][1]))
+            for i, name in enumerate(param_names)
+        }
+        
+        # Normalize bounds
+        normalized_bounds = [
+            (b[0]/self.param_scales[name], b[1]/self.param_scales[name])
+            for name, b in zip(param_names, bounds)
+        ]
+        
+        # picks with method of init value we want to use
+        if init_guess=='random':
+            x0 = np.array([np.random.uniform(b[0], b[1]) for b in bounds])
+        elif init_guess=='middle_guess':
+            x0 = [(b[0] + b[1])/2 for b in bounds]
+        else:
+            raise Exception("Pick a vaid init guess method either random or midde_guess")
+        normalized_x0 = self._normalize_params(np.array(x0), param_names)
+        
+        
+        # Run optimization
+        result = minimize(
+            self._objective_function,
+            normalized_x0,
+            args=(param_names, cost_function, target_metrics),
+            method=method,
+            bounds=normalized_bounds
+        )
+        
+        # Get final parameters and metrics
+        final_params = dict(zip(param_names, self._denormalize_params(result.x, param_names)))
+        for name, value in final_params.items():
+            setattr(self.tuner.syn, name, value)
+        final_metrics = self._calculate_metrics()
+        
+        return SynapseOptimizationResult(
+            optimal_params=final_params,
+            achieved_metrics=final_metrics,
+            target_metrics=target_metrics,
+            error=result.fun,
+            optimization_path=self.optimization_history
+        )
+    
+    def plot_optimization_results(self, result: SynapseOptimizationResult):
+        """Plot optimization results including convergence and final traces."""
+        # Ensure errors are properly shaped for plotting
+        iterations = range(len(result.optimization_path))
+        errors = np.array([float(h['error']) for h in result.optimization_path]).flatten()
+        
+        # Plot error convergence
+        fig1, ax1 = plt.subplots(figsize=(8, 5))
+        ax1.plot(iterations, errors, label='Error')
+        ax1.set_xlabel('Iteration')
+        ax1.set_ylabel('Error')
+        ax1.set_title('Error Convergence')
+        ax1.set_yscale('log')
+        ax1.legend()
+        plt.tight_layout()
+        plt.show()
+        
+        # Plot parameter convergence
+        param_names = list(result.optimal_params.keys())
+        num_params = len(param_names)
+        fig2, axs = plt.subplots(nrows=num_params, ncols=1, figsize=(8, 5 * num_params))
+        
+        if num_params == 1:
+            axs = [axs]
+            
+        for ax, param in zip(axs, param_names):
+            values = [float(h['params'][param]) for h in result.optimization_path]
+            ax.plot(iterations, values, label=f'{param}')
+            ax.set_xlabel('Iteration')
+            ax.set_ylabel('Parameter Value')
+            ax.set_title(f'Convergence of {param}')
+            ax.legend()
+        
+        plt.tight_layout()
+        plt.show()
+        
+        # Print final results
+        print("Optimization Results:")
+        print(f"Final Error: {float(result.error):.2e}\n")
+        print("Target Metrics:")
+        for metric, value in result.target_metrics.items():
+            achieved = result.achieved_metrics.get(metric)
+            if achieved is not None and metric != 'amplitudes':  # Skip amplitude array
+                print(f"{metric}: {float(achieved):.3f} (target: {float(value):.3f})")
+        
+        print("\nOptimal Parameters:")
+        for param, value in result.optimal_params.items():
+            print(f"{param}: {float(value):.3f}")
+        
+        # Plot final model response
+        self.tuner._plot_model([self.tuner.general_settings['tstart'] - self.tuner.nstim.interval / 3, self.tuner.tstop])
+        amp = self.tuner._response_amplitude()
+        self.tuner._calc_ppr_induction_recovery(amp)        
+        
+        
+# dataclass means just init the typehints as self.typehint. looks a bit cleaner
+@dataclass
+class GapOptimizationResult:
+    """Container for gap junction optimization results"""
+    optimal_resistance: float
+    achieved_cc: float
+    target_cc: float
+    error: float
+    optimization_path: List[Dict[str, float]]
+
+class GapJunctionOptimizer:
+    def __init__(self, tuner):
+        """
+        Initialize the gap junction optimizer
+        
+        Parameters:
+        -----------
+        tuner : GapJunctionTuner
+            Instance of the GapJunctionTuner class
+        """
+        self.tuner = tuner
+        self.optimization_history = []
+        
+    def _objective_function(self, resistance: float, target_cc: float) -> float:
+        """
+        Calculate error between achieved and target coupling coefficient
+        
+        Parameters:
+        -----------
+        resistance : float
+            Gap junction resistance to try
+        target_cc : float
+            Target coupling coefficient to match
+            
+        Returns:
+        --------
+        float : Error between achieved and target coupling coefficient
+        """
+        # Run model with current resistance
+        self.tuner.model(resistance)
+        
+        # Calculate coupling coefficient
+        achieved_cc = self.tuner.coupling_coefficient(
+            self.tuner.t_vec, 
+            self.tuner.soma_v_1, 
+            self.tuner.soma_v_2,
+            self.tuner.general_settings['tstart'],
+            self.tuner.general_settings['tstart'] + self.tuner.general_settings['tdur']
+        )
+        
+        # Calculate error
+        error = (achieved_cc - target_cc) ** 2 #MSE
+        
+        # Store history
+        self.optimization_history.append({
+            'resistance': resistance,
+            'achieved_cc': achieved_cc,
+            'error': error
+        })
+        
+        return error
+    
+    def optimize_resistance(self, target_cc: float, 
+                          resistance_bounds: tuple = (1e-4, 1e-2),
+                          method: str = 'bounded') -> GapOptimizationResult:
+        """
+        Optimize gap junction resistance to achieve target coupling coefficient
+        
+        Parameters:
+        -----------
+        target_cc : float
+            Target coupling coefficient to achieve
+        resistance_bounds : tuple, optional
+            (min, max) bounds for resistance search
+        method : str, optional
+            Optimization method to use (default: 'bounded')
+            
+        Returns:
+        --------
+        GapOptimizationResult
+            Container with optimization results
+        """
+        self.optimization_history = []
+        
+        # Run optimization
+        result = minimize_scalar(
+            self._objective_function,
+            args=(target_cc,),
+            bounds=resistance_bounds,
+            method=method
+        )
+        
+        # Run final model with optimal resistance
+        self.tuner.model(result.x)
+        final_cc = self.tuner.coupling_coefficient(
+            self.tuner.t_vec,
+            self.tuner.soma_v_1,
+            self.tuner.soma_v_2,
+            self.tuner.general_settings['tstart'],
+            self.tuner.general_settings['tstart'] + self.tuner.general_settings['tdur']
+        )
+        
+        # Package up our results
+        optimization_result = GapOptimizationResult(
+            optimal_resistance=result.x,
+            achieved_cc=final_cc,
+            target_cc=target_cc,
+            error=result.fun,
+            optimization_path=self.optimization_history
+        )
+        
+        return optimization_result
+    
+    def plot_optimization_results(self, result: GapOptimizationResult):
+        """
+        Plot optimization results including convergence and final voltage traces
+        
+        Parameters:
+        -----------
+        result : GapOptimizationResult
+            Results from optimization
+        """
+        fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(15, 10))
+        
+        # Plot voltage traces
+        t_range = [
+            self.tuner.general_settings['tstart'] - 100.,
+            self.tuner.general_settings['tstart'] + self.tuner.general_settings['tdur'] + 100.
+        ]
+        t = np.array(self.tuner.t_vec)
+        v1 = np.array(self.tuner.soma_v_1)
+        v2 = np.array(self.tuner.soma_v_2)
+        tidx = (t >= t_range[0]) & (t <= t_range[1])
+        
+        ax1.plot(t[tidx], v1[tidx], 'b', label=f'{self.tuner.cell_name} 1')
+        ax1.plot(t[tidx], v2[tidx], 'r', label=f'{self.tuner.cell_name} 2')
+        ax1.set_xlabel('Time (ms)')
+        ax1.set_ylabel('Membrane Voltage (mV)')
+        ax1.legend()
+        ax1.set_title('Optimized Voltage Traces')
+        
+        # Plot error convergence
+        errors = [h['error'] for h in result.optimization_path]
+        ax2.plot(errors)
+        ax2.set_xlabel('Iteration')
+        ax2.set_ylabel('Error')
+        ax2.set_title('Error Convergence')
+        ax2.set_yscale('log')
+        
+        # Plot resistance convergence
+        resistances = [h['resistance'] for h in result.optimization_path]
+        ax3.plot(resistances)
+        ax3.set_xlabel('Iteration')
+        ax3.set_ylabel('Resistance')
+        ax3.set_title('Resistance Convergence')
+        ax3.set_yscale('log')
+        
+        # Print final results
+        result_text = (
+            f'Optimal Resistance: {result.optimal_resistance:.2e}\n'
+            f'Target CC: {result.target_cc:.3f}\n'
+            f'Achieved CC: {result.achieved_cc:.3f}\n'
+            f'Final Error: {result.error:.2e}'
+        )
+        ax4.text(0.1, 0.7, result_text, transform=ax4.transAxes, fontsize=10)
+        ax4.axis('off')
+        
+        plt.tight_layout()
+        plt.show()
+
+    def parameter_sweep(self, resistance_range: np.ndarray) -> dict:
+        """
+        Perform a parameter sweep across different resistance values
+        
+        Parameters:
+        -----------
+        resistance_range : np.ndarray
+            Array of resistance values to test
+            
+        Returns:
+        --------
+        dict : Results of parameter sweep including coupling coefficients
+        """
+        results = {
+            'resistance': [],
+            'coupling_coefficient': []
+        }
+        
+        for resistance in tqdm(resistance_range, desc="Sweeping resistance values"):
+            self.tuner.model(resistance)
+            cc = self.tuner.coupling_coefficient(
+                self.tuner.t_vec,
+                self.tuner.soma_v_1,
+                self.tuner.soma_v_2,
+                self.tuner.general_settings['tstart'],
+                self.tuner.general_settings['tstart'] + self.tuner.general_settings['tdur']
+            )
+            
+            results['resistance'].append(resistance)
+            results['coupling_coefficient'].append(cc)
+            
+        return results

{bmtool-0.6.3.dist-info → bmtool-0.6.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: bmtool
-Version: 0.6.3
+Version: 0.6.5
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 
@@ -114,7 +114,9 @@ Commands:
 - [ZAP](#zap)
 - [Tuner](#single-cell-tuning)
 - [VHalf Segregation](#vhalf-segregation-module)
-#### The single cell module can take any neuron HOC object and calculate passive properties, run a current clamp, calculate FI curve, or run a ZAP. The module is designed to work with HOC template files and can also turn Allen database SWC and json files into HOC objects and use those. The examples below uses "Cell_Cf" which is the name of a HOC templated loaded by the profiler.
+#### Jupyter Notebook for how to use passive properties, current injection, FI curve, and ZAP can be found [here](examples/single_cell/). There are versions with example how to use single cells in HOC format and in the Allen Database format. 
+
+#### The single cell module can take any neuron HOC object and calculate passive properties, run a current clamp, calculate FI curve, or run a ZAP. The module is designed to work with HOC template files and can also turn Allen database SWC and json files into HOC objects and use those. The examples below uses "Cell_Cf" which is the name of a HOC templated loaded by the profiler. E
 
 #### First step is it initialize the profiler.
 
@@ -351,7 +353,7 @@ ex: [https://github.com/tjbanks/two-cell-hco](https://github.com/tjbanks/two-cel
 -Gap Junction tuner
 
 #### SynapticTuner - Aids in the tuning of synapses by printing out synaptic properties and giving the user sliders in a Jupyter notebook to tune the synapse. For more info view the example [here](examples/synapses/synaptic_tuner.ipynb)
-#### GapJunctionTuner - Provides jupyter sliders to tune for coupling coefficient in a similar style to the SynapticTuner an example can be viewed [here](examples/synapses/gap_junction_tuner.ipynb)
+#### GapJunctionTuner - Provides jupyter sliders to tune for coupling coefficient in a similar style to the SynapticTuner. The Gap junction tuner also has an optimizer which can find the best resistance for the desired coupling coefficient. an example can be viewed [here](examples/synapses/gap_junction_tuner.ipynb)
 
 ### Connectors Module
 - [UnidirectionConnector](#unidirectional-connector---unidirectional-connections-in-bmtk-network-model-with-given-probability-within-a-single-population-or-between-two-populations)
@@ -409,7 +411,6 @@ net.add_edges(**connector.edge_params())
 ```
 
 ## Bmplot Module 
-### for a demo please see the notebook [here](examples/bmplot/bmplot.ipynb) 
 - [total_connection_matrix](#total_connection_matrix)
 - [percent_connection_matrix](#percent_connection_matrix)
 - [connector_percent_matrix](#connector_percent_matrix)
@@ -420,6 +421,7 @@ net.add_edges(**connector.edge_params())
 - [connection_histogram](#connection_histogram)
 - [plot_3d_positions](#plot_3d_positions)
 - [plot_3d_cell_rotation](#plot_3d_cell_rotation)
+### for a demo please see the notebook [here](examples/bmplot/bmplot.ipynb) 
 
 ### total_connection_matrix
 #### Generates a table of total number of connections each neuron population recieves

{bmtool-0.6.3.dist-info → bmtool-0.6.5.dist-info}/RECORD

@@ -2,12 +2,12 @@ bmtool/SLURM.py,sha256=4KvtrPofaHv5iairetgrlXdhAdowJfg_aeTx9W59JDM,16618
 bmtool/__init__.py,sha256=ZStTNkAJHJxG7Pwiy5UgCzC4KlhMS5pUNPtUJZVwL_Y,136
 bmtool/__main__.py,sha256=TmFkmDxjZ6250nYD4cgGhn-tbJeEm0u-EMz2ajAN9vE,650
 bmtool/bmplot.py,sha256=Im-Jrv8TK3CmTtksFzHrVogAve0l9ZwRrCW4q2MFRiA,53966
-bmtool/connectors.py,sha256=2vVUsqYMaCuWZ-4C5eUzqwsFItFM9vm0ytZdRQdWgoc,72243
+bmtool/connectors.py,sha256=hWkUUcJ4tmas8NDOFPPjQT-TgTlPcpjuZsYyAW2WkPA,72242
 bmtool/graphs.py,sha256=K8BiughRUeXFVvAgo8UzrwpSClIVg7UfmIcvtEsEsk0,6020
 bmtool/manage.py,sha256=_lCU0qBQZ4jSxjzAJUd09JEetb--cud7KZgxQFbLGSY,657
 bmtool/plot_commands.py,sha256=Tqujyf0c0u8olhiHOMwgUSJXIIE1hgjv6otb25G9cA0,12298
-bmtool/singlecell.py,sha256=Q4poQvG9fw0jlyMmHFzbRPrpcEkPz5MKS8Guuo73Bzs,26849
-bmtool/synapses.py,sha256=xNq2ln9XRf5CZa6dZ_dabPTDrrufQTiVVoYYeqQmDN4,32597
+bmtool/singlecell.py,sha256=MQiLucsI6OBIjtcJra3Z9PTFQOE-Zn5ST-R9SmFvrbQ,27049
+bmtool/synapses.py,sha256=jQFOpi9hzzBEijDQ7dsWfcxW-DtxN9v0UWxCqDSlcTs,48466
 bmtool/debug/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmtool/debug/commands.py,sha256=AwtcR7BUUheM0NxvU1Nu234zCdpobhJv5noX8x5K2vY,583
 bmtool/debug/debug.py,sha256=xqnkzLiH3s-tS26Y5lZZL62qR2evJdi46Gud-HzxEN4,207
@@ -16,9 +16,9 @@ bmtool/util/commands.py,sha256=zJF-fiLk0b8LyzHDfvewUyS7iumOxVnj33IkJDzux4M,64396
 bmtool/util/util.py,sha256=00vOAwTVIifCqouBoFoT0lBashl4fCalrk8fhg_Uq4c,56654
 bmtool/util/neuron/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 bmtool/util/neuron/celltuner.py,sha256=xSRpRN6DhPFz4q5buq_W8UmsD7BbUrkzYBEbKVloYss,87194
-bmtool-0.6.3.dist-info/LICENSE,sha256=qrXg2jj6kz5d0EnN11hllcQt2fcWVNumx0xNbV05nyM,1068
-bmtool-0.6.3.dist-info/METADATA,sha256=tQ9eD3BcEnX6hwKmJ92Syr2OO8cR47KolGIcWud1-TM,19859
-bmtool-0.6.3.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-bmtool-0.6.3.dist-info/entry_points.txt,sha256=0-BHZ6nUnh0twWw9SXNTiRmKjDnb1VO2DfG_-oprhAc,45
-bmtool-0.6.3.dist-info/top_level.txt,sha256=gpd2Sj-L9tWbuJEd5E8C8S8XkNm5yUE76klUYcM-eWM,7
-bmtool-0.6.3.dist-info/RECORD,,
+bmtool-0.6.5.dist-info/LICENSE,sha256=qrXg2jj6kz5d0EnN11hllcQt2fcWVNumx0xNbV05nyM,1068
+bmtool-0.6.5.dist-info/METADATA,sha256=-67VVvOyPqiGX7qoidn8SLVHuHRxSZnOIPKPxqZ8TNI,20224
+bmtool-0.6.5.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+bmtool-0.6.5.dist-info/entry_points.txt,sha256=0-BHZ6nUnh0twWw9SXNTiRmKjDnb1VO2DfG_-oprhAc,45
+bmtool-0.6.5.dist-info/top_level.txt,sha256=gpd2Sj-L9tWbuJEd5E8C8S8XkNm5yUE76klUYcM-eWM,7
+bmtool-0.6.5.dist-info/RECORD,,