bmtool 0.6.5.1__py3-none-any.whl → 0.6.6.2__py3-none-any.whl

bmtool/synapses.py

@@ -405,6 +405,10 @@ class SynapseTuner:
         ------
         - This function is based on experiments from the Allen Database.
         """
+        # lets also set the train drive and delay here
+        self.train_freq = freq
+        self.train_delay = delay
+        
         n_init_pulse = 8
         n_ending_pulse = 4
         self.nstim.start = self.general_settings['tstart']
@@ -500,7 +504,7 @@ class SynapseTuner:
         
         if print_math:
             print("\n" + "="*40)
-            print("Short Term Plasticity Results")
+            print(f"Short Term Plasticity Results for {self.train_freq}Hz with {self.train_delay} Delay")
             print("="*40)
             print("PPR: Above 1 is facilitating, below 1 is depressing.")
             print("Induction: Above 0 is facilitating, below 0 is depressing.")
@@ -682,6 +686,100 @@ class SynapseTuner:
 
         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.
+        
+        Parameters:
+        -----------
+        freqs : list, optional
+            List of frequencies to analyze (in Hz)
+        delay : float, optional
+            Delay between pulse trains in ms
+        plot : bool, optional
+            Whether to plot the results
+            
+        Returns:
+        --------
+        dict
+            Dictionary containing frequency-dependent metrics
+        """
+        results = {
+            'frequencies': freqs,
+            'ppr': [],
+            'induction': [],
+            'recovery': []
+        }
+        
+        # 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 = self._calc_ppr_induction_recovery(amp, print_math=False)
+            
+            results['ppr'].append(float(ppr))
+            results['induction'].append(float(induction))
+            results['recovery'].append(float(recovery))
+        
+        # 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
+        """
+        fig, (ax1, ax2, ax3) = plt.subplots(1, 3, figsize=(15, 5))
+        
+        
+        # Plot PPR
+        if log_plot:
+            ax1.semilogx(results['frequencies'], results['ppr'], 'o-')
+        else:
+            ax1.plot(results['frequencies'], results['ppr'], 'o-')
+        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.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()
 
 class GapJunctionTuner:
     def __init__(self, mechanisms_dir: str, templates_dir: str, general_settings: dict, conn_type_settings: dict):
@@ -829,13 +927,13 @@ class SynapseOptimizer:
         return np.array([normalized_params[i] * self.param_scales[name] for i, name in enumerate(param_names)])
         
     def _calculate_metrics(self) -> Dict[str, float]:
-        """Calculate standard metrics from the current simulation"""
-        self.tuner._simulate_model(50, 250) # 50 Hz with 250ms Delay
+        """Calculate standard metrics from the current simulation using specified frequency"""
+        self.tuner._simulate_model(self.train_frequency, self.train_delay)
         amp = self.tuner._response_amplitude()
         ppr, induction, recovery = self.tuner._calc_ppr_induction_recovery(amp, print_math=False)
         amp = self.tuner._find_max_amp(amp)
         return {
-            'induction': float(induction),  # Ensure these are scalar values
+            'induction': float(induction),
             'ppr': float(ppr),
             'recovery': float(recovery),
             'max_amplitude': float(amp)
@@ -874,15 +972,40 @@ class SynapseOptimizer:
         
         return error
     
-    def optimize_parameters(self, 
-                          target_metrics: Dict[str, float],
-                          param_bounds: Dict[str, Tuple[float, float]],
-                          cost_function: Optional[Callable] = None,
-                          method: str = 'SLSQP',init_guess='random') -> SynapseOptimizationResult:
+    def optimize_parameters(self, target_metrics: Dict[str, float],
+                            param_bounds: Dict[str, Tuple[float, float]],
+                            train_frequency: float = 50,train_delay: float = 250,
+                            cost_function: Optional[Callable] = None,
+                            method: str = 'SLSQP',init_guess='random') -> SynapseOptimizationResult:
         """
         Optimize synaptic parameters using custom cost function
-        """
+        
+        Parameters:
+        -----------
+        target_metrics : Dict[str, float]
+            Target values for synaptic metrics
+        param_bounds : Dict[str, Tuple[float, float]]
+            Bounds for each parameter to optimize
+        train_frequency : float, optional
+            Frequency of the stimulus train in Hz (default: 50)
+        train_delay : float, optional
+            Delay between pulse trains in ms (default: 250)
+        cost_function : Optional[Callable]
+            Custom cost function for optimization
+        method : str, optional
+            Optimization method to use (default: 'SLSQP')
+        init_guess : str, optional
+            Method for initial parameter guess ('random' or 'middle_guess')
+            
+        Returns:
+        --------
+        SynapseOptimizationResult
+            Results of the optimization
+    """
         self.optimization_history = []
+        self.train_frequency = train_frequency
+        self.train_delay = train_delay
+        
         param_names = list(param_bounds.keys())
         bounds = [param_bounds[name] for name in param_names]
         

{bmtool-0.6.5.1.dist-info → bmtool-0.6.6.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: bmtool
-Version: 0.6.5.1
+Version: 0.6.6.2
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 

{bmtool-0.6.5.1.dist-info → bmtool-0.6.6.2.dist-info}/RECORD

@@ -7,7 +7,7 @@ bmtool/graphs.py,sha256=K8BiughRUeXFVvAgo8UzrwpSClIVg7UfmIcvtEsEsk0,6020
 bmtool/manage.py,sha256=_lCU0qBQZ4jSxjzAJUd09JEetb--cud7KZgxQFbLGSY,657
 bmtool/plot_commands.py,sha256=Tqujyf0c0u8olhiHOMwgUSJXIIE1hgjv6otb25G9cA0,12298
 bmtool/singlecell.py,sha256=MQiLucsI6OBIjtcJra3Z9PTFQOE-Zn5ST-R9SmFvrbQ,27049
-bmtool/synapses.py,sha256=jQFOpi9hzzBEijDQ7dsWfcxW-DtxN9v0UWxCqDSlcTs,48466
+bmtool/synapses.py,sha256=KyvDtoL7_mbXLr7TXaaeFTjqUM_ZXoVzSABQ69eTAHI,52876
 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.5.1.dist-info/LICENSE,sha256=qrXg2jj6kz5d0EnN11hllcQt2fcWVNumx0xNbV05nyM,1068
-bmtool-0.6.5.1.dist-info/METADATA,sha256=mCHLJ27JL7d17fe5atQTwQGkVfzVQ6MhqHlhgbm8yh4,20226
-bmtool-0.6.5.1.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-bmtool-0.6.5.1.dist-info/entry_points.txt,sha256=0-BHZ6nUnh0twWw9SXNTiRmKjDnb1VO2DfG_-oprhAc,45
-bmtool-0.6.5.1.dist-info/top_level.txt,sha256=gpd2Sj-L9tWbuJEd5E8C8S8XkNm5yUE76klUYcM-eWM,7
-bmtool-0.6.5.1.dist-info/RECORD,,
+bmtool-0.6.6.2.dist-info/LICENSE,sha256=qrXg2jj6kz5d0EnN11hllcQt2fcWVNumx0xNbV05nyM,1068
+bmtool-0.6.6.2.dist-info/METADATA,sha256=ufAGAV4laD-Jo5B7L77lHrfMgb4_V7iv_6u1Lf3O1Qc,20226
+bmtool-0.6.6.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+bmtool-0.6.6.2.dist-info/entry_points.txt,sha256=0-BHZ6nUnh0twWw9SXNTiRmKjDnb1VO2DfG_-oprhAc,45
+bmtool-0.6.6.2.dist-info/top_level.txt,sha256=gpd2Sj-L9tWbuJEd5E8C8S8XkNm5yUE76klUYcM-eWM,7
+bmtool-0.6.6.2.dist-info/RECORD,,