bmtool 0.7.7__py3-none-any.whl → 0.7.8.1__py3-none-any.whl

bmtool/synapses.py

@@ -173,6 +173,7 @@ class SynapseTuner:
         self.other_vars_to_record = other_vars_to_record or []
         self.ispk = None
         self.input_mode = False  # Add input_mode attribute
+        self.last_figure = None  # Store reference to last generated figure
 
         # Store original slider_vars for connection switching
         self.original_slider_vars = slider_vars or list(self.synaptic_props.keys())
@@ -1045,7 +1046,9 @@ class SynapseTuner:
             for j in range(num_vars_to_plot, len(axs)):
                 fig.delaxes(axs[j])
 
-        # plt.tight_layout()
+        #plt.tight_layout()
+        fig.suptitle(f"Connection: {self.current_connection}")
+        self.last_figure = plt.gcf()
         plt.show()
 
     def _set_drive_train(self, freq=50.0, delay=250.0):
@@ -1148,7 +1151,7 @@ class SynapseTuner:
 
     def _calc_ppr_induction_recovery(self, amp, normalize_by_trial=True, print_math=True):
         """
-        Calculates paired-pulse ratio, induction, and recovery metrics from response amplitudes.
+        Calculates paired-pulse ratio, induction, recovery, and simple PPR metrics from response amplitudes.
 
         Parameters:
         -----------
@@ -1163,13 +1166,15 @@ class SynapseTuner:
         --------
         tuple
             A tuple containing:
-            - ppr: Paired-pulse ratio (2nd pulse / 1st pulse)
+            - ppr: Paired-pulse ratio (2nd pulse - 1st pulse) normalized by 90th percentile amplitude
             - induction: Measure of facilitation/depression during initial pulses
             - recovery: Measure of recovery after the delay period
+            - simple_ppr: Simple paired-pulse ratio (2nd pulse / 1st pulse)
 
         Notes:
         ------
-        - PPR > 1 indicates facilitation, PPR < 1 indicates depression
+        - PPR > 0 indicates facilitation, PPR < 0 indicates depression
+        - Simple PPR > 1 indicates facilitation, Simple PPR < 1 indicates depression
         - Induction > 0 indicates facilitation, Induction < 0 indicates depression
         - Recovery compares the response after delay to the initial pulses
         """
@@ -1190,34 +1195,44 @@ class SynapseTuner:
                 f"Short Term Plasticity Results for {self.train_freq}Hz with {self.train_delay} Delay"
             )
             print("=" * 40)
-            print("PPR: Above 0 is facilitating, below 0 is depressing.")
-            print("Induction: Above 0 is facilitating, below 0 is depressing.")
-            print("Recovery: A measure of how fast STP decays.\n")
+            print("Simple PPR: Above 1 is facilitating, below 1 is depressing")
+            print("PPR:        Above 0 is facilitating, below 0 is depressing.")
+            print("Induction:  Above 0 is facilitating, below 0 is depressing.")
+            print("Recovery:   A measure of how fast STP decays.\n")
+
+            # Simple PPR Calculation: Avg 2nd pulse / Avg 1st pulse
+            simple_ppr = np.mean(amp[:, 1:2]) / np.mean(amp[:, 0:1])
+            print("Simple Paired Pulse Ratio (PPR)")
+            print("    Calculation: Avg 2nd pulse / Avg 1st pulse")
+            print(
+                f"    Values: {np.mean(amp[:, 1:2]):.3f} / {np.mean(amp[:, 0:1]):.3f} = {simple_ppr:.3f}\n"
+            )
 
             # PPR Calculation: (Avg 2nd pulse - Avg 1st pulse) / 90th percentile amplitude
             ppr = (np.mean(amp[:, 1:2]) - np.mean(amp[:, 0:1])) / percentile_90
             print("Paired Pulse Response (PPR)")
-            print("Calculation: (Avg 2nd pulse - Avg 1st pulse) / 90th percentile amplitude")
+            print("    Calculation: (Avg 2nd pulse - Avg 1st pulse) / 90th percentile amplitude")
             print(
-                f"Values: ({np.mean(amp[:, 1:2]):.3f} - {np.mean(amp[:, 0:1]):.3f}) / {percentile_90:.3f} = {ppr:.3f}\n"
+                f"    Values: ({np.mean(amp[:, 1:2]):.3f} - {np.mean(amp[:, 0:1]):.3f}) / {percentile_90:.3f} = {ppr:.3f}\n"
             )
+            
 
             # Induction Calculation: (Avg (6th, 7th, 8th pulses) - Avg 1st pulse) / 90th percentile amplitude
             induction = (np.mean(amp[:, 5:8]) - np.mean(amp[:, :1])) / percentile_90
             print("Induction")
-            print("Calculation: (Avg(6th, 7th, 8th pulses) - Avg 1st pulse) / 90th percentile amplitude")
+            print("    Calculation: (Avg(6th, 7th, 8th pulses) - Avg 1st pulse) / 90th percentile amplitude")
             print(
-                f"Values: {np.mean(amp[:, 5:8]):.3f} - {np.mean(amp[:, :1]):.3f} / {percentile_90:.3f} = {induction:.3f}\n"
+                f"    Values: {np.mean(amp[:, 5:8]):.3f} - {np.mean(amp[:, :1]):.3f} / {percentile_90:.3f} = {induction:.3f}\n"
             )
 
             # Recovery Calculation: (Avg (9th, 10th, 11th, 12th pulses) - Avg (1st, 2nd, 3rd, 4th pulses)) / 90th percentile amplitude
             recovery = (np.mean(amp[:, 8:12]) - np.mean(amp[:, :4])) / percentile_90
             print("Recovery")
             print(
-                "Calculation: (Avg(9th, 10th, 11th, 12th pulses) - Avg(1st to 4th pulses)) / 90th percentile amplitude"
+                "    Calculation: (Avg(9th, 10th, 11th, 12th pulses) - Avg(1st to 4th pulses)) / 90th percentile amplitude"
             )
             print(
-                f"Values: {np.mean(amp[:, 8:12]):.3f} - {np.mean(amp[:, :4]):.3f} / {percentile_90:.3f} = {recovery:.3f}\n"
+                f"    Values: {np.mean(amp[:, 8:12]):.3f} - {np.mean(amp[:, :4]):.3f} / {percentile_90:.3f} = {recovery:.3f}\n"
             )
 
             print("=" * 40 + "\n")
@@ -1226,8 +1241,9 @@ class SynapseTuner:
         ppr = (np.mean(amp[:, 1:2]) - np.mean(amp[:, 0:1])) / percentile_90
         induction = (np.mean(amp[:, 5:8]) - np.mean(amp[:, :1])) / percentile_90
         recovery = (np.mean(amp[:, 8:12]) - np.mean(amp[:, :4])) / percentile_90
+        simple_ppr = np.mean(amp[:, 1:2]) / np.mean(amp[:, 0:1])
 
-        return ppr, induction, recovery
+        return ppr, induction, recovery, simple_ppr
 
     def _set_syn_prop(self, **kwargs):
         """
@@ -1268,19 +1284,19 @@ class SynapseTuner:
             for i in range(3):
                 self.vcl.amp[i] = self.conn["spec_settings"]["vclamp_amp"]
                 self.vcl.dur[i] = vcldur[1][i]
-            #h.finitialize(self.cell.Vinit * mV)
-            #h.continuerun(self.tstop * ms)
-            h.run()
+            h.finitialize(70 * mV)
+            h.continuerun(self.tstop * ms)
+            #h.run()
         else:
-            self.tstop = self.general_settings["tstart"] + self.general_settings["tdur"]
+            # Continuous input mode: ensure simulation runs long enough for the full stimulation duration
+            self.tstop = self.general_settings["tstart"] + self.w_duration.value + 300 # 300ms buffer time 
             self.nstim.interval = 1000 / input_frequency
             self.nstim.number = np.ceil(self.w_duration.value / 1000 * input_frequency + 1)
             self.nstim2.number = 0
-            self.tstop = self.w_duration.value + self.general_settings["tstart"]
 
-            #h.finitialize(self.cell.Vinit * mV)
-            #h.continuerun(self.tstop * ms)
-            h.run()
+            h.finitialize(70 * mV)
+            h.continuerun(self.tstop * ms)
+            #h.run()
 
     def InteractiveTuner(self):
         """
@@ -1375,6 +1391,52 @@ class SynapseTuner:
             options=durations, value=duration0, description="Duration"
         )
 
+        # Save functionality widgets
+        save_path_text = widgets.Text(
+            value="plot.png",
+            description="Save path:",
+            layout=widgets.Layout(width='300px')
+        )
+        save_button = widgets.Button(description="Save Plot", icon="save", button_style="success")
+
+        def save_plot(b):
+            if hasattr(self, 'last_figure') and self.last_figure is not None:
+                try:
+                    # Create a new figure with just the first subplot (synaptic current)
+                    fig, ax = plt.subplots(figsize=(8, 6))
+                    
+                    # Get the axes from the original figure
+                    original_axes = self.last_figure.get_axes()
+                    if len(original_axes) > 0:
+                        first_ax = original_axes[0]
+                        
+                        # Copy the data from the first subplot
+                        for line in first_ax.get_lines():
+                            ax.plot(line.get_xdata(), line.get_ydata(), 
+                                   color=line.get_color(), label=line.get_label())
+                        
+                        # Copy axis labels and title
+                        ax.set_xlabel(first_ax.get_xlabel())
+                        ax.set_ylabel(first_ax.get_ylabel())
+                        ax.set_title(first_ax.get_title())
+                        ax.set_xlim(first_ax.get_xlim())
+                        ax.legend()
+                        ax.grid(True)
+                        
+                        # Save the new figure
+                        fig.savefig(save_path_text.value)
+                        plt.close(fig)  # Close the temporary figure
+                        print(f"Synaptic current plot saved to {save_path_text.value}")
+                    else:
+                        print("No subplots found in the figure")
+                        
+                except Exception as e:
+                    print(f"Error saving plot: {e}")
+            else:
+                print("No plot to save")
+
+        save_button.on_click(save_plot)
+
         def create_dynamic_sliders():
             """Create sliders based on current connection's parameters"""
             sliders = {}
@@ -1453,7 +1515,7 @@ class SynapseTuner:
             the network dropdown. It coordinates the complete switching process:
             1. Calls _switch_network() to rebuild connections for the new network
             2. Updates the connection dropdown options with new network's connections
-            3. Recreates dynamic sliders for the new connection parameters
+            3. Recreates dynamic sliders for new connection parameters
             4. Refreshes the entire UI to reflect all changes
             """
             if w_network is None:
@@ -1515,8 +1577,9 @@ class SynapseTuner:
             else:
                 connection_row = HBox([w_connection])
             slider_row = HBox([w_input_freq, self.w_delay, self.w_duration])
+            save_row = HBox([save_path_text, save_button])
             
-            ui = VBox([connection_row, button_row, slider_row, slider_columns])
+            ui = VBox([connection_row, button_row, slider_row, slider_columns, save_row])
 
         # Function to update UI based on input mode
         def update_ui(*args):
@@ -1618,6 +1681,7 @@ class SynapseTuner:
             Dictionary containing frequency-dependent metrics with keys:
             - 'frequencies': List of tested frequencies
             - 'ppr': Paired-pulse ratios at each frequency
+            - 'simple_ppr': Simple paired-pulse ratios (2nd/1st pulse) at each frequency
             - 'induction': Induction values at each frequency
             - 'recovery': Recovery values at each frequency
 
@@ -1627,7 +1691,7 @@ class SynapseTuner:
         behavior of synapses, such as identifying facilitating vs. depressing regimes
         or the frequency at which a synapse transitions between these behaviors.
         """
-        results = {"frequencies": freqs, "ppr": [], "induction": [], "recovery": []}
+        results = {"frequencies": freqs, "ppr": [], "induction": [], "recovery": [], "simple_ppr": []}
 
         # Store original state
         original_ispk = self.ispk
@@ -1635,11 +1699,12 @@ class SynapseTuner:
         for freq in tqdm(freqs, desc="Analyzing frequencies"):
             self._simulate_model(freq, delay)
             amp = self._response_amplitude()
-            ppr, induction, recovery = self._calc_ppr_induction_recovery(amp, print_math=False)
+            ppr, induction, recovery, simple_ppr = self._calc_ppr_induction_recovery(amp, print_math=False)
 
             results["ppr"].append(float(ppr))
             results["induction"].append(float(induction))
             results["recovery"].append(float(recovery))
+            results["simple_ppr"].append(float(simple_ppr))
 
         # Restore original state
         self.ispk = original_ispk
@@ -1659,6 +1724,7 @@ class SynapseTuner:
             Dictionary containing frequency analysis results with keys:
             - 'frequencies': List of tested frequencies
             - 'ppr': Paired-pulse ratios at each frequency
+            - 'simple_ppr': Simple paired-pulse ratios at each frequency
             - 'induction': Induction values at each frequency
             - 'recovery': Recovery values at each frequency
         log_plot : bool
@@ -1667,24 +1733,27 @@ class SynapseTuner:
         Notes:
         ------
         Creates a figure with three subplots showing:
-        1. Paired-pulse ratio vs. frequency
+        1. Paired-pulse ratios (both normalized and simple) vs. frequency
         2. Induction vs. frequency
         3. Recovery vs. frequency
 
         Each plot includes a horizontal reference line at y=0 or y=1 to indicate
         the boundary between facilitation and depression.
         """
-        fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15, 5))
+        fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(18, 5))
 
-        # Plot PPR
+        # Plot both PPR measures
         if log_plot:
-            ax1.semilogx(results["frequencies"], results["ppr"], "o-")
+            ax1.semilogx(results["frequencies"], results["ppr"], "o-", label="Normalized PPR")
+            ax1.semilogx(results["frequencies"], results["simple_ppr"], "s-", label="Simple PPR")
         else:
-            ax1.plot(results["frequencies"], results["ppr"], "o-")
+            ax1.plot(results["frequencies"], results["ppr"], "o-", label="Normalized PPR")
+            ax1.plot(results["frequencies"], results["simple_ppr"], "s-", label="Simple PPR")
         ax1.axhline(y=1, color="gray", linestyle="--", alpha=0.5)
         ax1.set_xlabel("Frequency (Hz)")
         ax1.set_ylabel("Paired Pulse Ratio")
         ax1.set_title("PPR vs Frequency")
+        ax1.legend()
         ax1.grid(True)
 
         # Plot Induction
@@ -1713,6 +1782,168 @@ class SynapseTuner:
         plt.show()
 
 
+    def generate_synaptic_table(self, stp_frequency=50.0, stp_delay=250.0, plot=True):
+        """
+        Generate a comprehensive table of synaptic parameters for all connections.
+        
+        This method iterates through all available connections, runs simulations to 
+        characterize each synapse, and compiles the results into a pandas DataFrame.
+        
+        Parameters:
+        -----------
+        stp_frequency : float, optional
+            Frequency in Hz to use for STP (short-term plasticity) analysis. Default is 50.0 Hz.
+        stp_delay : float, optional
+            Delay in ms between pulse trains for STP analysis. Default is 250.0 ms.
+        plot : bool, optional
+            Whether to display the resulting table. Default is True.
+            
+        Returns:
+        --------
+        pd.DataFrame
+            DataFrame containing synaptic parameters for each connection with columns:
+            - connection: Connection name
+            - rise_time: 20-80% rise time (ms)
+            - decay_time: Decay time constant (ms)
+            - latency: Response latency (ms)
+            - half_width: Response half-width (ms)
+            - peak_amplitude: Peak synaptic current amplitude (pA)
+            - baseline: Baseline current (pA)
+            - ppr: Paired-pulse ratio (normalized)
+            - simple_ppr: Simple paired-pulse ratio (2nd/1st pulse)
+            - induction: STP induction measure
+            - recovery: STP recovery measure
+            
+        Notes:
+        ------
+        This method temporarily switches between connections to characterize each one,
+        then restores the original connection. The STP metrics are calculated at the
+        specified frequency and delay.
+        """
+        # Store original connection to restore later
+        original_connection = self.current_connection
+        
+        # Initialize results list
+        results = []
+        
+        print(f"Analyzing {len(self.conn_type_settings)} connections...")
+        
+        for conn_name in tqdm(self.conn_type_settings.keys(), desc="Analyzing connections"):
+            try:
+                # Switch to this connection
+                self._switch_connection(conn_name)
+                
+                # Run single event analysis
+                self.SingleEvent(plot_and_print=False)
+                
+                # Get synaptic properties from the single event
+                syn_props = self._get_syn_prop()
+                
+                # Run STP analysis at specified frequency
+                stp_results = self.stp_frequency_response(
+                    freqs=[stp_frequency], 
+                    delay=stp_delay, 
+                    plot=False, 
+                    log_plot=False
+                )
+                
+                # Extract STP metrics for this frequency
+                freq_idx = 0  # Only one frequency tested
+                ppr = stp_results['ppr'][freq_idx]
+                induction = stp_results['induction'][freq_idx]
+                recovery = stp_results['recovery'][freq_idx]
+                simple_ppr = stp_results['simple_ppr'][freq_idx]
+                
+                # Compile results for this connection
+                conn_results = {
+                    'connection': conn_name,
+                    'rise_time': float(self.rise_time),
+                    'decay_time': float(self.decay_time),
+                    'latency': float(syn_props.get('latency', 0)),
+                    'half_width': float(syn_props.get('half_width', 0)),
+                    'peak_amplitude': float(syn_props.get('amp', 0)),
+                    'baseline': float(syn_props.get('baseline', 0)),
+                    'ppr': float(ppr),
+                    'simple_ppr': float(simple_ppr),
+                    'induction': float(induction),
+                    'recovery': float(recovery)
+                }
+                
+                results.append(conn_results)
+                
+            except Exception as e:
+                print(f"Warning: Failed to analyze connection '{conn_name}': {e}")
+                # Add partial results if possible
+                results.append({
+                    'connection': conn_name,
+                    'rise_time': float('nan'),
+                    'decay_time': float('nan'),
+                    'latency': float('nan'),
+                    'half_width': float('nan'),
+                    'peak_amplitude': float('nan'),
+                    'baseline': float('nan'),
+                    'ppr': float('nan'),
+                    'simple_ppr': float('nan'),
+                    'induction': float('nan'),
+                    'recovery': float('nan')
+                })
+        
+        # Restore original connection
+        if original_connection in self.conn_type_settings:
+            self._switch_connection(original_connection)
+        
+        # Create DataFrame
+        df = pd.DataFrame(results)
+        
+        # Set connection as index for better display
+        df = df.set_index('connection')
+        
+        if plot:
+            # Display the table
+            print("\nSynaptic Parameters Table:")
+            print("=" * 80)
+            display(df.round(4))
+            
+            # Optional: Create a simple bar plot for key metrics
+            try:
+                fig, axes = plt.subplots(2, 2, figsize=(15, 10))
+                fig.suptitle(f'Synaptic Parameters Across Connections (STP at {stp_frequency}Hz)', fontsize=16)
+                
+                # Plot rise/decay times
+                df[['rise_time', 'decay_time']].plot(kind='bar', ax=axes[0,0])
+                axes[0,0].set_title('Rise and Decay Times')
+                axes[0,0].set_ylabel('Time (ms)')
+                axes[0,0].tick_params(axis='x', rotation=45)
+                
+                # Plot PPR metrics
+                df[['ppr', 'simple_ppr']].plot(kind='bar', ax=axes[0,1])
+                axes[0,1].set_title('Paired-Pulse Ratios')
+                axes[0,1].axhline(y=1, color='gray', linestyle='--', alpha=0.5)
+                axes[0,1].tick_params(axis='x', rotation=45)
+                
+                # Plot induction
+                df['induction'].plot(kind='bar', ax=axes[1,0], color='green')
+                axes[1,0].set_title('STP Induction')
+                axes[1,0].axhline(y=0, color='gray', linestyle='--', alpha=0.5)
+                axes[1,0].set_ylabel('Induction')
+                axes[1,0].tick_params(axis='x', rotation=45)
+                
+                # Plot recovery
+                df['recovery'].plot(kind='bar', ax=axes[1,1], color='orange')
+                axes[1,1].set_title('STP Recovery')
+                axes[1,1].axhline(y=0, color='gray', linestyle='--', alpha=0.5)
+                axes[1,1].set_ylabel('Recovery')
+                axes[1,1].tick_params(axis='x', rotation=45)
+                
+                plt.tight_layout()
+                plt.show()
+                
+            except Exception as e:
+                print(f"Warning: Could not create plots: {e}")
+        
+        return df
+        
+
 class GapJunctionTuner:
     def __init__(
         self,
@@ -1767,6 +1998,7 @@ class GapJunctionTuner:
         self.config = config
         self.available_networks = []
         self.current_network = None
+        self.last_figure = None
         if self.conn_type_settings is None and self.config is not None:
             self.conn_type_settings = self._build_conn_type_settings_from_config(self.config)
         if self.conn_type_settings is None or len(self.conn_type_settings) == 0:
@@ -2168,6 +2400,7 @@ class GapJunctionTuner:
         plt.xlabel("Time (ms)")
         plt.ylabel("Membrane Voltage (mV)")
         plt.legend()
+        self.last_figure = plt.gcf()
 
     def coupling_coefficient(self, t, v1, v2, t_start, t_end, dt=h.dt):
         """
@@ -2202,75 +2435,649 @@ class GapJunctionTuner:
         return (v2[idx2] - v2[idx1]) / (v1[idx2] - v1[idx1])
 
     def InteractiveTuner(self):
-        w_run = widgets.Button(description="Run", icon="history", button_style="primary")
-        values = [i * 10**-4 for i in range(1, 1001)]  # From 1e-4 to 1e-1
-
-        # Create the SelectionSlider widget with appropriate formatting
-        resistance = widgets.FloatLogSlider(
-            value=0.001,
-            base=10,
-            min=-4,  # max exponent of base
-            max=-1,  # min exponent of base
-            step=0.1,  # exponent step
-            description="Resistance: ",
-            continuous_update=True,
-        )
+        """
+        Sets up interactive sliders for tuning short-term plasticity (STP) parameters in a Jupyter Notebook.
+
+        This method creates an interactive UI with sliders for:
+        - Network selection dropdown (if multiple networks available and config provided)
+        - Connection type selection dropdown
+        - Input frequency
+        - Delay between pulse trains
+        - Duration of stimulation (for continuous input mode)
+        - Synaptic parameters (e.g., Use, tau_f, tau_d) based on the syn model
+
+        It also provides buttons for:
+        - Running a single event simulation
+        - Running a train input simulation
+        - Toggling voltage clamp mode
+        - Switching between standard and continuous input modes
 
-        output = widgets.Output()
+        Network Dropdown Feature:
+        ------------------------
+        When the SynapseTuner is initialized with a BMTK config file containing multiple networks:
+        - A network dropdown appears next to the connection dropdown
+        - Users can dynamically switch between networks (e.g., 'network_to_network', 'external_to_network')
+        - Switching networks rebuilds available connections and updates the connection dropdown
+        - The current connection is preserved if it exists in the new network
+        - If multiple networks exist but only one is specified during init, that network is used as default
 
-        ui_widgets = [w_run, resistance]
+        Notes:
+        ------
+        Ideal for exploratory parameter tuning and interactive visualization of
+        synapse behavior with different parameter values and stimulation protocols.
+        The network dropdown feature enables comprehensive exploration of multi-network
+        BMTK simulations without needing to reinitialize the tuner.
+        """
+        # Widgets setup (Sliders)
+        freqs = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 35, 50, 100, 200]
+        delays = [125, 250, 500, 1000, 2000, 4000]
+        durations = [100, 300, 500, 1000, 2000, 5000, 10000]
+        freq0 = 50
+        delay0 = 250
+        duration0 = 300
+        vlamp_status = self.vclamp
 
-        def on_button(*args):
-            with output:
-                # Clear only the output widget, not the entire cell
-                output.clear_output(wait=True)
+        # Connection dropdown
+        connection_options = sorted(list(self.conn_type_settings.keys()))
+        w_connection = widgets.Dropdown(
+            options=connection_options,
+            value=self.current_connection,
+            description="Connection:",
+            style={'description_width': 'initial'}
+        )
 
-                resistance_for_gap = resistance.value
-                print(f"Running simulation with resistance: {resistance_for_gap:0.6f} and {self.general_settings['iclamp_amp']*1000}pA current clamps")
+        # Network dropdown - only shown if config was provided and multiple networks are available
+        # This enables users to switch between different network datasets dynamically
+        w_network = None
+        if self.config is not None and len(self.available_networks) > 1:
+            w_network = widgets.Dropdown(
+                options=self.available_networks,
+                value=self.current_network,
+                description="Network:",
+                style={'description_width': 'initial'}
+            )
 
-                try:
-                    self.model(resistance_for_gap)
-                    self.plot_model()
+        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",
+        )
+        
+        # Voltage clamp amplitude input
+        default_vclamp_amp = getattr(self.conn['spec_settings'], 'vclamp_amp', -70.0)
+        w_vclamp_amp = widgets.FloatText(
+            value=default_vclamp_amp,
+            description="V_clamp (mV):",
+            step=5.0,
+            style={'description_width': 'initial'},
+            layout=widgets.Layout(width='150px')
+        )
+        
+        w_input_mode = widgets.ToggleButton(
+            value=False, description="Continuous input", icon="eject", button_style="info"
+        )
+        w_input_freq = widgets.SelectionSlider(options=freqs, value=freq0, description="Input Freq")
 
-                    # Convert NEURON vectors to numpy arrays
-                    t_array = np.array(self.t_vec)
-                    v1_array = np.array(self.soma_v_1)
-                    v2_array = np.array(self.soma_v_2)
+        # 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"
+        )
 
-                    cc = self.coupling_coefficient(t_array, v1_array, v2_array, 500, 1000)
-                    print(f"coupling_coefficient is {cc:0.4f}")
-                    plt.show()
+        # Save functionality widgets
+        save_path_text = widgets.Text(
+            value="plot.png",
+            description="Save path:",
+            layout=widgets.Layout(width='300px')
+        )
+        save_button = widgets.Button(description="Save Plot", icon="save", button_style="success")
 
+        def save_plot(b):
+            if hasattr(self, 'last_figure') and self.last_figure is not None:
+                try:
+                    # Create a new figure with just the first subplot (synaptic current)
+                    fig, ax = plt.subplots(figsize=(8, 6))
+                    
+                    # Get the axes from the original figure
+                    original_axes = self.last_figure.get_axes()
+                    if len(original_axes) > 0:
+                        first_ax = original_axes[0]
+                        
+                        # Copy the data from the first subplot
+                        for line in first_ax.get_lines():
+                            ax.plot(line.get_xdata(), line.get_ydata(), 
+                                   color=line.get_color(), label=line.get_label())
+                        
+                        # Copy axis labels and title
+                        ax.set_xlabel(first_ax.get_xlabel())
+                        ax.set_ylabel(first_ax.get_ylabel())
+                        ax.set_title(first_ax.get_title())
+                        ax.set_xlim(first_ax.get_xlim())
+                        ax.legend()
+                        ax.grid(True)
+                        
+                        # Save the new figure
+                        fig.savefig(save_path_text.value)
+                        plt.close(fig)  # Close the temporary figure
+                        print(f"Synaptic current plot saved to {save_path_text.value}")
+                    else:
+                        print("No subplots found in the figure")
+                        
                 except Exception as e:
-                    print(f"Error during simulation or analysis: {e}")
-                    import traceback
+                    print(f"Error saving plot: {e}")
+            else:
+                print("No plot to save")
 
-                    traceback.print_exc()
+        save_button.on_click(save_plot)
 
-        # Add connection dropdown if multiple connections exist
-        if len(self.conn_type_settings) > 1:
-            connection_dropdown = widgets.Dropdown(
-                options=list(self.conn_type_settings.keys()),
-                value=self.current_connection,
-                description='Connection:',
-            )
-            def on_connection_change(change):
-                if change['type'] == 'change' and change['name'] == 'value':
-                    self._switch_connection(change['new'])
-                    on_button()  # Automatically rerun the simulation after switching
-            connection_dropdown.observe(on_connection_change)
-            ui_widgets.insert(0, connection_dropdown)
+        def create_dynamic_sliders():
+            """Create sliders based on current connection's parameters"""
+            sliders = {}
+            for key, value in self.slider_vars.items():
+                if isinstance(value, (int, float)):  # Only create sliders for numeric values
+                    if hasattr(self.syn, key):
+                        if value == 0:
+                            print(
+                                f"{key} was set to zero, going to try to set a range of values, try settings the {key} to a nonzero value if you dont like the range!"
+                            )
+                            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
+                            )
+                        sliders[key] = slider
+                    else:
+                        print(f"skipping slider for {key} due to not being a synaptic variable")
+            return sliders
 
-        ui = VBox(ui_widgets)
+        # Generate sliders dynamically based on valid numeric entries in self.slider_vars
+        self.dynamic_sliders = create_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!"
+        )
 
-        display(ui)
-        display(output)
+        # Create output widget for displaying results
+        output_widget = widgets.Output()
+        
+        def run_single_event(*args):
+            clear_output()
+            display(ui)
+            display(output_widget)
+            
+            self.vclamp = w_vclamp.value
+            # Update voltage clamp amplitude if voltage clamp is enabled
+            if self.vclamp:
+                # Update the voltage clamp amplitude settings
+                self.conn['spec_settings']['vclamp_amp'] = w_vclamp_amp.value
+                # Update general settings if they exist
+                if hasattr(self, 'general_settings'):
+                    self.general_settings['vclamp_amp'] = w_vclamp_amp.value
+            # Update synaptic properties based on slider values
+            self.ispk = None
+            
+            # Clear previous results and run simulation
+            output_widget.clear_output()
+            with output_widget:
+                self.SingleEvent()
 
-        # Run once initially
-        on_button()
-        w_run.on_click(on_button)
+        def on_connection_change(*args):
+            """Handle connection dropdown change"""
+            try:
+                new_connection = w_connection.value
+                if new_connection != self.current_connection:
+                    # Switch to new connection
+                    self._switch_connection(new_connection)
+                    
+                    # Recreate dynamic sliders for new connection
+                    self.dynamic_sliders = create_dynamic_sliders()
+                    
+                    # Update UI
+                    update_ui_layout()
+                    update_ui()
+                    
+            except Exception as e:
+                print(f"Error switching connection: {e}")
 
+        def on_network_change(*args):
+            """
+            Handle network dropdown change events.
+            
+            This callback is triggered when the user selects a different network from 
+            the network dropdown. It coordinates the complete switching process:
+            1. Calls _switch_network() to rebuild connections for the new network
+            2. Updates the connection dropdown options with new network's connections
+            3. Recreates dynamic sliders for new connection parameters
+            4. Refreshes the entire UI to reflect all changes
+            """
+            if w_network is None:
+                return
+            try:
+                new_network = w_network.value
+                if new_network != self.current_network:
+                    # Switch to new network
+                    self._switch_network(new_network)
+                    
+                    # Update connection dropdown options with new network's connections
+                    connection_options = list(self.conn_type_settings.keys())
+                    w_connection.options = connection_options
+                    if connection_options:
+                        w_connection.value = self.current_connection
+                    
+                    # Recreate dynamic sliders for new connection
+                    self.dynamic_sliders = create_dynamic_sliders()
+                    
+                    # Update UI
+                    update_ui_layout()
+                    update_ui()
+                    
+            except Exception as e:
+                print(f"Error switching network: {e}")
 
+        def update_ui_layout():
+            """
+            Update the UI layout with new sliders and network dropdown.
+            
+            This function reconstructs the entire UI layout including:
+            - Network dropdown (if available) and connection dropdown in the top row
+            - Button controls and input mode toggles
+            - Parameter sliders arranged in columns
+            """
+            nonlocal ui, slider_columns
+            
+            # Add the dynamic sliders to the UI
+            slider_widgets = [slider for slider in self.dynamic_sliders.values()]
+            
+            if slider_widgets:
+                half = len(slider_widgets) // 2
+                col1 = VBox(slider_widgets[:half])
+                col2 = VBox(slider_widgets[half:])
+                slider_columns = HBox([col1, col2])
+            else:
+                slider_columns = VBox([])
+            
+            # Create button row with voltage clamp controls
+            if w_vclamp.value:  # Show voltage clamp amplitude input when toggle is on
+                button_row = HBox([w_run, w_single, w_vclamp, w_vclamp_amp, w_input_mode])
+            else:  # Hide voltage clamp amplitude input when toggle is off
+                button_row = HBox([w_run, w_single, w_vclamp, w_input_mode])
+            
+            # Construct the top row - include network dropdown if available
+            # This creates a horizontal layout with network dropdown (if present) and connection dropdown
+            if w_network is not None:
+                connection_row = HBox([w_network, w_connection])
+            else:
+                connection_row = HBox([w_connection])
+            slider_row = HBox([w_input_freq, self.w_delay, self.w_duration])
+            save_row = HBox([save_path_text, save_button])
+            
+            ui = VBox([connection_row, button_row, slider_row, slider_columns, save_row])
+
+        # Function to update UI based on input mode
+        def update_ui(*args):
+            clear_output()
+            display(ui)
+            display(output_widget)
+            
+            self.vclamp = w_vclamp.value
+            # Update voltage clamp amplitude if voltage clamp is enabled
+            if self.vclamp:
+                self.conn['spec_settings']['vclamp_amp'] = w_vclamp_amp.value
+                if hasattr(self, 'general_settings'):
+                    self.general_settings['vclamp_amp'] = w_vclamp_amp.value
+            
+            self.input_mode = w_input_mode.value
+            syn_props = {var: slider.value for var, slider in self.dynamic_sliders.items()}
+            self._set_syn_prop(**syn_props)
+            
+            # Clear previous results and run simulation
+            output_widget.clear_output()
+            with output_widget:
+                if not self.input_mode:
+                    self._simulate_model(w_input_freq.value, self.w_delay.value, w_vclamp.value)
+                else:
+                    self._simulate_model(w_input_freq.value, self.w_duration.value, w_vclamp.value)
+                amp = self._response_amplitude()
+                self._plot_model(
+                    [self.general_settings["tstart"] - self.nstim.interval / 3, self.tstop]
+                )
+                _ = self._calc_ppr_induction_recovery(amp)
+
+        # Function to switch between delay and duration sliders
+        def switch_slider(*args):
+            if w_input_mode.value:
+                self.w_delay.layout.display = "none"  # Hide delay slider
+                self.w_duration.layout.display = ""  # Show duration slider
+            else:
+                self.w_delay.layout.display = ""  # Show delay slider
+                self.w_duration.layout.display = "none"  # Hide duration slider
+
+        # Function to handle voltage clamp toggle
+        def on_vclamp_toggle(*args):
+            """Handle voltage clamp toggle changes to show/hide amplitude input"""
+            update_ui_layout()
+            clear_output()
+            display(ui)
+            display(output_widget)
+
+        # Link widgets to their callback functions
+        w_connection.observe(on_connection_change, names="value")
+        # Link network dropdown callback only if network dropdown was created
+        if w_network is not None:
+            w_network.observe(on_network_change, names="value")
+        w_input_mode.observe(switch_slider, names="value")
+        w_vclamp.observe(on_vclamp_toggle, names="value")
+
+        # Hide the duration slider initially until the user selects it
+        self.w_duration.layout.display = "none"  # Hide duration slider
+
+        w_single.on_click(run_single_event)
+        w_run.on_click(update_ui)
+
+        # Initial UI setup
+        slider_columns = VBox([])
+        ui = VBox([])
+        update_ui_layout()
+
+        display(ui)
+        update_ui()
+
+    def stp_frequency_response(
+        self,
+        freqs=[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 15, 20, 35, 50, 100, 200],
+        delay=250,
+        plot=True,
+        log_plot=True,
+    ):
+        """
+        Analyze synaptic response across different stimulation frequencies.
+
+        This method systematically tests how the synapse model responds to different
+        stimulation frequencies, calculating key short-term plasticity (STP) metrics
+        for each frequency.
+
+        Parameters:
+        -----------
+        freqs : list, optional
+            List of frequencies to analyze (in Hz). Default covers a wide range from 1-200 Hz.
+        delay : float, optional
+            Delay between pulse trains in ms. Default is 250 ms.
+        plot : bool, optional
+            Whether to plot the results. Default is True.
+        log_plot : bool, optional
+            Whether to use logarithmic scale for frequency axis. Default is True.
+
+        Returns:
+        --------
+        dict
+            Dictionary containing frequency-dependent metrics with keys:
+            - 'frequencies': List of tested frequencies
+            - 'ppr': Paired-pulse ratios at each frequency
+            - 'simple_ppr': Simple paired-pulse ratios (2nd/1st pulse) at each frequency
+            - 'induction': Induction values at each frequency
+            - 'recovery': Recovery values at each frequency
+
+        Notes:
+        ------
+        This method is particularly useful for characterizing the frequency-dependent
+        behavior of synapses, such as identifying facilitating vs. depressing regimes
+        or the frequency at which a synapse transitions between these behaviors.
+        """
+        results = {"frequencies": freqs, "ppr": [], "induction": [], "recovery": [], "simple_ppr": []}
+
+        # Store original state
+        original_ispk = self.ispk
+
+        for freq in tqdm(freqs, desc="Analyzing frequencies"):
+            self._simulate_model(freq, delay)
+            amp = self._response_amplitude()
+            ppr, induction, recovery, simple_ppr = self._calc_ppr_induction_recovery(amp, print_math=False)
+
+            results["ppr"].append(float(ppr))
+            results["induction"].append(float(induction))
+            results["recovery"].append(float(recovery))
+            results["simple_ppr"].append(float(simple_ppr))
+
+        # Restore original state
+        self.ispk = original_ispk
+
+        if plot:
+            self._plot_frequency_analysis(results, log_plot=log_plot)
+
+        return results
+
+    def _plot_frequency_analysis(self, results, log_plot):
+        """
+        Plot the frequency-dependent synaptic properties.
+
+        Parameters:
+        -----------
+        results : dict
+            Dictionary containing frequency analysis results with keys:
+            - 'frequencies': List of tested frequencies
+            - 'ppr': Paired-pulse ratios at each frequency
+            - 'simple_ppr': Simple paired-pulse ratios at each frequency
+            - 'induction': Induction values at each frequency
+            - 'recovery': Recovery values at each frequency
+        log_plot : bool
+            Whether to use logarithmic scale for frequency axis
+
+        Notes:
+        ------
+        Creates a figure with three subplots showing:
+        1. Paired-pulse ratios (both normalized and simple) vs. frequency
+        2. Induction vs. frequency
+        3. Recovery vs. frequency
+
+        Each plot includes a horizontal reference line at y=0 or y=1 to indicate
+        the boundary between facilitation and depression.
+        """
+        fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(18, 5))
+
+        # Plot both PPR measures
+        if log_plot:
+            ax1.semilogx(results["frequencies"], results["ppr"], "o-", label="Normalized PPR")
+            ax1.semilogx(results["frequencies"], results["simple_ppr"], "s-", label="Simple PPR")
+        else:
+            ax1.plot(results["frequencies"], results["ppr"], "o-", label="Normalized PPR")
+            ax1.plot(results["frequencies"], results["simple_ppr"], "s-", label="Simple PPR")
+        ax1.axhline(y=1, color="gray", linestyle="--", alpha=0.5)
+        ax1.set_xlabel("Frequency (Hz)")
+        ax1.set_ylabel("Paired Pulse Ratio")
+        ax1.set_title("PPR vs Frequency")
+        ax1.legend()
+        ax1.grid(True)
+
+        # Plot Induction
+        if log_plot:
+            ax2.semilogx(results["frequencies"], results["induction"], "o-")
+        else:
+            ax2.plot(results["frequencies"], results["induction"], "o-")
+        ax2.axhline(y=0, color="gray", linestyle="--", alpha=0.5)
+        ax2.set_xlabel("Frequency (Hz)")
+        ax2.set_ylabel("Induction")
+        ax2.set_title("Induction vs Frequency")
+        ax2.grid(True)
+
+        # Plot Recovery
+        if log_plot:
+            ax3.semilogx(results["frequencies"], results["recovery"], "o-")
+        else:
+            ax3.plot(results["frequencies"], results["recovery"], "o-")
+        ax3.axhline(y=0, color="gray", linestyle="--", alpha=0.5)
+        ax3.set_xlabel("Frequency (Hz)")
+        ax3.set_ylabel("Recovery")
+        ax3.set_title("Recovery vs Frequency")
+        ax3.grid(True)
+
+        plt.tight_layout()
+        plt.show()
+
+    def generate_synaptic_table(self, stp_frequency=50.0, stp_delay=250.0, plot=True):
+        """
+        Generate a comprehensive table of synaptic parameters for all connections.
+        
+        This method iterates through all available connections, runs simulations to 
+        characterize each synapse, and compiles the results into a pandas DataFrame.
+        
+        Parameters:
+        -----------
+        stp_frequency : float, optional
+            Frequency in Hz to use for STP (short-term plasticity) analysis. Default is 50.0 Hz.
+        stp_delay : float, optional
+            Delay in ms between pulse trains for STP analysis. Default is 250.0 ms.
+        plot : bool, optional
+            Whether to display the resulting table. Default is True.
+            
+        Returns:
+        --------
+        pd.DataFrame
+            DataFrame containing synaptic parameters for each connection with columns:
+            - connection: Connection name
+            - rise_time: 20-80% rise time (ms)
+            - decay_time: Decay time constant (ms)
+            - latency: Response latency (ms)
+            - half_width: Response half-width (ms)
+            - peak_amplitude: Peak synaptic current amplitude (pA)
+            - baseline: Baseline current (pA)
+            - ppr: Paired-pulse ratio (normalized)
+            - simple_ppr: Simple paired-pulse ratio (2nd/1st pulse)
+            - induction: STP induction measure
+            - recovery: STP recovery measure
+            
+        Notes:
+        ------
+        This method temporarily switches between connections to characterize each one,
+        then restores the original connection. The STP metrics are calculated at the
+        specified frequency and delay.
+        """
+        # Store original connection to restore later
+        original_connection = self.current_connection
+        
+        # Initialize results list
+        results = []
+        
+        print(f"Analyzing {len(self.conn_type_settings)} connections...")
+        
+        for conn_name in tqdm(self.conn_type_settings.keys(), desc="Analyzing connections"):
+            try:
+                # Switch to this connection
+                self._switch_connection(conn_name)
+                
+                # Run single event analysis
+                self.SingleEvent(plot_and_print=False)
+                
+                # Get synaptic properties from the single event
+                syn_props = self._get_syn_prop()
+                
+                # Run STP analysis at specified frequency
+                stp_results = self.stp_frequency_response(
+                    freqs=[stp_frequency], 
+                    delay=stp_delay, 
+                    plot=False, 
+                    log_plot=False
+                )
+                
+                # Extract STP metrics for this frequency
+                freq_idx = 0  # Only one frequency tested
+                ppr = stp_results['ppr'][freq_idx]
+                induction = stp_results['induction'][freq_idx]
+                recovery = stp_results['recovery'][freq_idx]
+                simple_ppr = stp_results['simple_ppr'][freq_idx]
+                
+                # Compile results for this connection
+                conn_results = {
+                    'connection': conn_name,
+                    'rise_time': float(self.rise_time),
+                    'decay_time': float(self.decay_time),
+                    'latency': float(syn_props.get('latency', 0)),
+                    'half_width': float(syn_props.get('half_width', 0)),
+                    'peak_amplitude': float(syn_props.get('amp', 0)),
+                    'baseline': float(syn_props.get('baseline', 0)),
+                    'ppr': float(ppr),
+                    'simple_ppr': float(simple_ppr),
+                    'induction': float(induction),
+                    'recovery': float(recovery)
+                }
+                
+                results.append(conn_results)
+                
+            except Exception as e:
+                print(f"Warning: Failed to analyze connection '{conn_name}': {e}")
+                # Add partial results if possible
+                results.append({
+                    'connection': conn_name,
+                    'rise_time': float('nan'),
+                    'decay_time': float('nan'),
+                    'latency': float('nan'),
+                    'half_width': float('nan'),
+                    'peak_amplitude': float('nan'),
+                    'baseline': float('nan'),
+                    'ppr': float('nan'),
+                    'simple_ppr': float('nan'),
+                    'induction': float('nan'),
+                    'recovery': float('nan')
+                })
+        
+        # Restore original connection
+        if original_connection in self.conn_type_settings:
+            self._switch_connection(original_connection)
+        
+        # Create DataFrame
+        df = pd.DataFrame(results)
+        
+        # Set connection as index for better display
+        df = df.set_index('connection')
+        
+        if plot:
+            # Display the table
+            print("\nSynaptic Parameters Table:")
+            print("=" * 80)
+            display(df.round(4))
+            
+            # Optional: Create a simple bar plot for key metrics
+            try:
+                fig, axes = plt.subplots(2, 2, figsize=(15, 10))
+                fig.suptitle(f'Synaptic Parameters Across Connections (STP at {stp_frequency}Hz)', fontsize=16)
+                
+                # Plot rise/decay times
+                df[['rise_time', 'decay_time']].plot(kind='bar', ax=axes[0,0])
+                axes[0,0].set_title('Rise and Decay Times')
+                axes[0,0].set_ylabel('Time (ms)')
+                axes[0,0].tick_params(axis='x', rotation=45)
+                
+                # Plot PPR metrics
+                df[['ppr', 'simple_ppr']].plot(kind='bar', ax=axes[0,1])
+                axes[0,1].set_title('Paired-Pulse Ratios')
+                axes[0,1].axhline(y=1, color='gray', linestyle='--', alpha=0.5)
+                axes[0,1].tick_params(axis='x', rotation=45)
+                
+                # Plot induction
+                df['induction'].plot(kind='bar', ax=axes[1,0], color='green')
+                axes[1,0].set_title('STP Induction')
+                axes[1,0].axhline(y=0, color='gray', linestyle='--', alpha=0.5)
+                axes[1,0].set_ylabel('Induction')
+                axes[1,0].tick_params(axis='x', rotation=45)
+                
+                # Plot recovery
+                df['recovery'].plot(kind='bar', ax=axes[1,1], color='orange')
+                axes[1,1].set_title('STP Recovery')
+                axes[1,1].axhline(y=0, color='gray', linestyle='--', alpha=0.5)
+                axes[1,1].set_ylabel('Recovery')
+                axes[1,1].tick_params(axis='x', rotation=45)
+                
+                plt.tight_layout()
+                plt.show()
+                
+            except Exception as e:
+                print(f"Warning: Could not create plots: {e}")
+        
+        return df
+        
 # optimizers!
 
 
@@ -2365,6 +3172,7 @@ class SynapseOptimizer:
         induction = 0
         ppr = 0
         recovery = 0
+        simple_ppr = 0
         amp = 0
         rise_time = 0
         decay_time = 0
@@ -2388,7 +3196,7 @@ class SynapseOptimizer:
         if self.run_train_input:
             self.tuner._simulate_model(self.train_frequency, self.train_delay)
             amp = self.tuner._response_amplitude()
-            ppr, induction, recovery = self.tuner._calc_ppr_induction_recovery(
+            ppr, induction, recovery, simple_ppr = self.tuner._calc_ppr_induction_recovery(
                 amp, print_math=False
             )
             amp = self.tuner._find_max_amp(amp)
@@ -2397,6 +3205,7 @@ class SynapseOptimizer:
             "induction": float(induction),
             "ppr": float(ppr),
             "recovery": float(recovery),
+            "simple_ppr": float(simple_ppr),
             "max_amplitude": float(amp),
             "rise_time": float(rise_time),
             "decay_time": float(decay_time),
@@ -2540,7 +3349,7 @@ class SynapseOptimizer:
         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")
+            raise Exception("Pick a valid init guess method: either 'random' or 'middle_guess'")
         normalized_x0 = self._normalize_params(np.array(x0), param_names)
 
         # Run optimization
@@ -2646,7 +3455,7 @@ class SynapseOptimizer:
             self.tuner.ispk = None
             self.tuner.SingleEvent(plot_and_print=True)
 
-# dataclass means just init the typehints as self.typehint. looks a bit cleaner
+# dataclass decorator automatically generates __init__ from type-annotated class variables for cleaner code
 @dataclass
 class GapOptimizationResult:
     """Container for gap junction optimization results"""