bmtool 0.7.6__py3-none-any.whl → 0.7.8__py3-none-any.whl

bmtool/singlecell.py

@@ -769,7 +769,7 @@ class FI(object):
         --------
         tuple
             (current_amplitudes, spike_counts) where:
-            - current_amplitudes: List of current injection amplitudes (nA)
+            - current_amplitudes: List of current injection amplitudes (pA)
             - spike_counts: List of spike counts corresponding to each amplitude
         """
         print("Running simulations for FI curve...")
@@ -781,14 +781,14 @@ class FI(object):
         print()
         print("Results")
         # lets make a df so the results line up nice
-        data = {"Injection (nA):": self.amps, "number of spikes": self.nspks}
+        data = {"Injection (pA):": [amp * 1000 for amp in 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'Injection (pA): ' + ', '.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
+        return [amp * 1000 for amp in self.amps], self.nspks
 
 
 class ZAP(CurrentClamp):
@@ -1040,6 +1040,9 @@ class Profiler:
         # initialize to None and then prefer config-derived paths if provided
         self.template_dir = None
         self.mechanism_dir = None
+        self.templates = None  # Initialize templates attribute
+        self.config = config  # Store config path
+        self.last_figure = None  # Store reference to last generated figure
 
         # If a BMTK config is provided, load mechanisms/templates from it
         if config is not None:
@@ -1067,7 +1070,7 @@ class Profiler:
                 load_templates_from_config(config)
             except Exception:
                 # fall back to explicit dirs if config parsing/loading fails
-                pass
+                print('failed')
 
         else:
             # fall back to explicit args if not set by config
@@ -1091,30 +1094,54 @@ class Profiler:
 
     def load_templates(self, hoc_template_file=None):
         if self.templates is None:  # Can really only do this once
-            if (
-                self.mechanism_dir != "./"
-                and self.mechanism_dir != "."
-                and self.mechanism_dir != "././"
-            ):
-                neuron.load_mechanisms(self.mechanism_dir)
-            h_base = set(dir(h))
-
-            cwd = os.getcwd()
-            os.chdir(self.template_dir)
-            if not hoc_template_file:
-                self.hoc_templates = glob.glob("*.hoc")
-                for hoc_template in self.hoc_templates:
-                    h.load_file(str(hoc_template))
+            # Check if we have a config file - if so, extract templates from node configs
+            if hasattr(self, 'config') and self.config is not None:
+                try:
+                    from bmtool.util.util import load_nodes_from_config
+                    nodes_networks = load_nodes_from_config(config=self.config)
+                    template_names = set()
+                    for nodes in nodes_networks:
+                        try:
+                            cell_template_names = nodes_networks[nodes]['model_template'].unique()
+                            # Clean up template names (remove 'hoc:' prefix if present)
+                            for template in cell_template_names:
+                                if isinstance(template, str):
+                                    # Remove 'hoc:' prefix if present
+                                    clean_name = template.replace('hoc:', '') if template.startswith('hoc:') else template
+                                    template_names.add(clean_name)
+                        except:
+                            # If fails, means no model_templates in that network
+                            pass
+                    
+                    self.templates = sorted(list(template_names))
+                    self.hoc_templates = []  # Templates loaded via config, not hoc files
+                    
+                except Exception as e:
+                    print(f"Failed to load templates from config: {e}")
             else:
-                self.hoc_templates = [hoc_template_file]
-                h.load_file(hoc_template_file)
-
-            os.chdir(cwd)
-
-            # h.load_file('biophys_components/hoc_templates/Template.hoc')
-            h_loaded = dir(h)
-
-            self.templates = [x for x in h_loaded if x not in h_base]
+                # Traditional loading with template_dir and mechanism_dir
+                if (
+                    self.mechanism_dir != "./"
+                    and self.mechanism_dir != "."
+                    and self.mechanism_dir != "././"
+                ):
+                    neuron.load_mechanisms(self.mechanism_dir)
+                h_base = set(dir(h))
+
+                cwd = os.getcwd()
+                os.chdir(self.template_dir)
+                if not hoc_template_file:
+                    self.hoc_templates = glob.glob("*.hoc")
+                    for hoc_template in self.hoc_templates:
+                        h.load_file(str(hoc_template))
+                else:
+                    self.hoc_templates = [hoc_template_file]
+                    h.load_file(hoc_template_file)
+
+                os.chdir(cwd)
+
+                h_loaded = dir(h)
+                self.templates = [x for x in h_loaded if x not in h_base]
 
         return self.templates
 
@@ -1163,13 +1190,20 @@ class Profiler:
 
         if plot:
             plt.figure()
-            plt.plot(time, amp)
+            t_array = np.array(time)
+            amp_array = np.array(amp)
+            t_idx = (t_array >= passive.inj_delay) & (t_array <= passive.inj_delay + passive.inj_dur)
+            plt.plot(t_array[t_idx], amp_array[t_idx])
             if passive.method == "exp2":
                 plt.plot(*passive.double_exponential_fit(), "r:", label="double exponential fit")
                 plt.legend()
+            elif passive.method == "exp":
+                plt.plot(*passive.single_exponential_fit(), "r:", label="single exponential fit")
+                plt.legend()
             plt.title("Passive Cell Current Injection")
             plt.xlabel("Time (ms)")
             plt.ylabel("Membrane Potential (mV)")
+            self.last_figure = plt.gcf()
             plt.show()
 
         return time, amp
@@ -1198,6 +1232,8 @@ class Profiler:
             plt.title("Current Injection")
             plt.xlabel("Time (ms)")
             plt.ylabel("Membrane Potential (mV)")
+            plt.xlim(ccl.inj_delay - 10, ccl.inj_delay + ccl.inj_dur + 10)
+            self.last_figure = plt.gcf()
             plt.show()
 
         return time, amp
@@ -1228,7 +1264,7 @@ class Profiler:
         plot: bool
             automatically plot an fi curve
 
-        Returns the injection amplitudes (nA) used, number of spikes per amplitude supplied
+        Returns the injection amplitudes (pA) used, number of spikes per amplitude supplied
             list(amps), list(# of spikes)
         """
         fi = FI(
@@ -1244,8 +1280,9 @@ class Profiler:
             plt.figure()
             plt.plot(amp, nspk)
             plt.title("FI Curve")
-            plt.xlabel("Injection (nA)")
+            plt.xlabel("Injection (pA)")
             plt.ylabel("# Spikes")
+            self.last_figure = plt.gcf()
             plt.show()
 
         return amp, nspk
@@ -1285,22 +1322,428 @@ class Profiler:
             plt.title("ZAP Response")
             plt.xlabel("Time (ms)")
             plt.ylabel("Membrane Potential (mV)")
+            self.last_figure = plt.gcf()
 
             plt.figure()
             plt.plot(time, zap.zap_vec)
             plt.title("ZAP Current")
             plt.xlabel("Time (ms)")
             plt.ylabel("Current Injection (nA)")
+            # Note: This will overwrite last_figure with the current plot
+            self.last_figure = plt.gcf()
 
             plt.figure()
             plt.plot(*zap.get_impedance(smooth=smooth))
             plt.title("Impedance Amplitude Profile")
             plt.xlabel("Frequency (Hz)")
             plt.ylabel("Impedance (MOhms)")
+            self.last_figure = plt.gcf()
             plt.show()
 
         return time, amp
 
+    def interactive_runner(self):
+        """Interactive runner for single cell profiling with GUI widgets.
+        
+        This method creates an interactive interface using ipywidgets that allows
+        users to select templates and analysis methods, adjust parameters, and run
+        simulations with real-time plotting.
+        """
+        try:
+            import ipywidgets as widgets
+            from IPython.display import display, clear_output
+            import matplotlib.pyplot as plt
+        except ImportError:
+            raise ImportError("ipywidgets and matplotlib are required for interactive mode. Install with: pip install ipywidgets matplotlib")
+        
+        # Get available templates
+        available_templates = self.load_templates()
+        
+        # Check what NEURON objects are available
+        import neuron
+        h = neuron.h
+        
+        # Create widgets
+        template_dropdown = widgets.Dropdown(
+            options=available_templates,
+            value=available_templates[0] if available_templates else None,
+            description='Template:',
+            style={'description_width': '80px'},
+            layout=widgets.Layout(width='300px')
+        )
+        
+        method_dropdown = widgets.Dropdown(
+            options=['passive_properties', 'current_injection', 'fi_curve', 'impedance_amplitude_profile'],
+            value='passive_properties',
+            description='Method:',
+            style={'description_width': '80px'},
+            layout=widgets.Layout(width='300px')
+        )
+        
+        # Default values based on method - from basic_settings in single_cell_tuning.ipynb
+        method_defaults = {
+            'passive_properties': {
+                'inj_amp': -20.0,
+                'inj_delay': 1500.0,
+                'inj_dur': 1000.0,
+                'tstop': 2500.0,
+                'tau_method': 'exp2'
+            },
+            'current_injection': {
+                'inj_amp': 50.0,
+                'inj_delay': 1500.0,
+                'inj_dur': 1000.0,
+                'tstop': 3000.0
+            },
+            'fi_curve': {
+                'i_start': -100.0,
+                'i_stop': 800.0,
+                'i_increment': 20.0,
+                'inj_delay': 1500.0,
+                'inj_dur': 1000.0
+            },
+            'impedance_amplitude_profile': {
+                'inj_amp': 100.0,
+                'inj_delay': 1000.0,
+                'inj_dur': 15000.0,
+                'tstop': 15500.0,
+                'fstart': 0.0,
+                'fend': 15.0,
+                'chirp_type': 'linear'
+            }
+        }
+        
+        # Common parameters - always plot results, no need for toggle
+        
+        # Method-specific parameters - styled like synapses.py sliders
+        slider_style = {'description_width': 'initial'}
+        slider_layout = None  # Use default width for longer sliders
+        text_style = {'description_width': 'initial'}
+        text_layout = widgets.Layout(width='200px')
+        
+        # Initialize sliders with default values for passive_properties (initial method)
+        defaults = method_defaults['passive_properties']
+        
+        inj_amp_slider = widgets.FloatSlider(value=defaults['inj_amp'], min=-500.0, max=1000.0, step=10.0, description='Injection Amp (pA):', style=slider_style)
+        inj_delay_slider = widgets.FloatSlider(value=defaults['inj_delay'], min=0.0, max=3000.0, step=10.0, description='Injection Delay (ms):', style=slider_style)
+        inj_dur_slider = widgets.FloatSlider(value=defaults['inj_dur'], min=100.0, max=20000.0, step=100.0, description='Injection Duration (ms):', style=slider_style)
+        tstop_slider = widgets.FloatSlider(value=defaults['tstop'], min=500.0, max=25000.0, step=100.0, description='Total Time (ms):', style=slider_style)
+        
+        # FI curve specific
+        fi_defaults = method_defaults['fi_curve']
+        i_start_slider = widgets.FloatSlider(value=fi_defaults['i_start'], min=-500.0, max=500.0, step=10.0, description='I Start (pA):', style=slider_style)
+        i_stop_slider = widgets.FloatSlider(value=fi_defaults['i_stop'], min=0.0, max=2000.0, step=50.0, description='I Stop (pA):', style=slider_style)
+        i_increment_slider = widgets.FloatSlider(value=fi_defaults['i_increment'], min=10.0, max=500.0, step=10.0, description='I Increment (pA):', style=slider_style)
+        
+        # ZAP specific
+        zap_defaults = method_defaults['impedance_amplitude_profile']
+        fstart_slider = widgets.FloatSlider(value=zap_defaults['fstart'], min=0.0, max=50.0, step=1.0, description='Start Freq (Hz):', style=slider_style)
+        fend_slider = widgets.FloatSlider(value=zap_defaults['fend'], min=1.0, max=100.0, step=1.0, description='End Freq (Hz):', style=slider_style)
+        chirp_dropdown = widgets.Dropdown(options=['linear', 'exponential'], value=zap_defaults['chirp_type'], description='Chirp Type:', style=slider_style)
+        
+        # Passive properties specific
+        tau_method_dropdown = widgets.Dropdown(
+            options=['simple', 'exp', 'exp2'], 
+            value=defaults['tau_method'], 
+            description='Tau Method:', 
+            style=slider_style
+        )
+        
+        # Sections
+        record_sec_text = widgets.Text(value='soma', description='Record Section:', style=text_style, layout=text_layout)
+        inj_sec_text = widgets.Text(value='soma', description='Injection Section:', style=text_style, layout=text_layout)
+        
+        # Post init function
+        post_init_text = widgets.Text(value='', description='Post Init Function:', placeholder='e.g., insert_mechs(123)', style={'description_width': 'initial'}, layout=widgets.Layout(width='300px'))
+        
+        run_button = widgets.Button(
+            description='Run Analysis', 
+            button_style='primary', 
+            icon='play',
+            layout=widgets.Layout(width='140px')
+        )
+        
+        reset_button = widgets.Button(
+            description='Reset to Defaults',
+            button_style='warning',
+            icon='refresh',
+            layout=widgets.Layout(width='150px')
+        )
+        
+        save_path_text = widgets.Text(value='', description='Save Path:', placeholder='e.g., plot.png', style={'description_width': 'initial'}, layout=widgets.Layout(width='300px'))
+        
+        save_button = widgets.Button(
+            description='Save Plot', 
+            button_style='success', 
+            icon='save',
+            layout=widgets.Layout(width='120px')
+        )
+        
+        output_area = widgets.Output(
+            layout=widgets.Layout(border='1px solid #ccc', padding='10px', margin='10px 0 0 0')
+        )
+        
+        # Layout containers - organized like synapse tuner
+        # Top row - template and method selection
+        selection_row = widgets.HBox([
+            template_dropdown,
+            method_dropdown
+        ], layout=widgets.Layout(margin='0 0 10px 0'))
+        
+        # Button row - main controls
+        button_row = widgets.HBox([
+            run_button,
+            reset_button,
+            save_button
+        ], layout=widgets.Layout(margin='0 0 10px 0'))
+        
+        # Section row - recording and injection sections  
+        section_row = widgets.HBox([
+            record_sec_text,
+            inj_sec_text,
+            post_init_text
+        ], layout=widgets.Layout(margin='0 0 10px 0'))
+        
+        # Save row
+        save_row = widgets.HBox([
+            save_path_text
+        ], layout=widgets.Layout(margin='0 0 10px 0'))
+        
+        # Parameter columns - organized in columns like synapse tuner
+        injection_params_col1 = widgets.VBox([
+            inj_amp_slider,
+            inj_delay_slider
+        ], layout=widgets.Layout(margin='0 10px 0 0'))
+        
+        injection_params_col2 = widgets.VBox([
+            inj_dur_slider,
+            tstop_slider
+        ], layout=widgets.Layout(margin='0 0 0 10px'))
+        
+        # Passive properties specific columns
+        passive_params_col1 = widgets.VBox([
+            inj_amp_slider,
+            inj_delay_slider
+        ], layout=widgets.Layout(margin='0 10px 0 0'))
+        
+        passive_params_col2 = widgets.VBox([
+            inj_dur_slider,
+            tstop_slider,
+            tau_method_dropdown
+        ], layout=widgets.Layout(margin='0 0 0 10px'))
+        
+        fi_params_col1 = widgets.VBox([
+            i_start_slider,
+            i_stop_slider
+        ], layout=widgets.Layout(margin='0 10px 0 0'))
+        
+        fi_params_col2 = widgets.VBox([
+            i_increment_slider,
+            inj_dur_slider  # Use duration for FI curve too
+        ], layout=widgets.Layout(margin='0 0 0 10px'))
+        
+        zap_params_col1 = widgets.VBox([
+            inj_amp_slider,
+            inj_delay_slider,
+            inj_dur_slider
+        ], layout=widgets.Layout(margin='0 10px 0 0'))
+        
+        zap_params_col2 = widgets.VBox([
+            tstop_slider,
+            fstart_slider,
+            fend_slider,
+            chirp_dropdown
+        ], layout=widgets.Layout(margin='0 0 0 10px'))
+        
+        # Function to update slider values based on method defaults
+        def update_slider_values(method):
+            """Update slider values to match the defaults for the selected method"""
+            if method in method_defaults:
+                defaults = method_defaults[method]
+                
+                # Update common sliders if they exist in defaults
+                if 'inj_amp' in defaults:
+                    inj_amp_slider.value = defaults['inj_amp']
+                if 'inj_delay' in defaults:
+                    inj_delay_slider.value = defaults['inj_delay']
+                if 'inj_dur' in defaults:
+                    inj_dur_slider.value = defaults['inj_dur']
+                if 'tstop' in defaults:
+                    tstop_slider.value = defaults['tstop']
+                    
+                # Update method-specific sliders
+                if method == 'fi_curve':
+                    if 'i_start' in defaults:
+                        i_start_slider.value = defaults['i_start']
+                    if 'i_stop' in defaults:
+                        i_stop_slider.value = defaults['i_stop']
+                    if 'i_increment' in defaults:
+                        i_increment_slider.value = defaults['i_increment']
+                        
+                elif method == 'impedance_amplitude_profile':
+                    if 'fstart' in defaults:
+                        fstart_slider.value = defaults['fstart']
+                    if 'fend' in defaults:
+                        fend_slider.value = defaults['fend']
+                    if 'chirp_type' in defaults:
+                        chirp_dropdown.value = defaults['chirp_type']
+                        
+                elif method == 'passive_properties':
+                    if 'tau_method' in defaults:
+                        tau_method_dropdown.value = defaults['tau_method']
+            
+        
+        # Function to update parameter visibility based on selected method
+        def update_params(*args):
+            method = method_dropdown.value
+            
+            # Update slider values to defaults for the selected method
+            update_slider_values(method)
+            
+            # Update parameter column visibility
+            if method == 'passive_properties':
+                param_columns.children = [widgets.HBox([passive_params_col1, passive_params_col2])]
+            elif method == 'current_injection':
+                param_columns.children = [widgets.HBox([injection_params_col1, injection_params_col2])]
+            elif method == 'fi_curve':
+                param_columns.children = [widgets.HBox([fi_params_col1, fi_params_col2])]
+            elif method == 'impedance_amplitude_profile':
+                param_columns.children = [widgets.HBox([zap_params_col1, zap_params_col2])]
+        
+        method_dropdown.observe(update_params, 'value')
+        
+        # Initialize parameter columns container
+        param_columns = widgets.VBox([widgets.HBox([passive_params_col1, passive_params_col2])])
+        
+        # Run function
+        def run_analysis(b):
+            output_area.clear_output()  # Clear immediately on click
+            with output_area:
+        
+                template = template_dropdown.value
+                method = method_dropdown.value
+                record_sec = record_sec_text.value
+                inj_sec = inj_sec_text.value
+                post_init = post_init_text.value if post_init_text.value else None
+        
+                kwargs = {
+                    'record_sec': record_sec,
+                    'inj_sec': inj_sec,
+                    'plot': True  # Always plot results
+                }
+        
+                if post_init:
+                    kwargs['post_init_function'] = post_init
+        
+                # Add method-specific parameters
+                if method == 'passive_properties':
+                    kwargs.update({
+                        'inj_amp': inj_amp_slider.value,
+                        'inj_delay': inj_delay_slider.value,
+                        'inj_dur': inj_dur_slider.value,
+                        'tstop': tstop_slider.value,
+                        'method': tau_method_dropdown.value
+                    })
+                elif method == 'current_injection':
+                    kwargs.update({
+                        'inj_amp': inj_amp_slider.value,
+                        'inj_delay': inj_delay_slider.value,
+                        'inj_dur': inj_dur_slider.value,
+                        'tstop': tstop_slider.value
+                    })
+                elif method == 'fi_curve':
+                    kwargs.update({
+                        'i_start': i_start_slider.value,
+                        'i_stop': i_stop_slider.value,
+                        'i_increment': i_increment_slider.value,
+                        'tstart': inj_delay_slider.value,
+                        'tdur': inj_dur_slider.value
+                    })
+                elif method == 'impedance_amplitude_profile':
+                    kwargs.update({
+                        'inj_amp': inj_amp_slider.value,
+                        'inj_delay': inj_delay_slider.value,
+                        'inj_dur': inj_dur_slider.value,
+                        'tstop': tstop_slider.value,
+                        'fstart': fstart_slider.value,
+                        'fend': fend_slider.value,
+                        'chirp_type': chirp_dropdown.value
+                    })
+        
+                print("="*60)
+                print(f"Running {method} for template: {template}")
+                print("="*60)
+                print("Parameters:")
+                for key, value in kwargs.items():
+                    print(f"  {key}: {value}")
+                print("-"*60)
+        
+                try:
+                    if method == 'passive_properties':
+                        result = self.passive_properties(template, **kwargs)
+        
+                    elif method == 'current_injection':
+                        result = self.current_injection(template, **kwargs)
+                    elif method == 'fi_curve':
+                        result = self.fi_curve(template, **kwargs)
+                    elif method == 'impedance_amplitude_profile':
+                        result = self.impedance_amplitude_profile(template, **kwargs)
+        
+        
+                except Exception as e:
+                    print("="*60)
+                    print(f"✗ Error running analysis: {e}")
+                    print("="*60)
+                    import traceback
+                    traceback.print_exc()
+        
+        # Reset function
+        def reset_to_defaults(b):
+            output_area.clear_output()  # Clear immediately on click
+            with output_area:
+                method = method_dropdown.value
+                update_slider_values(method)
+                print(f"Reset all parameters to defaults for {method}")
+        
+        # Save function
+        def save_plot(b):
+            path = save_path_text.value
+            if not path:
+                with output_area:
+                    print("Please enter a save path")
+                return
+            if self.last_figure is None:
+                with output_area:
+                    print("No plot to save. Run an analysis first.")
+                return
+            try:
+                self.last_figure.savefig(path)
+                with output_area:
+                    print(f"Plot saved to {path}")
+            except Exception as e:
+                with output_area:
+                    print(f"Error saving plot: {e}")
+        
+        run_button.on_click(run_analysis)
+        reset_button.on_click(reset_to_defaults)
+        save_button.on_click(save_plot)
+        
+        # Create main UI layout - matching synapse tuner structure
+        ui = widgets.VBox([
+            selection_row,
+            button_row, 
+            section_row,
+            param_columns,
+            save_row
+        ], layout=widgets.Layout(padding='10px'))
+        
+        # Display the interface - UI on top, output below (like synapse tuner)
+        display(ui)
+        display(output_area)
+        
+        # Initial update
+        update_params()
+
 
 # Example usage
 # profiler = Profiler('./temp/templates', './temp/mechanisms/modfiles')