pyconvexity 0.3.8.post2__tar.gz → 0.3.8.post4__tar.gz

{pyconvexity-0.3.8.post2 → pyconvexity-0.3.8.post4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyconvexity
-Version: 0.3.8.post2
+Version: 0.3.8.post4
 Summary: Python library for energy system modeling and optimization with PyPSA
 Author-email: Convexity Team <info@convexity.com>
 License: MIT

{pyconvexity-0.3.8.post2 → pyconvexity-0.3.8.post4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pyconvexity"
-version = "0.3.8.post2"
+version = "0.3.8post4"
 description = "Python library for energy system modeling and optimization with PyPSA"
 readme = "README.md"
 license = {text = "MIT"}
@@ -81,7 +81,7 @@ profile = "black"
 line_length = 100
 
 [tool.mypy]
-python_version = "0.3.8.post2"
+python_version = "0.3.8post4"
 warn_return_any = true
 warn_unused_configs = true
 disallow_untyped_defs = true

pyconvexity-0.3.8.post4/src/pyconvexity/_version.py

@@ -0,0 +1 @@
+__version__ = "0.3.8post4"

{pyconvexity-0.3.8.post2 → pyconvexity-0.3.8.post4}/src/pyconvexity/solvers/pypsa/api.py

@@ -25,7 +25,8 @@ def solve_network(
     constraints_dsl: Optional[str] = None,
     discount_rate: Optional[float] = None,
     progress_callback: Optional[Callable[[int, str], None]] = None,
-    return_detailed_results: bool = True
+    return_detailed_results: bool = True,
+    custom_solver_config: Optional[Dict[str, Any]] = None
 ) -> Dict[str, Any]:
     """
     Complete solve workflow: build PyPSA network from database, solve, store results.
@@ -38,12 +39,15 @@ def solve_network(
         db_path: Path to the database file
         network_id: ID of the network to solve
         scenario_id: Optional scenario ID (uses master scenario if None)
-        solver_name: Solver to use (default: "highs")
+        solver_name: Solver to use (default: "highs"). Use "custom" for custom_solver_config.
         solver_options: Optional solver-specific options
         constraints_dsl: Optional DSL constraints to apply
         discount_rate: Optional discount rate for multi-period optimization
         progress_callback: Optional callback for progress updates (progress: int, message: str)
         return_detailed_results: If True, return comprehensive results; if False, return simple status
+        custom_solver_config: Optional custom solver configuration when solver_name="custom"
+            Format: {"solver": "actual_solver_name", "solver_options": {...}}
+            Example: {"solver": "gurobi", "solver_options": {"Method": 2, "Crossover": 0}}
         
     Returns:
         Dictionary with solve results - comprehensive if return_detailed_results=True, simple status otherwise
@@ -76,10 +80,18 @@ def solve_network(
         if progress_callback:
             progress_callback(50, f"Network built: {len(network.buses)} buses, {len(network.generators)} generators")
         
-        # Create constraint applicator (constraints will be applied during solve via extra_functionality)
+        # Create constraint applicator and apply constraints BEFORE solve
         constraint_applicator = ConstraintApplicator()
         
-        # Solve network (constraints are applied during optimization)
+        # Apply constraints before solving (network modifications like GlobalConstraints)
+        if progress_callback:
+            progress_callback(60, "Applying constraints...")
+        
+        constraint_applicator.apply_constraints(
+            conn, network_id, network, scenario_id, constraints_dsl
+        )
+        
+        # Solve network
         if progress_callback:
             progress_callback(70, f"Solving with {solver_name}...")
             
@@ -92,7 +104,8 @@ def solve_network(
             conn=conn,
             network_id=network_id,
             scenario_id=scenario_id,
-            constraint_applicator=constraint_applicator
+            constraint_applicator=constraint_applicator,
+            custom_solver_config=custom_solver_config
         )
         
         if progress_callback:
@@ -193,7 +206,8 @@ def solve_pypsa_network(
     solver_name: str = "highs",
     solver_options: Optional[Dict[str, Any]] = None,
     store_results: bool = True,
-    progress_callback: Optional[Callable[[int, str], None]] = None
+    progress_callback: Optional[Callable[[int, str], None]] = None,
+    custom_solver_config: Optional[Dict[str, Any]] = None
 ) -> Dict[str, Any]:
     """
     Solve PyPSA network and optionally store results back to database.
@@ -206,10 +220,12 @@ def solve_pypsa_network(
         db_path: Path to the database file (needed for result storage)
         network_id: ID of the network (for result storage)
         scenario_id: Optional scenario ID
-        solver_name: Solver to use (default: "highs")
+        solver_name: Solver to use (default: "highs"). Use "custom" for custom_solver_config.
         solver_options: Optional solver-specific options
         store_results: Whether to store results back to database (default: True)
         progress_callback: Optional callback for progress updates
+        custom_solver_config: Optional custom solver configuration when solver_name="custom"
+            Format: {"solver": "actual_solver_name", "solver_options": {...}}
         
     Returns:
         Dictionary with solve results and statistics
@@ -226,7 +242,8 @@ def solve_pypsa_network(
     solve_result = solver.solve_network(
         network,
         solver_name=solver_name,
-        solver_options=solver_options
+        solver_options=solver_options,
+        custom_solver_config=custom_solver_config
     )
     
     if progress_callback:

{pyconvexity-0.3.8.post2 → pyconvexity-0.3.8.post4}/src/pyconvexity/solvers/pypsa/constraints.py

@@ -169,7 +169,8 @@ class ConstraintApplicator:
             
             logger.info(f"Constraint breakdown: {len(model_constraints)} model constraints, {len(network_constraints)} network constraints")
             
-            # Apply network constraints first (they modify the network structure)
+            # Apply network constraints ONLY (they modify the network structure before solve)
+            # Model constraints will be applied later by the solver via extra_functionality
             if network_constraints:
                 network_constraints.sort(key=lambda x: x['priority'])
                 for constraint in network_constraints:
@@ -193,88 +194,14 @@ class ConstraintApplicator:
                         # Continue with other constraints instead of failing the entire solve
                         continue
             
-            # Apply model constraints (they need access to the optimization model)
+            # Skip model constraints here - they will be applied by the solver during optimization
+            # via extra_functionality to ensure they have access to the actual optimization model
             if model_constraints:
-                self._apply_model_constraints(network, model_constraints)
+                logger.info(f"Skipping {len(model_constraints)} model constraints - will be applied during solve")
                 
         except Exception as e:
             logger.error(f"Failed to apply custom constraints: {e}", exc_info=True)
     
-    def _apply_model_constraints(self, network: 'pypsa.Network', model_constraints: list):
-        """
-        Apply model constraints that need access to the optimization model.
-        
-        This creates the optimization model, applies constraints to it, and then
-        replaces PyPSA's solve method to use the pre-constrained model.
-        
-        Args:
-            network: PyPSA Network object
-            model_constraints: List of model constraint dictionaries
-        """
-        try:
-            logger.info(f"Applying {len(model_constraints)} model constraints...")
-            
-            # Create the optimization model (same as PyPSA would do internally)
-            logger.info("Creating optimization model for constraint application...")
-            model = network.optimize.create_model()
-            logger.info(f"Created optimization model with {len(model.variables)} variable groups")
-            
-            # Sort constraints by priority
-            sorted_constraints = sorted(model_constraints, key=lambda x: x['priority'])
-            
-            # Apply each model constraint
-            for constraint in sorted_constraints:
-                try:
-                    constraint_code = constraint['constraint_code']
-                    constraint_name = constraint['name']
-                    
-                    logger.info(f"Applying model constraint '{constraint_name}' (priority {constraint['priority']})")
-                    
-                    # Create execution environment with network, model, and utilities
-                    exec_globals = {
-                        'n': network,
-                        'network': network,
-                        'model': model,
-                        'm': model,
-                        'snapshots': network.snapshots,
-                        'pd': pd,
-                        'np': np,
-                        'xr': __import__('xarray'),  # Import xarray for DataArray operations
-                    }
-                    
-                    # Execute the constraint code
-                    exec(constraint_code, exec_globals)
-                    logger.info(f"Successfully applied model constraint '{constraint_name}'")
-                    
-                except Exception as e:
-                    error_msg = f"Failed to apply model constraint '{constraint.get('name', 'unknown')}': {e}"
-                    logger.error(error_msg, exc_info=True)
-                    # Continue with other constraints instead of failing
-                    continue
-            
-            # Store the constrained model for the solver to use
-            # We'll replace PyPSA's solve_model method to use our pre-constrained model
-            logger.info("Replacing PyPSA's solve method to use pre-constrained model...")
-            
-            # Store original methods
-            original_optimize = network.optimize
-            original_solve_model = original_optimize.solve_model
-            
-            # Create a wrapper that uses our pre-constrained model
-            def constrained_solve_model(*args, **kwargs):
-                """Use the pre-constrained model instead of creating a new one."""
-                logger.info("Using pre-constrained model for solve...")
-                return original_solve_model(model, *args, **kwargs)
-            
-            # Replace the solve_model method
-            network.optimize.solve_model = constrained_solve_model
-            
-            logger.info(f"Successfully applied {len(model_constraints)} model constraints")
-            
-        except Exception as e:
-            logger.error(f"Failed to apply model constraints: {e}", exc_info=True)
-            # Don't re-raise - let the solve continue without constraints rather than fail completely
-    
     def _apply_dsl_constraints(self, network: 'pypsa.Network', constraints_dsl: str):
         """
         Apply DSL constraints to the network.

{pyconvexity-0.3.8.post2 → pyconvexity-0.3.8.post4}/src/pyconvexity/solvers/pypsa/solver.py

@@ -75,7 +75,11 @@ class NetworkSolver:
             
             # 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']
+                           'gurobi (barrier+crossover balanced)', 'gurobi (dual simplex)', 
+                           'mosek', 'mosek (default)', 'mosek (barrier)', 'mosek (barrier+crossover)', 'mosek (dual simplex)',
+                           'copt', 'copt (barrier)', 'copt (barrier homogeneous)', 'copt (barrier+crossover)', 
+                           'copt (dual simplex)', 'copt (concurrent)',
+                           'cplex', 'glpk', 'cbc', 'scip']
             
             if default_solver in known_solvers:
                 return default_solver
@@ -97,17 +101,21 @@ class NetworkSolver:
         conn=None,
         network_id: Optional[int] = None,
         scenario_id: Optional[int] = None,
-        constraint_applicator=None
+        constraint_applicator=None,
+        custom_solver_config: Optional[Dict[str, Any]] = None
     ) -> Dict[str, Any]:
         """
         Solve PyPSA network and return results.
         
         Args:
             network: PyPSA Network object to solve
-            solver_name: Solver to use (default: "highs")
+            solver_name: Solver to use (default: "highs"). Use "custom" for custom_solver_config.
             solver_options: Optional solver-specific options
             discount_rate: Optional discount rate for multi-period optimization
             job_id: Optional job ID for tracking
+            custom_solver_config: Optional custom solver configuration when solver_name="custom"
+                Format: {"solver": "actual_solver_name", "solver_options": {...}}
+                Example: {"solver": "gurobi", "solver_options": {"Method": 2, "Crossover": 0}}
             
         Returns:
             Dictionary with solve results and metadata
@@ -123,7 +131,7 @@ class NetworkSolver:
         
         try:
             # Get solver configuration
-            actual_solver_name, solver_config = self._get_solver_config(solver_name, solver_options)
+            actual_solver_name, solver_config = self._get_solver_config(solver_name, solver_options, custom_solver_config)
             
             
             years = list(network.investment_periods)
@@ -139,17 +147,17 @@ class NetworkSolver:
             if conn and network_id:
                 self._set_snapshot_weightings_after_multiperiod(conn, network_id, network)
             
-            # Prepare optimization constraints with type detection
+            # Prepare optimization constraints - ONLY model constraints
+            # Network constraints were already applied before solve in api.py
             extra_functionality = None
             model_constraints = []
-            network_constraints = []
             
             if conn and network_id and constraint_applicator:
                 optimization_constraints = constraint_applicator.get_optimization_constraints(conn, network_id, scenario_id)
                 if optimization_constraints:
                     logger.info(f"Found {len(optimization_constraints)} optimization constraints")
                     
-                    # Separate constraints by type
+                    # 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)
@@ -157,21 +165,19 @@ class NetworkSolver:
                         
                         if constraint_type == "model_constraint":
                             model_constraints.append(constraint)
-                            logger.info(f"Detected model constraint: {constraint_name}")
+                            logger.info(f"Will apply model constraint during solve: {constraint_name}")
                         else:
-                            network_constraints.append(constraint)
-                            logger.info(f"Detected network constraint: {constraint_name}")
+                            logger.info(f"Skipping network constraint (already applied): {constraint_name}")
                     
-                    logger.info(f"Constraint breakdown: {len(model_constraints)} model constraints, {len(network_constraints)} network constraints")
+                    logger.info(f"Will apply {len(model_constraints)} model constraints during optimization")
                     
-                    # Create extra_functionality for ALL constraints (both model and network)
-                    all_constraints = model_constraints + network_constraints
-                    if all_constraints:
-                        extra_functionality = self._create_extra_functionality(all_constraints, constraint_applicator)
-                        logger.info(f"Prepared {len(all_constraints)} constraints for optimization-time application")
+                    # 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")
             
-            # NOTE: Model constraints are now applied DURING solve via extra_functionality
-            # This ensures they are applied to the actual model PyPSA creates, not a separate model
+            # 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 ===")
@@ -271,17 +277,40 @@ class NetworkSolver:
                 "objective_value": None
             }
     
-    def _get_solver_config(self, solver_name: str, solver_options: Optional[Dict[str, Any]] = None) -> tuple[str, Optional[Dict[str, Any]]]:
+    def _get_solver_config(self, solver_name: str, solver_options: Optional[Dict[str, Any]] = None, 
+                           custom_solver_config: Optional[Dict[str, Any]] = None) -> tuple[str, Optional[Dict[str, Any]]]:
         """
         Get the actual solver name and options for special solver configurations.
         
         Args:
-            solver_name: The solver name (e.g., 'gurobi (barrier)', 'highs')
+            solver_name: The solver name (e.g., 'gurobi (barrier)', 'highs', 'custom')
             solver_options: Optional additional solver options
+            custom_solver_config: Optional custom solver configuration for solver_name='custom'
+                Format: {"solver": "actual_solver_name", "solver_options": {...}}
             
         Returns:
             Tuple of (actual_solver_name, solver_options_dict)
         """
+        # Handle "custom" solver with custom configuration
+        if solver_name == 'custom':
+            if not custom_solver_config:
+                raise ValueError("custom_solver_config must be provided when solver_name='custom'")
+            
+            if 'solver' not in custom_solver_config:
+                raise ValueError("custom_solver_config must contain 'solver' key with the actual solver name")
+            
+            actual_solver = custom_solver_config['solver']
+            custom_options = custom_solver_config.get('solver_options', {})
+            
+            # Merge with any additional solver_options passed separately
+            if solver_options:
+                merged_options = {'solver_options': {**custom_options, **solver_options}}
+            else:
+                merged_options = {'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
@@ -296,7 +325,7 @@ class NetworkSolver:
                     'Method': 2,             # Barrier
                     'Crossover': 0,          # Skip crossover
                     'MIPGap': 0.05,          # 5% gap
-                    'Threads': 4,            # Use all cores
+                    'Threads': 0,            # Use all cores (0 = auto)
                     'Presolve': 2,           # Aggressive presolve
                     'ConcurrentMIP': 1,      # Parallel root strategies
                     'BarConvTol': 1e-4,      # Relaxed barrier convergence
@@ -317,7 +346,7 @@ class NetworkSolver:
                     'Method': 2,             # Barrier
                     'Crossover': 0,          # Skip crossover
                     'MIPGap': 0.05,
-                    'Threads': 4,
+                    'Threads': 0,            # Use all cores (0 = auto)
                     'Presolve': 2,
                     'ConcurrentMIP': 1,
                     'BarConvTol': 1e-4,
@@ -338,7 +367,7 @@ class NetworkSolver:
                     'Method': 2,
                     'Crossover': 1,         # Dual crossover
                     'MIPGap': 0.01,
-                    'Threads': 4,
+                    'Threads': 0,            # Use all cores (0 = auto)
                     'Presolve': 2,
                     'Heuristics': 0.1,
                     'Cuts': 2,
@@ -367,8 +396,275 @@ class NetworkSolver:
                 gurobi_dual_options.update(solver_options)
             return 'gurobi', gurobi_dual_options
         
+        # Handle special Mosek configurations
+        elif solver_name == 'mosek (default)':
+            # No custom options - let Mosek use its default configuration
+            mosek_default_options = {
+                'solver_options': {
+                    'MSK_DPAR_MIO_REL_GAP_CONST': 0.05,       # MIP relative gap tolerance (5% to match Gurobi)
+                    'MSK_IPAR_MIO_MAX_TIME': 3600,            # Max time 1 hour
+                    # Safe MIP performance improvements
+                    'MSK_IPAR_MIO_HEURISTIC_LEVEL': 2,        # Moderate heuristics (safe, helps find good solutions faster)
+                    'MSK_IPAR_MIO_SYMMETRY_LEVEL': 2,         # Moderate symmetry detection (safe, can dramatically speed up symmetric problems)
+                    'MSK_IPAR_MIO_PRESOLVE_AGGREGATOR_USE': 1, # MIP presolve aggregator (safe, helps reduce problem size)
+                    # Logging
+                    'MSK_IPAR_LOG': 4,                        # Moderate logging (was 10)
+                    'MSK_IPAR_LOG_INTPNT': 1,                 # Log interior-point progress
+                    'MSK_IPAR_LOG_SIM': 4,                    # Log simplex progress
+                    'MSK_IPAR_LOG_MIO': 2,                    # Reduced MIP logging (was 4)
+                    'MSK_IPAR_LOG_MIO_FREQ': 10,              # Log MIP every 10 seconds
+                }
+            }
+            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)':
+            mosek_barrier_options = {
+                'solver_options': {
+                    'MSK_IPAR_INTPNT_BASIS': 0,                # Skip crossover (barrier-only) - 0 = MSK_BI_NEVER
+                    'MSK_DPAR_INTPNT_TOL_REL_GAP': 1e-4,      # Match Gurobi barrier tolerance
+                    'MSK_DPAR_INTPNT_TOL_PFEAS': 1e-5,        # Match Gurobi primal feasibility
+                    'MSK_DPAR_INTPNT_TOL_DFEAS': 1e-5,        # Match Gurobi dual feasibility
+                    # Removed MSK_DPAR_INTPNT_TOL_INFEAS - was 1000x tighter than other tolerances!
+                    'MSK_IPAR_NUM_THREADS': 0,                # Use all available cores (0 = auto)
+                    'MSK_IPAR_PRESOLVE_USE': 2,               # Aggressive presolve (match Gurobi Presolve=2)
+                    'MSK_IPAR_PRESOLVE_LINDEP_USE': 1,        # Linear dependency check
+                    'MSK_DPAR_MIO_REL_GAP_CONST': 0.05,       # Match Gurobi 5% MIP gap
+                    'MSK_IPAR_MIO_NODE_OPTIMIZER': 4,         # Use interior-point for MIP nodes
+                    'MSK_IPAR_MIO_ROOT_OPTIMIZER': 4,         # Use interior-point for MIP root
+                    # Safe MIP performance improvements
+                    'MSK_IPAR_MIO_HEURISTIC_LEVEL': 4,        # Aggressive heuristics (was 2, match Gurobi's aggressive approach)
+                    'MSK_IPAR_MIO_SYMMETRY_LEVEL': 2,         # Moderate symmetry detection
+                    'MSK_IPAR_MIO_PRESOLVE_AGGREGATOR_USE': 1, # MIP presolve aggregator
+                    'MSK_DPAR_MIO_MAX_TIME': 3600,            # Max time 1 hour
+                    # Logging
+                    'MSK_IPAR_LOG': 4,                        # Moderate logging
+                    'MSK_IPAR_LOG_INTPNT': 1,                 # Log interior-point progress
+                    'MSK_IPAR_LOG_MIO': 2,                    # Reduced MIP logging
+                    'MSK_IPAR_LOG_MIO_FREQ': 10,              # Log MIP every 10 seconds
+                }
+            }
+            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)':
+            mosek_barrier_crossover_options = {
+                'solver_options': {
+                    'MSK_IPAR_INTPNT_BASIS': 1,                # Always crossover (1 = MSK_BI_ALWAYS)
+                    'MSK_DPAR_INTPNT_TOL_REL_GAP': 1e-4,      # Match Gurobi barrier tolerance (was 1e-6)
+                    'MSK_DPAR_INTPNT_TOL_PFEAS': 1e-5,        # Match Gurobi (was 1e-6)
+                    'MSK_DPAR_INTPNT_TOL_DFEAS': 1e-5,        # Match Gurobi (was 1e-6)
+                    'MSK_IPAR_NUM_THREADS': 0,                # Use all available cores (0 = auto)
+                    'MSK_IPAR_PRESOLVE_USE': 1,               # Force presolve
+                    'MSK_IPAR_PRESOLVE_LINDEP_USE': 1,        # Linear dependency check
+                    'MSK_DPAR_MIO_REL_GAP_CONST': 0.05,       # Match Gurobi 5% MIP gap (was 1e-6)
+                    'MSK_IPAR_MIO_NODE_OPTIMIZER': 4,         # Use interior-point for MIP nodes
+                    'MSK_IPAR_MIO_ROOT_OPTIMIZER': 4,         # Use interior-point for MIP root
+                    # Safe MIP performance improvements
+                    'MSK_IPAR_MIO_HEURISTIC_LEVEL': 2,        # Moderate heuristics (safe, helps find good solutions faster)
+                    'MSK_IPAR_MIO_SYMMETRY_LEVEL': 2,         # Moderate symmetry detection (safe, can dramatically speed up symmetric problems)
+                    'MSK_IPAR_MIO_PRESOLVE_AGGREGATOR_USE': 1, # MIP presolve aggregator (safe, helps reduce problem size)
+                    'MSK_DPAR_MIO_MAX_TIME': 3600,            # Max time 1 hour (safety limit)
+                    # Logging
+                    'MSK_IPAR_LOG': 4,                        # Moderate logging (was 10)
+                    'MSK_IPAR_LOG_INTPNT': 1,                 # Log interior-point progress
+                    'MSK_IPAR_LOG_MIO': 2,                    # Reduced MIP logging (was 4)
+                    'MSK_IPAR_LOG_MIO_FREQ': 10,              # Log MIP every 10 seconds
+                    # Note: Don't force MSK_IPAR_OPTIMIZER - let Mosek choose based on problem type
+                }
+            }
+            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)':
+            mosek_dual_options = {
+                'solver_options': {
+                    'MSK_IPAR_NUM_THREADS': 0,                # Use all available cores (0 = automatic)
+                    'MSK_IPAR_PRESOLVE_USE': 1,               # Force presolve
+                    'MSK_IPAR_SIM_SCALING': 2,                # Aggressive scaling (2 = MSK_SCALING_AGGRESSIVE)
+                    'MSK_DPAR_MIO_REL_GAP_CONST': 0.05,       # Match Gurobi 5% MIP gap (was 1e-6)
+                    'MSK_IPAR_MIO_NODE_OPTIMIZER': 1,         # Use dual simplex for MIP nodes (1 = MSK_OPTIMIZER_DUAL_SIMPLEX)
+                    'MSK_IPAR_MIO_ROOT_OPTIMIZER': 1,         # Use dual simplex for MIP root
+                    # Safe MIP performance improvements
+                    'MSK_IPAR_MIO_HEURISTIC_LEVEL': 2,        # Moderate heuristics (safe, helps find good solutions faster)
+                    'MSK_IPAR_MIO_SYMMETRY_LEVEL': 2,         # Moderate symmetry detection (safe, can dramatically speed up symmetric problems)
+                    'MSK_IPAR_MIO_PRESOLVE_AGGREGATOR_USE': 1, # MIP presolve aggregator (safe, helps reduce problem size)
+                    'MSK_DPAR_MIO_MAX_TIME': 3600,            # Max time 1 hour (safety limit)
+                    # Logging
+                    'MSK_IPAR_LOG': 4,                        # Moderate logging (was 10)
+                    'MSK_IPAR_LOG_SIM': 4,                    # Log simplex progress
+                    'MSK_IPAR_LOG_MIO': 2,                    # Reduced MIP logging (was 4)
+                    'MSK_IPAR_LOG_MIO_FREQ': 10,              # Log MIP every 10 seconds
+                    # Note: For pure LP, set optimizer; for MILP, only set node/root optimizers
+                }
+            }
+            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
-        elif solver_name in ['highs', 'gurobi', 'cplex', 'glpk', 'cbc', 'scip', 'copt', 'mosek']:
+        elif solver_name == 'mosek':
+            # Add default MILP-friendly settings for plain Mosek
+            mosek_defaults = {
+                'solver_options': {
+                    'MSK_DPAR_MIO_REL_GAP_CONST': 0.05,       # Match Gurobi 5% MIP gap (was 1e-4)
+                    'MSK_IPAR_MIO_MAX_TIME': 3600,            # Max time 1 hour
+                    'MSK_IPAR_NUM_THREADS': 0,                # Use all cores (0 = auto)
+                    # CRITICAL: Use interior-point for MIP (much faster than simplex)
+                    'MSK_IPAR_MIO_NODE_OPTIMIZER': 4,         # Use interior-point for MIP nodes (4 = MSK_OPTIMIZER_INTPNT)
+                    'MSK_IPAR_MIO_ROOT_OPTIMIZER': 4,         # Use interior-point for MIP root (4 = MSK_OPTIMIZER_INTPNT)
+                    # Safe MIP performance improvements
+                    'MSK_IPAR_MIO_HEURISTIC_LEVEL': 2,        # Moderate heuristics (safe, helps find good solutions faster)
+                    'MSK_IPAR_MIO_SYMMETRY_LEVEL': 2,         # Moderate symmetry detection (safe, can dramatically speed up symmetric problems)
+                    'MSK_IPAR_MIO_PRESOLVE_AGGREGATOR_USE': 1, # MIP presolve aggregator (safe, helps reduce problem size)
+                    # Logging
+                    'MSK_IPAR_LOG': 4,                        # Moderate logging
+                    'MSK_IPAR_LOG_MIO': 2,                    # Log MIP occasionally
+                }
+            }
+            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':
+            # Add default MILP-friendly settings for plain Gurobi (for consistency)
+            gurobi_defaults = {
+                'solver_options': {
+                    'MIPGap': 1e-4,          # 0.01% gap
+                    'TimeLimit': 3600,       # 1 hour
+                    'Threads': 0,            # Use all cores
+                    'OutputFlag': 1,         # Enable output
+                }
+            }
+            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
+        elif solver_name == 'copt (barrier)':
+            copt_barrier_options = {
+                'solver_options': {
+                    'LpMethod': 2,              # Barrier method
+                    'Crossover': 0,             # Skip crossover for speed
+                    'RelGap': 0.05,             # 5% MIP gap (match Gurobi)
+                    'TimeLimit': 3600,          # 1 hour time limit
+                    'Threads': 2,               # 4 threads (memory-conscious)
+                    'Presolve': 3,              # Aggressive presolve
+                    'Scaling': 1,               # Enable scaling
+                    'FeasTol': 1e-5,            # Match Gurobi feasibility
+                    'DualTol': 1e-5,            # Match Gurobi dual tolerance
+                    # MIP performance settings
+                    'CutLevel': 2,              # Normal cut generation
+                    'HeurLevel': 3,             # Aggressive heuristics
+                    'StrongBranching': 1,       # Fast strong branching
+                }
+            }
+            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)':
+            copt_barrier_homogeneous_options = {
+                'solver_options': {
+                    'LpMethod': 2,              # Barrier method
+                    'Crossover': 0,             # Skip crossover
+                    'BarHomogeneous': 1,        # Use homogeneous self-dual form
+                    'RelGap': 0.05,             # 5% MIP gap
+                    'TimeLimit': 3600,          # 1 hour
+                    'Threads': 2,               # 4 threads (memory-conscious)
+                    'Presolve': 3,              # Aggressive presolve
+                    'Scaling': 1,               # Enable scaling
+                    'FeasTol': 1e-5,
+                    'DualTol': 1e-5,
+                    # MIP performance settings
+                    'CutLevel': 2,              # Normal cuts
+                    'HeurLevel': 3,             # Aggressive heuristics
+                    'StrongBranching': 1,       # Fast strong branching
+                }
+            }
+            if solver_options:
+                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)':
+            copt_barrier_crossover_options = {
+                'solver_options': {
+                    'LpMethod': 2,              # Barrier method
+                    'Crossover': 1,             # Enable crossover for better solutions
+                    'RelGap': 0.05,             # 5% MIP gap (relaxed for faster solves)
+                    'TimeLimit': 3600,          # 1 hour
+                    'Threads': 2,              # Use all cores
+                    'Presolve': 3,              # Aggressive presolve
+                    'Scaling': 1,               # Enable scaling
+                    'FeasTol': 1e-6,            # Tighter feasibility
+                    'DualTol': 1e-6,            # Tighter dual tolerance
+                    # MIP performance settings
+                    'CutLevel': 3,              # Aggressive cuts
+                    'HeurLevel': 3,             # Aggressive heuristics
+                    'StrongBranching': 2,       # Normal strong branching
+                }
+            }
+            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)':
+            copt_dual_simplex_options = {
+                'solver_options': {
+                    'LpMethod': 1,              # Dual simplex method
+                    'RelGap': 0.05,             # 5% MIP gap
+                    'TimeLimit': 3600,          # 1 hour
+                    'Threads': 2,              # Use all cores
+                    'Presolve': 3,              # Aggressive presolve
+                    'Scaling': 1,               # Enable scaling
+                    'FeasTol': 1e-6,
+                    'DualTol': 1e-6,
+                    # MIP performance settings
+                    'CutLevel': 2,              # Normal cuts
+                    'HeurLevel': 2,             # Normal heuristics
+                    'StrongBranching': 1,       # Fast strong branching
+                }
+            }
+            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)':
+            copt_concurrent_options = {
+                'solver_options': {
+                    'LpMethod': 4,              # Concurrent (simplex + barrier)
+                    'RelGap': 0.05,             # 5% MIP gap
+                    'TimeLimit': 3600,          # 1 hour
+                    'Threads': 2,              # Use all cores
+                    'Presolve': 3,              # Aggressive presolve
+                    'Scaling': 1,               # Enable scaling
+                    'FeasTol': 1e-5,
+                    'DualTol': 1e-5,
+                    # MIP performance settings
+                    'CutLevel': 2,              # Normal cuts
+                    'HeurLevel': 3,             # Aggressive heuristics
+                    'StrongBranching': 1,       # Fast strong branching
+                }
+            }
+            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']:
             return solver_name, solver_options
         
         else:

{pyconvexity-0.3.8.post2 → pyconvexity-0.3.8.post4}/src/pyconvexity.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyconvexity
-Version: 0.3.8.post2
+Version: 0.3.8.post4
 Summary: Python library for energy system modeling and optimization with PyPSA
 Author-email: Convexity Team <info@convexity.com>
 License: MIT

pyconvexity-0.3.8.post2/src/pyconvexity/_version.py

@@ -1 +0,0 @@
-__version__ = "0.3.8.post2"