bmtool 0.7.8__tar.gz → 0.7.8.1__tar.gz

{bmtool-0.7.8 → bmtool-0.7.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bmtool
-Version: 0.7.8
+Version: 0.7.8.1
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 

{bmtool-0.7.8 → bmtool-0.7.8.1}/bmtool/SLURM.py

@@ -409,6 +409,16 @@ class BlockRunner:
         self.param_name = param_name
         self.json_file_path = json_file_path
         self.syn_dict = syn_dict
+        # Store original component paths to restore later
+        self.original_component_paths = [block.component_path for block in self.blocks]
+
+    def restore_component_paths(self):
+        """
+        Restores all blocks' component_path to their original values.
+        """
+        for i, block in enumerate(self.blocks):
+            block.component_path = self.original_component_paths[i]
+        print("Component paths restored to original values.", flush=True)
 
     def submit_blocks_sequentially(self):
         """
@@ -473,6 +483,8 @@ class BlockRunner:
 
             print(f"Block {block.block_name} completed.", flush=True)
         print("All blocks are done!", flush=True)
+        # Restore component paths to their original values
+        self.restore_component_paths()
         if self.webhook:
             message = "SIMULATION UPDATE: Simulation are Done!"
             send_teams_message(self.webhook, message)
@@ -531,6 +543,9 @@ class BlockRunner:
                     print(f"Waiting for the last block {i} to complete...")
                     time.sleep(self.check_interval)
 
+        print("All blocks are done!", flush=True)
+        # Restore component paths to their original values
+        self.restore_component_paths()
         if self.webhook:
             message = "SIMULATION UPDATE: Simulations are Done!"
             send_teams_message(self.webhook, message)

{bmtool-0.7.8 → bmtool-0.7.8.1}/bmtool/synapses.py

@@ -3078,490 +3078,595 @@ class GapJunctionTuner:
         
         return df
         
+# optimizers!
 
-class GapJunctionTuner:
-    def __init__(
-        self,
-        mechanisms_dir: Optional[str] = None,
-        templates_dir: Optional[str] = None,
-        config: Optional[str] = None,
-        general_settings: Optional[dict] = None,
-        conn_type_settings: Optional[dict] = None,
-        hoc_cell: Optional[object] = None,
-    ):
-        """
-        Initialize the GapJunctionTuner class.
-
-        Parameters:
-        -----------
-        mechanisms_dir : str
-            Directory path containing the compiled mod files needed for NEURON mechanisms.
-        templates_dir : str
-            Directory path containing cell template files (.hoc or .py) loaded into NEURON.
-        config : str
-            Path to a BMTK config.json file. Can be used to load mechanisms, templates, and other settings.
-        general_settings : dict
-            General settings dictionary including parameters like simulation time step, duration, and temperature.
-        conn_type_settings : dict
-            A dictionary containing connection-specific settings for gap junctions.
-        hoc_cell : object, optional
-            An already loaded NEURON cell object. If provided, template loading and cell creation will be skipped.
-        """
-        self.hoc_cell = hoc_cell
-
-        if hoc_cell is None:
-            if config is None and (mechanisms_dir is None or templates_dir is None):
-                raise ValueError(
-                    "Either a config file, both mechanisms_dir and templates_dir, or a hoc_cell must be provided."
-                )
-
-            if config is None:
-                neuron.load_mechanisms(mechanisms_dir)
-                h.load_file(templates_dir)
-            else:
-                # this will load both mechs and templates
-                load_templates_from_config(config)
 
-        # Use default general settings if not provided, merge with user-provided
-        if general_settings is None:
-            self.general_settings: dict = DEFAULT_GAP_JUNCTION_GENERAL_SETTINGS.copy()
-        else:
-            self.general_settings = {**DEFAULT_GAP_JUNCTION_GENERAL_SETTINGS, **general_settings}
-        self.conn_type_settings = conn_type_settings
+@dataclass
+class SynapseOptimizationResult:
+    """Container for synaptic parameter optimization results"""
 
-        self._syn_params_cache = {}
-        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:
-            raise ValueError("conn_type_settings must be provided or config must be given to load gap junction connections from")
-        self.current_connection = list(self.conn_type_settings.keys())[0]
-        self.conn = self.conn_type_settings[self.current_connection]
+    optimal_params: Dict[str, float]
+    achieved_metrics: Dict[str, float]
+    target_metrics: Dict[str, float]
+    error: float
+    optimization_path: List[Dict[str, float]]
 
-        h.tstop = self.general_settings["tstart"] + self.general_settings["tdur"] + 100.0
-        h.dt = self.general_settings["dt"]  # Time step (resolution) of the simulation in ms
-        h.steps_per_ms = 1 / h.dt
-        h.celsius = self.general_settings["celsius"]
 
-        # Clean up any existing parallel context before setting up gap junctions
-        try:
-            pc_temp = h.ParallelContext()
-            pc_temp.done()  # Clean up any existing parallel context
-        except:
-            pass  # Ignore errors if no existing context
-        
-        # Force cleanup
-        import gc
-        gc.collect()
-
-        # set up gap junctions
-        self.pc = h.ParallelContext()
-
-        # Use provided hoc_cell or create new cells
-        if self.hoc_cell is not None:
-            self.cell1 = self.hoc_cell
-            # For gap junctions, we need two cells, so create a second one if using hoc_cell
-            self.cell_name = self.conn['cell']
-            self.cell2 = getattr(h, self.cell_name)()
-        else:
-            print(self.conn)
-            self.cell_name = self.conn['cell']
-            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.general_settings["iclamp_amp"]  # nA
-
-        sec1 = list(self.cell1.all)[self.conn["sec_id"]]
-        sec2 = list(self.cell2.all)[self.conn["sec_id"]]
-
-        # Use unique IDs to avoid conflicts with existing parallel context setups
-        import time
-        unique_id = int(time.time() * 1000) % 10000  # Use timestamp as unique base ID
-        
-        self.pc.source_var(sec1(self.conn["sec_x"])._ref_v, unique_id, sec=sec1)
-        self.gap_junc_1 = h.Gap(sec1(0.5))
-        self.pc.target_var(self.gap_junc_1._ref_vgap, unique_id + 1)
-
-        self.pc.source_var(sec2(self.conn["sec_x"])._ref_v, unique_id + 1, sec=sec2)
-        self.gap_junc_2 = h.Gap(sec2(0.5))
-        self.pc.target_var(self.gap_junc_2._ref_vgap, unique_id)
-
-        self.pc.setup_transfer()
-        
-        # Now it's safe to initialize NEURON
-        h.finitialize()
-
-    def _load_synaptic_params_from_config(self, config: dict, dynamics_params: str) -> dict:
-        try:
-            # Get the synaptic models directory from config
-            synaptic_models_dir = config.get('components', {}).get('synaptic_models_dir', '')
-            if synaptic_models_dir:
-                # Handle path variables
-                if synaptic_models_dir.startswith('$'):
-                    # This is a placeholder, try to resolve it
-                    config_dir = os.path.dirname(config.get('config_path', ''))
-                    synaptic_models_dir = synaptic_models_dir.replace('$COMPONENTS_DIR', 
-                                                                    os.path.join(config_dir, 'components'))
-                    synaptic_models_dir = synaptic_models_dir.replace('$BASE_DIR', config_dir)
-                
-                dynamics_file = os.path.join(synaptic_models_dir, dynamics_params)
-                
-                if os.path.exists(dynamics_file):
-                    with open(dynamics_file, 'r') as f:
-                        return json.load(f)
-                else:
-                    print(f"Warning: Dynamics params file not found: {dynamics_file}")
-        except Exception as e:
-            print(f"Warning: Error loading synaptic parameters: {e}")
-        
-        return {}
+class SynapseOptimizer:
+    def __init__(self, tuner):
+        """
+        Initialize the synapse optimizer with parameter scaling
 
-    def _load_available_networks(self) -> None:
+        Parameters:
+        -----------
+        tuner : SynapseTuner
+            Instance of the SynapseTuner class
         """
-        Load available network names from the config file for the network dropdown feature.
-        
-        This method is automatically called during initialization when a config file is provided.
-        It populates the available_networks list which enables the network dropdown in 
-        InteractiveTuner when multiple networks are available.
-        
-        Network Dropdown Behavior:
-        -------------------------
-        - If only one network exists: No network dropdown is shown
-        - If multiple networks exist: Network dropdown appears next to connection dropdown
-        - Networks are loaded from the edges data in the config file
-        - Current network defaults to the first available if not specified during init
+        self.tuner = tuner
+        self.optimization_history = []
+        self.param_scales = {}
+
+    def _normalize_params(self, params: np.ndarray, param_names: List[str]) -> np.ndarray:
         """
-        if self.config is None:
-            self.available_networks = []
-            return
-            
-        try:
-            edges = load_edges_from_config(self.config)
-            self.available_networks = list(edges.keys())
-            
-            # Set current network to first available if not specified
-            if self.current_network is None and self.available_networks:
-                self.current_network = self.available_networks[0]
-        except Exception as e:
-            print(f"Warning: Could not load networks from config: {e}")
-            self.available_networks = []
+        Normalize parameters to similar scales for better optimization performance.
 
-    def _build_conn_type_settings_from_config(self, config_path: str) -> Dict[str, dict]:
-        # Load configuration and get nodes and edges using util.py methods
-        config = load_config(config_path)
-        # Ensure the config dict knows its source path so path substitutions can be resolved
-        try:
-            config['config_path'] = config_path
-        except Exception:
-            pass
-        nodes = load_nodes_from_config(config_path)
-        edges = load_edges_from_config(config_path)
-        
-        conn_type_settings = {}
-        
-        # Process all edge datasets
-        for edge_dataset_name, edge_df in edges.items():
-            if edge_df.empty:
-                continue
-            
-            # Merging with node data to get model templates
-            source_node_df = None
-            target_node_df = None
-            
-            # First, try to deterministically parse the edge_dataset_name for patterns like '<src>_to_<tgt>'
-            if '_to_' in edge_dataset_name:
-                parts = edge_dataset_name.split('_to_')
-                if len(parts) == 2:
-                    src_name, tgt_name = parts
-                    if src_name in nodes:
-                        source_node_df = nodes[src_name].add_prefix('source_')
-                    if tgt_name in nodes:
-                        target_node_df = nodes[tgt_name].add_prefix('target_')
-            
-            # If not found by parsing name, fall back to inspecting a sample edge row
-            if source_node_df is None or target_node_df is None:
-                sample_edge = edge_df.iloc[0] if len(edge_df) > 0 else None
-                if sample_edge is not None:
-                    source_pop_name = sample_edge.get('source_population', '')
-                    target_pop_name = sample_edge.get('target_population', '')
-                    if source_pop_name in nodes:
-                        source_node_df = nodes[source_pop_name].add_prefix('source_')
-                    if target_pop_name in nodes:
-                        target_node_df = nodes[target_pop_name].add_prefix('target_')
-            
-            # As a last resort, attempt to heuristically match
-            if source_node_df is None or target_node_df is None:
-                for pop_name, node_df in nodes.items():
-                    if source_node_df is None and (edge_dataset_name.startswith(pop_name) or edge_dataset_name.endswith(pop_name)):
-                        source_node_df = node_df.add_prefix('source_')
-                    if target_node_df is None and (edge_dataset_name.startswith(pop_name) or edge_dataset_name.endswith(pop_name)):
-                        target_node_df = node_df.add_prefix('target_')
-            
-            if source_node_df is None or target_node_df is None:
-                print(f"Warning: Could not find node data for edge dataset {edge_dataset_name}")
-                continue
-            
-            # Merge edge data with source node info
-            edges_with_source = pd.merge(
-                edge_df.reset_index(), 
-                source_node_df, 
-                how='left', 
-                left_on='source_node_id', 
-                right_index=True
-            )
-            
-            # Merge with target node info
-            edges_with_nodes = pd.merge(
-                edges_with_source, 
-                target_node_df, 
-                how='left', 
-                left_on='target_node_id', 
-                right_index=True
-            )
-            
-            # Skip edge datasets that don't have gap junction information
-            if 'is_gap_junction' not in edges_with_nodes.columns:
-                continue
-            
-            # Filter to only gap junction edges
-            # Handle NaN values in is_gap_junction column
-            gap_junction_mask = edges_with_nodes['is_gap_junction'].fillna(False) == True
-            gap_junction_edges = edges_with_nodes[gap_junction_mask]
-            if gap_junction_edges.empty:
-                continue
-            
-            # Get unique edge types from the gap junction edges
-            if 'edge_type_id' in gap_junction_edges.columns:
-                edge_types = gap_junction_edges['edge_type_id'].unique()
-            else:
-                edge_types = [None]  # Single edge type
-            
-            # Process each edge type
-            for edge_type_id in edge_types:
-                # Filter edges for this type
-                if edge_type_id is not None:
-                    edge_type_data = gap_junction_edges[gap_junction_edges['edge_type_id'] == edge_type_id]
-                else:
-                    edge_type_data = gap_junction_edges
-                
-                if len(edge_type_data) == 0:
-                    continue
-                
-                # Get representative edge for this type
-                edge_info = edge_type_data.iloc[0]
-                
-                # Process gap junction
-                source_model_template = edge_info.get('source_model_template', '')
-                target_model_template = edge_info.get('target_model_template', '')
-                
-                source_cell_type = source_model_template.replace('hoc:', '') if source_model_template.startswith('hoc:') else source_model_template
-                target_cell_type = target_model_template.replace('hoc:', '') if target_model_template.startswith('hoc:') else target_model_template
-                
-                if source_cell_type != target_cell_type:
-                    continue  # Only process gap junctions between same cell types
-                
-                source_pop = edge_info.get('source_pop_name', '')
-                target_pop = edge_info.get('target_pop_name', '')
-                
-                conn_name = f"{source_pop}2{target_pop}_gj"
-                if edge_type_id is not None:
-                    conn_name += f"_type_{edge_type_id}"
-                
-                conn_settings = {
-                    'cell': source_cell_type,
-                    'sec_id': 0,
-                    'sec_x': 0.5,
-                    'iclamp_amp': -0.01,
-                    'spec_syn_param': {}
-                }
-                
-                # Load dynamics params
-                dynamics_file_name = edge_info.get('dynamics_params', '')
-                if dynamics_file_name and dynamics_file_name.upper() != 'NULL':
-                    try:
-                        syn_params = self._load_synaptic_params_from_config(config, dynamics_file_name)
-                        conn_settings['spec_syn_param'] = syn_params
-                    except Exception as e:
-                        print(f"Warning: could not load dynamics_params file '{dynamics_file_name}': {e}")
-                
-                conn_type_settings[conn_name] = conn_settings
-        
-        return conn_type_settings
+        Parameters:
+        -----------
+        params : np.ndarray
+            Original parameter values.
+        param_names : List[str]
+            Names of the parameters corresponding to the values.
 
-    def _switch_connection(self, new_connection: str) -> None:
+        Returns:
+        --------
+        np.ndarray
+            Normalized parameter values.
         """
-        Switch to a different gap junction connection and update all related properties.
-        
+        return np.array([params[i] / self.param_scales[name] for i, name in enumerate(param_names)])
+
+    def _denormalize_params(
+        self, normalized_params: np.ndarray, param_names: List[str]
+    ) -> np.ndarray:
+        """
+        Convert normalized parameters back to original scale.
+
         Parameters:
         -----------
-        new_connection : str
-            Name of the new connection type to switch to.
+        normalized_params : np.ndarray
+            Normalized parameter values.
+        param_names : List[str]
+            Names of the parameters corresponding to the normalized values.
+
+        Returns:
+        --------
+        np.ndarray
+            Denormalized parameter values in their original scale.
         """
-        if new_connection not in self.conn_type_settings:
-            raise ValueError(f"Connection '{new_connection}' not found in conn_type_settings")
-        
-        # Update current connection
-        self.current_connection = new_connection
-        self.conn = self.conn_type_settings[new_connection]
-        
-        # Check if cell type changed
-        new_cell_name = self.conn['cell']
-        if self.cell_name != new_cell_name:
-            self.cell_name = new_cell_name
-            
-            # Recreate cells
-            if self.hoc_cell is None:
-                self.cell1 = getattr(h, self.cell_name)()
-                self.cell2 = getattr(h, self.cell_name)()
-            else:
-                # For hoc_cell, recreate the second cell
-                self.cell2 = getattr(h, self.cell_name)()
-            
-            # Recreate IClamp
-            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.general_settings["iclamp_amp"]
+        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.
+
+        This method runs either a single event simulation, a train input simulation,
+        or both based on configuration flags, and calculates relevant synaptic metrics.
+
+        Returns:
+        --------
+        Dict[str, float]
+            Dictionary of calculated metrics including:
+            - induction: measure of synaptic facilitation/depression
+            - ppr: paired-pulse ratio
+            - recovery: recovery from facilitation/depression
+            - max_amplitude: maximum synaptic response amplitude
+            - rise_time: time for synaptic response to rise from 20% to 80% of peak
+            - decay_time: time constant of synaptic response decay
+            - latency: synaptic response latency
+            - half_width: synaptic response half-width
+            - baseline: baseline current
+            - amp: peak amplitude from syn_props
+        """
+        # Set these to 0 for when we return the dict
+        induction = 0
+        ppr = 0
+        recovery = 0
+        simple_ppr = 0
+        amp = 0
+        rise_time = 0
+        decay_time = 0
+        latency = 0
+        half_width = 0
+        baseline = 0
+        syn_amp = 0
+
+        if self.run_single_event:
+            self.tuner.SingleEvent(plot_and_print=False)
+            # Use the attributes set by SingleEvent method
+            rise_time = getattr(self.tuner, "rise_time", 0)
+            decay_time = getattr(self.tuner, "decay_time", 0)
+            # Get additional syn_props directly
+            syn_props = self.tuner._get_syn_prop()
+            latency = syn_props.get("latency", 0)
+            half_width = syn_props.get("half_width", 0)
+            baseline = syn_props.get("baseline", 0)
+            syn_amp = syn_props.get("amp", 0)
+
+        if self.run_train_input:
+            self.tuner._simulate_model(self.train_frequency, self.train_delay)
+            amp = self.tuner._response_amplitude()
+            ppr, induction, recovery, simple_ppr = self.tuner._calc_ppr_induction_recovery(
+                amp, print_math=False
+            )
+            amp = self.tuner._find_max_amp(amp)
+
+        return {
+            "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),
+            "latency": float(latency),
+            "half_width": float(half_width),
+            "baseline": float(baseline),
+            "amp": float(syn_amp),
+        }
+
+    def _default_cost_function(
+        self, metrics: Dict[str, float], target_metrics: Dict[str, float]
+    ) -> float:
+        """
+        Default cost function that minimizes the squared difference between achieved and target induction.
+
+        Parameters:
+        -----------
+        metrics : Dict[str, float]
+            Dictionary of calculated metrics from the current simulation.
+        target_metrics : Dict[str, float]
+            Dictionary of target metrics to optimize towards.
+
+        Returns:
+        --------
+        float
+            The squared error between achieved and target induction.
+        """
+        return float((metrics["induction"] - target_metrics["induction"]) ** 2)
+
+    def _objective_function(
+        self,
+        normalized_params: np.ndarray,
+        param_names: List[str],
+        cost_function: Callable,
+        target_metrics: Dict[str, float],
+    ) -> float:
+        """
+        Calculate error using provided cost function
+        """
+        # Denormalize parameters
+        params = self._denormalize_params(normalized_params, param_names)
+
+        # Set parameters
+        for name, value in zip(param_names, params):
+            setattr(self.tuner.syn, name, value)
+
+        # just do this and have the SingleEvent handle it
+        if self.run_single_event:
+            self.tuner.using_optimizer = True
+            self.tuner.param_names = param_names
+            self.tuner.params = params
+
+        # Calculate metrics and error
+        metrics = self._calculate_metrics()
+        error = float(cost_function(metrics, target_metrics))  # Ensure error is scalar
+
+        # Store history with denormalized values
+        history_entry = {
+            "params": dict(zip(param_names, params)),
+            "metrics": metrics,
+            "error": error,
+        }
+        self.optimization_history.append(history_entry)
+
+        return error
+
+    def optimize_parameters(
+        self,
+        target_metrics: Dict[str, float],
+        param_bounds: Dict[str, Tuple[float, float]],
+        run_single_event: bool = False,
+        run_train_input: bool = True,
+        train_frequency: float = 50,
+        train_delay: float = 250,
+        cost_function: Optional[Callable] = None,
+        method: str = "SLSQP",
+        init_guess="random",
+    ) -> SynapseOptimizationResult:
+        """
+        Optimize synaptic parameters to achieve target metrics.
+
+        Parameters:
+        -----------
+        target_metrics : Dict[str, float]
+            Target values for synaptic metrics (e.g., {'induction': 0.2, 'rise_time': 0.5})
+        param_bounds : Dict[str, Tuple[float, float]]
+            Bounds for each parameter to optimize (e.g., {'tau_d': (5, 50), 'Use': (0.1, 0.9)})
+        run_single_event : bool, optional
+            Whether to run single event simulations during optimization (default: False)
+        run_train_input : bool, optional
+            Whether to run train input simulations during optimization (default: True)
+        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. If None, uses default cost function
+            that optimizes induction.
+        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 including optimal parameters, achieved metrics,
+            target metrics, final error, and optimization path.
+
+        Notes:
+        ------
+        This function uses scipy.optimize.minimize to find the optimal parameter values
+        that minimize the difference between achieved and target metrics.
+        """
+        self.optimization_history = []
+        self.train_frequency = train_frequency
+        self.train_delay = train_delay
+        self.run_single_event = run_single_event
+        self.run_train_input = run_train_input
+
+        param_names = list(param_bounds.keys())
+        bounds = [param_bounds[name] for name in param_names]
+
+        if cost_function is None:
+            cost_function = self._default_cost_function
+
+        # Calculate scaling factors
+        self.param_scales = {
+            name: max(abs(bounds[i][0]), abs(bounds[i][1])) for i, name in enumerate(param_names)
+        }
+
+        # Normalize bounds
+        normalized_bounds = [
+            (b[0] / self.param_scales[name], b[1] / self.param_scales[name])
+            for name, b in zip(param_names, bounds)
+        ]
+
+        # picks with method of init value we want to use
+        if init_guess == "random":
+            x0 = np.array([np.random.uniform(b[0], b[1]) for b in bounds])
+        elif init_guess == "middle_guess":
+            x0 = [(b[0] + b[1]) / 2 for b in bounds]
         else:
-            # Update IClamp parameters even if same cell type
-            self.icl.amp = self.general_settings["iclamp_amp"]
-        
-        # Always recreate gap junctions when switching connections 
-        # (even for same cell type, sec_id or sec_x might differ)
-        
-        # Clean up previous gap junctions and parallel context
-        if hasattr(self, 'gap_junc_1'):
-            del self.gap_junc_1
-        if hasattr(self, 'gap_junc_2'):
-            del self.gap_junc_2
-        
-        # Properly clean up the existing parallel context
-        if hasattr(self, 'pc'):
-            self.pc.done()  # Clean up existing parallel context
-        
-        # Force garbage collection and reset NEURON state
-        import gc
-        gc.collect()
-        h.finitialize()
-        
-        # Create a fresh parallel context after cleanup
-        self.pc = h.ParallelContext()
-        
-        try:
-            sec1 = list(self.cell1.all)[self.conn["sec_id"]]
-            sec2 = list(self.cell2.all)[self.conn["sec_id"]]
-            
-            # Use unique IDs to avoid conflicts with existing parallel context setups
-            import time
-            unique_id = int(time.time() * 1000) % 10000  # Use timestamp as unique base ID
-            
-            self.pc.source_var(sec1(self.conn["sec_x"])._ref_v, unique_id, sec=sec1)
-            self.gap_junc_1 = h.Gap(sec1(0.5))
-            self.pc.target_var(self.gap_junc_1._ref_vgap, unique_id + 1)
-            
-            self.pc.source_var(sec2(self.conn["sec_x"])._ref_v, unique_id + 1, sec=sec2)
-            self.gap_junc_2 = h.Gap(sec2(0.5))
-            self.pc.target_var(self.gap_junc_2._ref_vgap, unique_id)
-            
-            self.pc.setup_transfer()
-        except Exception as e:
-            print(f"Error setting up gap junctions: {e}")
-            # Try to continue with basic setup
-            self.gap_junc_1 = h.Gap(list(self.cell1.all)[self.conn["sec_id"]](0.5))
-            self.gap_junc_2 = h.Gap(list(self.cell2.all)[self.conn["sec_id"]](0.5))
-        
-        # Reset NEURON state after complete setup
-        h.finitialize()
-        
-        print(f"Successfully switched to connection: {new_connection}")
+            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
+        result = minimize(
+            self._objective_function,
+            normalized_x0,
+            args=(param_names, cost_function, target_metrics),
+            method=method,
+            bounds=normalized_bounds,
+        )
 
-    def model(self, resistance):
+        # Get final parameters and metrics
+        final_params = dict(zip(param_names, self._denormalize_params(result.x, param_names)))
+        for name, value in final_params.items():
+            setattr(self.tuner.syn, name, value)
+        final_metrics = self._calculate_metrics()
+
+        return SynapseOptimizationResult(
+            optimal_params=final_params,
+            achieved_metrics=final_metrics,
+            target_metrics=target_metrics,
+            error=result.fun,
+            optimization_path=self.optimization_history,
+        )
+
+    def plot_optimization_results(self, result: SynapseOptimizationResult):
         """
-        Run a simulation with a specified gap junction resistance.
+        Plot optimization results including convergence and final traces.
+
+        Parameters:
+        -----------
+        result : SynapseOptimizationResult
+            Results from optimization as returned by optimize_parameters()
+
+        Notes:
+        ------
+        This method generates three plots:
+        1. Error convergence plot showing how the error decreased over iterations
+        2. Parameter convergence plots showing how each parameter changed
+        3. Final model response with the optimal parameters
+
+        It also prints a summary of the optimization results including target vs. achieved
+        metrics and the optimal parameter values.
+        """
+        # Ensure errors are properly shaped for plotting
+        iterations = range(len(result.optimization_path))
+        errors = np.array([float(h["error"]) for h in result.optimization_path]).flatten()
+
+        # Plot error convergence
+        fig1, ax1 = plt.subplots(figsize=(8, 5))
+        ax1.plot(iterations, errors, label="Error")
+        ax1.set_xlabel("Iteration")
+        ax1.set_ylabel("Error")
+        ax1.set_title("Error Convergence")
+        ax1.set_yscale("log")
+        ax1.legend()
+        plt.tight_layout()
+        plt.show()
+
+        # Plot parameter convergence
+        param_names = list(result.optimal_params.keys())
+        num_params = len(param_names)
+        fig2, axs = plt.subplots(nrows=num_params, ncols=1, figsize=(8, 5 * num_params))
+
+        if num_params == 1:
+            axs = [axs]
+
+        for ax, param in zip(axs, param_names):
+            values = [float(h["params"][param]) for h in result.optimization_path]
+            ax.plot(iterations, values, label=f"{param}")
+            ax.set_xlabel("Iteration")
+            ax.set_ylabel("Parameter Value")
+            ax.set_title(f"Convergence of {param}")
+            ax.legend()
+
+        plt.tight_layout()
+        plt.show()
+
+        # Print final results
+        print("Optimization Results:")
+        print(f"Final Error: {float(result.error):.2e}\n")
+        print("Target Metrics:")
+        for metric, value in result.target_metrics.items():
+            achieved = result.achieved_metrics.get(metric)
+            if achieved is not None and metric != "amplitudes":  # Skip amplitude array
+                print(f"{metric}: {float(achieved):.3f} (target: {float(value):.3f})")
+
+        print("\nOptimal Parameters:")
+        for param, value in result.optimal_params.items():
+            print(f"{param}: {float(value):.3f}")
+
+        # Plot final model response
+        if self.run_train_input:
+            self.tuner._plot_model(
+                [
+                    self.tuner.general_settings["tstart"] - self.tuner.nstim.interval / 3,
+                    self.tuner.tstop,
+                ]
+            )
+            amp = self.tuner._response_amplitude()
+            self.tuner._calc_ppr_induction_recovery(amp)
+        if self.run_single_event:
+            self.tuner.ispk = None
+            self.tuner.SingleEvent(plot_and_print=True)
+
+# dataclass decorator automatically generates __init__ from type-annotated class variables for cleaner code
+@dataclass
+class GapOptimizationResult:
+    """Container for gap junction optimization results"""
+
+    optimal_resistance: float
+    achieved_cc: float
+    target_cc: float
+    error: float
+    optimization_path: List[Dict[str, float]]
+
+
+class GapJunctionOptimizer:
+    def __init__(self, tuner):
+        """
+        Initialize the gap junction optimizer
+
+        Parameters:
+        -----------
+        tuner : GapJunctionTuner
+            Instance of the GapJunctionTuner class
+        """
+        self.tuner = tuner
+        self.optimization_history = []
+
+    def _objective_function(self, resistance: float, target_cc: float) -> float:
+        """
+        Calculate error between achieved and target coupling coefficient
 
         Parameters:
         -----------
         resistance : float
-            The gap junction resistance value (in MOhm) to use for the simulation.
+            Gap junction resistance to try
+        target_cc : float
+            Target coupling coefficient to match
+
+        Returns:
+        --------
+        float : Error between achieved and target coupling coefficient
+        """
+        # Run model with current resistance
+        self.tuner.model(resistance)
+
+        # Calculate coupling coefficient
+        achieved_cc = self.tuner.coupling_coefficient(
+            self.tuner.t_vec,
+            self.tuner.soma_v_1,
+            self.tuner.soma_v_2,
+            self.tuner.general_settings["tstart"],
+            self.tuner.general_settings["tstart"] + self.tuner.general_settings["tdur"],
+        )
+
+        # Calculate error
+        error = (achieved_cc - target_cc) ** 2  # MSE
+
+        # Store history
+        self.optimization_history.append(
+            {"resistance": resistance, "achieved_cc": achieved_cc, "error": error}
+        )
+
+        return error
+
+    def optimize_resistance(
+        self, target_cc: float, resistance_bounds: tuple = (1e-4, 1e-2), method: str = "bounded"
+    ) -> GapOptimizationResult:
+        """
+        Optimize gap junction resistance to achieve a target coupling coefficient.
+
+        Parameters:
+        -----------
+        target_cc : float
+            Target coupling coefficient to achieve (between 0 and 1)
+        resistance_bounds : tuple, optional
+            (min, max) bounds for resistance search in MOhm. Default is (1e-4, 1e-2).
+        method : str, optional
+            Optimization method to use. Default is 'bounded' which works well
+            for single-parameter optimization.
+
+        Returns:
+        --------
+        GapOptimizationResult
+            Container with optimization results including:
+            - optimal_resistance: The optimized resistance value
+            - achieved_cc: The coupling coefficient achieved with the optimal resistance
+            - target_cc: The target coupling coefficient
+            - error: The final error (squared difference between target and achieved)
+            - optimization_path: List of all values tried during optimization
 
         Notes:
         ------
-        This method sets up the gap junction resistance, initializes recording vectors for time
-        and membrane voltages of both cells, and runs the NEURON simulation.
+        Uses scipy.optimize.minimize_scalar with bounded method, which is
+        appropriate for this single-parameter optimization problem.
         """
-        self.gap_junc_1.g = resistance
-        self.gap_junc_2.g = resistance
+        self.optimization_history = []
 
-        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)
+        # Run optimization
+        result = minimize_scalar(
+            self._objective_function, args=(target_cc,), bounds=resistance_bounds, method=method
+        )
 
-        self.t_vec = t_vec
-        self.soma_v_1 = soma_v_1
-        self.soma_v_2 = soma_v_2
+        # Run final model with optimal resistance
+        self.tuner.model(result.x)
+        final_cc = self.tuner.coupling_coefficient(
+            self.tuner.t_vec,
+            self.tuner.soma_v_1,
+            self.tuner.soma_v_2,
+            self.tuner.general_settings["tstart"],
+            self.tuner.general_settings["tstart"] + self.tuner.general_settings["tdur"],
+        )
 
-        h.finitialize(-70 * mV)
-        h.continuerun(h.tstop * ms)
+        # Package up our results
+        optimization_result = GapOptimizationResult(
+            optimal_resistance=result.x,
+            achieved_cc=final_cc,
+            target_cc=target_cc,
+            error=result.fun,
+            optimization_path=self.optimization_history,
+        )
 
-    def plot_model(self):
+        return optimization_result
+
+    def plot_optimization_results(self, result: GapOptimizationResult):
         """
-        Plot the voltage traces of both cells to visualize gap junction coupling.
+        Plot optimization results including convergence and final voltage traces
 
-        This method creates a plot showing the membrane potential of both cells over time,
-        highlighting the effect of gap junction coupling when a current step is applied to cell 1.
+        Parameters:
+        -----------
+        result : GapOptimizationResult
+            Results from optimization
         """
+        fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(15, 10))
+
+        # Plot voltage traces
         t_range = [
-            self.general_settings["tstart"] - 100.0,
-            self.general_settings["tstart"] + self.general_settings["tdur"] + 100.0,
+            self.tuner.general_settings["tstart"] - 100.0,
+            self.tuner.general_settings["tstart"] + self.tuner.general_settings["tdur"] + 100.0,
         ]
-        t = np.array(self.t_vec)
-        v1 = np.array(self.soma_v_1)
-        v2 = np.array(self.soma_v_2)
+        t = np.array(self.tuner.t_vec)
+        v1 = np.array(self.tuner.soma_v_1)
+        v2 = np.array(self.tuner.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()
-        self.last_figure = plt.gcf()
+        ax1.plot(t[tidx], v1[tidx], "b", label=f"{self.tuner.cell_name} 1")
+        ax1.plot(t[tidx], v2[tidx], "r", label=f"{self.tuner.cell_name} 2")
+        ax1.set_xlabel("Time (ms)")
+        ax1.set_ylabel("Membrane Voltage (mV)")
+        ax1.legend()
+        ax1.set_title("Optimized Voltage Traces")
+
+        # Plot error convergence
+        errors = [h["error"] for h in result.optimization_path]
+        ax2.plot(errors)
+        ax2.set_xlabel("Iteration")
+        ax2.set_ylabel("Error")
+        ax2.set_title("Error Convergence")
+        ax2.set_yscale("log")
+
+        # Plot resistance convergence
+        resistances = [h["resistance"] for h in result.optimization_path]
+        ax3.plot(resistances)
+        ax3.set_xlabel("Iteration")
+        ax3.set_ylabel("Resistance")
+        ax3.set_title("Resistance Convergence")
+        ax3.set_yscale("log")
+
+        # Print final results
+        result_text = (
+            f"Optimal Resistance: {result.optimal_resistance:.2e}\n"
+            f"Target CC: {result.target_cc:.3f}\n"
+            f"Achieved CC: {result.achieved_cc:.3f}\n"
+            f"Final Error: {result.error:.2e}"
+        )
+        ax4.text(0.1, 0.7, result_text, transform=ax4.transAxes, fontsize=10)
+        ax4.axis("off")
 
-    def coupling_coefficient(self, t, v1, v2, t_start, t_end, dt=h.dt):
+        plt.tight_layout()
+        plt.show()
+
+    def parameter_sweep(self, resistance_range: np.ndarray) -> dict:
         """
-        Calculate the coupling coefficient between two cells connected by a gap junction.
+        Perform a parameter sweep across different resistance values.
 
         Parameters:
         -----------
-        t : array-like
-            Time vector.
-        v1 : array-like
-            Voltage trace of the cell receiving the current injection.
-        v2 : array-like
-            Voltage trace of the coupled cell.
-        t_start : float
-            Start time for calculating the steady-state voltage change.
-        t_end : float
-            End time for calculating the steady-state voltage change.
-        dt : float, optional
-            Time step of the simulation. Default is h.dt.
+        resistance_range : np.ndarray
+            Array of resistance values to test.
 
         Returns:
         --------
-        float
-            The coupling coefficient, defined as the ratio of voltage change in cell 2
-            to voltage change in cell 1 (ΔV₂/ΔV₁).
-        """
-        t = np.asarray(t)
-        v1 = np.asarray(v1)
-        v2 = np
+        dict
+            Dictionary containing the results of the parameter sweep, with keys:
+            - 'resistance': List of resistance values tested
+            - 'coupling_coefficient': Corresponding coupling coefficients
+
+        Notes:
+        ------
+        This method is useful for understanding the relationship between gap junction
+        resistance and coupling coefficient before attempting optimization.
+        """
+        results = {"resistance": [], "coupling_coefficient": []}
+
+        for resistance in tqdm(resistance_range, desc="Sweeping resistance values"):
+            self.tuner.model(resistance)
+            cc = self.tuner.coupling_coefficient(
+                self.tuner.t_vec,
+                self.tuner.soma_v_1,
+                self.tuner.soma_v_2,
+                self.tuner.general_settings["tstart"],
+                self.tuner.general_settings["tstart"] + self.tuner.general_settings["tdur"],
+            )
+
+            results["resistance"].append(resistance)
+            results["coupling_coefficient"].append(cc)
+
+        return results

{bmtool-0.7.8 → bmtool-0.7.8.1}/bmtool.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bmtool
-Version: 0.7.8
+Version: 0.7.8.1
 Summary: BMTool
 Home-page: https://github.com/cyneuro/bmtool
 Download-URL: 

{bmtool-0.7.8 → bmtool-0.7.8.1}/setup.py

@@ -5,7 +5,7 @@ with open("README.md", "r") as fh:
 
 setup(
     name="bmtool",
-    version="0.7.8",
+    version="0.7.8.1",
     author="Neural Engineering Laboratory at the University of Missouri",
     author_email="gregglickert@mail.missouri.edu",
     description="BMTool",