液体火箭发动机试验仿真系统流程图
液体火箭发动机仿真系统核心模块源代码框架
以下是一个简化的液体火箭发动机系统级仿真框架示例，使用Python编写，展示核心建模思想：
python
"""
液体火箭发动机系统级仿真框架
模拟燃气发生器循环液氧/煤油发动机
包含：推进剂供应系统、涡轮泵、燃烧室、喷管
"""
import numpy as np
from scipy.integrate import solve_ivp
from dataclasses import dataclass
from typing import Callable, Dict, List
import matplotlib.pyplot as plt
# ========== 1. 数据类型与常量定义 ==========
@dataclass
class EngineState:
"""发动机状态变量"""
time: float = 0.0
# 压力 (Pa)
P_comb: float = 101325.0 # 燃烧室压力
P_gg: float = 101325.0 # 燃气发生器压力
P_f: float = 0.0 # 燃料泵出口压力
P_ox: float = 0.0 # 氧泵出口压力
# 流量 (kg/s)
m_dot_f: float = 0.0 # 燃料总流量
m_dot_ox: float = 0.0 # 氧化剂总流量
m_dot_gg_f: float = 0.0 # 燃气发生器燃料流量
m_dot_gg_ox: float = 0.0 # 燃气发生器氧化剂流量
# 转速 (rad/s)
N_turbopump: float = 0.0 # 涡轮泵转速
# 控制输入
throttle: float = 1.0 # 节流阀开度 (0-1)
@dataclass
class EngineParams:
"""发动机固定参数"""
# 推进剂特性
gamma: float = 1.2 # 比热比
R: float = 320.0 # 气体常数 J/(kg·K)
# 涡轮泵特性
I_tp: float = 10.0 # 涡轮泵转动惯量 kg·m²
eta_pump_f: float = 0.75 # 燃料泵效率
eta_pump_ox: float = 0.75 # 氧泵效率
eta_turb: float = 0.85 # 涡轮效率
# 容积 (m³)
V_comb: float = 0.5 # 燃烧室容积
V_gg: float = 0.01 # 燃气发生器容积
# 喷管
A_throat: float = 0.1 # 喉部面积 m²
eps: float = 30.0 # 面积比
# 控制参数
K_valve: float = 0.05 # 阀门流量系数
# ========== 2. 核心物理模型 ==========
class ComponentModels:
"""部件物理模型"""
@staticmethod
def injector_flow(P_in: float, P_out: float, K: float, rho: float) -> float:
"""喷注器流量计算 (简化孔板模型)"""
if P_in <= P_out:
return 0.0
return K * np.sqrt(2 * rho * (P_in - P_out))
@staticmethod
def combustion_temp(O_F: float) -> float:
"""绝热燃烧温度估算 (简化)"""
T0 = 3500.0 # 基准温度 K
return T0 * (1.0 - 0.05 * abs(O_F - 2.6))
@staticmethod
def thrust(Pc: float, At: float, eps: float, Pa: float = 101325.0) -> float:
"""推力计算"""
# 简化推力公式: F = m_dot * Ve + (Pe - Pa) * Ae
Cf = np.sqrt(2 * gamma**2 / (gamma - 1) *
(2/(gamma+1))**((gamma+1)/(gamma-1)) *
(1 - (Pe/Pc)**((gamma-1)/gamma)))
return Cf * Pc * At
# ========== 3. 发动机系统模型 ==========
class LiquidEngineModel:
"""液体火箭发动机系统模型"""
def __init__(self, params: EngineParams):
self.params = params
self.state = EngineState()
self.history = []
def derivatives(self, t: float, y: np.ndarray, controls: Dict) -> np.ndarray:
"""
系统状态微分方程
y = [P_comb, P_gg, N_turbopump, m_dot_f, m_dot_ox, ...]
"""
# 解包状态变量
P_comb, P_gg, N = y[0], y[1], y[2]
# 获取控制输入
throttle = controls.get('throttle', 1.0)
# 1. 计算涡轮泵功率平衡
# 泵功率需求
W_pump_f = self._pump_power(P_comb, self.state.m_dot_f, rho_f=800)
W_pump_ox = self._pump_power(P_comb, self.state.m_dot_ox, rho_ox=1140)
# 涡轮功率产生
W_turb = self._turbine_power(P_gg, N)
# 涡轮泵转速微分: I * dN/dt = (W_turb - W_pump_f - W_pump_ox) / N
dN_dt = (W_turb - W_pump_f - W_pump_ox) / (self.params.I_tp * N + 1e-6)
# 2. 燃烧室压力微分
# 质量守恒: dP/dt = (R*T/V) * (Σm_dot_in - m_dot_out)
m_dot_in_comb = self.state.m_dot_f + self.state.m_dot_ox
m_dot_out_comb = self._nozzle_mass_flow(P_comb)
T_comb = ComponentModels.combustion_temp(
self.state.m_dot_ox / (self.state.m_dot_f + 1e-6)
)
dP_comb_dt = (self.params.R * T_comb / self.params.V_comb) * \
(m_dot_in_comb - m_dot_out_comb)
# 3. 燃气发生器压力微分
m_dot_in_gg = self.state.m_dot_gg_f + self.state.m_dot_gg_ox
m_dot_out_gg = self._gg_mass_flow(P_gg)
dP_gg_dt = (self.params.R * 1000 / self.params.V_gg) * \
(m_dot_in_gg - m_dot_out_gg)
# 4. 阀门流量动态 (一阶惯性)
tau_valve = 0.01 # 阀门时间常数
# 目标流量基于节流阀指令
m_dot_f_target = throttle * 50.0 # kg/s, 示例值
m_dot_ox_target = m_dot_f_target * 2.6 # 混合比2.6
dm_dot_f_dt = (m_dot_f_target - self.state.m_dot_f) / tau_valve
dm_dot_ox_dt = (m_dot_ox_target - self.state.m_dot_ox) / tau_valve
# 燃气发生器流量分配 (固定比例)
frac_to_gg = 0.03
dm_dot_gg_f_dt = (m_dot_f_target * frac_to_gg - self.state.m_dot_gg_f) / tau_valve
dm_dot_gg_ox_dt = (m_dot_ox_target * frac_to_gg - self.state.m_dot_gg_ox) / tau_valve
return np.array([
dP_comb_dt, dP_gg_dt, dN_dt,
dm_dot_f_dt, dm_dot_ox_dt,
dm_dot_gg_f_dt, dm_dot_gg_ox_dt
])
def _pump_power(self, P_out: float, m_dot: float, rho: float) -> float:
"""计算泵功率"""
if m_dot <= 0:
return 0.0
# 简化计算，忽略入口压力
delta_P = P_out - 2e5 # 假设入口压力0.2MPa
return m_dot * delta_P / (rho * self.params.eta_pump_f)
def _turbine_power(self, P_gg: float, N: float) -> float:
"""计算涡轮功率"""
# 简化涡轮模型
m_dot_turb = self.state.m_dot_gg_f + self.state.m_dot_gg_ox
if m_dot_turb <= 0:
return 0.0
# 等熵膨胀功率
T_gg = 800.0 # 燃气发生器温度 K
eta = self.params.eta_turb * (1.0 - 0.1 * (N / 3000)**2) # 转速影响
return m_dot_turb * self.params.R * T_gg * eta
def _nozzle_mass_flow(self, Pc: float) -> float:
"""喷管质量流量"""
if Pc <= 101325:
return 0.0
# 一维等熵流
gamma = self.params.gamma
R = self.params.R
T = 3500.0 # 假设燃烧温度
term = (2/(gamma+1))**((gamma+1)/(2*(gamma-1)))
return (Pc * self.params.A_throat / np.sqrt(R*T)) * \
np.sqrt(gamma) * term
def _gg_mass_flow(self, P_gg: float) -> float:
"""燃气发生器流量"""
return ComponentModels.injector_flow(
P_gg, 101325, 0.02, 0.5
)
def simulate(self, t_end: float, dt: float, control_seq: List[Dict]):
"""执行仿真"""
n_steps = int(t_end / dt)
t = 0.0
# 初始化状态向量
y = np.array([
self.state.P_comb,
self.state.P_gg,
self.state.N_turbopump,
self.state.m_dot_f,
self.state.m_dot_ox,
self.state.m_dot_gg_f,
self.state.m_dot_gg_ox
])
for i in range(n_steps):
# 获取当前时间步的控制指令
control_idx = min(int(t * len(control_seq) / t_end), len(control_seq)-1)
controls = control_seq[control_idx]
# 计算导数
dydt = self.derivatives(t, y, controls)
# 前向欧拉积分 (实际应用应用更高级方法)
y = y + dydt * dt
t += dt
# 更新状态并记录历史
self.state.time = t
self.state.P_comb = y[0]
self.state.P_gg = y[1]
self.state.N_turbopump = y[2]
# ... 更新其他状态
self.history.append({
'time': t,
'P_comb': y[0],
'N': y[2],
'm_dot_f': y[3],
'm_dot_ox': y[4],
'throttle': controls.get('throttle', 1.0)
})
def calculate_performance(self) -> Dict:
"""计算性能指标"""
if not self.history:
return {}
# 提取稳态数据 (最后20%的时间)
hist_array = np.array([list(h.values()) for h in self.history])
steady_start = int(0.8 * len(hist_array))
steady_state = hist_array[steady_start:, 1:] # 跳过时间列
avg_values = np.mean(steady_state, axis=0)
# 计算推力 (简化)
Pc_avg = avg_values[0] # P_comb
thrust = ComponentModels.thrust(
Pc_avg,
self.params.A_throat,
self.params.eps
)
# 计算比冲
m_dot_total = avg_values[2] + avg_values[3] # m_dot_f + m_dot_ox
Isp = thrust / (m_dot_total * 9.80665)
return {
'thrust_avg_N': thrust,
'Isp_avg_s': Isp,
'Pc_avg_Pa': avg_values[0],
'N_avg_rpm': avg_values[1] * 9.5493, # rad/s to rpm
'O_F_ratio': avg_values[3] / (avg_values[2] + 1e-6)
}
# ========== 4. 仿真控制器 ==========
class SimulationController:
"""仿真流程控制器"""
def __init__(self, model: LiquidEngineModel):
self.model = model
self.results = {}
def run_steady_state(self, throttle: float = 1.0) -> Dict:
"""运行稳态仿真"""
print(f"运行稳态仿真，节流阀开度: {throttle*100}%")
# 控制序列：前0.5s开启，之后保持
control_seq = [
{'throttle': 0.0} for _ in range(50) # 前0.5s关闭
]
control_seq.extend([
{'throttle': throttle} for _ in range(150) # 之后保持
])
self.model.simulate(t_end=2.0, dt=0.01, control_seq=control_seq)
performance = self.model.calculate_performance()
self.results['steady'] = {
'history': self.model.history.copy(),
'performance': performance
}
return performance
def run_transient(self, throttle_profile: List[float]) -> Dict:
"""运行瞬态仿真（节流）"""
print("运行瞬态仿真（节流测试）")
control_seq = []
for t, throttle in enumerate(throttle_profile):
control_seq.append({'throttle': throttle})
self.model = LiquidEngineModel(self.model.params) # 重置模型
self.model.simulate(
t_end=len(throttle_profile)*0.01,
dt=0.01,
control_seq=control_seq
)
self.results['transient'] = {
'history': self.model.history.copy(),
'throttle_profile': throttle_profile
}
return {'status': 'completed'}
def run_fault_scenario(self, fault_type: str, t_fault: float) -> Dict:
"""运行故障场景仿真"""
print(f"运行故障仿真: {fault_type} at t={t_fault}s")
# 正常控制序列
control_seq = [{'throttle': 1.0} for _ in range(200)] # 2秒
# 注入故障
if fault_type == 'valve_stuck':
# 模拟阀门卡滞在50%
for i in range(int(t_fault/0.01), len(control_seq)):
control_seq[i]['throttle'] = 0.5
control_seq[i]['fault'] = 'valve_stuck'
elif fault_type == 'pump_degrade':
# 模拟泵性能下降
for i in range(int(t_fault/0.01), len(control_seq)):
control_seq[i]['pump_efficiency'] = 0.5 # 效率降至50%
self.model = LiquidEngineModel(self.model.params)
self.model.simulate(t_end=2.0, dt=0.01, control_seq=control_seq)
return {
'fault_type': fault_type,
'history': self.model.history,
'performance': self.model.calculate_performance()
}
# ========== 5. 结果可视化与分析 ==========
class ResultVisualizer:
"""结果可视化"""
@staticmethod
def plot_steady_state(results: Dict, save_path: str = None):
"""绘制稳态仿真结果"""
history = results['history']
perf = results['performance']
fig, axes = plt.subplots(3, 2, figsize=(12, 10))
fig.suptitle('液体火箭发动机稳态仿真结果', fontsize=14)
# 提取数据
times = [h['time'] for h in history]
P_comb = [h['P_comb']/1e6 for h in history] # MPa
N = [h['N']/1000 for h in history] # krpm
m_dot_f = [h['m_dot_f'] for h in history]
m_dot_ox = [h['m_dot_ox'] for h in history]
throttle = [h['throttle']*100 for h in history] # %
# 1. 燃烧室压力
ax = axes[0, 0]
ax.plot(times, P_comb, 'r-', linewidth=2)
ax.set_xlabel('时间 (s)')
ax.set_ylabel('燃烧室压力 (MPa)')
ax.grid(True, alpha=0.3)
ax.set_title('燃烧室压力变化')
# 2. 涡轮泵转速
ax = axes[0, 1]
ax.plot(times, N, 'b-', linewidth=2)
ax.set_xlabel('时间 (s)')
ax.set_ylabel('转速 (krpm)')
ax.grid(True, alpha=0.3)
ax.set_title('涡轮泵转速')
# 3. 推进剂流量
ax = axes[1, 0]
ax.plot(times, m_dot_f, 'g-', label='燃料', linewidth=2)
ax.plot(times, m_dot_ox, 'b-', label='氧化剂', linewidth=2)
ax.set_xlabel('时间 (s)')
ax.set_ylabel('流量 (kg/s)')
ax.legend()
ax.grid(True, alpha=0.3)
ax.set_title('推进剂流量')
# 4. 混合比
O_F = [ox/(fuel+1e-6) for ox, fuel in zip(m_dot_ox, m_dot_f)]
ax = axes[1, 1]
ax.plot(times, O_F, 'purple-', linewidth=2)
ax.axhline(y=2.6, color='r', linestyle='--', alpha=0.5, label='设计值')
ax.set_xlabel('时间 (s)')
ax.set_ylabel('O/F 混合比')
ax.legend()
ax.grid(True, alpha=0.3)
ax.set_title('混合比变化')
# 5. 节流阀指令
ax = axes[2, 0]
ax.plot(times, throttle, 'k-', linewidth=2)
ax.set_xlabel('时间 (s)')
ax.set_ylabel('节流阀开度 (%)')
ax.grid(True, alpha=0.3)
ax.set_title('控制输入')
# 6. 性能指标表格
ax = axes[2, 1]
ax.axis('off')
perf_text = (
f"平均推力: {perf.get('thrust_avg_N', 0)/1000:.1f} kN\n"
f"平均比冲: {perf.get('Isp_avg_s', 0):.0f} s\n"
f"平均室压: {perf.get('Pc_avg_Pa', 0)/1e6:.2f} MPa\n"
f"平均转速: {perf.get('N_avg_rpm', 0):.0f} rpm\n"
f"平均混合比: {perf.get('O_F_ratio', 0):.2f}"
)
ax.text(0.1, 0.5, perf_text, fontsize=10,
verticalalignment='center',
bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.5))
ax.set_title('性能汇总')
plt.tight_layout()
if save_path:
plt.savefig(save_path, dpi=300, bbox_inches='tight')
plt.show()
@staticmethod
def plot_transient_response(results: Dict):
"""绘制瞬态响应"""
history = results['history']
profile = results.get('throttle_profile', [])
fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(10, 8))
times = [h['time'] for h in history]
P_comb = [h['P_comb']/1e6 for h in history]
throttle = [h['throttle']*100 for h in history]
# 压力和节流阀
ax1.plot(times, P_comb, 'r-', label='燃烧室压力', linewidth=2)
ax1.set_xlabel('时间 (s)')
ax1.set_ylabel('压力 (MPa)', color='r')
ax1.tick_params(axis='y', labelcolor='r')
ax1.grid(True, alpha=0.3)
ax1_twin = ax1.twinx()
ax1_twin.plot(times, throttle, 'b--', label='节流阀指令', linewidth=1.5)
ax1_twin.set_ylabel('节流阀开度 (%)', color='b')
ax1_twin.tick_params(axis='y', labelcolor='b')
lines1, labels1 = ax1.get_legend_handles_labels()
lines2, labels2 = ax1_twin.get_legend_handles_labels()
ax1.legend(lines1 + lines2, labels1 + labels2, loc='upper right')
ax1.set_title('瞬态响应 - 节流过程')
# 流量响应
m_dot_f = [h['m_dot_f'] for h in history]
m_dot_ox = [h['m_dot_ox'] for h in history]
ax2.plot(times, m_dot_f, 'g-', label='燃料流量', linewidth=2)
ax2.plot(times, m_dot_ox, 'b-', label='氧化剂流量', linewidth=2)
ax2.set_xlabel('时间 (s)')
ax2.set_ylabel('流量 (kg/s)')
ax2.legend()
ax2.grid(True, alpha=0.3)
ax2.set_title('推进剂流量响应')
plt.tight_layout()
plt.show()
# ========== 6. 主程序示例 ==========
def main():
"""主程序示例"""
print("="*60)
print("液体火箭发动机仿真系统 v1.0")
print("="*60)
# 1. 初始化发动机参数
params = EngineParams(
V_comb=0.8,
A_throat=0.12,
I_tp=15.0
)
# 2. 创建发动机模型
engine = LiquidEngineModel(params)
# 3. 创建仿真控制器
simulator = SimulationController(engine)
# 4. 运行稳态仿真
print("\n>>> 运行100%工况稳态仿真...")
perf_100 = simulator.run_steady_state(throttle=1.0)
print("\n>>> 运行80%工况稳态仿真...")
perf_80 = simulator.run_steady_state(throttle=0.8)
# 5. 运行瞬态仿真
print("\n>>> 运行节流瞬态仿真...")
# 创建节流剖面：1.0 -> 0.7 -> 0.9 -> 1.0
throttle_profile = [1.0]*50 + [0.7]*50 + [0.9]*50 + [1.0]*50
simulator.run_transient(throttle_profile)
# 6. 运行故障仿真
print("\n>>> 运行阀门卡滞故障仿真...")
fault_result = simulator.run_fault_scenario('valve_stuck', t_fault=1.0)
# 7. 可视化结果
print("\n>>> 生成可视化图表...")
visualizer = ResultVisualizer()
# 绘制稳态结果
visualizer.plot_steady_state(
simulator.results['steady'],
save_path='engine_steady_state.png'
)
# 绘制瞬态结果
visualizer.plot_transient_response(
simulator.results['transient']
)
# 8. 性能对比
print("\n" + "="*60)
print("性能对比总结:")
print("="*60)
print(f"{'工况':<10} {'推力(kN)':<12} {'比冲(s)':<10} {'室压(MPa)':<12} {'O/F':<8}")
print("-"*60)
print(f"{'100%':<10} {perf_100['thrust_avg_N']/1000:<12.1f} "
f"{perf_100['Isp_avg_s']:<10.0f} "
f"{perf_100['Pc_avg_Pa']/1e6:<12.2f} "
f"{perf_100['O_F_ratio']:<8.2f}")
print(f"{'80%':<10} {perf_80['thrust_avg_N']/1000:<12.1f} "
f"{perf_80['Isp_avg_s']:<10.0f} "
f"{perf_80['Pc_avg_Pa']/1e6:<12.2f} "
f"{perf_80['O_F_ratio']:<8.2f}")
# 9. 生成仿真报告
report = generate_simulation_report(simulator.results)
print(f"\n>>> 仿真完成！详细报告已保存至: {report}")
def generate_simulation_report(results: Dict, filename: str = "simulation_report.txt") -> str:
"""生成仿真报告"""
with open(filename, 'w') as f:
f.write("液体火箭发动机仿真报告\n")
f.write("="*50 + "\n\n")
f.write("1. 仿真配置\n")
f.write("-"*30 + "\n")
f.write(f"仿真时间: {len(results['steady']['history'])*0.01:.1f} s\n")
f.write(f"时间步长: 0.01 s\n")
f.write(f"数据点数: {len(results['steady']['history'])}\n\n")
f.write("2. 稳态性能\n")
f.write("-"*30 + "\n")
perf = results['steady']['performance']
for key, value in perf.items():
f.write(f"{key}: {value}\n")
f.write("\n3. 故障仿真结果\n")
f.write("-"*30 + "\n")
if 'fault_result' in results:
f.write(f"故障类型: {results.get('fault_type', 'N/A')}\n")
fault_perf = results.get('fault_performance', {})
for key, value in fault_perf.items():
f.write(f"{key}: {value}\n")
return filename
# ========== 7. 扩展模块示例 ==========
class AdvancedModels:
"""高级模型组件示例"""
@staticmethod
def combustion_instability_model(Pc: float, history: List[float],
freq: float = 1000.0) -> float:
"""简化的燃烧不稳定模型 (亥姆霍兹谐振器模型)"""
if len(history) < 10:
return 0.0
# 简单的延迟耦合模型
tau = 0.005 # 延迟时间
n_delay = int(tau / 0.01) # 假设时间步0.01s
if len(history) > n_delay:
P_delay = history[-n_delay]
# 压力振荡项
oscillation = 0.01 * Pc * np.sin(2*np.pi*freq*len(history)*0.01)
# 与历史压力耦合
coupling = 0.001 * (Pc - P_delay)
return oscillation + coupling
return 0.0
@staticmethod
def regen_cooling_model(q_heat: float, m_dot_coolant: float,
T_wall: float, geometry: Dict) -> float:
"""再生冷却简化模型"""
# 对流传热系数 (简化)
h = 5000.0 # W/(m²·K)
A = geometry.get('area', 1.0)
delta_T = 100.0 # 假设温升
# 冷却剂温升
Cp = 2000.0 # J/(kg·K) 煤油比热
delta_T_coolant = q_heat / (m_dot_coolant * Cp + 1e-6)
# 壁面热流
q_wall = h * A * delta_T
return {
'delta_T_coolant': delta_T_coolant,
'q_wall': q_wall,
'T_wall_new': T_wall + delta_T
}
# ========== 运行主程序 ==========
if __name__ == "__main__":
# 检查必要的库
try:
import numpy as np
import matplotlib.pyplot as plt
from scipy.integrate import solve_ivp
main()
except ImportError as e:
print(f"缺少依赖库: {e}")
print("请安装: pip install numpy matplotlib scipy")系统使用说明
核心功能模块
-
发动机模型 (
LiquidEngineModel)- 基于集中参数法的系统级动态模型
- 包含涡轮泵、燃烧室、燃气发生器等组件耦合
- 支持启动、稳态、关机、节流等瞬态过程
-
仿真控制器 (
SimulationController)- 管理仿真流程
- 支持稳态、瞬态、故障等多种仿真模式
- 控制序列生成与注入
-
可视化分析 (
ResultVisualizer)- 多参数并行可视化
- 性能指标计算与显示
- 支持结果导出
-
高级模型 (
AdvancedModels)- 燃烧不稳定模型
- 再生冷却模型
- 可扩展的专用模型接口
仿真流程
ini
# 基本使用示例
params = EngineParams() # 1. 设置参数
engine = LiquidEngineModel(params) # 2. 创建模型
simulator = SimulationController(engine) # 3. 创建控制器
# 4. 运行仿真
results = simulator.run_steady_state(throttle=1.0)
results = simulator.run_transient(throttle_profile)
# 5. 可视化
visualizer.plot_steady_state(results)扩展与定制
-
添加新组件
rubyclass NewComponent: def __init__(self, params): self.params = params def calculate(self, state): # 实现组件物理模型 return output -
修改控制逻辑
- 在
control_seq中定义控制指令序列 - 实现自定义的控制算法
- 在
-
集成高保真模型
- 可将CFD/FEA结果作为查找表集成
- 通过回调函数接口调用外部求解器
注意事项
-
此代码为教学演示框架，实际工程应用需要：
- 更精确的物理模型和物性参数
- 更稳健的数值积分方法
- 更完整的故障模式和边界条件
- 与专业工具（MATLAB/Simulink, Amesim等）的接口
-
关键参数（如效率系数、时间常数等）需通过试验数据标定
-
建议采用模块化开发，便于团队协作和模型维护
此仿真系统框架提供了液体火箭发动机数字孪生的基础架构，可根据具体型号需求进行深度定制和扩展。实际工程应用中，建议采用专业的仿真平台（如Modelica, Dymola）或商业软件进行详细实现。