如何终止solve_ivp求解ODE时的无限运行状态

方案1：用事件函数设置时间/步数终止条件 #

solve_ivp支持自定义事件，当事件触发时会立即终止积分。可以用这个机制监控运行时间或累计步数：

按运行时间终止 #

import time
from scipy.integrate import solve_ivp

start_time = None

def time_stop_event(t, y):
    elapsed = time.time() - start_time
    # 设定最大运行时间为300秒，差值为0时触发终止
    return elapsed - 300
time_stop_event.terminal = True  # 触发时终止积分
time_stop_event.direction = 0   # 不关心正负方向

# 替换成你的ODE系统
def ode_system(t, y):
    return ...

start_time = time.time()
sol = solve_ivp(ode_system, [0, 100], y0, method='BDF', events=[time_stop_event])

按累计步数终止 #

step_count = 0

def step_stop_event(t, y):
    global step_count
    step_count += 1
    # 设定最大步数为10000，达到时触发终止
    return step_count - 10000
step_stop_event.terminal = True
step_stop_event.direction = 0

sol = solve_ivp(ode_system, [0, 100], y0, method='BDF', events=[step_stop_event])

方案2：通过回调函数终止积分 #

solve_ivp的callback参数会在每个成功步后执行，返回True即可直接终止求解：

时间限制回调 #

import time

start_time = time.time()
max_runtime = 300  # 最大运行时间300秒

def runtime_callback(t, y):
    elapsed = time.time() - start_time
    if elapsed >= max_runtime:
        print(f"已达最大运行时间{max_runtime}秒，终止积分")
        return True
    return False

sol = solve_ivp(ode_system, [0, 100], y0, method='BDF', callback=runtime_callback)

步数限制回调 #

step_count = 0
max_steps = 10000

def step_callback(t, y):
    global step_count
    step_count += 1
    if step_count >= max_steps:
        print(f"已达最大步数{max_steps}，终止积分")
        return True
    return False

sol = solve_ivp(ode_system, [0, 100], y0, method='BDF', callback=step_callback)

方案3：限制最小步长，触发异常后终止 #

给BDF求解器设置min_step阈值，当求解器尝试使用小于该值的步长时，会抛出RuntimeError，捕获异常即可终止：

try:
    # 设定最小步长为1e-6，可根据需求调整
    sol = solve_ivp(ode_system, [0, 100], y0, method='BDF', options={'min_step': 1e-6})
except RuntimeError as e:
    print(f"步长过小触发异常，终止积分：{e}")
    # 可在此处理已生成的部分解

方案4：切换到scipy.ode类手动控制积分 #

旧的scipy.integrate.odeAPI提供更细粒度的控制，可以循环执行单步积分，随时检查终止条件：

import numpy as np
from scipy.integrate import ode
import time

# 替换成你的ODE系统
def ode_system(t, y):
    return ...

solver = ode(ode_system).set_integrator('vode', method='bdf')
solver.set_initial_value(y0, 0)

t_end = 100
max_runtime = 300
max_steps = 10000
start_time = time.time()
step_count = 0

# 存储结果
t_list = [0]
y_list = [y0.copy()]

while solver.successful() and solver.t < t_end:
    # 执行单步积分
    solver.integrate(t_end, step=True)
    step_count += 1
    t_list.append(solver.t)
    y_list.append(solver.y.copy())
    
    # 检查运行时间
    elapsed = time.time() - start_time
    if elapsed >= max_runtime:
        print("达到最大运行时间，终止")
        break
    # 检查步数
    if step_count >= max_steps:
        print("达到最大步数，终止")
        break

# 整理结果
sol_t = np.array(t_list)
sol_y = np.array(y_list)

内容的提问来源于stack exchange，提问作者Zihao Wang