以下是蒙特卡洛仿真与敏感性分析模块的完整使用示例涵盖从不确定性定义到结果可视化的全过程。一、完整蒙特卡洛分析示例import numpy as np import matplotlib.pyplot as plt import pandas as pd from datetime import datetime import seaborn as sns from scipy import stats import warnings warnings.filterwarnings(ignore) # 设置中文字体和图形样式 plt.rcParams[font.sans-serif] [SimHei, DejaVu Sans] plt.rcParams[axes.unicode_minus] False sns.set_style(whitegrid) sns.set_palette(husl) # 1. 创建基准火箭 from rocketpy import Rocket, Motor, NoseCone, TrapezoidalFins, Environment, Flight from rocketpy.uncertainty import NormalDistribution, UniformDistribution, LognormalDistribution, TriangularDistribution from rocketpy.monte_carlo import MonteCarloSimulation, LatinHypercubeSampling, SobolSensitivityAnalysis, MorrisSensitivityAnalysis def create_calisto_rocket(mass14.426, thrust_scale1.0, cd_power_off0.5, cd_power_on0.5): 创建 Calisto 火箭 # 火箭主体 calisto Rocket( radius0.0635, massmass, # 使用参数化的质量 inertia(6.321, 6.321, 0.034), power_off_dragcd_power_off, # 使用参数化的阻力系数 power_on_dragcd_power_on, center_of_mass_without_motor1.5 ) # 发动机 - 调整推力曲线 thrust_data [ (0, 0), (0.1, 1000*thrust_scale), (2.9, 1000*thrust_scale), (3.0, 0) ] motor Motor( thrust_sourcethrust_data, dry_mass1.5, dry_inertia(0.1, 0.1, 0.01) ) calisto.add_motor(motor, position0) # 鼻锥 nose_cone NoseCone( length0.3, kindvon karman, base_radius0.0635 ) calisto.add_aerodynamic_surface(nose_cone, position1.7) # 鳍片 fins TrapezoidalFins( n4, root_chord0.12, tip_chord0.06, span0.06, rocket_radius0.0635 ) calisto.add_aerodynamic_surface(fins, position0.2) return calisto def create_environment(wind_speed5.0, wind_direction0.0): 创建环境条件 env Environment( latitude28.5721, # 肯尼迪航天中心 longitude-80.6480, elevation3.0 ) # 设置日期时间 env.set_date((2024, 6, 15, 12, 0, 0)) # 设置风场 env.set_atmospheric_model(typestandard_atmosphere) # 使用恒定风 env.wind_speed wind_speed env.wind_direction wind_direction return env # 2. 运行单次仿真的函数 def run_single_simulation(params): 运行单次仿真 try: # 提取参数 mass params.get(mass, 14.426) thrust_scale params.get(thrust_scale, 1.0) cd_power_off params.get(cd_power_off, 0.5) cd_power_on params.get(cd_power_on, 0.5) wind_speed params.get(wind_speed, 5.0) wind_direction params.get(wind_direction, 0.0) # 创建火箭 rocket create_calisto_rocket( massmass, thrust_scalethrust_scale, cd_power_offcd_power_off, cd_power_oncd_power_on ) # 创建环境 env create_environment( wind_speedwind_speed, wind_directionwind_direction ) # 运行飞行仿真 flight Flight( rocketrocket, environmentenv, rail_length5.0, inclination85, heading0, terminate_on_apogeeTrue ) # 计算性能指标 result { apogee: flight.apogee, max_velocity: flight.max_velocity, max_acceleration: flight.max_acceleration, impact_range: flight.x_impact, impact_velocity: flight.impact_velocity, flight_time: flight.t_final, stability_margin: 2.5 # 简化计算 } return result except Exception as e: print(f仿真失败: {e}) # 返回默认值 return { apogee: 0, max_velocity: 0, max_acceleration: 0, impact_range: 0, impact_velocity: 0, flight_time: 0, stability_margin: 0 } # 3. 定义不确定性参数 print(*60) print(火箭蒙特卡洛仿真与敏感性分析) print(*60) print(\n1. 定义不确定性参数...) # 定义不确定性分布 uncertainties { mass: NormalDistribution( namemass, mean14.426, # 标称质量 (kg) std0.5, # 标准差 (kg) truncation(13.0, 16.0) # 截断范围 ), thrust_scale: LognormalDistribution( namethrust_scale, mu0.0, # 对数均值 sigma0.03 # 3%变异系数 ), cd_power_off: UniformDistribution( namecd_power_off, low0.45, high0.55 ), cd_power_on: UniformDistribution( namecd_power_on, low0.45, high0.55 ), wind_speed: TriangularDistribution( namewind_speed, left1.0, # 最小风速 mode5.0, # 最可能风速 right10.0 # 最大风速 ), wind_direction: UniformDistribution( namewind_direction, low0, # 0度 high360 # 360度 ) } # 4. 创建蒙特卡洛分析 print(\n2. 创建蒙特卡洛分析...) # 定义采样器 sampler LatinHypercubeSampling( distributionslist(uncertainties.values()), n_samples200, # 减少样本数以加速演示 seed42 ) # 生成样本 print(生成样本...) samples sampler.generate_samples() # 转换为DataFrame sample_df pd.DataFrame( samples, columns[dist.name for dist in uncertainties.values()] ) print(f\n样本统计摘要:) print(sample_df.describe()) # 5. 运行蒙特卡洛仿真 print(\n3. 运行蒙特卡洛仿真...) print(f运行 {len(sample_df)} 次仿真...) results [] for i, row in sample_df.iterrows(): if i % 20 0: print(f进度: {i1}/{len(sample_df)}) params row.to_dict() result run_single_simulation(params) results.append(result) # 转换为DataFrame results_df pd.DataFrame(results) # 合并输入输出数据 full_df pd.concat([sample_df, results_df], axis1) print(\n仿真完成!) print(f成功运行 {len(results_df)} 次仿真) # 6. 统计分析 print(\n4. 统计分析结果...) # 计算基本统计量 stats_summary results_df.agg([mean, std, min, max, lambda x: np.percentile(x, 5), lambda x: np.percentile(x, 95)]).T stats_summary.columns [mean, std, min, max, p5, p95] stats_summary[cov] stats_summary[std] / stats_summary[mean] print(\n输出变量统计摘要:) print(stats_summary.round(2)) # 7. 可靠性分析 print(\n5. 可靠性分析...) # 定义设计要求 requirements { apogee: {min: 1500, max: 3000}, # 顶点高度范围 (m) max_velocity: {max: 300}, # 最大速度限制 (m/s) impact_velocity: {max: 8.0}, # 着陆速度限制 (m/s) stability_margin: {min: 1.5} # 最小稳定裕度 } # 计算满足要求的概率 reliability {} for metric, limits in requirements.items(): if metric in results_df.columns: if min in limits and max in limits: prob np.mean((results_df[metric] limits[min]) (results_df[metric] limits[max])) reliability[metric] { probability: prob, description: f{limits[min]} ≤ {metric} ≤ {limits[max]} } elif min in limits: prob np.mean(results_df[metric] limits[min]) reliability[metric] { probability: prob, description: f{metric} ≥ {limits[min]} } elif max in limits: prob np.mean(results_df[metric] limits[max]) reliability[metric] { probability: prob, description: f{metric} ≤ {limits[max]} } print(\n可靠性分析:) for metric, info in reliability.items(): print(f {metric}: {info[probability]*100:.1f}% ({info[description]})) # 计算整体可靠性 (所有要求同时满足) all_pass np.ones(len(results_df), dtypebool) for metric, limits in requirements.items(): if metric in results_df.columns: if min in limits and max in limits: all_pass (results_df[metric] limits[min]) (results_df[metric] limits[max]) elif min in limits: all_pass (results_df[metric] limits[min]) elif max in limits: all_pass (results_df[metric] limits[max]) overall_reliability np.mean(all_pass) print(f\n整体可靠性 (所有要求同时满足): {overall_reliability*100:.1f}%) # 8. 敏感性分析 print(\n6. 敏感性分析...) # 计算相关性矩阵 correlation_matrix full_df.corr() # 提取输入输出相关性 input_vars list(uncertainties.keys()) output_vars list(results_df.columns) # 分析对顶点高度的影响 print(\n顶点高度 (apogee) 的敏感性分析:) # 计算Pearson相关系数 correlations {} for input_var in input_vars: if input_var in full_df.columns and apogee in full_df.columns: corr np.corrcoef(full_df[input_var], full_df[apogee])[0, 1] correlations[input_var] { pearson: corr, abs_pearson: abs(corr) } # 按相关性绝对值排序 sorted_correlations sorted(correlations.items(), keylambda x: x[1][abs_pearson], reverseTrue) print(\n输入变量对顶点高度的影响 (Pearson相关系数):) for var, corr_info in sorted_correlations: sign if corr_info[pearson] 0 else - print(f {var:15s}: {corr_info[pearson]:7.3f} ({sign}相关性)) # 9. 可视化结果 print(\n7. 生成可视化图表...) # 创建图形 fig plt.figure(figsize(16, 12)) fig.suptitle(火箭蒙特卡洛仿真分析结果, fontsize16, fontweightbold) # 子图1: 顶点高度分布 ax1 plt.subplot(3, 3, 1) ax1.hist(results_df[apogee], bins30, edgecolorblack, alpha0.7, colorskyblue) ax1.axvline(xstats_summary.loc[apogee, mean], colorred, linestyle--, labelf均值: {stats_summary.loc[apogee, mean]:.0f}m) ax1.axvline(xstats_summary.loc[apogee, p5], colororange, linestyle--, alpha0.7, label5%分位) ax1.axvline(xstats_summary.loc[apogee, p95], colororange, linestyle--, alpha0.7, label95%分位) ax1.set_xlabel(顶点高度 (m)) ax1.set_ylabel(频数) ax1.set_title(顶点高度分布) ax1.legend(fontsize8) ax1.grid(True, alpha0.3) # 子图2: 最大速度分布 ax2 plt.subplot(3, 3, 2) ax2.hist(results_df[max_velocity], bins30, edgecolorblack, alpha0.7, colorlightcoral) ax2.axvline(xrequirements[max_velocity][max], colorred, linestyle-, linewidth2, labelf限制: {requirements[max_velocity][max]}m/s) ax2.set_xlabel(最大速度 (m/s)) ax2.set_ylabel(频数) ax2.set_title(最大速度分布) ax2.legend(fontsize8) ax2.grid(True, alpha0.3) # 子图3: 着陆速度分布 ax3 plt.subplot(3, 3, 3) ax3.hist(results_df[impact_velocity], bins30, edgecolorblack, alpha0.7, colorlightgreen) ax3.axvline(xrequirements[impact_velocity][max], colorred, linestyle-, linewidth2, labelf限制: {requirements[impact_velocity][max]}m/s) ax3.set_xlabel(着陆速度 (m/s)) ax3.set_ylabel(频数) ax3.set_title(着陆速度分布) ax3.legend(fontsize8) ax3.grid(True, alpha0.3) # 子图4: 质量对顶点高度的影响 ax4 plt.subplot(3, 3, 4) ax4.scatter(full_df[mass], full_df[apogee], alpha0.6, s20, colorsteelblue) ax4.set_xlabel(质量 (kg)) ax4.set_ylabel(顶点高度 (m)) ax4.set_title(质量 vs 顶点高度) ax4.grid(True, alpha0.3) # 添加趋势线 z np.polyfit(full_df[mass], full_df[apogee], 1) p np.poly1d(z) ax4.plot(np.sort(full_df[mass]), p(np.sort(full_df[mass])), r--, linewidth2, labelf斜率: {z[0]:.1f} m/kg) # 子图5: 推力系数对顶点高度的影响 ax5 plt.subplot(3, 3, 5) ax5.scatter(full_df[thrust_scale], full_df[apogee], alpha0.6, s20, colordarkorange) ax5.set_xlabel(推力系数) ax5.set_ylabel(顶点高度 (m)) ax5.set_title(推力系数 vs 顶点高度) ax5.grid(True, alpha0.3) # 添加趋势线 z np.polyfit(full_df[thrust_scale], full_df[apogee], 1) p np.poly1d(z) ax5.plot(np.sort(full_df[thrust_scale]), p(np.sort(full_df[thrust_scale])), r--, linewidth2, labelf斜率: {z[0]:.0f} m/单位) # 子图6: 风速对顶点高度的影响 ax6 plt.subplot(3, 3, 6) ax6.scatter(full_df[wind_speed], full_df[apogee], alpha0.6, s20, colorpurple) ax6.set_xlabel(风速 (m/s)) ax6.set_ylabel(顶点高度 (m)) ax6.set_title(风速 vs 顶点高度) ax6.grid(True, alpha0.3) # 添加趋势线 z np.polyfit(full_df[wind_speed], full_df[apogee], 1) p np.poly1d(z) ax6.plot(np.sort(full_df[wind_speed]), p(np.sort(full_df[wind_speed])), r--, linewidth2, labelf斜率: {z[0]:.1f} m/(m/s)) # 子图7: 相关性热图 ax7 plt.subplot(3, 3, 7) corr_subset full_df[input_vars [apogee, max_velocity, impact_velocity]].corr() sns.heatmap(corr_subset, annotTrue, fmt.2f, cmapcoolwarm, center0, squareTrue, axax7, cbar_kws{shrink: 0.8}) ax7.set_title(变量相关性热图) # 子图8: 可靠性饼图 ax8 plt.subplot(3, 3, 8) reliability_labels [] reliability_values [] for metric, info in reliability.items(): reliability_labels.append(metric) reliability_values.append(info[probability]) # 添加整体可靠性 reliability_labels.append(整体可靠性) reliability_values.append(overall_reliability) colors plt.cm.Set3(np.linspace(0, 1, len(reliability_values))) wedges, texts, autotexts ax8.pie(reliability_values, labelsreliability_labels, autopct%1.1f%%, startangle90, colorscolors) ax8.axis(equal) ax8.set_title(可靠性分析) # 设置百分比文本样式 for autotext in autotexts: autotext.set_color(black) autotext.set_fontsize(9) # 子图9: 累积分布函数 ax9 plt.subplot(3, 3, 9) for metric in [apogee, max_velocity, impact_velocity]: if metric in results_df.columns: sorted_data np.sort(results_df[metric]) cdf np.arange(1, len(sorted_data) 1) / len(sorted_data) ax9.plot(sorted_data, cdf, labelmetric, linewidth2) ax9.set_xlabel(值) ax9.set_ylabel(累积概率) ax9.set_title(累积分布函数 (CDF)) ax9.legend(fontsize8) ax9.grid(True, alpha0.3) plt.tight_layout() plt.subplots_adjust(top0.93) plt.show() # 10. 保存结果 print(\n8. 保存结果...) # 创建结果字典 results_summary { timestamp: datetime.now().strftime(%Y-%m-%d %H:%M:%S), n_simulations: len(results_df), statistics: stats_summary.to_dict(), reliability: reliability, overall_reliability: overall_reliability, sensitivities: {var: corr_info for var, corr_info in correlations.items()} } # 保存到文件 import json import pickle # 保存结果摘要 with open(monte_carlo_summary.json, w) as f: json.dump(results_summary, f, indent2, defaultstr) # 保存原始数据 full_df.to_csv(monte_carlo_data.csv, indexFalse) with open(monte_carlo_results.pkl, wb) as f: pickle.dump({full_df: full_df, results_summary: results_summary}, f) print(结果已保存到文件:) print( - monte_carlo_summary.json (结果摘要)) print( - monte_carlo_data.csv (原始数据)) print( - monte_carlo_results.pkl (完整数据)) # 11. 生成报告 print(\n *60) print(蒙特卡洛分析报告) print(*60) print(f\n分析时间: {results_summary[timestamp]}) print(f仿真次数: {results_summary[n_simulations]}) print(\n关键性能指标:) print(- * 40) for metric in [apogee, max_velocity, impact_velocity, flight_time]: if metric in stats_summary.index: mean_val stats_summary.loc[metric, mean] std_val stats_summary.loc[metric, std] p5_val stats_summary.loc[metric, p5] p95_val stats_summary.loc[metric, p95] print(f{metric:20s}: {mean_val:6.1f} ± {std_val:5.1f} [{p5_val:5.1f}, {p95_val:5.1f}]) print(f\n整体可靠性: {overall_reliability*100:.1f}%) print(\n最敏感参数 (对顶点高度):) print(- * 40) for var, corr_info in sorted_correlations[:3]: effect 增加 if corr_info[pearson] 0 else 减小 print(f{var:15s}: |r| {abs(corr_info[pearson]):.3f} ({effect}顶点高度)) print(\n设计建议:) print(- * 40) if overall_reliability 0.9: print(⚠ 可靠性低于90%建议:) # 检查哪些要求未满足 for metric, info in reliability.items(): if info[probability] 0.9: print(f - {metric} 的可靠性只有 {info[probability]*100:.1f}%) # 提供改进建议 if metric apogee and stats_summary.loc[apogee, mean] 1500: print( → 考虑增加推力或减少质量) elif metric max_velocity and stats_summary.loc[max_velocity, mean] 280: print( → 考虑增加阻力或减少推力) elif metric impact_velocity and stats_summary.loc[impact_velocity, mean] 6: print( → 考虑增大降落伞或改进回收系统) else: print(✓ 设计可靠性良好满足要求) print(\n不确定性贡献:) print(- * 40) print(主要不确定性来源:) for var, corr_info in sorted_correlations[:3]: contribution corr_info[abs_pearson]**2 * 100 print(f {var:15s}: 贡献 {contribution:.1f}% 的顶点高度方差) print(\n *60) print(分析完成!) print(*60)二、高级分析功能# 继续上面的分析添加高级功能 # 12. 高级统计分析 print(\n9. 高级统计分析...) # 拟合分布 from scipy import stats def fit_distribution(data, dist_names[norm, lognorm, weibull_min, rayleigh]): 拟合最优分布 best_dist None best_aic np.inf best_params None for dist_name in dist_names: try: dist getattr(stats, dist_name) params dist.fit(data) # 计算AIC aic 2 * len(params) - 2 * np.sum(dist.logpdf(data, *params)) if aic best_aic: best_aic aic best_dist dist_name best_params params except: continue return best_dist, best_params, best_aic # 对关键输出拟合分布 print(\n分布拟合结果:) for metric in [apogee, max_velocity, impact_velocity]: if metric in results_df.columns: data results_df[metric].values best_dist, params, aic fit_distribution(data) print(f{metric:20s}: 最优分布 {best_dist}, AIC {aic:.1f}) # 13. 失效模式分析 print(\n10. 失效模式分析...) # 识别最差的仿真 worst_indices {} for metric in [apogee, max_velocity, impact_velocity]: if metric in results_df.columns: if metric apogee: # 对于顶点高度找最低的 worst_idx results_df[metric].idxmin() else: # 对于速度和加速度找最高的 worst_idx results_df[metric].idxmax() worst_indices[metric] worst_idx print(\n最差情况分析:) for metric, idx in worst_indices.items(): value results_df.loc[idx, metric] params sample_df.loc[idx].to_dict() print(f\n{metric} 最差情况:) print(f 值: {value:.2f}) print(f 参数组合:) for param_name, param_value in params.items(): nominal uncertainties[param_name].parameters.get(mean, uncertainties[param_name].parameters.get(mode, 0)) deviation (param_value - nominal) / nominal * 100 print(f {param_name}: {param_value:.3f} ({deviation:.1f}%)) # 14. 鲁棒性分析 print(\n11. 鲁棒性分析...) # 计算性能对参数变化的敏感性 def compute_robustness(data, param_col, metric_col, bins5): 计算鲁棒性指标 # 离散化参数 param_bins pd.qcut(data[param_col], bins, labelsFalse, duplicatesdrop) # 计算每个区间的性能统计 robustness_stats data.groupby(param_bins).agg({ metric_col: [mean, std, count] }) # 计算变异系数 robustness_stats[cov] robustness_stats[(metric_col, std)] / robustness_stats[(metric_col, mean)] return robustness_stats print(\n顶点高度对质量变化的鲁棒性:) robustness_stats compute_robustness(full_df, mass, apogee) print(robustness_stats.round(2)) # 15. 优化建议 print(\n12. 设计优化建议...) # 基于敏感性分析提出优化建议 print(\n基于敏感性分析的优化建议:) # 对每个参数提出建议 for var, corr_info in sorted_correlations: if abs(corr_info[pearson]) 0.2: # 只考虑显著相关的参数 param_mean sample_df[var].mean() param_std sample_df[var].std() print(f\n参数: {var}) print(f 当前范围: {param_mean:.3f} ± {param_std:.3f}) print(f 对顶点高度的影响: r {corr_info[pearson]:.3f}) if corr_info[pearson] 0: print(f 建议: 增加{var}可以提高顶点高度) improvement corr_info[pearson] * param_std print(f 预期改善: 每增加1个标准差顶点高度增加{improvement:.1f}m) else: print(f 建议: 减小{var}可以提高顶点高度) improvement abs(corr_info[pearson]) * param_std print(f 预期改善: 每减少1个标准差顶点高度增加{improvement:.1f}m) # 16. 验证与确认 print(\n13. 验证与确认...) # 与标称设计比较 nominal_params { mass: 14.426, thrust_scale: 1.0, cd_power_off: 0.5, cd_power_on: 0.5, wind_speed: 5.0, wind_direction: 0.0 } nominal_result run_single_simulation(nominal_params) monte_carlo_mean results_df.mean() print(\n标称设计与蒙特卡洛平均对比:) for metric in [apogee, max_velocity, impact_velocity]: if metric in nominal_result and metric in monte_carlo_mean: nominal_val nominal_result[metric] mc_mean monte_carlo_mean[metric] diff_pct (mc_mean - nominal_val) / nominal_val * 100 print(f{metric:20s}: 标称{nominal_val:.1f}, 蒙特卡洛平均{mc_mean:.1f}, 差异{diff_pct:.1f}%) # 17. 生成最终报告 print(\n *60) print(最终设计评估) print(*60) # 设计评估标准 def evaluate_design(overall_reliability, stats_summary): 评估设计质量 score 0 feedback [] # 可靠性评分 if overall_reliability 0.95: score 30 feedback.append(✓ 可靠性优秀 (95%)) elif overall_reliability 0.90: score 20 feedback.append(✓ 可靠性良好 (90-95%)) elif overall_reliability 0.80: score 10 feedback.append(⚠ 可靠性一般 (80-90%)) else: score 0 feedback.append(✗ 可靠性不足 (80%)) # 性能一致性评分 (变异系数) for metric in [apogee, max_velocity]: if metric in stats_summary.index: cov stats_summary.loc[metric, cov] if cov 0.05: score 10 feedback.append(f✓ {metric}一致性优秀 (CV5%)) elif cov 0.10: score 5 feedback.append(f✓ {metric}一致性良好 (CV10%)) elif cov 0.15: score 2 feedback.append(f⚠ {metric}一致性一般 (CV15%)) else: feedback.append(f✗ {metric}一致性差 (CV15%)) # 安全余量评分 safety_margins [] for metric, limits in requirements.items(): if metric in stats_summary.index and min in limits: margin (stats_summary.loc[metric, mean] - limits[min]) / limits[min] safety_margins.append(margin) elif metric in stats_summary.index and max in limits: margin (limits[max] - stats_summary.loc[metric, mean]) / limits[max] safety_margins.append(margin) if safety_margins: avg_margin np.mean(safety_margins) if avg_margin 0.2: score 20 feedback.append(✓ 安全余量充足 (20%)) elif avg_margin 0.1: score 10 feedback.append(✓ 安全余量合适 (10-20%)) elif avg_margin 0: score 5 feedback.append(⚠ 安全余量有限 (0-10%)) else: score 0 feedback.append(✗ 安全余量不足 (0%)) # 总体评分 if score 50: rating 优秀 elif score 40: rating 良好 elif score 30: rating 合格 else: rating 需要改进 return score, rating, feedback # 执行评估 score, rating, feedback evaluate_design(overall_reliability, stats_summary) print(f\n设计评分: {score}/60) print(f评级: {rating}) print(\n评估反馈:) for item in feedback: print(f {item}) print(\n *60) print(蒙特卡洛仿真与敏感性分析完成!) print(*60)三、结果解释与建议3.1 关键发现总结基于上述蒙特卡洛分析可以得到以下关键发现性能分布特征顶点高度、最大速度等关键参数的概率分布可靠性评估设计满足所有要求的概率敏感性排名识别对性能影响最大的参数失效模式识别最可能导致性能下降的参数组合优化方向基于敏感性分析提出设计改进建议3.2 使用建议样本数量选择初步分析100-200次仿真详细分析500-1000次仿真高精度分析1000-10000次仿真采样方法选择初步探索随机采样空间填充拉丁超立方采样高维问题Sobol序列采样并行计算充分利用多核CPU加速仿真设置合理的并行工作数结果验证检查收敛性与标称设计对比验证极端情况这个完整的蒙特卡洛分析示例展示了该模块处理火箭设计不确定性方面的强大能力为工程师提供了全面的设计洞察和决策支持。