bmtool 0.6.1__tar.gz → 0.6.3__tar.gz

{bmtool-0.6.1 → bmtool-0.6.3}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: bmtool
-Version: 0.6.1
+Version: 0.6.3
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 
@@ -31,6 +31,15 @@ Requires-Dist: pynmodlt
 Requires-Dist: xarray
 Requires-Dist: fooof
 Requires-Dist: requests
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
 
 # bmtool
 A collection of modules to make developing [Neuron](https://www.neuron.yale.edu/neuron/) and [BMTK](https://alleninstitute.github.io/bmtk/) models easier.
@@ -44,6 +53,7 @@ A collection of modules to make developing [Neuron](https://www.neuron.yale.edu/
 - [Synapses](#synapses-module)
 - [Connectors](#connectors-module)
 - [Bmplot](#bmplot-module)
+- [SLURM](#slurm-module)
 - [Graphs](#graphs-module)
 
 ## Getting Started
@@ -338,9 +348,10 @@ ex: [https://github.com/tjbanks/two-cell-hco](https://github.com/tjbanks/two-cel
 
 ### Synapses Module
 -[SynapticTuner](#synaptictuner)
+-Gap Junction tuner
 
 #### SynapticTuner - Aids in the tuning of synapses by printing out synaptic properties and giving the user sliders in a Jupyter notebook to tune the synapse. For more info view the example [here](examples/synapses/synaptic_tuner.ipynb)
-
+#### GapJunctionTuner - Provides jupyter sliders to tune for coupling coefficient in a similar style to the SynapticTuner an example can be viewed [here](examples/synapses/gap_junction_tuner.ipynb)
 
 ### Connectors Module
 - [UnidirectionConnector](#unidirectional-connector---unidirectional-connections-in-bmtk-network-model-with-given-probability-within-a-single-population-or-between-two-populations)
@@ -459,7 +470,8 @@ bmplot.plot_network_graph(config='config.json',sources='LA',targets='LA',tids='p
     
 ![png](readme_figures/output_35_0.png)
     
-
+## SLURM Module
+### This is an extremely helpful module that can simplify using SLURM too submit your models. There is also features to enable doing a seedSweep. This will vary the parameters of the simulation and make tuning the model easier. An example can be found [here](examples/SLURM/using_BlockRunner.ipynb) 
 
 
 ## Graphs Module

{bmtool-0.6.1 → bmtool-0.6.3}/README.md

@@ -10,6 +10,7 @@ A collection of modules to make developing [Neuron](https://www.neuron.yale.edu/
 - [Synapses](#synapses-module)
 - [Connectors](#connectors-module)
 - [Bmplot](#bmplot-module)
+- [SLURM](#slurm-module)
 - [Graphs](#graphs-module)
 
 ## Getting Started
@@ -304,9 +305,10 @@ ex: [https://github.com/tjbanks/two-cell-hco](https://github.com/tjbanks/two-cel
 
 ### Synapses Module
 -[SynapticTuner](#synaptictuner)
+-Gap Junction tuner
 
 #### SynapticTuner - Aids in the tuning of synapses by printing out synaptic properties and giving the user sliders in a Jupyter notebook to tune the synapse. For more info view the example [here](examples/synapses/synaptic_tuner.ipynb)
-
+#### GapJunctionTuner - Provides jupyter sliders to tune for coupling coefficient in a similar style to the SynapticTuner an example can be viewed [here](examples/synapses/gap_junction_tuner.ipynb)
 
 ### Connectors Module
 - [UnidirectionConnector](#unidirectional-connector---unidirectional-connections-in-bmtk-network-model-with-given-probability-within-a-single-population-or-between-two-populations)
@@ -425,7 +427,8 @@ bmplot.plot_network_graph(config='config.json',sources='LA',targets='LA',tids='p
     
 ![png](readme_figures/output_35_0.png)
     
-
+## SLURM Module
+### This is an extremely helpful module that can simplify using SLURM too submit your models. There is also features to enable doing a seedSweep. This will vary the parameters of the simulation and make tuning the model easier. An example can be found [here](examples/SLURM/using_BlockRunner.ipynb) 
 
 
 ## Graphs Module

{bmtool-0.6.1 → bmtool-0.6.3}/bmtool/SLURM.py

@@ -379,32 +379,36 @@ class BlockRunner:
         if self.webhook:
             message = "SIMULATION UPDATE: Simulations have been submited in parallel!"
             send_teams_message(self.webhook,message)
-        for i, block in enumerate(self.blocks):
-            if block.component_path == None:
-                raise Exception("Unable to use parallel submitter without defining the component path")
-            new_value = self.param_values[i]
-            
-            source_dir = block.component_path
-            destination_dir = f"{source_dir}{i+1}"
-            block.component_path = destination_dir
-
-            shutil.copytree(source_dir, destination_dir) # create new components folder 
-            json_file_path = os.path.join(destination_dir,self.json_file_path)
-            if self.syn_dict_list == None:
-                json_editor = seedSweep(json_file_path, self.param_name)
-                json_editor.edit_json(new_value)
-            else:
-                json_editor = multiSeedSweep(json_file_path,self.param_name,
-                                             self.syn_dict_list,base_ratio=1)
-                json_editor.edit_all_jsons(new_value)  
+        if self.param_values == None:
+            print(f"skipping json editing for block {block.block_name}",flush=True)
+        else:
+            for i, block in enumerate(self.blocks):
+                if block.component_path == None:
+                    raise Exception("Unable to use parallel submitter without defining the component path")
+                new_value = self.param_values[i]
+                
+                source_dir = block.component_path
+                destination_dir = f"{source_dir}{i+1}"
+                block.component_path = destination_dir
+
+                shutil.copytree(source_dir, destination_dir) # create new components folder 
+                json_file_path = os.path.join(destination_dir,self.json_file_path)
+                if self.syn_dict_list == None:
+                    json_editor = seedSweep(json_file_path, self.param_name)
+                    json_editor.edit_json(new_value)
+                else:
+                    json_editor = multiSeedSweep(json_file_path,self.param_name,
+                                                self.syn_dict_list,base_ratio=1)
+                    json_editor.edit_all_jsons(new_value)  
             
             # submit block with new component path 
             print(f"Submitting block: {block.block_name}", flush=True)
             block.submit_block()
-            if i == len(self.blocks) - 1:  
-                while not block.check_block_completed():
-                    print(f"Waiting for the last block {i} to complete...")
-                    time.sleep(self.check_interval)
+            if i == len(self.blocks) - 1:
+                if self.webook:  
+                    while not block.check_block_completed():
+                        print(f"Waiting for the last block {i} to complete...")
+                        time.sleep(self.check_interval)
                 
         if self.webhook:
             message = "SIMULATION UPDATE: Simulations are Done!"

{bmtool-0.6.1 → bmtool-0.6.3}/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-0.6.1 → bmtool-0.6.3}/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
+        #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.
-
-        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,116 @@ 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()
+
+class GapJunctionTuner:
+    def __init__(self, mechanisms_dir: str, templates_dir: str, general_settings: dict, conn_type_settings: dict):
+        neuron.load_mechanisms(mechanisms_dir)
+        h.load_file(templates_dir)
+        
+        self.general_settings = general_settings
+        self.conn_type_settings = conn_type_settings
+        
+        h.tstop = general_settings['tstart'] + general_settings['tdur'] + 100.
+        h.dt = general_settings['dt']  # Time step (resolution) of the simulation in ms
+        h.steps_per_ms = 1 / h.dt
+        h.celsius = general_settings['celsius']
+
+        self.cell_name = conn_type_settings['cell']
+        
+        # set up gap junctions
+        pc = h.ParallelContext()
+
+        self.cell1 = getattr(h, self.cell_name)()
+        self.cell2 = getattr(h, self.cell_name)()
+        
+        self.icl = h.IClamp(self.cell1.soma[0](0.5))
+        self.icl.delay = self.general_settings['tstart'] 
+        self.icl.dur = self.general_settings['tdur'] 
+        self.icl.amp = self.conn_type_settings['iclamp_amp'] # nA
+        
+        sec1 = list(self.cell1.all)[conn_type_settings['sec_id']]
+        sec2 = list(self.cell2.all)[conn_type_settings['sec_id']]
 
+        pc.source_var(sec1(conn_type_settings['sec_x'])._ref_v, 0, sec=sec1)
+        self.gap_junc_1 = h.Gap(sec1(0.5))
+        pc.target_var(self.gap_junc_1 ._ref_vgap, 1)
 
-    
+        pc.source_var(sec2(conn_type_settings['sec_x'])._ref_v, 1, sec=sec2)
+        self.gap_junc_2 = h.Gap(sec2(0.5))
+        pc.target_var(self.gap_junc_2._ref_vgap, 0)
+
+        pc.setup_transfer()
+    
+    def model(self,resistance):
+
+        self.gap_junc_1.g = resistance
+        self.gap_junc_2.g = resistance
+        
+        t_vec = h.Vector()
+        soma_v_1 = h.Vector()
+        soma_v_2 = h.Vector()
+        t_vec.record(h._ref_t)
+        soma_v_1.record(self.cell1.soma[0](0.5)._ref_v)
+        soma_v_2.record(self.cell2.soma[0](0.5)._ref_v)
+        
+        self.t_vec = t_vec
+        self.soma_v_1 = soma_v_1
+        self.soma_v_2 = soma_v_2
+        
+        h.finitialize(-70 * mV)
+        h.continuerun(h.tstop * ms)
+ 
+ 
+    def plot_model(self):
+        t_range = [self.general_settings['tstart'] - 100., self.general_settings['tstart']+self.general_settings['tdur'] + 100.]
+        t = np.array(self.t_vec)
+        v1 = np.array(self.soma_v_1)
+        v2 = np.array(self.soma_v_2)
+        tidx = (t >= t_range[0]) & (t <= t_range[1])
+
+        plt.figure()
+        plt.plot(t[tidx], v1[tidx], 'b', label=f'{self.cell_name} 1')
+        plt.plot(t[tidx], v2[tidx], 'r', label=f'{self.cell_name} 2')
+        plt.title(f"{self.cell_name} gap junction")
+        plt.xlabel('Time (ms)')
+        plt.ylabel('Membrane Voltage (mV)')
+        plt.legend()
+        plt.show()        
+
+
+    def coupling_coefficient(self,t, v1, v2, t_start, t_end, dt=h.dt):
+        t = np.asarray(t)
+        v1 = np.asarray(v1)
+        v2 = np.asarray(v2)
+        idx1 = np.nonzero(t < t_start)[0][-1]
+        idx2 = np.nonzero(t < t_end)[0][-1]
+        return (v2[idx2] - v2[idx1]) / (v1[idx2] - v1[idx1])
+
+    
+    def run_model(self):
+        w_run = widgets.Button(description='Run', icon='history', button_style='primary')
+        values = [i * 10**-4 for i in range(1, 101)]  # From 1e-4 to 1e-2
+
+        # Create the SelectionSlider widget with appropriate formatting
+        resistance = widgets.SelectionSlider(
+            options=[("%g"%i,i) for i in values],  # Use scientific notation for display
+            value=10**-3,  # Default value
+            description='Resistance: ',
+            continuous_update=True
+)
+
+        ui = VBox([w_run,resistance])
+        display(ui)
+        def on_button(*args):
+            clear_output()
+            display(ui)
+            resistance_for_gap = resistance.value
+            self.model(resistance_for_gap)
+            self.plot_model()
+            cc = self.coupling_coefficient(self.t_vec, self.soma_v_1, self.soma_v_2, 500, 1000)
+            print(f"coupling_coefficient is {cc:0.4f}")
+
+        on_button()    
+        w_run.on_click(on_button)

{bmtool-0.6.1 → bmtool-0.6.3}/bmtool.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: bmtool
-Version: 0.6.1
+Version: 0.6.3
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 
@@ -31,6 +31,15 @@ Requires-Dist: pynmodlt
 Requires-Dist: xarray
 Requires-Dist: fooof
 Requires-Dist: requests
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: summary
 
 # bmtool
 A collection of modules to make developing [Neuron](https://www.neuron.yale.edu/neuron/) and [BMTK](https://alleninstitute.github.io/bmtk/) models easier.
@@ -44,6 +53,7 @@ A collection of modules to make developing [Neuron](https://www.neuron.yale.edu/
 - [Synapses](#synapses-module)
 - [Connectors](#connectors-module)
 - [Bmplot](#bmplot-module)
+- [SLURM](#slurm-module)
 - [Graphs](#graphs-module)
 
 ## Getting Started
@@ -338,9 +348,10 @@ ex: [https://github.com/tjbanks/two-cell-hco](https://github.com/tjbanks/two-cel
 
 ### Synapses Module
 -[SynapticTuner](#synaptictuner)
+-Gap Junction tuner
 
 #### SynapticTuner - Aids in the tuning of synapses by printing out synaptic properties and giving the user sliders in a Jupyter notebook to tune the synapse. For more info view the example [here](examples/synapses/synaptic_tuner.ipynb)
-
+#### GapJunctionTuner - Provides jupyter sliders to tune for coupling coefficient in a similar style to the SynapticTuner an example can be viewed [here](examples/synapses/gap_junction_tuner.ipynb)
 
 ### Connectors Module
 - [UnidirectionConnector](#unidirectional-connector---unidirectional-connections-in-bmtk-network-model-with-given-probability-within-a-single-population-or-between-two-populations)
@@ -459,7 +470,8 @@ bmplot.plot_network_graph(config='config.json',sources='LA',targets='LA',tids='p
     
 ![png](readme_figures/output_35_0.png)
     
-
+## SLURM Module
+### This is an extremely helpful module that can simplify using SLURM too submit your models. There is also features to enable doing a seedSweep. This will vary the parameters of the simulation and make tuning the model easier. An example can be found [here](examples/SLURM/using_BlockRunner.ipynb) 
 
 
 ## Graphs Module

{bmtool-0.6.1 → bmtool-0.6.3}/setup.py

@@ -6,7 +6,7 @@ with open("README.md", "r") as fh:
 
 setup(
     name="bmtool",
-    version='0.6.1',
+    version='0.6.3',
     author="Neural Engineering Laboratory at the University of Missouri",
     author_email="gregglickert@mail.missouri.edu",
     description="BMTool",
@@ -41,7 +41,8 @@ setup(
         'Topic :: Software Development :: Libraries :: Python Modules',
         "Operating System :: OS Independent",
     ],
-    packages=find_packages(exclude=['tests']),
+    packages=find_packages(),  # Automatically finds all packages
+    include_package_data=True,
     entry_points={
         'console_scripts': [
             'bmtool = bmtool.manage:cli'