pyconvexity 0.4.2.post1__py3-none-any.whl → 0.4.6__py3-none-any.whl

pyconvexity/solvers/pypsa/solver.py

@@ -21,7 +21,15 @@ class NetworkSolver:
     This ensures consistent behavior for both single-year and multi-year models.
     """
 
-    def __init__(self):
+    def __init__(self, verbose: bool = False):
+        """
+        Initialize NetworkSolver.
+
+        Args:
+            verbose: Enable detailed logging output
+        """
+        self.verbose = verbose
+
         # Import PyPSA with error handling
         try:
             import pypsa
@@ -78,7 +86,6 @@ class NetworkSolver:
 
             # 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 = [
@@ -152,8 +159,6 @@ class NetworkSolver:
         start_time = time.time()
         run_id = str(uuid.uuid4())
 
-        logger.info(f"Starting network solve with {solver_name}")
-
         try:
             # Get solver configuration
             actual_solver_name, solver_config = self._get_solver_config(
@@ -165,11 +170,10 @@ class NetworkSolver:
             effective_discount_rate = (
                 discount_rate if discount_rate is not None else 0.0
             )
-            logger.info(f"Discount rate for solve: {effective_discount_rate}")
 
             years = list(network.investment_periods)
 
-            logger.info(f"Multi-period optimization with {len(years)} periods: {years}")
+            logger.info(f"Solving with {actual_solver_name}: {len(years)} periods {years}, discount rate {effective_discount_rate}")
 
             # Calculate investment period weightings with discount rate
             self._calculate_investment_weightings(network, effective_discount_rate)
@@ -190,102 +194,28 @@ class NetworkSolver:
                     )
                 )
                 if optimization_constraints:
-                    logger.info(
-                        f"Found {len(optimization_constraints)} optimization constraints"
-                    )
-
                     # Filter for model constraints only (network constraints already applied)
                     for constraint in optimization_constraints:
                         constraint_code = constraint.get("constraint_code", "")
                         constraint_type = self._detect_constraint_type(constraint_code)
-                        constraint_name = constraint.get("name", "unknown")
 
                         if constraint_type == "model_constraint":
                             model_constraints.append(constraint)
-                            logger.info(
-                                f"Will apply model constraint during solve: {constraint_name}"
-                            )
-                        else:
-                            logger.info(
-                                f"Skipping network constraint (already applied): {constraint_name}"
-                            )
 
-                    logger.info(
-                        f"Will apply {len(model_constraints)} model constraints during optimization"
-                    )
-
-                    # Create extra_functionality for model constraints only
                     if model_constraints:
                         extra_functionality = self._create_extra_functionality(
                             model_constraints, constraint_applicator
                         )
-                        logger.info(
-                            f"Prepared {len(model_constraints)} model constraints for optimization-time application"
-                        )
+                        if self.verbose:
+                            logger.info(
+                                f"Prepared {len(model_constraints)} model constraints for optimization"
+                            )
 
             # NOTE: Model constraints are applied DURING solve via extra_functionality
             # Network constraints were already applied to the network structure before solve
 
-            # Solver diagnostics
-            logger.info(f"=== PYPSA SOLVER DIAGNOSTICS ===")
-            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"=== END PYPSA SOLVER DIAGNOSTICS ===")
-
-            # 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 self.verbose:
+                logger.info(f"Snapshots: {len(network.snapshots)}, Solver options: {solver_config}")
 
             if solver_config:
                 result = network.optimize(
@@ -303,32 +233,6 @@ class NetworkSolver:
 
             solve_time = time.time() - start_time
 
-            # Post-solve debug logging (matches old code)
-            objective_value = getattr(network, "objective", None)
-            if objective_value is not None:
-                logger.info(f"[DEBUG] POST-SOLVE snapshot_weightings structure:")
-                if hasattr(network, "snapshot_weightings"):
-                    logger.info(f"[DEBUG] Type: {type(network.snapshot_weightings)}")
-                    logger.info(
-                        f"[DEBUG] Columns: {list(network.snapshot_weightings.columns)}"
-                    )
-                    logger.info(f"[DEBUG] Shape: {network.snapshot_weightings.shape}")
-                    logger.info(
-                        f"[DEBUG] Unique values in objective column: {network.snapshot_weightings['objective'].unique()}"
-                    )
-                    logger.info(
-                        f"[DEBUG] Sum of objective column: {network.snapshot_weightings['objective'].sum()}"
-                    )
-
-                    if hasattr(network, "investment_period_weightings"):
-                        logger.info(f"[DEBUG] investment_period_weightings exists:")
-                        logger.info(
-                            f"[DEBUG] Type: {type(network.investment_period_weightings)}"
-                        )
-                        logger.info(
-                            f"[DEBUG] Content:\n{network.investment_period_weightings}"
-                        )
-
             # Extract solve results with comprehensive statistics
             solve_result = self._extract_solve_results(
                 network, result, solve_time, actual_solver_name, run_id
@@ -336,31 +240,22 @@ class NetworkSolver:
 
             # Calculate comprehensive network statistics (all years combined)
             if solve_result.get("success"):
-                logger.info("Calculating comprehensive network statistics...")
                 network_statistics = self._calculate_comprehensive_network_statistics(
                     network, solve_time, actual_solver_name
                 )
                 solve_result["network_statistics"] = network_statistics
 
                 # Calculate year-based statistics for capacity expansion analysis
-                logger.info("Calculating year-based statistics...")
                 year_statistics = self._calculate_statistics_by_year(
                     network, solve_time, actual_solver_name
                 )
                 solve_result["year_statistics"] = year_statistics
                 solve_result["year_statistics_available"] = len(year_statistics) > 0
 
+            objective_value = getattr(network, "objective", None)
             logger.info(
-                f"Solve completed in {solve_time:.2f} seconds with status: {solve_result['status']}"
-            )
-            logger.info(f"PyPSA result object: {result}")
-            logger.info(
-                f"PyPSA result status: {getattr(result, 'status', 'no status attr')}"
-            )
-            logger.info(
-                f"Network objective: {getattr(network, 'objective', 'no objective')}"
+                f"Solve completed in {solve_time:.2f}s - status: {solve_result['status']}, objective: {objective_value}"
             )
-            logger.info(f"Solve result success: {solve_result.get('success')}")
 
             return solve_result
 
@@ -426,16 +321,12 @@ class NetworkSolver:
                     {"solver_options": custom_options} if custom_options else None
                 )
 
-            logger.info(
-                f"Using custom solver configuration: {actual_solver} with options: {custom_options}"
-            )
             return actual_solver, merged_options
 
         # Handle "default" solver
         if solver_name == "default":
             # 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
@@ -501,7 +392,6 @@ class NetworkSolver:
             }
             if solver_options:
                 gurobi_options_balanced.update(solver_options)
-            logger.info(f"Using Gurobi Barrier+Dual Crossover Balanced configuration")
             return "gurobi", gurobi_options_balanced
 
         elif solver_name == "gurobi (dual simplex)":
@@ -527,9 +417,6 @@ class NetworkSolver:
             }
             if solver_options:
                 mosek_default_options["solver_options"].update(solver_options)
-            logger.info(
-                f"Using Mosek with default configuration (auto-select optimizer) and moderate MIP strategies"
-            )
             return "mosek", mosek_default_options
 
         elif solver_name == "mosek (barrier)":
@@ -549,9 +436,6 @@ class NetworkSolver:
             }
             if solver_options:
                 mosek_barrier_options["solver_options"].update(solver_options)
-            logger.info(
-                f"Using Mosek Barrier with aggressive presolve and relaxed tolerances"
-            )
             return "mosek", mosek_barrier_options
 
         elif solver_name == "mosek (barrier+crossover)":
@@ -569,9 +453,6 @@ class NetworkSolver:
             }
             if solver_options:
                 mosek_barrier_crossover_options["solver_options"].update(solver_options)
-            logger.info(
-                f"Using Mosek Barrier+Crossover configuration with Gurobi-matched tolerances and moderate MIP strategies"
-            )
             return "mosek", mosek_barrier_crossover_options
 
         elif solver_name == "mosek (dual simplex)":
@@ -586,9 +467,6 @@ class NetworkSolver:
             }
             if solver_options:
                 mosek_dual_options["solver_options"].update(solver_options)
-            logger.info(
-                f"Using Mosek Dual Simplex configuration with Gurobi-matched tolerances and moderate MIP strategies"
-            )
             return "mosek", mosek_dual_options
 
         # Check if this is a known valid solver name
@@ -603,9 +481,6 @@ class NetworkSolver:
             }
             if solver_options:
                 mosek_defaults["solver_options"].update(solver_options)
-            logger.info(
-                f"Using Mosek with barrier method for MIP (interior-point for root/nodes)"
-            )
             return solver_name, mosek_defaults
 
         elif solver_name == "gurobi":
@@ -620,7 +495,6 @@ class NetworkSolver:
             }
             if solver_options:
                 gurobi_defaults["solver_options"].update(solver_options)
-            logger.info(f"Using Gurobi with default MILP-friendly settings")
             return solver_name, gurobi_defaults
 
         # Handle special COPT configurations
@@ -644,9 +518,6 @@ class NetworkSolver:
             }
             if solver_options:
                 copt_barrier_options["solver_options"].update(solver_options)
-            logger.info(
-                f"Using COPT Barrier configuration (fast interior-point method)"
-            )
             return "copt", copt_barrier_options
 
         elif solver_name == "copt (barrier homogeneous)":
@@ -672,7 +543,6 @@ class NetworkSolver:
                 copt_barrier_homogeneous_options["solver_options"].update(
                     solver_options
                 )
-            logger.info(f"Using COPT Barrier Homogeneous configuration")
             return "copt", copt_barrier_homogeneous_options
 
         elif solver_name == "copt (barrier+crossover)":
@@ -691,9 +561,6 @@ class NetworkSolver:
             }
             if solver_options:
                 copt_barrier_crossover_options["solver_options"].update(solver_options)
-            logger.info(
-                f"Using COPT Barrier+Crossover configuration (balanced performance)"
-            )
             return "copt", copt_barrier_crossover_options
 
         elif solver_name == "copt (dual simplex)":
@@ -715,7 +582,6 @@ class NetworkSolver:
             }
             if solver_options:
                 copt_dual_simplex_options["solver_options"].update(solver_options)
-            logger.info(f"Using COPT Dual Simplex configuration (robust method)")
             return "copt", copt_dual_simplex_options
 
         elif solver_name == "copt (concurrent)":
@@ -737,9 +603,6 @@ class NetworkSolver:
             }
             if solver_options:
                 copt_concurrent_options["solver_options"].update(solver_options)
-            logger.info(
-                f"Using COPT Concurrent configuration (parallel simplex + barrier)"
-            )
             return "copt", copt_concurrent_options
 
         elif solver_name in ["highs", "cplex", "glpk", "cbc", "scip", "copt"]:
@@ -816,10 +679,6 @@ class NetworkSolver:
         def extra_functionality(network, snapshots):
             """Apply optimization constraints during solve - matches old code structure"""
             try:
-                logger.info(
-                    f"Applying {len(optimization_constraints)} optimization constraints during solve"
-                )
-
                 # Apply each constraint in priority order
                 sorted_constraints = sorted(
                     optimization_constraints, key=lambda x: x.get("priority", 0)
@@ -836,8 +695,6 @@ class NetworkSolver:
                         )
                         continue
 
-                logger.info("Optimization constraints applied successfully")
-
             except Exception as e:
                 logger.error(f"Failed to apply optimization constraints: {e}")
                 # Don't re-raise - let optimization continue
@@ -853,10 +710,6 @@ class NetworkSolver:
 
             time_periods = get_network_time_periods(conn)
             if time_periods and len(network.snapshots) > 0:
-                logger.info(
-                    f"Setting snapshot weightings AFTER multi-period setup for {len(time_periods)} time periods"
-                )
-
                 # Get network info to determine time interval
                 network_info = get_network_info(conn)
                 time_interval = network_info.get("time_interval", "1H")
@@ -868,10 +721,6 @@ class NetworkSolver:
                         f"Could not parse time interval '{time_interval}', using default weight of 1.0"
                     )
 
-                logger.info(
-                    f"Parsed time interval '{time_interval}' -> weight = {weight}"
-                )
-
                 # Create weightings array - all snapshots get the same weight for this time resolution
                 weightings = [weight] * len(time_periods)
 
@@ -880,21 +729,6 @@ class NetworkSolver:
                     network.snapshot_weightings.loc[:, "objective"] = weightings
                     network.snapshot_weightings.loc[:, "generators"] = weightings
                     network.snapshot_weightings.loc[:, "stores"] = weightings
-                    logger.info(
-                        f"Set snapshot weightings AFTER multi-period setup: objective, generators, stores columns"
-                    )
-
-                    # Debug logging like old code
-                    logger.info(
-                        f"Snapshot weightings shape: {network.snapshot_weightings.shape}"
-                    )
-                    logger.info(
-                        f"Unique values in objective column: {network.snapshot_weightings['objective'].unique()}"
-                    )
-                    logger.info(
-                        f"Sum of objective column: {network.snapshot_weightings['objective'].sum()}"
-                    )
-                    logger.info(f"Weight per snapshot: {weight} hours")
                 else:
                     logger.warning(
                         f"Mismatch between weightings ({len(weightings)}) and snapshots ({len(network.snapshots)})"
@@ -903,7 +737,6 @@ class NetworkSolver:
             logger.warning(
                 f"Failed to set snapshot weightings after multi-period setup: {e}"
             )
-            logger.exception("Full traceback:")
 
     def _parse_time_interval(self, time_interval: str) -> Optional[float]:
         """Parse time interval string to hours - handles multiple formats."""
@@ -973,10 +806,6 @@ class NetworkSolver:
             # Convert pandas Index to list for easier handling
             years_list = years.tolist() if hasattr(years, "tolist") else list(years)
 
-            logger.info(
-                f"Calculating investment weightings for periods: {years_list} with discount rate: {discount_rate}"
-            )
-
             # For single year, use simple weighting of 1.0
             if len(years_list) == 1:
                 # Single year case
@@ -986,9 +815,6 @@ class NetworkSolver:
                         "years": pd.Series({years_list[0]: 1}),
                     }
                 )
-                logger.info(
-                    f"Set single-year investment period weightings for year {years_list[0]}"
-                )
             else:
                 # Multi-year case - EXACTLY match old code logic
                 # Get unique years from the network snapshots to determine period lengths
@@ -1003,8 +829,6 @@ class NetworkSolver:
                     # Fallback: use investment periods as years
                     snapshot_years = years_list
 
-                logger.info(f"Snapshot years found: {snapshot_years}")
-
                 # Calculate years per period - EXACTLY matching old code
                 years_diff = []
                 for i, year in enumerate(years_list):
@@ -1028,7 +852,6 @@ class NetworkSolver:
                                 period_years = 1
 
                     years_diff.append(period_years)
-                    logger.info(f"Period {year}: {period_years} years")
 
                 # Create weightings DataFrame with years column
                 weightings_df = pd.DataFrame(
@@ -1039,22 +862,14 @@ class NetworkSolver:
                 r = discount_rate
                 T = 0  # Cumulative time tracker
 
-                logger.info(f"Calculating discount factors with rate {r}:")
                 for period, nyears in weightings_df.years.items():
                     # Calculate discount factors for each year in this period
                     discounts = [(1 / (1 + r) ** t) for t in range(T, T + nyears)]
                     period_weighting = sum(discounts)
                     weightings_df.at[period, "objective"] = period_weighting
-
-                    logger.info(
-                        f"  Period {period}: years {T} to {T + nyears - 1}, discounts={[f'{d:.4f}' for d in discounts]}, sum={period_weighting:.4f}"
-                    )
                     T += nyears  # Update cumulative time
 
                 network.investment_period_weightings = weightings_df
-                logger.info(f"Final investment period weightings:")
-                logger.info(f"  Years: {weightings_df['years'].to_dict()}")
-                logger.info(f"  Objective: {weightings_df['objective'].to_dict()}")
 
         except Exception as e:
             logger.error(f"Failed to calculate investment weightings: {e}")
@@ -1086,15 +901,6 @@ class NetworkSolver:
             status = getattr(result, "status", "unknown")
             objective_value = getattr(network, "objective", None)
 
-            # Debug logging
-            logger.info(
-                f"Raw PyPSA result attributes: {dir(result) if result else 'None'}"
-            )
-            if hasattr(result, "termination_condition"):
-                logger.info(f"Termination condition: {result.termination_condition}")
-            if hasattr(result, "solver"):
-                logger.info(f"Solver info: {result.solver}")
-
             # Convert PyPSA result to dictionary format
             result_dict = self._convert_pypsa_result_to_dict(result)
 
@@ -1155,25 +961,18 @@ class NetworkSolver:
         try:
             # Check explicit status first
             if status in ["optimal", "feasible"]:
-                logger.info(f"Success determined by status: {status}")
                 return True
 
             # Check termination condition
             if hasattr(result, "termination_condition"):
                 term_condition = str(result.termination_condition).lower()
                 if "optimal" in term_condition:
-                    logger.info(
-                        f"Success determined by termination condition: {result.termination_condition}"
-                    )
                     return True
 
             # Check if we have a valid objective value
             if objective_value is not None and not (
                 objective_value == 0 and status == "unknown"
             ):
-                logger.info(
-                    f"Success determined by valid objective value: {objective_value}"
-                )
                 return True
 
             # Check solver-specific success indicators
@@ -1182,13 +981,10 @@ class NetworkSolver:
                 if hasattr(solver_info, "termination_condition"):
                     term_condition = str(solver_info.termination_condition).lower()
                     if "optimal" in term_condition:
-                        logger.info(
-                            f"Success determined by solver termination condition: {solver_info.termination_condition}"
-                        )
                         return True
 
             logger.warning(
-                f"Could not determine success: status={status}, objective={objective_value}, result_attrs={dir(result) if result else 'None'}"
+                f"Could not determine solve success: status={status}, objective={objective_value}"
             )
             return False
 
@@ -1438,12 +1234,8 @@ class NetworkSolver:
                 years = sorted(period_values.unique())
             else:
                 # If no year info, skip year-based calculations
-                logger.info(
-                    "No year information found in network - skipping year-based statistics"
-                )
                 return {}
 
-            logger.info(f"Calculating year-based statistics for years: {years}")
             year_statistics = {}
 
             for year in years:
@@ -1452,14 +1244,10 @@ class NetworkSolver:
                         network, year, solve_time, solver_name
                     )
                     year_statistics[year] = year_stats
-                    logger.info(f"Calculated statistics for year {year}")
                 except Exception as e:
                     logger.error(f"Failed to calculate statistics for year {year}: {e}")
                     continue
 
-            logger.info(
-                f"Successfully calculated year-based statistics for {len(year_statistics)} years"
-            )
             return year_statistics
 
         except Exception as e: