OEM — Orbit Ephemeris Message¶

use brahe as bh;
use brahe::ccsds::OEM;

fn main() {
    bh::initialize_eop().unwrap();

    // Parse from file (auto-detects KVN, XML, or JSON format)
    let oem = OEM::from_file("test_assets/ccsds/oem/OEMExample1.txt").unwrap();

    // Header properties
    println!("Format version: {}", oem.header.format_version);
    println!("Originator:     {}", oem.header.originator);
    println!(
        "Classification: {}",
        oem.header.classification.as_deref().unwrap_or("None")
    );
    println!("Creation date:  {}", oem.header.creation_date);
    println!("\nNumber of segments: {}", oem.segments.len());

    // Access segment metadata
    let seg = &oem.segments[0];
    println!("\nSegment 0:");
    println!("  Object name:   {}", seg.metadata.object_name);
    println!("  Object ID:     {}", seg.metadata.object_id);
    println!("  Center name:   {}", seg.metadata.center_name);
    println!("  Ref frame:     {}", seg.metadata.ref_frame);
    println!("  Time system:   {}", seg.metadata.time_system);
    println!("  Start time:    {}", seg.metadata.start_time);
    println!("  Stop time:     {}", seg.metadata.stop_time);
    println!(
        "  Interpolation: {}",
        seg.metadata.interpolation.as_deref().unwrap_or("None")
    );
    println!("  States:        {}", seg.states.len());
    println!("  Covariances:   {}", seg.covariances.len());
    let sv = &seg.states[0];
    println!("\nFirst state vector:");
    println!("  Epoch:    {}", sv.epoch);
    println!(
        "  Position: [{:.3}, {:.3}, {:.3}] m",
        sv.position[0], sv.position[1], sv.position[2]
    );
    println!(
        "  Velocity: [{:.5}, {:.5}, {:.5}] m/s",
        sv.velocity[0], sv.velocity[1], sv.velocity[2]
    );
    println!("\nAll states in segment 0:");
    for (i, sv) in seg.states.iter().enumerate() {
        println!(
            "  [{}] {}  pos=({:.3}, {:.3}, {:.3}) km",
            i,
            sv.epoch,
            sv.position[0] / 1e3,
            sv.position[1] / 1e3,
            sv.position[2] / 1e3
        );
    }
    let kvn = oem.to_string(brahe::ccsds::CCSDSFormat::KVN).unwrap();
    println!("\nKVN output length: {} characters", kvn.len());
}

use brahe as bh;
use brahe::ccsds::OEM;
use brahe::traits::Trajectory;

fn main() {
    bh::initialize_eop().unwrap();

    // Parse an OEM file
    let oem = OEM::from_file("test_assets/ccsds/oem/OEMExample5.txt").unwrap();
    let seg = &oem.segments[0];
    println!(
        "Segment: {}, {} states, frame={}",
        seg.metadata.object_name,
        seg.states.len(),
        seg.metadata.ref_frame
    );
    let traj = oem.segment_to_trajectory(0).unwrap();
    println!("\nTrajectory: {} states", traj.len());
    println!("  Frame: {:?}", traj.frame);
    println!("  Start: {}", traj.start_epoch().unwrap());
    println!("  End:   {}", traj.end_epoch().unwrap());
    println!("  Span:  {:.0} seconds", traj.timespan().unwrap());

    // Access states by index
    let (epoch, state) = traj.first().unwrap();
    println!("\nFirst state:");
    println!("  Epoch: {}", epoch);
    println!(
        "  Position: [{:.3}, {:.3}, {:.3}] km",
        state[0] / 1e3,
        state[1] / 1e3,
        state[2] / 1e3
    );
    println!(
        "  Velocity: [{:.3}, {:.3}, {:.3}] m/s",
        state[3], state[4], state[5]
    );

    // Convert all segments from a multi-segment OEM
    let oem_multi = OEM::from_file("test_assets/ccsds/oem/OEMExample1.txt").unwrap();
    let trajs = oem_multi.to_trajectories().unwrap();
    println!("\nMulti-segment OEM: {} trajectories", trajs.len());
    for (i, t) in trajs.iter().enumerate() {
        println!("  [{}] {} states, span={:.0}s", i, t.len(), t.timespan().unwrap());
    }
}

use brahe as bh;
use brahe::ccsds::{
    CCSDSFormat, CCSDSRefFrame, CCSDSTimeSystem, OEM, OEMMetadata, OEMSegment, OEMStateVector,
};
use brahe::traits::DStateProvider;
use nalgebra as na;

fn main() {
    bh::initialize_eop().unwrap();

    // Create a new OEM with header info
    let mut oem = OEM::new("BRAHE_EXAMPLE".to_string());

    // Define a LEO orbit and propagate with KeplerianPropagator (two-body)
    let epoch =
        bh::Epoch::from_datetime(2024, 6, 15, 0, 0, 0.0, 0.0, bh::TimeSystem::UTC);
    let oe = na::SVector::<f64, 6>::new(bh::R_EARTH + 500e3, 0.001, 51.6, 15.0, 30.0, 0.0);
    let prop = bh::KeplerianPropagator::from_keplerian(epoch, oe, bh::AngleFormat::Degrees, 60.0);

    // Create segment metadata
    let step = 60.0_f64; // 60-second spacing
    let n_states = 5usize;
    let stop_epoch = epoch + step * (n_states - 1) as f64;

    let metadata = OEMMetadata::new(
        "LEO SAT".to_string(),
        "2024-100A".to_string(),
        "EARTH".to_string(),
        CCSDSRefFrame::EME2000,
        CCSDSTimeSystem::UTC,
        epoch,
        stop_epoch,
    )
    .with_interpolation("LAGRANGE".to_string(), Some(7));

    let mut seg = OEMSegment::new(metadata);

    // Populate states from the Keplerian propagator
    for i in 0..n_states {
        let t = epoch + i as f64 * step;
        let s = prop.state(t).unwrap();
        seg.push_state(OEMStateVector::new(
            t,
            [s[0], s[1], s[2]],
            [s[3], s[4], s[5]],
        ));
    }

    oem.push_segment(seg);

    println!(
        "Created OEM with {} segment, {} states",
        oem.segments.len(),
        oem.segments[0].states.len()
    );
    let kvn = oem.to_string(CCSDSFormat::KVN).unwrap();
    println!("\nKVN output ({} chars):", kvn.len());
    let preview: String = kvn.chars().take(500).collect();
    println!("{}", preview);

    // Write to file
    oem.to_file("/tmp/brahe_example_oem.txt", CCSDSFormat::KVN)
        .unwrap();
    println!("\nWritten to /tmp/brahe_example_oem.txt");

    // Verify round-trip
    let oem2 = OEM::from_file("/tmp/brahe_example_oem.txt").unwrap();
    println!(
        "Round-trip: {} segment, {} states",
        oem2.segments.len(),
        oem2.segments[0].states.len()
    );
}

use brahe as bh;
use bh::ccsds::{
    CCSDSFormat, CCSDSRefFrame, CCSDSTimeSystem, OEM, OEMMetadata, OEMSegment, OEMStateVector,
};
use bh::traits::{DStatePropagator, Trajectory};
use nalgebra as na;

fn main() {
    bh::initialize_eop().unwrap();
    bh::initialize_sw().unwrap();

    // Define initial state
    let epoch = bh::Epoch::from_datetime(2024, 6, 15, 0, 0, 0.0, 0.0, bh::TimeSystem::UTC);
    let oe = na::SVector::<f64, 6>::new(bh::R_EARTH + 500e3, 0.001, 51.6, 15.0, 30.0, 45.0);
    let state = bh::state_koe_to_eci(oe, bh::AngleFormat::Degrees);
    let params = na::DVector::from_vec(vec![500.0, 2.0, 2.2, 2.0, 1.3]);

    // Create propagator with default force model
    let mut prop = bh::DNumericalOrbitPropagator::new(
        epoch,
        na::DVector::from_column_slice(state.as_slice()),
        bh::NumericalPropagationConfig::default(),
        bh::ForceModelConfig::default(),
        Some(params),
        None,
        None,
        None,
    )
    .unwrap();

    // Propagate for 90 minutes
    let target_epoch = epoch + 5400.0;
    prop.propagate_to(target_epoch);
    println!("Propagated from {} to {}", epoch, prop.current_epoch());

    // Get the accumulated trajectory
    let traj = prop.trajectory();
    println!(
        "Trajectory: {} states, span={:.0}s",
        traj.len(),
        traj.timespan().unwrap()
    );

    // Build an OEM from the trajectory states
    let mut oem = OEM::new("BRAHE_PROP".to_string());
    let stop_epoch = prop.current_epoch();

    let metadata = OEMMetadata::new(
        "LEO SAT".to_string(),
        "2024-100A".to_string(),
        "EARTH".to_string(),
        CCSDSRefFrame::EME2000,
        CCSDSTimeSystem::UTC,
        epoch,
        stop_epoch,
    )
    .with_interpolation("LAGRANGE".to_string(), Some(7));

    let mut seg = OEMSegment::new(metadata);

    // Extract states from trajectory and add to OEM
    for i in 0..traj.len() {
        let (epc, s) = traj.get(i).unwrap();
        seg.push_state(OEMStateVector::new(
            epc,
            [s[0], s[1], s[2]],
            [s[3], s[4], s[5]],
        ));
    }

    let num_states = seg.states.len();
    oem.push_segment(seg);
    println!("\nOEM: {} segment, {} states", oem.segments.len(), num_states);

    // Write to KVN
    let kvn = oem.to_string(CCSDSFormat::KVN).unwrap();
    println!("KVN output: {} characters", kvn.len());

    // Verify by re-parsing
    let oem2 = OEM::from_str(&kvn).unwrap();
    println!("Round-trip: {} states", oem2.segments[0].states.len());
}