bmtool 0.6.1__py3-none-any.whl → 0.6.2__py3-none-any.whl

bmtool/bmplot.py

@@ -21,7 +21,6 @@ import os
 import sys
 import re
 from typing import Optional, Dict
-from .analysis.spikes import load_spikes_to_df
 
 from .util.util import CellVarsFile,load_nodes_from_config #, missing_units
 from bmtk.analyzer.utils import listify

bmtool/synapses.py

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

{bmtool-0.6.1.dist-info → bmtool-0.6.2.dist-info}/METADATA

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

{bmtool-0.6.1.dist-info → bmtool-0.6.2.dist-info}/RECORD

@@ -1,13 +1,13 @@
 bmtool/SLURM.py,sha256=woANwh6ToP5nsEkVX1qlINvkfGMp3P7Roq4O8X611M8,16371
 bmtool/__init__.py,sha256=ZStTNkAJHJxG7Pwiy5UgCzC4KlhMS5pUNPtUJZVwL_Y,136
 bmtool/__main__.py,sha256=TmFkmDxjZ6250nYD4cgGhn-tbJeEm0u-EMz2ajAN9vE,650
-bmtool/bmplot.py,sha256=HuzBRrVsD6xFM-siWdT_t6XqffFhK6LFcGF7RttR6pQ,54013
+bmtool/bmplot.py,sha256=Im-Jrv8TK3CmTtksFzHrVogAve0l9ZwRrCW4q2MFRiA,53966
 bmtool/connectors.py,sha256=2vVUsqYMaCuWZ-4C5eUzqwsFItFM9vm0ytZdRQdWgoc,72243
 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=cBa4NAYob8BxCFi04FfVcqDs_LNYJrP4vscgnT8Rk1c,27498
+bmtool/synapses.py,sha256=dXUnPa9-8bmeSrJqD3tnRuXEZFqv6WD0oZtIgNqUt04,28535
 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.1.dist-info/LICENSE,sha256=qrXg2jj6kz5d0EnN11hllcQt2fcWVNumx0xNbV05nyM,1068
-bmtool-0.6.1.dist-info/METADATA,sha256=Ir2-vUb_0qfRxIJlj5iDuKVbnp5gFe6SOsqgCBWRdU4,19113
-bmtool-0.6.1.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
-bmtool-0.6.1.dist-info/entry_points.txt,sha256=0-BHZ6nUnh0twWw9SXNTiRmKjDnb1VO2DfG_-oprhAc,45
-bmtool-0.6.1.dist-info/top_level.txt,sha256=gpd2Sj-L9tWbuJEd5E8C8S8XkNm5yUE76klUYcM-eWM,7
-bmtool-0.6.1.dist-info/RECORD,,
+bmtool-0.6.2.dist-info/LICENSE,sha256=qrXg2jj6kz5d0EnN11hllcQt2fcWVNumx0xNbV05nyM,1068
+bmtool-0.6.2.dist-info/METADATA,sha256=cgrIq8s8qxEYPsLKcr_iqgmQy1hk8B_n_dsMyCLnw2w,19113
+bmtool-0.6.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+bmtool-0.6.2.dist-info/entry_points.txt,sha256=0-BHZ6nUnh0twWw9SXNTiRmKjDnb1VO2DfG_-oprhAc,45
+bmtool-0.6.2.dist-info/top_level.txt,sha256=gpd2Sj-L9tWbuJEd5E8C8S8XkNm5yUE76klUYcM-eWM,7
+bmtool-0.6.2.dist-info/RECORD,,

{bmtool-0.6.1.dist-info → bmtool-0.6.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.5.0)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any