Jaxonomy — hybrid dynamical systems on JAX

---

什么是 Jaxonomy？

Jaxonomy 是一个 Python 框架，用于对混合动力系统进行建模、仿真和优化——这类系统在一个模型中结合了连续物理过程、离散控制律和事件驱动逻辑。每次仿真都运行在 JAX 上，因此支持 JIT 编译、使用 vmap 批量处理，并且能够端到端完全求导。

import jax.numpy as jnp
import jaxonomy as jx

# Double integrator: A, B, C, D define the plant; Q, R weight the LQR cost.
A, B = jnp.array([[0., 1.], [0., 0.]]), jnp.array([[0.], [1.]])
C, D = jnp.eye(2), jnp.zeros((2, 1))
Q, R = jnp.eye(2), jnp.array([[1.]])

builder = jx.DiagramBuilder()
# Start displaced from the origin, so the regulator has something to do.
plant      = builder.add(jx.library.LTISystem(A, B, C, D,
                                              initialize_states=jnp.array([1.0, 0.0])))
controller = builder.add(jx.library.LinearQuadraticRegulator(A, B, Q, R))
builder.connect(plant.output_ports[0],      controller.input_ports[0])
builder.connect(controller.output_ports[0], plant.input_ports[0])

diagram = builder.build()
results = jx.simulate(
    diagram,
    diagram.create_context(),
    (0.0, 10.0),
    # Nothing is stored unless you name it here: without recorded_signals,
    # results.time and results.outputs come back as None.
    recorded_signals={"x": plant.output_ports[0],
                      "u": controller.output_ports[0]},
)

results.outputs["x"]    # (T, 2) — position and velocity, driven back to zero

---

🔥 为什么选择 JAX？

选择 JAX 作为计算底层，可解锁 NumPy 仿真器难以实现的功能：

Traditional simulator          Jaxonomy / JAX
──────────────────────         ─────────────────────────────────────────
simulate(params)          →    jit(simulate)(params)          10–100× faster
for p in param_grid: …    →    vmap(simulate)(param_grid)     embarrassingly parallel
finite_diff_gradient(…)   →    grad(simulate)(params)         exact gradients, free

特性	SciPy / NumPy	Julia / DiffEq	Modelica	MathWorks¹	Jaxonomy
原生支持 Python	✓	✗	✗	✗	✓
JIT / 代码生成	✗	✓	✓ (C++)	✓ (C/C++)	✓
对 ODE 进行完整自动微分	✗	部分支持	✗	部分支持²	✓
混合事件与零交叉	部分支持	✓	✓	✓	✓
非因果 / 基于方程	✗	✗	✓	✓ (Simscape)	✓
方块图组合	✗	部分支持	部分支持	✓ (Simulink)	✓
状态机建模	✗	✗	✗	✓ (Stateflow)	✓
内置 LQR / MPC / Kalman	✗	部分支持	通过库实现	✓ (工具箱)	✓
神经 ODE / SINDy	✗	✓	✗	✗	✓
降阶建模（balred / POD-DEIM / DMD / Koopman）	✗	部分支持	✗	✓ (工具箱)	✓
批量 / 集成（vmap）	✗	✗	✗	✗	✓
开源（MIT）	✓	✓	部分支持	✗	✓

_{¹ Simulink + Simscape + Stateflow + Control System Toolbox  ·  ² 通过 Simulink Design Optimization 实现，不支持端到端自动微分}

---

⚡ 主要功能

功能	能实现的功能
⚡ JAX 原生引擎	JIT 编译仿真，使用 vmap 运行集成仿真，并通过 ODE 求解器（包括事件处理）进行求导
🔀 混合动力学 + 状态机	在一个模型中组合连续 ODE、周期性离散更新、零交叉事件，以及使用 StateMachineBuilder 编写的有限状态机。对于混合轨迹优化，jax.grad 可通过事件时间传播梯度。
🔌 非因果建模	受 Modelica 启发的多领域组件（电气、机械、热、流体、电池），采用 Pantelides 指数缩减和 BDF 质量矩阵 DAE 求解器
🎯 控制与估计	LQR（连续、离散、有限时域、LQG）、线性 MPC（原生 + OSQP）、非线性 MPC（射击法 / 转录法 / Hermite-Simpson）、Kalman / EKF / UKF / RLS / Luenberger，以及带经典整定辅助工具的 2-DOF PID
🧮 支持单位的连线	端口和信号可选用 BusUnit 注释；图表编译器会在构建时捕获量纲不匹配，而非让其成为静默的运行时错误
🧠 数据驱动建模	Neural ODE、Universal Differential Equations、SINDy 符号回归、神经网络模块（MLP / PyTorch / TensorFlow / ONNX）、可微查找表拟合，以及统计代理模型（高斯过程、多项式混沌、RBF）
📉 降阶建模	jaxonomy.library.rom：线性 MOR（平衡截断、minreal、模态法 / 残差化）、结合 DEIM 超降阶的 POD–Galerkin，以及数据驱动的算子 ROM（DMD / DMDc / ERA、Koopman / eDMD 提升线性预测器）。统一通过 reduce(...) 入口使用；每个降阶模型都是可微、可仿真的模块
🎲 不确定性与灵敏度	一流的 jaxonomy.uq 工作流：基于参数分布的蒙特卡洛、拉丁超立方 + 准蒙特卡洛采样、Sobol 灵敏度分解、Morris 筛选
🤝 FMI 2.0 / 3.0 互操作	导入 FMI 协同仿真 FMU（ModelicaFMU，支持混合类型和数组 I/O）或模型交换 FMU（ModelicaFMUME，由 Jaxonomy 自带的求解器集成，并将 FMI 事件指示器作为零交叉处理）；通过 build_fmu 将图表导出为二进制 .fmu。已在 CI 中通过 Reference FMUs、OpenModelica 和 fmusim 参考仿真器验证
🧩 150 多个库模块	积分器、滤波器、状态机、查找表、坐标变换、容器模块、总线 / 多路复用器系列、随机源等

---

📦 安装

需要 Python 3.10+。

# Create and activate a virtual environment (recommended)
python -m venv .venv
source .venv/bin/activate        # Windows: .venv\Scripts\activate

# Install
pip install jaxonomy             # core
pip install jaxonomy[safe]       # + SciPy, Matplotlib, control, jaxopt
pip install jaxonomy[nmpc]       # + nonlinear MPC (requires IPOPT on PATH)
pip install jaxonomy[all]        # + everything

从源代码安装：

git clone https://github.com/machinavitalis/jaxonomy
cd jaxonomy
pip install -e .

CLI 运行器：

jaxonomy_cli run --model path/to/model.json

---

🚀 快速开始

只需几行代码即可运行首次仿真——创建自定义模块，将其构建到图表中，并通过其 ODE 进行积分：

import jaxonomy as jx
import jax.numpy as jnp

# Van der Pol oscillator as a custom block
class VanDerPol(jx.LeafSystem):
    def __init__(self, mu=1.0, **kwargs):
        super().__init__(**kwargs)
        self.declare_dynamic_parameter("mu", mu)
        self.declare_continuous_state(
            default_value=jnp.array([0.0, 2.0]), ode=self._ode
        )
        self.declare_continuous_state_output(name="x")

    def _ode(self, time, state, *inputs, **params):
        x, mu = state.continuous_state, params["mu"]
        return jnp.array([x[1],  mu * (1 - x[0]**2) * x[1] - x[0]])

builder = jx.DiagramBuilder()
vdp = builder.add(VanDerPol(mu=2.0, name="vdp"))
diagram = builder.build()

results = jx.simulate(
    diagram, diagram.create_context(), (0.0, 20.0),
    options=jx.SimulatorOptions(buffer_length=4000),  # room for adaptive steps
    recorded_signals={"x": vdp.output_ports[0]},
)
# results.outputs["x"] → time-series of shape (T, 2)

---

📚 文档

• 在线文档与教程： py.jaxonomy.com
• 本地文档：

  pip install -r requirements.docs.txt
  mkdocs serve   # → http://127.0.0.1:8000
  

• 示例笔记本： docs/examples/
• 范围说明： PINNs 与 PDE 代理模型 — 经典 PDE PINN 不在项目范围内；物理信息驱动的动力学学习（UDE / Neural DAE / Neural ODE / SINDy）则是核心内容。

---

🤖 通过 AI agent 驱动 Jaxonomy（MCP）

Jaxonomy 附带一个 MCP 服务，可将引擎公开为 AI agent 可直接调用的工具——它可以枚举库中的模块、构建并验证模型、运行仿真、拟合数据参数，以及对系统进行线性化，然后基于实际结果进行推理。如果你通过 agent 使用 Jaxonomy（Claude Desktop/Code、Cursor 等），值得配置此服务；如果你手动编写 Python，只需执行上文的 pip install 即可，无需配置。

pip install jaxonomy[mcp]

然后将此服务注册到你的 agent 客户端。对于 Claude Desktop，请添加到 claude_desktop_config.json：

{
  "mcpServers": {
    "jaxonomy": {
      "command": "python",
      "args": ["-m", "jaxonomy.mcp.server"]
    }
  }
}

使用安装了 jaxonomy[mcp] 的解释器（或 jaxonomy-mcp 入口点）。该服务在 MCP Registry 中的注册名称为 io.github.machinavitalis/jaxonomy；完整的工具参考、客户端配置和限制，请参阅 py.jaxonomy.com/mcp。

如果你只想让 agent 参考文档，请从 SKILL.md 开始——其中介绍了何时使用 Jaxonomy、何时选择其他工具、核心 API，以及最常导致初次编写脚本失败的问题。文档网站还提供了 llms.txt 版本： py.jaxonomy.com/llms.txt 列出所有页面， py.jaxonomy.com/llms-full.txt 则将整套文档合并为一个 Markdown 文件。

---

📖 示例

1 · 混合动力学：弹跳球

Jaxonomy 专为混合系统设计——这类模型中，连续物理过程与瞬时离散重置相互作用。弹跳球是典型示例：自由落体 ODE 会被碰撞事件打断，碰撞会反转速度。

控制方程

两次弹跳之间的动力学遵循：

$$ \dot{x} = v, \qquad \dot{v} = -g $$

当球撞到地面（$x = 0$，$v < 0$）时，会触发零交叉事件并重置状态：

$$ x^+ = 0, \qquad v^+ = -e \cdot v \quad (e \in [0, 1] \text{ — 恢复系数}) $$

import jaxonomy as jx
import jax.numpy as jnp

class BouncingBall(jx.LeafSystem):
    def __init__(self, g=9.81, e=0.8, **kwargs):
        super().__init__(**kwargs)
        self.declare_dynamic_parameter("g", g)
        self.declare_dynamic_parameter("e", e)
        # [height, velocity]
        self.declare_continuous_state(
            default_value=jnp.array([5.0, 0.0]), ode=self._ode
        )
        self.declare_continuous_state_output(name="state")

        # Zero-crossing: fires as height crosses zero from above
        self.declare_zero_crossing(
            guard=self._hit_ground,
            reset_map=self._bounce,
            direction="positive_then_non_positive",
        )

    def _ode(self, time, state, *inputs, **params):
        v = state.continuous_state[1]
        return jnp.array([v, -params["g"]])

    def _hit_ground(self, time, state, *inputs, **params):
        return state.continuous_state[0]  # guard on height

    def _bounce(self, time, state, *inputs, **params):
        x, v = state.continuous_state
        new_state = jnp.array([0.0, -params["e"] * v])
        return state.with_continuous_state(new_state)

builder = jx.DiagramBuilder()
ball = builder.add(BouncingBall(g=9.81, e=0.85, name="ball"))
diagram  = builder.build()
results  = jx.simulate(
    diagram, diagram.create_context(), (0.0, 8.0),
    recorded_signals={"state": ball.output_ports[0]},
)

零交叉事件通过对求解器的稠密输出多项式进行 40 步二分搜索来定位——无需用户指定容差，即可实现亚微秒级时间精度。

---

2 · 最优控制：LQR 摆杆

对于状态为 $x = [\theta, \dot\theta]^\top$ 的线性化摆杆：

$$ \dot{x} = Ax + Bu, \qquad A = \begin{bmatrix} 0 & 1 \ g/L & 0 \end{bmatrix}, \quad B = \begin{bmatrix} 0 \ 1/mL^2 \end{bmatrix} $$

线性二次调节器通过求解代数 Riccati 方程 $A^\top P + PA - PBR^{-1}B^\top P + Q = 0$，得到最优增益 $K = R^{-1}B^\top P$，从而最小化无限时域代价：

$$ J = \int_0^\infty \bigl( x^\top Q, x + u^\top R, u \bigr), dt $$

因此 $u^* = -Kx$。

import jaxonomy as jx
from jaxonomy.library import LTISystem, LinearQuadraticRegulator
import jax.numpy as jnp

g, L, m = 9.81, 1.0, 1.0
A = jnp.array([[0, 1], [g/L, 0]])
B = jnp.array([[0], [1 / (m * L**2)]])
C, D = jnp.eye(2), jnp.zeros((2, 1))

Q = jnp.diag(jnp.array([10.0, 1.0]))  # penalise angle more than rate
R = jnp.array([[0.1]])                 # control effort cost

builder    = jx.DiagramBuilder()
plant      = builder.add(LTISystem(A, B, C, D, name="pendulum"))
controller = builder.add(LinearQuadraticRegulator(A, B, Q, R, name="lqr"))

builder.connect(plant.output_ports[0],      controller.input_ports[0])
builder.connect(controller.output_ports[0], plant.input_ports[0])

diagram = builder.build()
context = diagram.create_context()

# Perturb the pendulum's initial angle by 15° (set one block's sub-state)
context = context.with_subcontext(
    plant.system_id,
    context[plant.system_id].with_continuous_state(jnp.array([jnp.pi / 12, 0.0])),
)

results = jx.simulate(
    diagram, context, (0.0, 5.0),
    recorded_signals={"x": plant.output_ports[0]},
)

---

3 · 可微参数辨识

Jaxonomy 可以对完整仿真求导，根据数据拟合模型参数——无需有限差分近似，也无需手写伴随代码。这里，我们通过对整个仿真过程求导，并使用 Optax 进行梯度下降，来恢复弹簧阻尼器的刚度和阻尼：

import jax
import jax.numpy as jnp
import optax
import jaxonomy as jx

class SpringDamper(jx.LeafSystem):
    def __init__(self, k=1.0, c=0.3, **kwargs):
        super().__init__(**kwargs)
        self.declare_dynamic_parameter("k", k)
        self.declare_dynamic_parameter("c", c)
        self.declare_continuous_state(
            default_value=jnp.array([1.0, 0.0]), ode=self._ode
        )

    def _ode(self, time, state, *inputs, **params):
        x, v = state.continuous_state
        return jnp.array([v, -params["k"] * x - params["c"] * v])

sd   = SpringDamper(name="sd")
opts = jx.SimulatorOptions(enable_autodiff=True, max_major_steps=200)

def final_state(theta):                       # theta = {"k": ..., "c": ...}
    ctx = sd.create_context()
    ctx.parameters["k"], ctx.parameters["c"] = theta["k"], theta["c"]
    res = jx.simulate(sd, ctx, (0.0, 1.5), options=opts)
    return res.context.continuous_state       # differentiable final [x, v]

target = jax.lax.stop_gradient(final_state({"k": 4.0, "c": 0.5}))  # "measured"
loss   = lambda theta: jnp.sum((final_state(theta) - target) ** 2)

theta   = {"k": 1.0, "c": 0.1}
opt     = optax.adam(2e-1)
state   = opt.init(theta)
grad_fn = jax.jit(jax.grad(loss))             # gradient through the ODE solver
for _ in range(300):
    updates, state = opt.update(grad_fn(theta), state)
    theta = optax.apply_updates(theta, updates)
# theta → {"k": 4.00, "c": 0.50}

jax.grad(loss) 会自动沿每个 ODE 步骤反向传播，因此同样的方法也适用于电池 ECM（上图）、动力总成或任何参数化模型。需要边界、变换和约束时，jaxonomy.optimization 会通过更高层的 Optimizable API 封装这一流程。

---

4 · 非因果物理建模

Jaxonomy 包含一个受 Modelica 启发的非因果建模层，用于多领域物理系统。你可以用符号形式描述组件连接；编译器会自动推导控制 DAE、降低其指数，并生成可直接用于任何图示的 LeafSystem。

带初始条件的 RC 电路：

$$ C,\dot{V}C = I, \qquad V_C(0) = 0,\text{V}, \qquad V{\text{src}} = 1,\text{V} $$

import jaxonomy as jx
from jaxonomy.acausal import AcausalCompiler, AcausalDiagram, EqnEnv
from jaxonomy.acausal import electrical as elec

ev = EqnEnv()
ad = AcausalDiagram()

vs  = elec.VoltageSource(ev, name="vs", v=1.0)
r   = elec.Resistor(ev,      name="r",  R=1.0)
c   = elec.Capacitor(ev,     name="c",  C=1.0,
                              initial_voltage=0.0, initial_voltage_fixed=True)
gnd = elec.Ground(ev,        name="gnd")

ad.connect(vs, "p", r,  "n")
ad.connect(r,  "p", c,  "p")
ad.connect(c,  "n", vs, "n")
ad.connect(vs, "n", gnd, "p")

compiler = AcausalCompiler(ev, ad)
rc_block = compiler()         # → LeafSystem, JIT-compiled ODE

builder = jx.DiagramBuilder()
rc = builder.add(rc_block)
diagram = builder.build()
results = jx.simulate(
    diagram,
    diagram.create_context(),
    (0.0, 5.0),
    recorded_signals={"rc": rc.output_ports[0]},
)

results.outputs["rc"]   # capacitor charges 0 → 0.993 V over 5 τ (R = C = 1)

同一流程也适用于多领域系统——连接 electrical、rotational 和 translational 领域的机电执行器可编译为一个经过优化的系统。

可用的非因果领域：electrical · rotational · translational · thermal · fluid

---

5 · 可微灵敏度与批量仿真

由于 jax.grad、jax.jit 和 jax.vmap 都可以与 simulate 组合使用，你可以用极少的样板代码实现强大的工作流：

import jax
import jax.numpy as jnp
import jaxonomy as jx

class SpringMass(jx.LeafSystem):
    def __init__(self, mass=1.0, damping=0.1, stiffness=10.0, **kwargs):
        super().__init__(**kwargs)
        self.declare_dynamic_parameter("mass", mass)
        self.declare_dynamic_parameter("damping", damping)
        self.declare_dynamic_parameter("stiffness", stiffness)
        self.declare_continuous_state(
            default_value=jnp.array([1.0, 0.0]), ode=self._ode
        )
        self.declare_continuous_state_output(name="x")

    def _ode(self, time, state, *inputs, **params):
        x, v = state.continuous_state
        a = -(params["stiffness"] * x + params["damping"] * v) / params["mass"]
        return jnp.array([v, a])

# ── Sensitivity: ∂(final position)/∂(all parameters) in one reverse pass ─────
plant = SpringMass(name="plant")
grad_opts = jx.SimulatorOptions(enable_autodiff=True, max_major_steps=200)

def final_position(theta):
    ctx = plant.create_context()
    for name, value in theta.items():
        ctx.parameters[name] = value
    res = jx.simulate(plant, ctx, (0.0, 5.0), options=grad_opts)
    return res.context.continuous_state[0]

grads = jax.grad(final_position)({"mass": 1.0, "damping": 0.1, "stiffness": 10.0})

# ── Monte Carlo ensemble: 1000 trajectories over a mass sweep (vmap) ─────────
builder = jx.DiagramBuilder()
plant_b = builder.add(SpringMass(name="plant"))
diagram = builder.build()

results = jx.simulate_batch(
    diagram, t_span=(0.0, 5.0),
    param_batches={"plant.mass": jnp.linspace(0.5, 2.0, 1000)},
    options=jx.SimulatorOptions(math_backend="jax", max_major_steps=200),
    recorded_signals={"x": plant_b.output_ports[0]},
)
# results.outputs["x"] shape: (1000, T, 2)

---

🧩 库概览

超过 150 个内置模块，涵盖完整的信号处理与控制工具包。以下是其中一部分代表性模块，并非全部：

类别	模块
信号源	Constant、Step、Ramp、Chirp、Pulse、Sawtooth、Clock、DataSource
随机过程	RandomNumber、UniformRandomNumber、WhiteNoise、BandLimitedNoise、PRBS、RandomSource——均支持 with_key，可在 vmap 下生成相互独立的噪声流
算术与非线性函数	Adder、Gain、Product、Abs、Power、Trigonometric、Saturate / SoftSaturate、DeadZone、RateLimiter / SoftRateLimiter、Quantizer、Backlash
连续动态系统	Integrator、Derivative、TransferFunction、LTISystem、PID / PIDContinuous
离散动态系统	IntegratorDiscrete、UnitDelay、FilterDiscrete、LowPassDiscrete、LeadLag、Notch、PIDDiscrete、PIDController2DOF、Decimator、RateTransition
路由、总线与矩阵	Mux / Demux、BusCreator / BusSelector / BusUpdate（带有 BusUnit 注释）、Slice、Stack、Switch / MultiPortSwitch、IfThenElse、MatrixMultiplication、MatrixInversion、DotProduct、CrossProduct
逻辑与状态机	TruthTable、LogicalOperator、Comparator、Relay、EdgeDetection、StateMachine（通过 StateMachineBuilder DSL 编写）
查找表	LookupTable1d / LookupTable2d / LookupTableND、Prelookup / InterpolationUsingPrelookup、TableSearch——均支持微分，并可通过 fit_lookup_table_* 根据数据拟合
延迟与容器	TransportDelay、VariableTransportDelay、EnabledSubsystem、TriggeredSubsystem、ForEach、Conditional
控制	LinearQuadraticRegulator / DiscreteTimeLinearQuadraticRegulator / FiniteHorizonLinearQuadraticRegulator / LinearQuadraticGaussian、LinearDiscreteTimeMPC（原生实现 + LinearDiscreteTimeMPC_OSQP）、DirectShootingNMPC / DirectTranscriptionNMPC / HermiteSimpsonNMPC
状态估计	KalmanFilter、ExtendedKalmanFilter、UnscentedKalmanFilter、InfiniteHorizonKalmanFilter、RecursiveLeastSquares、AugmentedStateEKF、Luenberger
物理与坐标	CoordinateRotation、RigidBody、BatteryCell
机器学习 / 数据	MLP（Equinox）、Sindy、PyTorch、TensorFlow、ONNX / ONNXJax
降阶模型与代理模型	reduce(...) → ReducedOrderModel；线性 MOR（balred / minreal / modal_truncation / residualize）、galerkin_reduce + deim（POD–DEIM）、dmd / dmdc / era、DMDForecaster / KoopmanPredictor，以及代理模型模块 GaussianProcess / PolynomialChaos / RadialBasisSurrogate
互操作	ModelicaFMU / ModelicaFMUME（导入 FMI 2.0 / 3.0 协同仿真与模型交换模型）+ 通过 build_fmu 导出 FMU；MuJoCo / MJX；Ros2Publisher / Ros2Subscriber；QuanserHAL；PyTwin
自定义	CustomPythonBlock、CustomJaxBlock，用于实现用户编写的算法，并支持每个实例持久化状态

除上述封装之外，自定义模块也是一等功能：继承 LeafSystem，声明端口和状态，即可让模块集成到完整框架中，包括 JIT、自动微分和事件检测。

---

🏗️ 系统架构

Jaxonomy 模型是一个 Diagram——由相互连接的模块构成的有向图。模块（LeafSystem）声明端口、连续 / 离散状态以及事件守卫。模拟器会自动协调 ODE 积分、离散更新和事件检测。

graph LR
    subgraph Diagram["DiagramBuilder.build()"]
        direction LR
        r[/"r(t)\nReference"/] --> sum(("Σ"))
        sum -->|"e(t)"| ctrl["Controller\nLQR · MPC · PID"]
        ctrl -->|"u(t)"| plant["Plant\nLTI · Nonlinear · Acausal"]
        plant -->|"x(t)"| obs["State Estimator\nKalman · EKF · UKF"]
        obs --> sum
        plant -->|"y(t)"| out[/"y(t)\nOutput"/]
    end

    style Diagram fill:#f5f8ff,stroke:#4a6fa5,stroke-width:2px
    style ctrl fill:#dbeafe,stroke:#2563eb
    style plant fill:#dcfce7,stroke:#16a34a
    style obs fill:#fef9c3,stroke:#ca8a04

JAX 后端为每次仿真提供底层支持，并通过 XLA 编译提供简洁的 Python API：

graph TD
    A["Python API\nDiagram · LeafSystem · simulate()"] --> B["JAX Backend\nJIT · vmap · grad"]
    B --> C1["Dopri5\nAdaptive RK45\nnon-stiff ODEs"]
    B --> C2["BDF\nImplicit solver\nstiff systems"]
    B --> C3["Event Handler\nZero-crossing\nbisection"]

    style A fill:#e0f2fe,stroke:#0284c7
    style B fill:#fdf4ff,stroke:#9333ea
    style C1 fill:#f0fdf4,stroke:#16a34a
    style C2 fill:#f0fdf4,stroke:#16a34a
    style C3 fill:#f0fdf4,stroke:#16a34a

---

Jaxonomy 技术栈

Jaxonomy 是由三个软件包组成的技术栈底层引擎。每个软件包都有自己的代码仓库，采用 MIT 许可证，且只依赖于其上层的软件包：

• Jaxonomy — 本软件包。 通用、原生支持 JAX 的混合动力系统仿真引擎。不专用于机器人；不依赖该技术栈中的其他软件包。
• Jaxterity — 构建于 Jaxonomy 之上的机器人层：URDF/MJCF 导入、基于 MJX 的多关节动力学、经过校准的执行器/传感器、系统辨识和全身控制。导入 Jaxonomy；绝不重新实现其基础功能。
• Jaxility — 部署产物工厂：将经过校准的机器人编译为适用于 Arm SoC（Cortex-A / Cortex-M）的嵌入式 C 代码，并附带已签名的证明清单。使用 Jaxterity。

边界规则：对机器人领域以外的控制工程师有用的内容（暖通空调、电池、航空航天、能源）属于 Jaxonomy；关节、执行器、接触和运动学链相关的内容属于 Jaxterity；嵌入式代码生成、目标平台和证明属于 Jaxility。

Jaxonomy 尚未实现（或只部分实现）的功能记录在 KNOWN_GAPS.md 中——这是内部证据台账 CLAIMS.md 的公开版逆向清单。

许可证

自 2.2.0 版本起，采用 MIT License 发布。

基于 Collimator, Inc. 的开源 MIT 许可软件包 pycollimator 衍生而来。