Skip to main content

librebound_sys/
ffi.rs

1//! Raw FFI bindings to the REBOUND C library.
2//!
3//! `reb_simulation` is treated as an opaque type. Field access goes through
4//! thin C helpers compiled in `helpers.c`.
5
6use libc::{c_double, c_int, c_uint, c_void};
7
8// ---------------------------------------------------------------------------
9// reb_particle — the only REBOUND struct we reproduce in full.
10// Passed by value in reb_simulation_add and returned by ASSIST routines.
11// ---------------------------------------------------------------------------
12
13/// REBOUND particle: position, velocity, acceleration, mass, radius, hash.
14///
15/// Layout matches `struct reb_particle` in `rebound.h` on LP64 platforms.
16#[repr(C)]
17#[derive(Debug, Clone, Copy)]
18pub struct reb_particle {
19    pub x: c_double,
20    pub y: c_double,
21    pub z: c_double,
22    pub vx: c_double,
23    pub vy: c_double,
24    pub vz: c_double,
25    pub ax: c_double,
26    pub ay: c_double,
27    pub az: c_double,
28    pub m: c_double,
29    pub r: c_double,
30    pub last_collision: c_double,
31    pub c: *mut c_void, // reb_treecell*
32    pub hash: u32,
33    pub ap: *mut c_void,
34    pub sim: *mut c_void, // reb_simulation*
35}
36
37impl Default for reb_particle {
38    fn default() -> Self {
39        Self {
40            x: 0.0,
41            y: 0.0,
42            z: 0.0,
43            vx: 0.0,
44            vy: 0.0,
45            vz: 0.0,
46            ax: 0.0,
47            ay: 0.0,
48            az: 0.0,
49            m: 0.0,
50            r: 0.0,
51            last_collision: 0.0,
52            c: std::ptr::null_mut(),
53            hash: 0,
54            ap: std::ptr::null_mut(),
55            sim: std::ptr::null_mut(),
56        }
57    }
58}
59
60// ---------------------------------------------------------------------------
61// Opaque types — fields accessed only through C helpers.
62// ---------------------------------------------------------------------------
63
64/// Opaque REBOUND simulation.
65#[repr(C)]
66pub struct reb_simulation {
67    _opaque: [u8; 0],
68}
69
70// ---------------------------------------------------------------------------
71// Constants
72// ---------------------------------------------------------------------------
73
74// REBOUND integrator IDs (from enum in reb_simulation)
75pub const REB_INTEGRATOR_IAS15: c_int = 0;
76pub const REB_INTEGRATOR_WHFAST: c_int = 1;
77
78// REBOUND gravity modes
79pub const REB_GRAVITY_NONE: c_int = 0;
80pub const REB_GRAVITY_BASIC: c_int = 1;
81
82// REBOUND status codes
83pub const REB_STATUS_SUCCESS: c_int = 0;
84pub const REB_STATUS_RUNNING: c_int = -1;
85pub const REB_STATUS_GENERIC_ERROR: c_int = 1;
86pub const REB_STATUS_NO_PARTICLES: c_int = 2;
87pub const REB_STATUS_ENCOUNTER: c_int = 3;
88pub const REB_STATUS_ESCAPE: c_int = 4;
89pub const REB_STATUS_USER: c_int = 5;
90pub const REB_STATUS_SIGINT: c_int = 6;
91pub const REB_STATUS_COLLISION: c_int = 7;
92
93// ---------------------------------------------------------------------------
94// REBOUND functions
95// ---------------------------------------------------------------------------
96
97unsafe extern "C" {
98    // Simulation lifecycle
99    pub fn reb_simulation_create() -> *mut reb_simulation;
100    pub fn reb_simulation_free(r: *mut reb_simulation);
101
102    // Particle management
103    pub fn reb_simulation_add(r: *mut reb_simulation, pt: reb_particle);
104
105    // Integration
106    pub fn reb_simulation_integrate(r: *mut reb_simulation, tmax: c_double) -> c_int;
107    pub fn reb_simulation_step(r: *mut reb_simulation);
108    pub fn reb_simulation_synchronize(r: *mut reb_simulation);
109
110    // Variational equations
111    pub fn reb_simulation_add_variation_1st_order(
112        r: *mut reb_simulation,
113        testparticle: c_int,
114    ) -> c_int;
115
116    // Integrator reset: frees IAS15 scratch arrays (b/e/br/er/csb/csx/csv/csa0
117    // plus g/x0/v0/a0/at/map). Required between orbit reuses to clear
118    // cross-orbit carryover in the compensated-summation and predictor state.
119    pub fn reb_integrator_ias15_reset(r: *mut reb_simulation);
120}
121
122// ---------------------------------------------------------------------------
123// C helper functions (from src/helpers.c)
124// ---------------------------------------------------------------------------
125
126unsafe extern "C" {
127    // reb_simulation field accessors
128    pub fn assist_rs_sim_get_t(r: *const reb_simulation) -> c_double;
129    pub fn assist_rs_sim_set_t(r: *mut reb_simulation, t: c_double);
130    pub fn assist_rs_sim_get_dt(r: *const reb_simulation) -> c_double;
131    pub fn assist_rs_sim_set_dt(r: *mut reb_simulation, dt: c_double);
132    pub fn assist_rs_sim_get_N(r: *const reb_simulation) -> c_uint;
133    pub fn assist_rs_sim_get_steps_done(r: *const reb_simulation) -> u64;
134    pub fn assist_rs_ias15_zero_state(r: *mut reb_simulation);
135    pub fn assist_rs_sim_get_N_var(r: *const reb_simulation) -> c_int;
136    pub fn assist_rs_sim_get_N_active(r: *const reb_simulation) -> c_int;
137    pub fn assist_rs_sim_set_N_active(r: *mut reb_simulation, n: c_int);
138    pub fn assist_rs_sim_get_particles(r: *const reb_simulation) -> *mut reb_particle;
139    pub fn assist_rs_sim_get_exact_finish_time(r: *const reb_simulation) -> c_int;
140    pub fn assist_rs_sim_set_exact_finish_time(r: *mut reb_simulation, v: c_int);
141    pub fn assist_rs_sim_get_force_is_velocity_dependent(r: *const reb_simulation) -> c_uint;
142    pub fn assist_rs_sim_get_status(r: *const reb_simulation) -> c_int;
143    pub fn assist_rs_sim_get_extras(r: *const reb_simulation) -> *mut c_void;
144    pub fn assist_rs_sim_get_integrator(r: *const reb_simulation) -> c_int;
145    pub fn assist_rs_sim_set_integrator(r: *mut reb_simulation, i: c_int);
146    pub fn assist_rs_sim_get_gravity(r: *const reb_simulation) -> c_int;
147    pub fn assist_rs_sim_set_gravity(r: *mut reb_simulation, g: c_int);
148    pub fn assist_rs_sim_get_ias15_epsilon(r: *const reb_simulation) -> c_double;
149    pub fn assist_rs_sim_set_ias15_epsilon(r: *mut reb_simulation, eps: c_double);
150    pub fn assist_rs_sim_get_ias15_min_dt(r: *const reb_simulation) -> c_double;
151    pub fn assist_rs_sim_set_ias15_min_dt(r: *mut reb_simulation, min_dt: c_double);
152    pub fn assist_rs_sim_get_ias15_adaptive_mode(r: *const reb_simulation) -> c_int;
153    pub fn assist_rs_sim_set_ias15_adaptive_mode(r: *mut reb_simulation, mode: c_int);
154    pub fn assist_rs_sim_get_ias15_iterations_max_exceeded(r: *const reb_simulation) -> u64;
155}