drone-models 0.1.0__tar.gz

drone_models-0.1.0/PKG-INFO

@@ -0,0 +1,145 @@
+Metadata-Version: 2.4
+Name: drone_models
+Version: 0.1.0
+Summary: Models of quadrotor drones for estimation and control tasks.
+Author: Marcel Rath, Martin Schuck
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Education
+Classifier: Intended Audience :: Science/Research
+Description-Content-Type: text/markdown
+Requires-Dist: numpy>=2.0.0
+Requires-Dist: scipy>=1.17.0
+Requires-Dist: casadi>=3.7.0
+Requires-Dist: array-api-compat
+Requires-Dist: array-api-extra
+Provides-Extra: sysid
+Requires-Dist: matplotlib; extra == "sysid"
+Requires-Dist: jax>=0.7; extra == "sysid"
+
+$$
+\huge \displaystyle \dot{x} = f(x,u)
+$$
+
+---
+
+Physics-based and data-driven quadrotor dynamics models for estimation, control, and simulation.
+
+[![Python Version]][Python Version URL] [![Ruff Check]][Ruff Check URL] [![Tests]][Tests URL] [![Docs]][Docs URL]
+
+[Python Version]: https://img.shields.io/badge/python-3.10+-blue.svg
+[Python Version URL]: https://www.python.org
+
+[Ruff Check]: https://github.com/utiasDSL/drone-models/actions/workflows/ruff.yml/badge.svg?style=flat-square
+[Ruff Check URL]: https://github.com/utiasDSL/drone-models/actions/workflows/ruff.yml
+
+[Tests]: https://github.com/utiasDSL/drone-models/actions/workflows/testing.yml/badge.svg
+[Tests URL]: https://github.com/utiasDSL/drone-models/actions/workflows/testing.yml
+
+[Docs]: https://github.com/utiasDSL/drone-models/actions/workflows/docs.yml/badge.svg
+[Docs URL]: https://utiasdsl.github.io/drone-models/
+
+## Overview
+
+`drone-models` provides quadrotor dynamics as pure Python functions, from full physics-based implementations to lightweight data-driven approximations. All models support NumPy, JAX, and any [Array API](https://data-apis.org/array-api/latest/) backend, plus [CasADi](https://web.casaid.org/) symbolic variants for optimization-based control. Pre-fitted parameters are included for several Crazyflie platforms.
+
+**Available models** — ranging from high-fidelity to lightweight:
+
+| Model | Description |
+|---|---|
+| `first_principles` | Full rigid-body physics with optional rotor dynamics and aerodynamic drag |
+| `so_rpy_rotor_drag` | Data-driven, attitude as roll/pitch/yaw, with rotor dynamics and drag |
+| `so_rpy_rotor` | Data-driven, attitude as roll/pitch/yaw, with rotor dynamics |
+| `so_rpy` | Lightest data-driven model, attitude as roll/pitch/yaw, no rotor dynamics |
+
+**Pre-fitted configurations** for Crazyflie 2.x (brushed) and Crazyflie 2.1 Brushless:
+`cf2x_L250`, `cf2x_P250`, `cf2x_T350`, `cf21B_500`
+
+## Installation
+
+```bash
+pip install drone-models
+```
+
+For system identification (fitting parameters from your own flight data):
+
+```bash
+pip install "drone-models[sysid]"
+```
+
+> **Note:** `drone_models` must be imported before SciPy to enable Array API support. If you encounter a `RuntimeError`, either import `drone_models` first or set `export SCIPY_ARRAY_API=1` in your shell.
+
+## Usage
+
+### Basic
+
+Bind parameters to a drone configuration with `parametrize`, then call the model with state and command arrays:
+
+```python
+import numpy as np
+from drone_models import parametrize
+from drone_models.first_principles import dynamics
+
+model = parametrize(dynamics, drone_model="cf2x_L250")
+
+pos     = np.zeros(3)
+quat    = np.array([0., 0., 0., 1.])   # xyzw, identity
+vel     = np.zeros(3)
+ang_vel = np.zeros(3)
+rotor_vel = np.ones(4) * 12_000.        # current motor RPMs
+cmd     = np.full(4, 15_000.)           # commanded motor RPMs
+
+pos_dot, quat_dot, vel_dot, ang_vel_dot, rotor_vel_dot = model(
+    pos, quat, vel, ang_vel, cmd, rotor_vel
+)
+```
+
+The model returns continuous-time state derivatives $\dot{x} = f(x, u)$. Integrate with any ODE solver (e.g. `scipy.integrate.solve_ivp`) to simulate forward in time.
+
+### Switching backends
+
+Pass any Array API-compatible array and the output type follows automatically — no code changes needed:
+
+```python
+import jax.numpy as jnp
+from drone_models import parametrize
+from drone_models.first_principles import dynamics
+
+model = parametrize(dynamics, drone_model="cf2x_L250", xp=jnp)
+# Pass jax arrays — get jax arrays back
+```
+
+Arbitrary leading batch dimensions work out of the box: stack states for a thousand drones and evaluate them in one call.
+
+### Symbolic models (CasADi)
+
+Every model exposes a `symbolic_dynamics` function returning CasADi `MX` expressions, for use in MPC, trajectory optimization, or estimation:
+
+```python
+from drone_models import parametrize
+from drone_models.first_principles import symbolic_dynamics
+
+sym_model = parametrize(symbolic_dynamics, drone_model="cf2x_L250")
+```
+
+## Development
+
+Clone and install with [pixi](https://pixi.sh):
+
+```bash
+git clone https://github.com/utiasDSL/drone-models.git
+cd drone-models
+pixi install
+```
+
+Run tests:
+
+```bash
+pixi run -e tests tests
+```
+
+## Citation
+
+Citation information coming soon. See the [docs](https://utiasdsl.github.io/drone-models/) for updates.

drone_models-0.1.0/README.md

@@ -0,0 +1,124 @@
+$$
+\huge \displaystyle \dot{x} = f(x,u)
+$$
+
+---
+
+Physics-based and data-driven quadrotor dynamics models for estimation, control, and simulation.
+
+[![Python Version]][Python Version URL] [![Ruff Check]][Ruff Check URL] [![Tests]][Tests URL] [![Docs]][Docs URL]
+
+[Python Version]: https://img.shields.io/badge/python-3.10+-blue.svg
+[Python Version URL]: https://www.python.org
+
+[Ruff Check]: https://github.com/utiasDSL/drone-models/actions/workflows/ruff.yml/badge.svg?style=flat-square
+[Ruff Check URL]: https://github.com/utiasDSL/drone-models/actions/workflows/ruff.yml
+
+[Tests]: https://github.com/utiasDSL/drone-models/actions/workflows/testing.yml/badge.svg
+[Tests URL]: https://github.com/utiasDSL/drone-models/actions/workflows/testing.yml
+
+[Docs]: https://github.com/utiasDSL/drone-models/actions/workflows/docs.yml/badge.svg
+[Docs URL]: https://utiasdsl.github.io/drone-models/
+
+## Overview
+
+`drone-models` provides quadrotor dynamics as pure Python functions, from full physics-based implementations to lightweight data-driven approximations. All models support NumPy, JAX, and any [Array API](https://data-apis.org/array-api/latest/) backend, plus [CasADi](https://web.casaid.org/) symbolic variants for optimization-based control. Pre-fitted parameters are included for several Crazyflie platforms.
+
+**Available models** — ranging from high-fidelity to lightweight:
+
+| Model | Description |
+|---|---|
+| `first_principles` | Full rigid-body physics with optional rotor dynamics and aerodynamic drag |
+| `so_rpy_rotor_drag` | Data-driven, attitude as roll/pitch/yaw, with rotor dynamics and drag |
+| `so_rpy_rotor` | Data-driven, attitude as roll/pitch/yaw, with rotor dynamics |
+| `so_rpy` | Lightest data-driven model, attitude as roll/pitch/yaw, no rotor dynamics |
+
+**Pre-fitted configurations** for Crazyflie 2.x (brushed) and Crazyflie 2.1 Brushless:
+`cf2x_L250`, `cf2x_P250`, `cf2x_T350`, `cf21B_500`
+
+## Installation
+
+```bash
+pip install drone-models
+```
+
+For system identification (fitting parameters from your own flight data):
+
+```bash
+pip install "drone-models[sysid]"
+```
+
+> **Note:** `drone_models` must be imported before SciPy to enable Array API support. If you encounter a `RuntimeError`, either import `drone_models` first or set `export SCIPY_ARRAY_API=1` in your shell.
+
+## Usage
+
+### Basic
+
+Bind parameters to a drone configuration with `parametrize`, then call the model with state and command arrays:
+
+```python
+import numpy as np
+from drone_models import parametrize
+from drone_models.first_principles import dynamics
+
+model = parametrize(dynamics, drone_model="cf2x_L250")
+
+pos     = np.zeros(3)
+quat    = np.array([0., 0., 0., 1.])   # xyzw, identity
+vel     = np.zeros(3)
+ang_vel = np.zeros(3)
+rotor_vel = np.ones(4) * 12_000.        # current motor RPMs
+cmd     = np.full(4, 15_000.)           # commanded motor RPMs
+
+pos_dot, quat_dot, vel_dot, ang_vel_dot, rotor_vel_dot = model(
+    pos, quat, vel, ang_vel, cmd, rotor_vel
+)
+```
+
+The model returns continuous-time state derivatives $\dot{x} = f(x, u)$. Integrate with any ODE solver (e.g. `scipy.integrate.solve_ivp`) to simulate forward in time.
+
+### Switching backends
+
+Pass any Array API-compatible array and the output type follows automatically — no code changes needed:
+
+```python
+import jax.numpy as jnp
+from drone_models import parametrize
+from drone_models.first_principles import dynamics
+
+model = parametrize(dynamics, drone_model="cf2x_L250", xp=jnp)
+# Pass jax arrays — get jax arrays back
+```
+
+Arbitrary leading batch dimensions work out of the box: stack states for a thousand drones and evaluate them in one call.
+
+### Symbolic models (CasADi)
+
+Every model exposes a `symbolic_dynamics` function returning CasADi `MX` expressions, for use in MPC, trajectory optimization, or estimation:
+
+```python
+from drone_models import parametrize
+from drone_models.first_principles import symbolic_dynamics
+
+sym_model = parametrize(symbolic_dynamics, drone_model="cf2x_L250")
+```
+
+## Development
+
+Clone and install with [pixi](https://pixi.sh):
+
+```bash
+git clone https://github.com/utiasDSL/drone-models.git
+cd drone-models
+pixi install
+```
+
+Run tests:
+
+```bash
+pixi run -e tests tests
+```
+
+## Citation
+
+Citation information coming soon. See the [docs](https://utiasdsl.github.io/drone-models/) for updates.

drone_models-0.1.0/docs/gen_ref_pages.py

@@ -0,0 +1,103 @@
+"""Generate the code reference pages and navigation."""
+
+from pathlib import Path
+
+import mkdocs_gen_files
+
+SKIP_PARTS = {"_typing", "__main__"}
+
+# model.py in these packages is re-exported via __init__, so document only at index level
+SKIP_MODULE_PAGES = {
+    ("drone_models", "first_principles", "model"),
+    ("drone_models", "so_rpy", "model"),
+    ("drone_models", "so_rpy_rotor", "model"),
+    ("drone_models", "so_rpy_rotor_drag", "model"),
+}
+
+TOP_LEVEL_PAGE = """\
+::: drone_models
+    options:
+      members:
+        - parametrize
+        - available_models
+        - model_features
+      show_submodules: false
+
+## Submodules
+
+### Models
+
+| Module | Description |
+|--------|-------------|
+| [first_principles](first_principles/index.md) | Full physics model |
+| [so_rpy_rotor_drag](so_rpy_rotor_drag/index.md) | Fitted model with rotor dynamics and drag |
+| [so_rpy_rotor](so_rpy_rotor/index.md) | Fitted model with rotor dynamics |
+| [so_rpy](so_rpy/index.md) | Simplest fitted model |
+
+### Core
+
+| Module | Description |
+|--------|-------------|
+| [core](../core.md) | `load_params`, `supports` decorator, internal `parametrize` |
+| [drones](../drones.md) | `available_drones` tuple |
+| [symbols](../symbols.md) | CasADi symbolic utilities |
+| [transform](../transform.md) | Motor/PWM/rotor conversion utilities |
+
+### Utilities
+
+| Module | Description |
+|--------|-------------|
+| [utils.rotation](../utils/rotation.md) | Quaternion/Euler/angular velocity conversions |
+| [utils.data_utils](../utils/data_utils.md) | `preprocessing`, `derivatives_svf` |
+| [utils.identification](../utils/identification.md) | `sys_id_translation`, `sys_id_rotation` |
+"""
+
+for path in sorted(Path("drone_models").rglob("*.py")):
+    module_path = path.relative_to(".").with_suffix("")
+    doc_path = path.relative_to(".").with_suffix(".md")
+    full_doc_path = Path("reference", doc_path)
+
+    parts = tuple(module_path.parts)
+
+    if any(part in SKIP_PARTS for part in parts):
+        continue
+
+    if parts in SKIP_MODULE_PAGES:
+        continue
+
+    if parts[-1] == "__init__":
+        parts = parts[:-1]
+        doc_path = doc_path.with_name("index.md")
+        full_doc_path = full_doc_path.with_name("index.md")
+    elif parts[-1] == "__main__":
+        continue
+
+    with mkdocs_gen_files.open(full_doc_path, "w") as fd:
+        if parts == ("drone_models",):
+            fd.write(TOP_LEVEL_PAGE)
+        else:
+            ident = ".".join(parts)
+            fd.write(f"::: {ident}\n")
+
+    mkdocs_gen_files.set_edit_path(full_doc_path, path)
+
+summary = """\
+* [drone_models](drone_models/index.md)
+* [first_principles](drone_models/first_principles/index.md)
+* [so_rpy_rotor_drag](drone_models/so_rpy_rotor_drag/index.md)
+* [so_rpy_rotor](drone_models/so_rpy_rotor/index.md)
+* [so_rpy](drone_models/so_rpy/index.md)
+* Core
+    * [core](drone_models/core.md)
+    * [drones](drone_models/drones.md)
+    * [symbols](drone_models/symbols.md)
+    * [transform](drone_models/transform.md)
+* Utilities
+    * [utils](drone_models/utils/index.md)
+    * [utils.rotation](drone_models/utils/rotation.md)
+    * [utils.data_utils](drone_models/utils/data_utils.md)
+    * [utils.identification](drone_models/utils/identification.md)
+"""
+
+with mkdocs_gen_files.open("reference/SUMMARY.md", "w") as nav_file:
+    nav_file.write(summary)

drone_models-0.1.0/drone_models/__init__.py

@@ -0,0 +1,73 @@
+"""drone-models: quadrotor dynamics models for estimation, control, and simulation.
+
+This package provides numeric and symbolic quadrotor dynamics models at multiple
+fidelity levels. Models are pure functions compatible with any Array API backend
+(NumPy, JAX, PyTorch, etc.) and with CasADi for symbolic computation.
+
+Use [parametrize][drone_models.parametrize] to bind a dynamics function to a named drone configuration,
+and [available_models][drone_models.available_models] to enumerate all registered models.
+"""
+
+import os
+import sys
+from typing import Callable
+
+# SciPy array API check. We use the most recent array API features, which require the
+# SCIPY_ARRAY_API environment variable to be set to "1". This flag MUST be set before importing
+# scipy, because scipy's C extensions cannot be unloaded once they have been imported. Therefore, we
+# have to error out if the flag is not set. Otherwise, we immediately import scipy to ensure that no
+# other package sets the flag to a different value before importing scipy.
+
+if "scipy" in sys.modules and os.environ.get("SCIPY_ARRAY_API") != "1":
+    msg = """scipy has already been imported and the 'SCIPY_ARRAY_API' environment variable has not
+    been set. Please restart your Python session and set SCIPY_ARRAY_API="1" before importing any
+    packages that depend on scipy, or import this package first to automatically set the flag."""
+    raise RuntimeError(msg)
+
+os.environ["SCIPY_ARRAY_API"] = "1"
+import scipy  # noqa: F401, ensure scipy uses array API features
+
+from drone_models.core import parametrize
+from drone_models.first_principles import dynamics as _first_principles_dynamics
+from drone_models.so_rpy import dynamics as _so_rpy_dynamics
+from drone_models.so_rpy_rotor import dynamics as _so_rpy_rotor_dynamics
+from drone_models.so_rpy_rotor_drag import dynamics as _so_rpy_rotor_drag_dynamics
+
+__all__ = ["parametrize", "available_models", "model_features"]
+
+
+available_models: dict[str, Callable] = {
+    "first_principles": _first_principles_dynamics,
+    "so_rpy": _so_rpy_dynamics,
+    "so_rpy_rotor": _so_rpy_rotor_dynamics,
+    "so_rpy_rotor_drag": _so_rpy_rotor_drag_dynamics,
+}
+
+
+def model_features(model: Callable) -> dict[str, bool]:
+    """Return the feature flags declared by a dynamics function.
+
+    Feature flags are set by the [supports][drone_models.core.supports] decorator on each
+    dynamics function and describe which optional inputs the model accepts.
+
+    Args:
+        model: A dynamics function, or a ``functools.partial`` wrapping one (as
+            returned by [parametrize][drone_models.parametrize]).
+
+    Returns:
+        A dict of feature names to booleans. Currently contains:
+            - ``"rotor_dynamics"``: ``True`` if the model accepts and integrates
+              ``rotor_vel``, ``False`` if passing ``rotor_vel`` raises a
+              ``ValueError``.
+
+    Example:
+        ```python
+        from drone_models import model_features
+        from drone_models.first_principles import dynamics
+
+        model_features(dynamics)  # {'rotor_dynamics': True}
+        ```
+    """
+    if hasattr(model, "func"):  # Is a partial function
+        return model_features(model.func)
+    return getattr(model, "__drone_model_features__")

drone_models-0.1.0/drone_models/_typing.py

@@ -0,0 +1,8 @@
+"""This file is to be remove later as soon as a proper typing is available by the official array-api."""
+
+from typing import Any, TypeAlias
+
+import numpy.typing as npt
+
+Array: TypeAlias = Any  # To be changed to array_api_typing later
+ArrayLike: TypeAlias = Array | npt.ArrayLike

drone_models-0.1.0/drone_models/core.py

@@ -0,0 +1,163 @@
+"""Core tools for registering and capability checking for the drone models."""
+
+from __future__ import annotations
+
+import inspect
+import tomllib
+import warnings
+from functools import partial, wraps
+from pathlib import Path
+from typing import TYPE_CHECKING, Any, Callable, ParamSpec, TypeVar
+
+import numpy as np
+
+if TYPE_CHECKING:
+    from types import ModuleType
+
+    from drone_models._typing import Array  # To be changed to array_api_typing later
+
+
+F = TypeVar("F", bound=Callable[..., Any])
+P = ParamSpec("P")
+R = TypeVar("R")
+
+
+def supports(rotor_dynamics: bool = True) -> Callable[[F], F]:
+    """Decorator that declares which optional inputs a dynamics function supports.
+
+    Wraps the decorated function so that:
+
+    * If ``rotor_dynamics=False`` and the caller passes ``rotor_vel``, a
+      ``ValueError`` is raised immediately.
+    * If ``rotor_dynamics=True`` and the caller omits ``rotor_vel``, a
+      ``UserWarning`` is issued and the commanded value is used directly.
+
+    The decorator also attaches a ``__drone_model_features__`` attribute to the
+    wrapper, which [model_features][drone_models.model_features] reads.
+
+    Args:
+        rotor_dynamics: Whether the decorated function models rotor velocity
+            dynamics. Set to ``False`` for models that do not accept or integrate
+            ``rotor_vel`` (e.g. ``so_rpy``). Defaults to ``True``.
+
+    Returns:
+        A decorator that wraps the dynamics function with the capability checks
+        described above.
+    """
+
+    def decorator(fn: F) -> F:
+        @wraps(fn)
+        def wrapper(
+            pos: Array,
+            quat: Array,
+            vel: Array,
+            ang_vel: Array,
+            cmd: Array,
+            rotor_vel: Array | None = None,
+            *args: Any,
+            **kwargs: Any,
+        ) -> tuple[Array, Array, Array, Array, Array | None]:
+            if not rotor_dynamics and rotor_vel is not None:
+                raise ValueError("Rotor dynamics not supported, but rotor_vel is provided.")
+            if rotor_dynamics and rotor_vel is None:
+                warnings.warn("Rotor velocity not provided, using commanded rotor velocity.")
+            return fn(pos, quat, vel, ang_vel, cmd, rotor_vel, *args, **kwargs)
+
+        wrapper.__drone_model_features__ = {"rotor_dynamics": rotor_dynamics}
+
+        return wrapper  # type: ignore
+
+    return decorator
+
+
+def parametrize(
+    fn: Callable[P, R], drone_model: str, xp: ModuleType | None = None, device: str | None = None
+) -> Callable[P, R]:
+    """Parametrize a dynamics function with the default dynamics parameters for a drone model.
+
+    Args:
+        fn: The dynamics function to parametrize.
+        drone_model: The drone model to use.
+        xp: The array API module to use. If not provided, numpy is used.
+        device: The device to use. If none, the device is inferred from the xp module.
+
+    Example:
+        ```{ .python notest }
+        from drone_models.core import parametrize
+        from drone_models.first_principles import dynamics
+
+        dynamics_fn = parametrize(dynamics, drone_model="cf2x_L250")
+        pos_dot, quat_dot, vel_dot, ang_vel_dot, rotor_vel_dot = dynamics_fn(
+            pos=pos, quat=quat, vel=vel, ang_vel=ang_vel, cmd=cmd, rotor_vel=rotor_vel
+        )
+        ```
+
+    Returns:
+        The parametrized dynamics function with all keyword argument only parameters filled in.
+    """
+    try:
+        xp = np if xp is None else xp
+        physics = fn.__module__.split(".")[-2]
+        sig = inspect.signature(fn)
+        kwonly_params = [
+            name
+            for name, param in sig.parameters.items()
+            if param.kind == inspect.Parameter.KEYWORD_ONLY
+        ]
+        params = load_params(physics, drone_model, xp=xp)
+        params = {k: xp.asarray(v, device=device) for k, v in params.items() if k in kwonly_params}
+    except KeyError as e:
+        raise KeyError(
+            f"Model `{physics}` does not exist in the parameter registry for drone `{drone_model}`"
+        ) from e
+    except ValueError as e:
+        raise ValueError(f"Drone model `{drone_model}` not supported for `{physics}`") from e
+    return partial(fn, **params)
+
+
+def load_params(physics: str, drone_model: str, xp: ModuleType | None = None) -> dict:
+    """Load and merge physical and model-specific parameters for a drone configuration.
+
+    Reads parameters from two TOML files:
+
+    * ``drone_models/data/params.toml`` — physical parameters shared across all
+      models (mass, inertia, thrust curves, …).
+    * ``drone_models/<physics>/params.toml`` — model-specific coefficients
+      (e.g. fitted RPY coefficients for ``so_rpy``).
+
+    The two dicts are merged (model-specific values take precedence), and
+    ``J_inv`` is computed from ``J`` and added to the result.
+
+    Args:
+        physics: Name of the model sub-package, e.g. ``"first_principles"``,
+            ``"so_rpy"``, ``"so_rpy_rotor"``, or ``"so_rpy_rotor_drag"``.
+        drone_model: Name of the drone configuration, e.g. ``"cf2x_L250"``.
+            Must exist as a section in both TOML files.
+        xp: Array API module used to convert parameter values. If ``None``,
+            NumPy is used.
+
+    Returns:
+        A flat dict mapping parameter names to arrays (or scalars) in the
+        requested array namespace.  Always contains at least ``mass``, ``J``,
+        ``J_inv``, ``gravity_vec``, and the model-specific coefficients for
+        ``physics``.
+
+    Raises:
+        KeyError: If ``drone_model`` is not found in either TOML file, or if
+            ``physics`` does not correspond to a known sub-package.
+    """
+    xp = np if xp is None else xp
+    with open(Path(__file__).parent / "data/params.toml", "rb") as f:
+        physical_params = tomllib.load(f)
+    if drone_model not in physical_params:
+        raise KeyError(f"Drone model `{drone_model}` not found in data/params.toml")
+    with open(Path(__file__).parent / f"{physics}/params.toml", "rb") as f:
+        model_params = tomllib.load(f)
+    if drone_model not in model_params:
+        raise KeyError(f"Drone model `{drone_model}` not found in model params.toml")
+    params = physical_params[drone_model] | model_params[drone_model]
+    # Make sure J_inv does not have a dtype fixed before conversion to xp arrays to avoid fixing it
+    # to np.float64 when other frameworks might prefer a different dtype.
+    params["J_inv"] = np.linalg.inv(params["J"]).tolist()
+    params = {k: xp.asarray(v) for k, v in params.items()}  # if k in fields
+    return params