AEM — Attitude Ephemeris Message¶

use brahe as bh;
use brahe::ccsds::{AEMAttitudeData, AEM};

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

    // Parse an AEM with two quaternion segments
    let aem = AEM::from_file("test_assets/ccsds/aem/AEMExampleG4.txt").unwrap();

    // Header
    println!("Format version: {}", aem.header.format_version);
    println!("Originator:     {}", aem.header.originator);
    println!("Creation date:  {}", aem.header.creation_date);
    println!(
        "Message ID:     {}",
        aem.header.message_id.as_deref().unwrap_or("None")
    );

    println!("\nSegments: {}", aem.segments.len());
    for (i, segment) in aem.segments.iter().enumerate() {
        let metadata = &segment.metadata;
        println!("\n  Segment {}:", i);
        println!("    Object name:   {}", metadata.object_name);
        println!("    Ref frame A:   {}", metadata.ref_frame_a);
        println!("    Ref frame B:   {}", metadata.ref_frame_b);
        println!("    Attitude type: {}", metadata.attitude_type);
        println!(
            "    Interpolation: {}",
            metadata
                .interpolation_method
                .map(|m| m.to_string())
                .unwrap_or_else(|| "None".to_string())
        );
        println!("    States:        {}", segment.states.len());

        let first = &segment.states[0];
        if let AEMAttitudeData::Quaternion { quaternion } = &first.data {
            let wire = quaternion.to_vector(false);
            println!(
                "    First quaternion [Q1, Q2, Q3, QC] @ {}: [{:.5}, {:.5}, {:.5}, {:.5}]",
                first.epoch, wire[0], wire[1], wire[2], wire[3]
            );
        }
    }
}

use brahe as bh;
use brahe::ccsds::AEM;
use brahe::frames::OrientationProvider;
use brahe::traits::Trajectory;

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

    // Parse an AEM with two quaternion segments
    let aem = AEM::from_file("test_assets/ccsds/aem/AEMExampleG4.txt").unwrap();

    // Segment 1 carries no INTERPOLATION_METHOD, so it converts cleanly to
    // the default slerp trajectory. Segment 0 sets INTERPOLATION_METHOD =
    // HERMITE, which has no AttitudeTrajectory equivalent and would error.
    let traj = aem.segment_to_attitude_trajectory(1).unwrap();
    println!("Trajectory: {} states", traj.len());
    println!("  Frame A:       {}", traj.frame_a);
    println!("  Frame B:       {}", traj.frame_b);
    println!("  Interpolation: {:?}", traj.interpolation_method);
    println!("  Has rates:     {}", traj.has_rates());
    println!("  Start:         {}", traj.start_epoch().unwrap());
    println!("  End:           {}", traj.end_epoch().unwrap());

    // Slerp-query the attitude at the midpoint of the trajectory's span
    let t0 = traj.start_epoch().unwrap();
    let t1 = traj.end_epoch().unwrap();
    let mid = t0 + (t1 - t0) / 2.0;
    let quaternion = traj.quaternion(mid).unwrap();
    let wire = quaternion.to_vector(false);
    println!(
        "\nInterpolated quaternion [Q1, Q2, Q3, QC] at {}: [{:.5}, {:.5}, {:.5}, {:.5}]",
        mid, wire[0], wire[1], wire[2], wire[3]
    );
}

use brahe as bh;
use brahe::attitude::Quaternion;
use brahe::ccsds::{
    ADMReferenceFrame, AEM, AEMAttitudeData, AEMAttitudeState, AEMAttitudeType, AEMMetadata,
    AEMSegment, CCSDSFormat, CCSDSTimeSystem,
};
use brahe::time::{Epoch, TimeSystem};

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

    // One segment spanning 60 seconds, carrying the rotation from EME2000 into
    // the spacecraft body frame at each epoch.
    let t0 = Epoch::from_datetime(2024, 1, 1, 0, 0, 0.0, 0.0, TimeSystem::UTC);
    let t1 = t0 + 60.0;

    let metadata = AEMMetadata::new(
        "SAT1",
        "2024-001A",
        ADMReferenceFrame::parse("EME2000"),
        ADMReferenceFrame::parse("SC_BODY_1"),
        CCSDSTimeSystem::UTC,
        t0,
        t1,
        AEMAttitudeType::Quaternion,
    );
    let mut segment = AEMSegment::new(metadata);

    // The body starts aligned with EME2000 and rotates 2 degrees about its Z
    // axis over the segment. A quaternion stores the half-angle, so the sample
    // at t1 uses 1 degree.
    let half_angle = 1.0_f64.to_radians();
    segment
        .push_state(AEMAttitudeState {
            epoch: t0,
            data: AEMAttitudeData::Quaternion {
                quaternion: Quaternion::new(1.0, 0.0, 0.0, 0.0),
            },
        })
        .unwrap();
    segment
        .push_state(AEMAttitudeState {
            epoch: t1,
            data: AEMAttitudeData::Quaternion {
                quaternion: Quaternion::new(half_angle.cos(), 0.0, 0.0, half_angle.sin()),
            },
        })
        .unwrap();

    let mut aem = AEM::new("BRAHE_EXAMPLE");
    aem.header.message_id = Some("AEM-2024-001".to_string());
    aem.push_segment(segment);

    println!(
        "Created AEM with {} segment, {} attitude states",
        aem.segments.len(),
        aem.segments[0].states.len()
    );

    // Write to KVN string
    let kvn = aem.to_string(CCSDSFormat::KVN).unwrap();
    println!("\nKVN output ({} chars):", kvn.len());
    println!("{}", kvn);

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

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