e2m2e.algorithm.transfer package

转移轨道设计。

按数学类型组织（ADR 0011 迁移，源：transfer/）：脉冲路径（lambert/ three_body_lambert/multi_impulse）、自然动力学路径（low_energy/manifold， 覆盖引力辅助数学内核）、低推力路径（low_thrust/）、任务层（search/ optimize/porkchop）。transfer_orbit.py 是编排器：接收 transfer_type （HMN/LGA/WSB/low_thrust），按枚举选路径组合底层数学模块。

已实现：HMN 霍曼转移、LGA 月球引力辅助、WSB 太阳引力辅助、小推力转移。

e2m2e.algorithm.transfer.config module

转移轨道统一配置类型定义。

把原先分散在 config.py （优化阶段）与 search_config.py （搜索阶段）的 两个 dataclass 合并为单一 TransferConfig，用 search_* / nlp_* 前缀区分子域字段，消除"两个 dataclass 描述同一件事"的碎片化。

同时保留 TransferOptimizationResult 于本模块，避免 transfer.py 与 transfer_optimization.py 之间的循环导入。

class e2m2e.algorithm.transfer.config.TransferConfig(search_alpha_min=None, search_alpha_max=None, search_n_alpha=None, search_n_departure=None, search_max_transfer_time=None, search_intersection_threshold=None, search_min_distance_threshold=None, search_collision_earth_radius=None, search_collision_moon_radius=None, search_integration_dt=None, nlp_alpha_min=0.5, nlp_alpha_max=2.5, nlp_earth_radius=0.0005202845956738336, nlp_moon_radius=0.0002601422978369168, nlp_use_relaxed_velocity=True, nlp_velocity_angle_tol=0.05, nlp_t_ins_range=None, nlp_transfer_time_range=None, nlp_use_copt=False, nlp_fallback_to_scipy=False, nlp_verbose=False)[源代码]

基类：object

转移轨道统一配置。

同时承载网格搜索阶段（search_* 前缀，供 TransferSearch 使用）与 NLP 优化阶段 （nlp_* 前缀，供 Transfer 与 DROTRONLPOptimizer 使用）的参数。

搜索阶段字段默认为 None，运行 search() 前须显式赋值（或通过散装 kwargs / configure_search() 设置）；优化阶段字段提供工程默认值。

Search-stage fields (default None):

search_alpha_min / search_alpha_max: α 网格上下界 search_n_alpha: α 方向网格点数 search_n_departure: 出发点采样数量 search_max_transfer_time: 最大转移时间（CR3BP 无量纲时间） search_intersection_threshold: 相交判定距离阈值（无量纲距离） search_min_distance_threshold: 候选解最小距离阈值（无量纲距离） search_collision_earth_radius: 地球碰撞检测半径（无量纲距离） search_collision_moon_radius: 月球碰撞检测半径（无量纲距离） search_integration_dt: 积分时间步长（无量纲时间）

NLP-stage fields (with engineering defaults):

nlp_alpha_min / nlp_alpha_max: 优化阶段 α 范围 nlp_earth_radius / nlp_moon_radius: 优化阶段碰撞检测半径（无量纲距离） nlp_use_relaxed_velocity: 是否使用松弛速度约束 nlp_velocity_angle_tol: 松弛速度约束角度容差（弧度） nlp_t_ins_range: RO 上的插入时间范围；None 时由调用方推导 nlp_transfer_time_range: 优化阶段转移时间范围 nlp_use_copt: 是否优先使用 COPT 优化器 nlp_fallback_to_scipy: COPT 失败时是否回退到 SciPy nlp_verbose: 优化器是否打印迭代信息

参数:

  • search_alpha_min (float | None)

  • search_alpha_max (float | None)

  • search_n_alpha (int | None)

  • search_n_departure (int | None)

  • search_max_transfer_time (float | None)

  • search_intersection_threshold (float | None)

  • search_min_distance_threshold (float | None)

  • search_collision_earth_radius (float | None)

  • search_collision_moon_radius (float | None)

  • search_integration_dt (float | None)

  • nlp_alpha_min (float)

  • nlp_alpha_max (float)

  • nlp_earth_radius (float)

  • nlp_moon_radius (float)

  • nlp_use_relaxed_velocity (bool)

  • nlp_velocity_angle_tol (float)

  • nlp_t_ins_range (tuple[float, float] | None)

  • nlp_transfer_time_range (tuple[float, float] | None)

  • nlp_use_copt (bool)

  • nlp_fallback_to_scipy (bool)

  • nlp_verbose (bool)

search_alpha_min: float | None = None
search_alpha_max: float | None = None
search_n_alpha: int | None = None
search_n_departure: int | None = None
search_max_transfer_time: float | None = None
search_intersection_threshold: float | None = None
search_min_distance_threshold: float | None = None
search_collision_earth_radius: float | None = None
search_collision_moon_radius: float | None = None
search_integration_dt: float | None = None
nlp_alpha_min: float = 0.5
nlp_alpha_max: float = 2.5
nlp_earth_radius: float = 0.0005202845956738336
nlp_moon_radius: float = 0.0002601422978369168
nlp_use_relaxed_velocity: bool = True
nlp_velocity_angle_tol: float = 0.05
nlp_t_ins_range: tuple[float, float] | None = None
nlp_transfer_time_range: tuple[float, float] | None = None
nlp_use_copt: bool = False
nlp_fallback_to_scipy: bool = False
nlp_verbose: bool = False
property nlp_alpha_range: tuple[float, float]

由 nlp_alpha_min / nlp_alpha_max 导出的优化阶段 α 范围。

class e2m2e.algorithm.transfer.config.TransferOptimizationResult(status=ConvergenceState.FAILED, cause=FailureCause.UNKNOWN, message='', departure_state=None, departure_alpha=0.0, departure_beta=0.0, insertion_state=None, final_state=None, delta_v1=0.0, delta_v2=0.0, total_delta_v=0.0, transfer_time=0.0, t_ins=0.0, transfer_trajectory=None, transfer_trajectory_times=None, constraints_violation=0.0, transfer_type=TransferType.DIRECT)[源代码]

基类：object

转移优化结果

变量:
参数:
status: ConvergenceState = 'failed'
cause: FailureCause = 'unknown'
message: str = ''
departure_state: ndarray | None = None
departure_alpha: float = 0.0
departure_beta: float = 0.0
insertion_state: ndarray | None = None
final_state: ndarray | None = None
delta_v1: float = 0.0
delta_v2: float = 0.0
total_delta_v: float = 0.0
transfer_time: float = 0.0
t_ins: float = 0.0
transfer_trajectory: ndarray | None = None
transfer_trajectory_times: ndarray | None = None
constraints_violation: float = 0.0
transfer_type: TransferType = 'direct'
class e2m2e.algorithm.transfer.config.TransferArc(states, times, delta_v=0.0)[源代码]

基类：object

一段无动力飞行弧（脉冲之间的轨迹段）。

变量:

  • states (numpy.ndarray) -- 弧上状态序列 [x, y, z, vx, vy, vz]，形状 (n, 6)，物理单位 (km, km/s)

  • times (numpy.ndarray) -- 对应时刻序列，形状 (n,)，s

  • delta_v (float) -- 进入该弧所需的脉冲大小，km/s（首段弧即出发脉冲）

参数:
states: ndarray
times: ndarray
delta_v: float = 0.0
class e2m2e.algorithm.transfer.config.TransferSolution(arcs, arrival_delta_v, total_delta_v, transfer_time, status, cause, message, n_iter)[源代码]

基类：object

三体打靶 / 低能转移的轻量结果类型。

与 TransferOptimizationResult 风格对齐，但按 frozen dataclass 保持最小： 多段弧各自携带进入脉冲，到达脉冲单列，总脉冲为各脉冲之和。

变量:
参数:
arcs: tuple[TransferArc, ...]
arrival_delta_v: float
total_delta_v: float
transfer_time: float
status: ConvergenceState
cause: FailureCause
message: str
n_iter: int

e2m2e.algorithm.transfer.cost module

转移轨道脉冲代价计算模块。

提供 ΔV 出发/插入脉冲及总代价的计算。

class e2m2e.algorithm.transfer.cost.TransferCost(dv1, dv2, total)[源代码]

基类：NamedTuple

转移代价三元组（无量纲速度单位）。

变量:

  • dv1 (float) -- 出发脉冲大小。

  • dv2 (float) -- 插入脉冲大小。

  • total (float) -- dv1 + dv2。

参数:
dv1: float

Alias for field number 0

dv2: float

Alias for field number 1

total: float

Alias for field number 2

e2m2e.algorithm.transfer.cost.compute_transfer_cost(departure_state, initial_velocity, final_velocity, insertion_velocity)[源代码]

计算两脉冲转移代价 Δv₁ + Δv₂。

参数:

  • departure_state (ndarray) -- 出发点六维状态 [x,y,z,vx,vy,vz]。

  • initial_velocity (ndarray) -- 出发注入速度（调整后）[vx,vy,vz]。

  • final_velocity (ndarray) -- 转移轨迹末端速度 [vx,vy,vz]。

  • insertion_velocity (ndarray) -- 目标轨道上插入点的速度 [vx,vy,vz]。

返回:

TransferCost 含 dv1、dv2 及 total。

返回类型:

TransferCost

e2m2e.algorithm.transfer.propulsion module

脉冲推进模型。

提供 ImpulsivePropulsion，用于计算转移轨道的出发注入速度与代价。

class e2m2e.algorithm.transfer.propulsion.ImpulsivePropulsion(normal=None)[源代码]

基类：object

脉冲推进模型。

将出发速度分解为切向与法向分量： v = alpha * |v| * t_hat + beta * |v| * n_hat， 其中 t_hat 为原始速度方向，n_hat 为轨道面法向。

变量:

normal -- 轨道面法向量，默认 [0, 0, 1] （z轴）。

参数:

normal (np.ndarray | None)

__init__(normal=None)[源代码]

初始化脉冲推进模型。

参数:

normal (ndarray | None) -- 轨道面法向量；None 时使用 [0.0, 0.0, 1.0]。

compute_departure_velocity(state, alpha=1.0, beta=0.0, **_)[源代码]

根据 alpha 和 beta 计算出发注入速度。

速度分解为切向和法向分量： v = alpha * |v| * t_hat + beta * |v| * n_hat， 其中 t_hat 为原始速度方向，n_hat 为轨道面法向。

参数:

  • state (ndarray) -- 出发点状态 [x, y, z, vx, vy, vz]。

  • alpha (float) -- 切向速度比（缩放切向分量）。

  • beta (float) -- 法向速度比（缩放法向分量），默认 0.0 （纯切向）。

  • **_ (Any) -- 忽略其他关键字参数。

返回:

注入速度向量 [vx, vy, vz]。

返回类型:

ndarray

compute_cost(departure_state, initial_velocity, final_velocity, insertion_velocity)[源代码]

计算转移代价。

委托给 e2m2e.algorithm.transfer.cost.compute_transfer_cost()。

参数:

  • departure_state (ndarray) -- 出发点六维状态 [x, y, z, vx, vy, vz]。

  • initial_velocity (ndarray) -- 出发注入速度（调整后） [vx, vy, vz]。

  • final_velocity (ndarray) -- 转移轨迹末端速度 [vx, vy, vz]。

  • insertion_velocity (ndarray) -- 目标轨道插入点速度 [vx, vy, vz]。

返回:

TransferCost 含 dv1、dv2 及 total。

返回类型:

TransferCost

e2m2e.algorithm.transfer.terminal module

终端条件模块

定义转移优化中出发/到达终端条件的抽象接口与具体实现。

class e2m2e.algorithm.transfer.terminal.TerminalCondition[源代码]

基类：ABC

转移终端条件抽象基类

定义出发状态与到达状态的获取契约。优化器通过此接口 与不同类型的终端（轨道、固定状态、事件触发等）交互。

abstractmethod get_initial_state()[源代码]

返回出发状态向量 [x, y, z, vx, vy, vz]

返回类型:

ndarray[tuple[Any, ...], dtype[floating]]

abstractmethod get_arrival_state(t_ins, dynamics)[源代码]

返回到达时刻的位置与速度

参数:

  • t_ins (float) -- 到达时刻（与轨道时间坐标一致）

  • dynamics (CR3BP_Dynamics) -- 动力学对象，用于状态传播

返回:

(position, velocity) 其中 position 形状 (3,)，velocity 形状 (3,)

返回类型:

tuple[npt.NDArray[np.floating], npt.NDArray[np.floating]]

class e2m2e.algorithm.transfer.terminal.OrbitTerminal(orbit)[源代码]

基类：TerminalCondition

基于周期轨道的终端条件

出发状态取轨道首点状态；到达状态通过动力学传播到指定相位获取。

参数:

orbit (Orbit)

__init__(orbit)[源代码]

初始化

参数:

orbit (Orbit) -- 周期轨道数据

返回类型:

None

get_initial_state()[源代码]

返回轨道首点状态

返回类型:

ndarray[tuple[Any, ...], dtype[floating]]

get_arrival_state(t_ins, dynamics)[源代码]

通过动力学传播获取到达相位状态

参数:
返回类型:

tuple[npt.NDArray[np.floating], npt.NDArray[np.floating]]

class e2m2e.algorithm.transfer.terminal.StateTerminal(state, time)[源代码]

基类：TerminalCondition

基于固定状态与时刻的终端条件

出发与到达状态均为固定值，不依赖动力学传播。

参数:

  • state (npt.ArrayLike)

  • time (float)

__init__(state, time)[源代码]

初始化

参数:

  • state (ArrayLike) -- 固定状态向量 [x, y, z, vx, vy, vz]

  • time (float) -- 固定时刻（仅用于记录，不影响状态提取）

返回类型:

None

get_initial_state()[源代码]

返回固定状态的副本

返回类型:

ndarray[tuple[Any, ...], dtype[floating]]

get_arrival_state(t_ins, dynamics)[源代码]

返回固定状态的位置与速度（忽略 t_ins）

参数:
返回类型:

tuple[npt.NDArray[np.floating], npt.NDArray[np.floating]]

e2m2e.algorithm.transfer.transfer module

DRO-RO 转移轨迹优化接口

把网格搜索得到的初值交由 NLP 优化器（Cui et al. 2025）求解，得到一条满足位置连续性 和速度平行性约束的转移轨迹。

class e2m2e.algorithm.transfer.transfer.Transfer(dynamics, propulsion=None)[源代码]

基类：object

DRO-RO 转移轨迹优化器

在端点条件（出发/到达）给定后，调用 NLP 优化器求解从 DRO（远距逆行轨道） 到 RO（共振轨道）的转移轨迹。

参数:
__init__(dynamics, propulsion=None)[源代码]

初始化转移优化器

参数:

  • dynamics (CR3BP_Dynamics) -- CR3BP 动力学实例，用于轨道传播

  • propulsion (ImpulsivePropulsion | None) -- 推进模型；None 时默认使用 ImpulsivePropulsion()

property departure_orbit: Orbit | None

出发轨道（DRO）。

property arrival_orbit: Orbit | None

到达轨道（RO）。

property departure: TerminalCondition | None

出发终端条件。

property arrival: TerminalCondition | None

到达终端条件。

property config: TransferConfig

转移优化配置。

property result: TransferOptimizationResult | None

最新优化结果。

set_departure(terminal)[源代码]

设置出发终端条件

参数:

terminal (TerminalCondition) -- 出发终端条件

返回:

self，支持链式调用

返回类型:

Transfer

set_arrival(terminal)[源代码]

设置到达终端条件

参数:

terminal (TerminalCondition) -- 到达终端条件

返回:

self，支持链式调用

返回类型:

Transfer

set_orbit(start, end)[源代码]

设置出发轨道和到达轨道（兼容旧接口）

内部调用 set_departure(OrbitTerminal(start)) 和 set_arrival(OrbitTerminal(end))。

参数:

  • start (Orbit) -- 出发轨道（DRO）

  • end (Orbit) -- 到达轨道（RO）

返回:

self，支持链式调用

返回类型:

Transfer

optimize(initial_guess, alpha_range, departure_state=None, t_ins_range=None, use_relaxed_velocity=None, velocity_angle_tol=None)[源代码]

优化转移轨迹

参数:

  • initial_guess (dict[str, float]) -- 初始猜测，包含 'alpha'、'transfer_time'、't_ins'

  • alpha_range (tuple[float, float]) -- α 参数范围 (min, max)

  • departure_state (ndarray | None) -- 手动指定出发点状态 [6]；None 时自动从 DRO 采样

  • t_ins_range (tuple[float, float] | None) -- RO 上的插入时间范围，默认为完整 RO 周期

  • use_relaxed_velocity (bool | None) -- 覆盖配置中的 use_relaxed_velocity

  • velocity_angle_tol (float | None) -- 覆盖配置中的 velocity_angle_tol

返回:

TransferOptimizationResult，包含优化详情

返回类型:

TransferOptimizationResult

e2m2e.algorithm.transfer.transfer_optimization module

DRO→RO 转移轨道 NLP 优化的高层编排。

实现论文 Cui et al. (2025) "搜索-优化"两步法中的优化阶段：

  • 优化变量：y = (α, T, t_ins)

  • 目标函数：J(y) = Δv1 + Δv2

  • 约束：位置连续性、速度平行性（或松弛形式）、撞星规避

本模块只承载高层编排：构造优化器、计算目标/约束、组装结果。 SciPy SLSQP 与 COPT 两种求解后端分别封装在 e2m2e.algorithm.transfer.nlp_scipy 与 e2m2e.algorithm.transfer.nlp_copt， 由 DROTRONLPOptimizer 调度。

class e2m2e.algorithm.transfer.transfer_optimization.DROTRONLPOptimizer(system, dynamics, *, departure_terminal=None, arrival_terminal=None, departure_orbit=None, arrival_orbit=None, departure_state=None, config=None, propulsion=None)[源代码]

基类：object

DRO→RO 转移轨道 NLP 优化器

实现论文 Section III.B 的优化阶段算法。 默认通过 SciPy SLSQP 求解；调用方可改走 COPT 后端 （见 optimize_with_copt()）。

变量:

  • system -- CR3BP 系统对象

  • dynamics -- CR3BP 动力学对象

  • departure_orbit -- 出发点轨道

  • arrival_orbit -- 目标轨道

  • departure_state -- 出发点状态

  • alpha_range -- α 搜索范围

  • velocity_angle_tolerance -- 速度平行性容差（弧度）

  • earth_radius -- 地球半径（无量纲）

  • moon_radius -- 月球半径（无量纲）

参数:
DEFAULT_ALPHA_RANGE = (0.5, 2.5)
DEFAULT_TRANSFER_TIME_RANGE = (1.0, 30.0)
DEFAULT_T_INS_RANGE = (0.0, 10.0)
EARTH_RADIUS_ND = 0.016366661277947565
MOON_RADIUS_ND = 0.00452159209157128
DEFAULT_VELOCITY_ANGLE_TOL = 1e-06
__init__(system, dynamics, *, departure_terminal=None, arrival_terminal=None, departure_orbit=None, arrival_orbit=None, departure_state=None, config=None, propulsion=None)[源代码]

初始化 NLP 优化器（issue #161）。

支持两种构造路径（不可混用）：

  • 新接口（推荐） — (departure_terminal, arrival_terminal)， 内部走 TerminalCondition 接口；这是 StateTerminal 等非轨道型终端接入的唯一方式。

  • 旧接口（向后兼容） — (departure_orbit, arrival_orbit, departure_state)，内部等价于把两条轨道包成 OrbitTerminal。

参数:
classmethod from_orbits(system, dynamics, departure_orbit, arrival_orbit, departure_state=None, config=None, propulsion=None)[源代码]

通过 Orbit 直接构造（向后兼容的便捷类方法）。

内部等价于把两条轨道包成 OrbitTerminal 再走新接口。

参数:
返回:

DROTRONLPOptimizer 实例

返回类型:

DROTRONLPOptimizer

set_progress_callback(callback)[源代码]

设置迭代进度回调函数。

参数:

callback (Callable | None) -- 签名 (iteration, obj, alpha, T, t_ins) -> None， 或 None 清除回调。

返回类型:

None

enable_cache(enabled=True)[源代码]

启用/禁用 _evaluate_all 结果缓存，避免同一点重复积分。

参数:

enabled (bool) -- True 开启缓存。

返回类型:

None

compute_departure_velocity(state, alpha, beta=0.0)[源代码]

根据 α 和 β 计算出发注入速度。

委托给 self.propulsion.compute_departure_velocity，保留方法签名以兼容外部调用。

参数:

  • state (ndarray) -- 出发点状态 [x, y, z, vx, vy, vz]

  • alpha (float) -- 切向速度比（缩放切向分量）

  • beta (float) -- 法向速度比（缩放法向分量），默认 0.0（纯切向）

返回:

注入速度向量 [vx, vy, vz]

返回类型:

ndarray

forward_integrate(initial_state, t_span, t_eval=None)[源代码]

前向积分转移弧

参数:

  • initial_state (ndarray) -- 初始状态 [x, y, z, vx, vy, vz]

  • t_span (tuple[float, float]) -- 积分时间范围 (t0, tf)

  • t_eval (ndarray | None) -- 评估时间点

返回:

(times, states)：时间序列和状态序列

返回类型:

tuple[ndarray, ndarray]

get_arrival_state_at_t_ins(t_ins)[源代码]

获取目标轨道上 t_ins（绝对时间）对应的状态

参数:

t_ins (float) -- 绝对时间（与 orbit.times 同一坐标系）

返回:

(position, velocity)：位置和速度

返回类型:

tuple[ndarray, ndarray]

objective_function(y)[源代码]

目标函数 J(y) = Δv1 + Δv2

参数:

y (ndarray) -- 优化变量 [alpha, T, t_ins]

返回:

总脉冲代价

返回类型:

float

constraint_position(y)[源代码]

位置连续性约束 Eq.(13)

(x_f - x_ins)^2 + (y_f - y_ins)^2 + (z_f - z_ins)^2 = 0

参数:

y (ndarray) -- 优化变量 [alpha, T, t_ins]

返回:

约束违反量

返回类型:

float

constraint_velocity_parallel(y)[源代码]

速度平行性约束 Eq.(14) 或松弛 Eq.(17)

v_f · v_ins / (||v_f|| ||v_ins||) - 1 = 0

参数:

y (ndarray) -- 优化变量 [alpha, T, t_ins]

返回:

约束违反量

返回类型:

float

check_collision(y)[源代码]

检查是否撞击地球或月球

参数:

y (ndarray) -- 优化变量 [alpha, T, t_ins]

返回:

(earth_collision, moon_collision)：是否撞击地球、月球

返回类型:

tuple[bool, bool]

optimize(initial_guess=None, alpha_range=None, transfer_time_range=None, t_ins_range=None, use_relaxed_velocity_constraint=None, velocity_angle_constraint=None, verbose=None)[源代码]

执行 SciPy 后端的 NLP 优化。

委托给 e2m2e.algorithm.transfer.nlp_scipy.solve_with_scipy()。完整参数说明见该函数。

参数:
返回类型:

TransferOptimizationResult

e2m2e.algorithm.transfer.transfer_optimization.optimize_transfer(system, dynamics, departure_orbit, arrival_orbit, departure_state, initial_guess=None, propulsion=None, **kwargs)[源代码]

便捷函数: 优化 DRO→RO 转移（SciPy SLSQP 后端）

参数:

  • system (CR3BP_System) -- CR3BP 系统

  • dynamics (CR3BP_Dynamics) -- CR3BP 动力学

  • departure_orbit (Orbit) -- 出发点轨道

  • arrival_orbit (Orbit) -- 目标轨道

  • departure_state (ndarray) -- 出发点状态

  • initial_guess (NLPOptimizationVariables | None) -- 初始猜测

  • propulsion (ImpulsivePropulsion | None) -- 推进模型；None 时使用 ImpulsivePropulsion()

  • **kwargs -- 其他优化参数（透传给 optimizer.optimize）

返回:

优化结果

返回类型:

TransferOptimizationResult

e2m2e.algorithm.transfer.search_geometry module

轨道搜索的几何核。

纯函数：仅 np.ndarray / Orbit 输入，不引入进度条与并行。

e2m2e.algorithm.transfer.search_geometry.compute_distance_series(trajectory_states, arrival_orbit)[源代码]
参数:
返回类型:

tuple[ndarray, ndarray]

e2m2e.algorithm.transfer.search_geometry.compute_distance_series_chunked(traj_positions, orbit_positions)[源代码]
参数:
返回类型:

tuple[ndarray, ndarray]

e2m2e.algorithm.transfer.search_geometry.compute_min_distance(trajectory_states, arrival_orbit)[源代码]
参数:
返回类型:

tuple[float, int, int]

e2m2e.algorithm.transfer.search_geometry.detect_intersection(trajectory_states, arrival_orbit, threshold)[源代码]
参数:
返回类型:

tuple[bool, ndarray | None, int]

e2m2e.algorithm.transfer.search_geometry.detect_local_minimum(trajectory_states, arrival_orbit)[源代码]
参数:
返回类型:

tuple[bool, float, int]

e2m2e.algorithm.transfer.search_geometry.check_collision(trajectory_states, mu, collision_earth_radius, collision_moon_radius)[源代码]
参数:
返回类型:

tuple[bool, str | None, int]

e2m2e.algorithm.transfer.search_geometry.is_feasible_result(result, min_distance_threshold, default_min_distance_threshold)[源代码]
参数:
返回类型:

bool

e2m2e.algorithm.transfer.search_parallel module

轨道搜索的并行/串行后端与 per-α 积分内核。

per-α 积分内核 search_single_departure() 通过 searcher 上的几何方法 分发（searcher._forward_integrate / _check_collision / _compute_distance_series 等）， 便于 monkeypatch.setattr(TransferSearch, "_x", ...) 注入合成行为。

e2m2e.algorithm.transfer.search_parallel.sample_departure_points(departure_orbit, n_departure)[源代码]

从轨道星历等时间间隔下采样出发点。

参数:

  • departure_orbit (Orbit)

  • n_departure (int)

返回类型:

tuple[ndarray, ndarray]

e2m2e.algorithm.transfer.search_parallel.forward_integrate(dynamics, initial_state, transfer_time, dt)[源代码]

CR3BP 下从 initial_state 前向积分到 transfer_time，得到等间隔采样轨迹。

参数:
返回类型:

tuple[ndarray, ndarray]

e2m2e.algorithm.transfer.search_parallel.search_single_departure(searcher, *, departure_state, departure_time, arrival_orbit, verbose=False, pbar=None, departure_index=None, progress_queue=None)[源代码]

对单出发点执行 α 网格搜索。

参数:

  • searcher (TransferSearch)

  • departure_state (np.ndarray)

  • departure_time (float)

  • arrival_orbit (Orbit)

  • verbose (bool)

  • pbar (Any | None)

  • departure_index (int | None)

  • progress_queue (Any | None)

返回类型:

list[TransferCandidateResult]

网格搜索分发。

参数:
返回类型:

list[TransferCandidateResult]

e2m2e.algorithm.transfer.search_parallel.grid_search_rust_dispatch(searcher, departure_orbit, arrival_orbit, departure_states, departure_times, dep_name, arr_name, verbose, n_workers)[源代码]

Rust + Rayon 后端网格搜索分发（阶段 D1）。

展平 POD 输入喂给 e2m2e.integrators.grid_search_rust() （py.allow_threads 释放 GIL + Rayon par_iter），拿回候选解后追加 departure_time_index / departure_orbit_name / arrival_orbit_name，对齐 Python sequential 后端字段。

几何方法被 monkeypatch 时，Rust 内核不经过 Python 分发，故保留 Python 路径以维持测试注入语义。除此之外 Rust 扩展或符号缺失必须直接报告，不能 默认改用进程后端（issue #378）。 Rust 总是走 Rayon 多核并行（parallel=True）——网格搜索的目标是快速完成。 n_workers 直接转发给 Rust 端 ThreadPoolBuilder.num_threads 限定线程数， 覆盖 RAYON_NUM_THREADS （该环境变量仅在 grid_search_rust() 的 n_workers=None 时生效，本 dispatch 路径总传入有限整数）；monkeypatch 回退 时 n_workers 用于选择 Python 后端的进程数。verbose 时建 tqdm 进度条， 出发粒度（Rust 端每完成一个 departure 触发一次回调）。

参数:

  • searcher (TransferSearch)

  • departure_orbit (Orbit)

  • arrival_orbit (Orbit)

  • departure_states (np.ndarray)

  • departure_times (np.ndarray)

  • dep_name (str)

  • arr_name (str)

  • verbose (bool)

  • n_workers (int)

返回类型:

list[TransferCandidateResult]

e2m2e.algorithm.transfer.search_parallel.grid_search_sequential(searcher, departure_states, departure_times, arrival_orbit, dep_name, arr_name, verbose)[源代码]

串行网格搜索。

参数:

  • searcher (TransferSearch)

  • departure_states (np.ndarray)

  • departure_times (np.ndarray)

  • arrival_orbit (Orbit)

  • dep_name (str)

  • arr_name (str)

  • verbose (bool)

返回类型:

list[TransferCandidateResult]

e2m2e.algorithm.transfer.search_parallel.grid_search_parallel_processes(searcher, departure_states, departure_times, arrival_orbit, dep_name, arr_name, verbose, n_workers)[源代码]

多进程并行：每进程独立 Python 解释器，利于 CPU 密集积分。

参数:

  • searcher (TransferSearch)

  • departure_states (np.ndarray)

  • departure_times (np.ndarray)

  • arrival_orbit (Orbit)

  • dep_name (str)

  • arr_name (str)

  • verbose (bool)

  • n_workers (int)

返回类型:

list[TransferCandidateResult]

e2m2e.algorithm.transfer.search_parallel.grid_search_parallel_threads(searcher, departure_states, departure_times, arrival_orbit, dep_name, arr_name, verbose, n_workers)[源代码]

多线程并行搜索：支持细粒度 tqdm 进度条。

参数:

  • searcher (TransferSearch)

  • departure_states (np.ndarray)

  • departure_times (np.ndarray)

  • arrival_orbit (Orbit)

  • dep_name (str)

  • arr_name (str)

  • verbose (bool)

  • n_workers (int)

返回类型:

list[TransferCandidateResult]

e2m2e.algorithm.transfer.search_parallel.process_departure_worker(idx, dep_state, dep_time, arrival_states, arrival_times, arrival_period, mu, alpha_min, alpha_max, n_alpha, n_departure, max_transfer_time, intersection_threshold, min_distance_threshold, collision_earth_radius, collision_moon_radius, integration_dt, integrator, rtol, atol, max_step, dep_name, arr_name, progress_queue=None)[源代码]

子进程入口（模块级，便于 Windows spawn 下 pickle）。

参数:
返回类型:

list[TransferCandidateResult]

e2m2e.algorithm.transfer.search_parallel.process_departure_worker_packed(packed)[源代码]

单元组打包，供 ProcessPoolExecutor 提交。

参数:

packed (tuple[Any, ...])

返回类型:

list[TransferCandidateResult]

e2m2e.algorithm.transfer.search_progress module

轨道搜索的 tqdm 进度条封装。

class e2m2e.algorithm.transfer.search_progress.AggregatePbarWithSlot(inner, lock, slot)[源代码]

基类：object

参数:
update(n=1)[源代码]
参数:

n (int)

返回类型:

None

set_postfix_str(s, refresh=True)[源代码]
参数:
返回类型:

None

e2m2e.algorithm.transfer.search_progress.open_search_progress_bar(total, desc)[源代码]
参数:
返回类型:

Any | None

e2m2e.algorithm.transfer.search_progress.use_multiline_worker_tqdm(n_workers)[源代码]
参数:

n_workers (int)

返回类型:

bool

e2m2e.algorithm.transfer.search_progress.reset_tqdm_bar(bar, total)[源代码]
参数:
返回类型:

None

e2m2e.algorithm.transfer.search_progress.open_parallel_worker_progress_bars(n_workers, n_alpha)[源代码]
参数:

  • n_workers (int)

  • n_alpha (int)

返回类型:

list[Any]

e2m2e.algorithm.transfer.solution_database module

解数据库：多 scan 聚合查询与筛选（主题 8）。

在 porkchop SQLite 存档基础上提供统一查询接口： - 多 scan 聚合（跨扫描合并查询） - 双线性插值代价查询（复用 PorkchopData.query()） - 筛选钩子（预留 Grossi 式主矢量筛选接口）

用法:

from e2m2e.algorithm.transfer.solution_database import SolutionDatabase

db = SolutionDatabase("porkchop.db")
db.add_scan(data, orbit_pair="LEO->GEO", direction="short")
dv = db.query(scan_id=1, t_dep=1000.0, tof=3600.0)
front = db.pareto_front(scan_id=1)
class e2m2e.algorithm.transfer.solution_database.SolutionDatabase(path)[源代码]

基类：object

porkchop 解数据库（SQLite 后端）。

封装多 scan 聚合查询，比裸用 PorkchopData 的类方法 更方便。不引入新依赖（stdlib sqlite3）。

变量:

path (str | pathlib.Path) -- SQLite 文件路径。

参数:

path (str | Path)

path: str | Path
add_scan(data, orbit_pair, *, direction='', revs=0, note='')[源代码]

把一次 porkchop 扫描加入数据库，返回 scan_id。

参数:
返回类型:

int

get_scan(scan_id)[源代码]

按 scan_id 取完整网格。

参数:

scan_id (int)

返回类型:

PorkchopData

query(scan_id, t_dep, tof)[源代码]

插值查询指定 scan 的转移代价。

参数:
返回类型:

float

pareto_front(scan_id, *, objectives=('total', 'tof'))[源代码]

提取指定 scan 的 Pareto 前沿。

参数:
返回类型:

ParetoFront

list_scans()[源代码]

列出所有扫描的元数据。

返回类型:

list[dict]

filter(scan_id, criterion)[源代码]

按判据筛选网格点（预留 Grossi 式主矢量筛选接口）。

参数:

  • scan_id (int) -- 扫描编号。

  • criterion (Callable[[float, float, float], bool]) -- 判据函数 f(t_dep, tof, total_dv) -> bool， True 表示保留。

返回:

布尔掩码数组，形状 (n, m)，与网格同形。

返回类型:

ndarray[tuple[Any, ...], dtype[bool]]

e2m2e.algorithm.transfer.mission_assessment module

任务综合评估：多指标加权（主题 8）。

在 Pareto 前沿上按用户权重把多目标标量化，辅助决策。对应规划文档 「丁百慧式多指标加权」——但文档未展开「动态权值」语义，本实现为 静态加权 （与文档接口 stub 一致）。

用法:

from e2m2e.algorithm.transfer.mission_assessment import MissionAssessment

ma = MissionAssessment()
# 在 NSGA-II 前沿上评估
scores = ma.evaluate(result.f, weights={"dv": 0.7, "tof": 0.3})
best_idx = int(np.argmin(scores))
class e2m2e.algorithm.transfer.mission_assessment.MissionAssessment(metric_names=None)[源代码]

基类：object

多指标加权综合评估器。

把多目标解集（Pareto 前沿）按用户给定的权重标量化， 返回每个解的综合得分（越小越优）。

指标名与目标向量的列对应：默认按列序命名 ["obj_0", "obj_1", ...]，也可显式传入 metric_names。

参数:

metric_names (list[str] | None)

metric_names: list[str] | None = None
evaluate(solutions, weights)[源代码]

对解集加权评分。

参数:

  • solutions (ndarray[tuple[Any, ...], dtype[floating]]) -- 目标向量矩阵，形状 (k, n_obj)，每行一个解。

  • weights (dict[str, float]) -- 指标权重，如 {"dv": 0.7, "tof": 0.3}。 权重和归一化到 1。未指定的指标权重为 0。

返回:

综合得分数组，形状 (k,)，越小越优。

抛出:

ValueError -- solutions 为空、weights 含未知指标名、 或 metric_names 长度与 solutions 列数不匹配。

返回类型:

ndarray

rank(solutions, weights)[源代码]

返回按综合得分升序排序的索引（最优在前）。

参数:
返回类型:

ndarray

best(solutions, weights)[源代码]

返回最优解的索引与得分。

参数:
返回类型:

tuple[int, float]

classmethod from_pareto_front(front, metric_names=None)[源代码]

从 ParetoFront 结果构造评估器（推断指标名）。

支持 NSGA2Result （用 obj_0..obj_{n-1}）和 ParetoFront （用 ["dv", "tof"] 等 porkchop 字段名）。

参数:
返回类型:

MissionAssessment

e2m2e.algorithm.transfer.lambert module

二体 Lambert 求解器（Izzo 算法）的 Python 薄封装。

Rust 内核在 e2m2e-propagation crate（crates/e2m2e-propagation/src/lambert.rs）， 经 e2m2e._integrators 暴露；本模块只做类型转换与结果封装。

class e2m2e.algorithm.transfer.lambert.LambertSolution(v0, vf, status, cause, message, n_iter, revs)[源代码]

基类：object

单次 Lambert 求解结果。

变量:
参数:
v0: ndarray
vf: ndarray
status: ConvergenceState
cause: FailureCause
message: str
n_iter: int
revs: int
e2m2e.algorithm.transfer.lambert.solve_lambert(r0, rf, tof, mu, direction='short', revs=0)[源代码]

解二体 Lambert 问题（Izzo 2015 算法）。

参数:

  • r0 (ArrayLike) -- 出发位置 [x, y, z]，km

  • rf (ArrayLike) -- 到达位置 [x, y, z]，km

  • tof (float) -- 飞行时间，s

  • mu (float) -- 中心天体 GM，km³/s²

  • direction (str) -- "short" 表示转移角 < π，"long" 表示 > π

  • revs (int) -- 完整圈数；≥ 1 时返回右分支（低能）解

返回:

LambertSolution

抛出:

ValueError -- tof 低于该圈数最小转移时间或迭代不收敛

返回类型:

LambertSolution

e2m2e.algorithm.transfer.lambert.solve_lambert_batch(r0_list, rf_list, tof_grid, mu, direction='short', revs=0)[源代码]

N×M 网格批量求解：每个 (r0, rf) 几何对每个 tof 各解一次。

参数:

  • r0_list (ArrayLike) -- 出发位置列表，形状 (N, 3)，km

  • rf_list (ArrayLike) -- 到达位置列表，形状 (N, 3)，km

  • tof_grid (ArrayLike) -- 飞行时间网格，形状 (M,)，s

  • mu (float) -- 中心天体 GM，km³/s²

  • direction (str) -- "short" 或 "long"

  • revs (int) -- 完整圈数

返回:

形状 (N, M, 2, 3) 的数组：[..., 0, :] 为出发速度 v0， [..., 1, :] 为到达速度 vf；无解的组合为 NaN。

返回类型:

ndarray

e2m2e.algorithm.transfer.three_body_lambert module

三体 Lambert 打靶模块。

以二体 Lambert 解为初猜，在 CR3BP 动力学下用 Newton 打靶修正出发速度， 使给定飞行时间后的末端位置命中目标。流程（孙俞等 2017、Fossa 等 2022）：

  1. 两端物理状态 (km, km/s) 经 CR3BP_System.physical_to_dimensionless 无量纲化；

  2. 无量纲几何上以 μ = 1 调 solve_lambert() 得初猜出发速度；

  3. Newton 迭代：传播 with_stm=True，取末端 STM 的 Φ_rv 块（Φ[0:3, 3:6]） 解修正量，收敛判据为末端位置误差 < 1e-8（无量纲）。

class e2m2e.algorithm.transfer.three_body_lambert.ThreeBodyLambert(dynamics)[源代码]

基类：object

CR3BP 两点边值打靶求解器。

变量:

  • dynamics -- CR3BP_Dynamics 对象（system 须已初始化特征尺度）

  • tolerance -- 末端位置误差收敛判据（无量纲）

  • max_iterations -- 最大 Newton 迭代次数

参数:

dynamics (CR3BP_Dynamics)

DEFAULT_TOLERANCE = 1e-08
DEFAULT_MAX_ITERATIONS = 20
DIVERGENCE_LIMIT = 10.0
__init__(dynamics)[源代码]

初始化

参数:

dynamics (CR3BP_Dynamics) -- CR3BP_Dynamics 对象

抛出:

ValueError -- 系统未初始化特征尺度（物理/无量纲换算不可用）

返回类型:

None

solve(term0, term1, tof, guess='lambert')[源代码]

解三体 Lambert 问题：修正出发速度使 tof 后末端位置命中 term1。

参数:

  • term0 (StateTerminal) -- 出发终端，状态为物理单位 (km, km/s)

  • term1 (StateTerminal) -- 到达终端，状态为物理单位 (km, km/s)；仅位置为约束， 速度用于计算到达脉冲

  • tof (float) -- 飞行时间，s

  • guess (Literal['lambert', 'orbit']) -- 初猜来源；"lambert" 用无量纲二体 Lambert 解， "orbit" 直接用 term0 的速度

返回:

TransferSolution，单弧，物理单位；失败时返回对应状态与原因码

返回类型:

TransferSolution

e2m2e.algorithm.transfer.porkchop module

porkchop 图扫描：二体 Lambert 双脉冲 ΔV 网格。

对出发时间 × 飞行时间网格逐点解 Lambert 问题，得到出发/到达脉冲 及其总和的网格数据（porkchop 图的数据层）。终端（出发/到达天体或 轨道）状态经 TerminalCondition 接口提取，本模块不关心状态如何产生。

除内存网格与绘图外，本模块还提供两项任务分析能力（主题 8）：

  • SQLite 存档：PorkchopData.to_sqlite() / PorkchopData.from_sqlite() 把网格落盘为关系表，多次扫描可累积、可查询（stdlib sqlite3，无新增依赖）。

  • ΔV–TOF Pareto 前沿：pareto_front() 用经典非支配排序（Deb 2002） 从网格中提取 Pareto 前沿（Topputo 2013 双目标范式）。

class e2m2e.algorithm.transfer.porkchop.PorkchopData(t_dep, tof, dv1, dv2, total)[源代码]

基类：object

porkchop 扫描结果。

变量:
参数:
t_dep: ndarray
tof: ndarray
dv1: ndarray
dv2: ndarray
total: ndarray
plot(ax=None, levels=None)[源代码]

画总 ΔV 等值线图（porkchop 图）。

参数:

  • ax (Axes | None) -- 目标坐标轴，None 时新建

  • levels (int | npt.ArrayLike | None) -- contour 的等值线层级，None 时取 20

返回:

绘图所用的 Axes

返回类型:

Axes

to_sqlite(path, orbit_pair, *, direction='', revs=0, note='')[源代码]

把本网格写入 SQLite 解数据库，返回本次扫描的 scan_id。

库结构两张表：

  • scans(scan_id, orbit_pair, direction, revs, n_t_dep, n_tof, created_at, note)：每次调用存一行元数据。

  • design_points(scan_id, t_dep, tof, dv1, dv2, total)：网格展平 成 n×m 行，NaN（无解组合）存为 NULL。

同一文件多次调用以自增 scan_id 累积，形成可查询的转移代价 数据库（主题 8）。使用 stdlib sqlite3，不引入新依赖。

参数:

  • path (str | Path) -- SQLite 文件路径；父目录自动创建。

  • orbit_pair (str) -- 轨道对标识，如 "LEO->GEO"。

  • direction (str) -- Lambert 转移方向（"short"/"long"），记入元数据。

  • revs (int) -- 完整圈数，记入元数据。

  • note (str) -- 自由备注。

返回:

本次扫描的 scan_id。

返回类型:

int

classmethod from_sqlite(path, scan_id)[源代码]

按 scan_id 从 SQLite 解数据库重建网格（NULL 还原为 NaN）。

参数:
返回:

重建的 PorkchopData，与写入时数值等价。

抛出:

ValueError -- scan_id 不存在。

返回类型:

PorkchopData

query(t_dep, tof)[源代码]

双线性插值查询转移代价（总 ΔV）。

在规则网格上定位 (t_dep, tof) 所在的单元格，用四角点双线性 插值估计 total。若四角点含 NaN（无解组合），返回 NaN——调用方 应检查返回值或先用 pareto_front() 筛选有效区域。

对应规划文档「宋亮俊数据库的在线查询」（主题 8）：预计算网格 + 双线性插值，替代逐点重算 Lambert。

参数:

  • t_dep (float) -- 出发时间（须在本网格 t_dep 范围内）

  • tof (float) -- 飞行时间（须在本网格 tof 范围内）

返回:

插值得到的总 ΔV（km/s），或 NaN（格点含无解组合）。

抛出:

ValueError -- 查询点超出网格范围。

返回类型:

float

classmethod query_scan(path, scan_id, t_dep, tof)[源代码]

从 SQLite 解数据库读网格并插值查询。

等价于 cls.from_sqlite(path, scan_id).query(t_dep, tof)。

参数:

  • path (str | Path) -- SQLite 文件路径。

  • scan_id (int) -- 扫描编号。

  • t_dep (float) -- 查询点（同 query()）。

  • tof (float) -- 查询点（同 query()）。

返回:

插值得到的总 ΔV（km/s），或 NaN。

返回类型:

float

class e2m2e.algorithm.transfer.porkchop.ParetoFront(t_dep, tof, dv1, dv2, total, rank)[源代码]

基类：object

porkchop 网格的 Pareto 前沿（rank 0 非支配点集）。

变量:

  • t_dep (numpy.ndarray) -- 前沿点的出发时间，形状 (k,)

  • tof (numpy.ndarray) -- 前沿点的飞行时间，形状 (k,)

  • dv1 (numpy.ndarray) -- 前沿点的出发脉冲，形状 (k,)，km/s

  • dv2 (numpy.ndarray) -- 前沿点的到达脉冲，形状 (k,)，km/s

  • total (numpy.ndarray) -- 前沿点的总脉冲，形状 (k,)，km/s

  • rank (numpy.ndarray) -- 各前沿点的非支配层级，形状 (k,)，前沿点恒为 0

参数:
t_dep: ndarray
tof: ndarray
dv1: ndarray
dv2: ndarray
total: ndarray
rank: ndarray
plot(ax=None)[源代码]

画 Pareto 前沿（TOF vs 总 ΔV 散点 + 连线）。

参数:

ax (Axes | None) -- 目标坐标轴，None 时新建

返回:

绘图所用的 Axes

返回类型:

Axes

e2m2e.algorithm.transfer.porkchop.pareto_front(data, *, objectives=('total', 'tof'))[源代码]

从 porkchop 网格提取 ΔV–TOF Pareto 前沿（经典非支配排序）。

点 A 支配点 B 当且仅当 A 在两个目标上都不劣于 B、且至少一个目标 严格更优。前沿（rank 0）即不被任何有效点支配的点集。仅对有效点 （total 非 NaN）排序；NaN 组合不参与。

默认目标为 min(total) 与 min(tof) （Topputo 2013 双目标范式）。 也支持 ("dv1", "tof") 等其它字段组合；字段名必须是 PorkchopData 的 ndarray 字段。

复杂度 O(M·N²)，N 为有效点数。porkchop 网格通常数百至数千点， 纯 Python 足够；万级以上解集再考虑下沉 Rust。

参数:

  • data (PorkchopData) -- porkchop 扫描结果。

  • objectives (tuple[str, str]) -- 两个目标字段名（越小越优）。

返回:

ParetoFront （仅 rank 0 点）。

抛出:

ValueError -- 目标字段名不存在，或无有效点。

返回类型:

ParetoFront

e2m2e.algorithm.transfer.porkchop.porkchop(dep, arr, t_dep_range, tof_range, mu, dynamics, direction='short', revs=0)[源代码]

扫描出发时间 × 飞行时间网格，计算双脉冲 ΔV。

对网格点 (t_dep, tof)：出发终端状态取 t_dep 时刻，到达终端 状态取 t_dep + tof 时刻，解二体 Lambert 得转移速度，脉冲为转移 速度与终端轨道速度之差。

数值网格评估（终端传播 + Lambert + ΔV 组装 + 分发）全部在 Rust （#446，ADR 0017 范式）；Python 只做问题构造与结果解释：

  • 规格路径：两端均为内置终端（OrbitTerminal/StateTerminal 且未被 monkeypatch）、涉及轨道终端时 dynamics 为未 patch 的 CR3BP_Dynamics——终端规格直接交给 Rust，轨道终端的传播在 Rust 内逐点并行进行。

  • 协议路径：其余情况（自定义 TerminalCondition 子类、终端 方法被 patch、动力学不满足上条）由 Python 按 get_arrival_state 协议逐点提取状态网格，再交给同一 Rust 评估核。patch 语义因此 保持有效。

两条路径共用同一 Rust Lambert/ΔV 核，无 Python 数值回退；扩展缺失 按 #378 抛 RustExtensionUnavailableError。并行由 Rayon 执行， E2M2E_PORKCHOP_PARALLEL=0 可强制串行（与并行逐位一致）。

参数:

  • dep (TerminalCondition) -- 出发终端（如 OrbitTerminal）

  • arr (TerminalCondition) -- 到达终端

  • t_dep_range (ArrayLike) -- 出发时间网格 (n,)，与终端时间坐标一致

  • tof_range (ArrayLike) -- 飞行时间网格 (m,)，s

  • mu (float) -- 中心天体 GM，km³/s²

  • dynamics (CR3BP_Dynamics) -- 传播对象，透传给终端的 get_arrival_state

  • direction (str) -- "short" 或 "long"

  • revs (int) -- 完整圈数

返回:

PorkchopData

返回类型:

PorkchopData

e2m2e.algorithm.transfer.multi_impulse module

多脉冲转移框架与 Lawden 主矢量检验。

多脉冲 NLP 采用节点参数化：两端为固定 StateTerminal （位置、速度、时刻 均固定），中途脉冲节点以 (t_i, r_i) 为决策变量，相邻节点间的弧段由 Lambert 封闭——二体 solve_lambert() （快，默认，用于初扫）或 ThreeBodyLambert 打靶（准，用于精修）。各节点的脉冲是封闭结果的输出 （进出弧速度差），不是独立变量。这是 Prussing《Optimal Spacecraft Trajectories》 第 5 章与宝音贺西等 (2025) 内层封闭/外层 NLP 结构的标准形式。

主矢量检验的公式出处：

  • Prussing《Optimal Spacecraft Trajectories》(SIAM, 2019) 第 3 章：Lawden 主矢量 p(t) 的最优性必要条件——全程 |p(t)| ≤ 1；脉冲点 |p| = 1 且脉冲方向与 p 共线。

  • 同书第 4 章：给定脉冲转移的主矢量由端点横截条件 p(t0) = Δv̂₀、p(tf) = Δv̂_f 确定。协态 z = [−ṗ; p] 沿轨迹按 z(t) = Φ(t, t0)^{-T} z(t0) 携载（Φ 为状态转移 矩阵，固定脉冲不改变变分映射，故 Φ 在脉冲点连续、可跨弧链接）；先由 p(tf) 条件 解出 ṗ(t0)（3×3 线性系统），再逐采样点携载得 p(t) 曲线。

  • Lion & Handelsman (1968)：|p| 在弧内超过 1 是转移非最优的判据，在峰值处插入 中途脉冲可降低总 ΔV；Grossi et al. (2024) 用它驱动地月三脉冲转移设计。

class e2m2e.algorithm.transfer.multi_impulse.Impulse(time, delta_v)[源代码]

基类：object

脉冲节点：给定时刻的速度增量。

变量:

  • time (float) -- 脉冲时刻，s（与终端时刻同坐标）

  • delta_v (numpy.ndarray) -- 速度增量，形状 (3,)，km/s

参数:
time: float
delta_v: ndarray
class e2m2e.algorithm.transfer.multi_impulse.CoastArc(terminal0, tof, dynamics='two_body')[源代码]

基类：object

无动力弧段规划节点：自 terminal0 起飞行 tof。

变量:
参数:
terminal0: StateTerminal
tof: float
dynamics: str = 'two_body'
class e2m2e.algorithm.transfer.multi_impulse.PrimerVectorReport(times, primer, primer_magnitude, max_magnitude, lawden_satisfied, impulse_times, impulse_magnitudes, impulse_alignment_cosines, suggested_insertion_time, suggested_insertion_position, message='')[源代码]

基类：object

主矢量检验报告。

变量:

  • times (numpy.ndarray) -- 采样时刻，形状 (n,)，s（与终端时刻同坐标）

  • primer (numpy.ndarray) -- 主矢量 p(t)，形状 (n, 3)，无量纲

  • primer_magnitude (numpy.ndarray) -- |p(t)|，形状 (n,)

  • max_magnitude (float) -- 全程最大 |p|

  • lawden_satisfied (bool) -- Lawden 必要条件是否满足（弧内 |p|≤1 且中途脉冲 与 p 共线、|p|=1，均在容差内）

  • impulse_times (numpy.ndarray) -- 各脉冲时刻（含出发与到达脉冲），形状 (k,)，s

  • impulse_magnitudes (numpy.ndarray) -- 脉冲点 |p|，形状 (k,)

  • impulse_alignment_cosines (numpy.ndarray) -- 脉冲方向与 p 的夹角余弦，形状 (k,)； 零脉冲方向无定义，记为 NaN

  • suggested_insertion_time (float | None) -- 建议的中途脉冲插入时刻（弧内 |p|>1 的峰值处）， 无违例时为 None

  • suggested_insertion_position (numpy.ndarray | None) -- 建议插入点位置，形状 (3,)，km

  • message (str) -- 附加说明（端点携载误差、违例细节等）

参数:
times: ndarray
primer: ndarray
primer_magnitude: ndarray
max_magnitude: float
lawden_satisfied: bool
impulse_times: ndarray
impulse_magnitudes: ndarray
impulse_alignment_cosines: ndarray
suggested_insertion_time: float | None
suggested_insertion_position: ndarray | None
message: str = ''
class e2m2e.algorithm.transfer.multi_impulse.MultiImpulseTransfer(term0, term1, *, mu=None, dynamics=None)[源代码]

基类：object

固定端点间的多脉冲转移规划器。

变量:

  • term0 -- 出发终端（位置、速度、时刻固定）

  • term1 -- 到达终端（位置、速度、时刻固定）

  • mu -- 二体中心天体 GM，km³/s²（二体封闭必填）

  • dynamics -- CR3BP_Dynamics（三体封闭必填）

  • closure -- 默认弧段封闭方式

  • legs -- 当前方案的脉冲/弧段序列；初始为单弧，optimize() 后刷新

参数:
closure: Literal['two_body', 'three_body']
legs: list[Impulse | CoastArc]
optimize(n_impulses, bounds=None, *, backend='scipy', closure=None, x0=None, min_dt=0.001, verbose=False)[源代码]

优化 n_impulses 脉冲转移，最小化总 ΔV。

决策变量为各中途脉冲节点的时刻与位置 [t_1..t_m, r_1..r_m] （m = n_impulses − 2；时刻为相对 term0.time 的秒数，位置为 km）， 弧段按 closure 封闭，脉冲为封闭速度差。n_impulses=2 时无自由变量， 直接封闭单弧返回。

参数:

  • n_impulses (int) -- 脉冲总数（含出发与到达脉冲），≥ 2

  • bounds (dict[str, tuple] | None) -- 中途节点界限 {"t": (lo, hi), "r": (lo3, hi3)}； "t" 为相对 term0.time 的秒数区间，"r" 为位置分量盒 （km），对所有中途节点统一适用；None 时用默认界限

  • backend (str) -- NLP 后端，当前仅支持 "scipy" （SLSQP）

  • closure (Literal['two_body', 'three_body'] | None) -- 弧段封闭方式；None 时取实例默认

  • x0 (ArrayLike | None) -- 初猜决策向量；None 时中途节点在时间上均布、位置线性插值

  • min_dt (float) -- 相邻脉冲最小间隔，s

  • verbose (bool) -- 是否打印 SLSQP 迭代信息

返回:

TransferSolution，弧段数 = n_impulses − 1

返回类型:

TransferSolution

备注

SLSQP 对零脉冲初猜（目标值恰为双脉冲成本的弧上点）数值敏感：目标函数 在该平坦走廊上梯度极小，收敛判据可能提前触发、一步即停（#384）。首次 优化相对初猜改善不足时，自动从微扰初猜重试，取总 ΔV 最小者。

check_primer_vector(solution, n_samples=100, tol=0.001, closure=None)[源代码]

对给定转移解做主矢量检验（Lawden 必要条件）。

端点横截条件 p(t0) = Δv̂₀、p(tf) = Δv̂_f，协态 z = [−ṗ; p] 经 z(t) = Φ(t, t0)^{-T} z(t0) 携载（公式出处见模块 docstring）。

参数:

  • solution (TransferSolution) -- 待检验的转移解（弧段初态须为脉冲后状态）

  • n_samples (int) -- 每弧采样点数

  • tol (float) -- Lawden 判据容差（|p|≤1+tol、脉冲点 |p|∈1±tol、 共线 |cos|≥1−tol）

  • closure (Literal['two_body', 'three_body'] | None) -- 弧段重传播所用动力学；None 时取实例默认，须与产生 solution 时的封闭方式一致

返回:

PrimerVectorReport

抛出:

ValueError -- 出发或到达脉冲过小，无法确定主矢量端点方向

返回类型:

PrimerVectorReport

e2m2e.algorithm.transfer.hohmann module

HMN 霍曼直接转移：TLI 出发状态构造 + 霍曼转移物理量计算。

算法来源： - 开普勒根数→笛卡尔：Curtis (2008) Algorithm 4.2 - 霍曼转移 Δv：Curtis §6.1 / Vallado - 航迹角语义：Curtis Eq. 2.132

class e2m2e.algorithm.transfer.hohmann.TliParams(parking_alt_km, inclination_deg, flight_path_angle_deg=0.0, raan_deg=0.0, arg_perigee_deg=0.0, epoch=0.0)[源代码]

基类：object

Trans-Lunar Injection 出发参数。

语义参照 Curtis (2008) Algorithm 4.2 + Lu et al. (2021) Eqs. 1-10。

变量:

  • parking_alt_km (float) -- 停泊轨道高度 (km)，圆轨道假设 (γ=0)

  • inclination_deg (float) -- 停泊轨道倾角 (deg)

  • flight_path_angle_deg (float) -- 航迹角 (deg)，霍曼转移出发条件为 0

  • raan_deg (float) -- 升交点赤经 (deg)

  • arg_perigee_deg (float) -- 近地点幅角 (deg)

  • epoch (float | str) -- 出发历元（UTC 字符串或 JD_TDB 浮点数）

参数:
parking_alt_km: float
inclination_deg: float
flight_path_angle_deg: float = 0.0
raan_deg: float = 0.0
arg_perigee_deg: float = 0.0
epoch: float | str = 0.0
e2m2e.algorithm.transfer.hohmann.keplerian_to_cartesian(a_km, e, i_deg, omega_deg, raan_deg, nu_deg, mu=398600.4418)[源代码]

Curtis (2008) Algorithm 4.2: 开普勒根数 → ECI 笛卡尔状态。

参数:

  • a_km (float) -- 半长轴 (km)

  • e (float) -- 偏心率

  • i_deg (float) -- 倾角 (deg)

  • omega_deg (float) -- 近地点幅角 (deg)

  • raan_deg (float) -- 升交点赤经 (deg)

  • nu_deg (float) -- 真近点角 (deg)

  • mu (float) -- 引力参数 (km³/s²)

返回:

(r_eci, v_eci) in (km, km/s)，shape 均为 (3,)

返回类型:

tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]]

e2m2e.algorithm.transfer.hohmann.construct_departure_state(params, mu_earth=398600.4418, r_earth=6378.1363)[源代码]

TLI 参数 → ECI 出发状态向量。

简化路径（γ=0，圆停泊轨道，霍曼转移标准出发条件）： 1. r_park = r_earth + parking_alt_km 2. v_park = √(mu_earth / r_park) 3. r_pf = [r_park, 0, 0]ᵀ; v_pf = [0, v_park, 0]ᵀ 4. R = R₃(-Ω)·R₁(-i)·R₃(-ω) 5. r_eci = R·r_pf; v_eci = R·v_pf

非零航迹角路径（γ≠0）：尚未实现，抛出 NotImplementedError。

参数:

  • params (TliParams) -- TLI 出发参数

  • mu_earth (float) -- 地球引力参数 (km³/s²)

  • r_earth (float) -- 地球赤道半径 (km)

返回:

(r0, v0) in (km, km/s)，shape 均为 (3,)

返回类型:

tuple[ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]]

e2m2e.algorithm.transfer.hohmann.hohmann_delta_v(r1, r2, mu=398600.4418)[源代码]

经典霍曼转移 Δv（Curtis §6.1 / Vallado）。

参数:

  • r1 (float) -- 出发轨道半径 (km)

  • r2 (float) -- 到达轨道半径 (km)

  • mu (float) -- 引力参数 (km³/s²)

返回:

(dv1, dv2) in km/s

返回类型:

tuple[float, float]

e2m2e.algorithm.transfer.hohmann.hohmann_tof(r1, r2, mu=398600.4418)[源代码]

霍曼转移飞行时间（半椭圆周期）。

参数:

  • r1 (float) -- 出发轨道半径 (km)

  • r2 (float) -- 到达轨道半径 (km)

  • mu (float) -- 引力参数 (km³/s²)

返回:

飞行时间 (秒)

返回类型:

float

e2m2e.algorithm.transfer.hohmann.scan_lambert_delta_v(r0, v0_park, r_target, v_target, tof_grid, mu=398600.4418)[源代码]

用 Lambert 批量扫描找最优 tof。

对每个 tof 调用 solve_lambert_batch，计算总 Δv = |v0_lambert - v0_park| + |vf_lambert - v_target|， 返回 (最优 tof, 最优 v0_lambert, 最优 vf_lambert)。

参数:
返回:

(最优 tof, 最优 v0_lambert, 最优 vf_lambert)

抛出:

ValueError -- 所有 tof 均无解。

返回类型:

tuple[float, ndarray[tuple[Any, ...], dtype[float64]], ndarray[tuple[Any, ...], dtype[float64]]]

e2m2e.algorithm.transfer.hohmann.ephemeris_shoot_transfer(dynamics, t0, r0, v0, tof, n_patches=5, max_iter=30, tolerance=1e-06)[源代码]

用 MultipleShooting 在给定动力学模型下修正 Lambert 初猜。

步骤：

  1. 沿 Lambert 初猜弧段均匀采样 n_patches 个 patch point 时刻。

  2. 用动力学模型 dynamics.propagate 从 (r0, v0) 积分整条弧段， 在各 patch point 时刻插值取状态作为初猜。

  3. 调用 MultipleShooting.correct() 收敛。

  4. 返回 e2m2e.algorithm.solver.multiple_shooting.MultipleShootingResult。

参数:

  • dynamics (Any) -- 动力学对象，需提供 propagate(state, t_span, with_stm=True) 和 equations_of_motion(t, state) 接口。

  • t0 (float) -- 出发时刻（秒，动力学模型的时间基准）。

  • r0 (ndarray[tuple[Any, ...], dtype[float64]]) -- 出发位置 (3,) km。

  • v0 (ndarray[tuple[Any, ...], dtype[float64]]) -- 出发速度 (3,) km/s，Lambert 解。

  • tof (float) -- 飞行时间 (秒)。

  • n_patches (int) -- patch point 数量，默认 5。

  • max_iter (int) -- 多重打靶最大迭代次数，默认 30。

  • tolerance (float) -- 收敛容差，默认 1e-6。

返回:

打靶修正结果。

返回类型:

MultipleShootingResult

抛出:

ValueError -- n_patches < 2。

e2m2e.algorithm.transfer.low_energy module

流形拼接与低能转移流水线模块。

低能转移初猜生成（郑越、赵敏 2023 流程的产品化）：

  1. 出发轨道不稳定流形与目标轨道稳定流形各自传播到同一庞加莱截面；

  2. patch_manifolds() 把两管穿越点交给默认 Rust 数值核完成两两配对、 位置/速度差和加权排序；

  3. design_low_energy_transfer() 以 ThreeBodyLambert 打靶闭合弧段。

Python 侧保留流形对象与高层编排；backend="python" 只作显式等价性参照， Rust 不可用时不自动回退。

class e2m2e.algorithm.transfer.low_energy.PatchCandidate(i_a, i_b, state_a, state_b, delta_r, delta_v, cost)[源代码]

基类：object

流形管拼接候选（同一截面上两个穿越点的配对）。

变量:

  • i_a (int) -- 管 A 穿越点索引

  • i_b (int) -- 管 B 穿越点索引

  • state_a (numpy.ndarray) -- 管 A 穿越态（无量纲六维向量）

  • state_b (numpy.ndarray) -- 管 B 穿越态（无量纲）

  • delta_r (float) -- 位置差（无量纲）

  • delta_v (float) -- 速度差（无量纲）

  • cost (float) -- 加权拼接代价，w_r·位置差 + w_v·速度差

参数:
i_a: int
i_b: int
state_a: ndarray
state_b: ndarray
delta_r: float
delta_v: float
cost: float
e2m2e.algorithm.transfer.low_energy.patch_manifolds(m_a, m_b, section, weights=(1.0, 1.0), *, backend='rust', parallel=None, n_workers=None, progress_callback=None)[源代码]

两流形管在同一截面的穿越点两两配对，按拼接代价升序输出。

默认 backend='rust'：配对、范数、代价和排序均由 Rust 执行；Rust 扩展缺失时直接报错。backend='python' 仅保留作显式等价性对照，绝不 作为运行时回退。截面对象和流形管遍历仍由 Python 编排层负责。

参数:

  • m_a (ManifoldTube) -- 管 A（如出发轨道不稳定流形）

  • m_b (ManifoldTube) -- 管 B（如目标轨道稳定流形）

  • section (PoincareSection) -- 庞加莱截面

  • weights (tuple[float, float]) -- (w_r, w_v) 位置/速度差权重（无量纲量纲下的相对权重）

  • backend (Literal['rust', 'python']) -- 'rust'``（默认）或显式参照 ``'python'

  • parallel (bool | None) -- Rust 路径是否使用 Rayon；None 由环境变量决定

  • n_workers (int | None) -- Rust Rayon 线程数；None 使用全局线程池

  • progress_callback (Callable[[int], Any] | None) -- 每完成一个截面态配对调用，Rust 侧可合并增量

返回:

按 cost 升序排列的候选列表；任一管无穿越时返回空列表

返回类型:

list[PatchCandidate]

e2m2e.algorithm.transfer.low_energy.design_low_energy_transfer(departure, target, epoch=None, model='cr3bp')[源代码]

低能转移流水线：流形拼接初猜 + CR3BP 打靶闭合。

流程：出发轨道不稳定流形 + 目标轨道稳定流形（± 分支都试）→ 次天体近拱点截面拼接取最优候选 → 出发弧（流形弧，精确）+ ThreeBodyLambert 把拼接点之后闭合到目标轨道。

脉冲构成：出发脉冲（上出发流形）+ 拼接脉冲（截面处）+ 到达脉冲（入目标流形）。

参数:

  • departure (OrbitTerminal) -- 出发轨道终端

  • target (Orbit) -- 目标周期轨道（须关联 system 且 period 已知）

  • epoch -- 参考历元（预留；星历转换未接入，见下）

  • model (Literal['cr3bp']) -- 动力学模型，当前仅支持 "cr3bp"

返回:

TransferSolution，两段弧（物理单位）

抛出:

ValueError -- model 不支持，或两流形管在截面上无穿越点

返回类型:

TransferSolution

TODO: 星历转换（CR3BP 闭合解 → 星历模型）未接入；接入时复用设计链路

e2m2e.algorithm.design 的 Rust 多重打靶修正，epoch 参数即为其入口。

e2m2e.algorithm.transfer.lga module

LGA 月球引力辅助间接转移：弹道搜索 + 近月飞越处理。

无动力 LGA（unpowered lunar gravity assist）：飞越段 Δv = 0， 总 Δv 仅来自出发脉冲和到达脉冲。

算法来源：Parker & Anderson (2014) §4.3 + Shi et al. (2025) 搜索编排。 CR3BP 直接传播穿越（非 patched conic），近月点检测复用 PoincareSection.periapsis("moon") + detect_crossings()。

class e2m2e.algorithm.transfer.lga.LgaSearchParams(departure_phase_range=(0.0, 6.283185307179586), n_departure_phase=50, out_of_plane_halfwidth_deg=2.5, n_out_of_plane=9, tof_range=(5.0, 45.0), n_tof=50, perilune_alt_min=100.0, perilune_alt_max=10000.0, max_total_dv=25.0, n_propagation_samples=500)[源代码]

基类：object

LGA 弹道搜索参数。

出发速度大小固定为略超逃逸速度，方向由两个角度参数化：面内角 （departure_phase，在停泊轨道切向 × 径向平面内）与面外角 （out-of-plane，绕出发轨道面法向）。面外角网格覆盖经验可行带： 其中心随倾角缓慢负移（约 -0.08·δ，实测倾角 0°–90°），修复了 共面网格下发射倾角 ≥ 20° 时全部候选被近月高度筛掉的问题 （issue #512）。

近月点高度由传播自然决定，不作为独立搜索变量， 仅用于筛选可行候选（Parker & Anderson 2014 §3.4）。

变量:

  • departure_phase_range (tuple[float, float]) -- 出发相位角范围 (min, max)，弧度，[0, 2pi)

  • n_departure_phase (int) -- 出发相位角网格点数

  • out_of_plane_halfwidth_deg (float) -- 面外角网格半宽 (deg)，对称展开于经验可行带 中心（约 -0.08·出发轨道面倾角）两侧

  • n_out_of_plane (int) -- 面外角网格点数（1 退化为纯共面搜索）

  • tof_range (tuple[float, float]) -- 飞行时间范围 (min, max)，天（LGA 典型 15-45 天，Shi et al. 2025）

  • n_tof (int) -- TOF 网格点数

  • perilune_alt_min (float) -- 近月点高度下限 (km)，低于此值的候选丢弃（避免撞击月面）

  • perilune_alt_max (float) -- 近月点高度上限 (km)，高于此值的候选丢弃（飞越不够近）

  • max_total_dv (float) -- 最大总 Δv 筛选阈值，km/s（超过的候选丢弃； 候选的 CR3BP 无量纲 Δv 按特征速度换算到 km/s 后比较）

参数:
departure_phase_range: tuple[float, float] = (0.0, 6.283185307179586)
n_departure_phase: int = 50
out_of_plane_halfwidth_deg: float = 2.5
n_out_of_plane: int = 9
tof_range: tuple[float, float] = (5.0, 45.0)
n_tof: int = 50
perilune_alt_min: float = 100.0
perilune_alt_max: float = 10000.0
max_total_dv: float = 25.0
n_propagation_samples: int = 500
class e2m2e.algorithm.transfer.lga.LgaCandidate(departure_phase, out_of_plane_angle, tof_sec, departure_state, perilune_state, perilune_alt_km, perilune_time_dim, arrival_state, dv_departure, dv_arrival, total_dv, jacobi_departure, jacobi_arrival, arrival_time_dim, status, cause, message)[源代码]

基类：object

单个 LGA 候选解（无动力 LGA）。

飞越段 Δv = 0（仅利用月球引力），总 Δv = 出发脉冲 + 到达脉冲。

dv 字段（dv_departure / dv_arrival / total_dv）均为 CR3BP 无量纲单位； 换算 km/s 需乘以 CR3BP_System.characteristic_velocity。

参数:
departure_phase: float
out_of_plane_angle: float
tof_sec: float
departure_state: ndarray
perilune_state: ndarray
perilune_alt_km: float
perilune_time_dim: float
arrival_state: ndarray
dv_departure: float
dv_arrival: float
total_dv: float
jacobi_departure: float
jacobi_arrival: float
arrival_time_dim: float
status: ConvergenceState
cause: FailureCause
message: str
e2m2e.algorithm.transfer.lga.search_lga_trajectories(departure_state, target_state, system, dynamics, params=None)[源代码]

LGA 弹道网格搜索。

搜索空间：出发速度方向（面内角 × 面外角）× 飞行时间（TOF）三维网格。

出发态为 LEO 停泊轨道（圆轨道速度）。对每个 (angle, b, tof) 组合：

  1. 从停泊轨道出发，沿方向施加逃逸速度级的 TLI 脉冲 （v_tli = v_escape * 1.01，方向由面内/面外角参数化，确保超逃逸速度）

  2. CR3BP 前向传播 tof 时间，检测近月点（PoincareSection.periapsis("moon")）

  3. 近月点高度在 perilune_alt_range 内的保留

  4. 继续传播，检测轨迹首次到达目标轨道距离（r_target）的时刻

  5. Δv_dep = |v_departure - v_parking| Δv_arr = |v_at_target_distance - v_target|

  6. 物理总 Δv（无量纲 Δv × 特征速度）< max_total_dv 的保留为候选

departure_phase_range 控制出发速度面内方向角范围（弧度）： 0 = 纯切向（沿停泊轨道切向），pi/2 = 径向向外。 面外角网格覆盖经验可行带（中心约 -0.08·出发轨道面倾角， ±out_of_plane_halfwidth_deg 对称展开，issue #512 实测倾角 0°–90°）。 共面出发态（倾角 0）的网格对称于 0，纯共面行为是共面候选的子集。

参数:
返回:

带最终状态的候选搜索结果；可按序列方式读取候选。

返回类型:

CandidateSearchResult[LgaCandidate]

e2m2e.algorithm.transfer.wsb module

WSB 太阳引力辅助间接转移：BCR4BP 弹道搜索 + 到达段精化。

弱稳定边界（Weak Stability Boundary）转移利用地月 BCR4BP 动力学中的 太阳引力摄动，在近月点附近使航天器的相对月球 Kepler 能量 H₂ < 0 （弹道捕获判据——无需制动脉冲即被月球束缚），自然被月球捕获后可由 小量圆化脉冲稳定。总 Δv 仅来自出发脉冲和到达脉冲。

搜索空间：sun_phase × departure_phase × tof 三维网格。默认 Rust 后端把 候选参数化、BCR4BP 传播、截面检测和筛选交给 Rayon；Python 实现只在调用方 显式指定 backend="python" 时作为等价性参照，绝不自动回退。

BCR4BP 旋转系→惯性系速度修正（任务 #259 方案）：

v_rel_moon = (vx - y, vy + x - (1-μ), vz)

其中 (1-μ, 0, 0) 为月球在旋转系中的位置，减去月球惯性速度 ω × r_moon = (0, 1-μ, 0) 得到相对月球的惯性系速度。

class e2m2e.algorithm.transfer.wsb.WsbSearchParams(sun_phase_range=(0.0, 6.283185307179586), n_sun_phase=50, departure_phase_range=(0.0, 6.283185307179586), n_departure_phase=180, tof_range=(90.0, 150.0), n_tof=50, tli_speed_factor=0.99, rtol=1e-09, atol=1e-09, max_steps=20000, perilune_alt_min=100.0, perilune_alt_max=10000.0, max_total_dv=5.0, h2_energy_threshold=0.0, n_propagation_samples=500)[源代码]

基类：object

WSB 弹道搜索参数。

搜索空间：太阳相位角 × 出发相位角 × 飞行时间（TOF）。 近月点高度由传播自然决定，不作为独立搜索变量。 弹道捕获由 H₂ < 0 判定（Belbruno & Miller 1993）。

变量:

  • sun_phase_range (tuple[float, float]) -- 太阳相位角范围 (min, max)，弧度，[0, 2pi)

  • n_sun_phase (int) -- 太阳相位角网格点数

  • departure_phase_range (tuple[float, float]) -- 出发相位角范围 (min, max)，弧度，[0, 2pi)， 即出发点在停泊轨道上的滑行角（绕地球旋转，改变月地几何）

  • n_departure_phase (int) -- 出发相位角网格点数

  • tof_range (tuple[float, float]) -- 飞行时间范围 (min, max)，天（WSB 典型 90-150 天）

  • n_tof (int) -- TOF 网格点数

  • tli_speed_factor (float) -- TLI 脉冲速度与逃逸速度之比。典型值 < 1 （如 0.99，远地点略超月球轨道的奔月轨道）；= 1 为抛物线逃逸

  • rtol (float) -- 传播相对容差（网格筛选级，粗干精化；精化由 ThreeBodyLambert 打靶负责）

  • atol (float) -- 传播绝对容差（同上）

  • max_steps (int) -- 筛选阶段单条轨迹最大积分步数（仅 Rust 后端生效）。超过 即判为传播失败丢弃；真候选典型几百步，深混沌擦月轨迹需几十万步 且无筛选价值。Python 参照后端不截断，保持精确语义

  • n_propagation_samples (int) -- 传播采样点数

  • perilune_alt_min (float) -- 近月点高度下限 (km)

  • perilune_alt_max (float) -- 近月点高度上限 (km)

  • max_total_dv (float) -- 最大总 Δv 筛选阈值 (km/s)

  • h2_energy_threshold (float) -- H₂ 能量阈值（无量纲），H₂ < 此值的候选保留（弹道捕获）

  • n_propagation_samples -- 传播采样点数

参数:
sun_phase_range: tuple[float, float] = (0.0, 6.283185307179586)
n_sun_phase: int = 50
departure_phase_range: tuple[float, float] = (0.0, 6.283185307179586)
n_departure_phase: int = 180
tof_range: tuple[float, float] = (90.0, 150.0)
n_tof: int = 50
tli_speed_factor: float = 0.99
rtol: float = 1e-09
atol: float = 1e-09
max_steps: int = 20000
perilune_alt_min: float = 100.0
perilune_alt_max: float = 10000.0
max_total_dv: float = 5.0
h2_energy_threshold: float = 0.0
n_propagation_samples: int = 500
class e2m2e.algorithm.transfer.wsb.WsbCandidate(sun_phase0, departure_phase, tof_sec, departure_state, perilune_state, perilune_alt_km, perilune_time_dim, arrival_state, h2_kepler, dv_departure, dv_arrival, total_dv, arrival_time_dim, status, cause, message)[源代码]

基类：object

单个 WSB 候选解（无动力月球飞越 + BCR4BP 太阳摄动）。

飞越段 Δv = 0，总 Δv = 出发脉冲 + 到达脉冲。

参数:
sun_phase0: float
departure_phase: float
tof_sec: float
departure_state: ndarray
perilune_state: ndarray
perilune_alt_km: float
perilune_time_dim: float
arrival_state: ndarray
h2_kepler: float
dv_departure: float
dv_arrival: float
total_dv: float
arrival_time_dim: float
status: ConvergenceState
cause: FailureCause
message: str
e2m2e.algorithm.transfer.wsb.compute_kepler_energy_moon(state, mu)[源代码]

BCR4BP 旋转系中相对月球的开普勒能量（无量纲）。

速度从旋转系转换到惯性系并减去月球惯性速度，得到相对月球的速度：

v_rel = (vx - y, vy + x - (1-μ), vz)

H₂ = 0.5 * |v_rel|² - μ / |r - r_moon|

符号约定（Belbruno 2010 Eq 2.8）：

H₂ < 0: 弹道捕获（束缚轨道，无需制动脉冲即被月球束缚） H₂ = 0: WSB 边界（抛物线） H₂ > 0: 双曲飞越（超逃逸速度）

参数:

  • state (ndarray) -- 旋转系无量纲状态 (6,)，[x, y, z, vx, vy, vz]

  • mu (float) -- 地月质量参数

返回:

无量纲开普勒能量

返回类型:

float

e2m2e.algorithm.transfer.wsb.search_wsb_trajectories(departure_state, target_state, system, params=None, *, backend='rust', parallel=None, n_workers=None, progress_callback=None)[源代码]

WSB 弹道三维网格搜索。

默认 backend='rust'：BCR4BP 传播、近月点检测、候选筛选和 Rayon 并行均在 Rust 内完成。backend='python' 仅供显式等价性对照，绝不 在 Rust 扩展缺失或运行失败时自动回退。

参数:
返回类型:

CandidateSearchResult[WsbCandidate]

e2m2e.algorithm.transfer.lowthrust_shooting module

低推力多段直接打靶求解器。

在地基 VariableMassFiniteBurn / propagate_compiled_lowthrust （7D 可变 质量受控传播，commit b66fa88）之上，建第一个低推力最优控制闭环求解器： 单弧多段直接打靶，min-fuel，固定时间，段内常量控制。

## 数学模型

固定初态 [r0, v0, m0]，把 [t0, tf] 均分成 N 段。决策变量为各段常量 控制 (throttle_i, u_i)，方向存原始向量（内部归一化），共 4N 维。传播 为接龙：段 i 在段内常量控制下积分，段末 7D 状态作段 i+1 初态，串行到末态。 目标为最大化末态质量（min-fuel）；约束为末态位置速度匹配目标（6 条等式）。

这是航天界低推力「先打靶后配点」的标准入门路线。详见 docs/plans/lowthrust-shooting-prd.md。

class e2m2e.algorithm.transfer.lowthrust_shooting.EngineConfig(t_max, isp)[源代码]

基类：object

推进配置：最大推力与比冲。

与 VariableMassFiniteBurn 的常量推力语义对齐： 打靶求解器在各段用满油门或部分油门（throttle ∈ [0,1]）施加推力。

参数:

  • t_max (float) -- 最大推力（N）。

  • isp (float) -- 比冲（s）。

t_max: float
isp: float
class e2m2e.algorithm.transfer.lowthrust_shooting.LowThrustSegment(throttle, direction)[源代码]

基类：object

单段常量控制：throttle + 惯性系方向（归一化后的单位向量）。

参数:
throttle: float
direction: ndarray[tuple[Any, ...], dtype[floating]]
class e2m2e.algorithm.transfer.lowthrust_shooting.LowThrustShootingSolution(time, states, segments, final_mass, fuel_consumed, status, cause, message, n_iter)[源代码]

基类：object

低推力打靶求解结果。

对齐 TransferSolution 风格，额外携带控制 历史与 7D 状态（含质量剖面）。

变量:
参数:
time: ndarray[tuple[Any, ...], dtype[floating]]
states: ndarray[tuple[Any, ...], dtype[floating]]
segments: tuple[LowThrustSegment, ...]
final_mass: float
fuel_consumed: float
status: ConvergenceState
cause: FailureCause
message: str
n_iter: int
class e2m2e.algorithm.transfer.lowthrust_shooting.LowThrustShooting(system, forces, engine, initial_state, initial_mass, target_state, t0, tf, *, backend='rust')[源代码]

基类：object

单弧多段低推力直接打靶求解器（min-fuel）。

固定初态与目标末态位置/速度、固定飞行时间，以各段常量控制 (throttle, 方向) 为决策变量，最小化燃料消耗（最大化末态质量）。 传播接龙复用地基 propagate_compiled_lowthrust() （7D 受控动力学）。

参数:

  • system (System) -- 动力学系统，提供 coordinate_system 与 origin。

  • forces (Sequence[PhysicalModel]) -- 非推力力模型列表（重力等）。各 force 须支持 to_rust_spec （否则求解器在构造时抛错）。

  • engine (EngineConfig) -- 推进配置（最大推力、比冲）。

  • initial_state (npt.ArrayLike) -- 出发状态 [r, v]，(6,)，km / km/s。

  • initial_mass (float) -- 初始质量（kg）。

  • target_state (npt.ArrayLike) -- 目标末态 [r, v]，(6,)，km / km/s。

  • t0 (float) -- 起始时刻（SPICE et 秒）。

  • tf (float) -- 终止时刻（SPICE et 秒）。

  • backend (str) -- 数值评估后端；默认 "rust"，"python" 保留原实现作 等价性对照与降级。

solve_from_qlaw(n_segments, target_oe, forces, *, step=120.0, use_analytic_jac=True, maxiter=100, verbose=False)[源代码]

用 Q-law 生成初猜，再解析雅可比打磨。

两级流程（gap-analysis）：Q-law 前向反馈积分产出次优控制历史 （qlaw_guess()），喂 solve() 做 min-fuel 最优控制打磨。Q-law 解决「满推力初猜推过头」的发散问题。

参数:

  • n_segments (int) -- 段数 N（Q-law 重采样 + 求解器决策变量数 = 3N）。

  • target_oe (tuple[float, float, float]) -- Q-law 目标 (a_T, e_T, i_T) （只控 a,e,i）。

  • forces (Sequence[PhysicalModel]) -- 非推力力模型（与构造时一致，Q-law 用于查 μ）。

  • step (float) -- Q-law 前向积分步长（秒）。

  • use_analytic_jac (bool) -- 打磨阶段用解析雅可比。

  • maxiter (int) -- SLSQP 最大迭代。

  • verbose (bool) -- 打印进度。

返回类型:

LowThrustShootingSolution

solve(n_segments, *, x0=None, throttle_bounds=(0.0, 1.0), use_analytic_jac=True, ftol=1e-09, maxiter=200, verbose=False)[源代码]

求解 min-fuel 低推力打靶。

参数:

  • n_segments (int) -- 段数 N，≥ 1。决策变量每段 (throttle, θ₁, θ₂)， 总数 3N （角度参数化方向，Du 2024 式 5）。

  • x0 (ArrayLike | None) -- 初猜决策向量 (3N,)；None 时 throttle 全满、方向角对齐初速。

  • throttle_bounds (tuple[float, float]) -- throttle 上下界，默认 (0, 1)。

  • use_analytic_jac (bool) -- True 时用解析雅可比（灵敏度方程，每迭代 1 次传播）； False 回退 SLSQP 数值差分（每迭代 3N+1 次传播）。

  • ftol (float) -- SLSQP 目标容差。

  • maxiter (int) -- SLSQP 最大迭代次数。

  • verbose (bool) -- 是否打印 SLSQP 迭代信息。

返回:

LowThrustShootingSolution。

返回类型:

LowThrustShootingSolution

e2m2e.algorithm.transfer.lowthrust_collocation module

低推力 Hermite-Simpson 配点求解器。

与 LowThrustShooting （直接打靶） 并列的直接法求解器。把节点状态与控制都作为决策变量，用 Hermite-Simpson 缺陷 约束保证段间动力学连续——比单弧打靶更鲁棒、初猜要求低（Q-law 输出直接可用）。

## Hermite-Simpson 配点

把 [t0,tf] 分 N 段（N+1 节点），决策变量 = 节点状态 {x_i} （7D）+ 节点控制 {p_i=(throttle,θ₁,θ₂)} （3D），共 10(N+1)。缺陷约束（每段 7 维）：

`text x_c = (x_i + x_{i+1})/2 + (dt/8)(f_i − f_{i+1}) 缺陷_i = x_{i+1} − x_i − (dt/6)(f_i + 4·f(x_c, p_c) + f_{i+1}) `

缺陷为零 ⟺ 节点间动力学连续（Simpson 三阶积分与状态差一致）。

详见 docs/plans/lowthrust-collocation-prd.md。

class e2m2e.algorithm.transfer.lowthrust_collocation.LowThrustCollocation(system, forces, engine, initial_state, initial_mass, target_state, t0, tf, *, backend='rust')[源代码]

基类：object

低推力 Hermite-Simpson 配点求解器（min-fuel）。

与 LowThrustShooting （直接打靶）并列：打靶适合小规模高精度，配点 适合大规模鲁棒。两者复用 EngineConfig/LowThrustSegment/Q-law 初猜/ LowThrustShootingSolution。

参数:

  • system (System) -- 动力学系统（提供 origin）。

  • forces (Sequence[PhysicalModel]) -- 非推力力模型，须支持 to_rust_spec。

  • engine (EngineConfig) -- 推进配置。

  • initial_state (npt.ArrayLike) -- 出发状态 [r,v]，(6,)。

  • initial_mass (float) -- 初始质量 kg。

  • target_state (npt.ArrayLike) -- 目标末态 [r,v]，(6,)。

  • t0 (float) -- 起止时刻。

  • tf (float) -- 起止时刻。

  • backend (str) -- 数值评估后端；默认 "rust"，"python" 保留原实现作 等价性对照与降级。

solve(n_segments, *, z0=None, ftol=1e-09, maxiter=300, verbose=False)[源代码]

求解 min-fuel 配点 NLP。

参数:

  • n_segments (int) -- 段数 N（节点数 N+1，决策变量 10(N+1)）。

  • z0 (ArrayLike | None) -- 初猜决策向量；None 时节点状态沿初末线性插值、控制满推沿初速。

  • ftol (float) -- SLSQP 目标容差。

  • maxiter (int) -- SLSQP 最大迭代。

  • verbose (bool) -- 打印 SLSQP 进度。

返回:

LowThrustShootingSolution （节点状态 + 各段控制）。

返回类型:

LowThrustShootingSolution

solve_from_qlaw(n_segments, target_oe, forces, *, step=120.0, maxiter=200, verbose=False)[源代码]

用 Q-law 生成初猜，再配点打磨。

参数:
返回类型:

LowThrustShootingSolution

e2m2e.algorithm.transfer.qlaw module

Q-law 低推力初猜生成器（Lyapunov 反馈律）。

用 Q-law（Petropoulos；Holt 2024 式 6-10）做低推力转移的初猜生成：前向反馈 积分产出次优控制历史，喂 LowThrustShooting 做解析雅可比打磨。是 gap-analysis「Q-law 作初猜 → 打靶优化」两级流程的上半段。

## 最简版（控 a, e, i）

只控半长轴、偏心率、倾角，规避 ω̇/Ω̇ 的 1/e、1/sin i 奇异。Q 函数：

` Q = Σ_{X∈{a,e,i}} (δ(X, X_T) / max_ν(Ẋ))² `

控制律（Holt 式 8，最速下降）：u_RTN = −f·BᵀMᵀ/||MB||，其中 f=T/m、 B 是 Gauss 方程 3×3 子阵、M=∂Q/∂[a,e,i]（中心差分）。油门固定满推。

## 架构：Rust 反馈积分 + Python 初猜组装

Rust 内核在一次调用中完成逐步重算方向的 Q-law 自适应反馈积分与 Q 函数评估。 Python 侧只解析参数、从 Rust 轨迹选择段中点并组装求解器需要的控制段，不保留 Python 数值降级路径；独立公开的 rv_to_keplerian() 维持既有兼容行为， 不参与反馈积分。

e2m2e.algorithm.transfer.qlaw.rv_to_keplerian(r, v, mu)[源代码]

笛卡尔状态 → 经典开普勒根数 (a, e, i, Ω, ω, ν)。

标准算法（Bate-Müller-White）。角度单位弧度，a 单位同 r（km）。 圆轨道（e≈0）ω/ν 单独无意义，但 ω+ν（近地点幅角+真近点角=纬度幅角）稳定。

参数:
返回类型:

tuple[float, float, float, float, float, float]

e2m2e.algorithm.transfer.qlaw.qlaw_guess(system, forces, engine, initial_state, initial_mass, target_oe, t0, tf, n_segments, *, step=60.0, verbose=False)[源代码]

Q-law 前向反馈积分，返回 (决策向量 y(3N), segments, Q 历史)。

Q-law 反馈积分、方向和 Q 函数评估由 Rust 内核一次完成；Python 侧只把 Rust 轨迹重采样为 n_segments 段常量控制，喂给求解器。

参数:

  • system (System) -- 动力学系统（取 origin 与中心体 μ）。

  • forces (Sequence[PhysicalModel]) -- 非推力力模型（PointMassGravity 等，用于查 μ）。

  • engine (EngineConfig) -- 推进配置。

  • initial_state (npt.ArrayLike) -- 出发状态 [r,v] (6,)。

  • initial_mass (float) -- 初始质量 kg。

  • target_oe (tuple[float, float, float]) -- 目标 (a_T, e_T, i_T)（只控 a,e,i）。

  • t0 (float) -- 起止时刻。

  • tf (float) -- 起止时刻。

  • n_segments (int) -- 重采样的段数（求解器决策变量数 = 3N）。

  • step (float) -- 前向积分步长（秒），默认 60。方向跟随精度由它决定。

  • verbose (bool) -- 打印每段进度。

返回:

(y, segments, q_history, final_state)：y 是求解器决策向量 (3N,)，segments 是各段常量控制，q_history 是各段段中点的 Q 值，final_state 是 Q-law 前向 积分的真实末态 7D（含质量），供测试验证根数收敛（注意：求解器用 y 重建 会因段内固定方向而与 final_state 略有差异，final_state 是连续反馈的真实结果）。

返回类型:

tuple[np.ndarray, list[LowThrustSegment], np.ndarray, np.ndarray]

e2m2e.algorithm.transfer.qlaw.make_shooter_for_qlaw(system, forces, engine, initial_state, initial_mass, target_state, t0, tf)[源代码]

便利构造：用同样参数建一个 LowThrustShooting，供 Q-law 初猜打磨。

参数:
返回类型:

LowThrustShooting

e2m2e.algorithm.transfer.nlp_core module

NLP 优化公共抽象。

提供 NLPOptimizationVariables 数据结构与后端无关的辅助类型， 作为 SciPy / COPT 后端之间共享的"问题描述"层。

class e2m2e.algorithm.transfer.nlp_core.NLPOptimizationVariables(alpha=0.0, transfer_time=0.0, t_ins=0.0)[源代码]

基类：object

NLP 优化变量

优化变量: y = (α, T, t_ins)，分别表示切向速度比、转移时间与 目标轨道上的插入时间。

变量:

  • alpha (float) -- 切向速度比

  • transfer_time (float) -- 转移时间 T

  • t_ins (float) -- 从轨道远地点到插入点的时间

参数:
alpha: float = 0.0
transfer_time: float = 0.0
t_ins: float = 0.0
to_array()[源代码]

转换为 numpy 数组。

返回:

[alpha, transfer_time, t_ins] 一维数组。

返回类型:

ndarray

classmethod from_array(arr)[源代码]

从 numpy 数组创建实例。

参数:

arr (ndarray) -- [alpha, transfer_time, t_ins] 一维数组。

返回:

对应的 NLPOptimizationVariables 实例。

返回类型:

NLPOptimizationVariables

e2m2e.algorithm.transfer.nlp_scipy module

SciPy SLSQP 后端。

把原先嵌入 DROTRONLPOptimizer 的 SciPy SLSQP 求解循环抽出为顶层函数 solve_with_scipy()，由 DROTRONLPOptimizer.optimize 调用。SLSQP 是 DRO→RO 转移优化的默认求解器， 无需额外依赖，仅依赖 scipy>=1.10。

e2m2e.algorithm.transfer.nlp_scipy.solve_with_scipy(optimizer, *, initial_guess=None, alpha_range=None, transfer_time_range=None, t_ins_range=None, use_relaxed_velocity_constraint=None, velocity_angle_constraint=None, verbose=None)[源代码]

使用 SciPy SLSQP 求解 DRO→RO 转移 NLP。

数学形式与论文 Cui et al. (2025) Section III.B 一致：最小化 \(\Delta v_1 + \Delta v_2\)，约束包括位置连续性、速度平行性 （或松弛为不等式）以及变量范围。

参数:

  • optimizer (DROTRONLPOptimizer) -- 已设置 alpha_range / transfer_time_range / t_ins_range 的 DROTRONLPOptimizer。

  • initial_guess (NLPOptimizationVariables | None) -- 初始猜测 (α, T, t_ins)；默认 (1, 10, 5)。

  • alpha_range (tuple[float, float] | None) -- 覆盖 optimizer.alpha_range。

  • transfer_time_range (tuple[float, float] | None) -- 覆盖 optimizer.transfer_time_range。

  • t_ins_range (tuple[float, float] | None) -- 覆盖 optimizer.t_ins_range。

  • use_relaxed_velocity_constraint (bool | None) -- 是否使用松弛速度约束；None 时取构造配置。

  • velocity_angle_constraint (float | None) -- 松弛速度约束角度（弧度）；None 时取构造配置。

  • verbose (bool | None) -- 是否打印迭代信息；None 时取构造配置。

返回:

TransferOptimizationResult，包含优化详情与转移类型分类。

返回类型:

TransferOptimizationResult

e2m2e.algorithm.transfer.nlp_copt module

COPT NLP 后端。

封装杉数科技商业优化求解器 COPT（Cardinal Optimizer）的非线性规划调用， 供 DROTRONLPOptimizer 选用。

未安装 coptpy 时：本模块仍可被导入（coptpy 退化为 None）， COPTNLPSolver 类不定义；optimize_with_copt() 默认直接报错 （fallback_to_scipy=False，ADR 0020 决策 4：不隐式换后端），显式传 fallback_to_scipy=True 才回退 SciPy 求解。

e2m2e.algorithm.transfer.nlp_copt.optimize_with_copt(optimizer, initial_guess=None, *, fallback_to_scipy=False, max_iter=1000, threads=1, bar_threads=1, time_limit=None, scipy_fallback_kwargs=None)[源代码]

使用 COPT 求解 NLP（与 data_processing_module 中用法一致： cp.Envr / createModel / COPT.Param / solve）。

数学形式与 e2m2e.algorithm.transfer.nlp_scipy.solve_with_scipy() 相同 （等式约束 + 最小化 Δv）。

参数:

  • optimizer (DROTRONLPOptimizer) -- 已设置 alpha_range / transfer_time_range / t_ins_range 的 DROTRONLPOptimizer

  • initial_guess (NLPOptimizationVariables | None) -- 初始猜测 (α, T, t_ins)；默认 (1, 10, 5)

  • fallback_to_scipy (bool) -- COPT 不可用或求解失败时是否回退 SciPy SLSQP。 默认 False：COPT 缺失/失败即报错（ADR 0020 决策 4，资源 缺失不隐式换后端）；显式传 True 才保留回退。

  • max_iter (int) -- COPT.Param.NLPIterLimit （最大迭代数）

  • bar_threads (int) -- COPT.Param.Threads / BarThreads （Python 回调建议为 1）

  • time_limit (float | None) -- 若给定，则设置 COPT.Param.TimeLimit （秒）， 与参考脚本中 MILP 用法一致

  • scipy_fallback_kwargs (dict[str, Any] | None) -- 回退时传给 optimizer.optimize 的额外参数

  • threads (int)

  • bar_threads

返回:

TransferOptimizationResult

返回类型:

TransferOptimizationResult

e2m2e.algorithm.transfer.nsga2 module

NSGA-II 多目标优化器（主题 8）。

经典 NSGA-II（Deb et al. 2002）：非支配排序 + 拥挤度选择 + 精英保留。 演化算子默认使用 Rust 内核；Python 路径保留作对照与降级。适应度评估 可选 ProcessPoolExecutor 并行（Windows spawn 安全，对齐 search_parallel.py 模式）。

约束处理用 Deb 可行支配规则：可行解支配不可行解；都不可行时按约束 违反量排序。无需罚因子。

用法:

def my_objectives(x: np.ndarray) -> tuple[np.ndarray, float]:
    # x: 决策向量
    # 返回 (目标向量, 约束违反量)
    return np.array([x[0]**2, (x[0]-2)**2]), 0.0

result = nsga2(
    objectives=my_objectives,
    bounds=[(-5.0, 5.0)],
    pop_size=100,
    n_gen=200,
    seed=42,
)
# result.x: (k, n_dim) 前沿决策向量
# result.f: (k, n_obj) 前沿目标向量
class e2m2e.algorithm.transfer.nsga2.NSGA2Result(x, f, rank, crowding, n_eval, history)[源代码]

基类：object

NSGA-II 优化结果。

变量:

  • x (numpy.ndarray) -- Pareto 前沿决策向量，形状 (k, n_dim)

  • f (numpy.ndarray) -- Pareto 前沿目标向量，形状 (k, n_obj)

  • rank (numpy.ndarray) -- 前沿点非支配层级（恒为 0），形状 (k,)

  • crowding (numpy.ndarray) -- 前沿点拥挤度，形状 (k,)

  • n_eval (int) -- 总目标函数评估次数

  • history (list[dict[str, Any]]) -- 每代种群规模与前沿规模记录

参数:
x: ndarray
f: ndarray
rank: ndarray
crowding: ndarray
n_eval: int
history: list[dict[str, Any]]
e2m2e.algorithm.transfer.nsga2.nsga2(objectives, bounds, *, pop_size=100, n_gen=200, crossover_prob=0.9, mutation_prob=None, eta_c=20.0, eta_m=20.0, seed=None, n_workers=None, verbose=False, backend='rust')[源代码]

NSGA-II 多目标优化。

参数:

  • objectives (Callable[[ndarray[tuple[Any, ...], dtype[floating]]], tuple[ndarray[tuple[Any, ...], dtype[floating]], float]]) -- 目标函数，签名 fn(x) -> (objectives, violation)。 objectives 形状 (n_obj,)，全部最小化；violation >= 0， 0 表示可行。必须是**模块级可 pickle 函数** （并行评估要求）。

  • bounds (list[tuple[float, float]]) -- 决策变量边界 [(lo, hi), ...]，长度 = n_dim。

  • pop_size (int) -- 种群规模。

  • n_gen (int) -- 进化代数。

  • crossover_prob (float) -- 交叉概率（SBX）。

  • mutation_prob (float | None) -- 变异概率，None 时取 1 / n_dim。

  • eta_c (float) -- SBX 交叉分布指数（越大子代越贴近父代）。

  • eta_m (float) -- 多项式变异分布指数。

  • seed (int | None) -- 随机种子。

  • n_workers (int | None) -- 并行进程数，None 时取 min(cpu_count(), 4)； 1 时退化为串行。

  • verbose (bool) -- 每代打印进度。

  • backend (str) -- 演化算子后端，"rust"``（默认）或 ``"python"。

返回:

NSGA2Result （Pareto 前沿 + 诊断信息）。

抛出:

ValueError -- bounds 为空、pop_size < 4、目标函数返回长度不一致。

返回类型:

NSGA2Result