nornax 0.0.1__tar.gz

nornax-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 AstroAI Lab
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

nornax-0.0.1/PKG-INFO

@@ -0,0 +1,208 @@
+Metadata-Version: 2.4
+Name: nornax
+Version: 0.0.1
+Summary: JAX-native Hermite integrators for N-body dynamics with Diffrax-facing solver hooks
+Author-email: AstroAI Lab <astroai@iwr.uni-heidelberg.de>, Tobias Buck <tobias.buck@iwr.uni-heidelberg.de>
+Maintainer-email: AstroAI Lab <astroai@iwr.uni-heidelberg.de>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/TobiBu/nornax
+Project-URL: Repository, https://github.com/TobiBu/nornax
+Project-URL: Issues, https://github.com/TobiBu/nornax/issues
+Project-URL: Documentation, https://github.com/TobiBu/nornax#readme
+Keywords: hermite,n-body,jax,gravity,integrator,fmm
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: jax>=0.8.0
+Requires-Dist: jaxlib>=0.8.0
+Requires-Dist: diffrax>=0.6.0
+Requires-Dist: equinox>=0.11.10
+Requires-Dist: jaxtyping>=0.2.34
+Requires-Dist: beartype>=0.14.0
+Provides-Extra: dev
+Requires-Dist: black>=24.8.0; extra == "dev"
+Requires-Dist: isort>=5.13.2; extra == "dev"
+Requires-Dist: pydoclint>=0.6.0; extra == "dev"
+Requires-Dist: pytest>=8.3.0; extra == "dev"
+Requires-Dist: pytest-cov>=5.0.0; extra == "dev"
+Requires-Dist: pre-commit>=3.8.0; extra == "dev"
+Requires-Dist: build>=1.2.2; extra == "dev"
+Requires-Dist: twine>=5.1.1; extra == "dev"
+Dynamic: license-file
+
+# nornax
+
+<p align="center">
+  <img src="./nornax.png" alt="nornax Logo" width="420" />
+</p>
+
+`nornax` is a JAX-native Hermite integrator package for gravitational N-body
+dynamics.
+
+The current direction is:
+
+- standalone and general-purpose first
+- Diffrax-facing solver design
+- GPU-efficient JAX kernels
+- clean backend adapters so `jaccpot` can plug in later
+
+## Current Scope
+
+The current implementation includes:
+
+- immutable `NBodyState` / `ForceDerivatives` PyTrees
+- backend-agnostic `ForceModel` protocol
+- standalone `DirectSumGravity` reference backend (O(N^2) all-pairs; the
+  default path materializes N×N pair tensors, and an opt-in `block_size`
+  caps peak memory at O(block_size × N) for larger N — `jaccpot` remains the
+  scalable backend)
+- standalone and Diffrax-backed Hermite-4, Hermite-6, and Hermite-8
+- adaptive global timestep control through Diffrax
+- diagnostics for total energy and angular momentum
+- convergence and long-run conservation tests
+
+## Installation
+
+Install from source:
+
+```bash
+pip install -e .
+```
+
+Install with development tooling:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Quick Start
+
+```python
+import jax
+import jax.numpy as jnp
+
+from nornax import AarsethController, solve_adaptive_to_time, total_energy
+from nornax.forces import DirectSumGravity
+
+jax.config.update("jax_enable_x64", True)
+
+force_model = DirectSumGravity()
+result = solve_adaptive_to_time(
+    jnp.asarray([[-1.0, 0.0, 0.0], [1.0, 0.0, 0.0]]),
+    jnp.asarray([[0.0, 0.5, 0.0], [0.0, -0.5, 0.0]]),
+    jnp.asarray([1.0, 1.0]),
+    force_model,
+    t_final=1.0,
+    order=8,
+    controller=AarsethController(eta=0.03, min_dt=1.0e-4, max_dt=5.0e-2),
+    atol=1.0e-8,
+)
+print(result.final_state.time, total_energy(result.final_state))
+```
+
+Examples:
+
+- [examples/two_body_diffrax.py](examples/two_body_diffrax.py): adaptive two-body solve
+- [examples/compare_hermite_orders.py](examples/compare_hermite_orders.py): compare Hermite-4/6/8 energy and angular-momentum drift
+- [examples/plummer_sphere_gpu.py](examples/plummer_sphere_gpu.py): small Plummer sphere run shaped for GPU/server use
+
+Notebooks:
+
+- [notebooks/hermite_orders_accuracy.ipynb](notebooks/hermite_orders_accuracy.ipynb): compare adaptive Hermite-4/6/8 drift and step counts
+- [notebooks/hermite_vs_diffrax_rk.ipynb](notebooks/hermite_vs_diffrax_rk.ipynb): compare Hermite against a standard Diffrax RK solver
+- [notebooks/direct_vs_jaccpot_backend.ipynb](notebooks/direct_vs_jaccpot_backend.ipynb): compare direct-sum and `jaccpot` backends for Hermite-4
+- [notebooks/plummer_sphere_gpu.ipynb](notebooks/plummer_sphere_gpu.ipynb): small Plummer sphere application notebook for GPU/server runs
+
+## Jaccpot Adapter
+
+`nornax` now includes a first adapter for `jaccpot` via `JaccpotForceModel`.
+This is useful today for Hermite-4, because the current `jaccpot` runtime
+exposes acceleration and jerk, but not higher time derivatives.
+
+```python
+import jax.numpy as jnp
+
+from jaccpot import FastMultipoleMethod
+from nornax import AarsethController, JaccpotForceModel, solve_adaptive_to_time
+
+solver = FastMultipoleMethod(preset="fast", basis="solidfmm")
+force_model = JaccpotForceModel(solver)
+
+result = solve_adaptive_to_time(
+    jnp.asarray([[1.0, 0.0, 0.0], [-1.0, 0.0, 0.0]]),
+    jnp.asarray([[0.0, 0.2, 0.0], [0.0, -0.2, 0.0]]),
+    jnp.asarray([1.0, 1.0]),
+    force_model,
+    t_final=0.1,
+    order=4,
+    controller=AarsethController(eta=0.03, min_dt=1.0e-4, max_dt=5.0e-2),
+    atol=1.0e-6,
+    args={"leaf_size": 8, "max_order": 2, "jerk_mode": "fast_approx"},
+)
+```
+
+Current limitation:
+
+- use `JaccpotForceModel` with Hermite-4 for now
+- Hermite-6 and Hermite-8 still require higher time derivatives than `jaccpot` currently provides
+
+## Planned Architecture
+
+- `nornax.state`: particle state and cached force derivatives
+- `nornax.forces`: standalone direct-sum backend plus future adapters
+- `nornax.solvers`: Hermite kernels and Diffrax-facing solver classes
+- `nornax.terms`: thin Diffrax integration hooks
+
+The scientific target is the family of higher-order Hermite methods discussed
+by Nitadori, Iwasawa, and Makino. The current implementation follows that paper
+through Hermite-8, including direct derivatives through `crackle` and
+higher-order adaptive timestep criteria.
+
+## Validation
+
+The test suite currently covers:
+
+- direct-force derivatives through `crackle`
+- Hermite-4/6/8 kernel behavior
+- Diffrax custom solver smoke tests for 4/6/8
+- convergence checks for 4/6/8
+- adaptive public solve APIs
+- long-run two-body energy-drift ordering across 4/6/8
+
+Benchmarks and examples live in [bench/bench_direct_sum.py](bench/bench_direct_sum.py)
+and [examples/compare_hermite_orders.py](examples/compare_hermite_orders.py).
+
+## Development
+
+Run quality gates locally:
+
+```bash
+black --check .
+isort --check-only .
+pytest
+```
+
+Or run pre-commit hooks:
+
+```bash
+pre-commit run --all-files
+```
+
+## Runtime Type Checking
+
+Enable package-wide runtime checks (`jaxtyping` + `beartype`) at import time:
+
+```bash
+export NORNAX_RUNTIME_TYPECHECK=1
+```
+
+## License
+
+MIT.

nornax-0.0.1/README.md

@@ -0,0 +1,169 @@
+# nornax
+
+<p align="center">
+  <img src="./nornax.png" alt="nornax Logo" width="420" />
+</p>
+
+`nornax` is a JAX-native Hermite integrator package for gravitational N-body
+dynamics.
+
+The current direction is:
+
+- standalone and general-purpose first
+- Diffrax-facing solver design
+- GPU-efficient JAX kernels
+- clean backend adapters so `jaccpot` can plug in later
+
+## Current Scope
+
+The current implementation includes:
+
+- immutable `NBodyState` / `ForceDerivatives` PyTrees
+- backend-agnostic `ForceModel` protocol
+- standalone `DirectSumGravity` reference backend (O(N^2) all-pairs; the
+  default path materializes N×N pair tensors, and an opt-in `block_size`
+  caps peak memory at O(block_size × N) for larger N — `jaccpot` remains the
+  scalable backend)
+- standalone and Diffrax-backed Hermite-4, Hermite-6, and Hermite-8
+- adaptive global timestep control through Diffrax
+- diagnostics for total energy and angular momentum
+- convergence and long-run conservation tests
+
+## Installation
+
+Install from source:
+
+```bash
+pip install -e .
+```
+
+Install with development tooling:
+
+```bash
+pip install -e ".[dev]"
+```
+
+## Quick Start
+
+```python
+import jax
+import jax.numpy as jnp
+
+from nornax import AarsethController, solve_adaptive_to_time, total_energy
+from nornax.forces import DirectSumGravity
+
+jax.config.update("jax_enable_x64", True)
+
+force_model = DirectSumGravity()
+result = solve_adaptive_to_time(
+    jnp.asarray([[-1.0, 0.0, 0.0], [1.0, 0.0, 0.0]]),
+    jnp.asarray([[0.0, 0.5, 0.0], [0.0, -0.5, 0.0]]),
+    jnp.asarray([1.0, 1.0]),
+    force_model,
+    t_final=1.0,
+    order=8,
+    controller=AarsethController(eta=0.03, min_dt=1.0e-4, max_dt=5.0e-2),
+    atol=1.0e-8,
+)
+print(result.final_state.time, total_energy(result.final_state))
+```
+
+Examples:
+
+- [examples/two_body_diffrax.py](examples/two_body_diffrax.py): adaptive two-body solve
+- [examples/compare_hermite_orders.py](examples/compare_hermite_orders.py): compare Hermite-4/6/8 energy and angular-momentum drift
+- [examples/plummer_sphere_gpu.py](examples/plummer_sphere_gpu.py): small Plummer sphere run shaped for GPU/server use
+
+Notebooks:
+
+- [notebooks/hermite_orders_accuracy.ipynb](notebooks/hermite_orders_accuracy.ipynb): compare adaptive Hermite-4/6/8 drift and step counts
+- [notebooks/hermite_vs_diffrax_rk.ipynb](notebooks/hermite_vs_diffrax_rk.ipynb): compare Hermite against a standard Diffrax RK solver
+- [notebooks/direct_vs_jaccpot_backend.ipynb](notebooks/direct_vs_jaccpot_backend.ipynb): compare direct-sum and `jaccpot` backends for Hermite-4
+- [notebooks/plummer_sphere_gpu.ipynb](notebooks/plummer_sphere_gpu.ipynb): small Plummer sphere application notebook for GPU/server runs
+
+## Jaccpot Adapter
+
+`nornax` now includes a first adapter for `jaccpot` via `JaccpotForceModel`.
+This is useful today for Hermite-4, because the current `jaccpot` runtime
+exposes acceleration and jerk, but not higher time derivatives.
+
+```python
+import jax.numpy as jnp
+
+from jaccpot import FastMultipoleMethod
+from nornax import AarsethController, JaccpotForceModel, solve_adaptive_to_time
+
+solver = FastMultipoleMethod(preset="fast", basis="solidfmm")
+force_model = JaccpotForceModel(solver)
+
+result = solve_adaptive_to_time(
+    jnp.asarray([[1.0, 0.0, 0.0], [-1.0, 0.0, 0.0]]),
+    jnp.asarray([[0.0, 0.2, 0.0], [0.0, -0.2, 0.0]]),
+    jnp.asarray([1.0, 1.0]),
+    force_model,
+    t_final=0.1,
+    order=4,
+    controller=AarsethController(eta=0.03, min_dt=1.0e-4, max_dt=5.0e-2),
+    atol=1.0e-6,
+    args={"leaf_size": 8, "max_order": 2, "jerk_mode": "fast_approx"},
+)
+```
+
+Current limitation:
+
+- use `JaccpotForceModel` with Hermite-4 for now
+- Hermite-6 and Hermite-8 still require higher time derivatives than `jaccpot` currently provides
+
+## Planned Architecture
+
+- `nornax.state`: particle state and cached force derivatives
+- `nornax.forces`: standalone direct-sum backend plus future adapters
+- `nornax.solvers`: Hermite kernels and Diffrax-facing solver classes
+- `nornax.terms`: thin Diffrax integration hooks
+
+The scientific target is the family of higher-order Hermite methods discussed
+by Nitadori, Iwasawa, and Makino. The current implementation follows that paper
+through Hermite-8, including direct derivatives through `crackle` and
+higher-order adaptive timestep criteria.
+
+## Validation
+
+The test suite currently covers:
+
+- direct-force derivatives through `crackle`
+- Hermite-4/6/8 kernel behavior
+- Diffrax custom solver smoke tests for 4/6/8
+- convergence checks for 4/6/8
+- adaptive public solve APIs
+- long-run two-body energy-drift ordering across 4/6/8
+
+Benchmarks and examples live in [bench/bench_direct_sum.py](bench/bench_direct_sum.py)
+and [examples/compare_hermite_orders.py](examples/compare_hermite_orders.py).
+
+## Development
+
+Run quality gates locally:
+
+```bash
+black --check .
+isort --check-only .
+pytest
+```
+
+Or run pre-commit hooks:
+
+```bash
+pre-commit run --all-files
+```
+
+## Runtime Type Checking
+
+Enable package-wide runtime checks (`jaxtyping` + `beartype`) at import time:
+
+```bash
+export NORNAX_RUNTIME_TYPECHECK=1
+```
+
+## License
+
+MIT.

nornax-0.0.1/nornax/__init__.py

@@ -0,0 +1,44 @@
+"""Nornax: JAX-native Hermite integrators for N-body dynamics."""
+
+from ._typecheck import enable_runtime_typecheck
+
+# Install the optional runtime type-checking hook before importing any nornax
+# submodules; the jaxtyping hook only instruments modules imported after it.
+enable_runtime_typecheck()
+
+from .adapters import JaccpotForceModel, JaccpotOptions  # noqa: E402
+from .controllers import AarsethController, AdaptiveStepPolicy  # noqa: E402
+from .diagnostics import (  # noqa: E402
+    gravitational_potential_energy,
+    total_angular_momentum,
+    total_energy,
+)
+from .initial_conditions import sample_plummer_sphere  # noqa: E402
+from .initialize import initialize_state  # noqa: E402
+from .solve import (  # noqa: E402
+    solve_adaptive_hermite4,
+    solve_adaptive_hermite4_to_time,
+    solve_adaptive_hermite6_to_time,
+    solve_adaptive_hermite8_to_time,
+    solve_adaptive_to_time,
+)
+from .state import ForceDerivatives, NBodyState  # noqa: E402
+
+__all__ = [
+    "AarsethController",
+    "AdaptiveStepPolicy",
+    "ForceDerivatives",
+    "JaccpotForceModel",
+    "JaccpotOptions",
+    "NBodyState",
+    "gravitational_potential_energy",
+    "initialize_state",
+    "sample_plummer_sphere",
+    "solve_adaptive_to_time",
+    "solve_adaptive_hermite4",
+    "solve_adaptive_hermite4_to_time",
+    "solve_adaptive_hermite6_to_time",
+    "solve_adaptive_hermite8_to_time",
+    "total_angular_momentum",
+    "total_energy",
+]

nornax-0.0.1/nornax/_typecheck.py

@@ -0,0 +1,24 @@
+"""Runtime type-checking opt-in for nornax.
+
+Set the environment variable ``NORNAX_RUNTIME_TYPECHECK=1`` before importing
+``nornax`` to enable package-wide ``jaxtyping`` + ``beartype`` instrumentation.
+
+The jaxtyping import hook only instruments modules imported *after* it is
+installed, so ``nornax.__init__`` calls :func:`enable_runtime_typecheck` before
+importing any nornax submodules.
+"""
+
+from __future__ import annotations
+
+import os
+
+
+def enable_runtime_typecheck() -> None:
+    """Install the jaxtyping + beartype import hook when requested via env var."""
+    if os.environ.get("NORNAX_RUNTIME_TYPECHECK", "0") != "1":
+        return
+    try:
+        from jaxtyping import install_import_hook
+    except ImportError:  # pragma: no cover - jaxtyping is a hard dependency
+        return
+    install_import_hook("nornax", "beartype.beartype")

nornax-0.0.1/nornax/_typing.py

@@ -0,0 +1,26 @@
+"""Shared jaxtyping shape aliases for nornax array annotations.
+
+These aliases document (and, when ``NORNAX_RUNTIME_TYPECHECK=1``, enforce) the
+array shapes flowing through the N-body kernels. Axis ``n`` is the particle
+count; jaxtyping binds it consistently within a single function call, so a
+mismatch between, say, ``positions`` and ``masses`` is caught.
+"""
+
+from __future__ import annotations
+
+from jax import Array
+from jaxtyping import Float
+
+# Per-particle 3-vector field: positions, velocities, and every acceleration
+# time derivative (jerk, snap, crackle, ...).
+Vec3 = Float[Array, "n 3"]
+
+# Per-particle scalar field (e.g. masses).
+PerParticle = Float[Array, "n"]
+
+# A 0-d array scalar (e.g. cached time). Python floats are accepted separately
+# at call boundaries via ``ScalarLike``.
+Scalar = Float[Array, ""]
+
+# A scalar accepted at an API boundary: either a 0-d array or a Python float.
+ScalarLike = Scalar | float

nornax-0.0.1/nornax/adapters/__init__.py

@@ -0,0 +1,5 @@
+"""Optional backend adapters for sibling projects."""
+
+from .jaccpot import JaccpotForceModel, JaccpotOptions
+
+__all__ = ["JaccpotForceModel", "JaccpotOptions"]

nornax-0.0.1/nornax/adapters/jaccpot.py

@@ -0,0 +1,115 @@
+"""Adapter from ``jaccpot`` FMM solvers to the Nornax force-model protocol."""
+
+from __future__ import annotations
+
+from collections.abc import Mapping
+from dataclasses import asdict, dataclass
+from typing import Any
+
+import jax.numpy as jnp
+
+from nornax._typing import PerParticle, ScalarLike, Vec3
+from nornax.state import ForceDerivatives
+
+
+@dataclass(frozen=True)
+class JaccpotOptions:
+    """Execution options forwarded to ``jaccpot`` runtime calls.
+
+    Note that ``max_order`` here is the *FMM multipole expansion order* passed
+    to the ``jaccpot`` solver. It is unrelated to the ``max_order`` argument of
+    :meth:`ForceModel.derivatives`, which selects how many *time* derivatives of
+    the acceleration (jerk, snap, ...) the Hermite solver requests. The name is
+    kept to match the ``jaccpot`` runtime kwarg it maps onto.
+    """
+
+    target_indices: jnp.ndarray | None = None
+    bounds: tuple[jnp.ndarray, jnp.ndarray] | None = None
+    leaf_size: int = 16
+    max_order: int = 2  # FMM expansion order (see class docstring)
+    theta: float | None = None
+    jit_tree: bool | None = None
+    refine_local: bool | None = None
+    max_refine_levels: int | None = None
+    aspect_threshold: float | None = None
+    jit_traversal: bool | None = None
+    reuse_prepared_state: bool = False
+    jerk_mode: str = "accurate"
+    jerk_fd_dt: float = 1.0e-3
+
+    def to_kwargs(self) -> dict[str, Any]:
+        """Convert options to runtime kwargs, dropping ``None`` entries."""
+        return {key: value for key, value in asdict(self).items() if value is not None}
+
+
+@dataclass(frozen=True)
+class JaccpotForceModel:
+    """Thin adapter exposing a ``jaccpot`` solver via the Nornax protocol.
+
+    Current `jaccpot` support covers acceleration and jerk only, so this
+    adapter is suitable for Hermite-4 today. Requests for higher time
+    derivatives raise ``NotImplementedError``.
+    """
+
+    solver: Any
+    options: JaccpotOptions = JaccpotOptions()
+
+    def derivatives(
+        self,
+        t: ScalarLike,
+        positions: Vec3,
+        velocities: Vec3,
+        masses: PerParticle,
+        *,
+        max_order: int,
+        args: object = None,
+    ) -> ForceDerivatives:
+        """Return acceleration derivatives supported by the underlying solver."""
+        del t
+        runtime_kwargs = self._resolve_runtime_kwargs(args)
+        if max_order < 1:
+            raise ValueError("max_order must be >= 1")
+        if max_order > 2:
+            raise NotImplementedError(
+                "jaccpot currently exposes time derivatives only through jerk; "
+                "use this adapter with Hermite-4 for now"
+            )
+        if max_order == 1:
+            accelerations = self.solver.compute_accelerations(
+                positions,
+                masses,
+                **self._acceleration_kwargs(runtime_kwargs),
+            )
+            return ForceDerivatives(acc=accelerations)
+        accelerations, jerk = self.solver.compute_accelerations_and_jerk(
+            positions,
+            masses,
+            velocities,
+            **runtime_kwargs,
+        )
+        return ForceDerivatives(acc=accelerations, jerk=jerk)
+
+    def _resolve_runtime_kwargs(self, args: object) -> dict[str, Any]:
+        """Merge default adapter options with per-call overrides."""
+        runtime_kwargs = self.options.to_kwargs()
+        if args is None:
+            return runtime_kwargs
+        if isinstance(args, JaccpotOptions):
+            runtime_kwargs.update(args.to_kwargs())
+            return runtime_kwargs
+        if isinstance(args, Mapping):
+            runtime_kwargs.update(
+                {key: value for key, value in args.items() if value is not None}
+            )
+            return runtime_kwargs
+        raise TypeError(
+            "jaccpot adapter args must be None, JaccpotOptions, or a mapping of runtime kwargs"
+        )
+
+    @staticmethod
+    def _acceleration_kwargs(runtime_kwargs: Mapping[str, Any]) -> dict[str, Any]:
+        """Drop jerk-only options for acceleration-only calls."""
+        jerk_only = {"jerk_mode", "jerk_fd_dt"}
+        return {
+            key: value for key, value in runtime_kwargs.items() if key not in jerk_only
+        }

nornax-0.0.1/nornax/controllers/__init__.py

@@ -0,0 +1,17 @@
+"""Adaptive timestep controllers for Nornax."""
+
+from .aarseth import (
+    AarsethController,
+    AdaptiveStepPolicy,
+    aarseth_timestep,
+    aarseth_timestep_6th_order,
+    aarseth_timestep_8th_order,
+)
+
+__all__ = [
+    "AarsethController",
+    "AdaptiveStepPolicy",
+    "aarseth_timestep",
+    "aarseth_timestep_6th_order",
+    "aarseth_timestep_8th_order",
+]