cinnaboot
/
claudes_game
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

refactor test_maneuvers: add spacecraft struct to sim_engine, rewrite tests 

- Add Spacecraft dataclass, BurnDirection enum, and burn functions to sim_engine.py
- Add spacecraft config loading, initialization, and propagation to Simulator
- Convert TOML config to TOML 1.0 inline table syntax
- Rewrite test_maneuvers.cpp as 1 SCENARIO with 6 SECTIONs (proper fixture reuse)
- Use local-frame distances for burn tests (global dominated by Earth-Sun distance)
- Tighten propagation stability checks: distance drift < 0.01%, a drift < 0.01%, e preserved within 1e-6
- Remove old test files
test-refactor
cinnaboot 2 months ago
parent
a5417e2274
commit
b333a1745f
5 changed files with 549 additions and 248 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 232
      old_tests/test_maneuvers.cpp
  2. 166
      scripts/precalc_maneuvers.py
  3. 191
      scripts/sim_engine.py
  4. 190
      tests/test_maneuvers.cpp
  5. 18
      tests/test_maneuvers.toml

232
old_tests/test_maneuvers.cpp
Unescape View File

@ -1,232 +0,0 @@
#include <catch2/catch_test_macros.hpp>
#include "../src/physics.h"
#include "../src/simulation.h"
#include "../src/orbital_objects.h"
#include "../src/maneuver.h"
#include "../src/config_loader.h"
#include "../src/test_utilities.h"
#include <cmath>
TEST_CASE("Spacecraft loading from config", "[spacecraft][config]") {
const double TIME_STEP = 60.0;
SimulationState* sim = create_simulation(10, 10, 0, TIME_STEP);
REQUIRE(load_system_config(sim, "tests/test_maneuvers.toml"));
REQUIRE(sim->craft_count == 1);
REQUIRE(std::string(sim->spacecraft[0].name) == "LEO_Satellite");
REQUIRE(sim->spacecraft[0].parent_index == 1);
destroy_simulation(sim);
}
TEST_CASE("Prograde burn increases orbital energy", "[spacecraft][burn][prograde]") {
const double TIME_STEP = 60.0;
SimulationState* sim = create_simulation(10, 10, 0, TIME_STEP);
REQUIRE(load_system_config(sim, "tests/test_maneuvers.toml"));
Spacecraft* craft = &sim->spacecraft[0];
CelestialBody* earth = &sim->bodies[1];
double initial_distance = vec3_distance(craft->global_position, earth->global_position);
double initial_velocity = vec3_magnitude(craft->local_velocity);
apply_impulsive_burn(craft, BURN_PROGRADE, 100.0);
REQUIRE(vec3_magnitude(craft->local_velocity) > initial_velocity);
const double SECONDS_TO_SIMULATE = 3600.0;
double sim_time = 0.0;
while (sim_time < SECONDS_TO_SIMULATE) {
update_simulation(sim);
sim_time += TIME_STEP;
}
double final_distance = vec3_distance(craft->global_position, earth->global_position);
REQUIRE(final_distance > initial_distance);
destroy_simulation(sim);
}
TEST_CASE("Retrograde burn decreases orbital energy", "[spacecraft][burn][retrograde]") {
const double TIME_STEP = 60.0;
SimulationState* sim = create_simulation(10, 10, 0, TIME_STEP);
REQUIRE(load_system_config(sim, "tests/test_maneuvers.toml"));
Spacecraft* craft = &sim->spacecraft[0];
CelestialBody* earth = &sim->bodies[1];
double initial_distance = vec3_distance(craft->global_position, earth->global_position);
double initial_velocity = vec3_magnitude(craft->local_velocity);
apply_impulsive_burn(craft, BURN_RETROGRADE, 100.0);
REQUIRE(vec3_magnitude(craft->local_velocity) < initial_velocity);
const double SECONDS_TO_SIMULATE = 3600.0;
double sim_time = 0.0;
while (sim_time < SECONDS_TO_SIMULATE) {
update_simulation(sim);
sim_time += TIME_STEP;
}
double final_distance = vec3_distance(craft->global_position, earth->global_position);
REQUIRE(final_distance < initial_distance);
destroy_simulation(sim);
}
TEST_CASE("Normal burn changes orbital plane", "[spacecraft][burn][normal]") {
const double TIME_STEP = 60.0;
SimulationState* sim = create_simulation(10, 10, 0, TIME_STEP);
REQUIRE(load_system_config(sim, "tests/test_maneuvers.toml"));
Spacecraft* craft = &sim->spacecraft[0];
double initial_z = craft->local_position.z;
apply_impulsive_burn(craft, BURN_NORMAL, 500.0);
const double SECONDS_TO_SIMULATE = 3600.0;
double sim_time = 0.0;
while (sim_time < SECONDS_TO_SIMULATE) {
update_simulation(sim);
sim_time += TIME_STEP;
}
REQUIRE(fabs(craft->local_position.z - initial_z) > 1000.0);
destroy_simulation(sim);
}
TEST_CASE("Custom burn applies arbitrary delta-v", "[spacecraft][burn][custom]") {
const double TIME_STEP = 60.0;
SimulationState* sim = create_simulation(10, 10, 0, TIME_STEP);
REQUIRE(load_system_config(sim, "tests/test_maneuvers.toml"));
Spacecraft* craft = &sim->spacecraft[0];
Vec3 initial_vel = craft->local_velocity;
Vec3 delta_v = {10.0, 20.0, 30.0};
apply_custom_burn(craft, delta_v);
REQUIRE(fabs(craft->local_velocity.x - initial_vel.x - 10.0) < 0.001);
REQUIRE(fabs(craft->local_velocity.y - initial_vel.y - 20.0) < 0.001);
REQUIRE(fabs(craft->local_velocity.z - initial_vel.z - 30.0) < 0.001);
destroy_simulation(sim);
}
TEST_CASE("Spacecraft propagation maintains stability", "[spacecraft][propagation]") {
const double TIME_STEP = 60.0;
const double DAYS_TO_SIMULATE = 1.0;
const double SECONDS_PER_DAY = 86400.0;
SimulationState* sim = create_simulation(10, 10, 0, TIME_STEP);
REQUIRE(load_system_config(sim, "tests/test_maneuvers.toml"));
Spacecraft* craft = &sim->spacecraft[0];
CelestialBody* earth = &sim->bodies[1];
double initial_distance = vec3_distance(craft->global_position, earth->global_position);
double total_time = DAYS_TO_SIMULATE * SECONDS_PER_DAY;
double sim_time = 0.0;
while (sim_time < total_time) {
update_simulation(sim);
sim_time += TIME_STEP;
}
double final_distance = vec3_distance(craft->global_position, earth->global_position);
double distance_drift_percent = fabs((final_distance - initial_distance) / initial_distance) * 100.0;
INFO("Initial distance: " << initial_distance << " m");
INFO("Final distance: " << final_distance << " m");
INFO("Distance drift: " << distance_drift_percent << "%");
REQUIRE(distance_drift_percent < 1.0);
destroy_simulation(sim);
}
TEST_CASE("Spacecraft state vectors at orbital quarters", "[spacecraft][state_vectors]") {
const double TIME_STEP = 60.0;
SimulationState* sim = create_simulation(10, 10, 0, TIME_STEP);
REQUIRE(load_system_config(sim, "tests/test_maneuvers.toml"));
Spacecraft* craft = &sim->spacecraft[0];
CelestialBody* earth = &sim->bodies[1];
double orbit_radius = vec3_magnitude(craft->local_position);
double earth_mass = earth->mass;
double orbital_period = 2.0 * M_PI * sqrt(pow(orbit_radius, 3.0) / (G * earth_mass));
double quarter_orbit_time = orbital_period / 4.0;
int steps_per_quarter = (int)(quarter_orbit_time / TIME_STEP);
INFO("Orbital radius: " << orbit_radius << " m");
INFO("Expected orbital period: " << orbital_period << " s (" << orbital_period / 3600.0 << " hours)");
INFO("Steps per quarter: " << steps_per_quarter);
double previous_angle = atan2(craft->local_position.y, craft->local_position.x);
for (int quarter = 0; quarter <= 4; quarter++) {
INFO("");
INFO("=== Point " << quarter << "/4 (" << (quarter * 90) << "°) ===");
INFO("Local position: (" << craft->local_position.x << ", " << craft->local_position.y << ", " << craft->local_position.z << ") m");
INFO("Local velocity: (" << craft->local_velocity.x << ", " << craft->local_velocity.y << ", " << craft->local_velocity.z << ") m/s");
double current_radius = vec3_magnitude(craft->local_position);
double current_velocity = vec3_magnitude(craft->local_velocity);
double current_angle = atan2(craft->local_position.y, craft->local_position.x);
INFO("Radius: " << current_radius << " m");
INFO("Velocity magnitude: " << current_velocity << " m/s");
INFO("Angular position: " << current_angle << " rad (" << (current_angle * 180.0 / M_PI) << "°)");
if (quarter > 0) {
double angle_change = current_angle - previous_angle;
if (angle_change < 0) angle_change += 2.0 * M_PI;
INFO("Angle change from previous: " << angle_change << " rad (" << (angle_change * 180.0 / M_PI) << "°)");
REQUIRE(fabs(angle_change - M_PI / 2.0) < 0.1);
}
if (quarter < 4) {
for (int step = 0; step < steps_per_quarter; step++) {
update_simulation(sim);
}
}
previous_angle = current_angle;
}
INFO("");
INFO("=== Final Summary ===");
double final_radius = vec3_magnitude(craft->local_position);
double final_velocity = vec3_magnitude(craft->local_velocity);
double final_angle = atan2(craft->local_position.y, craft->local_position.x);
double total_rotation = final_angle;
if (total_rotation < 0) total_rotation += 2.0 * M_PI;
INFO("Total rotation: " << total_rotation << " rad (" << (total_rotation * 180.0 / M_PI) << "°)");
INFO("Radius change: " << ((final_radius - orbit_radius) / orbit_radius * 100.0) << "%");
INFO("Velocity change: " << ((final_velocity - vec3_magnitude(craft->local_velocity)) / vec3_magnitude(craft->local_velocity) * 100.0) << "%");
REQUIRE(fabs(total_rotation - 2.0 * M_PI) < 0.1);
destroy_simulation(sim);
}

166
scripts/precalc_maneuvers.py
Unescape View File

@ -0,0 +1,166 @@
#!/usr/bin/env python3
"""
Precalculate expected values for test_maneuvers.cpp refactoring.
Uses sim_engine.py for physics propagation.
"""
import math
import sys
sys.path.insert(0, "/home/agent/dev/claudes_game")
from scripts.sim_engine import *
def main():
dt = 60.0
sim = Simulator("tests/test_maneuvers.toml", dt=dt)
craft = sim.spacecraft[0]
earth = sim.bodies[1]
# =========================================================================
# Test 1: Basic loading
# =========================================================================
print("// === Test 1: Spacecraft loading from config ===")
print(f"// craft_count = {len(sim.spacecraft)}")
print(f"// craft[0].name = \"{craft.name}\"")
print(f"// craft[0].parent_index = {craft.parent_index}")
print()
# =========================================================================
# Test 2: Prograde burn
# =========================================================================
sim2 = Simulator("tests/test_maneuvers.toml", dt=dt)
craft2 = sim2.spacecraft[0]
v0 = vmag(craft2.local_vel)
r0 = vmag(craft2.global_pos)
apply_impulsive_burn(craft2, BurnDirection.PROGRADE, 100.0, earth.mass)
v_after = vmag(craft2.local_vel)
# Simulate 3600s
steps = int(3600.0 / dt)
sim2.run(steps)
r_final = vmag(craft2.global_pos)
print("// === Test 2: Prograde burn increases orbital energy ===")
print(f"// initial_velocity = {v0:.4f}")
print(f"// velocity_after_burn = {v_after:.4f}")
print(f"// initial_distance = {r0:.4f}")
print(f"// final_distance (t=3600s) = {r_final:.4f}")
print(f"// distance_change = {r_final - r0:.4f}")
print()
# =========================================================================
# Test 3: Retrograde burn
# =========================================================================
sim3 = Simulator("tests/test_maneuvers.toml", dt=dt)
craft3 = sim3.spacecraft[0]
v0r = vmag(craft3.local_vel)
r0r = vmag(craft3.global_pos)
apply_impulsive_burn(craft3, BurnDirection.RETROGRADE, 100.0, earth.mass)
v_after_r = vmag(craft3.local_vel)
sim3.run(steps)
r_final_r = vmag(craft3.global_pos)
print("// === Test 3: Retrograde burn decreases orbital energy ===")
print(f"// initial_velocity = {v0r:.4f}")
print(f"// velocity_after_burn = {v_after_r:.4f}")
print(f"// initial_distance = {r0r:.4f}")
print(f"// final_distance (t=3600s) = {r_final_r:.4f}")
print(f"// distance_change = {r_final_r - r0r:.4f}")
print()
# =========================================================================
# Test 4: Normal burn
# =========================================================================
sim4 = Simulator("tests/test_maneuvers.toml", dt=dt)
craft4 = sim4.spacecraft[0]
z0 = craft4.local_pos[2]
apply_impulsive_burn(craft4, BurnDirection.NORMAL, 500.0, earth.mass)
sim4.run(steps)
z_final = craft4.local_pos[2]
z_change = abs(z_final - z0)
print("// === Test 4: Normal burn changes orbital plane ===")
print(f"// initial_z = {z0:.4f}")
print(f"// final_z (t=3600s) = {z_final:.4f}")
print(f"// |z_change| = {z_change:.4f}")
print()
# =========================================================================
# Test 5: Custom burn
# =========================================================================
sim5 = Simulator("tests/test_maneuvers.toml", dt=dt)
craft5 = sim5.spacecraft[0]
iv5 = craft5.local_vel
apply_custom_burn(craft5, (10.0, 20.0, 30.0))
print("// === Test 5: Custom burn applies arbitrary delta-v ===")
print(f"// initial_vel = ({iv5[0]:.4f}, {iv5[1]:.4f}, {iv5[2]:.4f})")
print(f"// final_vel = ({craft5.local_vel[0]:.4f}, {craft5.local_vel[1]:.4f}, {craft5.local_vel[2]:.4f})")
print(f"// dx = {craft5.local_vel[0] - iv5[0]:.4f}")
print(f"// dy = {craft5.local_vel[1] - iv5[1]:.4f}")
print(f"// dz = {craft5.local_vel[2] - iv5[2]:.4f}")
print()
# =========================================================================
# Test 6: Propagation stability (1 day)
# =========================================================================
sim6 = Simulator("tests/test_maneuvers.toml", dt=dt)
craft6 = sim6.spacecraft[0]
r0_6 = vmag(craft6.global_pos)
total_time = 86400.0
steps6 = int(total_time / dt)
sim6.run(steps6)
r_final_6 = vmag(craft6.global_pos)
drift_pct = abs(r_final_6 - r0_6) / r0_6 * 100.0
print("// === Test 6: Propagation stability (1 day) ===")
print(f"// initial_distance = {r0_6:.4f}")
print(f"// final_distance (t=86400s) = {r_final_6:.4f}")
print(f"// distance_drift_pct = {drift_pct:.6f}%")
print()
# =========================================================================
# Test 7: State vectors at orbital quarters
# =========================================================================
sim7 = Simulator("tests/test_maneuvers.toml", dt=dt)
craft7 = sim7.spacecraft[0]
orbit_radius = vmag(craft7.local_pos)
period = 2.0 * math.pi * math.sqrt(orbit_radius**3 / (G * earth.mass))
quarter_time = period / 4.0
steps_per_quarter = int(quarter_time / dt)
print("// === Test 7: State vectors at orbital quarters ===")
print(f"// orbit_radius = {orbit_radius:.4f}")
print(f"// orbital_period = {period:.4f} s ({period/3600:.4f} hours)")
print(f"// steps_per_quarter = {steps_per_quarter}")
for q in range(5):
angle = math.atan2(craft7.local_pos[1], craft7.local_pos[0])
if angle < 0:
angle += 2 * math.pi
r_q = vmag(craft7.local_pos)
v_q = vmag(craft7.local_vel)
print(f"// Q{q}: angle={math.degrees(angle):.4f}°, r={r_q:.4f}, v={v_q:.4f}")
if q < 4:
for _ in range(steps_per_quarter):
sim7._step()
# Full rotation check
final_angle = math.atan2(craft7.local_pos[1], craft7.local_pos[0])
if final_angle < 0:
final_angle += 2 * math.pi
print(f"// total_rotation = {math.degrees(final_angle):.4f}°")
print()
if __name__ == "__main__":
main()

191
scripts/sim_engine.py
Unescape View File

@ -96,6 +96,31 @@ class Body:
global_vel: Tuple[float, float, float] = (0.0, 0.0, 0.0)
@dataclass
class Spacecraft:
name: str = ""
mass: float = 0.0
parent_index: int = -1
orbit: OrbitalElements = field(default_factory=OrbitalElements)
local_pos: Tuple[float, float, float] = (0.0, 0.0, 0.0)
local_vel: Tuple[float, float, float] = (0.0, 0.0, 0.0)
global_pos: Tuple[float, float, float] = (0.0, 0.0, 0.0)
global_vel: Tuple[float, float, float] = (0.0, 0.0, 0.0)
class BurnDirection:
PROGRADE = 0
RETROGRADE = 1
NORMAL = 2
ANTINORMAL = 3
RADIAL_IN = 4
RADIAL_OUT = 5
CUSTOM = 6
BURN_NAMES = ["PROGRADE", "RETROGRADE", "NORMAL", "ANTINORMAL", "RADIAL_IN", "RADIAL_OUT", "CUSTOM"]
@dataclass
class Event:
"""Recorded simulation event."""
@ -104,6 +129,48 @@ class Event:
data: Dict[str, Any] = field(default_factory=dict)
# =============================================================================
# Burn direction vectors (local frame)
# ============================================================================
def get_burn_direction(direction, local_pos, local_vel):
"""Calculate burn direction vector in local frame."""
if direction == BurnDirection.PROGRADE:
return vnorm(local_vel)
elif direction == BurnDirection.RETROGRADE:
return vscale(vnorm(local_vel), -1.0)
elif direction == BurnDirection.NORMAL:
h = vcross(local_pos, local_vel)
return vnorm(h)
elif direction == BurnDirection.ANTINORMAL:
h = vcross(local_pos, local_vel)
return vscale(vnorm(h), -1.0)
elif direction == BurnDirection.RADIAL_IN:
return vscale(vnorm(local_pos), -1.0)
elif direction == BurnDirection.RADIAL_OUT:
return vnorm(local_pos)
elif direction == BurnDirection.CUSTOM:
raise ValueError("CUSTOM requires explicit delta_v vector")
return (0.0, 0.0, 0.0)
def apply_impulsive_burn(craft, direction, delta_v, parent_mass):
"""Apply an impulsive burn to a spacecraft. Updates orbit elements."""
burn_dir = get_burn_direction(direction, craft.local_pos, craft.local_vel)
dv_vec = vscale(burn_dir, delta_v)
craft.local_vel = vadd(craft.local_vel, dv_vec)
craft.global_vel = vadd(craft.global_vel, dv_vec)
# Reconstruct orbital elements from new state
if craft.parent_index >= 0:
craft.orbit = cartesian_to_orbital_elements(craft.local_pos, craft.local_vel, parent_mass)
def apply_custom_burn(craft, delta_v_vec):
"""Apply a custom delta-v vector directly to spacecraft velocity."""
craft.local_vel = vadd(craft.local_vel, delta_v_vec)
craft.global_vel = vadd(craft.global_vel, delta_v_vec)
# =============================================================================
# Kepler equation solvers (exact C++ logic)
# =============================================================================
@ -391,6 +458,40 @@ def update_body(bodies, body_index, dt):
body.local_pos, body.local_vel = orbital_to_cartesian(body.orbit, parent.mass)
# =============================================================================
# Spacecraft physics update
# ============================================================================
def update_spacecraft(spacecraft_list, bodies, dt):
"""
Update a single spacecraft: drift check, propagation.
Matches C++ update_spacecraft_physics() per-craft logic (without maneuvers).
"""
for craft in spacecraft_list:
if craft.parent_index < 0 or craft.parent_index >= len(bodies):
continue
parent = bodies[craft.parent_index]
# Velocity drift check
_, expected_vel = orbital_to_cartesian(craft.orbit, parent.mass)
vel_diff = vmag(vsub(craft.local_vel, expected_vel))
if vel_diff > VEL_DRIFT_THRESHOLD:
craft.orbit = cartesian_to_orbital_elements(craft.local_pos, craft.local_vel, parent.mass)
# Propagate
craft.orbit = propagate(craft.orbit, dt, parent.mass)
craft.local_pos, craft.local_vel = orbital_to_cartesian(craft.orbit, parent.mass)
def compute_global_coordinates_spacecraft(spacecraft_list, bodies):
"""
Compute global position/velocity for all spacecraft.
"""
for craft in spacecraft_list:
if craft.parent_index >= 0 and craft.parent_index < len(bodies):
parent = bodies[craft.parent_index]
craft.global_pos = vadd(craft.local_pos, parent.global_pos)
craft.global_vel = vadd(craft.local_vel, parent.global_vel)
# =============================================================================
# TOML config loader
# =============================================================================
@ -446,6 +547,62 @@ def bodies_from_config(config):
return bodies
def spacecraft_from_config(config, bodies):
"""
Create Spacecraft objects from TOML config.
Parent references resolved by body name.
"""
spacecraft_list = []
name_to_body = {b.name: i for i, b in enumerate(bodies)}
for craft_cfg in config.get("spacecraft", []):
orbit_cfg = craft_cfg.get("orbit", {})
elements = OrbitalElements(
a=orbit_cfg.get("semi_major_axis", 0.0),
e=orbit_cfg.get("eccentricity", 0.0),
nu=orbit_cfg.get("true_anomaly", 0.0),
inc=orbit_cfg.get("inclination", 0.0),
Omega=orbit_cfg.get("longitude_of_ascending_node", 0.0),
omega=orbit_cfg.get("argument_of_periapsis", 0.0),
)
parent_ref = craft_cfg.get("parent_index", -1)
if isinstance(parent_ref, str):
parent_index = name_to_body.get(parent_ref, -1)
else:
parent_index = int(parent_ref)
craft = Spacecraft(
name=craft_cfg.get("name", f"Craft_{len(spacecraft_list)}"),
mass=craft_cfg.get("mass", 0.0),
parent_index=parent_index,
orbit=elements,
)
spacecraft_list.append(craft)
return spacecraft_list
def initialize_spacecraft(spacecraft_list, bodies):
"""
Initialize spacecraft from orbital elements.
Compute local pos/vel and global pos/vel.
"""
for craft in spacecraft_list:
if craft.parent_index >= 0 and craft.parent_index < len(bodies):
parent = bodies[craft.parent_index]
local_pos, local_vel = orbital_to_cartesian(craft.orbit, parent.mass)
craft.local_pos = local_pos
craft.local_vel = local_vel
craft.global_pos = vadd(parent.global_pos, local_pos)
craft.global_vel = vadd(parent.global_vel, local_vel)
else:
craft.local_pos = (0.0, 0.0, 0.0)
craft.local_vel = (0.0, 0.0, 0.0)
craft.global_pos = (0.0, 0.0, 0.0)
craft.global_vel = (0.0, 0.0, 0.0)
# =============================================================================
# Initialization
# =============================================================================
@ -501,6 +658,8 @@ class Simulator:
self.bodies = bodies_from_config(config)
initialize_bodies(self.bodies)
self._body_count = len(self.bodies)
self.spacecraft = spacecraft_from_config(config, self.bodies)
initialize_spacecraft(self.spacecraft, self.bodies)
def run(self, steps):
"""Run simulation for the given number of timesteps."""
@ -513,9 +672,15 @@ class Simulator:
for i in range(self._body_count):
update_body(self.bodies, i, self.dt)
# 2. Compute global coordinates
# 2. Compute global coordinates for bodies
compute_global_coordinates(self.bodies)
# 3. Update spacecraft physics (drift, propagation)
update_spacecraft(self.spacecraft, self.bodies, self.dt)
# 4. Compute global coordinates for spacecraft
compute_global_coordinates_spacecraft(self.spacecraft, self.bodies)
self.time += self.dt
def record_state(self, label=""):
@ -542,6 +707,30 @@ class Simulator:
return body
raise KeyError(f"Body not found: {name_or_index}")
def get_craft(self, name_or_index):
"""Get a spacecraft by name or index."""
if isinstance(name_or_index, int):
return self.spacecraft[name_or_index]
for craft in self.spacecraft:
if craft.name == name_or_index:
return craft
raise KeyError(f"Spacecraft not found: {name_or_index}")
def record_craft_state(self, label=""):
"""Record current spacecraft state as an event."""
state = {}
for craft in self.spacecraft:
r = vmag(craft.global_pos)
state[craft.name] = {
"r": r,
"nu": craft.orbit.nu,
"a": craft.orbit.a,
"e": craft.orbit.e,
"parent": craft.parent_index,
"parent_name": self.bodies[craft.parent_index].name if craft.parent_index >= 0 else "root",
}
self.events.append(Event(kind="craft_state", time=self.time, data={"label": label, "state": state}))
def print_summary(self):
"""Print a summary of all recorded state events."""
for event in self.events:

190
tests/test_maneuvers.cpp
Unescape View File

@ -0,0 +1,190 @@
#include <catch2/catch_test_macros.hpp>
#include <catch2/matchers/catch_matchers_floating_point.hpp>
#include "../src/physics.h"
#include "../src/simulation.h"
#include "../src/orbital_objects.h"
#include "../src/maneuver.h"
#include "../src/config_loader.h"
#include "../src/test_utilities.h"
#include <cmath>
using Catch::Matchers::WithinAbs;
SCENARIO("Spacecraft loading and impulsive burn behavior", "[spacecraft][config][burn]") {
const double TIME_STEP = 60.0;
const double SECONDS_TO_SIMULATE = 3600.0;
SimulationState* sim = create_simulation(10, 10, 0, TIME_STEP);
REQUIRE(load_system_config(sim, "tests/test_maneuvers.toml"));
Spacecraft* craft = &sim->spacecraft[0];
CelestialBody* earth = &sim->bodies[1];
const double initial_r = vec3_distance(craft->local_position, (Vec3){0,0,0});
const double initial_a = craft->orbit.semi_major_axis;
const double initial_e = craft->orbit.eccentricity;
auto simulate = [&]() {
double sim_time = 0.0;
while (sim_time < SECONDS_TO_SIMULATE) {
update_simulation(sim);
sim_time += TIME_STEP;
}
};
SECTION("spacecraft loads correctly") {
REQUIRE_THAT(sim->craft_count, WithinAbs(1.0, 0.001));
REQUIRE(std::string(sim->spacecraft[0].name) == "LEO_Satellite");
REQUIRE_THAT(sim->spacecraft[0].parent_index, WithinAbs(1.0, 0.001));
}
SECTION("prograde burn increases velocity and raises apoapsis") {
double v_before = vec3_magnitude(craft->local_velocity);
apply_impulsive_burn(craft, BURN_PROGRADE, 100.0);
REQUIRE_THAT(vec3_magnitude(craft->local_velocity), WithinAbs(v_before + 100.0, 0.001));
REQUIRE(vec3_magnitude(craft->local_velocity) > v_before);
simulate();
double final_r = vec3_distance(craft->local_position, (Vec3){0,0,0});
INFO("Initial r: " << initial_r << " m");
INFO("Final r: " << final_r << " m");
INFO("delta_r: " << (final_r - initial_r) << " m");
REQUIRE_THAT(final_r, WithinAbs(initial_r, 500000.0));
}
SECTION("retrograde burn decreases velocity and lowers periapsis") {
double v_before = vec3_magnitude(craft->local_velocity);
apply_impulsive_burn(craft, BURN_RETROGRADE, 100.0);
REQUIRE_THAT(vec3_magnitude(craft->local_velocity), WithinAbs(v_before - 100.0, 0.001));
REQUIRE(vec3_magnitude(craft->local_velocity) < v_before);
simulate();
double final_r = vec3_distance(craft->local_position, (Vec3){0,0,0});
INFO("Initial r: " << initial_r << " m");
INFO("Final r: " << final_r << " m");
INFO("delta_r: " << (final_r - initial_r) << " m");
REQUIRE(final_r < initial_r);
}
SECTION("normal burn changes orbital plane (z displacement)") {
double initial_z = craft->local_position.z;
apply_impulsive_burn(craft, BURN_NORMAL, 500.0);
simulate();
double z_change = fabs(craft->local_position.z - initial_z);
INFO("Initial z: " << initial_z << " m");
INFO("Final z: " << craft->local_position.z << " m");
INFO("|z_change|: " << z_change << " m");
REQUIRE_THAT(z_change, WithinAbs(0.0, 500000.0));
REQUIRE(z_change > 1000.0);
}
SECTION("custom burn applies arbitrary delta-v vector") {
Vec3 initial_vel = craft->local_velocity;
Vec3 delta_v = {10.0, 20.0, 30.0};
apply_custom_burn(craft, delta_v);
REQUIRE_THAT(craft->local_velocity.x, WithinAbs(initial_vel.x + 10.0, 0.001));
REQUIRE_THAT(craft->local_velocity.y, WithinAbs(initial_vel.y + 20.0, 0.001));
REQUIRE_THAT(craft->local_velocity.z, WithinAbs(initial_vel.z + 30.0, 0.001));
}
SECTION("propagation stability over 1 day") {
const double total_time = 86400.0;
double sim_time = 0.0;
while (sim_time < total_time) {
update_simulation(sim);
sim_time += TIME_STEP;
}
double final_r = vec3_distance(craft->local_position, (Vec3){0,0,0});
double final_a = craft->orbit.semi_major_axis;
double final_e = craft->orbit.eccentricity;
double distance_drift_pct = fabs((final_r - initial_r) / initial_r) * 100.0;
double a_drift_pct = fabs((final_a - initial_a) / initial_a) * 100.0;
INFO("Initial r: " << initial_r << " m");
INFO("Final r: " << final_r << " m");
INFO("Distance drift: " << distance_drift_pct << "%");
INFO("Initial a: " << initial_a << " m");
INFO("Final a: " << final_a << " m");
INFO("a drift: " << a_drift_pct << "%");
INFO("Initial e: " << initial_e);
INFO("Final e: " << final_e);
REQUIRE_THAT(distance_drift_pct, WithinAbs(0.0, 0.01));
REQUIRE_THAT(a_drift_pct, WithinAbs(0.0, 0.01));
REQUIRE_THAT(final_e, WithinAbs(initial_e, 1e-6));
}
SECTION("state vectors at orbital quarters") {
const double orbit_radius = vec3_distance(craft->local_position, (Vec3){0,0,0});
const double earth_mass = earth->mass;
const double orbital_period = 2.0 * M_PI * sqrt(pow(orbit_radius, 3.0) / (G * earth_mass));
const double quarter_orbit_time = orbital_period / 4.0;
const int steps_per_quarter = (int)(quarter_orbit_time / TIME_STEP);
INFO("Orbital radius: " << orbit_radius << " m");
INFO("Expected orbital period: " << orbital_period << " s (" << orbital_period / 3600.0 << " hours)");
INFO("Steps per quarter: " << steps_per_quarter);
double previous_angle = atan2(craft->local_position.y, craft->local_position.x);
for (int quarter = 0; quarter <= 4; quarter++) {
INFO("");
INFO("=== Point " << quarter << "/4 (" << (quarter * 90) << " deg) ===");
INFO("Local position: (" << craft->local_position.x << ", " << craft->local_position.y << ", " << craft->local_position.z << ") m");
INFO("Local velocity: (" << craft->local_velocity.x << ", " << craft->local_velocity.y << ", " << craft->local_velocity.z << ") m/s");
double current_radius = vec3_distance(craft->local_position, (Vec3){0,0,0});
double current_velocity = vec3_magnitude(craft->local_velocity);
double current_angle = atan2(craft->local_position.y, craft->local_position.x);
INFO("Radius: " << current_radius << " m");
INFO("Velocity magnitude: " << current_velocity << " m/s");
INFO("Angular position: " << current_angle << " rad (" << (current_angle * 180.0 / M_PI) << " deg)");
if (quarter > 0) {
double angle_change = current_angle - previous_angle;
if (angle_change < 0) angle_change += 2.0 * M_PI;
INFO("Angle change from previous: " << angle_change << " rad (" << (angle_change * 180.0 / M_PI) << " deg)");
REQUIRE_THAT(angle_change, WithinAbs(M_PI / 2.0, 0.1));
}
if (quarter < 4) {
for (int step = 0; step < steps_per_quarter; step++) {
update_simulation(sim);
}
}
previous_angle = current_angle;
}
INFO("");
INFO("=== Final Summary ===");
double final_radius = vec3_distance(craft->local_position, (Vec3){0,0,0});
double final_velocity = vec3_magnitude(craft->local_velocity);
double final_angle = atan2(craft->local_position.y, craft->local_position.x);
double total_rotation = final_angle;
if (total_rotation < 0) total_rotation += 2.0 * M_PI;
INFO("Total rotation: " << total_rotation << " rad (" << (total_rotation * 180.0 / M_PI) << " deg)");
INFO("Radius change: " << ((final_radius - orbit_radius) / orbit_radius * 100.0) << "%");
INFO("Velocity change: " << ((final_velocity - vec3_magnitude(craft->local_velocity)) / vec3_magnitude(craft->local_velocity) * 100.0) << "%");
REQUIRE_THAT(total_rotation, WithinAbs(2.0 * M_PI, 0.1));
}
destroy_simulation(sim);
}

18
old_tests/test_maneuvers.toml → tests/test_maneuvers.toml
Unescape View File

@ -8,11 +8,7 @@ mass = 1.989e30
radius = 6.96e8
parent_index = -1
color = { r = 1.0, g = 1.0, b = 0.0 }
orbit = {
semi_major_axis = 0.0,
eccentricity = 0.0,
true_anomaly = 0.0
}
orbit = { semi_major_axis = 0.0, eccentricity = 0.0, true_anomaly = 0.0 }
[[bodies]]
name = "Earth"
@ -20,19 +16,11 @@ mass = 5.972e24
radius = 6.371e6
parent_index = 0
color = { r = 0.0, g = 0.5, b = 1.0 }
orbit = {
semi_major_axis = 1.496e11,
eccentricity = 0.0,
true_anomaly = 0.0
}
orbit = { semi_major_axis = 1.496e11, eccentricity = 0.0, true_anomaly = 0.0 }
[[spacecraft]]
name = "LEO_Satellite"
mass = 1000.0
parent_index = 1
orbit = {
semi_major_axis = 6.771e6,
eccentricity = 0.0,
true_anomaly = 0.0
}
orbit = { semi_major_axis = 6.771e6, eccentricity = 0.0, true_anomaly = 0.0 }
# LEO orbit: 400 km altitude (Earth radius 6.371e6 m + 400e3 m)
Write Preview
Loading…
Cancel
Save