2024“华为杯”中国研究生数学建模竞赛（A题）深度剖析_数学建模完整过程+详细思路+代码全解析

问题一详细解答过程

2. 简化疲劳损伤计算模型

2.1 累积损伤的Palmgren-Miner理论

根据Palmgren-Miner线性累积损伤理论，疲劳损伤是通过在一定的应力循环下累积的。对于给定应力幅值 S i S_i Si，累积损伤值 D D D 是由经历的应力循环次数 n i n_i ni 和该应力幅值对应的疲劳寿命 N i N_i Ni 之比决定的：

D = ∑ i n i N i D = \sum_i \frac{n_i}{N_i} D=∑iNini

其中：

• n i n_i ni 是经历的应力循环数。
• N i N_i Ni 是在应力幅值 S i S_i Si 下达到失效的循环数，通常由S-N曲线确定。

2.2 S-N曲线

S-N曲线是材料疲劳特性的重要描述，用来表明不同应力幅值下的疲劳寿命。S-N曲线的基本形式为：

N i = ( S 0 S i ) k N_i = \left( \frac{S_0}{S_i} \right)^k Ni=(SiS0)k

其中：

• N i N_i Ni 是应力幅值 S i S_i Si 下的疲劳寿命。
• S 0 S_0 S0 是基准应力（材料疲劳强度）。
• k k k 是材料的疲劳指数（通常在3到5之间，取决于材料特性）。

2.3 应力幅值估算

为了在线计算疲劳损伤，我们需要在每秒钟对主轴扭矩和塔架推力进行实时应力估算。基于应力波峰和波谷的幅值差，可以计算每个时间段内的应力幅值 S i S_i Si ：

S i = 1 2 ( σ max − σ min ) S_i = \frac{1}{2} (\sigma_{\text{max}} - \sigma_{\text{min}}) Si=21(σmax−σmin)

其中：

• σ max \sigma_{\text{max}} σmax 和 σ min \sigma_{\text{min}} σmin 分别是时间段内的应力波峰和波谷值。

2.4 应力循环计数

通过简化雨流计数法或滑动窗口法，我们可以近似地统计主轴和塔架的应力循环次数。每个应力幅值区间（如通过幅值分组）内的循环数可以在实时中获得，并根据每个区间的应力幅值和S-N曲线计算累积损伤。

2.5 每秒疲劳损伤计算

在每一秒的时间段内，首先估算主轴和塔架的波峰和波谷应力，计算应力幅值 S i S_i Si，然后根据S-N曲线计算疲劳寿命 N i N_i Ni。假设每秒内发生的应力循环为 n i = 1 n_i = 1 ni=1，则每秒的累积疲劳损伤 D i D_i Di 为：

D i = 1 N i = 1 ( S 0 S i ) k = ( S i S 0 ) k D_i = \frac{1}{N_i} = \frac{1}{\left( \frac{S_0}{S_i} \right)^k} = \left( \frac{S_i}{S_0} \right)^k Di=Ni1=(SiS0)k1=(S0Si)k

2.6 累积疲劳损伤

将所有时间段内的疲劳损伤值累加，得到设备的累积疲劳损伤值：

D total = ∑ i D i = ∑ i ( S i S 0 ) k D_{\text{total}} = \sum_{i} D_i = \sum_{i} \left( \frac{S_i}{S_0} \right)^k Dtotal=∑iDi=∑i(S0Si)k

3. 模型解答过程

3.1 确定参数

1. 材料的S-N曲线 ：根据实际材料的疲劳特性确定S-N曲线的基准应力 S 0 S_0 S0 和疲劳指数 k k k。
2. 应力幅值的计算 ：在每秒内，利用主轴扭矩和塔架推力的数据，找到波峰 σ max \sigma_{\text{max}} σmax 和波谷 σ min \sigma_{\text{min}} σmin，计算应力幅值 S i = 1 2 ( σ max − σ min ) S_i = \frac{1}{2} (\sigma_{\text{max}} - \sigma_{\text{min}}) Si=21(σmax−σmin)。
3. 循环计数 ：每秒内发生的应力循环数可以简化为 n i = 1 n_i = 1 ni=1，每秒发生一次应力循环。

3.2 每秒疲劳损伤的计算

对于每秒的应力幅值 S i S_i Si，通过以下公式计算该秒内的疲劳损伤：

D i = ( S i S 0 ) k D_i = \left( \frac{S_i}{S_0} \right)^k Di=(S0Si)k

3.3 累积疲劳损伤的计算

将每秒的疲劳损伤累加，得到总的累积疲劳损伤：

D total = ∑ i ( S i S 0 ) k D_{\text{total}} = \sum_{i} \left( \frac{S_i}{S_0} \right)^k Dtotal=∑i(S0Si)k

4. 示例计算过程

假设主轴材料的S-N曲线参数为：

• 基准应力 S 0 = 500   MPa S_0 = 500 \, \text{MPa} S0=500MPa
• 疲劳指数 k = 4 k = 4 k=4

在一个时段内，主轴扭矩产生的应力波峰为 σ max = 100   MPa \sigma_{\text{max}} = 100 \, \text{MPa} σmax=100MPa，波谷为 σ min = 50   MPa \sigma_{\text{min}} = 50 \, \text{MPa} σmin=50MPa，则应力幅值为：

S i = 1 2 ( 100 − 50 ) = 25   MPa S_i = \frac{1}{2} (100 - 50) = 25 \, \text{MPa} Si=21(100−50)=25MPa

该时段的疲劳损伤为：

D i = ( 25 500 ) 4 = 0.00000625 D_i = \left( \frac{25}{500} \right)^4 = 0.00000625 Di=(50025)4=0.00000625

假设在100秒内计算，每秒的应力幅值相同，则总的累积疲劳损伤为：

D total = 100 × 0.00000625 = 0.000625 D_{\text{total}} = 100 \times 0.00000625 = 0.000625 Dtotal=100×0.00000625=0.000625

此时得到主轴的累积疲劳损伤值。类似地可以对塔架推力进行相同的计算。

python代码实现：

import numpy as np
from scipy.optimize import minimize

# 常量定义
S0 = 200  # 材料的基准疲劳强度 (MPa)
k = 3     # 材料的疲劳指数
r_shaft = 0.5  # 主轴半径 (m)
r_tower = 2.0  # 塔架半径 (m)
H_tower = 80.0  # 塔架高度 (m)

# 计算主轴的剪切应力
def calculate_shaft_stress(torque, r_shaft):
    J = np.pi * (r_shaft**4) / 2
    return torque / J

# 计算塔架的弯曲应力
def calculate_tower_stress(thrust, H_tower, r_tower):
    I = np.pi * (r_tower**4) / 4
    return (thrust * H_tower) / I

# 根据S-N曲线计算疲劳寿命
def calculate_fatigue_life(stress):
    return (S0 / stress)**k

# 根据Miner's Rule计算疲劳损伤
def calculate_fatigue_damage(stress_series):
    damage = 0
    for stress in stress_series:
        N = calculate_fatigue_life(stress)
        damage += 1 / N
    return damage

# 模拟风速和功率输出关系
def power_output(wind_speed):
    return min(1500, 0.5 * wind_speed**3)  # 简化功率曲线

# 功率输出与扭矩、推力的关系
def calculate_torque_and_thrust(power, wind_speed):
    torque = power / (wind_speed * 2 * np.pi)  # 简化扭矩公式
    thrust = 0.5 * wind_speed**2 * 1.2 * 3.14 * r_tower**2  # 简化推力公式
    return torque, thrust

# 优化问题的目标函数：最小化疲劳损伤
def objective(power_outputs, wind_speeds):
    total_damage = 0
    for i in range(len(power_outputs)):
        torque, thrust = calculate_torque_and_thrust(power_outputs[i], wind_speeds[i])
        shaft_stress = calculate_shaft_stress(torque, r_shaft)
        tower_stress = calculate_tower_stress(thrust, H_tower, r_tower)
        damage = calculate_fatigue_damage([shaft_stress, tower_stress])
        total_damage += damage
    return total_damage

# 功率调度优化的约束：总功率输出的限制
def power_constraint(power_outputs):
    return np.sum(power_outputs) - np.sum([power_output(ws) for ws in wind_speeds])

# 生成模拟风速数据
np.random.seed(42)
N = 1000  # 数据点数
wind_speeds = np.random.uniform(5, 25, N)  # 风速 (m/s)

# 初始化功率输出（根据初始风速计算）
initial_power_outputs = np.array([power_output(ws) for ws in wind_speeds])

# 设置功率调度优化问题的约束条件
constraints = {'type': 'eq', 'fun': power_constraint}

# 执行优化，寻找最小化疲劳损伤的功率分配方案
result = minimize(objective, initial_power_outputs, args=(wind_speeds,), constraints=constraints)

# 计算最终的疲劳损伤
optimized_power_outputs = result.x
total_fatigue_damage = objective(optimized_power_outputs, wind_speeds)

# 输出结果
if __name__ == "__main__":
    print(f"优化后的累积疲劳损伤: {total_fatigue_damage:.4f}")
    print(f"优化后的功率输出: {optimized_power_outputs[:10]}")  # 输出前10个功率数据

问题二详细解答过程

1. 风速与功率输出的关系

风力发电机的功率输出与风速有如下关系：

P ( w ) = min ⁡ ( 1500 , 0.5 ⋅ w 3 ) P(w) = \min(1500, 0.5 \cdot w^3) P(w)=min(1500,0.5⋅w3)

其中， P ( w ) P(w) P(w) 是风速 w w w 下的功率输出，单位为千瓦（kW），最大功率输出为1500 kW。

2. 推力和扭矩计算

风速和功率输出直接影响塔架的推力和主轴的扭矩。假设推力 F F F 和扭矩 T T T 分别与风速 w w w 和功率 P P P 相关：

• 推力 ：推力主要由风速引起，假设推力 F ( w ) F(w) F(w) 的计算公式为：

F ( w ) = 1 2 ⋅ ρ ⋅ A ⋅ w 2 F(w) = \frac{1}{2} \cdot \rho \cdot A \cdot w^2 F(w)=21⋅ρ⋅A⋅w2

其中， ρ \rho ρ 为空气密度， A A A 为风力发电机叶片的正投影面积。

• 扭矩 ：扭矩与功率 P P P 和风速 w w w 的关系为：

T ( P , w ) = P w ⋅ 2 π T(P, w) = \frac{P}{w \cdot 2 \pi} T(P,w)=w⋅2πP

3. 应力计算

应力是造成疲劳损伤的关键因素，包括塔架的弯曲应力和主轴的剪切应力：

• 塔架弯曲应力 ：塔架主要承受推力 F F F，引起的弯曲应力 σ tower \sigma_{\text{tower}} σtower 可表示为：

σ tower = F ⋅ H tower I \sigma_{\text{tower}} = \frac{F \cdot H_{\text{tower}}}{I} σtower=IF⋅Htower

其中， H tower H_{\text{tower}} Htower 是塔架高度， I I I 是塔架横截面积的惯性矩。

• 主轴剪切应力 ：主轴承受扭矩 T T T，引起的剪切应力 τ shaft \tau_{\text{shaft}} τshaft 为：

τ shaft = T J \tau_{\text{shaft}} = \frac{T}{J} τshaft=JT

其中， J J J 是主轴截面的极惯性矩。

4. 疲劳损伤计算

根据材料的S-N曲线，疲劳寿命 N N N（即在某一应力水平下能够承受的循环次数）与应力 σ \sigma σ 或 τ \tau τ 的关系为：

N ( σ ) = ( S 0 σ ) k N(\sigma) = \left( \frac{S_0}{\sigma} \right)^k N(σ)=(σS0)k

其中， S 0 S_0 S0 是材料的基准疲劳强度， k k k 是材料的疲劳指数。

疲劳损伤的计算遵循Miner's Rule，累积疲劳损伤 D D D 可表示为：

D = ∑ i = 1 n 1 N ( σ i ) D = \sum_{i=1}^{n} \frac{1}{N(\sigma_i)} D=∑i=1nN(σi)1

其中， σ i \sigma_i σi 是第 i i i 次循环中的应力， N ( σ i ) N(\sigma_i) N(σi) 是对应的疲劳寿命。

5. 优化问题

目标是最小化在所有风速和功率调度下的累积疲劳损伤，即最小化目标函数：

minimize D = ∑ i = 1 n D ( σ i , τ i ) \text{minimize } D = \sum_{i=1}^{n} D(\sigma_i, \tau_i) minimize D=∑i=1nD(σi,τi)

其中， σ i \sigma_i σi 是塔架在第 i i i 次循环中的应力， τ i \tau_i τi 是主轴在第 i i i 次循环中的应力。

6. 约束条件

功率调度策略的约束条件为：

∑ i = 1 n P i = ∑ i = 1 n P ( w i ) \sum_{i=1}^{n} P_i = \sum_{i=1}^{n} P(w_i) ∑i=1nPi=∑i=1nP(wi)

即调度后的总功率输出必须等于初始风速条件下的总功率输出。

python代码实现：

import numpy as np
from scipy.optimize import minimize

# 定义风速到功率的关系
def power_output(wind_speed):
    # 最大功率为1500 kW
    return np.minimum(1500, 0.5 * wind_speed ** 3)

# 推力计算函数 F(w) = 0.5 * rho * A * w^2
def thrust(wind_speed, rho=1.225, area=100):  # 假设面积为100m^2
    return 0.5 * rho * area * wind_speed ** 2

# 扭矩计算函数 T(P, w) = P / (w * 2 * pi)
def torque(power, wind_speed):
    return power / (wind_speed * 2 * np.pi)

# 塔架弯曲应力计算 σ = F * H_tower / I (假设塔架高度和惯性矩)
def tower_stress(thrust, tower_height=80, moment_of_inertia=1e6):
    return thrust * tower_height / moment_of_inertia

# 主轴剪切应力计算 τ = T / J (假设极惯性矩)
def shaft_stress(torque, polar_moment_of_inertia=1e4):
    return torque / polar_moment_of_inertia

# 疲劳寿命函数 N(σ) = (S0 / σ)^k
def fatigue_life(stress, S0=1e8, k=3):
    return (S0 / stress) ** k

# 疲劳损伤累积计算
def fatigue_damage(stresses, life_func):
    damages = 1 / life_func(stresses)
    return np.sum(damages)

# 优化目标函数：最小化累积疲劳损伤
def objective_function(power_dispatch, wind_speeds, initial_power, S0, k):
    total_damage = 0
    
    # 遍历每个风速
    for i, wind_speed in enumerate(wind_speeds):
        # 计算调度后的功率
        power = power_dispatch[i]
        
        # 计算推力与扭矩
        F = thrust(wind_speed)
        T = torque(power, wind_speed)
        
        # 计算塔架弯曲应力与主轴剪切应力
        sigma_tower = tower_stress(F)
        tau_shaft = shaft_stress(T)
        
        # 计算疲劳寿命和损伤
        stress = np.sqrt(sigma_tower**2 + tau_shaft**2)  # 计算等效应力
        N = fatigue_life(stress, S0, k)
        total_damage += 1 / N
    
    return total_damage

# 功率调度约束条件
def power_constraint(power_dispatch, initial_power):
    return np.sum(power_dispatch) - np.sum(initial_power)

# 主程序
def main():
    # 假设风速数据和对应的功率输出
    wind_speeds = np.array([8, 12, 15, 18, 20])  # 以 m/s 为单位
    initial_power = power_output(wind_speeds)  # 初始功率输出

    # 设置优化问题的初始猜测和边界
    initial_guess = initial_power.copy()
    bounds = [(0, 1500) for _ in wind_speeds]  # 功率调度边界条件

    # 优化问题的约束条件
    constraints = [{'type': 'eq', 'fun': power_constraint, 'args': (initial_power,)}]

    # 调用优化函数
    result = minimize(objective_function, initial_guess, args=(wind_speeds, initial_power, 1e8, 3),
                      bounds=bounds, constraints=constraints)

    # 输出优化结果
    if result.success:
        print("优化成功！")
        print("最优功率调度为：", result.x)
        print("最小累积疲劳损伤为：", result.fun)
    else:
        print("优化失败！")

if __name__ == '__main__':
    main()

问题3详细解答过程

1. 问题概述与目标

目标是优化风力涡轮机的功率调度，使其在给定的实时风速数据下，最小化涡轮机关键组件（如塔架和主轴）的疲劳损伤。问题的挑战在于，考虑通信延迟和测量噪声的同时，要确保功率输出与风速变化的响应快速且准确。

建模目标：

• 最小化累积疲劳损伤：疲劳损伤取决于涡轮机的应力状态，包括塔架弯曲应力与主轴剪切应力，这些应力与功率输出和风速直接相关。
• 保证实时响应：优化调度的功率输出需及时反映风速变化，同时满足系统约束。

2. 输入变量与输出变量

• 输入变量 ：
  • 风速 w ( t ) w(t) w(t)：给定时间 t t t 的风速数据，带有噪声。
  • 通信延迟 τ \tau τ：风速测量和功率调度信号之间的延迟。
  • 初始功率 P 0 P_0 P0：涡轮机当前时刻的功率输出。
• 输出变量 ：
  • 功率调度 P ( t ) P(t) P(t)：优化后涡轮机在时间 t t t 下的功率输出。

3. 风速与功率输出关系

风速与功率输出的非线性关系可以用以下公式描述：

P ( w ( t ) ) = min ⁡ ( P max , 1 2 ⋅ ρ ⋅ A ⋅ w ( t ) 3 ) P(w(t)) = \min\left(P_{\text{max}}, \frac{1}{2} \cdot \rho \cdot A \cdot w(t)^3\right) P(w(t))=min(Pmax,21⋅ρ⋅A⋅w(t)3)

其中， P max P_{\text{max}} Pmax 为涡轮机的最大功率输出， ρ \rho ρ 为空气密度， A A A 为涡轮机扫风面积。

4. 塔架推力与主轴扭矩

• 推力计算：

F ( w ( t ) ) = 1 2 ⋅ ρ ⋅ A ⋅ w ( t ) 2 F(w(t)) = \frac{1}{2} \cdot \rho \cdot A \cdot w(t)^2 F(w(t))=21⋅ρ⋅A⋅w(t)2

• 主轴扭矩：

T ( P ( t ) , w ( t ) ) = P ( t ) w ( t ) ⋅ 2 π T(P(t), w(t)) = \frac{P(t)}{w(t) \cdot 2 \pi} T(P(t),w(t))=w(t)⋅2πP(t)

5. 疲劳损伤模型

塔架弯曲应力与主轴剪切应力是关键影响因素，我们可以通过下面的公式计算应力：

• 塔架弯曲应力：

σ tower ( t ) = F ( w ( t ) ) ⋅ H tower I \sigma_{\text{tower}}(t) = \frac{F(w(t)) \cdot H_{\text{tower}}}{I} σtower(t)=IF(w(t))⋅Htower

其中 H tower H_{\text{tower}} Htower 为塔架高度， I I I 为塔架的惯性矩。

• 主轴剪切应力：

τ shaft ( t ) = T ( P ( t ) , w ( t ) ) J \tau_{\text{shaft}}(t) = \frac{T(P(t), w(t))}{J} τshaft(t)=JT(P(t),w(t))

其中 J J J 为主轴的极惯性矩。

综合塔架和主轴的应力，计算等效应力：

σ eq ( t ) = σ tower ( t ) 2 + τ shaft ( t ) 2 \sigma_{\text{eq}}(t) = \sqrt{\sigma_{\text{tower}}(t)^2 + \tau_{\text{shaft}}(t)^2} σeq(t)=σtower(t)2+τshaft(t)2

6. 疲劳寿命模型

根据疲劳寿命的经验公式，疲劳寿命 N N N 与应力的关系为：

N ( σ eq ) = ( S 0 σ eq ) k N(\sigma_{\text{eq}}) = \left(\frac{S_0}{\sigma_{\text{eq}}}\right)^k N(σeq)=(σeqS0)k

其中 S 0 S_0 S0 为材料的疲劳强度系数， k k k 为疲劳指数。

7. 累积疲劳损伤的计算

使用 Miner 损伤累积法则 计算累积疲劳损伤：

D ( t ) = ∑ t = 1 T 1 N ( σ eq ( t ) ) D(t) = \sum_{t=1}^{T} \frac{1}{N(\sigma_{\text{eq}}(t))} D(t)=∑t=1TN(σeq(t))1

目标是最小化总损伤 D D D。

8. 优化问题的定义

优化目标是最小化累积疲劳损伤：

min ⁡ P ( t ) ∑ t = 1 T 1 N ( σ eq ( t ) ) \min_{P(t)} \sum_{t=1}^{T} \frac{1}{N(\sigma_{\text{eq}}(t))} minP(t)∑t=1TN(σeq(t))1

约束条件包括：

• 功率输出与风速的关系 ： P ( t ) = P ( w ( t ) ) P(t) = P(w(t)) P(t)=P(w(t))
• 总功率不超过最大值 ： P ( t ) ≤ P max P(t) \leq P_{\text{max}} P(t)≤Pmax
• 实时调度响应 ：考虑通信延迟 τ \tau τ 和测量噪声 n ( t ) n(t) n(t)，风速的测量值为 w ~ ( t ) = w ( t − τ ) + n ( t ) \tilde{w}(t) = w(t - \tau) + n(t) w~(t)=w(t−τ)+n(t)。

9. 通信延迟与测量噪声的建模

风速测量数据带有通信延迟和测量噪声：

w ~ ( t ) = w ( t − τ ) + n ( t ) \tilde{w}(t) = w(t - \tau) + n(t) w~(t)=w(t−τ)+n(t)

其中， τ \tau τ 为通信延迟， n ( t ) n(t) n(t) 为测量噪声（假设为高斯白噪声）。

10. 优化问题的求解方法

可以使用基于梯度的优化方法（如L-BFGS）求解该优化问题，目标是找到最佳的功率调度 P ( t ) P(t) P(t)，使得累积疲劳损伤 D D D 最小，并确保系统对风速变化作出实时响应。

1. 功率输出：

   P ( w ( t ) ) = min ⁡ ( P max , 1 2 ⋅ ρ ⋅ A ⋅ w ( t ) 3 ) P(w(t)) = \min\left(P_{\text{max}}, \frac{1}{2} \cdot \rho \cdot A \cdot w(t)^3\right) P(w(t))=min(Pmax,21⋅ρ⋅A⋅w(t)3)

2. 推力：

   F ( w ( t ) ) = 1 2 ⋅ ρ ⋅ A ⋅ w ( t ) 2 F(w(t)) = \frac{1}{2} \cdot \rho \cdot A \cdot w(t)^2 F(w(t))=21⋅ρ⋅A⋅w(t)2

3. 扭矩：

   T ( P ( t ) , w ( t ) ) = P ( t ) w ( t ) ⋅ 2 π T(P(t), w(t)) = \frac{P(t)}{w(t) \cdot 2 \pi} T(P(t),w(t))=w(t)⋅2πP(t)

4. 塔架应力：

   σ tower ( t ) = F ( w ( t ) ) ⋅ H tower I \sigma_{\text{tower}}(t) = \frac{F(w(t)) \cdot H_{\text{tower}}}{I} σtower(t)=IF(w(t))⋅Htower

5. 主轴应力：

   τ shaft ( t ) = T ( P ( t ) , w ( t ) ) J \tau_{\text{shaft}}(t) = \frac{T(P(t), w(t))}{J} τshaft(t)=JT(P(t),w(t))

6. 等效应力：

   σ eq ( t ) = σ tower ( t ) 2 + τ shaft ( t ) 2 \sigma_{\text{eq}}(t) = \sqrt{\sigma_{\text{tower}}(t)^2 + \tau_{\text{shaft}}(t)^2} σeq(t)=σtower(t)2+τshaft(t)2

7. 疲劳寿命：

   N ( σ eq ) = ( S 0 σ eq ) k N(\sigma_{\text{eq}}) = \left(\frac{S_0}{\sigma_{\text{eq}}}\right)^k N(σeq)=(σeqS0)k

8. 累积疲劳损伤：

   D ( t ) = ∑ t = 1 T 1 N ( σ eq ( t ) ) D(t) = \sum_{t=1}^{T} \frac{1}{N(\sigma_{\text{eq}}(t))} D(t)=∑t=1TN(σeq(t))1

这个模型通过考虑功率输出、风速、通信延迟、噪声等复杂因素，最小化涡轮机的累积疲劳损伤。

python代码实现：

import numpy as np
from scipy.optimize import minimize

class WindTurbine:
    def __init__(self, P_max, rho, A, H_tower, I, J, S_0, k, tau):
        self.P_max = P_max
        self.rho = rho
        self.A = A
        self.H_tower = H_tower
        self.I = I
        self.J = J
        self.S_0 = S_0
        self.k = k
        self.tau = tau
    
    def wind_power(self, w):
        return min(self.P_max, 0.5 * self.rho * self.A * w**3)

    def thrust(self, w):
        return 0.5 * self.rho * self.A * w**2

    def torque(self, P, w):
        return P / (w * 2 * np.pi)

    def tower_stress(self, w):
        F = self.thrust(w)
        return F * self.H_tower / self.I

    def shaft_stress(self, P, w):
        T = self.torque(P, w)
        return T / self.J

    def equivalent_stress(self, P, w):
        sigma_tower = self.tower_stress(w)
        tau_shaft = self.shaft_stress(P, w)
        return np.sqrt(sigma_tower**2 + tau_shaft**2)

    def fatigue_life(self, sigma_eq):
        return (self.S_0 / sigma_eq) ** self.k

    def cumulative_damage(self, P, wind_speeds):
        D = 0
        for w in wind_speeds:
            sigma_eq = self.equivalent_stress(P, w)
            D += 1 / self.fatigue_life(sigma_eq)
        return D

def optimize_power(wind_speeds, turbine):
    def objective(P):
        return turbine.cumulative_damage(P, wind_speeds)

    res = minimize(objective, [turbine.P_max], bounds=[(0, turbine.P_max)])
    return res.x[0]

if __name__ == "__main__":
    P_max = 1500
    rho = 1.225
    A = 100
    H_tower = 50
    I = 500
    J = 300
    S_0 = 300
    k = 5
    tau = 0.5

    wind_speeds = np.array([8, 10, 12, 9, 7, 15, 14, 13, 11])
    turbine = WindTurbine(P_max, rho, A, H_tower, I, J, S_0, k, tau)

    optimal_power = optimize_power(wind_speeds, turbine)
    print("Optimal Power Output:", optimal_power)