pyconvexity 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

pyconvexity/solvers/pypsa/solver.py

@@ -1,7 +1,7 @@
 """
 Solving functionality for PyPSA networks.
 
-Handles the actual optimization solving with various solvers and configurations.
+Simplified to always use multi-period optimization for consistency.
 """
 
 import logging
@@ -16,10 +16,9 @@ logger = logging.getLogger(__name__)
 
 class NetworkSolver:
     """
-    Handles solving PyPSA networks with various solvers and configurations.
+    Simplified PyPSA network solver that always uses multi-period optimization.
     
-    This class encapsulates the solving logic, including solver configuration,
-    multi-period optimization setup, and result extraction.
+    This ensures consistent behavior for both single-year and multi-year models.
     """
     
     def __init__(self):
@@ -33,6 +32,61 @@ class NetworkSolver:
                 "Please ensure it is installed correctly in the environment."
             ) from e
     
+    def _get_user_settings_path(self):
+        """Get the path to the user settings file (same location as Tauri uses)"""
+        try:
+            import platform
+            import os
+            from pathlib import Path
+            
+            system = platform.system()
+            if system == "Darwin":  # macOS
+                home = Path.home()
+                app_data_dir = home / "Library" / "Application Support" / "com.convexity.desktop"
+            elif system == "Windows":
+                app_data_dir = Path(os.environ.get("APPDATA", "")) / "com.convexity.desktop"
+            else:  # Linux
+                home = Path.home()
+                app_data_dir = home / ".local" / "share" / "com.convexity.desktop"
+            
+            settings_file = app_data_dir / "user_settings.json"
+            return settings_file if settings_file.exists() else None
+            
+        except Exception as e:
+            logger.warning(f"Failed to determine user settings path: {e}")
+            return None
+    
+    def _resolve_default_solver(self) -> str:
+        """Resolve 'default' solver to user's preferred solver"""
+        try:
+            import json
+            
+            settings_path = self._get_user_settings_path()
+            if not settings_path:
+                logger.debug("User settings file not found, using 'highs' as default solver")
+                return 'highs'
+            
+            with open(settings_path, 'r') as f:
+                user_settings = json.load(f)
+            
+            # Get default solver from user settings
+            default_solver = user_settings.get('default_solver', 'highs')
+            logger.info(f"📖 Read default solver from user settings: {default_solver}")
+            
+            # Validate that it's a known solver
+            known_solvers = ['highs', 'gurobi', 'gurobi (barrier)', 'gurobi (barrier homogeneous)', 
+                           'gurobi (barrier+crossover balanced)', 'gurobi (dual simplex)', 'cplex', 'glpk', 'cbc', 'scip']
+            
+            if default_solver in known_solvers:
+                return default_solver
+            else:
+                logger.warning(f"Unknown default solver '{default_solver}' in user settings, falling back to 'highs'")
+                return 'highs'
+                
+        except Exception as e:
+            logger.warning(f"Failed to read default solver from user settings: {e}")
+            return 'highs'
+    
     def solve_network(
         self,
         network: 'pypsa.Network',
@@ -71,23 +125,17 @@ class NetworkSolver:
             # Get solver configuration
             actual_solver_name, solver_config = self._get_solver_config(solver_name, solver_options)
             
-            # Always use multi-period mode for consistency
-            # Extract years from network snapshots
-            if hasattr(network, '_available_years') and network._available_years:
-                years = network._available_years
-            elif hasattr(network.snapshots, 'year'):
-                years = sorted(network.snapshots.year.unique())
-            else:
-                # If no year info, use a single default year
-                years = [2020]  # Default single year
             
-            # Configure for multi-period optimization (works for single year too)
+            years = list(network.investment_periods)
             effective_discount_rate = discount_rate if discount_rate is not None else 0.05  # Default 5%
-            logger.info(f"Configuring multi-period optimization with discount rate {effective_discount_rate}")
-            network = self._configure_multi_period_optimization(network, years, effective_discount_rate)
             
-            # CRITICAL: Set snapshot weightings AFTER multi-period setup
-            # PyPSA's multi-period setup can reset snapshot weightings to 1.0
+            logger.info(f"Multi-period optimization with {len(years)} periods: {years}")
+            logger.info(f"Discount rate: {effective_discount_rate}")
+            
+            # Calculate investment period weightings with discount rate
+            self._calculate_investment_weightings(network, effective_discount_rate)
+            
+            # Set snapshot weightings after multi-period setup
             if conn and network_id:
                 self._set_snapshot_weightings_after_multiperiod(conn, network_id, network)
             
@@ -99,23 +147,47 @@ class NetworkSolver:
                     logger.info(f"Applying {len(optimization_constraints)} optimization-time constraints")
                     extra_functionality = self._create_extra_functionality(optimization_constraints, constraint_applicator)
             
-            # Solver diagnostics (simplified version of old code)
+            # Solver diagnostics
             logger.info(f"=== PYPSA SOLVER DIAGNOSTICS ===")
-            logger.info(f"Requested solver: {solver_name}")
-            logger.info(f"Actual solver: {actual_solver_name}")
+            logger.info(f"Solver: {actual_solver_name}")
+            logger.info(f"Investment periods: {years}")
+            logger.info(f"Snapshots: {len(network.snapshots)} (MultiIndex)")
             if solver_config:
                 logger.info(f"Solver options: {solver_config}")
-            logger.info(f"Multi-period optimization: {self._is_multi_period_network(network)}")
-            logger.info(f"Investment periods: {getattr(network, 'investment_periods', 'None')}")
             logger.info(f"=== END PYPSA SOLVER DIAGNOSTICS ===")
             
-            # Solve the network
-            logger.info(f"Solving network with {actual_solver_name}")
+            # Always solve with multi-period optimization
+            logger.info(f"Solving network with multi-period optimization using {actual_solver_name}")
+            
+            # DEBUG: Check network structure before solving
+            logger.info(f"DEBUG: Network snapshots type: {type(network.snapshots)}")
+            logger.info(f"DEBUG: Network snapshots names: {getattr(network.snapshots, 'names', 'No names')}")
+            logger.info(f"DEBUG: Network snapshots shape: {len(network.snapshots)}")
+            logger.info(f"DEBUG: First 3 snapshots: {network.snapshots[:3].tolist()}")
+            
+            # Check some timeseries data structure
+            if hasattr(network, 'generators_t') and hasattr(network.generators_t, 'p_max_pu'):
+                if not network.generators_t.p_max_pu.empty:
+                    logger.info(f"DEBUG: generators_t.p_max_pu type: {type(network.generators_t.p_max_pu)}")
+                    logger.info(f"DEBUG: generators_t.p_max_pu index type: {type(network.generators_t.p_max_pu.index)}")
+                    logger.info(f"DEBUG: generators_t.p_max_pu index names: {getattr(network.generators_t.p_max_pu.index, 'names', 'No names')}")
+                    logger.info(f"DEBUG: generators_t.p_max_pu shape: {network.generators_t.p_max_pu.shape}")
+                    logger.info(f"DEBUG: First 3 p_max_pu index values: {network.generators_t.p_max_pu.index[:3].tolist()}")
+            
+            if hasattr(network, 'loads_t') and hasattr(network.loads_t, 'p_set'):
+                if not network.loads_t.p_set.empty:
+                    logger.info(f"DEBUG: loads_t.p_set type: {type(network.loads_t.p_set)}")
+                    logger.info(f"DEBUG: loads_t.p_set index type: {type(network.loads_t.p_set.index)}")
+                    logger.info(f"DEBUG: loads_t.p_set index names: {getattr(network.loads_t.p_set.index, 'names', 'No names')}")
+                    logger.info(f"DEBUG: loads_t.p_set shape: {network.loads_t.p_set.shape}")
+                    logger.info(f"DEBUG: First 3 p_set index values: {network.loads_t.p_set.index[:3].tolist()}")
             
             if solver_config:
-                result = self._solve_with_config(network, actual_solver_name, solver_config, job_id, extra_functionality)
+                result = network.optimize(solver_name=actual_solver_name, multi_investment_periods=True, 
+                                        extra_functionality=extra_functionality, **solver_config)
             else:
-                result = self._solve_standard(network, actual_solver_name, job_id, extra_functionality)
+                result = network.optimize(solver_name=actual_solver_name, multi_investment_periods=True,
+                                        extra_functionality=extra_functionality)
             
             solve_time = time.time() - start_time
             
@@ -161,6 +233,7 @@ class NetworkSolver:
         except Exception as e:
             solve_time = time.time() - start_time
             logger.error(f"Solve failed after {solve_time:.2f} seconds: {e}")
+            logger.exception("Full solve error traceback:")
             
             return {
                 "success": False,
@@ -185,8 +258,10 @@ class NetworkSolver:
         """
         # Handle "default" solver
         if solver_name == 'default':
-            logger.warning("Solver name 'default' received - falling back to 'highs'.")
-            return 'highs', solver_options
+            # Try to read user's default solver preference
+            actual_solver = self._resolve_default_solver()
+            logger.info(f"Resolved 'default' solver to: {actual_solver}")
+            return actual_solver, solver_options
         
         # Handle special Gurobi configurations
         if solver_name == 'gurobi (barrier)':
@@ -275,85 +350,6 @@ class NetworkSolver:
             logger.warning(f"Unknown solver name '{solver_name}' - falling back to 'highs'")
             return 'highs', solver_options
     
-    def _solve_with_config(self, network: 'pypsa.Network', solver_name: str, solver_config: Dict[str, Any], job_id: Optional[str], extra_functionality=None) -> Any:
-        """Solve network with specific solver configuration."""
-        # Check if multi-period optimization is needed
-        is_multi_period = self._is_multi_period_network(network)
-        
-        # Add extra_functionality to solver config if provided
-        if extra_functionality:
-            solver_config = solver_config.copy()  # Don't modify original
-            solver_config['extra_functionality'] = extra_functionality
-        
-        if is_multi_period:
-            return network.optimize(solver_name=solver_name, multi_investment_periods=True, **solver_config)
-        else:
-            return network.optimize(solver_name=solver_name, **solver_config)
-    
-    def _solve_standard(self, network: 'pypsa.Network', solver_name: str, job_id: Optional[str], extra_functionality=None) -> Any:
-        """Solve network with standard configuration."""
-        # Check if multi-period optimization is needed
-        is_multi_period = self._is_multi_period_network(network)
-        
-        if extra_functionality:
-            if is_multi_period:
-                return network.optimize(solver_name=solver_name, multi_investment_periods=True, extra_functionality=extra_functionality)
-            else:
-                return network.optimize(solver_name=solver_name, extra_functionality=extra_functionality)
-        else:
-            if is_multi_period:
-                return network.optimize(solver_name=solver_name, multi_investment_periods=True)
-            else:
-                return network.optimize(solver_name=solver_name)
-    
-    def _is_multi_period_network(self, network: 'pypsa.Network') -> bool:
-        """
-        Determine if the network requires multi-period optimization.
-        
-        Multi-period optimization is needed when:
-        1. Network has investment_periods attribute with multiple periods
-        2. Network snapshots are MultiIndex with period/timestep structure
-        3. Network has generators with build_year attributes
-        
-        Args:
-            network: PyPSA Network object
-            
-        Returns:
-            True if multi-period optimization is needed, False otherwise
-        """
-        try:
-            # Check if network has investment_periods
-            if hasattr(network, 'investment_periods') and network.investment_periods is not None:
-                periods = list(network.investment_periods)
-                if len(periods) > 1:
-                    return True
-                elif len(periods) == 1:
-                    # Even with single period, check if we have build_year constraints
-                    if hasattr(network, 'generators') and not network.generators.empty:
-                        if 'build_year' in network.generators.columns:
-                            build_year_gens = network.generators[network.generators['build_year'].notna()]
-                            if not build_year_gens.empty:
-                                return True
-            
-            # Check if snapshots are MultiIndex (period, timestep structure)
-            if hasattr(network, 'snapshots') and hasattr(network.snapshots, 'names'):
-                if network.snapshots.names and len(network.snapshots.names) >= 2:
-                    if network.snapshots.names[0] == 'period':
-                        return True
-            
-            # Check if we have generators with build_year (fallback check)
-            if hasattr(network, 'generators') and not network.generators.empty:
-                if 'build_year' in network.generators.columns:
-                    build_year_gens = network.generators[network.generators['build_year'].notna()]
-                    if not build_year_gens.empty:
-                        # If we have build_year but no proper multi-period setup, we should still try multi-period
-                        return True
-            
-            return False
-            
-        except Exception as e:
-            logger.error(f"Error checking multi-period status: {e}")
-            return False
     
     def _create_extra_functionality(self, optimization_constraints: list, constraint_applicator) -> callable:
         """
@@ -477,80 +473,6 @@ class NetworkSolver:
             logger.warning(f"Could not parse time interval '{time_interval}': {e}")
             return None
     
-    def _configure_multi_period_optimization(self, network: 'pypsa.Network', years: list, discount_rate: float) -> 'pypsa.Network':
-        """
-        Configure network for multi-period optimization (works for single or multiple years).
-        
-        Args:
-            network: PyPSA Network object
-            years: List of years in the network
-            discount_rate: Discount rate for investment calculations
-            
-        Returns:
-            Configured network
-        """
-        try:
-            import pandas as pd
-            
-            logger.info(f"Configuring multi-period optimization for years: {years}")
-            logger.info(f"Current snapshots: {len(network.snapshots)} time steps")
-            
-            # Handle case where snapshots don't have year info but years were extracted manually
-            if not hasattr(network.snapshots, 'year'):
-                if len(years) > 0:
-                    # Use the manually extracted years from timestamps
-                    # Create MultiIndex snapshots by dividing existing snapshots among the years
-                    snapshots_per_year = len(network.snapshots) // len(years)
-                    multi_snapshots = []
-                    
-                    for i, year in enumerate(years):
-                        start_idx = i * snapshots_per_year
-                        end_idx = (i + 1) * snapshots_per_year if i < len(years) - 1 else len(network.snapshots)
-                        year_snapshots = network.snapshots[start_idx:end_idx]
-                        for snapshot in year_snapshots:
-                            multi_snapshots.append((year, snapshot))
-                    
-                    logger.info(f"Created {len(multi_snapshots)} multi-period snapshots from {len(network.snapshots)} original snapshots")
-                    
-                else:
-                    # Only use 2020 fallback if no years were extracted at all (should be rare)
-                    single_year = 2020
-                    multi_snapshots = [(single_year, snapshot) for snapshot in network.snapshots]
-                    years = [single_year]
-                    logger.warning(f"No years provided, using fallback year {single_year}")
-            else:
-                # Create MultiIndex snapshots from existing year-based snapshots
-                multi_snapshots = []
-                for year in years:
-                    year_snapshots = network.snapshots[network.snapshots.year == year]
-                    for snapshot in year_snapshots:
-                        multi_snapshots.append((year, snapshot))
-                
-                logger.info(f"Created {len(multi_snapshots)} multi-period snapshots from year-based snapshots")
-            
-            # Set MultiIndex snapshots and investment periods
-            network.snapshots = pd.MultiIndex.from_tuples(multi_snapshots, names=['period', 'timestep'])
-            network.investment_periods = years
-            print(network.investment_periods)  # Match old code debug output
-            
-            logger.info(f"Set investment_periods: {network.investment_periods}")
-            logger.info(f"MultiIndex snapshots created with levels: {network.snapshots.names}")
-            
-            # Calculate investment period weightings with discount rate
-            self._calculate_investment_weightings(network, discount_rate)
-            
-            # Configure build year constraints for multi-period optimization
-            self._configure_build_year_constraints(network, years)
-            
-            logger.info(f"Successfully configured multi-period optimization for {len(years)} investment periods")
-            
-        except Exception as e:
-            logger.error(f"Failed to configure multi-period optimization: {e}")
-            logger.exception("Full traceback:")
-            # Don't re-raise - let the solve continue with original configuration
-        
-        return network
-    
     def _calculate_investment_weightings(self, network: 'pypsa.Network', discount_rate: float) -> None:
         """
         Calculate investment period weightings using discount rate - matching old PyPSA solver exactly.
@@ -644,77 +566,6 @@ class NetworkSolver:
             logger.error(f"Failed to calculate investment weightings: {e}")
             logger.exception("Full traceback:")
     
-    def _configure_build_year_constraints(self, network: 'pypsa.Network', years: list) -> None:
-        """
-        Configure build year constraints for multi-period optimization.
-        
-        In PyPSA multi-period optimization, generators should only be available for investment
-        starting from their build year. This method ensures proper constraint setup.
-        
-        Args:
-            network: PyPSA Network object
-            years: List of investment periods (years)
-        """
-        try:
-            import pandas as pd
-            
-            logger.info("Configuring build year constraints for multi-period optimization")
-            
-            # Check if we have generators with build_year attributes
-            if not hasattr(network, 'generators') or network.generators.empty:
-                logger.warning("No generators found, skipping build year constraints")
-                return
-            
-            if 'build_year' not in network.generators.columns:
-                logger.warning("No build_year column found in generators, skipping build year constraints")
-                return
-            
-            # Get generators with build year information
-            generators_with_build_year = network.generators[network.generators['build_year'].notna()]
-            
-            if generators_with_build_year.empty:
-                logger.warning("No generators have build_year values, skipping build year constraints")
-                return
-            
-            logger.info(f"Applying build year constraints to {len(generators_with_build_year)} generators")
-            
-            # Check if generators have proper extendable capacity settings
-            if 'p_nom_extendable' in network.generators.columns:
-                extendable_generators = generators_with_build_year[generators_with_build_year['p_nom_extendable'] == True]
-                
-                if extendable_generators.empty:
-                    logger.warning("No generators are marked as extendable (p_nom_extendable=True). Build year constraints only apply to extendable generators.")
-                    return
-                
-                logger.info(f"Found {len(extendable_generators)} extendable generators with build years")
-            else:
-                logger.warning("No p_nom_extendable column found - cannot determine which generators are extendable")
-                return
-            
-            # Verify that build years align with investment periods
-            build_years = set(generators_with_build_year['build_year'].astype(int))
-            investment_years = set(years)
-            
-            unmatched_build_years = build_years - investment_years
-            if unmatched_build_years:
-                logger.warning(f"Some generators have build years not in investment periods: {sorted(unmatched_build_years)}")
-            
-            matched_build_years = build_years & investment_years
-            logger.info(f"Generators with build years matching investment periods: {sorted(matched_build_years)}")
-            
-            # Store build year information for potential custom constraint application
-            network._build_year_info = {
-                'generators_with_build_year': generators_with_build_year.index.tolist(),
-                'build_years': generators_with_build_year['build_year'].to_dict(),
-                'investment_periods': years,
-                'extendable_generators': extendable_generators.index.tolist() if 'extendable_generators' in locals() else []
-            }
-            
-            logger.info("Build year constraint configuration completed")
-            
-        except Exception as e:
-            logger.error(f"Failed to configure build year constraints: {e}")
-            logger.exception("Full traceback:")
     
     def _extract_solve_results(self, network: 'pypsa.Network', result: Any, solve_time: float, solver_name: str, run_id: str) -> Dict[str, Any]:
         """