修正没有利用--excel参数的bug。

.gitignore

@@ -8,6 +8,5 @@ wheels/
 
 # Virtual environments
 .venv
-test_*
 *.xls*
 *.png

.vscode/launch.json

@@ -9,9 +9,17 @@
             "name": "Main",
             "type": "debugpy",
             "request": "launch",
-            "program": "main.py",
+            "program": "src\\main.py",
             "console": "integratedTerminal",
-            "args": "--excel .\\data_template_8760-in-use.xlsx"
+            "args": "--excel .\\templates\\data_template_8760-in-use2.xlsx"
+        },
+        {
+            "name": "Multi_Scenarios",
+            "type": "debugpy",
+            "request": "launch",
+            "program": "src\\multi_scenario.py",
+            "console": "integratedTerminal",
+            "args": "--excel .\\templates\\data_template_8760-in-use2.xlsx"
         }
     ]
 }

docs/CURTAILMENT_LOSS_FEATURES.md

@@ -0,0 +1,134 @@
+# 弃电损失量功能增强文档
+
+## 修改概述
+
+在用户要求下，对 `main.py` 文件的 Excel 输出功能进行了增强，新增了**弃电损失量**相关的统计和输出。
+
+## 主要修改内容
+
+### 1. 统计结果工作表增强
+
+在 `export_results_to_excel` 函数的 `stats_df` 中新增了以下指标：
+
+| 新增指标 | 说明 | 单位 |
+|---------|------|------|
+| 总弃风电量 | 全部时间的弃风量总和 | MWh |
+| 总弃光电量 | 全部时间的弃光量总和 | MWh |
+| 总弃电量 | 弃风量 + 弃光量 | MWh |
+| 弃电损失比例 | 总弃电量 / 总潜在发电量 | % |
+
+**代码位置**：[`main.py:374-377`](main.py:374-377)
+
+```python
+# 计算弃电损失量
+total_curtail_wind = sum(result['curtailed_wind'])
+total_curtail_solar = sum(result['curtailed_solar'])
+total_curtail_energy = total_curtail_wind + total_curtail_solar
+
+# 计算总潜在发电量
+total_potential_generation = sum(solar_output) + sum(wind_output) + sum(thermal_output)
+curtailment_loss_ratio = (total_curtail_energy / total_potential_generation * 100) if total_potential_generation > 0 else 0
+```
+
+### 2. 运行数据工作表增强
+
+在 `data_df` 中新增了以下列：
+
+| 新增列名 | 说明 | 计算方式 |
+|---------|------|----------|
+| 弃电损失量(MW) | 每小时的弃电损失量 | 弃风量 + 弃光量 |
+| 累计弃电量(MWh) | 从开始到当前的累计弃电量 | 逐小时累加弃电损失量 |
+
+**代码位置**：[`main.py:323-348`](main.py:323-348)
+
+```python
+# 计算弃电损失量（弃风+弃光）
+curtailment_loss = [result['curtailed_wind'][i] + result['curtailed_solar'][i] for i in range(len(result['curtailed_wind']))]
+
+# 计算累计弃电损失量
+cumulative_curtailment = []
+cumulative = 0
+for loss in curtailment_loss:
+    cumulative += loss
+    cumulative_curtailment.append(cumulative)
+```
+
+## 功能特点
+
+### 1. 完整的弃电损失分析
+- **小时级分析**：`弃电损失量(MW)` 提供每小时的弃电情况
+- **累计分析**：`累计弃电量(MWh)` 提供弃电的累积趋势
+- **总量统计**：总弃风量、总弃光量、总弃电量的完整统计
+- **比例分析**：弃电损失比例，评估系统效率
+
+### 2. 数据一致性保证
+- 运行数据中的累计弃电量 = 统计结果中的总弃电量
+- 弃电损失量 = 弃风量 + 弃光量（逐小时匹配）
+- 所有计算基于原始优化结果，确保数据一致性
+
+### 3. 用户友好的输出
+- Excel文件中清晰的工作表分类
+- 中文列名，便于理解
+- 合理的单位标注（MW用于功率，MWh用于能量）
+
+## 输出效果
+
+### 统计结果工作表示例
+```
+指标                | 数值
+-------------------|------------------
+总弃风电量          | 12.50 MWh
+总弃光电量          | 8.30 MWh
+总弃电量            | 20.80 MWh
+弃电损失比例        | 2.34%
+```
+
+### 运行数据工作表新增列
+```
+小时 | 弃风量(MW) | 弃光量(MW) | 弃电损失量(MW) | 累计弃电量(MWh)
+-----|-----------|-----------|---------------|--------------
+1    | 0.5       | 0.3       | 0.8           | 0.8
+2    | 0.2       | 0.4       | 0.6           | 1.4
+3    | 0.0       | 0.5       | 0.5           | 1.9
+...  | ...       | ...       | ...           | ...
+```
+
+## 使用说明
+
+1. **运行程序**：`python main.py --excel data.xlsx`
+2. **查看结果**：在生成的Excel文件中查看"统计结果"和"运行数据"工作表
+3. **分析弃电**：
+   - 统计结果：了解总体弃电情况和损失比例
+   - 运行数据：分析逐小时弃电模式和累计趋势
+
+## 技术细节
+
+### 计算公式
+- **弃电损失量** = 弃风量 + 弃光量
+- **累计弃电量** = Σ(弃电损失量) (逐小时累加)
+- **弃电损失比例** = (总弃电量 / 总潜在发电量) × 100%
+- **总潜在发电量** = 光伏总出力 + 风电总出力 + 火电总出力
+
+### 数据来源
+- 基于 `storage_optimization.py` 中的 `result` 字典
+- 使用 `curtailed_wind` 和 `curtailed_solar` 数据
+- 确保与优化算法结果完全一致
+
+## 兼容性
+
+- ✅ 向后兼容：不影响原有功能
+- ✅ Excel格式：保持原有文件结构
+- ✅ 时间尺度：支持24小时和8760小时数据
+- ✅ 数据精度：保持原有计算精度
+
+## 验证
+
+创建了测试文件 `test_main_modifications.py` 用于验证功能正确性：
+- 验证Excel文件导出成功
+- 检查新增列是否正确添加
+- 验证数据计算的一致性
+- 确认统计结果的准确性
+
+## 总结
+
+此次修改成功地在Excel输出中增加了完整的弃电损失量分析功能，为用户提供了更详细和直观的弃电情况分析工具，有助于优化储能系统配置和运行策略。

docs/GRID_FEED_IN_RATIO_CALCULATION.md

@@ -0,0 +1,121 @@
+# 上网电量比例计算方法说明
+
+## 计算公式
+
+**上网电量比例** = 总上网电量 / 总发电量
+
+其中：
+- **总上网电量** = sum(grid_feed_in) - 只计算正值（上网电量）
+- **总发电量** = 火电发电量 + 实际风电发电量 + 实际光伏发电量
+
+## 详细计算过程
+
+### 1. 基础数据获取
+
+在 [`check_constraints()`](src/storage_optimization.py:350) 函数中：
+
+```python
+# 计算总量
+total_wind_potential = sum(wind_output)        # 风电总潜力
+total_solar_potential = sum(solar_output)      # 光伏总潜力  
+total_thermal = sum(thermal_output)            # 火电总量
+
+total_curtailed_wind = sum(balance_result['curtailed_wind'])    # 弃风总量
+total_curtailed_solar = sum(balance_result['curtailed_solar'])  # 弃光总量
+total_grid_feed_in = sum(balance_result['grid_feed_in'])        # 电网交互总量
+```
+
+### 2. 计算实际发电量
+
+```python
+# 实际发电量（考虑弃风弃光）
+actual_wind_generation = total_wind_potential - total_curtailed_wind
+actual_solar_generation = total_solar_potential - total_curtailed_solar
+total_generation = total_thermal + actual_wind_generation + actual_solar_generation
+```
+
+### 3. 计算上网电量比例
+
+```python
+actual_grid_feed_in_ratio = total_grid_feed_in / total_generation if total_generation > 0 else 0
+```
+
+## 数据来源说明
+
+### grid_feed_in 数据含义
+在 [`calculate_energy_balance()`](src/storage_optimization.py:107) 函数中：
+
+- **正值** = 向电网输送的电量（上网）
+- **负值** = 从电网购买的电量（购电）
+
+```python
+# 上网情况
+grid_feed_in[hour] = grid_feed_allowed  # 正值
+
+# 购电情况  
+grid_feed_in[hour] = -remaining_deficit  # 负值
+```
+
+### 分母说明
+**总发电量**包括：
+1. **火电发电量** - 全部计入（不考虑弃火电）
+2. **实际风电发电量** = 风电总潜力 - 弃风量
+3. **实际光伏发电量** = 光伏总潜力 - 弃光量
+
+## 计算示例
+
+假设有如下数据：
+- 火电总量：120 MWh (24小时 × 5MW)
+- 风电总量：72 MWh (24小时 × 平均3MW)
+- 光伏总量：48 MWh (24小时 × 平均2MW)
+- 弃风量：7.2 MWh
+- 弃光量：4.8 MWh
+- 上网电量：10 MWh
+
+计算过程：
+```python
+# 1. 实际发电量
+actual_wind = 72 - 7.2 = 64.8 MWh
+actual_solar = 48 - 4.8 = 43.2 MWh
+total_generation = 120 + 64.8 + 43.2 = 228 MWh
+
+# 2. 上网电量比例
+grid_feed_in_ratio = 10 / 228 = 0.0438 ≈ 4.38%
+```
+
+## 注意事项
+
+### 1. 购电情况的处理
+- 如果系统净购电（total_grid_feed_in < 0），上网电量比例仍按公式计算
+- 负的上网电量会降低比例值
+
+### 2. 零分母处理
+- 如果总发电量为0，比例设为0，避免除零错误
+
+### 3. 约束检查
+在优化算法中，上网电量比例用于约束检查：
+```python
+grid_constraint_satisfied = constraint_results['total_grid_feed_in_ratio'] <= params.max_grid_ratio
+```
+
+## 输出位置
+
+上网电量比例在以下位置输出：
+1. **控制台输出**：[`main.py:749`](main.py:749)
+   ```python
+   print(f"实际上网电量比例: {result['total_grid_feed_in_ratio']:.3f}")
+   ```
+
+2. **Excel统计结果**：[`main.py:393`](main.py:393)
+   ```python
+   f"{result['total_grid_feed_in_ratio']:.3f}",
+   ```
+
+3. **可视化显示**：[`src/advanced_visualization.py:158`](src/advanced_visualization.py:158)
+   ```python
+   上网电量比例: {result['total_grid_feed_in_ratio']:.1%}
+   ```
+
+## 总结
+
+上网电量比例反映的是系统向电网输送电量占总发电量的比例，是评估系统电网交互特性的重要指标。该比例越低，说明系统越倾向于本地消纳新能源；比例越高，说明系统向电网输出的电量越多。

docs/MULTI_SCENARIO_MODULE.md

@@ -0,0 +1,236 @@
+# 多场景聚类分析模块说明
+
+## 模块概述
+
+`multi_scenario.py` 是一个专门用于多维时间序列数据聚类分析的Python模块。该模块能够同时对光伏出力、风电出力和负荷需求进行聚类分析，识别不同的运行场景，提取典型场景，并生成详细的分析报告。
+
+## 核心功能
+
+### 1. 多维数据聚类
+- **同时聚类**：光伏、风电、负荷三个维度同时进行聚类分析
+- **特征标准化**：自动对多维数据进行标准化处理
+- **智能命名**：根据聚类中心自动生成场景名称（如"场景1(高光伏+中风电+高负荷)"）
+
+### 2. 最优聚类数确定
+- **肘部法则**：通过分析聚类内误差和确定最优聚类数
+- **轮廓系数**：计算聚类质量，选择轮廓系数最高的聚类数
+- **自动化选择**：支持自动寻找最优聚类数
+
+### 3. 场景特征分析
+- **统计信息**：计算各场景的光伏、风电、负荷的均值和标准差
+- **频率统计**：分析各场景的出现频率和持续时间
+- **特征对比**：生成雷达图对比不同场景的特征
+
+### 4. 典型日提取
+- **完整日识别**：自动识别各场景的完整代表日
+- **典型曲线**：提取每个场景的典型日内变化曲线
+- **场景标记**：记录典型日对应的年内的天数
+
+### 5. 可视化分析
+- **9宫格综合图表**：包含场景分布、频率、特征、典型日等
+- **时间序列展示**：展示8760小时数据的场景分布
+- **统计分析表格**：生成详细的场景统计摘要
+
+### 6. 结果导出
+- **Excel报告**：导出包含时间序列、统计、典型日的完整报告
+- **图表保存**：保存高质量的分析图表
+- **参数记录**：记录聚类参数和分析时间
+
+## 主要类和函数
+
+### MultiScenarioAnalyzer 类
+
+#### 初始化参数
+```python
+MultiScenarioAnalyzer(n_clusters: int = 8, random_state: int = 42)
+```
+- `n_clusters`: 聚类数量，默认8个场景
+- `random_state`: 随机种子，确保结果可重现
+
+#### 核心方法
+
+**fit_predict()** - 执行聚类分析
+```python
+result = analyzer.fit_predict(
+    solar_output,     # 光伏出力曲线 (MW)
+    wind_output,      # 风电出力曲线 (MW)  
+    load_demand,      # 负荷曲线 (MW)
+    find_optimal_k=False  # 是否自动寻找最优聚类数
+)
+```
+
+**plot_scenario_analysis()** - 生成分析图表
+```python
+analyzer.plot_scenario_analysis(
+    result,           # 聚类结果
+    solar_output,     # 光伏出力数据
+    wind_output,      # 风电出力数据
+    load_demand,      # 负荷数据
+    save_path=None,   # 图片保存路径
+    show_plot=False   # 是否显示图片
+)
+```
+
+**export_scenario_results()** - 导出Excel报告
+```python
+excel_file = analyzer.export_scenario_results(
+    result,           # 聚类结果
+    solar_output,     # 光伏出力数据
+    wind_output,      # 风电出力数据
+    load_demand,      # 负荷数据
+    filename=None     # 输出文件名
+)
+```
+
+### ScenarioResult 数据类
+
+存储聚类分析结果的容器：
+```python
+@dataclass
+class ScenarioResult:
+    cluster_labels: np.ndarray          # 每个时间点的场景标签
+    cluster_centers: np.ndarray         # 各场景的聚类中心
+    scenario_names: List[str]           # 场景名称
+    scenario_stats: Dict                # 各场景统计信息
+    silhouette_score: float             # 轮廓系数
+    n_scenarios: int                    # 场景数量
+    scenario_frequencies: np.ndarray    # 各场景出现频率
+    typical_days: Dict                  # 典型日数据
+```
+
+## 使用示例
+
+### 基础使用
+```python
+from src.multi_scenario import MultiScenarioAnalyzer
+
+# 创建分析器
+analyzer = MultiScenarioAnalyzer(n_clusters=6, random_state=42)
+
+# 执行聚类分析
+result = analyzer.fit_predict(solar_output, wind_output, load_demand)
+
+# 输出结果
+print(f"识别出 {result.n_scenarios} 个场景")
+print(f"轮廓系数: {result.silhouette_score:.3f}")
+for i, name in enumerate(result.scenario_names):
+    freq = result.scenario_frequencies[i]
+    print(f"{name}: 出现频率 {freq:.1%}")
+```
+
+### 自动寻找最优聚类数
+```python
+# 自动寻找最优聚类数
+result = analyzer.fit_predict(
+    solar_output, wind_output, load_demand, 
+    find_optimal_k=True
+)
+print(f"最优聚类数: {result.n_scenarios}")
+```
+
+### 生成分析图表
+```python
+# 生成综合分析图表
+analyzer.plot_scenario_analysis(
+    result, solar_output, wind_output, load_demand,
+    save_path="scenario_analysis.png",
+    show_plot=True
+)
+```
+
+### 导出详细报告
+```python
+# 导出Excel报告
+excel_file = analyzer.export_scenario_results(
+    result, solar_output, wind_output, load_demand
+)
+print(f"报告已导出: {excel_file}")
+```
+
+## 输出文件说明
+
+### Excel报告结构
+
+**时间序列数据**工作表：
+- 小时、天数、光伏、风电、负荷、场景标签、场景名称
+
+**场景统计**工作表：
+- 场景编号、名称、出现频率、各指标均值和标准差
+
+**典型日数据**工作表：
+- 各场景的典型日内24小时变化曲线
+
+**分析参数**工作表：
+- 聚类数量、轮廓系数、随机种子、分析时间
+
+### 图表内容
+
+生成的9宫格图表包含：
+1. **场景时间分布** - 8760小时中各场景的分布情况
+2. **场景频率饼图** - 各场景的出现频率
+3. **聚类中心热力图** - 场景特征对比
+4. **典型日曲线** - 前3个场景的日内变化
+5. **场景特征雷达图** - 多维特征对比
+6. **统计摘要表** - 关键指标汇总
+7. **全年趋势图** - 日均值变化趋势
+
+## 技术特点
+
+### 1. 数据预处理
+- 自动检测数据长度一致性
+- 多维数据标准化处理
+- 支持8760小时全年数据
+
+### 2. 聚类算法
+- 使用K-means聚类算法
+- 通过轮廓系数评估聚类质量
+- 支持自定义或自动确定聚类数
+
+### 3. 场景理解
+- 基于聚类中心自动生成场景描述
+- 考虑光伏、风电、负荷的相对水平
+- 提供直观的场景命名
+
+### 4. 典型日提取
+- 智能识别完整的代表日
+- 确保典型日的场景纯度
+- 提供典型日的年内位置信息
+
+### 5. 可视化设计
+- 中文标签和说明
+- 专业的统计图表
+- 清晰的数据展示
+
+## 应用场景
+
+1. **电力系统规划**：识别典型运行场景，指导储能配置
+2. **新能源消纳分析**：分析不同场景下的新能源消纳特性
+3. **负荷预测**：基于场景分类进行精准负荷预测
+4. **运行策略优化**：针对不同场景制定差异化运行策略
+5. **风险评估**：分析极端场景的出现概率和影响
+
+## 性能说明
+
+- **处理能力**：支持8760小时数据的聚类分析
+- **计算效率**：K-means算法确保快速收敛
+- **内存使用**：优化的数据结构，内存占用合理
+- **结果稳定性**：固定随机种子确保结果可重现
+
+## 依赖库
+
+- numpy: 数值计算
+- pandas: 数据处理
+- matplotlib: 基础绘图
+- seaborn: 统计图表
+- scikit-learn: 机器学习算法
+- dataclasses: 数据结构
+
+## 注意事项
+
+1. **数据质量**：确保输入数据无异常值和缺失值
+2. **数据长度**：支持24小时或8760小时数据
+3. **聚类数选择**：聚类数不宜过多，建议3-12个
+4. **结果解释**：结合实际业务背景解释聚类结果
+5. **图表显示**：如需显示图表，需要合适的显示环境
+
+该模块为多能互补系统的运行分析和场景识别提供了强大的工具支持，有助于深入理解系统的运行规律和特性。

docs/MYPY_TYPE_FIXES.md

@@ -0,0 +1,204 @@
+# mypy 类型注解修复说明
+
+## 修复概述
+
+针对 `multi_scenario.py` 模块中的 mypy 警告进行了全面的类型注解修复，提高了代码的类型安全性和可维护性。
+
+## 主要修复内容
+
+### 1. 导入类型增强
+
+**修复前**：
+```python
+from typing import List, Dict, Tuple, Optional
+```
+
+**修复后**：
+```python
+from typing import List, Dict, Tuple, Optional, Union
+```
+
+**说明**：添加了 `Union` 类型支持，用于处理混合类型的数据结构。
+
+### 2. 数据类字段类型注解
+
+**修复前**：
+```python
+@dataclass
+class ScenarioResult:
+    cluster_labels: np.ndarray
+    cluster_centers: np.ndarray
+    scenario_names: List[str]
+    scenario_stats: Dict                # 过于宽泛
+    silhouette_score: float
+    n_scenarios: int
+    scenario_frequencies: np.ndarray
+    typical_days: Dict                  # 过于宽泛
+```
+
+**修复后**：
+```python
+@dataclass
+class ScenarioResult:
+    cluster_labels: np.ndarray
+    cluster_centers: np.ndarray
+    scenario_names: List[str]
+    scenario_stats: Dict[str, Dict[str, float]]  # 明确嵌套结构
+    silhouette_score: float
+    n_scenarios: int
+    scenario_frequencies: np.ndarray
+    typical_days: Dict[str, Dict[str, float]]    # 明确嵌套结构
+```
+
+**说明**：将 `Dict` 类型具体化为 `Dict[str, Dict[str, float]]`，明确了字典的键值类型结构。
+
+### 3. 类属性类型注解
+
+**修复前**：
+```python
+def __init__(self, n_clusters: int = 8, random_state: int = 42):
+    self.n_clusters = n_clusters
+    self.random_state = random_state
+    self.scaler = StandardScaler()
+    self.kmeans = KMeans(n_clusters=n_clusters, random_state=random_state, n_init=10)
+    self.scenario_names = []  # 类型不明确
+```
+
+**修复后**：
+```python
+def __init__(self, n_clusters: int = 8, random_state: int = 42):
+    self.n_clusters: int = n_clusters
+    self.random_state: int = random_state
+    self.scaler: StandardScaler = StandardScaler()
+    self.kmeans: KMeans = KMeans(n_clusters=n_clusters, random_state=random_state, n_init=10)
+    self.scenario_names: List[str] = []
+```
+
+**说明**：为所有实例属性添加了明确的类型注解，提高类型检查的准确性。
+
+### 4. 函数返回类型注解
+
+**修复前**：
+```python
+def calculate_scenario_statistics(self, data: np.ndarray, labels: np.ndarray,
+                                original_data: np.ndarray) -> Dict:
+    # ...
+
+def extract_typical_days(self, solar_output: List[float], wind_output: List[float],
+                       load_demand: List[float], labels: np.ndarray) -> Dict:
+    # ...
+```
+
+**修复后**：
+```python
+def calculate_scenario_statistics(self, data: np.ndarray, labels: np.ndarray,
+                                original_data: np.ndarray) -> Dict[str, Dict[str, float]]:
+    # ...
+
+def extract_typical_days(self, solar_output: List[float], wind_output: List[float],
+                       load_demand: List[float], labels: np.ndarray) -> Dict[str, Dict[str, float]]:
+    # ...
+```
+
+**说明**：明确了函数返回的具体字典类型结构。
+
+### 5. 局部变量类型注解
+
+**修复前**：
+```python
+scenario_stats = {}
+
+typical_days = {}
+
+scenario_frequencies = np.array([...])
+
+hours = list(range(1, len(solar_output) + 1))
+days = [(h - 1) // 24 + 1 for h in hours]
+
+summary_data = []
+typical_data = []
+
+table_data = []
+```
+
+**修复后**：
+```python
+scenario_stats: Dict[str, Dict[str, float]] = {}
+
+typical_days: Dict[str, Dict[str, float]] = {}
+
+scenario_frequencies: np.ndarray = np.array([...])
+
+hours: List[int] = list(range(1, len(solar_output) + 1))
+days: List[int] = [(h - 1) // 24 + 1 for h in hours]
+
+summary_data: List[Dict[str, str]] = []
+typical_data: List[Dict[str, float]] = []
+
+table_data: List[List[str]] = []
+
+params_data: Dict[str, List[Union[int, str]]] = {...}
+```
+
+**说明**：为所有局部变量添加了明确的类型注解，消除了类型推断的不确定性。
+
+## 修复效果
+
+### 1. mypy 检查改善
+- **修复前**：存在多个类型注解缺失和类型不明确的警告
+- **修复后**：类型注解完整且明确，mypy 检查更加严格和准确
+
+### 2. 代码质量提升
+- **类型安全**：在编译时就能发现类型相关错误
+- **可读性**：类型注解使代码的意图更加明确
+- **维护性**：IDE 可以提供更好的代码补全和错误提示
+
+### 3. 开发体验改善
+- **智能提示**：IDE 可以基于类型注解提供准确的代码补全
+- **错误检测**：在开发阶段就能发现类型不匹配的问题
+- **重构支持**：重构时类型系统可以提供安全保障
+
+## 类型注解最佳实践
+
+### 1. 具体化泛型类型
+- **避免**：使用过于宽泛的类型如 `Dict`, `List`
+- **推荐**：使用具体的类型如 `Dict[str, float]`, `List[int]`
+
+### 2. 明确标注所有属性
+- **避免**：依赖类型推断的隐式类型
+- **推荐**：为所有实例属性和重要局部变量添加类型注解
+
+### 3. 使用合适的导入
+- **基础类型**：`List`, `Dict`, `Tuple`, `Optional`
+- **高级类型**：`Union`, `Type`, `Callable`
+- **特定库**：如 `numpy.ndarray`, `pandas.DataFrame`
+
+### 4. 保持一致性
+- **命名约定**：使用一致的变量命名和类型命名
+- **风格统一**：在整个项目中保持相同的类型注解风格
+
+## 验证方法
+
+可以使用以下命令验证类型注解的正确性：
+
+```bash
+# 安装 mypy
+pip install mypy
+
+# 运行类型检查
+mypy src/multi_scenario.py
+
+# 严格模式检查
+mypy --strict src/multi_scenario.py
+```
+
+## 总结
+
+通过这些类型注解修复，`multi_scenario.py` 模块现在具有：
+
+1. **完整的类型覆盖**：所有重要变量都有明确的类型注解
+2. **准确的类型信息**：类型注解精确反映了数据的实际结构
+3. **良好的开发体验**：IDE 和类型检查器可以提供更好的支持
+4. **高代码质量**：类型安全有助于减少运行时错误
+
+这些改进使代码更加健壮、易于维护，并提供了更好的开发工具支持。

docs/SCENARIO_STORAGE_OPTIMIZATION.md

@@ -0,0 +1,228 @@
+# 场景储能配置优化模块
+
+## 功能概述
+
+本模块将多场景聚类分析与储能容量优化相结合，为多能互补系统提供场景化的储能配置方案。通过识别不同的运行模式，为每种场景提供最优的储能容量建议。
+
+## 主要特性
+
+### 1. 多场景储能优化
+- **场景识别**: 基于光伏、风电、负荷三维度进行聚类分析
+- **储能配置**: 为每个场景独立计算最优储能容量
+- **结果汇总**: 提供加权平均和最大需求分析
+
+### 2. 智能数据处理
+- **短时扩展**: 自动将短时场景数据扩展为24小时
+- **长度适配**: 确保数据符合储能优化算法要求
+- **错误处理**: 完善的异常捕获和提示机制
+
+### 3. 可视化分析
+- **结果展示**: 清晰的场景储能需求汇总表
+- **配置建议**: 基于安全系数的储能容量推荐
+- **频率分析**: 基于场景出现频率的加权计算
+
+## 核心类和方法
+
+### MultiScenarioAnalyzer类
+
+#### 新增方法
+
+##### `optimize_storage_for_scenarios()`
+对聚类后的场景进行储能配置优化。
+
+**参数:**
+- `result`: 聚类结果 (ScenarioResult)
+- `solar_output`: 光伏出力曲线 (List[float], MW)
+- `wind_output`: 风电出力曲线 (List[float], MW) 
+- `load_demand`: 负荷曲线 (List[float], MW)
+- `system_params`: 系统参数 (SystemParameters, 可选)
+- `safety_factor`: 安全系数 (float, 默认1.2)
+
+**返回:**
+- Dict[str, Dict[str, float]]: 各场景的储能优化结果
+
+**功能:**
+1. 遍历所有识别出的场景
+2. 提取每个场景的数据点
+3. 确保数据长度为24小时
+4. 调用储能优化算法
+5. 计算加权平均和推荐容量
+
+##### `_extract_scenario_data()`
+提取指定场景的数据点。
+
+**参数:**
+- `solar_output`: 光伏出力曲线
+- `wind_output`: 风电出力曲线  
+- `load_demand`: 负荷曲线
+- `cluster_labels`: 场景标签
+- `scenario_id`: 场景编号
+
+**返回:**
+- Tuple[List[float], List[float], List[float], int]: 场景数据和时间长度
+
+##### `print_storage_optimization_summary()`
+打印储能配置优化汇总结果。
+
+**参数:**
+- `optimization_results`: 储能优化结果
+
+**输出:**
+- 格式化的场景对比表格
+- 加权平均和最大需求
+- 储能容量配置建议
+
+## 使用示例
+
+```python
+from multi_scenario import MultiScenarioAnalyzer
+from storage_optimization import SystemParameters
+
+# 1. 生成测试数据
+solar_output = [0.0] * 6 + [5.0] * 12 + [0.0] * 6  # 光伏出力
+wind_output = [3.0] * 24  # 风电出力
+load_demand = [10.0] * 24  # 负荷曲线
+
+# 2. 执行多场景聚类
+analyzer = MultiScenarioAnalyzer(n_clusters=3, random_state=42)
+result = analyzer.fit_predict(solar_output, wind_output, load_demand)
+
+# 3. 储能配置优化
+system_params = SystemParameters(
+    max_curtailment_wind=0.1,
+    max_curtailment_solar=0.1,
+    max_grid_ratio=0.2,
+    storage_efficiency=0.9,
+    discharge_rate=1.0,
+    charge_rate=1.0
+)
+
+optimization_results = analyzer.optimize_storage_for_scenarios(
+    result, solar_output, wind_output, load_demand, 
+    system_params, safety_factor=1.2
+)
+
+# 4. 查看结果
+analyzer.print_storage_optimization_summary(optimization_results)
+```
+
+## 输出结果
+
+### 优化结果结构
+```python
+{
+    'scenario_id': {
+        'scenario_name': '场景名称',
+        'duration': 24,  # 小时
+        'required_storage': 5.0,  # MWh
+        'curtailment_wind': 0.05,  # 弃风率
+        'curtailment_solar': 0.03,  # 弃光率
+        'grid_ratio': 0.15,  # 上网比例
+        'frequency': 0.3,  # 场景频率
+        'energy_balance_check': True  # 能量平衡检查
+    },
+    'summary': {
+        'weighted_average_storage': 4.5,  # MWh
+        'maximum_storage_need': 8.0,  # MWh
+        'recommended_capacity': 9.6,  # MWh
+        'safety_factor': 1.2,
+        'n_scenarios': 3
+    }
+}
+```
+
+### 控制台输出示例
+```
+================================================================================
+场景储能配置优化汇总
+================================================================================
+场景       名称                        频率       储能容量       弃风率      弃光率     
+--------------------------------------------------------------------------------
+场景1    低负荷(低光伏+低风电+低负荷)  25.0%     1.00 MWh     0.000      0.000     
+
+场景2    高负荷(高光伏+低风电+高负荷)  45.0%     3.00 MWh     0.100      0.050     
+
+场景3    中负荷(中光伏+高风电+中负荷)  30.0%     2.00 MWh     0.020      0.000     
+
+--------------------------------------------------------------------------------
+加权平均储能需求                            2.25      MWh
+最大储能需求                              3.00      MWh
+推荐储能容量                              3.60      MWh
+安全系数                                1.20     
+
+配置建议:
+  - 建议：储能容量配置相对合理
+================================================================================
+```
+
+## 技术特点
+
+### 1. 模块化设计
+- **职责分离**: `src/multi_scenario.py` 专门用于储能配置优化
+- **测试分离**: `test_multi_scenario.py` 只做基本聚类测试
+- **功能集成**: 聚类分析+储能优化的完整工作流
+
+### 2. 智能处理逻辑
+- **数据扩展**: 自动处理短时场景数据
+- **长度适配**: 确保24小时数据用于优化
+- **频率加权**: 基于场景出现频率的储能需求计算
+
+### 3. 鲁棒性设计
+- **异常处理**: 完善的错误捕获和提示
+- **边界检查**: 场景数据完整性验证
+- **参数验证**: 系统参数合理性检查
+
+## 测试验证
+
+### 基础功能测试
+- 多场景聚类分析
+- 储能配置优化计算
+- 结果汇总和展示
+
+### 边界情况测试
+- 短时间数据处理
+- 极大储能需求场景
+- 不同聚类数效果对比
+
+### 性能测试
+- 长时间序列数据处理
+- 多场景同时优化
+- 结果输出和存储
+
+## 应用价值
+
+### 1. 规划设计支持
+- **场景化设计**: 为不同运行模式提供定制化储能配置
+- **容量优化**: 基于实际运行模式的科学容量计算
+- **风险评估**: 考虑极端场景的安全系数设计
+
+### 2. 运行策略制定
+- **模式识别**: 自动识别典型运行模式
+- **策略切换**: 基于场景的储能运行策略
+- **适应性**: 适应季节性和随机性变化
+
+### 3. 投资决策依据
+- **成本优化**: 平衡储能投资与运行效果
+- **风险控制**: 基于极端场景的容量保障
+- **经济评估**: 为投资决策提供量化依据
+
+## 后续扩展
+
+### 1. 功能增强
+- **多时域优化**: 季节性和日内储能协调
+- **动态调度**: 基于实时场景的储能调度
+- **成本效益分析**: 集成经济性评估
+
+### 2. 应用扩展
+- **多能系统**: 扩展到更多能源类型
+- **微电网**: 适配不同规模的微电网
+- **虚拟电厂**: 支持虚拟电厂储能配置
+
+### 3. 算法优化
+- **智能算法**: 集成机器学习优化方法
+- **预测融合**: 结合天气预报的场景预测
+- **自适应**: 动态调整聚类和优化参数
+
+## 总结
+
+场景储能配置优化模块为多能互补系统提供了一个完整的储能容量设计工具。通过多场景聚类分析和储能优化的结合，实现了从数据到决策的全流程支持，具有很强的工程应用价值。

excel_reader.py

@@ -1,840 +0,0 @@
-"""
-Excel数据读取模块
-
-该模块提供从Excel文件中读取8760小时负荷和发电曲线数据的功能。
-
-作者: iFlow CLI
-创建日期: 2025-12-25
-"""
-
-import pandas as pd
-import numpy as np
-from typing import Dict, List, Optional, Tuple, Any
-import os
-from storage_optimization import SystemParameters
-
-
-def validate_excel_data(df: pd.DataFrame, data_type: str = "8760") -> bool:
-    """
-    验证Excel数据格式是否正确
-    
-    Args:
-        df: pandas DataFrame对象
-        data_type: 数据类型，"24"或"8760"
-        
-    Returns:
-        bool: 验证是否通过
-    """
-    expected_length = 8760 if data_type == "8760" else 24
-    
-    # 检查行数
-    if len(df) != expected_length:
-        print(f"错误：数据行数应为{expected_length}，实际为{len(df)}")
-        return False
-    
-    # 检查必需的列
-    required_columns = ['光伏出力(MW)', '风电出力(MW)', '火电出力(MW)', '负荷需求(MW)']
-    missing_columns = [col for col in required_columns if col not in df.columns]
-    
-    if missing_columns:
-        print(f"错误：缺少必需的列：{missing_columns}")
-        return False
-    
-    # 检查数据类型和非负值
-    for col in required_columns:
-        if not pd.api.types.is_numeric_dtype(df[col]):
-            print(f"错误：列'{col}'必须为数值类型")
-            return False
-        
-        if (df[col] < 0).any():
-            print(f"错误：列'{col}'包含负值")
-            return False
-    
-    return True
-
-
-def read_system_parameters(file_path: str) -> SystemParameters:
-    """
-    从Excel文件读取系统参数
-    
-    Args:
-        file_path: Excel文件路径
-        
-    Returns:
-        SystemParameters对象
-        
-    Raises:
-        FileNotFoundError: 文件不存在
-        ValueError: 参数格式错误
-    """
-    # 检查文件是否存在
-    if not os.path.exists(file_path):
-        raise FileNotFoundError(f"文件不存在：{file_path}")
-    
-    try:
-        # 读取参数工作表
-        df_params = pd.read_excel(file_path, sheet_name='参数')
-        
-        # 验证参数工作表格式
-        required_columns = ['参数名称', '参数值', '参数说明']
-        missing_columns = [col for col in required_columns if col not in df_params.columns]
-        
-        if missing_columns:
-            raise ValueError(f"参数工作表缺少必需的列：{missing_columns}")
-        
-        # 提取参数值
-        params_dict = {}
-        for _, row in df_params.iterrows():
-            param_name = row['参数名称']
-            param_value = row['参数值']
-            
-            # 跳过空行
-            if pd.isna(param_name) or pd.isna(param_value):
-                continue
-                
-            # 转换参数值
-            try:
-                if isinstance(param_value, str):
-                    # 尝试转换为浮点数
-                    param_value = float(param_value)
-                params_dict[param_name] = param_value
-            except (ValueError, TypeError):
-                raise ValueError(f"参数 '{param_name}' 的值 '{param_value}' 不是有效的数值")
-        
-        # 读取各参数值，如果找不到则使用默认值
-        get_param_value = lambda param_name: df_params.loc[df_params['参数名称'] == param_name, '参数值'].iloc[0] if param_name in df_params['参数名称'].values else None
-        
-        max_storage_capacity = get_param_value('最大储能容量')
-        # 处理空值或字符串"空"
-        if pd.isna(max_storage_capacity) or max_storage_capacity == '空':
-            max_storage_capacity = None
-        
-        try:
-            # 获取各参数值，区分None、NaN、0和有效值
-            def get_param_with_default(param_name, default_value):
-                value = get_param_value(param_name)
-                if value is None or pd.isna(value):
-                    return default_value
-                else:
-                    return value
-            
-            return SystemParameters(
-                max_curtailment_wind=get_param_with_default('最大弃风率', 0.1),
-                max_curtailment_solar=get_param_with_default('最大弃光率', 0.1),
-                max_grid_ratio=get_param_with_default('最大上网电量比例', 0.2),
-                storage_efficiency=get_param_with_default('储能效率', 0.9),
-                discharge_rate=get_param_with_default('放电倍率', 1.0),
-                charge_rate=get_param_with_default('充电倍率', 1.0),
-                max_storage_capacity=max_storage_capacity,
-                rated_thermal_capacity=get_param_with_default('额定火电装机容量', 100.0),
-                rated_solar_capacity=get_param_with_default('额定光伏装机容量', 100.0),
-                rated_wind_capacity=get_param_with_default('额定风电装机容量', 100.0),
-                available_thermal_energy=get_param_with_default('火电可用发电量', 2400.0),
-                available_solar_energy=get_param_with_default('光伏可用发电量', 600.0),
-                available_wind_energy=get_param_with_default('风电可用发电量', 1200.0)
-            )
-        except (KeyError, IndexError, Exception) as e:
-            print(f"读取参数失败：{str(e)}，使用默认参数")
-            return SystemParameters(
-                max_curtailment_wind=0.1,
-                max_curtailment_solar=0.1,
-                max_grid_ratio=0.2,
-                storage_efficiency=0.9,
-                discharge_rate=1.0,
-                charge_rate=1.0,
-                rated_thermal_capacity=100.0,
-                rated_solar_capacity=100.0,
-                rated_wind_capacity=100.0,
-                available_thermal_energy=2400.0,
-                available_solar_energy=600.0,
-                available_wind_energy=1200.0
-            )
-        
-    except Exception as e:
-        print(f"读取参数工作表失败，使用默认参数：{str(e)}")
-        # 如果参数工作表不存在或读取失败，返回默认参数
-        return SystemParameters()
-
-
-def read_excel_data(file_path: str, sheet_name: str = 0, include_parameters: bool = True) -> Dict[str, List[float]]:
-    """
-    从Excel文件读取8760小时数据
-    
-    Args:
-        file_path: Excel文件路径
-        sheet_name: 工作表名称或索引，默认为第一个工作表
-        include_parameters: 是否同时读取系统参数
-        
-    Returns:
-        包含所有数据的字典
-        
-    Raises:
-        FileNotFoundError: 文件不存在
-        ValueError: 数据格式错误
-    """
-    # 检查文件是否存在
-    if not os.path.exists(file_path):
-        raise FileNotFoundError(f"文件不存在：{file_path}")
-    
-    try:
-        # 读取Excel文件
-        df = pd.read_excel(file_path, sheet_name=sheet_name)
-        
-        # 自动检测数据类型
-        data_type = "8760" if len(df) >= 8760 else "24"
-        
-        # 验证数据格式
-        if not validate_excel_data(df, data_type):
-            raise ValueError("Excel数据格式验证失败")
-        
-        # 提取数据并转换为列表
-        solar_output = df['光伏出力(MW)'].tolist()
-        wind_output = df['风电出力(MW)'].tolist()
-        thermal_output = df['火电出力(MW)'].tolist()
-        load_demand = df['负荷需求(MW)'].tolist()
-        
-        # 如果是24小时数据，扩展到8760小时（重复365天）
-        if data_type == "24" and len(df) == 24:
-            print("检测到24小时数据，自动扩展到8760小时（重复365天）")
-            solar_output = solar_output * 365
-            wind_output = wind_output * 365
-            thermal_output = thermal_output * 365
-            load_demand = load_demand * 365
-        
-        # 构建返回结果
-        result = {
-            'solar_output': solar_output,
-            'wind_output': wind_output,
-            'thermal_output': thermal_output,
-            'load_demand': load_demand,
-            'data_type': data_type,
-            'original_length': len(df)
-        }
-        
-        # 如果需要读取参数
-        if include_parameters:
-            try:
-                result['system_parameters'] = read_system_parameters(file_path)
-                print("成功读取系统参数")
-            except Exception as e:
-                print(f"读取系统参数失败，使用默认参数：{str(e)}")
-                result['system_parameters'] = SystemParameters()
-            
-            try:
-                result['economic_parameters'] = read_economic_parameters(file_path)
-                print("成功读取经济参数")
-            except Exception as e:
-                print(f"读取经济参数失败，使用默认参数：{str(e)}")
-                from economic_optimization import EconomicParameters
-                result['economic_parameters'] = EconomicParameters()
-            
-            try:
-                result['optimization_settings'] = get_optimization_settings(file_path)
-                print("成功读取优化设置")
-            except Exception as e:
-                print(f"读取优化设置失败，使用默认设置：{str(e)}")
-                result['optimization_settings'] = {
-                    'storage_capacity_range': (0, 1000),
-                    'rate_range': (0.1, 2.0),
-                    'max_iterations': 100,
-                    'tolerance': 0.01
-                }
-        
-        return result
-        
-    except Exception as e:
-        raise ValueError(f"读取Excel文件失败：{str(e)}")
-
-
-def create_excel_template(file_path: str, data_type: str = "8760"):
-    """
-    创建Excel数据模板文件
-    
-    Args:
-        file_path: 保存路径
-        data_type: 数据类型，"24"或"8760"
-    """
-    # 生成示例数据
-    if data_type == "24":
-        hours = 24
-        # 24小时典型日数据
-        solar = [0.0] * 6 + [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 0.0] + [0.0] * 6
-        wind = [2.0, 3.0, 4.0, 3.0, 2.0, 1.0] * 4
-        thermal = [5.0] * 24
-        load = [3.0, 4.0, 5.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 18.0, 
-                16.0, 14.0, 12.0, 10.0, 8.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 2.0]
-        description = "24小时典型日数据模板"
-    else:
-        hours = 8760
-        # 生成8760小时的模拟数据（基于日模式加季节变化）
-        daily_solar = [0.0] * 6 + [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 0.0] + [0.0] * 6
-        daily_wind = [2.0, 3.0, 4.0, 3.0, 2.0, 1.0] * 4
-        daily_thermal = [5.0] * 24
-        daily_load = [3.0, 4.0, 5.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 18.0, 
-                     16.0, 14.0, 12.0, 10.0, 8.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 2.0]
-        
-        solar = []
-        wind = []
-        thermal = []
-        load = []
-        
-        np.random.seed(42)  # 确保可重复性
-        
-        for day in range(365):
-            # 季节性因子
-            season_factor = 1.0 + 0.3 * np.sin(2 * np.pi * day / 365)
-            
-            for hour in range(24):
-                # 添加随机变化
-                solar_variation = 1.0 + 0.2 * (np.random.random() - 0.5)
-                wind_variation = 1.0 + 0.3 * (np.random.random() - 0.5)
-                load_variation = 1.0 + 0.1 * (np.random.random() - 0.5)
-                
-                solar.append(daily_solar[hour] * season_factor * solar_variation)
-                wind.append(daily_wind[hour] * wind_variation)
-                thermal.append(daily_thermal[hour])
-                load.append(daily_load[hour] * (2.0 - season_factor) * load_variation)
-        
-        description = "8760小时全年数据模板"
-    
-    # 创建DataFrame
-    df = pd.DataFrame({
-        '小时': range(1, hours + 1),
-        '光伏出力(MW)': solar,
-        '风电出力(MW)': wind,
-        '火电出力(MW)': thermal,
-        '负荷需求(MW)': load
-    })
-    
-    # 保存到Excel
-    with pd.ExcelWriter(file_path, engine='openpyxl') as writer:
-        df.to_excel(writer, sheet_name='数据', index=False)
-        
-        # 添加参数工作表
-        parameters_df = pd.DataFrame({
-            '参数名称': [
-                '最大弃风率',
-                '最大弃光率', 
-                '最大上网电量比例',
-                '储能效率',
-                '放电倍率',
-                '充电倍率',
-                '最大储能容量',
-                '额定火电装机容量',
-                '额定光伏装机容量',
-                '额定风电装机容量',
-                '火电可用发电量',
-                '光伏可用发电量',
-                '风电可用发电量'
-            ],
-            '参数值': [
-                0.1,    # 最大弃风率
-                0.1,    # 最大弃光率
-                0.2,    # 最大上网电量比例
-                0.9,    # 储能效率
-                1.0,    # 放电倍率
-                1.0,    # 充电倍率
-                '',     # 最大储能容量（空表示无限制）
-                0.0,    # 额定火电装机容量（可以为0）
-                100.0,  # 额定光伏装机容量
-                100.0,  # 额定风电装机容量
-                2400.0, # 火电可用发电量
-                600.0,  # 光伏可用发电量
-                1200.0  # 风电可用发电量
-            ],
-            '参数说明': [
-                '允许的最大弃风率（0.0-1.0）',
-                '允许的最大弃光率（0.0-1.0）',
-                '允许的最大上网电量比例（0.0-∞，只限制上网电量）',
-                '储能充放电效率（0.0-1.0）',
-                '储能放电倍率（C-rate，>0）',
-                '储能充电倍率（C-rate，>0）',
-                '储能容量上限（MWh，空表示无限制）',
-                '额定火电装机容量（MW，可以为0）',
-                '额定光伏装机容量（MW）',
-                '额定风电装机容量（MW）',
-                '火电可用发电量（MWh）',
-                '光伏可用发电量（MWh）',
-                '风电可用发电量（MWh）'
-            ],
-            '取值范围': [
-                '0.0-1.0',
-                '0.0-1.0', 
-                '≥0.0',
-                '0.0-1.0',
-                '>0',
-                '>0',
-                '>0或空',
-                '≥0',
-                '>0',
-                '>0',
-                '≥0',
-                '≥0',
-                '≥0'
-            ],
-            '默认值': [
-                '0.1',
-                '0.1',
-                '0.2', 
-                '0.9',
-                '1.0',
-                '1.0',
-                '无限制',
-                '0.0',
-                '100.0',
-                '100.0',
-                '2400.0',
-                '600.0',
-                '1200.0'
-            ]
-        })
-        parameters_df.to_excel(writer, sheet_name='参数', index=False)
-        
-        # 添加经济参数工作表
-        economic_params_df = pd.DataFrame({
-            '参数名称': [
-                '光伏建设成本',
-                '风电建设成本',
-                '储能建设成本',
-                '购电价格',
-                '上网电价',
-                '光伏运维成本',
-                '风电运维成本',
-                '储能运维成本',
-                '项目寿命',
-                '折现率',
-                '储能容量搜索范围-最小值',
-                '储能容量搜索范围-最大值',
-                '充放电倍率搜索范围-最小值',
-                '充放电倍率搜索范围-最大值',
-                '最大迭代次数',
-                '收敛容差'
-            ],
-            '参数值': [
-                3000000,    # 光伏建设成本 (元/MW)
-                2500000,     # 风电建设成本 (元/MW)
-                800000,      # 储能建设成本 (元/MWh)
-                600,         # 购电价格 (元/MWh)
-                400,         # 上网电价 (元/MWh)
-                50000,       # 光伏运维成本 (元/MW/年)
-                45000,       # 风电运维成本 (元/MW/年)
-                3000,        # 储能运维成本 (元/MW/年)
-                25,          # 项目寿命 (年)
-                0.08,        # 折现率
-                0,           # 储能容量搜索范围-最小值 (MWh)
-                1000,        # 储能容量搜索范围-最大值 (MWh)
-                0.1,         # 充放电倍率搜索范围-最小值
-                2.0,         # 充放电倍率搜索范围-最大值
-                100,         # 最大迭代次数
-                0.01         # 收敛容差
-            ],
-            '参数说明': [
-                '光伏发电系统建设成本 (元/MW)',
-                '风力发电系统建设成本 (元/MW)',
-                '储能系统建设成本 (元/MWh)',
-                '从电网购电价格 (元/MWh)',
-                '向电网售电价格 (元/MWh)',
-                '光伏系统年度运维成本 (元/MW/年)',
-                '风电系统年度运维成本 (元/MW/年)',
-                '储能系统年度运维成本 (元/MW/年)',
-                '项目运营寿命 (年)',
-                '项目折现率 (用于NPV计算)',
-                '储能容量优化搜索范围下限 (MWh)',
-                '储能容量优化搜索范围上限 (MWh)',
-                '充放电倍率优化搜索范围下限',
-                '充放电倍率优化搜索范围上限',
-                '优化算法最大迭代次数',
-                '优化算法收敛容差'
-            ],
-            '取值范围': [
-                '>0',
-                '>0',
-                '>0',
-                '>0',
-                '≥0',
-                '≥0',
-                '≥0',
-                '≥0',
-                '>0',
-                '0-1',
-                '≥0',
-                '>0',
-                '>0',
-                '>0',
-                '>0',
-                '>0'
-            ],
-            '默认值': [
-                '3,000,000',
-                '2,500,000',
-                '800,000',
-                '600',
-                '400',
-                '50,000',
-                '45,000',
-                '3,000',
-                '25',
-                '0.08',
-                '0',
-                '1000',
-                '0.1',
-                '2.0',
-                '100',
-                '0.01'
-            ]
-        })
-        economic_params_df.to_excel(writer, sheet_name='经济参数', index=False)
-        
-        # 添加说明工作表
-        description_df = pd.DataFrame({
-            '项目': ['数据说明', '数据类型', '时间范围', '单位', '注意事项', '参数说明', '经济优化说明'],
-            '内容': [
-                description,
-                f'{data_type}小时电力数据',
-                f'1-{hours}小时',
-                'MW (兆瓦)',
-                '所有数值必须为非负数',
-                '系统参数请在"参数"工作表中修改',
-                '经济优化参数请在"经济参数"工作表中修改'
-            ]
-        })
-        description_df.to_excel(writer, sheet_name='说明', index=False)
-    
-    print(f"Excel模板已创建：{file_path}")
-
-
-def analyze_excel_data(file_path: str) -> Dict[str, float]:
-    """
-    分析Excel数据的基本统计信息
-    
-    Args:
-        file_path: Excel文件路径
-        
-    Returns:
-        包含统计信息的字典
-    """
-    try:
-        data = read_excel_data(file_path)
-        
-        solar = data['solar_output']
-        wind = data['wind_output']
-        thermal = data['thermal_output']
-        load = data['load_demand']
-        
-        return {
-            'data_length': len(solar),
-            'total_solar': sum(solar),
-            'total_wind': sum(wind),
-            'total_thermal': sum(thermal),
-            'total_generation': sum(solar) + sum(wind) + sum(thermal),
-            'total_load': sum(load),
-            'max_solar': max(solar),
-            'max_wind': max(wind),
-            'max_thermal': max(thermal),
-            'max_load': max(load),
-            'avg_solar': np.mean(solar),
-            'avg_wind': np.mean(wind),
-            'avg_thermal': np.mean(thermal),
-            'avg_load': np.mean(load)
-        }
-    except Exception as e:
-        print(f"分析数据失败：{str(e)}")
-        return {}
-
-
-def read_economic_parameters(file_path: str):
-    """
-    从Excel文件读取经济参数
-    
-    Args:
-        file_path: Excel文件路径
-        
-    Returns:
-        EconomicParameters对象
-        
-    Raises:
-        FileNotFoundError: 文件不存在
-        ValueError: 参数格式错误
-    """
-    from economic_optimization import EconomicParameters
-    
-    # 检查文件是否存在
-    if not os.path.exists(file_path):
-        raise FileNotFoundError(f"文件不存在：{file_path}")
-    
-    try:
-        # 读取经济参数工作表
-        df_params = pd.read_excel(file_path, sheet_name='经济参数')
-        
-        # 验证经济参数工作表格式
-        required_columns = ['参数名称', '参数值', '参数说明']
-        missing_columns = [col for col in required_columns if col not in df_params.columns]
-        
-        if missing_columns:
-            raise ValueError(f"经济参数工作表缺少必需的列：{missing_columns}")
-        
-        # 提取参数值
-        params_dict = {}
-        for _, row in df_params.iterrows():
-            param_name = row['参数名称']
-            param_value = row['参数值']
-            
-            # 跳过空行
-            if pd.isna(param_name) or pd.isna(param_value):
-                continue
-                
-            # 转换参数值
-            try:
-                if isinstance(param_value, str):
-                    # 尝试转换为浮点数
-                    param_value = float(param_value)
-                params_dict[param_name] = param_value
-            except (ValueError, TypeError):
-                raise ValueError(f"经济参数 '{param_name}' 的值 '{param_value}' 不是有效的数值")
-        
-        # 读取各参数值，如果找不到则使用默认值
-        get_param_value = lambda param_name: df_params.loc[df_params['参数名称'] == param_name, '参数值'].iloc[0] if param_name in df_params['参数名称'].values else None
-        
-        try:
-            # 获取各参数值，区分None、NaN、0和有效值
-            def get_param_with_default(param_name, default_value):
-                value = get_param_value(param_name)
-                if value is None or pd.isna(value):
-                    return default_value
-                else:
-                    return value
-            
-            return EconomicParameters(
-                solar_capex=get_param_with_default('光伏建设成本', 3000000),
-                wind_capex=get_param_with_default('风电建设成本', 2500000),
-                storage_capex=get_param_with_default('储能建设成本', 800000),
-                electricity_price=get_param_with_default('购电价格', 600),
-                feed_in_price=get_param_with_default('上网电价', 400),
-                solar_om=get_param_with_default('光伏运维成本', 50000),
-                wind_om=get_param_with_default('风电运维成本', 45000),
-                storage_om=get_param_with_default('储能运维成本', 3000),
-                project_lifetime=int(get_param_with_default('项目寿命', 25)),
-                discount_rate=get_param_with_default('折现率', 0.08)
-            )
-        except (KeyError, IndexError, Exception) as e:
-            print(f"读取经济参数失败：{str(e)}，使用默认参数")
-            return EconomicParameters(
-                solar_capex=3000000,
-                wind_capex=2500000,
-                storage_capex=800000,
-                electricity_price=600,
-                feed_in_price=400,
-                solar_om=50000,
-                wind_om=45000,
-                storage_om=3000,
-                project_lifetime=25,
-                discount_rate=0.08
-            )
-        
-    except Exception as e:
-        print(f"读取经济参数工作表失败，使用默认参数：{str(e)}")
-        # 如果经济参数工作表不存在或读取失败，返回默认参数
-        return EconomicParameters()
-
-
-def get_optimization_settings(file_path: str) -> Dict[str, Any]:
-    """
-    从Excel文件读取优化设置参数
-    
-    Args:
-        file_path: Excel文件路径
-        
-    Returns:
-        优化设置字典
-    """
-    try:
-        # 读取经济参数工作表
-        df_params = pd.read_excel(file_path, sheet_name='经济参数')
-        
-        # 提取优化设置参数
-        get_param_value = lambda param_name: df_params.loc[df_params['参数名称'] == param_name, '参数值'].iloc[0] if param_name in df_params['参数名称'].values else None
-        
-        def get_param_with_default(param_name, default_value):
-            value = get_param_value(param_name)
-            if value is None or pd.isna(value):
-                return default_value
-            else:
-                return value
-        
-        return {
-            'storage_capacity_range': (
-                get_param_with_default('储能容量搜索范围-最小值', 0),
-                get_param_with_default('储能容量搜索范围-最大值', 1000)
-            ),
-            'rate_range': (
-                get_param_with_default('充放电倍率搜索范围-最小值', 0.1),
-                get_param_with_default('充放电倍率搜索范围-最大值', 2.0)
-            ),
-            'max_iterations': int(get_param_with_default('最大迭代次数', 100)),
-            'tolerance': get_param_with_default('收敛容差', 0.01)
-        }
-        
-    except Exception as e:
-        print(f"读取优化设置失败，使用默认设置：{str(e)}")
-        return {
-            'storage_capacity_range': (0, 1000),
-            'rate_range': (0.1, 2.0),
-            'max_iterations': 100,
-            'tolerance': 0.01
-        }
-
-
-def validate_system_parameters(params: SystemParameters) -> Dict[str, Any]:
-    """
-    验证系统参数的有效性
-    
-    Args:
-        params: SystemParameters对象
-        
-    Returns:
-        验证结果字典
-    """
-    validation_result = {
-        'valid': True,
-        'errors': [],
-        'warnings': []
-    }
-    
-    # 检查弃风率
-    if not (0.0 <= params.max_curtailment_wind <= 1.0):
-        validation_result['valid'] = False
-        validation_result['errors'].append(f"弃风率必须在0.0-1.0之间，当前值：{params.max_curtailment_wind}")
-    
-    # 检查弃光率
-    if not (0.0 <= params.max_curtailment_solar <= 1.0):
-        validation_result['valid'] = False
-        validation_result['errors'].append(f"弃光率必须在0.0-1.0之间，当前值：{params.max_curtailment_solar}")
-    
-    # 检查上网电量比例
-    if not (0.0 <= params.max_grid_ratio):
-        validation_result['valid'] = False
-        validation_result['errors'].append(f"上网电量比例必须为非负值，当前值：{params.max_grid_ratio}")
-    
-    # 检查储能效率
-    if not (0.0 < params.storage_efficiency <= 1.0):
-        validation_result['valid'] = False
-        validation_result['errors'].append(f"储能效率必须在0.0-1.0之间，当前值：{params.storage_efficiency}")
-    
-    # 检查放电倍率
-    if params.discharge_rate <= 0:
-        validation_result['valid'] = False
-        validation_result['errors'].append(f"放电倍率必须大于0，当前值：{params.discharge_rate}")
-    
-    # 检查充电倍率
-    if params.charge_rate <= 0:
-        validation_result['valid'] = False
-        validation_result['errors'].append(f"充电倍率必须大于0，当前值：{params.charge_rate}")
-    
-    # 检查储能容量上限
-    if params.max_storage_capacity is not None and params.max_storage_capacity <= 0:
-        validation_result['valid'] = False
-        validation_result['errors'].append(f"储能容量上限必须大于0，当前值：{params.max_storage_capacity}")
-    
-    # 添加警告信息
-    if params.storage_efficiency < 0.8:
-        validation_result['warnings'].append("储能效率较低，可能影响系统性能")
-    
-    if params.max_curtailment_wind > 0.3 or params.max_curtailment_solar > 0.3:
-        validation_result['warnings'].append("弃风弃光率较高，可能造成能源浪费")
-    
-    if params.max_grid_ratio > 0.5:
-        validation_result['warnings'].append("上网电量比例较高，可能影响电网稳定性")
-    
-    return validation_result
-
-
-def main():
-    """主函数，演示Excel数据读取功能"""
-    import sys
-    
-    # 检查命令行参数
-    if len(sys.argv) > 1 and sys.argv[1] == '--economic':
-        print("=== 创建经济优化Excel模板 ===")
-        
-        # 创建经济优化模板文件
-        economic_template_8760 = "economic_data_template_8760.xlsx"
-        economic_template_24 = "economic_data_template_24.xlsx"
-        
-        print("\n1. 创建经济优化Excel模板文件...")
-        create_excel_template(economic_template_8760, "8760")
-        create_excel_template(economic_template_24, "24")
-        
-        print(f"\n[OK] 经济优化Excel模板创建完成！")
-        print(f"[FILE] 8760小时模板: {economic_template_8760}")
-        print(f"[FILE] 24小时模板: {economic_template_24}")
-        print(f"\n[INFO] 模板包含以下工作表：")
-        print(f"   1. 数据 - 8760小时电力数据")
-        print(f"   2. 参数 - 系统运行参数")
-        print(f"   3. 经济参数 - 经济优化参数")
-        print(f"   4. 说明 - 使用说明")
-        print(f"\n[USAGE] 使用方法：")
-        print(f"   uv run python economic_optimization.py --excel {economic_template_8760}")
-        return
-    
-    print("=== Excel数据读取模块演示 ===")
-    
-    # 创建模板文件
-    template_8760 = "data_template_8760.xlsx"
-    template_24 = "data_template_24.xlsx"
-    
-    print("\n1. 创建Excel模板文件...")
-    create_excel_template(template_8760, "8760")
-    create_excel_template(template_24, "24")
-    
-    # 分析模板数据
-    print(f"\n2. 分析{template_8760}数据...")
-    stats = analyze_excel_data(template_8760)
-    if stats:
-        print("数据统计信息：")
-        for key, value in stats.items():
-            print(f"  {key}: {value:.2f}")
-    
-    print(f"\n3. 演示读取{template_24}数据...")
-    try:
-        data = read_excel_data(template_24)
-        print(f"成功读取数据，类型：{data['data_type']}")
-        print(f"光伏出力前10小时：{data['solar_output'][:10]}")
-        print(f"风电出力前10小时：{data['wind_output'][:10]}")
-        print(f"负荷需求前10小时：{data['load_demand'][:10]}")
-        
-        # 演示参数读取
-        if 'system_parameters' in data:
-            params = data['system_parameters']
-            print(f"\n系统参数：")
-            print(f"  最大弃风率: {params.max_curtailment_wind}")
-            print(f"  最大弃光率: {params.max_curtailment_solar}")
-            print(f"  最大上网电量比例: {params.max_grid_ratio}")
-            print(f"  储能效率: {params.storage_efficiency}")
-            print(f"  放电倍率: {params.discharge_rate}")
-            print(f"  充电倍率: {params.charge_rate}")
-            print(f"  最大储能容量: {params.max_storage_capacity}")
-            
-            # 验证参数
-            validation = validate_system_parameters(params)
-            if validation['valid']:
-                print("[OK] 参数验证通过")
-            else:
-                print("[ERROR] 参数验证失败:")
-                for error in validation['errors']:
-                    print(f"  - {error}")
-            
-            if validation['warnings']:
-                print("[WARNING] 参数警告:")
-                for warning in validation['warnings']:
-                    print(f"  - {warning}")
-        
-    except Exception as e:
-        print(f"读取失败：{str(e)}")
-    
-    print("\n=== 演示完成 ===")
-    print("模板文件已创建，您可以根据实际数据修改Excel文件。")
-    print("系统参数可以在Excel的'参数'工作表中直接修改。")
-
-
-if __name__ == "__main__":
-    main()

main.py

@@ -320,6 +320,15 @@ def export_results_to_excel(solar_output, wind_output, thermal_output, load_dema
             grid_feed_out.append(power)  # 上网电量
 
     # 创建主要数据DataFrame
+    # 计算弃电损失量（弃风+弃光）
+    curtailment_loss = [result['curtailed_wind'][i] + result['curtailed_solar'][i] for i in range(len(result['curtailed_wind']))]
+    # 计算累计弃电损失量
+    cumulative_curtailment = []
+    cumulative = 0
+    for loss in curtailment_loss:
+        cumulative += loss
+        cumulative_curtailment.append(cumulative)
+    
     data_df = pd.DataFrame({
         '小时': hours,
         '光伏出力(MW)': solar_output,
@@ -332,6 +341,8 @@ def export_results_to_excel(solar_output, wind_output, thermal_output, load_dema
         '储能状态(MWh)': result['storage_profile'],
         '弃风量(MW)': result['curtailed_wind'],
         '弃光量(MW)': result['curtailed_solar'],
+        '弃电损失量(MW)': curtailment_loss,
+        '累计弃电量(MWh)': cumulative_curtailment,
         '购电量(MW)': grid_purchase,
         '上网电量(MW)': grid_feed_out
     })
@@ -340,6 +351,15 @@ def export_results_to_excel(solar_output, wind_output, thermal_output, load_dema
     total_grid_feed_in = sum(result['grid_feed_in'])
     total_grid_purchase = sum(-x for x in result['grid_feed_in'] if x < 0)  # 购电量
     total_grid_feed_out = sum(x for x in result['grid_feed_in'] if x > 0)   # 上网电量
+    
+    # 计算弃电损失量
+    total_curtail_wind = sum(result['curtailed_wind'])
+    total_curtail_solar = sum(result['curtailed_solar'])
+    total_curtail_energy = total_curtail_wind + total_curtail_solar
+    
+    # 计算总潜在发电量
+    total_potential_generation = sum(solar_output) + sum(wind_output) + sum(thermal_output)
+    curtailment_loss_ratio = (total_curtail_energy / total_potential_generation * 100) if total_potential_generation > 0 else 0
 
     stats_df = pd.DataFrame({
         '指标': [
@@ -351,6 +371,10 @@ def export_results_to_excel(solar_output, wind_output, thermal_output, load_dema
             '弃风率',
             '弃光率',
             '上网电量比例',
+            '总弃风电量',
+            '总弃光电量',
+            '总弃电量',
+            '弃电损失比例',
             '能量平衡校验',
             '净购电量/净上网电量',
             '总购电量',
@@ -366,6 +390,10 @@ def export_results_to_excel(solar_output, wind_output, thermal_output, load_dema
             f"{result['total_curtailment_wind_ratio']:.3f}",
             f"{result['total_curtailment_solar_ratio']:.3f}",
             f"{result['total_grid_feed_in_ratio']:.3f}",
+            f"{total_curtail_wind:.2f} MWh",
+            f"{total_curtail_solar:.2f} MWh",
+            f"{total_curtail_energy:.2f} MWh",
+            f"{curtailment_loss_ratio:.2f}%",
             "通过" if result['energy_balance_check'] else "未通过",
             f"{-total_grid_feed_in:.2f} MWh" if total_grid_feed_in < 0 else f"{total_grid_feed_in:.2f} MWh",
             f"{total_grid_purchase:.2f} MWh",

pyproject.toml

@@ -9,4 +9,12 @@ dependencies = [
     "numpy>=1.19.0",
     "openpyxl>=3.1.5",
     "pandas>=2.3.3",
+    "pyinstaller>=6.17.0",
+    "scikit-learn>=1.8.0",
+    "seaborn>=0.13.2",
+]
+
+[dependency-groups]
+dev = [
+    "mypy>=1.19.1",
 ]

src/storage_optimization.py

@@ -10,7 +10,7 @@
 
 import numpy as np
 import math
-from typing import List, Dict, Tuple, Optional
+from typing import List, Dict, Tuple, Optional, Any
 from dataclasses import dataclass
 
 
@@ -351,7 +351,7 @@ def check_constraints(
     solar_output: List[float],
     wind_output: List[float],
     thermal_output: List[float],
-    balance_result: Dict[str, List[float]],
+    balance_result: Dict[str, Any],
     params: SystemParameters
 ) -> Dict[str, float]:
     """
@@ -373,9 +373,25 @@ def check_constraints(
     total_solar_potential = sum(solar_output)
     total_thermal = sum(thermal_output)
 
-    total_curtailed_wind = sum(balance_result['curtailed_wind'])
-    total_curtailed_solar = sum(balance_result['curtailed_solar'])
-    total_grid_feed_in = sum(balance_result['grid_feed_in'])
+    # 确保数据是列表类型
+    curtailed_wind = balance_result['curtailed_wind']
+    curtailed_solar = balance_result['curtailed_solar']
+    grid_feed_in = balance_result['grid_feed_in']
+    
+    if isinstance(curtailed_wind, (list, tuple)):
+        total_curtailed_wind = sum(curtailed_wind)
+    else:
+        total_curtailed_wind = float(curtailed_wind) if isinstance(curtailed_wind, (int, float)) else 0.0
+        
+    if isinstance(curtailed_solar, (list, tuple)):
+        total_curtailed_solar = sum(curtailed_solar)
+    else:
+        total_curtailed_solar = float(curtailed_solar) if isinstance(curtailed_solar, (int, float)) else 0.0
+        
+    if isinstance(grid_feed_in, (list, tuple)):
+        total_grid_feed_in = sum(grid_feed_in)
+    else:
+        total_grid_feed_in = float(grid_feed_in) if isinstance(grid_feed_in, (int, float)) else 0.0
 
     # 实际发电量（考虑弃风弃光）
     actual_wind_generation = total_wind_potential - total_curtailed_wind
@@ -545,7 +561,8 @@ def optimize_storage_capacity(
     
     base_curtailed = sum(base_result['curtailed_wind']) + sum(base_result['curtailed_solar'])
     best_curtailed = base_curtailed
-    best_result = {**base_result, **check_constraints(solar_output, wind_output, thermal_output, base_result, params)}
+    constraint_results = check_constraints(solar_output, wind_output, thermal_output, base_result, params)
+    best_result: Dict[str, Any] = {**base_result, **constraint_results}
     
     print(f"基准容量 {best_capacity:.2f} MWh 的弃电量: {best_curtailed:.2f} MWh")
     
@@ -609,7 +626,7 @@ def optimize_storage_capacity(
             if curtailed < best_curtailed:
                 best_curtailed = curtailed
                 best_capacity = capacity
-                best_result = {**result, **constraint_results}
+                best_result = {**result, **constraint_results}  # type: ignore
                 print(f"  发现更优容量: {best_capacity} MWh, 弃电量: {best_curtailed:.2f} MWh")
         
         # 每处理10个容量值输出一次进度
@@ -647,7 +664,7 @@ def optimize_storage_capacity(
         adjusted_constraint_results = check_constraints(solar_output, wind_output, thermal_output, adjusted_result, params)
         
         # 更新结果
-        best_result = {**adjusted_result, **adjusted_constraint_results}
+        best_result = {**adjusted_result, **adjusted_constraint_results}  # type: ignore
         best_capacity = rounded_capacity
         best_curtailed = sum(adjusted_result['curtailed_wind']) + sum(adjusted_result['curtailed_solar'])
         
@@ -658,11 +675,20 @@ def optimize_storage_capacity(
     # 添加能量平衡校验
     total_generation = sum(thermal_output) + sum(wind_output) + sum(solar_output)
     total_consumption = sum(load_demand)
-    total_curtailed = sum(best_result['curtailed_wind']) + sum(best_result['curtailed_solar'])
-    total_grid = sum(best_result['grid_feed_in'])
-    total_charge = sum(best_result['charge_profile'])
-    total_discharge = sum(best_result['discharge_profile'])
-    storage_net_change = best_result['storage_profile'][-1] - best_result['storage_profile'][0]
+    
+    # 确保best_result中的数据是列表类型
+    curtailed_wind_list = best_result['curtailed_wind'] if isinstance(best_result['curtailed_wind'], list) else list(best_result['curtailed_wind'])
+    curtailed_solar_list = best_result['curtailed_solar'] if isinstance(best_result['curtailed_solar'], list) else list(best_result['curtailed_solar'])
+    grid_feed_in_list = best_result['grid_feed_in'] if isinstance(best_result['grid_feed_in'], list) else list(best_result['grid_feed_in'])
+    charge_profile_list = best_result['charge_profile'] if isinstance(best_result['charge_profile'], list) else list(best_result['charge_profile'])
+    discharge_profile_list = best_result['discharge_profile'] if isinstance(best_result['discharge_profile'], list) else list(best_result['discharge_profile'])
+    storage_profile_list = best_result['storage_profile'] if isinstance(best_result['storage_profile'], list) else list(best_result['storage_profile'])
+    
+    total_curtailed = sum(curtailed_wind_list) + sum(curtailed_solar_list)
+    total_grid = sum(grid_feed_in_list)
+    total_charge = sum(charge_profile_list)
+    total_discharge = sum(discharge_profile_list)
+    storage_net_change = storage_profile_list[-1] - storage_profile_list[0]
 
     # 能量平衡校验：发电量 + 放电量/效率 = 负荷 + 充电量*效率 + 弃风弃光 + 上网电量
     # 考虑储能充放电效率的能量平衡
@@ -695,14 +721,14 @@ def optimize_storage_capacity(
         print(f"  SOC差值: {soc_initial_final_diff:.4f} MWh")
 
     # 最终结果
-    result = {
+    result: Dict[str, Any] = {
         'required_storage_capacity': best_capacity,
-        'storage_profile': best_result['storage_profile'],
-        'charge_profile': best_result['charge_profile'],
-        'discharge_profile': best_result['discharge_profile'],
-        'curtailed_wind': best_result['curtailed_wind'],
-        'curtailed_solar': best_result['curtailed_solar'],
-        'grid_feed_in': best_result['grid_feed_in'],
+        'storage_profile': storage_profile_list,
+        'charge_profile': charge_profile_list,
+        'discharge_profile': discharge_profile_list,
+        'curtailed_wind': curtailed_wind_list,
+        'curtailed_solar': curtailed_solar_list,
+        'grid_feed_in': grid_feed_in_list,
         'total_curtailment_wind_ratio': best_result['total_curtailment_wind_ratio'],
         'total_curtailment_solar_ratio': best_result['total_curtailment_solar_ratio'],
         'total_grid_feed_in_ratio': best_result['total_grid_feed_in_ratio'],

src/test_hello.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""测试环境是否可用"""
+
+def hello():
+    return "环境正常，我可以写代码！"
+
+if __name__ == "__main__":
+    print(hello())

tests/test_curtail_priority.py

@@ -0,0 +1,92 @@
+"""
+测试弃风弃光优先级
+
+验证系统在需要弃风弃光时优先弃光的逻辑
+"""
+
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+from storage_optimization import optimize_storage_capacity, SystemParameters
+
+def test_curtail_priority():
+    """测试弃风弃光优先级"""
+    print("=== 测试弃风弃光优先级 ===")
+    
+    # 创建测试数据：有大量盈余电力的情况，光伏和风电都有出力
+    solar_output = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 20.0, 25.0, 30.0, 30.0, 25.0, 20.0, 15.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]  # 24小时
+    wind_output = [15.0, 15.0, 15.0, 15.0, 15.0, 15.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 10.0, 15.0, 15.0, 15.0, 15.0, 15.0, 15.0, 15.0, 15.0, 15.0, 15.0, 15.0]  # 24小时
+    thermal_output = [10.0] * 24  # 稳定的火电
+    load_demand = [20.0] * 24  # 稳定的负荷
+    
+    print(f"光伏总出力: {sum(solar_output):.2f} MW")
+    print(f"风电总出力: {sum(wind_output):.2f} MW")
+    print(f"火电总出力: {sum(thermal_output):.2f} MW")
+    print(f"总负荷: {sum(load_demand):.2f} MW")
+    print(f"理论盈余: {sum(solar_output) + sum(wind_output) + sum(thermal_output) - sum(load_demand):.2f} MW")
+    
+    # 设置参数，限制储能和上网电量，强制弃风弃光
+    params = SystemParameters(
+        max_curtailment_wind=0.1,  # 允许10%弃风
+        max_curtailment_solar=0.3,  # 允许30%弃光（更高）
+        max_grid_ratio=0.05,      # 5%上网比例（更低）
+        storage_efficiency=0.9,
+        discharge_rate=1.0,
+        charge_rate=1.0,
+        max_storage_capacity=30.0,  # 更小的储能容量
+        available_thermal_energy=240.0,  # 不计入上网电量计算
+        available_solar_energy=200.0,    # 基于实际光伏出力
+        available_wind_energy=300.0      # 基于实际风电出力
+    )
+    
+    print(f"\n系统参数:")
+    print(f"  最大弃风率: {params.max_curtailment_wind}")
+    print(f"  最大弃光率: {params.max_curtailment_solar}")
+    print(f"  最大上网比例: {params.max_grid_ratio}")
+    print(f"  可用光伏发电量: {params.available_solar_energy} MWh")
+    print(f"  可用风电发电量: {params.available_wind_energy} MWh")
+    
+    # 计算最大允许弃风弃光量
+    max_curtailed_wind_total = sum(wind_output) * params.max_curtailment_wind
+    max_curtailed_solar_total = sum(solar_output) * params.max_curtailment_solar
+    
+    print(f"\n理论最大弃风量: {max_curtailed_wind_total:.2f} MW")
+    print(f"理论最大弃光量: {max_curtailed_solar_total:.2f} MW")
+    
+    # 运行优化
+    result = optimize_storage_capacity(solar_output, wind_output, thermal_output, load_demand, params)
+    
+    # 分析结果
+    total_curtailed_wind = sum(result['curtailed_wind'])
+    total_curtailed_solar = sum(result['curtailed_solar'])
+    total_grid_feed_in = sum(x for x in result['grid_feed_in'] if x > 0)
+    
+    print(f"\n实际结果:")
+    print(f"  实际弃风量: {total_curtailed_wind:.2f} MW")
+    print(f"  实际弃光量: {total_curtailed_solar:.2f} MW")
+    print(f"  实际上网电量: {total_grid_feed_in:.2f} MWh")
+    print(f"  实际弃风率: {total_curtailed_wind/sum(wind_output):.3f}")
+    print(f"  实际弃光率: {total_curtailed_solar/sum(solar_output):.3f}")
+    
+    # 检查弃光是否优先于弃风
+    if total_curtailed_solar > 0 or total_curtailed_wind > 0:
+        total_curtailment = total_curtailed_solar + total_curtailed_wind
+        solar_ratio = total_curtailed_solar / total_curtailment if total_curtailment > 0 else 0
+        wind_ratio = total_curtailed_wind / total_curtailment if total_curtailment > 0 else 0
+        
+        print(f"\n弃风弃光比例分析:")
+        print(f"  弃光占比: {solar_ratio:.3f}")
+        print(f"  弃风占比: {wind_ratio:.3f}")
+        
+        # 验证优先弃光逻辑
+        # 在有弃风弃光的情况下，应该先弃光直到达到弃光率限制
+        if solar_ratio > 0.5:  # 如果弃光占比超过50%，说明优先弃光
+            print("  [OK] 验证通过：系统优先弃光")
+        else:
+            print("  [WARNING] 可能未完全优先弃光")
+    
+    print("\n=== 测试完成 ===")
+
+if __name__ == "__main__":
+    test_curtail_priority()

tests/test_curtailment_logic.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""
+测试弃风弃光逻辑的脚本
+验证"先弃光，当达到最大弃光比例后，再弃风，弃风不限"的逻辑是否正确实现
+"""
+
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), 'src'))
+
+from storage_optimization import calculate_energy_balance, SystemParameters
+
+def test_curtailment_logic():
+    """测试弃风弃光逻辑"""
+    
+    # 创建测试数据
+    # 24小时的简单场景：前12小时负荷低，后12小时负荷高
+    solar_output = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+    wind_output = [5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0]  # 恒定的风电出力
+    thermal_output = [2.0] * 24  # 恒定的火电出力
+    load_demand = [1.0] * 12 + [15.0] * 12  # 前12小时低负荷，后12小时高负荷
+    
+    # 设置系统参数
+    params = SystemParameters(
+        max_curtailment_wind=0.1,   # 弃风率限制10%（但实际上弃风不受限制）
+        max_curtailment_solar=0.2,  # 弃光率限制20%
+        max_grid_ratio=0.1,         # 上网电量比例限制10%
+        storage_efficiency=0.9,
+        discharge_rate=1.0,
+        charge_rate=1.0
+    )
+    
+    # 计算能量平衡
+    storage_capacity = 10.0  # 10MWh储能容量
+    result = calculate_energy_balance(
+        solar_output, wind_output, thermal_output, load_demand, params, storage_capacity
+    )
+    
+    # 分析结果
+    total_solar_potential = sum(solar_output)
+    total_wind_potential = sum(wind_output)
+    total_curtailed_solar = sum(result['curtailed_solar'])
+    total_curtailed_wind = sum(result['curtailed_wind'])
+    
+    actual_solar_curtailment_ratio = total_curtailed_solar / total_solar_potential if total_solar_potential > 0 else 0
+    actual_wind_curtailment_ratio = total_curtailed_wind / total_wind_potential if total_wind_potential > 0 else 0
+    
+    print("弃风弃光逻辑测试结果:")
+    print(f"总光伏出力: {total_solar_potential:.2f} MWh")
+    print(f"总风电出力: {total_wind_potential:.2f} MWh")
+    print(f"弃光量: {total_curtailed_solar:.2f} MWh ({actual_solar_curtailment_ratio:.2%})")
+    print(f"弃风量: {total_curtailed_wind:.2f} MWh ({actual_wind_curtailment_ratio:.2%})")
+    print(f"弃光率限制: {params.max_curtailment_solar:.2%}")
+    print(f"弃风率限制: {params.max_curtailment_wind:.2%} (实际不受限制)")
+    
+    # 验证逻辑
+    print("\n验证结果:")
+    solar_constraint_ok = actual_solar_curtailment_ratio <= params.max_curtailment_solar + 0.01  # 允许1%误差
+    print(f"弃光率是否在限制范围内: {'通过' if solar_constraint_ok else '未通过'}")
+    
+    # 弃风应该不受限制，所以不需要检查约束
+    print("弃风不受限制: 通过")
+    
+    # 检查弃风弃光的时间分布
+    print("\n弃风弃光时间分布:")
+    for hour in range(24):
+        if result['curtailed_solar'][hour] > 0 or result['curtailed_wind'][hour] > 0:
+            print(f"  小时 {hour:2d}: 弃光={result['curtailed_solar'][hour]:.2f}MW, 弃风={result['curtailed_wind'][hour]:.2f}MW")
+    
+    return solar_constraint_ok
+
+def test_solar_curtailment_priority():
+    """测试弃光优先逻辑"""
+    
+    # 创建极端测试场景：大量盈余电力
+    solar_output = [10.0] * 24  # 高光伏出力
+    wind_output = [10.0] * 24   # 高风电出力
+    thermal_output = [0.0] * 24  # 无火电
+    load_demand = [1.0] * 24    # 极低负荷
+    
+    # 设置系统参数
+    params = SystemParameters(
+        max_curtailment_wind=0.1,   # 弃风率限制10%（但实际上弃风不受限制）
+        max_curtailment_solar=0.1,  # 弃光率限制10%
+        max_grid_ratio=0.0,         # 不允许上网电量
+        storage_efficiency=0.9,
+        discharge_rate=1.0,
+        charge_rate=1.0
+    )
+    
+    # 计算能量平衡
+    storage_capacity = 5.0  # 5MWh储能容量
+    result = calculate_energy_balance(
+        solar_output, wind_output, thermal_output, load_demand, params, storage_capacity
+    )
+    
+    # 分析结果
+    total_solar_potential = sum(solar_output)
+    total_wind_potential = sum(wind_output)
+    total_curtailed_solar = sum(result['curtailed_solar'])
+    total_curtailed_wind = sum(result['curtailed_wind'])
+    
+    actual_solar_curtailment_ratio = total_curtailed_solar / total_solar_potential if total_solar_potential > 0 else 0
+    actual_wind_curtailment_ratio = total_curtailed_wind / total_wind_potential if total_wind_potential > 0 else 0
+    
+    print("\n弃光优先逻辑测试结果:")
+    print(f"总光伏出力: {total_solar_potential:.2f} MWh")
+    print(f"总风电出力: {total_wind_potential:.2f} MWh")
+    print(f"弃光量: {total_curtailed_solar:.2f} MWh ({actual_solar_curtailment_ratio:.2%})")
+    print(f"弃风量: {total_curtailed_wind:.2f} MWh ({actual_wind_curtailment_ratio:.2%})")
+    print(f"弃光率限制: {params.max_curtailment_solar:.2%}")
+    
+    # 验证弃光是否优先
+    solar_at_limit = abs(actual_solar_curtailment_ratio - params.max_curtailment_solar) < 0.01
+    print(f"\n弃光是否达到限制: {'是' if solar_at_limit else '否'}")
+    
+    # 验证弃风是否在弃光达到限制后才发生
+    wind_curtailment_exists = total_curtailed_wind > 0
+    print(f"是否存在弃风: {'是' if wind_curtailment_exists else '否'}")
+    
+    if solar_at_limit and wind_curtailment_exists:
+        print("通过 弃光优先逻辑正确：先弃光达到限制，然后弃风")
+        return True
+    else:
+        print("未通过 弃光优先逻辑可能存在问题")
+        return False
+
+if __name__ == "__main__":
+    print("开始测试弃风弃光逻辑...")
+    
+    test1_result = test_curtailment_logic()
+    test2_result = test_solar_curtailment_priority()
+    
+    if test1_result and test2_result:
+        print("\n通过 所有测试通过，弃风弃光逻辑实现正确")
+    else:
+        print("\n未通过 部分测试失败，需要检查逻辑实现")

tests/test_excel_data.py

@@ -0,0 +1,305 @@
+"""
+测试程序 - 验证Excel数据输入和储能容量优化
+
+该程序使用data_template_24.xlsx和data_template_8760.xlsx作为输入，
+测试储能容量优化系统的功能和错误处理。
+
+作者: iFlow CLI
+创建日期: 2025-12-25
+"""
+
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from typing import Dict, Any
+from excel_reader import read_excel_data, analyze_excel_data, read_system_parameters, validate_system_parameters
+from storage_optimization import optimize_storage_capacity, SystemParameters
+from advanced_visualization import create_comprehensive_plot, create_time_series_plot
+
+
+def test_excel_file(file_path: str, test_name: str) -> Dict[str, Any]:
+    """
+    测试单个Excel文件
+    
+    Args:
+        file_path: Excel文件路径
+        test_name: 测试名称
+        
+    Returns:
+        测试结果字典
+    """
+    print(f"\n{'='*60}")
+    print(f"测试：{test_name}")
+    print(f"文件：{file_path}")
+    print(f"{'='*60}")
+    
+    result = {
+        'test_name': test_name,
+        'file_path': file_path,
+        'success': False,
+        'error': None,
+        'data_stats': {},
+        'optimization_result': {}
+    }
+    
+    try:
+        # 1. 检查文件是否存在
+        if not os.path.exists(file_path):
+            raise FileNotFoundError(f"文件不存在：{file_path}")
+        print("[OK] 文件存在检查通过")
+        
+        # 2. 读取Excel数据
+        print("正在读取Excel数据...")
+        data = read_excel_data(file_path, include_parameters=True)
+        print(f"[OK] 数据读取成功，类型：{data['data_type']}")
+        print(f"  原始数据长度：{data['original_length']}")
+        print(f"  处理后数据长度：{len(data['solar_output'])}")
+        
+        # 2.1 测试参数读取
+        if 'system_parameters' in data:
+            params = data['system_parameters']
+            print(f"[OK] 系统参数读取成功")
+            print(f"  最大弃风率: {params.max_curtailment_wind}")
+            print(f"  最大弃光率: {params.max_curtailment_solar}")
+            print(f"  最大上网电量比例: {params.max_grid_ratio}")
+            print(f"  储能效率: {params.storage_efficiency}")
+            print(f"  放电倍率: {params.discharge_rate}")
+            print(f"  充电倍率: {params.charge_rate}")
+            print(f"  最大储能容量: {params.max_storage_capacity}")
+            
+            # 验证参数
+            validation = validate_system_parameters(params)
+            if validation['valid']:
+                print("[OK] 系统参数验证通过")
+            else:
+                print("[ERROR] 系统参数验证失败:")
+                for error in validation['errors']:
+                    print(f"  - {error}")
+                raise ValueError(f"系统参数验证失败: {validation['errors']}")
+            
+            if validation['warnings']:
+                print("[WARNING] 系统参数警告:")
+                for warning in validation['warnings']:
+                    print(f"  - {warning}")
+        else:
+            print("[WARNING] 未找到系统参数，使用默认参数")
+            params = SystemParameters()
+        
+        # 3. 分析数据统计信息
+        print("正在分析数据统计信息...")
+        stats = analyze_excel_data(file_path)
+        result['data_stats'] = stats
+        print("[OK] 数据统计分析完成")
+        
+        # 4. 验证数据完整性
+        print("正在验证数据完整性...")
+        solar_output = data['solar_output']
+        wind_output = data['wind_output']
+        thermal_output = data['thermal_output']
+        load_demand = data['load_demand']
+        
+        # 检查数据长度一致性
+        if not (len(solar_output) == len(wind_output) == len(thermal_output) == len(load_demand)):
+            raise ValueError("数据长度不一致")
+        print("[OK] 数据长度一致性检查通过")
+        
+        # 检查非负值
+        for name, values in [
+            ("光伏出力", solar_output), ("风电出力", wind_output),
+            ("火电出力", thermal_output), ("负荷需求", load_demand)
+        ]:
+            if any(v < 0 for v in values):
+                raise ValueError(f"{name}包含负值")
+        print("[OK] 非负值检查通过")
+        
+        # 5. 储能容量优化测试
+        print("正在进行储能容量优化计算...")
+        
+        # 使用Excel中的参数和不同的测试配置
+        excel_params = params  # 从Excel中读取的参数
+        test_configs = [
+            {
+                'name': 'Excel配置',
+                'params': excel_params
+            },
+            {
+                'name': '基础配置',
+                'params': SystemParameters(
+                    max_curtailment_wind=0.1,
+                    max_curtailment_solar=0.1,
+                    max_grid_ratio=0.2,
+                    storage_efficiency=0.9,
+                    discharge_rate=1.0,
+                    charge_rate=1.0
+                )
+            },
+            {
+                'name': '高弃风弃光配置',
+                'params': SystemParameters(
+                    max_curtailment_wind=0.2,
+                    max_curtailment_solar=0.2,
+                    max_grid_ratio=0.3,
+                    storage_efficiency=0.85,
+                    discharge_rate=1.5,
+                    charge_rate=1.5
+                )
+            },
+            {
+                'name': '低储能效率配置',
+                'params': SystemParameters(
+                    max_curtailment_wind=0.05,
+                    max_curtailment_solar=0.05,
+                    max_grid_ratio=0.1,
+                    storage_efficiency=0.75,
+                    discharge_rate=0.8,
+                    charge_rate=0.8
+                )
+            }
+        ]
+        
+        optimization_results = []
+        
+        for config in test_configs:
+            print(f"  测试配置：{config['name']}")
+            opt_result = optimize_storage_capacity(
+                solar_output, wind_output, thermal_output, load_demand, config['params']
+            )
+            
+            print(f"    所需储能容量：{opt_result['required_storage_capacity']:.2f} MWh")
+            print(f"    弃风率：{opt_result['total_curtailment_wind_ratio']:.3f}")
+            print(f"    弃光率：{opt_result['total_curtailment_solar_ratio']:.3f}")
+            print(f"    上网电量比例：{opt_result['total_grid_feed_in_ratio']:.3f}")
+            print(f"    能量平衡校验：{'通过' if opt_result['energy_balance_check'] else '未通过'}")
+            
+            optimization_results.append({
+                'config_name': config['name'],
+                'result': opt_result
+            })
+        
+        result['optimization_result'] = optimization_results
+        print("[OK] 储能容量优化计算完成")
+        
+        # 6. 可视化测试（仅对24小时数据进行，避免8760小时数据生成过大图像）
+        if data['data_type'] == '24':
+            print("正在生成可视化图表...")
+            try:
+                # 使用基础配置的结果生成图表
+                base_result = optimization_results[0]['result']
+                base_params = test_configs[0]['params']
+                
+                # 生成基础图表（截取前24小时数据）
+                solar_24 = solar_output[:24] if len(solar_output) > 24 else solar_output
+                wind_24 = wind_output[:24] if len(wind_output) > 24 else wind_output
+                thermal_24 = thermal_output[:24] if len(thermal_output) > 24 else thermal_output
+                load_24 = load_demand[:24] if len(load_demand) > 24 else load_demand
+                
+                # 截取结果的24小时数据
+                result_24 = {
+                    'required_storage_capacity': base_result['required_storage_capacity'],
+                    'charge_profile': base_result['charge_profile'][:24] if len(base_result['charge_profile']) > 24 else base_result['charge_profile'],
+                    'discharge_profile': base_result['discharge_profile'][:24] if len(base_result['discharge_profile']) > 24 else base_result['discharge_profile'],
+                    'curtailed_wind': base_result['curtailed_wind'][:24] if len(base_result['curtailed_wind']) > 24 else base_result['curtailed_wind'],
+                    'curtailed_solar': base_result['curtailed_solar'][:24] if len(base_result['curtailed_solar']) > 24 else base_result['curtailed_solar'],
+                    'grid_feed_in': base_result['grid_feed_in'][:24] if len(base_result['grid_feed_in']) > 24 else base_result['grid_feed_in'],
+                    'storage_profile': base_result['storage_profile'][:24] if len(base_result['storage_profile']) > 24 else base_result['storage_profile'],
+                    'total_curtailment_wind_ratio': base_result['total_curtailment_wind_ratio'],
+                    'total_curtailment_solar_ratio': base_result['total_curtailment_solar_ratio'],
+                    'total_grid_feed_in_ratio': base_result['total_grid_feed_in_ratio'],
+                    'energy_balance_check': base_result['energy_balance_check']
+                }
+                
+                create_comprehensive_plot(solar_24, wind_24, thermal_24, load_24, result_24, base_params)
+                create_time_series_plot(solar_24, wind_24, thermal_24, load_24, result_24)
+                print("[OK] 可视化图表生成完成")
+                
+            except Exception as e:
+                print(f"⚠ 可视化图表生成失败：{str(e)}")
+                print("  这不是严重错误，可能是字体或显示问题")
+        
+        # 标记测试成功
+        result['success'] = True
+        print(f"\n[OK] 测试 '{test_name}' 成功完成！")
+        
+    except Exception as e:
+        result['error'] = str(e)
+        result['traceback'] = traceback.format_exc()
+        print(f"\n[ERROR] 测试 '{test_name}' 失败：{str(e)}")
+        print("详细错误信息：")
+        traceback.print_exc()
+    
+    return result
+
+
+def run_comprehensive_tests():
+    """运行综合测试"""
+    print("开始运行Excel数据输入综合测试...")
+    print(f"当前工作目录：{os.getcwd()}")
+    
+    # 测试文件列表
+    test_files = [
+        {
+            'path': 'data_template_24.xlsx',
+            'name': '24小时数据模板测试'
+        },
+        {
+            'path': 'data_template_8760.xlsx',
+            'name': '8760小时数据模板测试'
+        }
+    ]
+    
+    # 运行所有测试
+    results = []
+    for test_file in test_files:
+        result = test_excel_file(test_file['path'], test_file['name'])
+        results.append(result)
+    
+    # 生成测试报告
+    print(f"\n{'='*80}")
+    print("测试报告总结")
+    print(f"{'='*80}")
+    
+    total_tests = len(results)
+    successful_tests = sum(1 for r in results if r['success'])
+    failed_tests = total_tests - successful_tests
+    
+    print(f"总测试数：{total_tests}")
+    print(f"成功测试：{successful_tests}")
+    print(f"失败测试：{failed_tests}")
+    print(f"成功率：{successful_tests/total_tests*100:.1f}%")
+    
+    print("\n详细结果：")
+    for i, result in enumerate(results, 1):
+        status = "[OK] 成功" if result['success'] else "[ERROR] 失败"
+        print(f"{i}. {result['test_name']}: {status}")
+        if not result['success']:
+            print(f"   错误：{result['error']}")
+    
+    # 如果有失败的测试，返回非零退出码
+    if failed_tests > 0:
+        print(f"\n有{failed_tests}个测试失败，请检查上述错误信息")
+        return False
+    else:
+        print("\n所有测试通过！系统运行正常。")
+        return True
+
+
+def main():
+    """主函数"""
+    try:
+        success = run_comprehensive_tests()
+        sys.exit(0 if success else 1)
+    except KeyboardInterrupt:
+        print("\n测试被用户中断")
+        sys.exit(1)
+    except Exception as e:
+        print(f"\n测试过程中发生未预期的错误：{str(e)}")
+        traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

tests/test_excel_parameters.py

@@ -0,0 +1,184 @@
+"""
+测试Excel参数设置功能
+
+该程序演示如何修改Excel参数工作表中的参数，并验证参数是否被正确读取。
+
+作者: iFlow CLI
+创建日期: 2025-12-25
+"""
+
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+import pandas as pd
+from excel_reader import read_excel_data, validate_system_parameters
+from storage_optimization import optimize_storage_capacity
+
+
+def test_parameter_modification():
+    """测试参数修改功能"""
+    print("=== 测试Excel参数设置功能 ===\n")
+    
+    # 1. 读取原始参数
+    print("1. 读取原始Excel参数...")
+    original_data = read_excel_data('data_template_24.xlsx', include_parameters=True)
+    original_params = original_data['system_parameters']
+    
+    print("原始参数:")
+    print(f"  最大弃风率: {original_params.max_curtailment_wind}")
+    print(f"  最大弃光率: {original_params.max_curtailment_solar}")
+    print(f"  最大上网电量比例: {original_params.max_grid_ratio}")
+    print(f"  储能效率: {original_params.storage_efficiency}")
+    print(f"  放电倍率: {original_params.discharge_rate}")
+    print(f"  充电倍率: {original_params.charge_rate}")
+    print(f"  最大储能容量: {original_params.max_storage_capacity}")
+    
+    # 2. 使用原始参数进行优化
+    print("\n2. 使用原始参数进行储能容量优化...")
+    original_result = optimize_storage_capacity(
+        original_data['solar_output'],
+        original_data['wind_output'],
+        original_data['thermal_output'],
+        original_data['load_demand'],
+        original_params
+    )
+    
+    print(f"原始参数优化结果:")
+    print(f"  所需储能容量: {original_result['required_storage_capacity']:.2f} MWh")
+    print(f"  弃风率: {original_result['total_curtailment_wind_ratio']:.3f}")
+    print(f"  弃光率: {original_result['total_curtailment_solar_ratio']:.3f}")
+    print(f"  上网电量比例: {original_result['total_grid_feed_in_ratio']:.3f}")
+    
+    # 3. 修改Excel参数
+    print("\n3. 修改Excel参数...")
+    
+    # 创建测试用的参数DataFrame
+    new_params_df = pd.DataFrame({
+        '参数名称': [
+            '最大弃风率',
+            '最大弃光率', 
+            '最大上网电量比例',
+            '储能效率',
+            '放电倍率',
+            '充电倍率',
+            '最大储能容量'
+        ],
+        '参数值': [
+            0.15,   # 增加弃风率
+            0.12,   # 增加弃光率
+            0.25,   # 增加上网电量比例
+            0.85,   # 降低储能效率
+            1.2,    # 增加放电倍率
+            1.2,    # 增加充电倍率
+            1000.0  # 设置储能容量上限
+        ],
+        '参数说明': [
+            '允许的最大弃风率（0.0-1.0）',
+            '允许的最大弃光率（0.0-1.0）',
+            '允许的最大上网电量比例（0.0-∞，只限制上网电量）',
+            '储能充放电效率（0.0-1.0）',
+            '储能放电倍率（C-rate，>0）',
+            '储能充电倍率（C-rate，>0）',
+            '储能容量上限（MWh，空表示无限制）'
+        ],
+        '取值范围': [
+            '0.0-1.0',
+            '0.0-1.0', 
+            '≥0.0',
+            '0.0-1.0',
+            '>0',
+            '>0',
+            '>0或空'
+        ],
+        '默认值': [
+            '0.1',
+            '0.1',
+            '0.2', 
+            '0.9',
+            '1.0',
+            '1.0',
+            '无限制'
+        ]
+    })
+    
+    # 读取原始Excel文件
+    with pd.ExcelFile('data_template_24.xlsx') as xls:
+        data_df = pd.read_excel(xls, sheet_name='数据')
+        description_df = pd.read_excel(xls, sheet_name='说明')
+    
+    # 保存修改后的Excel文件
+    with pd.ExcelWriter('data_template_24_modified.xlsx', engine='openpyxl') as writer:
+        data_df.to_excel(writer, sheet_name='数据', index=False)
+        new_params_df.to_excel(writer, sheet_name='参数', index=False)
+        description_df.to_excel(writer, sheet_name='说明', index=False)
+    
+    print("已创建修改后的Excel文件: data_template_24_modified.xlsx")
+    print("修改后的参数:")
+    print(f"  最大弃风率: 0.15 (原: {original_params.max_curtailment_wind})")
+    print(f"  最大弃光率: 0.12 (原: {original_params.max_curtailment_solar})")
+    print(f"  最大上网电量比例: 0.25 (原: {original_params.max_grid_ratio})")
+    print(f"  储能效率: 0.85 (原: {original_params.storage_efficiency})")
+    print(f"  放电倍率: 1.2 (原: {original_params.discharge_rate})")
+    print(f"  充电倍率: 1.2 (原: {original_params.charge_rate})")
+    print(f"  最大储能容量: 1000.0 (原: {original_params.max_storage_capacity})")
+    
+    # 4. 读取修改后的参数
+    print("\n4. 读取修改后的参数...")
+    modified_data = read_excel_data('data_template_24_modified.xlsx', include_parameters=True)
+    modified_params = modified_data['system_parameters']
+    
+    print("修改后的参数读取结果:")
+    print(f"  最大弃风率: {modified_params.max_curtailment_wind}")
+    print(f"  最大弃光率: {modified_params.max_curtailment_solar}")
+    print(f"  最大上网电量比例: {modified_params.max_grid_ratio}")
+    print(f"  储能效率: {modified_params.storage_efficiency}")
+    print(f"  放电倍率: {modified_params.discharge_rate}")
+    print(f"  充电倍率: {modified_params.charge_rate}")
+    print(f"  最大储能容量: {modified_params.max_storage_capacity}")
+    
+    # 5. 验证修改后的参数
+    validation = validate_system_parameters(modified_params)
+    if validation['valid']:
+        print("[OK] 修改后的参数验证通过")
+    else:
+        print("[ERROR] 修改后的参数验证失败:")
+        for error in validation['errors']:
+            print(f"  - {error}")
+    
+    if validation['warnings']:
+        print("[WARNING] 修改后的参数警告:")
+        for warning in validation['warnings']:
+            print(f"  - {warning}")
+    
+    # 6. 使用修改后的参数进行优化
+    print("\n5. 使用修改后的参数进行储能容量优化...")
+    modified_result = optimize_storage_capacity(
+        modified_data['solar_output'],
+        modified_data['wind_output'],
+        modified_data['thermal_output'],
+        modified_data['load_demand'],
+        modified_params
+    )
+    
+    print(f"修改后参数优化结果:")
+    print(f"  所需储能容量: {modified_result['required_storage_capacity']:.2f} MWh")
+    print(f"  弃风率: {modified_result['total_curtailment_wind_ratio']:.3f}")
+    print(f"  弃光率: {modified_result['total_curtailment_solar_ratio']:.3f}")
+    print(f"  上网电量比例: {modified_result['total_grid_feed_in_ratio']:.3f}")
+    print(f"  容量限制是否达到: {modified_result['capacity_limit_reached']}")
+    
+    # 7. 对比结果
+    print("\n6. 结果对比:")
+    print(f"储能容量变化: {original_result['required_storage_capacity']:.2f} -> {modified_result['required_storage_capacity']:.2f} MWh")
+    print(f"弃风率变化: {original_result['total_curtailment_wind_ratio']:.3f} -> {modified_result['total_curtailment_wind_ratio']:.3f}")
+    print(f"弃光率变化: {original_result['total_curtailment_solar_ratio']:.3f} -> {modified_result['total_curtailment_solar_ratio']:.3f}")
+    print(f"上网电量比例变化: {original_result['total_grid_feed_in_ratio']:.3f} -> {modified_result['total_grid_feed_in_ratio']:.3f}")
+    
+    print("\n=== 测试完成 ===")
+    print("Excel参数设置功能测试成功！")
+    print("用户可以通过修改Excel文件中的'参数'工作表来调整系统参数。")
+
+
+if __name__ == "__main__":
+    test_parameter_modification()

tests/test_extreme_single_renewable.py

@@ -0,0 +1,103 @@
+"""
+创建一个明确的测试算例，验证只有风电时弃电量不受限制
+这个测试会创建一个风电远超负荷的场景，来验证弃风是否真的不受限制
+"""
+
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+import pandas as pd
+import numpy as np
+
+def create_extreme_wind_test():
+    """创建极端风电测试场景：风电远超负荷"""
+    
+    # 创建24小时数据
+    hours = list(range(1, 25))
+    
+    # 风电出力：设计为远超负荷，强制产生弃风
+    wind_output = [200, 180, 160, 140, 120, 100, 80, 60, 50, 40, 30, 25, 20, 15, 10, 8, 6, 5, 4, 3, 2, 1, 0.5, 0.2]
+    
+    # 光伏出力：全部为0
+    solar_output = [0.0] * 24
+    
+    # 火电出力：全部为0
+    thermal_output = [0.0] * 24
+    
+    # 负荷需求：较低，确保风电远超负荷
+    load_demand = [20.0] * 24  # 只有20MW负荷，风电最高200MW
+    
+    # 创建DataFrame
+    data = {
+        '小时': hours,
+        '光伏出力(MW)': solar_output,
+        '风电出力(MW)': wind_output,
+        '火电出力(MW)': thermal_output,
+        '负荷需求(MW)': load_demand
+    }
+    df = pd.DataFrame(data)
+    
+    # 保存为Excel文件
+    excel_file = 'extreme_wind_test.xlsx'
+    df.to_excel(excel_file, index=False, sheet_name='data')
+    print(f"已创建极端风电测试文件: {excel_file}")
+    print(f"风电总出力: {sum(wind_output):.1f} MWh")
+    print(f"负荷总需求: {sum(load_demand):.1f} MWh")
+    print(f"风电超额: {sum(wind_output) - sum(load_demand):.1f} MWh (应该被弃掉)")
+    
+    return excel_file
+
+def create_extreme_solar_test():
+    """创建极端光伏测试场景：光伏远超负荷"""
+    
+    # 创建24小时数据
+    hours = list(range(1, 25))
+    
+    # 风电出力：全部为0
+    wind_output = [0.0] * 24
+    
+    # 光伏出力：设计为远超负荷，强制产生弃光
+    solar_output = [0, 0, 0, 0, 0, 0, 50, 100, 150, 200, 180, 150, 120, 100, 80, 60, 40, 20, 10, 5, 2, 1, 0.5, 0.2]
+    
+    # 火电出力：全部为0
+    thermal_output = [0.0] * 24
+    
+    # 负荷需求：较低，确保光伏远超负荷
+    load_demand = [30.0] * 24  # 只有30MW负荷，光伏最高200MW
+    
+    # 创建DataFrame
+    data = {
+        '小时': hours,
+        '光伏出力(MW)': solar_output,
+        '风电出力(MW)': wind_output,
+        '火电出力(MW)': thermal_output,
+        '负荷需求(MW)': load_demand
+    }
+    df = pd.DataFrame(data)
+    
+    # 保存为Excel文件
+    excel_file = 'extreme_solar_test.xlsx'
+    df.to_excel(excel_file, index=False, sheet_name='data')
+    print(f"已创建极端光伏测试文件: {excel_file}")
+    print(f"光伏总出力: {sum(solar_output):.1f} MWh")
+    print(f"负荷总需求: {sum(load_demand):.1f} MWh")
+    print(f"光伏超额: {sum(solar_output) - sum(load_demand):.1f} MWh (应该被弃掉)")
+    
+    return excel_file
+
+if __name__ == "__main__":
+    print("创建极端单一可再生能源测试文件...")
+    wind_file = create_extreme_wind_test()
+    print()
+    solar_file = create_extreme_solar_test()
+    print()
+    print(f"测试文件已创建完成:")
+    print(f"1. {wind_file} - 极端单一风电场景 (风电远超负荷)")
+    print(f"2. {solar_file} - 极端单一光伏场景 (光伏远超负荷)")
+    print(f"\n预期结果:")
+    print(f"- 如果弃电量不受限制，应该能看到大量的弃风/弃光")
+    print(f"- 如果弃电量受限制，系统会通过其他方式处理超额电力")
+    print(f"\n可以使用以下命令测试:")
+    print(f"uv run python main.py --excel {wind_file}")
+    print(f"uv run python main.py --excel {solar_file}")

tests/test_float_comparison.py

@@ -0,0 +1,63 @@
+#!/usr/bin/env python3
+"""
+测试浮点数比较逻辑的脚本
+"""
+
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), 'src'))
+
+from storage_optimization import calculate_energy_balance, SystemParameters
+
+def test_float_comparison():
+    """测试浮点数比较逻辑"""
+    
+    # 创建测试数据
+    solar_output = [1.0] * 24
+    wind_output = [1.0] * 24
+    thermal_output = [1.0] * 24
+    load_demand = [1.0] * 24
+    
+    # 测试非常小的上网电量比例（接近0）
+    params = SystemParameters(
+        max_curtailment_wind=0.1,
+        max_curtailment_solar=0.1,
+        max_grid_ratio=1e-15,  # 非常小的值，应该被视为0
+        storage_efficiency=0.9,
+        discharge_rate=1.0,
+        charge_rate=1.0
+    )
+    
+    # 计算能量平衡
+    storage_capacity = 5.0
+    result = calculate_energy_balance(
+        solar_output, wind_output, thermal_output, load_demand, params, storage_capacity
+    )
+    
+    # 检查结果
+    total_grid_feed_in = sum(result['grid_feed_in'])
+    print(f"测试非常小的上网电量比例 ({params.max_grid_ratio}):")
+    print(f"实际上网电量: {total_grid_feed_in:.6f} MWh")
+    
+    # 测试正常的上网电量比例
+    params2 = SystemParameters(
+        max_curtailment_wind=0.1,
+        max_curtailment_solar=0.1,
+        max_grid_ratio=0.1,  # 正常值
+        storage_efficiency=0.9,
+        discharge_rate=1.0,
+        charge_rate=1.0
+    )
+    
+    result2 = calculate_energy_balance(
+        solar_output, wind_output, thermal_output, load_demand, params2, storage_capacity
+    )
+    
+    total_grid_feed_in2 = sum(result2['grid_feed_in'])
+    print(f"\n测试正常的上网电量比例 ({params2.max_grid_ratio}):")
+    print(f"实际上网电量: {total_grid_feed_in2:.6f} MWh")
+    
+    print("\n浮点数比较逻辑测试完成")
+
+if __name__ == "__main__":
+    test_float_comparison()

tests/test_grid_calculation.py

@@ -0,0 +1,110 @@
+"""
+测试上网电量计算逻辑
+
+测试基于可用发电量乘以最大上网比例的上网电量计算
+"""
+
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+from storage_optimization import optimize_storage_capacity, SystemParameters
+
+def test_grid_calculation():
+    """测试上网电量计算逻辑"""
+    print("=== 测试上网电量计算逻辑 ===")
+    
+    # 创建测试数据：有大量盈余电力的情况
+    solar_output = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 20.0, 25.0, 30.0, 30.0, 25.0, 20.0, 15.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]  # 24小时
+    wind_output = [5.0] * 24  # 稳定的风电
+    thermal_output = [10.0] * 24  # 稳定的火电
+    load_demand = [8.0] * 24  # 稳定的负荷，小于发电量
+    
+    # 验证数据长度
+    print(f"数据长度验证: solar={len(solar_output)}, wind={len(wind_output)}, thermal={len(thermal_output)}, load={len(load_demand)}")
+    
+    print(f"总发电潜力: {sum(solar_output) + sum(wind_output) + sum(thermal_output):.2f} MW")
+    print(f"总负荷: {sum(load_demand):.2f} MW")
+    print(f"理论盈余: {sum(solar_output) + sum(wind_output) + sum(thermal_output) - sum(load_demand):.2f} MW")
+    
+    # 测试参数1：低上网比例
+    params1 = SystemParameters(
+        max_curtailment_wind=0.1,
+        max_curtailment_solar=0.1,
+        max_grid_ratio=0.1,  # 10%上网比例
+        storage_efficiency=0.9,
+        discharge_rate=1.0,
+        charge_rate=1.0,
+        available_thermal_energy=240.0,   # 24小时 * 10MW
+        available_solar_energy=150.0,     # 基于实际光伏出力
+        available_wind_energy=120.0       # 基于实际风电出力
+    )
+    
+    # 计算期望的上网电量上限（不考虑火电）
+    total_available_energy = params1.available_solar_energy + params1.available_wind_energy
+    expected_max_grid_feed_in = total_available_energy * params1.max_grid_ratio
+    
+    print(f"\n测试参数1：")
+    print(f"  可用发电量总计: {total_available_energy:.2f} MWh")
+    print(f"  最大上网比例: {params1.max_grid_ratio}")
+    print(f"  期望上网电量上限: {expected_max_grid_feed_in:.2f} MWh")
+    
+    # 设置储能容量上限以观察上网电量限制
+    params1.max_storage_capacity = 50.0  # 限制储能容量为50MWh
+    result1 = optimize_storage_capacity(solar_output, wind_output, thermal_output, load_demand, params1)
+    
+    actual_grid_feed_in = sum(x for x in result1['grid_feed_in'] if x > 0)
+    print(f"  实际上网电量: {actual_grid_feed_in:.2f} MWh")
+    print(f"  实际弃风量: {sum(result1['curtailed_wind']):.2f} MWh")
+    print(f"  实际弃光量: {sum(result1['curtailed_solar']):.2f} MWh")
+    
+    # 验证上网电量是否正确限制
+    if abs(actual_grid_feed_in - expected_max_grid_feed_in) < 1.0:  # 允许1MW误差
+        print("  [OK] 上网电量计算正确")
+    else:
+        print("  [ERROR] 上网电量计算有误")
+    
+    # 测试参数2：高上网比例
+    params2 = SystemParameters(
+        max_curtailment_wind=0.1,
+        max_curtailment_solar=0.1,
+        max_grid_ratio=0.5,  # 50%上网比例
+        storage_efficiency=0.9,
+        discharge_rate=1.0,
+        charge_rate=1.0,
+        available_thermal_energy=240.0,   # 24小时 * 10MW
+        available_solar_energy=150.0,     # 基于实际光伏出力
+        available_wind_energy=120.0       # 基于实际风电出力
+    )
+    
+    # 计算期望的上网电量上限（不考虑火电）
+    total_available_energy = params2.available_solar_energy + params2.available_wind_energy
+    expected_max_grid_feed_in2 = total_available_energy * params2.max_grid_ratio
+    
+    # 计算期望的上网电量上限（不考虑火电）
+    total_available_energy2 = params2.available_solar_energy + params2.available_wind_energy
+    
+    print(f"\n测试参数2：")
+    print(f"  可用发电量总计: {total_available_energy2:.2f} MWh")
+    print(f"  最大上网比例: {params2.max_grid_ratio}")
+    print(f"  期望上网电量上限: {expected_max_grid_feed_in2:.2f} MWh")
+    
+    # 设置储能容量上限以观察上网电量限制
+    params2.max_storage_capacity = 50.0  # 限制储能容量为50MWh
+    result2 = optimize_storage_capacity(solar_output, wind_output, thermal_output, load_demand, params2)
+    
+    actual_grid_feed_in2 = sum(x for x in result2['grid_feed_in'] if x > 0)
+    print(f"  实际上网电量: {actual_grid_feed_in2:.2f} MWh")
+    print(f"  实际弃风量: {sum(result2['curtailed_wind']):.2f} MWh")
+    print(f"  实际弃光量: {sum(result2['curtailed_solar']):.2f} MWh")
+    
+    # 验证上网电量是否正确限制
+    if abs(actual_grid_feed_in2 - expected_max_grid_feed_in2) < 1.0:  # 允许1MW误差
+        print("  [OK] 上网电量计算正确")
+    else:
+        print("  [ERROR] 上网电量计算有误")
+    
+    print("\n=== 测试完成 ===")
+
+if __name__ == "__main__":
+    test_grid_calculation()

tests/test_grid_priority.py

@@ -0,0 +1,216 @@
+"""
+测试优先上网逻辑
+
+该程序创建一个测试场景，验证系统是否优先上网而不是弃风弃光。
+
+作者: iFlow CLI
+创建日期: 2025-12-26
+"""
+
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+import pandas as pd
+from excel_reader import create_excel_template
+from storage_optimization import optimize_storage_capacity, SystemParameters
+
+
+def create_test_excel():
+    """创建测试用的Excel文件，有明显的发电盈余"""
+    # 创建24小时数据，其中某些小时有大量盈余
+    hours = 24
+    
+    # 设计数据：在6-12点有大量光伏出力，超过负荷
+    solar = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 10.0, 15.0, 20.0, 20.0, 15.0, 10.0, 5.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+    wind = [2.0] * 24  # 稳定的风电
+    thermal = [3.0] * 24  # 稳定的火电
+    load = [5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 8.0, 8.0, 9.0, 9.0, 8.0, 8.0, 6.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0, 5.0]
+    
+    # 验证长度
+    print(f"数据长度检查: solar={len(solar)}, wind={len(wind)}, thermal={len(thermal)}, load={len(load)}")
+    
+    # 设置严格的上网电量限制（10%），迫使系统在超出限制时弃风弃光
+    params = SystemParameters(
+        max_curtailment_wind=0.15,  # 允许15%弃风
+        max_curtailment_solar=0.15, # 允许15%弃光
+        max_grid_ratio=0.1,         # 严格限制上网电量比例10%
+        storage_efficiency=0.9,
+        discharge_rate=1.0,
+        charge_rate=1.0,
+        max_storage_capacity=5.0     # 限制储能容量，增加上网压力
+    )
+    
+    # 创建DataFrame
+    df = pd.DataFrame({
+        '小时': range(1, hours + 1),
+        '光伏出力(MW)': solar,
+        '风电出力(MW)': wind,
+        '火电出力(MW)': thermal,
+        '负荷需求(MW)': load
+    })
+    
+    # 保存到Excel
+    filename = 'test_grid_priority.xlsx'
+    with pd.ExcelWriter(filename, engine='openpyxl') as writer:
+        df.to_excel(writer, sheet_name='数据', index=False)
+        
+        # 添加参数工作表
+        parameters_df = pd.DataFrame({
+            '参数名称': [
+                '最大弃风率',
+                '最大弃光率', 
+                '最大上网电量比例',
+                '储能效率',
+                '放电倍率',
+                '充电倍率',
+                '最大储能容量'
+            ],
+            '参数值': [
+                0.15,   # 最大弃风率
+                0.15,   # 最大弃光率
+                0.1,    # 最大上网电量比例（严格限制）
+                0.9,    # 储能效率
+                1.0,    # 放电倍率
+                1.0,    # 充电倍率
+                5.0     # 最大储能容量（限制）
+            ],
+            '参数说明': [
+                '允许的最大弃风率（0.0-1.0）',
+                '允许的最大弃光率（0.0-1.0）',
+                '允许的最大上网电量比例（0.0-∞，只限制上网电量）',
+                '储能充放电效率（0.0-1.0）',
+                '储能放电倍率（C-rate，>0）',
+                '储能充电倍率（C-rate，>0）',
+                '储能容量上限（MWh，空表示无限制）'
+            ],
+            '取值范围': [
+                '0.0-1.0',
+                '0.0-1.0', 
+                '≥0.0',
+                '0.0-1.0',
+                '>0',
+                '>0',
+                '>0或空'
+            ],
+            '默认值': [
+                '0.1',
+                '0.1',
+                '0.2', 
+                '0.9',
+                '1.0',
+                '1.0',
+                '无限制'
+            ]
+        })
+        parameters_df.to_excel(writer, sheet_name='参数', index=False)
+        
+        # 添加说明工作表
+        description_df = pd.DataFrame({
+            '项目': ['数据说明', '数据类型', '时间范围', '单位', '注意事项', '参数说明'],
+            '内容': [
+                '测试优先上网逻辑的数据',
+                '24小时电力数据',
+                '1-24小时',
+                'MW (兆瓦)',
+                '所有数值必须为非负数',
+                '设置了严格的上网电量限制(10%)和储能容量限制(5MWh)'
+            ]
+        })
+        description_df.to_excel(writer, sheet_name='说明', index=False)
+    
+    print(f"测试Excel文件已创建：{filename}")
+    return filename
+
+
+def test_grid_priority():
+    """测试优先上网逻辑"""
+    print("=== 测试优先上网逻辑 ===\n")
+    
+    # 创建测试文件
+    test_file = create_test_excel()
+    
+    # 从Excel读取数据
+    from excel_reader import read_excel_data
+    data = read_excel_data(test_file, include_parameters=True)
+    
+    solar_output = data['solar_output']
+    wind_output = data['wind_output']
+    thermal_output = data['thermal_output']
+    load_demand = data['load_demand']
+    params = data['system_parameters']
+    
+    print("测试数据概况：")
+    print(f"光伏出力范围: {min(solar_output):.1f} - {max(solar_output):.1f} MW")
+    print(f"风电出力: {wind_output[0]:.1f} MW (恒定)")
+    print(f"火电出力: {thermal_output[0]:.1f} MW (恒定)")
+    print(f"负荷需求范围: {min(load_demand):.1f} - {max(load_demand):.1f} MW")
+    print(f"\n系统参数：")
+    print(f"最大上网电量比例: {params.max_grid_ratio}")
+    print(f"最大储能容量: {params.max_storage_capacity} MWh")
+    print(f"最大弃风率: {params.max_curtailment_wind}")
+    print(f"最大弃光率: {params.max_curtailment_solar}")
+    
+    # 计算总发电量和负荷
+    total_generation = sum(solar_output) + sum(wind_output) + sum(thermal_output)
+    total_load = sum(load_demand)
+    total_surplus = total_generation - total_load
+    
+    print(f"\n能量平衡：")
+    print(f"总发电量: {total_generation:.1f} MWh")
+    print(f"总负荷: {total_load:.1f} MWh")
+    print(f"总盈余: {total_surplus:.1f} MWh")
+    
+    # 运行优化
+    print("\n正在运行储能容量优化...")
+    result = optimize_storage_capacity(
+        solar_output, wind_output, thermal_output, load_demand, params
+    )
+    
+    # 分析结果
+    total_grid_feed_in = sum(result['grid_feed_in'])
+    total_curtailed_wind = sum(result['curtailed_wind'])
+    total_curtailed_solar = sum(result['curtailed_solar'])
+    
+    print(f"\n=== 优化结果 ===")
+    print(f"所需储能容量: {result['required_storage_capacity']:.2f} MWh")
+    print(f"实际上网电量: {total_grid_feed_in:.2f} MWh")
+    print(f"上网电量比例: {result['total_grid_feed_in_ratio']:.3f}")
+    print(f"弃风量: {total_curtailed_wind:.2f} MWh")
+    print(f"弃光量: {total_curtailed_solar:.2f} MWh")
+    print(f"弃风率: {result['total_curtailment_wind_ratio']:.3f}")
+    print(f"弃光率: {result['total_curtailment_solar_ratio']:.3f}")
+    
+    # 验证优先上网逻辑
+    max_allowed_grid = total_generation * params.max_grid_ratio
+    print(f"\n=== 验证优先上网逻辑 ===")
+    print(f"最大允许上网电量: {max_allowed_grid:.2f} MWh")
+    print(f"实际上网电量: {total_grid_feed_in:.2f} MWh")
+    
+    if abs(total_grid_feed_in - max_allowed_grid) < 1.0:  # 允许1MW误差
+        print("[OK] 验证通过：系统优先上网，达到上网电量限制上限")
+    else:
+        print("[ERROR] 验证失败：系统未充分利用上网电量限制")
+    
+    if total_curtailed_wind > 0 or total_curtailed_solar > 0:
+        print("[OK] 验证通过：在上网电量限制达到后，系统开始弃风弃光")
+    else:
+        print("[INFO] 注意：没有弃风弃光，可能盈余电力全部被储能或上网消化")
+    
+    # 查看具体小时的弃风弃光情况
+    print(f"\n=== 详细分析（盈余时段） ===")
+    for hour in range(6, 13):  # 6-12点是光伏出力高峰
+        available = solar_output[hour] + wind_output[hour] + thermal_output[hour]
+        demand = load_demand[hour]
+        surplus = available - demand
+        grid = result['grid_feed_in'][hour]
+        curtailed = result['curtailed_wind'][hour] + result['curtailed_solar'][hour]
+        
+        if surplus > 0:
+            print(f"小时{hour}: 盈余{surplus:.1f}MW -> 上网{grid:.1f}MW + 弃风弃光{curtailed:.1f}MW")
+    
+    print(f"\n测试完成！")
+
+
+if __name__ == "__main__":
+    test_grid_priority()

tests/test_multi_scenario.py

@@ -0,0 +1,131 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""测试多场景聚类模块"""
+
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), 'src'))
+
+from multi_scenario import MultiScenarioAnalyzer
+
+import numpy as np
+
+def test_multi_scenario_basic():
+    """测试基本功能"""
+    print("测试多场景聚类基本功能...")
+    
+    # 生成简单的测试数据（24小时）
+    hours = 24
+    solar_output = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0,
+                   5.0, 4.0, 3.0, 2.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+    wind_output = [2.0, 3.0, 4.0, 3.0, 2.0, 1.0, 1.0, 2.0, 3.0, 4.0, 3.0, 2.0,
+                   2.0, 3.0, 4.0, 3.0, 2.0, 1.0, 1.0, 2.0, 3.0, 4.0, 3.0, 2.0]
+    load_demand = [3.0, 4.0, 5.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 18.0,
+                  16.0, 14.0, 12.0, 10.0, 8.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 2.0]
+    
+    # 创建分析器
+    analyzer = MultiScenarioAnalyzer(n_clusters=3, random_state=42)
+    
+    try:
+        # 执行聚类分析
+        result = analyzer.fit_predict(solar_output, wind_output, load_demand)
+        
+        print("✅ 基本聚类测试通过")
+        print(f"   - 识别场景数: {result.n_scenarios}")
+        print(f"   - 轮廓系数: {result.silhouette_score:.3f}")
+        print(f"   - 场景名称: {result.scenario_names}")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ 测试失败: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def test_multi_scenario_yearly():
+    """测试年度数据聚类"""
+    print("\n测试年度数据聚类...")
+    
+    # 生成模拟的8760小时数据
+    np.random.seed(42)
+    
+    # 简单的模拟数据
+    solar_output = []
+    wind_output = []
+    load_demand = []
+    
+    for day in range(365):
+        # 光伏：白天有出力，夜间为0
+        daily_solar = [0.0] * 6 + list(np.random.uniform(1, 6, 12)) + [0.0] * 6
+        solar_output.extend(daily_solar)
+        
+        # 风电：相对随机
+        daily_wind = np.random.exponential(2.5, 24).tolist()
+        wind_output.extend(daily_wind)
+        
+        # 负荷：日内变化，夜间低，白天高
+        daily_load = [3.0, 4.0, 5.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 18.0,
+                     16.0, 14.0, 12.0, 10.0, 8.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 2.0]
+        load_demand.extend(daily_load)
+    
+    try:
+        analyzer = MultiScenarioAnalyzer(n_clusters=5, random_state=42)
+        result = analyzer.fit_predict(solar_output, wind_output, load_demand, find_optimal_k=True)
+        
+        print("✅ 年度数据聚类测试通过")
+        print(f"   - 最优聚类数: {result.n_scenarios}")
+        print(f"   - 轮廓系数: {result.silhouette_score:.3f}")
+        
+        # 输出前3个场景的统计
+        for i in range(min(3, result.n_scenarios)):
+            stats = result.scenario_stats[f'scenario_{i}']
+            print(f"   - 场景{i+1}: 频率{stats['frequency']:.1%}, "
+                  f"光伏{stats['solar_mean']:.1f}MW, "
+                  f"风电{stats['wind_mean']:.1f}MW, "
+                  f"负荷{stats['load_mean']:.1f}MW")
+        
+        # 测试图表生成
+        print("   - 测试图表生成...")
+        analyzer.plot_scenario_analysis(result, solar_output, wind_output, load_demand,
+                                       save_path="test_scenario_analysis.png")
+        print("   ✅ 图表生成成功")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ 年度数据测试失败: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def test_data_validation():
+    """测试数据验证"""
+    print("\n测试数据验证...")
+    
+    # 测试数据长度不一致
+    try:
+        analyzer = MultiScenarioAnalyzer(n_clusters=2)
+        analyzer.fit_predict([1, 2, 3], [1, 2], [1, 2, 3])  # 长度不一致
+        print("❌ 应该检测到数据长度不一致")
+        return False
+    except ValueError as e:
+        print("✅ 正确检测到数据长度不一致")
+    
+    return True
+
+if __name__ == "__main__":
+    print("=== 多场景聚类模块测试 ===\n")
+    
+    success = True
+    success &= test_multi_scenario_basic()
+    success &= test_multi_scenario_yearly()
+    success &= test_data_validation()
+    
+    print(f"\n{'='*50}")
+    if success:
+        print("🎉 所有测试通过！多场景聚类模块工作正常。")
+    else:
+        print("💥 部分测试失败，请检查代码。")
+    print(f"{'='*50}")

tests/test_optimization.py

@@ -0,0 +1,47 @@
+"""测试优化函数是否正常工作"""
+import sys
+sys.path.append('src')
+from storage_optimization import optimize_storage_capacity, SystemParameters
+
+# 使用简单的24小时示例数据
+solar_output = [0.0] * 6 + [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 0.0] + [0.0] * 6
+wind_output = [2.0, 3.0, 4.0, 3.0, 2.0, 1.0] * 4
+thermal_output = [5.0] * 24
+load_demand = [3.0, 4.0, 5.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 18.0,
+               16.0, 14.0, 12.0, 10.0, 8.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 2.0]
+
+# 系统参数
+params = SystemParameters(
+    max_curtailment_wind=0.1,
+    max_curtailment_solar=0.1,
+    max_grid_ratio=0.2,
+    storage_efficiency=0.9,
+    discharge_rate=1.0,
+    charge_rate=1.0,
+    max_storage_capacity=200.0  # 设置储能容量上限
+)
+
+print("开始测试优化函数...")
+print("储能容量上限: 200.0 MWh")
+
+# 计算最优储能容量
+result = optimize_storage_capacity(
+    solar_output, wind_output, thermal_output, load_demand, params
+)
+
+print("\n" + "="*50)
+print("测试结果:")
+print("="*50)
+print(f"result 类型: {type(result)}")
+print(f"result 是否为 None: {result is None}")
+
+if result is not None:
+    print(f"所选储能容量: {result.get('required_storage_capacity', 'N/A'):.2f} MWh")
+    print(f"总弃电量: {result.get('total_curtailed_energy', 'N/A'):.2f} MWh")
+    print(f"弃风率: {result.get('total_curtailment_wind_ratio', 'N/A'):.3f}")
+    print(f"弃光率: {result.get('total_curtailment_solar_ratio', 'N/A'):.3f}")
+    print(f"储能容量上限: {result.get('max_storage_limit', 'N/A')}")
+    print(f"优化目标: {result.get('optimization_goal', 'N/A')}")
+    print("\n✓ 测试成功！函数返回了有效结果。")
+else:
+    print("\n✗ 测试失败！函数返回了 None。")

tests/test_periodic_balance.py

@@ -0,0 +1,135 @@
+"""
+测试周期性平衡功能
+"""
+
+import sys
+import os
+
+# 添加src目录到路径
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+from storage_optimization import optimize_storage_capacity, SystemParameters
+
+def test_24hour_data():
+    """测试24小时数据（不需要周期性平衡）"""
+    print("=" * 60)
+    print("测试24小时数据（不需要周期性平衡）")
+    print("=" * 60)
+
+    # 示例数据
+    solar_output = [0.0] * 6 + [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 0.0] + [0.0] * 6
+    wind_output = [2.0, 3.0, 4.0, 3.0, 2.0, 1.0] * 4
+    thermal_output = [5.0] * 24
+    load_demand = [3.0, 4.0, 5.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 18.0,
+                   16.0, 14.0, 12.0, 10.0, 8.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 2.0]
+
+    # 系统参数
+    params = SystemParameters(
+        max_curtailment_wind=0.1,
+        max_curtailment_solar=0.1,
+        max_grid_ratio=0.2,
+        storage_efficiency=0.9,
+        discharge_rate=1.0,
+        charge_rate=1.0
+    )
+
+    # 计算最优储能容量
+    result = optimize_storage_capacity(
+        solar_output, wind_output, thermal_output, load_demand, params
+    )
+
+    print(f"\n=== 24小时优化结果 ===")
+    print(f"所需储能总容量: {result['required_storage_capacity']:.2f} MWh")
+    print(f"初始SOC: {result['storage_profile'][0]:.4f} MWh")
+    print(f"最终SOC: {result['storage_profile'][-1]:.4f} MWh")
+    print(f"SOC差值: {abs(result['storage_profile'][-1] - result['storage_profile'][0]):.4f} MWh")
+    print(f"实际弃风率: {result['total_curtailment_wind_ratio']:.3f}")
+    print(f"实际弃光率: {result['total_curtailment_solar_ratio']:.3f}")
+    print(f"实际上网电量比例: {result['total_grid_feed_in_ratio']:.3f}")
+    print(f"能量平衡校验: {'通过' if result['energy_balance_check'] else '未通过'}")
+
+
+def test_8760hour_data():
+    """测试8760小时数据（需要周期性平衡）"""
+    print("\n" + "=" * 60)
+    print("测试8760小时数据（需要周期性平衡）")
+    print("=" * 60)
+
+    # 生成8760小时示例数据（简化版本）
+    import numpy as np
+
+    # 使用重复的24小时模式生成8760小时数据
+    daily_solar = [0.0] * 6 + [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 0.0] + [0.0] * 6
+    daily_wind = [2.0, 3.0, 4.0, 3.0, 2.0, 1.0] * 4
+    daily_thermal = [5.0] * 24
+    daily_load = [3.0, 4.0, 5.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 18.0,
+                  16.0, 14.0, 12.0, 10.0, 8.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 2.0]
+
+    # 添加季节性变化
+    np.random.seed(42)
+    solar_output = []
+    wind_output = []
+    thermal_output = []
+    load_demand = []
+
+    for day in range(365):
+        # 季节性因子
+        season_factor = 1.0 + 0.3 * np.sin(2 * np.pi * day / 365)
+
+        for hour in range(24):
+            # 添加随机变化
+            solar_variation = 1.0 + 0.2 * (np.random.random() - 0.5)
+            wind_variation = 1.0 + 0.3 * (np.random.random() - 0.5)
+            load_variation = 1.0 + 0.1 * (np.random.random() - 0.5)
+
+            solar_output.append(daily_solar[hour] * season_factor * solar_variation)
+            wind_output.append(daily_wind[hour] * wind_variation)
+            thermal_output.append(daily_thermal[hour])
+            load_demand.append(daily_load[hour] * (2.0 - season_factor) * load_variation)
+
+    # 系统参数
+    params = SystemParameters(
+        max_curtailment_wind=0.1,
+        max_curtailment_solar=0.1,
+        max_grid_ratio=0.2,
+        storage_efficiency=0.9,
+        discharge_rate=1.0,
+        charge_rate=1.0,
+        max_storage_capacity=1000.0  # 设置储能容量上限以加快测试
+    )
+
+    # 计算最优储能容量
+    result = optimize_storage_capacity(
+        solar_output, wind_output, thermal_output, load_demand, params
+    )
+
+    print(f"\n=== 8760小时优化结果 ===")
+    print(f"所需储能总容量: {result['required_storage_capacity']:.2f} MWh")
+    print(f"初始SOC: {result['storage_profile'][0]:.4f} MWh")
+    print(f"最终SOC: {result['storage_profile'][-1]:.4f} MWh")
+    print(f"SOC差值: {abs(result['storage_profile'][-1] - result['storage_profile'][0]):.4f} MWh")
+    print(f"实际弃风率: {result['total_curtailment_wind_ratio']:.3f}")
+    print(f"实际弃光率: {result['total_curtailment_solar_ratio']:.3f}")
+    print(f"实际上网电量比例: {result['total_grid_feed_in_ratio']:.3f}")
+    print(f"能量平衡校验: {'通过' if result['energy_balance_check'] else '未通过'}")
+
+    # 验证周期性平衡
+    soc_diff = abs(result['storage_profile'][-1] - result['storage_profile'][0])
+    capacity = result['required_storage_capacity']
+    soc_convergence_threshold = capacity * 0.001  # 0.1%阈值
+
+    if soc_diff < soc_convergence_threshold:
+        print(f"\n✓ 周期性平衡验证通过")
+        print(f"  SOC差值: {soc_diff:.4f} MWh < 阈值: {soc_convergence_threshold:.4f} MWh")
+    else:
+        print(f"\n⚠ 周期性平衡验证未通过")
+        print(f"  SOC差值: {soc_diff:.4f} MWh >= 阈值: {soc_convergence_threshold:.4f} MWh")
+
+
+if __name__ == "__main__":
+    test_24hour_data()
+    test_8760hour_data()
+
+    print("\n" + "=" * 60)
+    print("所有测试完成")
+    print("=" * 60)

tests/test_scenario_storage_optimization.py

@@ -0,0 +1,232 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+"""测试场景储能配置优化模块"""
+
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), 'src'))
+
+from multi_scenario import MultiScenarioAnalyzer
+from storage_optimization import SystemParameters
+import numpy as np
+
+def test_scenario_storage_optimization():
+    """测试聚类场景的储能配置优化"""
+    print("=== 场景储能配置优化测试 ===")
+    
+    # 生成模拟数据
+    np.random.seed(42)
+    
+    solar_output = []
+    wind_output = []
+    load_demand = []
+    
+    for day in range(30):  # 30天数据用于测试
+        # 光伏：白天有出力，夜间为0
+        daily_solar = [0.0] * 6 + list(np.random.uniform(2, 8, 12)) + [0.0] * 6
+        solar_output.extend(daily_solar)
+        
+        # 风电：相对随机
+        daily_wind = np.random.exponential(3.0, 24).tolist()
+        wind_output.extend(daily_wind)
+        
+        # 负荷：日内变化，夜间低，白天高
+        daily_load = [4.0, 5.0, 6.0, 7.0, 9.0, 11.0, 13.0, 15.0, 17.0, 19.0, 21.0, 19.0,
+                     17.0, 15.0, 13.0, 11.0, 9.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 3.0]
+        load_demand.extend(daily_load)
+    
+    try:
+        # 1. 执行聚类分析
+        print("1. 执行多场景聚类分析...")
+        analyzer = MultiScenarioAnalyzer(n_clusters=4, random_state=42)
+        result = analyzer.fit_predict(solar_output, wind_output, load_demand)
+        
+        print(f"   识别出 {result.n_scenarios} 个场景")
+        
+        # 2. 对每个场景进行储能配置优化
+        print("\n2. 对每个场景进行储能配置优化...")
+        
+        # 系统参数
+        system_params = SystemParameters(
+            max_curtailment_wind=0.1,
+            max_curtailment_solar=0.1,
+            max_grid_ratio=0.2,
+            storage_efficiency=0.9,
+            discharge_rate=1.0,
+            charge_rate=1.0
+        )
+        
+        # 使用 analyzer 的优化功能
+        optimization_results = analyzer.optimize_storage_for_scenarios(
+            result, solar_output, wind_output, load_demand, system_params, safety_factor=1.2
+        )
+        
+        # 3. 显示优化结果
+        print("\n3. 储能配置优化结果...")
+        analyzer.print_storage_optimization_summary(optimization_results)
+        
+        # 4. 测试结果验证
+        assert 'summary' in optimization_results, "缺少汇总结果"
+        assert optimization_results['summary']['n_scenarios'] == result.n_scenarios, "场景数不匹配"
+        assert optimization_results['summary']['recommended_capacity'] > 0, "推荐容量应该大于0"
+        
+        print("\n✅ 场景储能配置优化测试通过")
+        return True, optimization_results
+        
+    except Exception as e:
+        print(f"❌ 场景储能配置优化测试失败: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return False, None
+
+def test_storage_optimization_with_different_scenarios():
+    """测试不同场景数量的储能优化"""
+    print("\n=== 不同场景数量的储能优化测试 ===")
+    
+    # 生成测试数据
+    np.random.seed(123)
+    
+    solar_output = []
+    wind_output = []
+    load_demand = []
+    
+    for day in range(60):  # 60天数据
+        # 光伏：模拟夏季和冬季差异
+        if day < 30:  # 夏季
+            daily_solar = [0.0] * 6 + list(np.random.uniform(3, 10, 12)) + [0.0] * 6
+        else:  # 冬季
+            daily_solar = [0.0] * 6 + list(np.random.uniform(1, 6, 12)) + [0.0] * 6
+        solar_output.extend(daily_solar)
+        
+        # 风电：模拟季节性变化
+        daily_wind = np.random.exponential(2.5, 24).tolist()
+        wind_output.extend(daily_wind)
+        
+        # 负荷：模拟夏冬负荷差异
+        if day < 30:  # 夏季负荷较高（空调）
+            daily_load = [6.0, 7.0, 8.0, 9.0, 11.0, 13.0, 15.0, 17.0, 19.0, 21.0, 23.0, 21.0,
+                         19.0, 17.0, 15.0, 13.0, 11.0, 9.0, 8.0, 7.0, 6.0, 5.0, 4.0, 5.0]
+        else:  # 冬季负荷相对较低
+            daily_load = [4.0, 5.0, 6.0, 7.0, 9.0, 11.0, 13.0, 15.0, 17.0, 19.0, 21.0, 19.0,
+                         17.0, 15.0, 13.0, 11.0, 9.0, 7.0, 6.0, 5.0, 4.0, 3.0, 2.0, 3.0]
+        load_demand.extend(daily_load)
+    
+    analyzer = MultiScenarioAnalyzer(random_state=123)
+    
+    # 测试不同聚类数
+    for n_clusters in [3, 5, 7]:
+        print(f"\n测试 {n_clusters} 个场景的储能优化...")
+        
+        try:
+            result = analyzer.fit_predict(solar_output, wind_output, load_demand, 
+                                        n_clusters=n_clusters)
+            
+            print(f"   实际识别出 {result.n_scenarios} 个场景")
+            
+            # 执行储能优化
+            optimization_results = analyzer.optimize_storage_for_scenarios(
+                result, solar_output, wind_output, load_demand, 
+                safety_factor=1.3
+            )
+            
+            # 显示结果
+            summary = optimization_results['summary']
+            print(f"   加权平均储能需求: {summary['weighted_average_storage']:.2f} MWh")
+            print(f"   推荐储能容量: {summary['recommended_capacity']:.2f} MWh")
+            
+        except Exception as e:
+            print(f"   ❌ {n_clusters}场景测试失败: {str(e)}")
+            return False
+    
+    print("\n✅ 不同场景数量的储能优化测试通过")
+    return True
+
+def test_edge_cases():
+    """测试边界情况"""
+    print("\n=== 边界情况测试 ===")
+    
+    # 测试短时间数据
+    print("1. 测试短时间数据...")
+    analyzer = MultiScenarioAnalyzer(n_clusters=2, random_state=42)
+    
+    # 只生成24小时数据
+    solar_24h = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0,
+                5.0, 4.0, 3.0, 2.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+    wind_24h = [2.0, 3.0, 4.0, 3.0, 2.0, 1.0, 1.0, 2.0, 3.0, 4.0, 3.0, 2.0,
+               2.0, 3.0, 4.0, 3.0, 2.0, 1.0, 1.0, 2.0, 3.0, 4.0, 3.0, 2.0]
+    load_24h = [3.0, 4.0, 5.0, 6.0, 8.0, 10.0, 12.0, 14.0, 16.0, 18.0, 20.0, 18.0,
+               16.0, 14.0, 12.0, 10.0, 8.0, 6.0, 5.0, 4.0, 3.0, 2.0, 1.0, 2.0]
+    
+    try:
+        result = analyzer.fit_predict(solar_24h, wind_24h, load_24h)
+        
+        # 对于短时间数据，应该会被扩展到24小时
+        optimization_results = analyzer.optimize_storage_for_scenarios(
+            result, solar_24h, wind_24h, load_24h
+        )
+        
+        print("   ✅ 短时间数据测试通过")
+        
+    except Exception as e:
+        print(f"   ❌ 短时间数据测试失败: {str(e)}")
+        return False
+    
+    # 测试极大储能需求情况
+    print("2. 测试极大储能需求情况...")
+    
+    # 创建储能需求很大的场景
+    solar_extreme = [10.0] * 24  # 始终高出力
+    wind_extreme = [8.0] * 24    # 始终高出力
+    load_extreme = [1.0] * 24    # 始终低负荷
+    
+    try:
+        result_extreme = analyzer.fit_predict(solar_extreme, wind_extreme, load_extreme)
+        optimization_results_extreme = analyzer.optimize_storage_for_scenarios(
+            result_extreme, solar_extreme, wind_extreme, load_extreme
+        )
+        
+        print(f"   极端场景推荐储能容量: {optimization_results_extreme['summary']['recommended_capacity']:.2f} MWh")
+        print("   ✅ 极大储能需求情况测试通过")
+        
+    except Exception as e:
+        print(f"   ❌ 极大储能需求情况测试失败: {str(e)}")
+        return False
+    
+    print("\n✅ 所有边界情况测试通过")
+    return True
+
+if __name__ == "__main__":
+    print("=== 场景储能配置优化模块测试 ===\n")
+    
+    success = True
+    
+    # 基础功能测试
+    success1, optimization_results = test_scenario_storage_optimization()
+    success &= success1
+    
+    # 不同场景数量测试
+    success2 = test_storage_optimization_with_different_scenarios()
+    success &= success2
+    
+    # 边界情况测试
+    success3 = test_edge_cases()
+    success &= success3
+    
+    print(f"\n{'='*60}")
+    if success:
+        print("🎉 所有场景储能配置优化测试通过！")
+        print("   储能优化模块功能正常工作。")
+    else:
+        print("💥 部分测试失败，请检查代码。")
+    print(f"{'='*60}")
+    
+    # 返回测试结果供其他模块使用
+    if success:
+        print(f"\n测试数据示例:")
+        if optimization_results:
+            summary = optimization_results['summary']
+            print(f"   - 加权平均储能需求: {summary['weighted_average_storage']:.2f} MWh")
+            print(f"   - 推荐储能容量: {summary['recommended_capacity']:.2f} MWh")
+            print(f"   - 安全系数: {summary['safety_factor']}")
+            print(f"   - 分析场景数: {summary['n_scenarios']}")

tests/test_single_renewable.py

@@ -0,0 +1,91 @@
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+import pandas as pd
+import numpy as np
+
+def create_single_wind_excel():
+    """创建只有风电的测试Excel文件"""
+    
+    # 创建24小时数据
+    hours = list(range(1, 25))
+    
+    # 风电出力：前12小时高，后12小时低
+    wind_output = [80, 75, 70, 65, 60, 55, 50, 45, 40, 35, 30, 25, 20, 15, 10, 8, 6, 5, 4, 3, 2, 1, 0.5, 0.2, 0.1]
+    
+    # 光伏出力：全部为0
+    solar_output = [0.0] * 24
+    
+    # 火电出力：全部为0
+    thermal_output = [0.0] * 24
+    
+    # 负荷需求：恒定40MW
+    load_demand = [40.0] * 24
+    
+    # 创建DataFrame
+    data = {
+        '小时': hours,
+        '光伏出力(MW)': solar_output,
+        '风电出力(MW)': wind_output,
+        '火电出力(MW)': thermal_output,
+        '负荷需求(MW)': load_demand
+    }
+    df = pd.DataFrame(data)
+    
+    # 保存为Excel文件
+    excel_file = 'single_wind_test.xlsx'
+    df.to_excel(excel_file, index=False, sheet_name='data')
+    print(f"已创建单一风电测试文件: {excel_file}")
+    print(f"风电总出力: {sum(wind_output):.1f} MWh")
+    print(f"负荷总需求: {sum(load_demand):.1f} MWh")
+    
+    return excel_file
+
+def create_single_solar_excel():
+    """创建只有光伏的测试Excel文件"""
+    
+    # 创建24小时数据
+    hours = list(range(1, 25))
+    
+    # 风电出力：全部为0
+    wind_output = [0.0] * 24
+    
+    # 光伏出力：中间时段高
+    solar_output = [0, 0, 0, 0, 0, 0, 10, 20, 40, 60, 80, 60, 40, 20, 10, 5, 2, 1, 0.5, 0.2, 0.1, 0, 0, 0]
+    
+    # 火电出力：全部为0
+    thermal_output = [0.0] * 24
+    
+    # 负荷需求：恒定30MW
+    load_demand = [30.0] * 24
+    
+    # 创建DataFrame
+    data = {
+        '小时': hours,
+        '光伏出力(MW)': solar_output,
+        '风电出力(MW)': wind_output,
+        '火电出力(MW)': thermal_output,
+        '负荷需求(MW)': load_demand
+    }
+    df = pd.DataFrame(data)
+    
+    # 保存为Excel文件
+    excel_file = 'single_solar_test.xlsx'
+    df.to_excel(excel_file, index=False, sheet_name='data')
+    print(f"已创建单一光伏测试文件: {excel_file}")
+    print(f"光伏总出力: {sum(solar_output):.1f} MWh")
+    print(f"负荷总需求: {sum(load_demand):.1f} MWh")
+    
+    return excel_file
+
+if __name__ == "__main__":
+    print("创建单一可再生能源测试文件...")
+    wind_file = create_single_wind_excel()
+    solar_file = create_single_solar_excel()
+    print(f"\n测试文件已创建完成:")
+    print(f"1. {wind_file} - 单一风电场景")
+    print(f"2. {solar_file} - 单一光伏场景")
+    print(f"\n可以使用以下命令测试:")
+    print(f"uv run python main.py --excel {wind_file}")
+    print(f"uv run python main.py --excel {solar_file}")

tests/test_single_renewable_curtail.py

@@ -0,0 +1,81 @@
+"""
+测试单一可再生能源时弃风量不受限制的功能
+"""
+
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+import numpy as np
+from storage_optimization import optimize_storage_capacity, SystemParameters
+
+def test_single_renewable_scenario():
+    """测试单一可再生能源场景"""
+    
+    print("=== 测试单一可再生能源弃风量限制功能 ===\n")
+    
+    # 场景1: 只有风电
+    print("场景1: 只有风电系统")
+    wind_only = [50.0] * 24  # 24小时风电出力，每小时50MW
+    solar_none = [0.0] * 24
+    thermal_none = [0.0] * 24
+    load = [30.0] * 24  # 负荷30MW，风电出力大于负荷
+    
+    params = SystemParameters(
+        max_curtailment_wind=0.1,  # 设置10%弃风限制
+        max_curtailment_solar=0.1,
+        max_grid_ratio=0.2,
+        storage_efficiency=0.9,
+        discharge_rate=1.0,
+        charge_rate=1.0,
+        max_storage_capacity=None
+    )
+    
+    result = optimize_storage_capacity(wind_only, solar_none, thermal_none, load, params)
+    
+    print(f"风电总出力: {np.sum(wind_only):.1f} MWh")
+    print(f"弃风量: {np.sum(result['curtailed_wind']):.1f} MWh")
+    print(f"弃风比例: {result['total_curtailment_wind_ratio']:.3f}")
+    print(f"储能容量: {result['required_storage_capacity']:.1f} MWh")
+    print(f"预期: 弃风量应该为0（因为只有风电，不受10%限制）")
+    print()
+    
+    # 场景2: 只有光伏
+    print("场景2: 只有光伏系统")
+    wind_none = [0.0] * 24
+    solar_only = [40.0] * 24  # 24小时光伏出力，每小时40MW
+    thermal_none = [0.0] * 24
+    load = [20.0] * 24  # 负荷20MW，光伏出力大于负荷
+    
+    result = optimize_storage_capacity(wind_none, solar_only, thermal_none, load, params)
+    
+    print(f"光伏总出力: {np.sum(solar_only):.1f} MWh")
+    print(f"弃光量: {np.sum(result['curtailed_solar']):.1f} MWh")
+    print(f"弃光比例: {result['total_curtailment_solar_ratio']:.3f}")
+    print(f"储能容量: {result['required_storage_capacity']:.1f} MWh")
+    print(f"预期: 弃光量应该为0（因为只有光伏，不受10%限制）")
+    print()
+    
+    # 场景3: 风电+光伏（混合系统）
+    print("场景3: 风电+光伏混合系统")
+    wind_mixed = [30.0] * 24
+    solar_mixed = [20.0] * 24
+    thermal_none = [0.0] * 24
+    load = [25.0] * 24  # 负荷25MW，总发电50MW > 负荷
+    
+    result = optimize_storage_capacity(wind_mixed, solar_mixed, thermal_none, load, params)
+    
+    print(f"风电总出力: {np.sum(wind_mixed):.1f} MWh")
+    print(f"光伏总出力: {np.sum(solar_mixed):.1f} MWh")
+    print(f"弃风量: {np.sum(result['curtailed_wind']):.1f} MWh")
+    print(f"弃光量: {np.sum(result['curtailed_solar']):.1f} MWh")
+    print(f"弃风比例: {result['total_curtailment_wind_ratio']:.3f}")
+    print(f"弃光比例: {result['total_curtailment_solar_ratio']:.3f}")
+    print(f"储能容量: {result['required_storage_capacity']:.1f} MWh")
+    print(f"预期: 弃风弃光量应受10%限制，总弃风弃光量约为{(720+480)*0.1:.0f} MWh")
+    print()
+    
+    print("=== 测试完成 ===")
+
+if __name__ == "__main__":
+    test_single_renewable_scenario()

tests/test_storage_capacity.py

@@ -0,0 +1,86 @@
+"""测试储能容量计算"""
+import sys
+sys.path.append('src')
+from storage_optimization import calculate_energy_balance, SystemParameters
+
+# 使用简单的示例数据
+solar_output = [0.0] * 6 + [10.0, 20.0, 30.0, 40.0, 50.0, 60.0, 50.0, 40.0, 30.0, 20.0, 10.0, 0.0] + [0.0] * 6
+wind_output = [20.0, 30.0, 40.0, 30.0, 20.0, 10.0] * 4
+thermal_output = [50.0] * 24
+load_demand = [30.0, 40.0, 50.0, 60.0, 80.0, 100.0, 120.0, 140.0, 160.0, 180.0, 200.0, 180.0,
+               160.0, 140.0, 120.0, 100.0, 80.0, 60.0, 50.0, 40.0, 30.0, 20.0, 10.0, 20.0]
+
+# 系统参数
+params = SystemParameters(
+    max_curtailment_wind=0.1,
+    max_curtailment_solar=0.1,
+    max_grid_ratio=0.2,
+    storage_efficiency=0.9,
+    discharge_rate=1.0,
+    charge_rate=1.0,
+    max_storage_capacity=200.0  # 设置储能容量上限
+)
+
+# 测试不同储能容量下的储能状态
+test_capacities = [50.0, 100.0, 150.0, 200.0]
+
+print("="*70)
+print("测试不同储能容量下的实际最大储能状态")
+print("="*70)
+print(f"储能容量上限: {params.max_storage_capacity} MWh")
+print(f"充放电倍率: {params.charge_rate} C\n")
+
+for capacity in test_capacities:
+    result = calculate_energy_balance(
+        solar_output, wind_output, thermal_output, load_demand,
+        params, capacity, initial_soc=0.0
+    )
+    
+    storage_profile = result['storage_profile']
+    max_storage_state = max(storage_profile)
+    min_storage_state = min(storage_profile)
+    total_curtailed = sum(result['curtailed_wind']) + sum(result['curtailed_solar'])
+    
+    print(f"储能容量: {capacity:.1f} MWh")
+    print(f"  实际最大储能状态: {max_storage_state:.2f} MWh ({max_storage_state/capacity*100:.1f}%)")
+    print(f"  实际最小储能状态: {min_storage_state:.2f} MWh")
+    print(f"  总弃电量: {total_curtailed:.2f} MWh")
+    
+    # 检查是否有充电受限的情况
+    charge_profile = result['charge_profile']
+    discharge_profile = result['discharge_profile']
+    
+    max_possible_charge = capacity * params.charge_rate  # 最大充电功率
+    max_possible_discharge = capacity * params.discharge_rate  # 最大放电功率
+    
+    max_actual_charge = max(charge_profile)
+    max_actual_discharge = max(discharge_profile)
+    
+    print(f"  最大充电功率: {max_actual_charge:.2f} MW (限制: {max_possible_charge:.2f} MW)")
+    print(f"  最大放电功率: {max_actual_discharge:.2f} MW (限制: {max_possible_discharge:.2f} MW)")
+    
+    # 检查是否达到功率限制
+    charge_limited = any(c >= max_possible_charge * 0.99 for c in charge_profile)
+    discharge_limited = any(d >= max_possible_discharge * 0.99 for d in discharge_profile)
+    
+    if charge_limited:
+        print(f"  ⚠ 充电功率受限")
+    if discharge_limited:
+        print(f"  ⚠ 放电功率受限")
+    
+    # 检查储能容量利用率
+    utilization = max_storage_state / capacity * 100
+    if utilization < 90:
+        print(f"  ⚠ 储能容量利用率低 ({utilization:.1f}%)")
+    
+    print()
+
+print("="*70)
+print("分析：为什么实际储能状态达不到设定的储能容量上限？")
+print("="*70)
+print("可能的原因：")
+print("1. 电力供需平衡：如果发电量和负荷基本平衡，不需要大量储能")
+print("2. 充放电倍率限制：充放电功率受限，无法快速填满储能")
+print("3. 约束条件限制：弃风弃光率、上网电量比例等约束限制了储能使用")
+print("4. 周期性平衡要求：储能需要在周期结束时回到接近初始状态")
+print("5. 初始SOC设置：初始SOC从0开始，可能需要多周期才能稳定")

tests/test_zero_grid.py

@@ -0,0 +1,212 @@
+# -*- coding: utf-8 -*-
+"""
+测试火电可用发电量为0时的上网电量限制
+
+验证当Excel中的火电可用发电量为0时，上网上限计算正确
+"""
+
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+import pandas as pd
+from excel_reader import create_excel_template, read_excel_data, read_system_parameters
+from storage_optimization import optimize_storage_capacity, SystemParameters
+
+def test_zero_grid_limit():
+    """测试火电可用发电量为0时的上网电量限制"""
+    print("=== 测试火电可用发电量为0时的上网电量限制 ===")
+    
+    # 创建一个测试Excel文件，其中火电可用发电量为0
+    test_file = "test_zero_grid.xlsx"
+    
+    # 创建基本模板
+    create_excel_template(test_file, "24")
+    
+    # 修改参数工作表
+    df_params = pd.read_excel(test_file, sheet_name='参数')
+    
+    # 修改参数
+    for idx, row in df_params.iterrows():
+        if row['参数名称'] == '火电可用发电量':
+            df_params.at[idx, '参数值'] = 0.0
+        elif row['参数名称'] == '光伏可用发电量':
+            df_params.at[idx, '参数值'] = 100.0  # 减少光伏可用发电量
+        elif row['参数名称'] == '风电可用发电量':
+            df_params.at[idx, '参数值'] = 100.0  # 减少风电可用发电量
+        elif row['参数名称'] == '最大上网电量比例':
+            df_params.at[idx, '参数值'] = 0.3   # 提高上网比例到30%
+    
+    # 保存修改后的Excel文件
+    with pd.ExcelWriter(test_file, mode='a', engine='openpyxl', if_sheet_exists='replace') as writer:
+        df_params.to_excel(writer, sheet_name='参数', index=False)
+    
+    print(f"创建测试Excel文件: {test_file}")
+    print("设置参数:")
+    print("  火电可用发电量: 0 MWh")
+    print("  光伏可用发电量: 100 MWh")
+    print("  风电可用发电量: 100 MWh")
+    print("  最大上网电量比例: 30%")
+    
+    # 读取参数
+    print("\n读取系统参数:")
+    try:
+        params = read_system_parameters(test_file)
+        print(f"  火电可用发电量: {params.available_thermal_energy} MWh")
+        print(f"  光伏可用发电量: {params.available_solar_energy} MWh")
+        print(f"  风电可用发电量: {params.available_wind_energy} MWh")
+        print(f"  最大上网电量比例: {params.max_grid_ratio}")
+        
+        # 计算期望的上网上限
+        total_available_energy = params.available_solar_energy + params.available_wind_energy
+        expected_max_grid_feed_in = total_available_energy * params.max_grid_ratio
+        
+        print(f"\n期望结果:")
+        print(f"  可用发电量总计（不计火电）: {total_available_energy} MWh")
+        print(f"  最大上网电量上限: {expected_max_grid_feed_in} MWh")
+        
+    except Exception as e:
+        print(f"  [ERROR] 读取参数失败: {str(e)}")
+        return
+    
+    # 重新设计测试数据：创建必须上网的场景
+    # 策略：设置极低的弃风弃光率，迫使系统必须上网
+    solar_output = [50.0] * 24  # 高光伏出力
+    wind_output = [50.0] * 24  # 高风电出力
+    thermal_output = [0.0] * 24  # 无火电
+    load_demand = [20.0] * 24  # 低负荷
+    
+    print(f"\n重新设计的测试数据:")
+    print(f"  光伏出力: {sum(solar_output):.1f} MWh")
+    print(f"  风电出力: {sum(wind_output):.1f} MWh")
+    print(f"  总发电量: {sum(solar_output) + sum(wind_output) + sum(thermal_output):.1f} MWh")
+    print(f"  总负荷: {sum(load_demand):.1f} MWh")
+    print(f"  理论盈余: {sum(solar_output) + sum(wind_output) + sum(thermal_output) - sum(load_demand):.1f} MWh")
+    
+    # 重新设置参数：极低的弃风弃光率，限制储能容量
+    params.max_curtailment_wind = 0.01   # 只能弃风1%
+    params.max_curtailment_solar = 0.01  # 只能弃光1%
+    params.max_storage_capacity = 100.0   # 限制储能容量
+    
+    print(f"\n修改后的系统参数:")
+    print(f"  最大弃风率: {params.max_curtailment_wind} (1%)")
+    print(f"  最大弃光率: {params.max_curtailment_solar} (1%)")
+    print(f"  最大储能容量: {params.max_storage_capacity} MWh")
+    
+    # 计算弃风弃光限制
+    max_curtail_wind = sum(wind_output) * params.max_curtailment_wind
+    max_curtail_solar = sum(solar_output) * params.max_curtailment_solar
+    total_surplus = sum(solar_output) + sum(wind_output) - sum(load_demand)
+    forced_grid_feed_in = total_surplus - max_curtail_wind - max_curtail_solar - params.max_storage_capacity
+    
+    print(f"\n强制上网分析:")
+    print(f"  最大允许弃风量: {max_curtail_wind:.1f} MWh")
+    print(f"  最大允许弃光量: {max_curtail_solar:.1f} MWh")
+    print(f"  储能容量: {params.max_storage_capacity} MWh")
+    print(f"  强制上网电量: {forced_grid_feed_in:.1f} MWh")
+    print(f"  期望上网电量上限: {expected_max_grid_feed_in:.1f} MWh")
+    
+    if forced_grid_feed_in > expected_max_grid_feed_in:
+        print(f"  [预期] 上网电量应达到上限: {expected_max_grid_feed_in:.1f} MWh")
+    else:
+        print(f"  [预期] 上网电量应为: {forced_grid_feed_in:.1f} MWh")
+    
+    print(f"\n运行优化计算（储能容量限制: {params.max_storage_capacity} MWh）")
+    
+    # 使用24小时数据（不自动扩展）
+    import os
+    os.remove(test_file)  # 删除之前创建的文件
+    
+    # 重新创建24小时模板
+    create_excel_template(test_file, "24")
+    
+    # 修改参数工作表
+    df_params = pd.read_excel(test_file, sheet_name='参数')
+    
+    # 修改参数
+    for idx, row in df_params.iterrows():
+        if row['参数名称'] == '火电可用发电量':
+            df_params.at[idx, '参数值'] = 0.0
+        elif row['参数名称'] == '光伏可用发电量':
+            df_params.at[idx, '参数值'] = 100.0  # 减少光伏可用发电量
+        elif row['参数名称'] == '风电可用发电量':
+            df_params.at[idx, '参数值'] = 100.0  # 减少风电可用发电量
+        elif row['参数名称'] == '最大上网电量比例':
+            df_params.at[idx, '参数值'] = 0.3   # 提高上网比例到30%
+    
+    # 保存修改后的Excel文件
+    with pd.ExcelWriter(test_file, mode='w', engine='openpyxl') as writer:
+        df_params.to_excel(writer, sheet_name='参数', index=False)
+    
+    # 重新读取参数
+    params = read_system_parameters(test_file)
+    
+    try:
+        result = optimize_storage_capacity(
+            solar_output, wind_output, thermal_output, load_demand, params
+        )
+        
+        if result is None:
+            print(f"  [ERROR] 优化计算失败，返回None")
+            return
+            
+        actual_grid_feed_in = sum(x for x in result['grid_feed_in'] if x > 0)
+        
+        print(f"\n实际结果:")
+        print(f"  实际上网电量: {actual_grid_feed_in:.2f} MWh")
+        print(f"  实际弃风量: {sum(result['curtailed_wind']):.2f} MW")
+        print(f"  实际弃光量: {sum(result['curtailed_solar']):.2f} MW")
+        print(f"  实际弃风率: {sum(result['curtailed_wind'])/sum(wind_output):.3f}")
+        print(f"  实际弃光率: {sum(result['curtailed_solar'])/sum(solar_output):.3f}")
+        
+        # 验证上网电量（基于实际系统行为重新设计）
+        print(f"\n验证结果:")
+        print(f"  实际上网电量: {actual_grid_feed_in:.2f} MWh")
+        print(f"  实际弃风量: {sum(result['curtailed_wind']):.2f} MWh")
+        print(f"  实际弃光量: {sum(result['curtailed_solar']):.2f} MWh")
+        print(f"  实际储能使用: {result['required_storage_capacity']:.2f} MWh")
+        
+        # 验证弃风弃光限制
+        expected_curtail_wind = sum(wind_output) * params.max_curtailment_wind
+        expected_curtail_solar = sum(solar_output) * params.max_curtailment_solar
+        
+        print(f"\n弃风弃光验证:")
+        print(f"  期望弃风量: {expected_curtail_wind:.2f} MWh")
+        print(f"  实际弃风量: {sum(result['curtailed_wind']):.2f} MWh")
+        print(f"  期望弃光量: {expected_curtail_solar:.2f} MWh")
+        print(f"  实际弃光量: {sum(result['curtailed_solar']):.2f} MWh")
+        
+        # 验证储能容量限制
+        print(f"\n储能容量验证:")
+        print(f"  储能容量限制: {params.max_storage_capacity:.2f} MWh")
+        if result['required_storage_capacity'] is not None:
+            print(f"  实际储能需求: {result['required_storage_capacity']:.2f} MWh")
+        else:
+            print(f"  实际储能需求: None (无限制)")
+        
+        # 综合验证
+        wind_curtail_ok = abs(sum(result['curtailed_wind']) - expected_curtail_wind) < 1.0
+        solar_curtail_ok = abs(sum(result['curtailed_solar']) - expected_curtail_solar) < 1.0
+        storage_limit_ok = (result['required_storage_capacity'] is not None and 
+                     result['required_storage_capacity'] >= params.max_storage_capacity * 0.95)  # 允许5%误差
+        
+        if wind_curtail_ok and solar_curtail_ok and storage_limit_ok and actual_grid_feed_in > 0:
+            print(f"\n[OK] 测试通过:")
+            print(f"  ✓ 弃风限制正确执行")
+            print(f"  ✓ 弃光限制正确执行") 
+            print(f"  ✓ 储能容量限制生效")
+            print(f"  ✓ 系统正确上网处理盈余电力")
+        else:
+            print(f"\n[WARNING] 测试部分通过:")
+            print(f"  弃风限制: {'✓' if wind_curtail_ok else '✗'}")
+            print(f"  弃光限制: {'✓' if solar_curtail_ok else '✗'}")
+            print(f"  储能限制: {'✓' if storage_limit_ok else '✗'}")
+            print(f"  上网功能: {'✓' if actual_grid_feed_in > 0 else '✗'}")
+            
+    except Exception as e:
+        print(f"  [ERROR] 优化计算失败: {str(e)}")
+    
+    print("\n=== 测试完成 ===")
+
+if __name__ == "__main__":
+    test_zero_grid_limit()

tests/test_zero_grid_simple.py

@@ -0,0 +1,115 @@
+# -*- coding: utf-8 -*-
+"""
+测试火电可用发电量为0时的系统行为 - 简化版本
+
+验证系统在无火电情况下的基本功能
+"""
+
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+from storage_optimization import optimize_storage_capacity, SystemParameters
+
+def test_zero_grid_simple():
+    """测试火电可用发电量为0时的系统行为"""
+    print("=== 测试火电可用发电量为0时的系统行为（简化版） ===")
+    
+    # 创建简单的测试场景
+    solar_output = [30.0] * 12 + [0.0] * 12  # 12小时有光伏，12小时无光伏
+    wind_output = [20.0] * 24  # 稳定风电
+    thermal_output = [0.0] * 24  # 无火电
+    load_demand = [25.0] * 24  # 稳定负荷
+    
+    print("测试数据设计:")
+    print(f"  光伏出力: {sum(solar_output):.1f} MWh (12小时)")
+    print(f"  风电出力: {sum(wind_output):.1f} MWh")
+    print(f"  火电出力: {sum(thermal_output):.1f} MWh")
+    print(f"  总发电量: {sum(solar_output) + sum(wind_output) + sum(thermal_output):.1f} MWh")
+    print(f"  总负荷: {sum(load_demand):.1f} MWh")
+    print(f"  理论盈余: {(sum(solar_output) + sum(wind_output) + sum(thermal_output) - sum(load_demand)):.1f} MWh")
+    
+    # 设置系统参数
+    params = SystemParameters(
+        max_curtailment_wind=0.1,      # 允许弃风10%
+        max_curtailment_solar=0.1,     # 允许弃光10%
+        max_grid_ratio=0.2,            # 允许上网20%
+        storage_efficiency=0.9,
+        discharge_rate=1.0,
+        charge_rate=1.0,
+        max_storage_capacity=50.0       # 限制储能容量
+    )
+    
+    print(f"\n系统参数:")
+    print(f"  最大弃风率: {params.max_curtailment_wind}")
+    print(f"  最大弃光率: {params.max_curtailment_solar}")
+    print(f"  最大上网电量比例: {params.max_grid_ratio}")
+    print(f"  储能容量限制: {params.max_storage_capacity} MWh")
+    
+    try:
+        result = optimize_storage_capacity(
+            solar_output, wind_output, thermal_output, load_demand, params
+        )
+        
+        if result is None:
+            print(f"\n[ERROR] 优化计算失败")
+            return
+        
+        # 计算结果统计
+        actual_grid_feed_in = sum(x for x in result['grid_feed_in'] if x > 0)
+        actual_curtail_wind = sum(result['curtailed_wind'])
+        actual_curtail_solar = sum(result['curtailed_solar'])
+        
+        print(f"\n优化结果:")
+        print(f"  储能容量需求: {result['required_storage_capacity']:.2f} MWh")
+        print(f"  实际上网电量: {actual_grid_feed_in:.2f} MWh")
+        print(f"  实际弃风量: {actual_curtail_wind:.2f} MWh")
+        print(f"  实际弃光量: {actual_curtail_solar:.2f} MWh")
+        print(f"  实际弃风率: {actual_curtail_wind/sum(wind_output):.3f}")
+        print(f"  实际弃光率: {actual_curtail_solar/sum(solar_output):.3f}")
+        
+        # 验证约束条件
+        total_generation = sum(solar_output) + sum(wind_output) + sum(thermal_output)
+        total_load = sum(load_demand)
+        total_surplus = total_generation - total_load
+        
+        expected_max_curtail_wind = sum(wind_output) * params.max_curtailment_wind
+        expected_max_curtail_solar = sum(solar_output) * params.max_curtailment_solar
+        
+        print(f"\n约束验证:")
+        print(f"  总盈余电力: {total_surplus:.2f} MWh")
+        print(f"  弃风限制: {actual_curtail_wind:.2f} <= {expected_max_curtail_wind:.2f} {'OK' if actual_curtail_wind <= expected_max_curtail_wind else 'NG'}")
+        print(f"  弃光限制: {actual_curtail_solar:.2f} <= {expected_max_curtail_solar:.2f} {'OK' if actual_curtail_solar <= expected_max_curtail_solar else 'NG'}")
+        print(f"  储能限制: {result['required_storage_capacity']:.2f} MWh (限制: {params.max_storage_capacity} MWh)")
+        
+        # 能量平衡验证
+        energy_used = actual_grid_feed_in + actual_curtail_wind + actual_curtail_solar + total_load
+        energy_balance = abs(total_generation - energy_used)
+        
+        print(f"\n能量平衡验证:")
+        print(f"  总发电量: {total_generation:.2f} MWh")
+        print(f"  能量使用: {energy_used:.2f} MWh")
+        print(f"  平衡误差: {energy_balance:.2f} MWh {'OK' if energy_balance < 0.1 else 'NG'}")
+        
+        # 综合评估
+        constraints_ok = (actual_curtail_wind <= expected_max_curtail_wind + 0.1 and
+                        actual_curtail_solar <= expected_max_curtail_solar + 0.1 and
+                        energy_balance < 0.1)
+        
+        if constraints_ok:
+            print(f"\n[OK] 测试通过:")
+            print(f"  [OK] 约束条件正确执行")
+            print(f"  [OK] 能量平衡正确")
+            print(f"  [OK] 系统在有盈余时正确处理")
+        else:
+            print(f"\n[WARNING] 测试部分通过，需要检查约束条件")
+            
+    except Exception as e:
+        print(f"\n[ERROR] 测试失败: {str(e)}")
+        import traceback
+        traceback.print_exc()
+    
+    print("\n=== 测试完成 ===")
+
+if __name__ == "__main__":
+    test_zero_grid_simple()

tests/test_zero_parameters.py

@@ -0,0 +1,101 @@
+# -*- coding: utf-8 -*-
+"""
+测试Excel中参数为0时的行为
+
+验证当Excel中的火电可用发电量为0时，系统使用0而不是默认值
+"""
+
+import sys
+import os
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+import pandas as pd
+from excel_reader import create_excel_template, read_excel_data, read_system_parameters
+from storage_optimization import optimize_storage_capacity, SystemParameters
+
+def test_zero_parameters():
+    """测试参数为0时的行为"""
+    print("=== 测试Excel中参数为0时的行为 ===")
+    
+    # 创建一个测试Excel文件，其中火电可用发电量为0
+    test_file = "test_zero_parameters.xlsx"
+    
+    # 创建基本模板
+    create_excel_template(test_file, "24")
+    
+    # 修改参数工作表，将火电可用发电量设为0
+    df_params = pd.read_excel(test_file, sheet_name='参数')
+    
+    # 找到火电可用发电量行并修改为0
+    for idx, row in df_params.iterrows():
+        if row['参数名称'] == '火电可用发电量':
+            df_params.at[idx, '参数值'] = 0.0
+            break
+    
+    # 保存修改后的Excel文件
+    with pd.ExcelWriter(test_file, mode='a', engine='openpyxl', if_sheet_exists='replace') as writer:
+        df_params.to_excel(writer, sheet_name='参数', index=False)
+    
+    print(f"创建测试Excel文件: {test_file}")
+    print("将火电可用发电量设置为0")
+    
+    # 读取参数
+    print("\n读取系统参数:")
+    try:
+        params = read_system_parameters(test_file)
+        print(f"  火电可用发电量: {params.available_thermal_energy} MWh")
+        print(f"  光伏可用发电量: {params.available_solar_energy} MWh")
+        print(f"  风电可用发电量: {params.available_wind_energy} MWh")
+        
+        # 验证火电可用发电量是否为0
+        if params.available_thermal_energy == 0.0:
+            print("  [OK] 火电可用发电量正确设置为0")
+        else:
+            print(f"  [ERROR] 火电可用发电量应该为0，但实际为{params.available_thermal_energy}")
+        
+    except Exception as e:
+        print(f"  [ERROR] 读取参数失败: {str(e)}")
+        return
+    
+    # 测试系统运行
+    print("\n测试系统运行:")
+    try:
+        data = read_excel_data(test_file, include_parameters=True)
+        solar_output = data['solar_output']
+        wind_output = data['wind_output']
+        thermal_output = data['thermal_output']
+        load_demand = data['load_demand']
+        
+        # 运行优化
+        result = optimize_storage_capacity(
+            solar_output, wind_output, thermal_output, load_demand, params
+        )
+        
+        print(f"  所需储能容量: {result['required_storage_capacity']:.2f} MWh")
+        print(f"  上网电量: {sum(x for x in result['grid_feed_in'] if x > 0):.2f} MWh")
+        print(f"  弃风量: {sum(result['curtailed_wind']):.2f} MWh")
+        print(f"  弃光量: {sum(result['curtailed_solar']):.2f} MWh")
+        
+        # 验证上网上限计算（不应包含火电）
+        total_available_energy = params.available_solar_energy + params.available_wind_energy
+        expected_max_grid_feed_in = total_available_energy * params.max_grid_ratio
+        actual_grid_feed_in = sum(x for x in result['grid_feed_in'] if x > 0)
+        
+        print(f"\n上网电量验证:")
+        print(f"  可用发电量（不计火电）: {total_available_energy:.2f} MWh")
+        print(f"  最大上网比例: {params.max_grid_ratio}")
+        print(f"  期望上网电量上限: {expected_max_grid_feed_in:.2f} MWh")
+        print(f"  实际上网电量: {actual_grid_feed_in:.2f} MWh")
+        
+        if abs(actual_grid_feed_in - expected_max_grid_feed_in) < 1.0:  # 允许1MW误差
+            print("  [OK] 上网电量计算正确（不计火电）")
+        else:
+            print("  [WARNING] 上网电量计算可能有误")
+            
+    except Exception as e:
+        print(f"  [ERROR] 系统运行失败: {str(e)}")
+    
+    print("\n=== 测试完成 ===")
+
+if __name__ == "__main__":
+    test_zero_parameters()