科研 Skill

SciPy工程参数优化

scipy-optimization

Applies scipy.optimize methods, including constrained, global, and multi-objective optimization, to engineering design problems. Use when a design problem needs numerical optimization.

发布者 Codar安全审核通过v0.1.0更新于 2026-11-18

SKILL.md

SciPy Optimization for Engineering Design

Overview

The scipy.optimize module provides a comprehensive suite of optimization algorithms for solving engineering design problems. This skill focuses on applying these methods to pump design optimization, system parameter tuning, and performance analysis.

Key capabilities:

  • Unconstrained optimization: Find optimal parameters without restrictions
  • Constrained optimization: Optimize with design constraints and bounds
  • Curve fitting: Fit models to experimental data
  • Global optimization: Find global minima in multi-modal problems
  • Multi-objective optimization: Balance competing design objectives

Optimization Methods

1. minimize() - Unconstrained and Constrained Optimization

The workhorse function for most optimization tasks.

from scipy.optimize import minimize
import numpy as np

# Basic usage
def objective(x):
    """Objective function to minimize"""
    return x[0]**2 + x[1]**2

result = minimize(objective, x0=[1.0, 1.0])
print(f"Optimal point: {result.x}")
print(f"Optimal value: {result.fun}")

Common algorithms:

  • 'Nelder-Mead': Derivative-free, robust but slower
  • 'BFGS': Quasi-Newton method, fast for smooth functions
  • 'L-BFGS-B': BFGS with bounds
  • 'SLSQP': Sequential Least Squares with constraints
  • 'trust-constr': General constrained optimization (preferred)

2. least_squares() - Curve Fitting and Residual Minimization

Specialized for problems of the form: minimize sum(residuals^2)

from scipy.optimize import least_squares

def residuals(params, x_data, y_data):
    """Calculate residuals between model and data"""
    a, b, c = params
    y_model = a * x_data**2 + b * x_data + c
    return y_model - y_data

# Fit quadratic to data
x_data = np.array([1, 2, 3, 4, 5])
y_data = np.array([2.1, 3.9, 9.2, 15.8, 25.1])
result = least_squares(residuals, x0=[1, 1, 1], args=(x_data, y_data))

Key features:

  • Handles bounds on variables
  • Robust loss functions (handles outliers)
  • Efficient for large residual problems
  • Returns Jacobian information

3. differential_evolution() - Global Optimization

Finds global minimum using evolutionary algorithms. Essential for multi-modal problems.

from scipy.optimize import differential_evolution

def complex_function(x):
    """Function with multiple local minima"""
    return np.sin(x[0]) * np.cos(x[1]) + (x[0] - 1)**2 + (x[1] + 2)**2

# Search over bounds
bounds = [(-5, 5), (-5, 5)]
result = differential_evolution(complex_function, bounds)

When to use:

  • Multiple local minima expected
  • No gradient information available
  • Need robust global solution
  • Can afford longer computation time

4. Constrained Optimization

Optimize subject to equality and inequality constraints.

from scipy.optimize import minimize, NonlinearConstraint, LinearConstraint

def objective(x):
    return x[0]**2 + x[1]**2

# Equality constraint: x[0] + x[1] = 1
def eq_constraint(x):
    return x[0] + x[1] - 1

# Inequality constraint: x[0]^2 + x[1]^2 >= 0.5
def ineq_constraint(x):
    return x[0]**2 + x[1]**2 - 0.5

constraints = [
    {'type': 'eq', 'fun': eq_constraint},
    {'type': 'ineq', 'fun': ineq_constraint}
]

result = minimize(objective, x0=[0.5, 0.5],
                 method='SLSQP', constraints=constraints)

Engineering Applications

1. Pump Efficiency Maximization

Optimize pump geometry (impeller diameter, blade angle, width) to maximize efficiency at design point.

Problem formulation:

  • Objective: Maximize efficiency η(D, β, b)
  • Constraints:
    • Minimum flow rate requirement
    • Maximum power consumption
    • Geometric constraints (e.g., D_min ≤ D ≤ D_max)
    • NPSH requirements

Approach:

def pump_efficiency(params):
    """Calculate pump efficiency (negative for minimization)"""
    D, beta, b = params  # diameter, blade angle, width

    # Simplified efficiency model
    Q = calculate_flow_rate(D, beta, b)
    H = calculate_head(D, beta, b)
    P = calculate_power(D, beta, b)

    eta = (rho * g * Q * H) / P
    return -eta  # Negative for maximization

bounds = [(0.1, 0.5), (20, 45), (0.02, 0.1)]  # D, beta, b
result = minimize(pump_efficiency, x0=[0.3, 30, 0.05],
                 method='L-BFGS-B', bounds=bounds)

2. Impeller Geometry Optimization

Optimize blade profile, shroud contour, and hub geometry for specific duty point.

Key considerations:

  • Velocity triangles at inlet/outlet
  • Blade loading distribution
  • Cavitation performance (NPSH)
  • Structural integrity (stress limits)

3. System Cost Minimization

Find optimal pump size and operating speed to minimize total lifecycle cost.

Cost components:

  • Capital cost (pump + motor + VFD)
  • Energy cost (operating hours × efficiency)
  • Maintenance cost
  • Replacement cost (NPV)

Formulation:

def total_cost(params):
    """Total lifecycle cost"""
    pump_size, speed_rpm = params

    # Capital cost
    capital = cost_pump(pump_size) + cost_motor(pump_size, speed_rpm)

    # Operating cost (20 year life)
    annual_energy = operating_hours * power(pump_size, speed_rpm) * electricity_rate
    operating = annual_energy * 20

    # Maintenance
    maintenance = maintenance_rate * capital * 20

    return capital + operating + maintenance

4. Multi-Objective Optimization

Balance competing objectives (e.g., efficiency vs cost, flow vs head).

Pareto front approach:

def weighted_objectives(params, weight):
    """Combine objectives with weighting"""
    eta = pump_efficiency(params)
    cost = pump_cost(params)

    # Normalize and combine
    return -weight * eta + (1 - weight) * cost

# Sweep weights to find Pareto front
pareto_solutions = []
for w in np.linspace(0, 1, 21):
    result = minimize(lambda x: weighted_objectives(x, w),
                     x0=[0.3, 30, 0.05], bounds=bounds)
    pareto_solutions.append(result.x)

5. Curve Fitting to Experimental Data

Fit pump characteristic curves (H-Q, η-Q, P-Q) to test data.

Applications:

  • Develop performance models from test data
  • Extrapolate performance to off-design conditions
  • Identify empirical coefficients in analytical models

Example:

from scipy.optimize import curve_fit

def pump_curve(Q, a, b, c):
    """Quadratic head-flow relationship"""
    return a - b * Q - c * Q**2

# Fit to test data
Q_test = np.array([0, 50, 100, 150, 200])  # m³/h
H_test = np.array([120, 115, 105, 90, 70])  # m

params, covariance = curve_fit(pump_curve, Q_test, H_test)
print(f"H = {params[0]:.2f} - {params[1]:.4f}*Q - {params[2]:.6f}*Q²")

Best Practices

1. Problem Formulation

  • Scale variables: Normalize to similar magnitudes (0-1 or -1 to 1)
  • Choose good initial guess: Start near expected solution
  • Define clear bounds: Prevent physically impossible solutions
  • Formulate smooth objectives: Avoid discontinuities

2. Algorithm Selection

  • Smooth, gradient-available: Use 'BFGS' or 'L-BFGS-B'
  • With constraints: Use 'SLSQP' or 'trust-constr'
  • Noisy/discontinuous: Use 'Nelder-Mead' or derivative-free methods
  • Multiple local minima: Use differential_evolution first, then refine
  • Curve fitting: Use curve_fit or least_squares

3. Convergence Tips

  • Try multiple initial guesses
  • Use reasonable tolerances (not too tight)
  • Provide analytical gradients if possible
  • Check optimization success flag
  • Validate physical feasibility of results

4. Constraint Formulation

  • Express as g(x) ≥ 0 for inequality constraints
  • Express as h(x) = 0 for equality constraints
  • Keep constraints smooth and differentiable
  • Avoid redundant constraints

Common Pitfalls

  1. Poor scaling: Variables of vastly different magnitudes
  2. Bad initial guess: Starting far from feasible region
  3. Wrong algorithm: Using gradient-based methods on non-smooth functions
  4. Tight tolerances: Asking for more precision than achievable
  5. Ignoring bounds: Not constraining to physical limits
  6. No validation: Not checking if solution makes engineering sense

Performance Optimization Tips

  1. Vectorize operations: Use NumPy arrays instead of loops
  2. Provide Jacobians: Analytical gradients are faster and more accurate
  3. Use appropriate method: Don't use global optimization if local is sufficient
  4. Cache expensive computations: Store intermediate results
  5. Start with simple model: Refine complexity iteratively

Integration with Pump Design Workflow

1. Define design variables (D, β, b, ω, etc.)
2. Establish objective function (maximize η, minimize cost)
3. Define constraints (Q_min, NPSH, stress limits)
4. Set bounds (physical limits)
5. Choose optimization algorithm
6. Run optimization with multiple initial guesses
7. Validate results (CFD, analytical checks)
8. Perform sensitivity analysis
9. Generate documentation and plots

Example Workflow

import numpy as np
from scipy.optimize import minimize, differential_evolution
import matplotlib.pyplot as plt

# Step 1: Define problem
def objective(x):
    D, beta = x
    return -calculate_efficiency(D, beta)

def constraint_flow(x):
    D, beta = x
    return calculate_flow_rate(D, beta) - Q_min

def constraint_power(x):
    D, beta = x
    return P_max - calculate_power(D, beta)

# Step 2: Set up optimization
bounds = [(0.2, 0.6), (20, 50)]
constraints = [
    {'type': 'ineq', 'fun': constraint_flow},
    {'type': 'ineq', 'fun': constraint_power}
]

# Step 3: Solve with global optimizer first
result_global = differential_evolution(
    objective, bounds, constraints=constraints
)

# Step 4: Refine with local optimizer
result_local = minimize(
    objective, x0=result_global.x,
    method='SLSQP', bounds=bounds,
    constraints=constraints
)

# Step 5: Report results
print(f"Optimal diameter: {result_local.x[0]:.3f} m")
print(f"Optimal blade angle: {result_local.x[1]:.1f}°")
print(f"Maximum efficiency: {-result_local.fun:.2%}")

References

示例提示词

帮我用scipy.optimize优化这台泵叶轮的几何参数以提高效率。

所属插件

热流体与能源动力面向热流体与能源动力研究:流体与热力学计算(fluids、thermo、CoolProp、REFPROP)、泵与流体机械设计及汽蚀分析、管网与系统集成、OpenFOAM/ANSYS/COMSOL 仿真、Cantera 燃烧计算、单位与物性工具。

安装该插件会一并获得同领域的 36 个 Skill / MCP。

同插件的其他科研 Skill

常见问题

SciPy工程参数优化能做什么?

Applies scipy.optimize methods, including constrained, global, and multi-objective optimization, to engineering design problems. Use when a design problem needs numerical optimization。

如何安装SciPy工程参数优化?

在科搭 Codar 左侧点击「插件」,在「组件」页签搜索「SciPy工程参数优化」并安装;在 Claude Code 或 Codex 中可以发送本页的安装提示词,或下载 Skill 包后解压到 ~/.claude/skills 或 ~/.codex/skills。

SciPy工程参数优化需要哪些权限?

该科研 Skill没有声明额外权限;执行具体操作时仍由 Agent 按自身规则请求确认。

SciPy工程参数优化经过官方审核吗?

是。SpeedSkills 收录的每个版本都会记录内容摘要与权限声明,当前版本已通过安全审核。